diff options
528 files changed, 14103 insertions, 6538 deletions
diff --git a/contrib/ChangeLog b/contrib/ChangeLog index cdb63c3aaad..62fd844d2da 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,12 @@ +2024-04-26 Jakub Jelinek <jakub@redhat.com> + + * gcc-changelog/git_update_version.py (active_refs): Add + releases/gcc-14. + +2024-04-18 Sandra Loosemore <sloosemore@baylibre.com> + + * config-list.mk (LIST): --enable-obsolete for nios2*-*-*. + 2024-04-12 Filip Kastl <fkastl@suse.cz> * check-params-in-docs.py: Ignore target specific params. diff --git a/contrib/config-list.mk b/contrib/config-list.mk index 16df66f0fc6..f282cd95c8d 100644 --- a/contrib/config-list.mk +++ b/contrib/config-list.mk @@ -78,7 +78,8 @@ LIST = \ moxie-uclinux moxie-rtems \ msp430-elf msp430-elfbare \ nds32le-elf nds32be-elf \ - nios2-elf nios2-linux-gnu nios2-rtems \ + nios2-elfOPT-enable-obsolete nios2-linux-gnuOPT-enable-obsolete \ + nios2-rtemsOPT-enable-obsolete \ nvptx-none \ or1k-elf or1k-linux-uclibc or1k-linux-musl or1k-rtems \ pdp11-aout \ diff --git a/contrib/gcc-changelog/git_update_version.py b/contrib/gcc-changelog/git_update_version.py index 3e79dab0096..f194757b0cb 100755 --- a/contrib/gcc-changelog/git_update_version.py +++ b/contrib/gcc-changelog/git_update_version.py @@ -76,8 +76,8 @@ def prepend_to_changelog_files(repo, folder, git_commit, add_to_git): repo.git.add(full_path) -active_refs = ['master', - 'releases/gcc-11', 'releases/gcc-12', 'releases/gcc-13'] +active_refs = ['master', 'releases/gcc-11', + 'releases/gcc-12', 'releases/gcc-13', 'releases/gcc-14'] parser = argparse.ArgumentParser(description='Update DATESTAMP and generate ' 'ChangeLog entries') diff --git a/gcc/BASE-VER b/gcc/BASE-VER index 63dba868a0c..94188a74831 100644 --- a/gcc/BASE-VER +++ b/gcc/BASE-VER @@ -1 +1 @@ -14.0.1 +15.0.0 diff --git a/gcc/ChangeLog b/gcc/ChangeLog index cb20a29685c..9b885348fde 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,837 @@ +2024-04-30 Andrew MacLeod <amacleod@redhat.com> + + * gimple-range-op.cc (gimple_range_op_handler::calc_op1): Don't + assert that here are less than 3 operands. + (gimple_range_op_handler::maybe_builtin_call): Simply return if + there is no type for the function call. + +2024-04-30 Andrew MacLeod <amacleod@redhat.com> + + * gimple-range.cc (gimple_ranger::range_on_entry): Adjust for new + API and support non-SSA expressions. + (gimple_ranger::range_on_exit): Ditto. + * gimple-range.h (range_on_entry, range_on_exit): Adjust API. + * value-query.cc (range_query::range_on_entry): New. + (range_query::range_on_exit): New. + (range_query::value_on_entry): New. + (range_query::value_on_exit): New. + (range_query::invoke_range_of_expr): New. + (range_query::get_tree_range): Allow stmt, on_entry or on_exit + range queries. + SSA_NAMES should invoke range_of_expr if possible. + * value-query.h (class range_query): Adjust prototypes. + +2024-04-30 Andrew MacLeod <amacleod@redhat.com> + + * gimple-range.cc (gimple_ranger::range_of_expr): Call range_of_stmt + when there is no context stmt. + +2024-04-30 Andrew MacLeod <amacleod@redhat.com> + + * gimple-range-cache.cc (ranger_cache::get_global_range): Do not + pre-evaluate PHI nodes from the cache. + (ranger_cache::fill_block_cache): Make re-entrant. + +2024-04-30 Andrew MacLeod <amacleod@redhat.com> + + * value-query.cc (get_range_global): Rename to gimple_range_global. + (gimple_range_global): Remove wrapper function. + (global_range_query::range_of_expr): Call gimple_range_global. + +2024-04-30 Andrew Pinski <quic_apinski@quicinc.com> + + * tree-cfg.cc (verify_gimple_assign): Remove quote + mark to shut up the warning. + +2024-04-30 Andrew Pinski <quic_apinski@quicinc.com> + + * tree-ssa-phiopt.cc (value_replacement): Reject undef variables + so they don't become unconditional used. + +2024-04-30 Andrew Pinski <quic_apinski@quicinc.com> + + * tree-ssa-phiopt.cc (value_replacement): Move check for + NE/EQ earlier. + +2024-04-30 Andrew Pinski <quic_apinski@quicinc.com> + + * tree-ssa-phiopt.cc (single_non_singleton_phi_for_edges): + Remove the special case of gimple_seq_singleton_p. + +2024-04-30 Andrew Pinski <quic_apinski@quicinc.com> + + PR middle-end/112976 + * cfgexpand.cc (expand_gimple_stmt_1): Remove + support for expanding nontemporal "moves" with + ssa names on the LHS. + +2024-04-30 Andrew Pinski <quic_apinski@quicinc.com> + + PR middle-end/112976 + * tree-cfg.cc (verify_gimple_assign): Verify that + nontmporal moves are stores. + * gimple.h (struct gimple): Note that only + nontemporal stores are supported. + +2024-04-30 Jivan Hakobyan <jivanhakobyan9@gmail.com> + + * config/riscv/iterators.md (fix_ops, fix_uns): New iterators. + (RINT, rint_pattern, rint_rm): Remove unused iterators. + * config/riscv/riscv-protos.h (get_fp_rounding_coefficient): Prototype. + * config/riscv/riscv-v.cc (get_fp_rounding_coefficient): Externalize. + external linkage. + * config/riscv/riscv.md (UNSPEC_LROUND): Remove. + (fix_trunc<ANYF:mode><GPR:mode>2): Replace with ... + (<fix_uns>_trunc<ANYF:mode>si2): New expander & associated insn. + (<fix_uns>_trunc<ANYF:mode>si2_ext): New insn. + (<fix_uns>_trunc<ANYF:mode>di2): Likewise. + (l<rint_pattern><ANYF:mode><GPR:mode>2): Replace with ... + (lrint<ANYF:mode>si2): New expander and associated insn. + (lrint<ANYF:mode>si2_ext, lrint<ANYF:mode>di2): New insns. + (<round_pattern><ANYF:mode>2): Replace with.... + (l<round_pattern><ANYF:mode>si2): New expander and associated insn. + (l<round_pattern><ANYF:mode>si2_sext): New insn. + (l<round_pattern><ANYF:mode>di2): Likewise. + (<round_pattern><ANYF:mode>2): New expander. + +2024-04-30 Aldy Hernandez <aldyh@redhat.com> + + * gimple-ssa-warn-access.cc (check_nul_terminated_array): Change + int_range<2> to int_range_max. + (memmodel_to_uhwi): Same. + * tree-ssa-loop-niter.cc (refine_value_range_using_guard): Same. + (determine_value_range): Same. + (infer_loop_bounds_from_signedness): Same. + (scev_var_range_cant_overflow): Same. + +2024-04-30 Richard Biener <rguenther@suse.de> + + PR middle-end/13421 + * optabs-tree.cc (optab_for_tree_code): Do not consider + {add,sub}v or {us,ss}{add,sub} optabs for POINTER_DIFF_EXPR + or POINTER_PLUS_EXPR. + +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/114876 + * gimple-ssa-sprintf.cc (format_character): For min == 0 && max == 0, + set max, likely and unlikely members to 1 rather than 0. Remove + useless res.knownrange = true;. Formatting fixes. + +2024-04-30 Jakub Jelinek <jakub@redhat.com> + Hongtao Liu <hongtao.liu@intel.com> + + PR tree-optimization/114883 + * tree-vect-loop.cc (vect_transform_reduction): Allow IFN_COND_MIN and + IFN_COND_MAX in the assert. + +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + * doc/cpp.texi (__STDC_VERSION__): Document 202311L value + for -std=c23/-std=gnu23. + +2024-04-30 Richard Biener <rguenther@suse.de> + + PR middle-end/114734 + * internal-fn.cc (expand_call_mem_ref): Use + get_gimple_for_ssa_name to get at the def stmt of the address + argument to honor SSA coalescing constraints. + +2024-04-29 demin.han <demin.han@starfivetech.com> + + PR target/114506 + * config/riscv/riscv-vector-costs.cc (non_contiguous_memory_access_p): Rename + (need_additional_vector_vars_p): Rename and refine condition + +2024-04-29 Pan Li <pan2.li@intel.com> + + PR target/114885 + * config/riscv/riscv.cc (riscv_legitimize_subreg_const_poly_move): New + func impl to take care of (const_int_poly:TI 8). + (riscv_legitimize_move): Handle subreg is const_int_poly, + +2024-04-29 Christoph Müllner <christoph.muellner@vrull.eu> + + * common/config/riscv/riscv-common.cc: Move ziccamoa, ziccif, + zicclsm, and ziccrse into riscv_zi_subext. + * config/riscv/riscv.opt: Define MASK_ZIC64B for + riscv_ziccmo_subext. + +2024-04-29 Jie Mei <jie.mei@oss.cipunited.com> + + * config/mips/i6400.md (i6400_fpu_minmax): New + define_insn_reservation. + * config/mips/mips.h (ISA_HAS_FMIN_FMAX): Define new macro. + * config/mips/mips.md (UNSPEC_FMIN): New unspec. + (UNSPEC_FMAX): Same as above. + (type): Add fminmax. + (smin<mode>3): Generates MIN.fmt instructions. + (smax<mode>3): Generates MAX.fmt instructions. + (fmin<mode>3): Generates MIN.fmt instructions. + (fmax<mode>3): Generates MAX.fmt instructions. + * config/mips/p6600.md (p6600_fpu_fabs): Include fminmax + type. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * tree-ssa-ccp.cc (ccp_finalize): Normalize before calling + set_bitmask. + * value-range.cc (irange::intersect_bitmask): Calculate changed + irange_bitmask bits on our own. + (irange::union_bitmask): Same. + (irange_bitmask::verify_mask): Verify that bits are normalized. + * value-range.h (irange_bitmask::union_): Do not normalize. + Remove return value. + (irange_bitmask::intersect): Same. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * range-op-ptr.cc (pointer_plus_operator::wi_fold): Use method + range setters instead of out of line functions. + (pointer_min_max_operator::wi_fold): Same. + (pointer_and_operator::wi_fold): Same. + (pointer_or_operator::wi_fold): Same. + * range-op.cc (operator_negate::fold_range): Same. + (operator_addr_expr::fold_range): Same. + (range_op_cast_tests): Same. + * range.cc (range_zero): Remove. + (range_nonzero): Remove. + * range.h (range_zero): Remove. + (range_nonzero): Remove. + * value-range.cc (range_tests_misc): Use method instead of out of + line function. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range-pretty-print.cc (print_int_bound): New. + (print_irange_bitmasks): New. + (vrange_printer::print_irange_bound): Remove. + (vrange_printer::print_irange_bitmasks): Remove. + * value-range-pretty-print.h: Remove print_irange_bitmasks and + print_irange_bound + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range.h (range_includes_zero_p): Accept vrange. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * tree-ssa-loop-split.cc (split_at_bb_p): Make int_range a Value_Range. + * tree-ssa-strlen.cc (get_range): Same. + * value-query.cc (range_query::get_tree_range): Handle both + integers and pointers. + * vr-values.cc (simplify_using_ranges::fold_cond_with_ops): Make + r0 and r1 Value_Range's. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range.cc (get_bitmask_from_range): Move out of irange class. + (irange::get_bitmask): Call function instead of internal method. + * value-range.h (class irange): Remove get_bitmask_from_range. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range.cc (get_legacy_range): Make static and add another + version of get_legacy_range that takes a vrange. + * value-range.h (class irange): Remove unnecessary friendship with + get_legacy_range. + (get_legacy_range): Accept a vrange. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range-storage.cc (irange_storage::set_irange): Move + verification code from here... + (vrange_storage::set_vrange): ...to here. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * gimple-range-op.cc (cfn_clz::fold_range): Change + range_includes_zero_p argument to a reference. + (cfn_ctz::fold_range): Same. + * range-op.cc (operator_plus::lhs_op1_relation): Same. + * value-range.h (range_includes_zero_p): Same. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * vr-values.cc (simplify_using_ranges::fold_cond_with_ops): Remove + type from range_true and range_false. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range-storage.h: Remove friends. + * value-range.cc (gt_ggc_mx): Remove. + (gt_pch_nx): Remove. + * value-range.h (class vrange): Remove GTY markers. + (class irange): Same. + (class int_range): Same. + (class frange): Same. + (gt_ggc_mx): Remove. + (gt_pch_nx): Remove. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * ipa-cp.cc (propagate_bits_across_jump_function): Access bitmask + through base class. + (ipcp_store_vr_results): Same. + * ipa-prop.cc (ipa_compute_jump_functions_for_edge): Same. + (ipcp_get_parm_bits): Same. + (ipcp_update_vr): Same. + * range-op-mixed.h (update_known_bitmask): Change argument to vrange. + * range-op.cc (update_known_bitmask): Same. + * value-range.cc (vrange::update_bitmask): New. + (irange::set_nonzero_bits): Move to vrange class. + (irange::get_nonzero_bits): Same. + * value-range.h (class vrange): Add update_bitmask, get_bitmask, + get_nonzero_bits, and set_nonzero_bits. + (class irange): Make bitmask methods virtual overrides. + (class Value_Range): Add get_bitmask and update_bitmask. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * tree-ssa-loop-niter.cc (refine_value_range_using_guard): Convert + bound to wide_int. + * value-range.cc (Value_Range::lower_bound): Remove. + (Value_Range::upper_bound): Remove. + (unsupported_range::lbound): New. + (unsupported_range::ubound): New. + (frange::lbound): New. + (frange::ubound): New. + (irange::lbound): New. + (irange::ubound): New. + * value-range.h (class vrange): Add lbound() and ubound(). + (class irange): Same. + (class frange): Same. + (class unsupported_range): Same. + (class Value_Range): Rename lower_bound and upper_bound to lbound + and ubound respectively. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * gimple-ssa-warn-access.cc (check_nul_terminated_array): Make Value_Range an int_range. + (memmodel_to_uhwi): Same + * tree-ssa-loop-niter.cc (refine_value_range_using_guard): Same. + (determine_value_range): Same. + (infer_loop_bounds_from_signedness): Same. + (scev_var_range_cant_overflow): Same. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range.h (vrange::~vrange): New. + (int_range::~int_range): Make final override. + +2024-04-28 Aldy Hernandez <aldyh@redhat.com> + + * value-range.cc (unsupported_range::accept): Move down. + (vrange::contains_p): Rename to... + (unsupported_range::contains_p): ...this. + (vrange::singleton_p): Rename to... + (unsupported_range::singleton_p): ...this. + (vrange::set): Rename to... + (unsupported_range::set): ...this. + (vrange::type): Rename to... + (unsupported_range::type): ...this. + (vrange::supports_type_p): Rename to... + (unsupported_range::supports_type_p): ...this. + (vrange::set_undefined): Rename to... + (unsupported_range::set_undefined): ...this. + (vrange::set_varying): Rename to... + (unsupported_range::set_varying): ...this. + (vrange::union_): Rename to... + (unsupported_range::union_): ...this. + (vrange::intersect): Rename to... + (unsupported_range::intersect): ...this. + (vrange::zero_p): Rename to... + (unsupported_range::zero_p): ...this. + (vrange::nonzero_p): Rename to... + (unsupported_range::nonzero_p): ...this. + (vrange::set_nonzero): Rename to... + (unsupported_range::set_nonzero): ...this. + (vrange::set_zero): Rename to... + (unsupported_range::set_zero): ...this. + (vrange::set_nonnegative): Rename to... + (unsupported_range::set_nonnegative): ...this. + (vrange::fits_p): Rename to... + (unsupported_range::fits_p): ...this. + (unsupported_range::operator=): New. + (frange::fits_p): New. + * value-range.h (class vrange): Make an abstract class. + (class unsupported_range): Declare override methods. + +2024-04-28 Gerald Pfeifer <gerald@pfeifer.com> + + PR target/69374 + PR target/112959 + * doc/install.texi (Specific) <*-*-freebsd*>: Remove references to + FreeBSD 7 and older. + +2024-04-28 Gerald Pfeifer <gerald@pfeifer.com> + + * doc/contrib.texi: Update David Binderman's entry. + +2024-04-28 liuhongt <hongtao.liu@intel.com> + + * config/i386/i386.md: (zero_extendsidi2): Adjust + alternative *k to ?k. + (zero_extend<mode>di2): Ditto. + (*zero_extend<mode>si2): Ditto. + (*zero_extendqihi2): Ditto. + +2024-04-28 Jiufu Guo <guojiufu@linux.ibm.com> + + PR target/95782 + * config/s390/s390-c.cc (s390_macro_to_expand): Avoid empty identifier. + +2024-04-28 Andrew Pinski <quic_apinski@quicinc.com> + + PR target/113822 + * config/aarch64/aarch64.cc (aarch64_evpc_reencode): Use + vec_perm_indices::new_shrunk_vector instead of manually + going through the indices. + +2024-04-27 Xi Ruoyao <xry111@xry111.site> + + PR target/114861 + * config/loongarch/loongarch.md (bstrins_<mode>_for_mask): Add + constraints for operands. + (bstrins_<mode>_for_ior_mask): Likewise. + +2024-04-27 Fangrui Song <maskray@gcc.gnu.org> + + * config/riscv/elf.h (LINK_SPEC): Add -X. + * config/riscv/freebsd.h (LINK_SPEC): Add -X. + * config/riscv/linux.h (LINK_SPEC): Add -X. + +2024-04-26 Wilco Dijkstra <wilco.dijkstra@arm.com> + + * config/aarch64/aarch64.cc (MAX_SET_SIZE): New define. + (aarch64_progress_pointer): Remove function. + (aarch64_set_one_block_and_progress_pointer): Simplify and clean up. + (aarch64_expand_setmem): Clean up implementation, use byte offsets, + simplify size calculation. + +2024-04-26 Wilco Dijkstra <wilco.dijkstra@arm.com> + + * config/aarch64/aarch64.cc (aarch64_mode_valid_for_sched_fusion_p): + Remove check for AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS. + (aarch64_advsimd_ldp_stp_p): Likewise. + (aarch64_stp_sequence_cost): Likewise. + (aarch64_expand_cpymem): Likewise. + (aarch64_expand_setmem): Likewise. + * config/aarch64/aarch64-ldp-fusion.cc (ldp_operand_mode_ok_p): + Likewise. + * config/aarch64/aarch64-ldpstp.md: Likewise. + * config/aarch64/aarch64-tuning-flags.def: Remove NO_LDP_STP_QREGS. + * config/aarch64/tuning_models/emag.h: Likewise. + * config/aarch64/tuning_models/xgene1.h: Likewise. + +2024-04-26 Frederik Harwath <frederik@harwath.name> + + * config.gcc: Add gfx90c. + * config/gcn/gcn-hsa.h (NO_SRAM_ECC): Likewise. + * config/gcn/gcn-opts.h (enum processor_type): Likewise. + (TARGET_GFX90c): New macro. + * config/gcn/gcn.cc (gcn_option_override): Handle gfx90c. + (gcn_omp_device_kind_arch_isa): Likewise. + (output_file_start): Likewise. + * config/gcn/gcn.h: Add gfx90c. + * config/gcn/gcn.opt: Likewise. + * config/gcn/mkoffload.cc (EF_AMDGPU_MACH_AMDGCN_GFX90c): New macro. + (get_arch): Handle gfx90c. + (main): Handle EF_AMDGPU_MACH_AMDGCN_GFX90c + * config/gcn/t-omp-device: Add gfx90c. + * doc/install.texi: Likewise. + * doc/invoke.texi: Likewise. + +2024-04-25 David Faust <david.faust@oracle.com> + + * config/bpf/bpf.h (PREFERRED_DEBUGGING_TYPE): Set to BTF_DEBUG. + +2024-04-25 David Faust <david.faust@oracle.com> + + * config/bpf/bpf.cc (bpf_option_override): Improve handling of CO-RE + options to avoid issues with -gtoggle. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + PR fortran/114825 + * tree-nested.cc (get_debug_decl): New function. + (get_nonlocal_debug_decl): Use it. + (get_local_debug_decl): Likewise. + +2024-04-25 Jose E. Marchesi <jose.marchesi@oracle.com> + + * config/bpf/bpf.opt: Use ASM_PSEUDOC for the default value of + -masm. + * config/bpf/bpf.h (ASM_SPEC): Adapt accordingly. + * doc/invoke.texi (eBPF Options): Update. + +2024-04-25 Richard Ball <richard.ball@arm.com> + + PR target/114837 + * config/arm/arm.cc (cmse_nonsecure_call_inline_register_clear): + Add zero/sign extend. + (arm_expand_prologue): Add zero/sign extend. + +2024-04-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114792 + * tree-ssa-loop-ch.cc (ch_order_loops): New function. + (ch_base::copy_headers): Sort loops to unloop inner-to-outer. + +2024-04-25 Eric Botcazou <ebotcazou@adacore.com> + + PR target/114416 + * config/sparc/sparc.h (SUN_V9_ABI_COMPATIBILITY): New macro. + * config/sparc/sol2.h (SUN_V9_ABI_COMPATIBILITY): Redefine it. + * config/sparc/sparc.cc (fp_type_for_abi): New predicate. + (traverse_record_type): Use it to spot floating-point types. + (compute_fp_layout): Also deal with array types. + +2024-04-25 Pan Li <pan2.li@intel.com> + + * config/riscv/vector-crypto.md: Add early clobber to the + dest operand of vwsll. + +2024-04-25 Haochen Gui <guihaoc@gcc.gnu.org> + + * config/rs6000/altivec.md (*bcdinvalid_<mode>): Replace bcdadd + with bcdsub. + (bcdinvalid_<mode>): Likewise. + +2024-04-24 Jakub Jelinek <jakub@redhat.com> + + PR other/114738 + * opts.cc (get_option_url): Revert 2024-04-17 changes. + * gcc-urlifier.cc: Don't include diagnostic-core.h. + (gcc_urlifier::make_doc_url): Revert 2024-04-17 changes. + * configure.ac (documentation-root-url): On release branches + append gcc-MAJOR.MINOR.0/ to the default DOCUMENTATION_ROOT_URL. + * doc/install.texi (--with-documentation-root-url=): Document + the change of the default. + * configure: Regenerate. + +2024-04-24 Pan Li <pan2.li@intel.com> + + Revert: + 2023-11-29 Juzhe-Zhong <juzhe.zhong@rivai.ai> + kito-cheng <kito.cheng@sifive.com> + kito-cheng <kito.cheng@gmail.com> + + PR target/112431 + * config/riscv/constraints.md (TARGET_VECTOR ? V_REGS : NO_REGS): New register filters. + * config/riscv/riscv.md (no,W21,W42,W84,W41,W81,W82): Ditto. + (no,yes): Ditto. + * config/riscv/vector.md: Support highpart register overlap for vwcvt. + +2024-04-24 Jose E. Marchesi <jose.marchesi@oracle.com> + + * config.gcc: Add bpf-c.o as a target object for C and C++. + * config/bpf/bpf.cc (bpf_target_macros): Move to bpf-c.cc. + * config/bpf/bpf-c.cc: New file. + (bpf_target_macros): Move from bpf.cc and define BPF CPU + feature macros. + * config/bpf/t-bpf: Add rules to build bpf-c.o. + +2024-04-24 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114787 + * tree-cfg.cc (remove_edge_and_dominated_blocks): When + removing a loop backedge clear niter info and when removing + the last backedge of a loop mark that loop for removal. + +2024-04-24 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114832 + * tree-vect-loop-manip.cc (slpeel_tree_duplicate_loop_to_edge_cfg): + Fix dominance check. + +2024-04-24 Haochen Jiang <haochen.jiang@intel.com> + + * config/i386/i386-options.cc (ix86_valid_target_attribute_tree): + Check whether AVX512F is explicitly enabled. + +2024-04-24 Pan Li <pan2.li@intel.com> + + Revert: + 2023-11-30 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + * config/riscv/vector.md: Support highpart overlap for vext.vf2 + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + PR target/114810 + * config/i386/i386.md (*andn<dwi>3_doubleword_bmi): Split the =&r,r,ro + alternative into =&r,r,r enabled only for x64 and =&r,r,o. + +2024-04-23 Jan Hubicka <jh@suse.cz> + + * doc/invoke.texi (-ftree-loop-distribute-patterns): Remove duplicated + sentence about optimization flags implying this. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * config/darwin.opt (init): Spelling fix: initialiser -> initializer. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * config/epiphany/epiphany.opt (may-round-for-trunc): Spelling fix: + floatig -> floating. + * config/riscv/riscv.opt (mcsr-check): Spelling fix: CRS -> CSR. + * params.opt (-param=ipa-cp-profile-count-base=): Spelling fix: + frequncy -> frequency. + +2024-04-23 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114799 + * tree-vect-slp.cc (vect_get_and_check_slp_defs): Properly + update ->any_pattern when swapping operands. + +2024-04-23 Andreas Krebbel <krebbel@linux.ibm.com> + + PR target/114676 + * config/s390/s390-c.cc (s390_expand_overloaded_builtin): Use a + MEM_REF with an addend of type ptr_type_node. + +2024-04-23 Yang Yujie <yangyujie@loongson.cn> + + * config.gcc: Add loongarch-evolution.o. + * config/loongarch/genopts/genstr.sh: Enable generation of + loongarch-evolution.[cc,h]. + * config/loongarch/t-loongarch: Likewise. + * config/loongarch/genopts/gen-evolution.awk: New file. + * config/loongarch/genopts/isa-evolution.in: Mark ISA version + of introduction for each ISA evolution feature. + * config/loongarch/loongarch-c.cc (loongarch_cpu_cpp_builtins): + Define builtin macros for enabled ISA evolutions and the ISA + version. + * config/loongarch/loongarch-cpu.cc: Use loongarch-evolution.h. + * config/loongarch/loongarch.h: Likewise. + * config/loongarch/loongarch-cpucfg-map.h: Delete. + * config/loongarch/loongarch-evolution.cc: New file. + * config/loongarch/loongarch-evolution.h: New file. + * config/loongarch/loongarch-opts.h (ISA_HAS_FRECIPE): Define. + (ISA_HAS_DIV32): Likewise. + (ISA_HAS_LAM_BH): Likewise. + (ISA_HAS_LAMCAS): Likewise. + (ISA_HAS_LD_SEQ_SA): Likewise. + +2024-04-23 Yang Yujie <yangyujie@loongson.cn> + + * config.gcc: Make la64v1.0 the default ISA preset of the lp64d ABI. + * config/loongarch/genopts/loongarch-strings: Define la64v1.0, la64v1.1. + * config/loongarch/genopts/loongarch.opt.in: Likewise. + * config/loongarch/loongarch-c.cc (LARCH_CPP_SET_PROCESSOR): Likewise. + (loongarch_cpu_cpp_builtins): Likewise. + * config/loongarch/loongarch-cpu.cc (get_native_prid): Likewise. + (fill_native_cpu_config): Likewise. + * config/loongarch/loongarch-def.cc (array_tune): Likewise. + * config/loongarch/loongarch-def.h: Likewise. + * config/loongarch/loongarch-driver.cc (driver_set_m_parm): Likewise. + (driver_get_normalized_m_opts): Likewise. + * config/loongarch/loongarch-opts.cc (default_tune_for_arch): Likewise. + (TUNE_FOR_ARCH): Likewise. + (arch_str): Likewise. + (loongarch_target_option_override): Likewise. + * config/loongarch/loongarch-opts.h (TARGET_uARCH_LA464): Likewise. + (TARGET_uARCH_LA664): Likewise. + * config/loongarch/loongarch-str.h (STR_CPU_ABI_DEFAULT): Likewise. + (STR_ARCH_ABI_DEFAULT): Likewise. + (STR_TUNE_GENERIC): Likewise. + (STR_ARCH_LA64V1_0): Likewise. + (STR_ARCH_LA64V1_1): Likewise. + * config/loongarch/loongarch.cc (loongarch_cpu_sched_reassociation_width): Likewise. + (loongarch_asm_code_end): Likewise. + * config/loongarch/loongarch.opt: Likewise. + * doc/invoke.texi: Likewise. + +2024-04-22 Pan Li <pan2.li@intel.com> + + * config/riscv/vector-crypto.md: + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2023-11-30 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + * config/riscv/constraints.md (TARGET_VECTOR ? V_REGS : NO_REGS): Fix constraint. + * config/riscv/riscv.md (no,W21,W42,W84,W41,W81,W82): Rename vconstraint into group_overlap. + (no,yes): Ditto. + (none,W21,W42,W84,W43,W86,W87): Ditto. + * config/riscv/vector.md: Ditto. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-04 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + * config/riscv/riscv.md: Rostify the constraints. + +2024-04-22 Haochen Jiang <haochen.jiang@intel.com> + + * common/config/i386/i386-common.cc (processor_alias_table): + Let Sierra Forest map to CPU_TYPE enum. + +2024-04-22 Andreas Krebbel <krebbel@linux.ibm.com> + + * config/s390/s390.cc (s390_option_override_internal): Check zarch + flag before enabling -mvx. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2023-11-30 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Add widenning overlap. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-01 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Support highpart overlap for indexed load. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-04 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Add highest-number overlap support. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2023-11-30 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Add widening overlap of vf2/vf4. + +2024-04-21 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-01 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Support highpart overlap for vx/vf. + +2024-04-20 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-04 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Fix incorrect overlap in v0. + +2024-04-20 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-11 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * config/riscv/vector.md: Support highest overlap for wv instructions. + +2024-04-20 Pan Li <pan2.li@intel.com> + + Revert: + 2023-12-18 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112432 + * config/riscv/riscv.md (none,W21,W42,W84,W43,W86,W87): Add W0. + (none,W21,W42,W84,W43,W86,W87,W0): Ditto. + * config/riscv/vector.md: Ditto. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR target/114783 + * config/i386/sse.md (*avx2_eq<mode>3): Change last operand's + constraint from "jm" to "xjm". + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/114753 + * internal-fn.cc (expand_arith_overflow): Add one missing restore + of flag_trapv before return. + +2024-04-19 Tamar Christina <tamar.christina@arm.com> + + PR tree-optimization/114769 + * tree-vect-patterns.cc: + (vect_recog_absolute_difference): Have only one success condition. + (vect_recog_abd_pattern): Handle further checks if + vect_recog_absolute_difference fails. + +2024-04-19 Cupertino Miranda <cupertino.miranda@oracle.com> + + * config/bpf/core-builtins.cc (get_index_for_enum_value): Create + function. + (pack_enum_value): Check for enumerator and error out. + (process_enum_value): Correct string allocation. + +2024-04-19 Cupertino Miranda <cupertino.miranda@oracle.com> + + * config/bpf/bpf-protos.h (bpf_add_core_reloc): Renamed function + to bpf_output_move. + * config/bpf/bpf.cc (bpf_legitimate_address_p): Allow + UNSPEC_CORE_RELOC to match an address. + (bpf_insn_cost): Make UNSPEC_CORE_RELOC immediate moves + expensive to prioritize loads and stores. + (TARGET_INSN_COST): Add hook. + (bpf_output_move): Wrapper to call bpf_output_core_reloc. + (bpf_print_operand): Add support to print immediate operands + specified with the UNSPEC_CORE_RELOC. + (bpf_print_operand_address): Likewise, but to support + UNSPEC_CORE_RELOC in addresses. + (bpf_init_builtins): Flag BPF_BUILTIN_CORE_RELOC as NOTHROW. + * config/bpf/bpf.md: Wrap patterns for MOV, LD and ST + instruction with bpf_output_move call. + (mov_reloc_core<MM:mode>): Remove now spurious define_insn. + * config/bpf/constraints.md: Added "c" and "C" constraints to + match immediates represented with UNSPEC_CORE_RELOC. + * config/bpf/core-builtins.cc (bpf_add_core_reloc): Remove + (bpf_output_core_reloc): Add function to create the CO-RE + relocations based on new matching rules. + * config/bpf/core-builtins.h (bpf_output_core_reloc): Add + prototype. + * config/bpf/predicates.md (core_imm_operand) Add predicate. + (mov_src_operand): Add match for core_imm_operand. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/114768 + * rtlanal.cc (set_noop_p): Don't return true for MEM <- MEM + sets if src has side-effects or for stores into ZERO_EXTRACT + if ZERO_EXTRACT operand has side-effects. + +2024-04-19 Alexandre Oliva <oliva@adacore.com> + + * config/t-vxworks (vxw-glimits.h): Don't mangle c23-required + __STDC_VERSION_LIMITS_H__ define. + +2024-04-18 Sandra Loosemore <sloosemore@baylibre.com> + + * config.gcc: Add nios2*-*-* to the list of obsoleted targets. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * doc/sourcebuild.texi (strndup): Add effective target. + +2024-04-18 Tamar Christina <tamar.christina@arm.com> + + PR target/114741 + * config/aarch64/aarch64.md (<optab><mode>3): Remove ^ from alt 2. + (copysign<GPF:mode>3): Use SIMD version of IOR directly. + +2024-04-18 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/114753 + * internal-fn.cc (expand_mul_overflow): Save flag_trapv and + temporarily clear it for the duration of the function, then + restore previous value. + (expand_vector_ubsan_overflow): Likewise. + (expand_arith_overflow): Likewise. + 2024-04-17 Jakub Jelinek <jakub@redhat.com> PR other/114738 diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index ee86d6c39bf..3424846c2ca 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20240418 +20240501 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 0d9014ae51f..edbc70e34a1 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,7 @@ +2024-04-26 Jakub Jelinek <jakub@redhat.com> + + * gnatvsn.ads: Bump Library_Version to 15. + 2024-04-15 Piotr Trojanek <trojanek@adacore.com> * doc/gnat_rm/implementation_defined_aspects.rst diff --git a/gcc/ada/gnatvsn.ads b/gcc/ada/gnatvsn.ads index 29238362cc0..6cf170dc4ca 100644 --- a/gcc/ada/gnatvsn.ads +++ b/gcc/ada/gnatvsn.ads @@ -32,7 +32,7 @@ package Gnatvsn is -- Static string identifying this version, that can be used as an argument -- to e.g. pragma Ident. - Library_Version : constant String := "14"; + Library_Version : constant String := "15"; -- Library version. It needs to be updated whenever the major version -- number is changed. -- diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 0e8784f9821..f6af0dc2dc8 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,25 @@ +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + PR c++/114456 + * c-cppbuiltin.cc (c_cpp_builtins): Predefine + __cpp_structured_bindings for C++26 to 202403L rather than + 201606L. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * c-attribs.cc (handle_objc_nullability_attribute): Spelling fix: + recognised -> recognized. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * c.opt (Wstrict-flex-arrays): Spelling fix: inproper -> improper. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR c/114780 + * c-common.cc (check_function_sentinel): Allow as sentinel any + argument of NULLPTR_TYPE. + 2024-04-13 Mark Wielaard <mark@klomp.org> * c.opt.urls: Regenerate. diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index 40a0cf90295..04e39b41bdf 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -6244,7 +6244,7 @@ handle_objc_nullability_attribute (tree *node, tree name, tree args, || strcmp (TREE_STRING_POINTER (val), "resettable") == 0)) *no_add_attrs = false; /* OK */ else if (val != error_mark_node) - error ("%qE attribute argument %qE is not recognised", name, val); + error ("%qE attribute argument %qE is not recognized", name, val); return NULL_TREE; } diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index 6fa8243b02b..01e3d247fc2 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -5783,6 +5783,7 @@ check_function_sentinel (const_tree fntype, int nargs, tree *argarray) sentinel = fold_for_warn (argarray[nargs - 1 - pos]); if ((!POINTER_TYPE_P (TREE_TYPE (sentinel)) || !integer_zerop (sentinel)) + && TREE_CODE (TREE_TYPE (sentinel)) != NULLPTR_TYPE /* Although __null (in C++) is only an integer we allow it nevertheless, as we are guaranteed that it's exactly as wide as a pointer, and we don't want to force diff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc index 38f32032982..0a927b28836 100644 --- a/gcc/c-family/c-cppbuiltin.cc +++ b/gcc/c-family/c-cppbuiltin.cc @@ -1044,7 +1044,8 @@ c_cpp_builtins (cpp_reader *pfile) /* Old macro, superseded by __cpp_nontype_template_parameter_auto. */ cpp_define (pfile, "__cpp_template_auto=201606L"); - cpp_define (pfile, "__cpp_structured_bindings=201606L"); + if (cxx_dialect <= cxx23) + cpp_define (pfile, "__cpp_structured_bindings=201606L"); cpp_define (pfile, "__cpp_variadic_using=201611L"); cpp_define (pfile, "__cpp_guaranteed_copy_elision=201606L"); cpp_define (pfile, "__cpp_nontype_template_parameter_auto=201606L"); @@ -1090,6 +1091,7 @@ c_cpp_builtins (cpp_reader *pfile) cpp_define (pfile, "__cpp_constexpr=202306L"); cpp_define (pfile, "__cpp_static_assert=202306L"); cpp_define (pfile, "__cpp_placeholder_variables=202306L"); + cpp_define (pfile, "__cpp_structured_bindings=202403L"); } if (flag_concepts) { diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt index 848c2fda203..403abc1f26e 100644 --- a/gcc/c-family/c.opt +++ b/gcc/c-family/c.opt @@ -1320,7 +1320,7 @@ C ObjC C++ ObjC++ LangEnabledBy(C ObjC C++ ObjC++,Wall, 3, 0) IntegerRange(0, 3) Wstrict-flex-arrays C C++ Var(warn_strict_flex_arrays) Warning -Warn about inproper usages of flexible array members +Warn about improper usages of flexible array members according to the level of -fstrict-flex-arrays. Wstrict-null-sentinel diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index 58ff5c9f608..4601d5fc499 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,23 @@ +2024-04-30 Richard Biener <rguenther@suse.de> + + * gimple-parser.cc (c_parser_gimple_binary_expression): + Parse __{CEIL,FLOOR,ROUND}_{DIV,MOD} and __EXACT_DIV. + +2024-04-19 Martin Uecker <uecker@tugraz.at> + Jakub Jelinek <jakub@redhat.com> + + PR lto/114574 + PR c/114361 + * c-decl.cc (shadow_tag_warned): For flag_isoc23 and code not + ENUMERAL_TYPE use SET_TYPE_STRUCTURAL_EQUALITY. + (parser_xref_tag): Likewise. + (start_struct): For flag_isoc23 use SET_TYPE_STRUCTURAL_EQUALITY. + (c_update_type_canonical): New function. + (finish_struct): Put NULL as second == operand rather than first. + Assert TYPE_STRUCTURAL_EQUALITY_P. Call c_update_type_canonical. + * c-typeck.cc (composite_type_internal): Use + SET_TYPE_STRUCTURAL_EQUALITY. Formatting fix. + 2024-04-09 Jakub Jelinek <jakub@redhat.com> * c-decl.cc (previous_tag): Fix duplicated words in comment; the the diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index 345090dae38..52af8f32998 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -5051,6 +5051,8 @@ shadow_tag_warned (const struct c_declspecs *declspecs, int warned) if (t == NULL_TREE) { t = make_node (code); + if (flag_isoc23 && code != ENUMERAL_TYPE) + SET_TYPE_STRUCTURAL_EQUALITY (t); pushtag (input_location, name, t); } } @@ -8809,6 +8811,8 @@ parser_xref_tag (location_t loc, enum tree_code code, tree name, the forward-reference will be altered into a real type. */ ref = make_node (code); + if (flag_isoc23 && code != ENUMERAL_TYPE) + SET_TYPE_STRUCTURAL_EQUALITY (ref); if (code == ENUMERAL_TYPE) { /* Give the type a default layout like unsigned int @@ -8910,6 +8914,8 @@ start_struct (location_t loc, enum tree_code code, tree name, if (ref == NULL_TREE || TREE_CODE (ref) != code) { ref = make_node (code); + if (flag_isoc23) + SET_TYPE_STRUCTURAL_EQUALITY (ref); pushtag (loc, name, ref); } @@ -9347,6 +9353,45 @@ is_flexible_array_member_p (bool is_last_field, return false; } +/* Recompute TYPE_CANONICAL for variants of the type including qualified + versions of the type and related pointer types after an aggregate type + has been finalized. + Will not update array types, pointers to array types, function + types and other derived types created while the type was still + incomplete, those will remain TYPE_STRUCTURAL_EQUALITY_P. */ + +static void +c_update_type_canonical (tree t) +{ + for (tree x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x)) + { + if (x != t && TYPE_STRUCTURAL_EQUALITY_P (x)) + { + if (TYPE_QUALS (x) == TYPE_QUALS (t)) + TYPE_CANONICAL (x) = TYPE_CANONICAL (t); + else if (TYPE_CANONICAL (t) != t + || check_qualified_type (x, t, TYPE_QUALS (x))) + TYPE_CANONICAL (x) + = build_qualified_type (TYPE_CANONICAL (t), TYPE_QUALS (x)); + else + TYPE_CANONICAL (x) = x; + } + else if (x != t) + continue; + for (tree p = TYPE_POINTER_TO (x); p; p = TYPE_NEXT_PTR_TO (p)) + { + if (!TYPE_STRUCTURAL_EQUALITY_P (p)) + continue; + if (TYPE_CANONICAL (x) != x || TYPE_REF_CAN_ALIAS_ALL (p)) + TYPE_CANONICAL (p) + = build_pointer_type_for_mode (TYPE_CANONICAL (x), TYPE_MODE (p), + false); + else + TYPE_CANONICAL (p) = p; + c_update_type_canonical (p); + } + } +} /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T. LOC is the location of the RECORD_TYPE or UNION_TYPE's definition. @@ -9695,11 +9740,12 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes, /* Set type canonical based on equivalence class. */ if (flag_isoc23) { - if (NULL == c_struct_htab) + if (c_struct_htab == NULL) c_struct_htab = hash_table<c_struct_hasher>::create_ggc (61); hashval_t hash = c_struct_hasher::hash (t); + gcc_checking_assert (TYPE_STRUCTURAL_EQUALITY_P (t)); tree *e = c_struct_htab->find_slot_with_hash (t, hash, INSERT); if (*e) TYPE_CANONICAL (t) = *e; @@ -9708,6 +9754,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes, TYPE_CANONICAL (t) = t; *e = t; } + c_update_type_canonical (t); } tree incomplete_vars = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)); diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index ddeab1e2a8a..4567b114734 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -532,6 +532,7 @@ composite_type_internal (tree t1, tree t2, struct composite_cache* cache) /* Otherwise, create a new type node and link it into the cache. */ tree n = make_node (code1); + SET_TYPE_STRUCTURAL_EQUALITY (n); TYPE_NAME (n) = TYPE_NAME (t1); struct composite_cache cache2 = { t1, t2, n, cache }; @@ -590,7 +591,8 @@ composite_type_internal (tree t1, tree t2, struct composite_cache* cache) TYPE_STUB_DECL (n) = pushdecl (build_decl (input_location, TYPE_DECL, NULL_TREE, n)); - n = finish_struct(input_location, n, fields, attributes, NULL, &expr); + n = finish_struct (input_location, n, fields, attributes, NULL, + &expr); n = qualify_type (n, t1); diff --git a/gcc/c/gimple-parser.cc b/gcc/c/gimple-parser.cc index 2dac41a335a..d156d83cd37 100644 --- a/gcc/c/gimple-parser.cc +++ b/gcc/c/gimple-parser.cc @@ -1055,6 +1055,41 @@ c_parser_gimple_binary_expression (gimple_parser &parser, tree ret_type) code = LTGT_EXPR; break; } + else if (strcmp (IDENTIFIER_POINTER (id), "__FLOOR_DIV") == 0) + { + code = FLOOR_DIV_EXPR; + break; + } + else if (strcmp (IDENTIFIER_POINTER (id), "__ROUND_DIV") == 0) + { + code = ROUND_DIV_EXPR; + break; + } + else if (strcmp (IDENTIFIER_POINTER (id), "__EXACT_DIV") == 0) + { + code = EXACT_DIV_EXPR; + break; + } + else if (strcmp (IDENTIFIER_POINTER (id), "__CEIL_DIV") == 0) + { + code = CEIL_DIV_EXPR; + break; + } + else if (strcmp (IDENTIFIER_POINTER (id), "__FLOOR_MOD") == 0) + { + code = FLOOR_MOD_EXPR; + break; + } + else if (strcmp (IDENTIFIER_POINTER (id), "__ROUND_MOD") == 0) + { + code = ROUND_MOD_EXPR; + break; + } + else if (strcmp (IDENTIFIER_POINTER (id), "__CEIL_MOD") == 0) + { + code = CEIL_MOD_EXPR; + break; + } } /* Fallthru. */ default: diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc index eef565eddb5..cfc5291aa0c 100644 --- a/gcc/cfgexpand.cc +++ b/gcc/cfgexpand.cc @@ -4002,17 +4002,16 @@ expand_gimple_stmt_1 (gimple *stmt) else { rtx target, temp; - bool nontemporal = gimple_assign_nontemporal_move_p (assign_stmt); + gcc_assert (!gimple_assign_nontemporal_move_p (assign_stmt)); bool promoted = false; target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE); if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target)) promoted = true; - /* If we want to use a nontemporal store, force the value to - register first. If we store into a promoted register, - don't directly expand to target. */ - temp = nontemporal || promoted ? NULL_RTX : target; + /* If we store into a promoted register, don't directly + expand to target. */ + temp = promoted ? NULL_RTX : target; temp = expand_expr_real_gassign (assign_stmt, temp, GET_MODE (target), EXPAND_NORMAL); @@ -4034,8 +4033,6 @@ expand_gimple_stmt_1 (gimple *stmt) convert_move (SUBREG_REG (target), temp, unsignedp); } - else if (nontemporal && emit_storent_insn (target, temp)) - ; else { temp = force_operand (temp, target); diff --git a/gcc/common/config/i386/i386-common.cc b/gcc/common/config/i386/i386-common.cc index f814df8385b..77b154663bc 100644 --- a/gcc/common/config/i386/i386-common.cc +++ b/gcc/common/config/i386/i386-common.cc @@ -2302,7 +2302,7 @@ const pta processor_alias_table[] = {"gracemont", PROCESSOR_ALDERLAKE, CPU_HASWELL, PTA_ALDERLAKE, M_CPU_SUBTYPE (INTEL_COREI7_ALDERLAKE), P_PROC_AVX2}, {"sierraforest", PROCESSOR_SIERRAFOREST, CPU_HASWELL, PTA_SIERRAFOREST, - M_CPU_SUBTYPE (INTEL_SIERRAFOREST), P_PROC_AVX2}, + M_CPU_TYPE (INTEL_SIERRAFOREST), P_PROC_AVX2}, {"grandridge", PROCESSOR_GRANDRIDGE, CPU_HASWELL, PTA_GRANDRIDGE, M_CPU_TYPE (INTEL_GRANDRIDGE), P_PROC_AVX2}, {"clearwaterforest", PROCESSOR_CLEARWATERFOREST, CPU_HASWELL, diff --git a/gcc/common/config/riscv/riscv-common.cc b/gcc/common/config/riscv/riscv-common.cc index 43b7549e3ec..8cc0e727737 100644 --- a/gcc/common/config/riscv/riscv-common.cc +++ b/gcc/common/config/riscv/riscv-common.cc @@ -1638,15 +1638,15 @@ static const riscv_ext_flag_table_t riscv_ext_flag_table[] = {"zihintntl", &gcc_options::x_riscv_zi_subext, MASK_ZIHINTNTL}, {"zihintpause", &gcc_options::x_riscv_zi_subext, MASK_ZIHINTPAUSE}, + {"ziccamoa", &gcc_options::x_riscv_zi_subext, MASK_ZICCAMOA}, + {"ziccif", &gcc_options::x_riscv_zi_subext, MASK_ZICCIF}, + {"zicclsm", &gcc_options::x_riscv_zi_subext, MASK_ZICCLSM}, + {"ziccrse", &gcc_options::x_riscv_zi_subext, MASK_ZICCRSE}, {"zicboz", &gcc_options::x_riscv_zicmo_subext, MASK_ZICBOZ}, {"zicbom", &gcc_options::x_riscv_zicmo_subext, MASK_ZICBOM}, {"zicbop", &gcc_options::x_riscv_zicmo_subext, MASK_ZICBOP}, {"zic64b", &gcc_options::x_riscv_zicmo_subext, MASK_ZIC64B}, - {"ziccamoa", &gcc_options::x_riscv_zicmo_subext, MASK_ZICCAMOA}, - {"ziccif", &gcc_options::x_riscv_zicmo_subext, MASK_ZICCIF}, - {"zicclsm", &gcc_options::x_riscv_zicmo_subext, MASK_ZICCLSM}, - {"ziccrse", &gcc_options::x_riscv_zicmo_subext, MASK_ZICCRSE}, {"zve32x", &gcc_options::x_target_flags, MASK_VECTOR}, {"zve32f", &gcc_options::x_target_flags, MASK_VECTOR}, diff --git a/gcc/config.gcc b/gcc/config.gcc index 5df3c52f8e9..95c91ee02be 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -274,6 +274,7 @@ esac case ${target}${target_min} in *-*-solaris2.11.[0-3]* \ | ia64*-*-* \ + | nios2*-*-* \ ) if test "x$enable_obsolete" != xyes; then echo "*** Configuration ${target}${target_min} is obsolete." >&2 @@ -393,6 +394,8 @@ bfin*-*) ;; bpf-*-*) cpu_type=bpf + c_target_objs="bpf-c.o" + cxx_target_objs="bpf-c.o" ;; frv*) cpu_type=frv extra_options="${extra_options} g.opt" @@ -485,7 +488,7 @@ loongarch*-*-*) cpu_type=loongarch d_target_objs="loongarch-d.o" extra_headers="larchintrin.h lsxintrin.h lasxintrin.h" - extra_objs="loongarch-c.o loongarch-builtins.o loongarch-cpu.o loongarch-opts.o loongarch-def.o" + extra_objs="loongarch-c.o loongarch-builtins.o loongarch-cpu.o loongarch-opts.o loongarch-def.o loongarch-evolution.o" extra_gcc_objs="loongarch-driver.o loongarch-cpu.o loongarch-opts.o loongarch-def.o" extra_options="${extra_options} g.opt fused-madd.opt" ;; @@ -4569,7 +4572,7 @@ case "${target}" in for which in arch tune; do eval "val=\$with_$which" case ${val} in - "" | fiji | gfx900 | gfx906 | gfx908 | gfx90a | gfx1030 | gfx1036 | gfx1100 | gfx1103) + "" | fiji | gfx900 | gfx906 | gfx908 | gfx90a | gfx90c | gfx1030 | gfx1036 | gfx1100 | gfx1103) # OK ;; *) @@ -4585,7 +4588,7 @@ case "${target}" in TM_MULTILIB_CONFIG= ;; xdefault | xyes) - TM_MULTILIB_CONFIG=`echo "gfx900,gfx906,gfx908,gfx90a,gfx1030,gfx1036,gfx1100,gfx1103" | sed "s/${with_arch},\?//;s/,$//"` + TM_MULTILIB_CONFIG=`echo "gfx900,gfx906,gfx908,gfx90a,gfx90c,gfx1030,gfx1036,gfx1100,gfx1103" | sed "s/${with_arch},\?//;s/,$//"` ;; *) TM_MULTILIB_CONFIG="${with_multilib_list}" @@ -5072,7 +5075,7 @@ case "${target}" in # Perform initial sanity checks on --with-* options. case ${with_arch} in - "" | abi-default | loongarch64 | la[46]64) ;; # OK, append here. + "" | la64v1.[01] | abi-default | loongarch64 | la[46]64) ;; # OK, append here. native) if test x${host} != x${target}; then echo "--with-arch=native is illegal for cross-compiler." 1>&2 @@ -5119,10 +5122,18 @@ case "${target}" in # Infer ISA-related default options from the ABI: pass 1 case ${abi_base}/${abi_ext} in - lp64*/base) + lp64d/base) # architectures that support lp64* ABI - arch_pattern="native|abi-default|loongarch64|la[46]64" - # default architecture for lp64* ABI + arch_pattern="native|abi-default|la64v1.[01]|loongarch64|la[46]64" + + # default architecture for lp64d ABI + arch_default="la64v1.0" + ;; + lp64[fs]/base) + # architectures that support lp64* ABI + arch_pattern="native|abi-default|la64v1.[01]|loongarch64|la[46]64" + + # default architecture for lp64[fs] ABI arch_default="abi-default" ;; *) @@ -5194,15 +5205,7 @@ case "${target}" in # Check default with_tune configuration using with_arch. - case ${with_arch} in - loongarch64) - tune_pattern="native|abi-default|loongarch64|la[46]64" - ;; - *) - # By default, $with_tune == $with_arch - tune_pattern="*" - ;; - esac + tune_pattern="native|generic|loongarch64|la[46]64" case ${with_tune} in "") ;; # OK @@ -5252,7 +5255,7 @@ case "${target}" in # Fixed: use the default gcc configuration for all multilib # builds by default. with_multilib_default="" ;; - arch,native|arch,loongarch64|arch,la[46]64) # OK, append here. + arch,native|arch,la64v1.[01]|arch,loongarch64|arch,la[46]64) # OK, append here. with_multilib_default="/march=${component}" ;; arch,*) with_multilib_default="/march=abi-default" @@ -5352,7 +5355,7 @@ case "${target}" in if test x${parse_state} = x"arch"; then # -march option case ${component} in - native | abi-default | loongarch64 | la[46]64) # OK, append here. + native | abi-default | la64v1.[01] | loongarch64 | la[46]64) # OK, append here. # Append -march spec for each multilib variant. loongarch_multilib_list_make="${loongarch_multilib_list_make}/march=${component}" parse_state="opts" @@ -5925,7 +5928,7 @@ case ${target} in # See macro definitions from loongarch-opts.h and loongarch-cpu.h. # Architecture - tm_defines="${tm_defines} DEFAULT_CPU_ARCH=CPU_$(echo ${with_arch} | tr a-z- A-Z_)" + tm_defines="${tm_defines} DEFAULT_CPU_ARCH=ARCH_$(echo ${with_arch} | tr a-z.- A-Z__)" # Base ABI type tm_defines="${tm_defines} DEFAULT_ABI_BASE=ABI_BASE_$(echo ${abi_base} | tr a-z- A-Z_)" @@ -5937,7 +5940,7 @@ case ${target} in # Microarchitecture if test x${with_tune} != x; then - tm_defines="${tm_defines} DEFAULT_CPU_TUNE=CPU_$(echo ${with_tune} | tr a-z- A-Z_)" + tm_defines="${tm_defines} DEFAULT_CPU_TUNE=TUNE_$(echo ${with_tune} | tr a-z.- A-Z__)" fi # FPU adjustment diff --git a/gcc/config/aarch64/aarch64-ldp-fusion.cc b/gcc/config/aarch64/aarch64-ldp-fusion.cc index 365dcf48b22..0bc225dae7b 100644 --- a/gcc/config/aarch64/aarch64-ldp-fusion.cc +++ b/gcc/config/aarch64/aarch64-ldp-fusion.cc @@ -315,17 +315,9 @@ any_post_modify_p (rtx x) static bool ldp_operand_mode_ok_p (machine_mode mode) { - const bool allow_qregs - = !(aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS); - if (!aarch64_ldpstp_operand_mode_p (mode)) return false; - const auto size = GET_MODE_SIZE (mode).to_constant (); - if (size == 16 && !allow_qregs) - return false; - // We don't pair up TImode accesses before RA because TImode is // special in that it can be allocated to a pair of GPRs or a single // FPR, and the RA is best placed to make that decision. diff --git a/gcc/config/aarch64/aarch64-ldpstp.md b/gcc/config/aarch64/aarch64-ldpstp.md index b7c0bf05cd1..7890a8cc32b 100644 --- a/gcc/config/aarch64/aarch64-ldpstp.md +++ b/gcc/config/aarch64/aarch64-ldpstp.md @@ -96,9 +96,7 @@ (set (match_operand:VQ2 2 "register_operand" "") (match_operand:VQ2 3 "memory_operand" ""))] "TARGET_FLOAT - && aarch64_operands_ok_for_ldpstp (operands, true) - && (aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS) == 0" + && aarch64_operands_ok_for_ldpstp (operands, true)" [(const_int 0)] { aarch64_finish_ldpstp_peephole (operands, true); @@ -111,9 +109,7 @@ (set (match_operand:VQ2 2 "memory_operand" "") (match_operand:VQ2 3 "register_operand" ""))] "TARGET_FLOAT - && aarch64_operands_ok_for_ldpstp (operands, false) - && (aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS) == 0" + && aarch64_operands_ok_for_ldpstp (operands, false)" [(const_int 0)] { aarch64_finish_ldpstp_peephole (operands, false); diff --git a/gcc/config/aarch64/aarch64-tuning-flags.def b/gcc/config/aarch64/aarch64-tuning-flags.def index d917da720b2..d5bcaebce77 100644 --- a/gcc/config/aarch64/aarch64-tuning-flags.def +++ b/gcc/config/aarch64/aarch64-tuning-flags.def @@ -36,9 +36,6 @@ AARCH64_EXTRA_TUNING_OPTION ("rename_fma_regs", RENAME_FMA_REGS) are not considered cheap. */ AARCH64_EXTRA_TUNING_OPTION ("cheap_shift_extend", CHEAP_SHIFT_EXTEND) -/* Disallow load/store pair instructions on Q-registers. */ -AARCH64_EXTRA_TUNING_OPTION ("no_ldp_stp_qregs", NO_LDP_STP_QREGS) - AARCH64_EXTRA_TUNING_OPTION ("rename_load_regs", RENAME_LOAD_REGS) AARCH64_EXTRA_TUNING_OPTION ("cse_sve_vl_constants", CSE_SVE_VL_CONSTANTS) diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 1beec94629d..662ff5a9b0c 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -103,6 +103,10 @@ /* Defined for convenience. */ #define POINTER_BYTES (POINTER_SIZE / BITS_PER_UNIT) +/* Maximum bytes set for an inline memset expansion. With -Os use 3 STP + and 1 MOVI/DUP (same size as a call). */ +#define MAX_SET_SIZE(speed) (speed ? 256 : 96) + /* Flags that describe how a function shares certain architectural state with its callers. @@ -10400,9 +10404,7 @@ aarch64_mode_valid_for_sched_fusion_p (machine_mode mode) || mode == SDmode || mode == DDmode || (aarch64_vector_mode_supported_p (mode) && (known_eq (GET_MODE_SIZE (mode), 8) - || (known_eq (GET_MODE_SIZE (mode), 16) - && (aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS) == 0))); + || known_eq (GET_MODE_SIZE (mode), 16))); } /* Return true if REGNO is a virtual pointer register, or an eliminable @@ -16519,10 +16521,6 @@ aarch64_advsimd_ldp_stp_p (enum vect_cost_for_stmt kind, return false; } - if (aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS) - return false; - return is_gimple_assign (stmt_info->stmt); } @@ -17170,9 +17168,6 @@ aarch64_stp_sequence_cost (unsigned int count, vect_cost_for_stmt kind, /* Count 1 insn per vector if we can't form STP Q pairs. */ if (aarch64_sve_mode_p (TYPE_MODE (vectype))) return count * 2; - if (aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS) - return count * 2; if (stmt_info) { @@ -25579,7 +25574,6 @@ static bool aarch64_evpc_reencode (struct expand_vec_perm_d *d) { expand_vec_perm_d newd; - unsigned HOST_WIDE_INT nelt; if (d->vec_flags != VEC_ADVSIMD) return false; @@ -25594,24 +25588,10 @@ aarch64_evpc_reencode (struct expand_vec_perm_d *d) if (new_mode == word_mode) return false; - /* to_constant is safe since this routine is specific to Advanced SIMD - vectors. */ - nelt = d->perm.length ().to_constant (); - - vec_perm_builder newpermconst; - newpermconst.new_vector (nelt / 2, nelt / 2, 1); + vec_perm_indices newpermindices; - /* Convert the perm constant if we can. Require even, odd as the pairs. */ - for (unsigned int i = 0; i < nelt; i += 2) - { - poly_int64 elt0 = d->perm[i]; - poly_int64 elt1 = d->perm[i + 1]; - poly_int64 newelt; - if (!multiple_p (elt0, 2, &newelt) || maybe_ne (elt0 + 1, elt1)) - return false; - newpermconst.quick_push (newelt.to_constant ()); - } - newpermconst.finalize (); + if (!newpermindices.new_shrunk_vector (d->perm, 2)) + return false; newd.vmode = new_mode; newd.vec_flags = VEC_ADVSIMD; @@ -25623,7 +25603,8 @@ aarch64_evpc_reencode (struct expand_vec_perm_d *d) newd.testing_p = d->testing_p; newd.one_vector_p = d->one_vector_p; - newd.perm.new_vector (newpermconst, newd.one_vector_p ? 1 : 2, nelt / 2); + newd.perm.new_vector (newpermindices.encoding (), newd.one_vector_p ? 1 : 2, + newpermindices.nelts_per_input ()); return aarch64_expand_vec_perm_const_1 (&newd); } @@ -26574,15 +26555,6 @@ aarch64_move_pointer (rtx pointer, poly_int64 amount) next, amount); } -/* Return a new RTX holding the result of moving POINTER forward by the - size of the mode it points to. */ - -static rtx -aarch64_progress_pointer (rtx pointer) -{ - return aarch64_move_pointer (pointer, GET_MODE_SIZE (GET_MODE (pointer))); -} - /* Expand a cpymem/movmem using the MOPS extension. OPERANDS are taken from the cpymem/movmem pattern. IS_MEMMOVE is true if this is a memmove rather than memcpy. Return true iff we succeeded. */ @@ -26625,11 +26597,9 @@ aarch64_expand_cpymem (rtx *operands, bool is_memmove) return aarch64_expand_cpymem_mops (operands, is_memmove); unsigned HOST_WIDE_INT size = UINTVAL (operands[2]); - bool use_ldpq = TARGET_SIMD && !(aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS); /* Set inline limits for memmove/memcpy. MOPS has a separate threshold. */ - unsigned max_copy_size = use_ldpq ? 256 : 128; + unsigned max_copy_size = TARGET_SIMD ? 256 : 128; unsigned mops_threshold = is_memmove ? aarch64_mops_memmove_size_threshold : aarch64_mops_memcpy_size_threshold; @@ -26710,48 +26680,6 @@ aarch64_expand_cpymem (rtx *operands, bool is_memmove) return true; } -/* Like aarch64_copy_one_block_and_progress_pointers, except for memset where - SRC is a register we have created with the duplicated value to be set. */ -static void -aarch64_set_one_block_and_progress_pointer (rtx src, rtx *dst, - machine_mode mode) -{ - /* If we are copying 128bits or 256bits, we can do that straight from - the SIMD register we prepared. */ - if (known_eq (GET_MODE_BITSIZE (mode), 256)) - { - mode = GET_MODE (src); - /* "Cast" the *dst to the correct mode. */ - *dst = adjust_address (*dst, mode, 0); - /* Emit the memset. */ - emit_move_insn (*dst, src); - emit_move_insn (aarch64_move_pointer (*dst, 16), src); - - /* Move the pointers forward. */ - *dst = aarch64_move_pointer (*dst, 32); - return; - } - if (known_eq (GET_MODE_BITSIZE (mode), 128)) - { - /* "Cast" the *dst to the correct mode. */ - *dst = adjust_address (*dst, GET_MODE (src), 0); - /* Emit the memset. */ - emit_move_insn (*dst, src); - /* Move the pointers forward. */ - *dst = aarch64_move_pointer (*dst, 16); - return; - } - /* For copying less, we have to extract the right amount from src. */ - rtx reg = lowpart_subreg (mode, src, GET_MODE (src)); - - /* "Cast" the *dst to the correct mode. */ - *dst = adjust_address (*dst, mode, 0); - /* Emit the memset. */ - emit_move_insn (*dst, reg); - /* Move the pointer forward. */ - *dst = aarch64_progress_pointer (*dst); -} - /* Expand a setmem using the MOPS instructions. OPERANDS are the same as for the setmem pattern. Return true iff we succeed. */ static bool @@ -26778,24 +26706,21 @@ aarch64_expand_setmem_mops (rtx *operands) bool aarch64_expand_setmem (rtx *operands) { - int n, mode_bits; + int mode_bytes; unsigned HOST_WIDE_INT len; rtx dst = operands[0]; rtx val = operands[2], src; unsigned align = UINTVAL (operands[3]); rtx base; - machine_mode cur_mode = BLKmode, next_mode; + machine_mode mode = BLKmode, next_mode; /* Variable-sized or strict-align memset may use the MOPS expansion. */ if (!CONST_INT_P (operands[1]) || !TARGET_SIMD || (STRICT_ALIGNMENT && align < 16)) return aarch64_expand_setmem_mops (operands); - bool size_p = optimize_function_for_size_p (cfun); - - /* Default the maximum to 256-bytes when considering only libcall vs - SIMD broadcast sequence. */ - unsigned max_set_size = 256; + /* Set inline limits for memset. MOPS has a separate threshold. */ + unsigned max_set_size = MAX_SET_SIZE (optimize_function_for_speed_p (cfun)); unsigned mops_threshold = aarch64_mops_memset_size_threshold; len = UINTVAL (operands[1]); @@ -26804,91 +26729,51 @@ aarch64_expand_setmem (rtx *operands) if (len > max_set_size || (TARGET_MOPS && len > mops_threshold)) return aarch64_expand_setmem_mops (operands); - int cst_val = !!(CONST_INT_P (val) && (INTVAL (val) != 0)); - /* The MOPS sequence takes: - 3 instructions for the memory storing - + 1 to move the constant size into a reg - + 1 if VAL is a non-zero constant to move into a reg - (zero constants can use XZR directly). */ - unsigned mops_cost = 3 + 1 + cst_val; - /* A libcall to memset in the worst case takes 3 instructions to prepare - the arguments + 1 for the call. */ - unsigned libcall_cost = 4; - - /* Attempt a sequence with a vector broadcast followed by stores. - Count the number of operations involved to see if it's worth it - against the alternatives. A simple counter simd_ops on the - algorithmically-relevant operations is used rather than an rtx_insn count - as all the pointer adjusmtents and mode reinterprets will be optimized - away later. */ - start_sequence (); - unsigned simd_ops = 0; - base = copy_to_mode_reg (Pmode, XEXP (dst, 0)); dst = adjust_automodify_address (dst, VOIDmode, base, 0); /* Prepare the val using a DUP/MOVI v0.16B, val. */ - src = expand_vector_broadcast (V16QImode, val); - src = force_reg (V16QImode, src); - simd_ops++; - /* Convert len to bits to make the rest of the code simpler. */ - n = len * BITS_PER_UNIT; - - /* Maximum amount to copy in one go. We allow 256-bit chunks based on the - AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS tuning parameter. */ - const int copy_limit = (aarch64_tune_params.extra_tuning_flags - & AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS) - ? GET_MODE_BITSIZE (TImode) : 256; + val = expand_vector_broadcast (V16QImode, val); + val = force_reg (V16QImode, val); - while (n > 0) + int offset = 0; + while (len > 0) { /* Find the largest mode in which to do the copy without over writing. */ opt_scalar_int_mode mode_iter; FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) - if (GET_MODE_BITSIZE (mode_iter.require ()) <= MIN (n, copy_limit)) - cur_mode = mode_iter.require (); + if (GET_MODE_SIZE (mode_iter.require ()) <= MIN (len, 16)) + mode = mode_iter.require (); + + gcc_assert (mode != BLKmode); + + mode_bytes = GET_MODE_SIZE (mode).to_constant (); + + src = val; - gcc_assert (cur_mode != BLKmode); + /* Prefer Q-register accesses. */ + if (mode_bytes == 16) + mode = V16QImode; + else + src = lowpart_subreg (mode, src, GET_MODE (val)); - mode_bits = GET_MODE_BITSIZE (cur_mode).to_constant (); - aarch64_set_one_block_and_progress_pointer (src, &dst, cur_mode); - simd_ops++; - n -= mode_bits; + emit_move_insn (adjust_address (dst, mode, offset), src); + len -= mode_bytes; + offset += mode_bytes; /* Emit trailing writes using overlapping unaligned accesses - (when !STRICT_ALIGNMENT) - this is smaller and faster. */ - if (n > 0 && n < copy_limit / 2 && !STRICT_ALIGNMENT) + (when !STRICT_ALIGNMENT) - this is smaller and faster. */ + if (len > 0 && len < 16 && !STRICT_ALIGNMENT) { - next_mode = smallest_mode_for_size (n, MODE_INT); - int n_bits = GET_MODE_BITSIZE (next_mode).to_constant (); - gcc_assert (n_bits <= mode_bits); - dst = aarch64_move_pointer (dst, (n - n_bits) / BITS_PER_UNIT); - n = n_bits; + next_mode = smallest_mode_for_size (len * BITS_PER_UNIT, MODE_INT); + int n_bytes = GET_MODE_SIZE (next_mode).to_constant (); + gcc_assert (n_bytes <= mode_bytes); + offset -= n_bytes - len; + len = n_bytes; } } - rtx_insn *seq = get_insns (); - end_sequence (); - if (size_p) - { - /* When optimizing for size we have 3 options: the SIMD broadcast sequence, - call to memset or the MOPS expansion. */ - if (TARGET_MOPS - && mops_cost <= libcall_cost - && mops_cost <= simd_ops) - return aarch64_expand_setmem_mops (operands); - /* If MOPS is not available or not shorter pick a libcall if the SIMD - sequence is too long. */ - else if (libcall_cost < simd_ops) - return false; - emit_insn (seq); - return true; - } - - /* At this point the SIMD broadcast sequence is the best choice when - optimizing for speed. */ - emit_insn (seq); return true; } diff --git a/gcc/config/aarch64/tuning_models/emag.h b/gcc/config/aarch64/tuning_models/emag.h index cbaf8853ec4..b6a9c9e2eb1 100644 --- a/gcc/config/aarch64/tuning_models/emag.h +++ b/gcc/config/aarch64/tuning_models/emag.h @@ -51,7 +51,7 @@ static const struct tune_params emag_tunings = 2, /* min_div_recip_mul_df. */ 17, /* max_case_values. */ tune_params::AUTOPREFETCHER_OFF, /* autoprefetcher_model. */ - (AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS), /* tune_flags. */ + (AARCH64_EXTRA_TUNE_NONE), /* tune_flags. */ &xgene1_prefetch_tune, AARCH64_LDP_STP_POLICY_ALWAYS, /* ldp_policy_model. */ AARCH64_LDP_STP_POLICY_ALWAYS /* stp_policy_model. */ diff --git a/gcc/config/aarch64/tuning_models/xgene1.h b/gcc/config/aarch64/tuning_models/xgene1.h index 3301f025260..432793eba9c 100644 --- a/gcc/config/aarch64/tuning_models/xgene1.h +++ b/gcc/config/aarch64/tuning_models/xgene1.h @@ -136,7 +136,7 @@ static const struct tune_params xgene1_tunings = 2, /* min_div_recip_mul_df. */ 17, /* max_case_values. */ tune_params::AUTOPREFETCHER_OFF, /* autoprefetcher_model. */ - (AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS), /* tune_flags. */ + (AARCH64_EXTRA_TUNE_NONE), /* tune_flags. */ &xgene1_prefetch_tune, AARCH64_LDP_STP_POLICY_ALWAYS, /* ldp_policy_model. */ AARCH64_LDP_STP_POLICY_ALWAYS /* stp_policy_model. */ diff --git a/gcc/config/arm/arm.cc b/gcc/config/arm/arm.cc index 0217abc218d..ea0c963a4d6 100644 --- a/gcc/config/arm/arm.cc +++ b/gcc/config/arm/arm.cc @@ -19210,6 +19210,30 @@ cmse_nonsecure_call_inline_register_clear (void) end_sequence (); emit_insn_before (seq, insn); + /* The AAPCS requires the callee to widen integral types narrower + than 32 bits to the full width of the register; but when handling + calls to non-secure space, we cannot trust the callee to have + correctly done so. So forcibly re-widen the result here. */ + tree ret_type = TREE_TYPE (fntype); + if ((TREE_CODE (ret_type) == INTEGER_TYPE + || TREE_CODE (ret_type) == ENUMERAL_TYPE + || TREE_CODE (ret_type) == BOOLEAN_TYPE) + && known_lt (GET_MODE_SIZE (TYPE_MODE (ret_type)), 4)) + { + machine_mode ret_mode = TYPE_MODE (ret_type); + rtx extend; + if (TYPE_UNSIGNED (ret_type)) + extend = gen_rtx_ZERO_EXTEND (SImode, + gen_rtx_REG (ret_mode, R0_REGNUM)); + else + extend = gen_rtx_SIGN_EXTEND (SImode, + gen_rtx_REG (ret_mode, R0_REGNUM)); + emit_insn_after (gen_rtx_SET (gen_rtx_REG (SImode, R0_REGNUM), + extend), insn); + + } + + if (TARGET_HAVE_FPCXT_CMSE) { rtx_insn *last, *pop_insn, *after = insn; @@ -23652,6 +23676,51 @@ arm_expand_prologue (void) ip_rtx = gen_rtx_REG (SImode, IP_REGNUM); + /* The AAPCS requires the callee to widen integral types narrower + than 32 bits to the full width of the register; but when handling + calls to non-secure space, we cannot trust the callee to have + correctly done so. So forcibly re-widen the result here. */ + if (IS_CMSE_ENTRY (func_type)) + { + function_args_iterator args_iter; + CUMULATIVE_ARGS args_so_far_v; + cumulative_args_t args_so_far; + bool first_param = true; + tree arg_type; + tree fndecl = current_function_decl; + tree fntype = TREE_TYPE (fndecl); + arm_init_cumulative_args (&args_so_far_v, fntype, NULL_RTX, fndecl); + args_so_far = pack_cumulative_args (&args_so_far_v); + FOREACH_FUNCTION_ARGS (fntype, arg_type, args_iter) + { + rtx arg_rtx; + + if (VOID_TYPE_P (arg_type)) + break; + + function_arg_info arg (arg_type, /*named=*/true); + if (!first_param) + /* We should advance after processing the argument and pass + the argument we're advancing past. */ + arm_function_arg_advance (args_so_far, arg); + first_param = false; + arg_rtx = arm_function_arg (args_so_far, arg); + gcc_assert (REG_P (arg_rtx)); + if ((TREE_CODE (arg_type) == INTEGER_TYPE + || TREE_CODE (arg_type) == ENUMERAL_TYPE + || TREE_CODE (arg_type) == BOOLEAN_TYPE) + && known_lt (GET_MODE_SIZE (GET_MODE (arg_rtx)), 4)) + { + if (TYPE_UNSIGNED (arg_type)) + emit_set_insn (gen_rtx_REG (SImode, REGNO (arg_rtx)), + gen_rtx_ZERO_EXTEND (SImode, arg_rtx)); + else + emit_set_insn (gen_rtx_REG (SImode, REGNO (arg_rtx)), + gen_rtx_SIGN_EXTEND (SImode, arg_rtx)); + } + } + } + if (IS_STACKALIGN (func_type)) { rtx r0, r1; diff --git a/gcc/config/bpf/bpf-c.cc b/gcc/config/bpf/bpf-c.cc new file mode 100644 index 00000000000..f12f0627103 --- /dev/null +++ b/gcc/config/bpf/bpf-c.cc @@ -0,0 +1,88 @@ +/* BPF-specific code for C family languages. + Copyright (C) 2024 Free Software Foundation, Inc. + Contributed by Oracle Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + +#define IN_TARGET_CODE 1 + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "c-family/c-common.h" +#include "cpplib.h" + +/* Define target-specific CPP macros. This function in used in the + definition of TARGET_CPU_CPP_BUILTINS in bpf.h */ + +#define builtin_define(TXT) cpp_define (pfile, TXT) + +void +bpf_target_macros (cpp_reader *pfile) +{ + builtin_define ("__BPF__"); + builtin_define ("__bpf__"); + + if (TARGET_BIG_ENDIAN) + builtin_define ("__BPF_BIG_ENDIAN__"); + else + builtin_define ("__BPF_LITTLE_ENDIAN__"); + + switch (bpf_isa) + { + case ISA_V1: + builtin_define_with_int_value ("__BPF_CPU_VERSION__", 1); + break; + case ISA_V2: + builtin_define_with_int_value ("__BPF_CPU_VERSION__", 2); + break; + case ISA_V3: + builtin_define_with_int_value ("__BPF_CPU_VERSION__", 3); + break; + case ISA_V4: + builtin_define_with_int_value ("__BPF_CPU_VERSION__", 4); + break; + default: + gcc_unreachable (); + break; + } + + /* Different BPF CPU versions support different features. Some of + them can be enabled/disabled explicitly. */ + if (bpf_has_alu32) + builtin_define ("__BPF_FEATURE_ALU32"); + if (bpf_has_jmp32) + builtin_define ("__BPF_FEATURE_JMP32"); + if (bpf_has_jmpext) + builtin_define ("__BPF_FEATURE_JMP_EXT"); + if (bpf_has_bswap) + builtin_define ("__BPF_FEATURE_BSWAP"); + if (bpf_has_sdiv) + builtin_define ("__BPF_FEATURE_SDIV_SMOD"); + if (bpf_has_smov) + builtin_define ("__BPF_FEATURE_MOVSX"); + + /* Other CPU features can only be enabled/disabled generically by + selecting the corresponding CPU version. */ + if (bpf_isa >= ISA_V4) + { + builtin_define ("__BPF_FEATURE_LDSX"); + builtin_define ("__BPF_FEATURE_GOTOL"); + builtin_define ("__BPF_FEATURE_ST"); + } +} diff --git a/gcc/config/bpf/bpf-protos.h b/gcc/config/bpf/bpf-protos.h index ac0c2f4038f..b4866d34209 100644 --- a/gcc/config/bpf/bpf-protos.h +++ b/gcc/config/bpf/bpf-protos.h @@ -30,7 +30,7 @@ extern void bpf_print_operand_address (FILE *, rtx); extern void bpf_expand_prologue (void); extern void bpf_expand_epilogue (void); extern void bpf_expand_cbranch (machine_mode, rtx *); -const char *bpf_add_core_reloc (rtx *operands, const char *templ); +const char *bpf_output_move (rtx *operands, const char *templ); class gimple_opt_pass; gimple_opt_pass *make_pass_lower_bpf_core (gcc::context *ctxt); diff --git a/gcc/config/bpf/bpf.cc b/gcc/config/bpf/bpf.cc index fb60770c170..e6ea211a2c6 100644 --- a/gcc/config/bpf/bpf.cc +++ b/gcc/config/bpf/bpf.cc @@ -192,7 +192,8 @@ bpf_option_override (void) init_machine_status = bpf_init_machine_status; /* BPF CO-RE support requires BTF debug info generation. */ - if (TARGET_BPF_CORE && !btf_debuginfo_p ()) + if (TARGET_BPF_CORE + && (!btf_debuginfo_p () || (debug_info_level < DINFO_LEVEL_NORMAL))) error ("BPF CO-RE requires BTF debugging information, use %<-gbtf%>"); /* BPF applications always generate .BTF.ext. */ @@ -215,7 +216,9 @@ bpf_option_override (void) /* -gbtf implies -mcore when using the BPF backend, unless -mno-co-re is specified. */ - if (btf_debuginfo_p () && !(target_flags_explicit & MASK_BPF_CORE)) + if (btf_debuginfo_p () + && (debug_info_level >= DINFO_LEVEL_NORMAL) + && !(target_flags_explicit & MASK_BPF_CORE)) target_flags |= MASK_BPF_CORE; /* Determine available features from ISA setting (-mcpu=). */ @@ -284,23 +287,6 @@ bpf_file_end (void) #undef TARGET_ASM_FILE_END #define TARGET_ASM_FILE_END bpf_file_end -/* Define target-specific CPP macros. This function in used in the - definition of TARGET_CPU_CPP_BUILTINS in bpf.h */ - -#define builtin_define(TXT) cpp_define (pfile, TXT) - -void -bpf_target_macros (cpp_reader *pfile) -{ - builtin_define ("__BPF__"); - builtin_define ("__bpf__"); - - if (TARGET_BIG_ENDIAN) - builtin_define ("__BPF_BIG_ENDIAN__"); - else - builtin_define ("__BPF_LITTLE_ENDIAN__"); -} - /* Return an RTX representing the place where a function returns or receives a value of data type RET_TYPE, a tree node representing a data type. */ @@ -584,6 +570,16 @@ bpf_legitimate_address_p (machine_mode mode, if (bpf_address_base_p (x0, strict) && GET_CODE (x1) == CONST_INT) return IN_RANGE (INTVAL (x1), -1 - 0x7fff, 0x7fff); + /* Check if any of the PLUS operation operands is a CORE unspec, and at + least the local value for the offset fits in the 16 bits available + in the encoding. */ + if (bpf_address_base_p (x1, strict) + && GET_CODE (x0) == UNSPEC && XINT (x0, 1) == UNSPEC_CORE_RELOC) + return IN_RANGE (INTVAL (XVECEXP (x0, 0, 0)), -1 - 0x7fff, 0x7fff); + if (bpf_address_base_p (x0, strict) + && GET_CODE (x1) == UNSPEC && XINT (x1, 1) == UNSPEC_CORE_RELOC) + return IN_RANGE (INTVAL (XVECEXP (x1, 0, 0)), -1 - 0x7fff, 0x7fff); + break; } default: @@ -615,6 +611,21 @@ bpf_rtx_costs (rtx x ATTRIBUTE_UNUSED, #undef TARGET_RTX_COSTS #define TARGET_RTX_COSTS bpf_rtx_costs +static int +bpf_insn_cost (rtx_insn *insn, bool speed ATTRIBUTE_UNUSED) +{ + rtx pat = PATTERN (insn); + if(GET_CODE (pat) == SET + && GET_CODE (XEXP (pat, 1)) == UNSPEC + && XINT (XEXP (pat, 1), 1) == UNSPEC_CORE_RELOC) + return COSTS_N_INSNS (100); + + return COSTS_N_INSNS (1); +} + +#undef TARGET_INSN_COST +#define TARGET_INSN_COST bpf_insn_cost + /* Return true if an argument at the position indicated by CUM should be passed by reference. If the hook returns true, a copy of that argument is made in memory and a pointer to the argument is passed @@ -771,6 +782,13 @@ bpf_output_call (rtx target) return ""; } +const char * +bpf_output_move (rtx *operands, const char *templ) +{ + bpf_output_core_reloc (operands, 2); + return templ; +} + /* Print register name according to assembly dialect. In normal syntax registers are printed like %rN where N is the register number. @@ -852,6 +870,12 @@ bpf_print_operand (FILE *file, rtx op, int code) gcc_unreachable (); } break; + case UNSPEC: + if (XINT (op, 1) == UNSPEC_CORE_RELOC) + bpf_print_operand (file, XVECEXP (op, 0, 0), code); + else + gcc_unreachable (); + break; default: output_addr_const (file, op); } @@ -880,13 +904,24 @@ bpf_print_operand_address (FILE *file, rtx addr) rtx op0 = XEXP (addr, 0); rtx op1 = XEXP (addr, 1); - if (GET_CODE (op0) == REG && GET_CODE (op1) == CONST_INT) + if (GET_CODE (op1) == REG) { + op0 = op1; + op1 = XEXP (addr, 0); + } + + if (GET_CODE (op0) == REG + && (GET_CODE (op1) == CONST_INT + || (GET_CODE (op1) == UNSPEC + && XINT (op1, 1) == UNSPEC_CORE_RELOC))) { if (asm_dialect == ASM_NORMAL) fprintf (file, "["); bpf_print_register (file, op0, 0); fprintf (file, "+"); - output_addr_const (file, op1); + if (GET_CODE (op1) == UNSPEC) + output_addr_const (file, XVECEXP (op1, 0, 0)); + else + output_addr_const (file, op1); if (asm_dialect == ASM_NORMAL) fprintf (file, "]"); } @@ -962,6 +997,7 @@ bpf_init_builtins (void) build_function_type_list (integer_type_node,integer_type_node, 0)); DECL_PURE_P (bpf_builtins[BPF_BUILTIN_CORE_RELOC]) = 1; + TREE_NOTHROW (bpf_builtins[BPF_BUILTIN_CORE_RELOC]) = 1; bpf_init_core_builtins (); } diff --git a/gcc/config/bpf/bpf.h b/gcc/config/bpf/bpf.h index 3cc5daa1b58..e163fbf688d 100644 --- a/gcc/config/bpf/bpf.h +++ b/gcc/config/bpf/bpf.h @@ -23,7 +23,9 @@ /**** Controlling the Compilation Driver. */ #define ASM_SPEC "%{mbig-endian:-EB} %{!mbig-endian:-EL} %{mxbpf:-mxbpf} " \ - "%{masm=pseudoc:-mdialect=pseudoc}" + "%{masm=normal:-mdialect=normal} " \ + "%{masm=pseudoc:-mdialect=pseudoc} " \ + "%{!masm=normal:%{!masm=pseudoc:-mdialect=pseudoc}}" #define LINK_SPEC "%{mbig-endian:-EB} %{!mbig-endian:-EL}" #define LIB_SPEC "" #define STARTFILE_SPEC "" @@ -243,6 +245,11 @@ enum reg_class /**** Debugging Info ****/ +/* Use BTF debug info by default. */ + +#undef PREFERRED_DEBUGGING_TYPE +#define PREFERRED_DEBUGGING_TYPE BTF_DEBUG + /* In eBPF it is not possible to unwind frames. Disable CFA. */ #define DWARF2_FRAME_INFO 0 diff --git a/gcc/config/bpf/bpf.md b/gcc/config/bpf/bpf.md index ea688aadf91..95859328d25 100644 --- a/gcc/config/bpf/bpf.md +++ b/gcc/config/bpf/bpf.md @@ -281,8 +281,8 @@ "" "@ {and\t%0,0xffff|%0 &= 0xffff} - {mov\t%0,%1\;and\t%0,0xffff|%0 = %1;%0 &= 0xffff} - {ldxh\t%0,%1|%0 = *(u16 *) (%1)}" + *return bpf_output_move (operands, \"{mov\t%0,%1\;and\t%0,0xffff|%0 = %1;%0 &= 0xffff}\"); + *return bpf_output_move (operands, \"{ldxh\t%0,%1|%0 = *(u16 *) (%1)}\");" [(set_attr "type" "alu,alu,ldx")]) (define_insn "zero_extendqidi2" @@ -291,8 +291,8 @@ "" "@ {and\t%0,0xff|%0 &= 0xff} - {mov\t%0,%1\;and\t%0,0xff|%0 = %1;%0 &= 0xff} - {ldxb\t%0,%1|%0 = *(u8 *) (%1)}" + *return bpf_output_move (operands, \"{mov\t%0,%1\;and\t%0,0xff|%0 = %1;%0 &= 0xff}\"); + *return bpf_output_move (operands, \"{ldxb\t%0,%1|%0 = *(u8 *) (%1)}\");" [(set_attr "type" "alu,alu,ldx")]) (define_insn "zero_extendsidi2" @@ -301,8 +301,8 @@ (match_operand:SI 1 "nonimmediate_operand" "r,q")))] "" "@ - * return bpf_has_alu32 ? \"{mov32\t%0,%1|%0 = %1}\" : \"{mov\t%0,%1\;and\t%0,0xffffffff|%0 = %1;%0 &= 0xffffffff}\"; - {ldxw\t%0,%1|%0 = *(u32 *) (%1)}" + *return bpf_output_move (operands, bpf_has_alu32 ? \"{mov32\t%0,%1|%0 = %1}\" : \"{mov\t%0,%1\;and\t%0,0xffffffff|%0 = %1;%0 &= 0xffffffff}\"); + *return bpf_output_move (operands, \"{ldxw\t%0,%1|%0 = *(u32 *) (%1)}\");" [(set_attr "type" "alu,ldx")]) ;;; Sign-extension @@ -328,8 +328,8 @@ (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "r,q")))] "bpf_has_smov" "@ - {movs\t%0,%1,32|%0 = (s32) %1} - {ldxsw\t%0,%1|%0 = *(s32 *) (%1)}" + *return bpf_output_move (operands, \"{movs\t%0,%1,32|%0 = (s32) %1}\"); + *return bpf_output_move (operands, \"{ldxsw\t%0,%1|%0 = *(s32 *) (%1)}\");" [(set_attr "type" "alu,ldx")]) (define_insn "extendhidi2" @@ -337,8 +337,8 @@ (sign_extend:DI (match_operand:HI 1 "nonimmediate_operand" "r,q")))] "bpf_has_smov" "@ - {movs\t%0,%1,16|%0 = (s16) %1} - {ldxsh\t%0,%1|%0 = *(s16 *) (%1)}" + *return bpf_output_move (operands, \"{movs\t%0,%1,16|%0 = (s16) %1}\"); + *return bpf_output_move (operands, \"{ldxsh\t%0,%1|%0 = *(s16 *) (%1)}\");" [(set_attr "type" "alu,ldx")]) (define_insn "extendqidi2" @@ -346,22 +346,22 @@ (sign_extend:DI (match_operand:QI 1 "nonimmediate_operand" "r,q")))] "bpf_has_smov" "@ - {movs\t%0,%1,8|%0 = (s8) %1} - {ldxsb\t%0,%1|%0 = *(s8 *) (%1)}" + *return bpf_output_move (operands, \"{movs\t%0,%1,8|%0 = (s8) %1}\"); + *return bpf_output_move (operands, \"{ldxsb\t%0,%1|%0 = *(s8 *) (%1)}\");" [(set_attr "type" "alu,ldx")]) (define_insn "extendhisi2" [(set (match_operand:SI 0 "register_operand" "=r") (sign_extend:SI (match_operand:HI 1 "register_operand" "r")))] "bpf_has_smov" - "{movs32\t%0,%1,16|%w0 = (s16) %w1}" + "*return bpf_output_move (operands, \"{movs32\t%0,%1,16|%w0 = (s16) %w1}\");" [(set_attr "type" "alu")]) (define_insn "extendqisi2" [(set (match_operand:SI 0 "register_operand" "=r") (sign_extend:SI (match_operand:QI 1 "register_operand" "r")))] "bpf_has_smov" - "{movs32\t%0,%1,8|%w0 = (s8) %w1}" + "*return bpf_output_move (operands, \"{movs32\t%0,%1,8|%w0 = (s8) %w1}\");" [(set_attr "type" "alu")]) ;;;; Data movement @@ -380,31 +380,17 @@ }") (define_insn "*mov<MM:mode>" - [(set (match_operand:MM 0 "nonimmediate_operand" "=r, r,r,q,q") - (match_operand:MM 1 "mov_src_operand" " q,rI,B,r,I"))] + [(set (match_operand:MM 0 "nonimmediate_operand" "=r, r, r,q,q") + (match_operand:MM 1 "mov_src_operand" " q,rIc,BC,r,I"))] "" "@ - {ldx<mop>\t%0,%1|%0 = *(<smop> *) (%1)} - {mov\t%0,%1|%0 = %1} - {lddw\t%0,%1|%0 = %1 ll} - {stx<mop>\t%0,%1|*(<smop> *) (%0) = %1} - {st<mop>\t%0,%1|*(<smop> *) (%0) = %1}" + *return bpf_output_move (operands, \"{ldx<mop>\t%0,%1|%0 = *(<smop> *) (%1)}\"); + *return bpf_output_move (operands, \"{mov\t%0,%1|%0 = %1}\"); + *return bpf_output_move (operands, \"{lddw\t%0,%1|%0 = %1 ll}\"); + *return bpf_output_move (operands, \"{stx<mop>\t%0,%1|*(<smop> *) (%0) = %1}\"); + *return bpf_output_move (operands, \"{st<mop>\t%0,%1|*(<smop> *) (%0) = %1}\");" [(set_attr "type" "ldx,alu,alu,stx,st")]) -(define_insn "*mov_reloc_core<MM:mode>" - [(set (match_operand:MM 0 "nonimmediate_operand" "=r,q,r") - (unspec:MM [ - (match_operand:MM 1 "immediate_operand" " I,I,B") - (match_operand:SI 2 "immediate_operand" " I,I,I") - ] UNSPEC_CORE_RELOC) - )] - "" - "@ - *return bpf_add_core_reloc (operands, \"{mov\t%0,%1|%0 = %1}\"); - *return bpf_add_core_reloc (operands, \"{st<mop>\t%0,%1|*(<smop> *) (%0) = %1}\"); - *return bpf_add_core_reloc (operands, \"{lddw\t%0,%1|%0 = %1 ll}\");" - [(set_attr "type" "alu,st,alu")]) - ;;;; Shifts (define_mode_iterator SIM [(SI "bpf_has_alu32") DI]) diff --git a/gcc/config/bpf/bpf.opt b/gcc/config/bpf/bpf.opt index 541ebe4dfc4..62156e26799 100644 --- a/gcc/config/bpf/bpf.opt +++ b/gcc/config/bpf/bpf.opt @@ -96,7 +96,7 @@ EnumValue Enum(bpf_isa) String(v4) Value(ISA_V4) masm= -Target RejectNegative Joined Var(asm_dialect) Enum(asm_dialect) Init(ASM_NORMAL) +Target RejectNegative Joined Var(asm_dialect) Enum(asm_dialect) Init(ASM_PSEUDOC) Use given assembler dialect. Enum diff --git a/gcc/config/bpf/constraints.md b/gcc/config/bpf/constraints.md index 4b8d65883ee..dd04e67fa81 100644 --- a/gcc/config/bpf/constraints.md +++ b/gcc/config/bpf/constraints.md @@ -34,6 +34,26 @@ "Register r0") ;; +;; BPF CO-RE immediate constraints. +;; This constraints are used to match with the immediate operand that is +;; represented with an UNSPEC_CORE_RELOC. This unspec is the result of using the +;; BPF CO-RE infrastructure. +;; It differentiates from a normal immediate constraints, as the instruction +;; will also emit a BTF based specific relocation, i.e. a CO-RE relocation. +;; + +(define_constraint "c" + "A 32-bit CO-RE signed immediate." + (and (match_code "unspec") + (match_test "XINT (op, 1) == UNSPEC_CORE_RELOC") + (match_test "IN_RANGE (XVECEXP (op, 0, 0), -1 - 0x7fffffff, 0x7fffffff)"))) + +(define_constraint "C" + "For 64-bit CO-RE signed immediate." + (and (match_code "unspec") + (match_test "XINT (op, 1) == UNSPEC_CORE_RELOC"))) + +;; ;; Memory constraints. ;; diff --git a/gcc/config/bpf/core-builtins.cc b/gcc/config/bpf/core-builtins.cc index 8333ad81d0e..829acea98f7 100644 --- a/gcc/config/bpf/core-builtins.cc +++ b/gcc/config/bpf/core-builtins.cc @@ -795,6 +795,23 @@ process_field_expr (struct cr_builtins *data) static GTY(()) hash_map<tree, tree> *bpf_enum_mappings; tree enum_value_type = NULL_TREE; +static int +get_index_for_enum_value (tree type, tree expr) +{ + gcc_assert (TREE_CODE (expr) == CONST_DECL + && TREE_CODE (type) == ENUMERAL_TYPE); + + unsigned int index = 0; + for (tree l = TYPE_VALUES (type); l; l = TREE_CHAIN (l)) + { + gcc_assert (index < (1 << 16)); + if (TREE_VALUE (l) == expr) + return index; + index++; + } + return -1; +} + /* Pack helper for the __builtin_preserve_enum_value. */ static struct cr_local @@ -846,6 +863,16 @@ pack_enum_value_fail: ret.reloc_data.default_value = integer_one_node; } + if (ret.fail == false ) + { + int index = get_index_for_enum_value (type, tmp); + if (index == -1 || index >= (1 << 16)) + { + bpf_error ("enum value in CO-RE builtin cannot be represented"); + ret.fail = true; + } + } + ret.reloc_data.type = type; ret.reloc_data.kind = kind; return ret; @@ -864,25 +891,17 @@ process_enum_value (struct cr_builtins *data) struct cr_final ret = { NULL, type, data->kind }; - if (TREE_CODE (expr) == CONST_DECL - && TREE_CODE (type) == ENUMERAL_TYPE) - { - unsigned int index = 0; - for (tree l = TYPE_VALUES (type); l; l = TREE_CHAIN (l)) - { - if (TREE_VALUE (l) == expr) - { - char *tmp = (char *) ggc_alloc_atomic ((index / 10) + 1); - sprintf (tmp, "%d", index); - ret.str = (const char *) tmp; - - break; - } - index++; - } - } - else - gcc_unreachable (); + gcc_assert (TREE_CODE (expr) == CONST_DECL + && TREE_CODE (type) == ENUMERAL_TYPE); + + int index = get_index_for_enum_value (type, expr); + gcc_assert (index != -1 && index < (1 << 16)); + + /* Index can only be a value up to 2^16. Should always fit + in 6 chars. */ + char tmp[6]; + sprintf (tmp, "%u", index); + ret.str = CONST_CAST (char *, ggc_strdup(tmp)); return ret; } @@ -1561,6 +1580,7 @@ bpf_expand_core_builtin (tree exp, enum bpf_builtins code) return NULL_RTX; } + /* This function is called in the final assembly output for the unspec:UNSPEC_CORE_RELOC. It recovers the vec index kept as the third operand and collects the data from the vec. With that it calls the process @@ -1568,27 +1588,63 @@ bpf_expand_core_builtin (tree exp, enum bpf_builtins code) Also it creates a label pointing to the unspec instruction and uses it in the CO-RE relocation creation. */ -const char * -bpf_add_core_reloc (rtx *operands, const char *templ) +void +bpf_output_core_reloc (rtx *operands, int nr_ops) { - struct cr_builtins *data = get_builtin_data (INTVAL (operands[2])); - builtin_helpers helper; - helper = core_builtin_helpers[data->orig_builtin_code]; - - rtx_code_label * tmp_label = gen_label_rtx (); - output_asm_label (tmp_label); - assemble_name (asm_out_file, ":\n"); + /* Search for an UNSPEC_CORE_RELOC within the operands of the emitting + intructions. */ + rtx unspec_exp = NULL_RTX; + for (int i = 0; i < nr_ops; i++) + { + rtx op = operands[i]; - gcc_assert (helper.process != NULL); - struct cr_final reloc_data = helper.process (data); - make_core_relo (&reloc_data, tmp_label); + /* An immediate CO-RE reloc. */ + if (GET_CODE (op) == UNSPEC + && XINT (op, 1) == UNSPEC_CORE_RELOC) + unspec_exp = op; - /* Replace default value for later processing builtin types. - Example if the type id builtins. */ - if (data->rtx_default_value != NULL_RTX) - operands[1] = data->rtx_default_value; + /* In case of a MEM operation with an offset resolved in CO-RE. */ + if (GET_CODE (op) == MEM + && (op = XEXP (op, 0)) != NULL_RTX + && (GET_CODE (op) == PLUS)) + { + rtx x0 = XEXP (op, 0); + rtx x1 = XEXP (op, 1); + + if (GET_CODE (x0) == UNSPEC + && XINT (x0, 1) == UNSPEC_CORE_RELOC) + unspec_exp = x0; + if (GET_CODE (x1) == UNSPEC + && XINT (x1, 1) == UNSPEC_CORE_RELOC) + unspec_exp = x1; + } + if (unspec_exp != NULL_RTX) + break; + } - return templ; + if (unspec_exp != NULL_RTX) + { + int index = INTVAL (XVECEXP (unspec_exp, 0, 1)); + struct cr_builtins *data = get_builtin_data (index); + builtin_helpers helper; + helper = core_builtin_helpers[data->orig_builtin_code]; + + rtx_code_label * tmp_label = gen_label_rtx (); + output_asm_label (tmp_label); + assemble_name (asm_out_file, ":\n"); + + rtx orig_default_value = data->rtx_default_value; + + gcc_assert (helper.process != NULL); + struct cr_final reloc_data = helper.process (data); + make_core_relo (&reloc_data, tmp_label); + + /* Replace default value for later processing builtin types. + An example are the type id builtins. */ + if (data->rtx_default_value != NULL_RTX + && orig_default_value != data->rtx_default_value) + XVECEXP (unspec_exp, 0, 0) = data->rtx_default_value; + } } static tree diff --git a/gcc/config/bpf/core-builtins.h b/gcc/config/bpf/core-builtins.h index e56b55b94e0..ebe321b16fb 100644 --- a/gcc/config/bpf/core-builtins.h +++ b/gcc/config/bpf/core-builtins.h @@ -59,5 +59,7 @@ void bpf_init_core_builtins (void); rtx bpf_expand_core_builtin (tree exp, enum bpf_builtins code); tree bpf_resolve_overloaded_core_builtin (location_t loc, tree fndecl, void *arglist); +void +bpf_output_core_reloc (rtx *operands, int nr_ops); #endif diff --git a/gcc/config/bpf/predicates.md b/gcc/config/bpf/predicates.md index fa042585379..568156f56e3 100644 --- a/gcc/config/bpf/predicates.md +++ b/gcc/config/bpf/predicates.md @@ -27,6 +27,10 @@ (match_test "IN_RANGE (INTVAL (op), 0, 0xffffffff)")) (match_code "symbol_ref,label_ref,const"))) +(define_predicate "core_imm_operand" + (and (match_code "unspec") + (match_test "XINT (op, 1) == UNSPEC_CORE_RELOC"))) + (define_predicate "lddw_operand" (match_code "symbol_ref,label_ref,const,const_double,const_int")) @@ -57,7 +61,8 @@ (define_predicate "mov_src_operand" (ior (match_operand 0 "memory_operand") (match_operand 0 "reg_or_imm_operand") - (match_operand 0 "lddw_operand"))) + (match_operand 0 "lddw_operand") + (match_operand 0 "core_imm_operand"))) (define_predicate "register_compare_operator" (match_code "eq,ne,geu,gtu,ge,gt")) diff --git a/gcc/config/bpf/t-bpf b/gcc/config/bpf/t-bpf index dc50332350c..2facccbd57a 100644 --- a/gcc/config/bpf/t-bpf +++ b/gcc/config/bpf/t-bpf @@ -1,6 +1,10 @@ TM_H += $(srcdir)/config/bpf/btfext-out.h $(srcdir)/config/bpf/core-builtins.h +bpf-c.o: $(srcdir)/config/bpf/bpf-c.cc + $(COMPILE) $< + $(POSTCOMPILE) + btfext-out.o: $(srcdir)/config/bpf/btfext-out.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/darwin.opt b/gcc/config/darwin.opt index 119faf7b385..307a760629b 100644 --- a/gcc/config/darwin.opt +++ b/gcc/config/darwin.opt @@ -211,7 +211,7 @@ Driver RejectNegative Separate init Driver RejectNegative Separate --init <symbol_name> The symbol <symbol_name> will be used as the first initialiser for a dylib. +-init <symbol_name> The symbol <symbol_name> will be used as the first initializer for a dylib. install_name Driver RejectNegative Separate diff --git a/gcc/config/epiphany/epiphany.opt b/gcc/config/epiphany/epiphany.opt index 563e7ef2233..6cffea81250 100644 --- a/gcc/config/epiphany/epiphany.opt +++ b/gcc/config/epiphany/epiphany.opt @@ -105,7 +105,7 @@ Enum(attr_fp_mode) String(int) Value(FP_MODE_INT) may-round-for-trunc Target Mask(MAY_ROUND_FOR_TRUNC) -A floatig point to integer truncation may be replaced with rounding to save mode switching. +A floating point to integer truncation may be replaced with rounding to save mode switching. mvect-double Target Mask(VECT_DOUBLE) diff --git a/gcc/config/gcn/gcn-hsa.h b/gcc/config/gcn/gcn-hsa.h index 7d6e3141cea..4611bc55392 100644 --- a/gcc/config/gcn/gcn-hsa.h +++ b/gcc/config/gcn/gcn-hsa.h @@ -93,7 +93,7 @@ extern unsigned int gcn_local_sym_hash (const char *name); #define NO_XNACK "march=fiji:;march=gfx1030:;march=gfx1036:;march=gfx1100:;march=gfx1103:;" \ /* These match the defaults set in gcn.cc. */ \ "!mxnack*|mxnack=default:%{march=gfx900|march=gfx906|march=gfx908:-mattr=-xnack};" -#define NO_SRAM_ECC "!march=*:;march=fiji:;march=gfx900:;march=gfx906:;" +#define NO_SRAM_ECC "!march=*:;march=fiji:;march=gfx900:;march=gfx906:;march=gfx90c:;" /* In HSACOv4 no attribute setting means the binary supports "any" hardware configuration. The name of the attribute also changed. */ diff --git a/gcc/config/gcn/gcn-opts.h b/gcc/config/gcn/gcn-opts.h index 49099bad7e7..1091035a69a 100644 --- a/gcc/config/gcn/gcn-opts.h +++ b/gcc/config/gcn/gcn-opts.h @@ -25,6 +25,7 @@ enum processor_type PROCESSOR_VEGA20, // gfx906 PROCESSOR_GFX908, PROCESSOR_GFX90a, + PROCESSOR_GFX90c, PROCESSOR_GFX1030, PROCESSOR_GFX1036, PROCESSOR_GFX1100, @@ -36,6 +37,7 @@ enum processor_type #define TARGET_VEGA20 (gcn_arch == PROCESSOR_VEGA20) #define TARGET_GFX908 (gcn_arch == PROCESSOR_GFX908) #define TARGET_GFX90a (gcn_arch == PROCESSOR_GFX90a) +#define TARGET_GFX90c (gcn_arch == PROCESSOR_GFX90c) #define TARGET_GFX1030 (gcn_arch == PROCESSOR_GFX1030) #define TARGET_GFX1036 (gcn_arch == PROCESSOR_GFX1036) #define TARGET_GFX1100 (gcn_arch == PROCESSOR_GFX1100) diff --git a/gcc/config/gcn/gcn.cc b/gcc/config/gcn/gcn.cc index 9f91d4f9ebd..d6531f55190 100644 --- a/gcc/config/gcn/gcn.cc +++ b/gcc/config/gcn/gcn.cc @@ -138,6 +138,7 @@ gcn_option_override (void) : gcn_arch == PROCESSOR_VEGA20 ? ISA_GCN5 : gcn_arch == PROCESSOR_GFX908 ? ISA_CDNA1 : gcn_arch == PROCESSOR_GFX90a ? ISA_CDNA2 + : gcn_arch == PROCESSOR_GFX90c ? ISA_GCN5 : gcn_arch == PROCESSOR_GFX1030 ? ISA_RDNA2 : gcn_arch == PROCESSOR_GFX1036 ? ISA_RDNA2 : gcn_arch == PROCESSOR_GFX1100 ? ISA_RDNA3 @@ -196,6 +197,7 @@ gcn_option_override (void) flag_xnack = HSACO_ATTR_OFF; break; case PROCESSOR_GFX90a: + case PROCESSOR_GFX90c: flag_xnack = HSACO_ATTR_ANY; break; default: @@ -3050,6 +3052,8 @@ gcn_omp_device_kind_arch_isa (enum omp_device_kind_arch_isa trait, return gcn_arch == PROCESSOR_GFX908; if (strcmp (name, "gfx90a") == 0) return gcn_arch == PROCESSOR_GFX90a; + if (strcmp (name, "gfx90c") == 0) + return gcn_arch == PROCESSOR_GFX90c; if (strcmp (name, "gfx1030") == 0) return gcn_arch == PROCESSOR_GFX1030; if (strcmp (name, "gfx1036") == 0) @@ -6596,6 +6600,10 @@ output_file_start (void) case PROCESSOR_GFX90a: cpu = "gfx90a"; break; + case PROCESSOR_GFX90c: + cpu = "gfx90c"; + sram_ecc = ""; + break; case PROCESSOR_GFX1030: cpu = "gfx1030"; xnack = ""; diff --git a/gcc/config/gcn/gcn.h b/gcc/config/gcn/gcn.h index 4148ceaf582..afa615320ca 100644 --- a/gcc/config/gcn/gcn.h +++ b/gcc/config/gcn/gcn.h @@ -47,6 +47,8 @@ builtin_define ("__gfx908__"); \ else if (TARGET_GFX90a) \ builtin_define ("__gfx90a__"); \ + else if (TARGET_GFX90c) \ + builtin_define ("__gfx90c__"); \ else if (TARGET_GFX1030) \ builtin_define ("__gfx1030__"); \ else if (TARGET_GFX1036) \ diff --git a/gcc/config/gcn/gcn.opt b/gcc/config/gcn/gcn.opt index 42bb5f75a42..3317c492507 100644 --- a/gcc/config/gcn/gcn.opt +++ b/gcc/config/gcn/gcn.opt @@ -41,6 +41,9 @@ EnumValue Enum(gpu_type) String(gfx90a) Value(PROCESSOR_GFX90a) EnumValue +Enum(gpu_type) String(gfx90c) Value(PROCESSOR_GFX90c) + +EnumValue Enum(gpu_type) String(gfx1030) Value(PROCESSOR_GFX1030) EnumValue diff --git a/gcc/config/gcn/mkoffload.cc b/gcc/config/gcn/mkoffload.cc index 9a438de331a..810298a799b 100644 --- a/gcc/config/gcn/mkoffload.cc +++ b/gcc/config/gcn/mkoffload.cc @@ -59,6 +59,8 @@ #define EF_AMDGPU_MACH_AMDGCN_GFX908 0x30 #undef EF_AMDGPU_MACH_AMDGCN_GFX90a #define EF_AMDGPU_MACH_AMDGCN_GFX90a 0x3f +#undef EF_AMDGPU_MACH_AMDGCN_GFX90c +#define EF_AMDGPU_MACH_AMDGCN_GFX90c 0x32 #undef EF_AMDGPU_MACH_AMDGCN_GFX1030 #define EF_AMDGPU_MACH_AMDGCN_GFX1030 0x36 #undef EF_AMDGPU_MACH_AMDGCN_GFX1036 @@ -861,6 +863,8 @@ get_arch (const char *str, const char *with_arch_str) return EF_AMDGPU_MACH_AMDGCN_GFX908; else if (strcmp (str, "gfx90a") == 0) return EF_AMDGPU_MACH_AMDGCN_GFX90a; + else if (strcmp (str, "gfx90c") == 0) + return EF_AMDGPU_MACH_AMDGCN_GFX90c; else if (strcmp (str, "gfx1030") == 0) return EF_AMDGPU_MACH_AMDGCN_GFX1030; else if (strcmp (str, "gfx1036") == 0) @@ -1099,6 +1103,11 @@ main (int argc, char **argv) if (TEST_SRAM_ECC_UNSET (elf_flags)) SET_SRAM_ECC_ANY (elf_flags); break; + case EF_AMDGPU_MACH_AMDGCN_GFX90c: + if (TEST_XNACK_UNSET (elf_flags)) + SET_XNACK_ANY (elf_flags); + SET_SRAM_ECC_UNSET (elf_flags); + break; default: fatal_error (input_location, "unhandled architecture"); } diff --git a/gcc/config/gcn/t-omp-device b/gcc/config/gcn/t-omp-device index 7bcf910cbd0..b92e19bb6d6 100644 --- a/gcc/config/gcn/t-omp-device +++ b/gcc/config/gcn/t-omp-device @@ -1,4 +1,4 @@ omp-device-properties-gcn: $(srcdir)/config/gcn/gcn.cc echo kind: gpu > $@ echo arch: amdgcn gcn >> $@ - echo isa: fiji gfx803 gfx900 gfx906 gfx908 gfx90a gfx1030 gfx1036 gfx1100 gfx1103 >> $@ + echo isa: fiji gfx803 gfx900 gfx906 gfx908 gfx90a gfx90c gfx1030 gfx1036 gfx1100 gfx1103 >> $@ diff --git a/gcc/config/i386/i386-options.cc b/gcc/config/i386/i386-options.cc index 68a2e1c6910..ac48b5c61c4 100644 --- a/gcc/config/i386/i386-options.cc +++ b/gcc/config/i386/i386-options.cc @@ -1431,6 +1431,7 @@ ix86_valid_target_attribute_tree (tree fndecl, tree args, scenario. */ if ((def->x_ix86_isa_flags2 & OPTION_MASK_ISA2_AVX10_1_256) && (opts->x_ix86_isa_flags & OPTION_MASK_ISA_AVX512F) + && (opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_AVX512F) && !(def->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA2_EVEX512) && !(opts->x_ix86_isa_flags2_explicit & OPTION_MASK_ISA2_EVEX512)) opts->x_ix86_isa_flags2 |= OPTION_MASK_ISA2_EVEX512; diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index adab1ef9e04..764bfe20ff2 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -4569,10 +4569,10 @@ (define_insn "*zero_extendsidi2" [(set (match_operand:DI 0 "nonimmediate_operand" - "=r,?r,?o,r ,o,?*y,?!*y,$r,$v,$x,*x,*v,*r,*k") + "=r,?r,?o,r ,o,?*y,?!*y,$r,$v,$x,*x,*v,?r,?k") (zero_extend:DI (match_operand:SI 1 "x86_64_zext_operand" - "0 ,rm,r ,rmWz,0,r ,m ,v ,r ,m ,*x,*v,*k,*km")))] + "0 ,rm,r ,rmWz,0,r ,m ,v ,r ,m ,*x,*v,?k,?km")))] "" { switch (get_attr_type (insn)) @@ -4705,9 +4705,9 @@ [(QI "avx512dq") (HI "avx512f") (SI "avx512bw") (DI "avx512bw")]) (define_insn "zero_extend<mode>di2" - [(set (match_operand:DI 0 "register_operand" "=r,*r,*k") + [(set (match_operand:DI 0 "register_operand" "=r,?r,?k") (zero_extend:DI - (match_operand:SWI12 1 "nonimmediate_operand" "<r>m,*k,*km")))] + (match_operand:SWI12 1 "nonimmediate_operand" "<r>m,?k,?km")))] "TARGET_64BIT" "@ movz{<imodesuffix>l|x}\t{%1, %k0|%k0, %1} @@ -4760,9 +4760,9 @@ (set_attr "mode" "SI")]) (define_insn "*zero_extend<mode>si2" - [(set (match_operand:SI 0 "register_operand" "=r,*r,*k") + [(set (match_operand:SI 0 "register_operand" "=r,?r,?k") (zero_extend:SI - (match_operand:SWI12 1 "nonimmediate_operand" "<r>m,*k,*km")))] + (match_operand:SWI12 1 "nonimmediate_operand" "<r>m,?k,?km")))] "!(TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))" "@ movz{<imodesuffix>l|x}\t{%1, %0|%0, %1} @@ -4815,8 +4815,8 @@ ; zero extend to SImode to avoid partial register stalls (define_insn "*zero_extendqihi2" - [(set (match_operand:HI 0 "register_operand" "=r,*r,*k") - (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "qm,*k,*km")))] + [(set (match_operand:HI 0 "register_operand" "=r,?r,?k") + (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "qm,?k,?km")))] "!(TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun))" "@ movz{bl|x}\t{%1, %k0|%k0, %1} @@ -12482,10 +12482,10 @@ }) (define_insn_and_split "*andn<dwi>3_doubleword_bmi" - [(set (match_operand:<DWI> 0 "register_operand" "=&r,r,r") + [(set (match_operand:<DWI> 0 "register_operand" "=&r,&r,r,r") (and:<DWI> - (not:<DWI> (match_operand:<DWI> 1 "register_operand" "r,0,r")) - (match_operand:<DWI> 2 "nonimmediate_operand" "ro,ro,0"))) + (not:<DWI> (match_operand:<DWI> 1 "register_operand" "r,r,0,r")) + (match_operand:<DWI> 2 "nonimmediate_operand" "r,o,ro,0"))) (clobber (reg:CC FLAGS_REG))] "TARGET_BMI" "#" @@ -12496,7 +12496,8 @@ (parallel [(set (match_dup 3) (and:DWIH (not:DWIH (match_dup 4)) (match_dup 5))) (clobber (reg:CC FLAGS_REG))])] - "split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);") + "split_double_mode (<DWI>mode, &operands[0], 3, &operands[0], &operands[3]);" + [(set_attr "isa" "x64,*,*,*")]) (define_insn_and_split "*andn<mode>3_doubleword" [(set (match_operand:DWI 0 "register_operand") diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index 5bb49823f9a..1bf50726e83 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -17029,7 +17029,7 @@ [(set (match_operand:VI_256 0 "register_operand" "=x") (eq:VI_256 (match_operand:VI_256 1 "nonimmediate_operand" "%x") - (match_operand:VI_256 2 "nonimmediate_operand" "jm")))] + (match_operand:VI_256 2 "nonimmediate_operand" "xjm")))] "TARGET_AVX2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))" "vpcmpeq<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}" [(set_attr "type" "ssecmp") diff --git a/gcc/config/loongarch/genopts/gen-evolution.awk b/gcc/config/loongarch/genopts/gen-evolution.awk new file mode 100644 index 00000000000..4d105afa906 --- /dev/null +++ b/gcc/config/loongarch/genopts/gen-evolution.awk @@ -0,0 +1,230 @@ +#!/usr/bin/gawk +# +# A simple script that generates loongarch-evolution.h +# from genopts/isa-evolution.in +# +# Copyright (C) 2021-2024 Free Software Foundation, Inc. +# +# This file is part of GCC. +# +# GCC is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License as published by the Free +# Software Foundation; either version 3, or (at your option) any later +# version. +# +# GCC is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public +# License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + +BEGIN { + # isa_version_major[] + # isa_version_minor[] + # cpucfg_word[] + # cpucfg_bit_in_word[] + # name_capitalized[] + # comment[] +} + +{ + cpucfg_word[NR] = $1 + cpucfg_bit_in_word[NR] = $2 + name[NR] = gensub(/-/, "_", "g", $3) + name_capitalized[NR] = toupper(name[NR]) + isa_version_major[NR] = gensub(/^([1-9][0-9]*)\.([0-9]+)$/, "\\1", 1, $4) + isa_version_minor[NR] = gensub(/^([1-9][0-9]*)\.([0-9]+)$/, "\\2", 1, $4) + + $1 = $2 = $3 = $4 = "" + sub (/^\s*/, "") + comment[NR] = $0 +} + +function copyright_header(from_year,to_year) +{ + print " Copyright (C) " from_year "-" to_year \ + " Free Software Foundation, Inc." + print "" + print "This file is part of GCC." + print "" + print "GCC is free software; you can redistribute it and/or modify" + print "it under the terms of the GNU General Public License as published by" + print "the Free Software Foundation; either version 3, or (at your option)" + print "any later version." + print "" + print "GCC is distributed in the hope that it will be useful," + print "but WITHOUT ANY WARRANTY; without even the implied warranty of" + print "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the" + print "GNU General Public License for more details." + print "" + print "You should have received a copy of the GNU General Public License" + print "along with GCC; see the file COPYING3. If not see" + print "<http://www.gnu.org/licenses/>." +} + +function gen_cpucfg_map() +{ + print "static constexpr struct {" + print " int cpucfg_word;" + print " unsigned int cpucfg_bit;" + print " HOST_WIDE_INT isa_evolution_bit;" + print "} cpucfg_map[] = {" + + for (i = 1; i <= NR; i++) + printf (" { %d, 1u << %d, OPTION_MASK_ISA_%s },\n", + cpucfg_word[i], cpucfg_bit_in_word[i], name_capitalized[i]) + + print "};" +} + +function gen_cpucfg_useful_idx() +{ + split("0 1 2 16 17 18 19", init_useful_idx) + + delete idx_bucket + + for (i in init_useful_idx) + idx_bucket[init_useful_idx[i]] = 1 + delete init_useful_idx + + for (i in cpucfg_word) + idx_bucket[cpucfg_word[i]] = 1 + + delete idx_list + for (i in idx_bucket) + idx_list[length(idx_list)-1] = i+0 + delete idx_bucket + + asort (idx_list) + + print "static constexpr int cpucfg_useful_idx[] = {" + for (i in idx_list) + printf(" %d,\n", idx_list[i]) + print "};" + + print "" + + printf ("static constexpr int N_CPUCFG_WORDS = %d;\n", + idx_list[length(idx_list)] + 1) + + delete idx_list +} + +function gen_evolution_decl() +{ + print "/* ISA evolution features */" + print "enum {" + + for (i = 1; i <= NR; i++) + print " EVO_" name_capitalized[i] " = " i - 1 "," + + print " N_EVO_FEATURES = " NR + print "};" + print "" + + print "/* Condition macros */" + for (i = 1; i <= NR; i++) + printf ("#define ISA_HAS_%s \\\n" \ + " (la_target.isa.evolution & OPTION_MASK_ISA_%s)\n", + name_capitalized[i], name_capitalized[i]) + print "" + + print "/* Bitmasks on la_target.isa.evolution. */" + print "extern int la_evo_feature_masks[N_EVO_FEATURES];" + print "" + print "/* Builtin macro names for the evolution features. */" + print "extern const char* la_evo_macro_name[N_EVO_FEATURES];" + print "" + print "/* The ISA version where a specific feature is introduced. */" + print "extern int la_evo_version_major[N_EVO_FEATURES];" + print "extern int la_evo_version_minor[N_EVO_FEATURES];" +} + +function gen_full_header() +{ + print "/* Generated automatically by \"genstr\" from \"isa-evolution.in\"." + print " Please do not edit this file directly." + print "" + + copyright_header(2023, 2024) + + print "*/" + print "" + + print "#ifndef LOONGARCH_EVOLUTION_H" + print "#define LOONGARCH_EVOLUTION_H" + print "" + print "#if !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) && !defined(IN_RTS)" + print "" + print "#include \"options.h\"" + print "" + + gen_cpucfg_map() + + print "" + + gen_cpucfg_useful_idx() + + print "" + + gen_evolution_decl() + + print "" + print "#endif" + print "" + print "#endif /* LOONGARCH_EVOLUTION_H */" +} + + +function gen_full_source() +{ + print "/* Generated automatically by \"genstr\" from \"isa-evolution.in\"." + print " Please do not edit this file directly." + print "" + + copyright_header(2023, 2024) + + print "*/" + print "" + print "#include \"config.h\"" + print "#include \"system.h\"" + print "#include \"coretypes.h\"" + print "#include \"options.h\"" + print "" + print "#include \"loongarch-evolution.h\"" + print "" + + print "int la_evo_feature_masks[] = {"; + for (i = 1; i <= NR; i++) + print " OPTION_MASK_ISA_" name_capitalized[i] "," + print "};" + print "" + + print "const char* la_evo_macro_name[] = {"; + for (i = 1; i <= NR; i++) + print " \"__loongarch_" name[i] "\"," + print "};" + print "" + + + print "int la_evo_version_major[] = {" + for (i = 1; i <= NR; i++) + print " " isa_version_major[i] ", /* " name_capitalized[i] " */" + print "};" + print "" + + print "int la_evo_version_minor[] = {" + for (i = 1; i <= NR; i++) + print " " isa_version_minor[i] ", /* " name_capitalized[i] " */" + print "};" +} + +END { + if (header_p) + gen_full_header() + else + gen_full_source() +} diff --git a/gcc/config/loongarch/genopts/genstr.sh b/gcc/config/loongarch/genopts/genstr.sh index 724c9aaedac..5b3bf7fdf0c 100755 --- a/gcc/config/loongarch/genopts/genstr.sh +++ b/gcc/config/loongarch/genopts/genstr.sh @@ -108,78 +108,30 @@ EOF print("m"$3) gsub(/-/, "_", $3) print("Target Mask(ISA_"toupper($3)") Var(la_isa_evolution)") - $1=""; $2=""; $3="" + $1=""; $2=""; $3=""; $4="" sub(/^ */, "", $0) print($0) }' isa-evolution.in } -gen_cpucfg_map() { - cat <<EOF -/* Generated automatically by "genstr" from "isa-evolution.in". - Please do not edit this file directly. - - Copyright (C) 2023-2024 Free Software Foundation, Inc. - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - -#ifndef LOONGARCH_CPUCFG_MAP_H -#define LOONGARCH_CPUCFG_MAP_H - -#include "options.h" - -static constexpr struct { - int cpucfg_word; - unsigned int cpucfg_bit; - HOST_WIDE_INT isa_evolution_bit; -} cpucfg_map[] = { -EOF - - # Generate the strings from isa-evolution.in. - awk '{ - gsub(/-/, "_", $3) - print(" { "$1", 1u << "$2", OPTION_MASK_ISA_"toupper($3)" },") - }' isa-evolution.in - - echo "};" - echo - echo "static constexpr int cpucfg_useful_idx[] = {" - - awk 'BEGIN { print(" 0,\n 1,\n 2,\n 16,\n 17,\n 18,\n 19,") } - {if ($1+0 > max+0) max=$1; print(" "$1",")}' \ - isa-evolution.in | sort -n | uniq - - echo "};" - echo "" - - awk 'BEGIN { max=19 } - { if ($1+0 > max+0) max=$1 } - END { print "static constexpr int N_CPUCFG_WORDS = "1+max";" }' \ - isa-evolution.in - - echo "#endif /* LOONGARCH_CPUCFG_MAP_H */" -} - main() { case "$1" in - cpucfg-map) gen_cpucfg_map;; - header) gen_defines;; - opt) gen_options;; - *) echo "Unknown Command: \"$1\". Available: cpucfg-map, header, opt"; exit 1;; + evolution_h) + awk -v header_p=1 -f gen-evolution.awk isa-evolution.in + ;; + evolution_c) + awk -v header_p=0 -f gen-evolution.awk isa-evolution.in + ;; + header) + gen_defines + ;; + opt) + gen_options + ;; + *) + echo "Unknown Command: \"$1\". Available: header, opt, evolution_h, evolution_c" + exit 1 + ;; esac } diff --git a/gcc/config/loongarch/genopts/isa-evolution.in b/gcc/config/loongarch/genopts/isa-evolution.in index 11a198b649f..50f72d5a0bc 100644 --- a/gcc/config/loongarch/genopts/isa-evolution.in +++ b/gcc/config/loongarch/genopts/isa-evolution.in @@ -1,5 +1,5 @@ -2 25 frecipe Support frecipe.{s/d} and frsqrte.{s/d} instructions. -2 26 div32 Support div.w[u] and mod.w[u] instructions with inputs not sign-extended. -2 27 lam-bh Support am{swap/add}[_db].{b/h} instructions. -2 28 lamcas Support amcas[_db].{b/h/w/d} instructions. -3 23 ld-seq-sa Do not need load-load barriers (dbar 0x700). +2 25 frecipe 1.1 Support frecipe.{s/d} and frsqrte.{s/d} instructions. +2 26 div32 1.1 Support div.w[u] and mod.w[u] instructions with inputs not sign-extended. +2 27 lam-bh 1.1 Support am{swap/add}[_db].{b/h} instructions. +2 28 lamcas 1.1 Support amcas[_db].{b/h/w/d} instructions. +3 23 ld-seq-sa 1.1 Do not need load-load barriers (dbar 0x700). diff --git a/gcc/config/loongarch/genopts/loongarch-strings b/gcc/config/loongarch/genopts/loongarch-strings index e434a89c9ee..e9ebd254bfa 100644 --- a/gcc/config/loongarch/genopts/loongarch-strings +++ b/gcc/config/loongarch/genopts/loongarch-strings @@ -23,10 +23,13 @@ OPTSTR_ARCH arch OPTSTR_TUNE tune STR_CPU_NATIVE native -STR_CPU_ABI_DEFAULT abi-default +STR_ARCH_ABI_DEFAULT abi-default +STR_TUNE_GENERIC generic STR_CPU_LOONGARCH64 loongarch64 STR_CPU_LA464 la464 STR_CPU_LA664 la664 +STR_ARCH_LA64V1_0 la64v1.0 +STR_ARCH_LA64V1_1 la64v1.1 # Base architecture STR_ISA_BASE_LA64 la64 diff --git a/gcc/config/loongarch/genopts/loongarch.opt.in b/gcc/config/loongarch/genopts/loongarch.opt.in index 50ea47a161f..d00950cb4f4 100644 --- a/gcc/config/loongarch/genopts/loongarch.opt.in +++ b/gcc/config/loongarch/genopts/loongarch.opt.in @@ -95,30 +95,55 @@ Enable LoongArch Advanced SIMD Extension (LASX, 256-bit). ;; Base target models (implies ISA & tune parameters) Enum -Name(cpu_type) Type(int) -LoongArch CPU types: +Name(arch_type) Type(int) +LoongArch ARCH presets: EnumValue -Enum(cpu_type) String(@@STR_CPU_NATIVE@@) Value(CPU_NATIVE) +Enum(arch_type) String(@@STR_CPU_NATIVE@@) Value(ARCH_NATIVE) EnumValue -Enum(cpu_type) String(@@STR_CPU_ABI_DEFAULT@@) Value(CPU_ABI_DEFAULT) +Enum(arch_type) String(@@STR_ARCH_ABI_DEFAULT@@) Value(ARCH_ABI_DEFAULT) EnumValue -Enum(cpu_type) String(@@STR_CPU_LOONGARCH64@@) Value(CPU_LOONGARCH64) +Enum(arch_type) String(@@STR_CPU_LOONGARCH64@@) Value(ARCH_LOONGARCH64) EnumValue -Enum(cpu_type) String(@@STR_CPU_LA464@@) Value(CPU_LA464) +Enum(arch_type) String(@@STR_CPU_LA464@@) Value(ARCH_LA464) EnumValue -Enum(cpu_type) String(@@STR_CPU_LA664@@) Value(CPU_LA664) +Enum(arch_type) String(@@STR_CPU_LA664@@) Value(ARCH_LA664) + +EnumValue +Enum(arch_type) String(@@STR_ARCH_LA64V1_0@@) Value(ARCH_LA64V1_0) + +EnumValue +Enum(arch_type) String(@@STR_ARCH_LA64V1_1@@) Value(ARCH_LA64V1_1) m@@OPTSTR_ARCH@@= -Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET) Save +Target RejectNegative Joined Enum(arch_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET) Save -m@@OPTSTR_ARCH@@=PROCESSOR Generate code for the given PROCESSOR ISA. +Enum +Name(tune_type) Type(int) +LoongArch TUNE presets: + +EnumValue +Enum(tune_type) String(@@STR_CPU_NATIVE@@) Value(TUNE_NATIVE) + +EnumValue +Enum(tune_type) String(@@STR_TUNE_GENERIC@@) Value(TUNE_GENERIC) + +EnumValue +Enum(tune_type) String(@@STR_CPU_LOONGARCH64@@) Value(TUNE_LOONGARCH64) + +EnumValue +Enum(tune_type) String(@@STR_CPU_LA464@@) Value(TUNE_LA464) + +EnumValue +Enum(tune_type) String(@@STR_CPU_LA664@@) Value(TUNE_LA664) + m@@OPTSTR_TUNE@@= -Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_tune) Init(M_OPT_UNSET) Save +Target RejectNegative Joined Enum(tune_type) Var(la_opt_cpu_tune) Init(M_OPT_UNSET) Save -m@@OPTSTR_TUNE@@=PROCESSOR Generate optimized code for PROCESSOR. diff --git a/gcc/config/loongarch/loongarch-c.cc b/gcc/config/loongarch/loongarch-c.cc index 4d88c1729ff..c6763647cd1 100644 --- a/gcc/config/loongarch/loongarch-c.cc +++ b/gcc/config/loongarch/loongarch-c.cc @@ -31,29 +31,6 @@ along with GCC; see the file COPYING3. If not see #define builtin_define(TXT) cpp_define (pfile, TXT) #define builtin_assert(TXT) cpp_assert (pfile, TXT) -/* Define preprocessor macros for the -march and -mtune options. - PREFIX is either _LOONGARCH_ARCH or _LOONGARCH_TUNE, INFO is - the selected processor. If INFO's canonical name is "foo", - define PREFIX to be "foo", and define an additional macro - PREFIX_FOO. */ -#define LARCH_CPP_SET_PROCESSOR(PREFIX, CPU_TYPE) \ - do \ - { \ - char *macro, *p; \ - int cpu_type = (CPU_TYPE); \ - \ - macro = concat ((PREFIX), "_", \ - loongarch_cpu_strings[cpu_type], NULL); \ - for (p = macro; *p != 0; p++) \ - *p = TOUPPER (*p); \ - \ - builtin_define (macro); \ - builtin_define_with_value ((PREFIX), \ - loongarch_cpu_strings[cpu_type], 1); \ - free (macro); \ - } \ - while (0) - void loongarch_cpu_cpp_builtins (cpp_reader *pfile) { @@ -61,11 +38,17 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) builtin_assert ("cpu=loongarch"); builtin_define ("__loongarch__"); - LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_ARCH", la_target.cpu_arch); - LARCH_CPP_SET_PROCESSOR ("_LOONGARCH_TUNE", la_target.cpu_tune); + builtin_define_with_value ("__loongarch_arch", + loongarch_arch_strings[la_target.cpu_arch], 1); + + builtin_define_with_value ("__loongarch_tune", + loongarch_tune_strings[la_target.cpu_tune], 1); + + builtin_define_with_value ("_LOONGARCH_ARCH", + loongarch_arch_strings[la_target.cpu_arch], 1); - LARCH_CPP_SET_PROCESSOR ("__loongarch_arch", la_target.cpu_arch); - LARCH_CPP_SET_PROCESSOR ("__loongarch_tune", la_target.cpu_tune); + builtin_define_with_value ("_LOONGARCH_TUNE", + loongarch_tune_strings[la_target.cpu_tune], 1); /* Base architecture / ABI. */ if (TARGET_64BIT) @@ -120,6 +103,29 @@ loongarch_cpu_cpp_builtins (cpp_reader *pfile) builtin_define ("__loongarch_simd_width=256"); } + /* ISA evolution features */ + int max_v_major = 1, max_v_minor = 0; + + for (int i = 0; i < N_EVO_FEATURES; i++) + if (la_target.isa.evolution & la_evo_feature_masks[i]) + { + builtin_define (la_evo_macro_name[i]); + + int major = la_evo_version_major[i], + minor = la_evo_version_minor[i]; + + max_v_major = major > max_v_major ? major : max_v_major; + max_v_minor = major == max_v_major + ? (minor > max_v_minor ? minor : max_v_minor): max_v_minor; + } + + /* Find the minimum ISA version required to run the target program. */ + if (!(max_v_major == 1 && max_v_minor <= 1 && ISA_HAS_LASX)) + { + builtin_define_with_int_value ("__loongarch_version_major", max_v_major); + builtin_define_with_int_value ("__loongarch_version_minor", max_v_minor); + } + /* Add support for FLOAT128_TYPE on the LoongArch architecture. */ builtin_define ("__FLOAT128_TYPE__"); diff --git a/gcc/config/loongarch/loongarch-cpu.cc b/gcc/config/loongarch/loongarch-cpu.cc index 97ac5fed9d8..8564ebb24ee 100644 --- a/gcc/config/loongarch/loongarch-cpu.cc +++ b/gcc/config/loongarch/loongarch-cpu.cc @@ -28,8 +28,8 @@ along with GCC; see the file COPYING3. If not see #include "loongarch-def.h" #include "loongarch-opts.h" #include "loongarch-cpu.h" -#include "loongarch-cpucfg-map.h" #include "loongarch-str.h" +#include "loongarch-evolution.h" /* Native CPU detection with "cpucfg" */ @@ -62,7 +62,7 @@ cache_cpucfg (void) uint32_t get_native_prid (void) { - /* Fill loongarch_cpu_default_config[CPU_NATIVE] with cpucfg data, + /* Fill loongarch_cpu_default_config[ARCH_NATIVE] with cpucfg data, see "Loongson Architecture Reference Manual" (Volume 1, Section 2.2.10.5) */ return cpucfg_cache[0]; @@ -76,13 +76,14 @@ get_native_prid_str (void) return (const char*) prid_str; } -/* Fill property tables for CPU_NATIVE. */ +/* Fill property tables for ARCH_NATIVE / TUNE_NATIVE. */ void fill_native_cpu_config (struct loongarch_target *tgt) { - int arch_native_p = tgt->cpu_arch == CPU_NATIVE; - int tune_native_p = tgt->cpu_tune == CPU_NATIVE; - int native_cpu_type = CPU_NATIVE; + int arch_native_p = tgt->cpu_arch == ARCH_NATIVE; + int tune_native_p = tgt->cpu_tune == TUNE_NATIVE; + int native_cpu_arch = ARCH_NATIVE; + int native_cpu_tune = TUNE_NATIVE; /* Nothing needs to be done unless "-march/tune=native" is given or implied. */ @@ -99,11 +100,13 @@ fill_native_cpu_config (struct loongarch_target *tgt) switch (cpucfg_cache[0] & 0x00ffff00) { case 0x0014c000: /* LA464 */ - native_cpu_type = CPU_LA464; + native_cpu_arch = ARCH_LA464; + native_cpu_tune = TUNE_LA464; break; case 0x0014d000: /* LA664 */ - native_cpu_type = CPU_LA664; + native_cpu_arch = ARCH_LA664; + native_cpu_tune = TUNE_LA664; break; default: @@ -119,7 +122,7 @@ fill_native_cpu_config (struct loongarch_target *tgt) if (arch_native_p) { int tmp; - tgt->cpu_arch = native_cpu_type; + tgt->cpu_arch = native_cpu_arch; auto &preset = loongarch_cpu_default_isa[tgt->cpu_arch]; @@ -127,8 +130,8 @@ fill_native_cpu_config (struct loongarch_target *tgt) With: base architecture (ARCH) At: cpucfg_words[1][1:0] */ - if (native_cpu_type != CPU_NATIVE) - tmp = loongarch_cpu_default_isa[native_cpu_type].base; + if (native_cpu_arch != ARCH_NATIVE) + tmp = loongarch_cpu_default_isa[native_cpu_arch].base; else switch (cpucfg_cache[1] & 0x3) { @@ -173,7 +176,7 @@ fill_native_cpu_config (struct loongarch_target *tgt) } /* Check consistency with PRID presets. */ - if (native_cpu_type != CPU_NATIVE && tmp != preset.fpu) + if (native_cpu_arch != ARCH_NATIVE && tmp != preset.fpu) warning (0, "floating-point unit %qs differs from PRID preset %qs", loongarch_isa_ext_strings[tmp], loongarch_isa_ext_strings[preset.fpu]); @@ -182,7 +185,7 @@ fill_native_cpu_config (struct loongarch_target *tgt) preset.fpu = tmp; - /* Fill: loongarch_cpu_default_isa[CPU_NATIVE].simd + /* Fill: loongarch_cpu_default_isa[ARCH_NATIVE].simd With: SIMD extension type (LSX, LASX) At: cpucfg_words[2][7:6] */ @@ -212,7 +215,7 @@ fill_native_cpu_config (struct loongarch_target *tgt) /* Check consistency with PRID presets. */ /* - if (native_cpu_type != CPU_NATIVE && tmp != preset.simd) + if (native_cpu_arch != ARCH_NATIVE && tmp != preset.simd) warning (0, "SIMD extension %qs differs from PRID preset %qs", loongarch_isa_ext_strings[tmp], loongarch_isa_ext_strings[preset.simd]); @@ -229,10 +232,10 @@ fill_native_cpu_config (struct loongarch_target *tgt) if (cpucfg_cache[entry.cpucfg_word] & entry.cpucfg_bit) hw_isa_evolution |= entry.isa_evolution_bit; - if (native_cpu_type != CPU_NATIVE) + if (native_cpu_arch != ARCH_NATIVE) { /* Check if the local CPU really supports the features of the base - ISA of probed native_cpu_type. If any feature is not detected, + ISA of probed native_cpu_arch. If any feature is not detected, either GCC or the hardware is buggy. */ if ((preset.evolution & hw_isa_evolution) != hw_isa_evolution) warning (0, @@ -247,7 +250,7 @@ fill_native_cpu_config (struct loongarch_target *tgt) if (tune_native_p) { - tgt->cpu_tune = native_cpu_type; + tgt->cpu_tune = native_cpu_tune; /* Fill: loongarch_cpu_cache[tgt->cpu_tune] With: cache size info diff --git a/gcc/config/loongarch/loongarch-def.cc b/gcc/config/loongarch/loongarch-def.cc index 63a8f108f4e..d19628f3454 100644 --- a/gcc/config/loongarch/loongarch-def.cc +++ b/gcc/config/loongarch/loongarch-def.cc @@ -31,39 +31,64 @@ template <class T, int N> using array = loongarch_def_array<T, N>; template <class T> -using array_tune = array<T, N_TUNE_TYPES>; +using array_arch = array<T, N_ARCH_TYPES>; template <class T> -using array_arch = array<T, N_ARCH_TYPES>; +using array_tune = array<T, N_TUNE_TYPES>; -/* CPU property tables. */ -array_tune<const char *> loongarch_cpu_strings = array_tune<const char *> () - .set (CPU_NATIVE, STR_CPU_NATIVE) - .set (CPU_ABI_DEFAULT, STR_CPU_ABI_DEFAULT) - .set (CPU_LOONGARCH64, STR_CPU_LOONGARCH64) - .set (CPU_LA464, STR_CPU_LA464) - .set (CPU_LA664, STR_CPU_LA664); +array_arch<const char *> loongarch_arch_strings = array_arch<const char *> () + .set (ARCH_NATIVE, STR_CPU_NATIVE) + .set (ARCH_ABI_DEFAULT, STR_ARCH_ABI_DEFAULT) + .set (ARCH_LOONGARCH64, STR_CPU_LOONGARCH64) + .set (ARCH_LA464, STR_CPU_LA464) + .set (ARCH_LA664, STR_CPU_LA664) + .set (ARCH_LA64V1_0, STR_ARCH_LA64V1_0) + .set (ARCH_LA64V1_1, STR_ARCH_LA64V1_1); + +array_tune<const char *> loongarch_tune_strings = array_tune<const char *> () + .set (TUNE_NATIVE, STR_CPU_NATIVE) + .set (TUNE_GENERIC, STR_TUNE_GENERIC) + .set (TUNE_LOONGARCH64, STR_CPU_LOONGARCH64) + .set (TUNE_LA464, STR_CPU_LA464) + .set (TUNE_LA664, STR_CPU_LA664); array_arch<loongarch_isa> loongarch_cpu_default_isa = array_arch<loongarch_isa> () - .set (CPU_LOONGARCH64, + .set (ARCH_LOONGARCH64, loongarch_isa () .base_ (ISA_BASE_LA64) .fpu_ (ISA_EXT_FPU64)) - .set (CPU_LA464, + + .set (ARCH_LA464, loongarch_isa () .base_ (ISA_BASE_LA64) .fpu_ (ISA_EXT_FPU64) .simd_ (ISA_EXT_SIMD_LASX)) - .set (CPU_LA664, + + .set (ARCH_LA664, loongarch_isa () .base_ (ISA_BASE_LA64) .fpu_ (ISA_EXT_FPU64) .simd_ (ISA_EXT_SIMD_LASX) .evolution_ (OPTION_MASK_ISA_DIV32 | OPTION_MASK_ISA_LD_SEQ_SA | OPTION_MASK_ISA_LAM_BH | OPTION_MASK_ISA_LAMCAS + | OPTION_MASK_ISA_FRECIPE)) + .set (ARCH_LA64V1_0, + loongarch_isa () + .base_ (ISA_BASE_LA64) + .fpu_ (ISA_EXT_FPU64) + .simd_ (ISA_EXT_SIMD_LSX)) + + .set (ARCH_LA64V1_1, + loongarch_isa () + .base_ (ISA_BASE_LA64) + .fpu_ (ISA_EXT_FPU64) + .simd_ (ISA_EXT_SIMD_LSX) + .evolution_ (OPTION_MASK_ISA_DIV32 | OPTION_MASK_ISA_LD_SEQ_SA + | OPTION_MASK_ISA_LAM_BH | OPTION_MASK_ISA_LAMCAS | OPTION_MASK_ISA_FRECIPE)); + static inline loongarch_cache la464_cache () { return loongarch_cache () @@ -75,9 +100,10 @@ static inline loongarch_cache la464_cache () array_tune<loongarch_cache> loongarch_cpu_cache = array_tune<loongarch_cache> () - .set (CPU_LOONGARCH64, la464_cache ()) - .set (CPU_LA464, la464_cache ()) - .set (CPU_LA664, la464_cache ()); + .set (TUNE_GENERIC, la464_cache ()) + .set (TUNE_LOONGARCH64, la464_cache ()) + .set (TUNE_LA464, la464_cache ()) + .set (TUNE_LA664, la464_cache ()); static inline loongarch_align la464_align () { @@ -91,9 +117,10 @@ static inline loongarch_align la664_align () array_tune<loongarch_align> loongarch_cpu_align = array_tune<loongarch_align> () - .set (CPU_LOONGARCH64, la664_align ()) - .set (CPU_LA464, la464_align ()) - .set (CPU_LA664, la664_align ()); + .set (TUNE_GENERIC, la664_align ()) + .set (TUNE_LOONGARCH64, la664_align ()) + .set (TUNE_LA464, la464_align ()) + .set (TUNE_LA664, la664_align ()); /* Default RTX cost initializer. */ loongarch_rtx_cost_data::loongarch_rtx_cost_data () @@ -117,7 +144,7 @@ loongarch_rtx_cost_data::loongarch_rtx_cost_data () any known "-mtune" type). */ array_tune<loongarch_rtx_cost_data> loongarch_cpu_rtx_cost_data = array_tune<loongarch_rtx_cost_data> () - .set (CPU_LA664, + .set (TUNE_LA664, loongarch_rtx_cost_data () .movcf2gr_ (COSTS_N_INSNS (1)) .movgr2cf_ (COSTS_N_INSNS (1))); @@ -140,16 +167,18 @@ const loongarch_rtx_cost_data loongarch_rtx_cost_optimize_size = .movcf2gr_ (COST_COMPLEX_INSN); array_tune<int> loongarch_cpu_issue_rate = array_tune<int> () - .set (CPU_NATIVE, 4) - .set (CPU_LOONGARCH64, 4) - .set (CPU_LA464, 4) - .set (CPU_LA664, 6); + .set (TUNE_NATIVE, 4) + .set (TUNE_GENERIC, 4) + .set (TUNE_LOONGARCH64, 4) + .set (TUNE_LA464, 4) + .set (TUNE_LA664, 6); array_tune<int> loongarch_cpu_multipass_dfa_lookahead = array_tune<int> () - .set (CPU_NATIVE, 4) - .set (CPU_LOONGARCH64, 4) - .set (CPU_LA464, 4) - .set (CPU_LA664, 6); + .set (TUNE_NATIVE, 4) + .set (TUNE_GENERIC, 4) + .set (TUNE_LOONGARCH64, 4) + .set (TUNE_LA464, 4) + .set (TUNE_LA664, 6); /* Wiring string definitions from loongarch-str.h to global arrays with standard index values from loongarch-opts.h, so we can diff --git a/gcc/config/loongarch/loongarch-def.h b/gcc/config/loongarch/loongarch-def.h index 60ce3e230f1..ef7d183df50 100644 --- a/gcc/config/loongarch/loongarch-def.h +++ b/gcc/config/loongarch/loongarch-def.h @@ -177,21 +177,32 @@ struct loongarch_target { struct loongarch_isa isa; struct loongarch_abi abi; - int cpu_arch; /* CPU_ */ - int cpu_tune; /* same */ + int cpu_arch; /* ARCH_ */ + int cpu_tune; /* TUNE_ */ int cmodel; /* CMODEL_ */ int tls_dialect; /* TLS_ */ }; -/* CPU model */ +/* ISA target presets (-march=*) */ enum { - CPU_NATIVE = 0, - CPU_ABI_DEFAULT = 1, - CPU_LOONGARCH64 = 2, - CPU_LA464 = 3, - CPU_LA664 = 4, - N_ARCH_TYPES = 5, - N_TUNE_TYPES = 5 + ARCH_NATIVE = 0, + ARCH_ABI_DEFAULT = 1, + ARCH_LOONGARCH64 = 2, + ARCH_LA464 = 3, + ARCH_LA664 = 4, + ARCH_LA64V1_0 = 5, + ARCH_LA64V1_1 = 6, + N_ARCH_TYPES = 7, +}; + +/* Tune target presets (-mtune=*) */ +enum { + TUNE_NATIVE = 0, + TUNE_GENERIC = 1, + TUNE_LOONGARCH64 = 2, + TUNE_LA464 = 3, + TUNE_LA664 = 4, + N_TUNE_TYPES = 5, }; /* TLS types. */ @@ -200,9 +211,11 @@ enum { TLS_DESCRIPTORS = 1 }; -/* CPU model properties */ +/* Target preset properties */ extern loongarch_def_array<const char *, N_ARCH_TYPES> - loongarch_cpu_strings; + loongarch_arch_strings; +extern loongarch_def_array<const char *, N_TUNE_TYPES> + loongarch_tune_strings; extern loongarch_def_array<loongarch_isa, N_ARCH_TYPES> loongarch_cpu_default_isa; extern loongarch_def_array<int, N_TUNE_TYPES> diff --git a/gcc/config/loongarch/loongarch-driver.cc b/gcc/config/loongarch/loongarch-driver.cc index 8c4ed34698b..628dcdc3b77 100644 --- a/gcc/config/loongarch/loongarch-driver.cc +++ b/gcc/config/loongarch/loongarch-driver.cc @@ -85,10 +85,10 @@ driver_set_m_parm (int argc, const char **argv) loongarch_isa_ext_strings, 0, N_ISA_EXT_TYPES) LARCH_DRIVER_PARSE_PARM (la_target.cpu_arch, ARCH, \ - loongarch_cpu_strings, 0, N_ARCH_TYPES) + loongarch_arch_strings, 0, N_ARCH_TYPES) LARCH_DRIVER_PARSE_PARM (la_target.cpu_tune, TUNE, \ - loongarch_cpu_strings, 0, N_TUNE_TYPES) + loongarch_tune_strings, 0, N_TUNE_TYPES) LARCH_DRIVER_PARSE_PARM (la_target.cmodel, CMODEL, \ loongarch_cmodel_strings, 0, N_CMODEL_TYPES) @@ -190,7 +190,7 @@ driver_get_normalized_m_opts (int argc, const char **argv ATTRIBUTE_UNUSED) APPEND_VAL (loongarch_abi_base_strings[la_target.abi.base]); APPEND_OPT (ARCH); - APPEND_VAL (loongarch_cpu_strings[la_target.cpu_arch]); + APPEND_VAL (loongarch_arch_strings[la_target.cpu_arch]); APPEND_OPT (ISA_EXT_FPU); APPEND_VAL (loongarch_isa_ext_strings[la_target.isa.fpu]); @@ -202,7 +202,7 @@ driver_get_normalized_m_opts (int argc, const char **argv ATTRIBUTE_UNUSED) APPEND_VAL (loongarch_cmodel_strings[la_target.cmodel]); APPEND_OPT (TUNE); - APPEND_VAL (loongarch_cpu_strings[la_target.cpu_tune]); + APPEND_VAL (loongarch_tune_strings[la_target.cpu_tune]); obstack_1grow (&opts_obstack, '\0'); diff --git a/gcc/config/loongarch/loongarch-evolution.cc b/gcc/config/loongarch/loongarch-evolution.cc new file mode 100644 index 00000000000..1fb4e3b01b8 --- /dev/null +++ b/gcc/config/loongarch/loongarch-evolution.cc @@ -0,0 +1,60 @@ +/* Generated automatically by "genstr" from "isa-evolution.in". + Please do not edit this file directly. + + Copyright (C) 2023-2024 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. +*/ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "options.h" + +#include "loongarch-evolution.h" + +int la_evo_feature_masks[] = { + OPTION_MASK_ISA_FRECIPE, + OPTION_MASK_ISA_DIV32, + OPTION_MASK_ISA_LAM_BH, + OPTION_MASK_ISA_LAMCAS, + OPTION_MASK_ISA_LD_SEQ_SA, +}; + +const char* la_evo_macro_name[] = { + "__loongarch_frecipe", + "__loongarch_div32", + "__loongarch_lam_bh", + "__loongarch_lamcas", + "__loongarch_ld_seq_sa", +}; + +int la_evo_version_major[] = { + 1, /* FRECIPE */ + 1, /* DIV32 */ + 1, /* LAM_BH */ + 1, /* LAMCAS */ + 1, /* LD_SEQ_SA */ +}; + +int la_evo_version_minor[] = { + 1, /* FRECIPE */ + 1, /* DIV32 */ + 1, /* LAM_BH */ + 1, /* LAMCAS */ + 1, /* LD_SEQ_SA */ +}; diff --git a/gcc/config/loongarch/loongarch-cpucfg-map.h b/gcc/config/loongarch/loongarch-evolution.h index e035322d267..7e8e602c70c 100644 --- a/gcc/config/loongarch/loongarch-cpucfg-map.h +++ b/gcc/config/loongarch/loongarch-evolution.h @@ -17,10 +17,13 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ +<http://www.gnu.org/licenses/>. +*/ -#ifndef LOONGARCH_CPUCFG_MAP_H -#define LOONGARCH_CPUCFG_MAP_H +#ifndef LOONGARCH_EVOLUTION_H +#define LOONGARCH_EVOLUTION_H + +#if !defined(IN_LIBGCC2) && !defined(IN_TARGET_LIBS) && !defined(IN_RTS) #include "options.h" @@ -48,4 +51,39 @@ static constexpr int cpucfg_useful_idx[] = { }; static constexpr int N_CPUCFG_WORDS = 20; -#endif /* LOONGARCH_CPUCFG_MAP_H */ + +/* ISA evolution features */ +enum { + EVO_FRECIPE = 0, + EVO_DIV32 = 1, + EVO_LAM_BH = 2, + EVO_LAMCAS = 3, + EVO_LD_SEQ_SA = 4, + N_EVO_FEATURES = 5 +}; + +/* Condition macros */ +#define ISA_HAS_FRECIPE \ + (la_target.isa.evolution & OPTION_MASK_ISA_FRECIPE) +#define ISA_HAS_DIV32 \ + (la_target.isa.evolution & OPTION_MASK_ISA_DIV32) +#define ISA_HAS_LAM_BH \ + (la_target.isa.evolution & OPTION_MASK_ISA_LAM_BH) +#define ISA_HAS_LAMCAS \ + (la_target.isa.evolution & OPTION_MASK_ISA_LAMCAS) +#define ISA_HAS_LD_SEQ_SA \ + (la_target.isa.evolution & OPTION_MASK_ISA_LD_SEQ_SA) + +/* Bitmasks on la_target.isa.evolution. */ +extern int la_evo_feature_masks[N_EVO_FEATURES]; + +/* Builtin macro names for the evolution features. */ +extern const char* la_evo_macro_name[N_EVO_FEATURES]; + +/* The ISA version where a specific feature is introduced. */ +extern int la_evo_version_major[N_EVO_FEATURES]; +extern int la_evo_version_minor[N_EVO_FEATURES]; + +#endif + +#endif /* LOONGARCH_EVOLUTION_H */ diff --git a/gcc/config/loongarch/loongarch-opts.cc b/gcc/config/loongarch/loongarch-opts.cc index 7b21cc311a8..8408a70e5ca 100644 --- a/gcc/config/loongarch/loongarch-opts.cc +++ b/gcc/config/loongarch/loongarch-opts.cc @@ -101,6 +101,7 @@ static int abi_compat_p (const struct loongarch_isa *isa, struct loongarch_abi abi); static int abi_default_cpu_arch (struct loongarch_abi abi, struct loongarch_isa *isa); +static int default_tune_for_arch (int arch, int fallback); /* Mandatory configure-time defaults. */ #ifndef DEFAULT_ABI_BASE @@ -259,35 +260,35 @@ loongarch_config_target (struct loongarch_target *target, /* If cpu_tune is not set using neither -mtune nor --with-tune, the current cpu_arch is used as its default. */ t.cpu_tune = constrained.tune ? target->cpu_tune - : (constrained.arch ? target->cpu_arch : - (with_default_tune ? DEFAULT_CPU_TUNE : DEFAULT_CPU_ARCH)); + : (constrained.arch + ? default_tune_for_arch (target->cpu_arch, with_default_tune + ? DEFAULT_CPU_TUNE : TUNE_GENERIC) + : (with_default_tune ? DEFAULT_CPU_TUNE + : default_tune_for_arch (DEFAULT_CPU_ARCH, TUNE_GENERIC))); /* Handle -march/tune=native */ #ifdef __loongarch__ /* For native compilers, gather local CPU information - and fill the "CPU_NATIVE" index of arrays defined in - loongarch-cpu.c. */ + and fill the "ARCH_NATIVE/TUNE_NATIVE" index of arrays + defined in loongarch-cpu.c. */ fill_native_cpu_config (&t); #else - if (t.cpu_arch == CPU_NATIVE) + if (t.cpu_arch == ARCH_NATIVE) fatal_error (UNKNOWN_LOCATION, "%qs does not work on a cross compiler", "-m" OPTSTR_ARCH "=" STR_CPU_NATIVE); - else if (t.cpu_tune == CPU_NATIVE) + else if (t.cpu_tune == TUNE_NATIVE) fatal_error (UNKNOWN_LOCATION, "%qs does not work on a cross compiler", "-m" OPTSTR_TUNE "=" STR_CPU_NATIVE); #endif - /* Handle -march/tune=abi-default */ - if (t.cpu_tune == CPU_ABI_DEFAULT) - t.cpu_tune = abi_default_cpu_arch (t.abi, NULL); - - if (t.cpu_arch == CPU_ABI_DEFAULT) + /* Handle -march=abi-default */ + if (t.cpu_arch == ARCH_ABI_DEFAULT) { t.cpu_arch = abi_default_cpu_arch (t.abi, &(t.isa)); loongarch_cpu_default_isa[t.cpu_arch] = t.isa; @@ -438,16 +439,16 @@ config_target_isa: so we adjust that first if it is not constrained. */ int fallback_arch = abi_default_cpu_arch (t.abi, NULL); - if (t.cpu_arch == CPU_NATIVE) + if (t.cpu_arch == ARCH_NATIVE) warning (0, "your native CPU architecture (%qs) " "does not support %qs ABI, falling back to %<-m%s=%s%>", arch_str (&t), abi_str (t.abi), OPTSTR_ARCH, - loongarch_cpu_strings[fallback_arch]); + loongarch_arch_strings[fallback_arch]); else warning (0, "default CPU architecture (%qs) " "does not support %qs ABI, falling back to %<-m%s=%s%>", arch_str (&t), abi_str (t.abi), OPTSTR_ARCH, - loongarch_cpu_strings[fallback_arch]); + loongarch_arch_strings[fallback_arch]); t.cpu_arch = fallback_arch; constrained.arch = 1; @@ -664,11 +665,40 @@ abi_default_cpu_arch (struct loongarch_abi abi, case ABI_BASE_LP64F: case ABI_BASE_LP64S: *isa = isa_required (abi); - return CPU_LOONGARCH64; + return ARCH_LOONGARCH64; } gcc_unreachable (); } +static inline int +default_tune_for_arch (int arch, int fallback) +{ + int ret; + switch (arch) + { + +#define TUNE_FOR_ARCH(NAME) \ + case ARCH_##NAME: \ + ret = TUNE_##NAME; \ + break; + + TUNE_FOR_ARCH(NATIVE) + TUNE_FOR_ARCH(LOONGARCH64) + TUNE_FOR_ARCH(LA464) + TUNE_FOR_ARCH(LA664) + +#undef TUNE_FOR_ARCH + + case ARCH_ABI_DEFAULT: + case ARCH_LA64V1_0: + case ARCH_LA64V1_1: + ret = fallback; + } + + gcc_assert (0 <= ret && ret < N_TUNE_TYPES); + return ret; +} + static const char* abi_str (struct loongarch_abi abi) { @@ -731,7 +761,7 @@ isa_str (const struct loongarch_isa *isa, char separator) static const char* arch_str (const struct loongarch_target *target) { - if (target->cpu_arch == CPU_NATIVE) + if (target->cpu_arch == ARCH_NATIVE) { /* Describe a native CPU with unknown PRID. */ const char* isa_string = isa_str (&target->isa, ','); @@ -741,7 +771,7 @@ arch_str (const struct loongarch_target *target) APPEND_STRING (isa_string) } else - APPEND_STRING (loongarch_cpu_strings[target->cpu_arch]); + APPEND_STRING (loongarch_arch_strings[target->cpu_arch]); APPEND1 ('\0') return XOBFINISH (&msg_obstack, const char *); @@ -956,7 +986,7 @@ loongarch_target_option_override (struct loongarch_target *target, /* Other arch-specific overrides. */ switch (target->cpu_arch) { - case CPU_LA664: + case ARCH_LA664: /* Enable -mrecipe=all for LA664 by default. */ if (!opts_set->x_recip_mask) { diff --git a/gcc/config/loongarch/loongarch-opts.h b/gcc/config/loongarch/loongarch-opts.h index 9844b27ed27..22efac71000 100644 --- a/gcc/config/loongarch/loongarch-opts.h +++ b/gcc/config/loongarch/loongarch-opts.h @@ -115,20 +115,9 @@ struct loongarch_flags { #define ISA_HAS_LASX \ (la_target.isa.simd == ISA_EXT_SIMD_LASX) -#define ISA_HAS_FRECIPE \ - (la_target.isa.evolution & OPTION_MASK_ISA_FRECIPE) -#define ISA_HAS_DIV32 \ - (la_target.isa.evolution & OPTION_MASK_ISA_DIV32) -#define ISA_HAS_LAM_BH \ - (la_target.isa.evolution & OPTION_MASK_ISA_LAM_BH) -#define ISA_HAS_LAMCAS \ - (la_target.isa.evolution & OPTION_MASK_ISA_LAMCAS) -#define ISA_HAS_LD_SEQ_SA \ - (la_target.isa.evolution & OPTION_MASK_ISA_LD_SEQ_SA) - /* TARGET_ macros for use in *.md template conditionals */ -#define TARGET_uARCH_LA464 (la_target.cpu_tune == CPU_LA464) -#define TARGET_uARCH_LA664 (la_target.cpu_tune == CPU_LA664) +#define TARGET_uARCH_LA464 (la_target.cpu_tune == TUNE_LA464) +#define TARGET_uARCH_LA664 (la_target.cpu_tune == TUNE_LA664) /* Note: optimize_size may vary across functions, while -m[no]-memcpy imposes a global constraint. */ diff --git a/gcc/config/loongarch/loongarch-str.h b/gcc/config/loongarch/loongarch-str.h index 20da2b169ed..47f761babb2 100644 --- a/gcc/config/loongarch/loongarch-str.h +++ b/gcc/config/loongarch/loongarch-str.h @@ -27,10 +27,13 @@ along with GCC; see the file COPYING3. If not see #define OPTSTR_TUNE "tune" #define STR_CPU_NATIVE "native" -#define STR_CPU_ABI_DEFAULT "abi-default" +#define STR_ARCH_ABI_DEFAULT "abi-default" +#define STR_TUNE_GENERIC "generic" #define STR_CPU_LOONGARCH64 "loongarch64" #define STR_CPU_LA464 "la464" #define STR_CPU_LA664 "la664" +#define STR_ARCH_LA64V1_0 "la64v1.0" +#define STR_ARCH_LA64V1_1 "la64v1.1" #define STR_ISA_BASE_LA64 "la64" diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc index 6b92e7034c5..e7835ae34ae 100644 --- a/gcc/config/loongarch/loongarch.cc +++ b/gcc/config/loongarch/loongarch.cc @@ -9609,9 +9609,10 @@ loongarch_cpu_sched_reassociation_width (struct loongarch_target *target, switch (target->cpu_tune) { - case CPU_LOONGARCH64: - case CPU_LA464: - case CPU_LA664: + case TUNE_GENERIC: + case TUNE_LOONGARCH64: + case TUNE_LA464: + case TUNE_LA664: /* Vector part. */ if (LSX_SUPPORTED_MODE_P (mode) || LASX_SUPPORTED_MODE_P (mode)) { @@ -10980,9 +10981,9 @@ loongarch_asm_code_end (void) if (flag_verbose_asm) { fprintf (asm_out_file, "\n%s CPU: %s\n", ASM_COMMENT_START, - loongarch_cpu_strings [la_target.cpu_arch]); + loongarch_arch_strings[la_target.cpu_arch]); fprintf (asm_out_file, "%s Tune: %s\n", ASM_COMMENT_START, - loongarch_cpu_strings [la_target.cpu_tune]); + loongarch_tune_strings[la_target.cpu_tune]); fprintf (asm_out_file, "%s Base ISA: %s\n", ASM_COMMENT_START, loongarch_isa_base_strings [la_target.isa.base]); DUMP_FEATURE (ISA_HAS_FRECIPE); diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h index db8a9eb9516..f7fe950f333 100644 --- a/gcc/config/loongarch/loongarch.h +++ b/gcc/config/loongarch/loongarch.h @@ -22,6 +22,7 @@ along with GCC; see the file COPYING3. If not see /* LoongArch external variables defined in loongarch.cc. */ #include "config/loongarch/loongarch-opts.h" +#include "config/loongarch/loongarch-evolution.h" #define SWITCHABLE_TARGET 1 diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md index a316c8fb820..5c80c169cbf 100644 --- a/gcc/config/loongarch/loongarch.md +++ b/gcc/config/loongarch/loongarch.md @@ -1543,9 +1543,9 @@ (set_attr "mode" "<MODE>")]) (define_insn_and_split "*bstrins_<mode>_for_mask" - [(set (match_operand:GPR 0 "register_operand") - (and:GPR (match_operand:GPR 1 "register_operand") - (match_operand:GPR 2 "ins_zero_bitmask_operand")))] + [(set (match_operand:GPR 0 "register_operand" "=r") + (and:GPR (match_operand:GPR 1 "register_operand" "r") + (match_operand:GPR 2 "ins_zero_bitmask_operand" "i")))] "" "#" "" @@ -1563,11 +1563,11 @@ }) (define_insn_and_split "*bstrins_<mode>_for_ior_mask" - [(set (match_operand:GPR 0 "register_operand") - (ior:GPR (and:GPR (match_operand:GPR 1 "register_operand") - (match_operand:GPR 2 "const_int_operand")) - (and:GPR (match_operand:GPR 3 "register_operand") - (match_operand:GPR 4 "const_int_operand"))))] + [(set (match_operand:GPR 0 "register_operand" "=r") + (ior:GPR (and:GPR (match_operand:GPR 1 "register_operand" "r") + (match_operand:GPR 2 "const_int_operand" "i")) + (and:GPR (match_operand:GPR 3 "register_operand" "r") + (match_operand:GPR 4 "const_int_operand" "i"))))] "loongarch_pre_reload_split () && loongarch_use_bstrins_for_ior_with_mask (<MODE>mode, operands)" "#" diff --git a/gcc/config/loongarch/loongarch.opt b/gcc/config/loongarch/loongarch.opt index 773747f2add..91cb5236ad8 100644 --- a/gcc/config/loongarch/loongarch.opt +++ b/gcc/config/loongarch/loongarch.opt @@ -103,30 +103,55 @@ Enable LoongArch Advanced SIMD Extension (LASX, 256-bit). ;; Base target models (implies ISA & tune parameters) Enum -Name(cpu_type) Type(int) -LoongArch CPU types: +Name(arch_type) Type(int) +LoongArch ARCH presets: EnumValue -Enum(cpu_type) String(native) Value(CPU_NATIVE) +Enum(arch_type) String(native) Value(ARCH_NATIVE) EnumValue -Enum(cpu_type) String(abi-default) Value(CPU_ABI_DEFAULT) +Enum(arch_type) String(abi-default) Value(ARCH_ABI_DEFAULT) EnumValue -Enum(cpu_type) String(loongarch64) Value(CPU_LOONGARCH64) +Enum(arch_type) String(loongarch64) Value(ARCH_LOONGARCH64) EnumValue -Enum(cpu_type) String(la464) Value(CPU_LA464) +Enum(arch_type) String(la464) Value(ARCH_LA464) EnumValue -Enum(cpu_type) String(la664) Value(CPU_LA664) +Enum(arch_type) String(la664) Value(ARCH_LA664) + +EnumValue +Enum(arch_type) String(la64v1.0) Value(ARCH_LA64V1_0) + +EnumValue +Enum(arch_type) String(la64v1.1) Value(ARCH_LA64V1_1) march= -Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET) Save +Target RejectNegative Joined Enum(arch_type) Var(la_opt_cpu_arch) Init(M_OPT_UNSET) Save -march=PROCESSOR Generate code for the given PROCESSOR ISA. +Enum +Name(tune_type) Type(int) +LoongArch TUNE presets: + +EnumValue +Enum(tune_type) String(native) Value(TUNE_NATIVE) + +EnumValue +Enum(tune_type) String(generic) Value(TUNE_GENERIC) + +EnumValue +Enum(tune_type) String(loongarch64) Value(TUNE_LOONGARCH64) + +EnumValue +Enum(tune_type) String(la464) Value(TUNE_LA464) + +EnumValue +Enum(tune_type) String(la664) Value(TUNE_LA664) + mtune= -Target RejectNegative Joined Enum(cpu_type) Var(la_opt_cpu_tune) Init(M_OPT_UNSET) Save +Target RejectNegative Joined Enum(tune_type) Var(la_opt_cpu_tune) Init(M_OPT_UNSET) Save -mtune=PROCESSOR Generate optimized code for PROCESSOR. diff --git a/gcc/config/loongarch/t-loongarch b/gcc/config/loongarch/t-loongarch index acf5da95310..6ce36a80fc1 100644 --- a/gcc/config/loongarch/t-loongarch +++ b/gcc/config/loongarch/t-loongarch @@ -21,7 +21,7 @@ GTM_H += loongarch-multilib.h OPTIONS_H_EXTRA += $(srcdir)/config/loongarch/loongarch-def.h \ $(srcdir)/config/loongarch/loongarch-def-array.h \ $(srcdir)/config/loongarch/loongarch-tune.h \ - $(srcdir)/config/loongarch/loongarch-cpucfg-map.h + $(srcdir)/config/loongarch/loongarch-evolution.h # Canonical target triplet from config.gcc LA_MULTIARCH_TRIPLET = $(patsubst LA_MULTIARCH_TRIPLET=%,%,$\ @@ -62,7 +62,11 @@ loongarch-opts.o: $(srcdir)/config/loongarch/loongarch-opts.cc $(LA_STR_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< loongarch-cpu.o: $(srcdir)/config/loongarch/loongarch-cpu.cc $(LA_STR_H) \ - $(srcdir)/config/loongarch/loongarch-cpucfg-map.h + $(srcdir)/config/loongarch/loongarch-evolution.h + $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< + +loongarch-evolution.o: $(srcdir)/config/loongarch/loongarch-evolution.cc $(LA_STR_H) \ + $(srcdir)/config/loongarch/loongarch-evolution.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< loongarch-def.o: $(srcdir)/config/loongarch/loongarch-def.cc $(LA_STR_H) @@ -84,11 +88,17 @@ s-loongarch-opt: $(srcdir)/config/loongarch/genopts/genstr.sh \ $(srcdir)/config/loongarch/loongarch.opt $(STAMP) s-loongarch-opt -$(srcdir)/config/loongarch/loongarch-cpucfg-map.h: s-loongarch-cpucfg-map +$(srcdir)/config/loongarch/loongarch-evolution.h: s-loongarch-evolution @true -s-loongarch-cpucfg-map: $(srcdir)/config/loongarch/genopts/genstr.sh \ - $(srcdir)/config/loongarch/genopts/isa-evolution.in - $(SHELL) $< cpucfg-map > tmp-cpucfg.h - $(SHELL) $(srcdir)/../move-if-change tmp-cpucfg.h \ - $(srcdir)/config/loongarch/loongarch-cpucfg-map.h +$(srcdir)/config/loongarch/loongarch-evolution.cc: s-loongarch-evolution + @true +s-loongarch-evolution: $(srcdir)/config/loongarch/genopts/genstr.sh \ + $(srcdir)/config/loongarch/genopts/isa-evolution.in \ + $(srcdir)/config/loongarch/genopts/gen-evolution.awk + $(SHELL) $< evolution_h > tmp-isa-evo.h + $(SHELL) $< evolution_c > tmp-isa-evo.cc + $(SHELL) $(srcdir)/../move-if-change tmp-isa-evo.h \ + $(srcdir)/config/loongarch/loongarch-evolution.h + $(SHELL) $(srcdir)/../move-if-change tmp-isa-evo.cc \ + $(srcdir)/config/loongarch/loongarch-evolution.cc $(STAMP) $@ diff --git a/gcc/config/mips/i6400.md b/gcc/config/mips/i6400.md index 9f216fe0210..d6f691ee217 100644 --- a/gcc/config/mips/i6400.md +++ b/gcc/config/mips/i6400.md @@ -219,6 +219,12 @@ (eq_attr "type" "fabs,fneg,fmove")) "i6400_fpu_short, i6400_fpu_apu") +;; min, max +(define_insn_reservation "i6400_fpu_minmax" 2 + (and (eq_attr "cpu" "i6400") + (eq_attr "type" "fminmax")) + "i6400_fpu_short+i6400_fpu_logic") + ;; fadd, fsub, fcvt (define_insn_reservation "i6400_fpu_fadd" 4 (and (eq_attr "cpu" "i6400") diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h index 616a275b918..9d965966f2f 100644 --- a/gcc/config/mips/mips.h +++ b/gcc/config/mips/mips.h @@ -1262,6 +1262,8 @@ struct mips_cpu_info { #define ISA_HAS_9BIT_DISPLACEMENT (mips_isa_rev >= 6 \ || ISA_HAS_MIPS16E2) +#define ISA_HAS_FMIN_FMAX (mips_isa_rev >= 6) + /* ISA has data indexed prefetch instructions. This controls use of 'prefx', along with TARGET_HARD_FLOAT and TARGET_DOUBLE_FLOAT. (prefx is a cop1x instruction, so can only be used if FP is diff --git a/gcc/config/mips/mips.md b/gcc/config/mips/mips.md index b0fb5850a9e..26f758c90dd 100644 --- a/gcc/config/mips/mips.md +++ b/gcc/config/mips/mips.md @@ -97,6 +97,10 @@ UNSPEC_GET_FCSR UNSPEC_SET_FCSR + ;; Floating-point unspecs. + UNSPEC_FMIN + UNSPEC_FMAX + ;; HI/LO moves. UNSPEC_MFHI UNSPEC_MTHI @@ -370,6 +374,7 @@ ;; frsqrt floating point reciprocal square root ;; frsqrt1 floating point reciprocal square root step1 ;; frsqrt2 floating point reciprocal square root step2 +;; fminmax floating point min/max ;; dspmac DSP MAC instructions not saturating the accumulator ;; dspmacsat DSP MAC instructions that saturate the accumulator ;; accext DSP accumulator extract instructions @@ -387,8 +392,8 @@ prefetch,prefetchx,condmove,mtc,mfc,mthi,mtlo,mfhi,mflo,const,arith,logical, shift,slt,signext,clz,pop,trap,imul,imul3,imul3nc,imadd,idiv,idiv3,move, fmove,fadd,fmul,fmadd,fdiv,frdiv,frdiv1,frdiv2,fabs,fneg,fcmp,fcvt,fsqrt, - frsqrt,frsqrt1,frsqrt2,dspmac,dspmacsat,accext,accmod,dspalu,dspalusat, - multi,atomic,syncloop,nop,ghost,multimem, + frsqrt,frsqrt1,frsqrt2,fminmax,dspmac,dspmacsat,accext,accmod,dspalu, + dspalusat,multi,atomic,syncloop,nop,ghost,multimem, simd_div,simd_fclass,simd_flog2,simd_fadd,simd_fcvt,simd_fmul,simd_fmadd, simd_fdiv,simd_bitins,simd_bitmov,simd_insert,simd_sld,simd_mul,simd_fcmp, simd_fexp2,simd_int_arith,simd_bit,simd_shift,simd_splat,simd_fill, @@ -7971,6 +7976,47 @@ [(set_attr "move_type" "load") (set_attr "insn_count" "2")]) +;; +;; Float point MIN/MAX +;; + +(define_insn "smin<mode>3" + [(set (match_operand:SCALARF 0 "register_operand" "=f") + (smin:SCALARF (match_operand:SCALARF 1 "register_operand" "f") + (match_operand:SCALARF 2 "register_operand" "f")))] + "ISA_HAS_FMIN_FMAX" + "min.<fmt>\t%0,%1,%2" + [(set_attr "type" "fminmax") + (set_attr "mode" "<UNITMODE>")]) + +(define_insn "smax<mode>3" + [(set (match_operand:SCALARF 0 "register_operand" "=f") + (smax:SCALARF (match_operand:SCALARF 1 "register_operand" "f") + (match_operand:SCALARF 2 "register_operand" "f")))] + "ISA_HAS_FMIN_FMAX" + "max.<fmt>\t%0,%1,%2" + [(set_attr "type" "fminmax") + (set_attr "mode" "<UNITMODE>")]) + +(define_insn "fmin<mode>3" + [(set (match_operand:SCALARF 0 "register_operand" "=f") + (unspec:SCALARF [(use (match_operand:SCALARF 1 "register_operand" "f")) + (use (match_operand:SCALARF 2 "register_operand" "f"))] + UNSPEC_FMIN))] + "ISA_HAS_FMIN_FMAX" + "min.<fmt>\t%0,%1,%2" + [(set_attr "type" "fminmax") + (set_attr "mode" "<UNITMODE>")]) + +(define_insn "fmax<mode>3" + [(set (match_operand:SCALARF 0 "register_operand" "=f") + (unspec:SCALARF [(use (match_operand:SCALARF 1 "register_operand" "f")) + (use (match_operand:SCALARF 2 "register_operand" "f"))] + UNSPEC_FMAX))] + "ISA_HAS_FMIN_FMAX" + "max.<fmt>\t%0,%1,%2" + [(set_attr "type" "fminmax") + (set_attr "mode" "<UNITMODE>")]) ;; 2 HI loads are joined. (define_peephole2 diff --git a/gcc/config/mips/p6600.md b/gcc/config/mips/p6600.md index a9e3262cc18..b6cb554939a 100644 --- a/gcc/config/mips/p6600.md +++ b/gcc/config/mips/p6600.md @@ -167,10 +167,10 @@ (eq_attr "type" "fadd")) "p6600_fpu_long, p6600_fpu_apu") -;; fabs, fneg, fcmp +;; fabs, fneg, fcmp, fminmax (define_insn_reservation "p6600_fpu_fabs" 2 (and (eq_attr "cpu" "p6600") - (ior (eq_attr "type" "fabs,fneg,fcmp,fmove") + (ior (eq_attr "type" "fabs,fneg,fcmp,fmove,fminmax") (and (eq_attr "type" "condmove") (eq_attr "mode" "SF,DF")))) "p6600_fpu_short, p6600_fpu_apu") diff --git a/gcc/config/riscv/bitmanip.md b/gcc/config/riscv/bitmanip.md index ccda25c01c1..ad3ad758959 100644 --- a/gcc/config/riscv/bitmanip.md +++ b/gcc/config/riscv/bitmanip.md @@ -50,11 +50,11 @@ (sign_extend:DI (div:SI (plus:SI (ashift:SI (subreg:SI (match_operand:DI 1 "register_operand") 0) (match_operand:QI 2 "imm123_operand")) (subreg:SI (match_operand:DI 3 "register_operand") 0)) - (subreg:SI (match_operand:DI 4 "register_operand") 0)))) + (match_operand:SI 4 "register_operand")))) (clobber (match_operand:DI 5 "register_operand"))] "TARGET_64BIT && TARGET_ZBA" [(set (match_dup 5) (plus:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3))) - (set (match_dup 0) (sign_extend:DI (div:SI (subreg:SI (match_dup 5) 0) (subreg:SI (match_dup 4) 0))))]) + (set (match_dup 0) (sign_extend:DI (div:SI (subreg:SI (match_dup 5) 0) (match_dup 4))))]) ; Zba does not provide W-forms of sh[123]add(.uw)?, which leads to an ; interesting irregularity: we can generate a signed 32-bit result @@ -722,13 +722,14 @@ (define_split [(set (match_operand:X 0 "register_operand") (and:X (not:X (lshiftrt:X (match_operand:X 1 "register_operand") - (subreg:QI (match_operand:X 2 "register_operand") 0))) + (match_operand:QI 2 "register_operand"))) (const_int 1)))] "TARGET_ZBS" [(set (match_dup 0) (zero_extract:X (match_dup 1) (const_int 1) (match_dup 2))) - (set (match_dup 0) (xor:X (match_dup 0) (const_int 1)))]) + (set (match_dup 0) (xor:X (match_dup 0) (const_int 1)))] + "operands[2] = gen_lowpart (<MODE>mode, operands[2]);") ;; We can create a polarity-reversed mask (i.e. bit N -> { set = 0, clear = -1 }) ;; using a bext(i) followed by an addi instruction. diff --git a/gcc/config/riscv/constraints.md b/gcc/config/riscv/constraints.md index 972e8842c9f..a590df545d7 100644 --- a/gcc/config/riscv/constraints.md +++ b/gcc/config/riscv/constraints.md @@ -159,29 +159,6 @@ (define_register_constraint "vm" "TARGET_VECTOR ? VM_REGS : NO_REGS" "A vector mask register (if available).") -;; These following constraints are used by RVV instructions with dest EEW > src EEW. -;; RISC-V 'V' Spec 5.2. Vector Operands: -;; The destination EEW is greater than the source EEW, the source EMUL is at least 1, -;; and the overlap is in the highest-numbered part of the destination register group. -;; (e.g., when LMUL=8, vzext.vf4 v0, v6 is legal, but a source of v0, v2, or v4 is not). -(define_register_constraint "W21" "TARGET_VECTOR ? V_REGS : NO_REGS" - "A vector register has register number % 2 == 1." "regno % 2 == 1") - -(define_register_constraint "W42" "TARGET_VECTOR ? V_REGS : NO_REGS" - "A vector register has register number % 4 == 2." "regno % 4 == 2") - -(define_register_constraint "W84" "TARGET_VECTOR ? V_REGS : NO_REGS" - "A vector register has register number % 8 == 4." "regno % 8 == 4") - -(define_register_constraint "W43" "TARGET_VECTOR ? V_REGS : NO_REGS" - "A vector register has register number % 4 == 3." "regno % 4 == 3") - -(define_register_constraint "W86" "TARGET_VECTOR ? V_REGS : NO_REGS" - "A vector register has register number % 8 == 6." "regno % 8 == 6") - -(define_register_constraint "W87" "TARGET_VECTOR ? V_REGS : NO_REGS" - "A vector register has register number % 8 == 7." "regno % 8 == 7") - ;; This constraint is used to match instruction "csrr %0, vlenb" which is generated in "mov<mode>". ;; VLENB is a run-time constant which represent the vector register length in bytes. ;; BYTES_PER_RISCV_VECTOR represent runtime invariant of vector register length in bytes. diff --git a/gcc/config/riscv/elf.h b/gcc/config/riscv/elf.h index f533764d9f8..c97f13c0cca 100644 --- a/gcc/config/riscv/elf.h +++ b/gcc/config/riscv/elf.h @@ -20,6 +20,7 @@ along with GCC; see the file COPYING3. If not see #define LINK_SPEC "\ -melf" XLEN_SPEC DEFAULT_ENDIAN_SPEC "riscv \ %{mno-relax:--no-relax} \ +-X \ %{mbig-endian:-EB} \ %{mlittle-endian:-EL} \ %{shared}" diff --git a/gcc/config/riscv/freebsd.h b/gcc/config/riscv/freebsd.h index bd08a985285..5dd4d51c42b 100644 --- a/gcc/config/riscv/freebsd.h +++ b/gcc/config/riscv/freebsd.h @@ -44,6 +44,7 @@ along with GCC; see the file COPYING3. If not see %{p:%nconsider using `-pg' instead of `-p' with gprof (1)} \ %{v:-V} \ %{assert*} %{R*} %{rpath*} %{defsym*} \ + -X \ %{mbig-endian:-EB} \ %{mlittle-endian:-EL} \ %{shared:-Bshareable %{h*} %{soname*}} \ diff --git a/gcc/config/riscv/iterators.md b/gcc/config/riscv/iterators.md index a7694137685..75e119e407a 100644 --- a/gcc/config/riscv/iterators.md +++ b/gcc/config/riscv/iterators.md @@ -196,6 +196,13 @@ (define_code_iterator bitmanip_rotate [rotate rotatert]) +;; These code iterators allow the signed and unsigned fix operations to use +;; the same template. +(define_code_iterator fix_ops [fix unsigned_fix]) + +(define_code_attr fix_uns [(fix "fix") (unsigned_fix "fixuns")]) + + ;; ------------------------------------------------------------------- ;; Code Attributes ;; ------------------------------------------------------------------- @@ -312,11 +319,6 @@ ;; Int Iterators. ;; ------------------------------------------------------------------- -;; Iterator and attributes for floating-point rounding instructions. -(define_int_iterator RINT [UNSPEC_LRINT UNSPEC_LROUND]) -(define_int_attr rint_pattern [(UNSPEC_LRINT "rint") (UNSPEC_LROUND "round")]) -(define_int_attr rint_rm [(UNSPEC_LRINT "dyn") (UNSPEC_LROUND "rmm")]) - ;; Iterator and attributes for quiet comparisons. (define_int_iterator QUIET_COMPARISON [UNSPEC_FLT_QUIET UNSPEC_FLE_QUIET]) (define_int_attr quiet_pattern [(UNSPEC_FLT_QUIET "lt") (UNSPEC_FLE_QUIET "le")]) diff --git a/gcc/config/riscv/linux.h b/gcc/config/riscv/linux.h index 15851f653bc..3c356227134 100644 --- a/gcc/config/riscv/linux.h +++ b/gcc/config/riscv/linux.h @@ -50,6 +50,7 @@ along with GCC; see the file COPYING3. If not see #define LINK_SPEC "\ -melf" XLEN_SPEC DEFAULT_ENDIAN_SPEC "riscv" LD_EMUL_SUFFIX " \ %{mno-relax:--no-relax} \ +-X \ %{mbig-endian:-EB} \ %{mlittle-endian:-EL} \ %{shared} \ diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 5d46a29d8b7..e5aebf3fc3d 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -711,6 +711,7 @@ bool gather_scatter_valid_offset_p (machine_mode); HOST_WIDE_INT estimated_poly_value (poly_int64, unsigned int); bool whole_reg_to_reg_move_p (rtx *, machine_mode, int); bool splat_to_scalar_move_p (rtx *); +rtx get_fp_rounding_coefficient (machine_mode); } /* We classify builtin types into two classes: diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc index 814c5febabe..c9e0feebca6 100644 --- a/gcc/config/riscv/riscv-v.cc +++ b/gcc/config/riscv/riscv-v.cc @@ -4494,7 +4494,7 @@ vls_mode_valid_p (machine_mode vls_mode) All double floating point will be unchanged for ceil if it is greater than and equal to 4503599627370496. */ -static rtx +rtx get_fp_rounding_coefficient (machine_mode inner_mode) { REAL_VALUE_TYPE real; diff --git a/gcc/config/riscv/riscv-vector-costs.cc b/gcc/config/riscv/riscv-vector-costs.cc index d27bb68a7b9..4582b0db425 100644 --- a/gcc/config/riscv/riscv-vector-costs.cc +++ b/gcc/config/riscv/riscv-vector-costs.cc @@ -563,14 +563,24 @@ get_store_value (gimple *stmt) return gimple_assign_rhs1 (stmt); } -/* Return true if it is non-contiguous load/store. */ +/* Return true if addtional vector vars needed. */ static bool -non_contiguous_memory_access_p (stmt_vec_info stmt_info) +need_additional_vector_vars_p (stmt_vec_info stmt_info) { enum stmt_vec_info_type type = STMT_VINFO_TYPE (vect_stmt_to_vectorize (stmt_info)); - return ((type == load_vec_info_type || type == store_vec_info_type) - && !adjacent_dr_p (STMT_VINFO_DATA_REF (stmt_info))); + if (type == load_vec_info_type || type == store_vec_info_type) + { + if (STMT_VINFO_GATHER_SCATTER_P (stmt_info) + && STMT_VINFO_MEMORY_ACCESS_TYPE (stmt_info) == VMAT_GATHER_SCATTER) + return true; + + machine_mode mode = TYPE_MODE (STMT_VINFO_VECTYPE (stmt_info)); + int lmul = riscv_get_v_regno_alignment (mode); + if (DR_GROUP_SIZE (stmt_info) * lmul > RVV_M8) + return true; + } + return false; } /* Return the LMUL of the current analysis. */ @@ -739,10 +749,7 @@ update_local_live_ranges ( stmt_vec_info stmt_info = vinfo->lookup_stmt (gsi_stmt (si)); enum stmt_vec_info_type type = STMT_VINFO_TYPE (vect_stmt_to_vectorize (stmt_info)); - if (non_contiguous_memory_access_p (stmt_info) - /* LOAD_LANES/STORE_LANES doesn't need a perm indice. */ - && STMT_VINFO_MEMORY_ACCESS_TYPE (stmt_info) - != VMAT_LOAD_STORE_LANES) + if (need_additional_vector_vars_p (stmt_info)) { /* For non-adjacent load/store STMT, we will potentially convert it into: diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 0519e0679ed..24d1ead3902 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -2786,6 +2786,45 @@ riscv_v_adjust_scalable_frame (rtx target, poly_int64 offset, bool epilogue) REG_NOTES (insn) = dwarf; } +/* Take care below subreg const_poly_int move: + + 1. (set (subreg:DI (reg:TI 237) 8) + (subreg:DI (const_poly_int:TI [4, 2]) 8)) + => + (set (subreg:DI (reg:TI 237) 8) + (const_int 0)) */ + +static bool +riscv_legitimize_subreg_const_poly_move (machine_mode mode, rtx dest, rtx src) +{ + gcc_assert (SUBREG_P (src) && CONST_POLY_INT_P (SUBREG_REG (src))); + gcc_assert (SUBREG_BYTE (src).is_constant ()); + + int byte_offset = SUBREG_BYTE (src).to_constant (); + rtx const_poly = SUBREG_REG (src); + machine_mode subreg_mode = GET_MODE (const_poly); + + if (subreg_mode != TImode) /* Only TImode is needed for now. */ + return false; + + if (byte_offset == 8) + { + /* The const_poly_int cannot exceed int64, just set zero here. */ + emit_move_insn (dest, CONST0_RTX (mode)); + return true; + } + + /* The below transform will be covered in somewhere else. + Thus, ignore this here. + (set (subreg:DI (reg:TI 237) 0) + (subreg:DI (const_poly_int:TI [4, 2]) 0)) + => + (set (subreg:DI (reg:TI 237) 0) + (const_poly_int:DI [4, 2])) */ + + return false; +} + /* If (set DEST SRC) is not a valid move instruction, emit an equivalent sequence that is valid. */ @@ -2839,6 +2878,11 @@ riscv_legitimize_move (machine_mode mode, rtx dest, rtx src) } return true; } + + if (SUBREG_P (src) && CONST_POLY_INT_P (SUBREG_REG (src)) + && riscv_legitimize_subreg_const_poly_move (mode, dest, src)) + return true; + /* Expand (set (reg:DI target) (subreg:DI (reg:V8QI reg) 0)) Expand this data movement instead of simply forbid it since @@ -8830,26 +8874,43 @@ riscv_macro_fusion_pair_p (rtx_insn *prev, rtx_insn *curr) extract_base_offset_in_addr (SET_DEST (prev_set), &base_prev, &offset_prev); extract_base_offset_in_addr (SET_DEST (curr_set), &base_curr, &offset_curr); - /* The two stores must be contained within opposite halves of the same - 16 byte aligned block of memory. We know that the stack pointer and - the frame pointer have suitable alignment. So we just need to check - the offsets of the two stores for suitable alignment. - - Originally the thought was to check MEM_ALIGN, but that was reporting - incorrect alignments, even for SP/FP accesses, so we gave up on that - approach. */ - if (base_prev != NULL_RTX - && base_curr != NULL_RTX - && REG_P (base_prev) - && REG_P (base_curr) - && REGNO (base_prev) == REGNO (base_curr) - && (REGNO (base_prev) == STACK_POINTER_REGNUM - || REGNO (base_prev) == HARD_FRAME_POINTER_REGNUM) - && ((INTVAL (offset_prev) == INTVAL (offset_curr) + 8 - && (INTVAL (offset_prev) % 16) == 0) - || ((INTVAL (offset_curr) == INTVAL (offset_prev) + 8) - && (INTVAL (offset_curr) % 16) == 0))) - return true; + /* Fail if we did not find both bases. */ + if (base_prev == NULL_RTX || base_curr == NULL_RTX) + return false; + + /* Fail if either base is not a register. */ + if (!REG_P (base_prev) || !REG_P (base_curr)) + return false; + + /* Fail if the bases are not the same register. */ + if (REGNO (base_prev) != REGNO (base_curr)) + return false; + + /* Originally the thought was to check MEM_ALIGN, but that was + reporting incorrect alignments, even for SP/FP accesses, so we + gave up on that approach. Instead just check for stack/hfp + which we know are aligned. */ + if (REGNO (base_prev) != STACK_POINTER_REGNUM + && REGNO (base_prev) != HARD_FRAME_POINTER_REGNUM) + return false; + + /* The two stores must be contained within opposite halves of the + same 16 byte aligned block of memory. We know that the stack + pointer and the frame pointer have suitable alignment. So we + just need to check the offsets of the two stores for suitable + alignment. */ + /* Get the smaller offset into OFFSET_PREV. */ + if (INTVAL (offset_prev) > INTVAL (offset_curr)) + std::swap (offset_prev, offset_curr); + + /* If the smaller offset (OFFSET_PREV) is not 16 byte aligned, + then fail. */ + if ((INTVAL (offset_prev) % 16) != 0) + return false; + + /* The higher offset must be 8 bytes more than the lower + offset. */ + return (INTVAL (offset_prev) + 8 == INTVAL (offset_curr)); } } diff --git a/gcc/config/riscv/riscv.md b/gcc/config/riscv/riscv.md index c2b4323c53a..8f518fdbe5a 100644 --- a/gcc/config/riscv/riscv.md +++ b/gcc/config/riscv/riscv.md @@ -64,7 +64,6 @@ UNSPEC_ROUNDEVEN UNSPEC_NEARBYINT UNSPEC_LRINT - UNSPEC_LROUND UNSPEC_FMIN UNSPEC_FMAX UNSPEC_FMINM @@ -538,51 +537,6 @@ ] (const_string "no"))) -;; Widening instructions have group-overlap constraints. Those are only -;; valid for certain register-group sizes. This attribute marks the -;; alternatives not matching the required register-group size as disabled. -(define_attr "group_overlap" "none,W21,W42,W84,W43,W86,W87,W0" - (const_string "none")) - -(define_attr "group_overlap_valid" "no,yes" - (cond [(eq_attr "group_overlap" "none") - (const_string "yes") - - (and (eq_attr "group_overlap" "W21") - (match_test "riscv_get_v_regno_alignment (GET_MODE (operands[0])) != 2")) - (const_string "no") - - (and (eq_attr "group_overlap" "W42") - (match_test "riscv_get_v_regno_alignment (GET_MODE (operands[0])) != 4")) - (const_string "no") - - (and (eq_attr "group_overlap" "W84") - (match_test "riscv_get_v_regno_alignment (GET_MODE (operands[0])) != 8")) - (const_string "no") - - ;; According to RVV ISA: - ;; The destination EEW is greater than the source EEW, the source EMUL is at least 1, - ;; and the overlap is in the highest-numbered part of the destination register group - ;; (e.g., when LMUL=8, vzext.vf4 v0, v6 is legal, but a source of v0, v2, or v4 is not). - ;; So the source operand should have LMUL >= 1. - (and (eq_attr "group_overlap" "W43") - (match_test "riscv_get_v_regno_alignment (GET_MODE (operands[0])) != 4 - && riscv_get_v_regno_alignment (GET_MODE (operands[3])) >= 1")) - (const_string "no") - - (and (eq_attr "group_overlap" "W86,W87") - (match_test "riscv_get_v_regno_alignment (GET_MODE (operands[0])) != 8 - && riscv_get_v_regno_alignment (GET_MODE (operands[3])) >= 1")) - (const_string "no") - - ;; W21 supports highest-number overlap for source LMUL = 1. - ;; For 'wv' variant, we can also allow wide source operand overlaps dest operand. - (and (eq_attr "group_overlap" "W0") - (match_test "riscv_get_v_regno_alignment (GET_MODE (operands[0])) > 1")) - (const_string "no") - ] - (const_string "yes"))) - ;; This attribute marks the alternatives not matching the constraints ;; described in spec as disabled. (define_attr "spec_restriction" "none,thv,rvv" @@ -611,9 +565,6 @@ (eq_attr "fp_vector_disabled" "yes") (const_string "no") - (eq_attr "group_overlap_valid" "no") - (const_string "no") - (eq_attr "spec_restriction_disabled" "yes") (const_string "no") ] @@ -1967,21 +1918,48 @@ ;; ;; .................... -(define_insn "fix_trunc<ANYF:mode><GPR:mode>2" - [(set (match_operand:GPR 0 "register_operand" "=r") - (fix:GPR +(define_expand "<fix_uns>_trunc<ANYF:mode>si2" + [(set (match_operand:SI 0 "register_operand" "=r") + (fix_ops:SI (match_operand:ANYF 1 "register_operand" " f")))] "TARGET_HARD_FLOAT || TARGET_ZFINX" - "fcvt.<GPR:ifmt>.<ANYF:fmt> %0,%1,rtz" +{ + if (TARGET_64BIT) + { + rtx t = gen_reg_rtx (DImode); + emit_insn (gen_<fix_uns>_trunc<ANYF:mode>si2_sext (t, operands[1])); + t = gen_lowpart (SImode, t); + SUBREG_PROMOTED_VAR_P (t) = 1; + SUBREG_PROMOTED_SET (t, SRP_SIGNED); + emit_move_insn (operands[0], t); + DONE; + } +}) + +(define_insn "*<fix_uns>_trunc<ANYF:mode>si2" + [(set (match_operand:SI 0 "register_operand" "=r") + (fix_ops:SI + (match_operand:ANYF 1 "register_operand" " f")))] + "TARGET_HARD_FLOAT || TARGET_ZFINX" + "fcvt.w<u>.<ANYF:fmt> %0,%1,rtz" + [(set_attr "type" "fcvt_f2i") + (set_attr "mode" "<ANYF:MODE>")]) + +(define_insn "<fix_uns>_trunc<ANYF:mode>si2_sext" + [(set (match_operand:DI 0 "register_operand" "=r") + (sign_extend:DI (fix_ops:SI + (match_operand:ANYF 1 "register_operand" " f"))))] + "TARGET_64BIT && (TARGET_HARD_FLOAT || TARGET_ZFINX)" + "fcvt.w<u>.<ANYF:fmt> %0,%1,rtz" [(set_attr "type" "fcvt_f2i") (set_attr "mode" "<ANYF:MODE>")]) -(define_insn "fixuns_trunc<ANYF:mode><GPR:mode>2" - [(set (match_operand:GPR 0 "register_operand" "=r") - (unsigned_fix:GPR +(define_insn "<fix_uns>_trunc<ANYF:mode>di2" + [(set (match_operand:DI 0 "register_operand" "=r") + (fix_ops:DI (match_operand:ANYF 1 "register_operand" " f")))] - "TARGET_HARD_FLOAT || TARGET_ZFINX" - "fcvt.<GPR:ifmt>u.<ANYF:fmt> %0,%1,rtz" + "TARGET_64BIT && (TARGET_HARD_FLOAT || TARGET_ZFINX)" + "fcvt.l<u>.<ANYF:fmt> %0,%1,rtz" [(set_attr "type" "fcvt_f2i") (set_attr "mode" "<ANYF:MODE>")]) @@ -2003,17 +1981,170 @@ [(set_attr "type" "fcvt_i2f") (set_attr "mode" "<ANYF:MODE>")]) -(define_insn "l<rint_pattern><ANYF:mode><GPR:mode>2" - [(set (match_operand:GPR 0 "register_operand" "=r") - (unspec:GPR +(define_expand "lrint<ANYF:mode>si2" + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI + [(match_operand:ANYF 1 "register_operand" " f")] + UNSPEC_LRINT))] + "TARGET_HARD_FLOAT || TARGET_ZFINX" +{ + if (TARGET_64BIT) + { + rtx t = gen_reg_rtx (DImode); + emit_insn (gen_lrint<ANYF:mode>si2_sext (t, operands[1])); + t = gen_lowpart (SImode, t); + SUBREG_PROMOTED_VAR_P (t) = 1; + SUBREG_PROMOTED_SET (t, SRP_SIGNED); + emit_move_insn (operands[0], t); + DONE; + } +}) + +(define_insn "*lrint<ANYF:mode>si2" + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI [(match_operand:ANYF 1 "register_operand" " f")] - RINT))] + UNSPEC_LRINT))] "TARGET_HARD_FLOAT || TARGET_ZFINX" - "fcvt.<GPR:ifmt>.<ANYF:fmt> %0,%1,<rint_rm>" + "fcvt.w.<ANYF:fmt> %0,%1,dyn" + [(set_attr "type" "fcvt_f2i") + (set_attr "mode" "<ANYF:MODE>")]) + +(define_insn "lrint<ANYF:mode>si2_sext" + [(set (match_operand:DI 0 "register_operand" "=r") + (sign_extend:DI (unspec:SI + [(match_operand:ANYF 1 "register_operand" " f")] + UNSPEC_LRINT)))] + "TARGET_64BIT && (TARGET_HARD_FLOAT || TARGET_ZFINX)" + "fcvt.w.<ANYF:fmt> %0,%1,dyn" + [(set_attr "type" "fcvt_f2i") + (set_attr "mode" "<ANYF:MODE>")]) + +(define_insn "lrint<ANYF:mode>di2" + [(set (match_operand:DI 0 "register_operand" "=r") + (unspec:DI + [(match_operand:ANYF 1 "register_operand" " f")] + UNSPEC_LRINT))] + "TARGET_64BIT && (TARGET_HARD_FLOAT || TARGET_ZFINX)" + "fcvt.l.<ANYF:fmt> %0,%1,dyn" [(set_attr "type" "fcvt_f2i") (set_attr "mode" "<ANYF:MODE>")]) -(define_insn "<round_pattern><ANYF:mode>2" +(define_expand "l<round_pattern><ANYF:mode>si2" + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI + [(match_operand:ANYF 1 "register_operand" " f")] + ROUND))] + "TARGET_HARD_FLOAT || TARGET_ZFINX" +{ + if (TARGET_64BIT) + { + rtx t = gen_reg_rtx (DImode); + emit_insn (gen_l<round_pattern><ANYF:mode>si2_sext (t, operands[1])); + t = gen_lowpart (SImode, t); + SUBREG_PROMOTED_VAR_P (t) = 1; + SUBREG_PROMOTED_SET (t, SRP_SIGNED); + emit_move_insn (operands[0], t); + DONE; + } +}) + +(define_insn "*l<round_pattern><ANYF:mode>si2" + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI + [(match_operand:ANYF 1 "register_operand" " f")] + ROUND))] + "TARGET_HARD_FLOAT || TARGET_ZFINX" + "fcvt.w.<ANYF:fmt> %0,%1,<round_rm>" + [(set_attr "type" "fcvt_f2i") + (set_attr "mode" "<ANYF:MODE>")]) + +(define_insn "l<round_pattern><ANYF:mode>si2_sext" + [(set (match_operand:DI 0 "register_operand" "=r") + (sign_extend:DI (unspec:SI + [(match_operand:ANYF 1 "register_operand" " f")] + ROUND)))] + "TARGET_64BIT && (TARGET_HARD_FLOAT || TARGET_ZFINX)" + "fcvt.w.<ANYF:fmt> %0,%1,<round_rm>" + [(set_attr "type" "fcvt_f2i") + (set_attr "mode" "<ANYF:MODE>")]) + +(define_insn "l<round_pattern><ANYF:mode>di2" + [(set (match_operand:DI 0 "register_operand" "=r") + (unspec:DI + [(match_operand:ANYF 1 "register_operand" " f")] + ROUND))] + "TARGET_64BIT && (TARGET_HARD_FLOAT || TARGET_ZFINX)" + "fcvt.l.<ANYF:fmt> %0,%1,<round_rm>" + [(set_attr "type" "fcvt_f2i") + (set_attr "mode" "<ANYF:MODE>")]) + +(define_expand "<round_pattern><ANYF:mode>2" + [(set (match_operand:ANYF 0 "register_operand" "=f") + (unspec:ANYF + [(match_operand:ANYF 1 "register_operand" " f")] + ROUND))] + "TARGET_HARD_FLOAT && (TARGET_ZFA + || flag_fp_int_builtin_inexact || !flag_trapping_math)" +{ + if (TARGET_ZFA) + emit_insn (gen_<round_pattern><ANYF:mode>_zfa2 (operands[0], + operands[1])); + else + { + rtx reg; + rtx label = gen_label_rtx (); + rtx end_label = gen_label_rtx (); + rtx abs_reg = gen_reg_rtx (<ANYF:MODE>mode); + rtx coeff_reg = gen_reg_rtx (<ANYF:MODE>mode); + rtx tmp_reg = gen_reg_rtx (<ANYF:MODE>mode); + + riscv_emit_move (tmp_reg, operands[1]); + riscv_emit_move (coeff_reg, + riscv_vector::get_fp_rounding_coefficient (<ANYF:MODE>mode)); + emit_insn (gen_abs<ANYF:mode>2 (abs_reg, operands[1])); + + riscv_expand_conditional_branch (label, LT, abs_reg, coeff_reg); + + emit_jump_insn (gen_jump (end_label)); + emit_barrier (); + + emit_label (label); + switch (<ANYF:MODE>mode) + { + case SFmode: + reg = gen_reg_rtx (SImode); + emit_insn (gen_l<round_pattern>sfsi2 (reg, operands[1])); + emit_insn (gen_floatsisf2 (abs_reg, reg)); + break; + case DFmode: + if (TARGET_64BIT) + { + reg = gen_reg_rtx (DImode); + emit_insn (gen_l<round_pattern>dfdi2 (reg, operands[1])); + emit_insn (gen_floatdidf2 (abs_reg, reg)); + } + else + { + reg = gen_reg_rtx (SImode); + emit_insn (gen_l<round_pattern>dfsi2 (reg, operands[1])); + emit_insn (gen_floatsidf2 (abs_reg, reg)); + } + break; + default: + gcc_unreachable (); + } + + emit_insn (gen_copysign<ANYF:mode>3 (tmp_reg, abs_reg, operands[1])); + + emit_label (end_label); + riscv_emit_move (operands[0], tmp_reg); + } + + DONE; +}) + +(define_insn "<round_pattern><ANYF:mode>_zfa2" [(set (match_operand:ANYF 0 "register_operand" "=f") (unspec:ANYF [(match_operand:ANYF 1 "register_operand" " f")] diff --git a/gcc/config/riscv/riscv.opt b/gcc/config/riscv/riscv.opt index 8da0764eb4b..ee824756381 100644 --- a/gcc/config/riscv/riscv.opt +++ b/gcc/config/riscv/riscv.opt @@ -152,7 +152,7 @@ required to materialize symbol addresses. mcsr-check Target Var(riscv_mcsr_check) Init(0) -Enable the CSR checking for the ISA-dependent CRS and the read-only CSR. +Enable the CSR checking for the ISA-dependent CSR and the read-only CSR. The ISA-dependent CSR are only valid when the specific ISA is set. The read-only CSR can not be written by the CSR instructions. @@ -237,8 +237,6 @@ Mask(ZIHINTPAUSE) Var(riscv_zi_subext) Mask(ZICOND) Var(riscv_zi_subext) -Mask(ZIC64B) Var(riscv_zi_subext) - Mask(ZICCAMOA) Var(riscv_zi_subext) Mask(ZICCIF) Var(riscv_zi_subext) @@ -390,6 +388,8 @@ Mask(ZICBOM) Var(riscv_zicmo_subext) Mask(ZICBOP) Var(riscv_zicmo_subext) +Mask(ZIC64B) Var(riscv_zicmo_subext) + TargetVariable int riscv_zf_subext diff --git a/gcc/config/riscv/thead.md b/gcc/config/riscv/thead.md index 5c7d4beb1b6..a47fe6f28b8 100644 --- a/gcc/config/riscv/thead.md +++ b/gcc/config/riscv/thead.md @@ -466,12 +466,12 @@ (define_insn_and_split "*th_memidx_operand" [(set (match_operand:DI 0 "register_operand" "=r") (ashift:DI - (zero_extend:DI (subreg:SI (match_operand:DI 1 "register_operand" "r") 0)) + (zero_extend:DI (match_operand:SI 1 "register_operand" "r")) (match_operand 2 "const_int_operand" "n")))] "TARGET_64BIT && TARGET_XTHEADMEMIDX && lra_in_progress" "#" "" - [(set (match_dup 0) (zero_extend:DI (subreg:SI (match_dup 1) 0))) + [(set (match_dup 0) (zero_extend:DI (match_dup 1))) (set (match_dup 0) (ashift:DI (match_dup 0) (match_dup 2)))] "" [(set_attr "type" "bitmanip")]) diff --git a/gcc/config/riscv/vector-crypto.md b/gcc/config/riscv/vector-crypto.md index 519c6a10d94..e474ddf5da7 100755 --- a/gcc/config/riscv/vector-crypto.md +++ b/gcc/config/riscv/vector-crypto.md @@ -303,26 +303,25 @@ (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_vwsll<mode>_scalar" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr, &vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1, vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (ashift:VWEXTI (zero_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) - (match_operand:<VSUBEL> 4 "pmode_reg_or_uimm5_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK")) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) + (match_operand:<VSUBEL> 4 "pmode_reg_or_uimm5_operand" " rK, rK")) + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_ZVBB" "vwsll.v%o4\t%0,%3,%4%p1" [(set_attr "type" "vwsll") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) ;; vbrev.v vbrev8.v vrev8.v (define_insn "@pred_v<rev><mode>" diff --git a/gcc/config/riscv/vector.md b/gcc/config/riscv/vector.md index 8b1c24c5d79..228d0f9a766 100644 --- a/gcc/config/riscv/vector.md +++ b/gcc/config/riscv/vector.md @@ -2254,70 +2254,67 @@ ;; DEST eew is greater than SOURCE eew. (define_insn "@pred_indexed_<order>load<mode>_x2_greater_eew" - [(set (match_operand:VEEWEXT2 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VEEWEXT2 0 "register_operand" "=&vr, &vr") (if_then_else:VEEWEXT2 (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (unspec:VEEWEXT2 - [(match_operand 3 "pmode_reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ") + [(match_operand 3 "pmode_reg_or_0_operand" " rJ, rJ") (mem:BLK (scratch)) - (match_operand:<VINDEX_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")] ORDER) - (match_operand:VEEWEXT2 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VINDEX_DOUBLE_TRUNC> 4 "register_operand" " vr, vr")] ORDER) + (match_operand:VEEWEXT2 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vl<order>xei<double_trunc_sew>.v\t%0,(%z3),%4%p1" [(set_attr "type" "vld<order>x") - (set_attr "mode" "<MODE>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<MODE>")]) (define_insn "@pred_indexed_<order>load<mode>_x4_greater_eew" - [(set (match_operand:VEEWEXT4 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VEEWEXT4 0 "register_operand" "=&vr, &vr") (if_then_else:VEEWEXT4 (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (unspec:VEEWEXT4 - [(match_operand 3 "pmode_reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ") + [(match_operand 3 "pmode_reg_or_0_operand" " rJ, rJ") (mem:BLK (scratch)) - (match_operand:<VINDEX_QUAD_TRUNC> 4 "register_operand" "W43,W43,W43,W43,W86,W86,W86,W86, vr, vr")] ORDER) - (match_operand:VEEWEXT4 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VINDEX_QUAD_TRUNC> 4 "register_operand" " vr, vr")] ORDER) + (match_operand:VEEWEXT4 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vl<order>xei<quad_trunc_sew>.v\t%0,(%z3),%4%p1" [(set_attr "type" "vld<order>x") - (set_attr "mode" "<MODE>") - (set_attr "group_overlap" "W43,W43,W43,W43,W86,W86,W86,W86,none,none")]) + (set_attr "mode" "<MODE>")]) (define_insn "@pred_indexed_<order>load<mode>_x8_greater_eew" - [(set (match_operand:VEEWEXT8 0 "register_operand" "=vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VEEWEXT8 0 "register_operand" "=&vr, &vr") (if_then_else:VEEWEXT8 (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (unspec:VEEWEXT8 - [(match_operand 3 "pmode_reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ") + [(match_operand 3 "pmode_reg_or_0_operand" " rJ, rJ") (mem:BLK (scratch)) - (match_operand:<VINDEX_OCT_TRUNC> 4 "register_operand" "W87,W87,W87,W87, vr, vr")] ORDER) - (match_operand:VEEWEXT8 2 "vector_merge_operand" " vu, vu, 0, 0, vu, 0")))] + (match_operand:<VINDEX_OCT_TRUNC> 4 "register_operand" " vr, vr")] ORDER) + (match_operand:VEEWEXT8 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vl<order>xei<oct_trunc_sew>.v\t%0,(%z3),%4%p1" [(set_attr "type" "vld<order>x") - (set_attr "mode" "<MODE>") - (set_attr "group_overlap" "W87,W87,W87,W87,none,none")]) + (set_attr "mode" "<MODE>")]) ;; DEST eew is smaller than SOURCE eew. (define_insn "@pred_indexed_<order>load<mode>_x2_smaller_eew" @@ -3733,66 +3730,63 @@ ;; Vector Double-Widening Sign-extend and Zero-extend. (define_insn "@pred_<optab><mode>_vf2" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (any_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "v<sz>ext.vf2\t%0,%3%p1" [(set_attr "type" "vext") - (set_attr "mode" "<MODE>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<MODE>")]) ;; Vector Quad-Widening Sign-extend and Zero-extend. (define_insn "@pred_<optab><mode>_vf4" - [(set (match_operand:VQEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VQEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VQEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" " i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (any_extend:VQEXTI - (match_operand:<V_QUAD_TRUNC> 3 "register_operand" "W43,W43,W43,W43,W86,W86,W86,W86, vr, vr")) - (match_operand:VQEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<V_QUAD_TRUNC> 3 "register_operand" " vr, vr")) + (match_operand:VQEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "v<sz>ext.vf4\t%0,%3%p1" [(set_attr "type" "vext") - (set_attr "mode" "<MODE>") - (set_attr "group_overlap" "W43,W43,W43,W43,W86,W86,W86,W86,none,none")]) + (set_attr "mode" "<MODE>")]) ;; Vector Oct-Widening Sign-extend and Zero-extend. (define_insn "@pred_<optab><mode>_vf8" - [(set (match_operand:VOEXTI 0 "register_operand" "=vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VOEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VOEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" " i, i, i, i, i, i") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (any_extend:VOEXTI - (match_operand:<V_OCT_TRUNC> 3 "register_operand" "W87,W87,W87,W87, vr, vr")) - (match_operand:VOEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, 0")))] + (match_operand:<V_OCT_TRUNC> 3 "register_operand" " vr, vr")) + (match_operand:VOEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "v<sz>ext.vf8\t%0,%3%p1" [(set_attr "type" "vext") - (set_attr "mode" "<MODE>") - (set_attr "group_overlap" "W87,W87,W87,W87,none,none")]) + (set_attr "mode" "<MODE>")]) ;; Vector Widening Add/Subtract/Multiply. (define_insn "@pred_dual_widen_<any_widen_binop:optab><any_extend:su><mode>" @@ -3818,72 +3812,69 @@ (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_dual_widen_<any_widen_binop:optab><any_extend:su><mode>_scalar" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (any_widen_binop:VWEXTI (any_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) (any_extend:VWEXTI (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 4 "reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ")))) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VSUBEL> 4 "reg_or_0_operand" " rJ, rJ")))) + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vw<any_widen_binop:insn><any_extend:u>.vx\t%0,%3,%z4%p1" [(set_attr "type" "vi<widen_binop_insn_type>") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_single_widen_sub<any_extend:su><mode>" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, &vr, &vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (minus:VWEXTI - (match_operand:VWEXTI 3 "register_operand" " vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, 0, 0, vr, vr") + (match_operand:VWEXTI 3 "register_operand" " vr, vr") (any_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr, vr, vr"))) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr, vr"))) + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vwsub<any_extend:u>.wv\t%0,%3,%4%p1" [(set_attr "type" "viwalu") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,W0,W0,none,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_single_widen_add<any_extend:su><mode>" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, &vr, &vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTI (any_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr, vr, vr")) - (match_operand:VWEXTI 3 "register_operand" " vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, 0, 0, vr, vr")) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr, vr")) + (match_operand:VWEXTI 3 "register_operand" " vr, vr")) + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vwadd<any_extend:u>.wv\t%0,%3,%4%p1" [(set_attr "type" "viwalu") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,W0,W0,none,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_single_widen_<plus_minus:optab><any_extend:su><mode>_scalar" [(set (match_operand:VWEXTI 0 "register_operand" "=vr, vr") @@ -3930,47 +3921,46 @@ (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_widen_mulsu<mode>_scalar" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (mult:VWEXTI (sign_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) (zero_extend:VWEXTI (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 4 "reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ, rJ")))) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VSUBEL> 4 "reg_or_0_operand" " rJ, rJ")))) + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vwmulsu.vx\t%0,%3,%z4%p1" [(set_attr "type" "viwmul") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) ;; vwcvt<u>.x.x.v (define_insn "@pred_<optab><mode>" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr,&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTI (any_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) (vec_duplicate:VWEXTI (reg:<VEL> X0_REGNUM))) - (match_operand:VWEXTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:VWEXTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vwcvt<u>.x.x.v\t%0,%3%p1" [(set_attr "type" "viwalu") @@ -3978,8 +3968,7 @@ (set_attr "vl_op_idx" "4") (set (attr "ta") (symbol_ref "riscv_vector::get_ta(operands[5])")) (set (attr "ma") (symbol_ref "riscv_vector::get_ma(operands[6])")) - (set (attr "avl_type_idx") (const_int 7)) - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set (attr "avl_type_idx") (const_int 7))]) ;; ------------------------------------------------------------------------------- ;; ---- Predicated integer Narrowing operations @@ -5936,30 +5925,29 @@ (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_widen_mul_plus<su><mode>_scalar" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1") + (match_operand 5 "vector_length_operand" " rK") + (match_operand 6 "const_int_operand" " i") + (match_operand 7 "const_int_operand" " i") + (match_operand 8 "const_int_operand" " i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTI (mult:VWEXTI (any_extend:VWEXTI (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 3 "reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ"))) + (match_operand:<VSUBEL> 3 "register_operand" " r"))) (any_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W42,W42,W84,W84, vr"))) - (match_operand:VWEXTI 2 "register_operand" " 0, 0, 0, 0, 0, 0, 0")) + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr"))) + (match_operand:VWEXTI 2 "register_operand" " 0")) (match_dup 2)))] "TARGET_VECTOR" - "vwmacc<u>.vx\t%0,%z3,%4%p1" + "vwmacc<u>.vx\t%0,%3,%4%p1" [(set_attr "type" "viwmuladd") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W42,W42,W84,W84,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_widen_mul_plussu<mode>" [(set (match_operand:VWEXTI 0 "register_operand" "=&vr") @@ -5986,56 +5974,54 @@ (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_widen_mul_plussu<mode>_scalar" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1") + (match_operand 5 "vector_length_operand" " rK") + (match_operand 6 "const_int_operand" " i") + (match_operand 7 "const_int_operand" " i") + (match_operand 8 "const_int_operand" " i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTI (mult:VWEXTI (sign_extend:VWEXTI (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 3 "reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ"))) + (match_operand:<VSUBEL> 3 "register_operand" " r"))) (zero_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W42,W42,W84,W84, vr"))) - (match_operand:VWEXTI 2 "register_operand" " 0, 0, 0, 0, 0, 0, 0")) + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr"))) + (match_operand:VWEXTI 2 "register_operand" " 0")) (match_dup 2)))] "TARGET_VECTOR" - "vwmaccsu.vx\t%0,%z3,%4%p1" + "vwmaccsu.vx\t%0,%3,%4%p1" [(set_attr "type" "viwmuladd") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W42,W42,W84,W84,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) (define_insn "@pred_widen_mul_plusus<mode>_scalar" - [(set (match_operand:VWEXTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, ?&vr") + [(set (match_operand:VWEXTI 0 "register_operand" "=&vr") (if_then_else:VWEXTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1") + (match_operand 5 "vector_length_operand" " rK") + (match_operand 6 "const_int_operand" " i") + (match_operand 7 "const_int_operand" " i") + (match_operand 8 "const_int_operand" " i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTI (mult:VWEXTI (zero_extend:VWEXTI (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 3 "reg_or_0_operand" " rJ, rJ, rJ, rJ, rJ, rJ, rJ"))) + (match_operand:<VSUBEL> 3 "register_operand" " r"))) (sign_extend:VWEXTI - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W42,W42,W84,W84, vr"))) - (match_operand:VWEXTI 2 "register_operand" " 0, 0, 0, 0, 0, 0, 0")) + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr"))) + (match_operand:VWEXTI 2 "register_operand" " 0")) (match_dup 2)))] "TARGET_VECTOR" - "vwmaccus.vx\t%0,%z3,%4%p1" + "vwmaccus.vx\t%0,%3,%4%p1" [(set_attr "type" "viwmuladd") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W42,W42,W84,W84,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) ;; ------------------------------------------------------------------------------- ;; ---- Predicated BOOL mask operations @@ -7115,84 +7101,81 @@ (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_dual_widen_<optab><mode>_scalar" - [(set (match_operand:VWEXTF 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=&vr, &vr") (if_then_else:VWEXTF (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 9 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") + (match_operand 9 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) (any_widen_binop:VWEXTF (float_extend:VWEXTF - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) (float_extend:VWEXTF (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 4 "register_operand" " f, f, f, f, f, f, f, f, f, f, f, f, f, f")))) - (match_operand:VWEXTF 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VSUBEL> 4 "register_operand" " f, f")))) + (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfw<insn>.vf\t%0,%3,%4%p1" [(set_attr "type" "vf<widen_binop_insn_type>") (set_attr "mode" "<V_DOUBLE_TRUNC>") (set (attr "frm_mode") - (symbol_ref "riscv_vector::get_frm_mode (operands[9])")) - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_single_widen_add<mode>" - [(set (match_operand:VWEXTF 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, &vr, &vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=&vr, &vr") (if_then_else:VWEXTF (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 9 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") + (match_operand 9 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTF (float_extend:VWEXTF - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr, vr, vr")) - (match_operand:VWEXTF 3 "register_operand" " vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, 0, 0, vr, vr")) - (match_operand:VWEXTF 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr, vr")) + (match_operand:VWEXTF 3 "register_operand" " vr, vr")) + (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfwadd.wv\t%0,%3,%4%p1" [(set_attr "type" "vfwalu") (set_attr "mode" "<V_DOUBLE_TRUNC>") (set (attr "frm_mode") - (symbol_ref "riscv_vector::get_frm_mode (operands[9])")) - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,W0,W0,none,none")]) + (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_single_widen_sub<mode>" - [(set (match_operand:VWEXTF 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, &vr, &vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=&vr, &vr") (if_then_else:VWEXTF (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1,vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 9 "const_int_operand" " i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 5 "vector_length_operand" " rK, rK") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") + (match_operand 9 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) (minus:VWEXTF - (match_operand:VWEXTF 3 "register_operand" " vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, vr, 0, 0, vr, vr") + (match_operand:VWEXTF 3 "register_operand" " vr, vr") (float_extend:VWEXTF - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr, vr, vr"))) - (match_operand:VWEXTF 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr, vr"))) + (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfwsub.wv\t%0,%3,%4%p1" [(set_attr "type" "vfwalu") (set_attr "mode" "<V_DOUBLE_TRUNC>") (set (attr "frm_mode") - (symbol_ref "riscv_vector::get_frm_mode (operands[9])")) - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,W0,W0,none,none")]) + (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_single_widen_<plus_minus:optab><mode>_scalar" [(set (match_operand:VWEXTF 0 "register_operand" "=vr, vr") @@ -7256,15 +7239,15 @@ (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_widen_mul_<optab><mode>_scalar" - [(set (match_operand:VWEXTF 0 "register_operand" "=vd, vr, vd, vr, vd, vr, ?&vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=&vr") (if_then_else:VWEXTF (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 9 "const_int_operand" " i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1") + (match_operand 5 "vector_length_operand" " rK") + (match_operand 6 "const_int_operand" " i") + (match_operand 7 "const_int_operand" " i") + (match_operand 8 "const_int_operand" " i") + (match_operand 9 "const_int_operand" " i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) @@ -7272,18 +7255,17 @@ (mult:VWEXTF (float_extend:VWEXTF (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 3 "register_operand" " f, f, f, f, f, f, f"))) + (match_operand:<VSUBEL> 3 "register_operand" " f"))) (float_extend:VWEXTF - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W42,W42,W84,W84, vr"))) - (match_operand:VWEXTF 2 "register_operand" " 0, 0, 0, 0, 0, 0, 0")) + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr"))) + (match_operand:VWEXTF 2 "register_operand" " 0")) (match_dup 2)))] "TARGET_VECTOR" "vfw<macc_msac>.vf\t%0,%3,%4%p1" [(set_attr "type" "vfwmuladd") (set_attr "mode" "<V_DOUBLE_TRUNC>") (set (attr "frm_mode") - (symbol_ref "riscv_vector::get_frm_mode (operands[9])")) - (set_attr "group_overlap" "W21,W21,W42,W42,W84,W84,none")]) + (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_widen_mul_neg_<optab><mode>" [(set (match_operand:VWEXTF 0 "register_operand" "=&vr") @@ -7315,15 +7297,15 @@ (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_widen_mul_neg_<optab><mode>_scalar" - [(set (match_operand:VWEXTF 0 "register_operand" "=vd, vr, vd, vr, vd, vr, ?&vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=&vr") (if_then_else:VWEXTF (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1,vmWc1") - (match_operand 5 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK") - (match_operand 6 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" " i, i, i, i, i, i, i") - (match_operand 9 "const_int_operand" " i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1") + (match_operand 5 "vector_length_operand" " rK") + (match_operand 6 "const_int_operand" " i") + (match_operand 7 "const_int_operand" " i") + (match_operand 8 "const_int_operand" " i") + (match_operand 9 "const_int_operand" " i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) @@ -7332,18 +7314,17 @@ (mult:VWEXTF (float_extend:VWEXTF (vec_duplicate:<V_DOUBLE_TRUNC> - (match_operand:<VSUBEL> 3 "register_operand" " f, f, f, f, f, f, f"))) + (match_operand:<VSUBEL> 3 "register_operand" " f"))) (float_extend:VWEXTF - (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" "W21,W21,W42,W42,W84,W84, vr")))) - (match_operand:VWEXTF 2 "register_operand" " 0, 0, 0, 0, 0, 0, 0")) + (match_operand:<V_DOUBLE_TRUNC> 4 "register_operand" " vr")))) + (match_operand:VWEXTF 2 "register_operand" " 0")) (match_dup 2)))] "TARGET_VECTOR" "vfw<nmsac_nmacc>.vf\t%0,%3,%4%p1" [(set_attr "type" "vfwmuladd") (set_attr "mode" "<V_DOUBLE_TRUNC>") (set (attr "frm_mode") - (symbol_ref "riscv_vector::get_frm_mode (operands[9])")) - (set_attr "group_overlap" "W21,W21,W42,W42,W84,W84,none")]) + (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) ;; ------------------------------------------------------------------------------- ;; ---- Predicated floating-point comparison operations @@ -7713,88 +7694,84 @@ ;; ------------------------------------------------------------------------------- (define_insn "@pred_widen_fcvt_x<v_su>_f<mode>" - [(set (match_operand:VWCONVERTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWCONVERTI 0 "register_operand" "=&vr, &vr") (if_then_else:VWCONVERTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 8 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") + (match_operand 8 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) (unspec:VWCONVERTI - [(match_operand:<VNCONVERT> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")] VFCVTS) - (match_operand:VWCONVERTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + [(match_operand:<VNCONVERT> 3 "register_operand" " vr, vr")] VFCVTS) + (match_operand:VWCONVERTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfwcvt.x<v_su>.f.v\t%0,%3%p1" [(set_attr "type" "vfwcvtftoi") (set_attr "mode" "<VNCONVERT>") (set (attr "frm_mode") - (symbol_ref "riscv_vector::get_frm_mode (operands[8])")) - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (symbol_ref "riscv_vector::get_frm_mode (operands[8])"))]) (define_insn "@pred_widen_<fix_cvt><mode>" - [(set (match_operand:VWCONVERTI 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWCONVERTI 0 "register_operand" "=&vr, &vr") (if_then_else:VWCONVERTI (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (any_fix:VWCONVERTI - (match_operand:<VNCONVERT> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) - (match_operand:VWCONVERTI 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VNCONVERT> 3 "register_operand" " vr, vr")) + (match_operand:VWCONVERTI 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfwcvt.rtz.x<u>.f.v\t%0,%3%p1" [(set_attr "type" "vfwcvtftoi") - (set_attr "mode" "<VNCONVERT>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<VNCONVERT>")]) (define_insn "@pred_widen_<float_cvt><mode>" - [(set (match_operand:V_VLSF 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:V_VLSF 0 "register_operand" "=&vr, &vr") (if_then_else:V_VLSF (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (any_float:V_VLSF - (match_operand:<VNCONVERT> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) - (match_operand:V_VLSF 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<VNCONVERT> 3 "register_operand" " vr, vr")) + (match_operand:V_VLSF 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfwcvt.f.x<u>.v\t%0,%3%p1" [(set_attr "type" "vfwcvtitof") - (set_attr "mode" "<VNCONVERT>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<VNCONVERT>")]) (define_insn "@pred_extend<mode>" - [(set (match_operand:VWEXTF_ZVFHMIN 0 "register_operand" "=vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, vd, vr, ?&vr, ?&vr") + [(set (match_operand:VWEXTF_ZVFHMIN 0 "register_operand" "=&vr, &vr") (if_then_else:VWEXTF_ZVFHMIN (unspec:<VM> - [(match_operand:<VM> 1 "vector_mask_operand" " vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1, vm,Wc1,vmWc1,vmWc1") - (match_operand 4 "vector_length_operand" " rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK, rK") - (match_operand 5 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 6 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") - (match_operand 7 "const_int_operand" "i, i, i, i, i, i, i, i, i, i, i, i, i, i") + [(match_operand:<VM> 1 "vector_mask_operand" "vmWc1,vmWc1") + (match_operand 4 "vector_length_operand" " rK, rK") + (match_operand 5 "const_int_operand" " i, i") + (match_operand 6 "const_int_operand" " i, i") + (match_operand 7 "const_int_operand" " i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (float_extend:VWEXTF_ZVFHMIN - (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84, vr, vr")) - (match_operand:VWEXTF_ZVFHMIN 2 "vector_merge_operand" " vu, vu, 0, 0, vu, vu, 0, 0, vu, vu, 0, 0, vu, 0")))] + (match_operand:<V_DOUBLE_TRUNC> 3 "register_operand" " vr, vr")) + (match_operand:VWEXTF_ZVFHMIN 2 "vector_merge_operand" " vu, 0")))] "TARGET_VECTOR" "vfwcvt.f.f.v\t%0,%3%p1" [(set_attr "type" "vfwcvtftof") - (set_attr "mode" "<V_DOUBLE_TRUNC>") - (set_attr "group_overlap" "W21,W21,W21,W21,W42,W42,W42,W42,W84,W84,W84,W84,none,none")]) + (set_attr "mode" "<V_DOUBLE_TRUNC>")]) ;; ------------------------------------------------------------------------------- ;; ---- Predicated floating-point narrow conversions diff --git a/gcc/config/rs6000/altivec.md b/gcc/config/rs6000/altivec.md index 4d4c94ff0a0..bb20441c096 100644 --- a/gcc/config/rs6000/altivec.md +++ b/gcc/config/rs6000/altivec.md @@ -4586,18 +4586,18 @@ [(set (reg:CCFP CR6_REGNO) (compare:CCFP (unspec:V2DF [(match_operand:VBCD 1 "register_operand" "v")] - UNSPEC_BCDADD) + UNSPEC_BCDSUB) (match_operand:V2DF 2 "zero_constant" "j"))) (clobber (match_scratch:VBCD 0 "=v"))] "TARGET_P8_VECTOR" - "bcdadd. %0,%1,%1,0" + "bcdsub. %0,%1,%1,0" [(set_attr "type" "vecsimple")]) (define_expand "bcdinvalid_<mode>" [(parallel [(set (reg:CCFP CR6_REGNO) (compare:CCFP (unspec:V2DF [(match_operand:VBCD 1 "register_operand")] - UNSPEC_BCDADD) + UNSPEC_BCDSUB) (match_dup 2))) (clobber (match_scratch:VBCD 3))]) (set (match_operand:SI 0 "register_operand") diff --git a/gcc/config/s390/s390-c.cc b/gcc/config/s390/s390-c.cc index 8d3d1a467a8..4521a86f048 100644 --- a/gcc/config/s390/s390-c.cc +++ b/gcc/config/s390/s390-c.cc @@ -275,7 +275,9 @@ s390_macro_to_expand (cpp_reader *pfile, const cpp_token *tok) /* __vector long __bool a; */ if (ident == C_CPP_HASHNODE (__bool_keyword)) expand_bool_p = true; - else + + /* If there are more tokens to check. */ + else if (ident) { /* Triggered with: __vector long long __bool a; */ do @@ -498,11 +500,11 @@ s390_expand_overloaded_builtin (location_t loc, /* Build a vector type with the alignment of the source location in order to enable correct alignment hints to be generated for vl. */ - tree mem_type = build_aligned_type (return_type, - TYPE_ALIGN (TREE_TYPE (TREE_TYPE ((*arglist)[1])))); + unsigned align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE ((*arglist)[1]))); + tree mem_type = build_aligned_type (return_type, align); return build2 (MEM_REF, mem_type, fold_build_pointer_plus ((*arglist)[1], (*arglist)[0]), - build_int_cst (TREE_TYPE ((*arglist)[1]), 0)); + build_int_cst (ptr_type_node, 0)); } case S390_OVERLOADED_BUILTIN_s390_vec_xst: case S390_OVERLOADED_BUILTIN_s390_vec_xstd2: @@ -511,11 +513,13 @@ s390_expand_overloaded_builtin (location_t loc, /* Build a vector type with the alignment of the target location in order to enable correct alignment hints to be generated for vst. */ - tree mem_type = build_aligned_type (TREE_TYPE((*arglist)[0]), - TYPE_ALIGN (TREE_TYPE (TREE_TYPE ((*arglist)[2])))); + unsigned align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE ((*arglist)[2]))); + tree mem_type = build_aligned_type (TREE_TYPE ((*arglist)[0]), align); return build2 (MODIFY_EXPR, mem_type, - build1 (INDIRECT_REF, mem_type, - fold_build_pointer_plus ((*arglist)[2], (*arglist)[1])), + build2 (MEM_REF, mem_type, + fold_build_pointer_plus ((*arglist)[2], + (*arglist)[1]), + build_int_cst (ptr_type_node, 0)), (*arglist)[0]); } case S390_OVERLOADED_BUILTIN_s390_vec_load_pair: diff --git a/gcc/config/s390/s390.cc b/gcc/config/s390/s390.cc index bf46eab2d63..5968808fcb6 100644 --- a/gcc/config/s390/s390.cc +++ b/gcc/config/s390/s390.cc @@ -16104,7 +16104,7 @@ s390_option_override_internal (struct gcc_options *opts, } else { - if (TARGET_CPU_VX_P (opts)) + if (TARGET_CPU_VX_P (opts) && TARGET_ZARCH_P (opts->x_target_flags)) /* Enable vector support if available and not explicitly disabled by user. E.g. with -m31 -march=z13 -mzarch */ opts->x_target_flags |= MASK_OPT_VX; diff --git a/gcc/config/sparc/sol2.h b/gcc/config/sparc/sol2.h index e849af9038b..552f58b2cc8 100644 --- a/gcc/config/sparc/sol2.h +++ b/gcc/config/sparc/sol2.h @@ -456,3 +456,6 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); #undef SPARC_LOW_FE_EXCEPT_VALUES #define SPARC_LOW_FE_EXCEPT_VALUES 1 + +#undef SUN_V9_ABI_COMPATIBILITY +#define SUN_V9_ABI_COMPATIBILITY 1 diff --git a/gcc/config/sparc/sparc.cc b/gcc/config/sparc/sparc.cc index 30fa4474bbd..8a5f76c8885 100644 --- a/gcc/config/sparc/sparc.cc +++ b/gcc/config/sparc/sparc.cc @@ -6782,6 +6782,22 @@ sparc_pass_by_reference (cumulative_args_t, const function_arg_info &arg) || GET_MODE_SIZE (mode) > 16); } +/* Return true if TYPE is considered as a floating-point type by the ABI. */ + +static bool +fp_type_for_abi (const_tree type) +{ + /* This is the original GCC implementation. */ + if (FLOAT_TYPE_P (type) || VECTOR_TYPE_P (type)) + return true; + + /* This has been introduced in GCC 14 to match the vendor compiler. */ + if (SUN_V9_ABI_COMPATIBILITY && TREE_CODE (type) == ARRAY_TYPE) + return fp_type_for_abi (TREE_TYPE (type)); + + return false; +} + /* Traverse the record TYPE recursively and call FUNC on its fields. NAMED is true if this is for a named parameter. DATA is passed to FUNC for each field. OFFSET is the starting position and @@ -6820,8 +6836,7 @@ traverse_record_type (const_tree type, bool named, T *data, packed); else { - const bool fp_type - = FLOAT_TYPE_P (field_type) || VECTOR_TYPE_P (field_type); + const bool fp_type = fp_type_for_abi (field_type); Func (field, bitpos, fp_type && named && !packed && TARGET_FPU, data); } @@ -7072,6 +7087,13 @@ compute_fp_layout (const_tree field, int bitpos, assign_data_t *data, mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field))); nregs = 2; } + else if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE) + { + tree elt_type = strip_array_types (TREE_TYPE (field)); + mode = TYPE_MODE (elt_type); + nregs + = int_size_in_bytes (TREE_TYPE (field)) / int_size_in_bytes (elt_type); + } else nregs = 1; diff --git a/gcc/config/sparc/sparc.h b/gcc/config/sparc/sparc.h index fb074808d30..232ecb30ddc 100644 --- a/gcc/config/sparc/sparc.h +++ b/gcc/config/sparc/sparc.h @@ -1700,3 +1700,6 @@ extern int sparc_indent_opcode; #define SPARC_LOW_FE_EXCEPT_VALUES 0 #define TARGET_SUPPORTS_WIDE_INT 1 + +/* Define this to 1 to accept ABI changes to match the vendor compiler. */ +#define SUN_V9_ABI_COMPATIBILITY 0 diff --git a/gcc/config/t-vxworks b/gcc/config/t-vxworks index b89350c3c70..6063943e346 100644 --- a/gcc/config/t-vxworks +++ b/gcc/config/t-vxworks @@ -57,7 +57,7 @@ T_GLIMITS_H = vxw-glimits.h vxw-glimits.h: $(srcdir)/glimits.h ID=`echo $(BASEVER_c) | sed -e 's/\./_/g'` && \ - sed -e "s/_LIMITS_H__/_LIMITS_H__$${ID}_/" < $< > $@T + sed -e "s/_LIMITS_H___/_LIMITS_H__$${ID}_/" < $< > $@T mv $@T $@ # Arrange to "provide" a tailored version of stdint-gcc.h diff --git a/gcc/configure b/gcc/configure index 266ab8f84b2..23da7d55d62 100755 --- a/gcc/configure +++ b/gcc/configure @@ -8232,7 +8232,13 @@ if test "${with_documentation_root_url+set}" = set; then : *) as_fn_error $? "documentation root URL does not end with /" "$LINENO" 5 ;; esac else - DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/" + + docroot_url_suffix= + case "$gcc_version" in + *.[123456].0) docroot_url_suffix="gcc-$gcc_version/";; + *.[123456].1) docroot_url_suffix="gcc-`echo $gcc_version | sed 's/1$/0/'`/";; + esac + DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/$docroot_url_suffix" fi @@ -21569,7 +21575,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 21572 "configure" +#line 21578 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -21675,7 +21681,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 21678 "configure" +#line 21684 "configure" #include "confdefs.h" #if HAVE_DLFCN_H diff --git a/gcc/configure.ac b/gcc/configure.ac index a5aec1bc967..d7cf0b92cd8 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -1088,9 +1088,16 @@ AC_ARG_WITH(documentation-root-url, no) AC_MSG_ERROR([documentation root URL not specified]) ;; */) DOCUMENTATION_ROOT_URL="$withval" ;; *) AC_MSG_ERROR([documentation root URL does not end with /]) ;; - esac], - DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/" -) + esac],[ + docroot_url_suffix= +changequote(,)dnl + case "$gcc_version" in + *.[123456].0) docroot_url_suffix="gcc-$gcc_version/";; + *.[123456].1) docroot_url_suffix="gcc-`echo $gcc_version | sed 's/1$/0/'`/";; + esac +changequote([,])dnl + DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/$docroot_url_suffix" +]) AC_DEFINE_UNQUOTED(DOCUMENTATION_ROOT_URL,"$DOCUMENTATION_ROOT_URL", [Define to the root for documentation URLs.]) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 5ba3f1c242e..8234073701a 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,121 @@ +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + PR c++/114456 + * parser.cc (cp_parser_decomposition_declaration): Implement C++26 + P0609R3 - Attributes for Structured Bindings. Parse attributed + identifier lists for structured binding declarations, pass the + attributes to start_decl. + +2024-04-30 Nathaniel Shead <nathanieloshead@gmail.com> + + PR c++/105320 + PR c++/114275 + * cp-tree.h (propagate_defining_module): Declare. + (lookup_imported_hidden_friend): Declare. + * decl.cc (duplicate_decls): Also check if hidden decls can be + redeclared in this module. + * module.cc (imported_temploid_friends): New. + (init_modules): Initialize it. + (trees_out::decl_value): Write it; don't consider imported + temploid friends as attached to a module. + (trees_in::decl_value): Read it. + (get_originating_module_decl): Follow the owning decl for an + imported temploid friend. + (propagate_defining_module): New. + * name-lookup.cc (get_mergeable_namespace_binding): New. + (lookup_imported_hidden_friend): New. + * pt.cc (tsubst_friend_function): Propagate defining module for + new friend functions. + (tsubst_friend_class): Lookup imported hidden friends. Check + for valid module attachment of existing names. Propagate + defining module for new classes. + +2024-04-30 Nathaniel Shead <nathanieloshead@gmail.com> + + * cp-tree.h (module_may_redeclare): Add default parameter. + * decl.cc (duplicate_decls): Don't emit errors for failed + module_may_redeclare. + (xref_tag): Likewise. + (start_enum): Likewise. + * semantics.cc (begin_class_definition): Likewise. + * module.cc (module_may_redeclare): Clean up logic. Emit error + messages on failure. + +2024-04-30 Patrick Palka <ppalka@redhat.com> + + PR c++/114889 + * module.cc (trees_in::read_class_def): Look through + TEMPLATE_DECL when adding to CLASSTYPE_BEFRIENDING_CLASSES. + +2024-04-30 Patrick Palka <ppalka@redhat.com> + + PR c++/114888 + * typeck.cc (cp_build_binary_op) <case *_DIV_*>: Add missing + dependence check for the second sizeof operand. + +2024-04-26 Patrick Palka <ppalka@redhat.com> + + * error.cc (print_instantiation_partial_context_line): Clear the + pretty printer prefix around the call to diagnostic_show_locus. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + PR c++/111284 + * constexpr.cc (cxx_bind_parameters_in_call): For PARM_DECLs with + TREE_ADDRESSABLE types use vc_glvalue rather than vc_prvalue for + cxx_eval_constant_expression and if it doesn't have the same + type as it should, cast the reference type to reference to type + before convert_from_reference and instead of adjust_temp_type + take address of the arg, cast to reference to type and then + convert_from_reference. + (cxx_eval_constant_expression) <case PARM_DECL>: For lval case + on parameters with TREE_ADDRESSABLE types lookup result in + ctx->globals if possible. Otherwise if lookup in ctx->globals + was successful for parameter with TREE_ADDRESSABLE type, + recurse with vc_prvalue on the returned value. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + PR lto/113208 + * cp-tree.h (maybe_optimize_cdtor): Declare. + * decl2.cc (import_export_decl): Call it for cloned cdtors. + * optimize.cc (maybe_optimize_cdtor): New function. + +2024-04-24 Patrick Palka <ppalka@redhat.com> + + PR c++/114709 + * constexpr.cc (cxx_fold_indirect_ref): Restrict object/offset + canonicalization to RECORD_TYPE member accesses. + +2024-04-23 Nathaniel Shead <nathanieloshead@gmail.com> + + * parser.cc (cp_parser_parameter_declaration): Check if + decl_specifiers.type is null. + +2024-04-23 Patrick Palka <ppalka@redhat.com> + + PR c++/114795 + * module.cc (trees_in::is_matching_decl): Propagate deduced + function return type. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * parser.cc (cp_parser_using_declaration): Spelling fix: favour + -> favor. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + PR c++/114784 + * method.cc (implicitly_declare_fn): Call clone_attrs + on DECL_ATTRIBUTES on STRIP_TEMPLATE (inherited_ctor) rather than + inherited_ctor. Also copy DECL_DISREGARD_INLINE_LIMITS flag from it. + +2024-04-23 Nathaniel Shead <nathanieloshead@gmail.com> + + PR c++/114078 + * decl.cc (grokdeclarator): Check allocation functions for xobj + parameters. + 2024-04-16 Jakub Jelinek <jakub@redhat.com> PR c++/114706 diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index dbdd7c29fe8..7c4ecf08c4b 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -11167,7 +11167,9 @@ in_charge_arg_for_name (tree name) if (name == complete_dtor_identifier) return integer_two_node; else if (name == deleting_dtor_identifier) - return integer_three_node; + /* The deleting dtor should now be handled by + build_delete_destructor_body. */ + gcc_unreachable (); gcc_checking_assert (name == base_dtor_identifier); } diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index 302b266809f..50f799d7ff7 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -1872,13 +1872,18 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t, tree fun, x = build_address (x); } if (TREE_ADDRESSABLE (type)) - /* Undo convert_for_arg_passing work here. */ - x = convert_from_reference (x); - /* Normally we would strip a TARGET_EXPR in an initialization context - such as this, but here we do the elision differently: we keep the - TARGET_EXPR, and use its CONSTRUCTOR as the value of the parm. */ - arg = cxx_eval_constant_expression (ctx, x, vc_prvalue, - non_constant_p, overflow_p); + { + /* Undo convert_for_arg_passing work here. */ + x = convert_from_reference (x); + arg = cxx_eval_constant_expression (ctx, x, vc_glvalue, + non_constant_p, overflow_p); + } + else + /* Normally we would strip a TARGET_EXPR in an initialization context + such as this, but here we do the elision differently: we keep the + TARGET_EXPR, and use its CONSTRUCTOR as the value of the parm. */ + arg = cxx_eval_constant_expression (ctx, x, vc_prvalue, + non_constant_p, overflow_p); /* Check we aren't dereferencing a null pointer when calling a non-static member function, which is undefined behaviour. */ if (i == 0 && DECL_OBJECT_MEMBER_FUNCTION_P (fun) @@ -1904,7 +1909,16 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, tree t, tree fun, { /* Make sure the binding has the same type as the parm. But only for constant args. */ - if (!TYPE_REF_P (type)) + if (TREE_ADDRESSABLE (type)) + { + if (!same_type_p (type, TREE_TYPE (arg))) + { + arg = build_fold_addr_expr (arg); + arg = cp_fold_convert (build_reference_type (type), arg); + arg = convert_from_reference (arg); + } + } + else if (!TYPE_REF_P (type)) arg = adjust_temp_type (type, arg); if (!TREE_CONSTANT (arg)) *non_constant_args = true; @@ -3229,19 +3243,13 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, ctx->global->put_value (remapped, arg); remapped = DECL_CHAIN (remapped); } - for (; remapped; remapped = TREE_CHAIN (remapped)) - if (DECL_NAME (remapped) == in_charge_identifier) - { - /* FIXME destructors unnecessarily have in-charge parameters - even in classes without vbases, map it to 0 for now. */ - gcc_assert (!CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fun))); - ctx->global->put_value (remapped, integer_zero_node); - } - else - { - gcc_assert (seen_error ()); - *non_constant_p = true; - } + if (remapped) + { + /* We shouldn't have any parms without args, but fail gracefully + in error recovery. */ + gcc_checking_assert (seen_error ()); + *non_constant_p = true; + } /* Add the RESULT_DECL to the values map, too. */ gcc_assert (!DECL_BY_REFERENCE (res)); ctx->global->put_value (res, NULL_TREE); @@ -5799,6 +5807,9 @@ cxx_fold_indirect_ref (const constexpr_ctx *ctx, location_t loc, tree type, more folding opportunities. */ auto canonicalize_obj_off = [] (tree& obj, tree& off) { while (TREE_CODE (obj) == COMPONENT_REF + /* We need to preserve union member accesses so that we can + later properly diagnose accessing the wrong member. */ + && TREE_CODE (TREE_TYPE (TREE_OPERAND (obj, 0))) == RECORD_TYPE && (tree_int_cst_sign_bit (off) || integer_zerop (off))) { tree field = TREE_OPERAND (obj, 1); @@ -7496,9 +7507,19 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, case PARM_DECL: if (lval && !TYPE_REF_P (TREE_TYPE (t))) - /* glvalue use. */; + { + /* glvalue use. */ + if (TREE_ADDRESSABLE (TREE_TYPE (t))) + if (tree v = ctx->global->get_value (t)) + r = v; + } else if (tree v = ctx->global->get_value (t)) - r = v; + { + r = v; + if (TREE_ADDRESSABLE (TREE_TYPE (t))) + r = cxx_eval_constant_expression (ctx, r, vc_prvalue, + non_constant_p, overflow_p); + } else if (lval) /* Defer in case this is only used for its type. */; else if (ctx->global->is_outside_lifetime (t)) diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 1dbb577a38d..5d1bd6ba493 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -289,8 +289,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX]; /* The name of a constructor that does not construct virtual base classes. */ #define base_ctor_identifier cp_global_trees[CPTI_BASE_CTOR_IDENTIFIER] /* The name of a destructor that takes an in-charge parameter to - decide whether or not to destroy virtual base classes and whether - or not to delete the object. */ + decide whether or not to destroy virtual base classes. */ #define dtor_identifier cp_global_trees[CPTI_DTOR_IDENTIFIER] /* The name of a destructor that destroys virtual base classes. */ #define complete_dtor_identifier cp_global_trees[CPTI_COMPLETE_DTOR_IDENTIFIER] @@ -7401,7 +7400,7 @@ inline bool module_exporting_p () extern module_state *get_module (tree name, module_state *parent = NULL, bool partition = false); -extern bool module_may_redeclare (tree decl); +extern bool module_may_redeclare (tree olddecl, tree newdecl = NULL); extern bool module_global_init_needed (); extern bool module_determine_import_inits (); @@ -7417,6 +7416,7 @@ extern unsigned get_importing_module (tree, bool = false) ATTRIBUTE_PURE; extern void set_instantiating_module (tree); extern void set_defining_module (tree); extern void maybe_key_decl (tree ctx, tree decl); +extern void propagate_defining_module (tree decl, tree orig); extern void mangle_module (int m, bool include_partition); extern void mangle_module_fini (); @@ -7447,6 +7447,7 @@ extern bool handle_module_option (unsigned opt, const char *arg, int value); /* In optimize.cc */ extern tree clone_attrs (tree); extern bool maybe_clone_body (tree); +extern void maybe_optimize_cdtor (tree); /* In parser.cc */ extern tree cp_convert_range_for (tree, tree, tree, cp_decomp *, bool, @@ -7649,6 +7650,7 @@ extern bool template_guide_p (const_tree); extern bool builtin_guide_p (const_tree); extern void store_explicit_specifier (tree, tree); extern tree lookup_explicit_specifier (tree); +extern tree lookup_imported_hidden_friend (tree); extern void walk_specializations (bool, void (*)(bool, spec_entry *, void *), diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 65ab64885ff..df855334133 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -1156,6 +1156,16 @@ decls_match (tree newdecl, tree olddecl, bool record_versions /* = true */) tree r2 = fndecl_declared_return_type (olddecl); tree r1 = fndecl_declared_return_type (newdecl); + /* For memchr et al, allow const void* return type (as specified by C++) + when we expect void* (as in C). */ + if (DECL_IS_UNDECLARED_BUILTIN (olddecl) + && DECL_EXTERN_C_P (olddecl) + && !same_type_p (r1, r2) + && TREE_CODE (r1) == POINTER_TYPE + && TREE_CODE (r2) == POINTER_TYPE + && comp_ptr_ttypes (TREE_TYPE (r1), TREE_TYPE (r2))) + r2 = r1; + tree p1 = TYPE_ARG_TYPES (f1); tree p2 = TYPE_ARG_TYPES (f2); @@ -2276,40 +2286,35 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden) if (modules_p () && TREE_CODE (CP_DECL_CONTEXT (olddecl)) == NAMESPACE_DECL - && TREE_CODE (olddecl) != NAMESPACE_DECL - && !hiding) + && TREE_CODE (olddecl) != NAMESPACE_DECL) { - if (!module_may_redeclare (olddecl)) - { - if (DECL_ARTIFICIAL (olddecl)) - error ("declaration %qD conflicts with builtin", newdecl); - else - { - error ("declaration %qD conflicts with import", newdecl); - inform (olddecl_loc, "import declared %q#D here", olddecl); - } - - return error_mark_node; - } + if (!module_may_redeclare (olddecl, newdecl)) + return error_mark_node; - tree not_tmpl = STRIP_TEMPLATE (olddecl); - if (DECL_LANG_SPECIFIC (not_tmpl) - && DECL_MODULE_ATTACH_P (not_tmpl) - /* Typedefs are not entities and so are OK to be redeclared - as exported: see [module.interface]/p6. */ - && TREE_CODE (olddecl) != TYPE_DECL) + if (!hiding) { - if (DECL_MODULE_EXPORT_P (STRIP_TEMPLATE (newdecl)) - && !DECL_MODULE_EXPORT_P (not_tmpl)) + /* The old declaration should match the exportingness of the new + declaration. But hidden friend declarations just keep the + exportingness of the old declaration; see CWG2588. */ + tree not_tmpl = STRIP_TEMPLATE (olddecl); + if (DECL_LANG_SPECIFIC (not_tmpl) + && DECL_MODULE_ATTACH_P (not_tmpl) + /* Typedefs are not entities and so are OK to be redeclared + as exported: see [module.interface]/p6. */ + && TREE_CODE (olddecl) != TYPE_DECL) { - auto_diagnostic_group d; - error ("conflicting exporting for declaration %qD", newdecl); - inform (olddecl_loc, - "previously declared here without exporting"); + if (DECL_MODULE_EXPORT_P (newdecl) + && !DECL_MODULE_EXPORT_P (not_tmpl)) + { + auto_diagnostic_group d; + error ("conflicting exporting for declaration %qD", newdecl); + inform (olddecl_loc, + "previously declared here without exporting"); + } } + else if (DECL_MODULE_EXPORT_P (newdecl)) + DECL_MODULE_EXPORT_P (not_tmpl) = true; } - else if (DECL_MODULE_EXPORT_P (newdecl)) - DECL_MODULE_EXPORT_P (not_tmpl) = true; } /* We have committed to returning OLDDECL at this point. */ @@ -13728,6 +13733,12 @@ grokdeclarator (const cp_declarator *declarator, inform (DECL_SOURCE_LOCATION (xobj_parm), "explicit object parameter declared here"); } + if (unqualified_id + && identifier_p (unqualified_id) + && IDENTIFIER_NEWDEL_OP_P (unqualified_id)) + error_at (DECL_SOURCE_LOCATION (xobj_parm), + "%qD cannot be an explicit object member " + "function", unqualified_id); } } tree pushed_scope = NULL_TREE; @@ -16620,12 +16631,7 @@ xref_tag (enum tag_types tag_code, tree name, { tree decl = TYPE_NAME (t); if (!module_may_redeclare (decl)) - { - auto_diagnostic_group d; - error ("cannot declare %qD in a different module", decl); - inform (DECL_SOURCE_LOCATION (decl), "previously declared here"); - return error_mark_node; - } + return error_mark_node; tree not_tmpl = STRIP_TEMPLATE (decl); if (DECL_LANG_SPECIFIC (not_tmpl) @@ -16973,12 +16979,7 @@ start_enum (tree name, tree enumtype, tree underlying_type, { tree decl = TYPE_NAME (enumtype); if (!module_may_redeclare (decl)) - { - auto_diagnostic_group d; - error ("cannot declare %qD in different module", decl); - inform (DECL_SOURCE_LOCATION (decl), "previously declared here"); - enumtype = error_mark_node; - } + enumtype = error_mark_node; else set_instantiating_module (decl); } diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc index 1339f210dde..b8dc55b51d9 100644 --- a/gcc/cp/decl2.cc +++ b/gcc/cp/decl2.cc @@ -275,11 +275,8 @@ build_artificial_parm (tree fn, tree name, tree type) return parm; } -/* Constructors for types with virtual baseclasses need an "in-charge" flag - saying whether this constructor is responsible for initialization of - virtual baseclasses or not. All destructors also need this "in-charge" - flag, which additionally determines whether or not the destructor should - free the memory for the object. +/* 'structors for types with virtual baseclasses need an "in-charge" flag + saying whether this function is responsible for virtual baseclasses or not. This function adds the "in-charge" flag to member function FN if appropriate. It is called from grokclassfn and tsubst. @@ -302,10 +299,9 @@ maybe_retrofit_in_chrg (tree fn) if (processing_template_decl) return; - /* We don't need an in-charge parameter for constructors that don't + /* We don't need an in-charge parameter for 'structors that don't have virtual bases. */ - if (DECL_CONSTRUCTOR_P (fn) - && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn))) + if (!CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn))) return; arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); @@ -3568,6 +3564,9 @@ import_export_decl (tree decl) } DECL_INTERFACE_KNOWN (decl) = 1; + + if (DECL_CLONED_FUNCTION_P (decl)) + maybe_optimize_cdtor (decl); } /* Return an expression that performs the destruction of DECL, which diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc index 7074845154e..37987ccb570 100644 --- a/gcc/cp/error.cc +++ b/gcc/cp/error.cc @@ -3793,7 +3793,9 @@ print_instantiation_partial_context_line (diagnostic_context *context, : _("required from here\n")); } gcc_rich_location rich_loc (loc); + char *saved_prefix = pp_take_prefix (context->printer); diagnostic_show_locus (context, &rich_loc, DK_NOTE); + pp_set_prefix (context->printer, saved_prefix); } /* Same as print_instantiation_full_context but less verbose. */ diff --git a/gcc/cp/method.cc b/gcc/cp/method.cc index 98c10e6a8b5..08a3d34fb01 100644 --- a/gcc/cp/method.cc +++ b/gcc/cp/method.cc @@ -3307,8 +3307,11 @@ implicitly_declare_fn (special_function_kind kind, tree type, /* Copy constexpr from the inherited constructor even if the inheriting constructor doesn't satisfy the requirements. */ constexpr_p = DECL_DECLARED_CONSTEXPR_P (inherited_ctor); + tree inherited_ctor_fn = STRIP_TEMPLATE (inherited_ctor); /* Also copy any attributes. */ - DECL_ATTRIBUTES (fn) = clone_attrs (DECL_ATTRIBUTES (inherited_ctor)); + DECL_ATTRIBUTES (fn) = clone_attrs (DECL_ATTRIBUTES (inherited_ctor_fn)); + DECL_DISREGARD_INLINE_LIMITS (fn) + = DECL_DISREGARD_INLINE_LIMITS (inherited_ctor_fn); } /* Add the "this" parameter. */ diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index d94d8ff4df9..fac0301d80e 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -2727,6 +2727,12 @@ vec<tree, va_heap, vl_embed> *post_load_decls; typedef hash_map<tree, auto_vec<tree>> keyed_map_t; static keyed_map_t *keyed_table; +/* Instantiations of temploid friends imported from another module + need to be attached to the same module as the temploid. This maps + these decls to the temploid they are instantiated them, as there is + no other easy way to get this information. */ +static hash_map<tree, tree> *imported_temploid_friends; + /********************************************************************/ /* Tree streaming. The tree streaming is very specific to the tree structures themselves. A tag indicates the kind of tree being @@ -7820,6 +7826,12 @@ trees_out::decl_value (tree decl, depset *dep) && DECL_MODULE_ATTACH_P (not_tmpl)) is_attached = true; + /* But don't consider imported temploid friends as attached, + since importers will need to merge this decl even if it was + attached to a different module. */ + if (imported_temploid_friends->get (decl)) + is_attached = false; + bits.b (is_attached); } bits.b (dep && dep->has_defn ()); @@ -7997,6 +8009,15 @@ trees_out::decl_value (tree decl, depset *dep) } } + if (TREE_CODE (inner) == FUNCTION_DECL + || TREE_CODE (inner) == TYPE_DECL) + { + /* Write imported temploid friends so that importers can reconstruct + this information on stream-in. */ + tree* slot = imported_temploid_friends->get (decl); + tree_node (slot ? *slot : NULL_TREE); + } + bool is_typedef = false; if (!type && TREE_CODE (inner) == TYPE_DECL) { @@ -8303,6 +8324,11 @@ trees_in::decl_value () } } + if (TREE_CODE (inner) == FUNCTION_DECL + || TREE_CODE (inner) == TYPE_DECL) + if (tree owner = tree_node ()) + imported_temploid_friends->put (decl, owner); + /* Regular typedefs will have a NULL TREE_TYPE at this point. */ unsigned tdef_flags = 0; bool is_typedef = false; @@ -11537,6 +11563,15 @@ trees_in::is_matching_decl (tree existing, tree decl, bool is_typedef) else if (!DEFERRED_NOEXCEPT_SPEC_P (d_spec) && !comp_except_specs (d_spec, e_spec, ce_type)) goto mismatch; + + /* Similarly if EXISTING has an undeduced return type, but DECL's + is already deduced. */ + if (undeduced_auto_decl (existing) && !undeduced_auto_decl (decl)) + { + dump (dumper::MERGE) + && dump ("Propagating deduced return type to %N", existing); + TREE_TYPE (existing) = change_return_type (TREE_TYPE (d_type), e_type); + } } else if (is_typedef) { @@ -12489,6 +12524,8 @@ trees_in::read_class_def (tree defn, tree maybe_template) for (; friend_classes; friend_classes = TREE_CHAIN (friend_classes)) { tree f = TREE_VALUE (friend_classes); + if (TREE_CODE (f) == TEMPLATE_DECL) + f = TREE_TYPE (f); if (CLASS_TYPE_P (f)) { @@ -13113,10 +13150,14 @@ depset::hash::add_binding_entity (tree decl, WMB_Flags flags, void *data_) /* Ignore NTTP objects. */ return false; + bool unscoped_enum_const_p = false; if (!(flags & WMB_Using) && CP_DECL_CONTEXT (decl) != data->ns) { /* A using that lost its wrapper or an unscoped enum constant. */ + /* FIXME: Ensure that unscoped enums are differentiated from + 'using enum' declarations when PR c++/114683 is fixed. */ + unscoped_enum_const_p = (TREE_CODE (decl) == CONST_DECL); flags = WMB_Flags (flags | WMB_Using); if (DECL_MODULE_EXPORT_P (TREE_CODE (decl) == CONST_DECL ? TYPE_NAME (TREE_TYPE (decl)) @@ -13177,6 +13218,8 @@ depset::hash::add_binding_entity (tree decl, WMB_Flags flags, void *data_) if (flags & WMB_Using) { decl = ovl_make (decl, NULL_TREE); + if (!unscoped_enum_const_p) + OVL_USING_P (decl) = true; if (flags & WMB_Export) OVL_EXPORT_P (decl) = true; } @@ -18930,6 +18973,12 @@ get_originating_module_decl (tree decl) && DECL_UNINSTANTIATED_TEMPLATE_FRIEND_P (decl)) decl = TYPE_NAME (DECL_CHAIN (decl)); + /* An imported temploid friend is attached to the same module the + befriending class was. */ + if (imported_temploid_friends) + if (tree *slot = imported_temploid_friends->get (decl)) + decl = *slot; + int use; if (tree ti = node_template_info (decl, use)) { @@ -18992,11 +19041,15 @@ get_importing_module (tree decl, bool flexible) return module->mod; } -/* Is it permissible to redeclare DECL. */ +/* Is it permissible to redeclare OLDDECL with NEWDECL. + + If NEWDECL is NULL, assumes that OLDDECL will be redeclared using + the current scope's module and attachment. */ bool -module_may_redeclare (tree decl) +module_may_redeclare (tree olddecl, tree newdecl) { + tree decl = olddecl; for (;;) { tree ctx = CP_DECL_CONTEXT (decl); @@ -19010,58 +19063,94 @@ module_may_redeclare (tree decl) decl = TYPE_NAME (ctx); } - tree not_tmpl = STRIP_TEMPLATE (decl); - int use_tpl = 0; - if (node_template_info (not_tmpl, use_tpl) && use_tpl) + if (node_template_info (STRIP_TEMPLATE (decl), use_tpl) && use_tpl) // Specializations of any kind can be redeclared anywhere. // FIXME: Should we be checking this in more places on the scope chain? return true; - if (!DECL_LANG_SPECIFIC (not_tmpl) || !DECL_MODULE_ATTACH_P (not_tmpl)) - // Decl is attached to global module. Current scope needs to be too. - return !module_attach_p (); + module_state *old_mod = (*modules)[0]; + module_state *new_mod = old_mod; - module_state *me = (*modules)[0]; - module_state *them = me; + tree old_origin = get_originating_module_decl (decl); + tree old_inner = STRIP_TEMPLATE (old_origin); + bool olddecl_attached_p = (DECL_LANG_SPECIFIC (old_inner) + && DECL_MODULE_ATTACH_P (old_inner)); + if (DECL_LANG_SPECIFIC (old_inner) && DECL_MODULE_IMPORT_P (old_inner)) + { + unsigned index = import_entity_index (old_origin); + old_mod = import_entity_module (index); + } - if (DECL_LANG_SPECIFIC (not_tmpl) && DECL_MODULE_IMPORT_P (not_tmpl)) + bool newdecl_attached_p = module_attach_p (); + if (newdecl) { - /* We can be given the TEMPLATE_RESULT. We want the - TEMPLATE_DECL. */ - int use_tpl = -1; - if (tree ti = node_template_info (decl, use_tpl)) + tree new_origin = get_originating_module_decl (newdecl); + tree new_inner = STRIP_TEMPLATE (new_origin); + newdecl_attached_p = (DECL_LANG_SPECIFIC (new_inner) + && DECL_MODULE_ATTACH_P (new_inner)); + if (DECL_LANG_SPECIFIC (new_inner) && DECL_MODULE_IMPORT_P (new_inner)) { - tree tmpl = TI_TEMPLATE (ti); - if (use_tpl == 2) - { - /* A partial specialization. Find that specialization's - template_decl. */ - for (tree list = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); - list; list = TREE_CHAIN (list)) - if (DECL_TEMPLATE_RESULT (TREE_VALUE (list)) == decl) - { - decl = TREE_VALUE (list); - break; - } - } - else if (DECL_TEMPLATE_RESULT (tmpl) == decl) - decl = tmpl; + unsigned index = import_entity_index (new_origin); + new_mod = import_entity_module (index); } - unsigned index = import_entity_index (decl); - them = import_entity_module (index); } - // Decl is attached to named module. Current scope needs to be - // attaching to the same module. - if (!module_attach_p ()) - return false; + /* Module attachment needs to match. */ + if (olddecl_attached_p == newdecl_attached_p) + { + if (!olddecl_attached_p) + /* Both are GM entities, OK. */ + return true; - // Both attached to named module. - if (me == them) - return true; + if (new_mod == old_mod + || (new_mod && get_primary (new_mod) == get_primary (old_mod))) + /* Both attached to same named module, OK. */ + return true; + } + + /* Attached to different modules, error. */ + decl = newdecl ? newdecl : olddecl; + location_t loc = newdecl ? DECL_SOURCE_LOCATION (newdecl) : input_location; + if (DECL_IS_UNDECLARED_BUILTIN (olddecl)) + error_at (loc, "declaration %qD conflicts with builtin", decl); + else if (DECL_LANG_SPECIFIC (old_inner) && DECL_MODULE_IMPORT_P (old_inner)) + { + auto_diagnostic_group d; + if (newdecl_attached_p) + error_at (loc, "redeclaring %qD in module %qs conflicts with import", + decl, new_mod->get_flatname ()); + else + error_at (loc, "redeclaring %qD in global module conflicts with import", + decl); - return me && get_primary (them) == get_primary (me); + if (olddecl_attached_p) + inform (DECL_SOURCE_LOCATION (olddecl), + "import declared attached to module %qs", + old_mod->get_flatname ()); + else + inform (DECL_SOURCE_LOCATION (olddecl), + "import declared in global module"); + } + else + { + auto_diagnostic_group d; + if (newdecl_attached_p) + error_at (loc, "conflicting declaration of %qD in module %qs", + decl, new_mod->get_flatname ()); + else + error_at (loc, "conflicting declaration of %qD in global module", + decl); + + if (olddecl_attached_p) + inform (DECL_SOURCE_LOCATION (olddecl), + "previously declared in module %qs", + old_mod->get_flatname ()); + else + inform (DECL_SOURCE_LOCATION (olddecl), + "previously declared in global module"); + } + return false; } /* DECL is being created by this TU. Record it came from here. We @@ -19198,6 +19287,34 @@ maybe_key_decl (tree ctx, tree decl) vec.safe_push (decl); } +/* DECL is an instantiated friend that should be attached to the same + module that ORIG is. */ + +void +propagate_defining_module (tree decl, tree orig) +{ + if (!modules_p ()) + return; + + tree not_tmpl = STRIP_TEMPLATE (orig); + if (DECL_LANG_SPECIFIC (not_tmpl) && DECL_MODULE_ATTACH_P (not_tmpl)) + { + tree inner = STRIP_TEMPLATE (decl); + retrofit_lang_decl (inner); + DECL_MODULE_ATTACH_P (inner) = true; + } + + if (DECL_LANG_SPECIFIC (not_tmpl) && DECL_MODULE_IMPORT_P (not_tmpl)) + { + bool exists = imported_temploid_friends->put (decl, orig); + + /* We should only be called if lookup for an existing decl + failed, in which case there shouldn't already be an entry + in the map. */ + gcc_assert (!exists); + } +} + /* Create the flat name string. It is simplest to have it handy. */ void @@ -20411,6 +20528,8 @@ init_modules (cpp_reader *reader) pending_table = new pending_map_t (EXPERIMENT (1, 400)); entity_map = new entity_map_t (EXPERIMENT (1, 400)); vec_safe_reserve (entity_ary, EXPERIMENT (1, 400)); + imported_temploid_friends + = new hash_map<tree,tree> (EXPERIMENT (1, 400)); } #if CHECKING_P diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc index 7af7f00e34c..78f08acffaa 100644 --- a/gcc/cp/name-lookup.cc +++ b/gcc/cp/name-lookup.cc @@ -4131,6 +4131,22 @@ mergeable_namespace_slots (tree ns, tree name, bool is_attached, tree *vec) return vslot; } +/* Retrieve the bindings for an existing mergeable entity in namespace + NS slot NAME. Returns NULL if no such bindings exists. */ + +static tree +get_mergeable_namespace_binding (tree ns, tree name, bool is_attached) +{ + tree *mslot = find_namespace_slot (ns, name, false); + if (!mslot || !*mslot || TREE_CODE (*mslot) != BINDING_VECTOR) + return NULL_TREE; + + tree *vslot = get_fixed_binding_slot + (mslot, name, is_attached ? BINDING_SLOT_PARTITION : BINDING_SLOT_GLOBAL, + false); + return vslot ? *vslot : NULL_TREE; +} + /* DECL is a new mergeable namespace-scope decl. Add it to the mergeable entities on GSLOT. */ @@ -4274,19 +4290,19 @@ walk_module_binding (tree binding, bitmap partitions, count += callback (btype, flags, data); } - bool hidden = STAT_DECL_HIDDEN_P (bind); + bool part_hidden = STAT_DECL_HIDDEN_P (bind); for (ovl_iterator iter (MAYBE_STAT_DECL (STAT_DECL (bind))); iter; ++iter) { if (iter.hidden_p ()) - hidden = true; + part_hidden = true; gcc_checking_assert - (!(hidden && DECL_IS_UNDECLARED_BUILTIN (*iter))); + (!(part_hidden && DECL_IS_UNDECLARED_BUILTIN (*iter))); WMB_Flags flags = WMB_None; if (maybe_dups) flags = WMB_Flags (flags | WMB_Dups); - if (decl_hidden) + if (part_hidden) flags = WMB_Flags (flags | WMB_Hidden); if (iter.using_p ()) { @@ -4295,7 +4311,7 @@ walk_module_binding (tree binding, bitmap partitions, flags = WMB_Flags (flags | WMB_Export); } count += callback (*iter, flags, data); - hidden = false; + part_hidden = false; } } } @@ -4453,6 +4469,43 @@ push_local_binding (tree id, tree decl, bool is_using) add_decl_to_level (b, decl); } +/* Lookup the FRIEND_TMPL within all merged module imports. Used to dedup + instantiations of temploid hidden friends from imported modules. */ + +tree +lookup_imported_hidden_friend (tree friend_tmpl) +{ + /* For a class-scope friend class it should have been found by regular + name lookup. Otherwise we're looking in the current namespace. */ + gcc_checking_assert (CP_DECL_CONTEXT (friend_tmpl) == current_namespace); + + tree inner = DECL_TEMPLATE_RESULT (friend_tmpl); + if (!DECL_LANG_SPECIFIC (inner) + || !DECL_MODULE_IMPORT_P (inner)) + return NULL_TREE; + + /* Imported temploid friends are not considered as attached to this + module for merging purposes. */ + tree bind = get_mergeable_namespace_binding (current_namespace, + DECL_NAME (inner), false); + if (!bind) + return NULL_TREE; + + /* We're only interested in declarations coming from the same module + of the friend class we're attempting to instantiate. */ + int m = get_originating_module (friend_tmpl); + gcc_assert (m != 0); + + /* There should be at most one class template from the module we're + looking for, return it. */ + for (ovl_iterator iter (bind); iter; ++iter) + if (DECL_CLASS_TEMPLATE_P (*iter) + && get_originating_module (*iter) == m) + return *iter; + + return NULL_TREE; +} + /* true means unconditionally make a BLOCK for the next level pushed. */ @@ -9090,8 +9143,14 @@ push_namespace (tree name, bool make_inline) { /* A public namespace is exported only if explicitly marked, or it contains exported entities. */ - if (TREE_PUBLIC (ns) && module_exporting_p ()) - DECL_MODULE_EXPORT_P (ns) = true; + if (module_exporting_p ()) + { + if (TREE_PUBLIC (ns)) + DECL_MODULE_EXPORT_P (ns) = true; + else if (!header_module_p ()) + error_at (input_location, + "exporting namespace with internal linkage"); + } if (module_purview_p ()) DECL_MODULE_PURVIEW_P (ns) = true; diff --git a/gcc/cp/optimize.cc b/gcc/cp/optimize.cc index ff4fb5be5bd..7147f5e00f1 100644 --- a/gcc/cp/optimize.cc +++ b/gcc/cp/optimize.cc @@ -723,3 +723,58 @@ maybe_clone_body (tree fn) /* We don't need to process the original function any further. */ return 1; } + +/* If maybe_clone_body is called while the cdtor is still tentative, + DECL_ONE_ONLY will be false and so will be can_alias_cdtor (fn). + In that case we wouldn't try to optimize using an alias and instead + would emit separate base and complete cdtor. The following function + attempts to still optimize that case when we import_export_decl + is called first time on one of the clones. */ + +void +maybe_optimize_cdtor (tree orig_decl) +{ + tree fns[3]; + tree fn = DECL_CLONED_FUNCTION (orig_decl); + gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (fn)); + if (DECL_INTERFACE_KNOWN (fn) + || !TREE_ASM_WRITTEN (fn) + || !DECL_ONE_ONLY (orig_decl) + || symtab->global_info_ready) + return; + + populate_clone_array (fn, fns); + + if (!fns[0] || !fns[1]) + return; + for (int i = 2 - !fns[2]; i >= 0; --i) + if (fns[i] != orig_decl && DECL_INTERFACE_KNOWN (fns[i])) + return; + DECL_INTERFACE_KNOWN (fn) = 1; + comdat_linkage (fn); + if (!can_alias_cdtor (fn)) + return; + /* For comdat base and complete cdtors put them into the same, + *[CD]5* comdat group instead of *[CD][12]*. */ + auto n0 = cgraph_node::get_create (fns[0]); + auto n1 = cgraph_node::get_create (fns[1]); + auto n2 = fns[2] ? cgraph_node::get_create (fns[1]) : NULL; + if (n0->lowered || n1->lowered || (n2 && n2->lowered)) + return; + import_export_decl (fns[0]); + n1->definition = false; + if (!n0->create_same_body_alias (fns[1], fns[0])) + return; + + tree comdat_group = cdtor_comdat_group (fns[1], fns[0]); + n1 = cgraph_node::get (fns[1]); + n0->set_comdat_group (comdat_group); + if (n1->same_comdat_group) + n1->remove_from_same_comdat_group (); + n1->add_to_same_comdat_group (n0); + if (fns[2]) + n2->add_to_same_comdat_group (n0); + import_export_decl (fns[1]); + /* Remove the body now that it is an alias. */ + release_function_body (fns[1]); +} diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 50d3ad35b61..a2bc6f69000 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -560,6 +560,8 @@ cp_debug_parser (FILE *file, cp_parser *parser) & THIS_FORBIDDEN)); cp_debug_print_flag (file, "In unbraced linkage specification", parser->in_unbraced_linkage_specification_p); + cp_debug_print_flag (file, "In unbraced export declaration", + parser->in_unbraced_export_declaration_p); cp_debug_print_flag (file, "Parsing a declarator", parser->in_declarator_p); cp_debug_print_flag (file, "In template argument list", @@ -4425,6 +4427,9 @@ cp_parser_new (cp_lexer *lexer) /* We are not processing an `extern "C"' declaration. */ parser->in_unbraced_linkage_specification_p = false; + /* We aren't parsing an export-declaration. */ + parser->in_unbraced_export_declaration_p = false; + /* We are not processing a declarator. */ parser->in_declarator_p = false; @@ -15249,10 +15254,6 @@ cp_parser_import_declaration (cp_parser *parser, module_parse mp_state, goto skip_eol; cp_parser_require_pragma_eol (parser, token); - if (parser->in_unbraced_linkage_specification_p) - error_at (token->location, "import cannot appear directly in" - " a linkage-specification"); - if (mp_state == MP_PURVIEW_IMPORTS || mp_state == MP_PRIVATE_IMPORTS) { /* Module-purview imports must not be from source inclusion @@ -15273,7 +15274,7 @@ cp_parser_import_declaration (cp_parser *parser, module_parse mp_state, /* export-declaration. - export declaration + export name-declaration export { declaration-seq-opt } */ static void @@ -15315,7 +15316,13 @@ cp_parser_module_export (cp_parser *parser) || cp_lexer_next_token_is_keyword (parser->lexer, RID__EXPORT)) error_at (token->location, "%<export%> not part of following" " module-directive"); + + bool saved_in_unbraced_export_declaration_p + = parser->in_unbraced_export_declaration_p; + parser->in_unbraced_export_declaration_p = true; cp_parser_declaration (parser, NULL_TREE); + parser->in_unbraced_export_declaration_p + = saved_in_unbraced_export_declaration_p; } module_kind = mk; @@ -15346,27 +15353,29 @@ cp_parser_declaration_seq_opt (cp_parser* parser) } } -/* Parse a declaration. +/* Parse a declaration. The distinction between name-declaration + and special-declaration is only since C++20. declaration: + name-declaration + special-declaration + + name-declaration: block-declaration + nodeclspec-function-declaration function-definition template-declaration - explicit-instantiation - explicit-specialization + deduction-guide (C++17) linkage-specification namespace-definition + empty-declaration + attribute-declaration + module-import-declaration (modules) - C++17: - deduction-guide - - modules: - (all these are only allowed at the outermost level, check - that semantically, for better diagnostics) - module-declaration - module-export-declaration - module-import-declaration - export-declaration + special-declaration: + explicit-instantiation + explicit-specialization + export-declaration (modules) GNU extension: @@ -15389,6 +15398,13 @@ cp_parser_declaration (cp_parser* parser, tree prefix_attrs) return; } + /* P2615: Determine if we're parsing a name-declaration specifically, + or if special-declarations are OK too. */ + bool require_name_decl_p + = (parser->in_unbraced_export_declaration_p + || (parser->in_unbraced_linkage_specification_p + && cxx_dialect >= cxx20)); + /* Try to figure out what kind of declaration is present. */ cp_token *token1 = cp_lexer_peek_token (parser->lexer); cp_token *token2 = (token1->type == CPP_EOF @@ -15496,13 +15512,30 @@ cp_parser_declaration (cp_parser* parser, tree prefix_attrs) /* `template <>' indicates a template specialization. */ if (token2->type == CPP_LESS && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER) - cp_parser_explicit_specialization (parser); + { + if (require_name_decl_p) + { + auto_diagnostic_group d; + cp_token *token3 = cp_lexer_peek_nth_token (parser->lexer, 3); + location_t loc = make_location (token1, token1, token3); + error_at (loc, "explicit specializations are not permitted here"); + if (parser->in_unbraced_export_declaration_p) + inform (loc, "a specialization is always exported alongside " + "its primary template"); + } + cp_parser_explicit_specialization (parser); + } /* `template <' indicates a template declaration. */ else if (token2->type == CPP_LESS) cp_parser_template_declaration (parser, /*member_p=*/false); /* Anything else must be an explicit instantiation. */ else - cp_parser_explicit_instantiation (parser); + { + if (require_name_decl_p) + error_at (token1->location, + "explicit instantiations are not permitted here"); + cp_parser_explicit_instantiation (parser); + } } /* If the next token is `export', it's new-style modules or old-style template. */ @@ -15511,7 +15544,14 @@ cp_parser_declaration (cp_parser* parser, tree prefix_attrs) if (!modules_p ()) cp_parser_template_declaration (parser, /*member_p=*/false); else - cp_parser_module_export (parser); + { + /* We check for nested exports in cp_parser_module_export. */ + if (require_name_decl_p + && !parser->in_unbraced_export_declaration_p) + error_at (token1->location, + "export-declarations are not permitted here"); + cp_parser_module_export (parser); + } } else if (cp_token_is_module_directive (token1)) { @@ -16075,13 +16115,37 @@ cp_parser_decomposition_declaration (cp_parser *parser, /* Parse the identifier-list. */ auto_vec<cp_expr, 10> v; + bool attr_diagnosed = false; + int first_attr = -1; + unsigned int cnt = 0; if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE)) while (true) { cp_expr e = cp_parser_identifier (parser); if (e.get_value () == error_mark_node) break; + tree attr = NULL_TREE; + if (cp_next_tokens_can_be_std_attribute_p (parser)) + { + if (cxx_dialect >= cxx17 && cxx_dialect < cxx26 && !attr_diagnosed) + { + pedwarn (cp_lexer_peek_token (parser->lexer)->location, + OPT_Wc__26_extensions, + "structured bindings with attributed identifiers " + "only available with %<-std=c++2c%> or " + "%<-std=gnu++2c%>"); + attr_diagnosed = true; + } + attr = cp_parser_std_attribute_spec_seq (parser); + if (attr == error_mark_node) + attr = NULL_TREE; + if (attr && first_attr == -1) + first_attr = v.length (); + } v.safe_push (e); + ++cnt; + if (first_attr != -1) + v.safe_push (attr); if (!cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) break; cp_lexer_consume_token (parser->lexer); @@ -16139,8 +16203,11 @@ cp_parser_decomposition_declaration (cp_parser *parser, declarator->id_loc = e.get_location (); } tree elt_pushed_scope; + tree attr = NULL_TREE; + if (first_attr != -1 && i >= (unsigned) first_attr) + attr = v[++i].get_value (); tree decl2 = start_decl (declarator, &decl_specs, SD_DECOMPOSITION, - NULL_TREE, NULL_TREE, &elt_pushed_scope); + NULL_TREE, attr, &elt_pushed_scope); if (decl2 == error_mark_node) decl = error_mark_node; else if (decl != error_mark_node && DECL_CHAIN (decl2) != prev) @@ -16183,7 +16250,7 @@ cp_parser_decomposition_declaration (cp_parser *parser, if (decl != error_mark_node) { - cp_decomp decomp = { prev, v.length () }; + cp_decomp decomp = { prev, cnt }; cp_finish_decl (decl, initializer, non_constant_p, NULL_TREE, (is_direct_init ? LOOKUP_NORMAL : LOOKUP_IMPLICIT), &decomp); @@ -16193,7 +16260,7 @@ cp_parser_decomposition_declaration (cp_parser *parser, else if (decl != error_mark_node) { *maybe_range_for_decl = prev; - cp_decomp decomp = { prev, v.length () }; + cp_decomp decomp = { prev, cnt }; /* Ensure DECL_VALUE_EXPR is created for all the decls but the underlying DECL. */ cp_finish_decomp (decl, &decomp); @@ -16809,7 +16876,7 @@ cp_parser_function_specifier_opt (cp_parser* parser, linkage-specification: extern string-literal { declaration-seq [opt] } - extern string-literal declaration */ + extern string-literal name-declaration */ static void cp_parser_linkage_specification (cp_parser* parser, tree prefix_attr) @@ -22406,7 +22473,7 @@ cp_parser_using_declaration (cp_parser* parser, if (access_declaration_p && errorcount == oldcount) warning_at (diag_token->location, OPT_Wdeprecated, "access declarations are deprecated " - "in favour of using-declarations; " + "in favor of using-declarations; " "suggestion: add the %<using%> keyword"); return true; @@ -25780,8 +25847,9 @@ cp_parser_parameter_declaration (cp_parser *parser, } if (xobj_param_p - && (declarator ? declarator->parameter_pack_p - : PACK_EXPANSION_P (decl_specifiers.type))) + && ((declarator && declarator->parameter_pack_p) + || (decl_specifiers.type + && PACK_EXPANSION_P (decl_specifiers.type)))) { location_t xobj_param = make_location (decl_specifiers.locations[ds_this], @@ -26767,6 +26835,7 @@ cp_parser_class_specifier (cp_parser* parser) unsigned char in_statement; bool in_switch_statement_p; bool saved_in_unbraced_linkage_specification_p; + bool saved_in_unbraced_export_declaration_p; tree old_scope = NULL_TREE; tree scope = NULL_TREE; cp_token *closing_brace; @@ -26818,6 +26887,10 @@ cp_parser_class_specifier (cp_parser* parser) saved_in_unbraced_linkage_specification_p = parser->in_unbraced_linkage_specification_p; parser->in_unbraced_linkage_specification_p = false; + /* Or in an export-declaration. */ + saved_in_unbraced_export_declaration_p + = parser->in_unbraced_export_declaration_p; + parser->in_unbraced_export_declaration_p = false; /* 'this' from an enclosing non-static member function is unavailable. */ tree saved_ccp = current_class_ptr; tree saved_ccr = current_class_ref; @@ -27200,6 +27273,8 @@ cp_parser_class_specifier (cp_parser* parser) = saved_num_template_parameter_lists; parser->in_unbraced_linkage_specification_p = saved_in_unbraced_linkage_specification_p; + parser->in_unbraced_export_declaration_p + = saved_in_unbraced_export_declaration_p; current_class_ptr = saved_ccp; current_class_ref = saved_ccr; @@ -27487,6 +27562,20 @@ cp_parser_class_head (cp_parser* parser, permerror (nested_name_specifier_token_start->location, "extra qualification not allowed"); } + /* The name-declaration of an export-declaration shall not declare + a partial specialization. */ + if (template_id_p + && parser->in_unbraced_export_declaration_p + && !processing_specialization + && !processing_explicit_instantiation) + { + auto_diagnostic_group d; + location_t loc = type_start_token->location; + error_at (loc, "declaration of partial specialization in unbraced " + "export-declaration"); + inform (loc, "a specialization is always exported alongside its " + "primary template"); + } /* An explicit-specialization must be preceded by "template <>". If it is not, try to recover gracefully. */ if (at_namespace_scope_p () diff --git a/gcc/cp/parser.h b/gcc/cp/parser.h index 373e78f3ea4..09b356e5e73 100644 --- a/gcc/cp/parser.h +++ b/gcc/cp/parser.h @@ -312,9 +312,13 @@ struct GTY(()) cp_parser { /* TRUE if the declaration we are parsing is part of a linkage-specification of the form `extern string-literal - declaration'. */ + name-declaration'. */ bool in_unbraced_linkage_specification_p; + /* TRUE if the declaration we are parsing is part of an + export-declaration of the form 'export name-declaration'. */ + bool in_unbraced_export_declaration_p; + /* TRUE if we are presently parsing a declarator, after the direct-declarator. */ bool in_declarator_p; diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 3b2106dd3f6..1c3eef60c06 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -11512,6 +11512,10 @@ tsubst_friend_function (tree decl, tree args) new_friend_result_template_info = DECL_TEMPLATE_INFO (not_tmpl); } + /* We need to propagate module attachment for the new friend from the + owner of this template. */ + propagate_defining_module (new_friend, decl); + /* Inside pushdecl_namespace_level, we will push into the current namespace. However, the friend function should go into the namespace of the template. */ @@ -11715,6 +11719,12 @@ tsubst_friend_class (tree friend_tmpl, tree args) tmpl = lookup_name (DECL_NAME (friend_tmpl), LOOK_where::CLASS_NAMESPACE, LOOK_want::NORMAL | LOOK_want::HIDDEN_FRIEND); + if (!tmpl) + /* If we didn't find by name lookup, the type may still exist but as a + 'hidden' import; we should check for this too to avoid accidentally + instantiating a duplicate. */ + tmpl = lookup_imported_hidden_friend (friend_tmpl); + if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl)) { /* The friend template has already been declared. Just @@ -11723,6 +11733,12 @@ tsubst_friend_class (tree friend_tmpl, tree args) of course. We only need the innermost template parameters because that is all that redeclare_class_template will look at. */ + + if (modules_p ()) + /* Check that the existing declaration's module attachment is + compatible with the attachment of the friend template. */ + module_may_redeclare (tmpl, friend_tmpl); + if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl)) > TMPL_ARGS_DEPTH (args)) { @@ -11751,9 +11767,16 @@ tsubst_friend_class (tree friend_tmpl, tree args) if (tmpl != error_mark_node) { /* The new TMPL is not an instantiation of anything, so we - forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE + forget its origins. It is also not a specialization of + anything. We don't reset CLASSTYPE_TI_TEMPLATE for the new type because that is supposed to be the corresponding template decl, i.e., TMPL. */ + spec_entry elt; + elt.tmpl = friend_tmpl; + elt.args = CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)); + elt.spec = TREE_TYPE (tmpl); + type_specializations->remove_elt (&elt); + DECL_USE_TEMPLATE (tmpl) = 0; DECL_TEMPLATE_INFO (tmpl) = NULL_TREE; CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0; @@ -11772,6 +11795,10 @@ tsubst_friend_class (tree friend_tmpl, tree args) args, tf_warning_or_error); } + /* We need to propagate the attachment of the original template to the + newly instantiated template type. */ + propagate_defining_module (tmpl, friend_tmpl); + /* Inject this template into the enclosing namspace scope. */ tmpl = pushdecl_namespace_level (tmpl, /*hiding=*/true); } diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 02c7c1bf5a4..2dde65a970b 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -3777,11 +3777,7 @@ begin_class_definition (tree t) if (modules_p ()) { if (!module_may_redeclare (TYPE_NAME (t))) - { - error ("cannot declare %qD in a different module", TYPE_NAME (t)); - inform (DECL_SOURCE_LOCATION (TYPE_NAME (t)), "declared here"); - return error_mark_node; - } + return error_mark_node; set_instantiating_module (TYPE_NAME (t)); set_defining_module (TYPE_NAME (t)); } diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index e5a52dc2b39..a25f8622651 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -5501,6 +5501,7 @@ cp_build_binary_op (const op_location_t &location, if (!TYPE_P (type1)) type1 = TREE_TYPE (type1); if (type0 + && type1 && INDIRECT_TYPE_P (type0) && same_type_p (TREE_TYPE (type0), type1)) { diff --git a/gcc/d/ChangeLog b/gcc/d/ChangeLog index e096154f80f..98d94d4338d 100644 --- a/gcc/d/ChangeLog +++ b/gcc/d/ChangeLog @@ -1,3 +1,10 @@ +2024-04-19 Iain Buclaw <ibuclaw@gdcproject.org> + + PR d/111650 + * decl.cc (get_fndecl_arguments): Move generation of frame type to ... + (DeclVisitor::visit (FuncDeclaration *)): ... here, after the call to + build_closure. + 2024-04-06 Iain Buclaw <ibuclaw@gdcproject.org> * dmd/MERGE: Merge upstream dmd b65767825f. diff --git a/gcc/d/decl.cc b/gcc/d/decl.cc index 3b7627d3dfa..0a87c85ae2e 100644 --- a/gcc/d/decl.cc +++ b/gcc/d/decl.cc @@ -163,16 +163,6 @@ get_fndecl_arguments (FuncDeclaration *decl) tree parm_decl = get_symbol_decl (decl->vthis); DECL_ARTIFICIAL (parm_decl) = 1; TREE_READONLY (parm_decl) = 1; - - if (decl->vthis->type == Type::tvoidptr) - { - /* Replace generic pointer with back-end closure type - (this wins for gdb). */ - tree frame_type = FRAMEINFO_TYPE (get_frameinfo (decl)); - gcc_assert (frame_type != NULL_TREE); - TREE_TYPE (parm_decl) = build_pointer_type (frame_type); - } - param_list = chainon (param_list, parm_decl); } @@ -1072,6 +1062,16 @@ public: /* May change cfun->static_chain. */ build_closure (d); + /* Replace generic pointer with back-end closure type + (this wins for gdb). */ + if (d->vthis && d->vthis->type == Type::tvoidptr) + { + tree frame_type = FRAMEINFO_TYPE (get_frameinfo (d)); + gcc_assert (frame_type != NULL_TREE); + tree parm_decl = get_symbol_decl (d->vthis); + TREE_TYPE (parm_decl) = build_pointer_type (frame_type); + } + if (d->vresult) declare_local_var (d->vresult); diff --git a/gcc/doc/contrib.texi b/gcc/doc/contrib.texi index 2a15fd05883..32e89d6df25 100644 --- a/gcc/doc/contrib.texi +++ b/gcc/doc/contrib.texi @@ -64,8 +64,8 @@ improved alias analysis, plus migrating GCC to Bugzilla. Geoff Berry for his Java object serialization work and various patches. @item -David Binderman tests weekly snapshots of GCC trunk against Fedora Rawhide -for several architectures. +David Binderman for testing GCC trunk against Fedora Rawhide +and csmith. @item Laurynas Biveinis for memory management work and DJGPP port fixes. diff --git a/gcc/doc/cpp.texi b/gcc/doc/cpp.texi index 3de6e7aa737..3f38ca37fea 100644 --- a/gcc/doc/cpp.texi +++ b/gcc/doc/cpp.texi @@ -1886,8 +1886,8 @@ the 1999 revision of the C standard; the value @code{201112L} signifies the 2011 revision of the C standard; the value @code{201710L} signifies the 2017 revision of the C standard (which is otherwise identical to the 2011 version apart from correction of -defects). An unspecified value larger than @code{201710L} is used for -the experimental @option{-std=c23} and @option{-std=gnu23} modes. +defects). The value @code{202311L} is used for the experimental +@option{-std=c23} and @option{-std=gnu23} modes. This macro is not defined if the @option{-traditional-cpp} option is used, nor when compiling C++ or Objective-C@. diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index 1c58dc334ab..b1d28dcb03b 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -764,7 +764,9 @@ The default value refers to the FSF's GCC bug tracker. Specify the URL root that contains GCC option documentation. The @var{url} should end with a @code{/} character. -The default value is @uref{https://gcc.gnu.org/onlinedocs/,,https://gcc.gnu.org/onlinedocs/}. +The default value is @uref{https://gcc.gnu.org/onlinedocs/,,https://gcc.gnu.org/onlinedocs/} +on the GCC main development trunk. On release branches, the default +is @code{https://gcc.gnu.org/onlinedocs/gcc-@var{major}.@var{minor}.0/}. @item --with-changes-root-url=@var{url} Specify the URL root that contains information about changes in GCC @@ -1268,8 +1270,8 @@ default set of libraries is selected based on the value of @item amdgcn*-*-* @var{list} is a comma separated list of ISA names (allowed values: @code{fiji}, -@code{gfx900}, @code{gfx906}, @code{gfx908}, @code{gfx90a}, @code{gfx1030}, -@code{gfx1036}, @code{gfx1100}, @code{gfx1103}). +@code{gfx900}, @code{gfx906}, @code{gfx908}, @code{gfx90a}, @code{gfx90c}, +@code{gfx1030}, @code{gfx1036}, @code{gfx1100}, @code{gfx1103}). It ought not include the name of the default ISA, specified via @option{--with-arch}. If @var{list} is empty, then there will be no multilibs and only the default run-time library will be built. If @@ -4090,22 +4092,12 @@ This configuration is intended for embedded systems. We support FreeBSD using the ELF file format with DWARF 2 debugging for all CPU architectures. There are no known issues with mixing object files and libraries with different -debugging formats. Otherwise, this release of GCC should now match -more of the configuration used in the stock FreeBSD configuration of -GCC@. In particular, @option{--enable-threads} is now configured by -default. However, as a general user, do not attempt to replace the -system compiler with this release. Known to bootstrap and check with -good results on FreeBSD 7.2-STABLE@. In the past, known to bootstrap -and check with good results on FreeBSD 3.0, 3.4, 4.0, 4.2, 4.3, 4.4, -4.5, 4.8, 4.9 and 5-CURRENT@. - -The version of binutils installed in @file{/usr/bin} probably works -with this release of GCC@. Bootstrapping against the latest GNU -binutils and/or the version found in @file{/usr/ports/devel/binutils} has -been known to enable additional features and improve overall testsuite -results. However, it is currently known that boehm-gc may not configure -properly on FreeBSD prior to the FreeBSD 7.0 release with GNU binutils -after 2.16.1. +debugging formats. + +We recommend bootstrapping against the latest GNU binutils or the +version found in the @file{devel/binutils} port. This also has been +known to enable additional features and improve overall testsuite +results. @html <hr /> @@ -4319,12 +4311,6 @@ Building GCC on this target requires the GNU Assembler. The bundled HP assembler will not work. To prevent GCC from using the wrong assembler, the option @option{--with-gnu-as} may be necessary. -The GCC libunwind library has not been ported to HPUX@. This means that for -GCC versions 3.2.3 and earlier, @option{--enable-libunwind-exceptions} -is required to build GCC@. For GCC 3.3 and later, this is the default. -For gcc 3.4.3 and later, @option{--enable-libunwind-exceptions} is -removed and the system libunwind library will always be used. - @html <hr /> <!-- rs6000-ibm-aix*, powerpc-ibm-aix* --> diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 7e517b8080e..9456ced468a 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -1049,7 +1049,7 @@ Objective-C and Objective-C++ Dialects}. -msign-extend-enabled -muser-enabled} @emph{LoongArch Options} -@gccoptlist{-march=@var{cpu-type} -mtune=@var{cpu-type} -mabi=@var{base-abi-type} +@gccoptlist{-march=@var{arch-type} -mtune=@var{tune-type} -mabi=@var{base-abi-type} -mfpu=@var{fpu-type} -msimd=@var{simd-type} -msoft-float -msingle-float -mdouble-float -mlsx -mno-lsx -mlasx -mno-lasx -mbranch-cost=@var{n} -mcheck-zero-division -mno-check-zero-division @@ -13852,8 +13852,6 @@ DO I = 1, N ENDDO @end smallexample and the initialization loop is transformed into a call to memset zero. -This flag is enabled by default at @option{-O3}. -It is also enabled by @option{-fprofile-use} and @option{-fauto-profile}. @opindex floop-interchange @item -floop-interchange @@ -21846,6 +21844,9 @@ Compile for CDNA1 Instinct MI100 series devices (gfx908). @item gfx90a Compile for CDNA2 Instinct MI200 series devices (gfx90a). +@item gfx90c +Compile for GCN5 Vega 7 devices (gfx90c). + @item gfx1030 Compile for RDNA2 gfx1030 devices (GFX10 series). @@ -25755,7 +25756,7 @@ exit, respectively. @opindex masm=@var{dialect} @item -masm=@var{dialect} Outputs assembly instructions using eBPF selected @var{dialect}. The default -is @samp{normal}. +is @samp{pseudoc}. Supported values for @var{dialect} are: @@ -26852,34 +26853,51 @@ These command-line options are defined for LoongArch targets: @table @gcctabopt @opindex march -@item -march=@var{cpu-type} -Generate instructions for the machine type @var{cpu-type}. In contrast to -@option{-mtune=@var{cpu-type}}, which merely tunes the generated code -for the specified @var{cpu-type}, @option{-march=@var{cpu-type}} allows GCC -to generate code that may not run at all on processors other than the one -indicated. Specifying @option{-march=@var{cpu-type}} implies -@option{-mtune=@var{cpu-type}}, except where noted otherwise. +@item -march=@var{arch-type} +Generate instructions for the machine type @var{arch-type}. +@option{-march=@var{arch-type}} allows GCC to generate code that +may not run at all on processors other than the one indicated. -The choices for @var{cpu-type} are: +The choices for @var{arch-type} are: @table @samp @item native -This selects the CPU to generate code for at compilation time by determining -the processor type of the compiling machine. Using @option{-march=native} -enables all instruction subsets supported by the local machine (hence -the result might not run on different machines). Using @option{-mtune=native} -produces code optimized for the local machine under the constraints -of the selected instruction set. +Local processor type detected by the native compiler. @item loongarch64 -A generic CPU with 64-bit extensions. +Generic LoongArch 64-bit processor. @item la464 -LoongArch LA464 CPU with LBT, LSX, LASX, LVZ. +LoongArch LA464-based processor with LSX, LASX. +@item la664 +LoongArch LA664-based processor with LSX, LASX +and all LoongArch v1.1 instructions. +@item la64v1.0 +LoongArch64 ISA version 1.0. +@item la64v1.1 +LoongArch64 ISA version 1.1. @end table +More information about LoongArch ISA versions can be found at +@uref{https://github.com/loongson/la-toolchain-conventions}. + @opindex mtune -@item -mtune=@var{cpu-type} -Optimize the output for the given processor, specified by microarchitecture -name. +@item -mtune=@var{tune-type} +Optimize the generated code for the given processor target. + +The choices for @var{tune-type} are: + +@table @samp +@item native +Local processor type detected by the native compiler. +@item generic +Generic LoongArch processor. +@item loongarch64 +Generic LoongArch 64-bit processor. +@item la464 +LoongArch LA464 core. +@item la664 +LoongArch LA664 core. +@end table + @opindex mabi @item -mabi=@var{base-abi-type} diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index b0b066852df..a29c4a63ab1 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,76 @@ +2024-04-29 Francois-Xavier Coudert <fxcoudert@gcc.gnu.org> + + * expr.cc (check_transformational): Add SELECTED_LOGICAL_KIND + to allowed functions for Fortran 2023. + * gfortran.h (GFC_ISYM_SL_KIND): New. + * gfortran.texi: Mention SELECTED_LOGICAL_KIND. + * intrinsic.cc (add_functions): Add SELECTED_LOGICAL_KIND. + (gfc_intrinsic_func_interface): Allow it in initialization + expressions. + * intrinsic.h (gfc_simplify_selected_logical_kind): New proto. + * intrinsic.texi: Add SELECTED_LOGICAL_KIND. + * simplify.cc (gfc_simplify_selected_logical_kind): New + function. + * trans-decl.cc (gfc_build_intrinsic_function_decls): Initialize + gfor_fndecl_sl_kind. + * trans-intrinsic.cc (gfc_conv_intrinsic_sl_kind): New function. + (gfc_conv_intrinsic_function): Call it for GFC_ISYM_SL_KIND. + * trans.h (gfor_fndecl_sl_kind): New symbol. + +2024-04-29 Francois-Xavier Coudert <fxcoudert@gcc.gnu.org> + + * iso-fortran-env.def: Add logical{8,16,32,64} and + real16 named constants. + +2024-04-29 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/114959 + * trans-expr.cc (gfc_trans_class_init_assign): Return NULL_TREE + if the default initializer has all NULL fields. Guard this + by a requirement that the code not be EXEC_INIT_ASSIGN and that + the object be an INTENT_OUT dummy. + * trans-stmt.cc (gfc_trans_allocate): Change the initializer + code for allocate with mold to EXEC_ALLOCATE to allow an + initializer with all NULL fields. + +2024-04-25 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/93678 + * trans-expr.cc (gfc_conv_procedure_call): Use the interface, + where possible, to obtain the type of character procedure + pointers of class entities. + +2024-04-25 Paul Thomas <pault@gcc.gnu.org> + Jakub Jelinek <jakub@gcc.gnu.org> + + PR fortran/89462 + * decl.cc (build_sym): Add an extra argument 'elem'. If 'elem' + is greater than 1, gfc_new_charlen is called to generate a new + charlen, registered in the symbol namespace. + (variable_decl, enumerator_decl): Set the new argument in the + calls to build_sym. + +2024-04-21 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/103471 + * resolve.cc (resolve_actual_arglist): Catch variables silently + set as untyped, resetting the flag so that gfc_resolve_expr can + generate the no implicit type error. + (gfc_resolve_index_1): Block index expressions of unknown type + from being converted to default integer, avoiding the fatal + error in trans-decl.cc. + * symbol.cc (gfc_set_default_type): Remove '(symbol)' from the + 'no IMPLICIT type' error message. + * trans-decl.cc (gfc_get_symbol_decl): Change fatal error locus + to that of the symbol declaration. + (gfc_trans_deferred_vars): Remove two trailing tabs. + +2024-04-18 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/114739 + * primary.cc (gfc_match_varspec): Check for default type before + checking for derived types with the right component name. + 2024-04-16 Harald Anlauf <anlauf@gmx.de> PR fortran/113793 diff --git a/gcc/fortran/decl.cc b/gcc/fortran/decl.cc index a7576f4bc40..b8308aeee55 100644 --- a/gcc/fortran/decl.cc +++ b/gcc/fortran/decl.cc @@ -1713,7 +1713,7 @@ gfc_verify_c_interop_param (gfc_symbol *sym) /* Function called by variable_decl() that adds a name to the symbol table. */ static bool -build_sym (const char *name, gfc_charlen *cl, bool cl_deferred, +build_sym (const char *name, int elem, gfc_charlen *cl, bool cl_deferred, gfc_array_spec **as, locus *var_locus) { symbol_attribute attr; @@ -1778,7 +1778,10 @@ build_sym (const char *name, gfc_charlen *cl, bool cl_deferred, if (sym->ts.type == BT_CHARACTER) { - sym->ts.u.cl = cl; + if (elem > 1) + sym->ts.u.cl = gfc_new_charlen (sym->ns, cl); + else + sym->ts.u.cl = cl; sym->ts.deferred = cl_deferred; } @@ -2960,7 +2963,7 @@ variable_decl (int elem) create a symbol for those yet. If we fail to create the symbol, bail out. */ if (!gfc_comp_struct (gfc_current_state ()) - && !build_sym (name, cl, cl_deferred, &as, &var_locus)) + && !build_sym (name, elem, cl, cl_deferred, &as, &var_locus)) { m = MATCH_ERROR; goto cleanup; @@ -10938,7 +10941,7 @@ enumerator_decl (void) /* OK, we've successfully matched the declaration. Now put the symbol in the current namespace. If we fail to create the symbol, bail out. */ - if (!build_sym (name, NULL, false, &as, &var_locus)) + if (!build_sym (name, 1, NULL, false, &as, &var_locus)) { m = MATCH_ERROR; goto cleanup; diff --git a/gcc/fortran/expr.cc b/gcc/fortran/expr.cc index 09d1ebd95d2..66edad58278 100644 --- a/gcc/fortran/expr.cc +++ b/gcc/fortran/expr.cc @@ -2885,6 +2885,13 @@ check_transformational (gfc_expr *e) "trim", "unpack", "findloc", NULL }; + static const char * const trans_func_f2023[] = { + "all", "any", "count", "dot_product", "matmul", "null", "pack", + "product", "repeat", "reshape", "selected_char_kind", "selected_int_kind", + "selected_logical_kind", "selected_real_kind", "spread", "sum", "transfer", + "transpose", "trim", "unpack", "findloc", NULL + }; + int i; const char *name; const char *const *functions; @@ -2895,7 +2902,9 @@ check_transformational (gfc_expr *e) name = e->symtree->n.sym->name; - if (gfc_option.allow_std & GFC_STD_F2008) + if (gfc_option.allow_std & GFC_STD_F2023) + functions = trans_func_f2023; + else if (gfc_option.allow_std & GFC_STD_F2008) functions = trans_func_f2008; else if (gfc_option.allow_std & GFC_STD_F2003) functions = trans_func_f2003; diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 58505446bac..a7a0fdba3dd 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -662,6 +662,7 @@ enum gfc_isym_id GFC_ISYM_SIND, GFC_ISYM_SINH, GFC_ISYM_SIZE, + GFC_ISYM_SL_KIND, GFC_ISYM_SLEEP, GFC_ISYM_SIZEOF, GFC_ISYM_SNGL, diff --git a/gcc/fortran/gfortran.texi b/gcc/fortran/gfortran.texi index 371666dcbb6..7e8783a3690 100644 --- a/gcc/fortran/gfortran.texi +++ b/gcc/fortran/gfortran.texi @@ -862,8 +862,8 @@ data types are: The @code{KIND} value matches the storage size in bytes, except for @code{COMPLEX} where the storage size is twice as much (or both real and imaginary part are a real value of the given size). It is recommended to use -the @ref{SELECTED_CHAR_KIND}, @ref{SELECTED_INT_KIND} and -@ref{SELECTED_REAL_KIND} intrinsics or the @code{INT8}, @code{INT16}, +the @ref{SELECTED_CHAR_KIND}, @ref{SELECTED_INT_KIND}, @ref{SELECTED_LOGICAL_KIND} +and @ref{SELECTED_REAL_KIND} intrinsics or the @code{INT8}, @code{INT16}, @code{INT32}, @code{INT64}, @code{REAL32}, @code{REAL64}, and @code{REAL128} parameters of the @code{ISO_FORTRAN_ENV} module instead of the concrete values. The available kind parameters can be found in the constant arrays @@ -1272,8 +1272,9 @@ equivalent to the standard-conforming declaration @noindent where @code{k} is the kind parameter suitable for the intended precision. As kind parameters are implementation-dependent, use the @code{KIND}, -@code{SELECTED_INT_KIND} and @code{SELECTED_REAL_KIND} intrinsics to retrieve -the correct value, for instance @code{REAL*8 x} can be replaced by: +@code{SELECTED_INT_KIND}, @code{SELECTED_LOGICAL_KIND} and +@code{SELECTED_REAL_KIND} intrinsics to retrieve the correct value, for +instance @code{REAL*8 x} can be replaced by: @smallexample INTEGER, PARAMETER :: dbl = KIND(1.0d0) REAL(KIND=dbl) :: x diff --git a/gcc/fortran/intrinsic.cc b/gcc/fortran/intrinsic.cc index c35f2bdd183..40f4c4f4b0b 100644 --- a/gcc/fortran/intrinsic.cc +++ b/gcc/fortran/intrinsic.cc @@ -2952,6 +2952,12 @@ add_functions (void) make_generic ("selected_int_kind", GFC_ISYM_SI_KIND, GFC_STD_F95); + add_sym_1 ("selected_logical_kind", GFC_ISYM_SL_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, + GFC_STD_F2023, /* it has the same requirements */ gfc_check_selected_int_kind, + gfc_simplify_selected_logical_kind, NULL, r, BT_INTEGER, di, REQUIRED); + + make_generic ("selected_logical_kind", GFC_ISYM_SL_KIND, GFC_STD_F2023); + add_sym_3 ("selected_real_kind", GFC_ISYM_SR_KIND, CLASS_TRANSFORMATIONAL, ACTUAL_NO, BT_INTEGER, di, GFC_STD_F95, gfc_check_selected_real_kind, gfc_simplify_selected_real_kind, NULL, @@ -5003,7 +5009,8 @@ gfc_intrinsic_func_interface (gfc_expr *expr, int error_flag) gfc_isym_id id = isym->id; if (id != GFC_ISYM_REPEAT && id != GFC_ISYM_RESHAPE && id != GFC_ISYM_SI_KIND && id != GFC_ISYM_SR_KIND - && id != GFC_ISYM_TRANSFER && id != GFC_ISYM_TRIM + && id != GFC_ISYM_SL_KIND && id != GFC_ISYM_TRANSFER + && id != GFC_ISYM_TRIM && !gfc_notify_std (GFC_STD_F2003, "Transformational function %qs " "at %L is invalid in an initialization " "expression", sym->name, &expr->where)) diff --git a/gcc/fortran/intrinsic.h b/gcc/fortran/intrinsic.h index 438160aad01..2c287caa6ad 100644 --- a/gcc/fortran/intrinsic.h +++ b/gcc/fortran/intrinsic.h @@ -399,6 +399,7 @@ gfc_expr *gfc_simplify_scale (gfc_expr *, gfc_expr *); gfc_expr *gfc_simplify_scan (gfc_expr *, gfc_expr *, gfc_expr *, gfc_expr *); gfc_expr *gfc_simplify_selected_char_kind (gfc_expr *); gfc_expr *gfc_simplify_selected_int_kind (gfc_expr *); +gfc_expr *gfc_simplify_selected_logical_kind (gfc_expr *); gfc_expr *gfc_simplify_selected_real_kind (gfc_expr *, gfc_expr *, gfc_expr *); gfc_expr *gfc_simplify_set_exponent (gfc_expr *, gfc_expr *); gfc_expr *gfc_simplify_sign (gfc_expr *, gfc_expr *); diff --git a/gcc/fortran/intrinsic.texi b/gcc/fortran/intrinsic.texi index 0445feaf73a..3d3b9edf8e6 100644 --- a/gcc/fortran/intrinsic.texi +++ b/gcc/fortran/intrinsic.texi @@ -281,6 +281,7 @@ Some basic guidelines for editing this document: * @code{SECOND}: SECOND, CPU time function * @code{SELECTED_CHAR_KIND}: SELECTED_CHAR_KIND, Choose character kind * @code{SELECTED_INT_KIND}: SELECTED_INT_KIND, Choose integer kind +* @code{SELECTED_LOGICAL_KIND}: SELECTED_LOGICAL_KIND, Choose logical kind * @code{SELECTED_REAL_KIND}: SELECTED_REAL_KIND, Choose real kind * @code{SET_EXPONENT}: SET_EXPONENT, Set the exponent of the model * @code{SHAPE}: SHAPE, Determine the shape of an array @@ -12788,6 +12789,48 @@ end program large_integers +@node SELECTED_LOGICAL_KIND +@section @code{SELECTED_LOGICAL_KIND} --- Choose logical kind +@fnindex SELECTED_LOGICAL_KIND +@cindex logical kind +@cindex kind, logical + +@table @asis +@item @emph{Description}: +@code{SELECTED_LOGICAL_KIND(BITS)} return the kind value of the smallest +logical type whose storage size in bits is at least @var{BITS}. If there +is no such logical kind, @code{SELECTED_LOGICAL_KIND} returns @math{-1}. + +@item @emph{Standard}: +Fortran 2023 and later + +@item @emph{Class}: +Transformational function + +@item @emph{Syntax}: +@code{RESULT = SELECTED_LOGICAL_KIND(BITS)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{BITS} @tab Shall be a scalar and of type @code{INTEGER}. +@end multitable + +@item @emph{Example}: +@smallexample +program logical_kinds + integer, parameter :: k1 = selected_logical_kind(1) + integer, parameter :: k40 = selected_logical_kind(40) + logical(kind=k1) :: l1 ! At least one bit + logical(kind=k40) :: l40 ! At least 40 bits + + ! What is their actual size? + print *, storage_size(l1), storage_size(l40) +end program logical_kinds +@end smallexample +@end table + + + @node SELECTED_REAL_KIND @section @code{SELECTED_REAL_KIND} --- Choose real kind @fnindex SELECTED_REAL_KIND diff --git a/gcc/fortran/iso-fortran-env.def b/gcc/fortran/iso-fortran-env.def index ed7946a2594..069bbc1fb86 100644 --- a/gcc/fortran/iso-fortran-env.def +++ b/gcc/fortran/iso-fortran-env.def @@ -68,10 +68,20 @@ NAMED_INTCST (ISOFORTRANENV_IOSTAT_EOR, "iostat_eor", LIBERROR_EOR, \ NAMED_INTCST (ISOFORTRANENV_IOSTAT_INQUIRE_INTERNAL_UNIT, \ "iostat_inquire_internal_unit", LIBERROR_INQUIRE_INTERNAL_UNIT, \ GFC_STD_F2008) +NAMED_INTCST (ISOFORTRANENV_LOGICAL8, "logical8", \ + gfc_get_int_kind_from_width_isofortranenv (8), GFC_STD_F2023) +NAMED_INTCST (ISOFORTRANENV_LOGICAL16, "logical16", \ + gfc_get_int_kind_from_width_isofortranenv (16), GFC_STD_F2023) +NAMED_INTCST (ISOFORTRANENV_LOGICAL32, "logical32", \ + gfc_get_int_kind_from_width_isofortranenv (32), GFC_STD_F2023) +NAMED_INTCST (ISOFORTRANENV_LOGICAL64, "logical64", \ + gfc_get_int_kind_from_width_isofortranenv (64), GFC_STD_F2023) NAMED_INTCST (ISOFORTRANENV_NUMERIC_STORAGE_SIZE, "numeric_storage_size", \ gfc_numeric_storage_size, GFC_STD_F2003) NAMED_INTCST (ISOFORTRANENV_OUTPUT_UNIT, "output_unit", GFC_STDOUT_UNIT_NUMBER, \ GFC_STD_F2003) +NAMED_INTCST (ISOFORTRANENV_REAL16, "real16", \ + gfc_get_real_kind_from_width_isofortranenv (16), GFC_STD_F2023) NAMED_INTCST (ISOFORTRANENV_REAL32, "real32", \ gfc_get_real_kind_from_width_isofortranenv (32), GFC_STD_F2008) NAMED_INTCST (ISOFORTRANENV_REAL64, "real64", \ diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc index 6b3e5ba4fcb..4368627041e 100644 --- a/gcc/fortran/resolve.cc +++ b/gcc/fortran/resolve.cc @@ -2189,6 +2189,14 @@ resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype, ? CLASS_DATA (sym)->as : sym->as; } + /* These symbols are set untyped by calls to gfc_set_default_type + with 'error_flag' = false. Reset the untyped attribute so that + the error will be generated in gfc_resolve_expr. */ + if (e->expr_type == EXPR_VARIABLE + && sym->ts.type == BT_UNKNOWN + && sym->attr.untyped) + sym->attr.untyped = 0; + /* Expressions are assigned a default ts.type of BT_PROCEDURE in primary.cc (match_actual_arg). If above code determines that it is a variable instead, it needs to be resolved as it was not @@ -5001,7 +5009,8 @@ gfc_resolve_index_1 (gfc_expr *index, int check_scalar, if ((index->ts.kind != gfc_index_integer_kind && force_index_integer_kind) - || index->ts.type != BT_INTEGER) + || (index->ts.type != BT_INTEGER + && index->ts.type != BT_UNKNOWN)) { gfc_clear_ts (&ts); ts.type = BT_INTEGER; diff --git a/gcc/fortran/simplify.cc b/gcc/fortran/simplify.cc index 3043483daa9..7a5d31c01a6 100644 --- a/gcc/fortran/simplify.cc +++ b/gcc/fortran/simplify.cc @@ -7333,6 +7333,28 @@ gfc_simplify_selected_int_kind (gfc_expr *e) gfc_expr * +gfc_simplify_selected_logical_kind (gfc_expr *e) +{ + int i, kind, bits; + + if (e->expr_type != EXPR_CONSTANT || gfc_extract_int (e, &bits)) + return NULL; + + kind = INT_MAX; + + for (i = 0; gfc_logical_kinds[i].kind != 0; i++) + if (gfc_logical_kinds[i].bit_size >= bits + && gfc_logical_kinds[i].kind < kind) + kind = gfc_logical_kinds[i].kind; + + if (kind == INT_MAX) + kind = -1; + + return gfc_get_int_expr (gfc_default_integer_kind, &e->where, kind); +} + + +gfc_expr * gfc_simplify_selected_real_kind (gfc_expr *p, gfc_expr *q, gfc_expr *rdx) { int range, precision, radix, i, kind, found_precision, found_range, diff --git a/gcc/fortran/symbol.cc b/gcc/fortran/symbol.cc index 3a3b6de5cec..8f7deac1d1e 100644 --- a/gcc/fortran/symbol.cc +++ b/gcc/fortran/symbol.cc @@ -320,7 +320,7 @@ gfc_set_default_type (gfc_symbol *sym, int error_flag, gfc_namespace *ns) "; did you mean %qs?", sym->name, &sym->declared_at, guessed); else - gfc_error ("Symbol %qs at %L has no IMPLICIT type(symbol)", + gfc_error ("Symbol %qs at %L has no IMPLICIT type", sym->name, &sym->declared_at); sym->attr.untyped = 1; /* Ensure we only give an error once. */ } diff --git a/gcc/fortran/trans-decl.cc b/gcc/fortran/trans-decl.cc index e160c5c98c1..dca7779528b 100644 --- a/gcc/fortran/trans-decl.cc +++ b/gcc/fortran/trans-decl.cc @@ -221,6 +221,7 @@ tree gfor_fndecl_is_contiguous0; /* Intrinsic functions implemented in Fortran. */ tree gfor_fndecl_sc_kind; tree gfor_fndecl_si_kind; +tree gfor_fndecl_sl_kind; tree gfor_fndecl_sr_kind; /* BLAS gemm functions. */ @@ -1797,7 +1798,8 @@ gfc_get_symbol_decl (gfc_symbol * sym) } if (sym->ts.type == BT_UNKNOWN) - gfc_fatal_error ("%s at %C has no default type", sym->name); + gfc_fatal_error ("%s at %L has no default type", sym->name, + &sym->declared_at); if (sym->attr.intrinsic) gfc_internal_error ("intrinsic variable which isn't a procedure"); @@ -3604,6 +3606,12 @@ gfc_build_intrinsic_function_decls (void) DECL_PURE_P (gfor_fndecl_si_kind) = 1; TREE_NOTHROW (gfor_fndecl_si_kind) = 1; + gfor_fndecl_sl_kind = gfc_build_library_function_decl_with_spec ( + get_identifier (PREFIX("selected_logical_kind")), ". R ", + gfc_int4_type_node, 1, pvoid_type_node); + DECL_PURE_P (gfor_fndecl_sl_kind) = 1; + TREE_NOTHROW (gfor_fndecl_sl_kind) = 1; + gfor_fndecl_sr_kind = gfc_build_library_function_decl_with_spec ( get_identifier (PREFIX("selected_real_kind2008")), ". R R ", gfc_int4_type_node, 3, pvoid_type_node, pvoid_type_node, @@ -5214,8 +5222,8 @@ gfc_trans_deferred_vars (gfc_symbol * proc_sym, gfc_wrapped_block * block) tree tmp = lookup_attribute ("omp allocate", DECL_ATTRIBUTES (n->sym->backend_decl)); tmp = TREE_VALUE (tmp); - TREE_PURPOSE (tmp) = se.expr; - TREE_VALUE (tmp) = align; + TREE_PURPOSE (tmp) = se.expr; + TREE_VALUE (tmp) = align; TREE_PURPOSE (TREE_CHAIN (tmp)) = init_stmtlist; TREE_VALUE (TREE_CHAIN (tmp)) = cleanup_stmtlist; } diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index 605434f4ddb..0280c441ced 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -1720,6 +1720,7 @@ gfc_trans_class_init_assign (gfc_code *code) gfc_se dst,src,memsz; gfc_expr *lhs, *rhs, *sz; gfc_component *cmp; + gfc_symbol *sym; gfc_start_block (&block); @@ -1736,18 +1737,25 @@ gfc_trans_class_init_assign (gfc_code *code) /* The _def_init is always scalar. */ rhs->rank = 0; - /* Check def_init for initializers. If this is a dummy with all default - initializer components NULL, return NULL_TREE and use the passed value as - required by F2018(8.5.10). */ - if (!lhs->ref && lhs->symtree->n.sym->attr.dummy) + /* Check def_init for initializers. If this is an INTENT(OUT) dummy with all + default initializer components NULL, return NULL_TREE and use the passed + value as required by F2018(8.5.10). */ + sym = code->expr1->expr_type == EXPR_VARIABLE ? code->expr1->symtree->n.sym + : NULL; + if (code->op != EXEC_ALLOCATE + && sym && sym->attr.dummy + && sym->attr.intent == INTENT_OUT) { - cmp = rhs->ref->next->u.c.component->ts.u.derived->components; - for (; cmp; cmp = cmp->next) + if (!lhs->ref && lhs->symtree->n.sym->attr.dummy) { - if (cmp->initializer) - break; - else if (!cmp->next) - return build_empty_stmt (input_location); + cmp = rhs->ref->next->u.c.component->ts.u.derived->components; + for (; cmp; cmp = cmp->next) + { + if (cmp->initializer) + break; + else if (!cmp->next) + return NULL_TREE; + } } } @@ -7879,8 +7887,14 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym, { gcc_assert (se->loop && info); - /* Set the type of the array. */ - tmp = gfc_typenode_for_spec (&comp->ts); + /* Set the type of the array. vtable charlens are not always reliable. + Use the interface, if possible. */ + if (comp->ts.type == BT_CHARACTER + && expr->symtree->n.sym->ts.type == BT_CLASS + && comp->ts.interface && comp->ts.interface->result) + tmp = gfc_typenode_for_spec (&comp->ts.interface->result->ts); + else + tmp = gfc_typenode_for_spec (&comp->ts); gcc_assert (se->ss->dimen == se->loop->dimen); /* Evaluate the bounds of the result, if known. */ diff --git a/gcc/fortran/trans-intrinsic.cc b/gcc/fortran/trans-intrinsic.cc index 4e26af21b46..83041183fcb 100644 --- a/gcc/fortran/trans-intrinsic.cc +++ b/gcc/fortran/trans-intrinsic.cc @@ -9187,6 +9187,27 @@ gfc_conv_intrinsic_si_kind (gfc_se *se, gfc_expr *expr) } +/* Generate code for SELECTED_LOGICAL_KIND (BITS) intrinsic function. */ + +static void +gfc_conv_intrinsic_sl_kind (gfc_se *se, gfc_expr *expr) +{ + tree arg, type; + + gfc_conv_intrinsic_function_args (se, expr, &arg, 1); + + /* The argument to SELECTED_LOGICAL_KIND is INTEGER(4). */ + type = gfc_get_int_type (4); + arg = gfc_build_addr_expr (NULL_TREE, fold_convert (type, arg)); + + /* Convert it to the required type. */ + type = gfc_typenode_for_spec (&expr->ts); + se->expr = build_call_expr_loc (input_location, + gfor_fndecl_sl_kind, 1, arg); + se->expr = fold_convert (type, se->expr); +} + + /* Generate code for SELECTED_REAL_KIND (P, R, RADIX) intrinsic function. */ static void @@ -10618,6 +10639,10 @@ gfc_conv_intrinsic_function (gfc_se * se, gfc_expr * expr) gfc_conv_intrinsic_si_kind (se, expr); break; + case GFC_ISYM_SL_KIND: + gfc_conv_intrinsic_sl_kind (se, expr); + break; + case GFC_ISYM_SR_KIND: gfc_conv_intrinsic_sr_kind (se, expr); break; diff --git a/gcc/fortran/trans-stmt.cc b/gcc/fortran/trans-stmt.cc index c34e0b4c0cd..d355009fa5e 100644 --- a/gcc/fortran/trans-stmt.cc +++ b/gcc/fortran/trans-stmt.cc @@ -7262,11 +7262,12 @@ gfc_trans_allocate (gfc_code * code, gfc_omp_namelist *omp_allocate) { /* Use class_init_assign to initialize expr. */ gfc_code *ini; - ini = gfc_get_code (EXEC_INIT_ASSIGN); + ini = gfc_get_code (EXEC_ALLOCATE); ini->expr1 = gfc_find_and_cut_at_last_class_ref (expr, true); tmp = gfc_trans_class_init_assign (ini); gfc_free_statements (ini); - gfc_add_expr_to_block (&block, tmp); + if (tmp != NULL_TREE) + gfc_add_expr_to_block (&block, tmp); } else if ((init_expr = allocate_get_initializer (code, expr))) { diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h index 2e10ce1a9b3..f94fa601400 100644 --- a/gcc/fortran/trans.h +++ b/gcc/fortran/trans.h @@ -978,6 +978,7 @@ extern GTY(()) tree gfor_fndecl_is_contiguous0; /* Implemented in Fortran. */ extern GTY(()) tree gfor_fndecl_sc_kind; extern GTY(()) tree gfor_fndecl_si_kind; +extern GTY(()) tree gfor_fndecl_sl_kind; extern GTY(()) tree gfor_fndecl_sr_kind; /* IEEE-related. */ diff --git a/gcc/gcc-urlifier.cc b/gcc/gcc-urlifier.cc index ff8c3f65ac5..be6459e8d7c 100644 --- a/gcc/gcc-urlifier.cc +++ b/gcc/gcc-urlifier.cc @@ -26,7 +26,6 @@ along with GCC; see the file COPYING3. If not see #include "gcc-urlifier.h" #include "opts.h" #include "options.h" -#include "diagnostic-core.h" #include "selftest.h" namespace { @@ -209,16 +208,7 @@ gcc_urlifier::make_doc_url (const char *doc_url_suffix) if (!doc_url_suffix) return nullptr; - char infix[32]; - /* On release branches, append to DOCUMENTATION_ROOT_URL the - subdirectory with documentation of the latest release made - from the branch. */ - if (BUILDING_GCC_MINOR != 0 && BUILDING_GCC_PATCHLEVEL <= 1U) - sprintf (infix, "gcc-%u.%u.0/", - BUILDING_GCC_MAJOR, BUILDING_GCC_MINOR); - else - infix[0] = '\0'; - return concat (DOCUMENTATION_ROOT_URL, infix, doc_url_suffix, nullptr); + return concat (DOCUMENTATION_ROOT_URL, doc_url_suffix, nullptr); } } // anonymous namespace diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc index a33b7a73872..72ac2552311 100644 --- a/gcc/gimple-range-cache.cc +++ b/gcc/gimple-range-cache.cc @@ -1047,7 +1047,9 @@ ranger_cache::get_global_range (vrange &r, tree name, bool ¤t_p) if (r.varying_p () && !cfun->after_inlining) { gimple *s = SSA_NAME_DEF_STMT (name); - if (gimple_get_lhs (s) == name) + // Do not process PHIs as SCEV may be in use and it can + // spawn cyclic lookups. + if (gimple_get_lhs (s) == name && !is_a<gphi *> (s)) { if (!fold_range (r, s, get_global_range_query ())) gimple_range_global (r, name); @@ -1413,7 +1415,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) // At this point we shouldn't be looking at the def, entry block. gcc_checking_assert (bb != def_bb && bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)); - gcc_checking_assert (m_workback.length () == 0); + unsigned start_length = m_workback.length (); // If the block cache is set, then we've already visited this block. if (m_on_entry.bb_range_p (name, bb)) @@ -1500,7 +1502,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) } m_on_entry.set_bb_range (name, bb, block_result); - gcc_checking_assert (m_workback.length () == 0); + gcc_checking_assert (m_workback.length () == start_length); return; } @@ -1512,7 +1514,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) m_on_entry.set_bb_range (name, bb, undefined); gcc_checking_assert (m_update->empty_p ()); - while (m_workback.length () > 0) + while (m_workback.length () > start_length) { basic_block node = m_workback.pop (); if (DEBUG_RANGE_CACHE) diff --git a/gcc/gimple-range-op.cc b/gcc/gimple-range-op.cc index a98f7db62a7..587de186db2 100644 --- a/gcc/gimple-range-op.cc +++ b/gcc/gimple-range-op.cc @@ -178,7 +178,6 @@ gimple_range_op_handler::gimple_range_op_handler (gimple *s) bool gimple_range_op_handler::calc_op1 (vrange &r, const vrange &lhs_range) { - gcc_checking_assert (gimple_num_ops (m_stmt) < 3); // Give up on empty ranges. if (lhs_range.undefined_p ()) return false; @@ -853,7 +852,7 @@ public: // __builtin_ffs* and __builtin_popcount* return [0, prec]. int prec = TYPE_PRECISION (lh.type ()); // If arg is non-zero, then ffs or popcount are non-zero. - int mini = range_includes_zero_p (&lh) ? 0 : 1; + int mini = range_includes_zero_p (lh) ? 0 : 1; int maxi = prec; // If some high bits are known to be zero, decrease the maximum. @@ -945,7 +944,7 @@ cfn_clz::fold_range (irange &r, tree type, const irange &lh, if (mini == -2) mini = 0; } - else if (!range_includes_zero_p (&lh)) + else if (!range_includes_zero_p (lh)) { mini = 0; maxi = prec - 1; @@ -1007,7 +1006,7 @@ cfn_ctz::fold_range (irange &r, tree type, const irange &lh, mini = -2; } // If arg is non-zero, then use [0, prec - 1]. - if (!range_includes_zero_p (&lh)) + if (!range_includes_zero_p (lh)) { mini = 0; maxi = prec - 1; @@ -1213,7 +1212,8 @@ gimple_range_op_handler::maybe_builtin_call () if (func == CFN_LAST) return; tree type = gimple_range_type (call); - gcc_checking_assert (type); + if (!type) + return; if (!Value_Range::supports_type_p (type)) return; diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc index 4d3b1ce8588..e75e2e17dc3 100644 --- a/gcc/gimple-range.cc +++ b/gcc/gimple-range.cc @@ -102,7 +102,15 @@ gimple_ranger::range_of_expr (vrange &r, tree expr, gimple *stmt) if (!stmt) { Value_Range tmp (TREE_TYPE (expr)); - m_cache.get_global_range (r, expr); + // If there is no global range for EXPR yet, try to evaluate it. + // This call sets R to a global range regardless. + if (!m_cache.get_global_range (r, expr)) + { + gimple *s = SSA_NAME_DEF_STMT (expr); + // Calculate a range for S if it is safe to do so. + if (s && gimple_bb (s) && gimple_get_lhs (s) == expr) + return range_of_stmt (r, s); + } // Pick up implied context information from the on-entry cache // if current_bb is set. Do not attempt any new calculations. if (current_bb && m_cache.block_range (tmp, current_bb, expr, false)) @@ -144,11 +152,13 @@ gimple_ranger::range_of_expr (vrange &r, tree expr, gimple *stmt) // Return the range of NAME on entry to block BB in R. -void +bool gimple_ranger::range_on_entry (vrange &r, basic_block bb, tree name) { + if (!gimple_range_ssa_p (name)) + return get_tree_range (r, name, NULL, bb, NULL); + Value_Range entry_range (TREE_TYPE (name)); - gcc_checking_assert (gimple_range_ssa_p (name)); unsigned idx; if ((idx = tracer.header ("range_on_entry ("))) @@ -166,16 +176,17 @@ gimple_ranger::range_on_entry (vrange &r, basic_block bb, tree name) if (idx) tracer.trailer (idx, "range_on_entry", true, name, r); + return true; } // Calculate the range for NAME at the end of block BB and return it in R. // Return false if no range can be calculated. -void +bool gimple_ranger::range_on_exit (vrange &r, basic_block bb, tree name) { - // on-exit from the exit block? - gcc_checking_assert (gimple_range_ssa_p (name)); + if (!gimple_range_ssa_p (name)) + return get_tree_range (r, name, NULL, NULL, bb); unsigned idx; if ((idx = tracer.header ("range_on_exit ("))) @@ -200,6 +211,7 @@ gimple_ranger::range_on_exit (vrange &r, basic_block bb, tree name) if (idx) tracer.trailer (idx, "range_on_exit", true, name, r); + return true; } // Calculate a range for NAME on edge E and return it in R. diff --git a/gcc/gimple-range.h b/gcc/gimple-range.h index 8739ab6a2ef..167b54b2a37 100644 --- a/gcc/gimple-range.h +++ b/gcc/gimple-range.h @@ -52,8 +52,8 @@ public: virtual bool range_of_stmt (vrange &r, gimple *, tree name = NULL) override; virtual bool range_of_expr (vrange &r, tree name, gimple * = NULL) override; virtual bool range_on_edge (vrange &r, edge e, tree name) override; - void range_on_entry (vrange &r, basic_block bb, tree name); - void range_on_exit (vrange &r, basic_block bb, tree name); + virtual bool range_on_entry (vrange &r, basic_block bb, tree name) override; + virtual bool range_on_exit (vrange &r, basic_block bb, tree name) override; void export_global_ranges (); inline gori_compute &gori () { return m_cache.m_gori; } virtual void dump (FILE *f) override; diff --git a/gcc/gimple-ssa-sprintf.cc b/gcc/gimple-ssa-sprintf.cc index abb934b08d5..3b19f4d3f35 100644 --- a/gcc/gimple-ssa-sprintf.cc +++ b/gcc/gimple-ssa-sprintf.cc @@ -2177,8 +2177,7 @@ format_character (const directive &dir, tree arg, pointer_query &ptr_qry) res.knownrange = true; - if (dir.specifier == 'C' - || dir.modifier == FMT_LEN_l) + if (dir.specifier == 'C' || dir.modifier == FMT_LEN_l) { /* A wide character can result in as few as zero bytes. */ res.range.min = 0; @@ -2189,10 +2188,13 @@ format_character (const directive &dir, tree arg, pointer_query &ptr_qry) { if (min == 0 && max == 0) { - /* The NUL wide character results in no bytes. */ - res.range.max = 0; - res.range.likely = 0; - res.range.unlikely = 0; + /* In strict reading of older ISO C or POSIX, this required + no characters to be emitted. ISO C23 changes that, so + does POSIX, to match what has been implemented in most of the + implementations, namely emitting a single NUL character. + Let's use 0 for minimum and 1 for all the other values. */ + res.range.max = 1; + res.range.likely = res.range.unlikely = 1; } else if (min >= 0 && min < 128) { @@ -2200,11 +2202,12 @@ format_character (const directive &dir, tree arg, pointer_query &ptr_qry) is not a 1-to-1 mapping to the source character set or if the source set is not ASCII. */ bool one_2_one_ascii - = (target_to_host_charmap[0] == 1 && target_to_host ('a') == 97); + = (target_to_host_charmap[0] == 1 + && target_to_host ('a') == 97); /* A wide character in the ASCII range most likely results in a single byte, and only unlikely in up to MB_LEN_MAX. */ - res.range.max = one_2_one_ascii ? 1 : target_mb_len_max ();; + res.range.max = one_2_one_ascii ? 1 : target_mb_len_max (); res.range.likely = 1; res.range.unlikely = target_mb_len_max (); res.mayfail = !one_2_one_ascii; @@ -2235,7 +2238,6 @@ format_character (const directive &dir, tree arg, pointer_query &ptr_qry) /* A plain '%c' directive. Its output is exactly 1. */ res.range.min = res.range.max = 1; res.range.likely = res.range.unlikely = 1; - res.knownrange = true; } /* Bump up the byte counters if WIDTH is greater. */ diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc index dedaae27b31..2c10d19e7f3 100644 --- a/gcc/gimple-ssa-warn-access.cc +++ b/gcc/gimple-ssa-warn-access.cc @@ -330,7 +330,7 @@ check_nul_terminated_array (GimpleOrTree expr, tree src, tree bound) wide_int bndrng[2]; if (bound) { - Value_Range r (TREE_TYPE (bound)); + int_range_max r (TREE_TYPE (bound)); get_range_query (cfun)->range_of_expr (r, bound); @@ -2816,7 +2816,7 @@ memmodel_to_uhwi (tree ord, gimple *stmt, unsigned HOST_WIDE_INT *cstval) { /* Use the range query to determine constant values in the absence of constant propagation (such as at -O0). */ - Value_Range rng (TREE_TYPE (ord)); + int_range_max rng (TREE_TYPE (ord)); if (!get_range_query (cfun)->range_of_expr (rng, ord, stmt) || !rng.singleton_p (&ord)) return false; diff --git a/gcc/gimple.h b/gcc/gimple.h index 8a8ca109bbf..bd315ffc2dd 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -236,7 +236,8 @@ struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"), for clearing this bit before using it. */ unsigned int visited : 1; - /* Nonzero if this tuple represents a non-temporal move. */ + /* Nonzero if this tuple represents a non-temporal move; currently + only stores are supported. */ unsigned int nontemporal_move : 1; /* Pass local flags. These flags are free for any pass to use as diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE index 50d430d5034..9a4b402573a 100644 --- a/gcc/go/gofrontend/MERGE +++ b/gcc/go/gofrontend/MERGE @@ -1,4 +1,4 @@ -98e92493db2ab7857a5934a950a830fc1f95a4e5 +60f985a7852632834936b4b859aa75d9df88f038 The first line of this file holds the git revision number of the last merge done from the gofrontend repository. diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index c7c5222a169..0a7053c2286 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -53,6 +53,8 @@ along with GCC; see the file COPYING3. If not see #include "rtl-iter.h" #include "gimple-range.h" #include "fold-const-call.h" +#include "tree-ssa-live.h" +#include "tree-outof-ssa.h" /* For lang_hooks.types.type_for_mode. */ #include "langhooks.h" @@ -2793,6 +2795,7 @@ expand_arith_overflow (enum tree_code code, gimple *stmt) case PLUS_EXPR: expand_addsub_overflow (loc, code, lhs, arg0, arg1, unsr_p, unsr_p, unsr_p, false, NULL); + flag_trapv = save_flag_trapv; return; case MULT_EXPR: expand_mul_overflow (loc, lhs, arg0, arg1, unsr_p, @@ -2963,8 +2966,8 @@ expand_call_mem_ref (tree type, gcall *stmt, int index) tree tmp = addr; if (TREE_CODE (tmp) == SSA_NAME) { - gimple *def = SSA_NAME_DEF_STMT (tmp); - if (gimple_assign_single_p (def)) + gimple *def = get_gimple_for_ssa_name (tmp); + if (def && gimple_assign_single_p (def)) tmp = gimple_assign_rhs1 (def); } diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc index b7add455bd5..a688dced5c9 100644 --- a/gcc/ipa-cp.cc +++ b/gcc/ipa-cp.cc @@ -2485,8 +2485,7 @@ propagate_bits_across_jump_function (cgraph_edge *cs, int idx, jfunc->m_vr->get_vrange (vr); if (!vr.undefined_p () && !vr.varying_p ()) { - irange &r = as_a <irange> (vr); - irange_bitmask bm = r.get_bitmask (); + irange_bitmask bm = vr.get_bitmask (); widest_int mask = widest_int::from (bm.mask (), TYPE_SIGN (parm_type)); widest_int value @@ -6346,14 +6345,13 @@ ipcp_store_vr_results (void) { Value_Range tmp = plats->m_value_range.m_vr; tree type = ipa_get_type (info, i); - irange &r = as_a<irange> (tmp); irange_bitmask bm (wide_int::from (bits->get_value (), TYPE_PRECISION (type), TYPE_SIGN (type)), wide_int::from (bits->get_mask (), TYPE_PRECISION (type), TYPE_SIGN (type))); - r.update_bitmask (bm); + tmp.update_bitmask (bm); ipa_vr vr (tmp); ts->m_vr->quick_push (vr); } @@ -6368,14 +6366,13 @@ ipcp_store_vr_results (void) tree type = ipa_get_type (info, i); Value_Range tmp; tmp.set_varying (type); - irange &r = as_a<irange> (tmp); irange_bitmask bm (wide_int::from (bits->get_value (), TYPE_PRECISION (type), TYPE_SIGN (type)), wide_int::from (bits->get_mask (), TYPE_PRECISION (type), TYPE_SIGN (type))); - r.update_bitmask (bm); + tmp.update_bitmask (bm); ipa_vr vr (tmp); ts->m_vr->quick_push (vr); } diff --git a/gcc/ipa-fnsummary.cc b/gcc/ipa-fnsummary.cc index dff40cd8aa5..668a01ef175 100644 --- a/gcc/ipa-fnsummary.cc +++ b/gcc/ipa-fnsummary.cc @@ -681,8 +681,12 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p, if (!vr.undefined_p () && !vr.varying_p ()) { if (!avals->m_known_value_ranges.length ()) - avals->m_known_value_ranges.safe_grow_cleared (count, - true); + { + avals->m_known_value_ranges.safe_grow_cleared (count, + true); + for (int i = 0; i < count; ++i) + avals->m_known_value_ranges[i].set_type (void_type_node); + } avals->m_known_value_ranges[i] = vr; } } diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc index 374e998aa64..b57f9750431 100644 --- a/gcc/ipa-prop.cc +++ b/gcc/ipa-prop.cc @@ -2381,8 +2381,7 @@ ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi, irange_bitmask bm (value, mask); if (!addr_nonzero) vr.set_varying (TREE_TYPE (arg)); - irange &r = as_a <irange> (vr); - r.update_bitmask (bm); + vr.update_bitmask (bm); ipa_set_jfunc_vr (jfunc, vr); } else if (addr_nonzero) @@ -5785,8 +5784,8 @@ ipcp_get_parm_bits (tree parm, tree *value, widest_int *mask) vr[i].get_vrange (tmp); if (tmp.undefined_p () || tmp.varying_p ()) return false; - irange &r = as_a <irange> (tmp); - irange_bitmask bm = r.get_bitmask (); + irange_bitmask bm; + bm = tmp.get_bitmask (); *mask = widest_int::from (bm.mask (), TYPE_SIGN (TREE_TYPE (parm))); *value = wide_int_to_tree (TREE_TYPE (parm), bm.value ()); return true; @@ -5857,8 +5856,7 @@ ipcp_update_vr (struct cgraph_node *node, ipcp_transformation *ts) if (POINTER_TYPE_P (TREE_TYPE (parm)) && opt_for_fn (node->decl, flag_ipa_bit_cp)) { - irange &r = as_a<irange> (tmp); - irange_bitmask bm = r.get_bitmask (); + irange_bitmask bm = tmp.get_bitmask (); unsigned tem = bm.mask ().to_uhwi (); unsigned HOST_WIDE_INT bitpos = bm.value ().to_uhwi (); unsigned align = tem & -tem; diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index 2b0ad183398..37911073126 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,61 @@ +2024-04-25 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/114836 + * gm2-compiler/M2Range.mod (FoldTypeAssign): Avoid error + string concatenation. + +2024-04-25 Gaius Mulley <gaiusmod2@gmail.com> + + * gm2-compiler/M2FileName.def (CalculateFileName): Remove + quoted string in comment. + * gm2-compiler/M2Range.mod (FoldTypeParam): Generate dialect + specific parameter incompatibility error message. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * lang.opt (fdef=, fmod=): Spelling fix: recognise -> recognize. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * lang.opt (fuse-list=): Spelling fix: finalializations -> + finalizations. + +2024-04-22 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/114811 + * gm2-compiler/M2GenGCC.mod (FoldBinarySet): Add condition + checking to ensure op2 and op3 are fully resolved before + type checking is performed. + +2024-04-22 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/114807 + * gm2-compiler/M2Check.mod (checkUnbounded): Remove unused + local variables. + (constCheckMeta): Include check for IsReallyPointer in the + failure case. + * gm2-compiler/M2Quads.mod (MoveWithMode): Remove CopyConstString. + * gm2-compiler/SymbolTable.def (IsHiddenReallyPointer): Export. + * gm2-compiler/SymbolTable.mod (SkipHiddenType): Remove. + (IsReallyPointer): Include IsHiddenReallyPointer test. + +2024-04-20 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/112893 + * gm2-compiler/M2Check.mod (GetProcedureProcType): Import. + (getType): Return value using GetProcedureProcType if sym is a + procedure. + * gm2-compiler/M2Range.mod (FoldTypeExpr): Remove quad if + expression is type compatible. + * gm2-compiler/SymbolTable.def (GetProcedureProcType): New + procedure function. + * gm2-compiler/SymbolTable.mod (Procedure): Add ProcedureType. + (MakeProcedure): Initialize ProcedureType. + (PutParam): Call AddProcedureProcTypeParam. + (PutVarParam): Call AddProcedureProcTypeParam. + (AddProcedureProcTypeParam): New procedure. + (GetProcedureProcType): New procedure function. + 2024-04-16 Gaius Mulley <gaiusmod2@gmail.com> PR modula2/114745 diff --git a/gcc/m2/gm2-compiler/M2Check.mod b/gcc/m2/gm2-compiler/M2Check.mod index 20d463d207b..1750fe07ecf 100644 --- a/gcc/m2/gm2-compiler/M2Check.mod +++ b/gcc/m2/gm2-compiler/M2Check.mod @@ -47,7 +47,8 @@ FROM SymbolTable IMPORT NulSym, IsRecord, IsSet, GetDType, GetSType, IsType, IsReallyPointer, IsPointer, IsParameter, ModeOfAddr, GetMode, GetType, IsUnbounded, IsComposite, IsConstructor, IsParameter, IsConstString, IsConstLitInternal, IsConstLit, - GetStringLength ; + GetStringLength, GetProcedureProcType, IsHiddenType, + IsHiddenReallyPointer ; FROM M2GCCDeclare IMPORT GetTypeMin, GetTypeMax ; FROM M2System IMPORT Address ; @@ -264,9 +265,6 @@ END checkSubrange ; *) PROCEDURE checkUnbounded (result: status; tinfo: tInfo; unbounded, right: CARDINAL) : status ; -VAR - lLow, rLow, - lHigh, rHigh: CARDINAL ; BEGIN (* Firstly check to see if we have resolved this as false. *) IF isFalse (result) @@ -683,7 +681,8 @@ BEGIN THEN RETURN result ELSIF IsSet (typeRight) OR IsEnumeration (typeRight) OR - IsProcedure (typeRight) OR IsRecord (typeRight) + IsProcedure (typeRight) OR IsRecord (typeRight) OR + IsReallyPointer (typeRight) THEN RETURN false ELSIF IsArray (typeRight) @@ -1397,7 +1396,7 @@ PROCEDURE getType (sym: CARDINAL) : CARDINAL ; BEGIN IF (sym # NulSym) AND IsProcedure (sym) THEN - RETURN Address + RETURN GetProcedureProcType (sym) ELSIF IsTyped (sym) THEN RETURN GetDType (sym) diff --git a/gcc/m2/gm2-compiler/M2FileName.def b/gcc/m2/gm2-compiler/M2FileName.def index 02413593003..01acb9b48d5 100644 --- a/gcc/m2/gm2-compiler/M2FileName.def +++ b/gcc/m2/gm2-compiler/M2FileName.def @@ -39,7 +39,7 @@ EXPORT QUALIFIED CalculateFileName, CalculateStemName, ExtractExtension ; given a module and an extension. This file name length will be operating system specific. String, Extension, is concatenated onto - Module and thus it is safe to `Mark' the extension + Module and thus it is safe to Mark the extension for garbage collection. *) diff --git a/gcc/m2/gm2-compiler/M2GenGCC.mod b/gcc/m2/gm2-compiler/M2GenGCC.mod index da52c924974..26ed399b24c 100644 --- a/gcc/m2/gm2-compiler/M2GenGCC.mod +++ b/gcc/m2/gm2-compiler/M2GenGCC.mod @@ -5000,29 +5000,32 @@ BEGIN TryDeclareConstant(tokenno, op3) ; location := TokenToLocation(tokenno) ; - IF CheckBinaryExpressionTypes (quad, p) + IF GccKnowsAbout(op2) AND GccKnowsAbout(op3) THEN - IF IsConst(op2) AND IsConstSet(op2) AND - IsConst(op3) AND IsConstSet(op3) AND - IsConst(op1) + IF CheckBinaryExpressionTypes (quad, p) THEN - IF IsValueSolved(op2) AND IsValueSolved(op3) + IF IsConst(op2) AND IsConstSet(op2) AND + IsConst(op3) AND IsConstSet(op3) AND + IsConst(op1) THEN - Assert(MixTypes(FindType(op3), FindType(op2), tokenno)#NulSym) ; - PutConst(op1, MixTypes(FindType(op3), FindType(op2), tokenno)) ; - PushValue(op2) ; - PushValue(op3) ; - op(tokenno) ; - PopValue(op1) ; - PushValue(op1) ; - PutConstSet(op1) ; - AddModGcc(op1, - DeclareKnownConstant(location, - Mod2Gcc(GetType(op3)), - PopSetTree(tokenno))) ; - p(op1) ; - NoChange := FALSE ; - SubQuad(quad) + IF IsValueSolved(op2) AND IsValueSolved(op3) + THEN + Assert(MixTypes(FindType(op3), FindType(op2), tokenno)#NulSym) ; + PutConst(op1, MixTypes(FindType(op3), FindType(op2), tokenno)) ; + PushValue(op2) ; + PushValue(op3) ; + op(tokenno) ; + PopValue(op1) ; + PushValue(op1) ; + PutConstSet(op1) ; + AddModGcc(op1, + DeclareKnownConstant(location, + Mod2Gcc(GetType(op3)), + PopSetTree(tokenno))) ; + p(op1) ; + NoChange := FALSE ; + SubQuad(quad) + END END END END diff --git a/gcc/m2/gm2-compiler/M2Quads.mod b/gcc/m2/gm2-compiler/M2Quads.mod index 68b91201702..8a9a23013b2 100644 --- a/gcc/m2/gm2-compiler/M2Quads.mod +++ b/gcc/m2/gm2-compiler/M2Quads.mod @@ -73,7 +73,7 @@ FROM SymbolTable IMPORT ModeOfAddr, GetMode, PutMode, GetSymName, IsUnknown, GetModuleQuads, GetProcedureQuads, GetModuleCtors, MakeProcedure, - CopyConstString, PutConstStringKnown, + PutConstStringKnown, PutModuleStartQuad, PutModuleEndQuad, PutModuleFinallyStartQuad, PutModuleFinallyEndQuad, PutProcedureStartQuad, PutProcedureEndQuad, @@ -3454,7 +3454,6 @@ BEGIN THEN GenQuadOtok (tokno, BecomesOp, Des, NulSym, Exp, TRUE, destok, UnknownTokenNo, exptok) ; - CopyConstString (tokno, Des, Exp) ELSE IF GetMode(Des)=RightValue THEN diff --git a/gcc/m2/gm2-compiler/M2Range.mod b/gcc/m2/gm2-compiler/M2Range.mod index 50c2a48fe7f..a8e572eff50 100644 --- a/gcc/m2/gm2-compiler/M2Range.mod +++ b/gcc/m2/gm2-compiler/M2Range.mod @@ -56,7 +56,7 @@ FROM M2Debug IMPORT Assert ; FROM Indexing IMPORT Index, InitIndex, InBounds, PutIndice, GetIndice ; FROM Storage IMPORT ALLOCATE ; FROM M2ALU IMPORT PushIntegerTree, PushInt, ConvertToInt, Equ, Gre, Less, GreEqu ; -FROM M2Options IMPORT VariantValueChecking, CaseEnumChecking ; +FROM M2Options IMPORT VariantValueChecking, CaseEnumChecking, GetPIM ; FROM M2Error IMPORT Error, InternalError, ErrorFormat0, ErrorFormat1, ErrorFormat2, FlushErrors, GetAnnounceScope ; @@ -1693,14 +1693,33 @@ END FoldTypeAssign ; (* - FoldTypeParam - + FoldTypeParam - performs a parameter check between actual and formal. + The quad is removed if the check succeeds. *) PROCEDURE FoldTypeParam (q: CARDINAL; tokenNo: CARDINAL; formal, actual, procedure: CARDINAL; paramNo: CARDINAL) ; +VAR + compatible: BOOLEAN ; BEGIN - IF ParameterTypeCompatible (tokenNo, - '{%4EN} parameter type failure between actual parameter type {%3ad} and the formal type {%2ad}', - procedure, formal, actual, paramNo, IsVarParam (procedure, paramNo)) + compatible := FALSE ; + IF IsVarParam (procedure, paramNo) + THEN + (* Expression type compatibility rules for pass by reference parameters. *) + compatible := ParameterTypeCompatible (tokenNo, + '{%4EN} parameter failure due to expression incompatibility between actual parameter {%3ad} and the {%4N} formal {%2ad} parameter in procedure {%1ad}', + procedure, formal, actual, paramNo, TRUE) + ELSIF GetPIM () + THEN + (* Assignment type compatibility rules for pass by value PIM parameters. *) + compatible := ParameterTypeCompatible (tokenNo, + '{%4EN} parameter failure due to assignment incompatibility between actual parameter {%3ad} and the {%4N} formal {%2ad} parameter in procedure {%1ad}', + procedure, formal, actual, paramNo, FALSE) + ELSE + compatible := ParameterTypeCompatible (tokenNo, + '{%4EN} parameter failure due to parameter incompatibility between actual parameter {%3ad} and the {%4N} formal {%2ad} parameter in procedure {%1ad}', + procedure, formal, actual, paramNo, FALSE) + END ; + IF compatible THEN SubQuad(q) END @@ -1719,7 +1738,8 @@ BEGIN 'expression of type {%1Etad} is incompatible with type {%2tad}', left, right, strict, isin) THEN - SubQuad(q) ; + SubQuad(q) + ELSE setReported (r) END END diff --git a/gcc/m2/gm2-compiler/SymbolTable.def b/gcc/m2/gm2-compiler/SymbolTable.def index ec48631e43f..06f8a227563 100644 --- a/gcc/m2/gm2-compiler/SymbolTable.def +++ b/gcc/m2/gm2-compiler/SymbolTable.def @@ -1395,6 +1395,13 @@ PROCEDURE IsProcedureNoReturn (Sym: CARDINAL) : BOOLEAN ; (* + GetProcedureProcType - returns the proctype matching procedure sym. +*) + +PROCEDURE GetProcedureProcType (sym: CARDINAL) : CARDINAL ; + + +(* PutModuleStartQuad - Places QuadNumber into the Module symbol, Sym. QuadNumber is the start quad of Module, Sym. @@ -3030,6 +3037,14 @@ PROCEDURE IsHiddenTypeDeclared (Sym: CARDINAL) : BOOLEAN ; (* + IsHiddenReallyPointer - returns TRUE is sym is a pointer, address or a + type declared as a pointer or address. +*) + +PROCEDURE IsHiddenReallyPointer (Sym: CARDINAL) : BOOLEAN ; + + +(* DisplayTrees - displays the SymbolTrees for Module symbol, ModSym. *) diff --git a/gcc/m2/gm2-compiler/SymbolTable.mod b/gcc/m2/gm2-compiler/SymbolTable.mod index 13ee1fb6fe3..f5890ec684f 100644 --- a/gcc/m2/gm2-compiler/SymbolTable.mod +++ b/gcc/m2/gm2-compiler/SymbolTable.mod @@ -407,6 +407,7 @@ TYPE SavePriority : BOOLEAN ; (* Does procedure need to save *) (* and restore interrupts? *) ReturnType : CARDINAL ; (* Return type for function. *) + ProcedureType : CARDINAL ; (* Proc type for this procedure. *) Offset : CARDINAL ; (* Location of procedure used *) (* in Pass 2 and if procedure *) (* is a syscall. *) @@ -3972,6 +3973,8 @@ BEGIN SavePriority := FALSE ; (* Does procedure need to save *) (* and restore interrupts? *) ReturnType := NulSym ; (* Not a function yet! *) + (* The ProcType equivalent. *) + ProcedureType := MakeProcType (tok, NulName) ; Offset := 0 ; (* Location of procedure. *) InitTree(LocalSymbols) ; InitList(EnumerationScopeList) ; @@ -3993,7 +3996,7 @@ BEGIN := InitValue() ; (* size of all parameters. *) Begin := 0 ; (* token number for BEGIN *) End := 0 ; (* token number for END *) - InitWhereDeclaredTok(tok, At) ; (* Where symbol declared. *) + InitWhereDeclaredTok(tok, At) ; (* Where the symbol was declared. *) errorScope := GetCurrentErrorScope () ; (* Title error scope. *) END END ; @@ -8011,37 +8014,16 @@ END CheckForHiddenType ; PROCEDURE IsReallyPointer (Sym: CARDINAL) : BOOLEAN ; BEGIN - IF IsVar(Sym) + IF IsVar (Sym) THEN - Sym := GetType(Sym) + Sym := GetType (Sym) END ; - Sym := SkipType(Sym) ; - RETURN( IsPointer(Sym) OR (Sym=Address) ) + Sym := SkipType (Sym) ; + RETURN IsPointer (Sym) OR (Sym = Address) OR IsHiddenReallyPointer (Sym) END IsReallyPointer ; (* - SkipHiddenType - if sym is a TYPE foo = bar - then call SkipType(bar) - else return sym - - it does skip over hidden type. -*) - -(* -PROCEDURE SkipHiddenType (Sym: CARDINAL) : CARDINAL ; -BEGIN - IF (Sym#NulSym) AND IsType(Sym) AND (GetType(Sym)#NulSym) - THEN - RETURN( SkipType(GetType(Sym)) ) - ELSE - RETURN( Sym ) - END -END SkipHiddenType ; -*) - - -(* IsHiddenReallyPointer - returns TRUE is sym is a pointer, address or a type declared as a pointer or address. *) @@ -10095,8 +10077,11 @@ BEGIN CASE SymbolType OF ErrorSym: | - ProcedureSym: CheckOptFunction(Sym, FALSE) ; Procedure.ReturnType := TypeSym | - ProcTypeSym : CheckOptFunction(Sym, FALSE) ; ProcType.ReturnType := TypeSym + ProcedureSym: CheckOptFunction(Sym, FALSE) ; + Procedure.ReturnType := TypeSym ; + PutFunction (Procedure.ProcedureType, TypeSym) | + ProcTypeSym : CheckOptFunction(Sym, FALSE) ; + ProcType.ReturnType := TypeSym ELSE InternalError ('expecting a Procedure or ProcType symbol') @@ -10113,13 +10098,16 @@ PROCEDURE PutOptFunction (Sym: CARDINAL; TypeSym: CARDINAL) ; VAR pSym: PtrToSymbol ; BEGIN - pSym := GetPsym(Sym) ; + pSym := GetPsym (Sym) ; WITH pSym^ DO CASE SymbolType OF ErrorSym: | - ProcedureSym: CheckOptFunction(Sym, TRUE) ; Procedure.ReturnType := TypeSym | - ProcTypeSym : CheckOptFunction(Sym, TRUE) ; ProcType.ReturnType := TypeSym + ProcedureSym: CheckOptFunction (Sym, TRUE) ; + Procedure.ReturnType := TypeSym ; + PutOptFunction (Procedure.ProcedureType, TypeSym) | + ProcTypeSym : CheckOptFunction (Sym, TRUE) ; + ProcType.ReturnType := TypeSym ELSE InternalError ('expecting a Procedure or ProcType symbol') @@ -10215,7 +10203,8 @@ BEGIN pSym := GetPsym(ParSym) ; pSym^.Param.ShadowVar := VariableSym END - END + END ; + AddProcedureProcTypeParam (Sym, ParamType, isUnbounded, FALSE) END ; RETURN( TRUE ) END PutParam ; @@ -10268,6 +10257,7 @@ BEGIN pSym^.VarParam.ShadowVar := VariableSym END END ; + AddProcedureProcTypeParam (Sym, ParamType, isUnbounded, TRUE) ; RETURN( TRUE ) END END PutVarParam ; @@ -10346,6 +10336,36 @@ END AddParameter ; (* + AddProcedureProcTypeParam - adds ParamType to the parameter ProcType + associated with procedure Sym. +*) + +PROCEDURE AddProcedureProcTypeParam (Sym, ParamType: CARDINAL; + isUnbounded, isVarParam: BOOLEAN) ; +VAR + pSym: PtrToSymbol ; +BEGIN + pSym := GetPsym (Sym) ; + WITH pSym^ DO + CASE SymbolType OF + + ProcedureSym: IF isVarParam + THEN + PutProcTypeVarParam (Procedure.ProcedureType, + ParamType, isUnbounded) + ELSE + PutProcTypeParam (Procedure.ProcedureType, + ParamType, isUnbounded) + END + + ELSE + InternalError ('expecting Sym to be a procedure') + END + END +END AddProcedureProcTypeParam ; + + +(* IsVarParam - Returns a conditional depending whether parameter ParamNo is a VAR parameter. *) @@ -12624,6 +12644,27 @@ END PutProcTypeVarParam ; (* + GetProcedureProcType - returns the proctype matching procedure sym. +*) + +PROCEDURE GetProcedureProcType (sym: CARDINAL) : CARDINAL ; +VAR + pSym: PtrToSymbol ; +BEGIN + pSym := GetPsym(sym) ; + WITH pSym^ DO + CASE SymbolType OF + + ProcedureSym: RETURN Procedure.ProcedureType + + ELSE + InternalError ('expecting Procedure symbol') + END + END +END GetProcedureProcType ; + + +(* PutProcedureReachable - Sets the procedure, Sym, to be reachable by the main Module. *) diff --git a/gcc/m2/lang.opt b/gcc/m2/lang.opt index 206bd03d09f..1c165317959 100644 --- a/gcc/m2/lang.opt +++ b/gcc/m2/lang.opt @@ -96,7 +96,7 @@ turn on tracing of procedure line numbers (internal switch) fdef= Modula-2 Joined -recognise the specified suffix as a definition module filename +recognize the specified suffix as a definition module filename fdump-system-exports Modula-2 @@ -172,7 +172,7 @@ compile all implementation modules and program module at once fmod= Modula-2 Joined -recognise the specified suffix as implementation and module filenames +recognize the specified suffix as implementation and module filenames fnil Modula-2 @@ -260,7 +260,7 @@ optimize non var unbounded parameters by passing it by reference, providing it i fuse-list= Modula-2 Joined -orders the initialization/finalializations for scaffold-static or force linking of modules if scaffold-dynamic +orders the initialization/finalizations for scaffold-static or force linking of modules if scaffold-dynamic fversion Modula-2 @@ -278,7 +278,7 @@ static-libgm2 Driver Link the standard Modula-2 libraries statically in the compilation. -; Here are C options that we also recognise, either within the compiler +; Here are C options that we also recognize, either within the compiler ; or to build the preprocessor command lines. Wall diff --git a/gcc/optabs-tree.cc b/gcc/optabs-tree.cc index e7bd0d10892..b69a5bc3676 100644 --- a/gcc/optabs-tree.cc +++ b/gcc/optabs-tree.cc @@ -135,6 +135,12 @@ optab_for_tree_code (enum tree_code code, const_tree type, case MIN_EXPR: return TYPE_UNSIGNED (type) ? umin_optab : smin_optab; + case POINTER_PLUS_EXPR: + return add_optab; + + case POINTER_DIFF_EXPR: + return sub_optab; + case REALIGN_LOAD_EXPR: return vec_realign_load_optab; @@ -249,13 +255,11 @@ optab_for_tree_code (enum tree_code code, const_tree type, trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type); switch (code) { - case POINTER_PLUS_EXPR: case PLUS_EXPR: if (TYPE_SATURATING (type)) return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab; return trapv ? addv_optab : add_optab; - case POINTER_DIFF_EXPR: case MINUS_EXPR: if (TYPE_SATURATING (type)) return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab; diff --git a/gcc/opts.cc b/gcc/opts.cc index a90dc57f8b5..3333600e0ea 100644 --- a/gcc/opts.cc +++ b/gcc/opts.cc @@ -3761,19 +3761,7 @@ get_option_url (const diagnostic_context *, { label_text url_suffix = get_option_url_suffix (option_index, lang_mask); if (url_suffix.get ()) - { - char infix[32]; - /* On release branches, append to DOCUMENTATION_ROOT_URL the - subdirectory with documentation of the latest release made - from the branch. */ - if (BUILDING_GCC_MINOR != 0 && BUILDING_GCC_PATCHLEVEL <= 1U) - sprintf (infix, "gcc-%u.%u.0/", - BUILDING_GCC_MAJOR, BUILDING_GCC_MINOR); - else - infix[0] = '\0'; - return concat (DOCUMENTATION_ROOT_URL, infix, url_suffix.get (), - nullptr); - } + return concat (DOCUMENTATION_ROOT_URL, url_suffix.get (), nullptr); } return nullptr; diff --git a/gcc/params.opt b/gcc/params.opt index 5eb045b2e6c..d34ef545bf0 100644 --- a/gcc/params.opt +++ b/gcc/params.opt @@ -263,7 +263,7 @@ Maximum size of a list of values associated with each parameter for interprocedu -param=ipa-cp-profile-count-base= Common Joined UInteger Var(param_ipa_cp_profile_count_base) Init(10) IntegerRange(0, 100) Param Optimization -When using profile feedback, use the edge at this percentage position in frequncy histogram as the bases for IPA-CP heuristics. +When using profile feedback, use the edge at this percentage position in frequency histogram as the bases for IPA-CP heuristics. -param=ipa-jump-function-lookups= Common Joined UInteger Var(param_ipa_jump_function_lookups) Init(8) Param Optimization diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index 94470aa8ff8..bb90627a59c 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,11 @@ +2024-04-23 Joseph Myers <josmyers@redhat.com> + + * gcc.pot: Regenerate. + +2024-04-19 Joseph Myers <josmyers@redhat.com> + + * sv.po: Update. + 2024-04-10 Joseph Myers <josmyers@redhat.com> * gcc.pot: Regenerate. diff --git a/gcc/po/gcc.pot b/gcc/po/gcc.pot index 70c952734a3..2a180da69bb 100644 --- a/gcc/po/gcc.pot +++ b/gcc/po/gcc.pot @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n" -"POT-Creation-Date: 2024-04-10 17:10+0000\n" +"POT-Creation-Date: 2024-04-23 20:27+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Language-Team: LANGUAGE <LL@li.org>\n" @@ -543,7 +543,7 @@ msgstr "" msgid "Warn about creation of array temporaries." msgstr "" -#: fortran/lang.opt:214 fortran/lang.opt:539 c-family/c.opt:1594 +#: fortran/lang.opt:214 fortran/lang.opt:539 c-family/c.opt:1598 #: config/alpha/alpha.opt:31 common.opt:685 common.opt:831 common.opt:1079 #: common.opt:1083 common.opt:1087 common.opt:1091 common.opt:1819 #: common.opt:1922 common.opt:2099 common.opt:2103 common.opt:2382 @@ -1163,8 +1163,8 @@ msgstr "" msgid "Append underscores to externally visible names." msgstr "" -#: fortran/lang.opt:832 c-family/c.opt:1729 c-family/c.opt:1806 -#: c-family/c.opt:1814 c-family/c.opt:2145 config/xtensa/xtensa.opt:42 +#: fortran/lang.opt:832 c-family/c.opt:1733 c-family/c.opt:1810 +#: c-family/c.opt:1818 c-family/c.opt:2149 config/xtensa/xtensa.opt:42 #: config/pa/pa.opt:46 config/pa/pa.opt:78 config/arc/arc.opt:140 #: config/arc/arc.opt:296 config/arc/arc.opt:304 config/arc/arc.opt:308 #: config/arc/arc.opt:312 config/arc/arc.opt:317 config/arc/arc.opt:326 @@ -1230,19 +1230,19 @@ msgstr "" msgid "Accept extensions to support legacy code." msgstr "" -#: rust/lang.opt:47 rust/lang.opt:51 c-family/c.opt:1465 c-family/c.opt:1469 +#: rust/lang.opt:47 rust/lang.opt:51 c-family/c.opt:1469 c-family/c.opt:1473 #, no-c-format msgid "Warn when a const variable is unused." msgstr "" -#: rust/lang.opt:55 c-family/c.opt:1481 +#: rust/lang.opt:55 c-family/c.opt:1485 #, no-c-format msgid "" "Warn if a caller of a function, marked with attribute warn_unused_result, " "does not use its return value." msgstr "" -#: rust/lang.opt:59 c-family/c.opt:850 common.opt:654 +#: rust/lang.opt:59 c-family/c.opt:854 common.opt:654 #, no-c-format msgid "Warn for infinitely recursive calls." msgstr "" @@ -1719,987 +1719,994 @@ msgstr "" msgid "Warn about casts which discard qualifiers." msgstr "" -#: c-family/c.opt:519 c-family/c.opt:523 +#: c-family/c.opt:519 +#, no-c-format +msgid "" +"Warn about a cast to reference type that does not use a related user-defined " +"conversion function." +msgstr "" + +#: c-family/c.opt:523 c-family/c.opt:527 #, no-c-format msgid "Warn about catch handlers of non-reference type." msgstr "" -#: c-family/c.opt:527 +#: c-family/c.opt:531 #, no-c-format msgid "" "Complain about a name being declared as a class member after a previous use " "of the same name." msgstr "" -#: c-family/c.opt:531 +#: c-family/c.opt:535 #, no-c-format msgid "Warn about subscripts whose type is \"char\"." msgstr "" -#: c-family/c.opt:535 c-family/c.opt:1626 c-family/c.opt:1630 -#: c-family/c.opt:1634 c-family/c.opt:1638 c-family/c.opt:1642 -#: c-family/c.opt:1646 c-family/c.opt:1650 c-family/c.opt:1657 -#: c-family/c.opt:1661 c-family/c.opt:1665 c-family/c.opt:1669 -#: c-family/c.opt:1673 c-family/c.opt:1677 c-family/c.opt:1681 -#: c-family/c.opt:1685 c-family/c.opt:1689 c-family/c.opt:1693 -#: c-family/c.opt:1697 c-family/c.opt:1701 c-family/c.opt:1705 +#: c-family/c.opt:539 c-family/c.opt:1630 c-family/c.opt:1634 +#: c-family/c.opt:1638 c-family/c.opt:1642 c-family/c.opt:1646 +#: c-family/c.opt:1650 c-family/c.opt:1654 c-family/c.opt:1661 +#: c-family/c.opt:1665 c-family/c.opt:1669 c-family/c.opt:1673 +#: c-family/c.opt:1677 c-family/c.opt:1681 c-family/c.opt:1685 +#: c-family/c.opt:1689 c-family/c.opt:1693 c-family/c.opt:1697 +#: c-family/c.opt:1701 c-family/c.opt:1705 c-family/c.opt:1709 #: config/i386/i386.opt:1022 #, no-c-format msgid "Removed in GCC 9. This switch has no effect." msgstr "" -#: c-family/c.opt:539 +#: c-family/c.opt:543 #, no-c-format msgid "" "Warn when a conversion function will never be called due to the type it " "converts to." msgstr "" -#: c-family/c.opt:543 +#: c-family/c.opt:547 #, no-c-format msgid "Warn for unsafe raw memory writes to objects of class types." msgstr "" -#: c-family/c.opt:547 +#: c-family/c.opt:551 #, no-c-format msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\"." msgstr "" -#: c-family/c.opt:551 +#: c-family/c.opt:555 #, no-c-format msgid "Warn about uses of a comma operator within a subscripting expression." msgstr "" -#: c-family/c.opt:555 +#: c-family/c.opt:559 #, no-c-format msgid "" "Warn about possibly nested block comments, and C++ comments spanning more " "than one physical line." msgstr "" -#: c-family/c.opt:559 +#: c-family/c.opt:563 #, no-c-format msgid "Synonym for -Wcomment." msgstr "" -#: c-family/c.opt:563 +#: c-family/c.opt:567 #, no-c-format msgid "Warn for conditionally-supported constructs." msgstr "" -#: c-family/c.opt:567 +#: c-family/c.opt:571 #, no-c-format msgid "Warn for implicit type conversions that may change a value." msgstr "" -#: c-family/c.opt:571 +#: c-family/c.opt:575 #, no-c-format msgid "Warn for converting NULL from/to a non-pointer type." msgstr "" -#: c-family/c.opt:579 +#: c-family/c.opt:583 #, no-c-format msgid "" "Warn when performing class template argument deduction on a type with no " "deduction guides." msgstr "" -#: c-family/c.opt:584 +#: c-family/c.opt:588 #, no-c-format msgid "Warn when all constructors and destructors are private." msgstr "" -#: c-family/c.opt:588 +#: c-family/c.opt:592 #, no-c-format msgid "Warn about dangling else." msgstr "" -#: c-family/c.opt:592 c-family/c.opt:596 +#: c-family/c.opt:596 c-family/c.opt:600 #, no-c-format msgid "Warn for uses of pointers to auto variables whose lifetime has ended." msgstr "" -#: c-family/c.opt:600 +#: c-family/c.opt:604 #, no-c-format msgid "Warn when a reference is bound to a temporary whose lifetime has ended." msgstr "" -#: c-family/c.opt:604 +#: c-family/c.opt:608 #, no-c-format msgid "Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage." msgstr "" -#: c-family/c.opt:608 +#: c-family/c.opt:612 #, no-c-format msgid "Warn when a declaration is found after a statement." msgstr "" -#: c-family/c.opt:612 +#: c-family/c.opt:616 #, no-c-format msgid "Warn for missing parameter types in function declarations." msgstr "" -#: c-family/c.opt:616 +#: c-family/c.opt:620 #, no-c-format msgid "Warn when deleting a pointer to incomplete type." msgstr "" -#: c-family/c.opt:620 +#: c-family/c.opt:624 #, no-c-format msgid "Warn about deleting polymorphic objects with non-virtual destructors." msgstr "" -#: c-family/c.opt:628 +#: c-family/c.opt:632 #, no-c-format msgid "" "Mark implicitly-declared copy operations as deprecated if the class has a " "user-provided copy operation." msgstr "" -#: c-family/c.opt:633 +#: c-family/c.opt:637 #, no-c-format msgid "" "Mark implicitly-declared copy operations as deprecated if the class has a " "user-provided copy operation or destructor." msgstr "" -#: c-family/c.opt:638 +#: c-family/c.opt:642 #, no-c-format msgid "" "Warn about deprecated arithmetic conversions on operands of enumeration " "types." msgstr "" -#: c-family/c.opt:642 +#: c-family/c.opt:646 #, no-c-format msgid "" "Warn about deprecated arithmetic conversions on operands where one is of " "enumeration type and the other is of a floating-point type." msgstr "" -#: c-family/c.opt:647 +#: c-family/c.opt:651 #, no-c-format msgid "" "Warn about positional initialization of structs requiring designated " "initializers." msgstr "" -#: c-family/c.opt:651 +#: c-family/c.opt:655 #, no-c-format msgid "Warn if qualifiers on arrays which are pointer targets are discarded." msgstr "" -#: c-family/c.opt:655 +#: c-family/c.opt:659 #, no-c-format msgid "Warn if type qualifiers on pointers are discarded." msgstr "" -#: c-family/c.opt:659 +#: c-family/c.opt:663 #, no-c-format msgid "Warn about compile-time integer division by zero." msgstr "" -#: c-family/c.opt:663 +#: c-family/c.opt:667 #, no-c-format msgid "Warn about implicit conversions from \"float\" to \"double\"." msgstr "" -#: c-family/c.opt:667 +#: c-family/c.opt:671 #, no-c-format msgid "" "Warn when a declaration has duplicate const, volatile, restrict or _Atomic " "specifier." msgstr "" -#: c-family/c.opt:671 +#: c-family/c.opt:675 #, no-c-format msgid "Warn about duplicated branches in if-else statements." msgstr "" -#: c-family/c.opt:675 +#: c-family/c.opt:679 #, no-c-format msgid "Warn about duplicated conditions in an if-else-if chain." msgstr "" -#: c-family/c.opt:679 +#: c-family/c.opt:683 #, no-c-format msgid "Warn about violations of Effective C++ style rules." msgstr "" -#: c-family/c.opt:683 +#: c-family/c.opt:687 #, no-c-format msgid "" "Warn if an additional enum-base is used in an elaborated-type-specifier." msgstr "" -#: c-family/c.opt:687 +#: c-family/c.opt:691 #, no-c-format msgid "Warn about an empty body in an if or else statement." msgstr "" -#: c-family/c.opt:691 +#: c-family/c.opt:695 #, no-c-format msgid "Warn about stray tokens after #else and #endif." msgstr "" -#: c-family/c.opt:695 +#: c-family/c.opt:699 #, no-c-format msgid "Warn about comparison of different enum types." msgstr "" -#: c-family/c.opt:699 +#: c-family/c.opt:703 #, no-c-format msgid "Warn about implicit conversion of enum types." msgstr "" -#: c-family/c.opt:703 +#: c-family/c.opt:707 #, no-c-format msgid "Warn about enum/integer type mismatches." msgstr "" -#: c-family/c.opt:711 +#: c-family/c.opt:715 #, no-c-format msgid "" "This switch is deprecated; use -Werror=implicit-function-declaration instead." msgstr "" -#: c-family/c.opt:715 +#: c-family/c.opt:719 #, no-c-format msgid "Warn when an exception handler is shadowed by another handler." msgstr "" -#: c-family/c.opt:719 +#: c-family/c.opt:723 #, no-c-format msgid "Warn if \"defined\" is used outside #if." msgstr "" -#: c-family/c.opt:727 +#: c-family/c.opt:731 #, no-c-format msgid "Warn about semicolon after in-class function definition." msgstr "" -#: c-family/c.opt:731 +#: c-family/c.opt:735 #, no-c-format msgid "" "Warn when a structure containing a C99 flexible array member as the last " "field is not at the end of another structure." msgstr "" -#: c-family/c.opt:736 +#: c-family/c.opt:740 #, no-c-format msgid "" "Warn for implicit type conversions that cause loss of floating point " "precision." msgstr "" -#: c-family/c.opt:740 +#: c-family/c.opt:744 #, no-c-format msgid "Warn if testing floating point numbers for equality." msgstr "" -#: c-family/c.opt:744 c-family/c.opt:799 +#: c-family/c.opt:748 c-family/c.opt:803 #, no-c-format msgid "Warn about printf/scanf/strftime/strfmon format string anomalies." msgstr "" -#: c-family/c.opt:748 +#: c-family/c.opt:752 #, no-c-format msgid "Warn about format strings that contain NUL bytes." msgstr "" -#: c-family/c.opt:752 +#: c-family/c.opt:756 #, no-c-format msgid "Warn about GCC format strings with strings unsuitable for diagnostics." msgstr "" -#: c-family/c.opt:756 +#: c-family/c.opt:760 #, no-c-format msgid "Warn if passing too many arguments to a function for its format string." msgstr "" -#: c-family/c.opt:760 +#: c-family/c.opt:764 #, no-c-format msgid "Warn about format strings that are not literals." msgstr "" -#: c-family/c.opt:764 +#: c-family/c.opt:768 #, no-c-format msgid "" "Warn about function calls with format strings that write past the end of the " "destination region. Same as -Wformat-overflow=1." msgstr "" -#: c-family/c.opt:769 +#: c-family/c.opt:773 #, no-c-format msgid "" "Warn about function calls with format strings that write past the end of the " "destination region." msgstr "" -#: c-family/c.opt:774 +#: c-family/c.opt:778 #, no-c-format msgid "Warn about possible security problems with format functions." msgstr "" -#: c-family/c.opt:778 +#: c-family/c.opt:782 #, no-c-format msgid "Warn about sign differences with format functions." msgstr "" -#: c-family/c.opt:782 +#: c-family/c.opt:786 #, no-c-format msgid "" "Warn about calls to snprintf and similar functions that truncate output. " "Same as -Wformat-truncation=1." msgstr "" -#: c-family/c.opt:787 +#: c-family/c.opt:791 #, no-c-format msgid "" "Warn about calls to snprintf and similar functions that truncate output." msgstr "" -#: c-family/c.opt:791 +#: c-family/c.opt:795 #, no-c-format msgid "Warn about strftime formats yielding 2-digit years." msgstr "" -#: c-family/c.opt:795 +#: c-family/c.opt:799 #, no-c-format msgid "Warn about zero-length formats." msgstr "" -#: c-family/c.opt:803 +#: c-family/c.opt:807 #, no-c-format msgid "" "Warn when __builtin_frame_address or __builtin_return_address is used " "unsafely." msgstr "" -#: c-family/c.opt:807 +#: c-family/c.opt:811 #, no-c-format msgid "" "Warn about the global module fragment not containing only preprocessing " "directives." msgstr "" -#: c-family/c.opt:811 +#: c-family/c.opt:815 #, no-c-format msgid "Warn when the field in a struct is not aligned." msgstr "" -#: c-family/c.opt:815 +#: c-family/c.opt:819 #, no-c-format msgid "Warn whenever type qualifiers are ignored." msgstr "" -#: c-family/c.opt:819 +#: c-family/c.opt:823 #, no-c-format msgid "Warn whenever attributes are ignored." msgstr "" -#: c-family/c.opt:823 +#: c-family/c.opt:827 #, no-c-format msgid "Warn about implicit declarations." msgstr "" -#: c-family/c.opt:831 +#: c-family/c.opt:835 #, no-c-format msgid "Warn about implicit function declarations." msgstr "" -#: c-family/c.opt:835 +#: c-family/c.opt:839 #, no-c-format msgid "Warn when a declaration does not specify a type." msgstr "" -#: c-family/c.opt:842 +#: c-family/c.opt:846 #, no-c-format msgid "Warn when a base is inaccessible in derived due to ambiguity." msgstr "" -#: c-family/c.opt:846 +#: c-family/c.opt:850 #, no-c-format msgid "" "Warn when there is a conversion between pointers that have incompatible " "types." msgstr "" -#: c-family/c.opt:854 +#: c-family/c.opt:858 #, no-c-format msgid "Warn about variables which are initialized to themselves." msgstr "" -#: c-family/c.opt:858 +#: c-family/c.opt:862 #, no-c-format msgid "" "Warn about uses of std::initializer_list that can result in dangling " "pointers." msgstr "" -#: c-family/c.opt:862 +#: c-family/c.opt:866 #, no-c-format msgid "" "Warn about nonsensical values of --param destructive-interference-size or " "constructive-interference-size." msgstr "" -#: c-family/c.opt:867 +#: c-family/c.opt:871 #, no-c-format msgid "" "Warn about C++11 inheriting constructors when the base has a variadic " "constructor." msgstr "" -#: c-family/c.opt:871 +#: c-family/c.opt:875 #, no-c-format msgid "" "Warn about incompatible integer to pointer and pointer to integer " "conversions." msgstr "" -#: c-family/c.opt:875 +#: c-family/c.opt:879 #, no-c-format msgid "Warn for suspicious integer expressions in boolean context." msgstr "" -#: c-family/c.opt:879 +#: c-family/c.opt:883 #, no-c-format msgid "" "Warn when there is a cast to a pointer from an integer of a different size." msgstr "" -#: c-family/c.opt:883 +#: c-family/c.opt:887 #, no-c-format msgid "Warn when a function never produces a constant expression." msgstr "" -#: c-family/c.opt:887 +#: c-family/c.opt:891 #, no-c-format msgid "Warn about invalid uses of the \"offsetof\" macro." msgstr "" -#: c-family/c.opt:891 +#: c-family/c.opt:895 #, no-c-format msgid "Warn about PCH files that are found but not used." msgstr "" -#: c-family/c.opt:895 +#: c-family/c.opt:899 #, no-c-format msgid "Warn about invalid UTF-8 characters." msgstr "" -#: c-family/c.opt:899 +#: c-family/c.opt:903 #, no-c-format msgid "Warn when a jump misses a variable initialization." msgstr "" -#: c-family/c.opt:903 +#: c-family/c.opt:907 #, no-c-format msgid "" "Warn when a string or character literal is followed by a ud-suffix which " "does not begin with an underscore." msgstr "" -#: c-family/c.opt:907 +#: c-family/c.opt:911 #, no-c-format msgid "" "Warn when logical not is used on the left hand side operand of a comparison." msgstr "" -#: c-family/c.opt:911 +#: c-family/c.opt:915 #, no-c-format msgid "" "Warn when a logical operator is suspiciously always evaluating to true or " "false." msgstr "" -#: c-family/c.opt:915 +#: c-family/c.opt:919 #, no-c-format msgid "Do not warn about using \"long long\" when -pedantic." msgstr "" -#: c-family/c.opt:919 +#: c-family/c.opt:923 #, no-c-format msgid "Warn about suspicious declarations of \"main\"." msgstr "" -#: c-family/c.opt:931 +#: c-family/c.opt:935 #, no-c-format msgid "" "Warn about suspicious calls to memset where the third argument contains the " "number of elements not multiplied by the element size." msgstr "" -#: c-family/c.opt:935 +#: c-family/c.opt:939 #, no-c-format msgid "" "Warn about suspicious calls to memset where the third argument is constant " "literal zero and the second is not." msgstr "" -#: c-family/c.opt:939 +#: c-family/c.opt:943 #, no-c-format msgid "" "Warn when the indentation of the code does not reflect the block structure." msgstr "" -#: c-family/c.opt:943 +#: c-family/c.opt:947 #, no-c-format msgid "" "Warn for deallocation calls with arguments returned from mismatched " "allocation functions." msgstr "" -#: c-family/c.opt:948 +#: c-family/c.opt:952 #, no-c-format msgid "" "Warn for mismatches between calls to operator new or delete and the " "corresponding call to the allocation or deallocation function." msgstr "" -#: c-family/c.opt:953 +#: c-family/c.opt:957 #, no-c-format msgid "" "Warn when a class is redeclared or referenced using a mismatched class-key." msgstr "" -#: c-family/c.opt:957 +#: c-family/c.opt:961 #, no-c-format msgid "" "Warn about declarations of entities that may be missing attributes that " "related entities have been declared with." msgstr "" -#: c-family/c.opt:962 +#: c-family/c.opt:966 #, no-c-format msgid "Warn about possibly missing braces around initializers." msgstr "" -#: c-family/c.opt:966 +#: c-family/c.opt:970 #, no-c-format msgid "Warn about global functions without previous declarations." msgstr "" -#: c-family/c.opt:970 +#: c-family/c.opt:974 #, no-c-format msgid "Warn about missing fields in struct initializers." msgstr "" -#: c-family/c.opt:978 +#: c-family/c.opt:982 #, no-c-format msgid "Warn about user-specified include directories that do not exist." msgstr "" -#: c-family/c.opt:982 +#: c-family/c.opt:986 #, no-c-format msgid "" "Warn about function parameters declared without a type specifier in K&R-" "style functions." msgstr "" -#: c-family/c.opt:986 +#: c-family/c.opt:990 #, no-c-format msgid "Warn about global functions without prototypes." msgstr "" -#: c-family/c.opt:990 +#: c-family/c.opt:994 #, no-c-format msgid "Warn about likely missing requires keyword." msgstr "" -#: c-family/c.opt:994 +#: c-family/c.opt:998 #, no-c-format msgid "" "Warn when the template keyword is missing after a member access token in a " "dependent member access expression if that member is a template." msgstr "" -#: c-family/c.opt:998 +#: c-family/c.opt:1002 #, no-c-format msgid "Warn about global variables without previous declarations." msgstr "" -#: c-family/c.opt:1005 +#: c-family/c.opt:1009 #, no-c-format msgid "Warn about use of multi-character character constants." msgstr "" -#: c-family/c.opt:1009 +#: c-family/c.opt:1013 #, no-c-format msgid "Warn on direct multiple inheritance." msgstr "" -#: c-family/c.opt:1013 +#: c-family/c.opt:1017 #, no-c-format msgid "" "Warn about unsafe macros expanding to multiple statements used as a body of " "a clause such as if, else, while, switch, or for." msgstr "" -#: c-family/c.opt:1017 +#: c-family/c.opt:1021 #, no-c-format msgid "Warn on namespace definition." msgstr "" -#: c-family/c.opt:1021 +#: c-family/c.opt:1025 #, no-c-format msgid "" "Warn about narrowing conversions within { } that are ill-formed in C++11." msgstr "" -#: c-family/c.opt:1025 +#: c-family/c.opt:1029 #, no-c-format msgid "Warn about \"extern\" declarations not at file scope." msgstr "" -#: c-family/c.opt:1029 +#: c-family/c.opt:1033 #, no-c-format msgid "" "Warn when a noexcept expression evaluates to false even though the " "expression can't actually throw." msgstr "" -#: c-family/c.opt:1033 +#: c-family/c.opt:1037 #, no-c-format msgid "" "Warn if C++17 noexcept function type will change the mangled name of a " "symbol." msgstr "" -#: c-family/c.opt:1037 +#: c-family/c.opt:1041 #, no-c-format msgid "" "Warn when non-templatized friend functions are declared within a template." msgstr "" -#: c-family/c.opt:1041 +#: c-family/c.opt:1045 #, no-c-format msgid "Warn about non-virtual destructors." msgstr "" -#: c-family/c.opt:1045 +#: c-family/c.opt:1049 #, no-c-format msgid "" "Warn about NULL being passed to argument slots marked as requiring non-NULL." msgstr "" -#: c-family/c.opt:1061 +#: c-family/c.opt:1065 #, no-c-format msgid "" "-Wnormalized=[none|id|nfc|nfkc]\tWarn about non-normalized Unicode strings." msgstr "" -#: c-family/c.opt:1084 +#: c-family/c.opt:1088 #, no-c-format msgid "" "Warn if a class interface has no superclass. Root classes may use an " "attribute to suppress this warning." msgstr "" -#: c-family/c.opt:1089 +#: c-family/c.opt:1093 #, no-c-format msgid "Warn if a C-style cast is used in a program." msgstr "" -#: c-family/c.opt:1093 +#: c-family/c.opt:1097 #, no-c-format msgid "Warn for obsolescent usage in a declaration." msgstr "" -#: c-family/c.opt:1097 +#: c-family/c.opt:1101 #, no-c-format msgid "Warn if an old-style parameter definition is used." msgstr "" -#: c-family/c.opt:1101 +#: c-family/c.opt:1105 #, no-c-format msgid "" "Warn about potentially suboptimal choices related to OpenACC parallelism." msgstr "" -#: c-family/c.opt:1105 +#: c-family/c.opt:1109 #, no-c-format msgid "Warn about suspicious OpenMP code." msgstr "" -#: c-family/c.opt:1109 +#: c-family/c.opt:1113 #, no-c-format msgid "Warn if a simd directive is overridden by the vectorizer cost model." msgstr "" -#: c-family/c.opt:1113 +#: c-family/c.opt:1117 #, no-c-format msgid "" "Warn if a string is longer than the maximum portable length specified by the " "standard." msgstr "" -#: c-family/c.opt:1117 c-family/c.opt:1121 +#: c-family/c.opt:1121 c-family/c.opt:1125 #, no-c-format msgid "Warn about overloaded virtual function names." msgstr "" -#: c-family/c.opt:1125 +#: c-family/c.opt:1129 #, no-c-format msgid "Warn about overriding initializers without side effects." msgstr "" -#: c-family/c.opt:1129 +#: c-family/c.opt:1133 #, no-c-format msgid "Warn about overriding initializers with side effects." msgstr "" -#: c-family/c.opt:1133 +#: c-family/c.opt:1137 #, no-c-format msgid "" "Warn if the named return value optimization is not performed although it is " "allowed." msgstr "" -#: c-family/c.opt:1137 +#: c-family/c.opt:1141 #, no-c-format msgid "Warn about packed bit-fields whose offset changed in GCC 4.4." msgstr "" -#: c-family/c.opt:1141 +#: c-family/c.opt:1145 #, no-c-format msgid "Warn when fields in a struct with the packed attribute are misaligned." msgstr "" -#: c-family/c.opt:1145 +#: c-family/c.opt:1149 #, no-c-format msgid "Warn about possibly missing parentheses." msgstr "" -#: c-family/c.opt:1153 +#: c-family/c.opt:1157 #, no-c-format msgid "" "Warn about calling std::move on a local object in a return statement " "preventing copy elision." msgstr "" -#: c-family/c.opt:1157 c-family/c.opt:1161 +#: c-family/c.opt:1161 c-family/c.opt:1165 #, no-c-format msgid "Warn for placement new expressions with undefined behavior." msgstr "" -#: c-family/c.opt:1165 +#: c-family/c.opt:1169 #, no-c-format msgid "Warn when converting the type of pointers to member functions." msgstr "" -#: c-family/c.opt:1169 +#: c-family/c.opt:1173 #, no-c-format msgid "Warn about function pointer arithmetic." msgstr "" -#: c-family/c.opt:1173 +#: c-family/c.opt:1177 #, no-c-format msgid "Warn when a pointer differs in signedness in an assignment." msgstr "" -#: c-family/c.opt:1177 +#: c-family/c.opt:1181 #, no-c-format msgid "Warn when a pointer is compared with a zero character constant." msgstr "" -#: c-family/c.opt:1181 +#: c-family/c.opt:1185 #, no-c-format msgid "Warn when a pointer is cast to an integer of a different size." msgstr "" -#: c-family/c.opt:1185 +#: c-family/c.opt:1189 #, no-c-format msgid "Warn about misuses of pragmas." msgstr "" -#: c-family/c.opt:1189 +#: c-family/c.opt:1193 #, no-c-format msgid "" "Warn if constructor or destructors with priorities from 0 to 100 are used." msgstr "" -#: c-family/c.opt:1193 +#: c-family/c.opt:1197 #, no-c-format msgid "" "Warn if a property for an Objective-C object has no assign semantics " "specified." msgstr "" -#: c-family/c.opt:1197 +#: c-family/c.opt:1201 #, no-c-format msgid "Warn if inherited methods are unimplemented." msgstr "" -#: c-family/c.opt:1201 +#: c-family/c.opt:1205 #, no-c-format msgid "Warn when a range-based for-loop is creating unnecessary copies." msgstr "" -#: c-family/c.opt:1205 +#: c-family/c.opt:1209 #, no-c-format msgid "Warn about multiple declarations of the same object." msgstr "" -#: c-family/c.opt:1209 +#: c-family/c.opt:1213 #, no-c-format msgid "Warn about redundant calls to std::move." msgstr "" -#: c-family/c.opt:1213 +#: c-family/c.opt:1217 #, no-c-format msgid "" "Warn when a class or enumerated type is referenced using a redundant class-" "key." msgstr "" -#: c-family/c.opt:1217 +#: c-family/c.opt:1221 #, no-c-format msgid "Warn about uses of register storage specifier." msgstr "" -#: c-family/c.opt:1221 +#: c-family/c.opt:1225 #, no-c-format msgid "Warn when the compiler reorders code." msgstr "" -#: c-family/c.opt:1225 +#: c-family/c.opt:1229 #, no-c-format msgid "" "Warn when an argument passed to a restrict-qualified parameter aliases with " "another argument." msgstr "" -#: c-family/c.opt:1230 +#: c-family/c.opt:1234 #, no-c-format msgid "" "Warn whenever void-returning functions return a non-void expressions, or a " "return expression is missing in a function not returning void." msgstr "" -#: c-family/c.opt:1234 +#: c-family/c.opt:1238 #, no-c-format msgid "" "Warn whenever a function's return type defaults to \"int\" (C), or about " "inconsistent return types (C++)." msgstr "" -#: c-family/c.opt:1238 +#: c-family/c.opt:1242 #, no-c-format msgid "Warn on suspicious constructs involving reverse scalar storage order." msgstr "" -#: c-family/c.opt:1242 +#: c-family/c.opt:1246 #, no-c-format msgid "Warn if a selector has multiple methods." msgstr "" -#: c-family/c.opt:1246 +#: c-family/c.opt:1250 #, no-c-format msgid "Warn when a value is moved to itself with std::move." msgstr "" -#: c-family/c.opt:1250 +#: c-family/c.opt:1254 #, no-c-format msgid "Warn about possible violations of sequence point rules." msgstr "" -#: c-family/c.opt:1254 +#: c-family/c.opt:1258 #, no-c-format msgid "Warn if a local declaration hides an instance variable." msgstr "" -#: c-family/c.opt:1258 c-family/c.opt:1262 +#: c-family/c.opt:1262 c-family/c.opt:1266 #, no-c-format msgid "Warn if left shift of a signed value overflows." msgstr "" -#: c-family/c.opt:1266 +#: c-family/c.opt:1270 #, no-c-format msgid "Warn if shift count is negative." msgstr "" -#: c-family/c.opt:1270 +#: c-family/c.opt:1274 #, no-c-format msgid "Warn if shift count >= width of type." msgstr "" -#: c-family/c.opt:1274 +#: c-family/c.opt:1278 #, no-c-format msgid "Warn if left shifting a negative value." msgstr "" -#: c-family/c.opt:1278 +#: c-family/c.opt:1282 #, no-c-format msgid "Warn about signed-unsigned comparisons." msgstr "" -#: c-family/c.opt:1286 +#: c-family/c.opt:1290 #, no-c-format msgid "" "Warn for implicit type conversions between signed and unsigned integers." msgstr "" -#: c-family/c.opt:1290 +#: c-family/c.opt:1294 #, no-c-format msgid "Warn when overload promotes from unsigned to signed." msgstr "" -#: c-family/c.opt:1294 +#: c-family/c.opt:1298 #, no-c-format msgid "Warn about missing sized deallocation functions." msgstr "" -#: c-family/c.opt:1298 +#: c-family/c.opt:1302 #, no-c-format msgid "" "Warn about divisions of two sizeof operators when the first one is applied " "to an array and the divisor does not equal the size of the array element." msgstr "" -#: c-family/c.opt:1303 +#: c-family/c.opt:1307 #, no-c-format msgid "Warn when sizeof is applied on a parameter declared as an array." msgstr "" -#: c-family/c.opt:1307 +#: c-family/c.opt:1311 #, no-c-format msgid "" "Warn about suspicious divisions of two sizeof expressions that don't work " "correctly with pointers." msgstr "" -#: c-family/c.opt:1311 +#: c-family/c.opt:1315 #, no-c-format msgid "" "Warn about suspicious length parameters to certain string functions if the " "argument uses sizeof." msgstr "" -#: c-family/c.opt:1319 +#: c-family/c.opt:1323 #, no-c-format msgid "" -"Warn about inproper usages of flexible array members according to the level " +"Warn about improper usages of flexible array members according to the level " "of -fstrict-flex-arrays." msgstr "" -#: c-family/c.opt:1324 +#: c-family/c.opt:1328 #, no-c-format msgid "Warn about uncasted NULL used as sentinel." msgstr "" -#: c-family/c.opt:1332 +#: c-family/c.opt:1336 #, no-c-format msgid "Warn about unprototyped function declarations." msgstr "" -#: c-family/c.opt:1336 +#: c-family/c.opt:1340 #, no-c-format msgid "Warn if type signatures of candidate methods do not match exactly." msgstr "" -#: c-family/c.opt:1340 +#: c-family/c.opt:1344 #, no-c-format msgid "" "Warn about calls to strcmp and strncmp used in equality expressions that are " @@ -2707,197 +2714,197 @@ msgid "" "argument." msgstr "" -#: c-family/c.opt:1346 +#: c-family/c.opt:1350 #, no-c-format msgid "" "Warn about buffer overflow in string manipulation functions like memcpy and " "strcpy." msgstr "" -#: c-family/c.opt:1351 +#: c-family/c.opt:1355 #, no-c-format msgid "" "Under the control of Object Size type, warn about buffer overflow in string " "manipulation functions like memcpy and strcpy." msgstr "" -#: c-family/c.opt:1356 +#: c-family/c.opt:1360 #, no-c-format msgid "" "Warn about reading past the end of a source array in string manipulation " "functions like memchr and memcpy." msgstr "" -#: c-family/c.opt:1360 +#: c-family/c.opt:1364 #, no-c-format msgid "" "Warn about truncation in string manipulation functions like strncat and " "strncpy." msgstr "" -#: c-family/c.opt:1364 +#: c-family/c.opt:1368 #, no-c-format msgid "" "Warn if a class type has a base or a field whose type uses the anonymous " "namespace or depends on a type with no linkage." msgstr "" -#: c-family/c.opt:1368 +#: c-family/c.opt:1372 #, no-c-format msgid "Warn about functions which might be candidates for format attributes." msgstr "" -#: c-family/c.opt:1372 +#: c-family/c.opt:1376 #, no-c-format msgid "" "Suggest that the override keyword be used when the declaration of a virtual " "function overrides another." msgstr "" -#: c-family/c.opt:1377 +#: c-family/c.opt:1381 #, no-c-format msgid "Warn about enumerated switches, with no default, missing a case." msgstr "" -#: c-family/c.opt:1381 +#: c-family/c.opt:1385 #, no-c-format msgid "Warn about enumerated switches missing a \"default:\" statement." msgstr "" -#: c-family/c.opt:1385 +#: c-family/c.opt:1389 #, no-c-format msgid "Warn about all enumerated switches missing a specific case." msgstr "" -#: c-family/c.opt:1389 +#: c-family/c.opt:1393 #, no-c-format msgid "Warn about switches with boolean controlling expression." msgstr "" -#: c-family/c.opt:1393 +#: c-family/c.opt:1397 #, no-c-format msgid "Warn about switch values that are outside of the switch's type range." msgstr "" -#: c-family/c.opt:1397 +#: c-family/c.opt:1401 #, no-c-format msgid "" "Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions " "are used." msgstr "" -#: c-family/c.opt:1401 +#: c-family/c.opt:1405 #, no-c-format msgid "Deprecated. This switch has no effect." msgstr "" -#: c-family/c.opt:1409 +#: c-family/c.opt:1413 #, no-c-format msgid "Warn on primary template declaration." msgstr "" -#: c-family/c.opt:1413 +#: c-family/c.opt:1417 #, no-c-format msgid "Warn if a comparison always evaluates to true or false." msgstr "" -#: c-family/c.opt:1417 +#: c-family/c.opt:1421 #, no-c-format msgid "Warn about simple-template-id in a constructor or destructor." msgstr "" -#: c-family/c.opt:1421 +#: c-family/c.opt:1425 #, no-c-format msgid "Warn if a throw expression will always result in a call to terminate()." msgstr "" -#: c-family/c.opt:1425 +#: c-family/c.opt:1429 #, no-c-format msgid "Warn about features not present in traditional C." msgstr "" -#: c-family/c.opt:1429 +#: c-family/c.opt:1433 #, no-c-format msgid "" "Warn of prototypes causing type conversions different from what would happen " "in the absence of prototype." msgstr "" -#: c-family/c.opt:1433 +#: c-family/c.opt:1437 #, no-c-format msgid "" "Warn if trigraphs are encountered that might affect the meaning of the " "program." msgstr "" -#: c-family/c.opt:1437 +#: c-family/c.opt:1441 #, no-c-format msgid "Warn about @selector()s without previously declared methods." msgstr "" -#: c-family/c.opt:1441 +#: c-family/c.opt:1445 #, no-c-format msgid "Warn if an undefined macro is used in an #if directive." msgstr "" -#: c-family/c.opt:1445 +#: c-family/c.opt:1449 #, no-c-format msgid "Warn about invalid forms of delimited or named escape sequences." msgstr "" -#: c-family/c.opt:1453 +#: c-family/c.opt:1457 #, no-c-format msgid "Warn about unrecognized pragmas." msgstr "" -#: c-family/c.opt:1457 +#: c-family/c.opt:1461 #, no-c-format msgid "Warn about unsuffixed float constants." msgstr "" -#: c-family/c.opt:1473 +#: c-family/c.opt:1477 #, no-c-format msgid "Warn when typedefs locally defined in a function are not used." msgstr "" -#: c-family/c.opt:1477 +#: c-family/c.opt:1481 #, no-c-format msgid "Warn about macros defined in the main file that are not used." msgstr "" -#: c-family/c.opt:1497 +#: c-family/c.opt:1501 #, no-c-format msgid "Warn about useless casts." msgstr "" -#: c-family/c.opt:1501 +#: c-family/c.opt:1505 #, no-c-format msgid "Warn about using variadic macros." msgstr "" -#: c-family/c.opt:1505 +#: c-family/c.opt:1509 #, no-c-format msgid "" "Warn about questionable usage of the macros used to retrieve variable " "arguments." msgstr "" -#: c-family/c.opt:1509 +#: c-family/c.opt:1513 #, no-c-format msgid "Warn about the most vexing parse syntactic ambiguity." msgstr "" -#: c-family/c.opt:1513 +#: c-family/c.opt:1517 #, no-c-format msgid "Warn if a virtual base has a non-trivial move assignment operator." msgstr "" -#: c-family/c.opt:1517 +#: c-family/c.opt:1521 #, no-c-format msgid "Warn if a variable length array is used." msgstr "" -#: c-family/c.opt:1521 +#: c-family/c.opt:1525 #, no-c-format msgid "" "-Wvla-larger-than=<number>\tWarn on unbounded uses of variable-length " @@ -2905,34 +2912,34 @@ msgid "" "larger than <number> bytes." msgstr "" -#: c-family/c.opt:1527 +#: c-family/c.opt:1531 #, no-c-format msgid "" "Disable Wvla-larger-than= warning. Equivalent to Wvla-larger-" "than=<SIZE_MAX> or larger." msgstr "" -#: c-family/c.opt:1531 +#: c-family/c.opt:1535 #, no-c-format msgid "Warn about mismatched declarations of VLA parameters." msgstr "" -#: c-family/c.opt:1535 +#: c-family/c.opt:1539 #, no-c-format msgid "Warn about deprecated uses of volatile qualifier." msgstr "" -#: c-family/c.opt:1539 +#: c-family/c.opt:1543 #, no-c-format msgid "Warn when a register variable is declared volatile." msgstr "" -#: c-family/c.opt:1543 +#: c-family/c.opt:1547 #, no-c-format msgid "Warn on direct virtual inheritance." msgstr "" -#: c-family/c.opt:1547 +#: c-family/c.opt:1551 #, no-c-format msgid "" "In C++, nonzero means warn about deprecated conversion from string literals " @@ -2940,188 +2947,188 @@ msgid "" "not deprecated by the ISO C standard." msgstr "" -#: c-family/c.opt:1551 +#: c-family/c.opt:1555 #, no-c-format msgid "" "Warn about xor operators where it appears the user meant exponentiation." msgstr "" -#: c-family/c.opt:1555 +#: c-family/c.opt:1559 #, no-c-format msgid "Warn when a literal '0' is used as null pointer." msgstr "" -#: c-family/c.opt:1559 +#: c-family/c.opt:1563 #, no-c-format msgid "Warn about accesses to interior zero-length array members." msgstr "" -#: c-family/c.opt:1563 +#: c-family/c.opt:1567 #, no-c-format msgid "A synonym for -std=c89 (for C) or -std=c++98 (for C++)." msgstr "" -#: c-family/c.opt:1571 +#: c-family/c.opt:1575 #, no-c-format msgid "" "The version of the C++ ABI used for -Wabi warnings and link compatibility " "aliases." msgstr "" -#: c-family/c.opt:1575 +#: c-family/c.opt:1579 #, no-c-format msgid "Enforce class member access control semantics." msgstr "" -#: c-family/c.opt:1579 +#: c-family/c.opt:1583 #, no-c-format msgid "-fada-spec-parent=unit\tDump Ada specs as child units of given parent." msgstr "" -#: c-family/c.opt:1583 +#: c-family/c.opt:1587 #, no-c-format msgid "Support C++17 allocation of over-aligned types." msgstr "" -#: c-family/c.opt:1587 +#: c-family/c.opt:1591 #, no-c-format msgid "" "-faligned-new=<N>\tUse C++17 over-aligned type allocation for alignments " "greater than N." msgstr "" -#: c-family/c.opt:1598 c-family/c.opt:1915 c-family/c.opt:2317 -#: c-family/c.opt:2321 c-family/c.opt:2337 +#: c-family/c.opt:1602 c-family/c.opt:1919 c-family/c.opt:2321 +#: c-family/c.opt:2325 c-family/c.opt:2341 #, no-c-format msgid "No longer supported." msgstr "" -#: c-family/c.opt:1602 +#: c-family/c.opt:1606 #, no-c-format msgid "Recognize the \"asm\" keyword." msgstr "" -#: c-family/c.opt:1610 +#: c-family/c.opt:1614 #, no-c-format msgid "Recognize built-in functions." msgstr "" -#: c-family/c.opt:1617 +#: c-family/c.opt:1621 #, no-c-format msgid "Where shorter, use canonicalized paths to systems headers." msgstr "" -#: c-family/c.opt:1621 +#: c-family/c.opt:1625 #, no-c-format msgid "" "Enable the char8_t fundamental type and use it as the type for UTF-8 string " "and character literals." msgstr "" -#: c-family/c.opt:1709 +#: c-family/c.opt:1713 #, no-c-format msgid "Removed in GCC 8. This switch has no effect." msgstr "" -#: c-family/c.opt:1713 +#: c-family/c.opt:1717 #, no-c-format msgid "Enable support for C++ concepts." msgstr "" -#: c-family/c.opt:1717 +#: c-family/c.opt:1721 #, no-c-format msgid "Enable certain features present in the Concepts TS." msgstr "" -#: c-family/c.opt:1721 +#: c-family/c.opt:1725 #, no-c-format msgid "" "Specify maximum error replay depth during recursive diagnosis of a " "constraint satisfaction failure." msgstr "" -#: c-family/c.opt:1725 +#: c-family/c.opt:1729 #, no-c-format msgid "Allow the arguments of the '?' operator to have different types." msgstr "" -#: c-family/c.opt:1733 +#: c-family/c.opt:1737 #, no-c-format msgid "-fconst-string-class=<name>\tUse class <name> for constant strings." msgstr "" -#: c-family/c.opt:1737 +#: c-family/c.opt:1741 #, no-c-format msgid "-fconstexpr-depth=<number>\tSpecify maximum constexpr recursion depth." msgstr "" -#: c-family/c.opt:1741 +#: c-family/c.opt:1745 #, no-c-format msgid "" "-fconstexpr-cache-depth=<number>\tSpecify maximum constexpr recursion cache " "depth." msgstr "" -#: c-family/c.opt:1745 +#: c-family/c.opt:1749 #, no-c-format msgid "Allow IEC559 floating point exceptions in constant expressions." msgstr "" -#: c-family/c.opt:1749 +#: c-family/c.opt:1753 #, no-c-format msgid "" "-fconstexpr-loop-limit=<number>\tSpecify maximum constexpr loop iteration " "count." msgstr "" -#: c-family/c.opt:1753 +#: c-family/c.opt:1757 #, no-c-format msgid "" "-fconstexpr-ops-limit=<number>\tSpecify maximum number of constexpr " "operations during a single constexpr evaluation." msgstr "" -#: c-family/c.opt:1757 +#: c-family/c.opt:1761 #, no-c-format msgid "Enable certain features present in drafts of C++ Contracts." msgstr "" -#: c-family/c.opt:1770 +#: c-family/c.opt:1774 #, no-c-format msgid "" "-fcontract-assumption-mode=[on|off]\tEnable or disable treating axiom level " "contracts as assumptions (default on)." msgstr "" -#: c-family/c.opt:1774 +#: c-family/c.opt:1778 #, no-c-format msgid "" "-fcontract-build-level=[off|default|audit]\tSpecify max contract level to " "generate runtime checks for." msgstr "" -#: c-family/c.opt:1778 +#: c-family/c.opt:1782 #, no-c-format msgid "" "-fcontract-strict-declarations=[on|off]\tEnable or disable warnings on " "generalized redeclaration of functions with contracts (default off)." msgstr "" -#: c-family/c.opt:1782 +#: c-family/c.opt:1786 #, no-c-format msgid "" "-fcontract-mode=[on|off]\tEnable or disable all contract facilities (default " "on)." msgstr "" -#: c-family/c.opt:1786 +#: c-family/c.opt:1790 #, no-c-format msgid "" "-fcontract-continuation-mode=[on|off]\tEnable or disable contract " "continuation mode (default off)." msgstr "" -#: c-family/c.opt:1790 +#: c-family/c.opt:1794 #, no-c-format msgid "" "-fcontract-role=<name>:<semantics>\tSpecify the semantics for all levels in " @@ -3129,441 +3136,441 @@ msgid "" "(ex: opt:assume,assume,assume)." msgstr "" -#: c-family/c.opt:1794 +#: c-family/c.opt:1798 #, no-c-format msgid "" "-fcontract-semantic=<level>:<semantic>\tSpecify the concrete semantics for " "level." msgstr "" -#: c-family/c.opt:1798 +#: c-family/c.opt:1802 #, no-c-format msgid "Enable C++ coroutines (experimental)." msgstr "" -#: c-family/c.opt:1802 +#: c-family/c.opt:1806 #, no-c-format msgid "Emit debug annotations during preprocessing." msgstr "" -#: c-family/c.opt:1810 +#: c-family/c.opt:1814 #, no-c-format msgid "Factor complex constructors and destructors to favor space over speed." msgstr "" -#: c-family/c.opt:1818 +#: c-family/c.opt:1822 #, no-c-format msgid "Print hierarchical comparisons when template types are mismatched." msgstr "" -#: c-family/c.opt:1822 +#: c-family/c.opt:1826 #, no-c-format msgid "Note all candidates during overload resolution failure." msgstr "" -#: c-family/c.opt:1826 +#: c-family/c.opt:1830 #, no-c-format msgid "Preprocess directives only." msgstr "" -#: c-family/c.opt:1830 +#: c-family/c.opt:1834 #, no-c-format msgid "Permit '$' as an identifier character." msgstr "" -#: c-family/c.opt:1834 +#: c-family/c.opt:1838 #, no-c-format msgid "" "-fmacro-prefix-map=<old>=<new>\tMap one directory name to another in " "__FILE__, __BASE_FILE__, and __builtin_FILE()." msgstr "" -#: c-family/c.opt:1838 +#: c-family/c.opt:1842 #, no-c-format msgid "Write all declarations as Ada code transitively." msgstr "" -#: c-family/c.opt:1842 +#: c-family/c.opt:1846 #, no-c-format msgid "Write all declarations as Ada code for the given file only." msgstr "" -#: c-family/c.opt:1849 +#: c-family/c.opt:1853 #, no-c-format msgid "Do not elide common elements in template comparisons." msgstr "" -#: c-family/c.opt:1853 +#: c-family/c.opt:1857 #, no-c-format msgid "Generate code to check exception specifications." msgstr "" -#: c-family/c.opt:1860 +#: c-family/c.opt:1864 #, no-c-format msgid "" "-fexec-charset=<cset>\tConvert all strings and character constants to " "character set <cset>." msgstr "" -#: c-family/c.opt:1864 +#: c-family/c.opt:1868 #, no-c-format msgid "Permit universal character names (\\u and \\U) in identifiers." msgstr "" -#: c-family/c.opt:1868 +#: c-family/c.opt:1872 #, no-c-format msgid "" "-finput-charset=<cset>\tSpecify the default character set for source files." msgstr "" -#: c-family/c.opt:1872 +#: c-family/c.opt:1876 #, no-c-format msgid "" "Support dynamic initialization of thread-local variables in a different " "translation unit." msgstr "" -#: c-family/c.opt:1879 +#: c-family/c.opt:1883 #, no-c-format msgid "Fold calls to simple inline functions." msgstr "" -#: c-family/c.opt:1886 +#: c-family/c.opt:1890 #, no-c-format msgid "Do not assume that standard C libraries and \"main\" exist." msgstr "" -#: c-family/c.opt:1890 +#: c-family/c.opt:1894 #, no-c-format msgid "Recognize GNU-defined keywords." msgstr "" -#: c-family/c.opt:1894 +#: c-family/c.opt:1898 #, no-c-format msgid "Generate code for GNU runtime environment." msgstr "" -#: c-family/c.opt:1898 +#: c-family/c.opt:1902 #, no-c-format msgid "Use traditional GNU semantics for inline functions." msgstr "" -#: c-family/c.opt:1911 +#: c-family/c.opt:1915 #, no-c-format msgid "Assume normal C execution environment." msgstr "" -#: c-family/c.opt:1919 +#: c-family/c.opt:1923 #, no-c-format msgid "Implement P2564 for consteval propagation." msgstr "" -#: c-family/c.opt:1923 +#: c-family/c.opt:1927 #, no-c-format msgid "Export functions even if they can be inlined." msgstr "" -#: c-family/c.opt:1927 +#: c-family/c.opt:1931 #, no-c-format msgid "Make inline functions constexpr by default." msgstr "" -#: c-family/c.opt:1931 +#: c-family/c.opt:1935 #, no-c-format msgid "Emit implicit instantiations of inline templates." msgstr "" -#: c-family/c.opt:1935 +#: c-family/c.opt:1939 #, no-c-format msgid "Emit implicit instantiations of templates." msgstr "" -#: c-family/c.opt:1939 +#: c-family/c.opt:1943 #, no-c-format msgid "Implement C++17 inheriting constructor semantics." msgstr "" -#: c-family/c.opt:1946 +#: c-family/c.opt:1950 #, no-c-format msgid "Don't emit dllexported inline functions unless needed." msgstr "" -#: c-family/c.opt:1953 +#: c-family/c.opt:1957 #, no-c-format msgid "" "Allow implicit conversions between vectors with differing numbers of " "subparts and/or differing element types." msgstr "" -#: c-family/c.opt:1957 +#: c-family/c.opt:1961 #, no-c-format msgid "Enable C++ modules-ts (experimental)." msgstr "" -#: c-family/c.opt:1965 +#: c-family/c.opt:1969 #, no-c-format msgid "Enable C++ header module (experimental)." msgstr "" -#: c-family/c.opt:1972 +#: c-family/c.opt:1976 #, no-c-format msgid "" "Member functions defined within their class are inline in module purview." msgstr "" -#: c-family/c.opt:1976 +#: c-family/c.opt:1980 #, no-c-format msgid "Only emit Compiled Module Interface." msgstr "" -#: c-family/c.opt:1980 +#: c-family/c.opt:1984 #, no-c-format msgid "Mapper for module to CMI files." msgstr "" -#: c-family/c.opt:1984 +#: c-family/c.opt:1988 #, no-c-format msgid "Enable lazy module importing." msgstr "" -#: c-family/c.opt:1992 +#: c-family/c.opt:1996 #, no-c-format msgid "Warn about macros that have conflicting header units definitions." msgstr "" -#: c-family/c.opt:1996 +#: c-family/c.opt:2000 #, no-c-format msgid "Warn if pointers of distinct types are compared without a cast." msgstr "" -#: c-family/c.opt:2000 +#: c-family/c.opt:2004 #, no-c-format msgid "Note #include directives translated to import declarations." msgstr "" -#: c-family/c.opt:2004 +#: c-family/c.opt:2008 #, no-c-format msgid "" "Note #include directives not translated to import declarations, and not " "known to be textual." msgstr "" -#: c-family/c.opt:2008 +#: c-family/c.opt:2012 #, no-c-format msgid "Note a #include translation of a specific header." msgstr "" -#: c-family/c.opt:2012 +#: c-family/c.opt:2016 #, no-c-format msgid "Note Compiled Module Interface pathnames." msgstr "" -#: c-family/c.opt:2016 +#: c-family/c.opt:2020 #, no-c-format msgid "" "Note Compiled Module Interface pathname of a specific module or header-unit." msgstr "" -#: c-family/c.opt:2020 +#: c-family/c.opt:2024 #, no-c-format msgid "" "fmax-include-depth=<number> Set the maximum depth of the nested #include." msgstr "" -#: c-family/c.opt:2024 +#: c-family/c.opt:2028 #, no-c-format msgid "Don't warn about uses of Microsoft extensions." msgstr "" -#: c-family/c.opt:2043 +#: c-family/c.opt:2047 #, no-c-format msgid "" "Implement resolution of DR 150 for matching of template template arguments." msgstr "" -#: c-family/c.opt:2047 +#: c-family/c.opt:2051 #, no-c-format msgid "Generate code for NeXT (Apple macOS) runtime environment." msgstr "" -#: c-family/c.opt:2051 +#: c-family/c.opt:2055 #, no-c-format msgid "Assume that receivers of Objective-C messages may be nil." msgstr "" -#: c-family/c.opt:2055 +#: c-family/c.opt:2059 #, no-c-format msgid "" "Allow access to instance variables as if they were local declarations within " "instance method implementations." msgstr "" -#: c-family/c.opt:2059 +#: c-family/c.opt:2063 #, no-c-format msgid "" "-fvisibility=[private|protected|public|package]\tSet the default symbol " "visibility." msgstr "" -#: c-family/c.opt:2084 +#: c-family/c.opt:2088 #, no-c-format msgid "" "Treat a throw() exception specification as noexcept to improve code size." msgstr "" -#: c-family/c.opt:2088 +#: c-family/c.opt:2092 #, no-c-format msgid "" "Specify which ABI to use for Objective-C family code and meta-data " "generation." msgstr "" -#: c-family/c.opt:2094 +#: c-family/c.opt:2098 #, no-c-format msgid "" "Generate special Objective-C methods to initialize/destroy non-POD C++ " "ivars, if needed." msgstr "" -#: c-family/c.opt:2098 +#: c-family/c.opt:2102 #, no-c-format msgid "Allow fast jumps to the message dispatcher." msgstr "" -#: c-family/c.opt:2104 +#: c-family/c.opt:2108 #, no-c-format msgid "Enable Objective-C exception and synchronization syntax." msgstr "" -#: c-family/c.opt:2108 +#: c-family/c.opt:2112 #, no-c-format msgid "Enable garbage collection (GC) in Objective-C/Objective-C++ programs." msgstr "" -#: c-family/c.opt:2112 +#: c-family/c.opt:2116 #, no-c-format msgid "" "Enable inline checks for nil receivers with the NeXT runtime and ABI version " "2." msgstr "" -#: c-family/c.opt:2117 +#: c-family/c.opt:2121 #, no-c-format msgid "Enable Objective-C setjmp exception handling runtime." msgstr "" -#: c-family/c.opt:2121 +#: c-family/c.opt:2125 #, no-c-format msgid "Conform to the Objective-C 1.0 language as implemented in GCC 4.0." msgstr "" -#: c-family/c.opt:2125 +#: c-family/c.opt:2129 #, no-c-format msgid "Enable OpenACC." msgstr "" -#: c-family/c.opt:2129 +#: c-family/c.opt:2133 #, no-c-format msgid "Specify default OpenACC compute dimensions." msgstr "" -#: c-family/c.opt:2133 +#: c-family/c.opt:2137 #, no-c-format msgid "Enable OpenMP (implies -frecursive in Fortran)." msgstr "" -#: c-family/c.opt:2137 +#: c-family/c.opt:2141 #, no-c-format msgid "Enable OpenMP's SIMD directives." msgstr "" -#: c-family/c.opt:2141 +#: c-family/c.opt:2145 #, no-c-format msgid "Recognize C++ keywords like \"compl\" and \"xor\"." msgstr "" -#: c-family/c.opt:2152 +#: c-family/c.opt:2156 #, no-c-format msgid "Look for and use PCH files even when preprocessing." msgstr "" -#: c-family/c.opt:2156 +#: c-family/c.opt:2160 #, no-c-format msgid "Downgrade conformance errors to warnings." msgstr "" -#: c-family/c.opt:2160 +#: c-family/c.opt:2164 #, no-c-format msgid "Enable Plan 9 language extensions." msgstr "" -#: c-family/c.opt:2164 +#: c-family/c.opt:2168 #, no-c-format msgid "Treat the input file as already preprocessed." msgstr "" -#: c-family/c.opt:2172 +#: c-family/c.opt:2176 #, no-c-format msgid "" "-ftrack-macro-expansion=<0|1|2>\tTrack locations of tokens coming from macro " "expansion and display them in error messages." msgstr "" -#: c-family/c.opt:2176 +#: c-family/c.opt:2180 #, no-c-format msgid "" "Do not pretty-print template specializations as the template signature " "followed by the arguments." msgstr "" -#: c-family/c.opt:2180 +#: c-family/c.opt:2184 #, no-c-format msgid "Treat known sprintf return values as constants." msgstr "" -#: c-family/c.opt:2184 +#: c-family/c.opt:2188 #, no-c-format msgid "" "Used in Fix-and-Continue mode to indicate that object files may be swapped " "in at runtime." msgstr "" -#: c-family/c.opt:2188 +#: c-family/c.opt:2192 #, no-c-format msgid "Removed in GCC 10. This switch has no effect." msgstr "" -#: c-family/c.opt:2192 +#: c-family/c.opt:2196 #, no-c-format msgid "Generate run time type descriptor information." msgstr "" -#: c-family/c.opt:2196 ada/gcc-interface/lang.opt:81 +#: c-family/c.opt:2200 ada/gcc-interface/lang.opt:81 #, no-c-format msgid "Use the narrowest integer type possible for enumeration types." msgstr "" -#: c-family/c.opt:2200 +#: c-family/c.opt:2204 #, no-c-format msgid "Force the underlying type for \"wchar_t\" to be \"unsigned short\"." msgstr "" -#: c-family/c.opt:2204 +#: c-family/c.opt:2208 #, no-c-format msgid "When \"signed\" or \"unsigned\" is not given make the bitfield signed." msgstr "" -#: c-family/c.opt:2208 ada/gcc-interface/lang.opt:85 +#: c-family/c.opt:2212 ada/gcc-interface/lang.opt:85 #, no-c-format msgid "Make \"char\" signed by default." msgstr "" -#: c-family/c.opt:2212 +#: c-family/c.opt:2216 #, no-c-format msgid "Enable C++14 sized deallocation support." msgstr "" -#: c-family/c.opt:2219 +#: c-family/c.opt:2223 #, no-c-format msgid "" "-fstrict-flex-arrays=<level> Control when to treat the trailing array of " @@ -3572,439 +3579,439 @@ msgid "" "structures as flexible array members." msgstr "" -#: c-family/c.opt:2226 +#: c-family/c.opt:2230 #, no-c-format msgid "" "-fsso-struct=[big-endian|little-endian|native]\tSet the default scalar " "storage order." msgstr "" -#: c-family/c.opt:2242 +#: c-family/c.opt:2246 #, no-c-format msgid "Display statistics accumulated during compilation." msgstr "" -#: c-family/c.opt:2246 +#: c-family/c.opt:2250 #, no-c-format msgid "" "Assume that values of enumeration type are always within the minimum range " "of that type." msgstr "" -#: c-family/c.opt:2253 c-family/c.opt:2258 +#: c-family/c.opt:2257 c-family/c.opt:2262 #, no-c-format msgid "" "Follow the C++17 evaluation order requirements for assignment expressions, " "shift, member function calls, etc." msgstr "" -#: c-family/c.opt:2275 +#: c-family/c.opt:2279 #, no-c-format msgid "" "Set the maximum number of template instantiation notes for a single warning " "or error." msgstr "" -#: c-family/c.opt:2282 +#: c-family/c.opt:2286 #, no-c-format msgid "" "-ftemplate-depth=<number>\tSpecify maximum template instantiation depth." msgstr "" -#: c-family/c.opt:2289 +#: c-family/c.opt:2293 #, no-c-format msgid "" "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing " "local statics." msgstr "" -#: c-family/c.opt:2293 +#: c-family/c.opt:2297 #, no-c-format msgid "" "When \"signed\" or \"unsigned\" is not given make the bitfield unsigned." msgstr "" -#: c-family/c.opt:2297 ada/gcc-interface/lang.opt:89 +#: c-family/c.opt:2301 ada/gcc-interface/lang.opt:89 #, no-c-format msgid "Make \"char\" unsigned by default." msgstr "" -#: c-family/c.opt:2301 +#: c-family/c.opt:2305 #, no-c-format msgid "Use __cxa_atexit to register destructors." msgstr "" -#: c-family/c.opt:2305 +#: c-family/c.opt:2309 #, no-c-format msgid "Use __cxa_get_exception_ptr in exception handling." msgstr "" -#: c-family/c.opt:2309 +#: c-family/c.opt:2313 #, no-c-format msgid "Marks all inlined functions and methods as having hidden visibility." msgstr "" -#: c-family/c.opt:2313 +#: c-family/c.opt:2317 #, no-c-format msgid "Changes visibility to match Microsoft Visual Studio by default." msgstr "" -#: c-family/c.opt:2325 +#: c-family/c.opt:2329 #, no-c-format msgid "Emit common-like symbols as weak symbols." msgstr "" -#: c-family/c.opt:2329 +#: c-family/c.opt:2333 #, no-c-format msgid "" "-fwide-exec-charset=<cset>\tConvert all wide strings and character constants " "to character set <cset>." msgstr "" -#: c-family/c.opt:2333 +#: c-family/c.opt:2337 #, no-c-format msgid "Generate a #line directive pointing at the current working directory." msgstr "" -#: c-family/c.opt:2341 +#: c-family/c.opt:2345 #, no-c-format msgid "" "Generate lazy class lookup (via objc_getClass()) for use in Zero-Link mode." msgstr "" -#: c-family/c.opt:2345 +#: c-family/c.opt:2349 #, no-c-format msgid "Dump declarations to a .decl file." msgstr "" -#: c-family/c.opt:2349 +#: c-family/c.opt:2353 #, no-c-format msgid "" "-femit-struct-debug-baseonly\tAggressive reduced debug info for structs." msgstr "" -#: c-family/c.opt:2353 +#: c-family/c.opt:2357 #, no-c-format msgid "" "-femit-struct-debug-reduced\tConservative reduced debug info for structs." msgstr "" -#: c-family/c.opt:2357 +#: c-family/c.opt:2361 #, no-c-format msgid "" "-femit-struct-debug-detailed=<spec-list>\tDetailed reduced debug info for " "structs." msgstr "" -#: c-family/c.opt:2361 +#: c-family/c.opt:2365 #, no-c-format msgid "" "Interpret imaginary, fixed-point, or other gnu number suffix as the " "corresponding number literal rather than a user-defined number literal." msgstr "" -#: c-family/c.opt:2366 +#: c-family/c.opt:2370 #, no-c-format msgid "-idirafter <dir>\tAdd <dir> to the end of the system include path." msgstr "" -#: c-family/c.opt:2370 +#: c-family/c.opt:2374 #, no-c-format msgid "-imacros <file>\tAccept definition of macros in <file>." msgstr "" -#: c-family/c.opt:2374 +#: c-family/c.opt:2378 #, no-c-format msgid "-imultilib <dir>\tSet <dir> to be the multilib include subdirectory." msgstr "" -#: c-family/c.opt:2378 +#: c-family/c.opt:2382 #, no-c-format msgid "-include <file>\tInclude the contents of <file> before other files." msgstr "" -#: c-family/c.opt:2382 +#: c-family/c.opt:2386 #, no-c-format msgid "-iprefix <path>\tSpecify <path> as a prefix for next two options." msgstr "" -#: c-family/c.opt:2386 +#: c-family/c.opt:2390 #, no-c-format msgid "-isysroot <dir>\tSet <dir> to be the system root directory." msgstr "" -#: c-family/c.opt:2390 +#: c-family/c.opt:2394 #, no-c-format msgid "-isystem <dir>\tAdd <dir> to the start of the system include path." msgstr "" -#: c-family/c.opt:2394 +#: c-family/c.opt:2398 #, no-c-format msgid "-iquote <dir>\tAdd <dir> to the end of the quote include path." msgstr "" -#: c-family/c.opt:2398 +#: c-family/c.opt:2402 #, no-c-format msgid "-iwithprefix <dir>\tAdd <dir> to the end of the system include path." msgstr "" -#: c-family/c.opt:2402 +#: c-family/c.opt:2406 #, no-c-format msgid "" "-iwithprefixbefore <dir>\tAdd <dir> to the end of the main include path." msgstr "" -#: c-family/c.opt:2412 +#: c-family/c.opt:2416 #, no-c-format msgid "" "Do not search standard system include directories (those specified with -" "isystem will still be used)." msgstr "" -#: c-family/c.opt:2416 +#: c-family/c.opt:2420 #, no-c-format msgid "Do not search standard system include directories for C++." msgstr "" -#: c-family/c.opt:2428 +#: c-family/c.opt:2432 #, no-c-format msgid "Generate C header of platform-specific features." msgstr "" -#: c-family/c.opt:2432 +#: c-family/c.opt:2436 #, no-c-format msgid "Remap file names when including files." msgstr "" -#: c-family/c.opt:2436 c-family/c.opt:2440 +#: c-family/c.opt:2440 c-family/c.opt:2444 #, no-c-format msgid "" "Conform to the ISO 1998 C++ standard revised by the 2003 technical " "corrigendum." msgstr "" -#: c-family/c.opt:2444 +#: c-family/c.opt:2448 #, no-c-format msgid "Conform to the ISO 2011 C++ standard." msgstr "" -#: c-family/c.opt:2448 +#: c-family/c.opt:2452 #, no-c-format msgid "Deprecated in favor of -std=c++11." msgstr "" -#: c-family/c.opt:2452 +#: c-family/c.opt:2456 #, no-c-format msgid "Deprecated in favor of -std=c++14." msgstr "" -#: c-family/c.opt:2456 +#: c-family/c.opt:2460 #, no-c-format msgid "Conform to the ISO 2014 C++ standard." msgstr "" -#: c-family/c.opt:2460 +#: c-family/c.opt:2464 #, no-c-format msgid "Deprecated in favor of -std=c++17." msgstr "" -#: c-family/c.opt:2464 +#: c-family/c.opt:2468 #, no-c-format msgid "Conform to the ISO 2017 C++ standard." msgstr "" -#: c-family/c.opt:2468 c-family/c.opt:2472 +#: c-family/c.opt:2472 c-family/c.opt:2476 #, no-c-format msgid "" "Conform to the ISO 2020 C++ standard (experimental and incomplete support)." msgstr "" -#: c-family/c.opt:2476 c-family/c.opt:2480 +#: c-family/c.opt:2480 c-family/c.opt:2484 #, no-c-format msgid "" "Conform to the ISO 2023 C++ draft standard (experimental and incomplete " "support)." msgstr "" -#: c-family/c.opt:2484 c-family/c.opt:2488 +#: c-family/c.opt:2488 c-family/c.opt:2492 #, no-c-format msgid "" "Conform to the ISO 2026 C++ draft standard (experimental and incomplete " "support)." msgstr "" -#: c-family/c.opt:2492 c-family/c.opt:2646 +#: c-family/c.opt:2496 c-family/c.opt:2650 #, no-c-format msgid "Conform to the ISO 2011 C standard." msgstr "" -#: c-family/c.opt:2496 +#: c-family/c.opt:2500 #, no-c-format msgid "Deprecated in favor of -std=c11." msgstr "" -#: c-family/c.opt:2500 c-family/c.opt:2504 c-family/c.opt:2650 -#: c-family/c.opt:2654 +#: c-family/c.opt:2504 c-family/c.opt:2508 c-family/c.opt:2654 +#: c-family/c.opt:2658 #, no-c-format msgid "Conform to the ISO 2017 C standard (published in 2018)." msgstr "" -#: c-family/c.opt:2508 c-family/c.opt:2658 +#: c-family/c.opt:2512 c-family/c.opt:2662 #, no-c-format msgid "" "Conform to the ISO 2023 C standard draft (expected to be published in 2024) " "(experimental and incomplete support)." msgstr "" -#: c-family/c.opt:2512 +#: c-family/c.opt:2516 #, no-c-format msgid "Deprecated in favor of -std=c23." msgstr "" -#: c-family/c.opt:2516 c-family/c.opt:2520 c-family/c.opt:2630 +#: c-family/c.opt:2520 c-family/c.opt:2524 c-family/c.opt:2634 #, no-c-format msgid "Conform to the ISO 1990 C standard." msgstr "" -#: c-family/c.opt:2524 c-family/c.opt:2638 +#: c-family/c.opt:2528 c-family/c.opt:2642 #, no-c-format msgid "Conform to the ISO 1999 C standard." msgstr "" -#: c-family/c.opt:2528 +#: c-family/c.opt:2532 #, no-c-format msgid "Deprecated in favor of -std=c99." msgstr "" -#: c-family/c.opt:2532 c-family/c.opt:2537 +#: c-family/c.opt:2536 c-family/c.opt:2541 #, no-c-format msgid "" "Conform to the ISO 1998 C++ standard revised by the 2003 technical " "corrigendum with GNU extensions." msgstr "" -#: c-family/c.opt:2542 +#: c-family/c.opt:2546 #, no-c-format msgid "Conform to the ISO 2011 C++ standard with GNU extensions." msgstr "" -#: c-family/c.opt:2546 +#: c-family/c.opt:2550 #, no-c-format msgid "Deprecated in favor of -std=gnu++11." msgstr "" -#: c-family/c.opt:2550 +#: c-family/c.opt:2554 #, no-c-format msgid "Deprecated in favor of -std=gnu++14." msgstr "" -#: c-family/c.opt:2554 +#: c-family/c.opt:2558 #, no-c-format msgid "Conform to the ISO 2014 C++ standard with GNU extensions." msgstr "" -#: c-family/c.opt:2558 +#: c-family/c.opt:2562 #, no-c-format msgid "Deprecated in favor of -std=gnu++17." msgstr "" -#: c-family/c.opt:2562 +#: c-family/c.opt:2566 #, no-c-format msgid "Conform to the ISO 2017 C++ standard with GNU extensions." msgstr "" -#: c-family/c.opt:2566 c-family/c.opt:2570 +#: c-family/c.opt:2570 c-family/c.opt:2574 #, no-c-format msgid "" "Conform to the ISO 2020 C++ standard with GNU extensions (experimental and " "incomplete support)." msgstr "" -#: c-family/c.opt:2574 c-family/c.opt:2578 +#: c-family/c.opt:2578 c-family/c.opt:2582 #, no-c-format msgid "" "Conform to the ISO 2023 C++ draft standard with GNU extensions (experimental " "and incomplete support)." msgstr "" -#: c-family/c.opt:2582 c-family/c.opt:2586 +#: c-family/c.opt:2586 c-family/c.opt:2590 #, no-c-format msgid "" "Conform to the ISO 2026 C++ draft standard with GNU extensions (experimental " "and incomplete support)." msgstr "" -#: c-family/c.opt:2590 +#: c-family/c.opt:2594 #, no-c-format msgid "Conform to the ISO 2011 C standard with GNU extensions." msgstr "" -#: c-family/c.opt:2594 +#: c-family/c.opt:2598 #, no-c-format msgid "Deprecated in favor of -std=gnu11." msgstr "" -#: c-family/c.opt:2598 c-family/c.opt:2602 +#: c-family/c.opt:2602 c-family/c.opt:2606 #, no-c-format msgid "" "Conform to the ISO 2017 C standard (published in 2018) with GNU extensions." msgstr "" -#: c-family/c.opt:2606 +#: c-family/c.opt:2610 #, no-c-format msgid "" "Conform to the ISO 2023 C standard draft (expected to be published in 2024) " "with GNU extensions (experimental and incomplete support)." msgstr "" -#: c-family/c.opt:2610 +#: c-family/c.opt:2614 #, no-c-format msgid "Deprecated in favor of -std=gnu23." msgstr "" -#: c-family/c.opt:2614 c-family/c.opt:2618 +#: c-family/c.opt:2618 c-family/c.opt:2622 #, no-c-format msgid "Conform to the ISO 1990 C standard with GNU extensions." msgstr "" -#: c-family/c.opt:2622 +#: c-family/c.opt:2626 #, no-c-format msgid "Conform to the ISO 1999 C standard with GNU extensions." msgstr "" -#: c-family/c.opt:2626 +#: c-family/c.opt:2630 #, no-c-format msgid "Deprecated in favor of -std=gnu99." msgstr "" -#: c-family/c.opt:2634 +#: c-family/c.opt:2638 #, no-c-format msgid "Conform to the ISO 1990 C standard as amended in 1994." msgstr "" -#: c-family/c.opt:2642 +#: c-family/c.opt:2646 #, no-c-format msgid "Deprecated in favor of -std=iso9899:1999." msgstr "" -#: c-family/c.opt:2662 +#: c-family/c.opt:2666 #, no-c-format msgid "" "-stdlib=[libstdc++|libc++]\tThe standard library to be used for C++ headers " "and runtime." msgstr "" -#: c-family/c.opt:2679 +#: c-family/c.opt:2683 #, no-c-format msgid "Enable traditional preprocessing." msgstr "" -#: c-family/c.opt:2683 +#: c-family/c.opt:2687 #, no-c-format msgid "-trigraphs\tSupport ISO C trigraphs." msgstr "" -#: c-family/c.opt:2687 +#: c-family/c.opt:2691 #, no-c-format msgid "Do not predefine system-specific and GCC-specific macros." msgstr "" @@ -4486,7 +4493,7 @@ msgstr "" #: m2/lang.opt:99 #, no-c-format -msgid "recognise the specified suffix as a definition module filename" +msgid "recognize the specified suffix as a definition module filename" msgstr "" #: m2/lang.opt:103 @@ -4590,7 +4597,7 @@ msgstr "" #: m2/lang.opt:175 #, no-c-format -msgid "recognise the specified suffix as implementation and module filenames" +msgid "recognize the specified suffix as implementation and module filenames" msgstr "" #: m2/lang.opt:179 @@ -4708,8 +4715,8 @@ msgstr "" #: m2/lang.opt:263 #, no-c-format msgid "" -"orders the initialization/finalializations for scaffold-static or force " -"linking of modules if scaffold-dynamic" +"orders the initialization/finalizations for scaffold-static or force linking " +"of modules if scaffold-dynamic" msgstr "" #: m2/lang.opt:271 @@ -5780,7 +5787,7 @@ msgstr "" #, no-c-format msgid "" "-init <symbol_name>\tThe symbol <symbol_name> will be used as the first " -"initialiser for a dylib." +"initializer for a dylib." msgstr "" #: config/darwin.opt:218 @@ -6464,12 +6471,12 @@ msgid "" msgstr "" #: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:98 -#: config/loongarch/loongarch.opt:241 +#: config/loongarch/loongarch.opt:266 #, no-c-format msgid "Specify the code model." msgstr "" -#: config/riscv/riscv.opt:129 config/loongarch/loongarch.opt:181 +#: config/riscv/riscv.opt:129 config/loongarch/loongarch.opt:206 #, no-c-format msgid "Do not generate unaligned memory accesses." msgstr "" @@ -6485,7 +6492,7 @@ msgstr "" msgid "Use %reloc() operators, rather than assembly macros, to load addresses." msgstr "" -#: config/riscv/riscv.opt:150 config/loongarch/loongarch.opt:249 +#: config/riscv/riscv.opt:150 config/loongarch/loongarch.opt:274 #, no-c-format msgid "" "Take advantage of linker relaxations to reduce the number of instructions " @@ -6495,7 +6502,7 @@ msgstr "" #: config/riscv/riscv.opt:155 #, no-c-format msgid "" -"Enable the CSR checking for the ISA-dependent CRS and the read-only CSR. The " +"Enable the CSR checking for the ISA-dependent CSR and the read-only CSR. The " "ISA-dependent CSR are only valid when the specific ISA is set. The read-" "only CSR can not be written by the CSR instructions." msgstr "" @@ -6523,25 +6530,25 @@ msgstr "" #: config/riscv/riscv.opt:201 config/aarch64/aarch64.opt:304 #: config/i386/i386.opt:1038 config/arm/arm.opt:349 -#: config/rs6000/rs6000.opt:550 +#: config/rs6000/rs6000.opt:554 #, no-c-format msgid "Use given stack-protector guard." msgstr "" #: config/riscv/riscv.opt:205 config/aarch64/aarch64.opt:308 -#: config/arm/arm.opt:353 config/rs6000/rs6000.opt:554 +#: config/arm/arm.opt:353 config/rs6000/rs6000.opt:558 #, no-c-format msgid "Valid arguments to -mstack-protector-guard=:" msgstr "" #: config/riscv/riscv.opt:215 config/i386/i386.opt:1052 -#: config/rs6000/rs6000.opt:564 +#: config/rs6000/rs6000.opt:568 #, no-c-format msgid "Use the given base register for addressing the stack-protector guard." msgstr "" #: config/riscv/riscv.opt:222 config/i386/i386.opt:1059 -#: config/rs6000/rs6000.opt:571 +#: config/rs6000/rs6000.opt:575 #, no-c-format msgid "Use the given offset for addressing the stack-protector guard." msgstr "" @@ -6632,13 +6639,13 @@ msgid "" msgstr "" #: config/riscv/riscv.opt:612 config/aarch64/aarch64.opt:49 -#: config/loongarch/loongarch.opt:258 +#: config/loongarch/loongarch.opt:283 #, no-c-format msgid "The possible TLS dialects:" msgstr "" #: config/riscv/riscv.opt:622 config/aarch64/aarch64.opt:145 -#: config/loongarch/loongarch.opt:268 +#: config/loongarch/loongarch.opt:293 #, no-c-format msgid "Specify TLS dialect." msgstr "" @@ -6790,7 +6797,7 @@ msgid "" "__mspabi helper function. The default value is 4." msgstr "" -#: config/aarch64/aarch64.opt:61 config/loongarch/loongarch.opt:219 +#: config/aarch64/aarch64.opt:61 config/loongarch/loongarch.opt:244 #, no-c-format msgid "The code model option names for -mcmodel:" msgstr "" @@ -7359,7 +7366,7 @@ msgstr "" #: config/epiphany/epiphany.opt:108 #, no-c-format msgid "" -"A floatig point to integer truncation may be replaced with rounding to save " +"A floating point to integer truncation may be replaced with rounding to save " "mode switching." msgstr "" @@ -7992,7 +7999,7 @@ msgstr "" msgid "Generate reciprocals instead of divss and sqrtss." msgstr "" -#: config/i386/i386.opt:601 config/loongarch/loongarch.opt:210 +#: config/i386/i386.opt:601 config/loongarch/loongarch.opt:235 #, no-c-format msgid "Control generation of reciprocal estimates." msgstr "" @@ -10688,149 +10695,149 @@ msgstr "" msgid "Save the TOC in the prologue for indirect calls rather than inline." msgstr "" -#: config/rs6000/rs6000.opt:475 +#: config/rs6000/rs6000.opt:479 #, no-c-format msgid "" "Fuse certain integer operations together for better performance on power8." msgstr "" -#: config/rs6000/rs6000.opt:479 +#: config/rs6000/rs6000.opt:483 #, no-c-format msgid "Allow sign extension in fusion operations." msgstr "" -#: config/rs6000/rs6000.opt:483 +#: config/rs6000/rs6000.opt:487 #, no-c-format msgid "Use vector and scalar instructions added in ISA 2.07." msgstr "" -#: config/rs6000/rs6000.opt:487 +#: config/rs6000/rs6000.opt:491 #, no-c-format msgid "" "Fuse certain integer operations together for better performance on power10." msgstr "" -#: config/rs6000/rs6000.opt:491 +#: config/rs6000/rs6000.opt:495 #, no-c-format msgid "Use ISA 2.07 Category:Vector.AES and Category:Vector.SHA2 instructions." msgstr "" -#: config/rs6000/rs6000.opt:498 +#: config/rs6000/rs6000.opt:502 #, no-c-format msgid "Use ISA 2.07 transactional memory (HTM) instructions." msgstr "" -#: config/rs6000/rs6000.opt:502 +#: config/rs6000/rs6000.opt:506 #, no-c-format msgid "Generate the quad word memory instructions (lq/stq)." msgstr "" -#: config/rs6000/rs6000.opt:506 +#: config/rs6000/rs6000.opt:510 #, no-c-format msgid "Generate the quad word memory atomic instructions (lqarx/stqcx)." msgstr "" -#: config/rs6000/rs6000.opt:510 +#: config/rs6000/rs6000.opt:514 #, no-c-format msgid "" "Generate aggregate parameter passing code with at most 64-bit alignment." msgstr "" -#: config/rs6000/rs6000.opt:514 +#: config/rs6000/rs6000.opt:518 #, no-c-format msgid "Analyze and remove doubleword swaps from VSX computations." msgstr "" -#: config/rs6000/rs6000.opt:522 +#: config/rs6000/rs6000.opt:526 #, no-c-format msgid "Use certain scalar instructions added in ISA 3.0." msgstr "" -#: config/rs6000/rs6000.opt:526 +#: config/rs6000/rs6000.opt:530 #, no-c-format msgid "Use vector instructions added in ISA 3.0." msgstr "" -#: config/rs6000/rs6000.opt:530 +#: config/rs6000/rs6000.opt:534 #, no-c-format msgid "Use the new min/max instructions defined in ISA 3.0." msgstr "" -#: config/rs6000/rs6000.opt:534 +#: config/rs6000/rs6000.opt:538 #, no-c-format msgid "Generate the integer modulo instructions." msgstr "" -#: config/rs6000/rs6000.opt:538 +#: config/rs6000/rs6000.opt:542 #, no-c-format msgid "Enable IEEE 128-bit floating point via the __float128 keyword." msgstr "" -#: config/rs6000/rs6000.opt:542 +#: config/rs6000/rs6000.opt:546 #, no-c-format msgid "Enable using IEEE 128-bit floating point instructions." msgstr "" -#: config/rs6000/rs6000.opt:546 +#: config/rs6000/rs6000.opt:550 #, no-c-format msgid "Enable default conversions between __float128 & long double." msgstr "" -#: config/rs6000/rs6000.opt:586 +#: config/rs6000/rs6000.opt:590 #, no-c-format msgid "Generate (do not generate) prefixed memory instructions." msgstr "" -#: config/rs6000/rs6000.opt:590 +#: config/rs6000/rs6000.opt:594 #, no-c-format msgid "Generate (do not generate) pc-relative memory addressing." msgstr "" -#: config/rs6000/rs6000.opt:594 +#: config/rs6000/rs6000.opt:598 #, no-c-format msgid "" "Generate (do not generate) pc-relative memory optimizations for externals." msgstr "" -#: config/rs6000/rs6000.opt:598 +#: config/rs6000/rs6000.opt:602 #, no-c-format msgid "Generate (do not generate) MMA instructions." msgstr "" -#: config/rs6000/rs6000.opt:605 +#: config/rs6000/rs6000.opt:609 #, no-c-format msgid "" "Enable instructions that guard against return-oriented programming attacks." msgstr "" -#: config/rs6000/rs6000.opt:609 +#: config/rs6000/rs6000.opt:613 #, no-c-format msgid "Generate code that will run in privileged state." msgstr "" -#: config/rs6000/rs6000.opt:613 +#: config/rs6000/rs6000.opt:617 #, no-c-format msgid "Generate (do not generate) code that uses the XXSPLTIW instruction." msgstr "" -#: config/rs6000/rs6000.opt:617 +#: config/rs6000/rs6000.opt:621 #, no-c-format msgid "Generate (do not generate) code that uses the XXSPLTIDP instruction." msgstr "" -#: config/rs6000/rs6000.opt:621 +#: config/rs6000/rs6000.opt:625 #, no-c-format msgid "Generate (do not generate) code that uses the LXVKQ instruction." msgstr "" -#: config/rs6000/rs6000.opt:627 +#: config/rs6000/rs6000.opt:631 #, no-c-format msgid "" "Used to limit unroll factor which indicates how much the autovectorizer may " "unroll a loop. The default value is 4." msgstr "" -#: config/rs6000/rs6000.opt:633 +#: config/rs6000/rs6000.opt:637 #, no-c-format msgid "" "When costing for loop vectorization, we probably need to penalize the loop " @@ -10842,7 +10849,7 @@ msgid "" "value is 85." msgstr "" -#: config/rs6000/rs6000.opt:642 +#: config/rs6000/rs6000.opt:646 #, no-c-format msgid "" "Like parameter rs6000-density-pct-threshold, we also check the total sum of " @@ -10850,7 +10857,7 @@ msgid "" "threshold specified by this parameter. The default value is 70." msgstr "" -#: config/rs6000/rs6000.opt:648 +#: config/rs6000/rs6000.opt:652 #, no-c-format msgid "" "When both heuristics with rs6000-density-pct-threshold and rs6000-density-" @@ -10858,7 +10865,7 @@ msgid "" "the value which is specified by this parameter. The default value is 10." msgstr "" -#: config/rs6000/rs6000.opt:655 +#: config/rs6000/rs6000.opt:659 #, no-c-format msgid "" "When costing for loop vectorization, we probably need to penalize the loop " @@ -10869,7 +10876,7 @@ msgid "" "specified by this parameter. The default value is 45." msgstr "" -#: config/rs6000/rs6000.opt:664 +#: config/rs6000/rs6000.opt:668 #, no-c-format msgid "" "Like parameter rs6000-density-load-pct-threshold, we also check if the total " @@ -10877,7 +10884,7 @@ msgid "" "and penalize only if it's satisfied. The default value is 20." msgstr "" -#: config/rs6000/rs6000.opt:670 config/loongarch/loongarch.opt:277 +#: config/rs6000/rs6000.opt:674 config/loongarch/loongarch.opt:302 #, no-c-format msgid "" "Indicate how many non memory access vector instructions can be issued per " @@ -10885,7 +10892,7 @@ msgid "" "default value is 4." msgstr "" -#: config/rs6000/rs6000.opt:676 +#: config/rs6000/rs6000.opt:680 #, no-c-format msgid "" "When reduction factor computed for a loop exceeds the threshold specified by " @@ -11207,123 +11214,128 @@ msgstr "" #: config/loongarch/loongarch.opt:107 #, no-c-format -msgid "LoongArch CPU types:" +msgid "LoongArch ARCH presets:" msgstr "" -#: config/loongarch/loongarch.opt:126 +#: config/loongarch/loongarch.opt:132 #, no-c-format msgid "-march=PROCESSOR\tGenerate code for the given PROCESSOR ISA." msgstr "" -#: config/loongarch/loongarch.opt:130 +#: config/loongarch/loongarch.opt:136 +#, no-c-format +msgid "LoongArch TUNE presets:" +msgstr "" + +#: config/loongarch/loongarch.opt:155 #, no-c-format msgid "-mtune=PROCESSOR\tGenerate optimized code for PROCESSOR." msgstr "" -#: config/loongarch/loongarch.opt:139 +#: config/loongarch/loongarch.opt:164 #, no-c-format msgid "Base ABI types for LoongArch:" msgstr "" -#: config/loongarch/loongarch.opt:152 +#: config/loongarch/loongarch.opt:177 #, no-c-format msgid "-mabi=BASEABI\tGenerate code that conforms to the given BASEABI." msgstr "" -#: config/loongarch/loongarch.opt:161 config/mips/mips.opt:71 +#: config/loongarch/loongarch.opt:186 config/mips/mips.opt:71 #, no-c-format msgid "" "-mbranch-cost=COST\tSet the cost of branches to roughly COST instructions." msgstr "" -#: config/loongarch/loongarch.opt:165 config/mips/mips.opt:83 +#: config/loongarch/loongarch.opt:190 config/mips/mips.opt:83 #, no-c-format msgid "Trap on integer divide by zero." msgstr "" -#: config/loongarch/loongarch.opt:169 +#: config/loongarch/loongarch.opt:194 #, no-c-format msgid "Conditional moves for integral are enabled." msgstr "" -#: config/loongarch/loongarch.opt:173 +#: config/loongarch/loongarch.opt:198 #, no-c-format msgid "Conditional moves for float are enabled." msgstr "" -#: config/loongarch/loongarch.opt:177 +#: config/loongarch/loongarch.opt:202 #, no-c-format msgid "" "Prevent optimizing block moves, which is also the default behavior of -Os." msgstr "" -#: config/loongarch/loongarch.opt:185 +#: config/loongarch/loongarch.opt:210 #, no-c-format msgid "" "-mmax-inline-memcpy-size=SIZE\tSet the max size of memcpy to inline, default " "is 1024." msgstr "" -#: config/loongarch/loongarch.opt:189 config/mips/mips.opt:150 +#: config/loongarch/loongarch.opt:214 config/mips/mips.opt:150 #, no-c-format msgid "The code model option names for -mexplicit-relocs:" msgstr "" -#: config/loongarch/loongarch.opt:202 config/mips/mips.opt:163 +#: config/loongarch/loongarch.opt:227 config/mips/mips.opt:163 #, no-c-format msgid "Use %reloc() assembly operators." msgstr "" -#: config/loongarch/loongarch.opt:206 config/mips/mips.opt:167 +#: config/loongarch/loongarch.opt:231 config/mips/mips.opt:167 #, no-c-format msgid "Use %reloc() assembly operators (for backward compatibility)." msgstr "" -#: config/loongarch/loongarch.opt:214 +#: config/loongarch/loongarch.opt:239 #, no-c-format msgid "" "Generate approximate reciprocal divide and square root for better throughput." msgstr "" -#: config/loongarch/loongarch.opt:245 +#: config/loongarch/loongarch.opt:270 #, no-c-format msgid "Avoid using the GOT to access external symbols." msgstr "" -#: config/loongarch/loongarch.opt:254 +#: config/loongarch/loongarch.opt:279 #, no-c-format msgid "Pass -mrelax or -mno-relax option to the assembler." msgstr "" -#: config/loongarch/loongarch.opt:272 +#: config/loongarch/loongarch.opt:297 #, no-c-format msgid "" "Used to limit unroll factor which indicates how much the autovectorizer may " "unroll a loop. The default value is 6." msgstr "" -#: config/loongarch/loongarch.opt:290 +#: config/loongarch/loongarch.opt:315 #, no-c-format msgid "Support frecipe.{s/d} and frsqrte.{s/d} instructions." msgstr "" -#: config/loongarch/loongarch.opt:294 +#: config/loongarch/loongarch.opt:319 #, no-c-format msgid "" "Support div.w[u] and mod.w[u] instructions with inputs not sign-extended." msgstr "" -#: config/loongarch/loongarch.opt:298 +#: config/loongarch/loongarch.opt:323 #, no-c-format msgid "Support am{swap/add}[_db].{b/h} instructions." msgstr "" -#: config/loongarch/loongarch.opt:302 +#: config/loongarch/loongarch.opt:327 #, no-c-format msgid "Support amcas[_db].{b/h/w/d} instructions." msgstr "" -#: config/loongarch/loongarch.opt:306 +#: config/loongarch/loongarch.opt:331 #, no-c-format msgid "Do not need load-load barriers (dbar 0x700)." msgstr "" @@ -18071,7 +18083,7 @@ msgstr "" #, no-c-format msgid "" "When using profile feedback, use the edge at this percentage position in " -"frequncy histogram as the bases for IPA-CP heuristics." +"frequency histogram as the bases for IPA-CP heuristics." msgstr "" #: params.opt:270 @@ -20899,8 +20911,8 @@ msgid "" "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n" msgstr "" -#: tree-diagnostic-path.cc:342 tree-diagnostic.cc:294 c/c-decl.cc:6532 -#: c/c-typeck.cc:8234 cp/error.cc:1189 c-family/c-pretty-print.cc:446 +#: tree-diagnostic-path.cc:342 tree-diagnostic.cc:294 c/c-decl.cc:6534 +#: c/c-typeck.cc:8236 cp/error.cc:1189 c-family/c-pretty-print.cc:446 #, gcc-internal-format msgid "<anonymous>" msgstr "" @@ -21248,12 +21260,12 @@ msgstr "" msgid "invalid address mode" msgstr "" -#: config/aarch64/aarch64.cc:29006 +#: config/aarch64/aarch64.cc:29016 msgid "cannot combine GNU and SVE vectors in a binary operation" msgstr "" #: config/alpha/alpha.cc:5082 config/i386/i386.cc:14193 -#: config/rs6000/rs6000.cc:14617 config/sparc/sparc.cc:9362 +#: config/rs6000/rs6000.cc:14616 config/sparc/sparc.cc:9362 #, c-format msgid "'%%&' used without any local dynamic TLS references" msgstr "" @@ -21269,18 +21281,18 @@ msgid "invalid %%r value" msgstr "" #: config/alpha/alpha.cc:5180 config/ia64/ia64.cc:5542 -#: config/rs6000/rs6000.cc:14312 config/xtensa/xtensa.cc:3066 +#: config/rs6000/rs6000.cc:14311 config/xtensa/xtensa.cc:3066 #, c-format msgid "invalid %%R value" msgstr "" -#: config/alpha/alpha.cc:5186 config/rs6000/rs6000.cc:14232 +#: config/alpha/alpha.cc:5186 config/rs6000/rs6000.cc:14231 #: config/xtensa/xtensa.cc:3039 #, c-format msgid "invalid %%N value" msgstr "" -#: config/alpha/alpha.cc:5194 config/rs6000/rs6000.cc:14260 +#: config/alpha/alpha.cc:5194 config/rs6000/rs6000.cc:14259 #, c-format msgid "invalid %%P value" msgstr "" @@ -21310,7 +21322,7 @@ msgstr "" msgid "invalid %%U value" msgstr "" -#: config/alpha/alpha.cc:5280 config/rs6000/rs6000.cc:14320 +#: config/alpha/alpha.cc:5280 config/rs6000/rs6000.cc:14319 #, c-format msgid "invalid %%s value" msgstr "" @@ -21320,7 +21332,7 @@ msgstr "" msgid "invalid %%C value" msgstr "" -#: config/alpha/alpha.cc:5328 config/rs6000/rs6000.cc:14096 +#: config/alpha/alpha.cc:5328 config/rs6000/rs6000.cc:14095 #, c-format msgid "invalid %%E value" msgstr "" @@ -21333,7 +21345,7 @@ msgstr "" #: config/alpha/alpha.cc:5362 config/gcn/gcn.cc:7411 config/gcn/gcn.cc:7420 #: config/gcn/gcn.cc:7480 config/gcn/gcn.cc:7488 config/gcn/gcn.cc:7504 #: config/gcn/gcn.cc:7522 config/gcn/gcn.cc:7573 config/gcn/gcn.cc:7692 -#: config/gcn/gcn.cc:7809 config/rs6000/rs6000.cc:14622 +#: config/gcn/gcn.cc:7809 config/rs6000/rs6000.cc:14621 #, c-format msgid "invalid %%xn code" msgstr "" @@ -21524,56 +21536,56 @@ msgstr "" msgid "Unsupported code '%c' for fixed-point:" msgstr "" -#: config/avr/avr.cc:3937 +#: config/avr/avr.cc:3948 msgid "internal compiler error. Unknown mode:" msgstr "" -#: config/avr/avr.cc:4806 config/avr/avr.cc:5749 config/avr/avr.cc:6196 +#: config/avr/avr.cc:4815 config/avr/avr.cc:5758 config/avr/avr.cc:6205 msgid "invalid insn:" msgstr "" -#: config/avr/avr.cc:4860 config/avr/avr.cc:4971 config/avr/avr.cc:5029 -#: config/avr/avr.cc:5081 config/avr/avr.cc:5100 config/avr/avr.cc:5292 -#: config/avr/avr.cc:5600 config/avr/avr.cc:5885 config/avr/avr.cc:6089 -#: config/avr/avr.cc:6253 config/avr/avr.cc:6346 config/avr/avr.cc:6544 +#: config/avr/avr.cc:4869 config/avr/avr.cc:4980 config/avr/avr.cc:5038 +#: config/avr/avr.cc:5090 config/avr/avr.cc:5109 config/avr/avr.cc:5301 +#: config/avr/avr.cc:5609 config/avr/avr.cc:5894 config/avr/avr.cc:6098 +#: config/avr/avr.cc:6262 config/avr/avr.cc:6355 config/avr/avr.cc:6553 msgid "incorrect insn:" msgstr "" -#: config/avr/avr.cc:5116 config/avr/avr.cc:5391 config/avr/avr.cc:5671 -#: config/avr/avr.cc:5957 config/avr/avr.cc:6135 config/avr/avr.cc:6402 -#: config/avr/avr.cc:6602 +#: config/avr/avr.cc:5125 config/avr/avr.cc:5400 config/avr/avr.cc:5680 +#: config/avr/avr.cc:5966 config/avr/avr.cc:6144 config/avr/avr.cc:6411 +#: config/avr/avr.cc:6611 msgid "unknown move insn:" msgstr "" -#: config/avr/avr.cc:7369 +#: config/avr/avr.cc:7378 msgid "bad shift insn:" msgstr "" -#: config/avr/avr.cc:7477 config/avr/avr.cc:7960 config/avr/avr.cc:8377 +#: config/avr/avr.cc:7486 config/avr/avr.cc:7969 config/avr/avr.cc:8386 msgid "internal compiler error. Incorrect shift:" msgstr "" -#: config/avr/avr.cc:10201 +#: config/avr/avr.cc:10210 msgid "unsupported fixed-point conversion" msgstr "" -#: config/avr/avr.cc:11576 +#: config/avr/avr.cc:11585 msgid "variable" msgstr "" -#: config/avr/avr.cc:11581 +#: config/avr/avr.cc:11590 msgid "function parameter" msgstr "" -#: config/avr/avr.cc:11586 +#: config/avr/avr.cc:11595 msgid "structure field" msgstr "" -#: config/avr/avr.cc:11592 +#: config/avr/avr.cc:11601 msgid "return type of function" msgstr "" -#: config/avr/avr.cc:11597 +#: config/avr/avr.cc:11606 msgid "pointer" msgstr "" @@ -21594,12 +21606,12 @@ msgstr "" msgid "invalid const_double operand" msgstr "" -#: config/bpf/bpf.cc:894 +#: config/bpf/bpf.cc:943 msgid "invalid address in operand" msgstr "" #. Fallthrough. -#: config/bpf/bpf.cc:901 +#: config/bpf/bpf.cc:950 msgid "unsupported operand" msgstr "" @@ -21997,7 +22009,7 @@ msgstr "" msgid "invalid %%P operand" msgstr "" -#: config/iq2000/iq2000.cc:3131 config/rs6000/rs6000.cc:14250 +#: config/iq2000/iq2000.cc:3131 config/rs6000/rs6000.cc:14249 #, c-format msgid "invalid %%p value" msgstr "" @@ -22078,7 +22090,7 @@ msgid "post-increment address is not a register" msgstr "" #: config/m32r/m32r.cc:2338 config/m32r/m32r.cc:2353 -#: config/rs6000/rs6000.cc:20975 +#: config/rs6000/rs6000.cc:20974 msgid "bad address" msgstr "" @@ -22258,175 +22270,175 @@ msgstr "" msgid "Try running '%s' in the shell to raise its limit.\n" msgstr "" -#: config/rs6000/rs6000.cc:3824 +#: config/rs6000/rs6000.cc:3823 msgid "%<-mvsx%> requires hardware floating point" msgstr "" -#: config/rs6000/rs6000.cc:3832 +#: config/rs6000/rs6000.cc:3831 msgid "%<-mvsx%> needs indexed addressing" msgstr "" -#: config/rs6000/rs6000.cc:3837 +#: config/rs6000/rs6000.cc:3836 msgid "%<-mvsx%> and %<-mno-altivec%> are incompatible" msgstr "" -#: config/rs6000/rs6000.cc:3839 +#: config/rs6000/rs6000.cc:3838 msgid "%<-mno-altivec%> disables vsx" msgstr "" -#: config/rs6000/rs6000.cc:3959 +#: config/rs6000/rs6000.cc:3958 msgid "%<-mquad-memory%> requires 64-bit mode" msgstr "" -#: config/rs6000/rs6000.cc:3962 +#: config/rs6000/rs6000.cc:3961 msgid "%<-mquad-memory-atomic%> requires 64-bit mode" msgstr "" -#: config/rs6000/rs6000.cc:3974 +#: config/rs6000/rs6000.cc:3973 msgid "%<-mquad-memory%> is not available in little endian mode" msgstr "" -#: config/rs6000/rs6000.cc:11340 +#: config/rs6000/rs6000.cc:11339 msgid "bad move" msgstr "" -#: config/rs6000/rs6000.cc:13880 +#: config/rs6000/rs6000.cc:13879 msgid "Bad 128-bit move" msgstr "" -#: config/rs6000/rs6000.cc:14060 +#: config/rs6000/rs6000.cc:14059 #, c-format msgid "invalid %%A value" msgstr "" -#: config/rs6000/rs6000.cc:14069 config/xtensa/xtensa.cc:3015 +#: config/rs6000/rs6000.cc:14068 config/xtensa/xtensa.cc:3015 #, c-format msgid "invalid %%D value" msgstr "" -#: config/rs6000/rs6000.cc:14084 +#: config/rs6000/rs6000.cc:14083 #, c-format msgid "invalid %%e value" msgstr "" -#: config/rs6000/rs6000.cc:14105 +#: config/rs6000/rs6000.cc:14104 #, c-format msgid "invalid %%f value" msgstr "" -#: config/rs6000/rs6000.cc:14114 +#: config/rs6000/rs6000.cc:14113 #, c-format msgid "invalid %%F value" msgstr "" -#: config/rs6000/rs6000.cc:14123 +#: config/rs6000/rs6000.cc:14122 #, c-format msgid "invalid %%G value" msgstr "" -#: config/rs6000/rs6000.cc:14158 +#: config/rs6000/rs6000.cc:14157 #, c-format msgid "invalid %%j code" msgstr "" -#: config/rs6000/rs6000.cc:14168 +#: config/rs6000/rs6000.cc:14167 #, c-format msgid "invalid %%J code" msgstr "" -#: config/rs6000/rs6000.cc:14178 +#: config/rs6000/rs6000.cc:14177 #, c-format msgid "invalid %%k value" msgstr "" -#: config/rs6000/rs6000.cc:14193 config/xtensa/xtensa.cc:3052 +#: config/rs6000/rs6000.cc:14192 config/xtensa/xtensa.cc:3052 #, c-format msgid "invalid %%K value" msgstr "" -#: config/rs6000/rs6000.cc:14240 +#: config/rs6000/rs6000.cc:14239 #, c-format msgid "invalid %%O value" msgstr "" -#: config/rs6000/rs6000.cc:14287 +#: config/rs6000/rs6000.cc:14286 #, c-format msgid "invalid %%q value" msgstr "" -#: config/rs6000/rs6000.cc:14329 +#: config/rs6000/rs6000.cc:14328 #, c-format msgid "invalid %%t value" msgstr "" -#: config/rs6000/rs6000.cc:14346 +#: config/rs6000/rs6000.cc:14345 #, c-format msgid "invalid %%T value" msgstr "" -#: config/rs6000/rs6000.cc:14358 +#: config/rs6000/rs6000.cc:14357 #, c-format msgid "invalid %%u value" msgstr "" -#: config/rs6000/rs6000.cc:14372 config/xtensa/xtensa.cc:3027 +#: config/rs6000/rs6000.cc:14371 config/xtensa/xtensa.cc:3027 #, c-format msgid "invalid %%v value" msgstr "" -#: config/rs6000/rs6000.cc:14422 +#: config/rs6000/rs6000.cc:14421 #, c-format msgid "invalid %%V value" msgstr "" -#: config/rs6000/rs6000.cc:14438 config/xtensa/xtensa.cc:3073 +#: config/rs6000/rs6000.cc:14437 config/xtensa/xtensa.cc:3073 #, c-format msgid "invalid %%x value" msgstr "" -#: config/rs6000/rs6000.cc:14495 +#: config/rs6000/rs6000.cc:14494 #, c-format msgid "invalid %%z value" msgstr "" -#: config/rs6000/rs6000.cc:14564 +#: config/rs6000/rs6000.cc:14563 #, c-format msgid "invalid %%y value, try using the 'Z' constraint" msgstr "" -#: config/rs6000/rs6000.cc:15506 +#: config/rs6000/rs6000.cc:15505 msgid "Invalid mixing of IEEE 128-bit and IBM 128-bit floating point types" msgstr "" -#: config/rs6000/rs6000.cc:24376 +#: config/rs6000/rs6000.cc:24375 msgid "AltiVec argument passed to unprototyped function" msgstr "" -#: config/rs6000/rs6000.cc:27991 +#: config/rs6000/rs6000.cc:27990 msgid "Could not generate addis value for fusion" msgstr "" -#: config/rs6000/rs6000.cc:28060 +#: config/rs6000/rs6000.cc:28059 msgid "Unable to generate load/store offset for fusion" msgstr "" -#: config/rs6000/rs6000.cc:28136 +#: config/rs6000/rs6000.cc:28135 msgid "Bad GPR fusion" msgstr "" -#: config/rs6000/rs6000.cc:28738 +#: config/rs6000/rs6000.cc:28737 msgid "invalid conversion from type %<__vector_quad%>" msgstr "" -#: config/rs6000/rs6000.cc:28740 +#: config/rs6000/rs6000.cc:28739 msgid "invalid conversion to type %<__vector_quad%>" msgstr "" -#: config/rs6000/rs6000.cc:28742 +#: config/rs6000/rs6000.cc:28741 msgid "invalid conversion from type %<__vector_pair%>" msgstr "" -#: config/rs6000/rs6000.cc:28744 +#: config/rs6000/rs6000.cc:28743 msgid "invalid conversion to type %<__vector_pair%>" msgstr "" @@ -22869,7 +22881,7 @@ msgstr "" msgid "<message unknown at compile time>" msgstr "" -#: c/c-typeck.cc:9039 +#: c/c-typeck.cc:9041 msgid "(anonymous)" msgstr "" @@ -22884,25 +22896,25 @@ msgstr "" msgid "expected label" msgstr "" -#: cp/call.cc:4113 +#: cp/call.cc:4136 msgid "candidate:" msgstr "" -#: cp/call.cc:8309 +#: cp/call.cc:8332 msgid " after user-defined conversion:" msgstr "" -#: cp/call.cc:8475 cp/pt.cc:2043 cp/pt.cc:26288 +#: cp/call.cc:8498 cp/pt.cc:2043 cp/pt.cc:26344 msgid "candidate is:" msgid_plural "candidates are:" msgstr[0] "" msgstr[1] "" -#: cp/call.cc:12997 cp/call.cc:13423 +#: cp/call.cc:13020 cp/call.cc:13446 msgid "candidate 1:" msgstr "" -#: cp/call.cc:12999 cp/call.cc:13424 +#: cp/call.cc:13022 cp/call.cc:13447 msgid "candidate 2:" msgstr "" @@ -23138,7 +23150,7 @@ msgstr "" msgid "%r%s:%d:%R in %<constexpr%> expansion of %qs" msgstr "" -#: cp/pt.cc:2041 cp/semantics.cc:6306 +#: cp/pt.cc:2041 cp/semantics.cc:6310 msgid "candidates are:" msgstr "" @@ -23182,27 +23194,27 @@ msgstr "" msgid "source type is not polymorphic" msgstr "" -#: cp/typeck.cc:7442 c/c-typeck.cc:4683 +#: cp/typeck.cc:7442 c/c-typeck.cc:4685 #, gcc-internal-format msgid "wrong type argument to unary minus" msgstr "" -#: cp/typeck.cc:7443 c/c-typeck.cc:4669 +#: cp/typeck.cc:7443 c/c-typeck.cc:4671 #, gcc-internal-format msgid "wrong type argument to unary plus" msgstr "" -#: cp/typeck.cc:7470 c/c-typeck.cc:4728 +#: cp/typeck.cc:7470 c/c-typeck.cc:4730 #, gcc-internal-format msgid "wrong type argument to bit-complement" msgstr "" -#: cp/typeck.cc:7487 c/c-typeck.cc:4736 +#: cp/typeck.cc:7487 c/c-typeck.cc:4738 #, gcc-internal-format msgid "wrong type argument to abs" msgstr "" -#: cp/typeck.cc:7499 c/c-typeck.cc:4758 +#: cp/typeck.cc:7499 c/c-typeck.cc:4760 #, gcc-internal-format msgid "wrong type argument to conjugation" msgstr "" @@ -23496,11 +23508,11 @@ msgstr "" msgid "implied END DO" msgstr "" -#: fortran/parse.cc:2432 fortran/resolve.cc:12746 +#: fortran/parse.cc:2432 fortran/resolve.cc:12765 msgid "assignment" msgstr "" -#: fortran/parse.cc:2435 fortran/resolve.cc:12812 fortran/resolve.cc:12815 +#: fortran/parse.cc:2435 fortran/resolve.cc:12831 fortran/resolve.cc:12834 msgid "pointer assignment" msgstr "" @@ -23508,201 +23520,201 @@ msgstr "" msgid "simple IF" msgstr "" -#: fortran/resolve.cc:2434 fortran/resolve.cc:2629 +#: fortran/resolve.cc:2442 fortran/resolve.cc:2637 msgid "elemental procedure" msgstr "" -#: fortran/resolve.cc:2532 +#: fortran/resolve.cc:2540 msgid "allocatable argument" msgstr "" -#: fortran/resolve.cc:2537 +#: fortran/resolve.cc:2545 msgid "asynchronous argument" msgstr "" -#: fortran/resolve.cc:2542 +#: fortran/resolve.cc:2550 msgid "optional argument" msgstr "" -#: fortran/resolve.cc:2547 +#: fortran/resolve.cc:2555 msgid "pointer argument" msgstr "" -#: fortran/resolve.cc:2552 +#: fortran/resolve.cc:2560 msgid "target argument" msgstr "" -#: fortran/resolve.cc:2557 +#: fortran/resolve.cc:2565 msgid "value argument" msgstr "" -#: fortran/resolve.cc:2562 +#: fortran/resolve.cc:2570 msgid "volatile argument" msgstr "" -#: fortran/resolve.cc:2567 +#: fortran/resolve.cc:2575 msgid "assumed-shape argument" msgstr "" -#: fortran/resolve.cc:2572 +#: fortran/resolve.cc:2580 msgid "assumed-rank argument" msgstr "" -#: fortran/resolve.cc:2577 +#: fortran/resolve.cc:2585 msgid "coarray argument" msgstr "" -#: fortran/resolve.cc:2582 +#: fortran/resolve.cc:2590 msgid "parametrized derived type argument" msgstr "" -#: fortran/resolve.cc:2587 +#: fortran/resolve.cc:2595 msgid "polymorphic argument" msgstr "" -#: fortran/resolve.cc:2592 +#: fortran/resolve.cc:2600 msgid "NO_ARG_CHECK attribute" msgstr "" #. As assumed-type is unlimited polymorphic (cf. above). #. See also TS 29113, Note 6.1. -#: fortran/resolve.cc:2599 +#: fortran/resolve.cc:2607 msgid "assumed-type argument" msgstr "" -#: fortran/resolve.cc:2610 +#: fortran/resolve.cc:2618 msgid "array result" msgstr "" -#: fortran/resolve.cc:2615 +#: fortran/resolve.cc:2623 msgid "pointer or allocatable result" msgstr "" -#: fortran/resolve.cc:2622 +#: fortran/resolve.cc:2630 msgid "result with non-constant character length" msgstr "" -#: fortran/resolve.cc:2634 +#: fortran/resolve.cc:2642 msgid "bind(c) procedure" msgstr "" -#: fortran/resolve.cc:4206 +#: fortran/resolve.cc:4214 #, c-format msgid "Invalid context for NULL() pointer at %%L" msgstr "" -#: fortran/resolve.cc:4223 +#: fortran/resolve.cc:4231 #, c-format msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s" msgstr "" -#: fortran/resolve.cc:4241 fortran/resolve.cc:4424 fortran/resolve.cc:4579 +#: fortran/resolve.cc:4249 fortran/resolve.cc:4432 fortran/resolve.cc:4587 #, c-format msgid "Inconsistent ranks for operator at %%L and %%L" msgstr "" -#: fortran/resolve.cc:4251 +#: fortran/resolve.cc:4259 #, c-format msgid "" "Unexpected derived-type entities in binary intrinsic numeric operator " "%%<%s%%> at %%L" msgstr "" -#: fortran/resolve.cc:4256 +#: fortran/resolve.cc:4264 #, c-format msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s" msgstr "" -#: fortran/resolve.cc:4271 +#: fortran/resolve.cc:4279 #, c-format msgid "Operands of string concatenation operator at %%L are %s/%s" msgstr "" -#: fortran/resolve.cc:4314 +#: fortran/resolve.cc:4322 #, c-format msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s" msgstr "" -#: fortran/resolve.cc:4337 +#: fortran/resolve.cc:4345 #, c-format msgid "Operand of .not. operator at %%L is %s" msgstr "" -#: fortran/resolve.cc:4351 +#: fortran/resolve.cc:4359 msgid "COMPLEX quantities cannot be compared at %L" msgstr "" -#: fortran/resolve.cc:4460 +#: fortran/resolve.cc:4468 #, c-format msgid "Logicals at %%L must be compared with %s instead of %s" msgstr "" -#: fortran/resolve.cc:4466 +#: fortran/resolve.cc:4474 #, c-format msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s" msgstr "" -#: fortran/resolve.cc:4480 +#: fortran/resolve.cc:4488 #, c-format msgid "Unknown operator %%<%s%%> at %%L; did you mean %%<%s%%>?" msgstr "" -#: fortran/resolve.cc:4483 +#: fortran/resolve.cc:4491 #, c-format msgid "Unknown operator %%<%s%%> at %%L" msgstr "" -#: fortran/resolve.cc:4488 +#: fortran/resolve.cc:4496 #, c-format msgid "Operand of user operator %%<%s%%> at %%L is %s" msgstr "" -#: fortran/resolve.cc:4493 +#: fortran/resolve.cc:4501 #, c-format msgid "Operands of user operator %%<%s%%> at %%L are %s/%s" msgstr "" -#: fortran/resolve.cc:7650 +#: fortran/resolve.cc:7659 msgid "Loop variable" msgstr "" -#: fortran/resolve.cc:7654 +#: fortran/resolve.cc:7663 msgid "iterator variable" msgstr "" -#: fortran/resolve.cc:7658 +#: fortran/resolve.cc:7667 msgid "Start expression in DO loop" msgstr "" -#: fortran/resolve.cc:7662 +#: fortran/resolve.cc:7671 msgid "End expression in DO loop" msgstr "" -#: fortran/resolve.cc:7666 +#: fortran/resolve.cc:7675 msgid "Step expression in DO loop" msgstr "" -#: fortran/resolve.cc:7953 fortran/resolve.cc:7956 +#: fortran/resolve.cc:7962 fortran/resolve.cc:7965 msgid "DEALLOCATE object" msgstr "" -#: fortran/resolve.cc:8334 fortran/resolve.cc:8337 +#: fortran/resolve.cc:8353 fortran/resolve.cc:8356 msgid "ALLOCATE object" msgstr "" -#: fortran/resolve.cc:8574 fortran/resolve.cc:10651 fortran/resolve.cc:10772 +#: fortran/resolve.cc:8593 fortran/resolve.cc:10670 fortran/resolve.cc:10791 msgid "STAT variable" msgstr "" -#: fortran/resolve.cc:8625 fortran/resolve.cc:10663 fortran/resolve.cc:10784 +#: fortran/resolve.cc:8644 fortran/resolve.cc:10682 fortran/resolve.cc:10803 msgid "ERRMSG variable" msgstr "" -#: fortran/resolve.cc:10453 +#: fortran/resolve.cc:10472 msgid "item in READ" msgstr "" -#: fortran/resolve.cc:10675 +#: fortran/resolve.cc:10694 msgid "ACQUIRED_LOCK variable" msgstr "" @@ -23722,14 +23734,14 @@ msgid "" "dummy declaration" msgstr "" -#: fortran/trans-decl.cc:6370 +#: fortran/trans-decl.cc:6371 #, c-format msgid "" "Actual string length does not match the declared one for dummy argument " "'%s' (%ld/%ld)" msgstr "" -#: fortran/trans-decl.cc:6378 +#: fortran/trans-decl.cc:6379 #, c-format msgid "" "Actual string length is shorter than the declared one for dummy argument " @@ -23993,7 +24005,7 @@ msgstr "" #: go/gofrontend/expressions.cc:11743 go/gofrontend/expressions.cc:11838 #: go/gofrontend/expressions.cc:14014 go/gofrontend/expressions.cc:14143 #: go/gofrontend/expressions.cc:14157 go/gofrontend/expressions.cc:14178 -#: cp/pt.cc:9349 +#: cp/pt.cc:9370 #, gcc-internal-format msgid "too many arguments" msgstr "" @@ -24699,15 +24711,15 @@ msgstr "" #: 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:220 c-family/c.opt:224 -#: c-family/c.opt:236 c-family/c.opt:2369 c-family/c.opt:2377 +#: c-family/c.opt:236 c-family/c.opt:2373 c-family/c.opt:2381 #: config/darwin.opt:30 common.opt:329 common.opt:332 common.opt:3680 #, gcc-internal-format msgid "missing filename after %qs" msgstr "" #: c-family/c.opt:85 c-family/c.opt:88 c-family/c.opt:91 c-family/c.opt:94 -#: c-family/c.opt:200 c-family/c.opt:212 c-family/c.opt:268 c-family/c.opt:2365 -#: c-family/c.opt:2385 c-family/c.opt:2389 c-family/c.opt:2393 +#: c-family/c.opt:200 c-family/c.opt:212 c-family/c.opt:268 c-family/c.opt:2369 +#: c-family/c.opt:2389 c-family/c.opt:2393 c-family/c.opt:2397 #, gcc-internal-format msgid "missing path after %qs" msgstr "" @@ -24737,49 +24749,49 @@ msgstr "" msgid "argument %qs to %<-Wbidi-chars%> not recognized" msgstr "" -#: c-family/c.opt:1068 +#: c-family/c.opt:1072 #, gcc-internal-format msgid "argument %qs to %<-Wnormalized%> not recognized" msgstr "" -#: c-family/c.opt:1732 +#: c-family/c.opt:1736 #, gcc-internal-format msgid "no class name specified with %qs" msgstr "" -#: c-family/c.opt:1760 +#: c-family/c.opt:1764 #, gcc-internal-format msgid "argument %qs must be either %<on%> or %<off%>" msgstr "" -#: c-family/c.opt:1904 +#: c-family/c.opt:1908 #, gcc-internal-format msgid "" "%<-fhandle-exceptions%> has been renamed %<-fexceptions%> (and is now on by " "default)" msgstr "" -#: c-family/c.opt:1979 +#: c-family/c.opt:1983 #, gcc-internal-format msgid "missing mapper" msgstr "" -#: c-family/c.opt:2007 +#: c-family/c.opt:2011 #, gcc-internal-format msgid "missing header name" msgstr "" -#: c-family/c.opt:2015 +#: c-family/c.opt:2019 #, gcc-internal-format msgid "missing module name" msgstr "" -#: c-family/c.opt:2062 +#: c-family/c.opt:2066 #, gcc-internal-format msgid "unrecognized ivar visibility value %qs" msgstr "" -#: c-family/c.opt:2229 +#: c-family/c.opt:2233 #, gcc-internal-format msgid "unrecognized scalar storage order value %qs" msgstr "" @@ -24881,6 +24893,11 @@ msgstr "" msgid "using old darwin ABI" msgstr "" +#: config/rs6000/rs6000.opt:475 +#, gcc-internal-format +msgid "Do not use %<-mpower8-internal%>; use %<-mcpu=power8%> instead" +msgstr "" + #: config/fused-madd.opt:22 #, gcc-internal-format msgid "%<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead" @@ -25045,69 +25062,69 @@ msgstr "" msgid "valid format is %<ns::attr%> or %<ns::%>" msgstr "" -#: attribs.cc:519 +#: attribs.cc:524 #, gcc-internal-format msgid "" "ignoring attribute %qE in declaration of a built-in function %qD because it " "conflicts with attribute %qs" msgstr "" -#: attribs.cc:525 c-family/c-attribs.cc:1271 c-family/c-attribs.cc:1315 +#: attribs.cc:530 c-family/c-attribs.cc:1271 c-family/c-attribs.cc:1315 #, gcc-internal-format msgid "ignoring attribute %qE because it conflicts with attribute %qs" msgstr "" -#: attribs.cc:531 c-family/c-attribs.cc:995 c-family/c-attribs.cc:2690 +#: attribs.cc:536 c-family/c-attribs.cc:995 c-family/c-attribs.cc:2690 #: c-family/c-attribs.cc:3177 c-family/c-attribs.cc:5054 -#: c-family/c-attribs.cc:5147 cp/decl.cc:16428 cp/decl.cc:16478 +#: c-family/c-attribs.cc:5147 cp/decl.cc:16434 cp/decl.cc:16484 #: cp/friend.cc:318 cp/tree.cc:5259 #, gcc-internal-format msgid "previous declaration here" msgstr "" #. Warn about and ignore all others for now, but store them. -#: attribs.cc:729 c-family/c-attribs.cc:4203 objc/objc-act.cc:5134 +#: attribs.cc:734 c-family/c-attribs.cc:4203 objc/objc-act.cc:5134 #: objc/objc-act.cc:7125 objc/objc-act.cc:8323 objc/objc-act.cc:8379 #, gcc-internal-format msgid "%qE attribute directive ignored" msgstr "" -#: attribs.cc:739 +#: attribs.cc:744 #, gcc-internal-format msgid "%<%E::%E%> scoped attribute directive ignored" msgstr "" -#: attribs.cc:752 c/c-parser.cc:2084 cp/cp-gimplify.cc:3667 +#: attribs.cc:757 c/c-parser.cc:2084 cp/cp-gimplify.cc:3667 #, gcc-internal-format msgid "wrong number of arguments specified for %qE attribute" msgstr "" -#: attribs.cc:755 +#: attribs.cc:760 #, gcc-internal-format, gfc-internal-format msgid "expected %i or more, found %i" msgstr "" -#: attribs.cc:758 c/c-parser.cc:2087 cp/cp-gimplify.cc:3669 +#: attribs.cc:763 c/c-parser.cc:2087 cp/cp-gimplify.cc:3669 #, gcc-internal-format, gfc-internal-format msgid "expected %i, found %i" msgstr "" -#: attribs.cc:761 +#: attribs.cc:766 #, gcc-internal-format, gfc-internal-format msgid "expected between %i and %i, found %i" msgstr "" -#: attribs.cc:781 c-family/c-attribs.cc:4916 +#: attribs.cc:786 c-family/c-attribs.cc:4916 #, gcc-internal-format msgid "%qE attribute does not apply to types" msgstr "" -#: attribs.cc:829 +#: attribs.cc:834 #, gcc-internal-format msgid "%qE attribute only applies to function types" msgstr "" -#: attribs.cc:839 +#: attribs.cc:844 #, gcc-internal-format msgid "type attributes ignored after type is already defined" msgstr "" @@ -25120,7 +25137,7 @@ msgstr "" #. is a constraint violation if it is not one of the known #. standard attributes. Diagnose it here with a pedwarn and #. then discard it to prevent a duplicate warning later. -#: attribs.cc:933 attribs.cc:1921 attribs.cc:1931 attribs.cc:1941 +#: attribs.cc:938 attribs.cc:1926 attribs.cc:1936 attribs.cc:1946 #: c-family/c-attribs.cc:1023 c-family/c-attribs.cc:1175 #: c-family/c-attribs.cc:1194 c-family/c-attribs.cc:1212 #: c-family/c-attribs.cc:1242 c-family/c-attribs.cc:1286 @@ -25152,14 +25169,14 @@ msgstr "" #: c-family/c-attribs.cc:5763 c-family/c-attribs.cc:5845 #: c-family/c-attribs.cc:5877 c-family/c-attribs.cc:5919 #: c-family/c-attribs.cc:5935 c-family/c-attribs.cc:6103 -#: c-family/c-attribs.cc:6115 c-family/c-common.cc:6137 -#: c-family/c-common.cc:6140 config/darwin.cc:2208 config/arm/arm.cc:7519 -#: config/arm/arm.cc:7546 config/arm/arm.cc:7563 config/avr/avr.cc:11217 +#: c-family/c-attribs.cc:6115 c-family/c-common.cc:6138 +#: c-family/c-common.cc:6141 config/darwin.cc:2208 config/arm/arm.cc:7519 +#: config/arm/arm.cc:7546 config/arm/arm.cc:7563 config/avr/avr.cc:11226 #: config/csky/csky.cc:6498 config/csky/csky.cc:6519 config/h8300/h8300.cc:4972 #: config/h8300/h8300.cc:4996 config/i386/i386-options.cc:3755 #: config/i386/i386-options.cc:3913 config/i386/i386-options.cc:4145 #: config/i386/i386-options.cc:4175 config/ia64/ia64.cc:795 -#: config/loongarch/loongarch.cc:7999 config/rs6000/rs6000.cc:20739 +#: config/loongarch/loongarch.cc:7999 config/rs6000/rs6000.cc:20738 #: ada/gcc-interface/utils.cc:6746 ada/gcc-interface/utils.cc:6762 #: ada/gcc-interface/utils.cc:6859 ada/gcc-interface/utils.cc:6876 #: ada/gcc-interface/utils.cc:6893 ada/gcc-interface/utils.cc:6908 @@ -25185,67 +25202,67 @@ msgstr "" msgid "%qE attribute ignored" msgstr "" -#: attribs.cc:1209 +#: attribs.cc:1214 #, gcc-internal-format msgid "missing %<target%> attribute for multi-versioned %qD" msgstr "" -#: attribs.cc:1212 cp/decl.cc:1337 cp/decl.cc:2351 cp/decl.cc:2399 +#: attribs.cc:1217 cp/decl.cc:1337 cp/decl.cc:2351 cp/decl.cc:2399 #: cp/decl.cc:2415 cp/decl.cc:3095 cp/decl.cc:3533 #, gcc-internal-format msgid "previous declaration of %qD" msgstr "" -#: attribs.cc:1320 +#: attribs.cc:1325 #, gcc-internal-format msgid "ignoring attributes applied to %qT after definition" msgstr "" -#: attribs.cc:1852 +#: attribs.cc:1857 #, gcc-internal-format msgid "%q+D already declared with dllexport attribute: dllimport ignored" msgstr "" -#: attribs.cc:1864 +#: attribs.cc:1869 #, gcc-internal-format msgid "" "%q+D redeclared without dllimport attribute after being referenced with dll " "linkage" msgstr "" -#: attribs.cc:1878 +#: attribs.cc:1883 #, gcc-internal-format msgid "%q+D redeclared without dllimport attribute: previous dllimport ignored" msgstr "" -#: attribs.cc:1959 +#: attribs.cc:1964 #, gcc-internal-format msgid "inline function %q+D declared as dllimport: attribute ignored" msgstr "" -#: attribs.cc:1967 +#: attribs.cc:1972 #, gcc-internal-format msgid "function %q+D definition is marked dllimport" msgstr "" -#: attribs.cc:1975 +#: attribs.cc:1980 #, gcc-internal-format msgid "variable %q+D definition is marked dllimport" msgstr "" -#: attribs.cc:2006 +#: attribs.cc:2011 #, gcc-internal-format msgid "external linkage required for symbol %q+D because of %qE attribute" msgstr "" -#: attribs.cc:2020 +#: attribs.cc:2025 #, gcc-internal-format msgid "" "%qE implies default visibility, but %qD has already been declared with a " "different visibility" msgstr "" -#: attribs.cc:2322 +#: attribs.cc:2327 #, gcc-internal-format msgid "%qD specifies more restrictive attribute than its target %qD: %s" msgid_plural "" @@ -25253,12 +25270,12 @@ msgid_plural "" msgstr[0] "" msgstr[1] "" -#: attribs.cc:2328 attribs.cc:2348 +#: attribs.cc:2333 attribs.cc:2353 #, gcc-internal-format msgid "%qD target declared here" msgstr "" -#: attribs.cc:2342 +#: attribs.cc:2347 #, gcc-internal-format msgid "%qD specifies less restrictive attribute than its target %qD: %s" msgid_plural "" @@ -25337,7 +25354,7 @@ msgstr "" msgid "%qD specified bound %E equals destination size" msgstr "" -#: builtins.cc:5297 gimplify.cc:3921 +#: builtins.cc:5297 gimplify.cc:3922 #, gcc-internal-format msgid "too few arguments to function %<va_start%>" msgstr "" @@ -26539,12 +26556,12 @@ msgstr "" #. include_self= #. TODO: Add OPT_Wundefined-inline. -#: cgraphunit.cc:1098 c/c-decl.cc:13291 +#: cgraphunit.cc:1098 c/c-decl.cc:13338 #, gcc-internal-format msgid "%q+F used but never defined" msgstr "" -#: cgraphunit.cc:1100 c/c-decl.cc:13301 +#: cgraphunit.cc:1100 c/c-decl.cc:13348 #, gcc-internal-format msgid "%q+F declared %<static%> but never defined" msgstr "" @@ -27232,7 +27249,7 @@ msgstr "" msgid "total size of local objects exceeds maximum %wu" msgstr "" -#: function.cc:1789 gimplify.cc:7017 gimplify.cc:7179 +#: function.cc:1789 gimplify.cc:7018 gimplify.cc:7180 #, gcc-internal-format msgid "impossible constraint in %<asm%>" msgstr "" @@ -27925,7 +27942,7 @@ msgid "" "flexible array member %qD does not have well defined padding bits for %qs" msgstr "" -#: gimple-fold.cc:4726 cp/constexpr.cc:4888 +#: gimple-fold.cc:4726 cp/constexpr.cc:4887 #, gcc-internal-format msgid "PDP11 bit-field handling unsupported in %qs" msgstr "" @@ -27976,21 +27993,21 @@ msgstr "" msgid "function may return address of local variable" msgstr "" -#: gimple-ssa-isolate-paths.cc:414 c/c-typeck.cc:11585 +#: gimple-ssa-isolate-paths.cc:414 c/c-typeck.cc:11587 #, gcc-internal-format msgid "function returns address of local variable" msgstr "" #: gimple-ssa-isolate-paths.cc:417 gimple-ssa-warn-access.cc:2055 #: gimple-ssa-warn-access.cc:3713 tree.cc:12442 tree.cc:12479 tree.cc:12520 -#: tree.cc:12553 c/c-parser.cc:20633 c/c-parser.cc:20774 c/c-typeck.cc:3157 -#: c/c-typeck.cc:3252 c/c-typeck.cc:5869 c/c-typeck.cc:11491 -#: c/c-typeck.cc:11508 c/gimple-parser.cc:2574 c/gimple-parser.cc:2582 -#: cp/call.cc:8180 cp/call.cc:10375 cp/class.cc:9399 cp/constexpr.cc:892 -#: cp/constexpr.cc:1319 cp/constexpr.cc:4309 cp/constexpr.cc:5980 -#: cp/constexpr.cc:6351 cp/cvt.cc:1095 cp/cvt.cc:1133 cp/decl.cc:9104 +#: tree.cc:12553 c/c-parser.cc:20633 c/c-parser.cc:20774 c/c-typeck.cc:3159 +#: c/c-typeck.cc:3254 c/c-typeck.cc:5871 c/c-typeck.cc:11493 +#: c/c-typeck.cc:11510 c/gimple-parser.cc:2574 c/gimple-parser.cc:2582 +#: cp/call.cc:8203 cp/call.cc:10398 cp/class.cc:9399 cp/constexpr.cc:889 +#: cp/constexpr.cc:1316 cp/constexpr.cc:4306 cp/constexpr.cc:5979 +#: cp/constexpr.cc:6350 cp/cvt.cc:1095 cp/cvt.cc:1133 cp/decl.cc:9104 #: cp/decl2.cc:5886 cp/decl2.cc:5941 cp/method.cc:1234 cp/parser.cc:22475 -#: cp/pt.cc:9157 cp/semantics.cc:2374 cp/semantics.cc:3778 cp/semantics.cc:4896 +#: cp/pt.cc:9178 cp/semantics.cc:2378 cp/semantics.cc:3782 cp/semantics.cc:4900 #: cp/typeck.cc:2143 cp/typeck.cc:2363 cp/typeck.cc:4509 cp/typeck.cc:10693 #: rust/backend/rust-constexpr.cc:4407 rust/backend/rust-tree.cc:621 #: rust/backend/rust-tree.cc:3813 @@ -29200,10 +29217,10 @@ msgstr "" #: gimple-ssa-warn-access.cc:3965 gimple-ssa-warn-access.cc:4613 #: gimple-ssa-warn-access.cc:4616 gimple-ssa-warn-restrict.cc:1830 #: tree-ssa-uninit.cc:921 tree-ssa-uninit.cc:1120 c/c-decl.cc:4099 -#: c/c-decl.cc:4389 c/c-typeck.cc:9539 c/c-typeck.cc:12293 cp/call.cc:8555 -#: cp/call.cc:8566 cp/class.cc:1718 cp/class.cc:3517 cp/constexpr.cc:1065 +#: c/c-decl.cc:4389 c/c-typeck.cc:9541 c/c-typeck.cc:12295 cp/call.cc:8578 +#: cp/call.cc:8589 cp/class.cc:1718 cp/class.cc:3517 cp/constexpr.cc:1062 #: cp/decl.cc:4631 cp/decl.cc:12893 cp/decl.cc:13481 cp/decl.cc:13490 -#: cp/decl.cc:14485 cp/friend.cc:406 cp/friend.cc:416 cp/init.cc:2935 +#: cp/decl.cc:14491 cp/friend.cc:406 cp/friend.cc:416 cp/init.cc:2935 #: cp/parser.cc:3692 cp/parser.cc:3838 cp/parser.cc:3889 cp/parser.cc:7166 #: cp/parser.cc:25045 cp/typeck.cc:5002 #, gcc-internal-format @@ -29616,410 +29633,410 @@ msgstr "" msgid "attribute %<fallthrough%> not preceding a case label or default label" msgstr "" -#: gimplify.cc:4091 +#: gimplify.cc:4092 #, gcc-internal-format msgid "using result of function returning %<void%>" msgstr "" -#: gimplify.cc:7018 +#: gimplify.cc:7019 #, gcc-internal-format, gfc-internal-format msgid "non-memory output %d must stay in memory" msgstr "" -#: gimplify.cc:7033 +#: gimplify.cc:7034 #, gcc-internal-format msgid "invalid lvalue in %<asm%> output %d" msgstr "" -#: gimplify.cc:7180 +#: gimplify.cc:7181 #, gcc-internal-format, gfc-internal-format msgid "non-memory input %d must stay in memory" msgstr "" -#: gimplify.cc:7220 gimplify.cc:7230 +#: gimplify.cc:7221 gimplify.cc:7231 #, gcc-internal-format, gfc-internal-format msgid "memory input %d is not directly addressable" msgstr "" -#: gimplify.cc:7853 +#: gimplify.cc:7854 #, gcc-internal-format msgid "" "threadprivate variable %qE used in a region with %<order(concurrent)%> clause" msgstr "" -#: gimplify.cc:7855 +#: gimplify.cc:7856 #, gcc-internal-format msgid "enclosing region" msgstr "" -#: gimplify.cc:7859 +#: gimplify.cc:7860 #, gcc-internal-format msgid "threadprivate variable %qE used in target region" msgstr "" -#: gimplify.cc:7861 +#: gimplify.cc:7862 #, gcc-internal-format msgid "enclosing target region" msgstr "" -#: gimplify.cc:7874 +#: gimplify.cc:7875 #, gcc-internal-format msgid "threadprivate variable %qE used in untied task" msgstr "" -#: gimplify.cc:7876 +#: gimplify.cc:7877 #, gcc-internal-format msgid "enclosing task" msgstr "" -#: gimplify.cc:7973 +#: gimplify.cc:7974 #, gcc-internal-format msgid "%qE not specified in enclosing %qs" msgstr "" -#: gimplify.cc:7975 +#: gimplify.cc:7976 #, gcc-internal-format msgid "enclosing %qs" msgstr "" -#: gimplify.cc:8149 +#: gimplify.cc:8150 #, gcc-internal-format msgid "%qE not specified in enclosing OpenACC %qs construct" msgstr "" -#: gimplify.cc:8153 +#: gimplify.cc:8154 #, gcc-internal-format msgid "enclosing OpenACC %qs construct and" msgstr "" -#: gimplify.cc:8156 +#: gimplify.cc:8157 #, gcc-internal-format msgid "enclosing OpenACC %qs construct with %qs clause" msgstr "" -#: gimplify.cc:8226 +#: gimplify.cc:8227 #, gcc-internal-format msgid "%qE with %<link%> clause used in %<routine%> function" msgstr "" -#: gimplify.cc:8234 +#: gimplify.cc:8235 #, gcc-internal-format msgid "%qE requires a %<declare%> directive for use in a %<routine%> function" msgstr "" -#: gimplify.cc:8296 +#: gimplify.cc:8297 #, gcc-internal-format msgid "%qE not specified in enclosing %<target%>" msgstr "" -#: gimplify.cc:8298 +#: gimplify.cc:8299 #, gcc-internal-format msgid "enclosing %<target%>" msgstr "" -#: gimplify.cc:8333 gimplify.cc:12427 +#: gimplify.cc:8334 gimplify.cc:12428 #, gcc-internal-format msgid "variable %qE declared in enclosing %<host_data%> region" msgstr "" -#: gimplify.cc:8354 +#: gimplify.cc:8355 #, gcc-internal-format msgid "%qD referenced in target region does not have a mappable type" msgstr "" -#: gimplify.cc:8498 +#: gimplify.cc:8499 #, gcc-internal-format msgid "iteration variable %qE is predetermined linear" msgstr "" -#: gimplify.cc:8501 +#: gimplify.cc:8502 #, gcc-internal-format msgid "iteration variable %qE should be private" msgstr "" -#: gimplify.cc:8515 +#: gimplify.cc:8516 #, gcc-internal-format msgid "iteration variable %qE should not be firstprivate" msgstr "" -#: gimplify.cc:8518 +#: gimplify.cc:8519 #, gcc-internal-format msgid "iteration variable %qE should not be reduction" msgstr "" -#: gimplify.cc:8521 +#: gimplify.cc:8522 #, gcc-internal-format msgid "iteration variable %qE should not be linear" msgstr "" -#: gimplify.cc:9525 gimplify.cc:9536 gimplify.cc:9548 gimplify.cc:9564 -#: gimplify.cc:9769 gimplify.cc:9792 gimplify.cc:9803 gimplify.cc:9821 +#: gimplify.cc:9526 gimplify.cc:9537 gimplify.cc:9549 gimplify.cc:9565 +#: gimplify.cc:9770 gimplify.cc:9793 gimplify.cc:9804 gimplify.cc:9822 #, gcc-internal-format msgid "unexpected mapping node" msgstr "" -#: gimplify.cc:9858 +#: gimplify.cc:9859 #, gcc-internal-format msgid "unexpected pointer mapping node" msgstr "" -#: gimplify.cc:10071 +#: gimplify.cc:10072 #, gcc-internal-format msgid "base pointer cycle detected" msgstr "" -#: gimplify.cc:10578 +#: gimplify.cc:10579 #, gcc-internal-format msgid "" "data movement for component %qE is not compatible with movement for struct " "%qE" msgstr "" -#: gimplify.cc:10894 +#: gimplify.cc:10895 #, gcc-internal-format msgid "%qE appears more than once in map clauses" msgstr "" -#: gimplify.cc:11850 +#: gimplify.cc:11851 #, gcc-internal-format msgid "mapping field %qE of variable length structure" msgstr "" -#: gimplify.cc:12120 gimplify.cc:12126 +#: gimplify.cc:12121 gimplify.cc:12127 #, gcc-internal-format msgid "conditional %<lastprivate%> clause on %qs construct" msgstr "" -#: gimplify.cc:12143 +#: gimplify.cc:12144 #, gcc-internal-format msgid "non-scalar variable %qD in conditional %<lastprivate%> clause" msgstr "" -#: gimplify.cc:12165 +#: gimplify.cc:12166 #, gcc-internal-format msgid "%<task%> reduction modifier on a construct with a %<nowait%> clause" msgstr "" -#: gimplify.cc:12173 +#: gimplify.cc:12174 #, gcc-internal-format msgid "" "invalid %<task%> reduction modifier on construct other than %<parallel%>, " "%qs, %<sections%> or %<scope%>" msgstr "" -#: gimplify.cc:12184 gimplify.cc:12190 gimplify.cc:12196 gimplify.cc:12202 -#: gimplify.cc:12208 gimplify.cc:16422 +#: gimplify.cc:12185 gimplify.cc:12191 gimplify.cc:12197 gimplify.cc:12203 +#: gimplify.cc:12209 gimplify.cc:16423 #, gcc-internal-format msgid "%<inscan%> %<reduction%> clause on %qs construct" msgstr "" -#: gimplify.cc:12302 +#: gimplify.cc:12303 #, gcc-internal-format msgid "" "%<linear%> clause for variable other than loop iterator specified on " "construct combined with %<distribute%>" msgstr "" -#: gimplify.cc:12927 +#: gimplify.cc:12928 #, gcc-internal-format msgid "" "copyprivate variable %qE is not threadprivate or private in outer context" msgstr "" -#: gimplify.cc:12984 +#: gimplify.cc:12985 #, gcc-internal-format msgid "%s variable %qE is private in outer context" msgstr "" -#: gimplify.cc:13016 +#: gimplify.cc:13017 #, gcc-internal-format msgid "expected %qs %<if%> clause modifier rather than %qs" msgstr "" -#: gimplify.cc:13055 +#: gimplify.cc:13056 #, gcc-internal-format msgid "" "%<device%> clause with %<ancestor%> is only allowed on %<target%> construct" msgstr "" -#: gimplify.cc:13071 +#: gimplify.cc:13072 #, gcc-internal-format msgid "" "with %<ancestor%>, only the %<device%>, %<firstprivate%>, %<private%>, " "%<defaultmap%>, and %<map%> clauses may appear on the construct" msgstr "" -#: gimplify.cc:13287 +#: gimplify.cc:13288 #, gcc-internal-format msgid "" "%qD specified in %qs clause but not in %<inscan%> %<reduction%> clause on " "the containing construct" msgstr "" -#: gimplify.cc:13499 +#: gimplify.cc:13500 #, gcc-internal-format msgid "%<_Atomic%> %qD in implicit %<map%> clause" msgstr "" -#: gimplify.cc:13553 +#: gimplify.cc:13554 #, gcc-internal-format msgid "" "%<_Atomic%> %qD in implicit %<firstprivate%> clause on %<target%> construct" msgstr "" -#: gimplify.cc:13891 +#: gimplify.cc:13892 #, gcc-internal-format msgid "%<_Atomic%> %qD in %<firstprivate%> clause on %<target%> construct" msgstr "" -#: gimplify.cc:13964 +#: gimplify.cc:13965 #, gcc-internal-format msgid "" "same variable used in %<firstprivate%> and %<lastprivate%> clauses on " "%<distribute%> construct" msgstr "" -#: gimplify.cc:14141 +#: gimplify.cc:14142 #, gcc-internal-format msgid "" "incompatible data clause with reduction on %qE; promoting to " "%<present_or_copy%>" msgstr "" -#: gimplify.cc:14439 +#: gimplify.cc:14440 #, gcc-internal-format msgid "" "%qD specified in %<inscan%> %<reduction%> clause but not in %<scan%> " "directive clause" msgstr "" -#: gimplify.cc:14458 +#: gimplify.cc:14459 #, gcc-internal-format msgid "invalid private reduction on %qE" msgstr "" -#: gimplify.cc:14625 +#: gimplify.cc:14626 #, gcc-internal-format msgid "" "%<inscan%> %<reduction%> clause used together with %<linear%> clause for a " "variable other than loop iterator" msgstr "" -#: gimplify.cc:14969 +#: gimplify.cc:14970 #, gcc-internal-format msgid "%<mutexinoutset%> kind in %<depend%> clause on a %<taskwait%> construct" msgstr "" -#: gimplify.cc:14979 +#: gimplify.cc:14980 #, gcc-internal-format msgid "%<taskwait%> construct with %<nowait%> clause but no %<depend%> clauses" msgstr "" -#: gimplify.cc:15263 gimplify.cc:15267 gimplify.cc:15276 gimplify.cc:15288 -#: gimplify.cc:15293 +#: gimplify.cc:15264 gimplify.cc:15268 gimplify.cc:15277 gimplify.cc:15289 +#: gimplify.cc:15294 #, gcc-internal-format msgid "%qs clause may not appear on non-rectangular %qs" msgstr "" -#: gimplify.cc:15454 +#: gimplify.cc:15455 #, gcc-internal-format msgid "" "%<linear%> clause may not be specified together with %<ordered%> clause if " "stand-alone %<ordered%> construct is nested in it" msgstr "" -#: gimplify.cc:15519 +#: gimplify.cc:15520 #, gcc-internal-format msgid "threadprivate iteration variable %qD" msgstr "" -#: gimplify.cc:15550 gimplify.cc:15658 +#: gimplify.cc:15551 gimplify.cc:15659 #, gcc-internal-format msgid "conditional %<lastprivate%> on loop iterator %qD ignored" msgstr "" -#: gimplify.cc:16360 +#: gimplify.cc:16361 #, gcc-internal-format msgid "" "%<bind%> clause not specified on a %<loop%> construct not nested inside " "another OpenMP construct" msgstr "" -#: gimplify.cc:16384 +#: gimplify.cc:16385 #, gcc-internal-format msgid "" "%<bind(parallel)%> on a %<loop%> construct nested inside %<simd%> construct" msgstr "" -#: gimplify.cc:16404 +#: gimplify.cc:16405 #, gcc-internal-format msgid "" "%<bind(teams)%> on a %<loop%> region not strictly nested inside of a " "%<teams%> region" msgstr "" -#: gimplify.cc:16429 +#: gimplify.cc:16430 #, gcc-internal-format msgid "" "invalid %<task%> reduction modifier on construct other than %<parallel%>, " "%qs or %<sections%>" msgstr "" -#: gimplify.cc:16457 +#: gimplify.cc:16458 #, gcc-internal-format msgid "" "%<lastprivate%> clause on a %<loop%> construct refers to a variable %qD " "which is not the loop iterator" msgstr "" -#: gimplify.cc:17539 +#: gimplify.cc:17540 #, gcc-internal-format msgid "" "%<ordered%> construct with %qs clause must be closely nested inside a loop " "with %<ordered%> clause" msgstr "" -#: gimplify.cc:17560 +#: gimplify.cc:17561 #, gcc-internal-format msgid "variable %qE is not an iteration of outermost loop %d, expected %qE" msgstr "" -#: gimplify.cc:17573 +#: gimplify.cc:17574 #, gcc-internal-format msgid "" "number of variables in %qs clause with %<sink%> modifier does not match " "number of iteration variables" msgstr "" -#: gimplify.cc:17587 +#: gimplify.cc:17588 #, gcc-internal-format msgid "" "more than one %qs clause with %<source%> modifier on an %<ordered%> construct" msgstr "" -#: gimplify.cc:17600 +#: gimplify.cc:17601 #, gcc-internal-format msgid "" "%qs clause with %<source%> modifier specified together with %qs clauses with " "%<sink%> modifier on the same construct" msgstr "" -#: gimplify.cc:18917 +#: gimplify.cc:18918 #, gcc-internal-format msgid "gimplification failed" msgstr "" -#: gimplify.cc:19518 +#: gimplify.cc:19519 #, gcc-internal-format msgid "%qT is promoted to %qT when passed through %<...%>" msgstr "" -#: gimplify.cc:19523 +#: gimplify.cc:19524 #, gcc-internal-format msgid "(so you should pass %qT not %qT to %<va_arg%>)" msgstr "" -#: gimplify.cc:19530 +#: gimplify.cc:19531 #, gcc-internal-format msgid "if this code is reached, the program will abort" msgstr "" @@ -30623,7 +30640,7 @@ msgstr "" msgid "calling %qD using non-%<strub%> type %qT in %<strub%> context %qD" msgstr "" -#: ipa-strub.cc:2836 +#: ipa-strub.cc:2839 #, gcc-internal-format msgid "failed to split %qD for %<strub%>" msgstr "" @@ -33984,73 +34001,78 @@ msgstr "" msgid "label %qD in the middle of basic block %d" msgstr "" +#: tree-cfg.cc:5830 +#, gcc-internal-format, gfc-internal-format +msgid "returns_twice call is not last in basic block %d" +msgstr "" + #: tree-cfg.cc:5839 #, gcc-internal-format, gfc-internal-format -msgid "returns_twice call is %s in basic block %d" +msgid "returns_twice call is not first in basic block %d" msgstr "" -#: tree-cfg.cc:5866 +#: tree-cfg.cc:5871 #, gcc-internal-format, gfc-internal-format msgid "fallthru edge after a control statement in bb %d" msgstr "" -#: tree-cfg.cc:5879 +#: tree-cfg.cc:5884 #, gcc-internal-format, gfc-internal-format msgid "true/false edge after a non-GIMPLE_COND in bb %d" msgstr "" -#: tree-cfg.cc:5902 tree-cfg.cc:5924 tree-cfg.cc:5941 tree-cfg.cc:6010 +#: tree-cfg.cc:5907 tree-cfg.cc:5929 tree-cfg.cc:5946 tree-cfg.cc:6015 #, gcc-internal-format, gfc-internal-format msgid "wrong outgoing edge flags at end of bb %d" msgstr "" -#: tree-cfg.cc:5912 +#: tree-cfg.cc:5917 #, gcc-internal-format, gfc-internal-format msgid "explicit goto at end of bb %d" msgstr "" -#: tree-cfg.cc:5946 +#: tree-cfg.cc:5951 #, gcc-internal-format, gfc-internal-format msgid "return edge does not point to exit in bb %d" msgstr "" -#: tree-cfg.cc:5976 +#: tree-cfg.cc:5981 #, gcc-internal-format msgid "found default case not at the start of case vector" msgstr "" -#: tree-cfg.cc:5984 +#: tree-cfg.cc:5989 #, gcc-internal-format msgid "case labels not sorted: " msgstr "" -#: tree-cfg.cc:6001 +#: tree-cfg.cc:6006 #, gcc-internal-format, gfc-internal-format msgid "extra outgoing edge %d->%d" msgstr "" -#: tree-cfg.cc:6024 +#: tree-cfg.cc:6029 #, gcc-internal-format, gfc-internal-format msgid "missing edge %i->%i" msgstr "" -#: tree-cfg.cc:9780 +#: tree-cfg.cc:9785 #, gcc-internal-format msgid "%<noreturn%> function does return" msgstr "" -#: tree-cfg.cc:9800 tree-cfg.cc:9835 +#: tree-cfg.cc:9805 tree-cfg.cc:9840 #, gcc-internal-format msgid "control reaches end of non-void function" msgstr "" -#: tree-cfg.cc:9901 +#: tree-cfg.cc:9906 #, gcc-internal-format msgid "" "ignoring return value of %qD declared with attribute %<warn_unused_result%>" msgstr "" -#: tree-cfg.cc:9906 cp/cvt.cc:1137 +#: tree-cfg.cc:9911 cp/cvt.cc:1137 #, gcc-internal-format msgid "" "ignoring return value of function declared with attribute " @@ -34272,17 +34294,17 @@ msgstr "" msgid "invalid fn spec attribute \"%s\" arg %i" msgstr "" -#: tree-ssa-ccp.cc:4681 c-family/c-common.cc:5911 +#: tree-ssa-ccp.cc:4681 c-family/c-common.cc:5912 #, gcc-internal-format msgid "%qs pointer is null" msgstr "" -#: tree-ssa-ccp.cc:4684 c-family/c-common.cc:5914 +#: tree-ssa-ccp.cc:4684 c-family/c-common.cc:5915 #, gcc-internal-format msgid "in a call to non-static member function %qD" msgstr "" -#: tree-ssa-ccp.cc:4690 c-family/c-common.cc:5920 +#: tree-ssa-ccp.cc:4690 c-family/c-common.cc:5921 #, gcc-internal-format, gfc-internal-format msgid "argument %u null where non-null expected" msgstr "" @@ -34292,7 +34314,7 @@ msgstr "" msgid "in a call to built-in function %qD" msgstr "" -#: tree-ssa-ccp.cc:4700 c-family/c-common.cc:5924 +#: tree-ssa-ccp.cc:4700 c-family/c-common.cc:5925 #, gcc-internal-format msgid "in a call to function %qD declared %qs" msgstr "" @@ -34750,7 +34772,7 @@ msgstr "" msgid "vector shuffling operation will be expanded piecewise" msgstr "" -#: tree-vect-loop.cc:5064 +#: tree-vect-loop.cc:5065 #, gcc-internal-format msgid "vectorization did not happen for a simd loop" msgstr "" @@ -35306,7 +35328,7 @@ msgid "" "requested alignment for %q+D is greater than implemented alignment of %wu" msgstr "" -#: varasm.cc:2334 c/c-decl.cc:5901 c/c-parser.cc:1910 m2/gm2-gcc/m2type.cc:1240 +#: varasm.cc:2334 c/c-decl.cc:5903 c/c-parser.cc:1910 m2/gm2-gcc/m2type.cc:1240 #, gcc-internal-format msgid "storage size of %q+D isn%'t known" msgstr "" @@ -36405,7 +36427,7 @@ msgstr "" #: c-family/c-attribs.cc:6247 #, gcc-internal-format -msgid "%qE attribute argument %qE is not recognised" +msgid "%qE attribute argument %qE is not recognized" msgstr "" #: c-family/c-attribs.cc:6262 @@ -36637,13 +36659,13 @@ msgid "" "%<true%>" msgstr "" -#: c-family/c-common.cc:3778 cp/semantics.cc:945 +#: c-family/c-common.cc:3778 cp/semantics.cc:949 #, gcc-internal-format msgid "suggest parentheses around assignment used as truth value" msgstr "" -#: c-family/c-common.cc:3865 c/c-decl.cc:4966 c/c-decl.cc:7655 -#: c/c-parser.cc:3739 c/c-typeck.cc:16504 +#: c-family/c-common.cc:3865 c/c-decl.cc:4966 c/c-decl.cc:7657 +#: c/c-parser.cc:3739 c/c-typeck.cc:16506 #, gcc-internal-format msgid "invalid use of %<restrict%>" msgstr "" @@ -36768,331 +36790,331 @@ msgstr "" msgid "not enough variable arguments to fit a sentinel" msgstr "" -#: c-family/c-common.cc:5792 +#: c-family/c-common.cc:5793 #, gcc-internal-format msgid "missing sentinel in function call" msgstr "" -#: c-family/c-common.cc:6019 c-family/c-common.cc:6069 d/d-attribs.cc:837 +#: c-family/c-common.cc:6020 c-family/c-common.cc:6070 d/d-attribs.cc:837 #: d/d-attribs.cc:887 #, gcc-internal-format msgid "bad option %qs to attribute %<optimize%>" msgstr "" -#: c-family/c-common.cc:6022 c-family/c-common.cc:6073 +#: c-family/c-common.cc:6023 c-family/c-common.cc:6074 #, gcc-internal-format msgid "bad option %qs to pragma %<optimize%>" msgstr "" -#: c-family/c-common.cc:6121 +#: c-family/c-common.cc:6122 #, gcc-internal-format msgid "attribute %<fallthrough%> specified multiple times" msgstr "" -#: c-family/c-common.cc:6125 +#: c-family/c-common.cc:6126 #, gcc-internal-format msgid "%<fallthrough%> attribute specified with a parameter" msgstr "" -#: c-family/c-common.cc:6306 c-family/c-common.cc:7228 -#: c-family/c-common.cc:7275 c-family/c-common.cc:7354 -#: c-family/c-common.cc:7437 c-family/c-common.cc:8080 +#: c-family/c-common.cc:6307 c-family/c-common.cc:7229 +#: c-family/c-common.cc:7276 c-family/c-common.cc:7355 +#: c-family/c-common.cc:7438 c-family/c-common.cc:8081 #: config/aarch64/aarch64-sve-builtins.cc:3026 -#: config/arm/arm-mve-builtins.cc:1570 c/c-typeck.cc:3918 +#: config/arm/arm-mve-builtins.cc:1570 c/c-typeck.cc:3920 #, gcc-internal-format msgid "too few arguments to function %qE" msgstr "" -#: c-family/c-common.cc:6311 c-family/c-common.cc:7281 -#: c-family/c-common.cc:7463 c-family/c-common.cc:8082 +#: c-family/c-common.cc:6312 c-family/c-common.cc:7282 +#: c-family/c-common.cc:7464 c-family/c-common.cc:8083 #: config/aarch64/aarch64-sve-builtins.cc:3028 -#: config/arm/arm-mve-builtins.cc:1572 c/c-typeck.cc:3777 +#: config/arm/arm-mve-builtins.cc:1572 c/c-typeck.cc:3779 #, gcc-internal-format msgid "too many arguments to function %qE" msgstr "" -#: c-family/c-common.cc:6353 +#: c-family/c-common.cc:6354 #, gcc-internal-format msgid "third argument to function %qE must be a constant integer" msgstr "" -#: c-family/c-common.cc:6378 +#: c-family/c-common.cc:6379 #, gcc-internal-format msgid "" "second argument to function %qE must be a constant integer power of 2 " "between %qi and %qu bits" msgstr "" -#: c-family/c-common.cc:6400 c-family/c-common.cc:6447 +#: c-family/c-common.cc:6401 c-family/c-common.cc:6448 #, gcc-internal-format msgid "non-floating-point argument in call to function %qE" msgstr "" -#: c-family/c-common.cc:6426 +#: c-family/c-common.cc:6427 #, gcc-internal-format msgid "non-floating-point arguments in call to function %qE" msgstr "" -#: c-family/c-common.cc:6440 +#: c-family/c-common.cc:6441 #, gcc-internal-format msgid "non-const integer argument %u in call to function %qE" msgstr "" -#: c-family/c-common.cc:6462 +#: c-family/c-common.cc:6463 #, gcc-internal-format msgid "non-integer argument 3 in call to function %qE" msgstr "" -#: c-family/c-common.cc:6479 c-family/c-common.cc:6529 -#: c-family/c-common.cc:6594 c-family/c-common.cc:6614 +#: c-family/c-common.cc:6480 c-family/c-common.cc:6530 +#: c-family/c-common.cc:6595 c-family/c-common.cc:6615 #, gcc-internal-format msgid "argument %u in call to function %qE does not have integral type" msgstr "" -#: c-family/c-common.cc:6486 +#: c-family/c-common.cc:6487 #, gcc-internal-format msgid "" "argument 3 in call to function %qE does not have pointer to integral type" msgstr "" -#: c-family/c-common.cc:6492 +#: c-family/c-common.cc:6493 #, gcc-internal-format msgid "argument 3 in call to function %qE has pointer to enumerated type" msgstr "" -#: c-family/c-common.cc:6498 +#: c-family/c-common.cc:6499 #, gcc-internal-format msgid "argument 3 in call to function %qE has pointer to boolean type" msgstr "" -#: c-family/c-common.cc:6504 c-family/c-common.cc:6511 -#: c-family/c-common.cc:6566 c-family/c-common.cc:6573 +#: c-family/c-common.cc:6505 c-family/c-common.cc:6512 +#: c-family/c-common.cc:6567 c-family/c-common.cc:6574 #, gcc-internal-format msgid "argument %u in call to function %qE has pointer to %qs type (%qT)" msgstr "" -#: c-family/c-common.cc:6535 c-family/c-common.cc:6620 +#: c-family/c-common.cc:6536 c-family/c-common.cc:6621 #, gcc-internal-format msgid "argument %u in call to function %qE has enumerated type" msgstr "" -#: c-family/c-common.cc:6541 c-family/c-common.cc:6626 +#: c-family/c-common.cc:6542 c-family/c-common.cc:6627 #, gcc-internal-format msgid "argument %u in call to function %qE has boolean type" msgstr "" -#: c-family/c-common.cc:6554 +#: c-family/c-common.cc:6555 #, gcc-internal-format msgid "argument %u in call to function %qE does not have pointer type" msgstr "" -#: c-family/c-common.cc:6560 +#: c-family/c-common.cc:6561 #, gcc-internal-format msgid "argument %u in call to function %qE points to incomplete type" msgstr "" -#: c-family/c-common.cc:6604 +#: c-family/c-common.cc:6605 #, gcc-internal-format msgid "argument %u in call to function %qE does not have %<int%> type" msgstr "" -#: c-family/c-common.cc:6635 +#: c-family/c-common.cc:6636 #, gcc-internal-format msgid "argument 1 in call to function %qE has unsigned type" msgstr "" -#: c-family/c-common.cc:6642 +#: c-family/c-common.cc:6643 #, gcc-internal-format msgid "argument 1 in call to function %qE has signed type" msgstr "" -#: c-family/c-common.cc:6905 rust/backend/rust-tree.cc:3601 +#: c-family/c-common.cc:6906 rust/backend/rust-tree.cc:3601 #, gcc-internal-format msgid "cannot apply %<offsetof%> to static data member %qD" msgstr "" -#: c-family/c-common.cc:6910 rust/backend/rust-tree.cc:3606 +#: c-family/c-common.cc:6911 rust/backend/rust-tree.cc:3606 #, gcc-internal-format msgid "cannot apply %<offsetof%> when %<operator[]%> is overloaded" msgstr "" -#: c-family/c-common.cc:6917 rust/backend/rust-tree.cc:3613 +#: c-family/c-common.cc:6918 rust/backend/rust-tree.cc:3613 #, gcc-internal-format msgid "cannot apply %<offsetof%> to a non constant address" msgstr "" -#: c-family/c-common.cc:6930 rust/backend/rust-tree.cc:3626 +#: c-family/c-common.cc:6931 rust/backend/rust-tree.cc:3626 #, gcc-internal-format msgid "attempt to take address of bit-field structure member %qD" msgstr "" -#: c-family/c-common.cc:6983 rust/backend/rust-tree.cc:3678 +#: c-family/c-common.cc:6984 rust/backend/rust-tree.cc:3678 #, gcc-internal-format msgid "index %E denotes an offset greater than size of %qT" msgstr "" -#: c-family/c-common.cc:7144 +#: c-family/c-common.cc:7145 #, gcc-internal-format msgid "size of array is too large" msgstr "" -#: c-family/c-common.cc:7258 c-family/c-common.cc:7396 +#: c-family/c-common.cc:7259 c-family/c-common.cc:7397 #, gcc-internal-format msgid "operand type %qT is incompatible with argument %d of %qE" msgstr "" -#: c-family/c-common.cc:7292 +#: c-family/c-common.cc:7293 #, gcc-internal-format msgid "expecting argument of type pointer or of type integer for argument 1" msgstr "" -#: c-family/c-common.cc:7308 +#: c-family/c-common.cc:7309 #, gcc-internal-format msgid "both arguments must be compatible" msgstr "" -#: c-family/c-common.cc:7538 +#: c-family/c-common.cc:7539 #, gcc-internal-format msgid "incorrect number of arguments to function %qE" msgstr "" -#: c-family/c-common.cc:7552 +#: c-family/c-common.cc:7553 #, gcc-internal-format msgid "argument 1 of %qE must be a non-void pointer type" msgstr "" -#: c-family/c-common.cc:7559 +#: c-family/c-common.cc:7560 #, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a complete type" msgstr "" -#: c-family/c-common.cc:7568 +#: c-family/c-common.cc:7569 #, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a constant size type" msgstr "" -#: c-family/c-common.cc:7579 +#: c-family/c-common.cc:7580 #, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a nonzero size object" msgstr "" -#: c-family/c-common.cc:7600 +#: c-family/c-common.cc:7601 #, gcc-internal-format msgid "argument %d of %qE must be a pointer type" msgstr "" -#: c-family/c-common.cc:7608 +#: c-family/c-common.cc:7609 #, gcc-internal-format msgid "argument %d of %qE must be a pointer to a constant size type" msgstr "" -#: c-family/c-common.cc:7614 +#: c-family/c-common.cc:7615 #, gcc-internal-format msgid "argument %d of %qE must not be a pointer to a function" msgstr "" -#: c-family/c-common.cc:7622 +#: c-family/c-common.cc:7623 #, gcc-internal-format msgid "size mismatch in argument %d of %qE" msgstr "" -#: c-family/c-common.cc:7635 +#: c-family/c-common.cc:7636 #, gcc-internal-format msgid "argument %d of %qE must not be a pointer to a %<const%> type" msgstr "" -#: c-family/c-common.cc:7640 +#: c-family/c-common.cc:7641 #, gcc-internal-format msgid "argument %d of %qE discards %<const%> qualifier" msgstr "" -#: c-family/c-common.cc:7649 +#: c-family/c-common.cc:7650 #, gcc-internal-format msgid "argument %d of %qE must not be a pointer to a %<volatile%> type" msgstr "" -#: c-family/c-common.cc:7654 +#: c-family/c-common.cc:7655 #, gcc-internal-format msgid "argument %d of %qE discards %<volatile%> qualifier" msgstr "" -#: c-family/c-common.cc:7667 +#: c-family/c-common.cc:7668 #, gcc-internal-format msgid "non-integer memory model argument %d of %qE" msgstr "" -#: c-family/c-common.cc:7680 +#: c-family/c-common.cc:7681 #, gcc-internal-format msgid "invalid memory model argument %d of %qE" msgstr "" -#: c-family/c-common.cc:8314 +#: c-family/c-common.cc:8315 #, gcc-internal-format msgid "" "this target does not define a speculation barrier; your program will still " "execute correctly, but incorrect speculation may not be restricted" msgstr "" -#: c-family/c-common.cc:8968 +#: c-family/c-common.cc:8969 #, gcc-internal-format msgid "index value is out of bound" msgstr "" -#: c-family/c-common.cc:9010 c-family/c-common.cc:9059 -#: c-family/c-common.cc:9075 +#: c-family/c-common.cc:9011 c-family/c-common.cc:9060 +#: c-family/c-common.cc:9076 #, gcc-internal-format msgid "conversion of scalar %qT to vector %qT involves truncation" msgstr "" #. Reject arguments that are built-in functions with #. no library fallback. -#: c-family/c-common.cc:9163 d/intrinsics.cc:1459 +#: c-family/c-common.cc:9164 d/intrinsics.cc:1459 #: rust/backend/rust-tree.cc:3497 #, gcc-internal-format msgid "built-in function %qE must be directly called" msgstr "" -#: c-family/c-common.cc:9183 +#: c-family/c-common.cc:9184 #, gcc-internal-format msgid "size of array %qE is not a constant expression" msgstr "" -#: c-family/c-common.cc:9186 +#: c-family/c-common.cc:9187 #, gcc-internal-format msgid "size of array is not a constant expression" msgstr "" -#: c-family/c-common.cc:9190 +#: c-family/c-common.cc:9191 #, gcc-internal-format msgid "size %qE of array %qE is negative" msgstr "" -#: c-family/c-common.cc:9193 +#: c-family/c-common.cc:9194 #, gcc-internal-format msgid "size %qE of array is negative" msgstr "" -#: c-family/c-common.cc:9198 +#: c-family/c-common.cc:9199 #, gcc-internal-format msgid "size %qE of array %qE exceeds maximum object size %qE" msgstr "" -#: c-family/c-common.cc:9201 +#: c-family/c-common.cc:9202 #, gcc-internal-format msgid "size %qE of array exceeds maximum object size %qE" msgstr "" -#: c-family/c-common.cc:9206 +#: c-family/c-common.cc:9207 #, gcc-internal-format msgid "size of array %qE exceeds maximum object size %qE" msgstr "" -#: c-family/c-common.cc:9209 +#: c-family/c-common.cc:9210 #, gcc-internal-format msgid "size of array exceeds maximum object size %qE" msgstr "" -#: c-family/c-common.cc:9280 +#: c-family/c-common.cc:9281 #, gcc-internal-format msgid "" "environment variable %qs must expand to a non-negative integer less than or " @@ -37730,7 +37752,7 @@ msgstr "" msgid "integer constant is too large for %<_BitInt(%d)%> type" msgstr "" -#: c-family/c-lex.cc:1045 c/c-decl.cc:12651 +#: c-family/c-lex.cc:1045 c/c-decl.cc:12698 #, gcc-internal-format msgid "%<_BitInt(%d)%> is not supported on this target" msgstr "" @@ -37814,7 +37836,7 @@ msgstr "" msgid "traditional C rejects string constant concatenation" msgstr "" -#: c-family/c-omp.cc:131 cp/pt.cc:19123 +#: c-family/c-omp.cc:131 cp/pt.cc:19155 #, gcc-internal-format msgid "" "%<#pragma omp critical%> with %<hint%> clause requires a name, except when " @@ -37874,7 +37896,7 @@ msgstr "" msgid "%<iterator%> modifier may not be specified on %<depobj%> construct" msgstr "" -#: c-family/c-omp.cc:969 cp/semantics.cc:10921 +#: c-family/c-omp.cc:969 cp/semantics.cc:10925 #, gcc-internal-format msgid "invalid type for iteration variable %qE" msgstr "" @@ -37889,17 +37911,17 @@ msgstr "" msgid "%qE is not initialized" msgstr "" -#: c-family/c-omp.cc:1011 cp/semantics.cc:10813 +#: c-family/c-omp.cc:1011 cp/semantics.cc:10817 #, gcc-internal-format msgid "missing controlling predicate" msgstr "" -#: c-family/c-omp.cc:1117 cp/semantics.cc:10409 +#: c-family/c-omp.cc:1117 cp/semantics.cc:10413 #, gcc-internal-format msgid "invalid controlling predicate" msgstr "" -#: c-family/c-omp.cc:1124 cp/semantics.cc:10819 +#: c-family/c-omp.cc:1124 cp/semantics.cc:10823 #, gcc-internal-format msgid "missing increment expression" msgstr "" @@ -37909,7 +37931,7 @@ msgstr "" msgid "increment is not constant 1 or -1 for %<!=%> condition" msgstr "" -#: c-family/c-omp.cc:1255 cp/semantics.cc:10526 +#: c-family/c-omp.cc:1255 cp/semantics.cc:10530 #, gcc-internal-format msgid "invalid increment expression" msgstr "" @@ -38005,7 +38027,7 @@ msgid "" "%<for simd%>, %<parallel for%>, %<parallel for simd%>" msgstr "" -#: c-family/c-omp.cc:2947 c/c-typeck.cc:16316 cp/semantics.cc:9513 +#: c-family/c-omp.cc:2947 c/c-typeck.cc:16318 cp/semantics.cc:9517 #, gcc-internal-format msgid "" "%qD specified in %<allocate%> clause but not in an explicit privatization " @@ -38017,7 +38039,7 @@ msgstr "" msgid "%qD is not a function argument" msgstr "" -#: c-family/c-omp.cc:3335 c/c-typeck.cc:15464 cp/semantics.cc:8252 +#: c-family/c-omp.cc:3335 c/c-typeck.cc:15466 cp/semantics.cc:8256 #, gcc-internal-format msgid "bit-field %qE in %qs clause" msgstr "" @@ -38027,8 +38049,8 @@ msgstr "" msgid "%qE does not have a mappable type in %qs clause" msgstr "" -#: c-family/c-omp.cc:3351 c/c-typeck.cc:13874 c/c-typeck.cc:15553 -#: c/c-typeck.cc:15741 +#: c-family/c-omp.cc:3351 c/c-typeck.cc:13876 c/c-typeck.cc:15555 +#: c/c-typeck.cc:15743 #, gcc-internal-format msgid "%<_Atomic%> %qE in %qs clause" msgstr "" @@ -38643,8 +38665,8 @@ msgstr "" msgid "wrong type argument to %s" msgstr "" -#: c-family/c-warn.cc:59 c-family/c-warn.cc:72 cp/constexpr.cc:3588 -#: cp/constexpr.cc:7354 m2/gm2-gcc/m2expr.cc:964 +#: c-family/c-warn.cc:59 c-family/c-warn.cc:72 cp/constexpr.cc:3585 +#: cp/constexpr.cc:7353 m2/gm2-gcc/m2expr.cc:964 #: rust/backend/rust-constexpr.cc:1908 rust/backend/rust-constexpr.cc:4331 #, gcc-internal-format msgid "overflow in constant expression" @@ -39169,19 +39191,19 @@ msgstr "" msgid "function %qD used as %<asm%> output" msgstr "" -#: c-family/c-warn.cc:1905 c/c-typeck.cc:5213 +#: c-family/c-warn.cc:1905 c/c-typeck.cc:5215 #: rust/checks/errors/rust-readonly-check.cc:100 #, gcc-internal-format msgid "assignment of read-only location %qE" msgstr "" -#: c-family/c-warn.cc:1906 c/c-typeck.cc:5216 +#: c-family/c-warn.cc:1906 c/c-typeck.cc:5218 #: rust/checks/errors/rust-readonly-check.cc:101 #, gcc-internal-format msgid "increment of read-only location %qE" msgstr "" -#: c-family/c-warn.cc:1907 c/c-typeck.cc:5219 +#: c-family/c-warn.cc:1907 c/c-typeck.cc:5221 #: rust/checks/errors/rust-readonly-check.cc:102 #, gcc-internal-format msgid "decrement of read-only location %qE" @@ -39467,7 +39489,7 @@ msgid_plural "" msgstr[0] "" msgstr[1] "" -#: c-family/c-warn.cc:2922 c/c-typeck.cc:5823 cp/call.cc:6362 +#: c-family/c-warn.cc:2922 c/c-typeck.cc:5825 cp/call.cc:6385 #, gcc-internal-format msgid "this condition has identical branches" msgstr "" @@ -39684,7 +39706,7 @@ msgid "" "%s%>" msgstr "" -#: common/config/aarch64/aarch64-common.cc:415 config/aarch64/aarch64.cc:18535 +#: common/config/aarch64/aarch64-common.cc:415 config/aarch64/aarch64.cc:18539 #, gcc-internal-format msgid "unknown value %qs for %<-mcpu%>" msgstr "" @@ -39715,15 +39737,15 @@ msgid "unrecognized option passed to %%:%<target_mode_check%>" msgstr "" #: common/config/arm/arm-common.cc:378 common/config/arm/arm-common.cc:442 -#: common/config/arm/arm-common.cc:489 config/aarch64/aarch64.cc:18467 -#: config/aarch64/aarch64.cc:18505 +#: common/config/arm/arm-common.cc:489 config/aarch64/aarch64.cc:18471 +#: config/aarch64/aarch64.cc:18509 #, gcc-internal-format msgid "valid arguments are: %s; did you mean %qs?" msgstr "" #: common/config/arm/arm-common.cc:381 common/config/arm/arm-common.cc:445 -#: common/config/arm/arm-common.cc:492 config/aarch64/aarch64.cc:18470 -#: config/aarch64/aarch64.cc:18508 +#: common/config/arm/arm-common.cc:492 config/aarch64/aarch64.cc:18474 +#: config/aarch64/aarch64.cc:18512 #, gcc-internal-format, gfc-internal-format msgid "valid arguments are: %s" msgstr "" @@ -40432,7 +40454,7 @@ msgid "ACLE function %qD requires ISA extension %qs" msgstr "" #: config/aarch64/aarch64-sve-builtins.cc:1091 config/aarch64/aarch64.cc:11151 -#: config/aarch64/aarch64.cc:18310 config/aarch64/aarch64.cc:19082 +#: config/aarch64/aarch64.cc:18314 config/aarch64/aarch64.cc:19086 #, gcc-internal-format msgid "" "you can enable %qs using the command-line option %<-march%>, or by using the " @@ -41031,19 +41053,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function" msgstr "" #: config/aarch64/aarch64.cc:7021 config/aarch64/aarch64.cc:7100 -#: config/aarch64/aarch64.cc:21311 +#: config/aarch64/aarch64.cc:21321 #, gcc-internal-format msgid "parameter passing for argument of type %qT changed in GCC 13.1" msgstr "" #: config/aarch64/aarch64.cc:7028 config/aarch64/aarch64.cc:7107 -#: config/aarch64/aarch64.cc:21318 +#: config/aarch64/aarch64.cc:21328 #, gcc-internal-format msgid "parameter passing for argument of type %qT changed in GCC 14.1" msgstr "" #: config/aarch64/aarch64.cc:7039 config/aarch64/aarch64.cc:7117 -#: config/aarch64/aarch64.cc:21326 config/arm/arm.cc:7342 +#: config/aarch64/aarch64.cc:21336 config/arm/arm.cc:7342 #: config/arm/arm.cc:7372 config/arm/arm.cc:29418 #, gcc-internal-format msgid "parameter passing for argument of type %qT changed in GCC 9.1" @@ -41095,37 +41117,37 @@ msgstr "" msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA" msgstr "" -#: config/aarch64/aarch64.cc:17928 +#: config/aarch64/aarch64.cc:17932 #, gcc-internal-format msgid "unknown flag passed in %<-moverride=%s%> (%s)" msgstr "" -#: config/aarch64/aarch64.cc:17972 +#: config/aarch64/aarch64.cc:17976 #, gcc-internal-format msgid "%qs string ill-formed" msgstr "" -#: config/aarch64/aarch64.cc:18028 +#: config/aarch64/aarch64.cc:18032 #, gcc-internal-format msgid "invalid format for %<sve_width%>" msgstr "" -#: config/aarch64/aarch64.cc:18040 +#: config/aarch64/aarch64.cc:18044 #, gcc-internal-format msgid "invalid %<sve_width%> value: %d" msgstr "" -#: config/aarch64/aarch64.cc:18060 +#: config/aarch64/aarch64.cc:18064 #, gcc-internal-format, gfc-internal-format msgid "tuning string missing in option (%s)" msgstr "" -#: config/aarch64/aarch64.cc:18078 +#: config/aarch64/aarch64.cc:18082 #, gcc-internal-format, gfc-internal-format msgid "unknown tuning option (%s)" msgstr "" -#: config/aarch64/aarch64.cc:18266 config/arm/arm.cc:3227 +#: config/aarch64/aarch64.cc:18270 config/arm/arm.cc:3227 #: config/riscv/riscv.cc:9367 #, gcc-internal-format msgid "" @@ -41133,343 +41155,343 @@ msgid "" "protector-guard-offset=%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18275 config/riscv/riscv.cc:9376 +#: config/aarch64/aarch64.cc:18279 config/riscv/riscv.cc:9376 #, gcc-internal-format msgid "" "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> " "must be used with %<-mstack-protector-guard=sysreg%>" msgstr "" -#: config/aarch64/aarch64.cc:18283 +#: config/aarch64/aarch64.cc:18287 #, gcc-internal-format msgid "specify a system register with a small string length" msgstr "" -#: config/aarch64/aarch64.cc:18293 config/arm/arm.cc:3239 -#: config/riscv/riscv.cc:9405 config/rs6000/rs6000.cc:4498 +#: config/aarch64/aarch64.cc:18297 config/arm/arm.cc:3239 +#: config/riscv/riscv.cc:9405 config/rs6000/rs6000.cc:4497 #, gcc-internal-format msgid "%qs is not a valid offset in %qs" msgstr "" -#: config/aarch64/aarch64.cc:18300 +#: config/aarch64/aarch64.cc:18304 #, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>" msgstr "" -#: config/aarch64/aarch64.cc:18306 +#: config/aarch64/aarch64.cc:18310 #, gcc-internal-format msgid "streaming functions require the ISA extension %qs" msgstr "" -#: config/aarch64/aarch64.cc:18308 +#: config/aarch64/aarch64.cc:18312 #, gcc-internal-format msgid "functions with SME state require the ISA extension %qs" msgstr "" -#: config/aarch64/aarch64.cc:18402 +#: config/aarch64/aarch64.cc:18406 #, gcc-internal-format msgid "" "only values 12 (4 KB) and 16 (64 KB) are supported for guard size. Given " "value %d (%llu KB) is out of range" msgstr "" -#: config/aarch64/aarch64.cc:18418 +#: config/aarch64/aarch64.cc:18422 #, gcc-internal-format msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>" msgstr "" -#: config/aarch64/aarch64.cc:18532 +#: config/aarch64/aarch64.cc:18536 #, gcc-internal-format msgid "missing cpu name in %<-mcpu=%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18542 +#: config/aarch64/aarch64.cc:18546 #, gcc-internal-format msgid "did you mean %<-march=%s%>?" msgstr "" -#: config/aarch64/aarch64.cc:18545 +#: config/aarch64/aarch64.cc:18549 #, gcc-internal-format msgid "invalid feature modifier %qs in %<-mcpu=%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18604 +#: config/aarch64/aarch64.cc:18608 #, gcc-internal-format msgid "invalid argument given to %<-mharden-sls=%>" msgstr "" -#: config/aarch64/aarch64.cc:18615 +#: config/aarch64/aarch64.cc:18619 #, gcc-internal-format msgid "%qs must be by itself for %<-mharden-sls=%>" msgstr "" -#: config/aarch64/aarch64.cc:18620 +#: config/aarch64/aarch64.cc:18624 #, gcc-internal-format msgid "invalid argument %<%s%> for %<-mharden-sls=%>" msgstr "" -#: config/aarch64/aarch64.cc:18648 +#: config/aarch64/aarch64.cc:18652 #, gcc-internal-format msgid "missing arch name in %<-march=%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18651 +#: config/aarch64/aarch64.cc:18655 #, gcc-internal-format msgid "unknown value %qs for %<-march%>" msgstr "" -#: config/aarch64/aarch64.cc:18657 +#: config/aarch64/aarch64.cc:18661 #, gcc-internal-format msgid "did you mean %<-mcpu=%s%>?" msgstr "" -#: config/aarch64/aarch64.cc:18660 +#: config/aarch64/aarch64.cc:18664 #, gcc-internal-format msgid "invalid feature modifier %qs in %<-march=%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18688 +#: config/aarch64/aarch64.cc:18692 #, gcc-internal-format msgid "missing cpu name in %<-mtune=%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18691 +#: config/aarch64/aarch64.cc:18695 #, gcc-internal-format msgid "unknown value %qs for %<-mtune%>" msgstr "" -#: config/aarch64/aarch64.cc:18843 +#: config/aarch64/aarch64.cc:18847 #, gcc-internal-format msgid "" "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in " "options %<%s%> being added" msgstr "" -#: config/aarch64/aarch64.cc:18899 +#: config/aarch64/aarch64.cc:18903 #, gcc-internal-format msgid "assembler does not support %<-mabi=ilp32%>" msgstr "" -#: config/aarch64/aarch64.cc:18906 +#: config/aarch64/aarch64.cc:18910 #, gcc-internal-format msgid "return address signing is only supported for %<-mabi=lp64%>" msgstr "" -#: config/aarch64/aarch64.cc:18979 +#: config/aarch64/aarch64.cc:18983 #, gcc-internal-format msgid "code model %qs with %<-f%s%>" msgstr "" -#: config/aarch64/aarch64.cc:18982 +#: config/aarch64/aarch64.cc:18986 #, gcc-internal-format msgid "code model %qs not supported in ilp32 mode" msgstr "" -#: config/aarch64/aarch64.cc:19080 +#: config/aarch64/aarch64.cc:19084 #, gcc-internal-format msgid "functions with %qs state require the ISA extension %qs" msgstr "" -#: config/aarch64/aarch64.cc:19183 +#: config/aarch64/aarch64.cc:19187 #, gcc-internal-format msgid "missing name in %<target(\"arch=\")%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19186 +#: config/aarch64/aarch64.cc:19190 #, gcc-internal-format msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19190 +#: config/aarch64/aarch64.cc:19194 #, gcc-internal-format msgid "" "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19224 +#: config/aarch64/aarch64.cc:19228 #, gcc-internal-format msgid "missing name in %<target(\"cpu=\")%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19227 +#: config/aarch64/aarch64.cc:19231 #, gcc-internal-format msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19231 config/aarch64/aarch64.cc:19315 +#: config/aarch64/aarch64.cc:19235 config/aarch64/aarch64.cc:19319 #, gcc-internal-format msgid "" "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19270 +#: config/aarch64/aarch64.cc:19274 #, gcc-internal-format msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19311 +#: config/aarch64/aarch64.cc:19315 #, gcc-internal-format msgid "missing value in %<target()%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19369 config/aarch64/aarch64.cc:19542 +#: config/aarch64/aarch64.cc:19373 config/aarch64/aarch64.cc:19546 #, gcc-internal-format msgid "malformed %<target()%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19413 +#: config/aarch64/aarch64.cc:19417 #, gcc-internal-format msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument" msgstr "" -#: config/aarch64/aarch64.cc:19421 config/i386/i386-options.cc:1303 +#: config/aarch64/aarch64.cc:19425 config/i386/i386-options.cc:1303 #, gcc-internal-format msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form" msgstr "" -#: config/aarch64/aarch64.cc:19475 +#: config/aarch64/aarch64.cc:19479 #, gcc-internal-format msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid" msgstr "" -#: config/aarch64/aarch64.cc:19532 config/arm/arm.cc:33675 -#: config/riscv/riscv-target-attr.cc:325 config/rs6000/rs6000.cc:24685 +#: config/aarch64/aarch64.cc:19536 config/arm/arm.cc:33675 +#: config/riscv/riscv-target-attr.cc:325 config/rs6000/rs6000.cc:24684 #: config/s390/s390.cc:16421 #, gcc-internal-format msgid "attribute %<target%> argument not a string" msgstr "" -#: config/aarch64/aarch64.cc:19567 +#: config/aarch64/aarch64.cc:19571 #, gcc-internal-format msgid "arch extension %<%s%> should be prefixed by %<+%>" msgstr "" -#: config/aarch64/aarch64.cc:19570 +#: config/aarch64/aarch64.cc:19574 #, gcc-internal-format msgid "pragma or attribute %<target(\"%s\")%> is not valid" msgstr "" -#: config/aarch64/aarch64.cc:19579 +#: config/aarch64/aarch64.cc:19583 #, gcc-internal-format msgid "malformed %<target(\"%s\")%> pragma or attribute" msgstr "" -#: config/aarch64/aarch64.cc:19793 +#: config/aarch64/aarch64.cc:19801 #, gcc-internal-format msgid "attribute %<target_version%> has multiple values" msgstr "" -#: config/aarch64/aarch64.cc:19801 +#: config/aarch64/aarch64.cc:19809 #, gcc-internal-format msgid "attribute %<target_version%> argument not a string" msgstr "" -#: config/aarch64/aarch64.cc:19823 +#: config/aarch64/aarch64.cc:19831 #, gcc-internal-format msgid "missing value in %<target_version%> attribute" msgstr "" -#: config/aarch64/aarch64.cc:19827 +#: config/aarch64/aarch64.cc:19835 #, gcc-internal-format msgid "" "invalid feature modifier %qs of value %qs in %<target_version%> attribute" msgstr "" -#: config/aarch64/aarch64.cc:19833 +#: config/aarch64/aarch64.cc:19841 #, gcc-internal-format msgid "" "duplicate feature modifier %qs of value %qs in %<target_version%> attribute" msgstr "" -#: config/aarch64/aarch64.cc:20410 config/i386/i386-features.cc:3521 +#: config/aarch64/aarch64.cc:20420 config/i386/i386-features.cc:3521 #: config/i386/i386-features.cc:3790 #, gcc-internal-format msgid "virtual function multiversioning not supported" msgstr "" -#: config/aarch64/aarch64.cc:20531 config/i386/i386-features.cc:3654 -#: config/rs6000/rs6000.cc:25375 +#: config/aarch64/aarch64.cc:20541 config/i386/i386-features.cc:3654 +#: config/rs6000/rs6000.cc:25374 #, gcc-internal-format msgid "multiversioning needs %<ifunc%> which is not supported on this target" msgstr "" -#: config/aarch64/aarch64.cc:22079 config/arm/arm.cc:6690 +#: config/aarch64/aarch64.cc:22089 config/arm/arm.cc:6690 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:12778 msgid "" "parameter passing for argument of type %qT with %<[[no_unique_address]]%> " "members changed %{in GCC 10.1%}" msgstr "" -#: config/aarch64/aarch64.cc:22084 config/arm/arm.cc:6695 +#: config/aarch64/aarch64.cc:22094 config/arm/arm.cc:6695 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:12773 msgid "" "parameter passing for argument of type %qT when C++17 is enabled changed to " "match C++14 %{in GCC 10.1%}" msgstr "" -#: config/aarch64/aarch64.cc:22089 config/arm/arm.cc:6700 +#: config/aarch64/aarch64.cc:22099 config/arm/arm.cc:6700 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}" msgstr "" -#: config/aarch64/aarch64.cc:23313 config/aarch64/aarch64.cc:23316 +#: config/aarch64/aarch64.cc:23323 config/aarch64/aarch64.cc:23326 #, gcc-internal-format msgid "lane %wd out of range %wd - %wd" msgstr "" -#: config/aarch64/aarch64.cc:28739 config/i386/i386.cc:25115 +#: config/aarch64/aarch64.cc:28749 config/i386/i386.cc:25115 #: config/i386/i386.cc:25246 #, gcc-internal-format msgid "unsupported simdlen %wd" msgstr "" -#: config/aarch64/aarch64.cc:28753 +#: config/aarch64/aarch64.cc:28763 #, gcc-internal-format msgid "GCC does not currently support return type %qT for simd" msgstr "" -#: config/aarch64/aarch64.cc:28757 config/i386/i386.cc:25137 +#: config/aarch64/aarch64.cc:28767 config/i386/i386.cc:25137 #, gcc-internal-format msgid "unsupported return type %qT for simd" msgstr "" -#: config/aarch64/aarch64.cc:28787 +#: config/aarch64/aarch64.cc:28797 #, gcc-internal-format msgid "GCC does not currently support argument type %qT for simd" msgstr "" -#: config/aarch64/aarch64.cc:28791 config/i386/i386.cc:25168 +#: config/aarch64/aarch64.cc:28801 config/i386/i386.cc:25168 #, gcc-internal-format msgid "unsupported argument type %qT for simd" msgstr "" -#: config/aarch64/aarch64.cc:28840 +#: config/aarch64/aarch64.cc:28850 #, gcc-internal-format msgid "GCC does not currently support simdlen %wd for type %qT" msgstr "" -#: config/aarch64/aarch64.cc:28861 +#: config/aarch64/aarch64.cc:28871 #, gcc-internal-format msgid "" "GCC does not currently support a simdclone with simdlens %wd and %wd for " "these types." msgstr "" -#: config/aarch64/aarch64.cc:28951 +#: config/aarch64/aarch64.cc:28961 #, gcc-internal-format msgid "cannot apply attribute %qs to %q+D after the function has been defined" msgstr "" -#: config/aarch64/aarch64.cc:28953 +#: config/aarch64/aarch64.cc:28963 #, gcc-internal-format msgid "%q+D defined here" msgstr "" -#: config/aarch64/aarch64.cc:29411 +#: config/aarch64/aarch64.cc:29421 #, gcc-internal-format msgid "non-local gotos in functions with SME state" msgstr "" -#: config/aarch64/aarch64.cc:29720 +#: config/aarch64/aarch64.cc:29730 #, gcc-internal-format msgid "catching non-call exceptions in functions with SME state" msgstr "" @@ -41652,7 +41674,7 @@ msgid "argument of %qE attribute is not \"ilink\" or \"firq\"" msgstr "" #: config/arc/arc.cc:2037 config/arm/arm.cc:7483 config/arm/arm.cc:7501 -#: config/arm/arm.cc:7680 config/avr/avr.cc:11235 config/avr/avr.cc:11249 +#: config/arm/arm.cc:7680 config/avr/avr.cc:11244 config/avr/avr.cc:11258 #: config/bfin/bfin.cc:4695 config/bfin/bfin.cc:4756 config/bfin/bfin.cc:4786 #: config/bpf/bpf.cc:93 config/csky/csky.cc:6459 config/csky/csky.cc:6487 #: config/epiphany/epiphany.cc:488 config/gcn/gcn.cc:377 @@ -41662,7 +41684,7 @@ msgstr "" #: config/m68k/m68k.cc:796 config/mcore/mcore.cc:3067 #: config/nvptx/nvptx.cc:5801 config/riscv/riscv.cc:5728 #: config/rl78/rl78.cc:820 config/rl78/rl78.cc:889 -#: config/rs6000/rs6000.cc:20636 config/rx/rx.cc:2728 config/rx/rx.cc:2754 +#: config/rs6000/rs6000.cc:20635 config/rx/rx.cc:2728 config/rx/rx.cc:2754 #: config/s390/s390.cc:1174 config/s390/s390.cc:1261 config/sh/sh.cc:8429 #: config/sh/sh.cc:8447 config/sh/sh.cc:8471 config/sh/sh.cc:8542 #: config/sh/sh.cc:8565 config/stormy16/stormy16.cc:2403 @@ -41779,7 +41801,7 @@ msgid "argument of %qE attribute is missing" msgstr "" #: config/arc/arc.cc:10857 config/arc/arc.cc:10896 config/arc/arc.cc:11022 -#: config/avr/avr.cc:11309 +#: config/avr/avr.cc:11318 #, gcc-internal-format msgid "%qE attribute allows only an integer constant argument" msgstr "" @@ -41799,7 +41821,7 @@ msgstr "" msgid "argument of %qE attribute ignored" msgstr "" -#: config/arc/arc.cc:11012 config/avr/avr.cc:11296 config/bfin/bfin.cc:4818 +#: config/arc/arc.cc:11012 config/avr/avr.cc:11305 config/bfin/bfin.cc:4818 #: config/i386/winnt.cc:63 config/nvptx/nvptx.cc:5824 #, gcc-internal-format msgid "%qE attribute only applies to variables" @@ -42470,91 +42492,91 @@ msgstr "" msgid "accessing program memory with data memory address" msgstr "" -#: config/avr/avr.cc:4249 +#: config/avr/avr.cc:4258 #, gcc-internal-format, gfc-internal-format msgid "fixed register %s used to pass parameter to function" msgstr "" -#: config/avr/avr.cc:4509 +#: config/avr/avr.cc:4518 #, gcc-internal-format msgid "writing to address space %qs not supported" msgstr "" -#: config/avr/avr.cc:11268 +#: config/avr/avr.cc:11277 #, gcc-internal-format msgid "%qE attribute only applies to variables in static storage" msgstr "" -#: config/avr/avr.cc:11275 +#: config/avr/avr.cc:11284 #, gcc-internal-format msgid "%qE attribute only supported for reduced Tiny cores" msgstr "" -#: config/avr/avr.cc:11317 +#: config/avr/avr.cc:11326 #, gcc-internal-format msgid "%qE attribute address out of range 0x%x%s0x%x" msgstr "" -#: config/avr/avr.cc:11331 +#: config/avr/avr.cc:11340 #, gcc-internal-format msgid "both %s and %qE attribute provide address" msgstr "" -#: config/avr/avr.cc:11341 +#: config/avr/avr.cc:11350 #, gcc-internal-format msgid "%qE attribute on non-volatile variable" msgstr "" -#: config/avr/avr.cc:11417 +#: config/avr/avr.cc:11426 #, gcc-internal-format msgid "address spaces are not supported for reduced Tiny devices" msgstr "" -#: config/avr/avr.cc:11424 +#: config/avr/avr.cc:11433 #, gcc-internal-format msgid "" "address space %qs not supported for devices with flash size up to %d KiB" msgstr "" -#: config/avr/avr.cc:11604 +#: config/avr/avr.cc:11613 #, gcc-internal-format msgid "pointer targeting address space %qs must be const in %qT" msgstr "" -#: config/avr/avr.cc:11607 +#: config/avr/avr.cc:11616 #, gcc-internal-format msgid "pointer targeting address space %qs must be const in %s %q+D" msgstr "" -#: config/avr/avr.cc:11628 +#: config/avr/avr.cc:11637 #, gcc-internal-format msgid "variable %q+D with attribute %qs must be located in static storage" msgstr "" -#: config/avr/avr.cc:11679 +#: config/avr/avr.cc:11688 #, gcc-internal-format msgid "" "variable %q+D must be const in order to be put into read-only section by " "means of %qs" msgstr "" -#: config/avr/avr.cc:11840 +#: config/avr/avr.cc:11849 #, gcc-internal-format msgid "static attribute %qs declaration for %q+D needs an address" msgstr "" -#: config/avr/avr.cc:11929 +#: config/avr/avr.cc:11938 #, gcc-internal-format msgid "only uninitialized variables can be placed in the %<.noinit%> section" msgstr "" #. This might happen with C++ if stuff needs constructing. -#: config/avr/avr.cc:12006 +#: config/avr/avr.cc:12015 #, gcc-internal-format msgid "variable %q+D with dynamic initialization put into program memory area" msgstr "" -#: config/avr/avr.cc:12017 +#: config/avr/avr.cc:12026 #, gcc-internal-format msgid "uninitialized variable %q+D put into program memory area" msgstr "" @@ -42563,44 +42585,44 @@ msgstr "" #. hence deny initializers now. The values of symbols with an #. address attribute are determined by the attribute, not by #. some initializer. -#: config/avr/avr.cc:12082 +#: config/avr/avr.cc:12091 #, gcc-internal-format msgid "variable %q+D with attribute %qs must not have an initializer" msgstr "" -#: config/avr/avr.cc:12135 +#: config/avr/avr.cc:12144 #, gcc-internal-format msgid "%q+D has incompatible attributes %qs and %qs" msgstr "" -#: config/avr/avr.cc:12198 +#: config/avr/avr.cc:12207 #, gcc-internal-format msgid "architecture %qs supported for assembler only" msgstr "" -#: config/avr/avr.cc:14758 +#: config/avr/avr.cc:14767 #, gcc-internal-format msgid "conversion from address space %qs to address space %qs" msgstr "" -#: config/avr/avr.cc:15839 config/avr/avr.cc:15852 +#: config/avr/avr.cc:15848 config/avr/avr.cc:15861 #, gcc-internal-format, gfc-internal-format msgid "%s expects a compile time integer constant" msgstr "" -#: config/avr/avr.cc:15866 +#: config/avr/avr.cc:15875 #, gcc-internal-format, gfc-internal-format msgid "%s expects a compile time long integer constant as first argument" msgstr "" -#: config/avr/avr.cc:15894 +#: config/avr/avr.cc:15903 #, 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.cc:15903 +#: config/avr/avr.cc:15912 #, gcc-internal-format msgid "rounding result will always be 0" msgstr "" @@ -42719,27 +42741,27 @@ msgstr "" msgid "eBPF stack limit exceeded" msgstr "" -#: config/bpf/bpf.cc:674 +#: config/bpf/bpf.cc:699 #, gcc-internal-format msgid "too many function arguments for eBPF" msgstr "" -#: config/bpf/bpf.cc:693 config/bpf/bpf.cc:695 +#: config/bpf/bpf.cc:718 config/bpf/bpf.cc:720 #, gcc-internal-format msgid "no constructors" msgstr "" -#: config/bpf/bpf.cc:711 config/bpf/bpf.cc:713 +#: config/bpf/bpf.cc:736 config/bpf/bpf.cc:738 #, gcc-internal-format msgid "no destructors" msgstr "" -#: config/bpf/bpf.cc:765 +#: config/bpf/bpf.cc:790 #, gcc-internal-format msgid "indirect call in function, which are not supported by eBPF" msgstr "" -#: config/bpf/bpf.cc:1015 config/loongarch/loongarch-builtins.cc:3005 +#: config/bpf/bpf.cc:1065 config/loongarch/loongarch-builtins.cc:3005 #: config/mips/mips.cc:17394 config/nios2/nios2.cc:3602 #: config/riscv/riscv-builtins.cc:344 #: config/riscv/riscv-vector-builtins.cc:4226 @@ -42747,29 +42769,29 @@ msgstr "" msgid "invalid argument to built-in function" msgstr "" -#: config/bpf/bpf.cc:1029 +#: config/bpf/bpf.cc:1079 #, gcc-internal-format msgid "invalid built-in function at expansion" msgstr "" -#: config/bpf/bpf.cc:1251 config/bpf/bpf.cc:1254 +#: config/bpf/bpf.cc:1301 config/bpf/bpf.cc:1304 #, gcc-internal-format msgid "could not inline call to %<__builtin_%s%>: size must be constant" msgstr "" -#: config/bpf/bpf.cc:1282 config/bpf/bpf.cc:1285 +#: config/bpf/bpf.cc:1332 config/bpf/bpf.cc:1335 #, gcc-internal-format msgid "" "could not inline call to %<__builtin_%s%>: too many bytes, use %<-minline-" "memops-threshold%>" msgstr "" -#: config/bpf/bpf.cc:1335 config/bpf/bpf.cc:1338 +#: config/bpf/bpf.cc:1385 config/bpf/bpf.cc:1388 #, gcc-internal-format msgid "could not inline call to %<__builtin_memset%>: size must be constant" msgstr "" -#: config/bpf/bpf.cc:1366 config/bpf/bpf.cc:1369 +#: config/bpf/bpf.cc:1416 config/bpf/bpf.cc:1419 #, gcc-internal-format msgid "" "could not inline call to %<__builtin_memset%>: too many bytes, use %<-" @@ -43819,7 +43841,7 @@ msgstr "" msgid "%<-mcall-ms2sysv-xlogues%> isn%'t currently supported with SEH" msgstr "" -#: config/i386/i386-options.cc:3103 config/loongarch/loongarch-opts.cc:868 +#: config/i386/i386-options.cc:3103 config/loongarch/loongarch-opts.cc:898 #, gcc-internal-format msgid "unknown option for %<-mrecip=%s%>" msgstr "" @@ -43964,7 +43986,7 @@ msgstr "" msgid "%qE attribute is used for non-class method" msgstr "" -#: config/i386/i386-options.cc:3923 config/rs6000/rs6000.cc:20748 +#: config/i386/i386-options.cc:3923 config/rs6000/rs6000.cc:20747 #, gcc-internal-format msgid "%qE incompatible attribute ignored" msgstr "" @@ -44348,35 +44370,35 @@ msgstr "" msgid "built-in function %qD is not enabled" msgstr "" -#: config/loongarch/loongarch-cpu.cc:112 +#: config/loongarch/loongarch-cpu.cc:115 #, gcc-internal-format msgid "" "unknown processor ID %<0x%x%>, some tuning parameters will fall back to " "default" msgstr "" -#: config/loongarch/loongarch-cpu.cc:141 +#: config/loongarch/loongarch-cpu.cc:144 #, gcc-internal-format msgid "unknown native base architecture %<0x%x%>, %qs failed" msgstr "" -#: config/loongarch/loongarch-cpu.cc:170 +#: config/loongarch/loongarch-cpu.cc:173 #, gcc-internal-format msgid "unknown native FPU type %<0x%x%>, %qs failed" msgstr "" -#: config/loongarch/loongarch-cpu.cc:177 +#: config/loongarch/loongarch-cpu.cc:180 #, gcc-internal-format msgid "floating-point unit %qs differs from PRID preset %qs" msgstr "" -#: config/loongarch/loongarch-cpu.cc:201 +#: config/loongarch/loongarch-cpu.cc:204 #, gcc-internal-format msgid "" "unknown SIMD extension (%qs disabled while %qs is enabled), disabling SIMD" msgstr "" -#: config/loongarch/loongarch-cpu.cc:239 +#: config/loongarch/loongarch-cpu.cc:242 #, gcc-internal-format msgid "" "detected base architecture %qs, but some of its features are not detected; " @@ -44384,98 +44406,98 @@ msgid "" "will be enabled" msgstr "" -#: config/loongarch/loongarch-opts.cc:234 +#: config/loongarch/loongarch-opts.cc:235 #, gcc-internal-format msgid "%<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs" msgstr "" -#: config/loongarch/loongarch-opts.cc:251 +#: config/loongarch/loongarch-opts.cc:252 #, gcc-internal-format msgid "ABI changed (%qs to %qs) while multilib is disabled" msgstr "" -#: config/loongarch/loongarch-opts.cc:277 -#: config/loongarch/loongarch-opts.cc:282 +#: config/loongarch/loongarch-opts.cc:281 +#: config/loongarch/loongarch-opts.cc:286 #, gcc-internal-format msgid "%qs does not work on a cross compiler" msgstr "" -#: config/loongarch/loongarch-opts.cc:374 +#: config/loongarch/loongarch-opts.cc:375 #, gcc-internal-format msgid "enabling %qs promotes %<%s%s%> to %<%s%s%>" msgstr "" -#: config/loongarch/loongarch-opts.cc:386 +#: config/loongarch/loongarch-opts.cc:387 #, gcc-internal-format msgid "%qs is disabled by %<-m%s%>, because it requires %<%s%s%>" msgstr "" -#: config/loongarch/loongarch-opts.cc:398 +#: config/loongarch/loongarch-opts.cc:399 #, gcc-internal-format msgid "%<-m%s=%s%> conflicts with %qs, which requires %<%s%s%>" msgstr "" -#: config/loongarch/loongarch-opts.cc:442 +#: config/loongarch/loongarch-opts.cc:443 #, gcc-internal-format msgid "" "your native CPU architecture (%qs) does not support %qs ABI, falling back to " "%<-m%s=%s%>" msgstr "" -#: config/loongarch/loongarch-opts.cc:447 +#: config/loongarch/loongarch-opts.cc:448 #, gcc-internal-format msgid "" "default CPU architecture (%qs) does not support %qs ABI, falling back to %<-" "m%s=%s%>" msgstr "" -#: config/loongarch/loongarch-opts.cc:478 +#: config/loongarch/loongarch-opts.cc:479 #, gcc-internal-format msgid "unable to implement ABI %qs with instruction set %qs" msgstr "" -#: config/loongarch/loongarch-opts.cc:500 +#: config/loongarch/loongarch-opts.cc:501 #, gcc-internal-format msgid "" "ABI %qs cannot be implemented due to limited instruction set %qs, falling " "back to %qs" msgstr "" -#: config/loongarch/loongarch-opts.cc:511 +#: config/loongarch/loongarch-opts.cc:512 #, gcc-internal-format msgid "" "instruction set %qs cannot implement default ABI %qs, falling back to %qs" msgstr "" -#: config/loongarch/loongarch-opts.cc:516 +#: config/loongarch/loongarch-opts.cc:517 #, gcc-internal-format msgid "" "no multilib-enabled ABI (%qs) can be implemented with instruction set %qs, " "falling back to %qs" msgstr "" -#: config/loongarch/loongarch-opts.cc:532 +#: config/loongarch/loongarch-opts.cc:533 #, gcc-internal-format msgid "" "ABI %qs is not enabled at configure-time, the linker might report an error" msgstr "" -#: config/loongarch/loongarch-opts.cc:535 +#: config/loongarch/loongarch-opts.cc:536 #, gcc-internal-format, gfc-internal-format msgid "ABI with startfiles: %s" msgstr "" -#: config/loongarch/loongarch-opts.cc:549 +#: config/loongarch/loongarch-opts.cc:550 #, gcc-internal-format msgid "%qs is not supported, now cmodel is set to %qs" msgstr "" -#: config/loongarch/loongarch-opts.cc:993 +#: config/loongarch/loongarch-opts.cc:1023 #, gcc-internal-format msgid "code model %qs is not compatible with %s" msgstr "" -#: config/loongarch/loongarch-opts.cc:1059 +#: config/loongarch/loongarch-opts.cc:1089 #, gcc-internal-format msgid "%qs cannot be used for compiling a shared library" msgstr "" @@ -46116,12 +46138,12 @@ msgid "" "attribute%>]" msgstr "" -#: config/riscv/riscv.cc:9387 config/rs6000/rs6000.cc:4510 +#: config/riscv/riscv.cc:9387 config/rs6000/rs6000.cc:4509 #, gcc-internal-format msgid "%qs is not a valid base register in %qs" msgstr "" -#: config/riscv/riscv.cc:9401 config/rs6000/rs6000.cc:4493 +#: config/riscv/riscv.cc:9401 config/rs6000/rs6000.cc:4492 #, gcc-internal-format msgid "%qs is not a valid number in %qs" msgstr "" @@ -46529,7 +46551,7 @@ msgstr "" msgid "%qs is not supported on little endian systems" msgstr "" -#: config/rs6000/rs6000.cc:3887 +#: config/rs6000/rs6000.cc:3886 #, gcc-internal-format msgid "" "power9 target option is incompatible with %<%s=<xxx>%> for <xxx> less than " @@ -46538,189 +46560,189 @@ msgstr "" #. Enforce that none of the ISA_3_0_MASKS_SERVER flags #. were explicitly cleared. -#: config/rs6000/rs6000.cc:3895 +#: config/rs6000/rs6000.cc:3894 #, gcc-internal-format msgid "%qs incompatible with explicitly disabled options" msgstr "" #. TARGET_VSX = 1 implies Power 7 and newer -#: config/rs6000/rs6000.cc:3929 config/rs6000/rs6000.cc:3937 -#: config/rs6000/rs6000.cc:3950 config/rs6000/rs6000.cc:4012 -#: config/rs6000/rs6000.cc:4045 config/rs6000/rs6000.cc:4060 -#: config/rs6000/rs6000.cc:4068 config/rs6000/rs6000.cc:4192 -#: config/rs6000/rs6000.cc:4205 config/rs6000/rs6000.cc:4214 -#: config/rs6000/rs6000.cc:4352 config/rs6000/rs6000.cc:4365 -#: config/rs6000/rs6000.cc:4386 +#: config/rs6000/rs6000.cc:3928 config/rs6000/rs6000.cc:3936 +#: config/rs6000/rs6000.cc:3949 config/rs6000/rs6000.cc:4011 +#: config/rs6000/rs6000.cc:4044 config/rs6000/rs6000.cc:4059 +#: config/rs6000/rs6000.cc:4067 config/rs6000/rs6000.cc:4191 +#: config/rs6000/rs6000.cc:4204 config/rs6000/rs6000.cc:4213 +#: config/rs6000/rs6000.cc:4351 config/rs6000/rs6000.cc:4364 +#: config/rs6000/rs6000.cc:4385 #, gcc-internal-format msgid "%qs requires %qs" msgstr "" -#: config/rs6000/rs6000.cc:4096 +#: config/rs6000/rs6000.cc:4095 #, gcc-internal-format msgid "target attribute or pragma changes %<long double%> size" msgstr "" -#: config/rs6000/rs6000.cc:4117 +#: config/rs6000/rs6000.cc:4116 #, gcc-internal-format msgid "%qs requires full ISA 2.06 support" msgstr "" -#: config/rs6000/rs6000.cc:4130 +#: config/rs6000/rs6000.cc:4129 #, gcc-internal-format msgid "Using IEEE extended precision %<long double%>" msgstr "" -#: config/rs6000/rs6000.cc:4133 +#: config/rs6000/rs6000.cc:4132 #, gcc-internal-format msgid "Using IBM extended precision %<long double%>" msgstr "" -#: config/rs6000/rs6000.cc:4152 +#: config/rs6000/rs6000.cc:4151 #, gcc-internal-format msgid "%qs requires VSX support" msgstr "" -#: config/rs6000/rs6000.cc:4161 +#: config/rs6000/rs6000.cc:4160 #, gcc-internal-format msgid "The %<-mfloat128%> option may not be fully supported" msgstr "" -#: config/rs6000/rs6000.cc:4184 +#: config/rs6000/rs6000.cc:4183 #, gcc-internal-format msgid "%qs requires full ISA 3.0 support" msgstr "" -#: config/rs6000/rs6000.cc:4271 +#: config/rs6000/rs6000.cc:4270 #, gcc-internal-format msgid "unknown vectorization library ABI type in %<-mveclibabi=%s%>" msgstr "" -#: config/rs6000/rs6000.cc:4284 config/rs6000/rs6000.cc:4299 +#: config/rs6000/rs6000.cc:4283 config/rs6000/rs6000.cc:4298 #, gcc-internal-format msgid "target attribute or pragma changes AltiVec ABI" msgstr "" -#: config/rs6000/rs6000.cc:4312 +#: config/rs6000/rs6000.cc:4311 #, gcc-internal-format msgid "target attribute or pragma changes darwin64 ABI" msgstr "" -#: config/rs6000/rs6000.cc:4518 +#: config/rs6000/rs6000.cc:4517 #, gcc-internal-format msgid "%qs needs a valid base register" msgstr "" -#: config/rs6000/rs6000.cc:4815 +#: config/rs6000/rs6000.cc:4814 #, gcc-internal-format msgid "unknown option for %<%s=%s%>" msgstr "" -#: config/rs6000/rs6000.cc:4844 +#: config/rs6000/rs6000.cc:4843 #, gcc-internal-format msgid "%qs is deprecated and not recommended in any circumstances" msgstr "" -#: config/rs6000/rs6000.cc:11170 +#: config/rs6000/rs6000.cc:11169 #, gcc-internal-format msgid "%qs is an opaque type, and you cannot set it to other values" msgstr "" -#: config/rs6000/rs6000.cc:18015 +#: config/rs6000/rs6000.cc:18014 #, gcc-internal-format msgid "no profiling of 64-bit code for this ABI" msgstr "" -#: config/rs6000/rs6000.cc:20411 +#: config/rs6000/rs6000.cc:20410 #, gcc-internal-format msgid "" "you cannot take the address of a nested function if you use the %qs option" msgstr "" -#: config/rs6000/rs6000.cc:20493 +#: config/rs6000/rs6000.cc:20492 #, gcc-internal-format msgid "use of %<long double%> in AltiVec types is invalid" msgstr "" -#: config/rs6000/rs6000.cc:20495 +#: config/rs6000/rs6000.cc:20494 #, gcc-internal-format msgid "use of boolean types in AltiVec types is invalid" msgstr "" -#: config/rs6000/rs6000.cc:20497 +#: config/rs6000/rs6000.cc:20496 #, gcc-internal-format msgid "use of %<complex%> in AltiVec types is invalid" msgstr "" -#: config/rs6000/rs6000.cc:20499 +#: config/rs6000/rs6000.cc:20498 #, gcc-internal-format msgid "use of decimal floating-point types in AltiVec types is invalid" msgstr "" -#: config/rs6000/rs6000.cc:20505 +#: config/rs6000/rs6000.cc:20504 #, gcc-internal-format msgid "use of %<long%> in AltiVec types is invalid for 64-bit code without %qs" msgstr "" -#: config/rs6000/rs6000.cc:20508 +#: config/rs6000/rs6000.cc:20507 #, gcc-internal-format msgid "use of %<long%> in AltiVec types is deprecated; use %<int%>" msgstr "" -#: config/rs6000/rs6000.cc:20513 +#: config/rs6000/rs6000.cc:20512 #, gcc-internal-format msgid "use of %<long long%> in AltiVec types is invalid without %qs" msgstr "" -#: config/rs6000/rs6000.cc:20516 +#: config/rs6000/rs6000.cc:20515 #, gcc-internal-format msgid "use of %<double%> in AltiVec types is invalid without %qs" msgstr "" -#: config/rs6000/rs6000.cc:24657 +#: config/rs6000/rs6000.cc:24656 #, gcc-internal-format msgid "invalid cpu %qs for %s%qs%s" msgstr "" -#: config/rs6000/rs6000.cc:24660 +#: config/rs6000/rs6000.cc:24659 #, gcc-internal-format msgid "%s%qs%s is not allowed" msgstr "" -#: config/rs6000/rs6000.cc:24662 +#: config/rs6000/rs6000.cc:24661 #, gcc-internal-format msgid "%s%qs%s is invalid" msgstr "" -#: config/rs6000/rs6000.cc:25183 +#: config/rs6000/rs6000.cc:25182 #, gcc-internal-format msgid "%<-mno-%s%> turns off %<-m%s%>" msgstr "" -#: config/rs6000/rs6000.cc:25342 +#: config/rs6000/rs6000.cc:25341 #, gcc-internal-format msgid "" "%<target_clones%> attribute needs GLIBC (2.23 and newer) that exports " "hardware capability bits" msgstr "" -#: config/rs6000/rs6000.cc:25631 +#: config/rs6000/rs6000.cc:25630 #, gcc-internal-format msgid "Virtual function multiversioning not supported" msgstr "" -#: config/rs6000/rs6000.cc:28769 +#: config/rs6000/rs6000.cc:28768 #, gcc-internal-format msgid "" "the result for the xxspltidp instruction is undefined for subnormal input " "values" msgstr "" -#: config/rs6000/rs6000.cc:29247 +#: config/rs6000/rs6000.cc:29246 #, gcc-internal-format msgid "type %<__vector_quad%> requires the %qs option" msgstr "" -#: config/rs6000/rs6000.cc:29252 +#: config/rs6000/rs6000.cc:29251 #, gcc-internal-format msgid "type %<__vector_pair%> requires the %qs option" msgstr "" @@ -46766,74 +46788,74 @@ msgstr "" msgid "builtin %qs can only be used on vector types" msgstr "" -#: config/s390/s390-c.cc:718 config/s390/s390.cc:999 +#: config/s390/s390-c.cc:720 config/s390/s390.cc:999 #, gcc-internal-format msgid "constant value required for builtin %qF argument %d" msgstr "" -#: config/s390/s390-c.cc:733 +#: config/s390/s390-c.cc:735 #, gcc-internal-format msgid "" "valid values for builtin %qF argument %d are 64, 128, 256, 512, 1024, 2048, " "and 4096" msgstr "" -#: config/s390/s390-c.cc:913 +#: config/s390/s390-c.cc:915 #, gcc-internal-format msgid "builtin %qF is for GCC internal use only" msgstr "" -#: config/s390/s390-c.cc:921 +#: config/s390/s390-c.cc:923 #, gcc-internal-format msgid "builtin %qF is deprecated" msgstr "" -#: config/s390/s390-c.cc:925 +#: config/s390/s390-c.cc:927 #, gcc-internal-format msgid "%qF requires %<-mvx%>" msgstr "" -#: config/s390/s390-c.cc:931 +#: config/s390/s390-c.cc:933 #, gcc-internal-format msgid "%qF requires z14 or higher" msgstr "" -#: config/s390/s390-c.cc:937 +#: config/s390/s390-c.cc:939 #, gcc-internal-format msgid "%qF requires z15 or higher" msgstr "" -#: config/s390/s390-c.cc:951 +#: config/s390/s390-c.cc:953 #, gcc-internal-format msgid "mismatch in number of arguments for builtin %qF. Expected: %d got %d" msgstr "" -#: config/s390/s390-c.cc:1000 +#: config/s390/s390-c.cc:1002 #, gcc-internal-format msgid "invalid parameter combination for intrinsic %qs" msgstr "" -#: config/s390/s390-c.cc:1006 +#: config/s390/s390-c.cc:1008 #, gcc-internal-format msgid "ambiguous overload for intrinsic %qs" msgstr "" -#: config/s390/s390-c.cc:1014 +#: config/s390/s390-c.cc:1016 #, gcc-internal-format msgid "%qs matching variant requires z14 or higher" msgstr "" -#: config/s390/s390-c.cc:1023 +#: config/s390/s390-c.cc:1025 #, gcc-internal-format msgid "%qs matching variant requires z15 or higher" msgstr "" -#: config/s390/s390-c.cc:1029 +#: config/s390/s390-c.cc:1031 #, gcc-internal-format msgid "%qs matching variant is deprecated" msgstr "" -#: config/s390/s390-c.cc:1069 +#: config/s390/s390-c.cc:1071 #, gcc-internal-format msgid "constant argument %d for builtin %qF is out of range for target type" msgstr "" @@ -47496,7 +47518,7 @@ msgstr "" msgid "attribute %qs applies to array types only" msgstr "" -#: c/c-convert.cc:104 c/c-typeck.cc:2351 c/c-typeck.cc:13556 cp/typeck.cc:2498 +#: c/c-convert.cc:104 c/c-typeck.cc:2353 c/c-typeck.cc:13558 cp/typeck.cc:2498 #: cp/typeck.cc:9511 cp/typeck.cc:10299 d/d-convert.cc:262 #, gcc-internal-format msgid "void value not ignored as it ought to be" @@ -47573,7 +47595,7 @@ msgid "" "underspecified declaration of %qE, which is already declared in this scope" msgstr "" -#: c/c-decl.cc:1733 c/c-decl.cc:7888 c/c-decl.cc:8890 c/c-decl.cc:9899 +#: c/c-decl.cc:1733 c/c-decl.cc:7890 c/c-decl.cc:8894 c/c-decl.cc:9946 #, gcc-internal-format msgid "originally defined here" msgstr "" @@ -47982,7 +48004,7 @@ msgstr "" #. expressions, but is still appropriate as an error to #. avoid types declared in such a context escaping to #. the type of an auto variable. -#: c/c-decl.cc:4976 c/c-decl.cc:8829 +#: c/c-decl.cc:4976 c/c-decl.cc:8833 #, gcc-internal-format msgid "%qT declared in underspecified object initializer" msgstr "" @@ -48012,95 +48034,95 @@ msgstr "" msgid "empty declaration of %<enum%> type does not redeclare tag" msgstr "" -#: c/c-decl.cc:5063 c/c-decl.cc:5071 +#: c/c-decl.cc:5065 c/c-decl.cc:5073 #, gcc-internal-format msgid "useless type name in empty declaration" msgstr "" -#: c/c-decl.cc:5079 +#: c/c-decl.cc:5081 #, gcc-internal-format msgid "%<inline%> in empty declaration" msgstr "" -#: c/c-decl.cc:5085 +#: c/c-decl.cc:5087 #, gcc-internal-format msgid "%<_Noreturn%> in empty declaration" msgstr "" -#: c/c-decl.cc:5091 +#: c/c-decl.cc:5093 #, gcc-internal-format msgid "%<constexpr%> in empty declaration" msgstr "" -#: c/c-decl.cc:5097 +#: c/c-decl.cc:5099 #, gcc-internal-format msgid "%<auto%> in file-scope empty declaration" msgstr "" -#: c/c-decl.cc:5103 +#: c/c-decl.cc:5105 #, gcc-internal-format msgid "%<register%> in file-scope empty declaration" msgstr "" -#: c/c-decl.cc:5111 +#: c/c-decl.cc:5113 #, gcc-internal-format msgid "" "storage class specifier in empty declaration with %<enum%> underlying type" msgstr "" -#: c/c-decl.cc:5117 +#: c/c-decl.cc:5119 #, gcc-internal-format msgid "%qs in empty declaration with %<enum%> underlying type" msgstr "" -#: c/c-decl.cc:5127 +#: c/c-decl.cc:5129 #, gcc-internal-format msgid "type qualifier in empty declaration with %<enum%> underlying type" msgstr "" -#: c/c-decl.cc:5133 +#: c/c-decl.cc:5135 #, gcc-internal-format msgid "%<alignas%> in empty declaration with %<enum%> underlying type" msgstr "" -#: c/c-decl.cc:5142 +#: c/c-decl.cc:5144 #, gcc-internal-format msgid "useless storage class specifier in empty declaration" msgstr "" -#: c/c-decl.cc:5148 +#: c/c-decl.cc:5150 #, gcc-internal-format msgid "useless %qs in empty declaration" msgstr "" -#: c/c-decl.cc:5161 +#: c/c-decl.cc:5163 #, gcc-internal-format msgid "useless type qualifier in empty declaration" msgstr "" -#: c/c-decl.cc:5168 +#: c/c-decl.cc:5170 #, gcc-internal-format msgid "useless %<_Alignas%> in empty declaration" msgstr "" -#: c/c-decl.cc:5186 +#: c/c-decl.cc:5188 #, gcc-internal-format msgid "invalid use of attributes in empty declaration" msgstr "" -#: c/c-decl.cc:5200 c/c-parser.cc:2403 +#: c/c-decl.cc:5202 c/c-parser.cc:2403 #, gcc-internal-format msgid "empty declaration" msgstr "" -#: c/c-decl.cc:5272 +#: c/c-decl.cc:5274 #, gcc-internal-format msgid "" "ISO C90 does not support %<static%> or type qualifiers in parameter array " "declarators" msgstr "" -#: c/c-decl.cc:5276 +#: c/c-decl.cc:5278 #, gcc-internal-format msgid "ISO C90 does not support %<[*]%> array declarators" msgstr "" @@ -48108,313 +48130,313 @@ msgstr "" #. C99 6.7.5.2p4 #. A function definition isn't function prototype scope C99 6.2.1p4. #. C99 6.7.5.2p4 -#: c/c-decl.cc:5282 c/c-decl.cc:8411 c/c-decl.cc:10744 +#: c/c-decl.cc:5284 c/c-decl.cc:8413 c/c-decl.cc:10791 #, gcc-internal-format msgid "%<[*]%> not allowed in other than function prototype scope" msgstr "" -#: c/c-decl.cc:5475 cp/decl2.cc:1852 cp/name-lookup.cc:8804 +#: c/c-decl.cc:5477 cp/decl2.cc:1852 cp/name-lookup.cc:8804 #, gcc-internal-format msgid "%<omp::%s%> not allowed to be specified in this context" msgstr "" -#: c/c-decl.cc:5555 +#: c/c-decl.cc:5557 #, gcc-internal-format msgid "%q+D is usually a function" msgstr "" -#: c/c-decl.cc:5560 c/c-decl.cc:10575 cp/decl.cc:17935 +#: c/c-decl.cc:5562 c/c-decl.cc:10622 cp/decl.cc:17941 #, gcc-internal-format msgid "no previous declaration for %qD" msgstr "" -#: c/c-decl.cc:5569 +#: c/c-decl.cc:5571 #, gcc-internal-format msgid "typedef %qD is initialized (use %<__typeof__%> instead)" msgstr "" -#: c/c-decl.cc:5574 +#: c/c-decl.cc:5576 #, gcc-internal-format msgid "function %qD is initialized like a variable" msgstr "" #. DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. -#: c/c-decl.cc:5580 +#: c/c-decl.cc:5582 #, gcc-internal-format msgid "parameter %qD is initialized" msgstr "" -#: c/c-decl.cc:5600 +#: c/c-decl.cc:5602 #, gcc-internal-format msgid "variable %qD has initializer but incomplete type" msgstr "" -#: c/c-decl.cc:5680 +#: c/c-decl.cc:5682 #, gcc-internal-format msgid "inline function %q+D given attribute %qs" msgstr "" -#: c/c-decl.cc:5736 +#: c/c-decl.cc:5738 #, gcc-internal-format msgid "uninitialized const member in %qT is invalid in C++" msgstr "" -#: c/c-decl.cc:5738 +#: c/c-decl.cc:5740 #, gcc-internal-format msgid "%qD should be initialized" msgstr "" -#: c/c-decl.cc:5819 +#: c/c-decl.cc:5821 #, gcc-internal-format msgid "initializer fails to determine size of %q+D" msgstr "" -#: c/c-decl.cc:5824 +#: c/c-decl.cc:5826 #, gcc-internal-format msgid "array size missing in %q+D" msgstr "" -#: c/c-decl.cc:5828 +#: c/c-decl.cc:5830 #, gcc-internal-format msgid "zero or negative size array %q+D" msgstr "" -#: c/c-decl.cc:5919 m2/gm2-gcc/m2type.cc:1250 +#: c/c-decl.cc:5921 m2/gm2-gcc/m2type.cc:1250 #, gcc-internal-format msgid "storage size of %q+D isn%'t constant" msgstr "" -#: c/c-decl.cc:5969 +#: c/c-decl.cc:5971 #, gcc-internal-format msgid "ignoring %<asm%> specifier for non-static local variable %q+D" msgstr "" -#: c/c-decl.cc:6007 +#: c/c-decl.cc:6009 #, gcc-internal-format msgid "cannot put object with volatile field into register" msgstr "" -#: c/c-decl.cc:6093 +#: c/c-decl.cc:6095 #, gcc-internal-format msgid "uninitialized %<const %D%> is invalid in C++" msgstr "" -#: c/c-decl.cc:6108 cp/decl.cc:9043 +#: c/c-decl.cc:6110 cp/decl.cc:9043 #, gcc-internal-format msgid "%q+D in declare target directive does not have mappable type" msgstr "" -#: c/c-decl.cc:6371 +#: c/c-decl.cc:6373 #, gcc-internal-format msgid "ISO C forbids forward parameter declarations" msgstr "" -#: c/c-decl.cc:6411 +#: c/c-decl.cc:6413 #, gcc-internal-format msgid "file-scope compound literal specifies %<register%>" msgstr "" -#: c/c-decl.cc:6417 +#: c/c-decl.cc:6419 #, gcc-internal-format msgid "compound literal implicitly auto and declared %qs" msgstr "" -#: c/c-decl.cc:6517 +#: c/c-decl.cc:6519 #, gcc-internal-format msgid "defining a type in a compound literal is invalid in C++" msgstr "" -#: c/c-decl.cc:6538 c/c-decl.cc:6553 +#: c/c-decl.cc:6540 c/c-decl.cc:6555 #, gcc-internal-format msgid "bit-field %qs width not an integer constant" msgstr "" -#: c/c-decl.cc:6548 +#: c/c-decl.cc:6550 #, gcc-internal-format msgid "bit-field %qs width not an integer constant expression" msgstr "" -#: c/c-decl.cc:6559 +#: c/c-decl.cc:6561 #, gcc-internal-format msgid "negative width in bit-field %qs" msgstr "" -#: c/c-decl.cc:6564 +#: c/c-decl.cc:6566 #, gcc-internal-format msgid "zero width for bit-field %qs" msgstr "" -#: c/c-decl.cc:6575 +#: c/c-decl.cc:6577 #, gcc-internal-format msgid "bit-field %qs has invalid type" msgstr "" -#: c/c-decl.cc:6581 +#: c/c-decl.cc:6583 #, gcc-internal-format msgid "cannot declare bit-field %qs with %<warn_if_not_aligned%> type" msgstr "" -#: c/c-decl.cc:6592 +#: c/c-decl.cc:6594 #, gcc-internal-format msgid "type of bit-field %qs is a GCC extension" msgstr "" -#: c/c-decl.cc:6598 +#: c/c-decl.cc:6600 #, gcc-internal-format msgid "width of %qs exceeds its type" msgstr "" -#: c/c-decl.cc:6617 +#: c/c-decl.cc:6619 #, gcc-internal-format msgid "%qs is narrower than values of its type" msgstr "" -#: c/c-decl.cc:6632 +#: c/c-decl.cc:6634 #, gcc-internal-format msgid "ISO C90 forbids array %qE whose size cannot be evaluated" msgstr "" -#: c/c-decl.cc:6635 +#: c/c-decl.cc:6637 #, gcc-internal-format msgid "ISO C90 forbids array whose size cannot be evaluated" msgstr "" -#: c/c-decl.cc:6642 +#: c/c-decl.cc:6644 #, gcc-internal-format msgid "ISO C90 forbids variable length array %qE" msgstr "" -#: c/c-decl.cc:6644 +#: c/c-decl.cc:6646 #, gcc-internal-format msgid "ISO C90 forbids variable length array" msgstr "" -#: c/c-decl.cc:6887 +#: c/c-decl.cc:6889 #, gcc-internal-format msgid "%<enum%> underlying type may not be specified here" msgstr "" -#: c/c-decl.cc:6915 c/c-decl.cc:7324 c/c-decl.cc:7334 +#: c/c-decl.cc:6917 c/c-decl.cc:7326 c/c-decl.cc:7336 #, gcc-internal-format msgid "variably modified %qE at file scope" msgstr "" -#: c/c-decl.cc:6917 +#: c/c-decl.cc:6919 #, gcc-internal-format msgid "variably modified field at file scope" msgstr "" -#: c/c-decl.cc:6937 +#: c/c-decl.cc:6939 #, gcc-internal-format msgid "type defaults to %<int%> in declaration of %qE" msgstr "" -#: c/c-decl.cc:6941 +#: c/c-decl.cc:6943 #, gcc-internal-format msgid "type defaults to %<int%> in type name" msgstr "" -#: c/c-decl.cc:6973 +#: c/c-decl.cc:6975 #, gcc-internal-format msgid "duplicate %<const%>" msgstr "" -#: c/c-decl.cc:6975 +#: c/c-decl.cc:6977 #, gcc-internal-format msgid "duplicate %<restrict%>" msgstr "" -#: c/c-decl.cc:6977 +#: c/c-decl.cc:6979 #, gcc-internal-format msgid "duplicate %<volatile%>" msgstr "" -#: c/c-decl.cc:6979 +#: c/c-decl.cc:6981 #, gcc-internal-format msgid "duplicate %<_Atomic%>" msgstr "" -#: c/c-decl.cc:6982 +#: c/c-decl.cc:6984 #, gcc-internal-format, gfc-internal-format msgid "conflicting named address spaces (%s vs %s)" msgstr "" -#: c/c-decl.cc:7005 c/c-parser.cc:3573 +#: c/c-decl.cc:7007 c/c-parser.cc:3573 #, gcc-internal-format msgid "%<_Atomic%>-qualified array type" msgstr "" -#: c/c-decl.cc:7020 +#: c/c-decl.cc:7022 #, gcc-internal-format msgid "function definition declared %<auto%>" msgstr "" -#: c/c-decl.cc:7022 +#: c/c-decl.cc:7024 #, gcc-internal-format msgid "function definition declared %<register%>" msgstr "" -#: c/c-decl.cc:7024 +#: c/c-decl.cc:7026 #, gcc-internal-format msgid "function definition declared %<typedef%>" msgstr "" -#: c/c-decl.cc:7026 +#: c/c-decl.cc:7028 #, gcc-internal-format msgid "function definition declared %qs" msgstr "" -#: c/c-decl.cc:7053 +#: c/c-decl.cc:7055 #, gcc-internal-format msgid "storage class specified for structure field %qE" msgstr "" -#: c/c-decl.cc:7056 +#: c/c-decl.cc:7058 #, gcc-internal-format msgid "storage class specified for structure field" msgstr "" -#: c/c-decl.cc:7060 +#: c/c-decl.cc:7062 #, gcc-internal-format msgid "storage class specified for parameter %qE" msgstr "" -#: c/c-decl.cc:7063 +#: c/c-decl.cc:7065 #, gcc-internal-format msgid "storage class specified for unnamed parameter" msgstr "" -#: c/c-decl.cc:7066 cp/decl.cc:13134 +#: c/c-decl.cc:7068 cp/decl.cc:13134 #, gcc-internal-format msgid "storage class specified for typename" msgstr "" -#: c/c-decl.cc:7084 +#: c/c-decl.cc:7086 #, gcc-internal-format msgid "%qE initialized and declared %<extern%>" msgstr "" -#: c/c-decl.cc:7088 +#: c/c-decl.cc:7090 #, gcc-internal-format msgid "%qE has both %<extern%> and initializer" msgstr "" -#: c/c-decl.cc:7093 +#: c/c-decl.cc:7095 #, gcc-internal-format msgid "file-scope declaration of %qE specifies %<auto%>" msgstr "" -#: c/c-decl.cc:7097 +#: c/c-decl.cc:7099 #, gcc-internal-format msgid "file-scope declaration of %qE specifies %<register%>" msgstr "" -#: c/c-decl.cc:7102 +#: c/c-decl.cc:7104 #, gcc-internal-format msgid "nested function %qE declared %<extern%>" msgstr "" -#: c/c-decl.cc:7105 +#: c/c-decl.cc:7107 #, gcc-internal-format msgid "function-scope %qE implicitly auto and declared %qs" msgstr "" @@ -48422,1118 +48444,1118 @@ msgstr "" #. Only the innermost declarator (making a parameter be of #. array type which is converted to pointer type) #. may have static or type qualifiers. -#: c/c-decl.cc:7152 c/c-decl.cc:7548 +#: c/c-decl.cc:7154 c/c-decl.cc:7550 #, gcc-internal-format msgid "static or type qualifiers in non-parameter array declarator" msgstr "" -#: c/c-decl.cc:7215 +#: c/c-decl.cc:7217 #, gcc-internal-format msgid "declaration of %qE as array of voids" msgstr "" -#: c/c-decl.cc:7217 +#: c/c-decl.cc:7219 #, gcc-internal-format msgid "declaration of type name as array of voids" msgstr "" -#: c/c-decl.cc:7224 +#: c/c-decl.cc:7226 #, gcc-internal-format msgid "declaration of %qE as array of functions" msgstr "" -#: c/c-decl.cc:7227 +#: c/c-decl.cc:7229 #, gcc-internal-format msgid "declaration of type name as array of functions" msgstr "" -#: c/c-decl.cc:7235 c/c-decl.cc:9497 +#: c/c-decl.cc:7237 c/c-decl.cc:9542 #, gcc-internal-format msgid "invalid use of structure with flexible array member" msgstr "" -#: c/c-decl.cc:7267 +#: c/c-decl.cc:7269 #, gcc-internal-format msgid "size of array %qE has non-integer type" msgstr "" -#: c/c-decl.cc:7271 +#: c/c-decl.cc:7273 #, gcc-internal-format msgid "size of unnamed array has non-integer type" msgstr "" -#: c/c-decl.cc:7279 +#: c/c-decl.cc:7281 #, gcc-internal-format msgid "size of array %qE has incomplete type" msgstr "" -#: c/c-decl.cc:7282 +#: c/c-decl.cc:7284 #, gcc-internal-format msgid "size of unnamed array has incomplete type" msgstr "" -#: c/c-decl.cc:7294 +#: c/c-decl.cc:7296 #, gcc-internal-format msgid "ISO C forbids zero-size array %qE" msgstr "" -#: c/c-decl.cc:7297 +#: c/c-decl.cc:7299 #, gcc-internal-format msgid "ISO C forbids zero-size array" msgstr "" -#: c/c-decl.cc:7306 +#: c/c-decl.cc:7308 #, gcc-internal-format msgid "size of array %qE is negative" msgstr "" -#: c/c-decl.cc:7308 +#: c/c-decl.cc:7310 #, gcc-internal-format msgid "size of unnamed array is negative" msgstr "" -#: c/c-decl.cc:7394 +#: c/c-decl.cc:7396 #, gcc-internal-format msgid "size of array %qE is too large" msgstr "" -#: c/c-decl.cc:7397 +#: c/c-decl.cc:7399 #, gcc-internal-format msgid "size of unnamed array is too large" msgstr "" -#: c/c-decl.cc:7436 c/c-decl.cc:8068 +#: c/c-decl.cc:7438 c/c-decl.cc:8070 #, gcc-internal-format msgid "ISO C90 does not support flexible array members" msgstr "" #. C99 6.7.5.2p4 -#: c/c-decl.cc:7458 +#: c/c-decl.cc:7460 #, gcc-internal-format msgid "%<[*]%> not in a declaration" msgstr "" -#: c/c-decl.cc:7472 +#: c/c-decl.cc:7474 #, gcc-internal-format msgid "array type has incomplete element type %qT" msgstr "" -#: c/c-decl.cc:7478 +#: c/c-decl.cc:7480 #, gcc-internal-format msgid "" "declaration of %qE as multidimensional array must have bounds for all " "dimensions except the first" msgstr "" -#: c/c-decl.cc:7482 +#: c/c-decl.cc:7484 #, gcc-internal-format msgid "" "declaration of multidimensional array must have bounds for all dimensions " "except the first" msgstr "" -#: c/c-decl.cc:7584 +#: c/c-decl.cc:7586 #, gcc-internal-format msgid "%qE declared as function returning a function" msgstr "" -#: c/c-decl.cc:7587 +#: c/c-decl.cc:7589 #, gcc-internal-format msgid "type name declared as function returning a function" msgstr "" -#: c/c-decl.cc:7594 +#: c/c-decl.cc:7596 #, gcc-internal-format msgid "%qE declared as function returning an array" msgstr "" -#: c/c-decl.cc:7597 +#: c/c-decl.cc:7599 #, gcc-internal-format msgid "type name declared as function returning an array" msgstr "" -#: c/c-decl.cc:7641 +#: c/c-decl.cc:7643 #, gcc-internal-format msgid "function definition has qualified void return type" msgstr "" -#: c/c-decl.cc:7645 cp/decl.cc:13543 +#: c/c-decl.cc:7647 cp/decl.cc:13543 #, gcc-internal-format msgid "type qualifiers ignored on function return type" msgstr "" -#: c/c-decl.cc:7684 c/c-decl.cc:7854 c/c-decl.cc:7908 c/c-decl.cc:8002 -#: c/c-decl.cc:8124 c/c-parser.cc:3575 +#: c/c-decl.cc:7686 c/c-decl.cc:7856 c/c-decl.cc:7910 c/c-decl.cc:8004 +#: c/c-decl.cc:8126 c/c-parser.cc:3575 #, gcc-internal-format msgid "%<_Atomic%>-qualified function type" msgstr "" -#: c/c-decl.cc:7690 c/c-decl.cc:7860 c/c-decl.cc:8007 c/c-decl.cc:8129 +#: c/c-decl.cc:7692 c/c-decl.cc:7862 c/c-decl.cc:8009 c/c-decl.cc:8131 #, gcc-internal-format msgid "ISO C forbids qualified function types" msgstr "" -#: c/c-decl.cc:7745 +#: c/c-decl.cc:7747 #, gcc-internal-format msgid "%qs combined with %<auto%> qualifier for %qE" msgstr "" -#: c/c-decl.cc:7749 +#: c/c-decl.cc:7751 #, gcc-internal-format msgid "%qs combined with %<register%> qualifier for %qE" msgstr "" -#: c/c-decl.cc:7755 +#: c/c-decl.cc:7757 #, gcc-internal-format msgid "%qs specified for auto variable %qE" msgstr "" -#: c/c-decl.cc:7771 +#: c/c-decl.cc:7773 #, gcc-internal-format msgid "%qs specified for parameter %qE" msgstr "" -#: c/c-decl.cc:7774 +#: c/c-decl.cc:7776 #, gcc-internal-format msgid "%qs specified for unnamed parameter" msgstr "" -#: c/c-decl.cc:7780 +#: c/c-decl.cc:7782 #, gcc-internal-format msgid "%qs specified for structure field %qE" msgstr "" -#: c/c-decl.cc:7783 +#: c/c-decl.cc:7785 #, gcc-internal-format msgid "%qs specified for structure field" msgstr "" -#: c/c-decl.cc:7798 +#: c/c-decl.cc:7800 #, gcc-internal-format msgid "bit-field %qE has atomic type" msgstr "" -#: c/c-decl.cc:7800 +#: c/c-decl.cc:7802 #, gcc-internal-format msgid "bit-field has atomic type" msgstr "" -#: c/c-decl.cc:7809 +#: c/c-decl.cc:7811 #, gcc-internal-format msgid "alignment specified for typedef %qE" msgstr "" -#: c/c-decl.cc:7811 +#: c/c-decl.cc:7813 #, gcc-internal-format msgid "alignment specified for %<register%> object %qE" msgstr "" -#: c/c-decl.cc:7816 +#: c/c-decl.cc:7818 #, gcc-internal-format msgid "alignment specified for parameter %qE" msgstr "" -#: c/c-decl.cc:7818 +#: c/c-decl.cc:7820 #, gcc-internal-format msgid "alignment specified for unnamed parameter" msgstr "" -#: c/c-decl.cc:7823 +#: c/c-decl.cc:7825 #, gcc-internal-format msgid "alignment specified for bit-field %qE" msgstr "" -#: c/c-decl.cc:7825 +#: c/c-decl.cc:7827 #, gcc-internal-format msgid "alignment specified for unnamed bit-field" msgstr "" -#: c/c-decl.cc:7828 +#: c/c-decl.cc:7830 #, gcc-internal-format msgid "alignment specified for function %qE" msgstr "" -#: c/c-decl.cc:7835 +#: c/c-decl.cc:7837 #, gcc-internal-format msgid "%<_Alignas%> specifiers cannot reduce alignment of %qE" msgstr "" -#: c/c-decl.cc:7838 +#: c/c-decl.cc:7840 #, gcc-internal-format msgid "%<_Alignas%> specifiers cannot reduce alignment of unnamed field" msgstr "" -#: c/c-decl.cc:7869 +#: c/c-decl.cc:7871 #, gcc-internal-format msgid "typedef %q+D declared %<inline%>" msgstr "" -#: c/c-decl.cc:7871 +#: c/c-decl.cc:7873 #, gcc-internal-format msgid "typedef %q+D declared %<_Noreturn%>" msgstr "" -#: c/c-decl.cc:7914 +#: c/c-decl.cc:7916 #, gcc-internal-format msgid "ISO C forbids const or volatile function types" msgstr "" #. C99 6.7.2.1p8 -#: c/c-decl.cc:7925 +#: c/c-decl.cc:7927 #, gcc-internal-format msgid "a member of a structure or union cannot have a variably modified type" msgstr "" -#: c/c-decl.cc:7942 cp/decl.cc:12014 +#: c/c-decl.cc:7944 cp/decl.cc:12014 #, gcc-internal-format msgid "variable or field %qE declared void" msgstr "" -#: c/c-decl.cc:7992 +#: c/c-decl.cc:7994 #, gcc-internal-format msgid "attributes in parameter array declarator ignored" msgstr "" -#: c/c-decl.cc:8034 +#: c/c-decl.cc:8036 #, gcc-internal-format msgid "parameter %q+D declared %<inline%>" msgstr "" -#: c/c-decl.cc:8036 +#: c/c-decl.cc:8038 #, gcc-internal-format msgid "parameter %q+D declared %<_Noreturn%>" msgstr "" -#: c/c-decl.cc:8049 +#: c/c-decl.cc:8051 #, gcc-internal-format msgid "field %qE declared as a function" msgstr "" -#: c/c-decl.cc:8056 +#: c/c-decl.cc:8058 #, gcc-internal-format msgid "field %qE has incomplete type" msgstr "" -#: c/c-decl.cc:8058 +#: c/c-decl.cc:8060 #, gcc-internal-format msgid "unnamed field has incomplete type" msgstr "" -#: c/c-decl.cc:8095 c/c-decl.cc:8106 c/c-decl.cc:8109 +#: c/c-decl.cc:8097 c/c-decl.cc:8108 c/c-decl.cc:8111 #, gcc-internal-format msgid "invalid storage class for function %qE" msgstr "" -#: c/c-decl.cc:8166 +#: c/c-decl.cc:8168 #, gcc-internal-format msgid "cannot inline function %<main%>" msgstr "" -#: c/c-decl.cc:8168 +#: c/c-decl.cc:8170 #, gcc-internal-format msgid "%<main%> declared %<_Noreturn%>" msgstr "" -#: c/c-decl.cc:8179 +#: c/c-decl.cc:8181 #, gcc-internal-format msgid "ISO C99 does not support %<_Noreturn%>" msgstr "" -#: c/c-decl.cc:8182 +#: c/c-decl.cc:8184 #, gcc-internal-format msgid "ISO C90 does not support %<_Noreturn%>" msgstr "" -#: c/c-decl.cc:8204 +#: c/c-decl.cc:8206 #, gcc-internal-format msgid "function previously declared %<static%> redeclared %<extern%>" msgstr "" -#: c/c-decl.cc:8222 +#: c/c-decl.cc:8224 #, gcc-internal-format msgid "%<constexpr%> object has variably modified type" msgstr "" -#: c/c-decl.cc:8226 c/c-parser.cc:12277 +#: c/c-decl.cc:8228 c/c-parser.cc:12277 #, gcc-internal-format msgid "invalid qualifiers for %<constexpr%> object" msgstr "" -#: c/c-decl.cc:8232 c/c-parser.cc:12280 +#: c/c-decl.cc:8234 c/c-parser.cc:12280 #, gcc-internal-format msgid "invalid qualifiers for field of %<constexpr%> object" msgstr "" -#: c/c-decl.cc:8258 +#: c/c-decl.cc:8260 #, gcc-internal-format msgid "variable previously declared %<static%> redeclared %<extern%>" msgstr "" -#: c/c-decl.cc:8270 +#: c/c-decl.cc:8272 #, gcc-internal-format msgid "variable %q+D declared %<inline%>" msgstr "" -#: c/c-decl.cc:8272 +#: c/c-decl.cc:8274 #, gcc-internal-format msgid "variable %q+D declared %<_Noreturn%>" msgstr "" -#: c/c-decl.cc:8307 +#: c/c-decl.cc:8309 #, gcc-internal-format msgid "non-nested function with variably modified type" msgstr "" -#: c/c-decl.cc:8309 +#: c/c-decl.cc:8311 #, gcc-internal-format msgid "object with variably modified type must have no linkage" msgstr "" -#: c/c-decl.cc:8417 c/c-decl.cc:10549 +#: c/c-decl.cc:8419 c/c-decl.cc:10596 #, gcc-internal-format msgid "function declaration isn%'t a prototype" msgstr "" -#: c/c-decl.cc:8429 +#: c/c-decl.cc:8431 #, gcc-internal-format msgid "parameter names (without types) in function declaration" msgstr "" -#: c/c-decl.cc:8474 +#: c/c-decl.cc:8476 #, gcc-internal-format msgid "parameter %u (%q+D) has incomplete type" msgstr "" -#: c/c-decl.cc:8478 +#: c/c-decl.cc:8480 #, gcc-internal-format, gfc-internal-format msgid "parameter %u has incomplete type" msgstr "" -#: c/c-decl.cc:8489 +#: c/c-decl.cc:8491 #, gcc-internal-format msgid "parameter %u (%q+D) has void type" msgstr "" -#: c/c-decl.cc:8493 +#: c/c-decl.cc:8495 #, gcc-internal-format, gfc-internal-format msgid "parameter %u has void type" msgstr "" -#: c/c-decl.cc:8568 +#: c/c-decl.cc:8570 #, gcc-internal-format msgid "%<void%> as only parameter may not be qualified" msgstr "" -#: c/c-decl.cc:8572 c/c-decl.cc:8608 +#: c/c-decl.cc:8574 c/c-decl.cc:8610 #, gcc-internal-format msgid "%<void%> must be the only parameter" msgstr "" -#: c/c-decl.cc:8602 +#: c/c-decl.cc:8604 #, gcc-internal-format msgid "parameter %q+D has just a forward declaration" msgstr "" -#: c/c-decl.cc:8650 +#: c/c-decl.cc:8652 #, gcc-internal-format msgid "" "%<%s %E%> declared inside parameter list will not be visible outside of this " "definition or declaration" msgstr "" -#: c/c-decl.cc:8657 +#: c/c-decl.cc:8659 #, gcc-internal-format, gfc-internal-format msgid "" "anonymous %s declared inside parameter list will not be visible outside of " "this definition or declaration" msgstr "" -#: c/c-decl.cc:8783 +#: c/c-decl.cc:8785 #, gcc-internal-format msgid "enum type defined here" msgstr "" -#: c/c-decl.cc:8789 +#: c/c-decl.cc:8791 #, gcc-internal-format msgid "struct defined here" msgstr "" -#: c/c-decl.cc:8795 +#: c/c-decl.cc:8797 #, gcc-internal-format msgid "union defined here" msgstr "" -#: c/c-decl.cc:8886 +#: c/c-decl.cc:8890 #, gcc-internal-format msgid "redefinition of %<union %E%>" msgstr "" -#: c/c-decl.cc:8888 +#: c/c-decl.cc:8892 #, gcc-internal-format msgid "redefinition of %<struct %E%>" msgstr "" -#: c/c-decl.cc:8897 +#: c/c-decl.cc:8901 #, gcc-internal-format msgid "nested redefinition of %<union %E%>" msgstr "" -#: c/c-decl.cc:8899 +#: c/c-decl.cc:8903 #, gcc-internal-format msgid "nested redefinition of %<struct %E%>" msgstr "" -#: c/c-decl.cc:8929 c/c-decl.cc:9927 +#: c/c-decl.cc:8935 c/c-decl.cc:9974 #, gcc-internal-format msgid "defining type in %qs expression is invalid in C++" msgstr "" -#: c/c-decl.cc:8935 c/c-decl.cc:9933 +#: c/c-decl.cc:8941 c/c-decl.cc:9980 #, gcc-internal-format msgid "%qT defined in underspecified object initializer" msgstr "" -#: c/c-decl.cc:8999 cp/decl.cc:5661 +#: c/c-decl.cc:9005 cp/decl.cc:5661 #, gcc-internal-format msgid "declaration does not declare anything" msgstr "" -#: c/c-decl.cc:9004 +#: c/c-decl.cc:9010 #, gcc-internal-format msgid "ISO C99 doesn%'t support unnamed structs/unions" msgstr "" -#: c/c-decl.cc:9007 +#: c/c-decl.cc:9013 #, gcc-internal-format msgid "ISO C90 doesn%'t support unnamed structs/unions" msgstr "" -#: c/c-decl.cc:9100 c/c-decl.cc:9118 c/c-decl.cc:9179 +#: c/c-decl.cc:9106 c/c-decl.cc:9124 c/c-decl.cc:9185 #, gcc-internal-format msgid "duplicate member %q+D" msgstr "" -#: c/c-decl.cc:9205 +#: c/c-decl.cc:9211 #, gcc-internal-format msgid "empty struct has size 0 in C, size 1 in C++" msgstr "" -#: c/c-decl.cc:9208 +#: c/c-decl.cc:9214 #, gcc-internal-format msgid "empty union has size 0 in C, size 1 in C++" msgstr "" -#: c/c-decl.cc:9389 +#: c/c-decl.cc:9434 #, gcc-internal-format msgid "union has no named members" msgstr "" -#: c/c-decl.cc:9391 +#: c/c-decl.cc:9436 #, gcc-internal-format msgid "union has no members" msgstr "" -#: c/c-decl.cc:9396 +#: c/c-decl.cc:9441 #, gcc-internal-format msgid "struct has no named members" msgstr "" -#: c/c-decl.cc:9398 +#: c/c-decl.cc:9443 #, gcc-internal-format msgid "struct has no members" msgstr "" -#: c/c-decl.cc:9476 cp/decl.cc:14570 +#: c/c-decl.cc:9521 cp/decl.cc:14576 #, gcc-internal-format msgid "flexible array member in union" msgstr "" -#: c/c-decl.cc:9482 +#: c/c-decl.cc:9527 #, gcc-internal-format msgid "flexible array member not at end of struct" msgstr "" -#: c/c-decl.cc:9488 +#: c/c-decl.cc:9533 #, gcc-internal-format msgid "flexible array member in a struct with no named members" msgstr "" -#: c/c-decl.cc:9519 +#: c/c-decl.cc:9564 #, gcc-internal-format msgid "" "structure containing a flexible array member is not at the end of another " "structure" msgstr "" -#: c/c-decl.cc:9542 +#: c/c-decl.cc:9587 #, gcc-internal-format msgid "type %qT is too large" msgstr "" -#: c/c-decl.cc:9606 +#: c/c-decl.cc:9651 #, gcc-internal-format msgid "type punning toggles scalar storage order" msgstr "" -#: c/c-decl.cc:9673 +#: c/c-decl.cc:9718 #, gcc-internal-format msgid "union cannot be made transparent" msgstr "" -#: c/c-decl.cc:9686 +#: c/c-decl.cc:9731 #, gcc-internal-format msgid "redefinition of struct or union %qT with variably modified type" msgstr "" -#: c/c-decl.cc:9689 +#: c/c-decl.cc:9734 #, gcc-internal-format msgid "redefinition of struct or union %qT" msgstr "" -#: c/c-decl.cc:9852 +#: c/c-decl.cc:9899 #, gcc-internal-format msgid "nested redefinition of %<enum %E%>" msgstr "" -#: c/c-decl.cc:9897 +#: c/c-decl.cc:9944 #, gcc-internal-format msgid "redeclaration of %<enum %E%>" msgstr "" -#: c/c-decl.cc:9909 +#: c/c-decl.cc:9956 #, gcc-internal-format msgid "%<enum%> declared with but defined without fixed underlying type" msgstr "" -#: c/c-decl.cc:9996 cp/decl.cc:17209 m2/gm2-gcc/m2type.cc:2073 +#: c/c-decl.cc:10043 cp/decl.cc:17215 m2/gm2-gcc/m2type.cc:2073 #, gcc-internal-format msgid "specified mode too small for enumerated values" msgstr "" -#: c/c-decl.cc:10015 +#: c/c-decl.cc:10062 #, gcc-internal-format msgid "enumeration values exceed range of largest integer" msgstr "" -#: c/c-decl.cc:10024 +#: c/c-decl.cc:10071 #, gcc-internal-format msgid "enumeration values exceed range of %qs" msgstr "" -#: c/c-decl.cc:10133 +#: c/c-decl.cc:10180 #, gcc-internal-format msgid "conflicting redefinition of enum %qT" msgstr "" -#: c/c-decl.cc:10165 c/c-decl.cc:10181 +#: c/c-decl.cc:10212 c/c-decl.cc:10228 #, gcc-internal-format msgid "enumerator value for %qE is not an integer constant" msgstr "" -#: c/c-decl.cc:10176 +#: c/c-decl.cc:10223 #, gcc-internal-format msgid "enumerator value for %qE is not an integer constant expression" msgstr "" -#: c/c-decl.cc:10200 +#: c/c-decl.cc:10247 #, gcc-internal-format msgid "overflow in enumeration values" msgstr "" -#: c/c-decl.cc:10207 +#: c/c-decl.cc:10254 #, gcc-internal-format msgid "enumerator value outside the range of underlying type" msgstr "" -#: c/c-decl.cc:10235 +#: c/c-decl.cc:10282 #, gcc-internal-format msgid "enumerator value outside the range of %qs" msgstr "" -#: c/c-decl.cc:10241 +#: c/c-decl.cc:10288 #, gcc-internal-format msgid "ISO C restricts enumerator values to range of %<int%> before C23" msgstr "" -#: c/c-decl.cc:10442 cp/decl.cc:5981 cp/decl.cc:17794 +#: c/c-decl.cc:10489 cp/decl.cc:5981 cp/decl.cc:17800 #, gcc-internal-format msgid "inline function %qD given attribute %qs" msgstr "" -#: c/c-decl.cc:10460 +#: c/c-decl.cc:10507 #, gcc-internal-format msgid "return type is an incomplete type" msgstr "" -#: c/c-decl.cc:10472 +#: c/c-decl.cc:10519 #, gcc-internal-format msgid "return type defaults to %<int%>" msgstr "" -#: c/c-decl.cc:10500 +#: c/c-decl.cc:10547 #, gcc-internal-format msgid "%q+D defined as variadic function without prototype" msgstr "" -#: c/c-decl.cc:10558 +#: c/c-decl.cc:10605 #, gcc-internal-format msgid "no previous prototype for %qD" msgstr "" -#: c/c-decl.cc:10567 +#: c/c-decl.cc:10614 #, gcc-internal-format msgid "%qD was used with no prototype before its definition" msgstr "" -#: c/c-decl.cc:10585 +#: c/c-decl.cc:10632 #, gcc-internal-format msgid "%qD was used with no declaration before its definition" msgstr "" -#: c/c-decl.cc:10604 +#: c/c-decl.cc:10651 #, gcc-internal-format msgid "return type of %qD is not %<int%>" msgstr "" -#: c/c-decl.cc:10606 +#: c/c-decl.cc:10653 #, gcc-internal-format msgid "%<_Atomic%>-qualified return type of %qD" msgstr "" -#: c/c-decl.cc:10613 +#: c/c-decl.cc:10660 #, gcc-internal-format msgid "%qD is normally a non-static function" msgstr "" -#: c/c-decl.cc:10664 +#: c/c-decl.cc:10711 #, gcc-internal-format msgid "old-style parameter declarations in prototyped function definition" msgstr "" -#: c/c-decl.cc:10679 +#: c/c-decl.cc:10726 #, gcc-internal-format msgid "traditional C rejects ISO C style function definitions" msgstr "" -#: c/c-decl.cc:10696 +#: c/c-decl.cc:10743 #, gcc-internal-format msgid "" "ISO C does not support omitting parameter names in function definitions " "before C23" msgstr "" -#: c/c-decl.cc:10736 c/c-decl.cc:10740 +#: c/c-decl.cc:10783 c/c-decl.cc:10787 #, gcc-internal-format msgid "old-style function definition" msgstr "" -#: c/c-decl.cc:10753 +#: c/c-decl.cc:10800 #, gcc-internal-format msgid "parameter name missing from parameter list" msgstr "" -#: c/c-decl.cc:10769 +#: c/c-decl.cc:10816 #, gcc-internal-format msgid "%qD declared as a non-parameter" msgstr "" -#: c/c-decl.cc:10777 +#: c/c-decl.cc:10824 #, gcc-internal-format msgid "multiple parameters named %qD" msgstr "" -#: c/c-decl.cc:10786 +#: c/c-decl.cc:10833 #, gcc-internal-format msgid "parameter %qD declared with void type" msgstr "" -#: c/c-decl.cc:10815 c/c-decl.cc:10820 +#: c/c-decl.cc:10862 c/c-decl.cc:10867 #, gcc-internal-format msgid "type of %qD defaults to %<int%>" msgstr "" -#: c/c-decl.cc:10840 +#: c/c-decl.cc:10887 #, gcc-internal-format msgid "parameter %qD has incomplete type" msgstr "" -#: c/c-decl.cc:10847 +#: c/c-decl.cc:10894 #, gcc-internal-format msgid "declaration for parameter %qD but no such parameter" msgstr "" -#: c/c-decl.cc:10900 +#: c/c-decl.cc:10947 #, gcc-internal-format msgid "number of arguments doesn%'t match built-in prototype" msgstr "" -#: c/c-decl.cc:10911 +#: c/c-decl.cc:10958 #, gcc-internal-format msgid "number of arguments doesn%'t match prototype" msgstr "" -#: c/c-decl.cc:10914 c/c-decl.cc:10961 c/c-decl.cc:10975 +#: c/c-decl.cc:10961 c/c-decl.cc:11008 c/c-decl.cc:11022 #, gcc-internal-format msgid "prototype declaration" msgstr "" -#: c/c-decl.cc:10953 +#: c/c-decl.cc:11000 #, gcc-internal-format msgid "promoted argument %qD doesn%'t match built-in prototype" msgstr "" -#: c/c-decl.cc:10958 +#: c/c-decl.cc:11005 #, gcc-internal-format msgid "promoted argument %qD doesn%'t match prototype" msgstr "" -#: c/c-decl.cc:10968 +#: c/c-decl.cc:11015 #, gcc-internal-format msgid "argument %qD doesn%'t match built-in prototype" msgstr "" -#: c/c-decl.cc:10973 +#: c/c-decl.cc:11020 #, gcc-internal-format msgid "argument %qD doesn%'t match prototype" msgstr "" -#: c/c-decl.cc:11231 cp/decl.cc:18731 +#: c/c-decl.cc:11278 cp/decl.cc:18737 #, gcc-internal-format msgid "no return statement in function returning non-void" msgstr "" -#: c/c-decl.cc:11250 cp/decl.cc:18802 +#: c/c-decl.cc:11297 cp/decl.cc:18808 #, gcc-internal-format msgid "parameter %qD set but not used" msgstr "" -#: c/c-decl.cc:11347 +#: c/c-decl.cc:11394 #, gcc-internal-format msgid "%<for%> loop initial declarations are only allowed in C99 or C11 mode" msgstr "" -#: c/c-decl.cc:11352 +#: c/c-decl.cc:11399 #, gcc-internal-format msgid "" "use option %<-std=c99%>, %<-std=gnu99%>, %<-std=c11%> or %<-std=gnu11%> to " "compile your code" msgstr "" -#: c/c-decl.cc:11359 +#: c/c-decl.cc:11406 #, gcc-internal-format msgid "ISO C90 does not support %<for%> loop initial declarations" msgstr "" -#: c/c-decl.cc:11393 +#: c/c-decl.cc:11440 #, gcc-internal-format msgid "declaration of static variable %qD in %<for%> loop initial declaration" msgstr "" -#: c/c-decl.cc:11397 +#: c/c-decl.cc:11444 #, gcc-internal-format msgid "" "declaration of %<extern%> variable %qD in %<for%> loop initial declaration" msgstr "" -#: c/c-decl.cc:11404 +#: c/c-decl.cc:11451 #, gcc-internal-format msgid "%<struct %E%> declared in %<for%> loop initial declaration" msgstr "" -#: c/c-decl.cc:11409 +#: c/c-decl.cc:11456 #, gcc-internal-format msgid "%<union %E%> declared in %<for%> loop initial declaration" msgstr "" -#: c/c-decl.cc:11415 +#: c/c-decl.cc:11462 #, gcc-internal-format msgid "%<enum %E%> declared in %<for%> loop initial declaration" msgstr "" -#: c/c-decl.cc:11419 +#: c/c-decl.cc:11466 #, gcc-internal-format msgid "declaration of non-variable %qD in %<for%> loop initial declaration" msgstr "" -#: c/c-decl.cc:11706 +#: c/c-decl.cc:11753 #, gcc-internal-format msgid "incompatible address space qualifiers %qs and %qs" msgstr "" -#: c/c-decl.cc:11765 c/c-decl.cc:11772 +#: c/c-decl.cc:11812 c/c-decl.cc:11819 #, gcc-internal-format msgid "duplicate %qE declaration specifier" msgstr "" -#: c/c-decl.cc:11800 c/c-decl.cc:12878 +#: c/c-decl.cc:11847 c/c-decl.cc:12925 #, gcc-internal-format msgid "multiple storage classes in declaration specifiers" msgstr "" -#: c/c-decl.cc:11802 +#: c/c-decl.cc:11849 #, gcc-internal-format msgid "%qs used with %<auto%>" msgstr "" #. auto may only be used with another storage class specifier, #. such as constexpr, if the type is inferred. -#: c/c-decl.cc:11807 +#: c/c-decl.cc:11854 #, gcc-internal-format msgid "%<auto%> used with %<constexpr%>" msgstr "" -#: c/c-decl.cc:11820 c/c-decl.cc:12220 c/c-decl.cc:12673 +#: c/c-decl.cc:11867 c/c-decl.cc:12267 c/c-decl.cc:12720 #, gcc-internal-format msgid "two or more data types in declaration specifiers" msgstr "" -#: c/c-decl.cc:11832 cp/parser.cc:34265 +#: c/c-decl.cc:11879 cp/parser.cc:34265 #, gcc-internal-format msgid "%<long long long%> is too long for GCC" msgstr "" -#: c/c-decl.cc:11845 +#: c/c-decl.cc:11892 #, gcc-internal-format msgid "ISO C90 does not support %<long long%>" msgstr "" -#: c/c-decl.cc:12082 c/c-parser.cc:11619 +#: c/c-decl.cc:12129 c/c-parser.cc:11619 #, gcc-internal-format msgid "ISO C90 does not support complex types" msgstr "" -#: c/c-decl.cc:12132 +#: c/c-decl.cc:12179 #, gcc-internal-format msgid "ISO C does not support saturating types" msgstr "" -#: c/c-decl.cc:12207 c/c-decl.cc:12813 c/c-decl.cc:12872 +#: c/c-decl.cc:12254 c/c-decl.cc:12860 c/c-decl.cc:12919 #, gcc-internal-format msgid "duplicate %qE" msgstr "" -#: c/c-decl.cc:12267 +#: c/c-decl.cc:12314 #, gcc-internal-format msgid "ISO C does not support %<__int%d%> types" msgstr "" -#: c/c-decl.cc:12289 +#: c/c-decl.cc:12336 #, gcc-internal-format msgid "%<__int%d%> is not supported on this target" msgstr "" -#: c/c-decl.cc:12332 +#: c/c-decl.cc:12379 #, gcc-internal-format msgid "ISO C90 does not support boolean types" msgstr "" -#: c/c-decl.cc:12451 +#: c/c-decl.cc:12498 #, gcc-internal-format msgid "ISO C does not support the %<_Float%d%s%> type before C23" msgstr "" -#: c/c-decl.cc:12502 cp/parser.cc:20288 +#: c/c-decl.cc:12549 cp/parser.cc:20288 #, gcc-internal-format msgid "%<_Float%d%s%> is not supported on this target" msgstr "" -#: c/c-decl.cc:12573 +#: c/c-decl.cc:12620 #, gcc-internal-format msgid "ISO C does not support decimal floating-point before C23" msgstr "" -#: c/c-decl.cc:12597 c/c-decl.cc:12974 c/c-parser.cc:10626 +#: c/c-decl.cc:12644 c/c-decl.cc:13021 c/c-parser.cc:10626 #, gcc-internal-format msgid "fixed-point types not supported for this target" msgstr "" -#: c/c-decl.cc:12599 +#: c/c-decl.cc:12646 #, gcc-internal-format msgid "ISO C does not support fixed-point types" msgstr "" -#: c/c-decl.cc:12628 +#: c/c-decl.cc:12675 #, gcc-internal-format msgid "%<_BitInt%> argument is not an integer constant expression" msgstr "" -#: c/c-decl.cc:12634 +#: c/c-decl.cc:12681 #, gcc-internal-format msgid "%<_BitInt%> argument %qE is not a positive integer constant expression" msgstr "" -#: c/c-decl.cc:12641 +#: c/c-decl.cc:12688 #, gcc-internal-format msgid "%<_BitInt%> argument %qE is larger than %<BITINT_MAXWIDTH%> %qd" msgstr "" -#: c/c-decl.cc:12689 +#: c/c-decl.cc:12736 #, gcc-internal-format msgid "C++ lookup of %qD would return a field, not a type" msgstr "" -#: c/c-decl.cc:12702 +#: c/c-decl.cc:12749 #, gcc-internal-format msgid "%qE fails to be a typedef or built in type" msgstr "" -#: c/c-decl.cc:12757 +#: c/c-decl.cc:12804 #, gcc-internal-format msgid "%qE is not at beginning of declaration" msgstr "" #. auto may only be used with another storage class specifier, #. such as constexpr, if the type is inferred. -#: c/c-decl.cc:12778 c/c-decl.cc:12855 +#: c/c-decl.cc:12825 c/c-decl.cc:12902 #, gcc-internal-format msgid "%qE used with %<auto%>" msgstr "" -#: c/c-decl.cc:12780 +#: c/c-decl.cc:12827 #, gcc-internal-format msgid "%qE used with %<register%>" msgstr "" -#: c/c-decl.cc:12782 c/c-decl.cc:12851 +#: c/c-decl.cc:12829 c/c-decl.cc:12898 #, gcc-internal-format msgid "%qE used with %<typedef%>" msgstr "" -#: c/c-decl.cc:12784 c/c-decl.cc:12821 +#: c/c-decl.cc:12831 c/c-decl.cc:12868 #, gcc-internal-format msgid "%qE used with %<constexpr%>" msgstr "" -#: c/c-decl.cc:12798 c/c-parser.cc:3100 c/c-parser.cc:4427 c/c-parser.cc:9960 +#: c/c-decl.cc:12845 c/c-parser.cc:3100 c/c-parser.cc:4427 c/c-parser.cc:9960 #, gcc-internal-format msgid "ISO C99 does not support %qE" msgstr "" -#: c/c-decl.cc:12801 c/c-parser.cc:3103 c/c-parser.cc:4430 c/c-parser.cc:9963 +#: c/c-decl.cc:12848 c/c-parser.cc:3103 c/c-parser.cc:4430 c/c-parser.cc:9963 #, gcc-internal-format msgid "ISO C90 does not support %qE" msgstr "" -#: c/c-decl.cc:12827 +#: c/c-decl.cc:12874 #, gcc-internal-format msgid "%<__thread%> before %<extern%>" msgstr "" -#: c/c-decl.cc:12836 +#: c/c-decl.cc:12883 #, gcc-internal-format msgid "%<__thread%> before %<static%>" msgstr "" -#: c/c-decl.cc:12842 +#: c/c-decl.cc:12889 #, gcc-internal-format msgid "%<typedef%> used with %<auto%>" msgstr "" -#: c/c-decl.cc:12849 +#: c/c-decl.cc:12896 #, gcc-internal-format msgid "%qE used with %<extern%>" msgstr "" -#: c/c-decl.cc:12857 +#: c/c-decl.cc:12904 #, gcc-internal-format msgid "%qE used with %qs" msgstr "" -#: c/c-decl.cc:12870 +#: c/c-decl.cc:12917 #, gcc-internal-format msgid "duplicate %<_Thread_local%> or %<__thread%>" msgstr "" -#: c/c-decl.cc:12886 +#: c/c-decl.cc:12933 #, gcc-internal-format msgid "%qs used with %qE" msgstr "" -#: c/c-decl.cc:12894 +#: c/c-decl.cc:12941 #, gcc-internal-format msgid "%<constexpr%> used with %qE" msgstr "" -#: c/c-decl.cc:12971 +#: c/c-decl.cc:13018 #, gcc-internal-format msgid "%<_Sat%> is used without %<_Fract%> or %<_Accum%>" msgstr "" -#: c/c-decl.cc:12986 +#: c/c-decl.cc:13033 #, gcc-internal-format msgid "ISO C does not support plain %<complex%> meaning %<double complex%>" msgstr "" -#: c/c-decl.cc:12997 +#: c/c-decl.cc:13044 #, gcc-internal-format msgid "ISO C does not support %<auto%> type deduction before C23" msgstr "" -#: c/c-decl.cc:13026 +#: c/c-decl.cc:13073 #, gcc-internal-format msgid "%<__auto_type%> followed by %<[[]]%> attributes" msgstr "" -#: c/c-decl.cc:13052 c/c-decl.cc:13068 c/c-decl.cc:13094 +#: c/c-decl.cc:13099 c/c-decl.cc:13115 c/c-decl.cc:13141 #, gcc-internal-format msgid "ISO C does not support complex integer types" msgstr "" -#: c/c-decl.cc:13237 +#: c/c-decl.cc:13284 #, gcc-internal-format msgid "%<signed _BitInt%> argument must be at least 2" msgstr "" -#: c/c-decl.cc:13246 +#: c/c-decl.cc:13293 #, gcc-internal-format msgid "ISO C does not support %<%s_BitInt(%d)%> before C23" msgstr "" -#: c/c-decl.cc:13545 cp/semantics.cc:6385 +#: c/c-decl.cc:13592 cp/semantics.cc:6389 #, gcc-internal-format msgid "" "%<#pragma omp declare reduction%> combiner refers to variable %qD which is " "not %<omp_out%> nor %<omp_in%>" msgstr "" -#: c/c-decl.cc:13549 cp/semantics.cc:6389 +#: c/c-decl.cc:13596 cp/semantics.cc:6393 #, gcc-internal-format msgid "" "%<#pragma omp declare reduction%> initializer refers to variable %qD which " "is not %<omp_priv%> nor %<omp_orig%>" msgstr "" -#: c/c-fold.cc:389 c/c-typeck.cc:12830 cp/typeck.cc:5735 +#: c/c-fold.cc:389 c/c-typeck.cc:12832 cp/typeck.cc:5735 #, gcc-internal-format msgid "left shift of negative value" msgstr "" -#: c/c-fold.cc:399 c/c-typeck.cc:12839 cp/typeck.cc:5743 +#: c/c-fold.cc:399 c/c-typeck.cc:12841 cp/typeck.cc:5743 #, gcc-internal-format msgid "left shift count is negative" msgstr "" -#: c/c-fold.cc:400 c/c-typeck.cc:12766 cp/typeck.cc:5682 +#: c/c-fold.cc:400 c/c-typeck.cc:12768 cp/typeck.cc:5682 #, gcc-internal-format msgid "right shift count is negative" msgstr "" -#: c/c-fold.cc:409 c/c-typeck.cc:12858 cp/typeck.cc:5751 +#: c/c-fold.cc:409 c/c-typeck.cc:12860 cp/typeck.cc:5751 #, gcc-internal-format msgid "left shift count >= width of type" msgstr "" -#: c/c-fold.cc:410 c/c-typeck.cc:12790 cp/typeck.cc:5693 +#: c/c-fold.cc:410 c/c-typeck.cc:12792 cp/typeck.cc:5693 #, gcc-internal-format msgid "right shift count >= width of type" msgstr "" -#: c/c-fold.cc:417 c/c-typeck.cc:12850 +#: c/c-fold.cc:417 c/c-typeck.cc:12852 #, gcc-internal-format msgid "left shift count >= width of vector element" msgstr "" -#: c/c-fold.cc:418 c/c-typeck.cc:12777 +#: c/c-fold.cc:418 c/c-typeck.cc:12779 #, gcc-internal-format msgid "right shift count >= width of vector element" msgstr "" @@ -49564,7 +49586,7 @@ msgid "ISO C forbids an empty translation unit" msgstr "" #: c/c-parser.cc:1917 c/c-parser.cc:1926 c/c-parser.cc:25405 cp/parser.cc:49092 -#: cp/semantics.cc:3629 cp/semantics.cc:3638 +#: cp/semantics.cc:3633 cp/semantics.cc:3642 #, gcc-internal-format msgid "%qs without corresponding %qs" msgstr "" @@ -49749,7 +49771,7 @@ msgstr "" msgid "static assertion failed: %E" msgstr "" -#: c/c-parser.cc:3164 cp/semantics.cc:11747 +#: c/c-parser.cc:3164 cp/semantics.cc:11751 #, gcc-internal-format msgid "static assertion failed" msgstr "" @@ -49928,7 +49950,7 @@ msgstr "" msgid "ISO C does not support %<[[]]%> attributes before C23" msgstr "" -#: c/c-parser.cc:6104 c/c-parser.cc:6167 c/c-typeck.cc:8822 +#: c/c-parser.cc:6104 c/c-parser.cc:6167 c/c-typeck.cc:8824 #, gcc-internal-format msgid "" "variable-sized object may not be initialized except with an empty initializer" @@ -50721,7 +50743,7 @@ msgstr "" msgid "setter method names must terminate with %<:%>" msgstr "" -#: c/c-parser.cc:14453 cp/semantics.cc:13234 +#: c/c-parser.cc:14453 cp/semantics.cc:13238 #, gcc-internal-format msgid "" "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a " @@ -50805,7 +50827,7 @@ msgstr "" msgid "%qD is not a variable" msgstr "" -#: c/c-parser.cc:15750 cp/semantics.cc:8610 +#: c/c-parser.cc:15750 cp/semantics.cc:8614 #, gcc-internal-format msgid "%qD is not a pointer variable" msgstr "" @@ -50881,12 +50903,12 @@ msgstr "" msgid "%<num_tasks%> value must be positive" msgstr "" -#: c/c-parser.cc:16378 cp/semantics.cc:8824 +#: c/c-parser.cc:16378 cp/semantics.cc:8828 #, gcc-internal-format msgid "%<grainsize%> value must be positive" msgstr "" -#: c/c-parser.cc:16427 cp/semantics.cc:8854 +#: c/c-parser.cc:16427 cp/semantics.cc:8858 #, gcc-internal-format msgid "%<priority%> value must be non-negative" msgstr "" @@ -50918,13 +50940,13 @@ msgstr "" msgid "too many %<defaultmap%> clauses with unspecified category" msgstr "" -#: c/c-parser.cc:16765 cp/semantics.cc:7681 cp/semantics.cc:7736 +#: c/c-parser.cc:16765 cp/semantics.cc:7685 cp/semantics.cc:7740 #, gcc-internal-format msgid "%qs expression must be integral" msgstr "" -#: c/c-parser.cc:16777 c/c-parser.cc:16900 cp/semantics.cc:7715 -#: cp/semantics.cc:7750 +#: c/c-parser.cc:16777 c/c-parser.cc:16900 cp/semantics.cc:7719 +#: cp/semantics.cc:7754 #, gcc-internal-format msgid "%qs value must be positive" msgstr "" @@ -50939,7 +50961,7 @@ msgstr "" msgid "unexpected argument" msgstr "" -#: c/c-parser.cc:17040 cp/semantics.cc:9041 +#: c/c-parser.cc:17040 cp/semantics.cc:9045 #, gcc-internal-format msgid "%<tile%> argument needs positive integral constant" msgstr "" @@ -50992,7 +51014,7 @@ msgstr "" msgid "schedule %<auto%> does not take a %<chunk_size%> parameter" msgstr "" -#: c/c-parser.cc:17572 cp/semantics.cc:7797 +#: c/c-parser.cc:17572 cp/semantics.cc:7801 #, gcc-internal-format msgid "chunk size value must be positive" msgstr "" @@ -51007,17 +51029,17 @@ msgstr "" msgid "%<num_teams%> value must be positive" msgstr "" -#: c/c-parser.cc:17753 cp/semantics.cc:7764 +#: c/c-parser.cc:17753 cp/semantics.cc:7768 #, gcc-internal-format msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE" msgstr "" -#: c/c-parser.cc:17802 cp/semantics.cc:7893 +#: c/c-parser.cc:17802 cp/semantics.cc:7897 #, gcc-internal-format msgid "%<thread_limit%> value must be positive" msgstr "" -#: c/c-parser.cc:17847 cp/semantics.cc:8021 +#: c/c-parser.cc:17847 cp/semantics.cc:8025 #, gcc-internal-format msgid "" "%<aligned%> clause alignment expression must be positive constant integer " @@ -51034,14 +51056,14 @@ msgstr "" msgid "duplicate %qs modifier" msgstr "" -#: c/c-parser.cc:18014 cp/semantics.cc:8156 +#: c/c-parser.cc:18014 cp/semantics.cc:8160 #, gcc-internal-format msgid "" "%<allocate%> clause allocator expression has type %qT rather than " "%<omp_allocator_handle_t%>" msgstr "" -#: c/c-parser.cc:18025 cp/semantics.cc:8111 cp/semantics.cc:8127 +#: c/c-parser.cc:18025 cp/semantics.cc:8115 cp/semantics.cc:8131 #, gcc-internal-format msgid "" "%<allocate%> clause %<align%> modifier argument needs to be positive " @@ -51129,7 +51151,7 @@ msgstr "" msgid "expected %<ancestor%> or %<device_num%>" msgstr "" -#: c/c-parser.cc:18974 cp/semantics.cc:7918 +#: c/c-parser.cc:18974 cp/semantics.cc:7922 #, gcc-internal-format msgid "the %<device%> clause expression must evaluate to %<1%>" msgstr "" @@ -51149,7 +51171,7 @@ msgstr "" msgid "expected %<host%>, %<nohost%> or %<any%>" msgstr "" -#: c/c-parser.cc:19228 cp/semantics.cc:8337 +#: c/c-parser.cc:19228 cp/semantics.cc:8341 #, gcc-internal-format msgid "" "%<detach%> clause event handle has type %qT rather than " @@ -51459,13 +51481,13 @@ msgstr "" msgid "%<weak%> clause requires atomic equality comparison" msgstr "" -#: c/c-parser.cc:21772 cp/semantics.cc:11229 cp/semantics.cc:11239 +#: c/c-parser.cc:21772 cp/semantics.cc:11233 cp/semantics.cc:11243 #, gcc-internal-format msgid "" "%<#pragma omp atomic capture%> uses two different expressions for memory" msgstr "" -#: c/c-parser.cc:21875 cp/semantics.cc:11316 +#: c/c-parser.cc:21875 cp/semantics.cc:11320 #, gcc-internal-format msgid "%<depobj%> expression is not lvalue expression" msgstr "" @@ -51534,7 +51556,7 @@ msgstr "" msgid "%<#pragma omp scan%> with zero succeeding executable statements" msgstr "" -#: c/c-parser.cc:22325 cp/semantics.cc:10803 cp/semantics.cc:10888 +#: c/c-parser.cc:22325 cp/semantics.cc:10807 cp/semantics.cc:10892 #, gcc-internal-format msgid "expected iteration declaration or initialization" msgstr "" @@ -51555,7 +51577,7 @@ msgstr "" msgid "for statement expected" msgstr "" -#: c/c-parser.cc:22651 cp/parser.cc:44894 cp/parser.cc:44937 cp/pt.cc:18112 +#: c/c-parser.cc:22651 cp/parser.cc:44894 cp/parser.cc:44937 cp/pt.cc:18143 #, gcc-internal-format msgid "iteration variable %qD should not be firstprivate" msgstr "" @@ -51624,7 +51646,7 @@ msgid "" "%<#pragma omp target exit data%> must contain at least one %<map%> clause" msgstr "" -#: c/c-parser.cc:24424 cp/semantics.cc:10311 +#: c/c-parser.cc:24424 cp/semantics.cc:10315 #, gcc-internal-format msgid "" "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> " @@ -51680,7 +51702,7 @@ msgstr "" msgid "expected identifier or string literal" msgstr "" -#: c/c-parser.cc:24743 cp/parser.cc:48071 cp/pt.cc:12015 +#: c/c-parser.cc:24743 cp/parser.cc:48071 cp/pt.cc:12036 #, gcc-internal-format msgid "property must be constant integer expression" msgstr "" @@ -51966,17 +51988,17 @@ msgstr "" msgid "expected assumption clause" msgstr "" -#: c/c-parser.cc:26640 cp/semantics.cc:9677 +#: c/c-parser.cc:26640 cp/semantics.cc:9681 #, gcc-internal-format msgid "%qE declared %<threadprivate%> after first use" msgstr "" -#: c/c-parser.cc:26642 cp/semantics.cc:9679 +#: c/c-parser.cc:26642 cp/semantics.cc:9683 #, gcc-internal-format msgid "automatic variable %qE cannot be %<threadprivate%>" msgstr "" -#: c/c-parser.cc:26646 cp/semantics.cc:9681 +#: c/c-parser.cc:26646 cp/semantics.cc:9685 #, gcc-internal-format msgid "%<threadprivate%> %qE has incomplete type" msgstr "" @@ -52013,7 +52035,7 @@ msgstr "" msgid "%qD has an incomplete type %qT" msgstr "" -#: c/c-typeck.cc:251 c/c-typeck.cc:11336 c/c-typeck.cc:11378 cp/call.cc:4919 +#: c/c-typeck.cc:251 c/c-typeck.cc:11338 c/c-typeck.cc:11380 cp/call.cc:4942 #, gcc-internal-format msgid "invalid use of void expression" msgstr "" @@ -52051,153 +52073,153 @@ msgid "" "arguments" msgstr "" -#: c/c-typeck.cc:707 c/c-typeck.cc:730 +#: c/c-typeck.cc:709 c/c-typeck.cc:732 #, gcc-internal-format msgid "function types not truly compatible in ISO C" msgstr "" -#: c/c-typeck.cc:886 +#: c/c-typeck.cc:888 #, gcc-internal-format msgid "cannot mix operands of decimal floating and vector types" msgstr "" -#: c/c-typeck.cc:891 +#: c/c-typeck.cc:893 #, gcc-internal-format msgid "cannot mix operands of decimal floating and complex types" msgstr "" -#: c/c-typeck.cc:896 +#: c/c-typeck.cc:898 #, gcc-internal-format msgid "cannot mix operands of decimal floating and other floating types" msgstr "" -#: c/c-typeck.cc:926 +#: c/c-typeck.cc:928 #, gcc-internal-format msgid "%<_Complex _BitInt(%d)%> unsupported" msgstr "" -#: c/c-typeck.cc:1472 +#: c/c-typeck.cc:1474 #, gcc-internal-format msgid "" "invalid use of pointers to arrays with different qualifiers in ISO C before " "C23" msgstr "" -#: c/c-typeck.cc:1476 +#: c/c-typeck.cc:1478 #, gcc-internal-format msgid "types are not quite compatible" msgstr "" -#: c/c-typeck.cc:1480 +#: c/c-typeck.cc:1482 #, gcc-internal-format msgid "pointer target types incompatible in C++" msgstr "" -#: c/c-typeck.cc:1655 +#: c/c-typeck.cc:1657 #, gcc-internal-format msgid "function return types not compatible due to %<volatile%>" msgstr "" -#: c/c-typeck.cc:1905 +#: c/c-typeck.cc:1907 #, gcc-internal-format msgid "" "converting an array compound literal to a pointer leads to a dangling " "pointer in C++" msgstr "" -#: c/c-typeck.cc:2599 c/c-typeck.cc:9852 +#: c/c-typeck.cc:2601 c/c-typeck.cc:9854 #, gcc-internal-format msgid "%qT has no member named %qE; did you mean %qE?" msgstr "" -#: c/c-typeck.cc:2603 c/c-typeck.cc:9856 +#: c/c-typeck.cc:2605 c/c-typeck.cc:9858 #, gcc-internal-format msgid "%qT has no member named %qE" msgstr "" -#: c/c-typeck.cc:2612 +#: c/c-typeck.cc:2614 #, gcc-internal-format msgid "accessing a member %qE of an atomic structure %qE" msgstr "" -#: c/c-typeck.cc:2615 +#: c/c-typeck.cc:2617 #, gcc-internal-format msgid "accessing a member %qE of an atomic union %qE" msgstr "" -#: c/c-typeck.cc:2679 +#: c/c-typeck.cc:2681 #, gcc-internal-format msgid "" "%qE is a pointer to pointer; did you mean to dereference it before applying " "%<->%> to it?" msgstr "" -#: c/c-typeck.cc:2688 +#: c/c-typeck.cc:2690 #, gcc-internal-format msgid "%qE is a pointer; did you mean to use %<->%>?" msgstr "" -#: c/c-typeck.cc:2695 +#: c/c-typeck.cc:2697 #, gcc-internal-format msgid "request for member %qE in something not a structure or union" msgstr "" -#: c/c-typeck.cc:2743 +#: c/c-typeck.cc:2745 #, gcc-internal-format msgid "dereferencing %<void *%> pointer" msgstr "" -#: c/c-typeck.cc:2798 +#: c/c-typeck.cc:2800 #, gcc-internal-format msgid "subscripted value is neither array nor pointer nor vector" msgstr "" -#: c/c-typeck.cc:2808 cp/typeck.cc:4005 cp/typeck.cc:4099 +#: c/c-typeck.cc:2810 cp/typeck.cc:4005 cp/typeck.cc:4099 #, gcc-internal-format msgid "array subscript is not an integer" msgstr "" -#: c/c-typeck.cc:2814 +#: c/c-typeck.cc:2816 #, gcc-internal-format msgid "subscripted value is pointer to function" msgstr "" -#: c/c-typeck.cc:2869 +#: c/c-typeck.cc:2871 #, gcc-internal-format msgid "ISO C forbids subscripting %<register%> array" msgstr "" -#: c/c-typeck.cc:2872 +#: c/c-typeck.cc:2874 #, gcc-internal-format msgid "ISO C90 forbids subscripting non-lvalue array" msgstr "" -#: c/c-typeck.cc:2991 +#: c/c-typeck.cc:2993 #, gcc-internal-format msgid "underspecified %qD referenced in its initializer" msgstr "" -#: c/c-typeck.cc:3046 +#: c/c-typeck.cc:3048 #, gcc-internal-format msgid "enum constant defined here" msgstr "" -#: c/c-typeck.cc:3154 cp/typeck.cc:2141 +#: c/c-typeck.cc:3156 cp/typeck.cc:2141 #, gcc-internal-format msgid "%<sizeof%> on array function parameter %qE will return size of %qT" msgstr "" -#: c/c-typeck.cc:3315 +#: c/c-typeck.cc:3317 #, gcc-internal-format msgid "called object %qE is not a function or function pointer" msgstr "" -#: c/c-typeck.cc:3320 +#: c/c-typeck.cc:3322 #, gcc-internal-format msgid "called object %qD is not a function or function pointer" msgstr "" -#: c/c-typeck.cc:3326 +#: c/c-typeck.cc:3328 #, gcc-internal-format msgid "called object is not a function or function pointer" msgstr "" @@ -52205,1743 +52227,1743 @@ msgstr "" #. This situation leads to run-time undefined behavior. We can't, #. therefore, simply error unless we can prove that all possible #. executions of the program must execute the code. -#: c/c-typeck.cc:3355 +#: c/c-typeck.cc:3357 #, gcc-internal-format msgid "function called through a non-compatible type" msgstr "" -#: c/c-typeck.cc:3360 c/c-typeck.cc:3415 +#: c/c-typeck.cc:3362 c/c-typeck.cc:3417 #, gcc-internal-format msgid "function with qualified void return type called" msgstr "" -#: c/c-typeck.cc:3470 +#: c/c-typeck.cc:3472 #, gcc-internal-format, gfc-internal-format msgid "type of formal parameter %d is incomplete" msgstr "" -#: c/c-typeck.cc:3482 +#: c/c-typeck.cc:3484 #, gcc-internal-format msgid "" "passing argument %d of %qE as integer rather than floating due to prototype" msgstr "" -#: c/c-typeck.cc:3488 +#: c/c-typeck.cc:3490 #, gcc-internal-format msgid "" "passing argument %d of %qE as integer rather than complex due to prototype" msgstr "" -#: c/c-typeck.cc:3494 +#: c/c-typeck.cc:3496 #, gcc-internal-format msgid "" "passing argument %d of %qE as complex rather than floating due to prototype" msgstr "" -#: c/c-typeck.cc:3500 +#: c/c-typeck.cc:3502 #, gcc-internal-format msgid "" "passing argument %d of %qE as floating rather than integer due to prototype" msgstr "" -#: c/c-typeck.cc:3506 +#: c/c-typeck.cc:3508 #, gcc-internal-format msgid "" "passing argument %d of %qE as complex rather than integer due to prototype" msgstr "" -#: c/c-typeck.cc:3512 +#: c/c-typeck.cc:3514 #, gcc-internal-format msgid "" "passing argument %d of %qE as floating rather than complex due to prototype" msgstr "" -#: c/c-typeck.cc:3528 +#: c/c-typeck.cc:3530 #, gcc-internal-format msgid "" "passing argument %d of %qE as %<float%> rather than %<double%> due to " "prototype" msgstr "" -#: c/c-typeck.cc:3554 +#: c/c-typeck.cc:3556 #, gcc-internal-format msgid "passing argument %d of %qE as %qT rather than %qT due to prototype" msgstr "" -#: c/c-typeck.cc:3580 +#: c/c-typeck.cc:3582 #, gcc-internal-format msgid "passing argument %d of %qE with different width due to prototype" msgstr "" -#: c/c-typeck.cc:3604 +#: c/c-typeck.cc:3606 #, gcc-internal-format msgid "passing argument %d of %qE as unsigned due to prototype" msgstr "" -#: c/c-typeck.cc:3609 +#: c/c-typeck.cc:3611 #, gcc-internal-format msgid "passing argument %d of %qE as signed due to prototype" msgstr "" -#: c/c-typeck.cc:3775 +#: c/c-typeck.cc:3777 #, gcc-internal-format msgid "too many arguments to method %qE" msgstr "" -#: c/c-typeck.cc:3785 +#: c/c-typeck.cc:3787 #, gcc-internal-format msgid "too many arguments to built-in function %qE expecting %d" msgstr "" -#: c/c-typeck.cc:3860 +#: c/c-typeck.cc:3862 #, gcc-internal-format msgid "implicit conversion from %qT to %qT when passing argument to function" msgstr "" -#: c/c-typeck.cc:3930 +#: c/c-typeck.cc:3932 #, gcc-internal-format msgid "too few arguments to built-in function %qE expecting %u" msgstr "" -#: c/c-typeck.cc:4108 c/c-typeck.cc:4136 cp/typeck.cc:5781 cp/typeck.cc:6064 +#: c/c-typeck.cc:4110 c/c-typeck.cc:4138 cp/typeck.cc:5781 cp/typeck.cc:6064 #, gcc-internal-format msgid "comparison with string literal results in unspecified behavior" msgstr "" -#: c/c-typeck.cc:4116 c/c-typeck.cc:4127 cp/typeck.cc:5813 cp/typeck.cc:5837 +#: c/c-typeck.cc:4118 c/c-typeck.cc:4129 cp/typeck.cc:5813 cp/typeck.cc:5837 #, gcc-internal-format msgid "comparison between pointer and zero character constant" msgstr "" -#: c/c-typeck.cc:4119 c/c-typeck.cc:4130 cp/typeck.cc:5816 cp/typeck.cc:5840 +#: c/c-typeck.cc:4121 c/c-typeck.cc:4132 cp/typeck.cc:5816 cp/typeck.cc:5840 #, gcc-internal-format msgid "did you mean to dereference the pointer?" msgstr "" -#: c/c-typeck.cc:4157 +#: c/c-typeck.cc:4159 #, gcc-internal-format msgid "comparison between %qT and %qT" msgstr "" -#: c/c-typeck.cc:4216 +#: c/c-typeck.cc:4218 #, gcc-internal-format msgid "pointer of type %<void *%> used in subtraction" msgstr "" -#: c/c-typeck.cc:4219 +#: c/c-typeck.cc:4221 #, gcc-internal-format msgid "pointer to a function used in subtraction" msgstr "" -#: c/c-typeck.cc:4253 +#: c/c-typeck.cc:4255 #, gcc-internal-format msgid "arithmetic on pointer to an incomplete type" msgstr "" -#: c/c-typeck.cc:4262 cp/typeck.cc:6859 +#: c/c-typeck.cc:4264 cp/typeck.cc:6859 #, gcc-internal-format msgid "arithmetic on pointer to an empty aggregate" msgstr "" -#: c/c-typeck.cc:4708 +#: c/c-typeck.cc:4710 #, gcc-internal-format msgid "%<~%> on a boolean expression" msgstr "" -#: c/c-typeck.cc:4712 +#: c/c-typeck.cc:4714 #, gcc-internal-format msgid "did you mean to use logical not?" msgstr "" -#: c/c-typeck.cc:4722 +#: c/c-typeck.cc:4724 #, gcc-internal-format msgid "ISO C does not support %<~%> for complex conjugation" msgstr "" -#: c/c-typeck.cc:4746 +#: c/c-typeck.cc:4748 #, gcc-internal-format msgid "wrong type argument to absu" msgstr "" -#: c/c-typeck.cc:4772 +#: c/c-typeck.cc:4774 #, gcc-internal-format msgid "wrong type argument to unary exclamation mark" msgstr "" -#: c/c-typeck.cc:4830 +#: c/c-typeck.cc:4832 #, gcc-internal-format msgid "increment of enumeration value is invalid in C++" msgstr "" -#: c/c-typeck.cc:4833 +#: c/c-typeck.cc:4835 #, gcc-internal-format msgid "decrement of enumeration value is invalid in C++" msgstr "" -#: c/c-typeck.cc:4840 +#: c/c-typeck.cc:4842 #, gcc-internal-format msgid "increment of a boolean expression" msgstr "" -#: c/c-typeck.cc:4843 +#: c/c-typeck.cc:4845 #, gcc-internal-format msgid "decrement of a boolean expression" msgstr "" -#: c/c-typeck.cc:4859 +#: c/c-typeck.cc:4861 #, gcc-internal-format msgid "ISO C does not support %<++%> and %<--%> on complex types" msgstr "" -#: c/c-typeck.cc:4885 c/c-typeck.cc:4919 +#: c/c-typeck.cc:4887 c/c-typeck.cc:4921 #, gcc-internal-format msgid "wrong type argument to increment" msgstr "" -#: c/c-typeck.cc:4887 c/c-typeck.cc:4922 +#: c/c-typeck.cc:4889 c/c-typeck.cc:4924 #, gcc-internal-format msgid "wrong type argument to decrement" msgstr "" -#: c/c-typeck.cc:4907 +#: c/c-typeck.cc:4909 #, gcc-internal-format msgid "increment of pointer to an incomplete type %qT" msgstr "" -#: c/c-typeck.cc:4911 +#: c/c-typeck.cc:4913 #, gcc-internal-format msgid "decrement of pointer to an incomplete type %qT" msgstr "" -#: c/c-typeck.cc:5019 +#: c/c-typeck.cc:5021 #, gcc-internal-format msgid "taking address of expression of type %<void%>" msgstr "" -#: c/c-typeck.cc:5078 c/c-typeck.cc:5271 +#: c/c-typeck.cc:5080 c/c-typeck.cc:5273 #, gcc-internal-format msgid "cannot take address of bit-field %qD" msgstr "" -#: c/c-typeck.cc:5092 +#: c/c-typeck.cc:5094 #, gcc-internal-format msgid "cannot take address of scalar with reverse storage order" msgstr "" -#: c/c-typeck.cc:5100 +#: c/c-typeck.cc:5102 #, gcc-internal-format msgid "address of array with reverse scalar storage order requested" msgstr "" -#: c/c-typeck.cc:5286 +#: c/c-typeck.cc:5288 #, gcc-internal-format msgid "address of register compound literal requested" msgstr "" -#: c/c-typeck.cc:5307 +#: c/c-typeck.cc:5309 #, gcc-internal-format msgid "global register variable %qD used in nested function" msgstr "" -#: c/c-typeck.cc:5310 +#: c/c-typeck.cc:5312 #, gcc-internal-format msgid "register variable %qD used in nested function" msgstr "" -#: c/c-typeck.cc:5315 +#: c/c-typeck.cc:5317 #, gcc-internal-format msgid "address of global register variable %qD requested" msgstr "" -#: c/c-typeck.cc:5317 d/d-codegen.cc:721 +#: c/c-typeck.cc:5319 d/d-codegen.cc:721 #, gcc-internal-format msgid "address of register variable %qD requested" msgstr "" -#: c/c-typeck.cc:5456 +#: c/c-typeck.cc:5458 #, gcc-internal-format msgid "non-lvalue array in conditional expression" msgstr "" -#: c/c-typeck.cc:5538 +#: c/c-typeck.cc:5540 #, gcc-internal-format msgid "" "implicit conversion from %qT to %qT to match other result of conditional" msgstr "" -#: c/c-typeck.cc:5597 c/c-typeck.cc:5603 +#: c/c-typeck.cc:5599 c/c-typeck.cc:5605 #, gcc-internal-format msgid "" "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of " "other operand" msgstr "" -#: c/c-typeck.cc:5620 +#: c/c-typeck.cc:5622 #, gcc-internal-format msgid "ISO C forbids conditional expr with only one void side" msgstr "" -#: c/c-typeck.cc:5637 +#: c/c-typeck.cc:5639 #, gcc-internal-format msgid "pointers to disjoint address spaces used in conditional expression" msgstr "" -#: c/c-typeck.cc:5661 +#: c/c-typeck.cc:5663 #, gcc-internal-format msgid "pointer to array loses qualifier in conditional expression" msgstr "" -#: c/c-typeck.cc:5665 +#: c/c-typeck.cc:5667 #, gcc-internal-format msgid "" "pointer to array loses qualifier in conditional expression in ISO C before " "C23" msgstr "" -#: c/c-typeck.cc:5670 +#: c/c-typeck.cc:5672 #, gcc-internal-format msgid "ISO C forbids conditional expr between %<void *%> and function pointer" msgstr "" -#: c/c-typeck.cc:5692 +#: c/c-typeck.cc:5694 #, gcc-internal-format msgid "pointer type mismatch in conditional expression" msgstr "" -#: c/c-typeck.cc:5695 +#: c/c-typeck.cc:5697 #, gcc-internal-format msgid "first expression has type %qT" msgstr "" -#: c/c-typeck.cc:5696 +#: c/c-typeck.cc:5698 #, gcc-internal-format msgid "second expression has type %qT" msgstr "" -#: c/c-typeck.cc:5707 c/c-typeck.cc:5720 +#: c/c-typeck.cc:5709 c/c-typeck.cc:5722 #, gcc-internal-format msgid "pointer/integer type mismatch in conditional expression" msgstr "" -#: c/c-typeck.cc:5747 +#: c/c-typeck.cc:5749 #, gcc-internal-format msgid "type mismatch in conditional expression" msgstr "" -#: c/c-typeck.cc:5862 +#: c/c-typeck.cc:5864 #, gcc-internal-format msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E" msgstr "" -#: c/c-typeck.cc:5866 +#: c/c-typeck.cc:5868 #, gcc-internal-format msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>" msgstr "" -#: c/c-typeck.cc:5884 +#: c/c-typeck.cc:5886 #, gcc-internal-format msgid "" "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E" msgstr "" -#: c/c-typeck.cc:5889 +#: c/c-typeck.cc:5891 #, gcc-internal-format msgid "" "ignoring return value of type %qT, declared with attribute %<nodiscard%>" msgstr "" -#: c/c-typeck.cc:5898 cp/cvt.cc:1116 rust/backend/rust-tree.cc:640 +#: c/c-typeck.cc:5900 cp/cvt.cc:1116 rust/backend/rust-tree.cc:640 #, gcc-internal-format msgid "in call to %qD, declared here" msgstr "" -#: c/c-typeck.cc:5947 +#: c/c-typeck.cc:5949 #, gcc-internal-format msgid "left-hand operand of comma expression has no effect" msgstr "" -#: c/c-typeck.cc:5965 c/c-typeck.cc:11905 +#: c/c-typeck.cc:5967 c/c-typeck.cc:11907 #, gcc-internal-format msgid "right-hand operand of comma expression has no effect" msgstr "" -#: c/c-typeck.cc:6036 +#: c/c-typeck.cc:6038 msgid "cast adds %q#v qualifier to function type" msgstr "" -#: c/c-typeck.cc:6042 +#: c/c-typeck.cc:6044 msgid "cast discards %qv qualifier from pointer target type" msgstr "" -#: c/c-typeck.cc:6077 +#: c/c-typeck.cc:6079 #, gcc-internal-format msgid "" "to be safe all intermediate pointers in cast from %qT to %qT must be " "%<const%> qualified" msgstr "" -#: c/c-typeck.cc:6174 +#: c/c-typeck.cc:6176 #, gcc-internal-format msgid "cast specifies array type" msgstr "" -#: c/c-typeck.cc:6180 +#: c/c-typeck.cc:6182 #, gcc-internal-format msgid "cast specifies function type" msgstr "" -#: c/c-typeck.cc:6195 +#: c/c-typeck.cc:6197 #, gcc-internal-format msgid "ISO C forbids casting nonscalar to the same type" msgstr "" -#: c/c-typeck.cc:6199 +#: c/c-typeck.cc:6201 #, gcc-internal-format msgid "useless cast to type %qT" msgstr "" -#: c/c-typeck.cc:6219 +#: c/c-typeck.cc:6221 #, gcc-internal-format msgid "ISO C forbids casts to union type" msgstr "" -#: c/c-typeck.cc:6229 +#: c/c-typeck.cc:6231 #, gcc-internal-format msgid "cast to union type from type not present in union" msgstr "" -#: c/c-typeck.cc:6264 +#: c/c-typeck.cc:6266 #, gcc-internal-format msgid "" "cast to %qs address space pointer from disjoint generic address space pointer" msgstr "" -#: c/c-typeck.cc:6269 +#: c/c-typeck.cc:6271 #, gcc-internal-format msgid "" "cast to generic address space pointer from disjoint %qs address space pointer" msgstr "" -#: c/c-typeck.cc:6274 +#: c/c-typeck.cc:6276 #, gcc-internal-format msgid "" "cast to %qs address space pointer from disjoint %qs address space pointer" msgstr "" -#: c/c-typeck.cc:6307 +#: c/c-typeck.cc:6309 #, gcc-internal-format msgid "cast increases required alignment of target type" msgstr "" -#: c/c-typeck.cc:6319 +#: c/c-typeck.cc:6321 #, gcc-internal-format msgid "cast from pointer to integer of different size" msgstr "" -#: c/c-typeck.cc:6324 +#: c/c-typeck.cc:6326 #, gcc-internal-format msgid "cast from function call of type %qT to non-matching type %qT" msgstr "" -#: c/c-typeck.cc:6334 cp/typeck.cc:9295 +#: c/c-typeck.cc:6336 cp/typeck.cc:9295 #, gcc-internal-format msgid "cast to pointer from integer of different size" msgstr "" -#: c/c-typeck.cc:6348 +#: c/c-typeck.cc:6350 #, gcc-internal-format msgid "ISO C forbids conversion of function pointer to object pointer type" msgstr "" -#: c/c-typeck.cc:6357 +#: c/c-typeck.cc:6359 #, gcc-internal-format msgid "ISO C forbids conversion of object pointer to function pointer type" msgstr "" -#: c/c-typeck.cc:6367 +#: c/c-typeck.cc:6369 #, gcc-internal-format msgid "cast between incompatible function types from %qT to %qT" msgstr "" -#: c/c-typeck.cc:6479 +#: c/c-typeck.cc:6481 #, gcc-internal-format msgid "defining a type in a cast is invalid in C++" msgstr "" -#: c/c-typeck.cc:6520 +#: c/c-typeck.cc:6522 #, gcc-internal-format msgid "assignment to expression with array type" msgstr "" -#: c/c-typeck.cc:6646 +#: c/c-typeck.cc:6648 #, gcc-internal-format msgid "enum conversion in assignment is invalid in C++" msgstr "" -#: c/c-typeck.cc:6848 c/c-typeck.cc:6865 c/c-typeck.cc:6916 +#: c/c-typeck.cc:6850 c/c-typeck.cc:6867 c/c-typeck.cc:6918 #, gcc-internal-format msgid "(near initialization for %qs)" msgstr "" -#: c/c-typeck.cc:6931 +#: c/c-typeck.cc:6933 #, gcc-internal-format msgid "array initialized from parenthesized string constant" msgstr "" -#: c/c-typeck.cc:6974 c/c-typeck.cc:7215 +#: c/c-typeck.cc:6976 c/c-typeck.cc:7217 #, gcc-internal-format msgid "expected %qT but argument is of type %qT" msgstr "" -#: c/c-typeck.cc:7008 +#: c/c-typeck.cc:7010 #, gcc-internal-format msgid "" "%qD argument %d type is %qT where %qT is expected in a call to built-in " "function declared without prototype" msgstr "" -#: c/c-typeck.cc:7011 +#: c/c-typeck.cc:7013 #, gcc-internal-format msgid "" "%qD argument %d promotes to %qT where %qT is expected in a call to built-in " "function declared without prototype" msgstr "" -#: c/c-typeck.cc:7016 +#: c/c-typeck.cc:7018 #, gcc-internal-format msgid "built-in %qD declared here" msgstr "" -#: c/c-typeck.cc:7210 +#: c/c-typeck.cc:7212 #, gcc-internal-format msgid "enum conversion when passing argument %d of %qE is invalid in C++" msgstr "" -#: c/c-typeck.cc:7219 +#: c/c-typeck.cc:7221 #, gcc-internal-format msgid "enum conversion from %qT to %qT in assignment is invalid in C++" msgstr "" -#: c/c-typeck.cc:7224 +#: c/c-typeck.cc:7226 #, gcc-internal-format msgid "enum conversion from %qT to %qT in initialization is invalid in C++" msgstr "" -#: c/c-typeck.cc:7229 +#: c/c-typeck.cc:7231 #, gcc-internal-format msgid "enum conversion from %qT to %qT in return is invalid in C++" msgstr "" -#: c/c-typeck.cc:7247 +#: c/c-typeck.cc:7249 #, gcc-internal-format msgid "implicit conversion from %qT to %qT" msgstr "" -#: c/c-typeck.cc:7426 c/c-typeck.cc:7824 +#: c/c-typeck.cc:7428 c/c-typeck.cc:7826 msgid "" "passing argument %d of %qE makes %q#v qualified function pointer from " "unqualified" msgstr "" -#: c/c-typeck.cc:7429 c/c-typeck.cc:7827 +#: c/c-typeck.cc:7431 c/c-typeck.cc:7829 msgid "assignment makes %q#v qualified function pointer from unqualified" msgstr "" -#: c/c-typeck.cc:7432 c/c-typeck.cc:7829 +#: c/c-typeck.cc:7434 c/c-typeck.cc:7831 msgid "initialization makes %q#v qualified function pointer from unqualified" msgstr "" -#: c/c-typeck.cc:7435 c/c-typeck.cc:7831 +#: c/c-typeck.cc:7437 c/c-typeck.cc:7833 msgid "return makes %q#v qualified function pointer from unqualified" msgstr "" -#: c/c-typeck.cc:7443 c/c-typeck.cc:7715 c/c-typeck.cc:7758 +#: c/c-typeck.cc:7445 c/c-typeck.cc:7717 c/c-typeck.cc:7760 msgid "" "passing argument %d of %qE discards %qv qualifier from pointer target type" msgstr "" -#: c/c-typeck.cc:7445 c/c-typeck.cc:7717 c/c-typeck.cc:7760 +#: c/c-typeck.cc:7447 c/c-typeck.cc:7719 c/c-typeck.cc:7762 msgid "assignment discards %qv qualifier from pointer target type" msgstr "" -#: c/c-typeck.cc:7447 c/c-typeck.cc:7719 c/c-typeck.cc:7762 +#: c/c-typeck.cc:7449 c/c-typeck.cc:7721 c/c-typeck.cc:7764 msgid "initialization discards %qv qualifier from pointer target type" msgstr "" -#: c/c-typeck.cc:7449 c/c-typeck.cc:7721 c/c-typeck.cc:7764 +#: c/c-typeck.cc:7451 c/c-typeck.cc:7723 c/c-typeck.cc:7766 msgid "return discards %qv qualifier from pointer target type" msgstr "" -#: c/c-typeck.cc:7458 +#: c/c-typeck.cc:7460 #, gcc-internal-format msgid "ISO C prohibits argument conversion to union type" msgstr "" -#: c/c-typeck.cc:7526 +#: c/c-typeck.cc:7528 #, gcc-internal-format msgid "request for implicit conversion from %qT to %qT not permitted in C++" msgstr "" -#: c/c-typeck.cc:7553 +#: c/c-typeck.cc:7555 #, gcc-internal-format msgid "passing argument %d of %qE from pointer to non-enclosed address space" msgstr "" -#: c/c-typeck.cc:7564 +#: c/c-typeck.cc:7566 #, gcc-internal-format msgid "assignment from pointer to non-enclosed address space" msgstr "" -#: c/c-typeck.cc:7575 +#: c/c-typeck.cc:7577 #, gcc-internal-format msgid "initialization from pointer to non-enclosed address space" msgstr "" -#: c/c-typeck.cc:7585 +#: c/c-typeck.cc:7587 #, gcc-internal-format msgid "return from pointer to non-enclosed address space" msgstr "" -#: c/c-typeck.cc:7601 +#: c/c-typeck.cc:7603 #, gcc-internal-format msgid "expected %qT but pointer is of type %qT" msgstr "" -#: c/c-typeck.cc:7616 +#: c/c-typeck.cc:7618 #, gcc-internal-format msgid "argument %d of %qE might be a candidate for a format attribute" msgstr "" -#: c/c-typeck.cc:7622 +#: c/c-typeck.cc:7624 #, gcc-internal-format msgid "assignment left-hand side might be a candidate for a format attribute" msgstr "" -#: c/c-typeck.cc:7628 +#: c/c-typeck.cc:7630 #, gcc-internal-format msgid "" "initialization left-hand side might be a candidate for a format attribute" msgstr "" -#: c/c-typeck.cc:7633 cp/typeck.cc:10458 +#: c/c-typeck.cc:7635 cp/typeck.cc:10458 #, gcc-internal-format msgid "return type might be a candidate for a format attribute" msgstr "" -#: c/c-typeck.cc:7657 +#: c/c-typeck.cc:7659 #, gcc-internal-format msgid "passing argument %d of %qE from incompatible scalar storage order" msgstr "" -#: c/c-typeck.cc:7667 +#: c/c-typeck.cc:7669 #, gcc-internal-format msgid "" "assignment to %qT from pointer type %qT with incompatible scalar storage " "order" msgstr "" -#: c/c-typeck.cc:7677 +#: c/c-typeck.cc:7679 #, gcc-internal-format msgid "" "initialization of %qT from pointer type %qT with incompatible scalar storage " "order" msgstr "" -#: c/c-typeck.cc:7682 +#: c/c-typeck.cc:7684 #, gcc-internal-format msgid "" "returning %qT from pointer type with incompatible scalar storage order %qT" msgstr "" -#: c/c-typeck.cc:7732 +#: c/c-typeck.cc:7734 #, gcc-internal-format msgid "" "ISO C forbids passing argument %d of %qE between function pointer and %<void " "*%>" msgstr "" -#: c/c-typeck.cc:7735 +#: c/c-typeck.cc:7737 #, gcc-internal-format msgid "ISO C forbids assignment between function pointer and %<void *%>" msgstr "" -#: c/c-typeck.cc:7737 +#: c/c-typeck.cc:7739 #, gcc-internal-format msgid "ISO C forbids initialization between function pointer and %<void *%>" msgstr "" -#: c/c-typeck.cc:7739 +#: c/c-typeck.cc:7741 #, gcc-internal-format msgid "ISO C forbids return between function pointer and %<void *%>" msgstr "" -#: c/c-typeck.cc:7769 +#: c/c-typeck.cc:7771 #, gcc-internal-format msgid "array with qualifier on the element is not qualified before C23" msgstr "" -#: c/c-typeck.cc:7786 +#: c/c-typeck.cc:7788 #, gcc-internal-format msgid "pointer targets in passing argument %d of %qE differ in signedness" msgstr "" -#: c/c-typeck.cc:7794 +#: c/c-typeck.cc:7796 #, gcc-internal-format msgid "pointer targets in assignment from %qT to %qT differ in signedness" msgstr "" -#: c/c-typeck.cc:7800 +#: c/c-typeck.cc:7802 #, gcc-internal-format msgid "pointer targets in initialization of %qT from %qT differ in signedness" msgstr "" -#: c/c-typeck.cc:7805 +#: c/c-typeck.cc:7807 #, gcc-internal-format msgid "" "pointer targets in returning %qT from a function with return type %qT differ " "in signedness" msgstr "" -#: c/c-typeck.cc:7847 +#: c/c-typeck.cc:7849 #, gcc-internal-format msgid "passing argument %d of %qE from incompatible pointer type" msgstr "" -#: c/c-typeck.cc:7856 +#: c/c-typeck.cc:7858 #, gcc-internal-format msgid "assignment to %qT from pointer to %qD with incompatible type %qT" msgstr "" -#: c/c-typeck.cc:7861 +#: c/c-typeck.cc:7863 #, gcc-internal-format msgid "assignment to %qT from incompatible pointer type %qT" msgstr "" -#: c/c-typeck.cc:7868 +#: c/c-typeck.cc:7870 #, gcc-internal-format msgid "initialization of %qT from pointer to %qD with incompatible type %qT" msgstr "" -#: c/c-typeck.cc:7873 +#: c/c-typeck.cc:7875 #, gcc-internal-format msgid "initialization of %qT from incompatible pointer type %qT" msgstr "" -#: c/c-typeck.cc:7880 +#: c/c-typeck.cc:7882 #, gcc-internal-format msgid "" "returning pointer to %qD of type %qT from a function with incompatible type " "%qT" msgstr "" -#: c/c-typeck.cc:7885 +#: c/c-typeck.cc:7887 #, gcc-internal-format msgid "returning %qT from a function with incompatible return type %qT" msgstr "" -#: c/c-typeck.cc:7927 +#: c/c-typeck.cc:7929 #, gcc-internal-format msgid "passing argument %d of %qE makes pointer from integer without a cast" msgstr "" -#: c/c-typeck.cc:7934 +#: c/c-typeck.cc:7936 #, gcc-internal-format msgid "assignment to %qT from %qT makes pointer from integer without a cast" msgstr "" -#: c/c-typeck.cc:7940 +#: c/c-typeck.cc:7942 #, gcc-internal-format msgid "" "initialization of %qT from %qT makes pointer from integer without a cast" msgstr "" -#: c/c-typeck.cc:7945 +#: c/c-typeck.cc:7947 #, gcc-internal-format msgid "" "returning %qT from a function with return type %qT makes pointer from " "integer without a cast" msgstr "" -#: c/c-typeck.cc:7966 +#: c/c-typeck.cc:7968 #, gcc-internal-format msgid "passing argument %d of %qE makes integer from pointer without a cast" msgstr "" -#: c/c-typeck.cc:7973 +#: c/c-typeck.cc:7975 #, gcc-internal-format msgid "assignment to %qT from %qT makes integer from pointer without a cast" msgstr "" -#: c/c-typeck.cc:7979 +#: c/c-typeck.cc:7981 #, gcc-internal-format msgid "" "initialization of %qT from %qT makes integer from pointer without a cast" msgstr "" -#: c/c-typeck.cc:7983 +#: c/c-typeck.cc:7985 #, gcc-internal-format msgid "" "returning %qT from a function with return type %qT makes integer from " "pointer without a cast" msgstr "" -#: c/c-typeck.cc:8015 +#: c/c-typeck.cc:8017 #, gcc-internal-format msgid "incompatible type for argument %d of %qE" msgstr "" -#: c/c-typeck.cc:8026 +#: c/c-typeck.cc:8028 #, gcc-internal-format msgid "incompatible types when assigning to type %qT from type %qT" msgstr "" -#: c/c-typeck.cc:8037 +#: c/c-typeck.cc:8039 #, gcc-internal-format msgid "incompatible types when initializing type %qT using type %qT" msgstr "" -#: c/c-typeck.cc:8047 +#: c/c-typeck.cc:8049 #, gcc-internal-format msgid "incompatible types when returning type %qT but %qT was expected" msgstr "" -#: c/c-typeck.cc:8127 +#: c/c-typeck.cc:8129 #, gcc-internal-format msgid "traditional C rejects automatic aggregate initialization" msgstr "" -#: c/c-typeck.cc:8369 +#: c/c-typeck.cc:8371 #, gcc-internal-format msgid "%<constexpr%> pointer initializer is not null" msgstr "" -#: c/c-typeck.cc:8377 +#: c/c-typeck.cc:8379 #, gcc-internal-format msgid "%<constexpr%> integer initializer is not an integer constant expression" msgstr "" -#: c/c-typeck.cc:8380 c/c-typeck.cc:8442 c/c-typeck.cc:8579 +#: c/c-typeck.cc:8382 c/c-typeck.cc:8444 c/c-typeck.cc:8581 #, gcc-internal-format msgid "%<constexpr%> initializer not representable in type of object" msgstr "" -#: c/c-typeck.cc:8390 +#: c/c-typeck.cc:8392 #, gcc-internal-format msgid "%<constexpr%> initializer is not an arithmetic constant expression" msgstr "" -#: c/c-typeck.cc:8407 +#: c/c-typeck.cc:8409 #, gcc-internal-format msgid "%<constexpr%> initializer for a real type is of complex type" msgstr "" -#: c/c-typeck.cc:8416 +#: c/c-typeck.cc:8418 #, gcc-internal-format msgid "" "%<constexpr%> initializer for a binary floating-point type is of decimal type" msgstr "" -#: c/c-typeck.cc:8544 c/c-typeck.cc:9478 cp/typeck2.cc:1218 +#: c/c-typeck.cc:8546 c/c-typeck.cc:9480 cp/typeck2.cc:1218 #, gcc-internal-format msgid "initialization of a flexible array member" msgstr "" -#: c/c-typeck.cc:8560 cp/typeck2.cc:1235 +#: c/c-typeck.cc:8562 cp/typeck2.cc:1235 #, gcc-internal-format msgid "" "cannot initialize array of %qT from a string literal with type array of %qT" msgstr "" -#: c/c-typeck.cc:8619 +#: c/c-typeck.cc:8621 #, gcc-internal-format msgid "array of inappropriate type initialized from string constant" msgstr "" -#: c/c-typeck.cc:8687 cp/typeck.cc:2534 +#: c/c-typeck.cc:8689 cp/typeck.cc:2534 #, gcc-internal-format msgid "invalid use of non-lvalue array" msgstr "" -#: c/c-typeck.cc:8701 c/c-typeck.cc:8827 c/c-typeck.cc:9563 +#: c/c-typeck.cc:8703 c/c-typeck.cc:8829 c/c-typeck.cc:9565 #, gcc-internal-format msgid "invalid initializer" msgstr "" -#: c/c-typeck.cc:8713 c/c-typeck.cc:8737 c/c-typeck.cc:8740 c/c-typeck.cc:8748 -#: c/c-typeck.cc:8796 c/c-typeck.cc:10342 c/c-typeck.cc:10421 +#: c/c-typeck.cc:8715 c/c-typeck.cc:8739 c/c-typeck.cc:8742 c/c-typeck.cc:8750 +#: c/c-typeck.cc:8798 c/c-typeck.cc:10344 c/c-typeck.cc:10423 #, gcc-internal-format msgid "initializer element is not constant" msgstr "" -#: c/c-typeck.cc:8722 +#: c/c-typeck.cc:8724 #, gcc-internal-format msgid "array initialized from non-constant array expression" msgstr "" -#: c/c-typeck.cc:8753 c/c-typeck.cc:8809 c/c-typeck.cc:10431 +#: c/c-typeck.cc:8755 c/c-typeck.cc:8811 c/c-typeck.cc:10433 #, gcc-internal-format msgid "initializer element is not a constant expression" msgstr "" -#: c/c-typeck.cc:8803 c/c-typeck.cc:10426 +#: c/c-typeck.cc:8805 c/c-typeck.cc:10428 #, gcc-internal-format msgid "initializer element is not computable at load time" msgstr "" -#: c/c-typeck.cc:9105 cp/decl.cc:7691 +#: c/c-typeck.cc:9107 cp/decl.cc:7691 #, gcc-internal-format msgid "opaque vector types cannot be initialized" msgstr "" -#: c/c-typeck.cc:9325 +#: c/c-typeck.cc:9327 #, gcc-internal-format msgid "extra brace group at end of initializer" msgstr "" -#: c/c-typeck.cc:9408 +#: c/c-typeck.cc:9410 #, gcc-internal-format msgid "braces around scalar initializer" msgstr "" -#: c/c-typeck.cc:9475 c/c-typeck.cc:10964 cp/typeck2.cc:1245 cp/typeck2.cc:1603 +#: c/c-typeck.cc:9477 c/c-typeck.cc:10966 cp/typeck2.cc:1245 cp/typeck2.cc:1580 #, gcc-internal-format msgid "initialization of flexible array member in a nested context" msgstr "" -#: c/c-typeck.cc:9512 +#: c/c-typeck.cc:9514 #, gcc-internal-format msgid "missing braces around initializer" msgstr "" -#: c/c-typeck.cc:9535 +#: c/c-typeck.cc:9537 #, gcc-internal-format msgid "missing initializer for field %qD of %qT" msgstr "" -#: c/c-typeck.cc:9575 +#: c/c-typeck.cc:9577 #, gcc-internal-format msgid "extra elements in scalar initializer" msgstr "" -#: c/c-typeck.cc:9694 c/c-typeck.cc:9776 +#: c/c-typeck.cc:9696 c/c-typeck.cc:9778 #, gcc-internal-format msgid "array index in non-array initializer" msgstr "" -#: c/c-typeck.cc:9699 c/c-typeck.cc:9838 +#: c/c-typeck.cc:9701 c/c-typeck.cc:9840 #, gcc-internal-format msgid "field name not in record or union initializer" msgstr "" -#: c/c-typeck.cc:9749 +#: c/c-typeck.cc:9751 #, gcc-internal-format msgid "array index in initializer not of integer type" msgstr "" -#: c/c-typeck.cc:9758 c/c-typeck.cc:9767 +#: c/c-typeck.cc:9760 c/c-typeck.cc:9769 #, gcc-internal-format msgid "array index in initializer is not an integer constant expression" msgstr "" -#: c/c-typeck.cc:9772 c/c-typeck.cc:9774 +#: c/c-typeck.cc:9774 c/c-typeck.cc:9776 #, gcc-internal-format msgid "nonconstant array index in initializer" msgstr "" -#: c/c-typeck.cc:9778 c/c-typeck.cc:9781 +#: c/c-typeck.cc:9780 c/c-typeck.cc:9783 #, gcc-internal-format msgid "array index in initializer exceeds array bounds" msgstr "" -#: c/c-typeck.cc:9800 +#: c/c-typeck.cc:9802 #, gcc-internal-format msgid "empty index range in initializer" msgstr "" -#: c/c-typeck.cc:9809 +#: c/c-typeck.cc:9811 #, gcc-internal-format msgid "array index range in initializer exceeds array bounds" msgstr "" -#: c/c-typeck.cc:9911 c/c-typeck.cc:9941 c/c-typeck.cc:10519 +#: c/c-typeck.cc:9913 c/c-typeck.cc:9943 c/c-typeck.cc:10521 #, gcc-internal-format msgid "initialized field with side-effects overwritten" msgstr "" -#: c/c-typeck.cc:9915 c/c-typeck.cc:9945 c/c-typeck.cc:10522 +#: c/c-typeck.cc:9917 c/c-typeck.cc:9947 c/c-typeck.cc:10524 #, gcc-internal-format msgid "initialized field overwritten" msgstr "" -#: c/c-typeck.cc:10453 +#: c/c-typeck.cc:10455 #, gcc-internal-format msgid "enum conversion in initialization is invalid in C++" msgstr "" -#: c/c-typeck.cc:10834 +#: c/c-typeck.cc:10836 #, gcc-internal-format msgid "excess elements in %qT initializer" msgstr "" -#: c/c-typeck.cc:10846 c/c-typeck.cc:10923 +#: c/c-typeck.cc:10848 c/c-typeck.cc:10925 #, gcc-internal-format msgid "excess elements in struct initializer" msgstr "" -#: c/c-typeck.cc:10867 +#: c/c-typeck.cc:10869 #, gcc-internal-format msgid "" "positional initialization of field in %<struct%> declared with " "%<designated_init%> attribute" msgstr "" -#: c/c-typeck.cc:10938 cp/typeck2.cc:1222 +#: c/c-typeck.cc:10940 cp/typeck2.cc:1222 #, gcc-internal-format msgid "non-static initialization of a flexible array member" msgstr "" -#: c/c-typeck.cc:11033 +#: c/c-typeck.cc:11035 #, gcc-internal-format msgid "excess elements in union initializer" msgstr "" -#: c/c-typeck.cc:11055 +#: c/c-typeck.cc:11057 #, gcc-internal-format msgid "traditional C rejects initialization of unions" msgstr "" -#: c/c-typeck.cc:11117 +#: c/c-typeck.cc:11119 #, gcc-internal-format msgid "excess elements in array initializer" msgstr "" -#: c/c-typeck.cc:11151 +#: c/c-typeck.cc:11153 #, gcc-internal-format msgid "excess elements in vector initializer" msgstr "" -#: c/c-typeck.cc:11183 +#: c/c-typeck.cc:11185 #, gcc-internal-format msgid "excess elements in scalar initializer" msgstr "" -#: c/c-typeck.cc:11426 +#: c/c-typeck.cc:11428 #, gcc-internal-format msgid "ISO C forbids %<goto *expr;%>" msgstr "" -#: c/c-typeck.cc:11432 +#: c/c-typeck.cc:11434 #, gcc-internal-format msgid "computed goto must be pointer type" msgstr "" -#: c/c-typeck.cc:11461 c/gimple-parser.cc:2562 cp/typeck.cc:11059 +#: c/c-typeck.cc:11463 c/gimple-parser.cc:2562 cp/typeck.cc:11059 #, gcc-internal-format msgid "function declared %<noreturn%> has a %<return%> statement" msgstr "" -#: c/c-typeck.cc:11488 +#: c/c-typeck.cc:11490 #, gcc-internal-format msgid "%<return%> with no value, in function returning non-void" msgstr "" -#: c/c-typeck.cc:11501 c/gimple-parser.cc:2572 +#: c/c-typeck.cc:11503 c/gimple-parser.cc:2572 #, gcc-internal-format msgid "%<return%> with a value, in function returning void" msgstr "" -#: c/c-typeck.cc:11504 +#: c/c-typeck.cc:11506 #, gcc-internal-format msgid "ISO C forbids %<return%> with expression, in function returning void" msgstr "" -#: c/c-typeck.cc:11581 +#: c/c-typeck.cc:11583 #, gcc-internal-format msgid "function returns address of label" msgstr "" -#: c/c-typeck.cc:11672 cp/semantics.cc:1702 +#: c/c-typeck.cc:11674 cp/semantics.cc:1706 #, gcc-internal-format msgid "switch quantity not an integer" msgstr "" -#: c/c-typeck.cc:11697 +#: c/c-typeck.cc:11699 #, gcc-internal-format msgid "%<long%> switch expression not converted to %<int%> in ISO C" msgstr "" -#: c/c-typeck.cc:11735 c/c-typeck.cc:11743 +#: c/c-typeck.cc:11737 c/c-typeck.cc:11745 #, gcc-internal-format msgid "case label is not an integer constant expression" msgstr "" -#: c/c-typeck.cc:11749 cp/parser.cc:13099 +#: c/c-typeck.cc:11751 cp/parser.cc:13099 #, gcc-internal-format msgid "case label not within a switch statement" msgstr "" -#: c/c-typeck.cc:11751 +#: c/c-typeck.cc:11753 #, gcc-internal-format msgid "%<default%> label not within a switch statement" msgstr "" -#: c/c-typeck.cc:11827 cp/parser.cc:14819 +#: c/c-typeck.cc:11829 cp/parser.cc:14819 #, gcc-internal-format msgid "break statement not within loop or switch" msgstr "" -#: c/c-typeck.cc:11830 c/c-typeck.cc:11850 cp/decl.cc:4052 cp/parser.cc:14829 +#: c/c-typeck.cc:11832 c/c-typeck.cc:11852 cp/decl.cc:4052 cp/parser.cc:14829 #: cp/parser.cc:14850 #, gcc-internal-format msgid "invalid exit from OpenMP structured block" msgstr "" -#: c/c-typeck.cc:11833 cp/parser.cc:14832 +#: c/c-typeck.cc:11835 cp/parser.cc:14832 #, gcc-internal-format msgid "break statement used with OpenMP for loop" msgstr "" -#: c/c-typeck.cc:11847 cp/parser.cc:14842 +#: c/c-typeck.cc:11849 cp/parser.cc:14842 #, gcc-internal-format msgid "continue statement not within a loop" msgstr "" -#: c/c-typeck.cc:11887 cp/cp-gimplify.cc:272 +#: c/c-typeck.cc:11889 cp/cp-gimplify.cc:272 #, gcc-internal-format msgid "statement with no effect" msgstr "" -#: c/c-typeck.cc:11931 +#: c/c-typeck.cc:11933 #, gcc-internal-format msgid "expression statement has incomplete type" msgstr "" -#: c/c-typeck.cc:12222 +#: c/c-typeck.cc:12224 #, gcc-internal-format msgid "" "the comparison will always evaluate as %<false%> for the pointer operand in " "%qE must not be NULL" msgstr "" -#: c/c-typeck.cc:12227 +#: c/c-typeck.cc:12229 #, gcc-internal-format msgid "" "the comparison will always evaluate as %<true%> for the pointer operand in " "%qE must not be NULL" msgstr "" -#: c/c-typeck.cc:12245 c/c-typeck.cc:12283 +#: c/c-typeck.cc:12247 c/c-typeck.cc:12285 #, gcc-internal-format msgid "" "the comparison will always evaluate as %<false%> for the address of %qE will " "never be NULL" msgstr "" -#: c/c-typeck.cc:12250 c/c-typeck.cc:12288 +#: c/c-typeck.cc:12252 c/c-typeck.cc:12290 #, gcc-internal-format msgid "" "the comparison will always evaluate as %<true%> for the address of %qE will " "never be NULL" msgstr "" -#: c/c-typeck.cc:12880 c/c-typeck.cc:13044 cp/typeck.cc:6086 +#: c/c-typeck.cc:12882 c/c-typeck.cc:13046 cp/typeck.cc:6086 #, gcc-internal-format msgid "comparing vectors with different element types" msgstr "" -#: c/c-typeck.cc:12888 c/c-typeck.cc:13052 cp/typeck.cc:6099 +#: c/c-typeck.cc:12890 c/c-typeck.cc:13054 cp/typeck.cc:6099 #, gcc-internal-format msgid "comparing vectors with different number of elements" msgstr "" -#: c/c-typeck.cc:12903 c/c-typeck.cc:13067 cp/typeck.cc:6117 +#: c/c-typeck.cc:12905 c/c-typeck.cc:13069 cp/typeck.cc:6117 #, gcc-internal-format msgid "comparison between types %qT and %qT" msgstr "" -#: c/c-typeck.cc:12913 c/c-typeck.cc:13077 cp/typeck.cc:6134 +#: c/c-typeck.cc:12915 c/c-typeck.cc:13079 cp/typeck.cc:6134 #, gcc-internal-format msgid "could not find an integer type of the same size as %qT" msgstr "" -#: c/c-typeck.cc:12927 cp/typeck.cc:5770 +#: c/c-typeck.cc:12929 cp/typeck.cc:5770 #, gcc-internal-format msgid "comparing floating-point with %<==%> or %<!=%> is unsafe" msgstr "" -#: c/c-typeck.cc:12966 c/c-typeck.cc:13118 +#: c/c-typeck.cc:12968 c/c-typeck.cc:13120 #, gcc-internal-format msgid "comparison of pointers to disjoint address spaces" msgstr "" -#: c/c-typeck.cc:12973 c/c-typeck.cc:12979 +#: c/c-typeck.cc:12975 c/c-typeck.cc:12981 #, gcc-internal-format msgid "ISO C forbids comparison of %<void *%> with function pointer" msgstr "" -#: c/c-typeck.cc:12986 c/c-typeck.cc:13128 +#: c/c-typeck.cc:12988 c/c-typeck.cc:13130 #, gcc-internal-format msgid "comparison of distinct pointer types lacks a cast" msgstr "" -#: c/c-typeck.cc:12999 c/c-typeck.cc:13005 c/c-typeck.cc:13155 -#: c/c-typeck.cc:13161 +#: c/c-typeck.cc:13001 c/c-typeck.cc:13007 c/c-typeck.cc:13157 +#: c/c-typeck.cc:13163 #, gcc-internal-format msgid "comparison between pointer and integer" msgstr "" -#: c/c-typeck.cc:13106 +#: c/c-typeck.cc:13108 #, gcc-internal-format msgid "comparison of complete and incomplete pointers" msgstr "" -#: c/c-typeck.cc:13108 +#: c/c-typeck.cc:13110 #, gcc-internal-format msgid "ISO C forbids ordered comparisons of pointers to functions" msgstr "" -#: c/c-typeck.cc:13113 +#: c/c-typeck.cc:13115 #, gcc-internal-format msgid "ordered comparison of pointer with null pointer" msgstr "" -#: c/c-typeck.cc:13136 c/c-typeck.cc:13139 c/c-typeck.cc:13146 -#: c/c-typeck.cc:13149 +#: c/c-typeck.cc:13138 c/c-typeck.cc:13141 c/c-typeck.cc:13148 +#: c/c-typeck.cc:13151 #, gcc-internal-format msgid "ordered comparison of pointer with integer zero" msgstr "" -#: c/c-typeck.cc:13226 +#: c/c-typeck.cc:13228 #, gcc-internal-format msgid "" "implicit conversion from %qT to %qT to match other operand of binary " "expression" msgstr "" -#: c/c-typeck.cc:13544 +#: c/c-typeck.cc:13546 #, gcc-internal-format msgid "used array that cannot be converted to pointer where scalar is required" msgstr "" -#: c/c-typeck.cc:13548 +#: c/c-typeck.cc:13550 #, gcc-internal-format msgid "used struct type value where scalar is required" msgstr "" -#: c/c-typeck.cc:13552 +#: c/c-typeck.cc:13554 #, gcc-internal-format msgid "used union type value where scalar is required" msgstr "" -#: c/c-typeck.cc:13568 +#: c/c-typeck.cc:13570 #, gcc-internal-format msgid "used vector type where scalar is required" msgstr "" -#: c/c-typeck.cc:13771 cp/semantics.cc:11389 +#: c/c-typeck.cc:13773 cp/semantics.cc:11393 #, gcc-internal-format msgid "" "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, " "%<sections%> or %<taskgroup%> clauses" msgstr "" -#: c/c-typeck.cc:13782 c/c-typeck.cc:13792 cp/semantics.cc:11400 -#: cp/semantics.cc:11410 +#: c/c-typeck.cc:13784 c/c-typeck.cc:13794 cp/semantics.cc:11404 +#: cp/semantics.cc:11414 #, gcc-internal-format msgid "expected %<cancel%> %<if%> clause modifier" msgstr "" -#: c/c-typeck.cc:13827 cp/semantics.cc:11445 +#: c/c-typeck.cc:13829 cp/semantics.cc:11449 #, gcc-internal-format msgid "" "%<#pragma omp cancellation point%> must specify one of %<parallel%>, " "%<for%>, %<sections%> or %<taskgroup%> clauses" msgstr "" -#: c/c-typeck.cc:13895 cp/semantics.cc:5550 cp/semantics.cc:8558 +#: c/c-typeck.cc:13897 cp/semantics.cc:5554 cp/semantics.cc:8562 #, gcc-internal-format msgid "%qD is not a variable in %qs clause" msgstr "" -#: c/c-typeck.cc:13899 c/c-typeck.cc:15706 cp/semantics.cc:5554 -#: cp/semantics.cc:8562 +#: c/c-typeck.cc:13901 c/c-typeck.cc:15708 cp/semantics.cc:5558 +#: cp/semantics.cc:8566 #, gcc-internal-format msgid "%qE is not a variable in %qs clause" msgstr "" -#: c/c-typeck.cc:13907 +#: c/c-typeck.cc:13909 #, gcc-internal-format msgid "%<_Atomic%> %qD in %qs clause" msgstr "" -#: c/c-typeck.cc:13917 c/c-typeck.cc:15713 c/c-typeck.cc:15867 -#: cp/semantics.cc:5563 cp/semantics.cc:8569 cp/semantics.cc:8757 +#: c/c-typeck.cc:13919 c/c-typeck.cc:15715 c/c-typeck.cc:15869 +#: cp/semantics.cc:5567 cp/semantics.cc:8573 cp/semantics.cc:8761 #, gcc-internal-format msgid "%qD is threadprivate variable in %qs clause" msgstr "" -#: c/c-typeck.cc:13954 cp/semantics.cc:5597 +#: c/c-typeck.cc:13956 cp/semantics.cc:5601 #, gcc-internal-format msgid "low bound %qE of array section does not have integral type" msgstr "" -#: c/c-typeck.cc:13961 cp/semantics.cc:5604 +#: c/c-typeck.cc:13963 cp/semantics.cc:5608 #, gcc-internal-format msgid "length %qE of array section does not have integral type" msgstr "" -#: c/c-typeck.cc:13984 cp/semantics.cc:5637 +#: c/c-typeck.cc:13986 cp/semantics.cc:5641 #, gcc-internal-format msgid "expected single pointer in %qs clause" msgstr "" -#: c/c-typeck.cc:14002 c/c-typeck.cc:14069 c/c-typeck.cc:14362 -#: cp/semantics.cc:5655 cp/semantics.cc:5722 +#: c/c-typeck.cc:14004 c/c-typeck.cc:14071 c/c-typeck.cc:14364 +#: cp/semantics.cc:5659 cp/semantics.cc:5726 #, gcc-internal-format msgid "zero length array section in %qs clause" msgstr "" -#: c/c-typeck.cc:14021 cp/semantics.cc:5674 +#: c/c-typeck.cc:14023 cp/semantics.cc:5678 #, gcc-internal-format msgid "for unknown bound array type length expression must be specified" msgstr "" -#: c/c-typeck.cc:14029 cp/semantics.cc:5682 +#: c/c-typeck.cc:14031 cp/semantics.cc:5686 #, gcc-internal-format msgid "negative low bound in array section in %qs clause" msgstr "" -#: c/c-typeck.cc:14038 c/c-typeck.cc:14162 cp/semantics.cc:5691 -#: cp/semantics.cc:5815 +#: c/c-typeck.cc:14040 c/c-typeck.cc:14164 cp/semantics.cc:5695 +#: cp/semantics.cc:5819 #, gcc-internal-format msgid "negative length in array section in %qs clause" msgstr "" -#: c/c-typeck.cc:14055 cp/semantics.cc:5708 +#: c/c-typeck.cc:14057 cp/semantics.cc:5712 #, gcc-internal-format msgid "low bound %qE above array section size in %qs clause" msgstr "" -#: c/c-typeck.cc:14098 cp/semantics.cc:5751 +#: c/c-typeck.cc:14100 cp/semantics.cc:5755 #, gcc-internal-format msgid "length %qE above array section size in %qs clause" msgstr "" -#: c/c-typeck.cc:14113 cp/semantics.cc:5766 +#: c/c-typeck.cc:14115 cp/semantics.cc:5770 #, gcc-internal-format msgid "high bound %qE above array section size in %qs clause" msgstr "" -#: c/c-typeck.cc:14150 cp/semantics.cc:5803 +#: c/c-typeck.cc:14152 cp/semantics.cc:5807 #, gcc-internal-format msgid "for array function parameter length expression must be specified" msgstr "" -#: c/c-typeck.cc:14154 cp/semantics.cc:5807 +#: c/c-typeck.cc:14156 cp/semantics.cc:5811 #, gcc-internal-format msgid "for pointer type length expression must be specified" msgstr "" -#: c/c-typeck.cc:14182 c/c-typeck.cc:14301 cp/semantics.cc:5834 -#: cp/semantics.cc:5970 +#: c/c-typeck.cc:14184 c/c-typeck.cc:14303 cp/semantics.cc:5838 +#: cp/semantics.cc:5974 #, gcc-internal-format msgid "array section is not contiguous in %qs clause" msgstr "" -#: c/c-typeck.cc:14192 cp/semantics.cc:5844 +#: c/c-typeck.cc:14194 cp/semantics.cc:5848 #, gcc-internal-format msgid "%qE does not have pointer or array type" msgstr "" -#: c/c-typeck.cc:14568 cp/semantics.cc:6906 +#: c/c-typeck.cc:14570 cp/semantics.cc:6910 #, gcc-internal-format msgid "iterator %qD has neither integral nor pointer type" msgstr "" -#: c/c-typeck.cc:14575 +#: c/c-typeck.cc:14577 #, gcc-internal-format msgid "iterator %qD has %<_Atomic%> qualified type" msgstr "" -#: c/c-typeck.cc:14581 cp/semantics.cc:6913 +#: c/c-typeck.cc:14583 cp/semantics.cc:6917 #, gcc-internal-format msgid "iterator %qD has const qualified type" msgstr "" -#: c/c-typeck.cc:14594 cp/semantics.cc:6929 +#: c/c-typeck.cc:14596 cp/semantics.cc:6933 #, gcc-internal-format msgid "iterator step with non-integral type" msgstr "" -#: c/c-typeck.cc:14614 cp/semantics.cc:6965 +#: c/c-typeck.cc:14616 cp/semantics.cc:6969 #, gcc-internal-format msgid "iterator %qD has zero step" msgstr "" -#: c/c-typeck.cc:14641 +#: c/c-typeck.cc:14643 #, gcc-internal-format msgid "type of iterator %qD refers to outer iterator %qD" msgstr "" -#: c/c-typeck.cc:14648 cp/semantics.cc:6999 +#: c/c-typeck.cc:14650 cp/semantics.cc:7003 #, gcc-internal-format msgid "begin expression refers to outer iterator %qD" msgstr "" -#: c/c-typeck.cc:14654 cp/semantics.cc:7005 +#: c/c-typeck.cc:14656 cp/semantics.cc:7009 #, gcc-internal-format msgid "end expression refers to outer iterator %qD" msgstr "" -#: c/c-typeck.cc:14660 cp/semantics.cc:7011 +#: c/c-typeck.cc:14662 cp/semantics.cc:7015 #, gcc-internal-format msgid "step expression refers to outer iterator %qD" msgstr "" -#: c/c-typeck.cc:14697 cp/semantics.cc:7059 +#: c/c-typeck.cc:14699 cp/semantics.cc:7063 #, gcc-internal-format msgid "expected pointer in %qs clause" msgstr "" -#: c/c-typeck.cc:14792 cp/semantics.cc:7148 +#: c/c-typeck.cc:14794 cp/semantics.cc:7152 #, gcc-internal-format msgid "" "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct" msgstr "" -#: c/c-typeck.cc:14814 cp/semantics.cc:7168 +#: c/c-typeck.cc:14816 cp/semantics.cc:7172 #, gcc-internal-format msgid "%<inscan%> %<reduction%> clause with array section" msgstr "" -#: c/c-typeck.cc:14840 c/c-typeck.cc:14850 +#: c/c-typeck.cc:14842 c/c-typeck.cc:14852 #, gcc-internal-format msgid "%qD in %<reduction%> clause is a zero size array" msgstr "" -#: c/c-typeck.cc:14870 +#: c/c-typeck.cc:14872 #, gcc-internal-format msgid "%<_Atomic%> %qE in %<reduction%> clause" msgstr "" -#: c/c-typeck.cc:14882 +#: c/c-typeck.cc:14884 #, gcc-internal-format msgid "zero sized type %qT in %qs clause" msgstr "" -#: c/c-typeck.cc:14890 +#: c/c-typeck.cc:14892 #, gcc-internal-format msgid "variable sized type %qT in %qs clause" msgstr "" -#: c/c-typeck.cc:14934 +#: c/c-typeck.cc:14936 #, gcc-internal-format msgid "%qE has invalid type for %<reduction(%s)%>" msgstr "" -#: c/c-typeck.cc:14943 cp/semantics.cc:6798 +#: c/c-typeck.cc:14945 cp/semantics.cc:6802 #, gcc-internal-format msgid "user defined reduction not found for %qE" msgstr "" -#: c/c-typeck.cc:15031 +#: c/c-typeck.cc:15033 #, gcc-internal-format msgid "variable length element type in array %<reduction%> clause" msgstr "" -#: c/c-typeck.cc:15049 c/c-typeck.cc:15961 cp/semantics.cc:9294 +#: c/c-typeck.cc:15051 c/c-typeck.cc:15963 cp/semantics.cc:9298 #, gcc-internal-format msgid "%<nowait%> clause must not be used together with %<copyprivate%>" msgstr "" -#: c/c-typeck.cc:15061 cp/semantics.cc:9362 +#: c/c-typeck.cc:15063 cp/semantics.cc:9366 #, gcc-internal-format msgid "%qE must be %<threadprivate%> for %<copyin%>" msgstr "" -#: c/c-typeck.cc:15076 cp/semantics.cc:7211 +#: c/c-typeck.cc:15078 cp/semantics.cc:7215 #, gcc-internal-format msgid "" "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> " "constructs when not using OpenMP 5.2 modifiers" msgstr "" -#: c/c-typeck.cc:15085 +#: c/c-typeck.cc:15087 #, gcc-internal-format msgid "" "linear clause applied to non-integral non-pointer variable with type %qT" msgstr "" -#: c/c-typeck.cc:15093 +#: c/c-typeck.cc:15095 #, gcc-internal-format msgid "%<_Atomic%> %qD in %<linear%> clause" msgstr "" -#: c/c-typeck.cc:15112 cp/semantics.cc:7295 +#: c/c-typeck.cc:15114 cp/semantics.cc:7299 #, gcc-internal-format msgid "%<linear%> clause step %qE is neither constant nor a parameter" msgstr "" -#: c/c-typeck.cc:15142 c/c-typeck.cc:15861 c/c-typeck.cc:16108 -#: cp/semantics.cc:7382 cp/semantics.cc:8751 cp/semantics.cc:9102 +#: c/c-typeck.cc:15144 c/c-typeck.cc:15863 c/c-typeck.cc:16110 +#: cp/semantics.cc:7386 cp/semantics.cc:8755 cp/semantics.cc:9106 #, gcc-internal-format msgid "%qE is not a variable in clause %qs" msgstr "" -#: c/c-typeck.cc:15159 cp/semantics.cc:7400 +#: c/c-typeck.cc:15161 cp/semantics.cc:7404 #, gcc-internal-format msgid "%qD appears more than once in data-sharing clauses" msgstr "" -#: c/c-typeck.cc:15170 cp/semantics.cc:7411 +#: c/c-typeck.cc:15172 cp/semantics.cc:7415 #, gcc-internal-format msgid "%qD appears more than once in reduction clauses" msgstr "" -#: c/c-typeck.cc:15184 c/c-typeck.cc:15254 c/c-typeck.cc:15289 +#: c/c-typeck.cc:15186 c/c-typeck.cc:15256 c/c-typeck.cc:15291 #, gcc-internal-format msgid "%qE appears more than once in data clauses" msgstr "" -#: c/c-typeck.cc:15194 c/c-typeck.cc:15262 c/c-typeck.cc:15609 -#: c/c-typeck.cc:15761 c/c-typeck.cc:15769 c/c-typeck.cc:15785 -#: c/c-typeck.cc:15794 c/c-typeck.cc:15802 cp/semantics.cc:7425 -#: cp/semantics.cc:7435 cp/semantics.cc:7528 cp/semantics.cc:7536 -#: cp/semantics.cc:7583 cp/semantics.cc:8440 cp/semantics.cc:8629 -#: cp/semantics.cc:8637 cp/semantics.cc:8657 cp/semantics.cc:8666 -#: cp/semantics.cc:8674 +#: c/c-typeck.cc:15196 c/c-typeck.cc:15264 c/c-typeck.cc:15611 +#: c/c-typeck.cc:15763 c/c-typeck.cc:15771 c/c-typeck.cc:15787 +#: c/c-typeck.cc:15796 c/c-typeck.cc:15804 cp/semantics.cc:7429 +#: cp/semantics.cc:7439 cp/semantics.cc:7532 cp/semantics.cc:7540 +#: cp/semantics.cc:7587 cp/semantics.cc:8444 cp/semantics.cc:8633 +#: cp/semantics.cc:8641 cp/semantics.cc:8661 cp/semantics.cc:8670 +#: cp/semantics.cc:8678 #, gcc-internal-format msgid "%qD appears more than once in data clauses" msgstr "" -#: c/c-typeck.cc:15197 c/c-typeck.cc:15268 c/c-typeck.cc:15805 -#: cp/semantics.cc:7438 cp/semantics.cc:7542 cp/semantics.cc:8677 +#: c/c-typeck.cc:15199 c/c-typeck.cc:15270 c/c-typeck.cc:15807 +#: cp/semantics.cc:7442 cp/semantics.cc:7546 cp/semantics.cc:8681 #, gcc-internal-format msgid "%qD appears both in data and map clauses" msgstr "" -#: c/c-typeck.cc:15242 cp/semantics.cc:7515 +#: c/c-typeck.cc:15244 cp/semantics.cc:7519 #, gcc-internal-format msgid "%qE is not a variable in clause %<firstprivate%>" msgstr "" -#: c/c-typeck.cc:15282 cp/semantics.cc:7575 +#: c/c-typeck.cc:15284 cp/semantics.cc:7579 #, gcc-internal-format msgid "%qE is not a variable in clause %<lastprivate%>" msgstr "" -#: c/c-typeck.cc:15301 cp/semantics.cc:7973 +#: c/c-typeck.cc:15303 cp/semantics.cc:7977 #, gcc-internal-format msgid "%qE is not a variable in %<aligned%> clause" msgstr "" -#: c/c-typeck.cc:15308 +#: c/c-typeck.cc:15310 #, gcc-internal-format msgid "%qE in %<aligned%> clause is neither a pointer nor an array" msgstr "" -#: c/c-typeck.cc:15315 +#: c/c-typeck.cc:15317 #, gcc-internal-format msgid "%<_Atomic%> %qD in %<aligned%> clause" msgstr "" -#: c/c-typeck.cc:15322 +#: c/c-typeck.cc:15324 #, gcc-internal-format msgid "%qE appears more than once in %<aligned%> clauses" msgstr "" -#: c/c-typeck.cc:15335 cp/semantics.cc:8044 +#: c/c-typeck.cc:15337 cp/semantics.cc:8048 #, gcc-internal-format msgid "%qE is not a variable in %<nontemporal%> clause" msgstr "" -#: c/c-typeck.cc:15341 +#: c/c-typeck.cc:15343 #, gcc-internal-format msgid "%qE appears more than once in %<nontemporal%> clauses" msgstr "" -#: c/c-typeck.cc:15354 cp/semantics.cc:8083 +#: c/c-typeck.cc:15356 cp/semantics.cc:8087 #, gcc-internal-format msgid "%qE is not a variable in %<allocate%> clause" msgstr "" -#: c/c-typeck.cc:15360 +#: c/c-typeck.cc:15362 #, gcc-internal-format msgid "%qE appears more than once in %<allocate%> clauses" msgstr "" -#: c/c-typeck.cc:15430 cp/semantics.cc:8209 +#: c/c-typeck.cc:15432 cp/semantics.cc:8213 #, gcc-internal-format msgid "%<depend%> clause with %<depobj%> dependence type on array section" msgstr "" -#: c/c-typeck.cc:15445 cp/semantics.cc:8224 +#: c/c-typeck.cc:15447 cp/semantics.cc:8228 #, gcc-internal-format msgid "" "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>" msgstr "" -#: c/c-typeck.cc:15453 cp/semantics.cc:8242 +#: c/c-typeck.cc:15455 cp/semantics.cc:8246 #, gcc-internal-format msgid "%qE is not lvalue expression nor array section in %qs clause" msgstr "" -#: c/c-typeck.cc:15474 cp/semantics.cc:8264 +#: c/c-typeck.cc:15476 cp/semantics.cc:8268 #, gcc-internal-format msgid "" "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> " "dependence type" msgstr "" -#: c/c-typeck.cc:15484 cp/semantics.cc:8276 +#: c/c-typeck.cc:15486 cp/semantics.cc:8280 #, gcc-internal-format msgid "" "%qE should not have %<omp_depend_t%> type in %<depend%> clause with " "dependence type other than %<depobj%>" msgstr "" -#: c/c-typeck.cc:15545 cp/semantics.cc:8375 +#: c/c-typeck.cc:15547 cp/semantics.cc:8379 #, gcc-internal-format msgid "array section does not have mappable type in %qs clause" msgstr "" -#: c/c-typeck.cc:15565 c/c-typeck.cc:15641 c/c-typeck.cc:15677 -#: cp/semantics.cc:8395 cp/semantics.cc:8474 cp/semantics.cc:8510 +#: c/c-typeck.cc:15567 c/c-typeck.cc:15643 c/c-typeck.cc:15679 +#: cp/semantics.cc:8399 cp/semantics.cc:8478 cp/semantics.cc:8514 #, gcc-internal-format msgid "unsupported map expression %qE" msgstr "" -#: c/c-typeck.cc:15605 c/c-typeck.cc:15782 cp/semantics.cc:8436 -#: cp/semantics.cc:8654 +#: c/c-typeck.cc:15607 c/c-typeck.cc:15784 cp/semantics.cc:8440 +#: cp/semantics.cc:8658 #, gcc-internal-format msgid "%qD appears more than once in motion clauses" msgstr "" -#: c/c-typeck.cc:15613 c/c-typeck.cc:15788 cp/semantics.cc:8444 -#: cp/semantics.cc:8660 +#: c/c-typeck.cc:15615 c/c-typeck.cc:15790 cp/semantics.cc:8448 +#: cp/semantics.cc:8664 #, gcc-internal-format msgid "%qD appears more than once in map clauses" msgstr "" -#: c/c-typeck.cc:15732 c/c-typeck.cc:15874 cp/semantics.cc:8597 -#: cp/semantics.cc:8764 +#: c/c-typeck.cc:15734 c/c-typeck.cc:15876 cp/semantics.cc:8601 +#: cp/semantics.cc:8768 #, gcc-internal-format msgid "%qD does not have a mappable type in %qs clause" msgstr "" -#: c/c-typeck.cc:15857 cp/semantics.cc:8746 +#: c/c-typeck.cc:15859 cp/semantics.cc:8750 #, gcc-internal-format msgid "%qE is neither a variable nor a function name in clause %qs" msgstr "" -#: c/c-typeck.cc:15883 cp/semantics.cc:8776 +#: c/c-typeck.cc:15885 cp/semantics.cc:8780 #, gcc-internal-format msgid "%qE appears more than once on the same %<declare target%> directive" msgstr "" -#: c/c-typeck.cc:15897 cp/semantics.cc:8792 +#: c/c-typeck.cc:15899 cp/semantics.cc:8796 #, gcc-internal-format msgid "%qD is not an argument in %<uniform%> clause" msgstr "" -#: c/c-typeck.cc:15900 cp/semantics.cc:8795 +#: c/c-typeck.cc:15902 cp/semantics.cc:8799 #, gcc-internal-format msgid "%qE is not an argument in %<uniform%> clause" msgstr "" -#: c/c-typeck.cc:15919 +#: c/c-typeck.cc:15921 #, gcc-internal-format msgid "%qs variable is not a pointer" msgstr "" -#: c/c-typeck.cc:15926 +#: c/c-typeck.cc:15928 #, gcc-internal-format msgid "%qs variable is neither a pointer nor an array" msgstr "" -#: c/c-typeck.cc:15974 c/c-typeck.cc:16069 cp/semantics.cc:9256 +#: c/c-typeck.cc:15976 c/c-typeck.cc:16071 cp/semantics.cc:9260 #, gcc-internal-format msgid "%<order%> clause must not be used together with %<ordered%>" msgstr "" -#: c/c-typeck.cc:15994 cp/semantics.cc:8316 +#: c/c-typeck.cc:15996 cp/semantics.cc:8320 #, gcc-internal-format msgid "too many %qs clauses on a task construct" msgstr "" -#: c/c-typeck.cc:16091 cp/semantics.cc:9070 +#: c/c-typeck.cc:16093 cp/semantics.cc:9074 #, gcc-internal-format msgid "%<inbranch%> clause is incompatible with %<notinbranch%>" msgstr "" -#: c/c-typeck.cc:16158 cp/semantics.cc:9433 +#: c/c-typeck.cc:16160 cp/semantics.cc:9437 #, gcc-internal-format msgid "%qE is predetermined %qs for %qs" msgstr "" -#: c/c-typeck.cc:16168 +#: c/c-typeck.cc:16170 #, gcc-internal-format msgid "" "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> " "clauses" msgstr "" -#: c/c-typeck.cc:16199 cp/semantics.cc:9208 +#: c/c-typeck.cc:16201 cp/semantics.cc:9212 #, gcc-internal-format msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value" msgstr "" -#: c/c-typeck.cc:16211 cp/semantics.cc:9221 +#: c/c-typeck.cc:16213 cp/semantics.cc:9225 #, gcc-internal-format msgid "" "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause" msgstr "" -#: c/c-typeck.cc:16222 c/c-typeck.cc:16230 cp/semantics.cc:9230 -#: cp/semantics.cc:9248 +#: c/c-typeck.cc:16224 c/c-typeck.cc:16232 cp/semantics.cc:9234 +#: cp/semantics.cc:9252 #, gcc-internal-format msgid "%qs clause specified together with %<inscan%> %<reduction%> clause" msgstr "" -#: c/c-typeck.cc:16278 cp/semantics.cc:9188 +#: c/c-typeck.cc:16280 cp/semantics.cc:9192 #, gcc-internal-format msgid "" "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause" msgstr "" -#: c/c-typeck.cc:16329 cp/semantics.cc:9238 +#: c/c-typeck.cc:16331 cp/semantics.cc:9242 #, gcc-internal-format msgid "%<nogroup%> clause must not be used together with %<reduction%> clause" msgstr "" -#: c/c-typeck.cc:16339 cp/semantics.cc:9267 +#: c/c-typeck.cc:16341 cp/semantics.cc:9271 #, gcc-internal-format msgid "%<detach%> clause must not be used together with %<mergeable%> clause" msgstr "" -#: c/c-typeck.cc:16357 cp/semantics.cc:9458 +#: c/c-typeck.cc:16359 cp/semantics.cc:9462 #, gcc-internal-format msgid "" "the event handle of a %<detach%> clause should not be in a data-sharing " "clause" msgstr "" -#: c/c-typeck.cc:16532 +#: c/c-typeck.cc:16534 #, gcc-internal-format msgid "cannot use %<va_arg%> with reverse storage order" msgstr "" -#: c/c-typeck.cc:16537 +#: c/c-typeck.cc:16539 #, gcc-internal-format msgid "second argument to %<va_arg%> is of incomplete type %qT" msgstr "" -#: c/c-typeck.cc:16543 +#: c/c-typeck.cc:16545 #, gcc-internal-format msgid "second argument to %<va_arg%> is a function type %qT" msgstr "" -#: c/c-typeck.cc:16549 +#: c/c-typeck.cc:16551 #, gcc-internal-format msgid "C++ requires promoted type, not enum type, in %<va_arg%>" msgstr "" @@ -54157,968 +54179,973 @@ msgstr "" msgid "expected case label" msgstr "" +#: cp/call.cc:2041 +#, gcc-internal-format +msgid "casting %qT to %qT does not use %qD" +msgstr "" + #. A bad conversion for 'this' must be discarding cv-quals. -#: cp/call.cc:3865 +#: cp/call.cc:3888 #, gcc-internal-format msgid " passing %qT as %<this%> argument discards qualifiers" msgstr "" -#: cp/call.cc:3869 +#: cp/call.cc:3892 msgid " no known conversion for implicit %<this%> parameter from %qH to %qI" msgstr "" -#: cp/call.cc:3876 +#: cp/call.cc:3899 #, gcc-internal-format, gfc-internal-format msgid " conversion of argument %d would be ill-formed:" msgstr "" #. Conversion of conversion function return value failed. -#: cp/call.cc:3884 +#: cp/call.cc:3907 msgid " no known conversion from %qH to %qI" msgstr "" -#: cp/call.cc:3890 +#: cp/call.cc:3913 msgid " no known conversion for argument %d from %qH to %qI" msgstr "" -#: cp/call.cc:3904 cp/pt.cc:7091 +#: cp/call.cc:3927 cp/pt.cc:7112 #, gcc-internal-format, gfc-internal-format msgid " candidate expects at least %d argument, %d provided" msgid_plural " candidate expects at least %d arguments, %d provided" msgstr[0] "" msgstr[1] "" -#: cp/call.cc:3909 cp/pt.cc:7096 +#: cp/call.cc:3932 cp/pt.cc:7117 #, gcc-internal-format, gfc-internal-format msgid " candidate expects %d argument, %d provided" msgid_plural " candidate expects %d arguments, %d provided" msgstr[0] "" msgstr[1] "" -#: cp/call.cc:3937 +#: cp/call.cc:3960 #, gcc-internal-format msgid "%s%<%D(%T, %T, %T)%> (built-in)" msgstr "" -#: cp/call.cc:3942 +#: cp/call.cc:3965 #, gcc-internal-format msgid "%s%<%D(%T, %T)%> (built-in)" msgstr "" -#: cp/call.cc:3946 +#: cp/call.cc:3969 #, gcc-internal-format msgid "%s%<%D(%T)%> (built-in)" msgstr "" -#: cp/call.cc:3950 +#: cp/call.cc:3973 #, gcc-internal-format msgid "%s%qT (conversion)" msgstr "" -#: cp/call.cc:3952 +#: cp/call.cc:3975 #, gcc-internal-format msgid "%s%#qD (near match)" msgstr "" -#: cp/call.cc:3954 +#: cp/call.cc:3977 #, gcc-internal-format msgid "%s%#qD (ignored)" msgstr "" -#: cp/call.cc:3956 +#: cp/call.cc:3979 #, gcc-internal-format msgid "%s%#qD (deleted)" msgstr "" -#: cp/call.cc:3958 +#: cp/call.cc:3981 #, gcc-internal-format msgid "%s%#qD (reversed)" msgstr "" -#: cp/call.cc:3960 +#: cp/call.cc:3983 #, gcc-internal-format msgid "%s%#qD (rewritten)" msgstr "" -#: cp/call.cc:3962 +#: cp/call.cc:3985 #, gcc-internal-format msgid "%s%#qD" msgstr "" -#: cp/call.cc:3966 +#: cp/call.cc:3989 #, gcc-internal-format msgid " inherited here" msgstr "" -#: cp/call.cc:3987 +#: cp/call.cc:4010 #, gcc-internal-format msgid "" " return type %qT of explicit conversion function cannot be converted to %qT " "with a qualification conversion" msgstr "" -#: cp/call.cc:3993 +#: cp/call.cc:4016 #, gcc-internal-format msgid "" " conversion from return type %qT of template conversion function " "specialization to %qT is not an exact match" msgstr "" -#: cp/call.cc:4004 +#: cp/call.cc:4027 #, gcc-internal-format msgid "" " substitution of deduced template arguments resulted in errors seen above" msgstr "" #. Re-run template unification with diagnostics. -#: cp/call.cc:4009 +#: cp/call.cc:4032 #, gcc-internal-format msgid " template argument deduction/substitution failed:" msgstr "" -#: cp/call.cc:4023 +#: cp/call.cc:4046 #, gcc-internal-format msgid "" " a constructor taking a single argument of its own class type is invalid" msgstr "" -#: cp/call.cc:4030 +#: cp/call.cc:4053 #, gcc-internal-format msgid "" " an inherited constructor is not a candidate for initialization from an " "expression of the same or derived type" msgstr "" -#: cp/call.cc:4109 +#: cp/call.cc:4132 #, gcc-internal-format msgid "" "some candidates omitted; use %<-fdiagnostics-all-candidates%> to display them" msgstr "" -#: cp/call.cc:4190 cp/call.cc:4735 +#: cp/call.cc:4213 cp/call.cc:4758 #, gcc-internal-format msgid "designated initializers cannot be used with a non-aggregate type %qT" msgstr "" -#: cp/call.cc:4629 +#: cp/call.cc:4652 msgid "conversion from %qH to %qI is ambiguous" msgstr "" -#: cp/call.cc:4741 cp/cvt.cc:864 +#: cp/call.cc:4764 cp/cvt.cc:864 msgid "could not convert %qE from %qH to %qI" msgstr "" -#: cp/call.cc:4806 +#: cp/call.cc:4829 msgid "" "initializing %qH with %qI in converted constant expression does not bind " "directly" msgstr "" -#: cp/call.cc:4827 +#: cp/call.cc:4850 msgid "conversion from %qH to %qI in a converted constant expression" msgstr "" -#: cp/call.cc:5012 +#: cp/call.cc:5035 #, gcc-internal-format msgid "no matching function for call to %<%D(%A)%>" msgstr "" -#: cp/call.cc:5015 +#: cp/call.cc:5038 #, gcc-internal-format msgid "call of overloaded %<%D(%A)%> is ambiguous" msgstr "" #. It's no good looking for an overloaded operator() on a #. pointer-to-member-function. -#: cp/call.cc:5299 +#: cp/call.cc:5322 #, gcc-internal-format msgid "" "pointer-to-member function %qE cannot be called without an object; consider " "using %<.*%> or %<->*%>" msgstr "" -#: cp/call.cc:5378 +#: cp/call.cc:5401 #, gcc-internal-format msgid "no match for call to %<(%T) (%A)%>" msgstr "" -#: cp/call.cc:5392 +#: cp/call.cc:5415 #, gcc-internal-format msgid "call of %<(%T) (%A)%> is ambiguous" msgstr "" -#: cp/call.cc:5435 +#: cp/call.cc:5458 #, gcc-internal-format msgid "ambiguous overload for " msgstr "" -#: cp/call.cc:5436 +#: cp/call.cc:5459 #, gcc-internal-format msgid "no match for " msgstr "" -#: cp/call.cc:5439 +#: cp/call.cc:5462 #, gcc-internal-format msgid " (operand types are %qT, %qT, and %qT)" msgstr "" -#: cp/call.cc:5441 +#: cp/call.cc:5464 #, gcc-internal-format msgid " (operand types are %qT and %qT)" msgstr "" -#: cp/call.cc:5443 +#: cp/call.cc:5466 #, gcc-internal-format msgid " (operand type is %qT)" msgstr "" -#: cp/call.cc:5460 +#: cp/call.cc:5483 #, gcc-internal-format msgid "ternary %<operator?:%>" msgstr "" -#: cp/call.cc:5464 +#: cp/call.cc:5487 #, gcc-internal-format msgid "ternary %<operator?:%> in %<%E ? %E : %E%>" msgstr "" -#: cp/call.cc:5473 cp/call.cc:5517 cp/call.cc:5527 +#: cp/call.cc:5496 cp/call.cc:5540 cp/call.cc:5550 #, gcc-internal-format msgid "%<operator%s%>" msgstr "" -#: cp/call.cc:5476 +#: cp/call.cc:5499 #, gcc-internal-format msgid "%<operator%s%> in %<%E%s%>" msgstr "" -#: cp/call.cc:5483 +#: cp/call.cc:5506 #, gcc-internal-format msgid "%<operator[]%>" msgstr "" -#: cp/call.cc:5486 +#: cp/call.cc:5509 #, gcc-internal-format msgid "%<operator[]%> in %<%E[%E]%>" msgstr "" -#: cp/call.cc:5494 +#: cp/call.cc:5517 #, gcc-internal-format msgid "%qs" msgstr "" -#: cp/call.cc:5497 +#: cp/call.cc:5520 #, gcc-internal-format msgid "%qs in %<%s %E%>" msgstr "" -#: cp/call.cc:5503 +#: cp/call.cc:5526 #, gcc-internal-format msgid "%<operator %s%>" msgstr "" -#: cp/call.cc:5506 +#: cp/call.cc:5529 #, gcc-internal-format msgid "%<operator %s%> in %<%s%E%>" msgstr "" -#: cp/call.cc:5521 +#: cp/call.cc:5544 #, gcc-internal-format msgid "%<operator%s%> in %<%E %s %E%>" msgstr "" -#: cp/call.cc:5530 +#: cp/call.cc:5553 #, gcc-internal-format msgid "%<operator%s%> in %<%s%E%>" msgstr "" -#: cp/call.cc:5642 +#: cp/call.cc:5665 #, gcc-internal-format msgid "ISO C++ forbids omitting the middle term of a %<?:%> expression" msgstr "" -#: cp/call.cc:5719 +#: cp/call.cc:5742 #, gcc-internal-format msgid "" "inferred scalar type %qT is not an integer or floating-point type of the " "same size as %qT" msgstr "" -#: cp/call.cc:5736 cp/call.cc:5743 +#: cp/call.cc:5759 cp/call.cc:5766 msgid "conversion of scalar %qH to vector %qI involves truncation" msgstr "" -#: cp/call.cc:5799 +#: cp/call.cc:5822 #, gcc-internal-format msgid "incompatible vector types in conditional expression: %qT, %qT and %qT" msgstr "" -#: cp/call.cc:5851 cp/call.cc:6197 cp/call.cc:6217 +#: cp/call.cc:5874 cp/call.cc:6220 cp/call.cc:6240 #, gcc-internal-format msgid "operands to %<?:%> of types %qT and %qT have unordered conversion rank" msgstr "" -#: cp/call.cc:5923 +#: cp/call.cc:5946 #, gcc-internal-format msgid "" "second operand to the conditional operator is of type %<void%>, but the " "third operand is neither a throw-expression nor of type %<void%>" msgstr "" -#: cp/call.cc:5928 +#: cp/call.cc:5951 #, gcc-internal-format msgid "" "third operand to the conditional operator is of type %<void%>, but the " "second operand is neither a throw-expression nor of type %<void%>" msgstr "" -#: cp/call.cc:5974 cp/call.cc:6086 cp/call.cc:6337 +#: cp/call.cc:5997 cp/call.cc:6109 cp/call.cc:6360 #, gcc-internal-format msgid "operands to %<?:%> have different types %qT and %qT" msgstr "" -#: cp/call.cc:5978 +#: cp/call.cc:6001 #, gcc-internal-format msgid " and each type can be converted to the other" msgstr "" -#: cp/call.cc:6225 +#: cp/call.cc:6248 msgid "" "implicit conversion from %qH to %qI to match other result of conditional" msgstr "" -#: cp/call.cc:6243 +#: cp/call.cc:6266 #, gcc-internal-format msgid "enumerated mismatch in conditional expression: %qT vs %qT" msgstr "" -#: cp/call.cc:6263 +#: cp/call.cc:6286 #, gcc-internal-format msgid "" "conditional expression between enumeration type %qT and floating-point type " "%qT" msgstr "" -#: cp/call.cc:6267 +#: cp/call.cc:6290 #, gcc-internal-format msgid "" "conditional expression between floating-point type %qT and enumeration type " "%qT" msgstr "" -#: cp/call.cc:6271 +#: cp/call.cc:6294 #, gcc-internal-format msgid "" "conditional expression between enumeration type %qT and floating-point type " "%qT is deprecated" msgstr "" -#: cp/call.cc:6276 +#: cp/call.cc:6299 #, gcc-internal-format msgid "" "conditional expression between floating-point type %qT and enumeration type " "%qT is deprecated" msgstr "" -#: cp/call.cc:6292 +#: cp/call.cc:6315 #, gcc-internal-format msgid "enumerated and non-enumerated type in conditional expression" msgstr "" -#: cp/call.cc:7184 +#: cp/call.cc:7207 #, gcc-internal-format msgid "no %<%D(int)%> declared for postfix %qs, trying prefix operator instead" msgstr "" -#: cp/call.cc:7186 +#: cp/call.cc:7209 #, gcc-internal-format msgid "no %<%D(int)%> declared for postfix %qs" msgstr "" -#: cp/call.cc:7266 +#: cp/call.cc:7289 #, gcc-internal-format msgid "" "in C++20 this comparison calls the current function recursively with " "reversed arguments" msgstr "" -#: cp/call.cc:7319 +#: cp/call.cc:7342 #, gcc-internal-format msgid "return type of %qD is not %qs" msgstr "" -#: cp/call.cc:7321 +#: cp/call.cc:7344 #, gcc-internal-format msgid "used as rewritten candidate for comparison of %qT and %qT" msgstr "" -#: cp/call.cc:7404 +#: cp/call.cc:7427 #, gcc-internal-format msgid "comparison between %q#T and %q#T" msgstr "" -#: cp/call.cc:7591 +#: cp/call.cc:7614 #, gcc-internal-format msgid "no match for call to %<%T::operator[] (%A)%>" msgstr "" -#: cp/call.cc:7605 +#: cp/call.cc:7628 #, gcc-internal-format msgid "call of %<%T::operator[] (%A)%> is ambiguous" msgstr "" -#: cp/call.cc:7883 +#: cp/call.cc:7906 #, gcc-internal-format msgid "" "exception cleanup for this placement new selects non-placement %<operator " "delete%>" msgstr "" -#: cp/call.cc:7886 +#: cp/call.cc:7909 #, gcc-internal-format msgid "" "%qD is a usual (non-placement) deallocation function in C++14 (or with %<-" "fsized-deallocation%>)" msgstr "" -#: cp/call.cc:7923 +#: cp/call.cc:7946 #, gcc-internal-format msgid "%qD is a usual (non-placement) deallocation function" msgstr "" -#: cp/call.cc:8117 +#: cp/call.cc:8140 #, gcc-internal-format msgid "no corresponding deallocation function for %qD" msgstr "" -#: cp/call.cc:8120 +#: cp/call.cc:8143 #, gcc-internal-format msgid "" "destroying delete %qD cannot be used to release the allocated memory if the " "initialization throws because the object is not constructed yet" msgstr "" -#: cp/call.cc:8129 +#: cp/call.cc:8152 #, gcc-internal-format msgid "no suitable %<operator %s%> for %qT" msgstr "" -#: cp/call.cc:8165 +#: cp/call.cc:8188 #, gcc-internal-format msgid "%q#D is private within this context" msgstr "" -#: cp/call.cc:8166 cp/decl.cc:9113 +#: cp/call.cc:8189 cp/decl.cc:9113 #, gcc-internal-format msgid "declared private here" msgstr "" -#: cp/call.cc:8171 +#: cp/call.cc:8194 #, gcc-internal-format msgid "%q#D is protected within this context" msgstr "" -#: cp/call.cc:8172 cp/decl.cc:9114 +#: cp/call.cc:8195 cp/decl.cc:9114 #, gcc-internal-format msgid "declared protected here" msgstr "" -#: cp/call.cc:8179 +#: cp/call.cc:8202 #, gcc-internal-format msgid "%q#D is inaccessible within this context" msgstr "" -#: cp/call.cc:8260 +#: cp/call.cc:8283 #, gcc-internal-format msgid "passing NULL to non-pointer argument %P of %qD" msgstr "" -#: cp/call.cc:8263 cp/call.cc:8282 cp/decl.cc:10850 cp/decl.cc:10858 +#: cp/call.cc:8286 cp/call.cc:8305 cp/decl.cc:10850 cp/decl.cc:10858 #: cp/typeck.cc:4606 #, gcc-internal-format msgid " declared here" msgstr "" -#: cp/call.cc:8267 +#: cp/call.cc:8290 #, gcc-internal-format msgid "converting to non-pointer type %qT from NULL" msgstr "" -#: cp/call.cc:8279 +#: cp/call.cc:8302 #, gcc-internal-format msgid "converting %<false%> to pointer type for argument %P of %qD" msgstr "" -#: cp/call.cc:8286 +#: cp/call.cc:8309 #, gcc-internal-format msgid "converting %<false%> to pointer type %qT" msgstr "" -#: cp/call.cc:8353 +#: cp/call.cc:8376 #, gcc-internal-format msgid " initializing argument %P of %qD" msgstr "" -#: cp/call.cc:8374 +#: cp/call.cc:8397 #, gcc-internal-format msgid "" "conversions to arrays of unknown bound are only available with %<-std=c+" "+20%> or %<-std=gnu++20%>" msgstr "" -#: cp/call.cc:8424 +#: cp/call.cc:8447 #, gcc-internal-format msgid "too many braces around initializer for %qT" msgstr "" -#: cp/call.cc:8435 +#: cp/call.cc:8458 msgid "converting to %qH from %qI requires direct-initialization" msgstr "" -#: cp/call.cc:8447 +#: cp/call.cc:8470 msgid "" "ISO C++ does not allow converting to %qH from %qI with greater conversion " "rank" msgstr "" -#: cp/call.cc:8455 +#: cp/call.cc:8478 msgid "" "ISO C++ does not allow converting to %qH from %qI with unordered conversion " "rank" msgstr "" -#: cp/call.cc:8471 +#: cp/call.cc:8494 msgid "invalid user-defined conversion from %qH to %qI" msgstr "" -#: cp/call.cc:8504 cp/cvt.cc:227 +#: cp/call.cc:8527 cp/cvt.cc:227 msgid "invalid conversion from %qH to %qI" msgstr "" -#: cp/call.cc:8551 cp/call.cc:8564 +#: cp/call.cc:8574 cp/call.cc:8587 #, gcc-internal-format msgid "" "converting to %qT from initializer list would use explicit constructor %qD" msgstr "" -#: cp/call.cc:8557 +#: cp/call.cc:8580 #, gcc-internal-format msgid "in C++11 and above a default constructor can be explicit" msgstr "" -#: cp/call.cc:8837 +#: cp/call.cc:8860 msgid "cannot bind rvalue reference of type %qH to lvalue of type %qI" msgstr "" -#: cp/call.cc:8846 +#: cp/call.cc:8869 msgid "" "cannot bind non-const lvalue reference of type %qH to a value of type %qI" msgstr "" -#: cp/call.cc:8851 +#: cp/call.cc:8874 msgid "" "cannot bind non-const lvalue reference of type %qH to an rvalue of type %qI" msgstr "" #. extype is volatile -#: cp/call.cc:8854 +#: cp/call.cc:8877 msgid "cannot bind lvalue reference of type %qH to an rvalue of type %qI" msgstr "" -#: cp/call.cc:8867 +#: cp/call.cc:8890 msgid "cannot bind reference of type %qH to %qI due to different array bounds" msgstr "" -#: cp/call.cc:8870 +#: cp/call.cc:8893 msgid "binding reference of type %qH to %qI discards qualifiers" msgstr "" -#: cp/call.cc:8909 +#: cp/call.cc:8932 #, gcc-internal-format msgid "cannot bind bit-field %qE to %qT" msgstr "" -#: cp/call.cc:8912 cp/call.cc:8930 +#: cp/call.cc:8935 cp/call.cc:8953 #, gcc-internal-format msgid "cannot bind packed field %qE to %qT" msgstr "" -#: cp/call.cc:8915 +#: cp/call.cc:8938 #, gcc-internal-format msgid "cannot bind rvalue %qE to %qT" msgstr "" -#: cp/call.cc:9116 +#: cp/call.cc:9139 msgid "implicit conversion from %qH to %qI when passing argument to function" msgstr "" -#: cp/call.cc:9145 cp/cvt.cc:2011 +#: cp/call.cc:9168 cp/cvt.cc:2011 #, gcc-internal-format msgid "" "scoped enum %qT passed through %<...%> as %qT before %<-fabi-version=6%>, " "%qT after" msgstr "" -#: cp/call.cc:9189 +#: cp/call.cc:9212 #, gcc-internal-format msgid "" "passing objects of non-trivially-copyable type %q#T through %<...%> is " "conditionally supported" msgstr "" -#: cp/call.cc:9225 +#: cp/call.cc:9248 #, gcc-internal-format msgid "cannot receive reference type %qT through %<...%>" msgstr "" -#: cp/call.cc:9235 +#: cp/call.cc:9258 #, gcc-internal-format msgid "" "receiving objects of non-trivially-copyable type %q#T through %<...%> is " "conditionally-supported" msgstr "" -#: cp/call.cc:9303 +#: cp/call.cc:9326 #, gcc-internal-format msgid "recursive evaluation of default argument for %q#D" msgstr "" -#: cp/call.cc:9312 +#: cp/call.cc:9335 #, gcc-internal-format msgid "" "call to %qD uses the default argument for parameter %P, which is not yet " "defined" msgstr "" -#: cp/call.cc:9412 +#: cp/call.cc:9435 #, gcc-internal-format msgid "argument of function call might be a candidate for a format attribute" msgstr "" -#: cp/call.cc:9492 +#: cp/call.cc:9515 #, gcc-internal-format msgid "use of multiversioned function without a default" msgstr "" -#: cp/call.cc:9997 +#: cp/call.cc:10020 #, gcc-internal-format msgid "use %<-fdiagnostics-all-candidates%> to display considered candidates" msgstr "" -#: cp/call.cc:10120 +#: cp/call.cc:10143 #, gcc-internal-format msgid "passing %qT as %<this%> argument discards qualifiers" msgstr "" -#: cp/call.cc:10123 cp/call.cc:12969 +#: cp/call.cc:10146 cp/call.cc:12992 #, gcc-internal-format msgid " in call to %qD" msgstr "" -#: cp/call.cc:10148 +#: cp/call.cc:10171 #, gcc-internal-format msgid "%qT is not an accessible base of %qT" msgstr "" -#: cp/call.cc:10373 +#: cp/call.cc:10396 #, gcc-internal-format msgid "passing arguments to ellipsis of inherited constructor %qD" msgstr "" -#: cp/call.cc:10510 +#: cp/call.cc:10533 #, gcc-internal-format msgid "" "assignment from temporary %<initializer_list%> does not extend the lifetime " "of the underlying array" msgstr "" -#: cp/call.cc:10877 +#: cp/call.cc:10900 #, gcc-internal-format msgid "%qD writing to an object of type %#qT with no trivial copy-assignment" msgstr "" -#: cp/call.cc:10880 +#: cp/call.cc:10903 #, gcc-internal-format msgid "%qD writing to an object of non-trivial type %#qT%s" msgstr "" -#: cp/call.cc:10885 +#: cp/call.cc:10908 #, gcc-internal-format msgid "%qD writing to an object of type %#qT with %qs member %qD" msgstr "" -#: cp/call.cc:10890 +#: cp/call.cc:10913 #, gcc-internal-format msgid "" "%qD writing to an object of type %#qT containing a pointer to data member%s" msgstr "" -#: cp/call.cc:10905 +#: cp/call.cc:10928 #, gcc-internal-format msgid "; use assignment or value-initialization instead" msgstr "" -#: cp/call.cc:10907 +#: cp/call.cc:10930 #, gcc-internal-format msgid "; use assignment instead" msgstr "" -#: cp/call.cc:10909 +#: cp/call.cc:10932 #, gcc-internal-format msgid "; use value-initialization instead" msgstr "" -#: cp/call.cc:10912 +#: cp/call.cc:10935 #, gcc-internal-format msgid "%qD clearing an object of type %#qT with no trivial copy-assignment%s" msgstr "" -#: cp/call.cc:10915 +#: cp/call.cc:10938 #, gcc-internal-format msgid "%qD clearing an object of non-trivial type %#qT%s" msgstr "" -#: cp/call.cc:10917 +#: cp/call.cc:10940 #, gcc-internal-format msgid "%qD clearing an object of type %#qT containing a pointer-to-member%s" msgstr "" -#: cp/call.cc:10938 +#: cp/call.cc:10961 #, gcc-internal-format msgid "; use copy-assignment or copy-initialization instead" msgstr "" -#: cp/call.cc:10940 +#: cp/call.cc:10963 #, gcc-internal-format msgid "; use copy-assignment instead" msgstr "" -#: cp/call.cc:10942 +#: cp/call.cc:10965 #, gcc-internal-format msgid "; use copy-initialization instead" msgstr "" -#: cp/call.cc:10945 +#: cp/call.cc:10968 #, gcc-internal-format msgid "%qD writing to an object of type %#qT with no trivial copy-assignment%s" msgstr "" -#: cp/call.cc:10948 +#: cp/call.cc:10971 #, gcc-internal-format msgid "%qD writing to an object of non-trivially copyable type %#qT%s" msgstr "" -#: cp/call.cc:10951 +#: cp/call.cc:10974 #, gcc-internal-format msgid "%qD writing to an object with a deleted copy constructor" msgstr "" -#: cp/call.cc:10962 +#: cp/call.cc:10985 #, gcc-internal-format msgid "%qD copying an object of non-trivial type %#qT from an array of %#qT" msgstr "" -#: cp/call.cc:10974 +#: cp/call.cc:10997 #, gcc-internal-format msgid "" "%qD copying an object of type %#qT with %qs member %qD from an array of " "%#qT; use assignment or copy-initialization instead" msgstr "" -#: cp/call.cc:10993 +#: cp/call.cc:11016 #, gcc-internal-format msgid "" "%qD writing to an object of a non-trivial type %#qT leaves %wu bytes " "unchanged" msgstr "" -#: cp/call.cc:10996 +#: cp/call.cc:11019 #, gcc-internal-format msgid "" "%qD writing to an object of a non-trivial type %#qT leaves %wu byte unchanged" msgstr "" -#: cp/call.cc:11006 +#: cp/call.cc:11029 #, gcc-internal-format msgid "" "%qD moving an object of non-trivially copyable type %#qT; use %<new%> and " "%<delete%> instead" msgstr "" -#: cp/call.cc:11009 +#: cp/call.cc:11032 #, gcc-internal-format msgid "" "%qD moving an object of type %#qT with deleted copy constructor; use %<new%> " "and %<delete%> instead" msgstr "" -#: cp/call.cc:11012 +#: cp/call.cc:11035 #, gcc-internal-format msgid "%qD moving an object of type %#qT with deleted destructor" msgstr "" -#: cp/call.cc:11021 +#: cp/call.cc:11044 #, gcc-internal-format msgid "" "%qD moving an object of non-trivial type %#qT and size %E into a region of " "size %E" msgstr "" -#: cp/call.cc:11043 +#: cp/call.cc:11066 #, gcc-internal-format msgid "%#qT declared here" msgstr "" -#: cp/call.cc:11097 +#: cp/call.cc:11120 #, gcc-internal-format msgid "" "argument %u in call to function %qE has pointer to a non-trivially-copyable " "type (%qT)" msgstr "" -#: cp/call.cc:11164 +#: cp/call.cc:11187 #, gcc-internal-format msgid "constructor delegates to itself" msgstr "" -#: cp/call.cc:11439 cp/typeck.cc:10389 +#: cp/call.cc:11462 cp/typeck.cc:10389 msgid "cannot convert %qH to %qI" msgstr "" -#: cp/call.cc:11461 +#: cp/call.cc:11484 #, gcc-internal-format msgid "no matching function for call to %<%T::operator %T(%A)%#V%>" msgstr "" -#: cp/call.cc:11493 +#: cp/call.cc:11516 #, gcc-internal-format msgid "no matching function for call to %<%T::%s%E(%A)%#V%>" msgstr "" -#: cp/call.cc:11541 +#: cp/call.cc:11564 #, gcc-internal-format msgid "call to non-function %qD" msgstr "" -#: cp/call.cc:11579 cp/pt.cc:17141 cp/typeck.cc:3483 +#: cp/call.cc:11602 cp/pt.cc:17172 cp/typeck.cc:3483 #, gcc-internal-format msgid "cannot call constructor %<%T::%D%> directly" msgstr "" -#: cp/call.cc:11581 +#: cp/call.cc:11604 #, gcc-internal-format msgid "for a function-style cast, remove the redundant %<::%D%>" msgstr "" -#: cp/call.cc:11763 +#: cp/call.cc:11786 #, gcc-internal-format msgid "no matching function for call to %<%s(%A)%>" msgstr "" -#: cp/call.cc:11766 +#: cp/call.cc:11789 #, gcc-internal-format msgid "call of overloaded %<%s(%A)%> is ambiguous" msgstr "" -#: cp/call.cc:11789 +#: cp/call.cc:11812 #, gcc-internal-format msgid "pure virtual %q#D called from non-static data member initializer" msgstr "" -#: cp/call.cc:11794 +#: cp/call.cc:11817 #, gcc-internal-format msgid "pure virtual %q#D called from constructor" msgstr "" -#: cp/call.cc:11795 +#: cp/call.cc:11818 #, gcc-internal-format msgid "pure virtual %q#D called from destructor" msgstr "" -#: cp/call.cc:11818 +#: cp/call.cc:11841 #, gcc-internal-format msgid "cannot call member function %qD without object" msgstr "" -#: cp/call.cc:12967 +#: cp/call.cc:12990 #, gcc-internal-format msgid "passing %qT chooses %qT over %qT" msgstr "" -#: cp/call.cc:12993 +#: cp/call.cc:13016 #, gcc-internal-format msgid "" "C++20 says that these are ambiguous, even though the second is reversed:" msgstr "" -#: cp/call.cc:13016 +#: cp/call.cc:13039 #, gcc-internal-format msgid "try making the operator a %<const%> member function" msgstr "" -#: cp/call.cc:13079 +#: cp/call.cc:13102 #, gcc-internal-format msgid "choosing %qD over %qD" msgstr "" -#: cp/call.cc:13080 +#: cp/call.cc:13103 msgid " for conversion from %qH to %qI" msgstr "" -#: cp/call.cc:13083 +#: cp/call.cc:13106 #, gcc-internal-format msgid " because conversion sequence for the argument is better" msgstr "" -#: cp/call.cc:13367 +#: cp/call.cc:13390 #, gcc-internal-format msgid "default argument mismatch in overload resolution" msgstr "" -#: cp/call.cc:13371 +#: cp/call.cc:13394 #, gcc-internal-format msgid " candidate 1: %q#F" msgstr "" -#: cp/call.cc:13373 +#: cp/call.cc:13396 #, gcc-internal-format msgid " candidate 2: %q#F" msgstr "" -#: cp/call.cc:13419 +#: cp/call.cc:13442 #, gcc-internal-format msgid "" "ISO C++ says that these are ambiguous, even though the worst conversion for " "the first is better than the worst conversion for the second:" msgstr "" -#: cp/call.cc:13827 +#: cp/call.cc:13850 #, gcc-internal-format msgid "a temporary bound to %qD only persists until the constructor exits" msgstr "" -#: cp/call.cc:13980 +#: cp/call.cc:14003 msgid "" "invalid initialization of non-const reference of type %qH from an rvalue of " "type %qI" msgstr "" -#: cp/call.cc:13984 +#: cp/call.cc:14007 msgid "" "invalid initialization of reference of type %qH from expression of type %qI" msgstr "" -#: cp/call.cc:14302 +#: cp/call.cc:14325 #, gcc-internal-format msgid "possibly dangling reference to a temporary" msgstr "" -#: cp/call.cc:14303 +#: cp/call.cc:14326 #, gcc-internal-format msgid "the temporary was destroyed at the end of the full expression %qE" msgstr "" -#: cp/call.cc:14571 +#: cp/call.cc:14594 #, gcc-internal-format msgid "explicit conversion function was not considered" msgstr "" @@ -55458,7 +55485,7 @@ msgstr "" msgid "method declared %qE overriding %qE method" msgstr "" -#: cp/class.cc:6204 cp/constexpr.cc:302 +#: cp/class.cc:6204 cp/constexpr.cc:299 #, gcc-internal-format msgid "" "enclosing class of %<constexpr%> non-static member function %q+#D is not a " @@ -55602,7 +55629,7 @@ msgstr "" msgid "next member %q#D declared here" msgstr "" -#: cp/class.cc:7785 cp/decl.cc:17637 cp/parser.cc:27637 +#: cp/class.cc:7785 cp/decl.cc:17643 cp/parser.cc:27637 #, gcc-internal-format msgid "redefinition of %q#T" msgstr "" @@ -55740,7 +55767,7 @@ msgstr "" msgid "lambdas are implicitly %<constexpr%> only in C++17 and later" msgstr "" -#: cp/constexpr.cc:272 cp/decl.cc:14672 +#: cp/constexpr.cc:270 cp/decl.cc:14678 #, gcc-internal-format msgid "" "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu+" @@ -55748,135 +55775,135 @@ msgid "" msgstr "" #. constexpr_fundef_p -#: cp/constexpr.cc:286 +#: cp/constexpr.cc:283 #, gcc-internal-format msgid "invalid return type %qT of %<constexpr%> function %q+D" msgstr "" -#: cp/constexpr.cc:313 +#: cp/constexpr.cc:310 #, gcc-internal-format msgid "%q#T has virtual base classes" msgstr "" -#: cp/constexpr.cc:571 +#: cp/constexpr.cc:568 #, gcc-internal-format msgid "%<constexpr%> constructor does not have empty body" msgstr "" -#: cp/constexpr.cc:829 +#: cp/constexpr.cc:826 #, gcc-internal-format msgid "" "%<constexpr%> constructor for union %qT must initialize exactly one non-" "static data member" msgstr "" -#: cp/constexpr.cc:890 +#: cp/constexpr.cc:887 #, gcc-internal-format msgid "" "member %qD must be initialized by mem-initializer in %<constexpr%> " "constructor" msgstr "" -#: cp/constexpr.cc:953 +#: cp/constexpr.cc:950 #, gcc-internal-format msgid "body of %<constexpr%> function %qD not a return-statement" msgstr "" -#: cp/constexpr.cc:1081 +#: cp/constexpr.cc:1078 #, gcc-internal-format msgid "%qD is not usable as a %<constexpr%> function because:" msgstr "" -#: cp/constexpr.cc:1318 cp/constexpr.cc:6347 +#: cp/constexpr.cc:1315 cp/constexpr.cc:6346 #, gcc-internal-format msgid "destroying %qE outside its lifetime" msgstr "" -#: cp/constexpr.cc:1609 cp/constexpr.cc:3306 +#: cp/constexpr.cc:1606 cp/constexpr.cc:3303 #: rust/backend/rust-constexpr.cc:3326 rust/backend/rust-constexpr.cc:3589 #, gcc-internal-format msgid "%<constexpr%> call flows off the end of the function" msgstr "" -#: cp/constexpr.cc:1611 cp/constexpr.cc:1710 cp/constexpr.cc:1719 -#: cp/constexpr.cc:3578 rust/backend/rust-constexpr.cc:3331 +#: cp/constexpr.cc:1608 cp/constexpr.cc:1707 cp/constexpr.cc:1716 +#: cp/constexpr.cc:3575 rust/backend/rust-constexpr.cc:3331 #: rust/backend/rust-constexpr.cc:3341 rust/backend/rust-constexpr.cc:4324 #, gcc-internal-format msgid "%q+E is not a constant expression" msgstr "" -#: cp/constexpr.cc:1896 cp/constexpr.cc:5913 cp/constexpr.cc:8212 +#: cp/constexpr.cc:1893 cp/constexpr.cc:5912 cp/constexpr.cc:8211 #: rust/backend/rust-constexpr.cc:875 rust/backend/rust-constexpr.cc:2494 #, gcc-internal-format msgid "dereferencing a null pointer" msgstr "" -#: cp/constexpr.cc:2075 +#: cp/constexpr.cc:2072 #, gcc-internal-format msgid "the comparison reduces to %qE" msgstr "" -#: cp/constexpr.cc:2078 +#: cp/constexpr.cc:2075 #, gcc-internal-format msgid "%qE evaluates to false" msgstr "" -#: cp/constexpr.cc:2157 +#: cp/constexpr.cc:2154 #, gcc-internal-format msgid "failed %<assume%> attribute assumption" msgstr "" -#: cp/constexpr.cc:2192 cp/constexpr.cc:9662 +#: cp/constexpr.cc:2189 cp/constexpr.cc:9661 #: rust/backend/rust-constexpr.cc:5758 #, gcc-internal-format msgid "call to internal function %qE" msgstr "" -#: cp/constexpr.cc:2246 rust/backend/rust-constexpr.cc:2615 +#: cp/constexpr.cc:2243 rust/backend/rust-constexpr.cc:2615 #, gcc-internal-format msgid "modifying a const object %qE is not allowed in a constant expression" msgstr "" -#: cp/constexpr.cc:2274 rust/backend/rust-constexpr.cc:2618 +#: cp/constexpr.cc:2271 rust/backend/rust-constexpr.cc:2618 #, gcc-internal-format msgid "originally declared %<const%> here" msgstr "" -#: cp/constexpr.cc:2530 cp/constexpr.cc:2586 cp/constexpr.cc:2619 -#: cp/constexpr.cc:2641 +#: cp/constexpr.cc:2527 cp/constexpr.cc:2583 cp/constexpr.cc:2616 +#: cp/constexpr.cc:2638 #, gcc-internal-format msgid "reference %<dynamic_cast%> failed" msgstr "" -#: cp/constexpr.cc:2531 +#: cp/constexpr.cc:2528 #, gcc-internal-format msgid "dynamic type %qT of its operand does not have a base class of type %qT" msgstr "" -#: cp/constexpr.cc:2555 +#: cp/constexpr.cc:2552 #, gcc-internal-format msgid "virtual table pointer is used uninitialized" msgstr "" -#: cp/constexpr.cc:2587 cp/constexpr.cc:2620 +#: cp/constexpr.cc:2584 cp/constexpr.cc:2617 #, gcc-internal-format msgid "" "static type %qT of its operand is a non-public base class of dynamic type %qT" msgstr "" -#: cp/constexpr.cc:2643 +#: cp/constexpr.cc:2640 #, gcc-internal-format msgid "%qT is an ambiguous base class of dynamic type %qT of its operand" msgstr "" -#: cp/constexpr.cc:2646 +#: cp/constexpr.cc:2643 #, gcc-internal-format msgid "" "dynamic type %qT of its operand does not have an unambiguous public base " "class %qT" msgstr "" -#: cp/constexpr.cc:2723 cp/constexpr.cc:3003 cp/constexpr.cc:9698 +#: cp/constexpr.cc:2720 cp/constexpr.cc:3000 cp/constexpr.cc:9697 #: rust/backend/rust-constexpr.cc:5789 #, gcc-internal-format msgid "call to non-%<constexpr%> function %qD" @@ -55884,149 +55911,149 @@ msgstr "" #. virtual_offset is only set for virtual bases, which make the #. class non-literal, so we don't need to handle it here. -#: cp/constexpr.cc:2729 +#: cp/constexpr.cc:2726 #, gcc-internal-format msgid "calling constexpr member function %qD through virtual base subobject" msgstr "" -#: cp/constexpr.cc:2845 rust/backend/rust-constexpr.cc:3387 +#: cp/constexpr.cc:2842 rust/backend/rust-constexpr.cc:3387 #, gcc-internal-format msgid "expression %qE does not designate a %<constexpr%> function" msgstr "" -#: cp/constexpr.cc:2923 +#: cp/constexpr.cc:2920 #, gcc-internal-format msgid "array deallocation of object allocated with non-array allocation" msgstr "" -#: cp/constexpr.cc:2927 cp/constexpr.cc:2950 +#: cp/constexpr.cc:2924 cp/constexpr.cc:2947 #, gcc-internal-format msgid "allocation performed here" msgstr "" -#: cp/constexpr.cc:2946 +#: cp/constexpr.cc:2943 #, gcc-internal-format msgid "non-array deallocation of object allocated with array allocation" msgstr "" -#: cp/constexpr.cc:2963 +#: cp/constexpr.cc:2960 #, gcc-internal-format msgid "deallocation of already deallocated storage" msgstr "" -#: cp/constexpr.cc:2970 +#: cp/constexpr.cc:2967 #, gcc-internal-format msgid "deallocation of storage that was not previously allocated" msgstr "" -#: cp/constexpr.cc:3087 rust/backend/rust-constexpr.cc:3442 +#: cp/constexpr.cc:3084 rust/backend/rust-constexpr.cc:3442 #, gcc-internal-format msgid "%qD called in a constant expression before its definition is complete" msgstr "" -#: cp/constexpr.cc:3094 +#: cp/constexpr.cc:3091 #, gcc-internal-format msgid "%qD called in a constant expression" msgstr "" -#: cp/constexpr.cc:3098 rust/backend/rust-constexpr.cc:3456 +#: cp/constexpr.cc:3095 rust/backend/rust-constexpr.cc:3456 #, gcc-internal-format msgid "%qD used before its definition" msgstr "" -#: cp/constexpr.cc:3170 rust/backend/rust-constexpr.cc:3498 +#: cp/constexpr.cc:3167 rust/backend/rust-constexpr.cc:3498 #, gcc-internal-format msgid "call has circular dependency" msgstr "" -#: cp/constexpr.cc:3181 rust/backend/rust-constexpr.cc:3509 +#: cp/constexpr.cc:3178 rust/backend/rust-constexpr.cc:3509 #, gcc-internal-format msgid "" "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-" "depth=%> to increase the maximum)" msgstr "" -#: cp/constexpr.cc:3536 +#: cp/constexpr.cc:3533 #, gcc-internal-format msgid "reference to %qD is not a constant expression" msgstr "" -#: cp/constexpr.cc:3539 +#: cp/constexpr.cc:3536 #, gcc-internal-format msgid "pointer to %qD is not a constant expression" msgstr "" -#: cp/constexpr.cc:3545 +#: cp/constexpr.cc:3542 #, gcc-internal-format msgid "" "address of non-static constexpr variable %qD may differ on each invocation " "of the enclosing function; add %<static%> to give it a constant address" msgstr "" -#: cp/constexpr.cc:3621 +#: cp/constexpr.cc:3618 #, gcc-internal-format msgid "right operand of shift expression %q+E is negative" msgstr "" -#: cp/constexpr.cc:3628 +#: cp/constexpr.cc:3625 #, gcc-internal-format msgid "" "right operand of shift expression %q+E is greater than or equal to the " "precision %wu of the left operand" msgstr "" -#: cp/constexpr.cc:3651 +#: cp/constexpr.cc:3648 #, gcc-internal-format msgid "left operand of shift expression %q+E is negative" msgstr "" -#: cp/constexpr.cc:3670 +#: cp/constexpr.cc:3667 #, gcc-internal-format msgid "shift expression %q+E overflows" msgstr "" -#: cp/constexpr.cc:3869 +#: cp/constexpr.cc:3866 #, gcc-internal-format msgid "arithmetic involving a null pointer in %qE" msgstr "" -#: cp/constexpr.cc:4304 rust/backend/rust-constexpr.cc:4399 +#: cp/constexpr.cc:4301 rust/backend/rust-constexpr.cc:4399 #, gcc-internal-format msgid "" "array subscript value %qE is outside the bounds of array %qD of type %qT" msgstr "" -#: cp/constexpr.cc:4307 rust/backend/rust-constexpr.cc:4404 +#: cp/constexpr.cc:4304 rust/backend/rust-constexpr.cc:4404 #, gcc-internal-format msgid "" "nonzero array subscript %qE is used with array %qD of type %qT with unknown " "bounds" msgstr "" -#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:4411 +#: cp/constexpr.cc:4309 rust/backend/rust-constexpr.cc:4411 #, gcc-internal-format msgid "array subscript value %qE is outside the bounds of array type %qT" msgstr "" -#: cp/constexpr.cc:4315 rust/backend/rust-constexpr.cc:4416 +#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:4416 #, gcc-internal-format msgid "" "nonzero array subscript %qE is used with array of type %qT with unknown " "bounds" msgstr "" -#: cp/constexpr.cc:4503 rust/backend/rust-constexpr.cc:1667 +#: cp/constexpr.cc:4500 rust/backend/rust-constexpr.cc:1667 #, gcc-internal-format msgid "accessing uninitialized array element" msgstr "" -#: cp/constexpr.cc:4565 rust/backend/rust-constexpr.cc:1724 +#: cp/constexpr.cc:4562 rust/backend/rust-constexpr.cc:1724 #, gcc-internal-format msgid "dereferencing a null pointer in %qE" msgstr "" -#: cp/constexpr.cc:4584 cp/constexpr.cc:4700 cp/constexpr.cc:4712 -#: cp/constexpr.cc:7406 cp/constexpr.cc:7526 cp/constexpr.cc:9612 +#: cp/constexpr.cc:4581 cp/constexpr.cc:4697 cp/constexpr.cc:4709 +#: cp/constexpr.cc:7405 cp/constexpr.cc:7525 cp/constexpr.cc:9611 #: rust/backend/rust-constexpr.cc:1738 rust/backend/rust-constexpr.cc:1983 #: rust/backend/rust-constexpr.cc:2225 rust/backend/rust-constexpr.cc:4743 #: rust/backend/rust-constexpr.cc:5712 @@ -56034,269 +56061,269 @@ msgstr "" msgid "%qE is not a constant expression" msgstr "" -#: cp/constexpr.cc:4592 rust/backend/rust-constexpr.cc:1744 +#: cp/constexpr.cc:4589 rust/backend/rust-constexpr.cc:1744 #, gcc-internal-format msgid "mutable %qD is not usable in a constant expression" msgstr "" -#: cp/constexpr.cc:4624 cp/constexpr.cc:4660 cp/constexpr.cc:6511 +#: cp/constexpr.cc:4621 cp/constexpr.cc:4657 cp/constexpr.cc:6510 #: rust/backend/rust-constexpr.cc:1774 rust/backend/rust-constexpr.cc:1797 #, gcc-internal-format msgid "accessing uninitialized member %qD" msgstr "" -#: cp/constexpr.cc:4626 cp/constexpr.cc:4639 cp/constexpr.cc:6506 +#: cp/constexpr.cc:4623 cp/constexpr.cc:4636 cp/constexpr.cc:6505 #: rust/backend/rust-constexpr.cc:1776 #, gcc-internal-format msgid "" "accessing %qD member instead of initialized %qD member in constant expression" msgstr "" -#: cp/constexpr.cc:4778 +#: cp/constexpr.cc:4775 #, gcc-internal-format msgid "%qs is not a constant expression because %qT is a union type" msgstr "" -#: cp/constexpr.cc:4781 +#: cp/constexpr.cc:4778 #, gcc-internal-format msgid "%qs is not a constant expression because %qT contains a union type" msgstr "" -#: cp/constexpr.cc:4792 +#: cp/constexpr.cc:4789 #, gcc-internal-format msgid "%qs is not a constant expression because %qT is a pointer type" msgstr "" -#: cp/constexpr.cc:4795 +#: cp/constexpr.cc:4792 #, gcc-internal-format msgid "%qs is not a constant expression because %qT contains a pointer type" msgstr "" -#: cp/constexpr.cc:4806 +#: cp/constexpr.cc:4803 #, gcc-internal-format msgid "%qs is not a constant expression because %qT is a reference type" msgstr "" -#: cp/constexpr.cc:4809 +#: cp/constexpr.cc:4806 #, gcc-internal-format msgid "%qs is not a constant expression because %qT contains a reference type" msgstr "" -#: cp/constexpr.cc:4820 +#: cp/constexpr.cc:4817 #, gcc-internal-format msgid "" "%qs is not a constant expression because %qT is a pointer to member type" msgstr "" -#: cp/constexpr.cc:4824 +#: cp/constexpr.cc:4821 #, gcc-internal-format msgid "" "%qs is not a constant expression because %qT contains a pointer to member " "type" msgstr "" -#: cp/constexpr.cc:4835 +#: cp/constexpr.cc:4832 #, gcc-internal-format msgid "%qs is not a constant expression because %qT is volatile" msgstr "" -#: cp/constexpr.cc:4838 +#: cp/constexpr.cc:4835 #, gcc-internal-format msgid "" "%qs is not a constant expression because %qT contains a volatile subobject" msgstr "" -#: cp/constexpr.cc:4991 +#: cp/constexpr.cc:4990 #, gcc-internal-format msgid "%qs cannot be constant evaluated on the target" msgstr "" -#: cp/constexpr.cc:5000 cp/constexpr.cc:5010 +#: cp/constexpr.cc:4999 cp/constexpr.cc:5009 #, gcc-internal-format msgid "%qs cannot be constant evaluated because the type is too large" msgstr "" -#: cp/constexpr.cc:5030 +#: cp/constexpr.cc:5029 #, gcc-internal-format msgid "%qs cannot be constant evaluated because the argument cannot be encoded" msgstr "" -#: cp/constexpr.cc:5076 +#: cp/constexpr.cc:5075 #, gcc-internal-format msgid "%qs accessing uninitialized byte at offset %d" msgstr "" -#: cp/constexpr.cc:5088 +#: cp/constexpr.cc:5087 #, gcc-internal-format msgid "" "%qs cannot be constant evaluated because the argument cannot be interpreted" msgstr "" -#: cp/constexpr.cc:5933 rust/backend/rust-constexpr.cc:895 +#: cp/constexpr.cc:5932 rust/backend/rust-constexpr.cc:895 #, gcc-internal-format msgid "accessing value of %qE through a %qT glvalue in a constant expression" msgstr "" #. Provide a more accurate message for deleted variables. -#: cp/constexpr.cc:5973 cp/constexpr.cc:6006 +#: cp/constexpr.cc:5972 cp/constexpr.cc:6005 #, gcc-internal-format msgid "use of allocated storage after deallocation in a constant expression" msgstr "" -#: cp/constexpr.cc:5975 cp/constexpr.cc:6001 cp/constexpr.cc:6008 -#: cp/constexpr.cc:6342 +#: cp/constexpr.cc:5974 cp/constexpr.cc:6000 cp/constexpr.cc:6007 +#: cp/constexpr.cc:6341 #, gcc-internal-format msgid "allocated here" msgstr "" -#: cp/constexpr.cc:5979 +#: cp/constexpr.cc:5978 #, gcc-internal-format msgid "accessing %qE outside its lifetime" msgstr "" -#: cp/constexpr.cc:5999 +#: cp/constexpr.cc:5998 #, gcc-internal-format msgid "" "the content of uninitialized storage is not usable in a constant expression" msgstr "" -#: cp/constexpr.cc:6011 rust/backend/rust-constexpr.cc:4041 +#: cp/constexpr.cc:6010 rust/backend/rust-constexpr.cc:4041 #, gcc-internal-format msgid "the value of %qD is not usable in a constant expression" msgstr "" -#: cp/constexpr.cc:6019 +#: cp/constexpr.cc:6018 #, gcc-internal-format msgid "%qD used in its own initializer" msgstr "" -#: cp/constexpr.cc:6024 +#: cp/constexpr.cc:6023 #, gcc-internal-format msgid "%q#D is not const" msgstr "" -#: cp/constexpr.cc:6027 +#: cp/constexpr.cc:6026 #, gcc-internal-format msgid "%q#D is volatile" msgstr "" -#: cp/constexpr.cc:6032 cp/constexpr.cc:6039 +#: cp/constexpr.cc:6031 cp/constexpr.cc:6038 #, gcc-internal-format msgid "%qD was not initialized with a constant expression" msgstr "" -#: cp/constexpr.cc:6045 +#: cp/constexpr.cc:6044 #, gcc-internal-format msgid "%qD was not declared %<constexpr%>" msgstr "" -#: cp/constexpr.cc:6048 +#: cp/constexpr.cc:6047 #, gcc-internal-format msgid "%qD does not have integral or enumeration type" msgstr "" -#: cp/constexpr.cc:6340 +#: cp/constexpr.cc:6339 #, gcc-internal-format msgid "" "modification of allocated storage after deallocation is not a constant " "expression" msgstr "" -#: cp/constexpr.cc:6349 +#: cp/constexpr.cc:6348 #, gcc-internal-format msgid "modification of %qE outside its lifetime is not a constant expression" msgstr "" -#: cp/constexpr.cc:6356 +#: cp/constexpr.cc:6355 #, gcc-internal-format msgid "" "destroying %qE from outside current evaluation is not a constant expression" msgstr "" -#: cp/constexpr.cc:6359 +#: cp/constexpr.cc:6358 #, gcc-internal-format msgid "" "modification of %qE from outside current evaluation is not a constant " "expression" msgstr "" -#: cp/constexpr.cc:6486 +#: cp/constexpr.cc:6485 #, gcc-internal-format msgid "" "change of the active member of a union from %qD to %qD is not a constant " "expression before C++20" msgstr "" -#: cp/constexpr.cc:6515 +#: cp/constexpr.cc:6514 #, gcc-internal-format msgid "" "%qD does not implicitly begin its lifetime because %qT does not have a non-" "deleted trivial default constructor, use %<std::construct_at%> instead" msgstr "" -#: cp/constexpr.cc:6522 +#: cp/constexpr.cc:6521 #, gcc-internal-format msgid "" "initializing %qD requires a member access expression as the left operand of " "the assignment" msgstr "" -#: cp/constexpr.cc:6534 rust/backend/rust-constexpr.cc:2822 +#: cp/constexpr.cc:6533 rust/backend/rust-constexpr.cc:2822 #, gcc-internal-format msgid "" "change of the active member of a union from %qD to %qD during initialization" msgstr "" -#: cp/constexpr.cc:6982 cp/constexpr.cc:8561 cp/constexpr.cc:8573 +#: cp/constexpr.cc:6981 cp/constexpr.cc:8560 cp/constexpr.cc:8572 #: rust/backend/rust-constexpr.cc:4668 #, gcc-internal-format msgid "statement is not a constant expression" msgstr "" -#: cp/constexpr.cc:7078 rust/backend/rust-constexpr.cc:4933 +#: cp/constexpr.cc:7077 rust/backend/rust-constexpr.cc:4933 #, gcc-internal-format msgid "" "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-" "loop-limit=%> to increase the limit)" msgstr "" -#: cp/constexpr.cc:7185 rust/backend/rust-constexpr.cc:999 +#: cp/constexpr.cc:7184 rust/backend/rust-constexpr.cc:999 #, gcc-internal-format msgid "inline assembly is not a constant expression" msgstr "" -#: cp/constexpr.cc:7187 rust/backend/rust-constexpr.cc:1000 +#: cp/constexpr.cc:7186 rust/backend/rust-constexpr.cc:1000 #, gcc-internal-format msgid "" "only unevaluated inline assembly is allowed in a %<constexpr%> function in C+" "+20" msgstr "" -#: cp/constexpr.cc:7205 +#: cp/constexpr.cc:7204 #, gcc-internal-format msgid "use of %qD" msgstr "" -#: cp/constexpr.cc:7209 +#: cp/constexpr.cc:7208 #, gcc-internal-format msgid "" "its value can vary between compiler versions or with different %<-mtune%> or " "%<-mcpu%> flags" msgstr "" -#: cp/constexpr.cc:7211 +#: cp/constexpr.cc:7210 #, gcc-internal-format msgid "" "if this use is part of a public ABI, change it to instead use a constant " "variable you define" msgstr "" -#: cp/constexpr.cc:7213 +#: cp/constexpr.cc:7212 #, gcc-internal-format, gfc-internal-format msgid "the default value for the current CPU tuning is %d bytes" msgstr "" -#: cp/constexpr.cc:7215 +#: cp/constexpr.cc:7214 #, gcc-internal-format msgid "" "you can stabilize this value with %<--param " @@ -56304,250 +56331,250 @@ msgid "" "Wno-interference-size%>" msgstr "" -#: cp/constexpr.cc:7368 +#: cp/constexpr.cc:7367 #, gcc-internal-format msgid "value %qE of type %qT is not a constant expression" msgstr "" -#: cp/constexpr.cc:7381 +#: cp/constexpr.cc:7380 #, gcc-internal-format msgid "" "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-" "fconstexpr-ops-limit=%> to increase the limit)" msgstr "" -#: cp/constexpr.cc:7556 +#: cp/constexpr.cc:7555 #, gcc-internal-format msgid "control passes through definition of %qD with thread storage duration" msgstr "" -#: cp/constexpr.cc:7559 +#: cp/constexpr.cc:7558 #, gcc-internal-format msgid "control passes through definition of %qD with static storage duration" msgstr "" -#: cp/constexpr.cc:7624 cp/constexpr.cc:10306 +#: cp/constexpr.cc:7623 cp/constexpr.cc:10305 #: rust/backend/rust-constexpr.cc:2056 rust/backend/rust-constexpr.cc:6206 #, gcc-internal-format msgid "temporary of non-literal type %qT in a constant expression" msgstr "" -#: cp/constexpr.cc:8073 cp/constexpr.cc:9813 +#: cp/constexpr.cc:8072 cp/constexpr.cc:9812 #, gcc-internal-format msgid "%<reinterpret_cast%> is not a constant expression" msgstr "" -#: cp/constexpr.cc:8101 rust/backend/rust-constexpr.cc:2461 +#: cp/constexpr.cc:8100 rust/backend/rust-constexpr.cc:2461 #, gcc-internal-format msgid "" "conversion from pointer type %qT to arithmetic type %qT in a constant " "expression" msgstr "" -#: cp/constexpr.cc:8151 +#: cp/constexpr.cc:8150 #, gcc-internal-format msgid "" "cast from %qT is not allowed in a constant expression because pointed-to " "type %qT is not similar to %qT" msgstr "" -#: cp/constexpr.cc:8158 +#: cp/constexpr.cc:8157 #, gcc-internal-format msgid "pointed-to object declared here" msgstr "" -#: cp/constexpr.cc:8163 +#: cp/constexpr.cc:8162 #, gcc-internal-format msgid "" "cast from %qT is not allowed in a constant expression because %qE does not " "point to an object" msgstr "" -#: cp/constexpr.cc:8175 +#: cp/constexpr.cc:8174 #, gcc-internal-format msgid "cast from %qT is not allowed in a constant expression before C++26" msgstr "" -#: cp/constexpr.cc:8189 +#: cp/constexpr.cc:8188 #, gcc-internal-format msgid "%qE is not a constant expression when the class %qT is still incomplete" msgstr "" -#: cp/constexpr.cc:8223 rust/backend/rust-constexpr.cc:2506 +#: cp/constexpr.cc:8222 rust/backend/rust-constexpr.cc:2506 #, gcc-internal-format msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression" msgstr "" -#: cp/constexpr.cc:8361 cp/constexpr.cc:10124 cp/constexpr.cc:10529 +#: cp/constexpr.cc:8360 cp/constexpr.cc:10123 cp/constexpr.cc:10528 #: rust/backend/rust-constexpr.cc:6100 rust/backend/rust-constexpr.cc:6415 #, gcc-internal-format msgid "expression %qE is not a constant expression" msgstr "" -#: cp/constexpr.cc:8406 cp/constexpr.cc:10570 +#: cp/constexpr.cc:8405 cp/constexpr.cc:10569 #, gcc-internal-format msgid "%<goto%> is not a constant expression" msgstr "" -#: cp/constexpr.cc:8464 +#: cp/constexpr.cc:8463 #, gcc-internal-format msgid "contract predicate is false in constant expression" msgstr "" -#: cp/constexpr.cc:8480 +#: cp/constexpr.cc:8479 #, gcc-internal-format msgid "unexpected template-id %qE" msgstr "" -#: cp/constexpr.cc:8486 cp/constraint.cc:178 cp/constraint.cc:755 +#: cp/constexpr.cc:8485 cp/constraint.cc:178 cp/constraint.cc:755 #, gcc-internal-format msgid "function concept must be called" msgstr "" -#: cp/constexpr.cc:8511 +#: cp/constexpr.cc:8510 #, gcc-internal-format msgid "address of a call to %qs is not a constant expression" msgstr "" -#: cp/constexpr.cc:8576 +#: cp/constexpr.cc:8575 #, gcc-internal-format msgid "unexpected expression %qE of kind %s" msgstr "" -#: cp/constexpr.cc:8852 rust/backend/rust-constexpr.cc:5158 +#: cp/constexpr.cc:8851 rust/backend/rust-constexpr.cc:5158 #, gcc-internal-format msgid "" "%qE is not a constant expression because it refers to mutable subobjects of " "%qT" msgstr "" -#: cp/constexpr.cc:8860 rust/backend/rust-constexpr.cc:5167 +#: cp/constexpr.cc:8859 rust/backend/rust-constexpr.cc:5167 #, gcc-internal-format msgid "" "%qE is not a constant expression because it refers to an incompletely " "initialized variable" msgstr "" -#: cp/constexpr.cc:8876 rust/backend/rust-constexpr.cc:5183 +#: cp/constexpr.cc:8875 rust/backend/rust-constexpr.cc:5183 #, gcc-internal-format msgid "" "%qE is not a constant expression because it refers to a result of %<operator " "new%>" msgstr "" -#: cp/constexpr.cc:8887 rust/backend/rust-constexpr.cc:5195 +#: cp/constexpr.cc:8886 rust/backend/rust-constexpr.cc:5195 #, gcc-internal-format msgid "" "%qE is not a constant expression because allocated storage has not been " "deallocated" msgstr "" -#: cp/constexpr.cc:8907 rust/backend/rust-constexpr.cc:5213 +#: cp/constexpr.cc:8906 rust/backend/rust-constexpr.cc:5213 #, gcc-internal-format msgid "immediate evaluation returns address of immediate function %qD" msgstr "" -#: cp/constexpr.cc:8911 +#: cp/constexpr.cc:8910 #, gcc-internal-format msgid "constant evaluation returns address of immediate function %qD" msgstr "" -#: cp/constexpr.cc:9549 rust/backend/rust-constexpr.cc:5667 +#: cp/constexpr.cc:9548 rust/backend/rust-constexpr.cc:5667 #, gcc-internal-format msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT" msgstr "" -#: cp/constexpr.cc:9778 +#: cp/constexpr.cc:9777 #, gcc-internal-format msgid "lambda capture of %qE is not a constant expression" msgstr "" -#: cp/constexpr.cc:9781 +#: cp/constexpr.cc:9780 #, gcc-internal-format msgid "because it is used as a glvalue" msgstr "" -#: cp/constexpr.cc:9837 rust/backend/rust-constexpr.cc:5893 +#: cp/constexpr.cc:9836 rust/backend/rust-constexpr.cc:5893 #, gcc-internal-format msgid "%<reinterpret_cast%> from integer to pointer" msgstr "" -#: cp/constexpr.cc:9871 rust/backend/rust-constexpr.cc:5921 +#: cp/constexpr.cc:9870 rust/backend/rust-constexpr.cc:5921 #, gcc-internal-format msgid "" "address-of an object %qE with thread local or automatic storage is not a " "constant expression" msgstr "" -#: cp/constexpr.cc:9910 +#: cp/constexpr.cc:9909 #, gcc-internal-format msgid "use of %<this%> in a constant expression" msgstr "" -#: cp/constexpr.cc:10059 +#: cp/constexpr.cc:10058 #, gcc-internal-format msgid "lambda-expression is not a constant expression before C++17" msgstr "" -#: cp/constexpr.cc:10071 +#: cp/constexpr.cc:10070 #, gcc-internal-format msgid "new-expression is not a constant expression before C++20" msgstr "" -#: cp/constexpr.cc:10138 +#: cp/constexpr.cc:10137 #, gcc-internal-format msgid "virtual functions cannot be %<constexpr%> before C++20" msgstr "" -#: cp/constexpr.cc:10154 +#: cp/constexpr.cc:10153 #, gcc-internal-format msgid "" "%<typeid%> is not a constant expression because %qE is of polymorphic type" msgstr "" -#: cp/constexpr.cc:10217 +#: cp/constexpr.cc:10216 #, gcc-internal-format msgid "cast to non-integral type %qT in a constant expression" msgstr "" -#: cp/constexpr.cc:10270 +#: cp/constexpr.cc:10269 #, gcc-internal-format msgid "%qD defined %<thread_local%> in %<constexpr%> context" msgstr "" -#: cp/constexpr.cc:10278 +#: cp/constexpr.cc:10277 #, gcc-internal-format msgid "%qD defined %<static%> in %<constexpr%> context" msgstr "" -#: cp/constexpr.cc:10356 rust/backend/rust-constexpr.cc:6251 +#: cp/constexpr.cc:10355 rust/backend/rust-constexpr.cc:6251 #, gcc-internal-format msgid "division by zero is not a constant expression" msgstr "" -#: cp/constexpr.cc:10457 rust/backend/rust-constexpr.cc:6349 +#: cp/constexpr.cc:10456 rust/backend/rust-constexpr.cc:6349 #, gcc-internal-format msgid "%<delete[]%> is not a constant expression" msgstr "" -#: cp/constexpr.cc:10526 +#: cp/constexpr.cc:10525 #, gcc-internal-format msgid "neither branch of %<if%> is a constant expression" msgstr "" -#: cp/constexpr.cc:10539 +#: cp/constexpr.cc:10538 #, gcc-internal-format msgid "non-constant array initialization" msgstr "" -#: cp/constexpr.cc:10587 rust/backend/rust-constexpr.cc:6427 +#: cp/constexpr.cc:10586 rust/backend/rust-constexpr.cc:6427 #, gcc-internal-format msgid "" "label definition in %<constexpr%> function only available with %<-std=c+" "+2b%> or %<-std=gnu++2b%>" msgstr "" -#: cp/constexpr.cc:10618 rust/backend/rust-constexpr.cc:6438 +#: cp/constexpr.cc:10617 rust/backend/rust-constexpr.cc:6438 #, gcc-internal-format, gfc-internal-format msgid "unexpected AST of kind %s" msgstr "" @@ -56674,301 +56701,301 @@ msgstr "" msgid "nested requirement %qE is not satisfied" msgstr "" -#: cp/constraint.cc:2743 +#: cp/constraint.cc:2744 #, gcc-internal-format msgid "satisfaction of atomic constraint %qE depends on itself" msgstr "" -#: cp/constraint.cc:2789 +#: cp/constraint.cc:2790 #, gcc-internal-format msgid "satisfaction value of atomic constraint %qE changed from %qE to %qE" msgstr "" -#: cp/constraint.cc:2792 +#: cp/constraint.cc:2793 #, gcc-internal-format msgid "satisfaction value first evaluated to %qE from here" msgstr "" -#: cp/constraint.cc:2909 +#: cp/constraint.cc:2910 #, gcc-internal-format msgid "no operand of the disjunction is satisfied" msgstr "" -#: cp/constraint.cc:2922 +#: cp/constraint.cc:2923 #, gcc-internal-format msgid "the operand %qE is unsatisfied because" msgstr "" -#: cp/constraint.cc:3564 +#: cp/constraint.cc:3565 #, gcc-internal-format msgid "definition of concept %qD is empty" msgstr "" -#: cp/constraint.cc:3567 +#: cp/constraint.cc:3568 #, gcc-internal-format msgid "definition of concept %qD has multiple statements" msgstr "" -#: cp/constraint.cc:3723 +#: cp/constraint.cc:3724 #, gcc-internal-format msgid " %qT is not nothrow copy assignable" msgstr "" -#: cp/constraint.cc:3726 cp/constraint.cc:3811 +#: cp/constraint.cc:3727 cp/constraint.cc:3812 #, gcc-internal-format msgid " %qT is not nothrow default constructible" msgstr "" -#: cp/constraint.cc:3729 +#: cp/constraint.cc:3730 #, gcc-internal-format msgid " %qT is not nothrow copy constructible" msgstr "" -#: cp/constraint.cc:3732 +#: cp/constraint.cc:3733 #, gcc-internal-format msgid " %qT is not trivially copy assignable" msgstr "" -#: cp/constraint.cc:3735 cp/constraint.cc:3851 +#: cp/constraint.cc:3736 cp/constraint.cc:3852 #, gcc-internal-format msgid " %qT is not trivially default constructible" msgstr "" -#: cp/constraint.cc:3738 +#: cp/constraint.cc:3739 #, gcc-internal-format msgid " %qT is not trivially copy constructible" msgstr "" -#: cp/constraint.cc:3741 +#: cp/constraint.cc:3742 #, gcc-internal-format msgid " %qT is not trivially destructible" msgstr "" -#: cp/constraint.cc:3744 +#: cp/constraint.cc:3745 #, gcc-internal-format msgid " %qT does not have unique object representations" msgstr "" -#: cp/constraint.cc:3747 +#: cp/constraint.cc:3748 #, gcc-internal-format msgid " %qT does not have a virtual destructor" msgstr "" -#: cp/constraint.cc:3750 +#: cp/constraint.cc:3751 #, gcc-internal-format msgid " %qT is not an abstract class" msgstr "" -#: cp/constraint.cc:3753 +#: cp/constraint.cc:3754 #, gcc-internal-format msgid " %qT is not an aggregate" msgstr "" -#: cp/constraint.cc:3756 +#: cp/constraint.cc:3757 #, gcc-internal-format msgid " %qT is not an array" msgstr "" -#: cp/constraint.cc:3759 +#: cp/constraint.cc:3760 #, gcc-internal-format msgid " %qT is not assignable from %qT" msgstr "" -#: cp/constraint.cc:3762 +#: cp/constraint.cc:3763 #, gcc-internal-format msgid " %qT is not a base of %qT" msgstr "" -#: cp/constraint.cc:3765 +#: cp/constraint.cc:3766 #, gcc-internal-format msgid " %qT is not a bounded array" msgstr "" -#: cp/constraint.cc:3768 +#: cp/constraint.cc:3769 #, gcc-internal-format msgid " %qT is not a class" msgstr "" -#: cp/constraint.cc:3772 +#: cp/constraint.cc:3773 #, gcc-internal-format msgid " %qT is not default constructible" msgstr "" -#: cp/constraint.cc:3774 +#: cp/constraint.cc:3775 #, gcc-internal-format msgid " %qT is not constructible from %qE" msgstr "" -#: cp/constraint.cc:3777 +#: cp/constraint.cc:3778 #, gcc-internal-format msgid " %qT is not convertible from %qE" msgstr "" -#: cp/constraint.cc:3780 +#: cp/constraint.cc:3781 #, gcc-internal-format msgid " %qT is not an empty class" msgstr "" -#: cp/constraint.cc:3783 +#: cp/constraint.cc:3784 #, gcc-internal-format msgid " %qT is not an enum" msgstr "" -#: cp/constraint.cc:3786 +#: cp/constraint.cc:3787 #, gcc-internal-format msgid " %qT is not a final class" msgstr "" -#: cp/constraint.cc:3789 +#: cp/constraint.cc:3790 #, gcc-internal-format msgid " %qT is not a function" msgstr "" -#: cp/constraint.cc:3792 +#: cp/constraint.cc:3793 #, gcc-internal-format msgid " %qT is not layout compatible with %qT" msgstr "" -#: cp/constraint.cc:3795 +#: cp/constraint.cc:3796 #, gcc-internal-format msgid " %qT is not a literal type" msgstr "" -#: cp/constraint.cc:3798 +#: cp/constraint.cc:3799 #, gcc-internal-format msgid " %qT is not a member function pointer" msgstr "" -#: cp/constraint.cc:3801 +#: cp/constraint.cc:3802 #, gcc-internal-format msgid " %qT is not a member object pointer" msgstr "" -#: cp/constraint.cc:3804 +#: cp/constraint.cc:3805 #, gcc-internal-format msgid " %qT is not a member pointer" msgstr "" -#: cp/constraint.cc:3807 +#: cp/constraint.cc:3808 #, gcc-internal-format msgid " %qT is not nothrow assignable from %qT" msgstr "" -#: cp/constraint.cc:3813 +#: cp/constraint.cc:3814 #, gcc-internal-format msgid " %qT is not nothrow constructible from %qE" msgstr "" -#: cp/constraint.cc:3816 +#: cp/constraint.cc:3817 #, gcc-internal-format msgid " %qT is not nothrow convertible from %qE" msgstr "" -#: cp/constraint.cc:3819 +#: cp/constraint.cc:3820 #, gcc-internal-format msgid " %qT is not an object type" msgstr "" -#: cp/constraint.cc:3822 +#: cp/constraint.cc:3823 #, gcc-internal-format msgid " %qT is not pointer-interconvertible base of %qT" msgstr "" -#: cp/constraint.cc:3826 +#: cp/constraint.cc:3827 #, gcc-internal-format msgid " %qT is not a POD type" msgstr "" -#: cp/constraint.cc:3829 +#: cp/constraint.cc:3830 #, gcc-internal-format msgid " %qT is not a polymorphic type" msgstr "" -#: cp/constraint.cc:3832 +#: cp/constraint.cc:3833 #, gcc-internal-format msgid " %qT is not a reference" msgstr "" -#: cp/constraint.cc:3835 +#: cp/constraint.cc:3836 #, gcc-internal-format msgid " %qT is not the same as %qT" msgstr "" -#: cp/constraint.cc:3838 +#: cp/constraint.cc:3839 #, gcc-internal-format msgid " %qT is not a scoped enum" msgstr "" -#: cp/constraint.cc:3841 +#: cp/constraint.cc:3842 #, gcc-internal-format msgid " %qT is not an standard layout type" msgstr "" -#: cp/constraint.cc:3844 +#: cp/constraint.cc:3845 #, gcc-internal-format msgid " %qT is not a trivial type" msgstr "" -#: cp/constraint.cc:3847 +#: cp/constraint.cc:3848 #, gcc-internal-format msgid " %qT is not trivially assignable from %qT" msgstr "" -#: cp/constraint.cc:3853 +#: cp/constraint.cc:3854 #, gcc-internal-format msgid " %qT is not trivially constructible from %qE" msgstr "" -#: cp/constraint.cc:3856 +#: cp/constraint.cc:3857 #, gcc-internal-format msgid " %qT is not trivially copyable" msgstr "" -#: cp/constraint.cc:3859 +#: cp/constraint.cc:3860 #, gcc-internal-format msgid " %qT is not a union" msgstr "" -#: cp/constraint.cc:3862 +#: cp/constraint.cc:3863 #, gcc-internal-format msgid "" " %qT is not a reference that binds to a temporary object of type %qT " "(direct-initialization)" msgstr "" -#: cp/constraint.cc:3866 +#: cp/constraint.cc:3867 #, gcc-internal-format msgid "" " %qT is not a reference that binds to a temporary object of type %qT (copy-" "initialization)" msgstr "" -#: cp/constraint.cc:3870 +#: cp/constraint.cc:3871 #, gcc-internal-format msgid " %qD is not deducible from %qT" msgstr "" -#: cp/constraint.cc:3897 +#: cp/constraint.cc:3898 #, gcc-internal-format msgid "invalid constraints" msgstr "" -#: cp/constraint.cc:3922 +#: cp/constraint.cc:3923 #, gcc-internal-format msgid "constraint %qE has type %qT, not %<bool%>" msgstr "" -#: cp/constraint.cc:3925 +#: cp/constraint.cc:3926 #, gcc-internal-format msgid "the expression %qE evaluated to %<false%>" msgstr "" -#: cp/constraint.cc:3976 +#: cp/constraint.cc:3977 #, gcc-internal-format msgid "constraints not satisfied" msgstr "" -#: cp/constraint.cc:3991 +#: cp/constraint.cc:3992 #, gcc-internal-format msgid "set %qs to at least %d for more detail" msgstr "" @@ -57882,7 +57909,7 @@ msgstr "" msgid "redeclaration %qD differs in %qs from previous declaration" msgstr "" -#: cp/decl.cc:1446 cp/decl.cc:16614 +#: cp/decl.cc:1446 cp/decl.cc:16620 #, gcc-internal-format msgid "previous declaration %qD" msgstr "" @@ -58115,12 +58142,12 @@ msgstr "" msgid "import declared %q#D here" msgstr "" -#: cp/decl.cc:2306 cp/decl.cc:16637 +#: cp/decl.cc:2306 cp/decl.cc:16643 #, gcc-internal-format msgid "conflicting exporting for declaration %qD" msgstr "" -#: cp/decl.cc:2308 cp/decl.cc:16639 +#: cp/decl.cc:2308 cp/decl.cc:16645 #, gcc-internal-format msgid "previously declared here without exporting" msgstr "" @@ -58763,8 +58790,8 @@ msgstr "" msgid "C99 designator %qE outside aggregate initializer" msgstr "" -#: cp/decl.cc:7218 cp/decl.cc:7506 cp/typeck2.cc:1616 cp/typeck2.cc:1946 -#: cp/typeck2.cc:1994 cp/typeck2.cc:2041 +#: cp/decl.cc:7218 cp/decl.cc:7506 cp/typeck2.cc:1593 cp/typeck2.cc:1923 +#: cp/typeck2.cc:1971 cp/typeck2.cc:2018 #, gcc-internal-format msgid "too many initializers for %qT" msgstr "" @@ -58880,17 +58907,17 @@ msgstr "" msgid "assignment (not initialization) in declaration" msgstr "" -#: cp/decl.cc:8457 cp/decl.cc:15228 +#: cp/decl.cc:8457 cp/decl.cc:15234 #, gcc-internal-format msgid "ISO C++17 does not allow %<register%> storage class specifier" msgstr "" -#: cp/decl.cc:8461 cp/decl.cc:15232 +#: cp/decl.cc:8461 cp/decl.cc:15238 #, gcc-internal-format msgid "%<register%> storage class specifier used" msgstr "" -#: cp/decl.cc:8506 cp/decl.cc:15195 +#: cp/decl.cc:8506 cp/decl.cc:15201 #, gcc-internal-format msgid "declaration of %q#D has no initializer" msgstr "" @@ -59670,7 +59697,7 @@ msgstr "" msgid "function definition does not declare parameters" msgstr "" -#: cp/decl.cc:12450 cp/decl.cc:12459 cp/decl.cc:14438 +#: cp/decl.cc:12450 cp/decl.cc:12459 cp/decl.cc:14444 #, gcc-internal-format msgid "declaration of %qD as non-function" msgstr "" @@ -59874,7 +59901,7 @@ msgstr "" msgid "storage class specifiers invalid in friend function declarations" msgstr "" -#: cp/decl.cc:13204 cp/decl.cc:14828 cp/parser.cc:15434 cp/parser.cc:21379 +#: cp/decl.cc:13204 cp/decl.cc:14834 cp/parser.cc:15434 cp/parser.cc:21379 #: cp/parser.cc:28062 #, gcc-internal-format msgid "attribute ignored" @@ -60113,697 +60140,702 @@ msgstr "" msgid "an explicit object member function cannot be %<static%>" msgstr "" -#: cp/decl.cc:13752 +#: cp/decl.cc:13735 +#, gcc-internal-format +msgid "%qD cannot be an explicit object member function" +msgstr "" + +#: cp/decl.cc:13758 #, gcc-internal-format msgid "destructors may not have parameters" msgstr "" -#: cp/decl.cc:13810 +#: cp/decl.cc:13816 #, gcc-internal-format msgid "cannot declare pointer to %q#T" msgstr "" -#: cp/decl.cc:13823 cp/decl.cc:13830 +#: cp/decl.cc:13829 cp/decl.cc:13836 #, gcc-internal-format msgid "cannot declare reference to %q#T" msgstr "" -#: cp/decl.cc:13832 +#: cp/decl.cc:13838 #, gcc-internal-format msgid "cannot declare pointer to %q#T member" msgstr "" -#: cp/decl.cc:13861 +#: cp/decl.cc:13867 #, gcc-internal-format msgid "cannot declare reference to qualified function type %qT" msgstr "" -#: cp/decl.cc:13862 +#: cp/decl.cc:13868 #, gcc-internal-format msgid "cannot declare pointer to qualified function type %qT" msgstr "" -#: cp/decl.cc:13935 +#: cp/decl.cc:13941 #, gcc-internal-format msgid "" "cannot declare reference to %q#T, which is not a typedef or a template type " "argument" msgstr "" -#: cp/decl.cc:14015 +#: cp/decl.cc:14021 #, gcc-internal-format msgid "template-id %qD used as a declarator" msgstr "" -#: cp/decl.cc:14041 +#: cp/decl.cc:14047 #, gcc-internal-format msgid "member functions are implicitly friends of their class" msgstr "" -#: cp/decl.cc:14046 +#: cp/decl.cc:14052 #, gcc-internal-format msgid "extra qualification %<%T::%> on member %qs" msgstr "" -#: cp/decl.cc:14076 +#: cp/decl.cc:14082 #, gcc-internal-format msgid "cannot define member function %<%T::%s%> within %qT" msgstr "" -#: cp/decl.cc:14078 +#: cp/decl.cc:14084 #, gcc-internal-format msgid "cannot declare member function %<%T::%s%> within %qT" msgstr "" -#: cp/decl.cc:14086 +#: cp/decl.cc:14092 #, gcc-internal-format msgid "cannot declare member %<%T::%s%> within %qT" msgstr "" -#: cp/decl.cc:14126 +#: cp/decl.cc:14132 #, gcc-internal-format msgid "non-parameter %qs cannot be a parameter pack" msgstr "" -#: cp/decl.cc:14135 +#: cp/decl.cc:14141 #, gcc-internal-format msgid "data member may not have variably modified type %qT" msgstr "" -#: cp/decl.cc:14138 +#: cp/decl.cc:14144 #, gcc-internal-format msgid "parameter may not have variably modified type %qT" msgstr "" -#: cp/decl.cc:14149 +#: cp/decl.cc:14155 #, gcc-internal-format msgid "%<explicit%> outside class declaration" msgstr "" -#: cp/decl.cc:14152 +#: cp/decl.cc:14158 #, gcc-internal-format msgid "%<explicit%> in friend declaration" msgstr "" -#: cp/decl.cc:14155 +#: cp/decl.cc:14161 #, gcc-internal-format msgid "" "only declarations of constructors and conversion operators can be " "%<explicit%>" msgstr "" -#: cp/decl.cc:14165 +#: cp/decl.cc:14171 #, gcc-internal-format msgid "non-member %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.cc:14172 +#: cp/decl.cc:14178 #, gcc-internal-format msgid "non-object member %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.cc:14178 +#: cp/decl.cc:14184 #, gcc-internal-format msgid "function %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.cc:14184 +#: cp/decl.cc:14190 #, gcc-internal-format msgid "%<static%> %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.cc:14190 +#: cp/decl.cc:14196 #, gcc-internal-format msgid "%<const%> %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.cc:14196 +#: cp/decl.cc:14202 #, gcc-internal-format msgid "reference %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.cc:14212 +#: cp/decl.cc:14218 #, gcc-internal-format msgid "typedef may not be a function definition" msgstr "" -#: cp/decl.cc:14215 +#: cp/decl.cc:14221 #, gcc-internal-format msgid "typedef may not be a member function definition" msgstr "" -#: cp/decl.cc:14241 +#: cp/decl.cc:14247 #, gcc-internal-format msgid "%<auto%> not allowed in alias declaration" msgstr "" -#: cp/decl.cc:14244 +#: cp/decl.cc:14250 #, gcc-internal-format msgid "typedef declared %<auto%>" msgstr "" -#: cp/decl.cc:14249 +#: cp/decl.cc:14255 #, gcc-internal-format msgid "requires-clause on typedef" msgstr "" -#: cp/decl.cc:14253 +#: cp/decl.cc:14259 #, gcc-internal-format msgid "typedef name may not be a nested-name-specifier" msgstr "" -#: cp/decl.cc:14279 +#: cp/decl.cc:14285 #, gcc-internal-format msgid "ISO C++ forbids nested type %qD with same name as enclosing class" msgstr "" -#: cp/decl.cc:14368 +#: cp/decl.cc:14374 #, gcc-internal-format msgid "%<inline%> specified for friend class declaration" msgstr "" -#: cp/decl.cc:14376 +#: cp/decl.cc:14382 #, gcc-internal-format msgid "template parameters cannot be friends" msgstr "" -#: cp/decl.cc:14378 +#: cp/decl.cc:14384 #, gcc-internal-format msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>" msgstr "" -#: cp/decl.cc:14382 +#: cp/decl.cc:14388 #, gcc-internal-format msgid "friend declaration requires class-key, i.e. %<friend %#T%>" msgstr "" -#: cp/decl.cc:14395 +#: cp/decl.cc:14401 #, gcc-internal-format msgid "trying to make class %qT a friend of global scope" msgstr "" -#: cp/decl.cc:14415 +#: cp/decl.cc:14421 #, gcc-internal-format msgid "invalid qualifiers on non-member function type" msgstr "" -#: cp/decl.cc:14419 +#: cp/decl.cc:14425 #, gcc-internal-format msgid "requires-clause on type-id" msgstr "" -#: cp/decl.cc:14429 +#: cp/decl.cc:14435 #, gcc-internal-format msgid "abstract declarator %qT used as declaration" msgstr "" -#: cp/decl.cc:14444 +#: cp/decl.cc:14450 #, gcc-internal-format msgid "requires-clause on declaration of non-function type %qT" msgstr "" -#: cp/decl.cc:14463 +#: cp/decl.cc:14469 #, gcc-internal-format msgid "cannot use %<::%> in parameter declaration" msgstr "" -#: cp/decl.cc:14473 cp/parser.cc:20813 +#: cp/decl.cc:14479 cp/parser.cc:20813 #, gcc-internal-format msgid "cannot declare a parameter with %<decltype(auto)%>" msgstr "" -#: cp/decl.cc:14480 +#: cp/decl.cc:14486 #, gcc-internal-format msgid "" "missing template argument list after %qE; template placeholder not permitted " "in parameter" msgstr "" -#: cp/decl.cc:14483 +#: cp/decl.cc:14489 #, gcc-internal-format msgid "or use %<auto%> for an abbreviated function template" msgstr "" -#: cp/decl.cc:14489 cp/parser.cc:25355 +#: cp/decl.cc:14495 cp/parser.cc:25355 #, gcc-internal-format msgid "%<auto%> parameter not permitted in this context" msgstr "" -#: cp/decl.cc:14499 +#: cp/decl.cc:14505 #, gcc-internal-format msgid "parameter declared %<auto%>" msgstr "" -#: cp/decl.cc:14553 cp/parser.cc:3687 +#: cp/decl.cc:14559 cp/parser.cc:3687 #, gcc-internal-format msgid "invalid use of template-name %qE without an argument list" msgstr "" -#: cp/decl.cc:14557 +#: cp/decl.cc:14563 #, gcc-internal-format msgid "non-static data member declared with placeholder %qT" msgstr "" -#: cp/decl.cc:14578 +#: cp/decl.cc:14584 #, gcc-internal-format msgid "ISO C++ forbids flexible array member %qs" msgstr "" -#: cp/decl.cc:14581 +#: cp/decl.cc:14587 #, gcc-internal-format msgid "ISO C++ forbids flexible array members" msgstr "" #. Something like struct S { int N::j; }; -#: cp/decl.cc:14597 +#: cp/decl.cc:14603 #, gcc-internal-format msgid "invalid use of %<::%>" msgstr "" -#: cp/decl.cc:14618 +#: cp/decl.cc:14624 #, gcc-internal-format msgid "declaration of function %qD in invalid context" msgstr "" -#: cp/decl.cc:14628 +#: cp/decl.cc:14634 #, gcc-internal-format msgid "function %qD declared %<virtual%> inside a union" msgstr "" -#: cp/decl.cc:14638 +#: cp/decl.cc:14644 #, gcc-internal-format msgid "%qD cannot be declared %<virtual%>, since it is always static" msgstr "" -#: cp/decl.cc:14652 +#: cp/decl.cc:14658 #, gcc-internal-format msgid "expected qualified name in friend declaration for destructor %qD" msgstr "" -#: cp/decl.cc:14659 +#: cp/decl.cc:14665 #, gcc-internal-format msgid "declaration of %qD as member of %qT" msgstr "" -#: cp/decl.cc:14666 cp/decl.cc:14679 +#: cp/decl.cc:14672 cp/decl.cc:14685 #, gcc-internal-format msgid "a destructor cannot be %qs" msgstr "" -#: cp/decl.cc:14685 +#: cp/decl.cc:14691 #, gcc-internal-format msgid "expected qualified name in friend declaration for constructor %qD" msgstr "" -#: cp/decl.cc:14694 +#: cp/decl.cc:14700 #, gcc-internal-format msgid "a constructor cannot be %<concept%>" msgstr "" -#: cp/decl.cc:14700 +#: cp/decl.cc:14706 #, gcc-internal-format msgid "a concept cannot be a member function" msgstr "" -#: cp/decl.cc:14708 cp/decl.cc:15063 +#: cp/decl.cc:14714 cp/decl.cc:15069 #, gcc-internal-format msgid "%qD cannot be %qs" msgstr "" -#: cp/decl.cc:14717 +#: cp/decl.cc:14723 #, gcc-internal-format msgid "specialization of variable template %qD declared as function" msgstr "" -#: cp/decl.cc:14720 +#: cp/decl.cc:14726 #, gcc-internal-format msgid "variable template declared here" msgstr "" -#: cp/decl.cc:14783 +#: cp/decl.cc:14789 #, gcc-internal-format msgid "field %qD has incomplete type %qT" msgstr "" -#: cp/decl.cc:14788 +#: cp/decl.cc:14794 #, gcc-internal-format msgid "name %qT has incomplete type" msgstr "" -#: cp/decl.cc:14808 +#: cp/decl.cc:14814 #, gcc-internal-format msgid "%qE is neither function nor member function; cannot be declared friend" msgstr "" -#: cp/decl.cc:14811 +#: cp/decl.cc:14817 #, gcc-internal-format msgid "" "unnamed field is neither function nor member function; cannot be declared " "friend" msgstr "" -#: cp/decl.cc:14829 cp/parser.cc:21380 cp/parser.cc:28063 +#: cp/decl.cc:14835 cp/parser.cc:21380 cp/parser.cc:28063 #, gcc-internal-format msgid "" "an attribute that appertains to a friend declaration that is not a " "definition is ignored" msgstr "" -#: cp/decl.cc:14879 cp/decl.cc:14890 +#: cp/decl.cc:14885 cp/decl.cc:14896 #, gcc-internal-format msgid "static data member %qE declared %qs" msgstr "" -#: cp/decl.cc:14884 +#: cp/decl.cc:14890 #, gcc-internal-format msgid "%<constexpr%> static data member %qD must have an initializer" msgstr "" -#: cp/decl.cc:14927 cp/decl.cc:14935 cp/decl.cc:14942 cp/decl.cc:14949 +#: cp/decl.cc:14933 cp/decl.cc:14941 cp/decl.cc:14948 cp/decl.cc:14955 #, gcc-internal-format msgid "non-static data member %qE declared %qs" msgstr "" -#: cp/decl.cc:15001 +#: cp/decl.cc:15007 #, gcc-internal-format msgid "storage class %<auto%> invalid for function %qs" msgstr "" -#: cp/decl.cc:15004 +#: cp/decl.cc:15010 #, gcc-internal-format msgid "storage class %<register%> invalid for function %qs" msgstr "" -#: cp/decl.cc:15010 +#: cp/decl.cc:15016 #, gcc-internal-format msgid "storage class %<__thread%> invalid for function %qs" msgstr "" -#: cp/decl.cc:15014 +#: cp/decl.cc:15020 #, gcc-internal-format msgid "storage class %<thread_local%> invalid for function %qs" msgstr "" -#: cp/decl.cc:15019 +#: cp/decl.cc:15025 #, gcc-internal-format msgid "%<constinit%> specifier invalid for function %qs" msgstr "" -#: cp/decl.cc:15022 +#: cp/decl.cc:15028 #, gcc-internal-format msgid "virt-specifiers in %qs not allowed outside a class definition" msgstr "" -#: cp/decl.cc:15034 +#: cp/decl.cc:15040 #, gcc-internal-format msgid "" "%<static%> specifier invalid for function %qs declared out of global scope" msgstr "" -#: cp/decl.cc:15038 +#: cp/decl.cc:15044 #, gcc-internal-format msgid "" "%<inline%> specifier invalid for function %qs declared out of global scope" msgstr "" -#: cp/decl.cc:15046 +#: cp/decl.cc:15052 #, gcc-internal-format msgid "virtual non-class function %qs" msgstr "" -#: cp/decl.cc:15053 +#: cp/decl.cc:15059 #, gcc-internal-format msgid "%qs defined in a non-class scope" msgstr "" -#: cp/decl.cc:15054 +#: cp/decl.cc:15060 #, gcc-internal-format msgid "%qs declared in a non-class scope" msgstr "" -#: cp/decl.cc:15097 +#: cp/decl.cc:15103 #, gcc-internal-format msgid "cannot declare member function %qD to have static linkage" msgstr "" -#: cp/decl.cc:15106 +#: cp/decl.cc:15112 #, gcc-internal-format msgid "cannot declare static function inside another function" msgstr "" -#: cp/decl.cc:15147 +#: cp/decl.cc:15153 #, gcc-internal-format msgid "" "%<static%> may not be used when defining (as opposed to declaring) a static " "data member" msgstr "" -#: cp/decl.cc:15154 +#: cp/decl.cc:15160 #, gcc-internal-format msgid "static member %qD declared %<register%>" msgstr "" -#: cp/decl.cc:15160 +#: cp/decl.cc:15166 #, gcc-internal-format msgid "cannot explicitly declare member %q#D to have extern linkage" msgstr "" -#: cp/decl.cc:15168 +#: cp/decl.cc:15174 #, gcc-internal-format msgid "declaration of %<constexpr%> variable %qD is not a definition" msgstr "" -#: cp/decl.cc:15175 +#: cp/decl.cc:15181 #, gcc-internal-format msgid "a variable cannot be declared %<consteval%>" msgstr "" -#: cp/decl.cc:15207 +#: cp/decl.cc:15213 #, gcc-internal-format msgid "%qs initialized and declared %<extern%>" msgstr "" -#: cp/decl.cc:15212 +#: cp/decl.cc:15218 #, gcc-internal-format msgid "%qs has both %<extern%> and initializer" msgstr "" -#: cp/decl.cc:15414 +#: cp/decl.cc:15420 #, gcc-internal-format msgid "default argument %qE uses %qD" msgstr "" -#: cp/decl.cc:15417 +#: cp/decl.cc:15423 #, gcc-internal-format msgid "default argument %qE uses local variable %qD" msgstr "" -#: cp/decl.cc:15544 +#: cp/decl.cc:15550 #, gcc-internal-format msgid "invalid use of cv-qualified type %qT in parameter declaration" msgstr "" -#: cp/decl.cc:15548 +#: cp/decl.cc:15554 #, gcc-internal-format msgid "invalid use of type %<void%> in parameter declaration" msgstr "" -#: cp/decl.cc:15577 +#: cp/decl.cc:15583 #, gcc-internal-format msgid "%<volatile%>-qualified parameter is deprecated" msgstr "" -#: cp/decl.cc:15585 +#: cp/decl.cc:15591 #, gcc-internal-format msgid "parameter %qD invalidly declared method type" msgstr "" -#: cp/decl.cc:15610 +#: cp/decl.cc:15616 #, gcc-internal-format msgid "parameter %qD includes pointer to array of unknown bound %qT" msgstr "" -#: cp/decl.cc:15612 +#: cp/decl.cc:15618 #, gcc-internal-format msgid "parameter %qD includes reference to array of unknown bound %qT" msgstr "" -#: cp/decl.cc:15895 +#: cp/decl.cc:15901 #, gcc-internal-format msgid "invalid constructor; you probably meant %<%T (const %T&)%>" msgstr "" -#: cp/decl.cc:15974 +#: cp/decl.cc:15980 #, gcc-internal-format msgid "%qD may not be declared within a namespace" msgstr "" -#: cp/decl.cc:15981 +#: cp/decl.cc:15987 #, gcc-internal-format msgid "%qD may not be declared as static" msgstr "" -#: cp/decl.cc:16009 +#: cp/decl.cc:16015 #, gcc-internal-format msgid "%qD must be a non-static member function" msgstr "" -#: cp/decl.cc:16017 +#: cp/decl.cc:16023 #, gcc-internal-format msgid "%qD must be a member function" msgstr "" -#: cp/decl.cc:16025 +#: cp/decl.cc:16031 #, gcc-internal-format msgid "" "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu+" "+23%>" msgstr "" -#: cp/decl.cc:16035 +#: cp/decl.cc:16041 #, gcc-internal-format msgid "" "%qD must be either a non-static member function or a non-member function" msgstr "" -#: cp/decl.cc:16045 +#: cp/decl.cc:16051 #, gcc-internal-format msgid "%qD must have an argument of class or enumerated type" msgstr "" #. 13.4.0.3 -#: cp/decl.cc:16076 +#: cp/decl.cc:16082 #, gcc-internal-format msgid "ISO C++ prohibits overloading %<operator ?:%>" msgstr "" -#: cp/decl.cc:16086 +#: cp/decl.cc:16092 #, gcc-internal-format msgid "%qD must not have variable number of arguments" msgstr "" -#: cp/decl.cc:16112 +#: cp/decl.cc:16118 #, gcc-internal-format msgid "%qD must have either zero or one argument" msgstr "" -#: cp/decl.cc:16113 +#: cp/decl.cc:16119 #, gcc-internal-format msgid "%qD must have either one or two arguments" msgstr "" -#: cp/decl.cc:16125 +#: cp/decl.cc:16131 #, gcc-internal-format msgid "postfix %qD must have %<int%> as its argument" msgstr "" -#: cp/decl.cc:16126 +#: cp/decl.cc:16132 #, gcc-internal-format msgid "postfix %qD must have %<int%> as its second argument" msgstr "" -#: cp/decl.cc:16137 +#: cp/decl.cc:16143 #, gcc-internal-format msgid "%qD must have no arguments" msgstr "" -#: cp/decl.cc:16138 cp/decl.cc:16148 +#: cp/decl.cc:16144 cp/decl.cc:16154 #, gcc-internal-format msgid "%qD must have exactly one argument" msgstr "" -#: cp/decl.cc:16149 +#: cp/decl.cc:16155 #, gcc-internal-format msgid "%qD must have exactly two arguments" msgstr "" -#: cp/decl.cc:16164 +#: cp/decl.cc:16170 #, gcc-internal-format msgid "%qD cannot have default arguments" msgstr "" -#: cp/decl.cc:16188 +#: cp/decl.cc:16194 #, gcc-internal-format msgid "converting %qT to %<void%> will never use a type conversion operator" msgstr "" -#: cp/decl.cc:16195 +#: cp/decl.cc:16201 #, gcc-internal-format msgid "" "converting %qT to a reference to the same type will never use a type " "conversion operator" msgstr "" -#: cp/decl.cc:16197 +#: cp/decl.cc:16203 #, gcc-internal-format msgid "" "converting %qT to the same type will never use a type conversion operator" msgstr "" -#: cp/decl.cc:16206 +#: cp/decl.cc:16212 #, gcc-internal-format msgid "" "converting %qT to a reference to a base class %qT will never use a type " "conversion operator" msgstr "" -#: cp/decl.cc:16208 +#: cp/decl.cc:16214 #, gcc-internal-format msgid "" "converting %qT to a base class %qT will never use a type conversion operator" msgstr "" -#: cp/decl.cc:16224 +#: cp/decl.cc:16230 #, gcc-internal-format msgid "user-defined %qD always evaluates both arguments" msgstr "" -#: cp/decl.cc:16243 +#: cp/decl.cc:16249 #, gcc-internal-format msgid "prefix %qD should return %qT" msgstr "" -#: cp/decl.cc:16250 +#: cp/decl.cc:16256 #, gcc-internal-format msgid "postfix %qD should return %qT" msgstr "" -#: cp/decl.cc:16262 +#: cp/decl.cc:16268 #, gcc-internal-format msgid "%qD should return by value" msgstr "" -#: cp/decl.cc:16317 +#: cp/decl.cc:16323 #, gcc-internal-format msgid "using template type parameter %qT after %qs" msgstr "" -#: cp/decl.cc:16340 +#: cp/decl.cc:16346 #, gcc-internal-format msgid "using alias template specialization %qT after %qs" msgstr "" -#: cp/decl.cc:16343 +#: cp/decl.cc:16349 #, gcc-internal-format msgid "using typedef-name %qD after %qs" msgstr "" -#: cp/decl.cc:16345 +#: cp/decl.cc:16351 #, gcc-internal-format msgid "%qD has a previous declaration here" msgstr "" -#: cp/decl.cc:16353 +#: cp/decl.cc:16359 #, gcc-internal-format msgid "%qT referred to as %qs" msgstr "" -#: cp/decl.cc:16354 cp/decl.cc:16361 +#: cp/decl.cc:16360 cp/decl.cc:16367 #, gcc-internal-format msgid "%qT has a previous declaration here" msgstr "" -#: cp/decl.cc:16360 +#: cp/decl.cc:16366 #, gcc-internal-format msgid "%qT referred to as enum" msgstr "" @@ -60815,115 +60847,115 @@ msgstr "" #. void f(class C); // No template header here #. #. then the required template argument is missing. -#: cp/decl.cc:16375 +#: cp/decl.cc:16381 #, gcc-internal-format msgid "template argument required for %<%s %T%>" msgstr "" -#: cp/decl.cc:16418 cp/name-lookup.cc:6074 cp/name-lookup.cc:6206 +#: cp/decl.cc:16424 cp/name-lookup.cc:6074 cp/name-lookup.cc:6206 #: cp/parser.cc:7215 cp/parser.cc:32113 #, gcc-internal-format msgid "reference to %qD is ambiguous" msgstr "" -#: cp/decl.cc:16427 +#: cp/decl.cc:16433 #, gcc-internal-format msgid "class template %qD redeclared as non-template" msgstr "" -#: cp/decl.cc:16449 cp/name-lookup.cc:5764 +#: cp/decl.cc:16455 cp/name-lookup.cc:5764 #, gcc-internal-format msgid "%qD has the same name as the class in which it is declared" msgstr "" -#: cp/decl.cc:16477 cp/friend.cc:317 cp/parser.cc:3512 cp/parser.cc:6920 -#: cp/pt.cc:9971 +#: cp/decl.cc:16483 cp/friend.cc:317 cp/parser.cc:3512 cp/parser.cc:6920 +#: cp/pt.cc:9992 #, gcc-internal-format msgid "%qT is not a template" msgstr "" -#: cp/decl.cc:16482 +#: cp/decl.cc:16488 #, gcc-internal-format msgid "perhaps you want to explicitly add %<%T::%>" msgstr "" -#: cp/decl.cc:16587 +#: cp/decl.cc:16593 #, gcc-internal-format msgid "use of enum %q#D without previous declaration" msgstr "" -#: cp/decl.cc:16613 +#: cp/decl.cc:16619 #, gcc-internal-format msgid "redeclaration of %qT as a non-template" msgstr "" -#: cp/decl.cc:16625 cp/semantics.cc:3777 +#: cp/decl.cc:16631 cp/semantics.cc:3781 #, gcc-internal-format msgid "cannot declare %qD in a different module" msgstr "" -#: cp/decl.cc:16626 cp/decl.cc:16979 lto/lto-symtab.cc:865 +#: cp/decl.cc:16632 cp/decl.cc:16985 lto/lto-symtab.cc:865 #, gcc-internal-format msgid "previously declared here" msgstr "" -#: cp/decl.cc:16753 +#: cp/decl.cc:16759 #, gcc-internal-format msgid "derived union %qT invalid" msgstr "" -#: cp/decl.cc:16760 +#: cp/decl.cc:16766 #, gcc-internal-format msgid "%qT defined with multiple direct bases" msgstr "" -#: cp/decl.cc:16771 +#: cp/decl.cc:16777 #, gcc-internal-format msgid "%qT defined with direct virtual base" msgstr "" -#: cp/decl.cc:16796 +#: cp/decl.cc:16802 #, gcc-internal-format msgid "base type %qT fails to be a struct or class type" msgstr "" -#: cp/decl.cc:16826 +#: cp/decl.cc:16832 #, gcc-internal-format msgid "recursive type %qT undefined" msgstr "" -#: cp/decl.cc:16828 +#: cp/decl.cc:16834 #, gcc-internal-format msgid "duplicate base type %qT invalid" msgstr "" -#: cp/decl.cc:16978 +#: cp/decl.cc:16984 #, gcc-internal-format msgid "cannot declare %qD in different module" msgstr "" -#: cp/decl.cc:16991 +#: cp/decl.cc:16997 #, gcc-internal-format msgid "scoped/unscoped mismatch in enum %q#T" msgstr "" -#: cp/decl.cc:16994 cp/decl.cc:17003 cp/decl.cc:17014 cp/decl.cc:17606 +#: cp/decl.cc:17000 cp/decl.cc:17009 cp/decl.cc:17020 cp/decl.cc:17612 #: cp/parser.cc:21734 #, gcc-internal-format msgid "previous definition here" msgstr "" -#: cp/decl.cc:17000 +#: cp/decl.cc:17006 #, gcc-internal-format msgid "underlying type mismatch in enum %q#T" msgstr "" -#: cp/decl.cc:17011 +#: cp/decl.cc:17017 #, gcc-internal-format msgid "different underlying type in enum %q#T" msgstr "" -#: cp/decl.cc:17084 +#: cp/decl.cc:17090 #, gcc-internal-format msgid "underlying type %qT of %qT must be an integral type" msgstr "" @@ -60932,83 +60964,83 @@ msgstr "" #. #. IF no integral type can represent all the enumerator values, the #. enumeration is ill-formed. -#: cp/decl.cc:17233 +#: cp/decl.cc:17239 #, gcc-internal-format msgid "no integral type can represent all of the enumerator values for %qT" msgstr "" -#: cp/decl.cc:17414 +#: cp/decl.cc:17420 #, gcc-internal-format msgid "" "enumerator value for %qD must have integral or unscoped enumeration type" msgstr "" -#: cp/decl.cc:17424 +#: cp/decl.cc:17430 #, gcc-internal-format msgid "enumerator value for %qD is not an integer constant" msgstr "" -#: cp/decl.cc:17473 +#: cp/decl.cc:17479 #, gcc-internal-format msgid "incremented enumerator value is too large for %<unsigned long%>" msgstr "" -#: cp/decl.cc:17474 +#: cp/decl.cc:17480 #, gcc-internal-format msgid "incremented enumerator value is too large for %<long%>" msgstr "" -#: cp/decl.cc:17485 +#: cp/decl.cc:17491 #, gcc-internal-format msgid "overflow in enumeration values at %qD" msgstr "" -#: cp/decl.cc:17505 +#: cp/decl.cc:17511 #, gcc-internal-format msgid "enumerator value %qE is outside the range of underlying type %qT" msgstr "" -#: cp/decl.cc:17604 cp/parser.cc:21732 +#: cp/decl.cc:17610 cp/parser.cc:21732 #, gcc-internal-format msgid "multiple definition of %q#T" msgstr "" -#: cp/decl.cc:17678 +#: cp/decl.cc:17684 #, gcc-internal-format msgid "return type %q#T is incomplete" msgstr "" -#: cp/decl.cc:17836 cp/typeck.cc:11241 +#: cp/decl.cc:17842 cp/typeck.cc:11241 #, gcc-internal-format msgid "%<operator=%> should return a reference to %<*this%>" msgstr "" -#: cp/decl.cc:18666 +#: cp/decl.cc:18672 #, gcc-internal-format msgid "no return statements in function returning %qT" msgstr "" -#: cp/decl.cc:18668 cp/typeck.cc:11121 +#: cp/decl.cc:18674 cp/typeck.cc:11121 #, gcc-internal-format msgid "only plain %<auto%> return type can be deduced to %<void%>" msgstr "" -#: cp/decl.cc:18728 +#: cp/decl.cc:18734 #, gcc-internal-format msgid "no return statement in %<constexpr%> function returning non-void" msgstr "" -#: cp/decl.cc:18908 +#: cp/decl.cc:18914 #, gcc-internal-format msgid "%qD is already defined in class %qT" msgstr "" -#: cp/decl.cc:19298 +#: cp/decl.cc:19304 #, gcc-internal-format msgid "using %qs" msgstr "" -#: cp/decl.cc:19310 +#: cp/decl.cc:19316 #, gcc-internal-format msgid "use of %qD before deduction of %<auto%>" msgstr "" @@ -61066,7 +61098,7 @@ msgstr "" msgid "deleting %qT is undefined" msgstr "" -#: cp/decl2.cc:768 cp/pt.cc:5940 +#: cp/decl2.cc:768 cp/pt.cc:5961 #, gcc-internal-format msgid "template declaration of %q#D" msgstr "" @@ -61077,7 +61109,7 @@ msgid "" "template parameter lists provided don%'t match the template parameters of %qD" msgstr "" -#: cp/decl2.cc:823 cp/pt.cc:5908 +#: cp/decl2.cc:823 cp/pt.cc:5929 #, gcc-internal-format msgid "destructor %qD declared as member template" msgstr "" @@ -61911,7 +61943,7 @@ msgstr "" msgid "array must be initialized with a brace-enclosed initializer" msgstr "" -#: cp/init.cc:2366 cp/semantics.cc:4054 rust/backend/rust-tree.cc:4168 +#: cp/init.cc:2366 cp/semantics.cc:4058 rust/backend/rust-tree.cc:4168 #, gcc-internal-format msgid "%qT is not a class type" msgstr "" @@ -61931,7 +61963,7 @@ msgstr "" msgid "invalid use of non-static member function %qD" msgstr "" -#: cp/init.cc:2531 cp/semantics.cc:2373 +#: cp/init.cc:2531 cp/semantics.cc:2377 #, gcc-internal-format msgid "invalid use of non-static data member %qD" msgstr "" @@ -62551,282 +62583,282 @@ msgid "" "match the implicit exception-specification %qX" msgstr "" -#: cp/method.cc:3423 +#: cp/method.cc:3426 #, gcc-internal-format msgid "defaulted declaration %q+D does not match the expected signature" msgstr "" -#: cp/method.cc:3426 +#: cp/method.cc:3429 #, gcc-internal-format msgid "expected signature: %qD" msgstr "" -#: cp/method.cc:3458 +#: cp/method.cc:3461 #, gcc-internal-format msgid "" "explicitly defaulted function %q+D cannot be declared %qs because the " "implicit declaration is not %qs:" msgstr "" -#: cp/method.cc:3478 +#: cp/method.cc:3481 #, gcc-internal-format msgid "a template cannot be defaulted" msgstr "" -#: cp/method.cc:3517 +#: cp/method.cc:3520 #, gcc-internal-format msgid "%qD cannot be defaulted" msgstr "" -#: cp/method.cc:3526 +#: cp/method.cc:3529 #, gcc-internal-format msgid "defaulted function %q+D with default argument" msgstr "" -#: cp/module.cc:1549 +#: cp/module.cc:1583 #, gcc-internal-format msgid "section %qs is missing or corrupted" msgstr "" -#: cp/module.cc:1551 +#: cp/module.cc:1585 #, gcc-internal-format, gfc-internal-format msgid "section #%u is missing or corrupted" msgstr "" -#: cp/module.cc:1773 +#: cp/module.cc:1807 #, gcc-internal-format msgid "not Encapsulated Lazy Records of Named Declarations" msgstr "" -#: cp/module.cc:1788 +#: cp/module.cc:1822 #, gcc-internal-format msgid "unexpected encapsulation format or type" msgstr "" -#: cp/module.cc:1797 +#: cp/module.cc:1831 #, gcc-internal-format msgid "encapsulation is malformed" msgstr "" -#: cp/module.cc:11377 +#: cp/module.cc:11577 #, gcc-internal-format msgid "conflicting global module declaration %#qD" msgstr "" -#: cp/module.cc:11379 +#: cp/module.cc:11579 #, gcc-internal-format msgid "existing declaration %#qD" msgstr "" -#: cp/module.cc:12419 +#: cp/module.cc:12626 #, gcc-internal-format msgid "definition of %qD does not match" msgstr "" -#: cp/module.cc:12421 +#: cp/module.cc:12628 #, gcc-internal-format msgid "existing definition %qD" msgstr "" -#: cp/module.cc:12433 +#: cp/module.cc:12640 #, gcc-internal-format msgid "... this enumerator %qD" msgstr "" -#: cp/module.cc:12435 +#: cp/module.cc:12642 #, gcc-internal-format msgid "enumerator %qD does not match ..." msgstr "" -#: cp/module.cc:12441 +#: cp/module.cc:12648 #, gcc-internal-format msgid "additional enumerators beginning with %qD" msgstr "" -#: cp/module.cc:12445 +#: cp/module.cc:12652 #, gcc-internal-format msgid "enumeration range differs" msgstr "" -#: cp/module.cc:13540 +#: cp/module.cc:13747 #, gcc-internal-format msgid "%q#D references internal linkage entity %q#D" msgstr "" -#: cp/module.cc:14123 +#: cp/module.cc:14330 #, gcc-internal-format msgid "recursive lazy load" msgstr "" #. Cannot import the current module. -#: cp/module.cc:14142 +#: cp/module.cc:14349 #, gcc-internal-format msgid "cannot import module in its own purview" msgstr "" -#: cp/module.cc:14143 cp/module.cc:19380 +#: cp/module.cc:14350 cp/module.cc:19589 #, gcc-internal-format msgid "module %qs declared here" msgstr "" -#: cp/module.cc:14487 +#: cp/module.cc:14694 #, gcc-internal-format msgid "indirect import %qs is not already loaded" msgstr "" -#: cp/module.cc:14493 +#: cp/module.cc:14700 #, gcc-internal-format msgid "import %qs has CRC mismatch" msgstr "" -#: cp/module.cc:16321 +#: cp/module.cc:16528 #, gcc-internal-format msgid "unable to represent further imported source locations" msgstr "" -#: cp/module.cc:17194 +#: cp/module.cc:17403 #, gcc-internal-format msgid "not exporting %<#define %E%> as it is a keyword" msgstr "" -#: cp/module.cc:17434 +#: cp/module.cc:17643 #, gcc-internal-format msgid "macro definitions of %qE corrupted" msgstr "" -#: cp/module.cc:17458 cp/module.cc:17461 +#: cp/module.cc:17667 cp/module.cc:17670 #, gcc-internal-format msgid "inconsistent imported macro definition %qE" msgstr "" -#: cp/module.cc:17467 +#: cp/module.cc:17676 #, gcc-internal-format msgid "%<#undef %E%>" msgstr "" -#: cp/module.cc:17469 +#: cp/module.cc:17678 #, gcc-internal-format msgid "%<#define %s%>" msgstr "" -#: cp/module.cc:17702 +#: cp/module.cc:17911 #, gcc-internal-format msgid "compiled module file is %qs" msgstr "" -#: cp/module.cc:17739 cp/module.cc:17744 +#: cp/module.cc:17948 cp/module.cc:17953 #, gcc-internal-format, gfc-internal-format msgid "compiled module is %sversion %s" msgstr "" -#: cp/module.cc:17750 +#: cp/module.cc:17959 #, gcc-internal-format, gfc-internal-format msgid "compiler is %sversion %s%s%s" msgstr "" -#: cp/module.cc:17780 +#: cp/module.cc:17989 #, gcc-internal-format msgid "module %qs found" msgstr "" -#: cp/module.cc:17782 +#: cp/module.cc:17991 #, gcc-internal-format msgid "header module expected, module %qs found" msgstr "" -#: cp/module.cc:17783 +#: cp/module.cc:17992 #, gcc-internal-format msgid "module %qs expected, header module found" msgstr "" -#: cp/module.cc:17798 +#: cp/module.cc:18007 #, gcc-internal-format msgid "module %qs CRC mismatch" msgstr "" -#: cp/module.cc:17812 +#: cp/module.cc:18021 #, gcc-internal-format msgid "target & host is %qs:%qs, expected %qs:%qs" msgstr "" -#: cp/module.cc:17824 +#: cp/module.cc:18033 #, gcc-internal-format msgid "language dialect differs %qs, expected %qs" msgstr "" -#: cp/module.cc:17840 +#: cp/module.cc:18049 #, gcc-internal-format msgid "module contains OpenMP, use %<-fopenmp%> to enable" msgstr "" -#: cp/module.cc:17857 +#: cp/module.cc:18066 #, gcc-internal-format msgid "fixed tree mismatch" msgstr "" -#: cp/module.cc:17948 +#: cp/module.cc:18157 #, gcc-internal-format msgid "interface partition is not exported" msgstr "" -#: cp/module.cc:18505 +#: cp/module.cc:18714 #, gcc-internal-format, gfc-internal-format msgid "failed to read compiled module cluster %u: %s" msgstr "" -#: cp/module.cc:18543 +#: cp/module.cc:18752 #, gcc-internal-format, gfc-internal-format msgid "failed to read compiled module: %s" msgstr "" -#: cp/module.cc:18553 +#: cp/module.cc:18762 #, gcc-internal-format msgid "" "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> " "value, or increasing the per-process file descriptor limit" msgstr "" -#: cp/module.cc:18558 +#: cp/module.cc:18767 #, gcc-internal-format msgid "imports must be built before being imported" msgstr "" -#: cp/module.cc:18561 +#: cp/module.cc:18770 #, gcc-internal-format msgid "returning to the gate for a mechanical issue" msgstr "" -#: cp/module.cc:19074 +#: cp/module.cc:19283 #, gcc-internal-format msgid "reading CMI %qs" msgstr "" -#: cp/module.cc:19225 +#: cp/module.cc:19434 #, gcc-internal-format msgid "failed to load binding %<%E%s%E%>" msgstr "" -#: cp/module.cc:19226 +#: cp/module.cc:19435 #, gcc-internal-format msgid "failed to load binding %<%E%s%E@%s%>" msgstr "" -#: cp/module.cc:19233 +#: cp/module.cc:19442 #, gcc-internal-format msgid "during load of binding %<%E%s%E%>" msgstr "" -#: cp/module.cc:19234 +#: cp/module.cc:19443 #, gcc-internal-format msgid "during load of binding %<%E%s%E@%s%>" msgstr "" -#: cp/module.cc:19296 +#: cp/module.cc:19505 #, gcc-internal-format msgid "failed to load pendings for %<%E%s%E%>" msgstr "" -#: cp/module.cc:19300 +#: cp/module.cc:19509 #, gcc-internal-format msgid "during load of pendings for %<%E%s%E%>" msgstr "" @@ -62838,102 +62870,102 @@ msgstr "" #. module, so we don't want to confuse things by having to think #. about whether 'extern "C++" { import foo; }' puts foo's #. contents into the global module all of a sudden. -#: cp/module.cc:19345 +#: cp/module.cc:19554 #, gcc-internal-format msgid "import of named module %qs inside language-linkage block" msgstr "" -#: cp/module.cc:19375 +#: cp/module.cc:19584 #, gcc-internal-format msgid "module already declared" msgstr "" -#: cp/module.cc:19376 +#: cp/module.cc:19585 #, gcc-internal-format msgid "module already imported" msgstr "" -#: cp/module.cc:19381 +#: cp/module.cc:19590 #, gcc-internal-format msgid "module %qs imported here" msgstr "" -#: cp/module.cc:19588 +#: cp/module.cc:19797 #, gcc-internal-format, gfc-internal-format msgid "unknown Compiled Module Interface: %s" msgstr "" -#: cp/module.cc:19631 +#: cp/module.cc:19840 #, gcc-internal-format msgid "cannot determine %<#include%> translation of %s: %s" msgstr "" -#: cp/module.cc:19649 +#: cp/module.cc:19858 #, gcc-internal-format msgid "include %qs translated to import" msgstr "" -#: cp/module.cc:19650 +#: cp/module.cc:19859 #, gcc-internal-format msgid "include %qs processed textually" msgstr "" -#: cp/module.cc:20009 +#: cp/module.cc:20218 #, gcc-internal-format msgid "C++ modules are incompatible with precompiled headers" msgstr "" -#: cp/module.cc:20013 +#: cp/module.cc:20222 #, gcc-internal-format msgid "C++ modules are incompatible with traditional preprocessing" msgstr "" -#: cp/module.cc:20023 +#: cp/module.cc:20232 #, gcc-internal-format msgid "macro debug output may be incomplete with modules" msgstr "" -#: cp/module.cc:20024 +#: cp/module.cc:20233 #, gcc-internal-format msgid "module dependencies require preprocessing" msgstr "" -#: cp/module.cc:20026 +#: cp/module.cc:20235 #, gcc-internal-format msgid "you should use the %<-%s%> option" msgstr "" -#: cp/module.cc:20061 cp/module.cc:20090 +#: cp/module.cc:20270 cp/module.cc:20299 #, gcc-internal-format msgid "invalid header name %qs" msgstr "" -#: cp/module.cc:20100 +#: cp/module.cc:20309 #, gcc-internal-format msgid "invalid module name %qs" msgstr "" -#: cp/module.cc:20298 +#: cp/module.cc:20507 #, gcc-internal-format msgid "%<-fmodule-only%> used for non-interface" msgstr "" -#: cp/module.cc:20338 +#: cp/module.cc:20547 #, gcc-internal-format msgid "writing CMI %qs" msgstr "" -#: cp/module.cc:20345 +#: cp/module.cc:20554 #, gcc-internal-format msgid "not writing module %qs due to errors" msgstr "" -#: cp/module.cc:20410 +#: cp/module.cc:20619 #, gcc-internal-format, gfc-internal-format msgid "failed to write compiled module: %s" msgstr "" -#: cp/module.cc:20507 +#: cp/module.cc:20716 #, gcc-internal-format msgid "unknown header kind %qs" msgstr "" @@ -63037,7 +63069,7 @@ msgid "" "%<-std=gnu++20%>" msgstr "" -#: cp/name-lookup.cc:5951 cp/pt.cc:18459 +#: cp/name-lookup.cc:5951 cp/pt.cc:18490 #, gcc-internal-format msgid "%qT is not a class, namespace, or enumeration" msgstr "" @@ -63703,7 +63735,7 @@ msgstr "" msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>" msgstr "" -#: cp/parser.cc:5995 cp/parser.cc:6150 cp/parser.cc:6334 cp/semantics.cc:4401 +#: cp/parser.cc:5995 cp/parser.cc:6150 cp/parser.cc:6334 cp/semantics.cc:4405 #, gcc-internal-format msgid "expected primary-expression" msgstr "" @@ -63828,7 +63860,7 @@ msgstr "" msgid "wrong number of arguments to %<__builtin_addressof%>" msgstr "" -#: cp/parser.cc:7734 cp/pt.cc:20928 +#: cp/parser.cc:7734 cp/pt.cc:20997 #, gcc-internal-format msgid "wrong number of arguments to %<__builtin_launder%>" msgstr "" @@ -64050,8 +64082,8 @@ msgstr "" msgid "capture of non-variable %qE" msgstr "" -#: cp/parser.cc:11688 cp/parser.cc:11698 cp/semantics.cc:4243 -#: cp/semantics.cc:4258 +#: cp/parser.cc:11688 cp/parser.cc:11698 cp/semantics.cc:4247 +#: cp/semantics.cc:4262 #, gcc-internal-format msgid "%q#D declared here" msgstr "" @@ -64096,7 +64128,7 @@ msgid "" "with %<-std=c++2b%> or %<-std=gnu++2b%>" msgstr "" -#: cp/parser.cc:11932 cp/pt.cc:14711 +#: cp/parser.cc:11932 cp/pt.cc:14742 #, gcc-internal-format msgid "" "a lambda with captures may not have an explicit object parameter of an " @@ -64637,12 +64669,12 @@ msgstr "" msgid "cannot expand initializer for member %qD" msgstr "" -#: cp/parser.cc:17514 cp/pt.cc:27598 +#: cp/parser.cc:17514 cp/pt.cc:27654 #, gcc-internal-format msgid "mem-initializer for %qD follows constructor delegation" msgstr "" -#: cp/parser.cc:17526 cp/pt.cc:27610 +#: cp/parser.cc:17526 cp/pt.cc:27666 #, gcc-internal-format msgid "constructor delegation follows mem-initializer for %qD" msgstr "" @@ -65082,7 +65114,7 @@ msgstr "" #: cp/parser.cc:22408 #, gcc-internal-format msgid "" -"access declarations are deprecated in favour of using-declarations; " +"access declarations are deprecated in favor of using-declarations; " "suggestion: add the %<using%> keyword" msgstr "" @@ -65316,7 +65348,7 @@ msgstr "" msgid "%qT not permitted in template argument" msgstr "" -#: cp/parser.cc:25052 cp/typeck2.cc:336 cp/typeck2.cc:382 cp/typeck2.cc:2496 +#: cp/parser.cc:25052 cp/typeck2.cc:336 cp/typeck2.cc:382 cp/typeck2.cc:2473 #: rust/backend/rust-tree.cc:3909 #, gcc-internal-format msgid "invalid use of %qT" @@ -65502,7 +65534,7 @@ msgstr "" #. In a lambda this should work, but doesn't currently. #. We're in a lambda, but it isn't the innermost class. #. This should work, but currently doesn't. -#: cp/parser.cc:27653 cp/pt.cc:4306 +#: cp/parser.cc:27653 cp/pt.cc:4327 #, gcc-internal-format msgid "unexpanded parameter pack in local class in lambda" msgstr "" @@ -66223,7 +66255,7 @@ msgstr "" msgid "%<ordered%> clause with parameter on range-based %<for%> loop" msgstr "" -#: cp/parser.cc:44943 cp/pt.cc:18119 +#: cp/parser.cc:44943 cp/pt.cc:18150 #, gcc-internal-format msgid "iteration variable %qD should not be reduction" msgstr "" @@ -66261,22 +66293,22 @@ msgstr "" msgid "types may not be defined in declare reduction type list" msgstr "" -#: cp/parser.cc:49385 cp/semantics.cc:6442 +#: cp/parser.cc:49385 cp/semantics.cc:6446 #, gcc-internal-format msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>" msgstr "" -#: cp/parser.cc:49389 cp/semantics.cc:6450 +#: cp/parser.cc:49389 cp/semantics.cc:6454 #, gcc-internal-format msgid "function or array type %qT in %<#pragma omp declare reduction%>" msgstr "" -#: cp/parser.cc:49392 cp/pt.cc:14604 cp/semantics.cc:6456 +#: cp/parser.cc:49392 cp/pt.cc:14635 cp/semantics.cc:6460 #, gcc-internal-format msgid "reference type %qT in %<#pragma omp declare reduction%>" msgstr "" -#: cp/parser.cc:49395 cp/semantics.cc:6462 +#: cp/parser.cc:49395 cp/semantics.cc:6466 #, gcc-internal-format msgid "" "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma " @@ -66299,12 +66331,12 @@ msgstr "" msgid "%<atomic_cancel%>" msgstr "" -#: cp/parser.cc:50533 cp/semantics.cc:11474 +#: cp/parser.cc:50533 cp/semantics.cc:11478 #, gcc-internal-format msgid "%<__transaction_relaxed%> without transactional memory support enabled" msgstr "" -#: cp/parser.cc:50535 cp/semantics.cc:11476 +#: cp/parser.cc:50535 cp/semantics.cc:11480 #, gcc-internal-format msgid "%<__transaction_atomic%> without transactional memory support enabled" msgstr "" @@ -66444,7 +66476,7 @@ msgstr "" msgid "specialization of %qD after instantiation" msgstr "" -#: cp/pt.cc:2046 cp/semantics.cc:6312 +#: cp/pt.cc:2046 cp/semantics.cc:6316 #, gcc-internal-format msgid "%s %#qD" msgstr "" @@ -66616,69 +66648,69 @@ msgstr "" msgid "argument to %<__integer_pack%> must be between 0 and %d" msgstr "" -#: cp/pt.cc:4169 +#: cp/pt.cc:4190 #, gcc-internal-format msgid "base initializer expansion %qT contains no parameter packs" msgstr "" -#: cp/pt.cc:4237 +#: cp/pt.cc:4258 #, gcc-internal-format msgid "expansion pattern %qT contains no parameter packs" msgstr "" -#: cp/pt.cc:4239 +#: cp/pt.cc:4260 #, gcc-internal-format msgid "expansion pattern %qE contains no parameter packs" msgstr "" -#: cp/pt.cc:4323 +#: cp/pt.cc:4344 #, gcc-internal-format msgid "parameter packs not expanded with %<...%>:" msgstr "" -#: cp/pt.cc:4340 cp/pt.cc:5221 +#: cp/pt.cc:4361 cp/pt.cc:5242 #, gcc-internal-format msgid " %qD" msgstr "" -#: cp/pt.cc:4342 +#: cp/pt.cc:4363 #, gcc-internal-format, gfc-internal-format msgid " %s" msgstr "" -#: cp/pt.cc:4468 +#: cp/pt.cc:4489 #, gcc-internal-format msgid "declaration of template parameter %q+D shadows template parameter" msgstr "" -#: cp/pt.cc:4471 +#: cp/pt.cc:4492 #, gcc-internal-format msgid "declaration of %q+#D shadows template parameter" msgstr "" -#: cp/pt.cc:4473 +#: cp/pt.cc:4494 #, gcc-internal-format msgid "template parameter %qD declared here" msgstr "" -#: cp/pt.cc:5157 +#: cp/pt.cc:5178 #, gcc-internal-format msgid "specialization of variable concept %q#D" msgstr "" -#: cp/pt.cc:5216 +#: cp/pt.cc:5237 #, gcc-internal-format msgid "template parameters not deducible in partial specialization:" msgstr "" -#: cp/pt.cc:5239 +#: cp/pt.cc:5260 #, gcc-internal-format msgid "" "partial specialization %q+D does not specialize any template arguments; to " "define the primary template, remove the template argument list" msgstr "" -#: cp/pt.cc:5243 +#: cp/pt.cc:5264 #, gcc-internal-format msgid "" "partial specialization %q+D does not specialize any template arguments and " @@ -66686,63 +66718,63 @@ msgid "" "template, remove the template argument list" msgstr "" -#: cp/pt.cc:5247 cp/pt.cc:5258 cp/pt.cc:5266 +#: cp/pt.cc:5268 cp/pt.cc:5279 cp/pt.cc:5287 #, gcc-internal-format msgid "primary template here" msgstr "" -#: cp/pt.cc:5255 +#: cp/pt.cc:5276 #, gcc-internal-format msgid "" "partial specialization is not more specialized than the primary template " "because it replaces multiple parameters with a pack expansion" msgstr "" -#: cp/pt.cc:5265 +#: cp/pt.cc:5286 #, gcc-internal-format msgid "too many arguments for partial specialization %qT" msgstr "" -#: cp/pt.cc:5280 +#: cp/pt.cc:5301 #, gcc-internal-format msgid "partial specialization %qD is not more specialized than" msgstr "" -#: cp/pt.cc:5282 +#: cp/pt.cc:5303 #, gcc-internal-format msgid "primary template %qD" msgstr "" -#: cp/pt.cc:5324 +#: cp/pt.cc:5345 #, gcc-internal-format msgid "" "parameter pack argument %qE must be at the end of the template argument list" msgstr "" -#: cp/pt.cc:5327 +#: cp/pt.cc:5348 #, gcc-internal-format msgid "" "parameter pack argument %qT must be at the end of the template argument list" msgstr "" -#: cp/pt.cc:5389 +#: cp/pt.cc:5410 #, gcc-internal-format msgid "type %qT of template argument %qE depends on a template parameter" msgid_plural "type %qT of template argument %qE depends on template parameters" msgstr[0] "" msgstr[1] "" -#: cp/pt.cc:5457 +#: cp/pt.cc:5478 #, gcc-internal-format msgid "declaration of %qD ambiguates earlier template instantiation for %qD" msgstr "" -#: cp/pt.cc:5461 +#: cp/pt.cc:5482 #, gcc-internal-format msgid "partial specialization of %qD after instantiation of %qD" msgstr "" -#: cp/pt.cc:5644 +#: cp/pt.cc:5665 #, gcc-internal-format msgid "no default argument for %qD" msgstr "" @@ -66751,52 +66783,52 @@ msgstr "" #. (DR 2032), or alias template can only have one #. parameter pack, at the end of the template #. parameter list. -#: cp/pt.cc:5667 +#: cp/pt.cc:5688 #, gcc-internal-format msgid "parameter pack %q+D must be at the end of the template parameter list" msgstr "" -#: cp/pt.cc:5703 +#: cp/pt.cc:5724 #, gcc-internal-format msgid "" "default template arguments may not be used in function template friend re-" "declaration" msgstr "" -#: cp/pt.cc:5706 +#: cp/pt.cc:5727 #, gcc-internal-format msgid "" "default template arguments may not be used in template friend declarations" msgstr "" -#: cp/pt.cc:5709 +#: cp/pt.cc:5730 #, gcc-internal-format msgid "" "default template arguments may not be used in function templates without %<-" "std=c++11%> or %<-std=gnu++11%>" msgstr "" -#: cp/pt.cc:5712 +#: cp/pt.cc:5733 #, gcc-internal-format msgid "default template arguments may not be used in partial specializations" msgstr "" -#: cp/pt.cc:5715 cp/pt.cc:5773 +#: cp/pt.cc:5736 cp/pt.cc:5794 #, gcc-internal-format msgid "default argument for template parameter for class enclosing %qD" msgstr "" -#: cp/pt.cc:5884 +#: cp/pt.cc:5905 #, gcc-internal-format msgid "template %qD declared" msgstr "" -#: cp/pt.cc:5892 +#: cp/pt.cc:5913 #, gcc-internal-format msgid "template class without a name" msgstr "" -#: cp/pt.cc:5900 +#: cp/pt.cc:5921 #, gcc-internal-format msgid "member template %qD may not have virt-specifiers" msgstr "" @@ -66806,538 +66838,538 @@ msgstr "" #. An allocation function can be a function #. template. ... Template allocation functions shall #. have two or more parameters. -#: cp/pt.cc:5923 +#: cp/pt.cc:5944 #, gcc-internal-format msgid "invalid template declaration of %qD" msgstr "" -#: cp/pt.cc:6075 +#: cp/pt.cc:6096 #, gcc-internal-format msgid "template definition of non-template %q#D" msgstr "" -#: cp/pt.cc:6114 +#: cp/pt.cc:6135 #, gcc-internal-format msgid "expected %d levels of template parms for %q#D, got %d" msgstr "" -#: cp/pt.cc:6128 +#: cp/pt.cc:6149 #, gcc-internal-format msgid "got %d template parameters for %q#D" msgstr "" -#: cp/pt.cc:6131 +#: cp/pt.cc:6152 #, gcc-internal-format msgid "got %d template parameters for %q#T" msgstr "" -#: cp/pt.cc:6133 +#: cp/pt.cc:6154 #, gcc-internal-format, gfc-internal-format msgid " but %d required" msgstr "" -#: cp/pt.cc:6154 +#: cp/pt.cc:6175 #, gcc-internal-format msgid "template arguments to %qD do not match original template %qD" msgstr "" -#: cp/pt.cc:6157 +#: cp/pt.cc:6178 #, gcc-internal-format msgid "use %<template<>%> for an explicit specialization" msgstr "" -#: cp/pt.cc:6179 +#: cp/pt.cc:6200 #, gcc-internal-format msgid "redeclaration of %qD with different constraints" msgstr "" -#: cp/pt.cc:6324 +#: cp/pt.cc:6345 #, gcc-internal-format msgid "%qT is not a template type" msgstr "" -#: cp/pt.cc:6337 +#: cp/pt.cc:6358 #, gcc-internal-format msgid "template specifiers not specified in declaration of %qD" msgstr "" -#: cp/pt.cc:6348 +#: cp/pt.cc:6369 #, gcc-internal-format, gfc-internal-format msgid "redeclared with %d template parameter" msgid_plural "redeclared with %d template parameters" msgstr[0] "" msgstr[1] "" -#: cp/pt.cc:6352 +#: cp/pt.cc:6373 #, gcc-internal-format msgid "previous declaration %qD used %d template parameter" msgid_plural "previous declaration %qD used %d template parameters" msgstr[0] "" msgstr[1] "" -#: cp/pt.cc:6386 +#: cp/pt.cc:6407 #, gcc-internal-format msgid "template parameter %q+#D" msgstr "" -#: cp/pt.cc:6388 +#: cp/pt.cc:6409 #, gcc-internal-format msgid "redeclared here as %q#D" msgstr "" -#: cp/pt.cc:6390 +#: cp/pt.cc:6411 #, gcc-internal-format msgid "redeclared here" msgstr "" -#: cp/pt.cc:6401 +#: cp/pt.cc:6422 #, gcc-internal-format msgid "declaration of template parameter %q+#D with different constraints" msgstr "" -#: cp/pt.cc:6404 cp/pt.cc:6432 +#: cp/pt.cc:6425 cp/pt.cc:6453 #, gcc-internal-format msgid "original declaration appeared here" msgstr "" -#: cp/pt.cc:6429 +#: cp/pt.cc:6450 #, gcc-internal-format msgid "redeclaration of %q#D with different constraints" msgstr "" -#: cp/pt.cc:6840 cp/pt.cc:6910 +#: cp/pt.cc:6861 cp/pt.cc:6931 #, gcc-internal-format msgid "%qE is not a valid template argument for type %qT" msgstr "" -#: cp/pt.cc:6843 +#: cp/pt.cc:6864 #, gcc-internal-format msgid "it must be the address of a function with external linkage" msgstr "" -#: cp/pt.cc:6846 +#: cp/pt.cc:6867 #, gcc-internal-format msgid "it must be the name of a function with external linkage" msgstr "" -#: cp/pt.cc:6860 +#: cp/pt.cc:6881 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because %qD has no linkage" msgstr "" -#: cp/pt.cc:6864 +#: cp/pt.cc:6885 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because %qD does not have " "external linkage" msgstr "" -#: cp/pt.cc:6913 +#: cp/pt.cc:6934 #, gcc-internal-format msgid "it must be a pointer-to-member of the form %<&X::Y%>" msgstr "" -#: cp/pt.cc:6915 +#: cp/pt.cc:6936 #, gcc-internal-format msgid "because it is a member of %qT" msgstr "" -#: cp/pt.cc:6984 +#: cp/pt.cc:7005 #, gcc-internal-format msgid " couldn%'t deduce template parameter %qD" msgstr "" -#: cp/pt.cc:6993 +#: cp/pt.cc:7014 #, gcc-internal-format msgid " types %qT and %qT have incompatible cv-qualifiers" msgstr "" -#: cp/pt.cc:7002 +#: cp/pt.cc:7023 #, gcc-internal-format msgid " mismatched types %qT and %qT" msgstr "" -#: cp/pt.cc:7011 +#: cp/pt.cc:7032 #, gcc-internal-format msgid " template parameter %qD is not a parameter pack, but argument %qD is" msgstr "" -#: cp/pt.cc:7022 +#: cp/pt.cc:7043 #, gcc-internal-format msgid " template argument %qE does not match pointer-to-member constant %qE" msgstr "" -#: cp/pt.cc:7032 +#: cp/pt.cc:7053 #, gcc-internal-format msgid " %qE is not equivalent to %qE" msgstr "" -#: cp/pt.cc:7041 +#: cp/pt.cc:7062 #, gcc-internal-format msgid " inconsistent parameter pack deduction with %qT and %qT" msgstr "" -#: cp/pt.cc:7053 +#: cp/pt.cc:7074 #, gcc-internal-format msgid " deduced conflicting types for parameter %qT (%qT and %qT)" msgstr "" -#: cp/pt.cc:7057 +#: cp/pt.cc:7078 #, gcc-internal-format msgid " deduced conflicting values for non-type parameter %qE (%qE and %qE)" msgstr "" -#: cp/pt.cc:7068 +#: cp/pt.cc:7089 #, gcc-internal-format msgid " variable-sized array type %qT is not a valid template argument" msgstr "" -#: cp/pt.cc:7079 +#: cp/pt.cc:7100 #, gcc-internal-format msgid " member function type %qT is not a valid template argument" msgstr "" -#: cp/pt.cc:7122 +#: cp/pt.cc:7143 #, gcc-internal-format msgid " cannot convert %qE (type %qT) to type %qT" msgstr "" -#: cp/pt.cc:7135 +#: cp/pt.cc:7156 #, gcc-internal-format msgid " %qT is an ambiguous base class of %qT" msgstr "" -#: cp/pt.cc:7139 +#: cp/pt.cc:7160 #, gcc-internal-format msgid " %qT is not derived from %qT" msgstr "" -#: cp/pt.cc:7150 +#: cp/pt.cc:7171 #, gcc-internal-format msgid "" " template parameters of a template template argument are inconsistent with " "other deduced template arguments" msgstr "" -#: cp/pt.cc:7160 +#: cp/pt.cc:7181 #, gcc-internal-format msgid " cannot deduce a template for %qT from non-template type %qT" msgstr "" -#: cp/pt.cc:7170 +#: cp/pt.cc:7191 #, gcc-internal-format msgid " template argument %qE does not match %qE" msgstr "" -#: cp/pt.cc:7221 +#: cp/pt.cc:7242 #, gcc-internal-format msgid "" "%qE is not a valid template argument of type %qT because %qE is not a " "variable or function" msgstr "" -#: cp/pt.cc:7230 +#: cp/pt.cc:7251 #, gcc-internal-format msgid "" "%qE is not a valid template argument of type %qT in C++98 because %qD does " "not have external linkage" msgstr "" -#: cp/pt.cc:7240 +#: cp/pt.cc:7261 #, gcc-internal-format msgid "" "%qE is not a valid template argument of type %qT because %qD has no linkage" msgstr "" -#: cp/pt.cc:7257 +#: cp/pt.cc:7278 #, gcc-internal-format msgid "the address of %qD is not a valid template argument" msgstr "" -#: cp/pt.cc:7267 +#: cp/pt.cc:7288 #, gcc-internal-format msgid "" "the address of the %qT subobject of %qD is not a valid template argument" msgstr "" -#: cp/pt.cc:7274 +#: cp/pt.cc:7295 #, gcc-internal-format msgid "" "the address of %qD is not a valid template argument because it does not have " "static storage duration" msgstr "" -#: cp/pt.cc:7292 +#: cp/pt.cc:7313 #, gcc-internal-format msgid "" "%qD is not a valid template argument because %qD is a variable, not the " "address of a variable" msgstr "" -#: cp/pt.cc:7300 +#: cp/pt.cc:7321 #, gcc-internal-format msgid "" "%qE is not a valid template argument for %qT because it is not the address " "of a variable" msgstr "" -#: cp/pt.cc:7422 +#: cp/pt.cc:7443 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because string literals " "can never be used in this context" msgstr "" -#: cp/pt.cc:7587 +#: cp/pt.cc:7608 #, gcc-internal-format msgid "in template argument for type %qT" msgstr "" -#: cp/pt.cc:7601 +#: cp/pt.cc:7622 #, gcc-internal-format msgid "template argument %qE for type %qT not a compile-time constant" msgstr "" -#: cp/pt.cc:7687 +#: cp/pt.cc:7708 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because of conflicts in cv-" "qualification" msgstr "" -#: cp/pt.cc:7695 +#: cp/pt.cc:7716 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because it is not an lvalue" msgstr "" -#: cp/pt.cc:7713 +#: cp/pt.cc:7734 #, gcc-internal-format msgid "" "%q#D is not a valid template argument for type %qT because a reference " "variable does not have a constant address" msgstr "" -#: cp/pt.cc:7772 +#: cp/pt.cc:7793 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because it is a pointer" msgstr "" -#: cp/pt.cc:7774 +#: cp/pt.cc:7795 #, gcc-internal-format msgid "try using %qE instead" msgstr "" -#: cp/pt.cc:7828 +#: cp/pt.cc:7849 #, gcc-internal-format msgid "" "%qE is not a valid template argument for type %qT because it is of type %qT" msgstr "" -#: cp/pt.cc:8420 +#: cp/pt.cc:8441 #, gcc-internal-format msgid "ignoring attributes on template argument %qT" msgstr "" -#: cp/pt.cc:8436 +#: cp/pt.cc:8457 #, gcc-internal-format msgid "ignoring attributes in template argument %qE" msgstr "" -#: cp/pt.cc:8580 +#: cp/pt.cc:8601 #, gcc-internal-format msgid "injected-class-name %qD used as template template argument" msgstr "" -#: cp/pt.cc:8609 +#: cp/pt.cc:8630 #, gcc-internal-format msgid "invalid use of destructor %qE as a type" msgstr "" -#: cp/pt.cc:8614 +#: cp/pt.cc:8635 #, gcc-internal-format msgid "to refer to a type member of a template parameter, use %<typename %E%>" msgstr "" -#: cp/pt.cc:8630 cp/pt.cc:8664 cp/pt.cc:8714 +#: cp/pt.cc:8651 cp/pt.cc:8685 cp/pt.cc:8735 #, gcc-internal-format msgid "type/value mismatch at argument %d in template parameter list for %qD" msgstr "" -#: cp/pt.cc:8638 +#: cp/pt.cc:8659 #, gcc-internal-format msgid " expected a constant of type %qT, got %qT" msgstr "" -#: cp/pt.cc:8646 +#: cp/pt.cc:8667 #, gcc-internal-format msgid "" " ambiguous template argument for non-type template parameter is treated as " "function type" msgstr "" -#: cp/pt.cc:8652 +#: cp/pt.cc:8673 #, gcc-internal-format msgid " expected a class template, got %qE" msgstr "" -#: cp/pt.cc:8655 +#: cp/pt.cc:8676 #, gcc-internal-format msgid " expected a type, got %qE" msgstr "" -#: cp/pt.cc:8669 +#: cp/pt.cc:8690 #, gcc-internal-format msgid " expected a type, got %qT" msgstr "" -#: cp/pt.cc:8672 +#: cp/pt.cc:8693 #, gcc-internal-format msgid " expected a class template, got %qT" msgstr "" -#: cp/pt.cc:8718 +#: cp/pt.cc:8739 #, gcc-internal-format msgid " expected a template of type %qD, got %qT" msgstr "" -#: cp/pt.cc:8732 +#: cp/pt.cc:8753 #, gcc-internal-format msgid "constraint mismatch at argument %d in template parameter list for %qD" msgstr "" -#: cp/pt.cc:8735 +#: cp/pt.cc:8756 #, gcc-internal-format msgid " expected %qD but got %qD" msgstr "" -#: cp/pt.cc:8823 +#: cp/pt.cc:8844 #, gcc-internal-format msgid "could not convert template argument %qE from %qT to %qT" msgstr "" -#: cp/pt.cc:8961 cp/pt.cc:9287 +#: cp/pt.cc:8982 cp/pt.cc:9308 #, gcc-internal-format, gfc-internal-format msgid "template argument %d is invalid" msgstr "" -#: cp/pt.cc:8976 cp/pt.cc:9121 +#: cp/pt.cc:8997 cp/pt.cc:9142 #, gcc-internal-format, gfc-internal-format msgid "wrong number of template arguments (%d, should be %d)" msgstr "" -#: cp/pt.cc:9117 +#: cp/pt.cc:9138 #, gcc-internal-format, gfc-internal-format msgid "wrong number of template arguments (%d, should be at least %d)" msgstr "" -#: cp/pt.cc:9126 +#: cp/pt.cc:9147 #, gcc-internal-format msgid "provided for %qD" msgstr "" -#: cp/pt.cc:9151 +#: cp/pt.cc:9172 #, gcc-internal-format msgid "" "pack expansion argument for non-pack parameter %qD of alias template %qD" msgstr "" -#: cp/pt.cc:9155 +#: cp/pt.cc:9176 #, gcc-internal-format msgid "pack expansion argument for non-pack parameter %qD of concept %qD" msgstr "" -#: cp/pt.cc:9253 +#: cp/pt.cc:9274 #, gcc-internal-format msgid "" "so any instantiation with a non-empty parameter pack would be ill-formed" msgstr "" -#: cp/pt.cc:9820 +#: cp/pt.cc:9841 #, gcc-internal-format msgid "%q#D is not a function template" msgstr "" -#: cp/pt.cc:9983 +#: cp/pt.cc:10004 #, gcc-internal-format msgid "non-template type %qT used as a template" msgstr "" -#: cp/pt.cc:9985 +#: cp/pt.cc:10006 #, gcc-internal-format msgid "for template declaration %q+D" msgstr "" -#: cp/pt.cc:10154 cp/pt.cc:22201 +#: cp/pt.cc:10175 cp/pt.cc:22257 #, gcc-internal-format msgid "template constraint failure for %qD" msgstr "" -#: cp/pt.cc:10507 +#: cp/pt.cc:10528 #, gcc-internal-format msgid "use of invalid variable template %qE" msgstr "" -#: cp/pt.cc:11231 +#: cp/pt.cc:11252 #, gcc-internal-format msgid "" "template instantiation depth exceeds maximum of %d (use %<-ftemplate-" "depth=%> to increase the maximum)" msgstr "" -#: cp/pt.cc:11975 +#: cp/pt.cc:11996 #, gcc-internal-format msgid "score argument must be constant integer expression" msgstr "" -#: cp/pt.cc:11984 +#: cp/pt.cc:12005 #, gcc-internal-format msgid "score argument must be non-negative" msgstr "" -#: cp/pt.cc:12011 +#: cp/pt.cc:12032 #, gcc-internal-format msgid "property must be constant integer expression or string literal" msgstr "" -#: cp/pt.cc:12560 +#: cp/pt.cc:12581 #, gcc-internal-format msgid "flexible array member %qD in union" msgstr "" -#: cp/pt.cc:13050 +#: cp/pt.cc:13071 #, gcc-internal-format msgid "fold of empty expansion over %O" msgstr "" -#: cp/pt.cc:13500 +#: cp/pt.cc:13531 #, gcc-internal-format msgid "%qE is not the entire pattern of the pack expansion" msgstr "" -#: cp/pt.cc:13588 +#: cp/pt.cc:13619 #, gcc-internal-format msgid "mismatched argument pack lengths while expanding %qT" msgstr "" -#: cp/pt.cc:13591 +#: cp/pt.cc:13622 #, gcc-internal-format msgid "mismatched argument pack lengths while expanding %qE" msgstr "" -#: cp/pt.cc:14279 +#: cp/pt.cc:14310 #, gcc-internal-format msgid " when instantiating default argument for call to %qD" msgstr "" -#: cp/pt.cc:14375 +#: cp/pt.cc:14406 #, gcc-internal-format msgid "creating pointer to member function of non-class type %qT" msgstr "" -#: cp/pt.cc:15367 +#: cp/pt.cc:15398 #, gcc-internal-format, gfc-internal-format msgid "mismatched argument pack lengths (%d vs %d)" msgstr "" @@ -67355,305 +67387,305 @@ msgstr "" #. #. is an attempt to declare a variable with function #. type. -#: cp/pt.cc:15556 +#: cp/pt.cc:15587 #, gcc-internal-format msgid "variable %qD has function type" msgstr "" -#: cp/pt.cc:15757 +#: cp/pt.cc:15788 #, gcc-internal-format msgid "invalid parameter type %qT" msgstr "" -#: cp/pt.cc:15759 +#: cp/pt.cc:15790 #, gcc-internal-format msgid "in declaration %q+D" msgstr "" -#: cp/pt.cc:15886 +#: cp/pt.cc:15917 #, gcc-internal-format msgid "function returning an array" msgstr "" -#: cp/pt.cc:15888 +#: cp/pt.cc:15919 #, gcc-internal-format msgid "function returning a function" msgstr "" -#: cp/pt.cc:16594 +#: cp/pt.cc:16625 #, gcc-internal-format msgid "forming reference to void" msgstr "" -#: cp/pt.cc:16596 +#: cp/pt.cc:16627 #, gcc-internal-format msgid "forming pointer to reference type %qT" msgstr "" -#: cp/pt.cc:16598 +#: cp/pt.cc:16629 #, gcc-internal-format msgid "forming reference to reference type %qT" msgstr "" -#: cp/pt.cc:16611 +#: cp/pt.cc:16642 #, gcc-internal-format msgid "forming pointer to qualified function type %qT" msgstr "" -#: cp/pt.cc:16614 +#: cp/pt.cc:16645 #, gcc-internal-format msgid "forming reference to qualified function type %qT" msgstr "" -#: cp/pt.cc:16662 +#: cp/pt.cc:16693 #, gcc-internal-format msgid "creating pointer to member of non-class type %qT" msgstr "" -#: cp/pt.cc:16668 +#: cp/pt.cc:16699 #, gcc-internal-format msgid "creating pointer to member reference type %qT" msgstr "" -#: cp/pt.cc:16674 +#: cp/pt.cc:16705 #, gcc-internal-format msgid "creating pointer to member of type void" msgstr "" -#: cp/pt.cc:16740 +#: cp/pt.cc:16771 #, gcc-internal-format msgid "creating array of %qT" msgstr "" -#: cp/pt.cc:16777 +#: cp/pt.cc:16808 #, gcc-internal-format msgid "%qD is instantiated for an empty pack" msgstr "" -#: cp/pt.cc:16798 +#: cp/pt.cc:16829 #, gcc-internal-format msgid "%qT is not a class, struct, or union type" msgstr "" -#: cp/pt.cc:16838 +#: cp/pt.cc:16869 #, gcc-internal-format msgid "%qT resolves to %qT, which is not an enumeration type" msgstr "" -#: cp/pt.cc:16846 +#: cp/pt.cc:16877 #, gcc-internal-format msgid "%qT resolves to %qT, which is not a class type" msgstr "" -#: cp/pt.cc:16964 +#: cp/pt.cc:16995 #, gcc-internal-format msgid "use of %qs in template" msgstr "" -#: cp/pt.cc:17283 +#: cp/pt.cc:17314 #, gcc-internal-format msgid "qualifying type %qT does not match destructor name ~%qT" msgstr "" -#: cp/pt.cc:17298 +#: cp/pt.cc:17329 #, gcc-internal-format msgid "" "dependent-name %qE is parsed as a non-type, but instantiation yields a type" msgstr "" -#: cp/pt.cc:17300 +#: cp/pt.cc:17331 #, gcc-internal-format msgid "say %<typename %E%> if a type is meant" msgstr "" -#: cp/pt.cc:17393 +#: cp/pt.cc:17424 #, gcc-internal-format msgid "initializer for %q#D expands to an empty list of expressions" msgstr "" -#: cp/pt.cc:19416 cp/pt.cc:21569 +#: cp/pt.cc:19448 cp/pt.cc:21638 #, gcc-internal-format msgid "invalid use of pack expansion expression" msgstr "" -#: cp/pt.cc:19420 cp/pt.cc:21573 +#: cp/pt.cc:19452 cp/pt.cc:21642 #, gcc-internal-format msgid "use %<...%> to expand argument pack" msgstr "" -#: cp/pt.cc:19550 +#: cp/pt.cc:19599 #, gcc-internal-format msgid "empty initializer in lambda init-capture" msgstr "" -#: cp/pt.cc:20843 +#: cp/pt.cc:20912 #, 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.cc:20878 +#: cp/pt.cc:20947 #, gcc-internal-format msgid "declarations in dependent base %qT are not found by unqualified lookup" msgstr "" -#: cp/pt.cc:20883 +#: cp/pt.cc:20952 #, gcc-internal-format msgid "use %<this->%D%> instead" msgstr "" -#: cp/pt.cc:20886 +#: cp/pt.cc:20955 #, gcc-internal-format msgid "use %<%T::%D%> instead" msgstr "" -#: cp/pt.cc:20891 +#: cp/pt.cc:20960 #, gcc-internal-format msgid "%qD declared here, later in the translation unit" msgstr "" -#: cp/pt.cc:20942 +#: cp/pt.cc:21011 #, gcc-internal-format msgid "wrong number of arguments to %<__builtin_convertvector%>" msgstr "" -#: cp/pt.cc:20969 +#: cp/pt.cc:21038 #, gcc-internal-format msgid "wrong number of arguments to %<assume%> attribute" msgstr "" -#: cp/pt.cc:21180 +#: cp/pt.cc:21249 #, gcc-internal-format msgid "%qT is not a class or namespace" msgstr "" -#: cp/pt.cc:21183 +#: cp/pt.cc:21252 #, gcc-internal-format msgid "%qD is not a class or namespace" msgstr "" -#: cp/pt.cc:21501 +#: cp/pt.cc:21570 #, gcc-internal-format msgid "using invalid field %qD" msgstr "" -#: cp/pt.cc:21847 +#: cp/pt.cc:21903 #, gcc-internal-format msgid "%qT is/uses unnamed type" msgstr "" -#: cp/pt.cc:21849 +#: cp/pt.cc:21905 #, gcc-internal-format msgid "template argument for %qD uses local type %qT" msgstr "" -#: cp/pt.cc:21859 +#: cp/pt.cc:21915 #, gcc-internal-format msgid "%qT is a variably modified type" msgstr "" -#: cp/pt.cc:21874 +#: cp/pt.cc:21930 #, gcc-internal-format msgid "integral expression %qE is not constant" msgstr "" -#: cp/pt.cc:21892 +#: cp/pt.cc:21948 #, gcc-internal-format msgid " trying to instantiate %qD" msgstr "" -#: cp/pt.cc:26285 +#: cp/pt.cc:26341 #, gcc-internal-format msgid "ambiguous template instantiation for %q#T" msgstr "" -#: cp/pt.cc:26287 +#: cp/pt.cc:26343 #, gcc-internal-format msgid "ambiguous template instantiation for %q#D" msgstr "" -#: cp/pt.cc:26293 +#: cp/pt.cc:26349 msgid "%s %#qS" msgstr "" -#: cp/pt.cc:26320 cp/pt.cc:26415 +#: cp/pt.cc:26376 cp/pt.cc:26471 #, gcc-internal-format msgid "explicit instantiation of non-template %q#D" msgstr "" -#: cp/pt.cc:26326 +#: cp/pt.cc:26382 #, gcc-internal-format msgid "explicit instantiation of variable concept %q#D" msgstr "" -#: cp/pt.cc:26328 +#: cp/pt.cc:26384 #, gcc-internal-format msgid "explicit instantiation of function concept %q#D" msgstr "" -#: cp/pt.cc:26347 +#: cp/pt.cc:26403 #, gcc-internal-format msgid "%qD is not a static data member of a class template" msgstr "" -#: cp/pt.cc:26353 cp/pt.cc:26410 +#: cp/pt.cc:26409 cp/pt.cc:26466 #, gcc-internal-format msgid "no matching template for %qD found" msgstr "" -#: cp/pt.cc:26358 +#: cp/pt.cc:26414 #, gcc-internal-format msgid "" "type %qT for explicit instantiation %qD does not match declared type %qT" msgstr "" -#: cp/pt.cc:26366 +#: cp/pt.cc:26422 #, gcc-internal-format msgid "explicit instantiation of %q#D" msgstr "" -#: cp/pt.cc:26402 +#: cp/pt.cc:26458 #, gcc-internal-format msgid "duplicate explicit instantiation of %q#D" msgstr "" -#: cp/pt.cc:26425 cp/pt.cc:26492 +#: cp/pt.cc:26481 cp/pt.cc:26548 #, gcc-internal-format msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations" msgstr "" -#: cp/pt.cc:26430 cp/pt.cc:26507 +#: cp/pt.cc:26486 cp/pt.cc:26563 #, gcc-internal-format msgid "storage class %qD applied to template instantiation" msgstr "" -#: cp/pt.cc:26464 +#: cp/pt.cc:26520 #, gcc-internal-format msgid "explicit instantiation of non-class template %qD" msgstr "" -#: cp/pt.cc:26467 +#: cp/pt.cc:26523 #, gcc-internal-format msgid "explicit instantiation of non-template type %qT" msgstr "" -#: cp/pt.cc:26476 +#: cp/pt.cc:26532 #, gcc-internal-format msgid "explicit instantiation of %q#T before definition of template" msgstr "" -#: cp/pt.cc:26497 +#: cp/pt.cc:26553 #, gcc-internal-format msgid "ISO C++ forbids the use of %qE on explicit instantiations" msgstr "" -#: cp/pt.cc:26537 +#: cp/pt.cc:26593 #, gcc-internal-format msgid "duplicate explicit instantiation of %q#T" msgstr "" -#: cp/pt.cc:26853 +#: cp/pt.cc:26909 #, gcc-internal-format msgid "exception specification of %qD depends on itself" msgstr "" @@ -67665,12 +67697,12 @@ 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.cc:27326 +#: cp/pt.cc:27382 #, gcc-internal-format msgid "explicit instantiation of %qD but no definition available" msgstr "" -#: cp/pt.cc:27371 +#: cp/pt.cc:27427 #, gcc-internal-format msgid "" "template instantiation depth exceeds maximum of %d instantiating %q+D, " @@ -67678,170 +67710,170 @@ msgid "" "increase the maximum)" msgstr "" -#: cp/pt.cc:27745 +#: cp/pt.cc:27801 #, gcc-internal-format msgid "" "non-type template parameters of deduced class type only available with %<-" "std=c++20%> or %<-std=gnu++20%>" msgstr "" -#: cp/pt.cc:27775 +#: cp/pt.cc:27831 #, gcc-internal-format msgid "" "%qT is not a valid type for a template non-type parameter because it is not " "structural" msgstr "" -#: cp/pt.cc:27784 +#: cp/pt.cc:27840 #, gcc-internal-format msgid "" "non-type template parameters of class type only available with %<-std=c+" "+20%> or %<-std=gnu++20%>" msgstr "" -#: cp/pt.cc:27792 +#: cp/pt.cc:27848 #, gcc-internal-format msgid "invalid template non-type parameter" msgstr "" -#: cp/pt.cc:27794 +#: cp/pt.cc:27850 #, gcc-internal-format msgid "%q#T is not a valid type for a template non-type parameter" msgstr "" -#: cp/pt.cc:29238 +#: cp/pt.cc:29294 #, gcc-internal-format msgid "keyword %<template%> not allowed in declarator-id" msgstr "" -#: cp/pt.cc:29429 +#: cp/pt.cc:29485 #, gcc-internal-format msgid "a concept cannot be constrained" msgstr "" -#: cp/pt.cc:29438 +#: cp/pt.cc:29494 #, gcc-internal-format msgid "concept %qE not in namespace scope" msgstr "" -#: cp/pt.cc:29444 +#: cp/pt.cc:29500 #, gcc-internal-format msgid "concept %qE has multiple template parameter lists" msgstr "" -#: cp/pt.cc:29475 +#: cp/pt.cc:29531 #, gcc-internal-format msgid "" "deducing from brace-enclosed initializer list requires %<#include " "<initializer_list>%>" msgstr "" -#: cp/pt.cc:30753 +#: cp/pt.cc:30809 #, gcc-internal-format msgid "non-deducible template %qT used without template arguments" msgstr "" -#: cp/pt.cc:30765 +#: cp/pt.cc:30821 #, gcc-internal-format msgid "" "alias template deduction only available with %<-std=c++20%> or %<-std=gnu+" "+20%>" msgstr "" -#: cp/pt.cc:30771 +#: cp/pt.cc:30827 #, gcc-internal-format msgid "use %qD directly instead" msgstr "" -#: cp/pt.cc:30899 +#: cp/pt.cc:30955 #, gcc-internal-format msgid "" "cannot deduce template arguments for copy-initialization of %qT, as it has " "no non-explicit deduction guides or user-declared constructors" msgstr "" -#: cp/pt.cc:30906 +#: cp/pt.cc:30962 #, gcc-internal-format msgid "" "cannot deduce template arguments of %qT, as it has no viable deduction guides" msgstr "" -#: cp/pt.cc:30918 +#: cp/pt.cc:30974 #, gcc-internal-format msgid "class template argument deduction failed:" msgstr "" -#: cp/pt.cc:30921 +#: cp/pt.cc:30977 #, gcc-internal-format msgid "explicit deduction guides not considered for copy-initialization" msgstr "" #. TODO: Pass down location from cp_finish_decl. -#: cp/pt.cc:30935 +#: cp/pt.cc:30991 #, gcc-internal-format msgid "" "class template argument deduction for %qT failed: explicit deduction guide " "selected in copy-list-initialization" msgstr "" -#: cp/pt.cc:30939 +#: cp/pt.cc:30995 #, gcc-internal-format msgid "explicit deduction guide declared here" msgstr "" -#: cp/pt.cc:30953 +#: cp/pt.cc:31009 #, gcc-internal-format msgid "%qT may not intend to support class template argument deduction" msgstr "" -#: cp/pt.cc:30955 +#: cp/pt.cc:31011 #, gcc-internal-format msgid "add a deduction guide to suppress this warning" msgstr "" -#: cp/pt.cc:31077 +#: cp/pt.cc:31133 #, gcc-internal-format msgid "direct-list-initialization of %<auto%> requires exactly one element" msgstr "" -#: cp/pt.cc:31080 +#: cp/pt.cc:31136 #, gcc-internal-format msgid "" "for deduction to %<std::initializer_list%>, use copy-list-initialization (i." "e. add %<=%> before the %<{%>)" msgstr "" -#: cp/pt.cc:31147 +#: cp/pt.cc:31203 #, gcc-internal-format msgid "unable to deduce lambda return type from %qE" msgstr "" -#: cp/pt.cc:31150 +#: cp/pt.cc:31206 #, gcc-internal-format msgid "unable to deduce %qT from %qE" msgstr "" -#: cp/pt.cc:31225 +#: cp/pt.cc:31281 #, gcc-internal-format msgid "placeholder constraints not satisfied" msgstr "" -#: cp/pt.cc:31229 +#: cp/pt.cc:31285 #, gcc-internal-format msgid "deduced initializer does not satisfy placeholder constraints" msgstr "" -#: cp/pt.cc:31233 +#: cp/pt.cc:31289 #, gcc-internal-format msgid "deduced return type does not satisfy placeholder constraints" msgstr "" -#: cp/pt.cc:31237 +#: cp/pt.cc:31293 #, gcc-internal-format msgid "deduced expression type does not satisfy placeholder constraints" msgstr "" -#: cp/pt.cc:31392 +#: cp/pt.cc:31448 #, gcc-internal-format msgid "invalid use of %qT in template argument" msgstr "" @@ -67994,722 +68026,722 @@ msgstr "" msgid "virtual function declared here" msgstr "" -#: cp/semantics.cc:1110 +#: cp/semantics.cc:1114 #, gcc-internal-format msgid "" "%<std::is_constant_evaluated%> always evaluates to true in %<if constexpr%>" msgstr "" -#: cp/semantics.cc:1116 +#: cp/semantics.cc:1120 #, gcc-internal-format msgid "" "%<std::is_constant_evaluated%> evaluates to true when checking if trivially " "empty iteration statement is trivial infinite loop" msgstr "" -#: cp/semantics.cc:1121 +#: cp/semantics.cc:1125 #, gcc-internal-format msgid "" "and evaluates to false when actually evaluating the condition in non-" "%<constexpr%> function" msgstr "" -#: cp/semantics.cc:1126 +#: cp/semantics.cc:1130 #, gcc-internal-format msgid "" "%<std::is_constant_evaluated%> always evaluates to false in a non-" "%<constexpr%> function" msgstr "" -#: cp/semantics.cc:1130 +#: cp/semantics.cc:1134 #, gcc-internal-format msgid "" "%<std::is_constant_evaluated%> always evaluates to true in a %<consteval%> " "function" msgstr "" -#: cp/semantics.cc:1347 +#: cp/semantics.cc:1351 #, gcc-internal-format msgid "suggest explicit braces around empty body in %<do%> statement" msgstr "" -#: cp/semantics.cc:1886 +#: cp/semantics.cc:1890 #, gcc-internal-format msgid "catching polymorphic type %q#T by value" msgstr "" -#: cp/semantics.cc:1891 +#: cp/semantics.cc:1895 #, gcc-internal-format msgid "catching type %q#T by value" msgstr "" -#: cp/semantics.cc:1896 +#: cp/semantics.cc:1900 #, gcc-internal-format msgid "catching non-reference type %q#T" msgstr "" -#: cp/semantics.cc:2108 +#: cp/semantics.cc:2112 #, gcc-internal-format msgid "type of %<asm%> operand %qE could not be determined" msgstr "" -#: cp/semantics.cc:2190 +#: cp/semantics.cc:2194 #, gcc-internal-format msgid "%<__label__%> declarations are only allowed in function scopes" msgstr "" -#: cp/semantics.cc:2363 +#: cp/semantics.cc:2367 #, gcc-internal-format msgid "invalid use of member %qD in static member function" msgstr "" -#: cp/semantics.cc:2367 +#: cp/semantics.cc:2371 #, gcc-internal-format msgid "invalid use of member %qD in constructor %<pre%> contract" msgstr "" -#: cp/semantics.cc:2371 +#: cp/semantics.cc:2375 #, gcc-internal-format msgid "invalid use of member %qD in destructor %<post%> contract" msgstr "" -#: cp/semantics.cc:2634 +#: cp/semantics.cc:2638 #, gcc-internal-format msgid "%qE missing template arguments" msgstr "" -#: cp/semantics.cc:2694 +#: cp/semantics.cc:2698 #, gcc-internal-format msgid "" "a statement expression is an insufficient context for overload resolution" msgstr "" -#: cp/semantics.cc:3053 +#: cp/semantics.cc:3057 #, gcc-internal-format msgid "cannot call a concept as a function" msgstr "" -#: cp/semantics.cc:3136 +#: cp/semantics.cc:3140 #, gcc-internal-format msgid "arguments to destructor are not allowed" msgstr "" -#: cp/semantics.cc:3240 +#: cp/semantics.cc:3244 #, gcc-internal-format msgid "%<this%> is unavailable for explicit object member functions" msgstr "" -#: cp/semantics.cc:3252 +#: cp/semantics.cc:3256 #, gcc-internal-format msgid "use explicit object parameter %qs instead" msgstr "" -#: cp/semantics.cc:3256 +#: cp/semantics.cc:3260 #, gcc-internal-format msgid "name the explicit object parameter" msgstr "" -#: cp/semantics.cc:3261 +#: cp/semantics.cc:3265 #, gcc-internal-format msgid "%<this%> is unavailable for static member functions" msgstr "" -#: cp/semantics.cc:3263 +#: cp/semantics.cc:3267 #, gcc-internal-format msgid "invalid use of %<this%> before it is valid" msgstr "" -#: cp/semantics.cc:3265 +#: cp/semantics.cc:3269 #, gcc-internal-format msgid "invalid use of %<this%> after it is valid" msgstr "" -#: cp/semantics.cc:3267 +#: cp/semantics.cc:3271 #, gcc-internal-format msgid "invalid use of %<this%> in non-member function" msgstr "" -#: cp/semantics.cc:3269 +#: cp/semantics.cc:3273 #, gcc-internal-format msgid "invalid use of %<this%> at top level" msgstr "" -#: cp/semantics.cc:3291 +#: cp/semantics.cc:3295 #, gcc-internal-format msgid "invalid qualifying scope in pseudo-destructor name" msgstr "" -#: cp/semantics.cc:3299 cp/typeck.cc:3085 +#: cp/semantics.cc:3303 cp/typeck.cc:3085 #, gcc-internal-format msgid "qualified type %qT does not match destructor name ~%qT" msgstr "" -#: cp/semantics.cc:3321 +#: cp/semantics.cc:3325 #, gcc-internal-format msgid "%qE is not of type %qT" msgstr "" -#: cp/semantics.cc:3435 +#: cp/semantics.cc:3439 #, gcc-internal-format msgid "compound literal of non-object type %qT" msgstr "" -#: cp/semantics.cc:3455 +#: cp/semantics.cc:3459 #, gcc-internal-format msgid "%<auto{x}%> cannot be constrained" msgstr "" -#: cp/semantics.cc:3460 +#: cp/semantics.cc:3464 #, gcc-internal-format msgid "%<auto{x}%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>" msgstr "" -#: cp/semantics.cc:3652 +#: cp/semantics.cc:3656 #, gcc-internal-format msgid "template type parameters must use the keyword %<class%> or %<typename%>" msgstr "" -#: cp/semantics.cc:3705 +#: cp/semantics.cc:3709 #, gcc-internal-format msgid "" "invalid use of type %qT as a default value for a template template-parameter" msgstr "" -#: cp/semantics.cc:3709 +#: cp/semantics.cc:3713 #, gcc-internal-format msgid "invalid default argument for a template template parameter" msgstr "" -#: cp/semantics.cc:3726 +#: cp/semantics.cc:3730 #, gcc-internal-format msgid "definition of %q#T inside template parameter list" msgstr "" -#: cp/semantics.cc:3757 +#: cp/semantics.cc:3761 #, gcc-internal-format msgid "invalid definition of qualified type %qT" msgstr "" -#: cp/semantics.cc:4049 +#: cp/semantics.cc:4053 #, gcc-internal-format msgid "invalid base-class specification" msgstr "" -#: cp/semantics.cc:4217 +#: cp/semantics.cc:4221 #, gcc-internal-format msgid "cannot capture member %qD of anonymous union" msgstr "" -#: cp/semantics.cc:4234 +#: cp/semantics.cc:4238 #, gcc-internal-format msgid "%qD is not captured" msgstr "" -#: cp/semantics.cc:4238 +#: cp/semantics.cc:4242 #, gcc-internal-format msgid "the lambda has no capture-default" msgstr "" -#: cp/semantics.cc:4240 +#: cp/semantics.cc:4244 #, gcc-internal-format msgid "" "lambda in local class %q+T cannot capture variables from the enclosing " "context" msgstr "" -#: cp/semantics.cc:4255 +#: cp/semantics.cc:4259 #, gcc-internal-format msgid "use of local variable with automatic storage from containing function" msgstr "" -#: cp/semantics.cc:4257 +#: cp/semantics.cc:4261 #, gcc-internal-format msgid "use of parameter from containing function" msgstr "" -#: cp/semantics.cc:4385 +#: cp/semantics.cc:4389 #, gcc-internal-format msgid "use of parameter outside function body" msgstr "" -#: cp/semantics.cc:4395 +#: cp/semantics.cc:4399 #, gcc-internal-format msgid "missing template arguments" msgstr "" -#: cp/semantics.cc:4431 +#: cp/semantics.cc:4435 #, gcc-internal-format msgid "" "template parameter %qD of type %qT is not allowed in an integral constant " "expression because it is not of integral or enumeration type" msgstr "" -#: cp/semantics.cc:4482 +#: cp/semantics.cc:4486 #, gcc-internal-format msgid "use of class template %qT as expression" msgstr "" #. Ambiguous reference to base members. -#: cp/semantics.cc:4489 +#: cp/semantics.cc:4493 #, gcc-internal-format msgid "request for member %qD is ambiguous in multiple inheritance lattice" msgstr "" -#: cp/semantics.cc:4517 +#: cp/semantics.cc:4521 #, gcc-internal-format msgid "%qD cannot appear in a constant-expression" msgstr "" -#: cp/semantics.cc:4670 +#: cp/semantics.cc:4674 #, gcc-internal-format msgid "type of %qE is unknown" msgstr "" -#: cp/semantics.cc:4688 rust/backend/rust-tree.cc:5511 +#: cp/semantics.cc:4692 rust/backend/rust-tree.cc:5511 #, gcc-internal-format msgid "%qT is not an enumeration type" msgstr "" -#: cp/semantics.cc:4715 +#: cp/semantics.cc:4719 #, gcc-internal-format msgid "%<__type_pack_element%> index is not an integral constant" msgstr "" -#: cp/semantics.cc:4721 +#: cp/semantics.cc:4725 #, gcc-internal-format msgid "%<__type_pack_element%> index is negative" msgstr "" -#: cp/semantics.cc:4727 +#: cp/semantics.cc:4731 #, gcc-internal-format msgid "%<__type_pack_element%> index is out of range" msgstr "" #. Parameter packs can only be used in templates -#: cp/semantics.cc:4850 +#: cp/semantics.cc:4854 #, gcc-internal-format msgid "parameter pack %<__bases%> only valid in template declaration" msgstr "" -#: cp/semantics.cc:4882 +#: cp/semantics.cc:4886 #, gcc-internal-format msgid "cannot apply %<offsetof%> to destructor %<~%T%>" msgstr "" -#: cp/semantics.cc:4895 +#: cp/semantics.cc:4899 #, gcc-internal-format msgid "cannot apply %<offsetof%> to member function %qD" msgstr "" -#: cp/semantics.cc:4899 +#: cp/semantics.cc:4903 #, gcc-internal-format msgid "cannot apply %<offsetof%> to member function" msgstr "" -#: cp/semantics.cc:4904 +#: cp/semantics.cc:4908 #, gcc-internal-format msgid "cannot apply %<offsetof%> to an enumerator %qD" msgstr "" -#: cp/semantics.cc:4915 +#: cp/semantics.cc:4919 #, gcc-internal-format msgid "" "%<offsetof%> within non-standard-layout type %qT is conditionally-supported" msgstr "" -#: cp/semantics.cc:6115 +#: cp/semantics.cc:6119 #, gcc-internal-format msgid "pointer-to-member mapping %qE not supported" msgstr "" -#: cp/semantics.cc:6309 +#: cp/semantics.cc:6313 #, gcc-internal-format msgid "user defined reduction lookup is ambiguous" msgstr "" -#: cp/semantics.cc:6582 +#: cp/semantics.cc:6586 #, gcc-internal-format msgid "%qE in %<reduction%> clause is a zero size array" msgstr "" -#: cp/semantics.cc:6628 +#: cp/semantics.cc:6632 #, gcc-internal-format msgid "%qE has const type for %<reduction%>" msgstr "" -#: cp/semantics.cc:6747 +#: cp/semantics.cc:6751 #, gcc-internal-format msgid "user defined reduction with constructor initializer for base class %qT" msgstr "" -#: cp/semantics.cc:7219 +#: cp/semantics.cc:7223 #, gcc-internal-format msgid "" "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or " "%<for%> constructs when using OpenMP 5.2 modifiers" msgstr "" -#: cp/semantics.cc:7234 +#: cp/semantics.cc:7238 #, gcc-internal-format msgid "" "linear clause with %qs modifier applied to non-reference variable with %qT " "type" msgstr "" -#: cp/semantics.cc:7249 +#: cp/semantics.cc:7253 #, gcc-internal-format msgid "" "linear clause applied to non-integral non-pointer variable with %qT type" msgstr "" -#: cp/semantics.cc:7273 +#: cp/semantics.cc:7277 #, gcc-internal-format msgid "linear step expression must be integral" msgstr "" -#: cp/semantics.cc:7366 cp/semantics.cc:7498 cp/semantics.cc:7558 -#: cp/semantics.cc:7959 cp/semantics.cc:9085 +#: cp/semantics.cc:7370 cp/semantics.cc:7502 cp/semantics.cc:7562 +#: cp/semantics.cc:7963 cp/semantics.cc:9089 #, gcc-internal-format msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses" msgstr "" -#: cp/semantics.cc:7378 cp/semantics.cc:9098 +#: cp/semantics.cc:7382 cp/semantics.cc:9102 #, gcc-internal-format msgid "%qD is not a variable in clause %qs" msgstr "" -#: cp/semantics.cc:7511 +#: cp/semantics.cc:7515 #, gcc-internal-format msgid "%qD is not a variable in clause %<firstprivate%>" msgstr "" -#: cp/semantics.cc:7571 +#: cp/semantics.cc:7575 #, gcc-internal-format msgid "%qD is not a variable in clause %<lastprivate%>" msgstr "" -#: cp/semantics.cc:7622 +#: cp/semantics.cc:7626 #, gcc-internal-format msgid "%<gang%> static expression must be integral" msgstr "" -#: cp/semantics.cc:7636 +#: cp/semantics.cc:7640 #, gcc-internal-format msgid "%<gang%> static value must be positive" msgstr "" -#: cp/semantics.cc:7670 +#: cp/semantics.cc:7674 #, gcc-internal-format msgid "%<gang%> num expression must be integral" msgstr "" -#: cp/semantics.cc:7673 +#: cp/semantics.cc:7677 #, gcc-internal-format msgid "%<vector%> length expression must be integral" msgstr "" -#: cp/semantics.cc:7677 +#: cp/semantics.cc:7681 #, gcc-internal-format msgid "%<worker%> num expression must be integral" msgstr "" -#: cp/semantics.cc:7699 +#: cp/semantics.cc:7703 #, gcc-internal-format msgid "%<gang%> num value must be positive" msgstr "" -#: cp/semantics.cc:7703 +#: cp/semantics.cc:7707 #, gcc-internal-format msgid "%<vector%> length value must be positive" msgstr "" -#: cp/semantics.cc:7708 +#: cp/semantics.cc:7712 #, gcc-internal-format msgid "%<worker%> num value must be positive" msgstr "" -#: cp/semantics.cc:7784 +#: cp/semantics.cc:7788 #, gcc-internal-format msgid "schedule chunk size expression must be integral" msgstr "" -#: cp/semantics.cc:7817 +#: cp/semantics.cc:7821 #, gcc-internal-format msgid "%qs length expression must be integral" msgstr "" -#: cp/semantics.cc:7831 +#: cp/semantics.cc:7835 #, gcc-internal-format msgid "%qs length expression must be positive constant integer expression" msgstr "" -#: cp/semantics.cc:7851 +#: cp/semantics.cc:7855 #, gcc-internal-format msgid "%<async%> expression must be integral" msgstr "" -#: cp/semantics.cc:7880 +#: cp/semantics.cc:7884 #, gcc-internal-format msgid "%<thread_limit%> expression must be integral" msgstr "" -#: cp/semantics.cc:7910 +#: cp/semantics.cc:7914 #, gcc-internal-format msgid "%<device%> id must be integral" msgstr "" -#: cp/semantics.cc:7941 +#: cp/semantics.cc:7945 #, gcc-internal-format msgid "%<dist_schedule%> chunk size expression must be integral" msgstr "" -#: cp/semantics.cc:7970 +#: cp/semantics.cc:7974 #, gcc-internal-format msgid "%qD is not a variable in %<aligned%> clause" msgstr "" -#: cp/semantics.cc:7985 +#: cp/semantics.cc:7989 #, gcc-internal-format msgid "" "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference " "to pointer or array" msgstr "" -#: cp/semantics.cc:7992 +#: cp/semantics.cc:7996 #, gcc-internal-format msgid "%qD appears more than once in %<aligned%> clauses" msgstr "" -#: cp/semantics.cc:8007 +#: cp/semantics.cc:8011 #, gcc-internal-format msgid "%<aligned%> clause alignment expression must be integral" msgstr "" -#: cp/semantics.cc:8040 +#: cp/semantics.cc:8044 #, gcc-internal-format msgid "%qD is not a variable in %<nontemporal%> clause" msgstr "" -#: cp/semantics.cc:8051 +#: cp/semantics.cc:8055 #, gcc-internal-format msgid "%qD appears more than once in %<nontemporal%> clauses" msgstr "" -#: cp/semantics.cc:8068 +#: cp/semantics.cc:8072 #, gcc-internal-format msgid "%<this%> not allowed in %<allocate%> clause" msgstr "" -#: cp/semantics.cc:8080 +#: cp/semantics.cc:8084 #, gcc-internal-format msgid "%qD is not a variable in %<allocate%> clause" msgstr "" -#: cp/semantics.cc:8089 +#: cp/semantics.cc:8093 #, gcc-internal-format msgid "%qD appears more than once in %<allocate%> clauses" msgstr "" -#: cp/semantics.cc:8237 +#: cp/semantics.cc:8241 #, gcc-internal-format msgid "%qD is not lvalue expression nor array section in %qs clause" msgstr "" -#: cp/semantics.cc:8739 +#: cp/semantics.cc:8743 #, gcc-internal-format msgid "template %qE in clause %qs" msgstr "" -#: cp/semantics.cc:8742 +#: cp/semantics.cc:8746 #, gcc-internal-format msgid "overloaded function name %qE in clause %qs" msgstr "" -#: cp/semantics.cc:8811 +#: cp/semantics.cc:8815 #, gcc-internal-format msgid "%<grainsize%> expression must be integral" msgstr "" -#: cp/semantics.cc:8841 +#: cp/semantics.cc:8845 #, gcc-internal-format msgid "%<priority%> expression must be integral" msgstr "" -#: cp/semantics.cc:8871 +#: cp/semantics.cc:8875 #, gcc-internal-format msgid "%<hint%> expression must be integral" msgstr "" -#: cp/semantics.cc:8884 +#: cp/semantics.cc:8888 #, gcc-internal-format msgid "%<hint%> expression must be constant integer expression" msgstr "" -#: cp/semantics.cc:8901 +#: cp/semantics.cc:8905 #, gcc-internal-format msgid "%<filter%> expression must be integral" msgstr "" -#: cp/semantics.cc:8932 +#: cp/semantics.cc:8936 #, gcc-internal-format msgid "%qs variable is neither a pointer nor reference to pointer" msgstr "" -#: cp/semantics.cc:8942 +#: cp/semantics.cc:8946 #, gcc-internal-format msgid "" "%qs variable is neither a pointer, nor an array nor reference to pointer or " "array" msgstr "" -#: cp/semantics.cc:9026 +#: cp/semantics.cc:9030 #, gcc-internal-format msgid "%<tile%> argument needs integral type" msgstr "" -#: cp/semantics.cc:9443 +#: cp/semantics.cc:9447 #, gcc-internal-format msgid "" "%<const%> qualified %qE without %<mutable%> member may appear only in " "%<shared%> or %<firstprivate%> clauses" msgstr "" -#: cp/semantics.cc:9670 +#: cp/semantics.cc:9674 #, gcc-internal-format msgid "%<threadprivate%> %qD is not file, namespace or block scope variable" msgstr "" -#: cp/semantics.cc:9684 +#: cp/semantics.cc:9688 #, gcc-internal-format msgid "%<threadprivate%> %qE directive not in %qT definition" msgstr "" -#: cp/semantics.cc:10421 +#: cp/semantics.cc:10425 #, gcc-internal-format msgid "difference between %qE and %qD does not have integer type" msgstr "" -#: cp/semantics.cc:10906 +#: cp/semantics.cc:10910 #, gcc-internal-format msgid "%<#pragma omp simd%> used with class iteration variable %qE" msgstr "" -#: cp/semantics.cc:11226 cp/semantics.cc:11236 +#: cp/semantics.cc:11230 cp/semantics.cc:11240 #, gcc-internal-format msgid "%<#pragma omp atomic update%> uses two different expressions for memory" msgstr "" -#: cp/semantics.cc:11578 +#: cp/semantics.cc:11582 #, gcc-internal-format msgid "" "%<static_assert%> message must be a string literal or object with %<size%> " "and %<data%> members" msgstr "" -#: cp/semantics.cc:11594 +#: cp/semantics.cc:11598 #, gcc-internal-format msgid "" "%<static_assert%> message %<size()%> must be implicitly convertible to " "%<std::size_t%>" msgstr "" -#: cp/semantics.cc:11603 +#: cp/semantics.cc:11607 #, gcc-internal-format msgid "" "%<static_assert%> message %<data()%> must be implicitly convertible to " "%<const char*%>" msgstr "" -#: cp/semantics.cc:11661 +#: cp/semantics.cc:11665 #, gcc-internal-format msgid "%<static_assert%> message %<size()%> must be a constant expression" msgstr "" -#: cp/semantics.cc:11669 +#: cp/semantics.cc:11673 #, gcc-internal-format msgid "%<static_assert%> message %<size()%> %qE too large" msgstr "" -#: cp/semantics.cc:11696 +#: cp/semantics.cc:11700 #, gcc-internal-format msgid "%<static_assert%> message %<data()[%d]%> must be a constant expression" msgstr "" -#: cp/semantics.cc:11723 +#: cp/semantics.cc:11727 #, gcc-internal-format msgid "%<static_assert%> message %<data()%> must be a core constant expression" msgstr "" -#: cp/semantics.cc:11749 +#: cp/semantics.cc:11753 #, gcc-internal-format msgid "static assertion failed: %.*s" msgstr "" -#: cp/semantics.cc:11757 +#: cp/semantics.cc:11761 #, gcc-internal-format msgid "non-constant condition for static assertion" msgstr "" -#: cp/semantics.cc:11786 +#: cp/semantics.cc:11790 #, gcc-internal-format msgid "argument to %<decltype%> must be an expression" msgstr "" -#: cp/semantics.cc:11832 +#: cp/semantics.cc:11836 #, gcc-internal-format msgid "%<decltype%> cannot resolve address of overloaded function" msgstr "" -#: cp/semantics.cc:12144 rust/backend/rust-tree.cc:5225 +#: cp/semantics.cc:12148 rust/backend/rust-tree.cc:5225 #, gcc-internal-format msgid "" "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument" msgstr "" -#: cp/semantics.cc:12153 rust/backend/rust-tree.cc:5234 +#: cp/semantics.cc:12157 rust/backend/rust-tree.cc:5234 #, gcc-internal-format msgid "" "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer " "to member" msgstr "" -#: cp/semantics.cc:12324 rust/backend/rust-tree.cc:5838 +#: cp/semantics.cc:12328 rust/backend/rust-tree.cc:5838 #, gcc-internal-format msgid "" "%<__builtin_is_corresponding_member%> not well defined for anonymous unions" msgstr "" -#: cp/semantics.cc:12348 rust/backend/rust-tree.cc:5882 +#: cp/semantics.cc:12352 rust/backend/rust-tree.cc:5882 #, gcc-internal-format msgid "%<__builtin_is_corresponding_member%> needs two arguments" msgstr "" -#: cp/semantics.cc:12359 rust/backend/rust-tree.cc:5892 +#: cp/semantics.cc:12363 rust/backend/rust-tree.cc:5892 #, gcc-internal-format msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member" msgstr "" -#: cp/semantics.cc:12843 +#: cp/semantics.cc:12847 #, gcc-internal-format msgid "%qD is not a class or alias template" msgstr "" -#: cp/semantics.cc:13032 +#: cp/semantics.cc:13036 #, gcc-internal-format msgid "operand of fold expression has no unexpanded parameter packs" msgstr "" -#: cp/semantics.cc:13092 +#: cp/semantics.cc:13096 #, gcc-internal-format msgid "both arguments in binary fold have unexpanded parameter packs" msgstr "" -#: cp/semantics.cc:13094 +#: cp/semantics.cc:13098 #, gcc-internal-format msgid "no unexpanded parameter packs in binary fold" msgstr "" -#: cp/semantics.cc:13112 +#: cp/semantics.cc:13116 #, gcc-internal-format msgid "non-pointer argument to %<__builtin_launder%>" msgstr "" @@ -68717,22 +68749,22 @@ msgstr "" #. std::bit_cast for destination ARRAY_TYPE is not possible, #. as functions may not return an array, so don't bother trying #. to support this (and then deal with VLAs etc.). -#: cp/semantics.cc:13161 +#: cp/semantics.cc:13165 #, gcc-internal-format msgid "%<__builtin_bit_cast%> destination type %qT is an array type" msgstr "" -#: cp/semantics.cc:13167 +#: cp/semantics.cc:13171 #, gcc-internal-format msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable" msgstr "" -#: cp/semantics.cc:13194 +#: cp/semantics.cc:13198 #, gcc-internal-format msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable" msgstr "" -#: cp/semantics.cc:13202 +#: cp/semantics.cc:13206 #, gcc-internal-format msgid "" "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE" @@ -70203,112 +70235,112 @@ msgstr "" msgid "cannot initialize aggregate of type %qT with a compound literal" msgstr "" -#: cp/typeck2.cc:1843 cp/typeck2.cc:1874 +#: cp/typeck2.cc:1820 cp/typeck2.cc:1851 #, gcc-internal-format msgid "missing initializer for member %qD" msgstr "" -#: cp/typeck2.cc:1850 +#: cp/typeck2.cc:1827 #, gcc-internal-format msgid "member %qD is uninitialized reference" msgstr "" -#: cp/typeck2.cc:1857 +#: cp/typeck2.cc:1834 #, gcc-internal-format msgid "member %qD with uninitialized reference fields" msgstr "" -#: cp/typeck2.cc:1943 +#: cp/typeck2.cc:1920 #, gcc-internal-format msgid "designator order for field %qD does not match declaration order in %qT" msgstr "" -#: cp/typeck2.cc:2016 +#: cp/typeck2.cc:1993 #, gcc-internal-format msgid "no field %qD found in union being initialized" msgstr "" -#: cp/typeck2.cc:2027 +#: cp/typeck2.cc:2004 #, gcc-internal-format msgid "index value instead of field name in union initializer" msgstr "" -#: cp/typeck2.cc:2242 +#: cp/typeck2.cc:2219 #, gcc-internal-format msgid "circular pointer delegation detected" msgstr "" -#: cp/typeck2.cc:2256 +#: cp/typeck2.cc:2233 #, gcc-internal-format msgid "base operand of %<->%> has non-pointer type %qT" msgstr "" -#: cp/typeck2.cc:2286 +#: cp/typeck2.cc:2263 #, gcc-internal-format msgid "result of %<operator->()%> yields non-pointer result" msgstr "" -#: cp/typeck2.cc:2288 +#: cp/typeck2.cc:2265 #, gcc-internal-format msgid "base operand of %<->%> is not a pointer" msgstr "" -#: cp/typeck2.cc:2315 +#: cp/typeck2.cc:2292 #, gcc-internal-format msgid "%qE cannot be used as a member pointer, since it is of type %qT" msgstr "" -#: cp/typeck2.cc:2324 +#: cp/typeck2.cc:2301 #, gcc-internal-format msgid "cannot apply member pointer %qE to %qE, which is of non-class type %qT" msgstr "" -#: cp/typeck2.cc:2346 +#: cp/typeck2.cc:2323 #, gcc-internal-format msgid "pointer to member type %qT incompatible with object type %qT" msgstr "" -#: cp/typeck2.cc:2408 +#: cp/typeck2.cc:2385 #, gcc-internal-format msgid "pointer-to-member-function type %qT requires an rvalue" msgstr "" -#: cp/typeck2.cc:2419 +#: cp/typeck2.cc:2396 #, gcc-internal-format msgid "pointer-to-member-function type %qT requires an lvalue" msgstr "" -#: cp/typeck2.cc:2427 +#: cp/typeck2.cc:2404 #, gcc-internal-format msgid "pointer-to-member-function type %qT requires an lvalue before C++20" msgstr "" -#: cp/typeck2.cc:2468 +#: cp/typeck2.cc:2445 #, gcc-internal-format msgid "functional cast to array type %qT" msgstr "" -#: cp/typeck2.cc:2485 +#: cp/typeck2.cc:2462 #, gcc-internal-format msgid "%<auto(x)%> cannot be constrained" msgstr "" -#: cp/typeck2.cc:2490 +#: cp/typeck2.cc:2467 #, gcc-internal-format msgid "%<auto(x)%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>" msgstr "" -#: cp/typeck2.cc:2515 +#: cp/typeck2.cc:2492 #, gcc-internal-format msgid "invalid value-initialization of reference type" msgstr "" -#: cp/typeck2.cc:2756 +#: cp/typeck2.cc:2733 #, gcc-internal-format msgid "call to function %qD which throws incomplete type %q#T" msgstr "" -#: cp/typeck2.cc:2759 +#: cp/typeck2.cc:2736 #, gcc-internal-format msgid "call to function which throws incomplete type %q#T" msgstr "" @@ -70522,33 +70554,33 @@ msgstr "" msgid "cannot represent built-in %<va_list%> type in D" msgstr "" -#: d/decl.cc:383 +#: d/decl.cc:373 #, gcc-internal-format, gfc-internal-format msgid "pragma(%s) not implemented" msgstr "" -#: d/decl.cc:490 d/decl.cc:608 d/decl.cc:682 d/decl.cc:725 d/decl.cc:764 +#: d/decl.cc:480 d/decl.cc:598 d/decl.cc:672 d/decl.cc:715 d/decl.cc:754 #, gcc-internal-format msgid "had semantic errors when compiling" msgstr "" #. Hiding detected; same name, overlapping specializations. -#: d/decl.cc:581 +#: d/decl.cc:571 #, gcc-internal-format msgid "use of %qs" msgstr "" -#: d/decl.cc:583 +#: d/decl.cc:573 #, gcc-internal-format msgid "is hidden by %qs" msgstr "" -#: d/decl.cc:586 +#: d/decl.cc:576 #, gcc-internal-format msgid "use %<alias %s = %s.%s;%> to introduce base class overload set" msgstr "" -#: d/decl.cc:822 +#: d/decl.cc:812 #, gcc-internal-format msgid "size is too large" msgstr "" @@ -71315,7 +71347,7 @@ msgstr "" msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants" msgstr "" -#: fortran/check.cc:123 fortran/resolve.cc:11517 +#: fortran/check.cc:123 fortran/resolve.cc:11536 #, gcc-internal-format, gfc-internal-format msgid "Invalid use of BOZ literal constant at %L" msgstr "" @@ -72585,12 +72617,12 @@ msgstr "" msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)" msgstr "" -#: fortran/data.cc:220 fortran/resolve.cc:5289 +#: fortran/data.cc:220 fortran/resolve.cc:5298 #, gcc-internal-format, gfc-internal-format msgid "Substring start index at %L is less than one" msgstr "" -#: fortran/data.cc:226 fortran/resolve.cc:5319 +#: fortran/data.cc:226 fortran/resolve.cc:5328 #, gcc-internal-format, gfc-internal-format msgid "Substring end index at %L exceeds the string length" msgstr "" @@ -72775,7 +72807,7 @@ msgstr "" msgid "deferred type parameter at %C" msgstr "" -#: fortran/decl.cc:1162 fortran/resolve.cc:13307 +#: fortran/decl.cc:1162 fortran/resolve.cc:13326 #, gcc-internal-format, gfc-internal-format msgid "Scalar INTEGER expression expected at %L" msgstr "" @@ -74823,12 +74855,12 @@ msgstr "" msgid "Error in array constructor referenced at %L" msgstr "" -#: fortran/expr.cc:1861 fortran/primary.cc:2389 fortran/primary.cc:2566 +#: fortran/expr.cc:1861 fortran/primary.cc:2398 fortran/primary.cc:2575 #, gcc-internal-format, gfc-internal-format msgid "LEN part_ref at %C" msgstr "" -#: fortran/expr.cc:1886 fortran/primary.cc:2384 fortran/primary.cc:2581 +#: fortran/expr.cc:1886 fortran/primary.cc:2393 fortran/primary.cc:2590 #, gcc-internal-format, gfc-internal-format msgid "KIND part_ref at %C" msgstr "" @@ -74910,7 +74942,7 @@ msgstr "" msgid "Evaluation of nonstandard initialization expression at %L" msgstr "" -#: fortran/expr.cc:3023 fortran/resolve.cc:2854 +#: fortran/expr.cc:3023 fortran/resolve.cc:2862 #, gcc-internal-format msgid "" "Function %qs in initialization expression at %L must be an intrinsic function" @@ -75210,7 +75242,7 @@ msgstr "" msgid "Explicit interface required for component %qs at %L: %s" msgstr "" -#: fortran/expr.cc:4232 fortran/expr.cc:4247 fortran/resolve.cc:2734 +#: fortran/expr.cc:4232 fortran/expr.cc:4247 fortran/resolve.cc:2742 #, gcc-internal-format msgid "Explicit interface required for %qs at %L: %s" msgstr "" @@ -75749,12 +75781,12 @@ msgstr "" msgid "Second argument of defined assignment at %L must be INTENT(IN)" msgstr "" -#: fortran/interface.cc:1035 fortran/resolve.cc:18209 +#: fortran/interface.cc:1035 fortran/resolve.cc:18228 #, gcc-internal-format, gfc-internal-format msgid "First argument of operator interface at %L must be INTENT(IN)" msgstr "" -#: fortran/interface.cc:1042 fortran/resolve.cc:18227 +#: fortran/interface.cc:1042 fortran/resolve.cc:18246 #, gcc-internal-format, gfc-internal-format msgid "Second argument of operator interface at %L must be INTENT(IN)" msgstr "" @@ -76766,7 +76798,7 @@ msgstr "" #. Use of -fdec-char-conversions allows assignment of character data #. to non-character variables. This not permitted for nonconstant #. strings. -#: fortran/intrinsic.cc:5413 fortran/resolve.cc:11492 +#: fortran/intrinsic.cc:5413 fortran/resolve.cc:11511 #, gcc-internal-format, gfc-internal-format msgid "Cannot convert %s to %s at %L" msgstr "" @@ -77334,7 +77366,7 @@ msgid "" "defined input/output procedure" msgstr "" -#: fortran/io.cc:3422 fortran/resolve.cc:16037 +#: fortran/io.cc:3422 fortran/resolve.cc:16056 #, gcc-internal-format msgid "" "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER " @@ -77917,7 +77949,7 @@ msgstr "" msgid "STOP code at %L must be default integer KIND=%d" msgstr "" -#: fortran/match.cc:3210 fortran/resolve.cc:12631 +#: fortran/match.cc:3210 fortran/resolve.cc:12650 #, gcc-internal-format, gfc-internal-format msgid "QUIET specifier at %L must be a scalar LOGICAL" msgstr "" @@ -80095,8 +80127,8 @@ msgstr "" msgid "ORDER clause must not be used together ORDERED at %L" msgstr "" -#: fortran/openmp.cc:7567 fortran/openmp.cc:7578 fortran/resolve.cc:11290 -#: fortran/resolve.cc:12859 +#: fortran/openmp.cc:7567 fortran/openmp.cc:7578 fortran/resolve.cc:11309 +#: fortran/resolve.cc:12878 #, gcc-internal-format, gfc-internal-format msgid "IF clause at %L requires a scalar LOGICAL expression" msgstr "" @@ -82056,211 +82088,211 @@ msgstr "" msgid "Coarray designator at %C but %qs is not a coarray" msgstr "" -#: fortran/primary.cc:2329 +#: fortran/primary.cc:2338 #, gcc-internal-format msgid "Symbol %qs at %C has no IMPLICIT type" msgstr "" -#: fortran/primary.cc:2336 +#: fortran/primary.cc:2345 #, gcc-internal-format msgid "Unexpected %<%c%> for nonderived-type variable %qs at %C" msgstr "" -#: fortran/primary.cc:2357 +#: fortran/primary.cc:2366 #, gcc-internal-format, gfc-internal-format msgid "Expected structure component name at %C" msgstr "" -#: fortran/primary.cc:2378 fortran/primary.cc:2553 +#: fortran/primary.cc:2387 fortran/primary.cc:2562 #, gcc-internal-format, gfc-internal-format msgid "RE or IM part_ref at %C" msgstr "" -#: fortran/primary.cc:2430 fortran/primary.cc:2558 +#: fortran/primary.cc:2439 fortran/primary.cc:2567 #, gcc-internal-format, gfc-internal-format msgid "The RE or IM part_ref at %C must be applied to a COMPLEX expression" msgstr "" -#: fortran/primary.cc:2437 fortran/primary.cc:2571 +#: fortran/primary.cc:2446 fortran/primary.cc:2580 #, gcc-internal-format, gfc-internal-format msgid "The LEN part_ref at %C must be applied to a CHARACTER expression" msgstr "" -#: fortran/primary.cc:2496 +#: fortran/primary.cc:2505 #, gcc-internal-format, gfc-internal-format msgid "Expected argument list at %C" msgstr "" -#: fortran/primary.cc:2514 +#: fortran/primary.cc:2523 #, gcc-internal-format msgid "" "%qs at %C is not an inquiry reference to an intrinsic type component %qs" msgstr "" -#: fortran/primary.cc:2517 +#: fortran/primary.cc:2526 #, gcc-internal-format msgid "%qs at %C is not an inquiry reference to an intrinsic type component" msgstr "" -#: fortran/primary.cc:2587 +#: fortran/primary.cc:2596 #, gcc-internal-format, gfc-internal-format msgid "" "The KIND part_ref at %C must be applied to an expression of intrinsic type" msgstr "" -#: fortran/primary.cc:2615 +#: fortran/primary.cc:2624 #, gcc-internal-format msgid "Procedure pointer component %qs requires an argument list at %C" msgstr "" -#: fortran/primary.cc:2718 +#: fortran/primary.cc:2727 #, gcc-internal-format, gfc-internal-format msgid "Nonpolymorphic reference to abstract type at %C" msgstr "" -#: fortran/primary.cc:2725 +#: fortran/primary.cc:2734 #, gcc-internal-format, gfc-internal-format msgid "Coindexed procedure-pointer component at %C" msgstr "" -#: fortran/primary.cc:2763 +#: fortran/primary.cc:2772 #, gcc-internal-format msgid "gfc_variable_attr(): Expression isn't a variable" msgstr "" -#: fortran/primary.cc:2981 +#: fortran/primary.cc:2990 #, gcc-internal-format msgid "gfc_caf_attr(): Expression isn't a variable" msgstr "" -#: fortran/primary.cc:3038 +#: fortran/primary.cc:3047 #, gcc-internal-format msgid "gfc_caf_attr(): Bad array reference" msgstr "" -#: fortran/primary.cc:3217 +#: fortran/primary.cc:3226 #, gcc-internal-format msgid "" "No initializer for allocatable component %qs given in the structure " "constructor at %C" msgstr "" -#: fortran/primary.cc:3228 +#: fortran/primary.cc:3237 #, gcc-internal-format, gfc-internal-format msgid "Structure constructor with missing optional arguments at %C" msgstr "" -#: fortran/primary.cc:3237 +#: fortran/primary.cc:3246 #, gcc-internal-format msgid "" "No initializer for component %qs given in the structure constructor at %C" msgstr "" -#: fortran/primary.cc:3285 +#: fortran/primary.cc:3294 #, gcc-internal-format msgid "Cannot construct ABSTRACT type %qs at %L" msgstr "" -#: fortran/primary.cc:3305 +#: fortran/primary.cc:3314 #, gcc-internal-format, gfc-internal-format msgid "Structure constructor with named arguments at %C" msgstr "" -#: fortran/primary.cc:3320 +#: fortran/primary.cc:3329 #, gcc-internal-format, gfc-internal-format msgid "Component initializer without name after component named %s at %L" msgstr "" -#: fortran/primary.cc:3325 +#: fortran/primary.cc:3334 #, gcc-internal-format, gfc-internal-format msgid "Too many components in structure constructor at %L" msgstr "" -#: fortran/primary.cc:3384 +#: fortran/primary.cc:3393 msgid "CHARACTER expression will be truncated in constructor (%td/%td) at %L" msgstr "" -#: fortran/primary.cc:3402 +#: fortran/primary.cc:3411 #, gcc-internal-format msgid "Component %qs is initialized twice in the structure constructor at %L" msgstr "" -#: fortran/primary.cc:3414 +#: fortran/primary.cc:3423 #, gcc-internal-format msgid "" "Coindexed expression to pointer component %qs in structure constructor at %L" msgstr "" -#: fortran/primary.cc:3468 +#: fortran/primary.cc:3477 #, gcc-internal-format msgid "" "component %qs at %L has already been set by a parent derived type constructor" msgstr "" -#: fortran/primary.cc:3633 +#: fortran/primary.cc:3642 #, gcc-internal-format, gfc-internal-format msgid "%%LOC() as an rvalue at %C" msgstr "" -#: fortran/primary.cc:3692 +#: fortran/primary.cc:3701 #, gcc-internal-format msgid "" "%qs at %C is the name of a recursive function and so refers to the result " "variable. Use an explicit RESULT variable for direct recursion (12.5.2.1)" msgstr "" -#: fortran/primary.cc:3723 fortran/primary.cc:4125 +#: fortran/primary.cc:3732 fortran/primary.cc:4134 #, gcc-internal-format, gfc-internal-format msgid "Symbol at %C is not appropriate for an expression" msgstr "" -#: fortran/primary.cc:3828 +#: fortran/primary.cc:3837 #, gcc-internal-format msgid "Unexpected use of subroutine name %qs at %C" msgstr "" -#: fortran/primary.cc:3860 +#: fortran/primary.cc:3869 #, gcc-internal-format msgid "Statement function %qs requires argument list at %C" msgstr "" -#: fortran/primary.cc:3863 +#: fortran/primary.cc:3872 #, gcc-internal-format msgid "Function %qs requires an argument list at %C" msgstr "" -#: fortran/primary.cc:3913 +#: fortran/primary.cc:3922 #, gcc-internal-format msgid "Missing argument to %qs at %C" msgstr "" -#: fortran/primary.cc:3926 +#: fortran/primary.cc:3935 #, gcc-internal-format, gfc-internal-format msgid "" "The leftmost part-ref in a data-ref cannot be a function reference at %C" msgstr "" -#: fortran/primary.cc:4081 +#: fortran/primary.cc:4090 #, gcc-internal-format msgid "Missing argument list in function %qs at %C" msgstr "" -#: fortran/primary.cc:4195 +#: fortran/primary.cc:4204 #, gcc-internal-format msgid "Derived type %qs cannot be used as a variable at %C" msgstr "" -#: fortran/primary.cc:4236 +#: fortran/primary.cc:4245 #, gcc-internal-format, gfc-internal-format msgid "Named constant at %C in an EQUIVALENCE" msgstr "" -#: fortran/primary.cc:4241 +#: fortran/primary.cc:4250 #, gcc-internal-format msgid "PARAMETER %qs shall not appear in a DATA statement at %C" msgstr "" -#: fortran/primary.cc:4277 +#: fortran/primary.cc:4286 #, gcc-internal-format msgid "%qs at %C is not a variable" msgstr "" @@ -82714,14 +82746,14 @@ msgid "" "recursively in procedure %qs. Declare it RECURSIVE or use %<-frecursive%>" msgstr "" -#: fortran/resolve.cc:1976 fortran/resolve.cc:6834 +#: fortran/resolve.cc:1976 fortran/resolve.cc:6843 #, gcc-internal-format msgid "" "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively. " "Declare it RECURSIVE or use %<-frecursive%>" msgstr "" -#: fortran/resolve.cc:2035 fortran/resolve.cc:10804 fortran/resolve.cc:12786 +#: fortran/resolve.cc:2035 fortran/resolve.cc:10823 fortran/resolve.cc:12805 #, gcc-internal-format, gfc-internal-format msgid "Label %d referenced at %L is never defined" msgstr "" @@ -82764,39 +82796,39 @@ msgstr "" msgid "Symbol %qs at %L is ambiguous" msgstr "" -#: fortran/resolve.cc:2212 +#: fortran/resolve.cc:2220 #, gcc-internal-format, gfc-internal-format msgid "By-value argument at %L is not of numeric type" msgstr "" -#: fortran/resolve.cc:2219 +#: fortran/resolve.cc:2227 #, gcc-internal-format, gfc-internal-format msgid "By-value argument at %L cannot be an array or an array section" msgstr "" -#: fortran/resolve.cc:2233 +#: fortran/resolve.cc:2241 #, gcc-internal-format, gfc-internal-format msgid "By-value argument at %L is not allowed in this context" msgstr "" -#: fortran/resolve.cc:2245 +#: fortran/resolve.cc:2253 #, gcc-internal-format, gfc-internal-format msgid "Passing internal procedure at %L by location not allowed" msgstr "" -#: fortran/resolve.cc:2256 +#: fortran/resolve.cc:2264 #, gcc-internal-format msgid "" "ELEMENTAL procedure pointer component %qs is not allowed as an actual " "argument at %L" msgstr "" -#: fortran/resolve.cc:2265 +#: fortran/resolve.cc:2273 #, gcc-internal-format, gfc-internal-format msgid "Coindexed actual argument at %L with ultimate pointer component" msgstr "" -#: fortran/resolve.cc:2412 +#: fortran/resolve.cc:2420 #, gcc-internal-format msgid "" "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be " @@ -82804,92 +82836,92 @@ msgid "" "argument with the same rank (Fortran 2018, 15.5.2.12)" msgstr "" -#: fortran/resolve.cc:2451 +#: fortran/resolve.cc:2459 #, gcc-internal-format msgid "" "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs " "is a scalar, but another actual argument is an array" msgstr "" -#: fortran/resolve.cc:2725 +#: fortran/resolve.cc:2733 #, gcc-internal-format msgid "Return type mismatch of function %qs at %L (%s/%s)" msgstr "" -#: fortran/resolve.cc:2752 +#: fortran/resolve.cc:2760 #, gcc-internal-format msgid "Interface mismatch in global procedure %qs at %L: %s" msgstr "" -#: fortran/resolve.cc:2858 +#: fortran/resolve.cc:2866 #, gcc-internal-format msgid "There is no specific function for the generic %qs at %L" msgstr "" -#: fortran/resolve.cc:2878 +#: fortran/resolve.cc:2886 #, gcc-internal-format msgid "" "Generic function %qs at %L is not consistent with a specific intrinsic " "interface" msgstr "" -#: fortran/resolve.cc:2916 +#: fortran/resolve.cc:2924 #, gcc-internal-format msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic" msgstr "" -#: fortran/resolve.cc:2971 +#: fortran/resolve.cc:2979 #, gcc-internal-format msgid "Unable to resolve the specific function %qs at %L" msgstr "" -#: fortran/resolve.cc:3048 +#: fortran/resolve.cc:3056 #, gcc-internal-format msgid "" "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L" msgstr "" -#: fortran/resolve.cc:3080 +#: fortran/resolve.cc:3088 #, gcc-internal-format msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?" msgstr "" -#: fortran/resolve.cc:3084 fortran/resolve.cc:18139 +#: fortran/resolve.cc:3092 fortran/resolve.cc:18158 #, gcc-internal-format msgid "Function %qs at %L has no IMPLICIT type" msgstr "" -#: fortran/resolve.cc:3208 +#: fortran/resolve.cc:3216 #, gcc-internal-format msgid "Reference to impure function %qs at %L inside a FORALL %s" msgstr "" -#: fortran/resolve.cc:3215 +#: fortran/resolve.cc:3223 #, gcc-internal-format msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s" msgstr "" -#: fortran/resolve.cc:3222 +#: fortran/resolve.cc:3230 #, gcc-internal-format msgid "Reference to impure function %qs at %L within a PURE procedure" msgstr "" -#: fortran/resolve.cc:3289 +#: fortran/resolve.cc:3297 #, gcc-internal-format msgid "Unexpected junk after %qs at %L" msgstr "" -#: fortran/resolve.cc:3300 +#: fortran/resolve.cc:3308 #, gcc-internal-format msgid "%qs at %L is not a function" msgstr "" -#: fortran/resolve.cc:3308 fortran/resolve.cc:3823 +#: fortran/resolve.cc:3316 fortran/resolve.cc:3831 #, gcc-internal-format msgid "ABSTRACT INTERFACE %qs must not be referenced at %L" msgstr "" -#: fortran/resolve.cc:3320 +#: fortran/resolve.cc:3328 #, gcc-internal-format msgid "" "ABSTRACT INTERFACE %qs at %L must not have an assumed character length " @@ -82897,349 +82929,349 @@ msgid "" msgstr "" #. Internal procedures are taken care of in resolve_contained_fntype. -#: fortran/resolve.cc:3363 +#: fortran/resolve.cc:3371 #, gcc-internal-format msgid "" "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is " "not a dummy argument" msgstr "" -#: fortran/resolve.cc:3397 +#: fortran/resolve.cc:3405 #, gcc-internal-format msgid "resolve_function(): bad function type" msgstr "" -#: fortran/resolve.cc:3411 +#: fortran/resolve.cc:3419 #, gcc-internal-format, gfc-internal-format msgid "" "A BOZ literal constant at %L cannot appear as an actual argument in a " "function reference" msgstr "" -#: fortran/resolve.cc:3427 +#: fortran/resolve.cc:3435 #, gcc-internal-format msgid "" "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE " "construct" msgstr "" -#: fortran/resolve.cc:3489 +#: fortran/resolve.cc:3497 #, gcc-internal-format msgid "" "ENTRY %qs at %L cannot be called recursively, as function %qs is not " "RECURSIVE" msgstr "" -#: fortran/resolve.cc:3493 +#: fortran/resolve.cc:3501 #, gcc-internal-format msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE" msgstr "" -#: fortran/resolve.cc:3551 +#: fortran/resolve.cc:3559 #, gcc-internal-format msgid "Using function %qs at %L is deprecated" msgstr "" -#: fortran/resolve.cc:3567 +#: fortran/resolve.cc:3575 #, gcc-internal-format msgid "Subroutine call to %qs in FORALL block at %L is not PURE" msgstr "" -#: fortran/resolve.cc:3573 +#: fortran/resolve.cc:3581 #, gcc-internal-format msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE" msgstr "" -#: fortran/resolve.cc:3579 +#: fortran/resolve.cc:3587 #, gcc-internal-format msgid "Subroutine call to %qs at %L is not PURE" msgstr "" -#: fortran/resolve.cc:3647 +#: fortran/resolve.cc:3655 #, gcc-internal-format msgid "There is no specific subroutine for the generic %qs at %L" msgstr "" -#: fortran/resolve.cc:3656 +#: fortran/resolve.cc:3664 #, gcc-internal-format msgid "" "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine " "interface" msgstr "" -#: fortran/resolve.cc:3691 +#: fortran/resolve.cc:3699 #, gcc-internal-format msgid "" "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic" msgstr "" -#: fortran/resolve.cc:3736 +#: fortran/resolve.cc:3744 #, gcc-internal-format msgid "Unable to resolve the specific subroutine %qs at %L" msgstr "" -#: fortran/resolve.cc:3794 +#: fortran/resolve.cc:3802 #, gcc-internal-format msgid "%qs at %L has a type, which is not consistent with the CALL at %L" msgstr "" -#: fortran/resolve.cc:3833 +#: fortran/resolve.cc:3841 #, gcc-internal-format msgid "" "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not " "RECURSIVE" msgstr "" -#: fortran/resolve.cc:3837 +#: fortran/resolve.cc:3845 #, gcc-internal-format msgid "" "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE" msgstr "" -#: fortran/resolve.cc:3882 +#: fortran/resolve.cc:3890 #, gcc-internal-format msgid "resolve_subroutine(): bad function type" msgstr "" -#: fortran/resolve.cc:3899 +#: fortran/resolve.cc:3907 #, gcc-internal-format msgid "Using subroutine %qs at %L is deprecated" msgstr "" -#: fortran/resolve.cc:3926 +#: fortran/resolve.cc:3934 #, gcc-internal-format, gfc-internal-format msgid "Shapes for operands at %L and %L are not conformable" msgstr "" -#: fortran/resolve.cc:3978 +#: fortran/resolve.cc:3986 #, gcc-internal-format msgid "logical_to_bitwise(): Bad intrinsic" msgstr "" -#: fortran/resolve.cc:4081 +#: fortran/resolve.cc:4089 #, gcc-internal-format msgid "Impure function %qs at %L might not be evaluated" msgstr "" -#: fortran/resolve.cc:4085 +#: fortran/resolve.cc:4093 #, gcc-internal-format, gfc-internal-format msgid "Impure function at %L might not be evaluated" msgstr "" -#: fortran/resolve.cc:4172 +#: fortran/resolve.cc:4180 #, gcc-internal-format msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs" msgstr "" -#: fortran/resolve.cc:4196 +#: fortran/resolve.cc:4204 #, gcc-internal-format msgid "Operands at %L and %L cannot appear as operands of binary operator %qs" msgstr "" -#: fortran/resolve.cc:4381 fortran/resolve.cc:4396 +#: fortran/resolve.cc:4389 fortran/resolve.cc:4404 #, gcc-internal-format, gfc-internal-format msgid "" "BOZ literal constant near %L cannot appear as an operand of a relational " "operator" msgstr "" -#: fortran/resolve.cc:4446 +#: fortran/resolve.cc:4454 #, gcc-internal-format, gfc-internal-format msgid "Equality comparison for %s at %L" msgstr "" -#: fortran/resolve.cc:4448 +#: fortran/resolve.cc:4456 #, gcc-internal-format, gfc-internal-format msgid "Inequality comparison for %s at %L" msgstr "" -#: fortran/resolve.cc:4508 +#: fortran/resolve.cc:4516 #, gcc-internal-format msgid "resolve_operator(): Bad intrinsic" msgstr "" -#: fortran/resolve.cc:4794 +#: fortran/resolve.cc:4802 #, gcc-internal-format, gfc-internal-format msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d" msgstr "" -#: fortran/resolve.cc:4799 +#: fortran/resolve.cc:4807 #, gcc-internal-format, gfc-internal-format msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d" msgstr "" -#: fortran/resolve.cc:4809 +#: fortran/resolve.cc:4817 #, gcc-internal-format, gfc-internal-format msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d" msgstr "" -#: fortran/resolve.cc:4814 +#: fortran/resolve.cc:4822 #, gcc-internal-format, gfc-internal-format msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d" msgstr "" -#: fortran/resolve.cc:4835 +#: fortran/resolve.cc:4843 #, gcc-internal-format, gfc-internal-format msgid "Illegal stride of zero at %L" msgstr "" -#: fortran/resolve.cc:4852 +#: fortran/resolve.cc:4860 #, gcc-internal-format, gfc-internal-format msgid "" "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d" msgstr "" -#: fortran/resolve.cc:4860 +#: fortran/resolve.cc:4868 #, gcc-internal-format, gfc-internal-format msgid "" "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d" msgstr "" -#: fortran/resolve.cc:4876 +#: fortran/resolve.cc:4884 #, gcc-internal-format, gfc-internal-format msgid "" "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d" msgstr "" -#: fortran/resolve.cc:4885 +#: fortran/resolve.cc:4893 #, gcc-internal-format, gfc-internal-format msgid "" "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d" msgstr "" -#: fortran/resolve.cc:4901 +#: fortran/resolve.cc:4909 #, gcc-internal-format msgid "check_dimension(): Bad array reference" msgstr "" -#: fortran/resolve.cc:4924 +#: fortran/resolve.cc:4932 #, gcc-internal-format, gfc-internal-format msgid "Rightmost upper bound of assumed size array section not specified at %L" msgstr "" -#: fortran/resolve.cc:4934 +#: fortran/resolve.cc:4942 #, gcc-internal-format, gfc-internal-format msgid "Rank mismatch in array reference at %L (%d/%d)" msgstr "" -#: fortran/resolve.cc:4942 +#: fortran/resolve.cc:4950 #, gcc-internal-format, gfc-internal-format msgid "Coindex rank mismatch in array reference at %L (%d/%d)" msgstr "" -#: fortran/resolve.cc:4958 +#: fortran/resolve.cc:4966 #, gcc-internal-format, gfc-internal-format msgid "Coindex of codimension %d must be a scalar at %L" msgstr "" -#: fortran/resolve.cc:4986 +#: fortran/resolve.cc:4994 #, gcc-internal-format, gfc-internal-format msgid "Array index at %L must be scalar" msgstr "" -#: fortran/resolve.cc:4992 +#: fortran/resolve.cc:5000 #, gcc-internal-format, gfc-internal-format msgid "Array index at %L must be of INTEGER type, found %s" msgstr "" -#: fortran/resolve.cc:4998 +#: fortran/resolve.cc:5006 #, gcc-internal-format, gfc-internal-format msgid "REAL array index at %L" msgstr "" -#: fortran/resolve.cc:5037 +#: fortran/resolve.cc:5046 #, gcc-internal-format, gfc-internal-format msgid "Argument dim at %L must be scalar" msgstr "" -#: fortran/resolve.cc:5044 +#: fortran/resolve.cc:5053 #, gcc-internal-format, gfc-internal-format msgid "Argument dim at %L must be of INTEGER type" msgstr "" -#: fortran/resolve.cc:5104 +#: fortran/resolve.cc:5113 #, gcc-internal-format, gfc-internal-format msgid "Invalid array reference of a non-array entity at %L" msgstr "" -#: fortran/resolve.cc:5118 +#: fortran/resolve.cc:5127 #, gcc-internal-format msgid "find_array_spec(): unused as(1)" msgstr "" -#: fortran/resolve.cc:5130 +#: fortran/resolve.cc:5139 #, gcc-internal-format msgid "find_array_spec(): unused as(2)" msgstr "" -#: fortran/resolve.cc:5175 +#: fortran/resolve.cc:5184 #, gcc-internal-format, gfc-internal-format msgid "Array index at %L is an array of rank %d" msgstr "" -#: fortran/resolve.cc:5273 +#: fortran/resolve.cc:5282 #, gcc-internal-format, gfc-internal-format msgid "Substring start index at %L must be of type INTEGER" msgstr "" -#: fortran/resolve.cc:5280 +#: fortran/resolve.cc:5289 #, gcc-internal-format, gfc-internal-format msgid "Substring start index at %L must be scalar" msgstr "" -#: fortran/resolve.cc:5302 +#: fortran/resolve.cc:5311 #, gcc-internal-format, gfc-internal-format msgid "Substring end index at %L must be of type INTEGER" msgstr "" -#: fortran/resolve.cc:5309 +#: fortran/resolve.cc:5318 #, gcc-internal-format, gfc-internal-format msgid "Substring end index at %L must be scalar" msgstr "" -#: fortran/resolve.cc:5329 +#: fortran/resolve.cc:5338 #, gcc-internal-format, gfc-internal-format msgid "Substring end index at %L is too large" msgstr "" -#: fortran/resolve.cc:5520 +#: fortran/resolve.cc:5529 #, gcc-internal-format msgid "resolve_ref(): Bad array reference" msgstr "" -#: fortran/resolve.cc:5534 +#: fortran/resolve.cc:5543 #, gcc-internal-format, gfc-internal-format msgid "" "Component to the right of a part reference with nonzero rank must not have " "the POINTER attribute at %L" msgstr "" -#: fortran/resolve.cc:5544 +#: fortran/resolve.cc:5553 #, gcc-internal-format, gfc-internal-format msgid "" "Component to the right of a part reference with nonzero rank must not have " "the ALLOCATABLE attribute at %L" msgstr "" -#: fortran/resolve.cc:5592 +#: fortran/resolve.cc:5601 #, gcc-internal-format, gfc-internal-format msgid "" "Two or more part references with nonzero rank must not be specified at %L" msgstr "" -#: fortran/resolve.cc:5684 +#: fortran/resolve.cc:5693 #, gcc-internal-format msgid "gfc_expression_rank(): Two array specs" msgstr "" -#: fortran/resolve.cc:5781 +#: fortran/resolve.cc:5790 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual " "argument" msgstr "" -#: fortran/resolve.cc:5791 +#: fortran/resolve.cc:5800 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L may only be used as actual argument" msgstr "" @@ -83248,14 +83280,14 @@ msgstr "" #. for all inquiry functions in resolve_function; the reason is #. that the function-name resolution happens too late in that #. function. -#: fortran/resolve.cc:5801 +#: fortran/resolve.cc:5810 #, gcc-internal-format, gfc-internal-format msgid "" "Assumed-type variable %s at %L as actual argument to an inquiry function " "shall be the first argument" msgstr "" -#: fortran/resolve.cc:5820 +#: fortran/resolve.cc:5829 #, gcc-internal-format, gfc-internal-format msgid "Assumed-rank variable %s at %L may only be used as actual argument" msgstr "" @@ -83264,326 +83296,326 @@ msgstr "" #. for all inquiry functions in resolve_function; the reason is #. that the function-name resolution happens too late in that #. function. -#: fortran/resolve.cc:5830 +#: fortran/resolve.cc:5839 #, gcc-internal-format, gfc-internal-format msgid "" "Assumed-rank variable %s at %L as actual argument to an inquiry function " "shall be the first argument" msgstr "" -#: fortran/resolve.cc:5841 +#: fortran/resolve.cc:5850 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject " "reference" msgstr "" -#: fortran/resolve.cc:5850 +#: fortran/resolve.cc:5859 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L shall not have a subobject reference" msgstr "" -#: fortran/resolve.cc:5866 +#: fortran/resolve.cc:5875 #, gcc-internal-format, gfc-internal-format msgid "Assumed-rank variable %s at %L shall not have a subobject reference" msgstr "" -#: fortran/resolve.cc:5923 +#: fortran/resolve.cc:5932 #, gcc-internal-format msgid "Scalar variable %qs has an array reference at %L" msgstr "" -#: fortran/resolve.cc:6068 +#: fortran/resolve.cc:6077 #, gcc-internal-format msgid "" "Variable %qs, used in a specification expression, is referenced at %L before " "the ENTRY statement in which it is a parameter" msgstr "" -#: fortran/resolve.cc:6073 +#: fortran/resolve.cc:6082 #, gcc-internal-format msgid "" "Variable %qs is used at %L before the ENTRY statement in which it is a " "parameter" msgstr "" -#: fortran/resolve.cc:6143 +#: fortran/resolve.cc:6152 #, gcc-internal-format, gfc-internal-format msgid "Polymorphic subobject of coindexed object at %L" msgstr "" -#: fortran/resolve.cc:6156 +#: fortran/resolve.cc:6165 #, gcc-internal-format, gfc-internal-format msgid "Coindexed object with polymorphic allocatable subcomponent at %L" msgstr "" -#: fortran/resolve.cc:6172 +#: fortran/resolve.cc:6181 #, gcc-internal-format msgid "Using variable %qs at %L is deprecated" msgstr "" -#: fortran/resolve.cc:6415 +#: fortran/resolve.cc:6424 #, gcc-internal-format msgid "" "%qs at %L is host associated at %L into a contained procedure with an " "internal procedure of the same name" msgstr "" -#: fortran/resolve.cc:6593 fortran/resolve.cc:6745 +#: fortran/resolve.cc:6602 fortran/resolve.cc:6754 #, gcc-internal-format, gfc-internal-format msgid "Error in typebound call at %L" msgstr "" -#: fortran/resolve.cc:6709 +#: fortran/resolve.cc:6718 #, gcc-internal-format, gfc-internal-format msgid "Passed-object at %L must be scalar" msgstr "" -#: fortran/resolve.cc:6716 +#: fortran/resolve.cc:6725 #, gcc-internal-format msgid "" "Base object for procedure-pointer component call at %L is of ABSTRACT type " "%qs" msgstr "" -#: fortran/resolve.cc:6755 +#: fortran/resolve.cc:6764 #, gcc-internal-format msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs" msgstr "" -#: fortran/resolve.cc:6764 +#: fortran/resolve.cc:6773 #, gcc-internal-format, gfc-internal-format msgid "Base object for NOPASS type-bound procedure call at %L must be scalar" msgstr "" #. Nothing matching found! -#: fortran/resolve.cc:6959 +#: fortran/resolve.cc:6968 #, gcc-internal-format msgid "" "Found no matching specific binding for the call to the GENERIC %qs at %L" msgstr "" -#: fortran/resolve.cc:6993 +#: fortran/resolve.cc:7002 #, gcc-internal-format msgid "%qs at %L should be a SUBROUTINE" msgstr "" -#: fortran/resolve.cc:7045 +#: fortran/resolve.cc:7054 #, gcc-internal-format msgid "%qs at %L should be a FUNCTION" msgstr "" -#: fortran/resolve.cc:7580 +#: fortran/resolve.cc:7589 #, gcc-internal-format msgid "gfc_resolve_expr(): Bad expression type" msgstr "" -#: fortran/resolve.cc:7613 +#: fortran/resolve.cc:7622 #, gcc-internal-format, gfc-internal-format msgid "%s at %L must be a scalar" msgstr "" -#: fortran/resolve.cc:7623 +#: fortran/resolve.cc:7632 #, gcc-internal-format, gfc-internal-format msgid "%s at %L must be integer" msgstr "" -#: fortran/resolve.cc:7627 fortran/resolve.cc:7634 +#: fortran/resolve.cc:7636 fortran/resolve.cc:7643 #, gcc-internal-format, gfc-internal-format msgid "%s at %L must be INTEGER" msgstr "" -#: fortran/resolve.cc:7689 +#: fortran/resolve.cc:7698 #, gcc-internal-format, gfc-internal-format msgid "Step expression in DO loop at %L cannot be zero" msgstr "" -#: fortran/resolve.cc:7712 +#: fortran/resolve.cc:7721 #, gcc-internal-format, gfc-internal-format msgid "DO loop at %L will be executed zero times" msgstr "" -#: fortran/resolve.cc:7729 +#: fortran/resolve.cc:7738 #, gcc-internal-format, gfc-internal-format msgid "DO loop at %L is undefined as it overflows" msgstr "" -#: fortran/resolve.cc:7735 +#: fortran/resolve.cc:7744 #, gcc-internal-format, gfc-internal-format msgid "DO loop at %L is undefined as it underflows" msgstr "" -#: fortran/resolve.cc:7796 +#: fortran/resolve.cc:7805 #, gcc-internal-format, gfc-internal-format msgid "FORALL index-name at %L must be a scalar INTEGER" msgstr "" -#: fortran/resolve.cc:7801 +#: fortran/resolve.cc:7810 #, gcc-internal-format, gfc-internal-format msgid "FORALL start expression at %L must be a scalar INTEGER" msgstr "" -#: fortran/resolve.cc:7808 +#: fortran/resolve.cc:7817 #, gcc-internal-format, gfc-internal-format msgid "FORALL end expression at %L must be a scalar INTEGER" msgstr "" -#: fortran/resolve.cc:7816 +#: fortran/resolve.cc:7825 #, gcc-internal-format, gfc-internal-format msgid "FORALL stride expression at %L must be a scalar %s" msgstr "" -#: fortran/resolve.cc:7821 +#: fortran/resolve.cc:7830 #, gcc-internal-format, gfc-internal-format msgid "FORALL stride expression at %L cannot be zero" msgstr "" -#: fortran/resolve.cc:7834 +#: fortran/resolve.cc:7843 #, gcc-internal-format msgid "FORALL index %qs may not appear in triplet specification at %L" msgstr "" -#: fortran/resolve.cc:7939 fortran/resolve.cc:8237 +#: fortran/resolve.cc:7948 fortran/resolve.cc:8246 #, gcc-internal-format, gfc-internal-format msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER" msgstr "" -#: fortran/resolve.cc:7947 fortran/resolve.cc:8200 +#: fortran/resolve.cc:7956 fortran/resolve.cc:8209 #, gcc-internal-format, gfc-internal-format msgid "Coindexed allocatable object at %L" msgstr "" -#: fortran/resolve.cc:8057 +#: fortran/resolve.cc:8066 #, gcc-internal-format, gfc-internal-format msgid "" "Source-expr at %L must be scalar or have the same rank as the allocate-" "object at %L" msgstr "" -#: fortran/resolve.cc:8088 +#: fortran/resolve.cc:8097 #, gcc-internal-format, gfc-internal-format msgid "Source-expr at %L and allocate-object at %L must have the same shape" msgstr "" -#: fortran/resolve.cc:8248 +#: fortran/resolve.cc:8257 #, gcc-internal-format, gfc-internal-format msgid "Type of entity at %L is type incompatible with source-expr at %L" msgstr "" -#: fortran/resolve.cc:8260 +#: fortran/resolve.cc:8269 #, gcc-internal-format, gfc-internal-format msgid "" "The allocate-object at %L and the source-expr at %L shall have the same kind " "type parameter" msgstr "" -#: fortran/resolve.cc:8274 +#: fortran/resolve.cc:8283 #, gcc-internal-format, gfc-internal-format msgid "" "The source-expr at %L shall neither be of type LOCK_TYPE nor have a " "LOCK_TYPE component if allocate-object at %L is a coarray" msgstr "" -#: fortran/resolve.cc:8289 +#: fortran/resolve.cc:8308 #, gcc-internal-format, gfc-internal-format msgid "" "The source-expr at %L shall neither be of type EVENT_TYPE nor have a " "EVENT_TYPE component if allocate-object at %L is a coarray" msgstr "" -#: fortran/resolve.cc:8302 +#: fortran/resolve.cc:8321 #, gcc-internal-format, gfc-internal-format msgid "" "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr" msgstr "" -#: fortran/resolve.cc:8320 +#: fortran/resolve.cc:8339 #, gcc-internal-format, gfc-internal-format msgid "" "Allocating %s at %L with type-spec requires the same character-length " "parameter as in the declaration" msgstr "" -#: fortran/resolve.cc:8404 fortran/resolve.cc:8419 +#: fortran/resolve.cc:8423 fortran/resolve.cc:8438 #, gcc-internal-format, gfc-internal-format msgid "Array specification required in ALLOCATE statement at %L" msgstr "" -#: fortran/resolve.cc:8411 +#: fortran/resolve.cc:8430 #, gcc-internal-format, gfc-internal-format msgid "" "Array specification or array-valued SOURCE= expression required in ALLOCATE " "statement at %L" msgstr "" -#: fortran/resolve.cc:8436 +#: fortran/resolve.cc:8455 #, gcc-internal-format, gfc-internal-format msgid "Coarray specification required in ALLOCATE statement at %L" msgstr "" -#: fortran/resolve.cc:8446 fortran/resolve.cc:8548 +#: fortran/resolve.cc:8465 fortran/resolve.cc:8567 #, gcc-internal-format, gfc-internal-format msgid "Bad coarray specification in ALLOCATE statement at %L" msgstr "" -#: fortran/resolve.cc:8452 +#: fortran/resolve.cc:8471 #, gcc-internal-format, gfc-internal-format msgid "Upper cobound is less than lower cobound at %L" msgstr "" -#: fortran/resolve.cc:8464 +#: fortran/resolve.cc:8483 #, gcc-internal-format, gfc-internal-format msgid "Upper cobound is less than lower cobound of 1 at %L" msgstr "" -#: fortran/resolve.cc:8475 fortran/resolve.cc:8503 +#: fortran/resolve.cc:8494 fortran/resolve.cc:8522 #, gcc-internal-format, gfc-internal-format msgid "Bad array specification in ALLOCATE statement at %L" msgstr "" -#: fortran/resolve.cc:8522 +#: fortran/resolve.cc:8541 #, gcc-internal-format msgid "" "%qs must not appear in the array specification at %L in the same ALLOCATE " "statement where it is itself allocated" msgstr "" -#: fortran/resolve.cc:8537 +#: fortran/resolve.cc:8556 #, gcc-internal-format msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L" msgstr "" -#: fortran/resolve.cc:8579 +#: fortran/resolve.cc:8598 #, gcc-internal-format, gfc-internal-format msgid "Stat-variable at %L must be a scalar INTEGER variable" msgstr "" -#: fortran/resolve.cc:8608 +#: fortran/resolve.cc:8627 #, gcc-internal-format, gfc-internal-format msgid "Stat-variable at %L shall not be %sd within the same %s statement" msgstr "" -#: fortran/resolve.cc:8621 +#: fortran/resolve.cc:8640 #, gcc-internal-format, gfc-internal-format msgid "ERRMSG at %L is useless without a STAT tag" msgstr "" -#: fortran/resolve.cc:8635 +#: fortran/resolve.cc:8654 #, gcc-internal-format, gfc-internal-format msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable" msgstr "" -#: fortran/resolve.cc:8664 +#: fortran/resolve.cc:8683 #, gcc-internal-format, gfc-internal-format msgid "Errmsg-variable at %L shall not be %sd within the same %s statement" msgstr "" -#: fortran/resolve.cc:8696 +#: fortran/resolve.cc:8715 #, gcc-internal-format, gfc-internal-format msgid "Allocate-object at %L also appears at %L" msgstr "" -#: fortran/resolve.cc:8702 fortran/resolve.cc:8708 +#: fortran/resolve.cc:8721 fortran/resolve.cc:8727 #, gcc-internal-format, gfc-internal-format msgid "Allocate-object at %L is subobject of object at %L" msgstr "" @@ -83592,301 +83624,301 @@ msgstr "" #. element in the list. Either way, we must #. issue an error and get the next case from P. #. FIXME: Sort P and Q by line number. -#: fortran/resolve.cc:8936 +#: fortran/resolve.cc:8955 #, gcc-internal-format, gfc-internal-format msgid "CASE label at %L overlaps with CASE label at %L" msgstr "" -#: fortran/resolve.cc:8987 +#: fortran/resolve.cc:9006 #, gcc-internal-format, gfc-internal-format msgid "Expression in CASE statement at %L must be of type %s" msgstr "" -#: fortran/resolve.cc:8998 +#: fortran/resolve.cc:9017 #, gcc-internal-format, gfc-internal-format msgid "Expression in CASE statement at %L must be of kind %d" msgstr "" -#: fortran/resolve.cc:9011 +#: fortran/resolve.cc:9030 #, gcc-internal-format, gfc-internal-format msgid "Expression in CASE statement at %L must be scalar" msgstr "" -#: fortran/resolve.cc:9057 +#: fortran/resolve.cc:9076 #, gcc-internal-format, gfc-internal-format msgid "" "Selection expression in computed GOTO statement at %L must be a scalar " "integer expression" msgstr "" -#: fortran/resolve.cc:9076 +#: fortran/resolve.cc:9095 #, gcc-internal-format, gfc-internal-format msgid "Argument of SELECT statement at %L cannot be %s" msgstr "" -#: fortran/resolve.cc:9086 +#: fortran/resolve.cc:9105 #, gcc-internal-format, gfc-internal-format msgid "Argument of SELECT statement at %L must be a scalar expression" msgstr "" -#: fortran/resolve.cc:9104 fortran/resolve.cc:9112 +#: fortran/resolve.cc:9123 fortran/resolve.cc:9131 #, gcc-internal-format, gfc-internal-format msgid "Expression in CASE statement at %L is not in the range of %s" msgstr "" -#: fortran/resolve.cc:9174 fortran/resolve.cc:9938 +#: fortran/resolve.cc:9193 fortran/resolve.cc:9957 #, gcc-internal-format, gfc-internal-format msgid "" "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L" msgstr "" -#: fortran/resolve.cc:9200 +#: fortran/resolve.cc:9219 #, gcc-internal-format, gfc-internal-format msgid "Logical range in CASE statement at %L is not allowed" msgstr "" -#: fortran/resolve.cc:9213 +#: fortran/resolve.cc:9232 #, gcc-internal-format, gfc-internal-format msgid "Constant logical value in CASE statement is repeated at %L" msgstr "" -#: fortran/resolve.cc:9228 +#: fortran/resolve.cc:9247 #, gcc-internal-format, gfc-internal-format msgid "Range specification at %L can never be matched" msgstr "" -#: fortran/resolve.cc:9331 +#: fortran/resolve.cc:9350 #, gcc-internal-format, gfc-internal-format msgid "Logical SELECT CASE block at %L has more that two cases" msgstr "" -#: fortran/resolve.cc:9393 +#: fortran/resolve.cc:9412 #, gcc-internal-format msgid "Associating entity %qs at %L is a procedure pointer" msgstr "" -#: fortran/resolve.cc:9402 +#: fortran/resolve.cc:9421 #, gcc-internal-format msgid "Derived type %qs cannot be used as a variable at %L" msgstr "" -#: fortran/resolve.cc:9419 +#: fortran/resolve.cc:9438 #, gcc-internal-format msgid "Associating entity %qs at %L is a procedure name" msgstr "" -#: fortran/resolve.cc:9435 +#: fortran/resolve.cc:9454 #, gcc-internal-format, gfc-internal-format msgid "Associating selector-expression at %L yields a procedure" msgstr "" -#: fortran/resolve.cc:9489 +#: fortran/resolve.cc:9508 #, gcc-internal-format, gfc-internal-format msgid "Selector at %L cannot be NULL()" msgstr "" -#: fortran/resolve.cc:9494 +#: fortran/resolve.cc:9513 #, gcc-internal-format, gfc-internal-format msgid "Selector at %L has no type" msgstr "" -#: fortran/resolve.cc:9552 +#: fortran/resolve.cc:9571 #, gcc-internal-format msgid "Associate-name %qs at %L is used as array" msgstr "" -#: fortran/resolve.cc:9563 +#: fortran/resolve.cc:9582 #, gcc-internal-format, gfc-internal-format msgid "CLASS selector at %L needs a temporary which is not yet implemented" msgstr "" -#: fortran/resolve.cc:9802 +#: fortran/resolve.cc:9821 #, gcc-internal-format, gfc-internal-format msgid "Selector shall be polymorphic in SELECT TYPE statement at %L" msgstr "" -#: fortran/resolve.cc:9846 fortran/resolve.cc:9858 +#: fortran/resolve.cc:9865 fortran/resolve.cc:9877 #, gcc-internal-format, gfc-internal-format msgid "Selector at %L must not be coindexed" msgstr "" -#: fortran/resolve.cc:9887 +#: fortran/resolve.cc:9906 #, gcc-internal-format, gfc-internal-format msgid "TYPE IS at %L overlaps with TYPE IS at %L" msgstr "" -#: fortran/resolve.cc:9900 +#: fortran/resolve.cc:9919 #, gcc-internal-format msgid "Derived type %qs at %L must be extensible" msgstr "" -#: fortran/resolve.cc:9913 +#: fortran/resolve.cc:9932 #, gcc-internal-format msgid "Derived type %qs at %L must be an extension of %qs" msgstr "" -#: fortran/resolve.cc:9916 +#: fortran/resolve.cc:9935 #, gcc-internal-format msgid "Unexpected intrinsic type %qs at %L" msgstr "" -#: fortran/resolve.cc:9926 +#: fortran/resolve.cc:9945 #, gcc-internal-format, gfc-internal-format msgid "" "The type-spec at %L shall specify that each length type parameter is assumed" msgstr "" -#: fortran/resolve.cc:10173 +#: fortran/resolve.cc:10192 #, gcc-internal-format, gfc-internal-format msgid "Double CLASS IS block in SELECT TYPE statement at %L" msgstr "" -#: fortran/resolve.cc:10306 +#: fortran/resolve.cc:10325 #, gcc-internal-format, gfc-internal-format msgid "RANK DEFAULT at %L is repeated at %L" msgstr "" -#: fortran/resolve.cc:10315 +#: fortran/resolve.cc:10334 #, gcc-internal-format, gfc-internal-format msgid "RANK (*) at %L is repeated at %L" msgstr "" -#: fortran/resolve.cc:10318 +#: fortran/resolve.cc:10337 #, gcc-internal-format, gfc-internal-format msgid "RANK (%i) at %L is repeated at %L" msgstr "" -#: fortran/resolve.cc:10328 +#: fortran/resolve.cc:10347 #, gcc-internal-format, gfc-internal-format msgid "" "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L" msgstr "" -#: fortran/resolve.cc:10437 +#: fortran/resolve.cc:10456 #, gcc-internal-format, gfc-internal-format msgid "Invalid context for NULL () intrinsic at %L" msgstr "" -#: fortran/resolve.cc:10491 +#: fortran/resolve.cc:10510 #, gcc-internal-format, gfc-internal-format msgid "DTIO %s procedure at %L must be recursive" msgstr "" -#: fortran/resolve.cc:10501 +#: fortran/resolve.cc:10520 #, gcc-internal-format, gfc-internal-format msgid "" "Data transfer element at %L cannot be polymorphic unless it is processed by " "a defined input/output procedure" msgstr "" -#: fortran/resolve.cc:10514 +#: fortran/resolve.cc:10533 #, gcc-internal-format, gfc-internal-format msgid "" "Data transfer element at %L cannot have POINTER components unless it is " "processed by a defined input/output procedure" msgstr "" -#: fortran/resolve.cc:10523 +#: fortran/resolve.cc:10542 #, gcc-internal-format, gfc-internal-format msgid "Data transfer element at %L cannot have procedure pointer components" msgstr "" -#: fortran/resolve.cc:10530 +#: fortran/resolve.cc:10549 #, gcc-internal-format, gfc-internal-format msgid "" "Data transfer element at %L cannot have ALLOCATABLE components unless it is " "processed by a defined input/output procedure" msgstr "" -#: fortran/resolve.cc:10541 +#: fortran/resolve.cc:10560 #, gcc-internal-format, gfc-internal-format msgid "Data transfer element at %L cannot have PRIVATE components" msgstr "" -#: fortran/resolve.cc:10547 +#: fortran/resolve.cc:10566 #, gcc-internal-format, gfc-internal-format msgid "" "Data transfer element at %L cannot have PRIVATE components unless it is " "processed by a defined input/output procedure" msgstr "" -#: fortran/resolve.cc:10565 +#: fortran/resolve.cc:10584 #, gcc-internal-format, gfc-internal-format msgid "" "Data transfer element at %L cannot be a full reference to an assumed-size " "array" msgstr "" -#: fortran/resolve.cc:10622 +#: fortran/resolve.cc:10641 #, gcc-internal-format, gfc-internal-format msgid "Lock variable at %L must be a scalar of type LOCK_TYPE" msgstr "" -#: fortran/resolve.cc:10632 +#: fortran/resolve.cc:10651 #, gcc-internal-format, gfc-internal-format msgid "Event variable at %L must be a scalar of type EVENT_TYPE" msgstr "" -#: fortran/resolve.cc:10636 +#: fortran/resolve.cc:10655 #, gcc-internal-format, gfc-internal-format msgid "Event variable argument at %L must be a coarray or coindexed" msgstr "" -#: fortran/resolve.cc:10639 +#: fortran/resolve.cc:10658 #, gcc-internal-format, gfc-internal-format msgid "Event variable argument at %L must be a coarray but not coindexed" msgstr "" -#: fortran/resolve.cc:10646 fortran/resolve.cc:10768 +#: fortran/resolve.cc:10665 fortran/resolve.cc:10787 #, gcc-internal-format, gfc-internal-format msgid "STAT= argument at %L must be a scalar INTEGER variable" msgstr "" -#: fortran/resolve.cc:10658 fortran/resolve.cc:10780 +#: fortran/resolve.cc:10677 fortran/resolve.cc:10799 #, gcc-internal-format, gfc-internal-format msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable" msgstr "" -#: fortran/resolve.cc:10670 +#: fortran/resolve.cc:10689 #, gcc-internal-format, gfc-internal-format msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable" msgstr "" -#: fortran/resolve.cc:10683 +#: fortran/resolve.cc:10702 #, gcc-internal-format, gfc-internal-format msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression" msgstr "" -#: fortran/resolve.cc:10744 +#: fortran/resolve.cc:10763 #, gcc-internal-format, gfc-internal-format msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression" msgstr "" -#: fortran/resolve.cc:10748 fortran/resolve.cc:10758 +#: fortran/resolve.cc:10767 fortran/resolve.cc:10777 #, gcc-internal-format, gfc-internal-format msgid "Imageset argument at %L must between 1 and num_images()" msgstr "" -#: fortran/resolve.cc:10811 +#: fortran/resolve.cc:10830 #, gcc-internal-format, gfc-internal-format msgid "" "Statement at %L is not a valid branch target statement for the branch " "statement at %L" msgstr "" -#: fortran/resolve.cc:10821 +#: fortran/resolve.cc:10840 #, gcc-internal-format, gfc-internal-format msgid "Branch at %L may result in an infinite loop" msgstr "" #. Note: A label at END CRITICAL does not leave the CRITICAL #. construct as END CRITICAL is still part of it. -#: fortran/resolve.cc:10838 fortran/resolve.cc:10861 +#: fortran/resolve.cc:10857 fortran/resolve.cc:10880 #, gcc-internal-format, gfc-internal-format msgid "GOTO statement at %L leaves CRITICAL construct for label at %L" msgstr "" -#: fortran/resolve.cc:10842 fortran/resolve.cc:10867 +#: fortran/resolve.cc:10861 fortran/resolve.cc:10886 #, gcc-internal-format, gfc-internal-format msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L" msgstr "" @@ -83894,80 +83926,80 @@ msgstr "" #. The label is not in an enclosing block, so illegal. This was #. allowed in Fortran 66, so we allow it as extension. No #. further checks are necessary in this case. -#: fortran/resolve.cc:10882 +#: fortran/resolve.cc:10901 #, gcc-internal-format, gfc-internal-format msgid "Label at %L is not in the same block as the GOTO statement at %L" msgstr "" -#: fortran/resolve.cc:10954 +#: fortran/resolve.cc:10973 #, gcc-internal-format, gfc-internal-format msgid "WHERE mask at %L has inconsistent shape" msgstr "" -#: fortran/resolve.cc:10970 +#: fortran/resolve.cc:10989 #, gcc-internal-format, gfc-internal-format msgid "WHERE assignment target at %L has inconsistent shape" msgstr "" -#: fortran/resolve.cc:10983 fortran/resolve.cc:11075 +#: fortran/resolve.cc:11002 fortran/resolve.cc:11094 #, gcc-internal-format, gfc-internal-format msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L" msgstr "" -#: fortran/resolve.cc:10993 fortran/resolve.cc:11085 +#: fortran/resolve.cc:11012 fortran/resolve.cc:11104 #, gcc-internal-format, gfc-internal-format msgid "Unsupported statement inside WHERE at %L" msgstr "" -#: fortran/resolve.cc:11024 +#: fortran/resolve.cc:11043 #, gcc-internal-format, gfc-internal-format msgid "Assignment to a FORALL index variable at %L" msgstr "" -#: fortran/resolve.cc:11033 +#: fortran/resolve.cc:11052 #, gcc-internal-format msgid "" "The FORALL with index %qs is not used on the left side of the assignment at " "%L and so might cause multiple assignment to this object" msgstr "" -#: fortran/resolve.cc:11190 +#: fortran/resolve.cc:11209 #, gcc-internal-format, gfc-internal-format msgid "FORALL construct at %L" msgstr "" -#: fortran/resolve.cc:11211 +#: fortran/resolve.cc:11230 #, gcc-internal-format, gfc-internal-format msgid "FORALL index-name at %L must be a scalar variable of type integer" msgstr "" -#: fortran/resolve.cc:11221 +#: fortran/resolve.cc:11240 #, gcc-internal-format, gfc-internal-format msgid "An outer FORALL construct already has an index with this name %L" msgstr "" -#: fortran/resolve.cc:11298 +#: fortran/resolve.cc:11317 #, gcc-internal-format, gfc-internal-format msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array" msgstr "" -#: fortran/resolve.cc:11416 +#: fortran/resolve.cc:11435 #, gcc-internal-format msgid "gfc_resolve_blocks(): Bad block type" msgstr "" -#: fortran/resolve.cc:11479 +#: fortran/resolve.cc:11498 #, gcc-internal-format, gfc-internal-format msgid "" "Variable in the ordinary assignment at %L is a procedure pointer component" msgstr "" -#: fortran/resolve.cc:11540 +#: fortran/resolve.cc:11559 #, gcc-internal-format msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L" msgstr "" -#: fortran/resolve.cc:11572 +#: fortran/resolve.cc:11591 #, gcc-internal-format, gfc-internal-format msgid "" "Coindexed expression at %L is assigned to a derived type variable with a " @@ -83975,7 +84007,7 @@ msgid "" msgstr "" #. F2008, C1283 (4). -#: fortran/resolve.cc:11578 +#: fortran/resolve.cc:11597 #, gcc-internal-format, gfc-internal-format msgid "" "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the " @@ -83984,43 +84016,43 @@ msgid "" "component selection." msgstr "" -#: fortran/resolve.cc:11590 +#: fortran/resolve.cc:11609 #, gcc-internal-format, gfc-internal-format msgid "Assignment to coindexed variable at %L in a PURE procedure" msgstr "" -#: fortran/resolve.cc:11622 +#: fortran/resolve.cc:11641 #, gcc-internal-format, gfc-internal-format msgid "Assignment to polymorphic coarray at %L is not permitted" msgstr "" -#: fortran/resolve.cc:11626 +#: fortran/resolve.cc:11645 #, gcc-internal-format, gfc-internal-format msgid "Assignment to an allocatable polymorphic variable at %L" msgstr "" -#: fortran/resolve.cc:11631 +#: fortran/resolve.cc:11650 #, gcc-internal-format msgid "" "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-" "lhs%>" msgstr "" -#: fortran/resolve.cc:11638 +#: fortran/resolve.cc:11657 #, gcc-internal-format msgid "" "Nonallocatable variable must not be polymorphic in intrinsic assignment at " "%L - check that there is a matching specific subroutine for %<=%> operator" msgstr "" -#: fortran/resolve.cc:11649 +#: fortran/resolve.cc:11668 #, gcc-internal-format, gfc-internal-format msgid "" "Coindexed variable must not have an allocatable ultimate component in " "assignment at %L" msgstr "" -#: fortran/resolve.cc:12072 +#: fortran/resolve.cc:12091 #, gcc-internal-format, gfc-internal-format msgid "" "TODO: type-bound defined assignment(s) at %L not done because multiple part " @@ -84029,93 +84061,93 @@ msgstr "" #. Even if standard does not support this feature, continue to build #. the two statements to avoid upsetting frontend_passes.c. -#: fortran/resolve.cc:12376 +#: fortran/resolve.cc:12395 #, gcc-internal-format, gfc-internal-format msgid "Pointer procedure assignment at %L" msgstr "" -#: fortran/resolve.cc:12388 +#: fortran/resolve.cc:12407 #, gcc-internal-format, gfc-internal-format msgid "" "The function result on the lhs of the assignment at %L must have the pointer " "attribute." msgstr "" -#: fortran/resolve.cc:12473 +#: fortran/resolve.cc:12492 #, gcc-internal-format msgid "" "TEAM argument to %qs at %L must be a scalar expression of type TEAM_TYPE" msgstr "" -#: fortran/resolve.cc:12664 +#: fortran/resolve.cc:12683 #, gcc-internal-format, gfc-internal-format msgid "TEAM NUMBER argument to FORM TEAM at %L must be a scalar INTEGER" msgstr "" -#: fortran/resolve.cc:12700 +#: fortran/resolve.cc:12719 #, gcc-internal-format, gfc-internal-format msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable" msgstr "" -#: fortran/resolve.cc:12704 +#: fortran/resolve.cc:12723 #, gcc-internal-format msgid "Variable %qs has not been assigned a target label at %L" msgstr "" -#: fortran/resolve.cc:12715 +#: fortran/resolve.cc:12734 #, gcc-internal-format, gfc-internal-format msgid "" "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier" msgstr "" -#: fortran/resolve.cc:12753 +#: fortran/resolve.cc:12772 #, gcc-internal-format, gfc-internal-format msgid "Expected intrinsic assignment in OMP WORKSHARE at %L" msgstr "" -#: fortran/resolve.cc:12795 +#: fortran/resolve.cc:12814 #, gcc-internal-format, gfc-internal-format msgid "ASSIGN statement at %L requires a scalar default INTEGER variable" msgstr "" -#: fortran/resolve.cc:12842 +#: fortran/resolve.cc:12861 #, gcc-internal-format, gfc-internal-format msgid "Invalid NULL at %L" msgstr "" -#: fortran/resolve.cc:12846 +#: fortran/resolve.cc:12865 #, gcc-internal-format, gfc-internal-format msgid "" "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression" msgstr "" -#: fortran/resolve.cc:12907 +#: fortran/resolve.cc:12926 #, gcc-internal-format msgid "gfc_resolve_code(): No expression on DO WHILE" msgstr "" -#: fortran/resolve.cc:12912 +#: fortran/resolve.cc:12931 #, gcc-internal-format, gfc-internal-format msgid "" "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression" msgstr "" -#: fortran/resolve.cc:12996 +#: fortran/resolve.cc:13015 #, gcc-internal-format, gfc-internal-format msgid "FORALL mask clause at %L requires a scalar LOGICAL expression" msgstr "" -#: fortran/resolve.cc:13100 +#: fortran/resolve.cc:13119 #, gcc-internal-format msgid "gfc_resolve_code(): Bad statement code" msgstr "" -#: fortran/resolve.cc:13121 +#: fortran/resolve.cc:13140 #, gcc-internal-format msgid "Using parameter %qs declared at %L is deprecated" msgstr "" -#: fortran/resolve.cc:13215 +#: fortran/resolve.cc:13234 #, gcc-internal-format msgid "" "Variable %qs with binding label %qs at %L uses the same global identifier as " @@ -84124,7 +84156,7 @@ msgstr "" #. This can only happen if the variable is defined in a module - if it #. isn't the same module, reject it. -#: fortran/resolve.cc:13229 +#: fortran/resolve.cc:13248 #, gcc-internal-format msgid "" "Variable %qs from module %qs with binding label %qs at %L uses the same " @@ -84134,63 +84166,63 @@ msgstr "" #. Print an error if the procedure is defined multiple times; we have to #. exclude references to the same procedure via module association or #. multiple checks for the same procedure. -#: fortran/resolve.cc:13248 +#: fortran/resolve.cc:13267 #, gcc-internal-format msgid "" "Procedure %qs with binding label %qs at %L uses the same global identifier " "as entity at %L" msgstr "" -#: fortran/resolve.cc:13334 +#: fortran/resolve.cc:13353 #, gcc-internal-format, gfc-internal-format msgid "String length at %L is too large" msgstr "" -#: fortran/resolve.cc:13572 +#: fortran/resolve.cc:13591 #, gcc-internal-format msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank" msgstr "" -#: fortran/resolve.cc:13576 +#: fortran/resolve.cc:13595 #, gcc-internal-format msgid "Scalar object %qs at %L may not be ALLOCATABLE" msgstr "" -#: fortran/resolve.cc:13584 +#: fortran/resolve.cc:13603 #, gcc-internal-format msgid "Array pointer %qs at %L must have a deferred shape or assumed rank" msgstr "" -#: fortran/resolve.cc:13595 +#: fortran/resolve.cc:13614 #, gcc-internal-format msgid "Array %qs at %L cannot have a deferred shape" msgstr "" -#: fortran/resolve.cc:13613 +#: fortran/resolve.cc:13632 #, gcc-internal-format msgid "Type %qs of CLASS variable %qs at %L is not extensible" msgstr "" -#: fortran/resolve.cc:13625 +#: fortran/resolve.cc:13644 #, gcc-internal-format msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer" msgstr "" -#: fortran/resolve.cc:13658 +#: fortran/resolve.cc:13677 #, gcc-internal-format msgid "" "The type %qs cannot be host associated at %L because it is blocked by an " "incompatible object of the same name declared at %L" msgstr "" -#: fortran/resolve.cc:13680 +#: fortran/resolve.cc:13699 #, gcc-internal-format msgid "" "Implied SAVE for module variable %qs at %L, needed due to the default " "initialization" msgstr "" -#: fortran/resolve.cc:13713 +#: fortran/resolve.cc:13732 #, gcc-internal-format msgid "" "Entity %qs at %L has a deferred type parameter and requires either the " @@ -84199,1071 +84231,1071 @@ msgstr "" #. F08:C541. The shape of an array defined in a main program or module #. * needs to be constant. -#: fortran/resolve.cc:13749 +#: fortran/resolve.cc:13768 #, gcc-internal-format msgid "The module or main program array %qs at %L must have constant shape" msgstr "" -#: fortran/resolve.cc:13774 +#: fortran/resolve.cc:13793 #, gcc-internal-format, gfc-internal-format msgid "" "Entity with assumed character length at %L must be a dummy argument or a " "PARAMETER" msgstr "" -#: fortran/resolve.cc:13795 +#: fortran/resolve.cc:13814 #, gcc-internal-format msgid "%qs at %L must have constant character length in this context" msgstr "" -#: fortran/resolve.cc:13802 +#: fortran/resolve.cc:13821 #, gcc-internal-format msgid "COMMON variable %qs at %L must have constant character length" msgstr "" -#: fortran/resolve.cc:13850 +#: fortran/resolve.cc:13869 #, gcc-internal-format msgid "Allocatable %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:13853 +#: fortran/resolve.cc:13872 #, gcc-internal-format msgid "External %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:13856 +#: fortran/resolve.cc:13875 #, gcc-internal-format msgid "Dummy %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:13859 +#: fortran/resolve.cc:13878 #, gcc-internal-format msgid "Intrinsic %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:13862 +#: fortran/resolve.cc:13881 #, gcc-internal-format msgid "Function result %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:13865 +#: fortran/resolve.cc:13884 #, gcc-internal-format msgid "Automatic array %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:13907 +#: fortran/resolve.cc:13926 #, gcc-internal-format, gfc-internal-format msgid "%s at %L" msgstr "" -#: fortran/resolve.cc:13939 +#: fortran/resolve.cc:13958 #, gcc-internal-format msgid "Character-valued statement function %qs at %L must have constant length" msgstr "" -#: fortran/resolve.cc:13962 +#: fortran/resolve.cc:13981 #, gcc-internal-format msgid "" "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is " "PUBLIC at %L" msgstr "" -#: fortran/resolve.cc:13984 +#: fortran/resolve.cc:14003 #, gcc-internal-format msgid "" "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs " "which is PRIVATE" msgstr "" -#: fortran/resolve.cc:14002 +#: fortran/resolve.cc:14021 #, gcc-internal-format msgid "Function %qs at %L cannot have an initializer" msgstr "" -#: fortran/resolve.cc:14014 +#: fortran/resolve.cc:14033 #, gcc-internal-format msgid "External object %qs at %L may not have an initializer" msgstr "" -#: fortran/resolve.cc:14024 +#: fortran/resolve.cc:14043 #, gcc-internal-format msgid "ELEMENTAL function %qs at %L must have a scalar result" msgstr "" -#: fortran/resolve.cc:14034 +#: fortran/resolve.cc:14053 #, gcc-internal-format msgid "" "Statement function %qs at %L may not have pointer or allocatable attribute" msgstr "" -#: fortran/resolve.cc:14053 +#: fortran/resolve.cc:14072 #, gcc-internal-format msgid "CHARACTER(*) function %qs at %L cannot be array-valued" msgstr "" -#: fortran/resolve.cc:14057 +#: fortran/resolve.cc:14076 #, gcc-internal-format msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued" msgstr "" -#: fortran/resolve.cc:14061 +#: fortran/resolve.cc:14080 #, gcc-internal-format msgid "CHARACTER(*) function %qs at %L cannot be pure" msgstr "" -#: fortran/resolve.cc:14065 +#: fortran/resolve.cc:14084 #, gcc-internal-format msgid "CHARACTER(*) function %qs at %L cannot be recursive" msgstr "" -#: fortran/resolve.cc:14078 +#: fortran/resolve.cc:14097 #, gcc-internal-format msgid "CHARACTER(*) function %qs at %L" msgstr "" -#: fortran/resolve.cc:14089 +#: fortran/resolve.cc:14108 #, gcc-internal-format msgid "Procedure pointer %qs at %L shall not be elemental" msgstr "" -#: fortran/resolve.cc:14095 +#: fortran/resolve.cc:14114 #, gcc-internal-format msgid "Dummy procedure %qs at %L shall not be elemental" msgstr "" -#: fortran/resolve.cc:14115 +#: fortran/resolve.cc:14134 #, gcc-internal-format msgid "" "Function result variable %qs at %L of elemental function %qs shall not have " "an ALLOCATABLE or POINTER attribute" msgstr "" -#: fortran/resolve.cc:14172 +#: fortran/resolve.cc:14191 #, gcc-internal-format msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L" msgstr "" -#: fortran/resolve.cc:14178 +#: fortran/resolve.cc:14197 #, gcc-internal-format msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L" msgstr "" -#: fortran/resolve.cc:14184 +#: fortran/resolve.cc:14203 #, gcc-internal-format msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L" msgstr "" -#: fortran/resolve.cc:14192 +#: fortran/resolve.cc:14211 #, gcc-internal-format msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L" msgstr "" -#: fortran/resolve.cc:14198 +#: fortran/resolve.cc:14217 #, gcc-internal-format msgid "Procedure pointer result %qs at %L is missing the pointer attribute" msgstr "" -#: fortran/resolve.cc:14241 +#: fortran/resolve.cc:14260 #, gcc-internal-format, gfc-internal-format msgid "" "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its " "interface in %s" msgstr "" -#: fortran/resolve.cc:14249 +#: fortran/resolve.cc:14268 #, gcc-internal-format, gfc-internal-format msgid "" "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface " "in %s" msgstr "" -#: fortran/resolve.cc:14257 +#: fortran/resolve.cc:14276 #, gcc-internal-format, gfc-internal-format msgid "" "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its " "interface in %s" msgstr "" -#: fortran/resolve.cc:14266 +#: fortran/resolve.cc:14285 #, gcc-internal-format msgid "" "%s between the MODULE PROCEDURE declaration in MODULE %qs and the " "declaration at %L in (SUB)MODULE %qs" msgstr "" -#: fortran/resolve.cc:14290 +#: fortran/resolve.cc:14309 #, gcc-internal-format msgid "Interface of %qs at %L must be explicit" msgstr "" -#: fortran/resolve.cc:14360 +#: fortran/resolve.cc:14379 #, gcc-internal-format msgid "FINAL procedure %qs at %L is not a SUBROUTINE" msgstr "" -#: fortran/resolve.cc:14369 +#: fortran/resolve.cc:14388 #, gcc-internal-format, gfc-internal-format msgid "FINAL procedure at %L must have exactly one argument" msgstr "" -#: fortran/resolve.cc:14377 fortran/resolve.cc:14394 +#: fortran/resolve.cc:14396 fortran/resolve.cc:14413 #, gcc-internal-format msgid "Argument of FINAL procedure at %L must be of type %qs" msgstr "" -#: fortran/resolve.cc:14385 +#: fortran/resolve.cc:14404 #, gcc-internal-format, gfc-internal-format msgid "" "FINAL procedure at %L with assumed rank argument must be the only finalizer " "with the same kind/type (F2018: C790)" msgstr "" -#: fortran/resolve.cc:14402 +#: fortran/resolve.cc:14421 #, gcc-internal-format, gfc-internal-format msgid "Argument of FINAL procedure at %L must not be a POINTER" msgstr "" -#: fortran/resolve.cc:14408 +#: fortran/resolve.cc:14427 #, gcc-internal-format, gfc-internal-format msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE" msgstr "" -#: fortran/resolve.cc:14414 +#: fortran/resolve.cc:14433 #, gcc-internal-format, gfc-internal-format msgid "Argument of FINAL procedure at %L must not be OPTIONAL" msgstr "" -#: fortran/resolve.cc:14422 +#: fortran/resolve.cc:14441 #, gcc-internal-format, gfc-internal-format msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)" msgstr "" -#: fortran/resolve.cc:14431 +#: fortran/resolve.cc:14450 #, gcc-internal-format, gfc-internal-format msgid "Non-scalar FINAL procedure at %L should have assumed shape argument" msgstr "" -#: fortran/resolve.cc:14453 +#: fortran/resolve.cc:14472 #, gcc-internal-format msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs" msgstr "" -#: fortran/resolve.cc:14490 +#: fortran/resolve.cc:14509 #, gcc-internal-format msgid "" "Only array FINAL procedures declared for derived type %qs defined at %L, " "suggest also scalar one unless an assumed rank finalizer has been declared" msgstr "" -#: fortran/resolve.cc:14531 +#: fortran/resolve.cc:14550 #, gcc-internal-format msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L" msgstr "" -#: fortran/resolve.cc:14567 +#: fortran/resolve.cc:14586 #, gcc-internal-format msgid "%qs and %qs for GENERIC %qs at %L are ambiguous" msgstr "" -#: fortran/resolve.cc:14626 +#: fortran/resolve.cc:14645 #, gcc-internal-format msgid "Undefined specific binding %qs as target of GENERIC %qs at %L" msgstr "" -#: fortran/resolve.cc:14638 +#: fortran/resolve.cc:14657 #, gcc-internal-format msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too" msgstr "" -#: fortran/resolve.cc:14666 +#: fortran/resolve.cc:14685 #, gcc-internal-format msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name" msgstr "" -#: fortran/resolve.cc:14722 +#: fortran/resolve.cc:14741 #, gcc-internal-format, gfc-internal-format msgid "Type-bound operator at %L cannot be NOPASS" msgstr "" -#: fortran/resolve.cc:14934 +#: fortran/resolve.cc:14953 #, gcc-internal-format msgid "" "%qs must be a module procedure or an external procedure with an explicit " "interface at %L" msgstr "" -#: fortran/resolve.cc:14977 +#: fortran/resolve.cc:14996 #, gcc-internal-format msgid "Procedure %qs with PASS(%s) at %L has no argument %qs" msgstr "" -#: fortran/resolve.cc:14991 +#: fortran/resolve.cc:15010 #, gcc-internal-format msgid "Procedure %qs with PASS at %L must have at least one argument" msgstr "" -#: fortran/resolve.cc:15005 fortran/resolve.cc:15547 +#: fortran/resolve.cc:15024 fortran/resolve.cc:15566 #, gcc-internal-format msgid "Non-polymorphic passed-object dummy argument of %qs at %L" msgstr "" -#: fortran/resolve.cc:15014 +#: fortran/resolve.cc:15033 #, gcc-internal-format msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs" msgstr "" -#: fortran/resolve.cc:15024 +#: fortran/resolve.cc:15043 #, gcc-internal-format msgid "" "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-" "type %qs" msgstr "" -#: fortran/resolve.cc:15066 +#: fortran/resolve.cc:15085 #, gcc-internal-format msgid "" "All LEN type parameters of the passed dummy argument %qs of %qs at %L must " "be ASSUMED." msgstr "" -#: fortran/resolve.cc:15076 +#: fortran/resolve.cc:15095 #, gcc-internal-format msgid "Passed-object dummy argument of %qs at %L must be scalar" msgstr "" -#: fortran/resolve.cc:15082 +#: fortran/resolve.cc:15101 #, gcc-internal-format msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE" msgstr "" -#: fortran/resolve.cc:15088 +#: fortran/resolve.cc:15107 #, gcc-internal-format msgid "Passed-object dummy argument of %qs at %L must not be POINTER" msgstr "" -#: fortran/resolve.cc:15117 +#: fortran/resolve.cc:15136 #, gcc-internal-format msgid "Procedure %qs at %L has the same name as a component of %qs" msgstr "" -#: fortran/resolve.cc:15127 +#: fortran/resolve.cc:15146 #, gcc-internal-format msgid "Procedure %qs at %L has the same name as an inherited component of %qs" msgstr "" -#: fortran/resolve.cc:15222 +#: fortran/resolve.cc:15241 #, gcc-internal-format msgid "" "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and " "not overridden" msgstr "" -#: fortran/resolve.cc:15327 +#: fortran/resolve.cc:15346 #, gcc-internal-format msgid "Coarray component %qs at %L must be allocatable with deferred shape" msgstr "" -#: fortran/resolve.cc:15336 +#: fortran/resolve.cc:15355 #, gcc-internal-format msgid "" "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray" msgstr "" -#: fortran/resolve.cc:15346 +#: fortran/resolve.cc:15365 #, gcc-internal-format msgid "" "Component %qs at %L with coarray component shall be a nonpointer, " "nonallocatable scalar" msgstr "" -#: fortran/resolve.cc:15371 +#: fortran/resolve.cc:15390 #, gcc-internal-format msgid "" "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer" msgstr "" -#: fortran/resolve.cc:15382 +#: fortran/resolve.cc:15401 #, gcc-internal-format msgid "Component %qs of BIND(C) type at %L must have length one" msgstr "" -#: fortran/resolve.cc:15480 +#: fortran/resolve.cc:15499 #, gcc-internal-format msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs" msgstr "" -#: fortran/resolve.cc:15494 +#: fortran/resolve.cc:15513 #, gcc-internal-format msgid "" "Procedure pointer component %qs with PASS at %L must have at least one " "argument" msgstr "" -#: fortran/resolve.cc:15510 +#: fortran/resolve.cc:15529 #, gcc-internal-format msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs" msgstr "" -#: fortran/resolve.cc:15520 +#: fortran/resolve.cc:15539 #, gcc-internal-format msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar" msgstr "" -#: fortran/resolve.cc:15529 +#: fortran/resolve.cc:15548 #, gcc-internal-format msgid "" "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute" msgstr "" -#: fortran/resolve.cc:15538 +#: fortran/resolve.cc:15557 #, gcc-internal-format msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE" msgstr "" -#: fortran/resolve.cc:15580 +#: fortran/resolve.cc:15599 #, gcc-internal-format msgid "" "Component %qs of %qs at %L has the same name as an inherited type-bound " "procedure" msgstr "" -#: fortran/resolve.cc:15593 +#: fortran/resolve.cc:15612 #, gcc-internal-format msgid "" "Character length of component %qs needs to be a constant specification " "expression at %L" msgstr "" -#: fortran/resolve.cc:15604 +#: fortran/resolve.cc:15623 #, gcc-internal-format msgid "" "Character length expression of component %qs at %L must be of INTEGER type, " "found %s" msgstr "" -#: fortran/resolve.cc:15617 +#: fortran/resolve.cc:15636 #, gcc-internal-format msgid "" "Character component %qs of %qs at %L with deferred length must be a POINTER " "or ALLOCATABLE" msgstr "" -#: fortran/resolve.cc:15650 +#: fortran/resolve.cc:15669 #, gcc-internal-format msgid "" "the component %qs is a PRIVATE type and cannot be a component of %qs, which " "is PUBLIC at %L" msgstr "" -#: fortran/resolve.cc:15658 +#: fortran/resolve.cc:15677 #, gcc-internal-format, gfc-internal-format msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s" msgstr "" -#: fortran/resolve.cc:15667 +#: fortran/resolve.cc:15686 #, gcc-internal-format, gfc-internal-format msgid "" "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE " "attribute" msgstr "" -#: fortran/resolve.cc:15753 +#: fortran/resolve.cc:15772 #, gcc-internal-format, gfc-internal-format msgid "Conflicting initializers in union at %L and %L" msgstr "" -#: fortran/resolve.cc:15798 +#: fortran/resolve.cc:15817 #, gcc-internal-format msgid "" "As extending type %qs at %L has a coarray component, parent type %qs shall " "also have one" msgstr "" -#: fortran/resolve.cc:15811 +#: fortran/resolve.cc:15830 #, gcc-internal-format msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT" msgstr "" -#: fortran/resolve.cc:15875 +#: fortran/resolve.cc:15894 #, gcc-internal-format msgid "" "Parameterized type %qs does not have a component corresponding to parameter " "%qs at %L" msgstr "" -#: fortran/resolve.cc:15908 +#: fortran/resolve.cc:15927 #, gcc-internal-format msgid "" "Generic name %qs of function %qs at %L being the same name as derived type " "at %L" msgstr "" -#: fortran/resolve.cc:15922 +#: fortran/resolve.cc:15941 #, gcc-internal-format msgid "Derived type %qs at %L has not been declared" msgstr "" -#: fortran/resolve.cc:15990 +#: fortran/resolve.cc:16009 #, gcc-internal-format msgid "Assumed size array %qs in namelist %qs at %L is not allowed" msgstr "" -#: fortran/resolve.cc:15996 +#: fortran/resolve.cc:16015 #, gcc-internal-format msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L" msgstr "" -#: fortran/resolve.cc:16002 +#: fortran/resolve.cc:16021 #, gcc-internal-format msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L" msgstr "" -#: fortran/resolve.cc:16010 +#: fortran/resolve.cc:16029 #, gcc-internal-format msgid "" "NAMELIST object %qs with nonconstant character length in namelist %qs at %L" msgstr "" -#: fortran/resolve.cc:16027 +#: fortran/resolve.cc:16046 #, gcc-internal-format msgid "" "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC " "namelist %qs at %L" msgstr "" -#: fortran/resolve.cc:16049 +#: fortran/resolve.cc:16068 #, gcc-internal-format msgid "" "NAMELIST object %qs has use-associated PRIVATE components and cannot be " "member of namelist %qs at %L" msgstr "" -#: fortran/resolve.cc:16060 +#: fortran/resolve.cc:16079 #, gcc-internal-format msgid "" "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC " "namelist %qs at %L" msgstr "" -#: fortran/resolve.cc:16087 +#: fortran/resolve.cc:16106 #, gcc-internal-format msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L" msgstr "" -#: fortran/resolve.cc:16106 +#: fortran/resolve.cc:16125 #, gcc-internal-format msgid "Parameter array %qs at %L cannot be automatic or of deferred shape" msgstr "" -#: fortran/resolve.cc:16122 +#: fortran/resolve.cc:16141 #, gcc-internal-format msgid "" "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type" msgstr "" -#: fortran/resolve.cc:16133 +#: fortran/resolve.cc:16152 #, gcc-internal-format, gfc-internal-format msgid "Incompatible derived type in PARAMETER at %L" msgstr "" -#: fortran/resolve.cc:16141 +#: fortran/resolve.cc:16160 #, gcc-internal-format msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute" msgstr "" -#: fortran/resolve.cc:16193 +#: fortran/resolve.cc:16212 #, gcc-internal-format msgid "" "Entity %qs at %L has a deferred LEN parameter %qs and requires either the " "POINTER or ALLOCATABLE attribute" msgstr "" -#: fortran/resolve.cc:16205 +#: fortran/resolve.cc:16224 #, gcc-internal-format msgid "" "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a " "variable declared in the main program, a module or a submodule(F08/C513)" msgstr "" -#: fortran/resolve.cc:16212 +#: fortran/resolve.cc:16231 #, gcc-internal-format msgid "" "The object %qs at %L with ASSUMED type parameters must be a dummy or a " "SELECT TYPE selector(F08/4.2)" msgstr "" -#: fortran/resolve.cc:16271 +#: fortran/resolve.cc:16290 #, gcc-internal-format, gfc-internal-format msgid "" "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays " "at %L are unsupported" msgstr "" -#: fortran/resolve.cc:16284 +#: fortran/resolve.cc:16303 #, gcc-internal-format msgid "" "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND " "clause" msgstr "" -#: fortran/resolve.cc:16342 +#: fortran/resolve.cc:16361 #, gcc-internal-format, gfc-internal-format msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L" msgstr "" -#: fortran/resolve.cc:16345 +#: fortran/resolve.cc:16364 #, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L" msgstr "" -#: fortran/resolve.cc:16442 +#: fortran/resolve.cc:16461 #, gcc-internal-format msgid "" "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an " "assumed-shape or assumed-rank array" msgstr "" -#: fortran/resolve.cc:16463 +#: fortran/resolve.cc:16482 #, gcc-internal-format, gfc-internal-format msgid "Bad specification for assumed size array at %L" msgstr "" -#: fortran/resolve.cc:16477 +#: fortran/resolve.cc:16496 #, gcc-internal-format, gfc-internal-format msgid "Assumed size array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.cc:16480 +#: fortran/resolve.cc:16499 #, gcc-internal-format, gfc-internal-format msgid "Assumed shape array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.cc:16490 +#: fortran/resolve.cc:16509 #, gcc-internal-format, gfc-internal-format msgid "Assumed-rank array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.cc:16497 +#: fortran/resolve.cc:16516 #, gcc-internal-format, gfc-internal-format msgid "" "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute" msgstr "" -#: fortran/resolve.cc:16510 +#: fortran/resolve.cc:16529 #, gcc-internal-format, gfc-internal-format msgid "Symbol at %L is not a DUMMY variable" msgstr "" -#: fortran/resolve.cc:16516 +#: fortran/resolve.cc:16535 #, gcc-internal-format msgid "" "%qs at %L cannot have the VALUE attribute because it is not a dummy argument" msgstr "" -#: fortran/resolve.cc:16526 +#: fortran/resolve.cc:16545 #, gcc-internal-format msgid "" "Character dummy variable %qs at %L with VALUE attribute must have constant " "length" msgstr "" -#: fortran/resolve.cc:16535 +#: fortran/resolve.cc:16554 #, gcc-internal-format msgid "" "C interoperable character dummy variable %qs at %L with VALUE attribute must " "have length one" msgstr "" -#: fortran/resolve.cc:16548 fortran/resolve.cc:16725 +#: fortran/resolve.cc:16567 fortran/resolve.cc:16744 #, gcc-internal-format msgid "The derived type %qs at %L is of type %qs, which has not been defined" msgstr "" -#: fortran/resolve.cc:16562 +#: fortran/resolve.cc:16581 #, gcc-internal-format, gfc-internal-format msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument" msgstr "" -#: fortran/resolve.cc:16571 +#: fortran/resolve.cc:16590 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of " "an numeric intrinsic type" msgstr "" -#: fortran/resolve.cc:16580 +#: fortran/resolve.cc:16599 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, " "CODIMENSION, POINTER or VALUE attribute" msgstr "" -#: fortran/resolve.cc:16588 +#: fortran/resolve.cc:16607 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) " "attribute" msgstr "" -#: fortran/resolve.cc:16595 +#: fortran/resolve.cc:16614 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an " "assumed-size array" msgstr "" -#: fortran/resolve.cc:16615 +#: fortran/resolve.cc:16634 #, gcc-internal-format, gfc-internal-format msgid "Assumed type of variable %s at %L is only permitted for dummy variables" msgstr "" -#: fortran/resolve.cc:16622 +#: fortran/resolve.cc:16641 #, 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.cc:16629 +#: fortran/resolve.cc:16648 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute" msgstr "" -#: fortran/resolve.cc:16636 +#: fortran/resolve.cc:16655 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L shall not be an explicit-shape array" msgstr "" -#: fortran/resolve.cc:16662 +#: fortran/resolve.cc:16681 #, gcc-internal-format msgid "" "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block " "nor declared at the module level scope" msgstr "" -#: fortran/resolve.cc:16672 +#: fortran/resolve.cc:16691 #, gcc-internal-format msgid "BIND(C) Variable %qs at %L must have length one" msgstr "" -#: fortran/resolve.cc:16751 +#: fortran/resolve.cc:16770 #, gcc-internal-format msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs" msgstr "" -#: fortran/resolve.cc:16766 +#: fortran/resolve.cc:16785 #, 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.cc:16779 +#: fortran/resolve.cc:16798 #, gcc-internal-format, gfc-internal-format msgid "" "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE " "must be a coarray" msgstr "" -#: fortran/resolve.cc:16797 +#: fortran/resolve.cc:16816 #, gcc-internal-format msgid "" "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have " "a default initializer" msgstr "" -#: fortran/resolve.cc:16809 +#: fortran/resolve.cc:16828 #, gcc-internal-format msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)" msgstr "" -#: fortran/resolve.cc:16818 +#: fortran/resolve.cc:16837 #, gcc-internal-format msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)" msgstr "" -#: fortran/resolve.cc:16831 +#: fortran/resolve.cc:16850 #, gcc-internal-format msgid "" "Function result %qs at %L shall not be a coarray or have a coarray component" msgstr "" -#: fortran/resolve.cc:16840 +#: fortran/resolve.cc:16859 #, gcc-internal-format msgid "" "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray" msgstr "" -#: fortran/resolve.cc:16853 +#: fortran/resolve.cc:16872 #, gcc-internal-format msgid "" "Variable %qs at %L with coarray component shall be a nonpointer, " "nonallocatable scalar, which is not a coarray" msgstr "" -#: fortran/resolve.cc:16869 +#: fortran/resolve.cc:16888 #, gcc-internal-format msgid "" "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy " "argument" msgstr "" -#: fortran/resolve.cc:16877 +#: fortran/resolve.cc:16896 #, gcc-internal-format msgid "" "Coarray variable %qs at %L shall not have codimensions with deferred shape" msgstr "" -#: fortran/resolve.cc:16884 +#: fortran/resolve.cc:16903 #, gcc-internal-format msgid "Allocatable coarray variable %qs at %L must have deferred shape" msgstr "" -#: fortran/resolve.cc:16897 +#: fortran/resolve.cc:16916 #, gcc-internal-format msgid "" "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray " "or have coarray components" msgstr "" -#: fortran/resolve.cc:16906 +#: fortran/resolve.cc:16925 #, gcc-internal-format msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs" msgstr "" -#: fortran/resolve.cc:16922 +#: fortran/resolve.cc:16941 #, gcc-internal-format msgid "" "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure " "%qs" msgstr "" -#: fortran/resolve.cc:16928 +#: fortran/resolve.cc:16947 #, gcc-internal-format msgid "" "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure " "%qs" msgstr "" -#: fortran/resolve.cc:16953 +#: fortran/resolve.cc:16972 #, gcc-internal-format msgid "Namelist %qs cannot be an argument to subroutine or function at %L" msgstr "" -#: fortran/resolve.cc:17013 +#: fortran/resolve.cc:17032 #, gcc-internal-format, gfc-internal-format msgid "Threadprivate at %L isn't SAVEd" msgstr "" -#: fortran/resolve.cc:17025 +#: fortran/resolve.cc:17044 #, gcc-internal-format msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd" msgstr "" -#: fortran/resolve.cc:17132 +#: fortran/resolve.cc:17151 #, gcc-internal-format, gfc-internal-format msgid "Expecting definable entity near %L" msgstr "" -#: fortran/resolve.cc:17140 +#: fortran/resolve.cc:17159 #, gcc-internal-format msgid "BLOCK DATA element %qs at %L must be in COMMON" msgstr "" -#: fortran/resolve.cc:17147 +#: fortran/resolve.cc:17166 #, gcc-internal-format msgid "DATA array %qs at %L must be specified in a previous declaration" msgstr "" -#: fortran/resolve.cc:17154 +#: fortran/resolve.cc:17173 #, gcc-internal-format msgid "DATA element %qs at %L cannot have a coindex" msgstr "" -#: fortran/resolve.cc:17170 +#: fortran/resolve.cc:17189 #, gcc-internal-format msgid "DATA element %qs at %L is a pointer and so must be a full array" msgstr "" -#: fortran/resolve.cc:17177 +#: fortran/resolve.cc:17196 #, gcc-internal-format, gfc-internal-format msgid "" "DATA object near %L has the pointer attribute and the corresponding DATA " "value is not a valid initial-data-target" msgstr "" -#: fortran/resolve.cc:17186 +#: fortran/resolve.cc:17205 #, gcc-internal-format msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute" msgstr "" -#: fortran/resolve.cc:17248 +#: fortran/resolve.cc:17267 #, gcc-internal-format, gfc-internal-format msgid "Nonconstant array section at %L in DATA statement" msgstr "" -#: fortran/resolve.cc:17261 +#: fortran/resolve.cc:17280 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %L has more variables than values" msgstr "" -#: fortran/resolve.cc:17337 +#: fortran/resolve.cc:17356 #, gcc-internal-format, gfc-internal-format msgid "Non-constant character length at %L in DATA statement" msgstr "" -#: fortran/resolve.cc:17365 +#: fortran/resolve.cc:17384 #, 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.cc:17373 +#: fortran/resolve.cc:17392 #, 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.cc:17381 +#: fortran/resolve.cc:17400 #, 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.cc:17388 +#: fortran/resolve.cc:17407 #, gcc-internal-format, gfc-internal-format msgid "step of implied-do loop at %L shall not be zero" msgstr "" -#: fortran/resolve.cc:17513 +#: fortran/resolve.cc:17532 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %L has more values than variables" msgstr "" -#: fortran/resolve.cc:17679 +#: fortran/resolve.cc:17698 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %L defined but not used" msgstr "" -#: fortran/resolve.cc:17685 +#: fortran/resolve.cc:17704 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %L defined but cannot be used" msgstr "" -#: fortran/resolve.cc:17769 +#: fortran/resolve.cc:17788 #, gcc-internal-format msgid "" "Derived type variable %qs at %L must have SEQUENCE attribute to be an " "EQUIVALENCE object" msgstr "" -#: fortran/resolve.cc:17778 +#: fortran/resolve.cc:17797 #, gcc-internal-format msgid "" "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an " "EQUIVALENCE object" msgstr "" -#: fortran/resolve.cc:17786 +#: fortran/resolve.cc:17805 #, gcc-internal-format msgid "" "Derived type variable %qs at %L with default initialization cannot be in " "EQUIVALENCE with a variable in COMMON" msgstr "" -#: fortran/resolve.cc:17802 +#: fortran/resolve.cc:17821 #, gcc-internal-format msgid "" "Derived type variable %qs at %L with pointer component(s) cannot be an " "EQUIVALENCE object" msgstr "" -#: fortran/resolve.cc:17905 +#: fortran/resolve.cc:17924 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in EQUIVALENCE statement at %L" msgstr "" -#: fortran/resolve.cc:17920 +#: fortran/resolve.cc:17939 #, 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.cc:17945 +#: fortran/resolve.cc:17964 #, gcc-internal-format msgid "" "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure " "procedure %qs" msgstr "" -#: fortran/resolve.cc:17954 +#: fortran/resolve.cc:17973 #, gcc-internal-format msgid "Named constant %qs at %L cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.cc:18029 +#: fortran/resolve.cc:18048 #, gcc-internal-format msgid "" "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.cc:18040 +#: fortran/resolve.cc:18059 #, gcc-internal-format msgid "Structure component %qs at %L cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.cc:18051 +#: fortran/resolve.cc:18070 #, gcc-internal-format, gfc-internal-format msgid "Substring at %L has length zero" msgstr "" -#: fortran/resolve.cc:18082 +#: fortran/resolve.cc:18101 #, gcc-internal-format msgid "Self reference in character length expression for %qs at %L" msgstr "" -#: fortran/resolve.cc:18149 +#: fortran/resolve.cc:18168 #, gcc-internal-format msgid "PUBLIC function %qs at %L of PRIVATE type %qs" msgstr "" -#: fortran/resolve.cc:18162 +#: fortran/resolve.cc:18181 #, gcc-internal-format msgid "ENTRY %qs at %L has no IMPLICIT type" msgstr "" -#: fortran/resolve.cc:18184 +#: fortran/resolve.cc:18203 #, gcc-internal-format msgid "User operator procedure %qs at %L must be a FUNCTION" msgstr "" -#: fortran/resolve.cc:18194 +#: fortran/resolve.cc:18213 #, gcc-internal-format msgid "User operator procedure %qs at %L cannot be assumed character length" msgstr "" -#: fortran/resolve.cc:18202 +#: fortran/resolve.cc:18221 #, gcc-internal-format msgid "User operator procedure %qs at %L must have at least one argument" msgstr "" -#: fortran/resolve.cc:18216 +#: fortran/resolve.cc:18235 #, gcc-internal-format, gfc-internal-format msgid "First argument of operator interface at %L cannot be optional" msgstr "" -#: fortran/resolve.cc:18234 +#: fortran/resolve.cc:18253 #, gcc-internal-format, gfc-internal-format msgid "Second argument of operator interface at %L cannot be optional" msgstr "" -#: fortran/resolve.cc:18241 +#: fortran/resolve.cc:18260 #, gcc-internal-format, gfc-internal-format msgid "Operator interface at %L must have, at most, two arguments" msgstr "" -#: fortran/resolve.cc:18323 +#: fortran/resolve.cc:18342 #, gcc-internal-format msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE" msgstr "" @@ -85813,7 +85845,7 @@ msgstr "" #: fortran/symbol.cc:323 #, gcc-internal-format -msgid "Symbol %qs at %L has no IMPLICIT type(symbol)" +msgid "Symbol %qs at %L has no IMPLICIT type" msgstr "" #. BIND(C) variables should not be implicitly declared. @@ -86344,99 +86376,99 @@ msgstr "" #: fortran/trans-decl.cc:1800 #, gcc-internal-format, gfc-internal-format -msgid "%s at %C has no default type" +msgid "%s at %L has no default type" msgstr "" -#: fortran/trans-decl.cc:1803 +#: fortran/trans-decl.cc:1804 #, gcc-internal-format msgid "intrinsic variable which isn't a procedure" msgstr "" -#: fortran/trans-decl.cc:4564 fortran/trans-decl.cc:7957 +#: fortran/trans-decl.cc:4565 fortran/trans-decl.cc:7958 #, gcc-internal-format msgid "Return value of function %qs at %L not set" msgstr "" -#: fortran/trans-decl.cc:5109 +#: fortran/trans-decl.cc:5110 #, gcc-internal-format msgid "Deferred type parameter not yet supported" msgstr "" -#: fortran/trans-decl.cc:5224 +#: fortran/trans-decl.cc:5225 #, gcc-internal-format msgid "Sorry, !$OMP allocate for COMMON block variable %qs at %L not supported" msgstr "" -#: fortran/trans-decl.cc:5231 +#: fortran/trans-decl.cc:5232 #, gcc-internal-format msgid "" "Sorry, !$OMP allocate for variable %qs at %L with SAVE attribute not yet " "implemented" msgstr "" -#: fortran/trans-decl.cc:5437 +#: fortran/trans-decl.cc:5438 #, gcc-internal-format msgid "backend decl for module variable %qs already exists" msgstr "" -#: fortran/trans-decl.cc:5450 +#: fortran/trans-decl.cc:5451 #, gcc-internal-format msgid "Unused PRIVATE module variable %qs declared at %L" msgstr "" -#: fortran/trans-decl.cc:6072 +#: fortran/trans-decl.cc:6073 #, gcc-internal-format msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument" msgstr "" -#: fortran/trans-decl.cc:6075 +#: fortran/trans-decl.cc:6076 #, gcc-internal-format msgid "Symbol %qs at %L has the WEAK attribute but is a local variable" msgstr "" -#: fortran/trans-decl.cc:6090 +#: fortran/trans-decl.cc:6091 #, gcc-internal-format msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set" msgstr "" -#: fortran/trans-decl.cc:6096 +#: fortran/trans-decl.cc:6097 #, gcc-internal-format msgid "" "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not " "set and does not have a default initializer" msgstr "" -#: fortran/trans-decl.cc:6107 fortran/trans-decl.cc:6258 +#: fortran/trans-decl.cc:6108 fortran/trans-decl.cc:6259 #, gcc-internal-format msgid "Unused dummy argument %qs at %L" msgstr "" -#: fortran/trans-decl.cc:6123 +#: fortran/trans-decl.cc:6124 #, gcc-internal-format msgid "Unused module variable %qs which has been explicitly imported at %L" msgstr "" -#: fortran/trans-decl.cc:6142 +#: fortran/trans-decl.cc:6143 #, gcc-internal-format msgid "Unused variable %qs declared at %L" msgstr "" -#: fortran/trans-decl.cc:6191 +#: fortran/trans-decl.cc:6192 #, gcc-internal-format msgid "Unused parameter %qs declared at %L" msgstr "" -#: fortran/trans-decl.cc:6195 +#: fortran/trans-decl.cc:6196 #, gcc-internal-format msgid "Unused parameter %qs which has been explicitly imported at %L" msgstr "" -#: fortran/trans-decl.cc:6225 +#: fortran/trans-decl.cc:6226 #, gcc-internal-format msgid "Return value %qs of function %qs declared at %L not set" msgstr "" -#: fortran/trans-decl.cc:6822 +#: fortran/trans-decl.cc:6823 #, gcc-internal-format, gfc-internal-format msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct" msgstr "" @@ -87052,7 +87084,7 @@ msgstr "" msgid "closing LTRANS output list %s: %m" msgstr "" -#: m2/gm2-lang.cc:1151 +#: m2/gm2-lang.cc:1137 #, gcc-internal-format msgid "cannot convert expression, only base types can be converted" msgstr "" diff --git a/gcc/po/sv.po b/gcc/po/sv.po index d8a55cf55d3..32e63d610ac 100644 --- a/gcc/po/sv.po +++ b/gcc/po/sv.po @@ -32,7 +32,7 @@ msgstr "" "Project-Id-Version: gcc 14.1-b20240218\n" "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n" "POT-Creation-Date: 2024-02-16 21:35+0000\n" -"PO-Revision-Date: 2024-04-02 09:51+0200\n" +"PO-Revision-Date: 2024-04-10 22:53+0200\n" "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n" "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n" "Language: sv\n" @@ -62421,10 +62421,9 @@ msgid "%<#pragma omp assumes%> may only be used at file or namespace scope" msgstr "%<#pragma omp assumes%> kan endast användas med fil- eller namnrymdsräckvidd" #: cp/parser.cc:51053 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma GCC ivdep%> must be inside a function" +#, gcc-internal-format msgid "%<#pragma GCC %s%> must be inside a function" -msgstr "%<#pragma GCC ivdep%> måste vara inuti en funktion" +msgstr "%<#pragma GCC %s%> måste vara inuti en funktion" #: cp/parser.cc:51195 #, gcc-internal-format @@ -63989,16 +63988,14 @@ msgid " since %q+#D declared in base class" msgstr " eftersom %q+#D är deklarerad i basklassen" #: cp/search.cc:2281 -#, fuzzy, gcc-internal-format -#| msgid "virtual function %q+D overriding final function" +#, gcc-internal-format msgid "explicit object member function overrides virtual function" -msgstr "virtuell funktion %q+D åsidosätter slutlig funktion" +msgstr "en explicit objektmedlemsfunktion åsidosätter en virtuell funktion" #: cp/search.cc:2284 -#, fuzzy, gcc-internal-format -#| msgid "resolver indirect function declared here" +#, gcc-internal-format msgid "virtual function declared here" -msgstr "upplösning av indirekt funktion deklarerad här" +msgstr "den virtuella funktionen deklarerad här" #: cp/semantics.cc:1109 #, gcc-internal-format @@ -64081,22 +64078,19 @@ msgid "arguments to destructor are not allowed" msgstr "argument till destruerare är inte tillåtet" #: cp/semantics.cc:3175 -#, fuzzy, gcc-internal-format -#| msgid "%<this%> is unavailable for static member functions" +#, gcc-internal-format msgid "%<this%> is unavailable for explicit object member functions" -msgstr "%<this%> är inte tillgängligt i en statisk medlemsfunktion" +msgstr "%<this%> är inte tillgängligt i explicita objektmedlemsfunktioner" #: cp/semantics.cc:3187 -#, fuzzy, gcc-internal-format -#| msgid "use the apostrophe directive %qs instead" +#, gcc-internal-format msgid "use explicit object parameter %qs instead" -msgstr "använd apostrofdirektivet %qs istället" +msgstr "använd en explicit objektparameter %qs istället" #: cp/semantics.cc:3191 -#, fuzzy, gcc-internal-format -#| msgid "invalid template non-type parameter" +#, gcc-internal-format msgid "name the explicit object parameter" -msgstr "ogiltig mallparameter som inte är en typ" +msgstr "namnge den explicita objektdparametern" #: cp/semantics.cc:3196 #, gcc-internal-format @@ -64255,10 +64249,9 @@ msgid "%qT is not an enumeration type" msgstr "%qT är inte ett uppräkningstyp" #: cp/semantics.cc:4650 -#, fuzzy, gcc-internal-format -#| msgid "requested alignment is not an integer constant" +#, gcc-internal-format msgid "%<__type_pack_element%> index is not an integral constant" -msgstr "begärd minnesjustering är inte en heltalskonstant" +msgstr "indexet till %<__type_pack_element%> är inte en heltalskonstant" #: cp/semantics.cc:4656 #, gcc-internal-format @@ -64266,10 +64259,9 @@ msgid "%<__type_pack_element%> index is negative" msgstr "indexet till %<__type_pack_element%> är negativt" #: cp/semantics.cc:4662 -#, fuzzy, gcc-internal-format -#| msgid "Reference statement index out of range" +#, gcc-internal-format msgid "%<__type_pack_element%> index is out of range" -msgstr "Referenssatsindex utanför intervallet" +msgstr "indexet till %<__type_pack_element%> är utanför intervallet" #. Parameter packs can only be used in templates #: cp/semantics.cc:4785 @@ -64303,10 +64295,9 @@ msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-support msgstr "%<offsetof%> inom icke-standardlayouttypen %qT är villkorligt stött" #: cp/semantics.cc:6046 -#, fuzzy, gcc-internal-format -#| msgid "constructor priorities are not supported" +#, gcc-internal-format msgid "pointer-to-member mapping %qE not supported" -msgstr "konstruerarprioriteter stödjs ej" +msgstr "pekar-till-medlems-avbildningen %qE stödjs ej" #: cp/semantics.cc:6240 #, gcc-internal-format @@ -64590,10 +64581,9 @@ msgid "%<static_assert%> message %<data()%> must be implicitly convertible to %< msgstr "meddelandet %<data()%> till %<static_assert%> måste vara implicit konverterbart till %<const char*%>" #: cp/semantics.cc:11592 -#, fuzzy, gcc-internal-format -#| msgid "%<hint%> expression must be constant integer expression" +#, gcc-internal-format msgid "%<static_assert%> message %<size()%> must be a constant expression" -msgstr "%<hint%>-uttryck måste vara ett konstant heltalsuttryck" +msgstr "meddelandet %<size()%> till %<static_assert%> måste vara ett konstant uttryck" #: cp/semantics.cc:11600 #, gcc-internal-format @@ -64601,22 +64591,19 @@ msgid "%<static_assert%> message %<size()%> %qE too large" msgstr "meddelandet %<size()%> till %<static_assert%> %qE är för stort" #: cp/semantics.cc:11627 -#, fuzzy, gcc-internal-format -#| msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression" +#, gcc-internal-format msgid "%<static_assert%> message %<data()[%d]%> must be a constant expression" -msgstr "%<reinterpret_cast<%T>(%E)%> är inte ett konstant uttryck" +msgstr "meddelandet %<data()[%d]%> till %<static_assert%> måste vara ett konstant uttryck" #: cp/semantics.cc:11654 -#, fuzzy, gcc-internal-format -#| msgid "argument %d of %qE must be an integer constant expression" +#, gcc-internal-format msgid "%<static_assert%> message %<data()%> must be a core constant expression" -msgstr "argument %d till %qE måste vara ett konstant heltalsuttryck" +msgstr "meddelandet %<data()%> till %<static_assert%> måste vara ett kärnkonstant uttryck" #: cp/semantics.cc:11680 -#, fuzzy, gcc-internal-format -#| msgid "static assertion failed: %s" +#, gcc-internal-format msgid "static assertion failed: %.*s" -msgstr "statisk försäkran misslyckades: %s" +msgstr "statisk försäkran misslyckades: %.*s" #: cp/semantics.cc:11688 #, gcc-internal-format @@ -65213,10 +65200,9 @@ msgid "the compiler can assume that the address of %qD will never be NULL" msgstr "kompilatorn kan anta att adressen till %qD aldrig kommer att vara NULL" #: cp/typeck.cc:5055 -#, fuzzy, gcc-internal-format -#| msgid "bitwise operation between different enumeration types %qT and %qT is deprecated" +#, gcc-internal-format msgid "bitwise operation between different enumeration types %qT and %qT" -msgstr "bitvis konvertering mellan olika uppräkningstyper %qT och %qT bör undvikas" +msgstr "bitvis operation mellan olika uppräkningstyper %qT och %qT" #: cp/typeck.cc:5058 #, gcc-internal-format @@ -65224,10 +65210,9 @@ msgid "bitwise operation between different enumeration types %qT and %qT is depr msgstr "bitvis konvertering mellan olika uppräkningstyper %qT och %qT bör undvikas" #: cp/typeck.cc:5064 -#, fuzzy, gcc-internal-format -#| msgid "arithmetic between different enumeration types %qT and %qT is deprecated" +#, gcc-internal-format msgid "arithmetic between different enumeration types %qT and %qT" -msgstr "aritmetik mellan olika uppräkningstyper %qT och %qT bör undvikas" +msgstr "aritmetik mellan olika uppräkningstyper %qT och %qT" #: cp/typeck.cc:5067 #, gcc-internal-format @@ -65235,16 +65220,14 @@ msgid "arithmetic between different enumeration types %qT and %qT is deprecated" msgstr "aritmetik mellan olika uppräkningstyper %qT och %qT bör undvikas" #: cp/typeck.cc:5104 -#, fuzzy, gcc-internal-format -#| msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated" +#, gcc-internal-format msgid "comparison of enumeration type %qT with floating-point type %qT" -msgstr "jämförelse av uppräkningstypen %qT med flyttalstypen %qT är föråldrad" +msgstr "jämförelse av uppräkningstypen %qT med flyttalstypen %qT" #: cp/typeck.cc:5107 -#, fuzzy, gcc-internal-format -#| msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated" +#, gcc-internal-format msgid "comparison of floating-point type %qT with enumeration type %qT" -msgstr "jämförelse av flyttalstypen %qT med uppräkningstypen %qT bör undvikas" +msgstr "jämförelse av flyttalstypen %qT med uppräkningstypen %qT" #: cp/typeck.cc:5110 #, gcc-internal-format @@ -65257,16 +65240,14 @@ msgid "comparison of floating-point type %qT with enumeration type %qT is deprec msgstr "jämförelse av flyttalstypen %qT med uppräkningstypen %qT bör undvikas" #: cp/typeck.cc:5123 -#, fuzzy, gcc-internal-format -#| msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated" +#, gcc-internal-format msgid "arithmetic between enumeration type %qT and floating-point type %qT" -msgstr "aritmetik mellan uppräkningstypen %qT och flyttalstypen %qT är föråldrad" +msgstr "aritmetik mellan uppräkningstypen %qT och flyttalstypen %qT" #: cp/typeck.cc:5126 -#, fuzzy, gcc-internal-format -#| msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated" +#, gcc-internal-format msgid "arithmetic between floating-point type %qT and enumeration type %qT" -msgstr "aritmetik mellan flyttalstypen %qT och uppräkningstypen %qT är föråldrad" +msgstr "aritmetik mellan flyttalstypen %qT och uppräkningstypen %qT" #: cp/typeck.cc:5129 #, gcc-internal-format @@ -65373,10 +65354,9 @@ msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non msgstr "ISO C++ förbjuder att ta adressen till en okvalificerad eller parentetiserad icke-statisk medlemsfunktion för att skapa en pekare till en medlemsfunktion. Säg %<&%T::%D%>" #: cp/typeck.cc:7154 -#, fuzzy, gcc-internal-format -#| msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function. Say %<&%T::%D%>" +#, gcc-internal-format msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function" -msgstr "ISO C++ förbjuder att ta adressen till en okvalificerad eller parentetiserad icke-statisk medlemsfunktion för att skapa en pekare till en medlemsfunktion. Säg %<&%T::%D%>" +msgstr "ISO C++ förbjuder att ta adressen till en okvalificerad eller parentetiserad icke-statisk medlemsfunktion för att skapa en pekare till en explicit objektmedlemsfunktion" #: cp/typeck.cc:7160 #, gcc-internal-format @@ -65384,16 +65364,14 @@ msgid "ISO C++ forbids taking the address of a bound member function to form a p msgstr "ISO C++ förbjuder att ta adressen till en bunden medlemsfunktion för att skapa en pekare till medlemsfunktion. Säg %<&%T::%D%>" #: cp/typeck.cc:7166 -#, fuzzy, gcc-internal-format -#| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function. Say %<&%T::%D%>" +#, gcc-internal-format msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function" -msgstr "ISO C++ förbjuder att ta adressen till en bunden medlemsfunktion för att skapa en pekare till medlemsfunktion. Säg %<&%T::%D%>" +msgstr "ISO C++ förbjuder att ta adressen till en bunden medlemsfunktion för att skapa en pekare på en explicit objektmedlemsfunktion" #: cp/typeck.cc:7171 -#, fuzzy, gcc-internal-format -#| msgid "(a pointer to member can only be formed with %<&%E%>)" +#, gcc-internal-format msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>" -msgstr "(en pekare på medlem kan bara skapas med %<&%E%>)" +msgstr "en pekare på en explicit objektmedlemsfunktion kan bara skapas med %<&%T::%D%>" #. Make this a permerror because we used to accept it. #: cp/typeck.cc:7204 @@ -65733,10 +65711,9 @@ msgid "returning reference to temporary" msgstr "returnerar referens till en temporär" #: cp/typeck.cc:10633 -#, fuzzy, gcc-internal-format -#| msgid "returning reference to temporary" +#, gcc-internal-format msgid "returning pointer to temporary" -msgstr "returnerar referens till en temporär" +msgstr "returnerar pekare på en temporär" #: cp/typeck.cc:10636 #, gcc-internal-format @@ -65833,10 +65810,9 @@ msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> ( msgstr "%<operator new%> får inte returnera NULL om den inte är deklarerad %<throw()%> (eller %<-fcheck-new%> är aktivt)" #: cp/typeck.cc:11299 -#, fuzzy, gcc-internal-format -#| msgid "invalid covariant return type for %q#D" +#, gcc-internal-format msgid "not eliding copy on return from %qD" -msgstr "ogiltig kovariant returtyp för %q#D" +msgstr "utelämnar inte kopiering vid retur från %qD" #: cp/typeck.cc:11311 #, gcc-internal-format @@ -66347,16 +66323,14 @@ msgid "cast from %qs to %qs will produce zero result" msgstr "typkonvertering från %qs till %qs kommer producera ett nollresultat" #: d/d-convert.cc:748 -#, fuzzy, gcc-internal-format -#| msgid "cannot convert %qE from type %qT to type %qT" +#, gcc-internal-format msgid "cannot convert parameter %qs from type %qs to type %qs in assignment" -msgstr "kan inte konvertera %qE från typ %qT till typ %qT" +msgstr "det går inte att konvertera parametern %qs från typen %qs till typen %qs i en tilldelning" #: d/d-convert.cc:754 -#, fuzzy, gcc-internal-format -#| msgid "cannot convert %qH to %qI in argument passing" +#, gcc-internal-format msgid "cannot convert parameter %qs from type %qs to type %qs in argument passing" -msgstr "det går inte att konvertera %qH till %qI när argument skickas" +msgstr "det går inte att konvertera parametern %qs från typen %qs till typen %qs när argument skickas" #: d/d-convert.cc:759 #, gcc-internal-format @@ -66384,28 +66358,24 @@ msgid "bad argument for %<-fversion%>: %qs" msgstr "felaktigt argument till %<-fversion%>: %qs" #: d/d-lang.cc:968 -#, fuzzy, gcc-internal-format -#| msgid "error: unable to open '%s' for writing: %s\n" +#, gcc-internal-format msgid "unable to open %s for writing: %m" -msgstr "fel: kan inte öppna ”%s” för skrivning: %s\n" +msgstr "kan inte öppna %s för skrivning: %m" #: d/d-lang.cc:975 -#, fuzzy, gcc-internal-format -#| msgid "opening output file %s: %m" +#, gcc-internal-format msgid "writing output file %s: %m" -msgstr "vid öppnandet av utdatafil %s: %m" +msgstr "när utdatafil %s skrevs: %m" #: d/d-lang.cc:995 -#, fuzzy, gcc-internal-format -#| msgid "error: unable to open '%s' for writing: %s\n" +#, gcc-internal-format msgid "unable to open %s for reading: %m" -msgstr "fel: kan inte öppna ”%s” för skrivning: %s\n" +msgstr "kan inte öppna %s för skrivning: %m" #: d/d-lang.cc:1020 -#, fuzzy, gcc-internal-format -#| msgid "opening json file %s: %m" +#, gcc-internal-format msgid "reading ddoc file %s: %m" -msgstr "när json-filen %s öppnades: %m" +msgstr "när ddoc-filen %s skrevs: %m" #: d/d-lang.cc:1079 #, gcc-internal-format @@ -66484,16 +66454,14 @@ msgid "cannot handle comparison of type %<%s == %s%>" msgstr "kan inte hantera jämförelse av typen %<%s == %s%>" #: d/expr.cc:717 -#, fuzzy, gcc-internal-format -#| msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>" +#, gcc-internal-format msgid "array concatenation of expression %qs requires the GC and cannot be used with %<-fno-druntime%>" -msgstr "uttrycket %qs kräver %<object.TypeInfo%> och kan inte användas med %<-fno-rtti%>" +msgstr "vektorkonkatenering av uttrycket %qs kräver GC:n och kan inte användas med %<-fno-druntime%>" #: d/expr.cc:811 -#, fuzzy, gcc-internal-format -#| msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>" +#, gcc-internal-format msgid "appending to array in %qs requires the GC and cannot be used with %<-fno-druntime%>" -msgstr "uttrycket %qs kräver %<object.TypeInfo%> och kan inte användas med %<-fno-rtti%>" +msgstr "tillägg till en vektor i %qs kräver GC:n och kan inte användas med %<-fno-druntime%>" #. Static arrays have already been handled by the front-end. #: d/expr.cc:1285 @@ -66578,8 +66546,7 @@ msgstr "avsaknad av överensstämmelse i anrop till den inbyggda funktionen %qD" #. It's a D language intrinsic with no library implementation. #: d/intrinsics.cc:1479 -#, fuzzy, gcc-internal-format -#| msgid "built-in function %qE must be directly called" +#, gcc-internal-format msgid "intrinsic function %qE must be directly called" msgstr "inbyggd funktion %qE måste anropas direkt" @@ -67144,10 +67111,9 @@ msgid "Array constructor value at %L shall not be unlimited polymorphic [F2008: msgstr "Vektorkonstruerarvärde vid %L får inte vara obegränsat polymorft [F2008: C4106]" #: fortran/array.cc:2215 -#, fuzzy, gcc-internal-format -#| msgid "Different CHARACTER lengths (%ld/%ld) in array constructor at %L" +#, gcc-internal-format msgid "Different CHARACTER lengths (%wd/%wd) in array constructor at %L" -msgstr "Olika CHARACTER-längder (%ld/%ld) i vektorkonstruerare vid %L" +msgstr "Olika CHARACTER-längder (%wd/%wd) i vektorkonstruerare vid %L" #: fortran/array.cc:2333 #, gcc-internal-format @@ -67371,10 +67337,9 @@ msgid "Unequal character lengths (%ld/%ld) in %s at %L" msgstr "Olika teckenlängder (%ld/%ld) i %s vid %L" #: fortran/check.cc:1269 -#, fuzzy, gcc-internal-format -#| msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)" +#, gcc-internal-format msgid "Size of %qs argument of %qs intrinsic at %L too small (%wd/%ld)" -msgstr "Storlek på %qs-argumentet till inbyggd %qs vid %L är för liten (%i/%i)" +msgstr "Storlek på %qs-argumentet till inbyggd %qs vid %L är för liten (%wd/%ld)" #: fortran/check.cc:1332 #, gcc-internal-format, gfc-internal-format @@ -68183,10 +68148,8 @@ msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s" msgstr "%<MOLD%>-argumentet till inbyggd %<TRANSFER%> vid %L får inte vara %s" #: fortran/check.cc:6300 -#, fuzzy -#| msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld" msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd" -msgstr "Inbyggd TRANSFER vid %L har delvis odefinierat resultat: källstorlek %ld < resultatstorlek %ld" +msgstr "Inbyggd TRANSFER vid %L har delvis odefinierat resultat: källstorlek %zd < resultatstorlek %zd" #: fortran/check.cc:6424 #, gcc-internal-format @@ -68199,16 +68162,14 @@ msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape." msgstr "%qs- och %qs-argumenten till inbyggd %qs vid %L måste ha identiska former." #: fortran/check.cc:6573 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind" +#, gcc-internal-format, gfc-internal-format msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind" -msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L har icke-standardsort" +msgstr "Argumentet VALUES till DATE_AND_TIME vid %L har icke-standardsort" #: fortran/check.cc:6585 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Argument of ATANH at %L must be inside the range -1 to 1" +#, gcc-internal-format, gfc-internal-format msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four" -msgstr "Argument till ATANH vid %L måste vara i intervallet -1 till 1" +msgstr "Argumentet VALUES till DATE_AND_TIME vid %L måste ha ett decimalt exponentinterval på åtminstone fyra" #: fortran/check.cc:6724 fortran/check.cc:6756 #, gcc-internal-format @@ -68236,10 +68197,9 @@ msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind" msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L har icke-standardsort" #: fortran/check.cc:6843 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind" +#, gcc-internal-format, gfc-internal-format msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer" -msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L har icke-standardsort" +msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L med en sort som är mindre än standardheltal" #: fortran/check.cc:6864 #, gcc-internal-format, gfc-internal-format @@ -68252,10 +68212,9 @@ msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind" msgstr "Argumentet COUNT_RATE till SYSTEM_CLOCK vid %L har en icke-standardsort" #: fortran/check.cc:6881 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind" +#, gcc-internal-format, gfc-internal-format msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer" -msgstr "Argumentet COUNT_RATE till SYSTEM_CLOCK vid %L har en icke-standardsort" +msgstr "Argumentet COUNT_RATE till SYSTEM_CLOCK vid %L har en sort som är mindre än standardheltal" #: fortran/check.cc:6901 #, gcc-internal-format, gfc-internal-format @@ -68263,16 +68222,14 @@ msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind" msgstr "Argumentet COUNT_MAX till SYSTEM_CLOCK vid %L har en icke-standardsort" #: fortran/check.cc:6911 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind" +#, gcc-internal-format, gfc-internal-format msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer" -msgstr "Argumentet COUNT_MAX till SYSTEM_CLOCK vid %L har en icke-standardsort" +msgstr "Argumentet COUNT_MAX till SYSTEM_CLOCK vid %L har en sort som är mindre än standardheltal" #: fortran/check.cc:6926 fortran/check.cc:6933 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind" +#, gcc-internal-format, gfc-internal-format msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters" -msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L har icke-standardsort" +msgstr "heltalsargumentet till SYSTEM_CLOCK vid %L med en annan parametersort" #: fortran/check.cc:7147 #, gcc-internal-format @@ -68322,16 +68279,14 @@ msgid "non-constant array in DATA statement %L" msgstr "ickekonstant vektor i DATA-sats %L" #: fortran/data.cc:78 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d" +#, gcc-internal-format, gfc-internal-format msgid "Subscript at %L below array lower bound (%ld < %ld) in dimension %d" -msgstr "Vektorreferens vid %L är utanför gränsen (%ld < %ld) i dimension %d" +msgstr "Indexet vid %L är under vektorns lägre gräns (%ld < %ld) i dimension %d" #: fortran/data.cc:89 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d" +#, gcc-internal-format, gfc-internal-format msgid "Subscript at %L above array upper bound (%ld > %ld) in dimension %d" -msgstr "Undre vektorreferens vid %L är utanför gränsen (%ld > %ld) i dimension %d" +msgstr "Indexet vid %L är över vektorns övre gräns (%ld > %ld) i dimension %d" #: fortran/data.cc:172 #, gcc-internal-format, gfc-internal-format @@ -68344,10 +68299,9 @@ msgid "Unused initialization string at %L because variable has zero length" msgstr "Oanvänd initieringssträng vid %L för att variabeln har nollängd" #: fortran/data.cc:211 -#, fuzzy, gcc-internal-format -#| msgid "Initialization string at %L was truncated to fit the variable (%ld/%ld)" +#, gcc-internal-format msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)" -msgstr "Initieringssträng vid %L höggs av för att stämma med variabeln (%ld/%ld)" +msgstr "Initieringssträng vid %L höggs av för att stämma med variabeln (%wd/%wd)" #: fortran/data.cc:220 fortran/resolve.cc:5287 #, gcc-internal-format, gfc-internal-format @@ -69446,10 +69400,9 @@ msgid "Duplicate symbol %qs in formal argument list at %C" msgstr "Dubblerad symbol %qs i formell argumentlista vid %C" #: fortran/decl.cc:6805 -#, fuzzy, gcc-internal-format -#| msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C" +#, gcc-internal-format msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C" -msgstr "Formella argumentnamnen till MODULE PROCEDURE stämmer inte (%s/%s) vid %C" +msgstr "Formella argumentet %qs till MODULE PROCEDURE står i konflikt med alternativ retur vid %C" #: fortran/decl.cc:6809 #, gcc-internal-format @@ -71057,10 +71010,9 @@ msgid "%qs at %L associated to expression cannot be used in a variable definitio msgstr "%qs vid %L som är associerad med uttryck kan inte användas i ett variabeldefinitionssammanhang (%s)" #: fortran/expr.cc:6507 -#, fuzzy, gcc-internal-format -#| msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)" +#, gcc-internal-format msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)" -msgstr "%qs vid %L som är associerad med uttryck kan inte användas i ett variabeldefinitionssammanhang (%s)" +msgstr "%qs vid %L som är associerad med ett pekarfunktionsmål används i ett variabeldefinitionssammanhang (%s)" #: fortran/expr.cc:6526 #, gcc-internal-format @@ -71585,10 +71537,9 @@ msgid "Actual argument at %L to assumed-type dummy has type parameters or is of msgstr "Aktuellt argument vid %L till attrapp med antagen typ har typparametrar eller är av en härledd typ med typgräns eller FINAL-procedurer" #: fortran/interface.cc:3355 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs" +#, gcc-internal-format, gfc-internal-format msgid "Unlimited polymorphic actual argument at %L is not matched with either an unlimited polymorphic or assumed type dummy argument" -msgstr "Co-indexerat polymorft aktuellt argument vid %L skickas ett polymorft attrappargument %qs" +msgstr "Obegränsat polymorft aktuellt argument vid %L stämmer varken med en obegränsad polymorf eller ett attrappargument med antagen typ" #: fortran/interface.cc:3379 #, gcc-internal-format @@ -73711,10 +73662,9 @@ msgid "Symbol %qs in namelist %qs at %C must be declared before the namelist is msgstr "Symbolen %qs i namnlistan %qs vid %C måste deklareras före namnlistan deklareras." #: fortran/match.cc:5652 -#, fuzzy, gcc-internal-format -#| msgid "Symbol %qs at %L conflicts with the symbol at %L" +#, gcc-internal-format msgid "Derived type %qs at %L conflicts with namelist object %qs at %C" -msgstr "Symbolen %qs vid %L står i konflikt med symbolen vid %L" +msgstr "Den härledda typen %qs vid %L står i konflikt med namnlisteobjektet %qs vid %C" #: fortran/match.cc:5672 #, gcc-internal-format @@ -74369,10 +74319,9 @@ msgid "Duplicate %s modifier at %L in USES_ALLOCATORS clause" msgstr "Dubblerad %s-modifierare vid %L i en USES_ALLOCATORS-klausul" #: fortran/openmp.cc:1779 -#, fuzzy, gcc-internal-format -#| msgid "expected %<(%> at %C" +#, gcc-internal-format msgid "Unexpected %<(%> at %C" -msgstr "%<(%> förväntades vid %C" +msgstr "Oväntat %<(%> vid %C" #: fortran/openmp.cc:1826 #, gcc-internal-format @@ -74421,16 +74370,14 @@ msgid "COLLAPSE clause argument not constant positive integer at %C" msgstr "COLLAPSE-klausulargument är inte ett konstant positivt heltal vid %C" #: fortran/openmp.cc:2236 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE or DEFAULT at %C" +#, gcc-internal-format, gfc-internal-format msgid "Expected ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, PRESENT, NONE or DEFAULT at %C" -msgstr "ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, NONE eller DEFAULT förväntades vid %C" +msgstr "ALLOC, TO, FROM, TOFROM, FIRSTPRIVATE, PRESENT, NONE eller DEFAULT förväntades vid %C" #: fortran/openmp.cc:2258 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected SCALAR, AGGREGATE, ALLOCATABLE or POINTER at %C" +#, gcc-internal-format, gfc-internal-format msgid "Expected SCALAR, AGGREGATE, ALLOCATABLE, POINTER or ALL at %C" -msgstr "SCALAR, AGGREGATE, ALLOCATABLE eller POINTER förväntades vid %C" +msgstr "SCALAR, AGGREGATE, ALLOCATABLE, POINTER eller ALL förväntades vid %C" #: fortran/openmp.cc:2291 #, gcc-internal-format, gfc-internal-format @@ -74523,10 +74470,9 @@ msgid "Expected SEQ_CST, ACQUIRE or RELAXED at %C" msgstr "SEQ_CST, ACQUIRE eller RELAXED förväntades vid %C" #: fortran/openmp.cc:2816 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "WAIT clause at %L requires a scalar INTEGER expression" +#, gcc-internal-format, gfc-internal-format msgid "INDIRECT clause at %C requires a constant logical expression" -msgstr "WAIT-klausul vid %L kräver ett skalärt INTEGER-uttryck" +msgstr "INDIRECT-klausul vid %C kräver ett konstant logiskt uttryck" #: fortran/openmp.cc:3003 #, gcc-internal-format @@ -74544,10 +74490,9 @@ msgid "too many %<close%> modifiers at %L" msgstr "för många %<close%>-modifierare vid %L" #: fortran/openmp.cc:3125 -#, fuzzy, gcc-internal-format -#| msgid "too many %<close%> modifiers at %L" +#, gcc-internal-format msgid "too many %<present%> modifiers at %L" -msgstr "för många %<close%>-modifierare vid %L" +msgstr "för många %<present%>-modifierare vid %L" #: fortran/openmp.cc:3316 #, gcc-internal-format @@ -74655,22 +74600,19 @@ msgid "!$ACC ROUTINE with GANG, WORKER, or VECTOR clause is not permitted in PUR msgstr "!$ACC ROUTINE med GANG-, WORKER- eller VECTOR-klausul är inte tillåten i PURE-procedur vid %C" #: fortran/openmp.cc:4568 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected COMPILATION or EXECUTION in AT clause at %C" +#, gcc-internal-format, gfc-internal-format msgid "Expected ALIGN or ALLOCATOR clause at %C" -msgstr "COMPILATION eller EXECUTION förväntades i AT-klausul vid %C" +msgstr "ALIGN- eller ALLOCATOR-klausul förväntades vid %C" #: fortran/openmp.cc:4576 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Sorry, the event component of derived type at %L is not yet supported" +#, gcc-internal-format, gfc-internal-format msgid "Sorry, structure-element list item at %L in ALLOCATE directive is not yet supported" -msgstr "Ledsen, händelsekomponenten hos härledd typ vid %L stödjs inte ännu" +msgstr "Ledsen, postelementlistelementet vid %L i direktivet ALLOCATE stödjs inte ännu" #: fortran/openmp.cc:4579 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected expression in %s statement at %C" +#, gcc-internal-format, gfc-internal-format msgid "Unexpected expression as list item at %L in ALLOCATE directive" -msgstr "Förväntade uttryck i %s-sats vid %C" +msgstr "Oväntat uttryck som listelement vid %L i direktivet ALLOCATE" #: fortran/openmp.cc:4650 #, gcc-internal-format, gfc-internal-format @@ -74833,10 +74775,9 @@ msgid "COMMON at %L set in previous OMP DECLARE TARGET directive to a different msgstr "COMMON vid %L satt i föregående OMP DECLARE TARGET-direktiv till en annan DEVICE_TYPE" #: fortran/openmp.cc:5611 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "OMP DECLARE TARGET directive at %L with only DEVICE_TYPE clause is ignored" +#, gcc-internal-format, gfc-internal-format msgid "OMP DECLARE TARGET directive at %L with only DEVICE_TYPE or INDIRECT clauses is ignored" -msgstr "Direktivet OMP DECLARE TARGET vid %L med endast DEVICE_TYPE-klausul ignoreras" +msgstr "Direktivet OMP DECLARE TARGET vid %L med endast DEVICE_TYPE- eller INDIRECTklausuler ignoreras" #: fortran/openmp.cc:5622 #, gcc-internal-format, gfc-internal-format @@ -74845,10 +74786,9 @@ msgstr "Syntaxfel i !$OMP DECLARE TARGET-lista vid %C" #. FIXME: constant integer expressions. #: fortran/openmp.cc:5661 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected integer expression at %C" +#, gcc-internal-format, gfc-internal-format msgid "Expected trait-property-extension at %C" -msgstr "Heltalsuttryck förväntades vid %C" +msgstr "Trait-property-utvidgning förväntades vid %C" #: fortran/openmp.cc:5676 fortran/openmp.cc:5773 fortran/openmp.cc:5904 #: fortran/openmp.cc:6054 fortran/openmp.cc:6082 @@ -74862,10 +74802,9 @@ msgid "expected trait selector name at %C" msgstr "trait-väljarnamn förväntades vid %C" #: fortran/openmp.cc:5717 -#, fuzzy, gcc-internal-format -#| msgid "selector %qs not allowed for context selector set %qs at %C" +#, gcc-internal-format msgid "unknown selector %qs for context selector set %qs at %C" -msgstr "selektorn %qs är inte tillåten för kontextselektormängd %qs vid %C" +msgstr "okänd selektor %qs för kontextselektormängden %qs vid %C" #: fortran/openmp.cc:5735 #, gcc-internal-format @@ -74873,10 +74812,9 @@ msgid "selector %qs does not accept any properties at %C" msgstr "selektorn %qs tar inte några egenskaper vid %C" #: fortran/openmp.cc:5744 -#, fuzzy, gcc-internal-format -#| msgid "The %s directive cannot be specified within a %s region at %L" +#, gcc-internal-format msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set at %C" -msgstr "Direktivet %s kan inte anges inuti en %s-region vid %L" +msgstr "%<score%> kan inte anges bland egenskaper i %s trait-selector-set vid %C" #: fortran/openmp.cc:5751 fortran/openmp.cc:5914 fortran/openmp.cc:6006 #: fortran/openmp.cc:6073 @@ -74885,16 +74823,14 @@ msgid "expected %<(%> at %C" msgstr "%<(%> förväntades vid %C" #: fortran/openmp.cc:5759 -#, fuzzy, gcc-internal-format -#| msgid "score argument must be constant integer expression at %C" +#, gcc-internal-format msgid "%<score%> argument must be constant integer expression at %C" -msgstr "värdesargument måste vara ett konstant heltalsuttryck vid %C" +msgstr "argument till %<score%> måste vara ett konstant heltalsuttryck vid %C" #: fortran/openmp.cc:5767 -#, fuzzy, gcc-internal-format -#| msgid "score argument must be non-negative at %C" +#, gcc-internal-format msgid "%<score%> argument must be non-negative at %C" -msgstr "värdesargumentet måste vara ickenegativt vid %C" +msgstr "argumentet till %<score%> måste vara ickenegativt vid %C" #: fortran/openmp.cc:5779 #, gcc-internal-format, gfc-internal-format @@ -74917,22 +74853,19 @@ msgid "expected expression at %C" msgstr "uttryck förväntades vid %C" #: fortran/openmp.cc:5853 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "property must be constant integer or logical expression at %C" +#, gcc-internal-format, gfc-internal-format msgid "property must be a constant logical expression at %C" -msgstr "egenskapen måste vara ett konstant heltals- eller logiskt uttryck vid %C" +msgstr "egenskapen måste vara ett konstant logiskt uttryck vid %C" #: fortran/openmp.cc:5856 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "property must be constant integer expression" +#, gcc-internal-format, gfc-internal-format msgid "property must be a constant integer expression at %C" -msgstr "egenskapen måste vara ett konstant heltalsuttryck" +msgstr "egenskapen måste vara ett konstant heltalsuttryck vid %C" #: fortran/openmp.cc:5868 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "property must be constant integer or logical expression at %C" +#, gcc-internal-format, gfc-internal-format msgid "property must be a conforming device number at %C" -msgstr "egenskapen måste vara ett konstant heltals- eller logiskt uttryck vid %C" +msgstr "egenskapen måste vara ett konformt enhetsnummer vid %C" #: fortran/openmp.cc:5882 #, gcc-internal-format, gfc-internal-format @@ -74940,10 +74873,9 @@ msgid "expected simd clause at %C" msgstr "simd-klausul förväntades vid %C" #: fortran/openmp.cc:5955 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "expected trait selector name at %C" +#, gcc-internal-format, gfc-internal-format msgid "expected context selector set name at %C" -msgstr "trait-väljarnamn förväntades vid %C" +msgstr "kontextväljarmängdsnamn förväntades vid %C" #: fortran/openmp.cc:5962 #, gcc-internal-format @@ -75041,10 +74973,9 @@ msgid "!$OMP REQUIRES at %C must appear in the specification part of a program u msgstr "!$OMP REQUIRES vid %C måste förekomma i specifikationsdelen av en programenhet" #: fortran/openmp.cc:6456 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected SEQ_CST, ACQ_REL or RELAXED for ATOMIC_DEFAULT_MEM_ORDER clause at %C" +#, gcc-internal-format, gfc-internal-format msgid "Expected ACQ_REL, ACQUIRE, RELAXED, RELEASE or SEQ_CST for ATOMIC_DEFAULT_MEM_ORDER clause at %C" -msgstr "SEQ_CST, ACQ_REL eller RELAXED förväntades för ATOMIC_DEFAULT_MEM_ORDER-klausulen vid %C" +msgstr "ACQ_REL, ACQUIRE, RELAXED, RELEASE eller SEQ_CST förväntades till klausulen ATOMIC_DEFAULT_MEM_ORDER vid %C" #: fortran/openmp.cc:6472 #, gcc-internal-format, gfc-internal-format @@ -75097,16 +75028,14 @@ msgid "!$OMP ATOMIC at %L with %s clause requires %s clause" msgstr "!$OMP ATOMIC vid %L med %s-klausul kräver %s-klausul" #: fortran/openmp.cc:6907 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "!$OMP ATOMIC WRITE at %L incompatible with ACQUIRE clause" +#, gcc-internal-format, gfc-internal-format msgid "!$OMP ATOMIC WRITE at %L incompatible with ACQUIRES clause implicitly provided by a REQUIRES directive" -msgstr "!$OMP ATOMIC WRITE vid %L är inkompatibel med ACQUIRE-klausul" +msgstr "!$OMP ATOMIC WRITE vid %L är inkompatibel med klausulen ACQUIRES som implicit tillhandahålls av ett direktiv REQUIRES" #: fortran/openmp.cc:6918 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "!$OMP ATOMIC READ at %L incompatible with RELEASE clause" +#, gcc-internal-format, gfc-internal-format msgid "!$OMP ATOMIC READ at %L incompatible with RELEASE clause implicitly provided by a REQUIRES directive" -msgstr "!$OMP ATOMIC READ vid %L är inkompatibel med RELEASE-klausul" +msgstr "!$OMP ATOMIC READ vid %L är inkompatibelt med klausulen RELEASE som implicit tillhandahålls av ett direktiv REQUIRES" #: fortran/openmp.cc:6936 #, gcc-internal-format, gfc-internal-format @@ -75234,10 +75163,9 @@ msgid "Unexpected function-result variable %qs at %L in declarative !$OMP ALLOCA msgstr "Oväntad funktionsresultatvariabel %qs vid %L i deklarativt !$OMP ALLOCATE" #: fortran/openmp.cc:7355 -#, fuzzy, gcc-internal-format -#| msgid "Procedure pointer %qs in %s clause at %L" +#, gcc-internal-format msgid "Procedure pointer %qs not supported with !$OMP ALLOCATE at %L" -msgstr "Procedurpekare %qs i %s-klausul vid %L" +msgstr "Procedurpekaren %qs stödjs inte med !$OMP ALLOCATE vid %L" #: fortran/openmp.cc:7361 #, gcc-internal-format @@ -75250,10 +75178,9 @@ msgid "Argument %qs at %L to declarative !$OMP ALLOCATE shall be in the same sco msgstr "Argumentet %qs vid %L till deklarativt !$OMP ALLOCATE skall ligga i samma räckvidd som variabeldeklarationen" #: fortran/openmp.cc:7375 -#, fuzzy, gcc-internal-format -#| msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE" +#, gcc-internal-format msgid "Unexpected dummy argument %qs as argument at %L to declarative !$OMP ALLOCATE" -msgstr "Skickat objekt-attrappargument till %qs vid %L får inte vara ALLOCATABLE" +msgstr "Oväntat attrappargument %qs som argument vid %L till deklarativt !$OMP ALLOCATE" #: fortran/openmp.cc:7381 #, gcc-internal-format @@ -75291,10 +75218,9 @@ msgid "Unexpected pointer variable %qs at %L in declarative !$OMP ALLOCATE direc msgstr "Oväntad pekarvariabel %qs vid %L i deklarativt !$OMP ALLOCATE-direktiv" #: fortran/openmp.cc:7441 fortran/openmp.cc:7996 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "ALIGN modifier requires at %L a scalar positive constant integer alignment expression that is a power of two" +#, gcc-internal-format, gfc-internal-format msgid "ALIGN requires a scalar positive constant integer alignment expression at %L that is a power of two" -msgstr "En ALIGN-modifierare kräver vid %L ett skalärt positivt konstant heltals justeringsuttryck som är en potens av två" +msgstr "ALIGN kräver ett skalärt positivt konstant heltalsjusteringsuttryck vid %L som är en potens av två" #: fortran/openmp.cc:7456 #, gcc-internal-format @@ -75344,10 +75270,9 @@ msgid "IF clause modifier %s at %L not appropriate for the current OpenMP constr msgstr "IF-klausulmodifierare %s vid %L passar inte för den aktuella OpenMP-konstruktionen" #: fortran/openmp.cc:7687 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "IF clause at %L requires a scalar LOGICAL expression" +#, gcc-internal-format, gfc-internal-format msgid "SELF clause at %L requires a scalar LOGICAL expression" -msgstr "IF-klausul vid %L kräver ett skalärt LOGICAL-uttryck" +msgstr "SELF-klausulen vid %L kräver ett skalärt LOGICAL-uttryck" #: fortran/openmp.cc:7696 #, gcc-internal-format, gfc-internal-format @@ -75433,10 +75358,9 @@ msgid "Symbol %qs present on both data and map clauses at %L" msgstr "Symbolen %qs finns i både data- och avbildningsklausuler vid %L" #: fortran/openmp.cc:8021 -#, fuzzy, gcc-internal-format -#| msgid "%qs appears more than once in %<allocate%> clauses at %L" +#, gcc-internal-format msgid "%qs appears more than once in %<allocate%> at %L" -msgstr "%qs förekommer mer än en gång i %<allocate%>-klausuler vid %L" +msgstr "%qs förekommer mer än en gång i %<allocate%> vid %L" #: fortran/openmp.cc:8063 #, gcc-internal-format @@ -75444,16 +75368,14 @@ msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privati msgstr "%qs angivet i en %<allocate%>-klausul vid %L men inte i en explicit privatiseringsklausul" #: fortran/openmp.cc:8091 -#, fuzzy, gcc-internal-format -#| msgid "Unexpected coarray designator at %C" +#, gcc-internal-format msgid "Unexpected coarray %qs in %<allocate%> at %L" -msgstr "Oväntad co-vektorbeteckning vid %C" +msgstr "Oväntad co-vektor %qs i %<allocate%> vid %L" #: fortran/openmp.cc:8105 -#, fuzzy, gcc-internal-format -#| msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause" +#, gcc-internal-format msgid "%qs specified in %<allocate%> at %L but not in the associated ALLOCATE statement" -msgstr "%qs angivet i en %<allocate%>-klausul vid %L men inte i en explicit privatiseringsklausul" +msgstr "%qs angivet i en %<allocate%> vid %L men inte deN motsvarande ALLOCATE-satsen" #: fortran/openmp.cc:8139 #, gcc-internal-format @@ -75663,10 +75585,9 @@ msgid "Memspace %qs at %L in USES_ALLOCATORS must be a predefined memory space" msgstr "Memspace %qs vid %L i USES_ALLOCATORS måste vara ett fördefinierat minnesutrymme" #: fortran/openmp.cc:8717 -#, fuzzy, gcc-internal-format -#| msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)" +#, gcc-internal-format msgid "Allocator %qs at %L in USES_ALLOCATORS must be a scalar integer of kind %<omp_allocator_handle_kind%>" -msgstr "%qs vid %L skall vara en skalär av typen integer(kind=omp_event_handle_kind)" +msgstr "Allokeraren %qs vid %L i USES_ALLOCATORS måste vara ett skalärt heltal av ssorten %<omp_allocator_handle_kind%>" #: fortran/openmp.cc:8725 #, gcc-internal-format @@ -75955,8 +75876,7 @@ msgid "unexpected !$OMP ATOMIC expression at %L" msgstr "oväntat !$OMP ATOMIC-uttryck vid %L" #: fortran/openmp.cc:9948 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured-block-sequences" +#, gcc-internal-format, gfc-internal-format msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences" msgstr "Med INSCAN vid %L, slingkropp med !$OMP SCAN förväntades mellan två strukturerade blocksekvenser" @@ -76021,10 +75941,9 @@ msgid "%s iteration variable used in more than one loop at %L" msgstr "%s-iterationsvariabel använd i mer än en slinga vid %L" #: fortran/openmp.cc:10874 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "iteration variable %qE should not be reduction" +#, gcc-internal-format, gfc-internal-format msgid "%s iteration variable at %L is bound in intervening code" -msgstr "iterationsvariabel %qE får inte vara reduction" +msgstr "iterationsvariabeln %s vid %L binds i mellanliggande kod" #: fortran/openmp.cc:10883 #, gcc-internal-format, gfc-internal-format @@ -76032,10 +75951,9 @@ msgid "%s loop start expression not in canonical form at %L" msgstr "%s-slingans startuttryck är inte i kanonisk form vid %L" #: fortran/openmp.cc:10890 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%s loop start expression not in canonical form at %L" +#, gcc-internal-format, gfc-internal-format msgid "%s loop start expression at %L uses variable bound in intervening code" -msgstr "%s-slingans startuttryck är inte i kanonisk form vid %L" +msgstr "%s-slingans startuttryck vid %L använder en variabel bunden i mellanliggande kod" #: fortran/openmp.cc:10899 #, gcc-internal-format, gfc-internal-format @@ -76064,16 +75982,14 @@ msgstr "%s-slingans ökningsuttryck vid %L använder variabel begränsning i mel #. Parse error, can't recover from this. #: fortran/openmp.cc:10944 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "not enough DO loops for collapsed %s at %L" +#, gcc-internal-format, gfc-internal-format msgid "not enough DO loops for collapsed %s (level %d) at %L" -msgstr "för få DO-slingor för kollapsad %s vid %L" +msgstr "för få DO-slingor för kollapsad %s (nivå %d) vid %L" #: fortran/openmp.cc:10956 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%s !$ACC LOOP loops not perfectly nested at %L" +#, gcc-internal-format, gfc-internal-format msgid "%s inner loops must be perfectly nested with ORDERED clause at %L" -msgstr "%s !$ACC LOOP-slingor är inte perfekt nästade vid %L" +msgstr "%s inre slingor måste vara perfekt nästade med klausulen ORDERED vid %L" #: fortran/openmp.cc:10963 #, gcc-internal-format, gfc-internal-format @@ -76341,10 +76257,9 @@ msgid "%qs directive at %L associated with an ALLOCATE stmt must be preceded by msgstr "direktivet %qs vid %L associerat med en ALLOCATE-sats måste föregås av en körbar sats eller OpenMP-konstruktion; observera att variablerna i listan har alla attributet allokerbar eller pekare" #: fortran/parse.cc:1023 fortran/parse.cc:1325 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "OpenACC directives other than ROUTINE may not appear in PURE procedures at %C" +#, gcc-internal-format, gfc-internal-format msgid "OpenMP directive at %C is not pure and thus may not appear in a PURE procedure" -msgstr "Andra OpenACC-direktiv än ROUTINE får inte förekomma i PURE-procedurer vid %C" +msgstr "OpenMP-direktivet vid %C är inte rent och får därför inte förekomma i en PURE-procedurer" #: fortran/parse.cc:1296 #, gcc-internal-format, gfc-internal-format @@ -76767,16 +76682,14 @@ msgid "%s statements at %L and %L have both no list item but only one may" msgstr "%s-satserna vid %L och %L har saknar båda listelement men bara en får det" #: fortran/parse.cc:5829 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected expression at %C in PARAMETER statement" +#, gcc-internal-format, gfc-internal-format msgid "Unexpected %s at %C; expected ALLOCATE or %s statement" -msgstr "Uttryck förväntades vid %C i PARAMETER-sats" +msgstr "Oväntat %s vid %C; ALLOCATE eller en %s-sats förväntades" #: fortran/parse.cc:5832 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L" +#, gcc-internal-format, gfc-internal-format msgid "Unexpected %s at %C; expected ALLOCATE statement after %s" -msgstr "%<*%> förväntades i co-indexspecifikation i ALLOCATE-sats vid %L" +msgstr "Oväntat %s vid %C; ALLOCATE-sats efter %s förväntades" #: fortran/parse.cc:6120 #, gcc-internal-format, gfc-internal-format @@ -77022,16 +76935,12 @@ msgid "match_string_constant(): Delimiter not found" msgstr "match_string_constant(): Avgränsare finns inte" #: fortran/primary.cc:1193 -#, fuzzy -#| msgid "Substring start index (%ld) at %L below 1" msgid "Substring start index (%td) at %L below 1" -msgstr "Startindex för delsträng (%ld) vid %L under 1" +msgstr "Startindex för delsträng (%td) vid %L under 1" #: fortran/primary.cc:1199 -#, fuzzy -#| msgid "Substring end index (%ld) at %L exceeds string length" msgid "Substring end index (%td) at %L exceeds string length" -msgstr "Slutindex för delsträng (%ld) vid %L överstiger stränglängden" +msgstr "Slutindex för delsträng (%td) vid %L överstiger stränglängden" #: fortran/primary.cc:1284 #, gcc-internal-format, gfc-internal-format @@ -77234,10 +77143,8 @@ msgid "Too many components in structure constructor at %L" msgstr "För många komponenter i postkonstruerare vid %L" #: fortran/primary.cc:3242 -#, fuzzy -#| msgid "CHARACTER expression will be truncated in constructor (%ld/%ld) at %L" msgid "CHARACTER expression will be truncated in constructor (%td/%td) at %L" -msgstr "CHARACTER-uttryck kommer att huggas av i konstruerare (%ld/%ld) vid %L" +msgstr "CHARACTER-uttryck kommer att huggas av i konstruerare (%td/%td) vid %L" #: fortran/primary.cc:3260 #, gcc-internal-format @@ -77557,10 +77464,9 @@ msgid "%qs at %L cannot appear in COMMON [F2008:C5100]" msgstr "%qs vid %L kan inte förekomma i COMMON [F2008:C5100]" #: fortran/resolve.cc:1016 -#, fuzzy, gcc-internal-format -#| msgid "Global entity %qs at %L cannot appear in a COMMON block at %L" +#, gcc-internal-format msgid "Automatic object %qs at %L cannot appear in COMMON at %L" -msgstr "Den globala entiteten %qs vid %L får inte förekomma i ett COMMON-block vid %L" +msgstr "Det automatiska objektet %qs vid %L får inte förekomma i COMMON vid %L" #: fortran/resolve.cc:1028 #, gcc-internal-format @@ -78232,10 +78138,9 @@ msgid "Assumed-rank variable %s at %L shall not have a subobject reference" msgstr "Variabeln %s med antagen ordning vid %L skall inte ha en subobjektreferens" #: fortran/resolve.cc:5909 -#, fuzzy, gcc-internal-format -#| msgid "Bad array reference at %L" +#, gcc-internal-format msgid "Scalar variable %qs has an array reference at %L" -msgstr "Felaktig vektorreferens vid %L" +msgstr "Den skalära variabeln %qs har en vektorreferens vid %L" #: fortran/resolve.cc:6054 #, gcc-internal-format @@ -78858,16 +78763,14 @@ msgid "gfc_resolve_blocks(): Bad block type" msgstr "gfc_resolve_blocks(): Felaktig blocktyp" #: fortran/resolve.cc:11232 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Data transfer element at %L cannot have procedure pointer components" +#, gcc-internal-format, gfc-internal-format msgid "Variable in the ordinary assignment at %L is a procedure pointer component" -msgstr "Dataöverföringselement vid %L får inte ha procedurpekarkomponenter" +msgstr "Variabeln i den ordinära tilldelningen vid %L är en procedurpekarkomponent" #: fortran/resolve.cc:11293 -#, fuzzy, gcc-internal-format -#| msgid "CHARACTER expression will be truncated in assignment (%ld/%ld) at %L" +#, gcc-internal-format msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L" -msgstr "CHARACTER-uttryck kommer att huggas av i tilldelning (%ld/%ld) vid %L" +msgstr "CHARACTER-uttryck kommer att huggas av i tilldelning (%wd/%wd) vid %L" #: fortran/resolve.cc:11325 #, gcc-internal-format, gfc-internal-format @@ -79855,10 +79758,9 @@ msgid "DATA statement at %L has more variables than values" msgstr "DATA-sats vid %L har fler variabler än värden" #: fortran/resolve.cc:17044 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Nonconstant array section at %L in DATA statement" +#, gcc-internal-format, gfc-internal-format msgid "Non-constant character length at %L in DATA statement" -msgstr "Ickekonstant vektorsektion vid %L i DATA-sats" +msgstr "Ickekonstant teckenlängd vid %L i DATA-sats" #: fortran/resolve.cc:17072 #, gcc-internal-format, gfc-internal-format @@ -80417,10 +80319,9 @@ msgid "Result of SCALE overflows its kind at %L" msgstr "Resultat av SCALE spiller över sin sort vid %L" #: fortran/simplify.cc:7634 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%qs argument of %qs intrinsic at %L must be of rank %d" +#, gcc-internal-format, gfc-internal-format msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)" -msgstr "%qs-argumentet till inbyggd %qs vid %L måste ha ordning %d" +msgstr "DIM-argumentet (%d) till inbyggd SIZE vid %L är utanför intervallet (1:%d)" #: fortran/simplify.cc:7759 #, gcc-internal-format @@ -80919,10 +80820,9 @@ msgid "bad expression type during walk (%d)" msgstr "felaktig uttryckstyp under genomlöpning (%d)" #: fortran/trans-common.cc:411 -#, fuzzy, gcc-internal-format -#| msgid "Named COMMON block %qs at %L shall be of the same size as elsewhere (%lu vs %lu bytes)" +#, gcc-internal-format msgid "Named COMMON block %qs at %L shall be of the same size as elsewhere (%wu vs %wu bytes)" -msgstr "Namngivet COMMON-block %qs vid %L skall ha samma storlek som på andra håll (%lu mot %lu byte)" +msgstr "Namngivet COMMON-block %qs vid %L skall ha samma storlek som på andra håll (%wu mot %wu byte)" #: fortran/trans-common.cc:819 #, gcc-internal-format @@ -81031,10 +80931,9 @@ msgid "Sorry, !$OMP allocate for COMMON block variable %qs at %L not supported" msgstr "Ledsen, !$OMP allocate för COMMON-blocksvariabeln %qs vid %L stödjs inte" #: fortran/trans-decl.cc:5231 -#, fuzzy, gcc-internal-format -#| msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length" +#, gcc-internal-format msgid "Sorry, !$OMP allocate for variable %qs at %L with SAVE attribute not yet implemented" -msgstr "Teckenvärd attrappvariabel %qs vid %L med attributet VALUE måste ha konstant längd" +msgstr "Ledsen, !$OMP allokering för variabeln %qs vid %L med attributet SAVE stödjs inte ännu" #: fortran/trans-decl.cc:5437 #, gcc-internal-format @@ -81213,10 +81112,9 @@ msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, msgstr "Detta inkluderar explicit DEALLOCATE, omallokering eller inbyggd tilldelning, INTENT(OUT) för allokerbara attrappargument och omallokering av allokerbara komponenter allokerade med en OpenMP-allokerare" #: fortran/trans-openmp.cc:5607 fortran/trans-openmp.cc:5627 -#, fuzzy, gcc-internal-format -#| msgid "non-rectangular loop nest with step other than constant 1 or -1 for %qs" +#, gcc-internal-format msgid "non-rectangular loop nest with non-constant step for %qs" -msgstr "icke-rektangulär slinga nästar med ett steg annat än konstanten 1 eller -1 till %qs" +msgstr "icke-rektangulär slinga nästar med ett icke-konstant steg till %qs" #: fortran/trans-openmp.cc:5629 #, gcc-internal-format @@ -81803,16 +81701,14 @@ msgid "constant literal %qs contains %qc, expected 0 or 1" msgstr "den konstanta literalen %qs innehåller %qc, 0 eller 1 förväntades" #: m2/gm2-gcc/m2expr.cc:3964 m2/gm2-gcc/m2expr.cc:3976 -#, fuzzy, gcc-internal-format -#| msgid "language dialect differs %qs, expected %qs" +#, gcc-internal-format msgid "constant literal %qs contains %qc, expected %qs" -msgstr "språkdialekten skiljer %qs, %qs förväntades" +msgstr "den konstanta literalen %qs innehåller %qc, %qs förväntades" #: m2/gm2-gcc/m2expr.cc:3995 -#, fuzzy, gcc-internal-format -#| msgid "target & host is %qs:%qs, expected %qs:%qs" +#, gcc-internal-format msgid "constant literal %qs contains %qc, expected %qs or %qs" -msgstr "mål & värd är %qs:%qs, %qs:%qs förväntades" +msgstr "dem konstanta literalen %qs innehåller %qc, %qs eller %qs förväntades" #: m2/gm2-gcc/m2expr.cc:4061 #, gcc-internal-format @@ -82977,294 +82873,3 @@ msgstr "oanvänt namn %qE" #, gcc-internal-format, gfc-internal-format msgid "are you trying to break %s? how dare you?" msgstr "försöker du göra sönder %s? hur vågar du?" - -#~ msgid "to generate dependencies you must specify '-fcpp' " -#~ msgstr "för att generera beroenden måste man ange ”-fcpp” " - -#, no-c-format -#~ msgid "When vectorizing for SVE, consider using unpacked vectors for smaller elements and use the cost model to pick the cheapest approach. Also use the cost model to choose between SVE and Advanced SIMD vectorization." -#~ msgstr "Vid vektorisering för SVE, överväg att använda opackade vektorer för mindre element och använd kostnadsmodellen för att välja den billigaste metoden. Använd även kostnadsmodellen för att välja mellan SVE- och avancerad SIMD-vektorisering." - -#, no-c-format -#~ msgid "Generate eBPF for the given Linux kernel version." -#~ msgstr "Generera eBPF för den angivna versionen av Linuxkärnan." - -#, no-c-format -#~ msgid "Use NewABI-style %reloc() assembly operators." -#~ msgstr "Använd assembleroperator %reloc() i NewABI-stil." - -#, no-c-format -#~ msgid "Explain what alignment considerations lead to the decision to make an insn short or long." -#~ msgstr "Förklara vilka justeringsöverväganden som leder till beslutet att göra en instruktion kort eller lång." - -#, no-c-format -#~ msgid "Enable bbit peephole2." -#~ msgstr "Aktivera bbit peephole2." - -#~ msgid "invalid use of %<...%> with builtin function" -#~ msgstr "ogiltig användning av %<...%> med inbyggd funktion" - -#~ msgid "type conversion result count mismatch" -#~ msgstr "typkonverteringsresultaträknare stämmer inte" - -#~ msgid "multiple-value argument in single-value context" -#~ msgstr "flervärt argument i sammanhang för enstaka värde" - -#~ msgid "invalid use of %<...%> with non-slice" -#~ msgstr "ogiltig användning av %<...%> med annat än skiva" - -#~ msgid "invalid use of %<...%> calling non-variadic function" -#~ msgstr "ogiltig användning av %<.%> i en funktion som inte är variadisk" - -#~ msgid "index must be integer" -#~ msgstr "indexet måste vara ett heltal" - -#~ msgid "slice end must be integer" -#~ msgstr "skivslut måste vara ett heltal" - -#~ msgid "slice capacity must be integer" -#~ msgstr "skivkapacitet måste vara ett heltal" - -#~ msgid "inverted slice range" -#~ msgstr "inverterat skivintervall" - -#~ msgid "slice of unaddressable value" -#~ msgstr "skiva av oadresserbart värde" - -#~ msgid "too many expressions for struct" -#~ msgstr "för många uttryck för post" - -#~ msgid "too few expressions for struct" -#~ msgstr "för få argument för post" - -#, gcc-internal-format, gfc-internal-format -#~ msgid "argument %i of variable length array %s is null but the corresponding bound argument %i value is %s" -#~ msgstr "argument %i till vektorn %s med variabel längd är null men värdet på det motsvarande bundna argumentet %i är %s" - -#, gcc-internal-format -#~ msgid "argument %i to %<%T[static %E]%> is null where non-null expected" -#~ msgstr "argument %i till %<%T[static %E]%> är null där icke-null förväntades" - -#, gcc-internal-format -#~ msgid "%qs RHS in assignment statement" -#~ msgstr "%qs högersida i tilldelningssats" - -#, gcc-internal-format -#~ msgid "assuming signed overflow does not occur when simplifying %</%> or %<%%%> to %<>>%> or %<&%>" -#~ msgstr "antar att teckenspill inte förekommer vid förenkling av %</%> eller %<%%%> till %<>>%> eller %<&%>" - -#, gcc-internal-format -#~ msgid "assuming signed overflow does not occur when simplifying %<min/max (X,Y)%> to %<X%> or %<Y%>" -#~ msgstr "antar att teckenspill inte förekommer vid förenkling av %<min/max (X,Y)%> till %<X%> eller %<Y%>" - -#, gcc-internal-format -#~ msgid "assuming signed overflow does not occur when simplifying %<abs (X)%> to %<X%> or %<-X%>" -#~ msgstr "antar att teckenspill inte förekommer vid förenkling av %<abs (X)%> till %<X%> eller %<-X%>" - -#, gcc-internal-format -#~ msgid "%qE attribute ignored due to conflict with attribute %qs" -#~ msgstr "attributet %qE ignoreras eftersom det står i konflikt med attributet %qs" - -#, gcc-internal-format -#~ msgid "%qE attribute ignored due to conflict with %qs attribute" -#~ msgstr "attributet %qE ignoreras eftersom det står i konflikt med attributet %qs" - -#, gcc-internal-format -#~ msgid "converting a packed %qT pointer (alignment %d) to a %qT pointer (alignment %d) may result in an unaligned pointer value" -#~ msgstr "att konvertera en packad %qT-pekare (justering %d) till en %qT-pekare (justering %d) kan resultera i ett ojusterat pekarvärde" - -#, gcc-internal-format -#~ msgid "%<-march=%s%>: unsupported ISA subset %<%c%>" -#~ msgstr "%<-march=%s%>: ISA-delmängd som ej stödjs %<%c%>" - -#, gcc-internal-format -#~ msgid "%<-march=%s%>: ISA string is not in canonical order. %<%c%>" -#~ msgstr "%<-march=%s%>: ISA-strängen är inte i kanonisk ordning. %<%c%>" - -#, gcc-internal-format -#~ msgid "%<-march=%s%>: unexpected ISA string at end: %qs" -#~ msgstr "%<-march=%s%>: oväntad ISA-sträng på slutet: %qs" - -#, gcc-internal-format -#~ msgid "missing argument to %<target(\"branch-protection=\")%> pragma or attribute" -#~ msgstr "argument saknas till pragmat eller attributet %<target(\"branch-protection=\")%>" - -#, gcc-internal-format -#~ msgid "invalid protection type %qs in %<target(\"branch-protection=\")%> pragma or attribute" -#~ msgstr "felaktig skyddstyp %qs i pragmat eller attributet %<target(\"branch-protection=\")%>" - -#, gcc-internal-format -#~ msgid "GCC does not currently support mixed size types for %<simd%> functions" -#~ msgstr "GCC stödjer för närvarande inte typer av blandad storlek till %<simd%>-funktioner" - -#, gcc-internal-format -#~ msgid "unsupported return type %qT for %<simd%> functions" -#~ msgstr "returtypen %qT stödjs ej för %<simd%>-funktioner" - -#, gcc-internal-format -#~ msgid "unexpected %<%s%> after %<%s%>" -#~ msgstr "oväntat %<%s%> efter %<%s%>" - -#, gcc-internal-format -#~ msgid "invalid argument %<%s%> for %<-mbranch-protection=%>" -#~ msgstr "ogiltigt argument %<%s%> till %<-mbranch-protection=%>" - -#, gcc-internal-format -#~ msgid "missing argument for %<-mbranch-protection=%>" -#~ msgstr "argumentet saknas till %<-mbranch-protection=%>" - -#, gcc-internal-format -#~ msgid "IO definition for %q+D needs an address" -#~ msgstr "IO-definition för %q+D behöver en adress" - -#, gcc-internal-format -#~ msgid "unsupported variable field offset" -#~ msgstr "ej stött variabelt fältavstånd" - -#, gcc-internal-format -#~ msgid "unsupported variable size field access" -#~ msgstr "ej stödd fältåtkomst av variabel storlek" - -#, gcc-internal-format -#~ msgid "unsupported field expression" -#~ msgstr "ej stött fältuttryck" - -#, gcc-internal-format -#~ msgid "field size too large" -#~ msgstr "fältstorleken är för stor" - -#, gcc-internal-format -#~ msgid "invalid second argument to built-in function" -#~ msgstr "ogiltigt andra argument inbyggd funktion" - -#, gcc-internal-format -#~ msgid "argument is not a field access" -#~ msgstr "argumentet är inte en fältåtkomst" - -#, gcc-internal-format -#~ msgid "XNACK support" -#~ msgstr "XNACK-stöd" - -#, gcc-internal-format -#~ msgid "either -fopenacc or -fopenmp must be set" -#~ msgstr "antingen -fopenacc eller -fopenmp måste vara satt" - -#, gcc-internal-format -#~ msgid "code model %qs needs %s" -#~ msgstr "kodmodell %qs behöver %s" - -#, gcc-internal-format -#~ msgid "%qE attribute requires %s" -#~ msgstr "attributet %qE behöver %s" - -#, gcc-internal-format -#~ msgid "expected %<#pragma acc%> clause" -#~ msgstr "%<#pragma acc%>-klausul förväntades" - -#, gcc-internal-format -#~ msgid "expected %<#pragma omp%> clause" -#~ msgstr "%<#pragma omp%>-klausul förväntades" - -#, gcc-internal-format -#~ msgid "collapsed loops not perfectly nested" -#~ msgstr "kollapsade slingor inte perfekt nästade" - -#, gcc-internal-format -#~ msgid "expected %<construct%>, %<device%>, %<implementation%> or %<user%>" -#~ msgstr "%<construct%>, %<device%>, %<implementation%> eller %<user%> förväntades" - -#, gcc-internal-format -#~ msgid "expected %<seq_cst%>, %<relaxed%> or %<acq_rel%>" -#~ msgstr "%<seq_cst%>, %<relaxed%> eller %<acq_rel%> förväntades" - -#, gcc-internal-format -#~ msgid "pointer type mismatch between %qT and %qT of %qD and %qD in conditional expression" -#~ msgstr "pekartyper stämmer inte mellan %qT och %qT hos %qD och %qD i villkorsuttryck" - -#, gcc-internal-format -#~ msgid "excess elements in %<char%> array initializer" -#~ msgstr "överflödiga element i %<char%>-vektorinitierare" - -#, gcc-internal-format -#~ msgid "cannot dereference %qE in %qs clause" -#~ msgstr "det går inte att dereferera %qE i en %qs-klausul" - -#, gcc-internal-format -#~ msgid "change of the active member of a union from %qD to %qD" -#~ msgstr "ändring av den aktiva medlemmen av en union %qD till %qD" - -#, gcc-internal-format -#~ msgid "previous declaration %q#D here" -#~ msgstr "tidigare deklaration %q#D här" - -#, gcc-internal-format -#~ msgid "deduction guide %q+D redeclared" -#~ msgstr "härledningsguiden %q+D omdeklarerad" - -#, gcc-internal-format -#~ msgid " enters scope of %q#D, which has non-trivial destructor" -#~ msgstr " går in i räckvidden hos %q#D, som har en icke-trivial destruerare" - -#, gcc-internal-format -#~ msgid " enters scope of %q#D which has non-trivial destructor" -#~ msgstr " går in i räckvidden hos %q#D som har en icke-trivial destruerare" - -#, gcc-internal-format -#~ msgid "cannot define %qD in different module" -#~ msgstr "det går inte att definiera %qD i en annan modul" - -#, gcc-internal-format -#~ msgid "lambda templates are only available with %<-std=c++14%> or %<-std=gnu++14%>" -#~ msgstr "lambdamallar är endast tillgängliga med %<-std=c++14%> eller %<-std=gnu++14%>" - -#, gcc-internal-format -#~ msgid "unknown OpenMP directive name in %<omp::directive%> attribute argument" -#~ msgstr "okänt OpenMP-direktivnamn i attributargumentet %<omp::directive%>" - -#, gcc-internal-format -#~ msgid "not enough for loops to collapse" -#~ msgstr "för få for-slingor att kollapsa" - -#, gcc-internal-format -#~ msgid "%<#pragma GCC unroll%> must be inside a function" -#~ msgstr "%<#pragma GCC unroll%> måste vara inuti en funktion" - -#, gcc-internal-format -#~ msgid "taking address of temporary array" -#~ msgstr "tar adress till temporär vektor" - -#, gcc-internal-format -#~ msgid "closing json file %s: %m" -#~ msgstr "när json-filen %s stängdes: %m" - -#, gcc-internal-format -#~ msgid "closing mixin file %s: %m" -#~ msgstr "när mixin-filen %s stängdes: %m" - -#, gcc-internal-format -#~ msgid "opening mixin file %s: %m" -#~ msgstr "när mixin-filen %s öppnades: %m" - -#, gcc-internal-format -#~ msgid "TODO: Vector sections in data statements" -#~ msgstr "ATTGÖRA: Vektorsektionen i datasatser" - -#, gcc-internal-format, gfc-internal-format -#~ msgid "property must be constant integer expression or string literal at %C" -#~ msgstr "egenskaper måste vara ett konstant heltalsuttryck eller en strängkonstant vid %C" - -#, gcc-internal-format -#~ msgid "expected %<construct%>, %<device%>, %<implementation%> or %<user%> at %C" -#~ msgstr "%<construct%>, %<device%>, %<implementation%> eller %<user%> förväntades vid %C" - -#, gcc-internal-format, gfc-internal-format -#~ msgid "collapsed %s loops not perfectly nested at %L" -#~ msgstr "kollapsade %s-slingor är inte perfekt nästade vid %L" - -#, gcc-internal-format, gfc-internal-format -#~ msgid "OpenMP directives other than SIMD or DECLARE TARGET at %C may not appear in PURE procedures" -#~ msgstr "Andra OpenMP-direktiv än SIMD eller DECLARE TARGET vid %C för inte förekomma i PURE-procedurer" - -#, gcc-internal-format -#~ msgid "TODO" -#~ msgstr "ATTGÖRA" diff --git a/gcc/range-op-mixed.h b/gcc/range-op-mixed.h index 1b470811829..3ee7c9d6e0d 100644 --- a/gcc/range-op-mixed.h +++ b/gcc/range-op-mixed.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_RANGE_OP_MIXED_H #define GCC_RANGE_OP_MIXED_H -void update_known_bitmask (irange &, tree_code, const irange &, const irange &); +void update_known_bitmask (vrange &, tree_code, const vrange &, const vrange &); bool minus_op1_op2_relation_effect (irange &lhs_range, tree type, const irange &, const irange &, relation_kind rel); diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc index 2c85d75b5e8..7343ef635f3 100644 --- a/gcc/range-op-ptr.cc +++ b/gcc/range-op-ptr.cc @@ -101,10 +101,10 @@ pointer_plus_operator::wi_fold (irange &r, tree type, && !TYPE_OVERFLOW_WRAPS (type) && (flag_delete_null_pointer_checks || !wi::sign_mask (rh_ub))) - r = range_nonzero (type); + r.set_nonzero (type); else if (lh_lb == lh_ub && lh_lb == 0 && rh_lb == rh_ub && rh_lb == 0) - r = range_zero (type); + r.set_zero (type); else r.set_varying (type); } @@ -150,9 +150,9 @@ pointer_min_max_operator::wi_fold (irange &r, tree type, // are varying. if (!wi_includes_zero_p (type, lh_lb, lh_ub) && !wi_includes_zero_p (type, rh_lb, rh_ub)) - r = range_nonzero (type); + r.set_nonzero (type); else if (wi_zero_p (type, lh_lb, lh_ub) && wi_zero_p (type, rh_lb, rh_ub)) - r = range_zero (type); + r.set_zero (type); else r.set_varying (type); } @@ -175,7 +175,7 @@ pointer_and_operator::wi_fold (irange &r, tree type, // For pointer types, we are really only interested in asserting // whether the expression evaluates to non-NULL. if (wi_zero_p (type, lh_lb, lh_ub) || wi_zero_p (type, lh_lb, lh_ub)) - r = range_zero (type); + r.set_zero (type); else r.set_varying (type); } @@ -236,9 +236,9 @@ pointer_or_operator::wi_fold (irange &r, tree type, // whether the expression evaluates to non-NULL. if (!wi_includes_zero_p (type, lh_lb, lh_ub) && !wi_includes_zero_p (type, rh_lb, rh_ub)) - r = range_nonzero (type); + r.set_nonzero (type); else if (wi_zero_p (type, lh_lb, lh_ub) && wi_zero_p (type, rh_lb, rh_ub)) - r = range_zero (type); + r.set_zero (type); else r.set_varying (type); } diff --git a/gcc/range-op.cc b/gcc/range-op.cc index 4ccb86ef0ba..ab3a4f0b200 100644 --- a/gcc/range-op.cc +++ b/gcc/range-op.cc @@ -415,8 +415,8 @@ range_op_handler::operand_check_p (tree t1, tree t2, tree t3) const // LH and RH. void -update_known_bitmask (irange &r, tree_code code, - const irange &lh, const irange &rh) +update_known_bitmask (vrange &r, tree_code code, + const vrange &lh, const vrange &rh) { if (r.undefined_p () || lh.undefined_p () || rh.undefined_p () || r.singleton_p ()) @@ -1657,7 +1657,7 @@ operator_plus::lhs_op1_relation (const irange &lhs, } // If op2 does not contain 0, then LHS and OP1 can never be equal. - if (!range_includes_zero_p (&op2)) + if (!range_includes_zero_p (op2)) return VREL_NE; return VREL_VARYING; @@ -4364,9 +4364,11 @@ operator_negate::fold_range (irange &r, tree type, { if (empty_range_varying (r, type, lh, rh)) return true; - // -X is simply 0 - X. - return range_op_handler (MINUS_EXPR).fold_range (r, type, - range_zero (type), lh); + +// -X is simply 0 - X. + int_range<1> zero; + zero.set_zero (type); + return range_op_handler (MINUS_EXPR).fold_range (r, type, zero, lh); } bool @@ -4391,7 +4393,7 @@ operator_addr_expr::fold_range (irange &r, tree type, // Return a non-null pointer of the LHS type (passed in op2). if (lh.zero_p ()) - r = range_zero (type); + r.set_zero (type); else if (lh.undefined_p () || contains_zero_p (lh)) r.set_varying (type); else @@ -4675,7 +4677,7 @@ range_op_cast_tests () if (TYPE_PRECISION (integer_type_node) > TYPE_PRECISION (short_integer_type_node)) { - r0 = range_nonzero (integer_type_node); + r0.set_nonzero (integer_type_node); range_cast (r0, short_integer_type_node); r1 = int_range<1> (short_integer_type_node, min_limit (short_integer_type_node), @@ -4687,7 +4689,7 @@ range_op_cast_tests () // // NONZERO signed 16-bits is [-MIN_16,-1][1, +MAX_16]. // Converting this to 32-bits signed is [-MIN_16,-1][1, +MAX_16]. - r0 = range_nonzero (short_integer_type_node); + r0.set_nonzero (short_integer_type_node); range_cast (r0, integer_type_node); r1 = int_range<1> (integer_type_node, INT (-32768), INT (-1)); r2 = int_range<1> (integer_type_node, INT (1), INT (32767)); diff --git a/gcc/range.cc b/gcc/range.cc index c68f387f71c..b362e0f12e0 100644 --- a/gcc/range.cc +++ b/gcc/range.cc @@ -30,20 +30,6 @@ along with GCC; see the file COPYING3. If not see #include "range.h" value_range -range_zero (tree type) -{ - wide_int zero = wi::zero (TYPE_PRECISION (type)); - return value_range (type, zero, zero); -} - -value_range -range_nonzero (tree type) -{ - wide_int zero = wi::zero (TYPE_PRECISION (type)); - return value_range (type, zero, zero, VR_ANTI_RANGE); -} - -value_range range_positives (tree type) { unsigned prec = TYPE_PRECISION (type); diff --git a/gcc/range.h b/gcc/range.h index 391ea02daf5..eccb9490e4d 100644 --- a/gcc/range.h +++ b/gcc/range.h @@ -21,8 +21,6 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_RANGE_H #define GCC_RANGE_H -value_range range_zero (tree type); -value_range range_nonzero (tree type); value_range range_positives (tree type); value_range range_negatives (tree type); diff --git a/gcc/rtlanal.cc b/gcc/rtlanal.cc index d38455bc559..4158a531bdd 100644 --- a/gcc/rtlanal.cc +++ b/gcc/rtlanal.cc @@ -1637,12 +1637,15 @@ set_noop_p (const_rtx set) return true; if (MEM_P (dst) && MEM_P (src)) - return rtx_equal_p (dst, src) && !side_effects_p (dst); + return (rtx_equal_p (dst, src) + && !side_effects_p (dst) + && !side_effects_p (src)); if (GET_CODE (dst) == ZERO_EXTRACT) - return rtx_equal_p (XEXP (dst, 0), src) - && !BITS_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx - && !side_effects_p (src); + return (rtx_equal_p (XEXP (dst, 0), src) + && !BITS_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx + && !side_effects_p (src) + && !side_effects_p (XEXP (dst, 0))); if (GET_CODE (dst) == STRICT_LOW_PART) dst = XEXP (dst, 0); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 1a8f57b87c1..0690463aac2 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,836 @@ +2024-04-30 Jivan Hakobyan <jivanhakobyan9@gmail.com> + + * gcc.target/riscv/fix.c: New test. + * gcc.target/riscv/round.c: New test. + * gcc.target/riscv/round_32.c: New test. + * gcc.target/riscv/round_64.c: New test. + +2024-04-30 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + PR modula2/114886 + * lib/gm2.exp: Don't load timeout-dg.exp. + Don't set gm2_previous_timeout. + Don't call dg-timeout. + (gm2_push_timeout, gm2_pop_timeout): Remove. + (gm2_init): Don't call dg-timeout. + * lib/gm2-torture.exp: Don't load timeout-dg.exp. + Don't set gm2_previous_timeout. + Don't call dg-timeout. + (gm2_push_timeout, gm2_pop_timeout): Remove. + * gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp: Don't + load timeout-dg.exp. + Don't call gm2_push_timeout, gm2_pop_timeout. + * gm2/examples/map/pass/examples-map-pass.exp: Don't call + gm2_push_timeout, gm2_pop_timeout. + * gm2/iso/run/pass/iso-run-pass.exp: Don't load timeout-dg.exp. + Don't call gm2_push_timeout, gm2_pop_timeout. + * gm2/pimlib/base/run/pass/pimlib-base-run-pass.exp: Don't load + timeout-dg.exp. + Don't call gm2_push_timeout, gm2_pop_timeout. + * gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp: + Don't call gm2_push_timeout, gm2_pop_timeout. + * gm2/switches/whole-program/pass/run/switches-whole-program-pass-run.exp: + Don't load timeout-dg.exp. + Don't call gm2_push_timeout, gm2_pop_timeout. + +2024-04-30 Richard Biener <rguenther@suse.de> + + * gcc.dg/gimplefe-53.c: New testcase. + +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/114876 + * gcc.dg/pr114876.c: New test. + * gcc.dg/tree-ssa/builtin-sprintf-warn-1.c: Adjust expected + diagnostics. + +2024-04-30 Jakub Jelinek <jakub@redhat.com> + Hongtao Liu <hongtao.liu@intel.com> + + PR tree-optimization/114883 + * gfortran.dg/pr114883.f90: New test. + +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + PR c++/114456 + * g++.dg/cpp26/decomp1.C: New test. + * g++.dg/cpp26/decomp2.C: New test. + * g++.dg/cpp26/feat-cxx26.C (__cpp_structured_bindings): Expect + 202403 rather than 201606. + +2024-04-30 Nathaniel Shead <nathanieloshead@gmail.com> + + PR c++/105320 + PR c++/114275 + * g++.dg/modules/tpl-friend-10_a.C: New test. + * g++.dg/modules/tpl-friend-10_b.C: New test. + * g++.dg/modules/tpl-friend-10_c.C: New test. + * g++.dg/modules/tpl-friend-10_d.C: New test. + * g++.dg/modules/tpl-friend-11_a.C: New test. + * g++.dg/modules/tpl-friend-11_b.C: New test. + * g++.dg/modules/tpl-friend-12_a.C: New test. + * g++.dg/modules/tpl-friend-12_b.C: New test. + * g++.dg/modules/tpl-friend-12_c.C: New test. + * g++.dg/modules/tpl-friend-12_d.C: New test. + * g++.dg/modules/tpl-friend-12_e.C: New test. + * g++.dg/modules/tpl-friend-12_f.C: New test. + * g++.dg/modules/tpl-friend-13_a.C: New test. + * g++.dg/modules/tpl-friend-13_b.C: New test. + * g++.dg/modules/tpl-friend-13_c.C: New test. + * g++.dg/modules/tpl-friend-13_d.C: New test. + * g++.dg/modules/tpl-friend-13_e.C: New test. + * g++.dg/modules/tpl-friend-13_f.C: New test. + * g++.dg/modules/tpl-friend-13_g.C: New test. + * g++.dg/modules/tpl-friend-14_a.C: New test. + * g++.dg/modules/tpl-friend-14_b.C: New test. + * g++.dg/modules/tpl-friend-14_c.C: New test. + * g++.dg/modules/tpl-friend-14_d.C: New test. + * g++.dg/modules/tpl-friend-9.C: New test. + +2024-04-30 Nathaniel Shead <nathanieloshead@gmail.com> + + * g++.dg/modules/enum-12.C: Update error message. + * g++.dg/modules/friend-5_b.C: Likewise. + * g++.dg/modules/shadow-1_b.C: Likewise. + +2024-04-30 Patrick Palka <ppalka@redhat.com> + + PR c++/114889 + * g++.dg/modules/friend-8_a.H: New test. + * g++.dg/modules/friend-8_b.C: New test. + +2024-04-30 Patrick Palka <ppalka@redhat.com> + + PR c++/114888 + * g++.dg/template/sizeof19.C: New test. + +2024-04-29 Alexandre Oliva <oliva@gnu.org> + + Revert: + 2024-04-28 Alexandre Oliva <oliva@adacore.com> + + * lib/target-supports.exp (check_vect_support_and_set_flags): + Decay to link rather than compile. + +2024-04-29 Francois-Xavier Coudert <fxcoudert@gcc.gnu.org> + + * gfortran.dg/selected_logical_kind_1.f90: New test. + * gfortran.dg/selected_logical_kind_2.f90: New test. + * gfortran.dg/selected_logical_kind_3.f90: New test. + * gfortran.dg/selected_logical_kind_4.f90: New test. + +2024-04-29 Francois-Xavier Coudert <fxcoudert@gcc.gnu.org> + + * gfortran.dg/iso_fortran_env_8.f90: New test. + * gfortran.dg/iso_fortran_env_9.f90: New test. + +2024-04-29 demin.han <demin.han@starfivetech.com> + + PR target/114506 + * gcc.dg/vect/costmodel/riscv/rvv/pr114506.c: New test. + +2024-04-29 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/114959 + * gfortran.dg/pr114959.f90: New test. + +2024-04-29 Jie Mei <jie.mei@oss.cipunited.com> + + * gcc.target/mips/mips-minmax1.c: New test for MIPS R6. + * gcc.target/mips/mips-minmax2.c: Same as above. + +2024-04-28 liuhongt <hongtao.liu@intel.com> + + * gcc.target/i386/zero_extendkmask.c: New file. + +2024-04-28 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/cdce3.c: Require sqrt_insn effective target. + * gcc.target/powerpc/pr46728-10.c: Likewise. Drop darwin + explicit skipping. + * gcc.target/powerpc/pr46728-11.c: Likewise. Likewise. + * gcc.target/powerpc/pr46728-13.c: Likewise. Likewise. + * gcc.target/powerpc/pr46728-14.c: Likewise. Likewise. + +2024-04-28 Alexandre Oliva <oliva@adacore.com> + + PR target/58684 + * gcc.dg/torture/pr91323.c: Expect execution fail on + powerpc*-*-*. + +2024-04-28 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/powerpc/vec-mul.c: Run on target vsx_hw, just + compile otherwise. + +2024-04-28 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c: Disable + ldist. + +2024-04-28 Olivier Hainque <hainque@adacore.com> + + * gcc.target/powerpc/swaps-p8-20.c: Change powerpc_altivec_ok + require-effective-target test into vmx_hw. + * gcc.target/powerpc/vsx-vector-5.c: Change powerpc_vsx_ok + require-effective-target test into vsx_hw. + +2024-04-28 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/powerpc/pr106680-1.c: Error on vxworks too. + * gcc.target/powerpc/pr106680-2.c: Likewise. + * gcc.target/powerpc/pr106680-3.c: Likewise. + +2024-04-28 Alexandre Oliva <oliva@adacore.com> + + * lib/target-supports.exp (check_vect_support_and_set_flags): + Decay to link rather than compile. + +2024-04-28 Jiufu Guo <guojiufu@linux.ibm.com> + + PR target/95782 + * g++.target/s390/pr95782.C: New test. + +2024-04-27 Xi Ruoyao <xry111@xry111.site> + + PR target/114861 + * gcc.target/loongarch/pr114861.c: New test. + +2024-04-26 Wilco Dijkstra <wilco.dijkstra@arm.com> + + * gcc.target/aarch64/ldp_stp_q_disable.c: Remove test. + +2024-04-26 Patrick Palka <ppalka@redhat.com> + + * g++.dg/concepts/diagnostic2.C: Expect source line printed + for the "required from here" message. + * g++.dg/template/error60a.C: New test. + +2024-04-26 Haochen Jiang <haochen.jiang@intel.com> + + PR target/110621 + * gcc.target/i386/pr105354-2.c: As mentioned. + +2024-04-25 David Faust <david.faust@oracle.com> + + * gcc.target/bpf/bpf-debug-options-1.c: New test. + * gcc.target/bpf/bpf-debug-options-2.c: Likewise. + * gcc.target/bpf/bpf-debug-options-3.c: Likewise. + * gcc.target/bpf/core-options-4.c: Likewise. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + PR c++/111284 + * g++.dg/cpp1z/constexpr-111284.C: New test. + * g++.dg/cpp1y/constexpr-lifetime7.C: Expect one error on a different + line. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + PR lto/113208 + * g++.dg/abi/comdat2.C: New test. + * g++.dg/abi/comdat5.C: New test. + * g++.dg/lto/pr113208_0.C: New test. + * g++.dg/lto/pr113208_1.C: New file. + * g++.dg/lto/pr113208.h: New file. + +2024-04-25 David Faust <david.faust@oracle.com> + + * gcc.target/bpf/core-options-1.c: New test. + * gcc.target/bpf/core-options-2.c: Likewise. + * gcc.target/bpf/core-options-3.c: Likewise. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + PR fortran/114825 + * gfortran.dg/gomp/pr114825.f90: New test. + +2024-04-25 Jose E. Marchesi <jose.marchesi@oracle.com> + + * gcc.target/bpf/alu-1.c: Specify conventional asm dialect. + * gcc.target/bpf/xbpf-indirect-call-1.c: Likewise. + * gcc.target/bpf/sync-fetch-and-add.c: Likewise. + * gcc.target/bpf/smov-2.c: Likewise. + * gcc.target/bpf/smov-1.c: Likewise. + * gcc.target/bpf/smod-1.c: Likewise. + * gcc.target/bpf/sload-1.c: Likewise. + * gcc.target/bpf/sdiv-1.c: Likewise. + * gcc.target/bpf/nop-1.c: Likewise. + * gcc.target/bpf/neg-1.c: Likewise. + * gcc.target/bpf/ldxdw.c: Likewise. + * gcc.target/bpf/jmp-1.c: Likewise. + * gcc.target/bpf/inline-memops-threshold-1.c: Likewise. + * gcc.target/bpf/float-1.c: Likewise. + * gcc.target/bpf/double-2.c: Likewise. + * gcc.target/bpf/double-1.c: Likewise. + * gcc.target/bpf/core-builtin-type-id.c: Likewise. + * gcc.target/bpf/core-builtin-type-based.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-size-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-sign-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-sign-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-rshift-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-rshift-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-offset-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-lshift-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-lshift-1-le.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-lshift-1-be.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-existence-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-errors-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-errors-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-const-elimination.c: + Likewise. + * gcc.target/bpf/core-builtin-exprlist-4.c: Likewise. + * gcc.target/bpf/core-builtin-exprlist-3.c: Likewise. + * gcc.target/bpf/core-builtin-exprlist-2.c: Likewise. + * gcc.target/bpf/core-builtin-exprlist-1.c: Likewise. + * gcc.target/bpf/core-builtin-enumvalue-opt.c: Likewise. + * gcc.target/bpf/core-builtin-enumvalue-errors.c: Likewise. + * gcc.target/bpf/core-builtin-enumvalue.c: Likewise. + * gcc.target/bpf/core-builtin-3.c: Likewise. + * gcc.target/bpf/core-builtin-2.c: Likewise. + * gcc.target/bpf/core-builtin-1.c: Likewise. + * gcc.target/bpf/core-attr-struct-as-array.c: Likewise. + * gcc.target/bpf/core-attr-6.c: Likewise. + * gcc.target/bpf/core-attr-5.c: Likewise. + * gcc.target/bpf/core-attr-4.c: Likewise. + * gcc.target/bpf/core-attr-3.c: Likewise. + * gcc.target/bpf/core-attr-2.c: Likewise. + * gcc.target/bpf/core-attr-1.c: Likewise. + * gcc.target/bpf/builtin-load.c: Likewise. + * gcc.target/bpf/btfext-funcinfo-nocore.c: Likewise. + * gcc.target/bpf/btfext-funcinfo.c: Likewise. + * gcc.target/bpf/bswap-1.c: Likewise. + * gcc.target/bpf/bswap-2.c: Likewise. + * gcc.target/bpf/attr-kernel-helper.c: Likewise. + * gcc.target/bpf/atomic-xchg-2.c: Likewise. + * gcc.target/bpf/atomic-xchg-1.c: Likewise. + * gcc.target/bpf/atomic-op-3.c: Likewise. + * gcc.target/bpf/atomic-op-2.c: Likewise. + * gcc.target/bpf/atomic-op-1.c: Likewise. + * gcc.target/bpf/atomic-fetch-op-3.c: Likewise. + * gcc.target/bpf/atomic-fetch-op-2.c: Likewise. + * gcc.target/bpf/atomic-fetch-op-1.c: Likewise. + * gcc.target/bpf/atomic-cmpxchg-2.c: Likewise. + * gcc.target/bpf/atomic-cmpxchg-1.c: Likewise. + * gcc.target/bpf/alu-2.c: Likewise. + +2024-04-25 Richard Ball <richard.ball@arm.com> + + * gcc.target/arm/cmse/extend-param.c: New test. + * gcc.target/arm/cmse/extend-return.c: New test. + +2024-04-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114792 + * gcc.dg/torture/pr114792.c: New testcase. + +2024-04-25 Eric Botcazou <ebotcazou@adacore.com> + + * gcc.target/sparc/small-struct-1.c: New test. + * gcc.target/sparc/pr105573.c: Rename to... + * gcc.target/sparc/20230425-1.c: ...this. + * gcc.target/sparc/pr109541.c: Rename to... + * gcc.target/sparc/20230607-1.c: ...this + +2024-04-25 Pan Li <pan2.li@intel.com> + Kito Cheng <kito.cheng@sifive.com> + + PR target/114714 + * g++.target/riscv/rvv/base/pr114714-1.C: New test. + * g++.target/riscv/rvv/base/pr114714-2.C: New test. + +2024-04-25 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/93678 + * gfortran.dg/pr93678.f90: New test. + +2024-04-25 Paul Thomas <pault@gcc.gnu.org> + Jakub Jelinek <jakub@gcc.gnu.org> + + PR fortran/89462 + * gfortran.dg/pr89462.f90: New test. + +2024-04-25 Haochen Gui <guihaoc@gcc.gnu.org> + + * gcc.target/powerpc/bcd-4.c: Adjust the number of bcdadd and + bcdsub. + +2024-04-25 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-1.c: New test. + * gcc.target/riscv/rvv/base/pr112431-2.c: New test. + * gcc.target/riscv/rvv/base/pr112431-3.c: New test. + +2024-04-24 Patrick Palka <ppalka@redhat.com> + + * g++.dg/modules/pr99023_a.X: Run only in C++20 mode. + * g++.dg/modules/pr99023_b.X: Likewise. + +2024-04-24 Patrick Palka <ppalka@redhat.com> + + PR c++/114709 + * g++.dg/cpp0x/constexpr-union8.C: New test. + +2024-04-24 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-24 Juzhe-Zhong <juzhe.zhong@rivai.ai> + kito-cheng <kito.cheng@sifive.com> + kito-cheng <kito.cheng@gmail.com> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-1.c: New test. + * gcc.target/riscv/rvv/base/pr112431-2.c: New test. + * gcc.target/riscv/rvv/base/pr112431-3.c: New test. + +2024-04-24 Jose E. Marchesi <jose.marchesi@oracle.com> + + * gcc.target/bpf/feature-macro-1.c: New test. + * gcc.target/bpf/feature-macro-2.c: Likewise. + +2024-04-24 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114787 + * gcc.dg/torture/pr114787.c: New testcase. + +2024-04-24 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114832 + * gcc.dg/vect/pr114832.c: New testcase. + +2024-04-24 Haochen Jiang <haochen.jiang@intel.com> + + * gcc.target/i386/avx10_1-24.c: New test. + +2024-04-24 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/unop_v_constraint-2.c: Adjust asm + check cond. + * gcc.target/riscv/rvv/base/pr112431-4.c: New test. + * gcc.target/riscv/rvv/base/pr112431-5.c: New test. + * gcc.target/riscv/rvv/base/pr112431-6.c: New test. + +2024-04-24 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-24 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + * gcc.target/riscv/rvv/base/unop_v_constraint-2.c: Adapt test. + * gcc.target/riscv/rvv/base/pr112431-4.c: New test. + * gcc.target/riscv/rvv/base/pr112431-5.c: New test. + * gcc.target/riscv/rvv/base/pr112431-6.c: New test. + +2024-04-23 Nathaniel Shead <nathanieloshead@gmail.com> + + * g++.dg/cpp23/explicit-obj-basic7.C: New test. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + PR target/114810 + * g++.target/i386/pr114810.C: New test. + +2024-04-23 Harald Anlauf <anlauf@gmx.de> + + PR fortran/103496 + * gfortran.dg/c_sizeof_8.f90: New test. + +2024-04-23 Patrick Palka <ppalka@redhat.com> + + PR c++/114795 + * g++.dg/modules/auto-4_a.H: New test. + * g++.dg/modules/auto-4_b.C: New test. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + * objc.dg/attributes/nullability-00.m: Adjust expected diagnostic + spelling: recognised -> recognized. + * obj-c++.dg/attributes/nullability-00.mm: Likewise. + +2024-04-23 Stefan Schulze Frielinghaus <stefansf@linux.ibm.com> + + * gcc.dg/tree-ssa/forwprop-40.c: Xfail for s390. + * gcc.dg/tree-ssa/forwprop-41.c: Xfail for s390. + * lib/target-supports.exp: Add target check s390_mvx. + +2024-04-23 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/102597 + * gfortran.dg/pr102597.f90: New test. + +2024-04-23 Richard Biener <rguenther@suse.de> + + PR tree-optimization/114799 + * gcc.dg/vect/bb-slp-pr114799.c: New testcase. + +2024-04-23 Andreas Krebbel <krebbel@linux.ibm.com> + + PR target/114676 + * gcc.target/s390/zvector/pr114676.c: New test. + +2024-04-23 Jakub Jelinek <jakub@redhat.com> + + PR c++/114784 + * g++.dg/cpp0x/inh-ctor39.C: New test. + +2024-04-23 Nathaniel Shead <nathanieloshead@gmail.com> + + PR c++/114078 + * g++.dg/cpp23/explicit-obj-ops-alloc.C: New test. + +2024-04-22 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/114811 + * lib/gm2-torture.exp: Correct regexp checking for internal + compiler error strings in compiler output. + +2024-04-22 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/114807 + * gm2/pim/fail/badproctype.mod: Change MYSHORTREAL + to SHORTREAL. + * gm2/pim/fail/badprocbool.mod: New test. + * gm2/pim/fail/badproccard.mod: New test. + * gm2/pim/fail/badprocint.mod: New test. + * gm2/pim/fail/badprocint2.mod: New test. + * gm2/pim/pass/goodproccard2.mod: New test. + * gm2/pim/pass/goodprocint.mod: New test. + * gm2/pim/pass/goodprocint3.mod: New test. + * gm2/pim/run/pass/genconststr.mod: New test. + +2024-04-22 Marek Polacek <polacek@redhat.com> + + * lib/prune.exp (prune_gcc_output): Also prune -freport-bug output. + +2024-04-22 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-10.c: New test. + * gcc.target/riscv/rvv/base/pr112431-11.c: New test. + * gcc.target/riscv/rvv/base/pr112431-12.c: New test. + * gcc.target/riscv/rvv/base/pr112431-13.c: New test. + * gcc.target/riscv/rvv/base/pr112431-14.c: New test. + * gcc.target/riscv/rvv/base/pr112431-15.c: New test. + * gcc.target/riscv/rvv/base/pr112431-7.c: New test. + * gcc.target/riscv/rvv/base/pr112431-8.c: New test. + * gcc.target/riscv/rvv/base/pr112431-9.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-22 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-10.c: New test. + * gcc.target/riscv/rvv/base/pr112431-11.c: New test. + * gcc.target/riscv/rvv/base/pr112431-12.c: New test. + * gcc.target/riscv/rvv/base/pr112431-13.c: New test. + * gcc.target/riscv/rvv/base/pr112431-14.c: New test. + * gcc.target/riscv/rvv/base/pr112431-15.c: New test. + * gcc.target/riscv/rvv/base/pr112431-7.c: New test. + * gcc.target/riscv/rvv/base/pr112431-8.c: New test. + * gcc.target/riscv/rvv/base/pr112431-9.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-34.c: Remove xfail for vluxei8 check. + * gcc.target/riscv/rvv/base/pr112431-28.c: New test. + * gcc.target/riscv/rvv/base/pr112431-29.c: New test. + * gcc.target/riscv/rvv/base/pr112431-30.c: New test. + * gcc.target/riscv/rvv/base/pr112431-31.c: New test. + * gcc.target/riscv/rvv/base/pr112431-32.c: New test. + * gcc.target/riscv/rvv/base/pr112431-33.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-22 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-28.c: New test. + * gcc.target/riscv/rvv/base/pr112431-29.c: New test. + * gcc.target/riscv/rvv/base/pr112431-30.c: New test. + * gcc.target/riscv/rvv/base/pr112431-31.c: New test. + * gcc.target/riscv/rvv/base/pr112431-32.c: New test. + * gcc.target/riscv/rvv/base/pr112431-33.c: New test. + +2024-04-22 Stefan Schulze Frielinghaus <stefansf@linux.ibm.com> + + * gcc.target/s390/vxe/popcount-1.c: Remove xfail. + +2024-04-22 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-37.c: New test. + * gcc.target/riscv/rvv/base/pr112431-38.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-22 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-37.c: New test. + * gcc.target/riscv/rvv/base/pr112431-38.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-16.c: New test. + * gcc.target/riscv/rvv/base/pr112431-17.c: New test. + * gcc.target/riscv/rvv/base/pr112431-18.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-22 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-16.c: New test. + * gcc.target/riscv/rvv/base/pr112431-17.c: New test. + * gcc.target/riscv/rvv/base/pr112431-18.c: New test. + +2024-04-22 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-22.c: New test. + * gcc.target/riscv/rvv/base/pr112431-23.c: New test. + * gcc.target/riscv/rvv/base/pr112431-24.c: New test. + * gcc.target/riscv/rvv/base/pr112431-25.c: New test. + * gcc.target/riscv/rvv/base/pr112431-26.c: New test. + * gcc.target/riscv/rvv/base/pr112431-27.c: New test. + +2024-04-21 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/103471 + * gfortran.dg/pr103471.f90: New test. + +2024-04-21 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-21 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-22.c: New test. + * gcc.target/riscv/rvv/base/pr112431-23.c: New test. + * gcc.target/riscv/rvv/base/pr112431-24.c: New test. + * gcc.target/riscv/rvv/base/pr112431-25.c: New test. + * gcc.target/riscv/rvv/base/pr112431-26.c: New test. + * gcc.target/riscv/rvv/base/pr112431-27.c: New test. + +2024-04-21 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-34.c: New test. + +2024-04-20 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-20 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-34.c: New test. + +2024-04-20 Gaius Mulley <gaiusmod2@gmail.com> + + PR modula2/112893 + * gm2/pim/pass/another.mod: Correct bug exposed by type checker. + Swap ProcA and ProcB assignments. + * gm2/pim/pass/proccard.mod: Use VAL to convert procedure into a + cardinal. + * gm2/iso/const/fail/castproctype.mod: New test. + * gm2/pim/fail/badproctype.mod: New test. + +2024-04-20 Pan Li <pan2.li@intel.com> + + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-11.c: Xfail csr check. + * gcc.target/riscv/rvv/base/pr112431-39.c: New test. + * gcc.target/riscv/rvv/base/pr112431-40.c: New test. + * gcc.target/riscv/rvv/base/pr112431-41.c: New test. + +2024-04-20 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-20 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112431 + * gcc.target/riscv/rvv/base/pr112431-39.c: New test. + * gcc.target/riscv/rvv/base/pr112431-40.c: New test. + * gcc.target/riscv/rvv/base/pr112431-41.c: New test. + +2024-04-20 Pan Li <pan2.li@intel.com> + + * gcc.target/riscv/rvv/base/pr112431-42.c: New test. + +2024-04-20 Pan Li <pan2.li@intel.com> + + Revert: + 2024-04-20 Juzhe-Zhong <juzhe.zhong@rivai.ai> + + PR target/112432 + * gcc.target/riscv/rvv/base/pr112432-42.c: New test. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR target/114783 + * gcc.target/i386/avx2-pr114783.c: New test. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR c/114780 + * gcc.dg/format/sentinel-2.c: New test. + +2024-04-19 Martin Uecker <uecker@tugraz.at> + Jakub Jelinek <jakub@redhat.com> + + PR lto/114574 + PR c/114361 + * gcc.dg/pr114574-1.c: New test. + * gcc.dg/pr114574-2.c: New test. + * gcc.dg/pr114361.c: New test. + * gcc.dg/c23-tag-incomplete-1.c: New test. + * gcc.dg/c23-tag-incomplete-2.c: New test. + +2024-04-19 Thomas Schwinge <tschwinge@baylibre.com> + + PR testsuite/114768 + * gcc.dg/pr114768.c: Enable for nvptx target. + +2024-04-19 Cupertino Miranda <cupertino.miranda@oracle.com> + + * gcc.target/bpf/btfext-funcinfo.c: Updated to changes. + * gcc.target/bpf/core-builtin-fieldinfo-const-elimination.c: + Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-existence-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-lshift-1-be.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-lshift-1-le.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-lshift-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-offset-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-rshift-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-rshift-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-sign-1.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-sign-2.c: Likewise. + * gcc.target/bpf/core-builtin-fieldinfo-size-1.c: Likewise. + +2024-04-19 Iain Buclaw <ibuclaw@gdcproject.org> + + PR d/111650 + * gdc.dg/pr111650.d: New test. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/114768 + * gcc.dg/pr114768.c: New test. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR libgcc/114762 + * gcc.dg/torture/bitint-70.c: New test. + +2024-04-18 Paul Thomas <pault@gcc.gnu.org> + + PR fortran/114739 + * gfortran.dg/pr114739.f90: New test. + * gfortran.dg/derived_comp_array_ref_8.f90: Add 'implicit none' + for consistency with expected error message. + * gfortran.dg/nullify_4.f90: ditto + * gfortran.dg/pointer_init_6.f90: ditto + * gfortran.dg/pr107397.f90: ditto + * gfortran.dg/pr88138.f90: ditto + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/i386/bf16_short_warn.c: Add -msse2. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/i386/pr107261.c: Add -fomit-frame-pointer. + * gcc.target/i386/pr69482-1.c: Likewise. + * gcc.target/i386/pr69482-2.c: Likewise. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/arm/bfloat16_scalar_typecheck.c: Accept C23 + empty initializers. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * g++.dg/contracts/contracts9.C: Don't assume string literals + have non-negative addresses. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + Olivier Hainque <hainque@adacore.com> + + * gcc.target/aarch64/pr94201.c: Add missing + dg-require-effective-target fpic. + * gcc.target/aarch64/pr103085.c: Likewise. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * g++.target/i386/pr111497.C: Require fpic support. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + PR testsuite/113706 + * c-c++-common/pr103798-2.c: XFAIL in C++ on vxworks too. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/analyzer/fd-glibc-byte-stream-connection-server.c: + Include sys/select.h if present. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/analyzer/pipe-glibc.c: Require fork. + * gcc.dg/analyzer/pipe-manpages.c: Likewise. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/analyzer/fd-access-mode-target-headers.c: Skip on + vxworks as well. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * gcc.dg/analyzer/fd-4.c: Define macro to avoid mode_t on + vxworks. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * lib/target-supports.exp (check_effective_target_strndup): New. + * gcc.dg/builtin-dynamic-object-size-0.c: Skip strndup tests + when the function is not available. + * gcc.dg/builtin-dynamic-object-size-1.c: Likewise. + * gcc.dg/builtin-dynamic-object-size-2.c: Likewise. + * gcc.dg/builtin-dynamic-object-size-3.c: Likewise. + * gcc.dg/builtin-dynamic-object-size-4.c: Likewise. + * gcc.dg/builtin-object-size-1.c: Likewise. + * gcc.dg/builtin-object-size-2.c: Likewise. + * gcc.dg/builtin-object-size-3.c: Likewise. + * gcc.dg/builtin-object-size-4.c: Likewise. + +2024-04-18 Tamar Christina <tamar.christina@arm.com> + + PR target/114741 + * gcc.target/aarch64/fneg-abs_2.c: Update codegen. + * gcc.target/aarch64/fneg-abs_4.c: xfail for now. + * gcc.target/aarch64/pr114741.c: New test. + +2024-04-18 Jakub Jelinek <jakub@redhat.com> + + PR libgcc/114755 + * gcc.dg/torture/bitint-69.c: New test. + +2024-04-18 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/114753 + * gcc.dg/pr114753.c: New test. + +2024-04-18 Kewen Lin <linkw@linux.ibm.com> + + PR testsuite/114744 + * gcc.target/powerpc/builtins-6-p9-runnable.c: Adjust for BE by fixing + data_{u,}128, their uses and vec_uc_expected1, also adjust some formats. + +2024-04-18 Haochen Gui <guihaoc@gcc.gnu.org> + + * gcc.target/powerpc/bcd-4.c: Enable the case to be tested on P9. + Enable the case to be run on big endian. Fix function maxbcd and + other misc. problems. + 2024-04-17 Thomas Schwinge <tschwinge@baylibre.com> * lib/target-supports.exp (check_effective_target_vect_long_long): diff --git a/gcc/testsuite/c-c++-common/pr103798-2.c b/gcc/testsuite/c-c++-common/pr103798-2.c index 83cdfaa1660..e7e99c3679e 100644 --- a/gcc/testsuite/c-c++-common/pr103798-2.c +++ b/gcc/testsuite/c-c++-common/pr103798-2.c @@ -27,5 +27,4 @@ main () return 0; } -/* See PR c++/113706 for the xfail. */ -/* { dg-final { scan-assembler-not "memchr" { xfail { c++ && { *-*-solaris2* *-*-vxworks* } } } } } */ +/* { dg-final { scan-assembler-not "memchr" } } */ diff --git a/gcc/testsuite/g++.dg/abi/comdat2.C b/gcc/testsuite/g++.dg/abi/comdat2.C new file mode 100644 index 00000000000..502d00c0582 --- /dev/null +++ b/gcc/testsuite/g++.dg/abi/comdat2.C @@ -0,0 +1,26 @@ +// PR lto/113208 +// { dg-do compile { target { c++11 && { *-*-*gnu* } } } } +// { dg-additional-options "-O2 -fkeep-inline-functions" } +// { dg-final { scan-assembler "_ZN1BI1CEC5ERKS1_,comdat" } } +// { dg-final { scan-assembler-not "_ZN1BI1CEC1ERKS1_,comdat" } } +// { dg-final { scan-assembler-not "_ZN1BI1CEC2ERKS1_,comdat" } } + +template <typename T> +struct A { + int foo () const; + A (int, int); +}; +template <typename T> +struct B : A<T> { + constexpr B (const B &x) : A<T> (1, x.foo ()) {} + B () : A<T> (1, 2) {} +}; +struct C; +struct D : B<C> {}; +void bar (D); + +void +baz (D x) +{ + bar (x); +} diff --git a/gcc/testsuite/g++.dg/abi/comdat5.C b/gcc/testsuite/g++.dg/abi/comdat5.C new file mode 100644 index 00000000000..f6542aa0d4c --- /dev/null +++ b/gcc/testsuite/g++.dg/abi/comdat5.C @@ -0,0 +1,28 @@ +// PR lto/113208 +// { dg-do compile { target { c++11 && { *-*-*gnu* } } } } +// { dg-additional-options "-O2" } +// { dg-final { scan-assembler-not "_ZN1BI1CEC5ERKS1_,comdat" } } +// { dg-final { scan-assembler-not "_ZN1BI1CEC1ERKS1_,comdat" } } +// { dg-final { scan-assembler-not "_ZN1BI1CEC2ERKS1_,comdat" } } + +template <typename T> +struct A { + int foo () const; + A (int, int); +}; +template <typename T> +struct B : A<T> { + constexpr B (const B &x) : A<T> (1, x.foo ()) {} + B () : A<T> (1, 2) {} +}; +struct C; +struct D : B<C> {}; +void bar (D); + +void +baz (D x) +{ + bar (x); +} + +extern template struct B<C>; diff --git a/gcc/testsuite/g++.dg/concepts/diagnostic2.C b/gcc/testsuite/g++.dg/concepts/diagnostic2.C index 6550ed6b3bd..d6f5872de2c 100644 --- a/gcc/testsuite/g++.dg/concepts/diagnostic2.C +++ b/gcc/testsuite/g++.dg/concepts/diagnostic2.C @@ -23,7 +23,11 @@ void baz() { bar<int>(); // { dg-error "no match" } -/* { dg-begin-multiline-output "" } +/* { dg-begin-multiline-output "for no match error" } + bar<int>(); + ~~~~~~~~^~ + { dg-end-multiline-output "" } */ +/* { dg-begin-multiline-output "for required from here message" } bar<int>(); ~~~~~~~~^~ { dg-end-multiline-output "" } */ diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-union8.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-union8.C new file mode 100644 index 00000000000..34c264944b6 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-union8.C @@ -0,0 +1,8 @@ +// PR c++/114709 +// { dg-do compile { target c++11 } } + +struct T1 { int a, b; }; +struct T2 { int c; double d; }; +union U { T1 t1; T2 t2; }; + +constexpr int v = U{{1,2}}.t2.*&T2::c; // { dg-error "accessing 'U::t2'" } diff --git a/gcc/testsuite/g++.dg/cpp0x/inh-ctor39.C b/gcc/testsuite/g++.dg/cpp0x/inh-ctor39.C new file mode 100644 index 00000000000..89c0d8d87a9 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/inh-ctor39.C @@ -0,0 +1,55 @@ +// PR c++/114784 +// { dg-do compile { target c++11 } } +// { dg-additional-options "-O2" } + +template <typename T> +struct A { + [[gnu::always_inline]] A (int t) { foo ().bar (t, {}); } + [[gnu::always_inline]] A (long long t) { foo ().bar (t, {}); } + T foo (); +}; + +struct B : A<B> { + using A<B>::A; + [[gnu::always_inline]] B (long long v) : A (v) {} + template <typename T> + void bar (T &&, int); + char b; +}; + +struct C { + C (int v) : a(v) { } + C (long long v) : a(v) { } + B a; +}; + +static C +baz () +{ + C x(0); + C y(0LL); + return 0; +} + +[[gnu::cold]] int +qux () +{ + baz (); + return 0; +} + +template <typename> +struct D { + template <typename T> + [[gnu::always_inline]] D (T) { d = sizeof (T); } + D(); + int d; +}; +template <typename T> +struct E : D<T> { + using D<T>::D; +}; + +E<char> c = {}; +E<char> d = 1; +E<char> e = 1.0; diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-lifetime7.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-lifetime7.C index 4148f42f7be..a1da4f81201 100644 --- a/gcc/testsuite/g++.dg/cpp1y/constexpr-lifetime7.C +++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-lifetime7.C @@ -87,7 +87,7 @@ constexpr bool n1 = test_access<NonTrivial>(); // { dg-message "in .const constexpr bool n2 = test_modification<NonTrivial>(); // { dg-message "in .constexpr." "" { target c++20 } } constexpr bool n3 = test_scope<NonTrivial>(); // { dg-message "in .constexpr." "" { target c++20 } } constexpr bool n4 = test_destroy_temp<NonTrivial>(); // { dg-message "in .constexpr." "" { target c++20 } } -constexpr bool n5 = test_parameter(NonTrivial{}); // { dg-error "destroying" "" { target c++20 } } +constexpr bool n5 = test_parameter(NonTrivial{}); // { dg-message "in .constexpr." "" { target c++20 } } constexpr bool n6 = test_bindings<NonTrivial>(); #endif diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-111284.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-111284.C new file mode 100644 index 00000000000..eb31fd843e6 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-111284.C @@ -0,0 +1,19 @@ +// PR c++/111284 +// { dg-do compile { target c++17 } } + +struct S { + S () = default; + constexpr S (const S &) noexcept : s{this} {} + constexpr S & operator= (const S &) noexcept { return *this; } + constexpr bool foo () const noexcept { return s == this; } + S *s = this; +}; + +constexpr bool +bar (S x) noexcept +{ + return x.foo (); +} + +static_assert (bar (S {}), ""); +static_assert ([] (S x) { return x.foo (); } (S {}), ""); diff --git a/gcc/testsuite/g++.dg/cpp23/explicit-obj-basic7.C b/gcc/testsuite/g++.dg/cpp23/explicit-obj-basic7.C new file mode 100644 index 00000000000..a474e97fc18 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp23/explicit-obj-basic7.C @@ -0,0 +1,9 @@ +// { dg-do compile { target c++23 } } + +// Shouldn't ICE +struct S { + void a(this long); + void b(this const long); + void c(this long unsigned); + void c(this signed); +}; diff --git a/gcc/testsuite/g++.dg/cpp23/explicit-obj-ops-alloc.C b/gcc/testsuite/g++.dg/cpp23/explicit-obj-ops-alloc.C new file mode 100644 index 00000000000..8a277db7ef5 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp23/explicit-obj-ops-alloc.C @@ -0,0 +1,11 @@ +// PR c++/114078 +// { dg-do compile { target c++23 } } + +using size_t = decltype(sizeof(0)); + +struct S { + void* operator new(this size_t); // { dg-error "explicit object" } + void* operator new[](this size_t); // { dg-error "explicit object" } + void operator delete(this void*); // { dg-error "explicit object" } + void operator delete[](this void*); // { dg-error "explicit object" } +}; diff --git a/gcc/testsuite/g++.dg/cpp26/decomp1.C b/gcc/testsuite/g++.dg/cpp26/decomp1.C new file mode 100644 index 00000000000..b3c241f1d3a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/decomp1.C @@ -0,0 +1,33 @@ +// { dg-do compile { target c++11 } } +// { dg-options "" } + +namespace std { + template<typename T> struct tuple_size; + template<int, typename> struct tuple_element; +} + +struct A { + int i; + template <int I> int& get() { return i; } +}; + +template<> struct std::tuple_size<A> { static const int value = 3; }; +template<int I> struct std::tuple_element<I,A> { using type = int; }; + +struct B { + int i, j; + long long k, l; +} z[6]; + +void +foo (A &a, B &b) +{ + auto [ c [[]], d, e [[maybe_unused]] ] = a; // { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } + auto [ f, h [[maybe_unused]] [[]], i [[]], j ] = b; // { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } + for (auto [ k, l [[maybe_unused]], m, n [[]]] : z) // { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + ; // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } + auto &[o[[]][[]][[]], p[[]], q[[]]] = a; // { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + ; // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } +} diff --git a/gcc/testsuite/g++.dg/cpp26/decomp2.C b/gcc/testsuite/g++.dg/cpp26/decomp2.C new file mode 100644 index 00000000000..582a0fb8a2f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/decomp2.C @@ -0,0 +1,46 @@ +// { dg-do compile { target c++11 } } +// { dg-options "" } + +namespace std { + template<typename T> struct tuple_size; + template<int, typename> struct tuple_element; +} + +struct A { + int i; + template <int I> int& get() { return i; } +}; + +template<> struct std::tuple_size<A> { static const int value = 3; }; +template<int I> struct std::tuple_element<I,A> { using type = int; }; + +struct B { + int i, j; + long long k, l; +} z[6]; + +void +foo (A &a, B &b) +{ + auto [ c [[]], d, e [[gnu::deprecated]] ] = a; // { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } + // { dg-message "declared here" "" { target *-*-* } .-2 } + ++c; + ++d; + ++e; // { dg-warning "'e' is deprecated" } + auto [ f, h [[gnu::deprecated]] [[]], i [[]], j ] = b;// { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } + // { dg-message "declared here" "" { target *-*-* } .-2 } + ++f; + ++h; // { dg-warning "'h' is deprecated" } + ++i; + ++j; + for (auto [ k, l [[gnu::deprecated]], m, n [[]]] : z) // { dg-warning "structured bindings with attributed identifiers only available with" "" { target { c++17 && c++23_down } } } + { // { dg-warning "structured bindings only available with" "" { target c++14_down } .-1 } + // { dg-message "declared here" "" { target *-*-* } .-2 } + ++k; + ++l; // { dg-warning "'l' is deprecated" } + ++m; + ++n; + } +} diff --git a/gcc/testsuite/g++.dg/cpp26/feat-cxx26.C b/gcc/testsuite/g++.dg/cpp26/feat-cxx26.C index d19fca49995..204f8bac47d 100644 --- a/gcc/testsuite/g++.dg/cpp26/feat-cxx26.C +++ b/gcc/testsuite/g++.dg/cpp26/feat-cxx26.C @@ -394,8 +394,8 @@ #ifndef __cpp_structured_bindings # error "__cpp_structured_bindings" -#elif __cpp_structured_bindings != 201606 -# error "__cpp_structured_bindings != 201606" +#elif __cpp_structured_bindings != 202403 +# error "__cpp_structured_bindings != 202403" #endif #ifndef __cpp_template_template_args diff --git a/gcc/testsuite/g++.dg/cpp2a/linkage-spec1.C b/gcc/testsuite/g++.dg/cpp2a/linkage-spec1.C new file mode 100644 index 00000000000..9e8d5979059 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/linkage-spec1.C @@ -0,0 +1,22 @@ +// PR c++/107688 +// P2615R1: Meaningful exports: Newly invalid declarations +// { dg-do compile { target c++11 } } + +extern "C++" template <typename T> struct A {}; + +extern "C++" template <typename T> struct A<T*> {}; + +extern "C++" template <> struct A<int*> {}; +// { dg-error "explicit specializations are not permitted here" "" { target c++20 } .-1 } + +extern "C++" template struct A<int>; +// { dg-error "explicit instantiations are not permitted here" "" { target c++20 } .-1 } + + +// These should all still be valid, though +extern "C++" { + template <typename T> struct B {}; + template <typename T> struct B<T*> {}; + template <> struct B<int*> {}; + template struct B<int>; +} diff --git a/gcc/testsuite/g++.dg/debug/dwarf2/array-3.C b/gcc/testsuite/g++.dg/debug/dwarf2/array-3.C index 8db6133b765..ae04b217e28 100644 --- a/gcc/testsuite/g++.dg/debug/dwarf2/array-3.C +++ b/gcc/testsuite/g++.dg/debug/dwarf2/array-3.C @@ -12,9 +12,9 @@ const S S::array[2] = { S(), S() }; /* Verify that we get only one DW_TAG_subrange_type (plus the abbrev), and one DW_AT_upper_bound (non-abbrev), because the array definition loses the readonly wrapper for the array type because of - the dynamic initializers. The const types are 4: S, S*, int, and - S[4], plus the abbrev. A const version of S[4] doesn't make sense, + the dynamic initializers. The const types are 3: S, S*, and + S[2], plus the abbrev. A const version of S[2] doesn't make sense, but we output it. */ -/* { dg-final { scan-assembler-times " DW_TAG_const_type" 5 } } */ +/* { dg-final { scan-assembler-times " DW_TAG_const_type" 4 } } */ /* { dg-final { scan-assembler-times " DW_TAG_subrange_type" 2 } } */ /* { dg-final { scan-assembler-times " DW_AT_upper_bound" 1 } } */ diff --git a/gcc/testsuite/g++.dg/debug/dwarf2/array-4.C b/gcc/testsuite/g++.dg/debug/dwarf2/array-4.C index 6b3f546c1b5..6133234181a 100644 --- a/gcc/testsuite/g++.dg/debug/dwarf2/array-4.C +++ b/gcc/testsuite/g++.dg/debug/dwarf2/array-4.C @@ -11,6 +11,6 @@ const S array[2] = { S(), S() }; /* Like array-3, but with a non-member array without a separate declaration, to check that we don't issue the nonsensical DW_TAG_const_type used by the member array declaration there. */ -/* { dg-final { scan-assembler-times " DW_TAG_const_type" 4 } } */ +/* { dg-final { scan-assembler-times " DW_TAG_const_type" 3 } } */ /* { dg-final { scan-assembler-times " DW_TAG_subrange_type" 2 } } */ /* { dg-final { scan-assembler-times " DW_AT_upper_bound" 1 } } */ diff --git a/gcc/testsuite/g++.dg/lto/pr113208.h b/gcc/testsuite/g++.dg/lto/pr113208.h new file mode 100644 index 00000000000..7901ede7e92 --- /dev/null +++ b/gcc/testsuite/g++.dg/lto/pr113208.h @@ -0,0 +1,10 @@ +template <typename _Tp> struct _Vector_base { + int g() const; + _Vector_base(int, int); +}; +template <typename _Tp> +struct vector : _Vector_base<_Tp> { + CONSTEXPR vector(const vector &__x) + : _Vector_base<_Tp>(1, __x.g()) {} + vector() : _Vector_base<_Tp>(1, 2) {} +}; diff --git a/gcc/testsuite/g++.dg/lto/pr113208_0.C b/gcc/testsuite/g++.dg/lto/pr113208_0.C new file mode 100644 index 00000000000..dbaca558d31 --- /dev/null +++ b/gcc/testsuite/g++.dg/lto/pr113208_0.C @@ -0,0 +1,13 @@ +// { dg-lto-do link } +// { dg-lto-options { {-O1 -std=c++20 -flto}} } +// { dg-extra-ld-options "-r -nostdlib -flinker-output=nolto-rel" } +// { dg-require-linker-plugin "" } + +#define CONSTEXPR constexpr +#include "pr113208.h" + +struct QualityValue; +struct k : vector<QualityValue> {}; + +void m(k); +void n(k i) { m(i); } diff --git a/gcc/testsuite/g++.dg/lto/pr113208_1.C b/gcc/testsuite/g++.dg/lto/pr113208_1.C new file mode 100644 index 00000000000..f925086b527 --- /dev/null +++ b/gcc/testsuite/g++.dg/lto/pr113208_1.C @@ -0,0 +1,6 @@ +#define CONSTEXPR +#include "pr113208.h" + +struct QualityValue; +vector<QualityValue> values1; +vector<QualityValue> values{values1}; diff --git a/gcc/testsuite/g++.dg/modules/auto-4_a.H b/gcc/testsuite/g++.dg/modules/auto-4_a.H new file mode 100644 index 00000000000..0f7cd262dfa --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/auto-4_a.H @@ -0,0 +1,14 @@ +// PR c++/114795 +// { dg-additional-options "-fmodule-header" } +// { dg-module-cmi {} } + +template<class T> +struct A { + auto f() { return T(); } +}; + +template<class T> +void g() { + A<int> a; + a.f(); +} diff --git a/gcc/testsuite/g++.dg/modules/auto-4_b.C b/gcc/testsuite/g++.dg/modules/auto-4_b.C new file mode 100644 index 00000000000..378684ef6d0 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/auto-4_b.C @@ -0,0 +1,15 @@ +// PR c++/114795 +// { dg-additional-options "-fmodules-ts -fno-module-lazy" } + +template<class T> +struct A { + auto f() { return T(); } +}; + +A<int> a; + +import "auto-4_a.H"; + +int main() { + g<int>(); // { dg-bogus "before deduction of 'auto'" "" { target *-*-* } 0 } +} diff --git a/gcc/testsuite/g++.dg/modules/contracts-1_a.C b/gcc/testsuite/g++.dg/modules/contracts-1_a.C index f991ef8644e..723726451f4 100644 --- a/gcc/testsuite/g++.dg/modules/contracts-1_a.C +++ b/gcc/testsuite/g++.dg/modules/contracts-1_a.C @@ -8,7 +8,7 @@ export module foo; // { dg-module-cmi foo } export int violation_count{0}; -extern "C++" export void handle_contract_violation(const std::experimental::contract_violation &violation) +export extern "C++" void handle_contract_violation(const std::experimental::contract_violation &violation) { violation_count++; printf("violation_count: %d\n", violation_count); diff --git a/gcc/testsuite/g++.dg/modules/contracts-2_a.C b/gcc/testsuite/g++.dg/modules/contracts-2_a.C index 828d680d2a0..3d78c412d46 100644 --- a/gcc/testsuite/g++.dg/modules/contracts-2_a.C +++ b/gcc/testsuite/g++.dg/modules/contracts-2_a.C @@ -12,7 +12,7 @@ export module foo; export int violation_count{0}; export int violation_line_sum{0}; -extern "C++" export void handle_contract_violation(const std::experimental::contract_violation &violation) +export extern "C++" void handle_contract_violation(const std::experimental::contract_violation &violation) { violation_count++; violation_line_sum += violation.line_number () * violation_count; diff --git a/gcc/testsuite/g++.dg/modules/contracts-3_a.C b/gcc/testsuite/g++.dg/modules/contracts-3_a.C index a4f03d35842..b931ec0ddf7 100644 --- a/gcc/testsuite/g++.dg/modules/contracts-3_a.C +++ b/gcc/testsuite/g++.dg/modules/contracts-3_a.C @@ -8,7 +8,7 @@ export module foo; // { dg-module-cmi foo } export int violation_count{0}; -extern "C++" export void handle_contract_violation(const std::experimental::contract_violation &violation) +export extern "C++" void handle_contract_violation(const std::experimental::contract_violation &violation) { violation_count++; printf("violation_count: %d\n", violation_count); diff --git a/gcc/testsuite/g++.dg/modules/contracts-4_a.C b/gcc/testsuite/g++.dg/modules/contracts-4_a.C index f269e6c2078..a135f50fb7d 100644 --- a/gcc/testsuite/g++.dg/modules/contracts-4_a.C +++ b/gcc/testsuite/g++.dg/modules/contracts-4_a.C @@ -9,7 +9,7 @@ export module foo; // { dg-module-cmi foo } export int violation_count{0}; -extern "C++" export void handle_contract_violation(const std::experimental::contract_violation &violation) +export extern "C++" void handle_contract_violation(const std::experimental::contract_violation &violation) { violation_count++; printf("violation_count: %d\n", violation_count); diff --git a/gcc/testsuite/g++.dg/modules/enum-12.C b/gcc/testsuite/g++.dg/modules/enum-12.C index 57eeb85d92a..064f220dedf 100644 --- a/gcc/testsuite/g++.dg/modules/enum-12.C +++ b/gcc/testsuite/g++.dg/modules/enum-12.C @@ -4,7 +4,7 @@ export module foo; namespace std { - enum class align_val_t : decltype(sizeof(int)) {}; // { dg-error "different module" } + enum class align_val_t : decltype(sizeof(int)) {}; // { dg-error "conflicts with builtin" } } // { dg-prune-output "not writing module" } diff --git a/gcc/testsuite/g++.dg/modules/export-3.C b/gcc/testsuite/g++.dg/modules/export-3.C new file mode 100644 index 00000000000..76765fd2b2f --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/export-3.C @@ -0,0 +1,30 @@ +// P2615R1 invalid declarations +// PR c++/107688 +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi !bad } + +export module bad; + +extern "C++" export void foo(); // { dg-error "export-declarations are not permitted here" "" { target c++20 } } + +export template <typename T> struct S {}; + +export template <typename T> struct S<T*> {}; // { dg-error "partial specialization in unbraced export-declaration" } + +export template <> struct S<int*> {}; // { dg-error "explicit specializations are not permitted here" } + +export template struct S<int>; // { dg-error "explicit instantiations are not permitted here" } + +template <> export struct S<double>; // { dg-error "expected unqualified-id" } + +export export int x; // { dg-error ".export. may only occur once" } + +export { export int y; } // { dg-error ".export. may only occur once" } + +namespace { + export namespace ns {} // { dg-error "internal linkage" } +} + +export namespace {} // { dg-error "internal linkage" } + +// { dg-prune-output "not writing module" } diff --git a/gcc/testsuite/g++.dg/modules/export-4_a.C b/gcc/testsuite/g++.dg/modules/export-4_a.C new file mode 100644 index 00000000000..5f99577dc99 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/export-4_a.C @@ -0,0 +1,23 @@ +// P2615R1 valid declarations +// PR c++/107688 +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M } + +export module M; + +export {} +export { static_assert(true); } + +export namespace Empty {} +export using namespace Empty; + +export { + template <typename T> struct S {}; + template <typename T> struct S<T*> { using a = int; }; + template <> struct S<int*> { using b = int; }; + template struct S<int>; +} + +extern "C++" { + export void foo(); +} diff --git a/gcc/testsuite/g++.dg/modules/export-4_b.C b/gcc/testsuite/g++.dg/modules/export-4_b.C new file mode 100644 index 00000000000..4d721119916 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/export-4_b.C @@ -0,0 +1,13 @@ +// PR c++/107688 +// { dg-additional-options "-fmodules-ts" } + +import M; + +using namespace Empty; + +int main() { + S<int> x; + S<int*>::b y; + S<int**>::a z; + foo(); +} diff --git a/gcc/testsuite/g++.dg/modules/friend-5_b.C b/gcc/testsuite/g++.dg/modules/friend-5_b.C index f043d7a340d..6b561265155 100644 --- a/gcc/testsuite/g++.dg/modules/friend-5_b.C +++ b/gcc/testsuite/g++.dg/modules/friend-5_b.C @@ -4,7 +4,7 @@ export module bar; import foo; -class B { // { dg-error "in a different module" } +class B { // { dg-error "conflicts with import" } B() { object.value = 42; } A object; }; diff --git a/gcc/testsuite/g++.dg/modules/friend-8_a.H b/gcc/testsuite/g++.dg/modules/friend-8_a.H new file mode 100644 index 00000000000..b07ea25adfb --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/friend-8_a.H @@ -0,0 +1,23 @@ +// PR c++/114889 +// { dg-additional-options "-fmodule-header" } +// { dg-module-cmi {} } + +template<class, class> +struct _Hashtable; + +template<class _Key, class _Val> +struct _Map_base { + void f() { + _Hashtable<_Key, _Val> __h; + __h._M_hash_code(0); + } +}; + +template<class _Key, class _Value> +struct _Hashtable { + template<class, class> friend struct _Map_base; +protected: + void _M_hash_code(int); +}; + +inline _Hashtable<int, int> m; diff --git a/gcc/testsuite/g++.dg/modules/friend-8_b.C b/gcc/testsuite/g++.dg/modules/friend-8_b.C new file mode 100644 index 00000000000..b04280bc91a --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/friend-8_b.C @@ -0,0 +1,9 @@ +// PR c++/114889 +// { dg-additional-options "-fmodules-ts" } + +import "friend-8_a.H"; + +int main() { + _Map_base<int, int> m; + m.f(); +} diff --git a/gcc/testsuite/g++.dg/modules/lang-1_c.C b/gcc/testsuite/g++.dg/modules/lang-1_c.C index e3b939df373..b3908ed6188 100644 --- a/gcc/testsuite/g++.dg/modules/lang-1_c.C +++ b/gcc/testsuite/g++.dg/modules/lang-1_c.C @@ -6,7 +6,7 @@ extern "C++" } extern "C" -import "lang-1_a.H"; // { dg-error "cannot appear directly" } + import "lang-1_a.H"; // OK since p2615r1 extern "C" int cfunc (int); // { dg-error "conflicting declaration" } extern "C" int cxxfunc (int); diff --git a/gcc/testsuite/g++.dg/modules/pr101582-1.C b/gcc/testsuite/g++.dg/modules/pr101582-1.C index 1d3a3fcb6fa..ec7e44e1f43 100644 --- a/gcc/testsuite/g++.dg/modules/pr101582-1.C +++ b/gcc/testsuite/g++.dg/modules/pr101582-1.C @@ -2,8 +2,10 @@ // { dg-additional-options "-fmodules-ts" } export module pr101582; // { dg-module-cmi "pr101582" } -export ; // { dg-error "export declaration does not declare anything" "" { xfail *-*-* } } -export [[]]; // { dg-error "export declaration does not declare anything" "" { xfail *-*-* } } -export // { dg-error "export declaration does not declare anything" "" { xfail *-*-* } } + +// These are all legal since P2615R1. +export ; +export [[]]; +export { } diff --git a/gcc/testsuite/g++.dg/modules/pr99023_a.X b/gcc/testsuite/g++.dg/modules/pr99023_a.X index c872d15f792..507e9569535 100644 --- a/gcc/testsuite/g++.dg/modules/pr99023_a.X +++ b/gcc/testsuite/g++.dg/modules/pr99023_a.X @@ -1,4 +1,5 @@ // PR c++/99023, ICE +// { dg-require-effective-target c++20_only } // { dg-additional-options {-x c++-system-header initializer_list -fmodules-ts --param ggc-min-expand=0} } // { dg-prune-output {linker input file unused} } diff --git a/gcc/testsuite/g++.dg/modules/pr99023_b.X b/gcc/testsuite/g++.dg/modules/pr99023_b.X index ca5f32e5bcc..59d32bee8d5 100644 --- a/gcc/testsuite/g++.dg/modules/pr99023_b.X +++ b/gcc/testsuite/g++.dg/modules/pr99023_b.X @@ -1,4 +1,5 @@ // PR c++/99023, ICE +// { dg-require-effective-target c++20_only } // { dg-additional-options {-x c++-system-header iostream -fmodules-ts -flang-info-include-translate=<initializer_list> --param ggc-min-expand=0} } // { dg-prune-output {linker input file unused} } diff --git a/gcc/testsuite/g++.dg/modules/shadow-1_b.C b/gcc/testsuite/g++.dg/modules/shadow-1_b.C index 646381237ac..7f6a3182998 100644 --- a/gcc/testsuite/g++.dg/modules/shadow-1_b.C +++ b/gcc/testsuite/g++.dg/modules/shadow-1_b.C @@ -1,8 +1,5 @@ // { dg-additional-options -fmodules-ts } import shadow; -// unfortunately not the exact same diagnostic in both cases :( - void stat (); // { dg-error "conflicts with import" } - -struct stat {}; // { dg-error "in a different module" } +struct stat {}; // { dg-error "conflicts with import" } diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-10_a.C b/gcc/testsuite/g++.dg/modules/tpl-friend-10_a.C new file mode 100644 index 00000000000..7547326e554 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-10_a.C @@ -0,0 +1,15 @@ +// PR c++/105320 +// { dg-additional-options "-fmodules-ts -Wno-global-module" } +// { dg-module-cmi test_support } + +module; +template<class> struct _Sp_atomic; +template<class> struct shared_ptr { + template<class> friend struct _Sp_atomic; + using atomic_type = _Sp_atomic<int>; +}; +export module test_support; +export +template<class T> struct A { + shared_ptr<T> data; +}; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-10_b.C b/gcc/testsuite/g++.dg/modules/tpl-friend-10_b.C new file mode 100644 index 00000000000..6b88ee4258b --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-10_b.C @@ -0,0 +1,5 @@ +// PR c++/105320 +// { dg-additional-options "-fmodules-ts" } + +import test_support; +A<int> a; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-10_c.C b/gcc/testsuite/g++.dg/modules/tpl-friend-10_c.C new file mode 100644 index 00000000000..90bcd18a45e --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-10_c.C @@ -0,0 +1,7 @@ +// PR c++/105320 +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi user:part } + +export module user:part; +import test_support; +export A<int> b; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-10_d.C b/gcc/testsuite/g++.dg/modules/tpl-friend-10_d.C new file mode 100644 index 00000000000..861d19c9eaa --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-10_d.C @@ -0,0 +1,8 @@ +// PR c++/105320 +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi user } + +export module user; +export import :part; +import test_support; +A<double> c; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-11_a.C b/gcc/testsuite/g++.dg/modules/tpl-friend-11_a.C new file mode 100644 index 00000000000..f29eebd1a7f --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-11_a.C @@ -0,0 +1,14 @@ +// PR c++/114275 +// { dg-additional-options "-fmodules-ts -Wno-global-module" } +// { dg-module-cmi M } + +module; + +template <typename... _Elements> struct T; + +template <typename H> struct T<H> { + template <typename...> friend struct T; +}; + +export module M; +export template <typename=void> void fun() { T<int> t; } diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-11_b.C b/gcc/testsuite/g++.dg/modules/tpl-friend-11_b.C new file mode 100644 index 00000000000..5bf79998139 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-11_b.C @@ -0,0 +1,5 @@ +// PR c++/114275 +// { dg-additional-options "-fmodules-ts" } + +import M; +int main() { fun(); } diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-12_a.C b/gcc/testsuite/g++.dg/modules/tpl-friend-12_a.C new file mode 100644 index 00000000000..216dbf62c71 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-12_a.C @@ -0,0 +1,10 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M:A } + +module M:A; + +template <typename T> struct A { + template <typename U> friend struct B; +private: + int x = 42; +}; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-12_b.C b/gcc/testsuite/g++.dg/modules/tpl-friend-12_b.C new file mode 100644 index 00000000000..26e1c38b518 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-12_b.C @@ -0,0 +1,9 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M:B } + +export module M:B; +import :A; + +export template <typename U> struct B { + int foo(A<U> a) { return a.x; } +}; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-12_c.C b/gcc/testsuite/g++.dg/modules/tpl-friend-12_c.C new file mode 100644 index 00000000000..e44c2819cfd --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-12_c.C @@ -0,0 +1,10 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M:C } + +export module M:C; +import :A; + +template <typename T> struct B; +export template <typename T, typename U> int bar(B<T> t, U u) { + return t.foo(u); +} diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-12_d.C b/gcc/testsuite/g++.dg/modules/tpl-friend-12_d.C new file mode 100644 index 00000000000..9a575ad5046 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-12_d.C @@ -0,0 +1,8 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M } + +export module M; +export import :B; +export import :C; + +export int go_in_module(); diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-12_e.C b/gcc/testsuite/g++.dg/modules/tpl-friend-12_e.C new file mode 100644 index 00000000000..329d1e8b263 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-12_e.C @@ -0,0 +1,7 @@ +// { dg-additional-options "-fmodules-ts" } + +module M; + +int go_in_module() { + return bar(B<int>{}, A<int>{}); +} diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-12_f.C b/gcc/testsuite/g++.dg/modules/tpl-friend-12_f.C new file mode 100644 index 00000000000..c9855663fbd --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-12_f.C @@ -0,0 +1,8 @@ +// { dg-additional-options "-fmodules-ts" } + +import M; + +int main() { + B<double> b{}; + go_in_module(); +} diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_a.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_a.C new file mode 100644 index 00000000000..8c972776d60 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_a.C @@ -0,0 +1,13 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M } + +export module M; +export template <typename> struct A { + friend struct S; + template <typename> friend struct T; +}; + +export template <typename> struct B { + friend void f(); + template <typename> friend void g(); +}; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_b.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_b.C new file mode 100644 index 00000000000..0e27e97b113 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_b.C @@ -0,0 +1,11 @@ +// { dg-additional-options "-fmodules-ts" } + +import M; + +A<int> a; +struct S {}; // { dg-error "conflicts with import" } +template <typename> struct T {}; // { dg-error "conflicts with import" } + +B<int> c; +void f() {} // { dg-error "conflicts with import" } +template <typename> void g() {} // { dg-error "conflicts with import" } diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_c.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_c.C new file mode 100644 index 00000000000..3464aa26bf8 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_c.C @@ -0,0 +1,13 @@ +// { dg-additional-options "-fmodules-ts" } + +import M; + +struct S {}; // { dg-error "conflicts with import" } +template <typename> struct T {}; // { dg-message "previously declared" } +A<int> a; // { dg-message "required from here" } + +void f() {} // { dg-message "previously declared" } +template <typename> void g() {} // { dg-message "previously declared" } +B<int> b; // { dg-message "required from here" } + +// { dg-error "conflicting declaration" "" { target *-*-* } 0 } diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_d.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_d.C new file mode 100644 index 00000000000..5b935474ab2 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_d.C @@ -0,0 +1,7 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi X } + +export module X; +export import M; +A<int> ax; +B<int> bx; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_e.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_e.C new file mode 100644 index 00000000000..afbd0a39c23 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_e.C @@ -0,0 +1,18 @@ +// { dg-additional-options "-fmodules-ts" } + +// 'import X' does not correctly notice that S has already been declared. +struct S {}; // { dg-message "previously declared" "" { xfail *-*-* } } +template <typename> struct T {}; // { dg-message "previously declared" } +void f() {} // { dg-message "previously declared" } +template <typename T> void g() {} // { dg-message "previously declared" } + +import X; +A<double> a2; // { dg-message "required from here" } +B<double> b2; // { dg-message "required from here" } + +// specifically, S and T are defined in M, not X, despite the instantiation being in X +// { dg-error "conflicting declaration \[^\n\r\]* S@M" "" { xfail *-*-* } 0 } +// { dg-error "conflicting declaration \[^\n\r\]* T@M" "" { target *-*-* } 0 } +// and similarly for f and g +// { dg-error "conflicting declaration \[^\n\r\]* f@M" "" { target *-*-* } 0 } +// { dg-error "conflicting declaration \[^\n\r\]* g@M" "" { target *-*-* } 0 } diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_f.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_f.C new file mode 100644 index 00000000000..287f95c7bdc --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_f.C @@ -0,0 +1,7 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi Y } + +export module Y; +export import M; +A<double> ay; +B<double> by; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-13_g.C b/gcc/testsuite/g++.dg/modules/tpl-friend-13_g.C new file mode 100644 index 00000000000..b7da60f2322 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-13_g.C @@ -0,0 +1,11 @@ +// { dg-additional-options "-fmodules-ts" } + +import X; +import Y; + +// This should happily refer to the same S and T +// as already instantiated in both X and Y +A<long> az; + +// And same for f and g +B<long> bz; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-14_a.C b/gcc/testsuite/g++.dg/modules/tpl-friend-14_a.C new file mode 100644 index 00000000000..6912512ecf7 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-14_a.C @@ -0,0 +1,8 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M } + +export module M; + +export extern "C++" template <typename> struct A { + template <typename> friend struct B; +}; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-14_b.C b/gcc/testsuite/g++.dg/modules/tpl-friend-14_b.C new file mode 100644 index 00000000000..5f8aa7fd62e --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-14_b.C @@ -0,0 +1,8 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi X } + +export module X; +export import M; + +A<int> x; +export extern "C++" template <typename T> struct B { using type = T; }; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-14_c.C b/gcc/testsuite/g++.dg/modules/tpl-friend-14_c.C new file mode 100644 index 00000000000..8d89298878a --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-14_c.C @@ -0,0 +1,7 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi Y } + +export module Y; +export import M; + +A<double> x; diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-14_d.C b/gcc/testsuite/g++.dg/modules/tpl-friend-14_d.C new file mode 100644 index 00000000000..7a842586b62 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-14_d.C @@ -0,0 +1,9 @@ +// { dg-additional-options "-fmodules-ts" } + +import X; +import Y; + +int main() { + A<long> a; + B<int>::type r = 10; +} diff --git a/gcc/testsuite/g++.dg/modules/tpl-friend-9.C b/gcc/testsuite/g++.dg/modules/tpl-friend-9.C new file mode 100644 index 00000000000..c7216f0f8c1 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/tpl-friend-9.C @@ -0,0 +1,13 @@ +// PR c++/114275 +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M } + +export module M; + +template<class> struct A { + template<class> friend struct B; + friend void C(); +}; +A<int> a; +void C() {} +template<class> struct B { }; diff --git a/gcc/testsuite/g++.dg/modules/using-15_a.C b/gcc/testsuite/g++.dg/modules/using-15_a.C new file mode 100644 index 00000000000..3f4bb6c5914 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/using-15_a.C @@ -0,0 +1,14 @@ +// PR c++/114868 +// { dg-additional-options "-fmodules-ts -Wno-global-module" } +// { dg-module-cmi M:a } + +module; +namespace foo { + void a(); +} +export module M:a; + +namespace bar { + // propagate usings from partitions + export using foo::a; +} diff --git a/gcc/testsuite/g++.dg/modules/using-15_b.C b/gcc/testsuite/g++.dg/modules/using-15_b.C new file mode 100644 index 00000000000..4b0cb745157 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/using-15_b.C @@ -0,0 +1,6 @@ +// PR c++/114868 +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M } + +export module M; +export import :a; diff --git a/gcc/testsuite/g++.dg/modules/using-15_c.C b/gcc/testsuite/g++.dg/modules/using-15_c.C new file mode 100644 index 00000000000..74dd10a5413 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/using-15_c.C @@ -0,0 +1,8 @@ +// PR c++/114868 +// { dg-additional-options "-fmodules-ts" } +import M; + +int main() { + bar::a(); + foo::a(); // { dg-error "not been declared" } +} diff --git a/gcc/testsuite/g++.dg/modules/using-16_a.C b/gcc/testsuite/g++.dg/modules/using-16_a.C new file mode 100644 index 00000000000..25d8bca5d1c --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/using-16_a.C @@ -0,0 +1,11 @@ +// { dg-additional-options "-fmodules-ts" } +// { dg-module-cmi M:S } + +export module M:S; + +namespace foo { + // propagate hidden from partitions + export struct S { + friend void f(S); + }; +}; diff --git a/gcc/testsuite/g++.dg/modules/using-16_b.C b/gcc/testsuite/g++.dg/modules/using-16_b.C new file mode 100644 index 00000000000..3f704a913f4 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/using-16_b.C @@ -0,0 +1,12 @@ +// { dg-additional-options "-fmodules-ts -Wno-global-module" } +// { dg-module-cmi M } + +module; +namespace bar { + void f(int); +} +export module M; +export import :S; +namespace foo { + export using bar::f; +} diff --git a/gcc/testsuite/g++.dg/modules/using-16_c.C b/gcc/testsuite/g++.dg/modules/using-16_c.C new file mode 100644 index 00000000000..5e46cd16013 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/using-16_c.C @@ -0,0 +1,11 @@ +// { dg-additional-options "-fmodules-ts" } +import M; + +int main() { + // this should be hidden and fail + foo::f(foo::S{}); // { dg-error "cannot convert" } + + // but these should be legal + foo::f(10); + f(foo::S{}); +} diff --git a/gcc/testsuite/g++.dg/opt/const-builtin1.C b/gcc/testsuite/g++.dg/opt/const-builtin1.C new file mode 100644 index 00000000000..8b9987271c0 --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/const-builtin1.C @@ -0,0 +1,33 @@ +// PR c++/113706 +/* A variant of the pr103798-2.c test with const void * memchr return type, as + specified by the C++ standard. */ +/* { dg-do run } */ +/* { dg-options "-O2 -fdump-tree-optimized -save-temps" } */ + +extern "C" const void *memchr (const void *, int, __SIZE_TYPE__); // { dg-bogus "built-in" } + +__attribute__ ((weak)) +int +f (int a) +{ + return memchr ("aE", a, 2) != 0; +} + +__attribute__ ((weak)) +int +g (char a) +{ + return a == 'a' || a == 'E'; +} + +int +main () +{ + for (int i = 0; i < 255; i++) + if (f (i + 256) != g (i + 256)) + __builtin_abort (); + + return 0; +} + +/* { dg-final { scan-assembler-not "memchr" } } */ diff --git a/gcc/testsuite/g++.dg/template/crash71.C b/gcc/testsuite/g++.dg/template/crash71.C index 3ac862ed81b..949f46eaf0d 100644 --- a/gcc/testsuite/g++.dg/template/crash71.C +++ b/gcc/testsuite/g++.dg/template/crash71.C @@ -1,3 +1,5 @@ // PR c++/30659 -extern "C" template A<char> foo(); // { dg-error "forbids|static data|expected|template" } +extern "C" template A<char> foo(); +// { dg-error "forbids|static data|expected|template" "" { target c++17_down } .-1 } +// { dg-error "permitted|forbids|static data|expected|template" "" { target c++20 } .-2 } diff --git a/gcc/testsuite/g++.dg/template/error60a.C b/gcc/testsuite/g++.dg/template/error60a.C new file mode 100644 index 00000000000..9d0f170c18b --- /dev/null +++ b/gcc/testsuite/g++.dg/template/error60a.C @@ -0,0 +1,46 @@ +// A version of error60.C that first issues an unrelated error +// to cause the pretty printer prefix to get set, verifying we +// still print the source line for the "required from here" +// message correctly in that case. +// { dg-options "-fdiagnostics-show-caret" } + +template <typename Foo> +struct my_pointer +{ + my_pointer (Foo *ptr) // { dg-message " initializing argument 1" } + : m_ptr (ptr) + {} + + Foo *m_ptr; +}; + +template <typename Foo> +void test (Foo val) +{ + my_pointer<Foo> ptr (val); // { dg-error "invalid conversion from 'int' to 'int\\*'" } +} + +void usage () +{ + unrelated_error; // { dg-error "not declared" } + test<int> (42); // { dg-message " required from here" } + /* { dg-begin-multiline-output "" } + unrelated_error; + ^~~~~~~~~~~~~~~ + { dg-end-multiline-output "" } */ + /* { dg-begin-multiline-output "" } + test<int> (42); + ~~~~~~~~~~^~~~ + { dg-end-multiline-output "" } */ +} + + /* { dg-begin-multiline-output "" } + my_pointer (Foo *ptr) + ~~~~~^~~ + { dg-end-multiline-output "" } */ + /* { dg-begin-multiline-output "" } + my_pointer<Foo> ptr (val); + ^~~ + | + int + { dg-end-multiline-output "" } */ diff --git a/gcc/testsuite/g++.dg/template/sizeof19.C b/gcc/testsuite/g++.dg/template/sizeof19.C new file mode 100644 index 00000000000..a1467995a9b --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sizeof19.C @@ -0,0 +1,8 @@ +// PR c++/114888 + +template<class> +struct A { + struct B {} *b; + static const int c = sizeof (b) / sizeof (b[0]); +}; +const int d = A<int>::c; diff --git a/gcc/testsuite/g++.target/i386/pr114810.C b/gcc/testsuite/g++.target/i386/pr114810.C new file mode 100644 index 00000000000..a7b3643ca21 --- /dev/null +++ b/gcc/testsuite/g++.target/i386/pr114810.C @@ -0,0 +1,861 @@ +// PR target/114810 +// { dg-do compile { target { { { *-*-linux* } && ia32 } && c++17 } } } +// { dg-options "-mstackrealign -O2 -mbmi -fno-exceptions -fno-plt -march=x86-64 -w" } +// { dg-additional-options "-fpie" { target pie } } + +enum E1 { a, dp, b, jm, c, dq, d, mj, e, dr, f, jn, h, dt, j, nt, l, du, m, jo, n, dv, o, mk, p, dw, q, jp, s, dx, t, ol, u, dy, v, jq, w }; +enum dz { x, ml, y }; +struct ea { short g; } z, jr; +long long aa; +struct eb { ea ab; ea dp[]; }; +enum ac { }; +typedef enum { } nu; +struct ad { ac k; }; +unsigned ec (long); +struct ae; +int js (ae); +unsigned af (); +struct ed; +template < int ag > struct ee { using ah = ed[ag]; }; +template < int ag > struct array { typename ee < ag >::ah ai; ed & operator[] (int aj) { return ai[aj]; } }; +struct { void dp (...); } ak; +void ef (int); +template < typename al > struct jt { al & operator[] (short); }; +struct am { void operator= (bool); }; +struct an { am operator[] (unsigned); }; +template < typename, unsigned, unsigned >using eg = an; +struct ao; +struct ae { ae (ao *); }; +struct mm { mm (); mm (int); }; +enum ap { }; +enum eh { }; +bool aq, ju, ar, ei, nv, as, ej, at; +struct jv +{ + jv (eh au):dp (au) {} + jv (); + operator eh (); + unsigned av () + { + aq = dp & 7; + return dp * (aq ? : 4); + } + unsigned ek () + { + int aw; + bool mn = dp & 7; + aw = dp * (mn ? : 4); + return aw + 3 >> 2; + } + eh dp; +} ax, el, ay, jw, az, em, ba, om; +struct ed +{ + ed ():bb (), dp () {} + int bc () { return bb; } + jv en () { return (eh) dp; } + unsigned ek () + { + jv bd; + bd = (eh) dp; + return bd.ek (); + } + ap jx (); + unsigned bb:24; + int dp:8; +}; +struct be { short dp = 0; } bf, eo; +struct bg +{ + bg (); + bg (ed r) + { + dp.bh = r; + if (r.bc ()) + mo = true; + else + bi = true; + } + static bg ep (int); + bg (be); + struct { ed bh; } dp; + union { char mo:1; char bi:1; short bj = 0; }; +} jy, bk, eq, bl, mp, bm, er; +struct bn +{ + explicit bn (ed bo):bh (bo) {} + ed dp (); + ed bh; + be es; + char bj = 0; +}; +struct bp +{ + eg < int, 6, 4 > dp; +}; +jt < bg > bq; +jt < bn > definitions; +struct ao +{ + bp & br (); +}; +enum jz:short; +template < typename > using bs = ae; +ao *et (); +short bt, nw; +struct bu +{ + int dp; +}; +dz bv; +unsigned eu; +struct bw +{ + ac k; + unsigned dp; +} *bx; +bool ka (); +struct by +{ + bool dp; +}; +typedef enum +{ bz, ev } ca; +typedef enum +{ + mq, cb, ew, cc, kb, cd, ex, ce +} on; +typedef struct cf +{ + on jx; + char dp; + char cg; +} kc; +struct ch +{ + kc *dp; +}; +typedef enum +{ + ci, ey, cj, mr, ck, ez, cl, kd, cm, fa, cn, nx, co, fb, cp, ke, cq, fc, + cr, ms, cs, fd, ct, kf, cu, fe, cv, os, cw, ff, cx, kg, cy, fg, cz, mt, da +} fh; +typedef struct { cf db; fh dp; kc dc; ch kh[]; } dd; +nu fi (); +typedef enum +{ de, ny } fj; +typedef struct { fj jx; } df; +typedef struct { by dp; } dg; +dg *ki; +struct dh +{ + ad *dp; + eb *args; + bw *di; + bu *block; + struct + { + struct + { + bool fk; + } dj; + bool dp; + bool dk; + } mu; + ed dl[84]; +}; +ed fl (dh *, ea); +enum dm +{ }; +dm kj (); +enum +{ dn }; +struct fm +{ + operator ed (); + operator bg (); + bn dc (); + ao *operator-> (); +}; +struct oo +{ + oo (ed); + oo (bg); + oo (fm); +}; +struct fn +{ + enum dp + { + kk, fo, mv, fp, kl, fq + }; + jv lm; + fn (bw *, bu *); + fn fr (); + ed bo (jv); + bn dc (); + bn dc (be); + ed km (oo); + fm copy (bn, oo); + fm fs (); + fm nz (bn, oo, oo, oo); + void ft (oo); + void ft (E1, bn, oo); + fm ft (E1, bn, oo, oo); + void ft (E1, bn, oo, oo, oo); + void ft (E1, bn, bn, oo); + void kn (E1, bn, oo); + fm kn (dp, bn, oo); + fm kn (dp, bn, bn, oo); + fm fu (E1, bn, oo, oo); + fm fu (E1, bn, bn, oo, oo); + fm fu (dp, bn, bn, oo, oo); + fm mw (E1, bn, int); + fm fv (E1, bn, oo, oo); + fm fv (dp, bn, oo, oo); + void dp (E1, bn, mm, bool = false, bool = false, bool = false); + void dp (E1, bn, oo, oo, mm = false, bool = false, bool = false); + fm ds (E1, bn, oo, short, char = 0, bool = false); + fm ds (E1, bn, oo, oo, short = 0, char = 0, bool = false); + fm ko (E1, bn, oo, oo); + fm ko (E1, bn, oo, oo, oo); + fm fw (E1, bn, oo, oo); + fm dp (E1, bn, oo, oo, oo); + fm oy (E1, bn, oo, short, char, char, bool, bool); + fm fx (E1, bn, oo, oo, oo); +}; +int kp, fy, mx, fz, kq, ga, oa, gb; +int *kr, *gc, *my; +long gd; +ca ks; +namespace +{ + void ge (dh *, char *, unsigned, cf *, char *); + ed kt (dh *, kc *); + ed gf (dh *, ed, bg = bg (), bg = bg ()); + void mz (bool); + ed gg (dh *, fn, ed, ed); + ed ku (dh *, fn, ed, unsigned, bool); + ed gh (dh *, ed); + void op (dh *, ed, int, ed); + ed op (dh *, ed, int, jv); + void gi (dh *, ed, unsigned); + void kv (dh *, ed, bg, ed); + ed gj (dh *, ed, ed = ed ()); + void na (dh *, int *); + void gk (dh *, ed, ed); + ed kw (dh *); + bool gl (dh *); + void ob (dh *, dd *); + void gm (dh * ctx, dd * db) + { + fn bld (ctx->di, ctx->block); + ed dst = kt (ctx, &db->dc), dp = kt (ctx, db->kh[0].dp), kx, gn; + unsigned count = db->dc.dp; + if (db->dc.cg) + count *= 2; + if (kr && db->dc.cg) + { + long dp = count == 4 ? 0 : (1ull << (count & 3)) - 1 << mx; + if ((aa | dp) == aa && mx + count) + { + array < 16 > elems; + bs < ao > gn + { + et ()}; + unsigned g = ec (aa & mx ? : 1 << mx - 1); + for (unsigned i; count; ++i) + { + elems[i] = fl (ctx, ctx->args->dp[g]); + bq[i] = elems[i]; + } + definitions[0] = bn (dst); + int dp = js (gn), ot = dst.bc (); + ef (dp); + ak.dp (ot, elems); + } + } + ed go = bld.km (dp); + if (kp) + { + bg dp = bg::ep (kp); + bn ky = bld.dc (), gp = bld.dc (eo); + go = bld.fr ().fu (e, ky, gp, dp, go); + } + ed nb = fl (ctx, ctx->args->ab); + bool aligned; + if (db->dc.cg) + aligned = kr && fy % 4; + bool gq = count == 1 || kr && kp + fy % 4 + count; + if (aligned) + gn = gq ? bld.bo (ax) : bld.bo (el); + E1 kz; + switch (gn.ek ()) + { + case 1: + kz = dt; + break; + case 2: + kz = j; + break; + case 3: + gn = bld.bo (ay) = bld.bo (jw); + ei = true; + } + bld.dp (kz, bn (gn), kx, go); + if (aligned) + { + bg dp = kr ? bg::ep (kp + fy % 4) : go; + kv (ctx, gn, dp, dst); + } + if (ei) + { + gi (ctx, gn, 4); + jv dp = dst.ek ()? ax : el; + ed gr = op (ctx, gn, 2, dp), + oc = op (ctx, gn, 0, dp), gs = op (ctx, gn, 1, dp); + bld.ft (jm, bn (dst), oc, gs, gr); + } + gi (ctx, dst, db->dc.dp); + } + jz la (ca, unsigned); + void gt (dh *, dd *, ed); + bool nc (dh *, dd *); + void gu (dh *, E1, jz, unsigned, bn, ed); + void lb (dh *, jz, bn, ed); + bool gv (dh *, ed &, ed, unsigned, long); + dh *pb; + bu *gw; + dd *lc; + bool gx; + jv nd; + void gy () + { + fn bld (pb->di, gw); + switch (lc->dp) + { + case ms: + ob (pb, lc); + case ke: + gm (pb, lc); + case fb: + ob (pb, lc); + case fc: + ob (pb, lc); + case fg: + ob (pb, lc); + case cp: + { + if (bv == x || bv == y) + { + ed dp = kt (pb, &lc->dc), ld = kw (pb); + bld.copy (bn (dp), ld); + } + if (eu <= pb->di->dp) + gf (pb, kt (pb, &lc->dc)); + ed dp = bld.bo (az), bc = gf (pb, dp), gz = + fl (pb, jr), od = kt (pb, &lc->dc); + if (pb->di->dp) + { + bn dp = bld.dc (), ha = bld.dc (eo); + ed le = fl (pb, jr), hb = bld.fu (dr, dp, ha, jy, le), ne = kt (pb, &lc->dc); + bld.ko (jq, bn (ne), hb, bc); + } + bn hc = bld.dc (), lf = bld.dc (eo); + bg hd = bg::ep (0), oq = bg::ep (5); + ed hb = bld.fu (f, hc, lf, gz, hd); + bld.dp (u, bn (od), hb, oq, bc); + } + case cr: + { + ed dp = kt (pb, &lc->dc); + gf (pb, dp); + } + case mr: + case ey: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc); + if (lc) + if (lc->kh[0].dp->cg && kh.en ()) + { + bn he = bld.dc (); + bg dp; + kh = bld.fw (dx, he, dp, kh); + } + if (lc->kh[0].dp->cg && kh.en ()) + { + bn lg = bld.dc (); + bg dp; + kh = bld.fw (t, lg, dp, kh); + } + ge (pb, "", 8, &lc->db, ""); + bn dc = bld.lm.ek ()? bn (dst) : bld.dc (); + if (lc->dp) + kh = bld.copy (dc, kh); + else + { + bn hf = bld.dc (); + kh = bld.fu (fn::kk, dc, hf, kh, bg (bf)); + } + if (dst.ek () != bld.lm.ek ()) + { + bg dp; + bld.ft (jm, bn (dst), kh, dp); + } + mz (pb); + } + case nx: + { + ed nf = kt (pb, lc->kh[0].dp), kh = bld.km (nf), dst = kt (pb, &lc->dc); + if (kh.ek ()) + op (pb, kh, 0, dst); + if (dst.ek ()) + { + bg dp; + bld.ft (jm, bn (dst), kh, dp); + } + bld.copy (bn (dst), kh); + } + case cy: + case ff: + { + ed kh = kt (pb, lc->kh[0].dp), delta = kt (pb, lc->kh[1].dp), dst = + kt (pb, &lc->dc), bo, hg, hi, dp = bld.bo (az), hh = gf (pb, dp), lh = bld.fs (); + if (ka ()) + gt (pb, lc, kh); + { + ed hh = kt (pb, lc->kh[1].dp) = kt (pb, &lc->dc) = gh (pb, kh); + if (lc || ka ()) + hh = bld.km (hh); + if (nd == ba || kh.en ()) + bo = bld.bo (az) = gg (pb, bld, hh, kh); + if (dst.jx ()) + bld.dc (); + bld.ft (mj, bn (dst), bo); + bld.ft (b, bn (dst), bo); + if (kh.en ()) + bo = gg (pb, bld, hh, kh); + bld.copy (bn (dst), bo); + if (kh.en () == em) + { + hg = bld.bo (az) = bld.bo (az); + bld.ft (mj, bn (hg), kh); + gg (pb, bld, hh, hg) = gg (pb, bld, hh, hi); + bld.ft (jm, bn (dst), hg, hi); + gi (pb, dst, 2); + } + ge (pb, "", 4, &lc->db, ""); + mz (pb); + } + kt (pb, lc->kh[0].dp); + if (ka ()) + gt (pb, lc, kh); + if (fz) + bld.copy (bn (dst), kh); + delta = bld.km (delta) = gh (pb, kh); + if (ka () && gv (pb, bo, kh, fz, gd)) + { + bn dp = bld.dc (), oe = bld.dc (); + bg hj = bg::ep (0); + ed li = + bld.fv (jn, dp, delta, hj), hk = ku (pb, bld, kh, oa, true); + gj (pb, li) = bld.ko (ol, oe, hk, kh, li); + } + if (pb->di->k && fz) + { + bn dp = bld.dc (), ng = bld.dc (eo), hl = bld.dc (), lj = bld.dc (eo); + delta = bld.fu (dr, dp, ng, delta, bk); + bg hm = bg::ep (2); + delta = bld.fu (nt, hl, lj, delta, hm); + } + bn ou = bld.dc (), hn = bld.dc (), lk = bld.dc (), ho = bld.dc (eo) = bld.dc (), nh = bld.dc (eo) = bld.dc (), hp = bld.dc (eo) = bld.dc (), ll = bld.dc (eo), hq = bld.dc (); + bg of = bg::ep (0), hr = bg::ep (64) = bld.fu (q, nh, hr, delta); + if (fz) + { + bn dp = bld.dc (), ni = bld.dc () = bld.dc (), hs = bld.dc (), ln = bld.dc (), ht = bld.dc (), oz = bld.dc (), hu = bld.dc (), lo = bld.dc (); + ed hv = bld.fu (du, ni, hg, delta), nj = bld.fu (nt, hs, hg, delta); + if (fz) + { + bn dp = bld.dc () = bld.dc (), hw = bld.dc (), lp = bld.dc () = bld.dc (), hx = bld.dc (); + bg og = bg::ep (4444), hy = bg::ep (32); + ed lotolohi = bld.copy (dp, og), hz = bld.fu (dv, hw, hv, lotolohi) = + bld.fu (mk, lp, hv, hz) = bld.fu (q, hx, hy, delta); + } + hg = bld.fu (dv, ln, ht, hv, nj); + bg lq = bg::ep (88888888); + ed ia = bld.copy (oz, lq); + hi = bld.fu (dv, hu, lo, hg, ia); + } + else + { + bn dp = bld.dc (); + bg nk = bg::ep (4275878552); + hi = bld.copy (dp, nk); + } + ed hz = bld.ft (jm, hn, hg, hi); + ed hv = bld.fu (m, lk, ho, hz, delta); + ed nj = bld.fu (l, hp, hz, delta); + hz = bld.fu (o, ll, hv, nj); + hg = bld.bo (ax) = bld.bo (ax); + bld.ft (mj, bn (hg), bn (hi), hz); + fm ib = bld.dp (w, hq, kh, hg, hi); + bp & lr = ib->br (), &ic = ib->br (); + lr.dp[0] = true; + ic.dp[1] = true; + if (pb->di && fz) + { + bn dp = bld.dc (), ov = bld.dc (), id = bld.dc (); + bg ls = bg::ep (2), ie = bg::ep (1); + ed nl = bld.ko (dy, dp, ls, lh); + bo = bld.ds (a, ov, nl, kh); + lh = bld.dp (s, id, ie, lh, hh); + } + bo = gg (pb, bld, lh, kh); + jv ig; + bo = op (pb, bo, 0, ig); + bld.copy (bn (dst), bo); + mz (pb); + } + case cq: + { + ed dp = kt (pb, &lc->dc), lt = fl (pb, z); + bg ih = bg::ep (8), oh = bg::ep (4); + bld.dp (jp, bn (dp), lt, ih, oh); + } + case cw: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc); + if (lc->dc.cg) + { + bn dp = bld.dc (eo), ii = bld.dc (); + fm lu = bld.kn (fn::kl, ii, bg (bf)); + ed bo = bld.fv (fn::fp, dp, kh, lu); + gj (pb, dst); + } + gk (pb, kh, dst); + mz (pb); + } + case ci: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc); + if (kh.jx ()) + bld.ft (b, bn (dst), kh); + bld.copy (bn (dst), kh); + } + case mt: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc); + bn dp = bld.dc (), ij = bld.dc (eo), nm = + bld.dc (), ik = bld.dc (eo), lv = bld.dc (eo); + ed bo = bld.kn (fn::fo, dp, ij, kh); + bld.fu (fn::kk, nm, ik, bo, bg (bf)).dc ().dp (); + ed cond = gj (pb, bo); + bld.kn (fn::fo, bn (dst), lv, cond); + mz (pb); + } + case da: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc) = gj (pb, kh); + gj (pb, dst); + } + case os: + { + ed kh = kt (pb, lc->kh[0].dp), dp = kt (pb, &lc->dc); + bn il = bld.dc (), pc = bld.dc (eo), im = bld.dc (eo); + kh = bld.fu (fn::kk, il, pc, kh, bg (bf)); + bld.kn (fn::mv, bn (dp), im, kh); + mz (pb); + } + case cv: + { + ed kh = kt (pb, lc->kh[0].dp), dp = kt (pb, &lc->dc); + bn lw = bld.dc (), in = bld.dc (eo), nn = bld.dc (), io = bld.dc (eo), lx = bld.dc (), ip = bld.dc (eo), oi = bld.dc (eo); + kh = bld.kn (fn::fo, lw, in, kh); + kh = bld.fu (fn::kk, nn, io, kh, bg (bf)); + kh = bld.kn (fn::mv, lx, ip, kh); + bld.kn (fn::fo, bn (dp), oi, kh); + mz (pb); + } + case cx: + case cn: + case cm: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc); + unsigned dp = lc->dp ? af () : af (); + if (ka () == pb->di->dp) + if (lc->dp) + if (nc (pb, lc)) + if (nc (pb, lc)) + break; + jv iq; + kh = op (pb, kh, 0, iq); + jz ly = la (ks, lc->kh[0].dp->cg); + switch (lc->dp) + { + case cx: + case cn: + case cm: + break; + default: + __builtin_unreachable (); + } + bool ir = ks == bz || ks == ev && dst.jx (); + if (ir) + lb (pb, ly, bn (dst), kh); + gu (pb, dq, ly, dp, bn (dst), kh); + mz (pb); + } + case fe: + { + ed kh = kt (pb, lc->kh[0].dp), dst = kt (pb, &lc->dc); + if (gx) + gt (pb, lc, kh); + switch (lc->dp) + { + case kf: + kj (); + case cu: + case ct: + nw = kj (); + case fe: + nw = af (); + nv &= ka (); + case fd: + nw = kj (); + } + if (lc->dc.cg) + { + bn dp = bld.dc (); + bg lz; + kh = bld.fx (ol, dp, lz, eq, kh); + } + if (lc->dc.cg) + kh = gh (pb, kh); + if (lc->dc.cg && lc->dp) + { + bn dp = bld.dc (), is = bld.dc (), no = bld.dc (eo), it = bld.dc (), ma = bld.dc (eo), iu = bld.dc (eo); + bg oj = bld.lm.av ()? bg::ep (kq) : bld.ft (jm, dp, bl, mp); + kh = bld.fu (fn::kk, is, no, kh, bg (bf)); + kh = bld.fu (fn::kk, it, ma, oj, kh); + bld.kn (fn::mv, bn (dst), iu, kh); + } + if (lc || lc->dc.cg) + { + unsigned iv = lc->dc.cg / 8; + bn dc = iv || lc->dc.cg ? bld.dc () : bn (dst); + if (pb->di->k) + bld.oy (v, dc, kh, nw, 5, 5, true, nv); + bld.ds (dp, dc, kh, 5 | nw); + if (iv) + { + bn dp = bld.dc (); + ed mb = dc.dp (); + bld.ft (mj, bn (dst), dp, mb); + } + if (lc->dc.cg) + { + bg dp; + ed iw = dc.dp (); + bld.fw (dx, bn (dst), dp, iw); + } + } + if (lc->dc.cg) + { + ed hg, hi = bld.ft (mj, bn (hg), hi, kh); + if (pb->di->k) + { + bn dp = bld.dc (), np = bld.dc (); + hg = bld.oy (v, dp, hg, nw, 5, 5, true, nv); + hi = bld.oy (v, np, hi, nw, 5, 5, true, nv); + } + bn ix = bld.dc (), mc = bld.dc (); + hg = bld.ds (dp, ix, hg, nw); + hi = bld.ds (dp, mc, hi, 5 | nw); + bld.ft (jm, bn (dst), hg, hi); + gi (pb, dst, 2); + } + ge (pb, "", 4, &lc->db, ""); + mz (pb); + kh = kt (pb, lc->kh[0].dp) = kt (pb, &lc->dc); + gt (pb, lc, kh); + bool dp = ka (); + if (lc->dc.cg) + kh = gh (pb, kh); + if (lc->dc.cg) + { + bn iy = bld.dc (); + bg ow, iz; + kh = bld.fx (ol, iy, ow, bm, kh); + kh = ku (pb, bld, kh, ga, dp); + bld.fw (dx, bn (dst), iz, kh); + } + if (dst.en ()) + { + ed bo = ku (pb, bld, kh, ga, dp); + op (pb, bo, 0, dst); + } + if (dst.en () == om) + { + ed bo = ku (pb, bld, kh, ga, dp); + op (pb, bo, 0, dst); + } + if (dst.en () == az) + { + ed md = ku (pb, bld, kh, ga, dp); + bld.copy (bn (dst), md); + } + if (dst.en () == em) + { + ed hg = bld.bo (az), hi = bld.bo (az); + bld.ft (mj, bn (hg), hi, kh); + hg = ku (pb, bld, hg, ga, dp) = ku (pb, bld, hi, ga, dp); + bld.ft (jm, bn (dst), hg, hi); + gi (pb, dst, 2); + } + ge (pb, "", 5, &lc->db, ""); + mz (pb); + } + { + ed dp = kt (pb, lc->kh[0].dp), kh = gh (pb, dp), ja = kt (pb, lc->kh[1].dp), nq = bld.km (ja), jb = kt (pb, lc->kh[2].dp), lane = bld.km (jb), dst = kt (pb, &lc->dc); + if (dst.en ()) + bld.nz (bn (dst), nq, lane, kh); + if (dst.en ()) + { + ed dp = bld.bo (az), jc = bld.bo (az), me = bld.bo (ax), jd = bld.bo (ax); + bld.ft (mj, bn (dp), bn (jc), kh); + bld.ft (mj, bn (me), bn (jd), nq); + bn ok = bld.dc (), je = bld.dc (); + ed hg = bld.nz (ok, me, lane, jc); + ed hi = bld.nz (je, jd, lane, jc); + bld.ft (jm, bn (dst), hg, hi); + gi (pb, dst, 2); + } + ge (pb, "", 8, &lc->db, ""); + } + case cs: + { + ed kh = kt (pb, lc->kh[0].dp), dp = kt (pb, lc->kh[1].dp), mf = gh (pb, dp), dst = kt (pb, &lc->dc) = op (pb, kh, 0, jv ()); + gf (pb, dst, kh, mf); + mz (pb); + kh = kt (pb, lc->kh[0].dp) = kt (pb, &lc->dc); + if (kh.en ()) + bld.copy (bn (dst), kh); + if (dst.en () && kh.en ()) + { + ed dp = kt (pb, lc->kh[1].dp), jf = bld.km (dp), nr = kt (pb, lc->kh[2].dp), jg = bld.km (nr); + bld.dp (w, bn (dst), kh, jf, jg); + } + ge (pb, "", 4, &lc->db, ""); + kt (pb, &lc->dc); + bld.ft (d, bn (dst), bg ()); + } + if (lc->dp) + { + ed kh = kt (pb, lc->kh[0].dp); + bn dp = bld.dc (), mg = bld.dc (eo); + er = bld.fu (fn::kk, dp, mg, kh, bg (bf)); + } + bld.ft (er); + if (bt || pb->mu.dj.fk) + pb->mu.dk = gw->dp |= ju; + if (ki->dp.dp) + ar = true; + case cz: + case ck: + case cl: + { + bg cond = bg::ep (1); + if (lc->dp == cl || lc->dp == cz) + { + ed kh = kt (pb, lc->kh[0].dp); + bn dp = bld.dc (), jh = bld.dc (eo); + cond = bld.fu (fn::kk, dp, jh, kh, bg (bf)); + pb->mu.dp |= ka (); + } + bld.ft (cond); + if (bt || pb->mu.dj.fk) + pb->mu.dk = pb->mu.dp |= gl (pb); + gw->dp |= ju; + } + case fa: + { + ed dp = kt (pb, &lc->dc); + bld.kn (fn::kl, bn (dp), bg (bf)); + } + mz (pb); + case co: + { + bn pa = bld.dc (), dp = bld.dc (eo); + ed flbit = bld.kn (fn::fq, pa, bg (bf)), ji = kt (pb, &lc->dc); + bg mh = bg::ep (pb->di->dp - 1); + bld.fu (dw, bn (ji), dp, mh, flbit); + mz (pb); + } + case kd: + { + ed dp = kt (pb, &lc->dc); + bld.ft (c, bn (dp), bg (bf)); + } + mz (pb); + case kg: + ed dst = kt (pb, &lc->dc); + if (fi () && pb->dp->k) + { + bn jj = bld.dc (); + ed clock = bld.mw (h, jj, 9); + bg dp; + bld.ft (jm, bn (dst), clock, dp); + } + if (fi () && pb->dp->k) + { + bg ns = bg::ep (dn); + bld.kn (p, bn (dst), ns); + E1 dp = fi ()? jo : n; + bld.dp (dp, bn (dst), 0); + } + gi (pb, dst, 2); + } + } + dh *jk; + void mi (bool, bool, bool) + { + mm (); + for (df * dp (ka ()? (df *) bx : __null); + dp; dp = ka ()? (df *) bx : __null) + switch (dp->jx) + { + case de: + for (cf * db (ka ()? (cf *) bx : __null); + db; db = ka ()? (cf *) bx : __null) + switch (db->jx) + { + case mq: + na (jk, gc); + case kb: + na (jk, my); + case cc: + gy (); + case ew: + mm (); + case ce: + mm (); + case ex: + mm (); + case cb: + case cd: + mm (); + ge (jk, "", 6, db, ""); + } + mm (); + case ny: + mm (); + } + } +} +void +jl () +{ + dh ctx; + if (gb) + mi (as, ej, at); +} diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/pr114714-1.C b/gcc/testsuite/g++.target/riscv/rvv/base/pr114714-1.C new file mode 100644 index 00000000000..d3230f7f23e --- /dev/null +++ b/gcc/testsuite/g++.target/riscv/rvv/base/pr114714-1.C @@ -0,0 +1,85 @@ +/* Test that we do not have ice when compile */ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -std=c++17" } */ + +typedef int a; +typedef short b; +typedef unsigned c; +template < typename > using e = unsigned; +template < typename > void ab(); +#pragma riscv intrinsic "vector" +template < typename f, int, int ac > struct g { + using i = f; + template < typename m > using j = g< m, 0, ac >; + using k = g< i, 1, ac - 1 >; + using ad = g< i, 1, ac + 1 >; +}; +namespace ae { +struct af { + using h = g< short, 6, 0 < 3 >; +}; +struct ag { + using h = af::h; +}; +} template < typename, int > using ah = ae::ag::h; +template < class ai > using aj = typename ai::i; +template < class i, class ai > using j = typename ai::j< i >; +template < class ai > using ak = j< e< ai >, ai >; +template < class ai > using k = typename ai::k; +template < class ai > using ad = typename ai::ad; +template < a ap > vuint16m1_t ar(g< b, ap, 0 >, b); +template < a ap > vuint16m2_t ar(g< b, ap, 1 >, b); +template < a ap > vuint32m2_t ar(g< c, ap, 1 >, c); +template < a ap > vuint32m4_t ar(g< c, ap, 2 >, c); +template < class ai > using as = decltype(ar(ai(), aj< ai >())); +template < class ai > as< ai > at(ai); +namespace ae { +template < int ap > vuint32m4_t au(g< c, ap, 1 + 1 >, vuint32m2_t l) { + return __riscv_vlmul_ext_v_u32m2_u32m4(l); +} +} template < int ap > vuint32m2_t aw(g< c, ap, 1 >, vuint16m1_t l) { + return __riscv_vzext_vf2_u32m2(l, 0); +} +namespace ae { +vuint32m4_t ax(vuint32m4_t, vuint32m4_t, a); +} +template < class ay, class an > as< ay > az(ay ba, an bc) { + an bb; + return ae::ax(ae::au(ba, bc), ae::au(ba, bb), 2); +} +template < class bd > as< bd > be(bd, as< ad< bd > >); +namespace ae { +template < class bh, class bi > void bj(bh bk, bi bl) { + ad< decltype(bk) > bn; + az(bn, bl); +} +} template < int ap, int ac, class bp, class bq > +void br(g< c, ap, ac > bk, bp, bq bl) { + ae::bj(bk, bl); +} +template < class ai > using bs = decltype(at(ai())); +struct bt; +template < int ac = 1 > class bu { +public: + template < typename i > void operator()(i) { + ah< i, ac > d; + bt()(i(), d); + } +}; +struct bt { + template < typename bv, class bf > void operator()(bv, bf bw) { + using bx = bv; + ak< bf > by; + k< bf > bz; + using bq = bs< decltype(by) >; + using bp = bs< decltype(bw) >; + bp cb; + ab< bx >(); + for (;;) { + bp cc; + bq bl = aw(by, be(bz, cc)); + br(by, cb, bl); + } + } +}; +void d() { bu()(b()); } diff --git a/gcc/testsuite/g++.target/riscv/rvv/base/pr114714-2.C b/gcc/testsuite/g++.target/riscv/rvv/base/pr114714-2.C new file mode 100644 index 00000000000..55621e98fee --- /dev/null +++ b/gcc/testsuite/g++.target/riscv/rvv/base/pr114714-2.C @@ -0,0 +1,85 @@ +/* Test that we do not have ice when compile */ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -std=c++17" } */ + +typedef int a; +typedef short b; +typedef unsigned c; +template < typename > using e = unsigned; +template < typename > void ab(); +#pragma riscv intrinsic "vector" +template < typename f, int, int ac > struct g { + using i = f; + template < typename m > using j = g< m, 0, ac >; + using k = g< i, 1, ac - 1 >; + using ad = g< i, 1, ac + 1 >; +}; +namespace ae { +struct af { + using h = g< short, 6, 0 < 3 >; +}; +struct ag { + using h = af::h; +}; +} template < typename, int > using ah = ae::ag::h; +template < class ai > using aj = typename ai::i; +template < class i, class ai > using j = typename ai::j< i >; +template < class ai > using ak = j< e< ai >, ai >; +template < class ai > using k = typename ai::k; +template < class ai > using ad = typename ai::ad; +template < a ap > vuint16mf2_t ar(g< b, ap, 0 >, b); +template < a ap > vuint16m1_t ar(g< b, ap, 1 >, b); +template < a ap > vuint32m1_t ar(g< c, ap, 1 >, c); +template < a ap > vuint32m2_t ar(g< c, ap, 2 >, c); +template < class ai > using as = decltype(ar(ai(), aj< ai >())); +template < class ai > as< ai > at(ai); +namespace ae { +template < int ap > vuint32m2_t au(g< c, ap, 1 + 1 >, vuint32m1_t l) { + return __riscv_vlmul_ext_v_u32m1_u32m2(l); +} +} template < int ap > vuint32m1_t aw(g< c, ap, 1 >, vuint16mf2_t l) { + return __riscv_vzext_vf2_u32m1(l, 0); +} +namespace ae { +vuint32m2_t ax(vuint32m2_t, vuint32m2_t, a); +} +template < class ay, class an > as< ay > az(ay ba, an bc) { + an bb; + return ae::ax(ae::au(ba, bc), ae::au(ba, bb), 2); +} +template < class bd > as< bd > be(bd, as< ad< bd > >); +namespace ae { +template < class bh, class bi > void bj(bh bk, bi bl) { + ad< decltype(bk) > bn; + az(bn, bl); +} +} template < int ap, int ac, class bp, class bq > +void br(g< c, ap, ac > bk, bp, bq bl) { + ae::bj(bk, bl); +} +template < class ai > using bs = decltype(at(ai())); +struct bt; +template < int ac = 1 > class bu { +public: + template < typename i > void operator()(i) { + ah< i, ac > d; + bt()(i(), d); + } +}; +struct bt { + template < typename bv, class bf > void operator()(bv, bf bw) { + using bx = bv; + ak< bf > by; + k< bf > bz; + using bq = bs< decltype(by) >; + using bp = bs< decltype(bw) >; + bp cb; + ab< bx >(); + for (;;) { + bp cc; + bq bl = aw(by, be(bz, cc)); + br(by, cb, bl); + } + } +}; +void d() { bu()(b()); } diff --git a/gcc/testsuite/g++.target/s390/pr95782.C b/gcc/testsuite/g++.target/s390/pr95782.C new file mode 100644 index 00000000000..daf887fc6fe --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr95782.C @@ -0,0 +1,5 @@ +// { dg-do compile } +// { dg-options "-march=z14 -mzvector" } + +using vdbl = __vector double; +#define BREAK 1 diff --git a/gcc/testsuite/gcc.dg/c23-tag-incomplete-1.c b/gcc/testsuite/gcc.dg/c23-tag-incomplete-1.c new file mode 100644 index 00000000000..837de05948c --- /dev/null +++ b/gcc/testsuite/gcc.dg/c23-tag-incomplete-1.c @@ -0,0 +1,11 @@ +/* { dg-do compile } + * { dg-options "-std=c23 -g" } */ + +struct a; +typedef struct a b; + +void g() { + struct a { b* x; }; +} + +struct a { b* x; }; diff --git a/gcc/testsuite/gcc.dg/c23-tag-incomplete-2.c b/gcc/testsuite/gcc.dg/c23-tag-incomplete-2.c new file mode 100644 index 00000000000..ba36789e59b --- /dev/null +++ b/gcc/testsuite/gcc.dg/c23-tag-incomplete-2.c @@ -0,0 +1,11 @@ +/* { dg-do compile } + * { dg-options "-std=c23 -g" } */ + +struct a; +typedef struct a b; + +void f() { + extern struct a { b* x; } t; +} + +extern struct a { b* x; } t; diff --git a/gcc/testsuite/gcc.dg/cdce3.c b/gcc/testsuite/gcc.dg/cdce3.c index 601ddf055fd..f759a95972e 100644 --- a/gcc/testsuite/gcc.dg/cdce3.c +++ b/gcc/testsuite/gcc.dg/cdce3.c @@ -1,7 +1,8 @@ /* { dg-do compile } */ /* { dg-require-effective-target hard_float } */ +/* { dg-require-effective-target sqrt_insn } */ /* { dg-options "-O2 -fmath-errno -fdump-tree-cdce-details -fdump-tree-optimized" } */ -/* { dg-final { scan-tree-dump "cdce3.c:11: \[^\n\r]* function call is shrink-wrapped into error conditions\." "cdce" } } */ +/* { dg-final { scan-tree-dump "cdce3.c:12: \[^\n\r]* function call is shrink-wrapped into error conditions\." "cdce" } } */ /* { dg-final { scan-tree-dump "sqrtf \\(\[^\n\r]*\\); \\\[tail call\\\]" "optimized" } } */ /* { dg-skip-if "doesn't have a sqrtf insn" { mmix-*-* } } */ diff --git a/gcc/testsuite/gcc.dg/format/sentinel-2.c b/gcc/testsuite/gcc.dg/format/sentinel-2.c new file mode 100644 index 00000000000..4c29f6fb818 --- /dev/null +++ b/gcc/testsuite/gcc.dg/format/sentinel-2.c @@ -0,0 +1,21 @@ +/* PR c/114780 */ +/* { dg-do compile } */ +/* { dg-options "-std=c23 -Wformat" } */ + +#include <stddef.h> + +[[gnu::sentinel]] void foo (int, ...); +[[gnu::sentinel]] void bar (...); + +void +baz (nullptr_t p) +{ + foo (1, 2, nullptr); + foo (3, 4, 5, p); + bar (nullptr); + bar (p); + foo (6, 7, 0); // { dg-warning "missing sentinel in function call" } + bar (0); // { dg-warning "missing sentinel in function call" } + foo (8, 9, NULL); + bar (NULL); +} diff --git a/gcc/testsuite/gcc.dg/gimplefe-53.c b/gcc/testsuite/gcc.dg/gimplefe-53.c new file mode 100644 index 00000000000..926c77c74d4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/gimplefe-53.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-options "-fgimple" } */ + +int __GIMPLE +foo (int a, int b) +{ + int tem; + tem = a __EXACT_DIV b; + tem = tem __CEIL_DIV b; + tem = tem __FLOOR_DIV b; + tem = tem __ROUND_DIV b; + tem = tem __FLOOR_MOD b; + tem = tem __CEIL_MOD b; + tem = tem __ROUND_MOD b; + return tem; +} diff --git a/gcc/testsuite/gcc.dg/pr114361.c b/gcc/testsuite/gcc.dg/pr114361.c new file mode 100644 index 00000000000..1d5babaa966 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr114361.c @@ -0,0 +1,10 @@ +/* PR c/114361 */ +/* { dg-do compile } */ +/* { dg-options "-std=gnu23 -g" } */ + +void f() +{ + typedef struct foo bar; + typedef __typeof( ({ (struct foo { bar *x; }){ }; }) ) wuz; + struct foo { wuz *x; }; +} diff --git a/gcc/testsuite/gcc.dg/pr114574-1.c b/gcc/testsuite/gcc.dg/pr114574-1.c new file mode 100644 index 00000000000..e125b68a646 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr114574-1.c @@ -0,0 +1,7 @@ +/* PR lto/114574 + * { dg-do compile } + * { dg-options "-flto" } */ + +const struct S * x; +struct S {}; +void f(const struct S **); diff --git a/gcc/testsuite/gcc.dg/pr114574-2.c b/gcc/testsuite/gcc.dg/pr114574-2.c new file mode 100644 index 00000000000..0e709975e61 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr114574-2.c @@ -0,0 +1,7 @@ +/* PR lto/114574 + * { dg-do compile } + * { dg-options "-flto -std=c23" } */ + +const struct S * x; +struct S {}; +void f(const struct S **); diff --git a/gcc/testsuite/gcc.dg/pr114768.c b/gcc/testsuite/gcc.dg/pr114768.c new file mode 100644 index 00000000000..ffe3b368638 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr114768.c @@ -0,0 +1,10 @@ +/* PR rtl-optimization/114768 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-rtl-final" } */ +/* { dg-final { scan-rtl-dump "\\\(mem/v:" "final" } } */ + +void +foo (int *p) +{ + *p = *(volatile int *) p; +} diff --git a/gcc/testsuite/gcc.dg/pr114876.c b/gcc/testsuite/gcc.dg/pr114876.c new file mode 100644 index 00000000000..7bb380aa29e --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr114876.c @@ -0,0 +1,34 @@ +/* PR tree-optimization/114876 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ +/* { dg-final { scan-tree-dump-not "return \[01\];" "optimized" } } */ +/* { dg-final { scan-tree-dump "return 3;" "optimized" } } */ +/* { dg-final { scan-tree-dump "return 4;" "optimized" } } */ + +int +foo (void) +{ + char buf[64]; + return __builtin_sprintf (buf, "%lc%lc%lc", (__WINT_TYPE__) 0, (__WINT_TYPE__) 0, (__WINT_TYPE__) 0); +} + +int +bar (void) +{ + char buf[64]; + return __builtin_sprintf (buf, "%c%c%c", 0, 0, 0); +} + +int +baz (void) +{ + char buf[64]; + return __builtin_sprintf (buf, "%lc%lc%lca", (__WINT_TYPE__) 0, (__WINT_TYPE__) 0, (__WINT_TYPE__) 0); +} + +int +qux (void) +{ + char buf[64]; + return __builtin_sprintf (buf, "%c%c%ca", 0, 0, 0); +} diff --git a/gcc/testsuite/gcc.dg/torture/bitint-70.c b/gcc/testsuite/gcc.dg/torture/bitint-70.c new file mode 100644 index 00000000000..2d693bb5849 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bitint-70.c @@ -0,0 +1,22 @@ +/* PR libgcc/114762 */ +/* { dg-do run { target bitint } } */ +/* { dg-options "-std=c23" } */ +/* { dg-skip-if "" { ! run_expensive_tests } { "*" } { "-O0" "-O2" } } */ +/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */ + +#if __BITINT_MAXWIDTH__ >= 255 +__attribute__((__noipa__)) signed _BitInt(255) +foo (signed _BitInt(255) a, signed _BitInt(65) b) +{ + return a / b; +} +#endif + +int +main () +{ +#if __BITINT_MAXWIDTH__ >= 255 + if (foo (1, -0xffffffffffffffffwb - 1wb)) + __builtin_abort (); +#endif +} diff --git a/gcc/testsuite/gcc.dg/torture/pr114787.c b/gcc/testsuite/gcc.dg/torture/pr114787.c new file mode 100644 index 00000000000..1c7294bee7b --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr114787.c @@ -0,0 +1,27 @@ +/* { dg-do run } */ + +int a, b, c, d, e = -1, f, g, h, j, k, n, o, p; +int main() { + int i, l = 2, m; + for (b = 0; b < 1; b++) + l = 0; + for (; a >= 0; a--) + for (m = 3; m; m--) { + k = g; + i = 0; + for (; i < 1; i++) + for (; f < 1; f++) + h = g; + n = 2 & ((e ^ d) | 1) * j; + o = ~(e & n); + q: + if (c <= e) + return 0; + e = o; + } + p = l; + l = 0; + if (p) + goto q; + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr114792.c b/gcc/testsuite/gcc.dg/torture/pr114792.c new file mode 100644 index 00000000000..4990e76eb2a --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr114792.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-fno-tree-ccp -fno-tree-copy-prop" } */ + +int a; +int main() { + int b = -1, c; + for (; b >= 0; b++) { + for (c = 0; c; c++) { + L: + while (a) + if (a) + goto L; + } + } + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr91323.c b/gcc/testsuite/gcc.dg/torture/pr91323.c index 1411fcaa396..4574342e728 100644 --- a/gcc/testsuite/gcc.dg/torture/pr91323.c +++ b/gcc/testsuite/gcc.dg/torture/pr91323.c @@ -1,4 +1,5 @@ -/* { dg-do run } */ +/* { dg-do run { xfail powerpc*-*-* } } */ +/* remove the xfail for powerpc when pr58684 is fixed */ /* { dg-add-options ieee } */ /* { dg-require-effective-target fenv_exceptions } */ /* { dg-skip-if "fenv" { powerpc-ibm-aix* } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/builtin-sprintf-warn-1.c b/gcc/testsuite/gcc.dg/tree-ssa/builtin-sprintf-warn-1.c index 0cc03ff2de8..6cb2acb7f87 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/builtin-sprintf-warn-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/builtin-sprintf-warn-1.c @@ -200,11 +200,11 @@ void test_sprintf_chk_c_const (void) T (3, "%c%c", '1', '2'); /* Wide characters. */ - T (0, "%lc", (wint_t)0); /* { dg-warning "nul past the end" } */ - T (1, "%lc", (wint_t)0); - T (1, "%lc%lc", (wint_t)0, (wint_t)0); + T (0, "%lc", (wint_t)0); /* { dg-warning ".%lc. directive writing up to 1 bytes into a region of size 0" } */ + T (1, "%lc", (wint_t)0); /* { dg-warning "nul past the end" } */ + T (1, "%lc%lc", (wint_t)0, (wint_t)0); /* { dg-warning ".%lc. directive writing up to 1 bytes into a region of size between 0 and 1" } */ T (2, "%lc", (wint_t)0); - T (2, "%lc%lc", (wint_t)0, (wint_t)0); + T (2, "%lc%lc", (wint_t)0, (wint_t)0); /* { dg-warning "nul past the end" } */ /* The following could result in as few as no bytes and in as many as MB_CUR_MAX, but since the MB_CUR_MAX value is a runtime property @@ -1550,7 +1550,7 @@ void test_snprintf_c_const (char *d) /* Wide characters. */ T (0, "%lc", (wint_t)0); - T (1, "%lc", (wint_t)0); + T (1, "%lc", (wint_t)0); /* { dg-warning "output may be truncated before the last format character" } */ T (2, "%lc", (wint_t)0); /* The following could result in as few as a single byte and in as many @@ -1603,7 +1603,7 @@ void test_snprintf_chk_c_const (void) /* Wide characters. */ T (0, "%lc", (wint_t)0); - T (1, "%lc", (wint_t)0); + T (1, "%lc", (wint_t)0); /* { dg-warning "output may be truncated before the last format character" } */ T (2, "%lc", (wint_t)0); /* The following could result in as few as a single byte and in as many diff --git a/gcc/testsuite/gcc.dg/tree-ssa/forwprop-40.c b/gcc/testsuite/gcc.dg/tree-ssa/forwprop-40.c index 7513497f552..0c5233a68f4 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/forwprop-40.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/forwprop-40.c @@ -10,5 +10,5 @@ vector int g(vector int a) return a; } -/* { dg-final { scan-tree-dump-times "BIT_INSERT_EXPR" 0 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "BIT_INSERT_EXPR" 0 "optimized" { xfail s390_mvx } } } Xfail: PR114802 */ +/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized" { xfail s390_mvx } } } Xfail: PR114802 */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/forwprop-41.c b/gcc/testsuite/gcc.dg/tree-ssa/forwprop-41.c index b1e75797a90..a1f08289dd6 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/forwprop-41.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/forwprop-41.c @@ -11,6 +11,6 @@ vector int g(vector int a, int c) return a; } -/* { dg-final { scan-tree-dump-times "BIT_INSERT_EXPR" 1 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "BIT_INSERT_EXPR" 1 "optimized" { xfail s390_mvx } } } Xfail PR114802 */ +/* { dg-final { scan-tree-dump-times "BIT_FIELD_REF" 0 "optimized" { xfail s390_mvx } } } Xfail PR114802 */ /* { dg-final { scan-tree-dump-times "VEC_PERM_EXPR" 0 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-pr114799.c b/gcc/testsuite/gcc.dg/vect/bb-slp-pr114799.c new file mode 100644 index 00000000000..70572fe703b --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/bb-slp-pr114799.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-fno-tree-forwprop" } */ + +unsigned long x; +unsigned char y; + +void +foo (void) +{ + unsigned long tt = y; + tt+=255; + unsigned short t1 = tt; + t1 = 254 - t1; + tt += ((unsigned long)t1); + x = tt; +} diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c b/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c index 454a714a309..90b5d5a7f40 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/ppc/costmodel-vect-31a.c @@ -1,4 +1,5 @@ /* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-fno-tree-loop-distribute-patterns" } */ #include <stdarg.h> #include "../../tree-vect.h" diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-11.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-11.c index c9e28251225..5a39f04b140 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-11.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-11.c @@ -40,7 +40,7 @@ void foo2 (int64_t *__restrict a, } /* { dg-final { scan-assembler {e64,m8} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ /* { dg-final { scan-tree-dump-not "Preferring smaller LMUL loop because it has unexpected spills" "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr114506.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr114506.c new file mode 100644 index 00000000000..a88d24b2d2d --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr114506.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -ftree-vectorize -mrvv-max-lmul=dynamic -fdump-tree-vect-details" } */ + +float a[32000], b[32000], c[32000], d[32000]; +float aa[256][256], bb[256][256], cc[256][256]; + +void +s2275 () +{ + for (int i = 0; i < 256; i++) + { + for (int j = 0; j < 256; j++) + { + aa[j][i] = aa[j][i] + bb[j][i] * cc[j][i]; + } + a[i] = b[i] + c[i] * d[i]; + } +} + +/* { dg-final { scan-assembler-times {e32,m8} 1 } } */ +/* { dg-final { scan-assembler-not {e32,m4} } } */ +/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-tree-dump-not "Preferring smaller LMUL loop because it has unexpected spills" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/pr114832.c b/gcc/testsuite/gcc.dg/vect/pr114832.c new file mode 100644 index 00000000000..2de07ae22ef --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr114832.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-fno-tree-loop-if-convert -fno-tree-loop-distribute-patterns" } */ + +int a, b, c, d[3]; +void e() { + int f, g = 0; + for (; g < 3; g++) { + if (f || a || b && c) { + int h, *i = &h, **j = &i; + } + d[g] = 0; + } +} diff --git a/gcc/testsuite/gcc.target/aarch64/ldp_stp_q_disable.c b/gcc/testsuite/gcc.target/aarch64/ldp_stp_q_disable.c deleted file mode 100644 index 38c1870c47c..00000000000 --- a/gcc/testsuite/gcc.target/aarch64/ldp_stp_q_disable.c +++ /dev/null @@ -1,26 +0,0 @@ -/* { dg-options "-O2 -moverride=tune=no_ldp_stp_qregs" } */ - -typedef float float32x4_t __attribute__ ((__vector_size__ ((16)))); - -float32x4_t arr[4][4]; - -void -foo (float32x4_t x, float32x4_t y) -{ - arr[0][1] = x; - arr[1][0] = y; - arr[2][0] = x; - arr[1][1] = y; - arr[0][2] = x; - arr[0][3] = y; - arr[1][2] = x; - arr[2][1] = y; - arr[3][0] = x; - arr[3][1] = y; - arr[2][2] = x; - arr[1][3] = y; - arr[2][3] = x; - arr[3][2] = y; -} - -/* { dg-final { scan-assembler-not "stp\tq\[0-9\]+, q\[0-9\]" } } */ diff --git a/gcc/testsuite/gcc.target/arm/cmse/extend-param.c b/gcc/testsuite/gcc.target/arm/cmse/extend-param.c new file mode 100644 index 00000000000..01fac786238 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/cmse/extend-param.c @@ -0,0 +1,96 @@ +/* { dg-do compile } */ +/* { dg-options "-mcmse" } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +#include <arm_cmse.h> +#include <stdbool.h> + +#define ARRAY_SIZE (256) +char array[ARRAY_SIZE]; + +enum offset +{ + zero = 0, + one = 1, + two = 2 +}; + +/* +**__acle_se_unsignSecureFunc: +** ... +** uxtb r0, r0 +** ... +*/ +__attribute__((cmse_nonsecure_entry)) char unsignSecureFunc (unsigned char index) { + if (index >= ARRAY_SIZE) + return 0; + return array[index]; +} + +/* +**__acle_se_signSecureFunc: +** ... +** sxtb r0, r0 +** ... +*/ +__attribute__((cmse_nonsecure_entry)) char signSecureFunc (signed char index) { + if (index >= ARRAY_SIZE) + return 0; + return array[index]; +} + +/* +**__acle_se_shortUnsignSecureFunc: +** ... +** uxth r0, r0 +** ... +*/ +__attribute__((cmse_nonsecure_entry)) char shortUnsignSecureFunc (unsigned short index) { + if (index >= ARRAY_SIZE) + return 0; + return array[index]; +} + +/* +**__acle_se_shortSignSecureFunc: +** ... +** sxth r0, r0 +** ... +*/ +__attribute__((cmse_nonsecure_entry)) char shortSignSecureFunc (signed short index) { + if (index >= ARRAY_SIZE) + return 0; + return array[index]; +} + +/* +**__acle_se_enumSecureFunc: +** ... +** uxtb r0, r0 +** ... +*/ +__attribute__((cmse_nonsecure_entry)) char enumSecureFunc (enum offset index) { + + // Compiler may optimize away bounds check as value is an unsigned char. + + // According to AAPCS caller will zero extend to ensure value is < 256. + + if (index >= ARRAY_SIZE) + return 0; + return array[index]; + +} + +/* +**__acle_se_boolSecureFunc: +** ... +** uxtb r0, r0 +** ... +*/ +__attribute__((cmse_nonsecure_entry)) char boolSecureFunc (bool index) { + + if (index >= ARRAY_SIZE) + return 0; + return array[index]; + +}
\ No newline at end of file diff --git a/gcc/testsuite/gcc.target/arm/cmse/extend-return.c b/gcc/testsuite/gcc.target/arm/cmse/extend-return.c new file mode 100644 index 00000000000..cf731ed33df --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/cmse/extend-return.c @@ -0,0 +1,92 @@ +/* { dg-do compile } */ +/* { dg-options "-mcmse" } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +#include <arm_cmse.h> +#include <stdbool.h> + +enum offset +{ + zero = 0, + one = 1, + two = 2 +}; + +typedef unsigned char __attribute__ ((cmse_nonsecure_call)) ns_unsign_foo_t (void); +typedef signed char __attribute__ ((cmse_nonsecure_call)) ns_sign_foo_t (void); +typedef unsigned short __attribute__ ((cmse_nonsecure_call)) ns_short_unsign_foo_t (void); +typedef signed short __attribute__ ((cmse_nonsecure_call)) ns_short_sign_foo_t (void); +typedef enum offset __attribute__ ((cmse_nonsecure_call)) ns_enum_foo_t (void); +typedef bool __attribute__ ((cmse_nonsecure_call)) ns_bool_foo_t (void); + +/* +**unsignNonsecure0: +** ... +** bl __gnu_cmse_nonsecure_call +** uxtb r0, r0 +** ... +*/ +unsigned char unsignNonsecure0 (ns_unsign_foo_t * ns_foo_p) +{ + return ns_foo_p (); +} + +/* +**signNonsecure0: +** ... +** bl __gnu_cmse_nonsecure_call +** sxtb r0, r0 +** ... +*/ +signed char signNonsecure0 (ns_sign_foo_t * ns_foo_p) +{ + return ns_foo_p (); +} + +/* +**shortUnsignNonsecure0: +** ... +** bl __gnu_cmse_nonsecure_call +** uxth r0, r0 +** ... +*/ +unsigned short shortUnsignNonsecure0 (ns_short_unsign_foo_t * ns_foo_p) +{ + return ns_foo_p (); +} + +/* +**shortSignNonsecure0: +** ... +** bl __gnu_cmse_nonsecure_call +** sxth r0, r0 +** ... +*/ +signed short shortSignNonsecure0 (ns_short_sign_foo_t * ns_foo_p) +{ + return ns_foo_p (); +} + +/* +**enumNonsecure0: +** ... +** bl __gnu_cmse_nonsecure_call +** uxtb r0, r0 +** ... +*/ +unsigned char __attribute__((noipa)) enumNonsecure0 (ns_enum_foo_t * ns_foo_p) +{ + return ns_foo_p (); +} + +/* +**boolNonsecure0: +** ... +** bl __gnu_cmse_nonsecure_call +** uxtb r0, r0 +** ... +*/ +unsigned char boolNonsecure0 (ns_bool_foo_t * ns_foo_p) +{ + return ns_foo_p (); +}
\ No newline at end of file diff --git a/gcc/testsuite/gcc.target/bpf/alu-1.c b/gcc/testsuite/gcc.target/bpf/alu-1.c index 98149305e82..be85a451786 100644 --- a/gcc/testsuite/gcc.target/bpf/alu-1.c +++ b/gcc/testsuite/gcc.target/bpf/alu-1.c @@ -2,7 +2,7 @@ not enabled. */ /* { dg-do compile } */ -/* { dg-options "-mno-alu32" } */ +/* { dg-options "-mno-alu32 -masm=normal" } */ int foo (int a, int b) { diff --git a/gcc/testsuite/gcc.target/bpf/alu-2.c b/gcc/testsuite/gcc.target/bpf/alu-2.c index 0444a9bc68a..1a8f2af9b26 100644 --- a/gcc/testsuite/gcc.target/bpf/alu-2.c +++ b/gcc/testsuite/gcc.target/bpf/alu-2.c @@ -1,6 +1,6 @@ /* Check add and sub instructions. */ /* { dg-do compile } */ -/* { dg-options "" } */ +/* { dg-options "-masm=normal" } */ long foo (long x, long y) { diff --git a/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-1.c b/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-1.c index 4bb6a7dba29..c0c85a2b321 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-1.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mv3-atomics -O2" } */ +/* { dg-options "-mv3-atomics -O2 -masm=normal" } */ int foo (int *p, int *expected, int desired) diff --git a/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-2.c b/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-2.c index 4036570ac60..c452e0385e3 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-2.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-cmpxchg-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mno-v3-atomics -O2" } */ +/* { dg-options "-mno-v3-atomics -O2 -masm=normal" } */ int foo (int *p, int *expected, int desired) diff --git a/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-1.c b/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-1.c index 533e955fe88..1013bcafc7a 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-1.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-1.c @@ -1,7 +1,7 @@ /* Test 64-bit atomic-fetch-op instructions. */ /* { dg-do compile } */ -/* { dg-options "-mv3-atomics -O2" } */ +/* { dg-options "-mv3-atomics -O2 -masm=normal" } */ long val; diff --git a/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-2.c b/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-2.c index 6b9ee6348b5..6fce8e9b69c 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-2.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-2.c @@ -1,7 +1,7 @@ /* Test 32-bit atomic-fetch-op instructions. */ /* { dg-do compile } */ -/* { dg-options "-mv3-atomics -O2" } */ +/* { dg-options "-mv3-atomics -O2 -masm=normal" } */ int val; diff --git a/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-3.c b/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-3.c index 044a2f76474..04f9e5dbfe9 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-3.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-fetch-op-3.c @@ -1,7 +1,7 @@ /* Test atomic-fetch-op instructions are disabled with -mno-v3-atomics. */ /* { dg-do compile } */ -/* { dg-options "-mno-v3-atomics -O2" } */ +/* { dg-options "-mno-v3-atomics -O2 -masm=normal" } */ long val; diff --git a/gcc/testsuite/gcc.target/bpf/atomic-op-1.c b/gcc/testsuite/gcc.target/bpf/atomic-op-1.c index 453c0ed47ce..5c87dcbffe6 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-op-1.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-op-1.c @@ -1,6 +1,6 @@ /* Test 64-bit non-fetch atomic operations. */ /* { dg-do compile } */ -/* { dg-options "-mv3-atomics -O2" } */ +/* { dg-options "-mv3-atomics -O2 -masm=normal" } */ long val; diff --git a/gcc/testsuite/gcc.target/bpf/atomic-op-2.c b/gcc/testsuite/gcc.target/bpf/atomic-op-2.c index daacf42c00b..8331d33465f 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-op-2.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-op-2.c @@ -1,6 +1,6 @@ /* Test 32-bit non-fetch atomic operations. */ /* { dg-do compile } */ -/* { dg-options "-mv3-atomics -O2" } */ +/* { dg-options "-mv3-atomics -O2 -masm=normal" } */ int val; diff --git a/gcc/testsuite/gcc.target/bpf/atomic-op-3.c b/gcc/testsuite/gcc.target/bpf/atomic-op-3.c index b2ce2892634..af5b607c093 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-op-3.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-op-3.c @@ -1,6 +1,6 @@ /* Test that atomic insns are properly disabled with -mno-v3-atomics. */ /* { dg-do compile } */ -/* { dg-options "-mno-v3-atomics -O2" } */ +/* { dg-options "-mno-v3-atomics -O2 -masm=normal" } */ int val; diff --git a/gcc/testsuite/gcc.target/bpf/atomic-xchg-1.c b/gcc/testsuite/gcc.target/bpf/atomic-xchg-1.c index bab806393df..e8d4f14f36b 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-xchg-1.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-xchg-1.c @@ -1,6 +1,6 @@ /* Test atomic exchange instruction. */ /* { dg-do compile } */ -/* { dg-options "-mv3-atomics -O2" } */ +/* { dg-options "-mv3-atomics -O2 -masm=normal" } */ int foo (int *p, int *new) { diff --git a/gcc/testsuite/gcc.target/bpf/atomic-xchg-2.c b/gcc/testsuite/gcc.target/bpf/atomic-xchg-2.c index 3b6324e966b..9cc56e05fb7 100644 --- a/gcc/testsuite/gcc.target/bpf/atomic-xchg-2.c +++ b/gcc/testsuite/gcc.target/bpf/atomic-xchg-2.c @@ -1,6 +1,6 @@ /* Test atomic exchange instruction is disabled with -mno-v3-atomics. */ /* { dg-do compile } */ -/* { dg-options "-mno-v3-atomics -O2" } */ +/* { dg-options "-mno-v3-atomics -O2 -masm=normal" } */ int foo (int *p, int *new) { diff --git a/gcc/testsuite/gcc.target/bpf/attr-kernel-helper.c b/gcc/testsuite/gcc.target/bpf/attr-kernel-helper.c index 7c5a0007c97..40c541f0c75 100644 --- a/gcc/testsuite/gcc.target/bpf/attr-kernel-helper.c +++ b/gcc/testsuite/gcc.target/bpf/attr-kernel-helper.c @@ -1,7 +1,7 @@ /* Basic test for kernel_helper attribute BTF information. */ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf" } */ +/* { dg-options "-O0 -dA -gbtf -masm=normal" } */ extern int foo_helper(int) __attribute((kernel_helper(42))); extern int foo_nohelper(int); diff --git a/gcc/testsuite/gcc.target/bpf/bpf-debug-options-1.c b/gcc/testsuite/gcc.target/bpf/bpf-debug-options-1.c new file mode 100644 index 00000000000..409466c4ead --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/bpf-debug-options-1.c @@ -0,0 +1,17 @@ +/* Default to BTF debug info. */ +/* { dg-do compile } */ +/* { dg-options "-g -dA" }*/ + +struct A { + int x; + int y; +}; + +int +foo (struct A *a) +{ + return a->x; +} + +/* { dg-final { scan-assembler-not "DWARF version" } } */ +/* { dg-final { scan-assembler "btf_version" } } */ diff --git a/gcc/testsuite/gcc.target/bpf/bpf-debug-options-2.c b/gcc/testsuite/gcc.target/bpf/bpf-debug-options-2.c new file mode 100644 index 00000000000..03bde12315b --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/bpf-debug-options-2.c @@ -0,0 +1,18 @@ +/* -g defaults to BTF, which in turn implies -mco-re. */ +/* { dg-do compile } */ +/* { dg-options "-g -dA" }*/ + +struct A { + int x; + int y; +}; + +int +foo (struct A *a) +{ + return __builtin_preserve_access_index (a->x); +} + +/* { dg-final { scan-assembler-not "DWARF version" } } */ +/* { dg-final { scan-assembler "btf_version" } } */ +/* { dg-final { scan-assembler "btfext_version" } } */ diff --git a/gcc/testsuite/gcc.target/bpf/bpf-debug-options-3.c b/gcc/testsuite/gcc.target/bpf/bpf-debug-options-3.c new file mode 100644 index 00000000000..d41790e0928 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/bpf-debug-options-3.c @@ -0,0 +1,14 @@ +/* Using -g does not incorrectly force CO-RE enabled. */ +/* { dg-do compile } */ +/* { dg-options "-g -dA -mno-co-re" }*/ + +struct A { + int x; + int y; +}; + +int +foo (struct A *a) +{ + return __builtin_preserve_access_index (a->x); /* { dg-error "BPF CO-RE is required" } */ +} diff --git a/gcc/testsuite/gcc.target/bpf/bswap-1.c b/gcc/testsuite/gcc.target/bpf/bswap-1.c index ba19eb60485..2203e426fd4 100644 --- a/gcc/testsuite/gcc.target/bpf/bswap-1.c +++ b/gcc/testsuite/gcc.target/bpf/bswap-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mlittle-endian -mcpu=v3" } */ +/* { dg-options "-mlittle-endian -mcpu=v3 -masm=normal" } */ unsigned short in16 = 0x1234U; unsigned int in32 = 0x12345678U; diff --git a/gcc/testsuite/gcc.target/bpf/bswap-2.c b/gcc/testsuite/gcc.target/bpf/bswap-2.c index e5aef3845d0..9e5044efb94 100644 --- a/gcc/testsuite/gcc.target/bpf/bswap-2.c +++ b/gcc/testsuite/gcc.target/bpf/bswap-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mlittle-endian -mcpu=v4" } */ +/* { dg-options "-mlittle-endian -mcpu=v4 -masm=normal" } */ unsigned short in16 = 0x1234U; unsigned int in32 = 0x12345678U; diff --git a/gcc/testsuite/gcc.target/bpf/btfext-funcinfo-nocore.c b/gcc/testsuite/gcc.target/bpf/btfext-funcinfo-nocore.c index 09d3acc8c2d..e44facf4ef6 100644 --- a/gcc/testsuite/gcc.target/bpf/btfext-funcinfo-nocore.c +++ b/gcc/testsuite/gcc.target/bpf/btfext-funcinfo-nocore.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -dA -gbtf -mno-co-re" } */ +/* { dg-options "-O2 -dA -gbtf -mno-co-re -masm=normal" } */ struct T { int a; diff --git a/gcc/testsuite/gcc.target/bpf/btfext-funcinfo.c b/gcc/testsuite/gcc.target/bpf/btfext-funcinfo.c index a59c5bd37eb..fbbefeae68f 100644 --- a/gcc/testsuite/gcc.target/bpf/btfext-funcinfo.c +++ b/gcc/testsuite/gcc.target/bpf/btfext-funcinfo.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -dA -gbtf" } */ +/* { dg-options "-O2 -dA -gbtf -masm=normal" } */ struct T { int a; @@ -35,8 +35,6 @@ int bar_func (struct T *t) /* { dg-final { scan-assembler-times "label for function foo_func" 1 } } */ /* { dg-final { scan-assembler-times "label for function bar_func" 1 } } */ -/* { dg-final { scan-assembler-times "ascii \"0:2:1:1:3.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ -/* { dg-final { scan-assembler-times "ascii \"0:2:1:2.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"foo_sec.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"bar_sec.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "FuncInfo entry size" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/builtin-load.c b/gcc/testsuite/gcc.target/bpf/builtin-load.c index 0f93d91fb6f..1f51d80079f 100644 --- a/gcc/testsuite/gcc.target/bpf/builtin-load.c +++ b/gcc/testsuite/gcc.target/bpf/builtin-load.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -std=gnu99" } */ +/* { dg-options "-O0 -std=gnu99 -masm=normal" } */ void foo () { diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-1.c b/gcc/testsuite/gcc.target/bpf/core-attr-1.c index 1af9dc5ea6d..a9f153a85a1 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-1.c @@ -2,7 +2,7 @@ for BPF CO-RE support. */ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-2.c b/gcc/testsuite/gcc.target/bpf/core-attr-2.c index 25c819a0082..b66e3c85614 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-2.c @@ -2,7 +2,7 @@ for BPF CO-RE support. */ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ union U { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-3.c b/gcc/testsuite/gcc.target/bpf/core-attr-3.c index b46549f788c..12354fc6f86 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-3.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-3.c @@ -6,7 +6,7 @@ generated. */ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct O { int e; diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-4.c b/gcc/testsuite/gcc.target/bpf/core-attr-4.c index 9c0f966b556..6f025f42f3e 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-4.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-4.c @@ -2,7 +2,7 @@ LHS and both LHS and RHS of assignment. */ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct T { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-5.c b/gcc/testsuite/gcc.target/bpf/core-attr-5.c index 90734dab3a2..81e25fa85de 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-5.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-5.c @@ -2,7 +2,7 @@ LHS and both LHS and RHS of assignment. */ /* { dg-do compile } */ -/* { dg-options "-O2 -dA -gbtf -mco-re" } */ +/* { dg-options "-O2 -dA -gbtf -mco-re -masm=normal" } */ struct U { int c; diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-6.c b/gcc/testsuite/gcc.target/bpf/core-attr-6.c index d0c5371b86e..25215b5ae37 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-6.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-6.c @@ -2,7 +2,7 @@ LHS and both LHS and RHS of assignment. */ /* { dg-do compile } */ -/* { dg-options "-O2 -dA -gbtf -mco-re" } */ +/* { dg-options "-O2 -dA -gbtf -mco-re -masm=normal" } */ struct U { int c; diff --git a/gcc/testsuite/gcc.target/bpf/core-attr-struct-as-array.c b/gcc/testsuite/gcc.target/bpf/core-attr-struct-as-array.c index 3f6eb9cb97f..e34eb3c39be 100644 --- a/gcc/testsuite/gcc.target/bpf/core-attr-struct-as-array.c +++ b/gcc/testsuite/gcc.target/bpf/core-attr-struct-as-array.c @@ -2,7 +2,7 @@ for BPF CO-RE support. */ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-1.c index 3f15980a4c7..b4f9998afb8 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-2.c b/gcc/testsuite/gcc.target/bpf/core-builtin-2.c index c9ec8994ae3..b72e2566b71 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-3.c b/gcc/testsuite/gcc.target/bpf/core-builtin-3.c index 190ec2657d3..251b08ffcd4 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-3.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct T { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-errors.c b/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-errors.c index 138e9989516..65d74f3b9b2 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-errors.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-errors.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ #include "core-support.h" diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-opt.c b/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-opt.c index fc3c299fe9c..0b87c8d39fe 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-opt.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue-opt.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -dA -gbtf -mco-re" } */ +/* { dg-options "-O2 -dA -gbtf -mco-re -masm=normal" } */ #include "core-support.h" diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue.c b/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue.c index 23dfd8a10bf..ceb9987c0d6 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-enumvalue.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ #include "core-support.h" diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-1.c index b8bdeeaa125..8ce4a6e70de 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-2.c b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-2.c index 3a22b99f8e6..e8ae4c82e21 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct T { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-3.c b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-3.c index bccf2b3a696..313f2a7202e 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-3.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct T { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-4.c b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-4.c index 8ef239c30c1..6884c31f86e 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-4.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-exprlist-4.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct T { int a; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-const-elimination.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-const-elimination.c index 5f835487483..1cda6badea5 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-const-elimination.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-const-elimination.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -dA -gbtf -mco-re" } */ +/* { dg-options "-O2 -dA -gbtf -mco-re -masm=normal" } */ struct S { unsigned int a1: 7; @@ -25,5 +25,5 @@ unsigned int foo (struct T *t) return __builtin_preserve_field_info (t->s[0].a1, FIELD_BYTE_OFFSET) + 1; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],4" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],4" 1 } } */ /* { dg-final { scan-assembler-times "\[\t \]add32\[\t \]%r\[0-9\],1" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-1.c index 6f8c320ab8b..8eb24ded84c 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct F { int bar; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-2.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-2.c index 08fbdf01655..b57b1479b6e 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-errors-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct F { int bar; diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-existence-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-existence-1.c index c55f21a9c11..8e775dc8049 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-existence-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-existence-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ enum { FIELD_EXISTENCE = 2, @@ -24,7 +24,7 @@ unsigned int foo (struct S *s) return c + d + u + ar; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],1" 4 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],1" 4 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-be.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-be.c index dabf73dd259..10f8abf2fb3 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-be.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-be.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re -mbig-endian" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -mbig-endian -masm=normal" } */ struct S { int x1: 6; @@ -24,10 +24,10 @@ unsigned int foo (struct S *s) return x1 + x2 + x3 + x4; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],32" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],38" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],41" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],48" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],32" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],38" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],41" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],48" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-le.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-le.c index 99e3982d932..57e390771bd 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-le.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-1-le.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re -mlittle-endian" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -mlittle-endian -masm=normal" } */ struct S { int x1: 6; @@ -24,10 +24,10 @@ unsigned int foo (struct S *s) return x1 + x2 + x3 + x4; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],58" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],55" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],48" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],32" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],58" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],55" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],48" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],32" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-2.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-2.c index 25be969e22b..46db09aed1a 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-lshift-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { char c; @@ -26,9 +26,9 @@ unsigned int foo (union U *u) return s0s + s1c + ll; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],48" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],56" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],0" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],48" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],56" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],0" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0:0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0:1:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-offset-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-offset-1.c index 8b1d8b012a2..7a6a9dec924 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-offset-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-offset-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { unsigned int a1: 7; @@ -46,12 +46,12 @@ unsigned int foo (struct T *t) return s0a1 + s0a4 + s0x + s1a1 + s1a4 + s1x + c + d + e1 + e2 + f1; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],4" 2 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],8" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],12" 3 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],16" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],20" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],21" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],4" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],8" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],12" 3 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],16" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],20" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],21" 2 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1:0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1:0:3.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-1.c index d0c75d944cd..1b6d150aa2a 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int x1: 6; @@ -23,10 +23,10 @@ unsigned int foo (struct S *s) return x1 + x2 + x3 + x4; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],58" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],61" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],57" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],48" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],58" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],61" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],57" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],48" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-2.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-2.c index a71ddc17728..106b686375a 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-rshift-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { int x; @@ -25,8 +25,8 @@ unsigned int foo (union U *u) return sx + sc + i; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],32" 2 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],56" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],32" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],56" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-1.c index 3b2081e197c..f32f116a5b7 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ enum { FIELD_SIGNEDNESS = 3, @@ -23,8 +23,8 @@ unsigned int foo (struct S *s) return d + u + ar; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],1" 2 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],0" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],1" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],0" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:2.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-2.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-2.c index bf184299984..f28915e25cc 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-2.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-sign-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ enum { FIELD_SIGNEDNESS = 3, @@ -35,8 +35,8 @@ unsigned int foo (union U *u) return i + sig + un; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],1" 2 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],0" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],1" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],0" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-size-1.c b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-size-1.c index 8747bdeb9c3..12d3643bd1d 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-size-1.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-fieldinfo-size-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ struct S { unsigned int a1: 7; @@ -29,10 +29,10 @@ unsigned int foo (union U *u) return ls + s + a2 + a3 + ca; } -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],24" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],20" 1 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],4" 2 } } */ -/* { dg-final { scan-assembler-times "\[\t \]mov\[\t \]%r\[0-9\],15" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],24" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],20" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],4" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]lddw\[\t \]%r\[0-9\],15" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:0.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ /* { dg-final { scan-assembler-times "ascii \"0:1.0\"\[\t \]+\[^\n\]*btf_aux_string" 1 } } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-type-based.c b/gcc/testsuite/gcc.target/bpf/core-builtin-type-based.c index 9d818133c08..8f0ccfc0f1f 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-type-based.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-type-based.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ #include "core-support.h" diff --git a/gcc/testsuite/gcc.target/bpf/core-builtin-type-id.c b/gcc/testsuite/gcc.target/bpf/core-builtin-type-id.c index 9576b91bc94..cb0ee1ff6c9 100644 --- a/gcc/testsuite/gcc.target/bpf/core-builtin-type-id.c +++ b/gcc/testsuite/gcc.target/bpf/core-builtin-type-id.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O0 -dA -gbtf -mco-re" } */ +/* { dg-options "-O0 -dA -gbtf -mco-re -masm=normal" } */ #include "core-support.h" diff --git a/gcc/testsuite/gcc.target/bpf/core-options-1.c b/gcc/testsuite/gcc.target/bpf/core-options-1.c new file mode 100644 index 00000000000..7d8c677f239 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/core-options-1.c @@ -0,0 +1,15 @@ +/* -gbtf for the BPF target should enable CO-RE support automatically. */ +/* { dg-do compile } */ +/* { dg-options "-gbtf" } */ + +struct A { + int x; + int y; + char c; +}; + +int +foo (struct A *a) { + int y = __builtin_preserve_access_index (a->y); + return y; +} diff --git a/gcc/testsuite/gcc.target/bpf/core-options-2.c b/gcc/testsuite/gcc.target/bpf/core-options-2.c new file mode 100644 index 00000000000..8f466258e29 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/core-options-2.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-gbtf -gtoggle" } */ + +struct A { + int x; + int y; + char c; +}; + +int +foo (struct A *a) { + int y = __builtin_preserve_access_index (a->y); /* { dg-error "BPF CO-RE is required" } */ + return y; +} diff --git a/gcc/testsuite/gcc.target/bpf/core-options-3.c b/gcc/testsuite/gcc.target/bpf/core-options-3.c new file mode 100644 index 00000000000..ca32a7c4012 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/core-options-3.c @@ -0,0 +1,5 @@ +/* This combination of options tries to enable CO-RE without BTF, and should + produce an error. */ +/* { dg-do compile } */ +/* { dg-options "-gbtf -gtoggle -mco-re" } */ +/* { dg-excess-errors "BPF CO-RE requires BTF debugging information" } */ diff --git a/gcc/testsuite/gcc.target/bpf/core-options-4.c b/gcc/testsuite/gcc.target/bpf/core-options-4.c new file mode 100644 index 00000000000..fde4195da42 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/core-options-4.c @@ -0,0 +1,4 @@ +/* -g implies BTF, -gtoggle turns it off. CO-RE should not work. */ +/* { dg-do compile } */ +/* { dg-options "-g -mco-re -gtoggle" } */ +/* { dg-excess-errors "BPF CO-RE requires BTF debugging information" } */ diff --git a/gcc/testsuite/gcc.target/bpf/double-1.c b/gcc/testsuite/gcc.target/bpf/double-1.c index 200f1bd18f8..ae5d34c4bc2 100644 --- a/gcc/testsuite/gcc.target/bpf/double-1.c +++ b/gcc/testsuite/gcc.target/bpf/double-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mlittle-endian" } */ +/* { dg-options "-mlittle-endian -masm=normal" } */ double f; double a() { f = 1.0; return 1.0; } diff --git a/gcc/testsuite/gcc.target/bpf/double-2.c b/gcc/testsuite/gcc.target/bpf/double-2.c index d04ddd0c575..d87a65c2d91 100644 --- a/gcc/testsuite/gcc.target/bpf/double-2.c +++ b/gcc/testsuite/gcc.target/bpf/double-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mbig-endian" } */ +/* { dg-options "-mbig-endian -masm=normal" } */ double f; double a() { f = 1.0; return 1.0; } diff --git a/gcc/testsuite/gcc.target/bpf/feature-macro-1.c b/gcc/testsuite/gcc.target/bpf/feature-macro-1.c new file mode 100644 index 00000000000..5fa7d3f46a2 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/feature-macro-1.c @@ -0,0 +1,34 @@ +/* { dg-do compile } */ +/* { dg-options "-mcpu=v1 -malu32 -mjmp32 -mjmpext -mbswap -msdiv -msmov" } */ + +#ifndef __BPF_FEATURE_ALU32 +#error __BPF_FEATURE_ALU32 undefined +#endif + +#ifndef __BPF_FEATURE_JMP32 +#error __BPF_FEATURE_JMP32 undefined +#endif + +#ifndef __BPF_FEATURE_JMP_EXT +#error __BPF_FEATURE_JMP_EXT undefined +#endif + +#ifndef __BPF_FEATURE_SDIV_SMOD +#error __BPF_FEATURE_SDIV_SMOD undefined +#endif + +#ifndef __BPF_FEATURE_MOVSX +#error __BPF_FEATURE_MOVSX undefined +#endif + +#ifdef __BPF_FEATURE_LDSX +#error __BPF_FEATURE_LDSX defined with -mcpu=v1 +#endif + +#ifdef __BPF_FEATURE_GOTOL +#error __BPF_FEATURE_GOTOL defined with -mcpu=v4 +#endif + +#ifdef __BPF_FEATURE_ST +#error __BPF_FEATURE_ST defined with -mcpu=v4 +#endif diff --git a/gcc/testsuite/gcc.target/bpf/feature-macro-2.c b/gcc/testsuite/gcc.target/bpf/feature-macro-2.c new file mode 100644 index 00000000000..0ae0fc72f71 --- /dev/null +++ b/gcc/testsuite/gcc.target/bpf/feature-macro-2.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-mcpu=v4" } */ + +#ifndef __BPF_FEATURE_LDSX +#error __BPF_FEATURE_LDSX undefined with -mcpu=v4 +#endif + +#ifndef __BPF_FEATURE_GOTOL +#error __BPF_FEATURE_GOTOL undefined with -mcpu=v4 +#endif + +#ifndef __BPF_FEATURE_ST +#error __BPF_FEATURE_ST undefined with -mcpu=v4 +#endif diff --git a/gcc/testsuite/gcc.target/bpf/float-1.c b/gcc/testsuite/gcc.target/bpf/float-1.c index 05ed7bb651d..ccfb9c44f62 100644 --- a/gcc/testsuite/gcc.target/bpf/float-1.c +++ b/gcc/testsuite/gcc.target/bpf/float-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mlittle-endian" } */ +/* { dg-options "-mlittle-endian -masm=normal" } */ float f; float a() { f = 1.0; return 1.0; } diff --git a/gcc/testsuite/gcc.target/bpf/inline-memops-threshold-1.c b/gcc/testsuite/gcc.target/bpf/inline-memops-threshold-1.c index c2ba4db5b7b..d4ffc5b7f11 100644 --- a/gcc/testsuite/gcc.target/bpf/inline-memops-threshold-1.c +++ b/gcc/testsuite/gcc.target/bpf/inline-memops-threshold-1.c @@ -1,6 +1,6 @@ /* { dg-do compile } */ -/* { dg-options "-O2" "-minline-memops-threshold=256"} */ +/* { dg-options "-O2 -masm=normal -minline-memops-threshold=256" } */ char buf[512]; diff --git a/gcc/testsuite/gcc.target/bpf/jmp-1.c b/gcc/testsuite/gcc.target/bpf/jmp-1.c index eaf825395ef..1fa7307ee0b 100644 --- a/gcc/testsuite/gcc.target/bpf/jmp-1.c +++ b/gcc/testsuite/gcc.target/bpf/jmp-1.c @@ -3,7 +3,7 @@ if -mjmp32 is not enabled. */ /* { dg-do compile } */ -/* { dg-options "-mno-jmpext -mno-jmp32" } */ +/* { dg-options "-mno-jmpext -mno-jmp32 -masm=normal" } */ int foo (int a, int b) { diff --git a/gcc/testsuite/gcc.target/bpf/ldxdw.c b/gcc/testsuite/gcc.target/bpf/ldxdw.c index 72db8f03324..91f2f55ab91 100644 --- a/gcc/testsuite/gcc.target/bpf/ldxdw.c +++ b/gcc/testsuite/gcc.target/bpf/ldxdw.c @@ -2,7 +2,7 @@ with a constant instead of register + offset. */ /* { dg-do compile } */ -/* { dg-options "-O2" } */ +/* { dg-options "-O2 -masm=normal" } */ /* { dg-final { scan-assembler-times "ldxdw\t%r.,\\\[%r.\\+\[0-9\]+\\\]" 1 } } */ /* { dg-final { scan-assembler-not "ldxdw\t%r.,\[0-9\]+" } } */ diff --git a/gcc/testsuite/gcc.target/bpf/neg-1.c b/gcc/testsuite/gcc.target/bpf/neg-1.c index 9ffb956859d..7acc0cab553 100644 --- a/gcc/testsuite/gcc.target/bpf/neg-1.c +++ b/gcc/testsuite/gcc.target/bpf/neg-1.c @@ -1,7 +1,7 @@ /* Check negr and negr32 instructions. */ /* { dg-do compile } */ -/* { dg-options "-malu32" } */ +/* { dg-options "-malu32 -masm=normal" } */ long foo (long a, long b, int x, int y) { diff --git a/gcc/testsuite/gcc.target/bpf/nop-1.c b/gcc/testsuite/gcc.target/bpf/nop-1.c index c4d274f6bad..06914dd10b9 100644 --- a/gcc/testsuite/gcc.target/bpf/nop-1.c +++ b/gcc/testsuite/gcc.target/bpf/nop-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-std=gnu99 --patchable-function-entry=2,1" } */ +/* { dg-options "-std=gnu99 --patchable-function-entry=2,1 -masm=normal" } */ /* The purpose of this test is to make sure the right instruction is generated for NOPs. See bpf.md for a description on why this is diff --git a/gcc/testsuite/gcc.target/bpf/sdiv-1.c b/gcc/testsuite/gcc.target/bpf/sdiv-1.c index ad75b044e1d..a1e51618ee6 100644 --- a/gcc/testsuite/gcc.target/bpf/sdiv-1.c +++ b/gcc/testsuite/gcc.target/bpf/sdiv-1.c @@ -1,6 +1,6 @@ /* Verify that sdiv instruction is used for xBPF. */ /* { dg-do compile } */ -/* { dg-options "-O0 -mcpu=v4" } */ +/* { dg-options "-O0 -mcpu=v4 -masm=normal" } */ void foo () diff --git a/gcc/testsuite/gcc.target/bpf/sload-1.c b/gcc/testsuite/gcc.target/bpf/sload-1.c index d85822932d3..d1dd5b7f4d7 100644 --- a/gcc/testsuite/gcc.target/bpf/sload-1.c +++ b/gcc/testsuite/gcc.target/bpf/sload-1.c @@ -1,6 +1,6 @@ /* Check ISA V4 signed load instructions. */ /* { dg-do compile } */ -/* { dg-options "-mcpu=v4 -O2" } */ +/* { dg-options "-mcpu=v4 -O2 -masm=normal" } */ long foo (char *p1, short *p2, int *p3) { diff --git a/gcc/testsuite/gcc.target/bpf/smod-1.c b/gcc/testsuite/gcc.target/bpf/smod-1.c index c5fc6f7d4b2..5be0bf2856d 100644 --- a/gcc/testsuite/gcc.target/bpf/smod-1.c +++ b/gcc/testsuite/gcc.target/bpf/smod-1.c @@ -1,6 +1,6 @@ /* Verify that smod instruction is used for xBPF. */ /* { dg-do compile } */ -/* { dg-options "-O0 -mcpu=v4" } */ +/* { dg-options "-O0 -mcpu=v4 -masm=normal" } */ void foo () diff --git a/gcc/testsuite/gcc.target/bpf/smov-1.c b/gcc/testsuite/gcc.target/bpf/smov-1.c index ec17ad06fd2..49109a80e3e 100644 --- a/gcc/testsuite/gcc.target/bpf/smov-1.c +++ b/gcc/testsuite/gcc.target/bpf/smov-1.c @@ -1,6 +1,6 @@ /* Check signed mov instructions. */ /* { dg-do compile } */ -/* { dg-options "-mcpu=v4 -O2" } */ +/* { dg-options "-mcpu=v4 -O2 -masm=normal" } */ long foo (char a, short b, int c, unsigned long d) diff --git a/gcc/testsuite/gcc.target/bpf/smov-2.c b/gcc/testsuite/gcc.target/bpf/smov-2.c index 6f3516d2385..2f477ec2819 100644 --- a/gcc/testsuite/gcc.target/bpf/smov-2.c +++ b/gcc/testsuite/gcc.target/bpf/smov-2.c @@ -1,6 +1,6 @@ /* Check signed 32-bit mov instructions. */ /* { dg-do compile } */ -/* { dg-options "-mcpu=v4 -O2" } */ +/* { dg-options "-mcpu=v4 -O2 -masm=normal" } */ int foo (unsigned char a, unsigned short b) diff --git a/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c b/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c index 69949f14d0c..6902aabd337 100644 --- a/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c +++ b/gcc/testsuite/gcc.target/bpf/sync-fetch-and-add.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-options "-masm=normal" } */ long delta; long *val; diff --git a/gcc/testsuite/gcc.target/bpf/xbpf-indirect-call-1.c b/gcc/testsuite/gcc.target/bpf/xbpf-indirect-call-1.c index dc4b3cfb12d..f8ef3fa3178 100644 --- a/gcc/testsuite/gcc.target/bpf/xbpf-indirect-call-1.c +++ b/gcc/testsuite/gcc.target/bpf/xbpf-indirect-call-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mxbpf" } */ +/* { dg-options "-mxbpf -masm=normal" } */ /* GCC should generate an indirect call instruction (call %REG) when targetting xBPF. */ diff --git a/gcc/testsuite/gcc.target/i386/avx10_1-24.c b/gcc/testsuite/gcc.target/i386/avx10_1-24.c new file mode 100644 index 00000000000..2e93f041760 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/avx10_1-24.c @@ -0,0 +1,7 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=x86-64 -mavx10.1" } */ +/* { dg-final { scan-assembler-not "%zmm" } } */ + +typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__)); + +void __attribute__((target("avx10.1-256"))) callee256(__m512 *a, __m512 *b) { *a = *b; } diff --git a/gcc/testsuite/gcc.target/i386/avx2-pr114783.c b/gcc/testsuite/gcc.target/i386/avx2-pr114783.c new file mode 100644 index 00000000000..bc4dc3005fc --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/avx2-pr114783.c @@ -0,0 +1,12 @@ +/* PR target/114783 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mavx2 -mno-avx512f -masm=att" } */ +/* { dg-final { scan-assembler "vpcmpeqd\[ \\t\]+%ymm\[01\], %ymm\[01\], %ymm0" } } */ + +typedef int V __attribute__((vector_size (32))); + +V +foo (V x, V y) +{ + return x == y; +} diff --git a/gcc/testsuite/gcc.target/i386/pr105354-2.c b/gcc/testsuite/gcc.target/i386/pr105354-2.c index b78b62e1e7e..1c592e84860 100644 --- a/gcc/testsuite/gcc.target/i386/pr105354-2.c +++ b/gcc/testsuite/gcc.target/i386/pr105354-2.c @@ -17,7 +17,7 @@ sse2_test (void) b.a[i] = i + 16; res_ab.a[i] = 0; exp_ab.a[i] = -1; - if (i <= 8) + if (i < 8) { c.a[i] = i; d.a[i] = i + 8; diff --git a/gcc/testsuite/gcc.target/i386/zero_extendkmask.c b/gcc/testsuite/gcc.target/i386/zero_extendkmask.c new file mode 100644 index 00000000000..6b18980bbd1 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/zero_extendkmask.c @@ -0,0 +1,43 @@ +/* { dg-do compile { target { ! ia32 } } } */ +/* { dg-options "-march=x86-64-v4 -O2" } */ +/* { dg-final { scan-assembler-not {(?n)shr[bwl]} } } */ +/* { dg-final { scan-assembler-not {(?n)movz[bw]} } } */ + +#include<immintrin.h> + +__m512 +foo (__m512d a, __m512d b, __m512 c, __m512 d) +{ + return _mm512_mask_mov_ps (c, (__mmask16) (_mm512_cmpeq_pd_mask (a, b) >> 1), d); +} + + +__m512i +foo1 (__m512d a, __m512d b, __m512i c, __m512i d) +{ + return _mm512_mask_mov_epi16 (c, (__mmask32) (_mm512_cmpeq_pd_mask (a, b) >> 1), d); +} + +__m512i +foo2 (__m512d a, __m512d b, __m512i c, __m512i d) +{ + return _mm512_mask_mov_epi8 (c, (__mmask64) (_mm512_cmpeq_pd_mask (a, b) >> 1), d); +} + +__m512i +foo3 (__m512 a, __m512 b, __m512i c, __m512i d) +{ + return _mm512_mask_mov_epi16 (c, (__mmask32) (_mm512_cmpeq_ps_mask (a, b) >> 1), d); +} + +__m512i +foo4 (__m512 a, __m512 b, __m512i c, __m512i d) +{ + return _mm512_mask_mov_epi8 (c, (__mmask64) (_mm512_cmpeq_ps_mask (a, b) >> 1), d); +} + +__m512i +foo5 (__m512i a, __m512i b, __m512i c, __m512i d) +{ + return _mm512_mask_mov_epi8 (c, (__mmask64) (_mm512_cmp_epi16_mask (a, b, 5) >> 1), d); +} diff --git a/gcc/testsuite/gcc.target/loongarch/pr114861.c b/gcc/testsuite/gcc.target/loongarch/pr114861.c new file mode 100644 index 00000000000..e6507c406b9 --- /dev/null +++ b/gcc/testsuite/gcc.target/loongarch/pr114861.c @@ -0,0 +1,39 @@ +/* PR114861: ICE building the kernel with -Os + Reduced from linux/fs/ntfs3/attrib.c at revision c942a0cd3603. */ +/* { dg-do compile } */ +/* { dg-options "-Os -march=loongarch64 -msoft-float -mabi=lp64s" } */ + +long evcn, attr_collapse_range_vbo, attr_collapse_range_bytes; +unsigned short flags; +int attr_collapse_range_ni_0_0; +int *attr_collapse_range_mi; +unsigned attr_collapse_range_svcn, attr_collapse_range_vcn1; +void ni_insert_nonresident (unsigned, unsigned short, int **); +int mi_pack_runs (int); +int +attr_collapse_range (void) +{ + _Bool __trans_tmp_1; + int run = attr_collapse_range_ni_0_0; + unsigned evcn1, vcn, end; + short a_flags = flags; + __trans_tmp_1 = flags & (32768 | 1); + if (__trans_tmp_1) + return 2; + vcn = attr_collapse_range_vbo; + end = attr_collapse_range_bytes; + evcn1 = evcn; + for (;;) + if (attr_collapse_range_svcn >= end) + { + unsigned eat, next_svcn = mi_pack_runs (42); + attr_collapse_range_vcn1 = (vcn ? vcn : attr_collapse_range_svcn); + eat = (0 < end) - attr_collapse_range_vcn1; + mi_pack_runs (run - eat); + if (next_svcn + eat) + ni_insert_nonresident (evcn1 - eat - next_svcn, a_flags, + &attr_collapse_range_mi); + } + else + return 42; +} diff --git a/gcc/testsuite/gcc.target/mips/mips-minmax1.c b/gcc/testsuite/gcc.target/mips/mips-minmax1.c new file mode 100644 index 00000000000..087ed299d8f --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mips-minmax1.c @@ -0,0 +1,40 @@ +/* { dg-do compile } */ +/* { dg-options "-mhard-float -fno-finite-math-only -march=mips32r6" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +/* Test MIN.D. */ + +/* { dg-final { scan-assembler "\tmin\\.d\t" } } */ +double +test01 (double x, double y) +{ + return __builtin_fmin (x, y); +} + +/* Test MIN.S. */ + +/* { dg-final { scan-assembler "\tmin\\.s\t" } } */ +float +test02 (float x, float y) +{ + return __builtin_fminf (x, y); +} + +/* Test MAX.D. */ + +/* { dg-final { scan-assembler "\tmax\\.d\t" } } */ +double +test03 (double x, double y) +{ + return __builtin_fmax (x, y); +} + +/* Test MAX.S. */ + +/* { dg-final { scan-assembler "\tmax\\.s\t" } } */ +float +test04 (float x, float y) +{ + return __builtin_fmaxf (x, y); +} + diff --git a/gcc/testsuite/gcc.target/mips/mips-minmax2.c b/gcc/testsuite/gcc.target/mips/mips-minmax2.c new file mode 100644 index 00000000000..5359043f06f --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mips-minmax2.c @@ -0,0 +1,36 @@ +/* { dg-do compile } */ +/* { dg-options "-mhard-float -march=mips32r6" } */ +/* { dg-skip-if "code quality test" { *-*-* } { "-O0" } { "" } } */ + +extern double fmin (double, double); +extern double fmax (double, double); +extern float fminf (float, float); +extern float fmaxf (float, float); + +/* Test MIN.D. */ + +/* { dg-final { scan-assembler "\tmin\\.d\t" } } */ +double test01 (double x, double y) { + return fmin (x, y); +} + +/* Test MIN.S. */ + +/* { dg-final { scan-assembler "\tmin\\.s\t" } } */ +float test02 (float x, float y) { + return fminf (x, y); +} + +/* Test MAX.D. */ + +/* { dg-final { scan-assembler "\tmax\\.d\t" } } */ +double test03 (double x, double y) { + return fmax (x, y); +} + +/* Test MAX.S. */ + +/* { dg-final { scan-assembler "\tmax\\.s\t" } } */ +float test04 (float x, float y) { + return fmaxf (x, y); +} diff --git a/gcc/testsuite/gcc.target/powerpc/bcd-4.c b/gcc/testsuite/gcc.target/powerpc/bcd-4.c index 2c7041c4d32..6d2c59ef792 100644 --- a/gcc/testsuite/gcc.target/powerpc/bcd-4.c +++ b/gcc/testsuite/gcc.target/powerpc/bcd-4.c @@ -2,8 +2,8 @@ /* { dg-require-effective-target int128 } */ /* { dg-require-effective-target p9vector_hw } */ /* { dg-options "-mdejagnu-cpu=power9 -O2 -save-temps" } */ -/* { dg-final { scan-assembler-times {\mbcdadd\M} 7 } } */ -/* { dg-final { scan-assembler-times {\mbcdsub\M} 18 } } */ +/* { dg-final { scan-assembler-times {\mbcdadd\M} 5 } } */ +/* { dg-final { scan-assembler-times {\mbcdsub\M} 20 } } */ /* { dg-final { scan-assembler-times {\mbcds\M} 2 } } */ /* { dg-final { scan-assembler-times {\mdenbcdq\M} 1 } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr106680-1.c b/gcc/testsuite/gcc.target/powerpc/pr106680-1.c index d624d43230a..aadaa614cfe 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr106680-1.c +++ b/gcc/testsuite/gcc.target/powerpc/pr106680-1.c @@ -8,6 +8,6 @@ int foo () return 1; } -/* { dg-error "'-m64' requires a PowerPC64 cpu" "PR106680" { target powerpc*-*-linux* powerpc*-*-freebsd* powerpc-*-rtems* } 0 } */ +/* { dg-error "'-m64' requires a PowerPC64 cpu" "PR106680" { target powerpc*-*-linux* powerpc*-*-freebsd* powerpc-*-rtems* powerpc*-*-vxworks* } 0 } */ /* { dg-warning "'-m64' requires PowerPC64 architecture, enabling" "PR106680" { target powerpc*-*-darwin* } 0 } */ /* { dg-warning "'-maix64' requires PowerPC64 architecture remain enabled" "PR106680" { target powerpc*-*-aix* } 0 } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr106680-2.c b/gcc/testsuite/gcc.target/powerpc/pr106680-2.c index a9ed73726ef..f0758e30335 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr106680-2.c +++ b/gcc/testsuite/gcc.target/powerpc/pr106680-2.c @@ -9,6 +9,6 @@ int foo () return 1; } -/* { dg-error "'-m64' requires a PowerPC64 cpu" "PR106680" { target powerpc*-*-linux* powerpc*-*-freebsd* powerpc-*-rtems* } 0 } */ +/* { dg-error "'-m64' requires a PowerPC64 cpu" "PR106680" { target powerpc*-*-linux* powerpc*-*-freebsd* powerpc-*-rtems* powerpc*-*-vxworks* } 0 } */ /* { dg-warning "'-m64' requires PowerPC64 architecture, enabling" "PR106680" { target powerpc*-*-darwin* } 0 } */ /* { dg-warning "'-maix64' requires PowerPC64 architecture remain enabled" "PR106680" { target powerpc*-*-aix* } 0 } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr106680-3.c b/gcc/testsuite/gcc.target/powerpc/pr106680-3.c index b642d5c7a00..bca012e2cf6 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr106680-3.c +++ b/gcc/testsuite/gcc.target/powerpc/pr106680-3.c @@ -8,6 +8,6 @@ int foo () return 1; } -/* { dg-error "'-m64' requires a PowerPC64 cpu" "PR106680" { target powerpc*-*-linux* powerpc*-*-freebsd* powerpc-*-rtems* } 0 } */ +/* { dg-error "'-m64' requires a PowerPC64 cpu" "PR106680" { target powerpc*-*-linux* powerpc*-*-freebsd* powerpc-*-rtems* powerpc*-*-vxworks* } 0 } */ /* { dg-warning "'-m64' requires PowerPC64 architecture, enabling" "PR106680" { target powerpc*-*-darwin* } 0 } */ /* { dg-warning "'-maix64' requires PowerPC64 architecture remain enabled" "PR106680" { target powerpc*-*-aix* } 0 } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr46728-10.c b/gcc/testsuite/gcc.target/powerpc/pr46728-10.c index 3be4728d333..c04a3101c11 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr46728-10.c +++ b/gcc/testsuite/gcc.target/powerpc/pr46728-10.c @@ -1,6 +1,6 @@ /* { dg-do run } */ -/* { dg-skip-if "-mpowerpc-gpopt not supported" { powerpc*-*-darwin* } } */ /* { dg-options "-O2 -ffast-math -fno-inline -fno-unroll-loops -lm -mpowerpc-gpopt" } */ +/* { dg-require-effective-target sqrt_insn } */ #include <math.h> diff --git a/gcc/testsuite/gcc.target/powerpc/pr46728-11.c b/gcc/testsuite/gcc.target/powerpc/pr46728-11.c index 43b6728a4b8..d0e3d602121 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr46728-11.c +++ b/gcc/testsuite/gcc.target/powerpc/pr46728-11.c @@ -1,6 +1,6 @@ /* { dg-do run } */ -/* { dg-skip-if "-mpowerpc-gpopt not supported" { powerpc*-*-darwin* } } */ /* { dg-options "-O2 -ffast-math -fno-inline -fno-unroll-loops -lm -mpowerpc-gpopt" } */ +/* { dg-require-effective-target sqrt_insn } */ #include <math.h> diff --git a/gcc/testsuite/gcc.target/powerpc/pr46728-13.c b/gcc/testsuite/gcc.target/powerpc/pr46728-13.c index b9fd63973b7..2b9df737a9b 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr46728-13.c +++ b/gcc/testsuite/gcc.target/powerpc/pr46728-13.c @@ -1,6 +1,6 @@ /* { dg-do run } */ -/* { dg-skip-if "-mpowerpc-gpopt not supported" { powerpc*-*-darwin* } } */ /* { dg-options "-O2 -ffast-math -fno-inline -fno-unroll-loops -lm -mpowerpc-gpopt" } */ +/* { dg-require-effective-target sqrt_insn } */ #include <math.h> diff --git a/gcc/testsuite/gcc.target/powerpc/pr46728-14.c b/gcc/testsuite/gcc.target/powerpc/pr46728-14.c index 5affff13bdb..e6836f515e4 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr46728-14.c +++ b/gcc/testsuite/gcc.target/powerpc/pr46728-14.c @@ -1,6 +1,6 @@ /* { dg-do run } */ -/* { dg-skip-if "-mpowerpc-gpopt not supported" { powerpc*-*-darwin* } } */ /* { dg-options "-O2 -ffast-math -fno-inline -fno-unroll-loops -lm -mpowerpc-gpopt" } */ +/* { dg-require-effective-target sqrt_insn } */ #include <math.h> diff --git a/gcc/testsuite/gcc.target/powerpc/swaps-p8-20.c b/gcc/testsuite/gcc.target/powerpc/swaps-p8-20.c index 564e8acb1f4..755519bfe84 100644 --- a/gcc/testsuite/gcc.target/powerpc/swaps-p8-20.c +++ b/gcc/testsuite/gcc.target/powerpc/swaps-p8-20.c @@ -1,5 +1,5 @@ /* { dg-do run } */ -/* { dg-require-effective-target powerpc_altivec_ok } */ +/* { dg-require-effective-target vmx_hw } */ /* { dg-options "-O2 -mdejagnu-cpu=power8 -maltivec" } */ /* The expansion for vector character multiply introduces a vperm operation. diff --git a/gcc/testsuite/gcc.target/powerpc/vec-mul.c b/gcc/testsuite/gcc.target/powerpc/vec-mul.c index bfcaf80719d..aa0ef7aa45a 100644 --- a/gcc/testsuite/gcc.target/powerpc/vec-mul.c +++ b/gcc/testsuite/gcc.target/powerpc/vec-mul.c @@ -1,5 +1,5 @@ -/* { dg-do run } */ -/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-do compile { target { { ! vsx_hw } && powerpc_vsx_ok } } } */ +/* { dg-do run { target vsx_hw } } */ /* { dg-options "-mvsx -O3" } */ /* Test that the vec_mul builtin works as expected. */ diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-5.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-5.c index dcc88b1f3a4..37a324b6f89 100644 --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-5.c +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-5.c @@ -1,11 +1,8 @@ /* { dg-do run { target lp64 } } */ /* { dg-skip-if "" { powerpc*-*-darwin* } } */ -/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-require-effective-target vsx_hw } */ /* { dg-options "-mvsx -O2" } */ -/* This will run, and someday we should add the support to test whether we are - running on VSX hardware. */ - #include <altivec.h> #include <stdlib.h> diff --git a/gcc/testsuite/gcc.target/riscv/fix.c b/gcc/testsuite/gcc.target/riscv/fix.c new file mode 100644 index 00000000000..265a7da1fc5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/fix.c @@ -0,0 +1,34 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gc -mabi=lp64d" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } } */ + +int +foo (double n) +{ + return n; +} + +int +foo_1 (float n) +{ + return n; +} + +unsigned int +foo_2 (double n) +{ + return n; +} + +unsigned int +foo_3 (float n) +{ + return n; +} + +/* { dg-final { scan-assembler-times {\mfcvt.w.d} 1 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.w.s} 1 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.wu.d} 1 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.wu.s} 1 } } */ +/* { dg-final { scan-assembler-not "\\ssext.w\\s" } } */ + diff --git a/gcc/testsuite/gcc.target/riscv/round.c b/gcc/testsuite/gcc.target/riscv/round.c new file mode 100644 index 00000000000..decfc82a390 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/round.c @@ -0,0 +1,144 @@ +#include <math.h> + +extern void abort (void); +extern void exit (int); + +#define NEQ(a, b) (fabs((a) - (b)) > 0.000001) + +#define DECL_FUNC(TYPE1, TYPE2, ROUND) \ + __attribute__ ((noinline, noclone)) TYPE2 \ + convert_##TYPE1##_to_##TYPE2##_##ROUND (TYPE1 N) \ + { \ + return ROUND (N); \ + } + +#define DECL_ALL_ROUNDS_FOR(ROUND_FUNC) \ + DECL_FUNC(float, float, ROUND_FUNC) \ + DECL_FUNC(double, double, ROUND_FUNC) \ + DECL_FUNC(double, int, ROUND_FUNC) \ + DECL_FUNC(double, long, ROUND_FUNC) \ + DECL_FUNC(float, int, ROUND_FUNC) \ + DECL_FUNC(float, long, ROUND_FUNC) + + +DECL_ALL_ROUNDS_FOR(round) +DECL_ALL_ROUNDS_FOR(ceil) +DECL_ALL_ROUNDS_FOR(floor) +DECL_ALL_ROUNDS_FOR(trunc) +DECL_ALL_ROUNDS_FOR(nearbyint) + +#define TEST_ROUND(TYPE1, TYPE2, N, N_R, ROUND) \ + if (NEQ (convert_##TYPE1##_to_##TYPE2##_##ROUND (N), N_R)) \ + abort (); + + +int main () { + + /* Round */ + TEST_ROUND(double, double, -4.8, -5.0, round); + TEST_ROUND(double, double, -4.2, -4.0, round); + TEST_ROUND(double, double, 4.8, 5.0, round); + TEST_ROUND(double, double, 4.2, 4.0, round); + + TEST_ROUND(double, int, -4.8, -5, round); + TEST_ROUND(double, int, -4.2, -4, round); + TEST_ROUND(double, int, 4.8, 5, round); + TEST_ROUND(double, int, 4.2, 4, round); + + TEST_ROUND(double, long, -4.8, -5, round); + TEST_ROUND(double, long, -4.2, -4, round); + TEST_ROUND(double, long, 4.8, 5, round); + TEST_ROUND(double, long, 4.2, 4, round); + + TEST_ROUND(float, long, -4.8, -5, round); + TEST_ROUND(float, long, -4.2, -4, round); + TEST_ROUND(float, long, 4.8, 5, round); + TEST_ROUND(float, long, 4.2, 4, round); + + /* Ceil */ + TEST_ROUND(double, double, -4.8, -4.0, ceil); + TEST_ROUND(double, double, -4.2, -4.0, ceil); + TEST_ROUND(double, double, 4.8, 5.0, ceil); + TEST_ROUND(double, double, 4.2, 5.0, ceil); + + TEST_ROUND(double, int, -4.8, -4, ceil); + TEST_ROUND(double, int, -4.2, -4, ceil); + TEST_ROUND(double, int, 4.8, 5, ceil); + TEST_ROUND(double, int, 4.2, 5, ceil); + + TEST_ROUND(double, long, -4.8, -4, ceil); + TEST_ROUND(double, long, -4.2, -4, ceil); + TEST_ROUND(double, long, 4.8, 5, ceil); + TEST_ROUND(double, long, 4.2, 5, ceil); + + TEST_ROUND(float, long, -4.8, -4, ceil); + TEST_ROUND(float, long, -4.2, -4, ceil); + TEST_ROUND(float, long, 4.8, 5, ceil); + TEST_ROUND(float, long, 4.2, 5, ceil); + + /* Floor */ + TEST_ROUND(double, double, -4.8, -5.0, floor); + TEST_ROUND(double, double, -4.2, -5.0, floor); + TEST_ROUND(double, double, 4.8, 4.0, floor); + TEST_ROUND(double, double, 4.2, 4.0, floor); + + TEST_ROUND(double, int, -4.8, -5, floor); + TEST_ROUND(double, int, -4.2, -5, floor); + TEST_ROUND(double, int, 4.8, 4, floor); + TEST_ROUND(double, int, 4.2, 4, floor); + + TEST_ROUND(double, long, -4.8, -5, floor); + TEST_ROUND(double, long, -4.2, -5, floor); + TEST_ROUND(double, long, 4.8, 4, floor); + TEST_ROUND(double, long, 4.2, 4, floor); + + TEST_ROUND(float, long, -4.8, -5, floor); + TEST_ROUND(float, long, -4.2, -5, floor); + TEST_ROUND(float, long, 4.8, 4, floor); + TEST_ROUND(float, long, 4.2, 4, floor); + + /* Trunc */ + TEST_ROUND(double, double, -4.8, -4.0, trunc); + TEST_ROUND(double, double, -4.2, -4.0, trunc); + TEST_ROUND(double, double, 4.8, 4.0, trunc); + TEST_ROUND(double, double, 4.2, 4.0, trunc); + + TEST_ROUND(double, int, -4.8, -4, trunc); + TEST_ROUND(double, int, -4.2, -4, trunc); + TEST_ROUND(double, int, 4.8, 4, trunc); + TEST_ROUND(double, int, 4.2, 4, trunc); + + TEST_ROUND(double, long, -4.8, -4, trunc); + TEST_ROUND(double, long, -4.2, -4, trunc); + TEST_ROUND(double, long, 4.8, 4, trunc); + TEST_ROUND(double, long, 4.2, 4, trunc); + + TEST_ROUND(float, long, -4.8, -4, trunc); + TEST_ROUND(float, long, -4.2, -4, trunc); + TEST_ROUND(float, long, 4.8, 4, trunc); + TEST_ROUND(float, long, 4.2, 4, trunc); + + /* Nearbyint */ + TEST_ROUND(double, double, -4.8, -5.0, nearbyint); + TEST_ROUND(double, double, -4.2, -4.0, nearbyint); + TEST_ROUND(double, double, 4.8, 5.0, nearbyint); + TEST_ROUND(double, double, 4.2, 4.0, nearbyint); + + TEST_ROUND(double, int, -4.8, -5, nearbyint); + TEST_ROUND(double, int, -4.2, -4, nearbyint); + TEST_ROUND(double, int, 4.8, 5, nearbyint); + TEST_ROUND(double, int, 4.2, 4, nearbyint); + + TEST_ROUND(double, long, -4.8, -5, nearbyint); + TEST_ROUND(double, long, -4.2, -4, nearbyint); + TEST_ROUND(double, long, 4.8, 5, nearbyint); + TEST_ROUND(double, long, 4.2, 4, nearbyint); + + TEST_ROUND(float, long, -4.8, -5, nearbyint); + TEST_ROUND(float, long, -4.2, -4, nearbyint); + TEST_ROUND(float, long, 4.8, 5, nearbyint); + TEST_ROUND(float, long, 4.2, 4, nearbyint); + + exit(0); +} + diff --git a/gcc/testsuite/gcc.target/riscv/round_32.c b/gcc/testsuite/gcc.target/riscv/round_32.c new file mode 100644 index 00000000000..f9fea70ad55 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/round_32.c @@ -0,0 +1,22 @@ +/* { dg-do compile { target { riscv32*-*-* } } } */ +/* { dg-options "-march=rv32gc -mabi=ilp32d -fno-math-errno -funsafe-math-optimizations -fno-inline" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" "-Og" } } */ + +#include "round.c" + +/* { dg-final { scan-assembler-times {\mfcvt.w.s} 15 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.s.w} 5 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.d.w} 65 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.w.d} 15 } } */ +/* { dg-final { scan-assembler-times {,rup} 6 } } */ +/* { dg-final { scan-assembler-times {,rmm} 6 } } */ +/* { dg-final { scan-assembler-times {,rdn} 6 } } */ +/* { dg-final { scan-assembler-times {,rtz} 6 } } */ +/* { dg-final { scan-assembler-not {\mfcvt.l.d} } } */ +/* { dg-final { scan-assembler-not {\mfcvt.d.l} } } */ +/* { dg-final { scan-assembler-not "\\sceil\\s" } } */ +/* { dg-final { scan-assembler-not "\\sfloor\\s" } } */ +/* { dg-final { scan-assembler-not "\\sround\\s" } } */ +/* { dg-final { scan-assembler-not "\\snearbyint\\s" } } */ +/* { dg-final { scan-assembler-not "\\srint\\s" } } */ +/* { dg-final { scan-assembler-not "\\stail\\s" } } */ diff --git a/gcc/testsuite/gcc.target/riscv/round_64.c b/gcc/testsuite/gcc.target/riscv/round_64.c new file mode 100644 index 00000000000..e79690979a5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/round_64.c @@ -0,0 +1,23 @@ +/* { dg-do compile { target { riscv64*-*-* } } } */ +/* { dg-options "-march=rv64gc -mabi=lp64d -fno-math-errno -funsafe-math-optimizations -fno-inline" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" "-Og" } } */ + +#include "round.c" + +/* { dg-final { scan-assembler-times {\mfcvt.w.s} 10 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.s.w} 5 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.l.d} 10 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.d.l} 45 } } */ +/* { dg-final { scan-assembler-times {\mfcvt.w.d} 5 } } */ +/* { dg-final { scan-assembler-times {,rup} 6 } } */ +/* { dg-final { scan-assembler-times {,rmm} 6 } } */ +/* { dg-final { scan-assembler-times {,rdn} 6 } } */ +/* { dg-final { scan-assembler-times {,rtz} 6 } } */ +/* { dg-final { scan-assembler-not "\\sceil\\s" } } */ +/* { dg-final { scan-assembler-not "\\sfloor\\s" } } */ +/* { dg-final { scan-assembler-not "\\sround\\s" } } */ +/* { dg-final { scan-assembler-not "\\snearbyint\\s" } } */ +/* { dg-final { scan-assembler-not "\\srint\\s" } } */ +/* { dg-final { scan-assembler-not "\\stail\\s" } } */ +/* { dg-final { scan-assembler-not "\\ssext.w\\s" } } */ + diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-1.c index 6b9a7c448f0..6f9c6f7bd8c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-1.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-1.c @@ -101,4 +101,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-10.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-10.c index 5f161b31fa1..5d3f2fbe46d 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-10.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-10.c @@ -101,4 +101,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-11.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-11.c index 82827d14e34..6a2301b523f 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-11.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-11.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-12.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-12.c index c4ae60755ea..0f3eb4d58de 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-12.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-12.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-13.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-13.c index fde7076d34f..71786995c56 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-13.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-13.c @@ -185,4 +185,4 @@ foo2 (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-16.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-16.c index 98f42458883..42d11611d98 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-16.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-16.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-17.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-17.c index 9b60005344d..9ecc62e234b 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-17.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-17.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-18.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-18.c index dd65b2fa098..4365fe0af54 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-18.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-18.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-2.c index da92d59406f..b99dd19e623 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-2.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-2.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-22.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-22.c index 90db18217bb..ac56703c75c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-22.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-22.c @@ -185,4 +185,4 @@ foo2 (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-23.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-23.c index ee0b928e9df..f91119307f4 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-23.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-23.c @@ -116,4 +116,4 @@ foo2 (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-24.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-24.c index 603e2941cd3..bcd60c0a7c3 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-24.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-24.c @@ -83,4 +83,4 @@ foo2 (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-25.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-25.c index 0b52b9f24eb..57a8ef28486 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-25.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-25.c @@ -101,4 +101,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-26.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-26.c index d21a73765ed..0f05e2b2e1d 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-26.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-26.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-27.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-27.c index 2423f7b33ee..d640bcf74ba 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-27.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-27.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-28.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-28.c index d81afd2610f..c16cbdfe9f9 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-28.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-28.c @@ -101,4 +101,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-29.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-29.c index 2f8adb8ebee..cee6afafe87 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-29.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-29.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-3.c index 46f93a9049b..cac50bd003c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-3.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-3.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-30.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-30.c index d3ce98852db..f2e23628022 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-30.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-30.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-31.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-31.c index 72b928a579b..2cf006bd4c9 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-31.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-31.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-32.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-32.c index 273c5fca642..284b7a2891c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-32.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-32.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-33.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-33.c index a5c2ad1de62..82baf0fadb3 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-33.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-33.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-37.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-37.c index 6337ff875fe..66e81ea905a 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-37.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-37.c @@ -97,7 +97,7 @@ foo9 (void *in, void *out) } /* { dg-final { scan-assembler-not {vmv1r} } } */ -/* { dg-final { scan-assembler-not {vmv2r} } } */ -/* { dg-final { scan-assembler-not {vmv4r} } } */ -/* { dg-final { scan-assembler-not {vmv8r} } } */ +/* { dg-final { scan-assembler-not {vmv2r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {vmv4r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {vmv8r} { xfail riscv*-*-* } } } */ /* { dg-final { scan-assembler-not {csrr} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-38.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-38.c index 7b7d6cc7e98..a0cf9afc88e 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-38.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-38.c @@ -75,8 +75,8 @@ foo6 (void *in, void *out) __riscv_vse64_v_f64m8 (out, result, 4); } -/* { dg-final { scan-assembler-not {vmv1r} } } */ -/* { dg-final { scan-assembler-not {vmv2r} } } */ -/* { dg-final { scan-assembler-not {vmv4r} } } */ -/* { dg-final { scan-assembler-not {vmv8r} } } */ +/* { dg-final { scan-assembler-not {vmv1r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {vmv2r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {vmv4r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {vmv8r} { xfail riscv*-*-* } } } */ /* { dg-final { scan-assembler-not {csrr} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-39.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-39.c index 47820dd29f0..1234718bb35 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-39.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-39.c @@ -152,7 +152,7 @@ foo2 (void *in, void *out, int n) } /* { dg-final { scan-assembler-not {vmv1r} } } */ -/* { dg-final { scan-assembler-not {vmv2r} } } */ +/* { dg-final { scan-assembler-not {vmv2r} { xfail riscv*-*-* } } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-4.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-4.c index 4cc6aa68b13..cecf796e10c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-4.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-4.c @@ -101,4 +101,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-40.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-40.c index e44b8010579..5d6577cfe6e 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-40.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-40.c @@ -89,6 +89,6 @@ foo2 (void *in, void *out, int n) /* { dg-final { scan-assembler-not {vmv1r} } } */ /* { dg-final { scan-assembler-not {vmv2r} } } */ -/* { dg-final { scan-assembler-not {vmv4r} } } */ +/* { dg-final { scan-assembler-not {vmv4r} { xfail riscv*-*-* } } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-41.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-41.c index dc27006f6f9..c31144c05b5 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-41.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-41.c @@ -58,5 +58,5 @@ foo2 (void *in, void *out, int n) /* { dg-final { scan-assembler-not {vmv1r} } } */ /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ -/* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {vmv8r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c index 1ee5b20a899..fa5dac58a20 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c @@ -21,7 +21,7 @@ reduc_plus_float (float *__restrict a, int n) return r; } -/* { dg-final { scan-assembler-not {vmv1r} } } */ +/* { dg-final { scan-assembler-not {vmv1r} { xfail riscv*-*-* } } } */ /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-5.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-5.c index f7d668c624b..b34a835b965 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-5.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-5.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-6.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-6.c index 3eed1198a70..95af07166a3 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-6.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-6.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-7.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-7.c index 7064471496c..59cbd7ff4be 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-7.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-7.c @@ -101,6 +101,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ - - +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-8.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-8.c index ab56d0d69af..3a8ca02bd21 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-8.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-8.c @@ -65,4 +65,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-9.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-9.c index 82f369c0cd9..88ab1d9da5c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-9.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-9.c @@ -48,4 +48,4 @@ foo (char const *buf, size_t len) /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ -/* { dg-final { scan-assembler-not {csrr} } } */ +/* { dg-final { scan-assembler-not {csrr} { xfail riscv*-*-* } } } */ diff --git a/gcc/testsuite/gcc.target/s390/vxe/popcount-1.c b/gcc/testsuite/gcc.target/s390/vxe/popcount-1.c index 9ea835a1cf0..25ef354f963 100644 --- a/gcc/testsuite/gcc.target/s390/vxe/popcount-1.c +++ b/gcc/testsuite/gcc.target/s390/vxe/popcount-1.c @@ -21,7 +21,7 @@ vpopctb (uv16qi a) return r; } -/* { dg-final { scan-assembler "vpopctb\t%v24,%v24" { xfail *-*-* } } } */ +/* { dg-final { scan-assembler "vpopctb\t%v24,%v24" } } */ uv8hi __attribute__((noinline)) vpopcth (uv8hi a) @@ -34,7 +34,7 @@ vpopcth (uv8hi a) return r; } -/* { dg-final { scan-assembler "vpopcth\t%v24,%v24" { xfail *-*-* } } } */ +/* { dg-final { scan-assembler "vpopcth\t%v24,%v24" } } */ uv4si __attribute__((noinline)) vpopctf (uv4si a) diff --git a/gcc/testsuite/gcc.target/s390/zvector/pr114676.c b/gcc/testsuite/gcc.target/s390/zvector/pr114676.c new file mode 100644 index 00000000000..bdc66b2920a --- /dev/null +++ b/gcc/testsuite/gcc.target/s390/zvector/pr114676.c @@ -0,0 +1,19 @@ +/* { dg-do run { target { s390*-*-* } } } */ +/* { dg-options "-O3 -mzarch -march=z14 -mzvector" } */ + +#include <vecintrin.h> + +void __attribute__((noinline)) foo (int *mem) +{ + vec_xst ((vector float){ 1.0f, 2.0f, 3.0f, 4.0f }, 0, (float*)mem); +} + +int +main () +{ + int m[4] = { 0 }; + foo (m); + if (m[3] == 0) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.target/sparc/pr105573.c b/gcc/testsuite/gcc.target/sparc/20230425-1.c index 14043a5fdad..c07dd3261fc 100644 --- a/gcc/testsuite/gcc.target/sparc/pr105573.c +++ b/gcc/testsuite/gcc.target/sparc/20230425-1.c @@ -1,3 +1,6 @@ +/* PR target/105573 */ +/* Reported by Sam James <sjames@gcc.gnu.org> */ + /* { dg-do compile } */ /* { dg-options "-O3 -mvis3" } */ diff --git a/gcc/testsuite/gcc.target/sparc/pr109541.c b/gcc/testsuite/gcc.target/sparc/20230607-1.c index 1360f101930..3613dca602f 100644 --- a/gcc/testsuite/gcc.target/sparc/pr109541.c +++ b/gcc/testsuite/gcc.target/sparc/20230607-1.c @@ -1,3 +1,6 @@ +/* PR target.109541 */ +/* Reported by Sam James <sjames@gcc.gnu.org> */ + /* { dg-do compile } */ /* { dg-options "-O1 -mcpu=niagara4 -fpic -w" } */ diff --git a/gcc/testsuite/gcc.target/sparc/small-struct-1.c b/gcc/testsuite/gcc.target/sparc/small-struct-1.c new file mode 100644 index 00000000000..4897288766b --- /dev/null +++ b/gcc/testsuite/gcc.target/sparc/small-struct-1.c @@ -0,0 +1,46 @@ +/* PR target/114416 */ +/* Reported by Rainer Orth <ro@gcc.gnu.org> */ + +/* { dg-do compile } */ +/* { dg-options "-O" } */ +/* { dg-require-effective-target lp64 } */ + +struct vec2 +{ + double x[2]; +}; + +struct vec2x +{ + double x; + double y; +}; + +struct vec2 sum2 (double val) +{ + struct vec2 v; + v.x[0] = val; + v.x[1] = val; + return v; +} + +struct vec2x sum2x (double val) +{ + struct vec2x v; + v.x = val; + v.y = val; + return v; +} + +double get2 (struct vec2 v) +{ + return v.x[0] + v.x[1]; +} + +double get2x (struct vec2x v) +{ + return v.x + v.y; +} + +/* { dg-final { scan-assembler-not "ldx" } } */ +/* { dg-final { scan-assembler-not "stx" } } */ diff --git a/gcc/testsuite/gdc.dg/pr111650.d b/gcc/testsuite/gdc.dg/pr111650.d new file mode 100644 index 00000000000..4298a76d38f --- /dev/null +++ b/gcc/testsuite/gdc.dg/pr111650.d @@ -0,0 +1,21 @@ +// { dg-do compile } +ref V require(K, V)(ref V[K] aa, K key, lazy V value); + +struct Root +{ + ulong[3] f; +} + +Root[ulong] roots; + +Root getRoot(int fd, ulong rootID) +{ + return roots.require(rootID, + { + Root result; + inoLookup(fd, () => result); + return result; + }()); +} + +void inoLookup(int, scope Root delegate()) { } diff --git a/gcc/testsuite/gfortran.dg/c_sizeof_8.f90 b/gcc/testsuite/gfortran.dg/c_sizeof_8.f90 new file mode 100644 index 00000000000..0ae284436d0 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/c_sizeof_8.f90 @@ -0,0 +1,23 @@ +! { dg-do run } +! +! PR fortran/103496 +! +! Test that C_SIZEOF returns the expected results + +program pr103496 + use iso_c_binding + implicit none + integer :: a(6) + integer, pointer :: p(:) + + if (c_sizeof(a) /= 6*4) stop 1 + if (c_sizeof(a(1)) /= 4) stop 2 + if (c_sizeof(a(:)) /= 6*4) stop 3 + if (c_sizeof(a(2::2)) /= 3*4) stop 4 + + allocate(p(5)) + if (c_sizeof(p) /= 5*4) stop 5 + if (c_sizeof(p(1)) /= 4) stop 6 + if (c_sizeof(p(:)) /= 5*4) stop 7 + if (c_sizeof(p(2::2)) /= 2*4) stop 8 +end diff --git a/gcc/testsuite/gfortran.dg/gomp/pr114825.f90 b/gcc/testsuite/gfortran.dg/gomp/pr114825.f90 new file mode 100644 index 00000000000..b635476af61 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/pr114825.f90 @@ -0,0 +1,16 @@ +! PR fortran/114825 + +subroutine pr114825(b) + type t + real, allocatable :: m(:) + end type t + type(t), allocatable, target :: b(:) + type(t), pointer :: d + !$omp parallel private(d) + d => b(1) + !$omp end parallel +contains + subroutine sub + d => b(1) + end subroutine sub +end subroutine pr114825 diff --git a/gcc/testsuite/gfortran.dg/iso_fortran_env_8.f90 b/gcc/testsuite/gfortran.dg/iso_fortran_env_8.f90 new file mode 100644 index 00000000000..d3661b3b592 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/iso_fortran_env_8.f90 @@ -0,0 +1,32 @@ +! { dg-do run } +! +! Check for the new Fortran 2023 ISO_FORTRAN_ENV named constants + +program test + use iso_fortran_env + implicit none + + ! These integer kinds are guaranteed on + integer(int8) :: i8 + integer(int16) :: i16 + integer(int32) :: i32 + integer(int64) :: i64 + + logical(logical8) :: l8 + logical(logical16) :: l16 + logical(logical32) :: l32 + logical(logical64) :: l64 + + ! We do not support REAL16 for now, but check it can + ! still be used in specification expressions + real(kind=max(real16, real32)) :: x + + if (logical8 /= int8) stop 1 + if (logical16 /= int16) stop 2 + if (logical32 /= int32) stop 3 + if (logical64 /= int64) stop 4 + + ! We do not support REAL16 for now + if (real16 /= -2) stop 101 + +end program test diff --git a/gcc/testsuite/gfortran.dg/iso_fortran_env_9.f90 b/gcc/testsuite/gfortran.dg/iso_fortran_env_9.f90 new file mode 100644 index 00000000000..ffd70b23159 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/iso_fortran_env_9.f90 @@ -0,0 +1,29 @@ +! { dg-do compile } +! { dg-options "-std=f2018" } +! +! Check diagnostics for new F2023 named constants +! in ISO_FORTRAN_ENV +! + +subroutine foo + use iso_fortran_env + implicit none + logical(kind=logical8) :: x ! { dg-error "has no IMPLICIT type" } +end subroutine + +subroutine bar + use iso_fortran_env, only : logical8 ! { dg-error "not in the selected standard" } + use iso_fortran_env, only : logical16 ! { dg-error "not in the selected standard" } + use iso_fortran_env, only : logical32 ! { dg-error "not in the selected standard" } + use iso_fortran_env, only : logical64 ! { dg-error "not in the selected standard" } + use iso_fortran_env, only : real16 ! { dg-error "not in the selected standard" } + implicit none +end subroutine + +subroutine gee + use iso_fortran_env, only : int8 + use iso_fortran_env, only : int16 + use iso_fortran_env, only : int32 + use iso_fortran_env, only : int64 + implicit none +end subroutine diff --git a/gcc/testsuite/gfortran.dg/pr102597.f90 b/gcc/testsuite/gfortran.dg/pr102597.f90 new file mode 100644 index 00000000000..c2d875f897a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr102597.f90 @@ -0,0 +1,9 @@ +! { dg-do compile } +! Check that PR102597 does not resurface. Regression caused ICE at associate +! statement. +! Contributed by Gerhard Steinmetz <gscfq@t-online.de> +program p + use iso_fortran_env + associate (y => (compiler_version)) ! { dg-error "is a procedure name" } + end associate +end diff --git a/gcc/testsuite/gfortran.dg/pr103471.f90 b/gcc/testsuite/gfortran.dg/pr103471.f90 new file mode 100644 index 00000000000..695446e034e --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr103471.f90 @@ -0,0 +1,18 @@ +! { dg-do compile } +! Test the fix for PR103471 in which, rather than giving a "no IMPLICIT type" +! message, gfortran took to ICEing. The fuzzy symbol check for 'kk' demonstrates +! that the error is being detected at the right place. +! +! Contributed by Gerhard Steinmetz <gscfq@t-online.de> +! +program p + implicit none + integer, parameter :: x(4) = [1,2,3,4] + real, external :: y + integer :: kk + print *, [real(y(l))] ! { dg-error "has no IMPLICIT type" } + print *, [real(x(k))] ! { dg-error "has no IMPLICIT type; did you mean .kk.\\?" } +! This silently suppresses the error in the previous line. With the line before +! commented out, the error occurs in trans-decl.cc. +! print *, [real(y(k))] +end diff --git a/gcc/testsuite/gfortran.dg/pr114883.f90 b/gcc/testsuite/gfortran.dg/pr114883.f90 new file mode 100644 index 00000000000..3fec1d278b3 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr114883.f90 @@ -0,0 +1,53 @@ +! PR tree-optimization/114883 +! { dg-do compile } +! { dg-options "-O2 -fvect-cost-model=cheap" } +! { dg-additional-options "-march=x86-64-v4" { target i?86-*-* x86_64-*-* } } + +subroutine pr114883_1(a, b, c, d, e, f, g, h, o) + real(8) :: c(1011), d(1011), e(0:1011) + real(8) :: p, q, f, r, g(1011), h(1011), b, bar + integer :: o(100), a, t, u + p = 0.0_8 + r = bar() + u = 1 + do i = 1,a + do k = 1,1011 + km1 = max0(k-1,1) + h(k) = c(k) * e(k-1) * d(km1) + f = g(k) + h(k) + if(f.gt.1.e-6)then + p = min(p,r) + endif + end do + q = 0.9_8 * p + t = integer(b/q + 1) + if(t>100)then + u = t + endif + o(u) = o(u) + 1 + end do +end subroutine pr114883_1 +subroutine pr114883_2(a, b, c, d, e, f, g, h, o) + real(8) :: c(1011), d(1011), e(0:1011) + real(8) :: p, q, f, r, g(1011), h(1011), b, bar + integer :: o(100), a, t, u + p = 0.0_8 + r = bar() + u = 1 + do i = 1,a + do k = 1,1011 + km1 = max0(k-1,1) + h(k) = c(k) * e(k-1) * d(km1) + f = g(k) + h(k) + if(f.gt.1.e-6)then + p = max(p,r) + endif + end do + q = 0.9_8 * p + t = integer(b/q + 1) + if(t>100)then + u = t + endif + o(u) = o(u) + 1 + end do +end subroutine pr114883_2 diff --git a/gcc/testsuite/gfortran.dg/pr114959.f90 b/gcc/testsuite/gfortran.dg/pr114959.f90 new file mode 100644 index 00000000000..5cc3c052c1d --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr114959.f90 @@ -0,0 +1,33 @@ +! { dg-do compile } +! { dg-options "-fdump-tree-original" } +! +! Fix the regression caused by r14-9752 (fix for PR112407) +! Contributed by Orion Poplawski <orion@nwra.com> +! Problem isolated by Jakub Jelinek <jakub@gcc.gnu.org> and further +! reduced here. +! +module m + type :: smoother_type + integer :: i + end type + type :: onelev_type + class(smoother_type), allocatable :: sm + class(smoother_type), allocatable :: sm2a + end type +contains + subroutine save_smoothers(level,save1, save2) + Implicit None + type(onelev_type), intent(inout) :: level + class(smoother_type), allocatable , intent(inout) :: save1, save2 + integer(4) :: info + + info = 0 +! r14-9752 causes the 'stat' declaration from the first ALLOCATE statement +! to disappear, which triggers an ICE in gimplify_var_or_parm_decl. The +! second ALLOCATE statement has to be present for the ICE to occur. + allocate(save1, mold=level%sm,stat=info) + allocate(save2, mold=level%sm2a,stat=info) + end subroutine save_smoothers +end module m +! Two 'stat's from the allocate statements and two from the final wrapper. +! { dg-final { scan-tree-dump-times "integer\\(kind..\\) stat" 4 "original" } } diff --git a/gcc/testsuite/gfortran.dg/pr89462.f90 b/gcc/testsuite/gfortran.dg/pr89462.f90 new file mode 100644 index 00000000000..b2a4912fcc8 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr89462.f90 @@ -0,0 +1,13 @@ +! { dg-do compile } +! { dg-options "-pedantic-errors" } +! Test the fix for PR89462 in which the shared 'cl' field of the typespec +! shared between 'test', 'TR' and 'aTP' caused the compiler to go into an +! infinite loop. +! Contributed by Sergei Trofimovich <slyich@gmail.com> + CHARACTER*1 FUNCTION test(H) ! { dg-warning "Old-style character length" } + CHARACTER*1 test2,TR,aTP ! { dg-warning "Old-style character length" } + ENTRY test2(L) + CALL ttest3(aTP) + test = TR + RETURN + END diff --git a/gcc/testsuite/gfortran.dg/pr93678.f90 b/gcc/testsuite/gfortran.dg/pr93678.f90 new file mode 100644 index 00000000000..403bedd0c4f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr93678.f90 @@ -0,0 +1,32 @@ +! { dg-do compile } +! Test the fix for PR93678 in which the charlen for the 'unpackbytes' +! vtable field was incomplete and caused the ICE as indicated. +! Contributed by Luis Kornblueh <mail.luis@web.de> +! +! The testcase was reduced by various gfortran regulars. +module mo_a + implicit none + type t_b + integer :: i + contains + procedure :: unpackbytes => b_unpackbytes + end type t_b +contains + function b_unpackbytes (me) result (res) + class(t_b), intent(inout) :: me + character :: res(1) + res = char (me%i) + end function b_unpackbytes + subroutine b_unpackint (me, c) + class(t_b), intent(inout) :: me + character, intent(in) :: c +! print *, b_unpackbytes (me) ! ok + if (any (me% unpackbytes () .ne. c)) stop 1 ! ICEd here + end subroutine b_unpackint +end module mo_a + + use mo_a + class(t_b), allocatable :: z + allocate (z, source = t_b(97)) + call b_unpackint (z, "a") +end diff --git a/gcc/testsuite/gfortran.dg/selected_logical_kind_1.f90 b/gcc/testsuite/gfortran.dg/selected_logical_kind_1.f90 new file mode 100644 index 00000000000..18d8dedd50e --- /dev/null +++ b/gcc/testsuite/gfortran.dg/selected_logical_kind_1.f90 @@ -0,0 +1,29 @@ +! { dg-do run } + +program selected + implicit none + + integer, parameter :: k = max(1, selected_logical_kind(128)) + logical(kind=k) :: l + + ! This makes assumptions about the targets, but they are true + ! for all targets that gfortran supports + + if (selected_logical_kind(1) /= 1) STOP 1 + if (selected_logical_kind(8) /= 1) STOP 2 + if (selected_logical_kind(9) /= 2) STOP 3 + if (selected_logical_kind(16) /= 2) STOP 4 + if (selected_logical_kind(17) /= 4) STOP 5 + if (selected_logical_kind(32) /= 4) STOP 6 + if (selected_logical_kind(33) /= 8) STOP 7 + if (selected_logical_kind(64) /= 8) STOP 8 + + ! This should not exist + + if (selected_logical_kind(17921) /= -1) STOP 9 + + ! We test for a kind larger than 64 bits separately + + if (storage_size(l) /= 8 * k) STOP 10 + +end program diff --git a/gcc/testsuite/gfortran.dg/selected_logical_kind_2.f90 b/gcc/testsuite/gfortran.dg/selected_logical_kind_2.f90 new file mode 100644 index 00000000000..6f18958eb37 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/selected_logical_kind_2.f90 @@ -0,0 +1,9 @@ +! { dg-do compile } +! { dg-options "-std=f2018" } + +program selected + implicit none + + logical(selected_logical_kind(1)) :: l ! { dg-error "has no IMPLICIT type" } + print *, selected_logical_kind(1) ! { dg-error "has no IMPLICIT type" } +end program diff --git a/gcc/testsuite/gfortran.dg/selected_logical_kind_3.f90 b/gcc/testsuite/gfortran.dg/selected_logical_kind_3.f90 new file mode 100644 index 00000000000..ac948e9c252 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/selected_logical_kind_3.f90 @@ -0,0 +1,18 @@ +! { dg-do run } +! { dg-require-effective-target fortran_integer_16 } + +program selected + implicit none + + integer, parameter :: k1 = selected_logical_kind(128) + logical(kind=k1) :: l + + integer, parameter :: k2 = selected_int_kind(25) + integer(kind=k2) :: i + + if (storage_size(l) /= 8 * k1) STOP 1 + if (storage_size(i) /= 8 * k2) STOP 2 + if (bit_size(i) /= 8 * k2) STOP 3 + if (k1 /= k2) STOP 4 + +end program diff --git a/gcc/testsuite/gfortran.dg/selected_logical_kind_4.f90 b/gcc/testsuite/gfortran.dg/selected_logical_kind_4.f90 new file mode 100644 index 00000000000..0510991b165 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/selected_logical_kind_4.f90 @@ -0,0 +1,23 @@ +! { dg-do run } + +! Check that SELECTED_LOGICAL_KIND works in a non-constant context +! (which is rare but allowed) + +subroutine foo(i, j) + implicit none + integer :: i, j + if (selected_logical_kind(i) /= j) STOP j +end subroutine + +program selected + implicit none + + call foo(1, 1) + call foo(8, 1) + call foo(9, 2) + call foo(16, 2) + call foo(17, 4) + call foo(32, 4) + call foo(33, 8) + call foo(64, 8) +end program diff --git a/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp b/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp index 6b3a8ebefe2..db2ba6314c1 100644 --- a/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp +++ b/gcc/testsuite/gm2/coroutines/pim/run/pass/coroutines-pim-run-pass.exp @@ -24,16 +24,11 @@ if $tracelevel then { # load support procs load_lib gm2-torture.exp -load_lib timeout-dg.exp set gm2src ${srcdir}/../gm2 gm2_init_cor "" -# We should be able to compile, link or run in 20 seconds. -gm2_push_timeout 20 - - foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { # If we're only testing specific files and this isn't one of them, skip it. if ![runtest_file_p $runtests $testcase] then { @@ -42,5 +37,3 @@ foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { gm2-torture-execute $testcase "" "pass" } - -gm2_pop_timeout diff --git a/gcc/testsuite/gm2/examples/map/pass/examples-map-pass.exp b/gcc/testsuite/gm2/examples/map/pass/examples-map-pass.exp index 432518d7133..fabcf96f6d1 100644 --- a/gcc/testsuite/gm2/examples/map/pass/examples-map-pass.exp +++ b/gcc/testsuite/gm2/examples/map/pass/examples-map-pass.exp @@ -27,9 +27,6 @@ load_lib gm2-torture.exp gm2_init_pim "${srcdir}/${subdir}" -# We should be able to compile, link or run in 30 seconds. -gm2_push_timeout 30 - foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { # If we're only testing specific files and this isn't one of them, skip it. if ![runtest_file_p $runtests $testcase] then { @@ -38,5 +35,3 @@ foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { gm2-torture $testcase } - -gm2_pop_timeout diff --git a/gcc/testsuite/gm2/iso/const/fail/castproctype.mod b/gcc/testsuite/gm2/iso/const/fail/castproctype.mod new file mode 100644 index 00000000000..eb66513d874 --- /dev/null +++ b/gcc/testsuite/gm2/iso/const/fail/castproctype.mod @@ -0,0 +1,19 @@ +MODULE castproctype ; + +IMPORT SYSTEM ; + +TYPE + foo3 = PROCEDURE (CARDINAL, INTEGER, CHAR) ; + foo2 = PROCEDURE (CARDINAL, INTEGER) ; + +CONST + bar = SYSTEM.CAST (foo2, NIL) ; + +VAR + p2: foo2 ; + p3: foo3 ; +BEGIN + IF p2 = p3 + THEN + END +END castproctype. diff --git a/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp b/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp index af387e54b24..2c79b69ab6a 100644 --- a/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp +++ b/gcc/testsuite/gm2/iso/run/pass/iso-run-pass.exp @@ -23,14 +23,10 @@ if $tracelevel then { # load support procs load_lib gm2-torture.exp -load_lib timeout-dg.exp gm2_init_iso "${srcdir}/gm2/iso/run/pass" -fsoft-check-all gm2_link_obj fileio.o -# We should be able to compile, link or run in 60 seconds. -gm2_push_timeout 60 - foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { # If we're only testing specific files and this isn't one of them, skip it. if ![runtest_file_p $runtests $testcase] then { @@ -42,5 +38,3 @@ foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { gm2-torture-execute $testcase "" "pass" } } - -gm2_pop_timeout diff --git a/gcc/testsuite/gm2/pim/fail/badprocbool.mod b/gcc/testsuite/gm2/pim/fail/badprocbool.mod new file mode 100644 index 00000000000..63bb03477fc --- /dev/null +++ b/gcc/testsuite/gm2/pim/fail/badprocbool.mod @@ -0,0 +1,13 @@ +MODULE badprocbool ; + +FROM NumberIO IMPORT WriteCard ; +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE Func () : BOOLEAN ; +BEGIN + RETURN TRUE +END Func ; + +BEGIN + WriteString ('the value is: ') ; WriteCard (Func (), 5) ; WriteLn +END badprocbool. diff --git a/gcc/testsuite/gm2/pim/fail/badproccard.mod b/gcc/testsuite/gm2/pim/fail/badproccard.mod new file mode 100644 index 00000000000..3a6b8e525ec --- /dev/null +++ b/gcc/testsuite/gm2/pim/fail/badproccard.mod @@ -0,0 +1,13 @@ +MODULE badproccard ; + +FROM NumberIO IMPORT WriteCard ; +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE func () : CARDINAL ; +BEGIN + RETURN 42 +END func ; + +BEGIN + WriteString ('the value is: ') ; WriteCard (func, 5) ; WriteLn +END badproccard. diff --git a/gcc/testsuite/gm2/pim/fail/badprocint.mod b/gcc/testsuite/gm2/pim/fail/badprocint.mod new file mode 100644 index 00000000000..c06241b5172 --- /dev/null +++ b/gcc/testsuite/gm2/pim/fail/badprocint.mod @@ -0,0 +1,17 @@ +MODULE badprocint ; + +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE func () : INTEGER ; +BEGIN + RETURN 42 +END func ; + +PROCEDURE PassRef (VAR x: CARDINAL) ; +BEGIN +END PassRef ; + + +BEGIN + WriteString ('the value is: ') ; PassRef (func ()) ; WriteLn +END badprocint. diff --git a/gcc/testsuite/gm2/pim/fail/badprocint2.mod b/gcc/testsuite/gm2/pim/fail/badprocint2.mod new file mode 100644 index 00000000000..4d2901e800c --- /dev/null +++ b/gcc/testsuite/gm2/pim/fail/badprocint2.mod @@ -0,0 +1,14 @@ +MODULE badprocint2 ; + +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE PassRef (VAR x: CARDINAL) ; +BEGIN +END PassRef ; + +VAR + i: INTEGER ; +BEGIN + i := 42 ; + WriteString ('the value is: ') ; PassRef (i) ; WriteLn +END badprocint2. diff --git a/gcc/testsuite/gm2/pim/fail/badproctype.mod b/gcc/testsuite/gm2/pim/fail/badproctype.mod new file mode 100644 index 00000000000..cff3a31db8e --- /dev/null +++ b/gcc/testsuite/gm2/pim/fail/badproctype.mod @@ -0,0 +1,34 @@ +MODULE badproctype ; + +TYPE + PROCA = PROCEDURE (VAR ARRAY OF REAL); + PROCB = PROCEDURE (VAR ARRAY OF SHORTREAL); + +VAR + pa: PROCA; pb: PROCB; + x: ARRAY [0..1] OF REAL; + y: ARRAY [0..1] OF SHORTREAL; + +PROCEDURE ProcA(VAR z: ARRAY OF REAL); +BEGIN +END ProcA ; + +PROCEDURE ProcB(VAR z: ARRAY OF SHORTREAL); +BEGIN +END ProcB ; + +BEGIN + x := y; + pa := ProcA; + pb := ProcB; + pa(x); + pa(y); + pb(x); + pb(y); + pa := ProcB; (* proctype does not match. *) + pb := ProcA; (* proctype does not match. *) + pa(x); + pa(y); + pb(x); + pb(y) +END badproctype. diff --git a/gcc/testsuite/gm2/pim/pass/another.mod b/gcc/testsuite/gm2/pim/pass/another.mod index e249ded5608..0f6cf4b6977 100644 --- a/gcc/testsuite/gm2/pim/pass/another.mod +++ b/gcc/testsuite/gm2/pim/pass/another.mod @@ -2,7 +2,7 @@ MODULE another ; TYPE MYSHORTREAL = REAL; - + TYPE PROCA = PROCEDURE (VAR ARRAY OF REAL); PROCB = PROCEDURE (VAR ARRAY OF MYSHORTREAL); @@ -11,7 +11,7 @@ VAR pa: PROCA; pb: PROCB; x: ARRAY [0..1] OF REAL; y: ARRAY [0..1] OF MYSHORTREAL; - + PROCEDURE ProcA(VAR z: ARRAY OF REAL); BEGIN END ProcA ; @@ -28,8 +28,8 @@ BEGIN pa(y); pb(x); pb(y); - pa := ProcB; - pb := ProcA; + pa := ProcA; + pb := ProcB; pa(x); pa(y); pb(x); diff --git a/gcc/testsuite/gm2/pim/pass/goodproccard2.mod b/gcc/testsuite/gm2/pim/pass/goodproccard2.mod new file mode 100644 index 00000000000..f2f5c6e5b1d --- /dev/null +++ b/gcc/testsuite/gm2/pim/pass/goodproccard2.mod @@ -0,0 +1,16 @@ +MODULE badproccard2 ; + +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE func () : INTEGER ; +BEGIN + RETURN 42 +END func ; + +PROCEDURE PassValue (x: CARDINAL) ; +BEGIN +END PassValue ; + +BEGIN + WriteString ('the value is: ') ; PassValue (func ()) ; WriteLn +END badproccard2. diff --git a/gcc/testsuite/gm2/pim/pass/goodprocint.mod b/gcc/testsuite/gm2/pim/pass/goodprocint.mod new file mode 100644 index 00000000000..2ace5786245 --- /dev/null +++ b/gcc/testsuite/gm2/pim/pass/goodprocint.mod @@ -0,0 +1,13 @@ +MODULE goodprocint ; + +FROM NumberIO IMPORT WriteCard ; +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE func () : INTEGER ; +BEGIN + RETURN 42 +END func ; + +BEGIN + WriteString ('the value is: ') ; WriteCard (func (), 5) ; WriteLn +END goodprocint. diff --git a/gcc/testsuite/gm2/pim/pass/goodprocint3.mod b/gcc/testsuite/gm2/pim/pass/goodprocint3.mod new file mode 100644 index 00000000000..fcc1e733b05 --- /dev/null +++ b/gcc/testsuite/gm2/pim/pass/goodprocint3.mod @@ -0,0 +1,14 @@ +MODULE goodprocint3 ; + +FROM StrIO IMPORT WriteString, WriteLn ; + +PROCEDURE PassValue (x: CARDINAL) ; +BEGIN +END PassValue ; + +VAR + i: INTEGER ; +BEGIN + i := 42 ; + WriteString ('the value is: ') ; PassValue (i) ; WriteLn +END goodprocint3. diff --git a/gcc/testsuite/gm2/pim/pass/proccard.mod b/gcc/testsuite/gm2/pim/pass/proccard.mod index 4518022dab7..3042c28833d 100644 --- a/gcc/testsuite/gm2/pim/pass/proccard.mod +++ b/gcc/testsuite/gm2/pim/pass/proccard.mod @@ -8,7 +8,6 @@ BEGIN RETURN 42 END func ; - BEGIN - WriteString ('the value is: ') ; WriteCard (func, 5) ; WriteLn + WriteString ('the value is: ') ; WriteCard (VAL (CARDINAL, func), 5) ; WriteLn END proccard. diff --git a/gcc/testsuite/gm2/pim/run/pass/genconststr.mod b/gcc/testsuite/gm2/pim/run/pass/genconststr.mod new file mode 100644 index 00000000000..d8fa842571c --- /dev/null +++ b/gcc/testsuite/gm2/pim/run/pass/genconststr.mod @@ -0,0 +1,23 @@ +MODULE genconststr ; + +FROM libc IMPORT printf, exit ; +FROM StrLib IMPORT StrEqual ; + +CONST + foo = hello + space + world ; + hello = "hello" ; + space = " " ; + world = "world" ; + +PROCEDURE test (a: ARRAY OF CHAR) ; +BEGIN + IF NOT StrEqual (a, "hello world") + THEN + printf ("const string failed\n"); + exit (1) + END +END test ; + +BEGIN + test (foo) +END genconststr. diff --git a/gcc/testsuite/gm2/pimlib/base/run/pass/pimlib-base-run-pass.exp b/gcc/testsuite/gm2/pimlib/base/run/pass/pimlib-base-run-pass.exp index 7acdcdec670..059a0acd49f 100644 --- a/gcc/testsuite/gm2/pimlib/base/run/pass/pimlib-base-run-pass.exp +++ b/gcc/testsuite/gm2/pimlib/base/run/pass/pimlib-base-run-pass.exp @@ -24,15 +24,11 @@ if $tracelevel then { # load support procs load_lib gm2-torture.exp -load_lib timeout-dg.exp set gm2src ${srcdir}/../m2 gm2_init_pim "" -# We should be able to compile, link or run in 60 seconds. -gm2_push_timeout 60 - foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { # If we're only testing specific files and this isn't one of them, skip it. if ![runtest_file_p $runtests $testcase] then { @@ -41,5 +37,3 @@ foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { gm2-torture-execute $testcase "" "pass" } - -gm2_pop_timeout diff --git a/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp b/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp index 11b0f6665d4..05421267d1b 100644 --- a/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp +++ b/gcc/testsuite/gm2/projects/iso/run/pass/halma/projects-iso-run-pass-halma.exp @@ -29,11 +29,6 @@ set gm2src ${srcdir}/../m2 gm2_init_iso "" -# We should be able to compile, link or run in 45 seconds even on a -# really slow host/target. - -gm2_push_timeout 45 - foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { # If we're only testing specific files and this isn't one of them, skip it. if ![runtest_file_p $runtests $testcase] then { @@ -42,5 +37,3 @@ foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { gm2-torture-execute $testcase "" "pass" } - -gm2_pop_timeout diff --git a/gcc/testsuite/gm2/switches/whole-program/pass/run/switches-whole-program-pass-run.exp b/gcc/testsuite/gm2/switches/whole-program/pass/run/switches-whole-program-pass-run.exp index a9750e6da7d..40185c0b686 100644 --- a/gcc/testsuite/gm2/switches/whole-program/pass/run/switches-whole-program-pass-run.exp +++ b/gcc/testsuite/gm2/switches/whole-program/pass/run/switches-whole-program-pass-run.exp @@ -23,10 +23,8 @@ if $tracelevel then { # load support procs load_lib gm2-torture.exp -load_lib timeout-dg.exp gm2_init_pim "${srcdir}/gm2/switches/whole-program/run/pass" -fm2-whole-program -gm2_push_timeout 120 foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { # If we're only testing specific files and this isn't one of them, skip it. @@ -35,5 +33,3 @@ foreach testcase [lsort [glob -nocomplain $srcdir/$subdir/*.mod]] { } gm2-torture $testcase } - -gm2_pop_timeout diff --git a/gcc/testsuite/lib/gm2-torture.exp b/gcc/testsuite/lib/gm2-torture.exp index 090929954ca..513f5f45c47 100644 --- a/gcc/testsuite/lib/gm2-torture.exp +++ b/gcc/testsuite/lib/gm2-torture.exp @@ -21,34 +21,6 @@ load_lib file-format.exp load_lib target-libpath.exp load_lib timeout.exp -load_lib timeout-dg.exp - - -if {[info exists individual_timeout]} { - set gm2_previous_timeout $individual_timeout -} else { - set gm2_previous_timeout 10 -} - - -# We should be able to complete any test in 10 seconds. -dg-timeout S 10 - - -# only push one level. - -proc gm2_push_timeout { secs } { - global individual_timeout - set individual_timeout $secs -} - - -proc gm2_pop_timeout { } { - global individual_timeout - global gm2_previous_timeout - set individual_timeout $gm2_previous_timeout -} - # The default option list can be overridden by # TORTURE_OPTIONS="{ { list1 } ... { listN } }" @@ -138,7 +110,7 @@ proc gm2-torture-compile { src option } { proc gm2_check_compile_fail {testcase option objname gcc_output} { global tool; - set fatal_signal "*cc: Internal compiler error: program*got fatal signal" + set fatal_signal "*nternal compiler error: program*got fatal signal" if [string match "$fatal_signal 6" $gcc_output] then { ${tool}_fail $testcase "Got Signal 6, $option" @@ -170,8 +142,9 @@ proc gm2_check_compile_fail {testcase option objname gcc_output} { regsub -all -- "\[\r\n\]*" $gcc_output "" gcc_output # check for any internal error - if { [string match "internal error" $gcc_output] || - [string match "internal compiler error" $gcc_output] } then { + if { [string match "*internal error*" $gcc_output] || + [string match "*internal compiler error*" $gcc_output] } then { + puts stderr "ICE: " ${tool}_fail $testcase $option return 0 } diff --git a/gcc/testsuite/lib/gm2.exp b/gcc/testsuite/lib/gm2.exp index 81da3bc5d79..64d44494e48 100644 --- a/gcc/testsuite/lib/gm2.exp +++ b/gcc/testsuite/lib/gm2.exp @@ -23,36 +23,6 @@ load_lib prune.exp load_lib gcc-defs.exp load_lib target-libpath.exp load_lib timeout.exp -load_lib timeout-dg.exp - - -if {[info exists individual_timeout]} { - set gm2_previous_timeout $individual_timeout -} else { - set gm2_previous_timeout 10 -} - - -# set gm2_previous_timeout $individual_timeout - -# We should be able to complete any test in 10 seconds. -dg-timeout S 10 - - -# only push one level. - -proc gm2_push_timeout { secs } { - global individual_timeout - set individual_timeout $secs -} - - -proc gm2_pop_timeout { } { - global individual_timeout - global gm2_previous_timeout - set individual_timeout $gm2_previous_timeout -} - # # GCC_UNDER_TEST is the compiler under test. @@ -167,10 +137,6 @@ proc gm2_init { args } { set gm2_link_path "[gm2_link_flags [get_multilibs]]" verbose $gm2_link_path 1 - - # Set the default timeout value, larger tests can override - # this if necessary. - dg-timeout S 10 } diff --git a/gcc/testsuite/lib/prune.exp b/gcc/testsuite/lib/prune.exp index f3d3c99fbcb..d00d37f015f 100644 --- a/gcc/testsuite/lib/prune.exp +++ b/gcc/testsuite/lib/prune.exp @@ -51,6 +51,7 @@ proc prune_gcc_output { text } { regsub -all "(^|\n)\[^\n\]*: re(compiling|linking)\[^\n\]*" $text "" text regsub -all "(^|\n)Please submit.*instructions\[^\n\]*" $text "" text regsub -all "(^|\n)\[0-9\]\[0-9\]* errors\." $text "" text + regsub -all "(^|\n)Preprocessed.*bugreport\[^\n\]*" $text "" text # Diagnostic inclusion stack regsub -all "(^|\n)(In file)?\[ \]+included from \[^\n\]*" $text "" text diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 3a5713d9869..3a55b2a4159 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -12392,6 +12392,20 @@ proc check_effective_target_profile_update_atomic {} { } "-fprofile-update=atomic -fprofile-generate"] } +# Return 1 if the target has a vector facility. +proc check_effective_target_s390_mvx { } { + if ![istarget s390*-*-*] then { + return 0; + } + + return [check_no_compiler_messages_nocache s390_mvx assembly { + #if !defined __VX__ + #error no vector facility. + #endif + int dummy; + } [current_compiler_flags]] +} + # Return 1 if vector (va - vector add) instructions are understood by # the assembler and can be executed. This also covers checking for # the VX kernel feature. A kernel without that feature does not diff --git a/gcc/testsuite/obj-c++.dg/attributes/nullability-00.mm b/gcc/testsuite/obj-c++.dg/attributes/nullability-00.mm index 957fca4e3ba..cb25cbd4c62 100644 --- a/gcc/testsuite/obj-c++.dg/attributes/nullability-00.mm +++ b/gcc/testsuite/obj-c++.dg/attributes/nullability-00.mm @@ -8,7 +8,7 @@ __attribute__((objc_nullability("unspecified"))) id b; __attribute__((objc_nullability("nullable"))) id c; __attribute__((objc_nullability("nonnull"))) id d; __attribute__((objc_nullability("resettable"))) id e; -__attribute__((objc_nullability("nonsense"))) id e_3; /* { dg-error {'objc_nullability' attribute argument '"nonsense"' is not recognised} } */ +__attribute__((objc_nullability("nonsense"))) id e_3; /* { dg-error {'objc_nullability' attribute argument '"nonsense"' is not recognized} } */ __attribute__((objc_nullability(noGoingToWork))) id e_4; /* { dg-error {'noGoingToWork' was not declared in this scope} } */ @interface MyRoot diff --git a/gcc/testsuite/objc.dg/attributes/nullability-00.m b/gcc/testsuite/objc.dg/attributes/nullability-00.m index 81c0145f17b..2d7e22cf6f7 100644 --- a/gcc/testsuite/objc.dg/attributes/nullability-00.m +++ b/gcc/testsuite/objc.dg/attributes/nullability-00.m @@ -8,7 +8,7 @@ __attribute__((objc_nullability("unspecified"))) id b; __attribute__((objc_nullability("nullable"))) id c; __attribute__((objc_nullability("nonnull"))) id d; __attribute__((objc_nullability("resettable"))) id e; -__attribute__((objc_nullability("nonsense"))) id e_3; /* { dg-error {'objc_nullability' attribute argument '"nonsense"' is not recognised} } */ +__attribute__((objc_nullability("nonsense"))) id e_3; /* { dg-error {'objc_nullability' attribute argument '"nonsense"' is not recognized} } */ __attribute__((objc_nullability(noGoingToWork))) id e_4; /* { dg-error {'noGoingToWork' undeclared here} } */ @interface MyRoot diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc index d98b68d6787..b2d47b72084 100644 --- a/gcc/tree-cfg.cc +++ b/gcc/tree-cfg.cc @@ -4837,6 +4837,17 @@ verify_gimple_assign_single (gassign *stmt) static bool verify_gimple_assign (gassign *stmt) { + if (gimple_assign_nontemporal_move_p (stmt)) + { + tree lhs = gimple_assign_lhs (stmt); + if (is_gimple_reg (lhs)) + { + error ("nontemporal store lhs cannot be a gimple register"); + debug_generic_stmt (lhs); + return true; + } + } + switch (gimple_assign_rhs_class (stmt)) { case GIMPLE_SINGLE_RHS: @@ -9013,10 +9024,30 @@ remove_edge_and_dominated_blocks (edge e) /* If we are removing a path inside a non-root loop that may change loop ownership of blocks or remove loops. Mark loops for fixup. */ + class loop *src_loop = e->src->loop_father; if (current_loops - && loop_outer (e->src->loop_father) != NULL - && e->src->loop_father == e->dest->loop_father) - loops_state_set (LOOPS_NEED_FIXUP); + && loop_outer (src_loop) != NULL + && src_loop == e->dest->loop_father) + { + loops_state_set (LOOPS_NEED_FIXUP); + /* If we are removing a backedge clear the number of iterations + and estimates. */ + class loop *dest_loop = e->dest->loop_father; + if (e->dest == src_loop->header + || (e->dest == dest_loop->header + && flow_loop_nested_p (dest_loop, src_loop))) + { + free_numbers_of_iterations_estimates (dest_loop); + /* If we removed the last backedge mark the loop for removal. */ + FOR_EACH_EDGE (f, ei, dest_loop->header->preds) + if (f != e + && (f->src->loop_father == dest_loop + || flow_loop_nested_p (dest_loop, f->src->loop_father))) + break; + if (!f) + mark_loop_for_removal (dest_loop); + } + } if (!dom_info_available_p (CDI_DOMINATORS)) { diff --git a/gcc/tree-nested.cc b/gcc/tree-nested.cc index c8f07f78185..4e5f3be7676 100644 --- a/gcc/tree-nested.cc +++ b/gcc/tree-nested.cc @@ -1047,6 +1047,37 @@ get_frame_field (struct nesting_info *info, tree target_context, static void note_nonlocal_vla_type (struct nesting_info *info, tree type); +/* Helper for get_nonlocal_debug_decl and get_local_debug_decl. */ + +static tree +get_debug_decl (tree decl) +{ + tree new_decl + = build_decl (DECL_SOURCE_LOCATION (decl), + VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl)); + DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl); + DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl); + TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl); + TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl); + TREE_READONLY (new_decl) = TREE_READONLY (decl); + TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl); + DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1; + if ((TREE_CODE (decl) == PARM_DECL + || TREE_CODE (decl) == RESULT_DECL + || VAR_P (decl)) + && DECL_BY_REFERENCE (decl)) + DECL_BY_REFERENCE (new_decl) = 1; + /* Copy DECL_LANG_SPECIFIC and DECL_LANG_FLAG_* for OpenMP langhook + purposes. */ + DECL_LANG_SPECIFIC (new_decl) = DECL_LANG_SPECIFIC (decl); +#define COPY_DLF(n) DECL_LANG_FLAG_##n (new_decl) = DECL_LANG_FLAG_##n (decl) + COPY_DLF (0); COPY_DLF (1); COPY_DLF (2); COPY_DLF (3); + COPY_DLF (4); COPY_DLF (5); COPY_DLF (6); COPY_DLF (7); + COPY_DLF (8); +#undef COPY_DLF + return new_decl; +} + /* A subroutine of convert_nonlocal_reference_op. Create a local variable in the nested function with DECL_VALUE_EXPR set to reference the true variable in the parent function. This is used both for debug info @@ -1094,21 +1125,8 @@ get_nonlocal_debug_decl (struct nesting_info *info, tree decl) x = build_simple_mem_ref_notrap (x); /* ??? We should be remapping types as well, surely. */ - new_decl = build_decl (DECL_SOURCE_LOCATION (decl), - VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl)); + new_decl = get_debug_decl (decl); DECL_CONTEXT (new_decl) = info->context; - DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl); - DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl); - TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl); - TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl); - TREE_READONLY (new_decl) = TREE_READONLY (decl); - TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl); - DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1; - if ((TREE_CODE (decl) == PARM_DECL - || TREE_CODE (decl) == RESULT_DECL - || VAR_P (decl)) - && DECL_BY_REFERENCE (decl)) - DECL_BY_REFERENCE (new_decl) = 1; SET_DECL_VALUE_EXPR (new_decl, x); DECL_HAS_VALUE_EXPR_P (new_decl) = 1; @@ -1892,21 +1910,8 @@ get_local_debug_decl (struct nesting_info *info, tree decl, tree field) x = info->frame_decl; x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE); - new_decl = build_decl (DECL_SOURCE_LOCATION (decl), - VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl)); + new_decl = get_debug_decl (decl); DECL_CONTEXT (new_decl) = info->context; - DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl); - DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl); - TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl); - TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl); - TREE_READONLY (new_decl) = TREE_READONLY (decl); - TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl); - DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1; - if ((TREE_CODE (decl) == PARM_DECL - || TREE_CODE (decl) == RESULT_DECL - || VAR_P (decl)) - && DECL_BY_REFERENCE (decl)) - DECL_BY_REFERENCE (new_decl) = 1; SET_DECL_VALUE_EXPR (new_decl, x); DECL_HAS_VALUE_EXPR_P (new_decl) = 1; diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc index f6a5cd0ee6e..3749126b5f7 100644 --- a/gcc/tree-ssa-ccp.cc +++ b/gcc/tree-ssa-ccp.cc @@ -1024,6 +1024,7 @@ ccp_finalize (bool nonzero_p) unsigned int precision = TYPE_PRECISION (TREE_TYPE (val->value)); wide_int value = wi::to_wide (val->value); wide_int mask = wide_int::from (val->mask, precision, UNSIGNED); + value = value & ~mask; set_bitmask (name, value, mask); } } diff --git a/gcc/tree-ssa-loop-ch.cc b/gcc/tree-ssa-loop-ch.cc index b7ef485c4cc..d7dd3e5459d 100644 --- a/gcc/tree-ssa-loop-ch.cc +++ b/gcc/tree-ssa-loop-ch.cc @@ -759,6 +759,21 @@ protected: bool process_loop_p (class loop *loop) final override; }; // class pass_ch_vect +/* Sort comparator to order loops after the specified order. */ + +static int +ch_order_loops (const void *a_, const void *b_, void *order_) +{ + int *order = (int *)order_; + const class loop *a = *(const class loop * const *)a_; + const class loop *b = *(const class loop * const *)b_; + if (a->num == b->num) + return 0; + if (order[a->num] < order[b->num]) + return -1; + return 1; +} + /* For all loops, copy the condition at the end of the loop body in front of the loop. This is beneficial since it increases efficiency of code motion optimizations. It also saves one jump on entry to the loop. */ @@ -1152,6 +1167,16 @@ ch_base::copy_headers (function *fun) } if (!loops_to_unloop.is_empty ()) { + /* Make sure loops are ordered inner to outer for unlooping. */ + if (loops_to_unloop.length () != 1) + { + auto_vec<int, 8> order; + order.safe_grow (number_of_loops (cfun), true); + int i = 0; + for (auto loop : loops_list (cfun, LI_FROM_INNERMOST)) + order[loop->num] = i++; + loops_to_unloop.sort (ch_order_loops, order.address ()); + } bool irred_invalidated; auto_bitmap lc_invalidated; auto_vec<edge> edges_to_remove; diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc index c6d010f6d89..0fde07e626f 100644 --- a/gcc/tree-ssa-loop-niter.cc +++ b/gcc/tree-ssa-loop-niter.cc @@ -214,7 +214,7 @@ refine_value_range_using_guard (tree type, tree var, get_type_static_bounds (type, mint, maxt); mpz_init (minc1); mpz_init (maxc1); - Value_Range r (TREE_TYPE (varc1)); + int_range_max r (TREE_TYPE (varc1)); /* Setup range information for varc1. */ if (integer_zerop (varc1)) { @@ -368,7 +368,7 @@ determine_value_range (class loop *loop, tree type, tree var, mpz_t off, gphi_iterator gsi; /* Either for VAR itself... */ - Value_Range var_range (TREE_TYPE (var)); + int_range_max var_range (TREE_TYPE (var)); get_range_query (cfun)->range_of_expr (var_range, var); if (var_range.varying_p () || var_range.undefined_p ()) rtype = VR_VARYING; @@ -382,7 +382,7 @@ determine_value_range (class loop *loop, tree type, tree var, mpz_t off, /* Or for PHI results in loop->header where VAR is used as PHI argument from the loop preheader edge. */ - Value_Range phi_range (TREE_TYPE (var)); + int_range_max phi_range (TREE_TYPE (var)); for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi)) { gphi *phi = gsi.phi (); @@ -408,7 +408,7 @@ determine_value_range (class loop *loop, tree type, tree var, mpz_t off, involved. */ if (wi::gt_p (minv, maxv, sgn)) { - Value_Range vr (TREE_TYPE (var)); + int_range_max vr (TREE_TYPE (var)); get_range_query (cfun)->range_of_expr (vr, var); if (vr.varying_p () || vr.undefined_p ()) rtype = VR_VARYING; @@ -4067,7 +4067,7 @@ record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt, Value_Range base_range (TREE_TYPE (orig_base)); if (get_range_query (cfun)->range_of_expr (base_range, orig_base) && !base_range.undefined_p ()) - max = base_range.upper_bound (); + max = wi::to_wide (base_range.ubound ()); extreme = fold_convert (unsigned_type, low); if (TREE_CODE (orig_base) == SSA_NAME && TREE_CODE (high) == INTEGER_CST @@ -4090,7 +4090,7 @@ record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt, Value_Range base_range (TREE_TYPE (orig_base)); if (get_range_query (cfun)->range_of_expr (base_range, orig_base) && !base_range.undefined_p ()) - min = base_range.lower_bound (); + min = wi::to_wide (base_range.lbound ()); extreme = fold_convert (unsigned_type, high); if (TREE_CODE (orig_base) == SSA_NAME && TREE_CODE (low) == INTEGER_CST @@ -4367,7 +4367,7 @@ infer_loop_bounds_from_signedness (class loop *loop, gimple *stmt) low = lower_bound_in_type (type, type); high = upper_bound_in_type (type, type); - Value_Range r (TREE_TYPE (def)); + int_range_max r (TREE_TYPE (def)); get_range_query (cfun)->range_of_expr (r, def); if (!r.varying_p () && !r.undefined_p ()) { @@ -5426,7 +5426,7 @@ scev_var_range_cant_overflow (tree var, tree step, class loop *loop) if (!def_bb || !dominated_by_p (CDI_DOMINATORS, loop->latch, def_bb)) return false; - Value_Range r (TREE_TYPE (var)); + int_range_max r (TREE_TYPE (var)); get_range_query (cfun)->range_of_expr (r, var); if (r.varying_p () || r.undefined_p ()) return false; diff --git a/gcc/tree-ssa-loop-split.cc b/gcc/tree-ssa-loop-split.cc index a770ea371a2..a6be0cef7b0 100644 --- a/gcc/tree-ssa-loop-split.cc +++ b/gcc/tree-ssa-loop-split.cc @@ -144,18 +144,18 @@ split_at_bb_p (class loop *loop, basic_block bb, tree *border, affine_iv *iv, value range. */ else { - int_range<2> r; + Value_Range r (TREE_TYPE (op0)); get_global_range_query ()->range_of_expr (r, op0, stmt); if (!r.varying_p () && !r.undefined_p () && TREE_CODE (op1) == INTEGER_CST) { wide_int val = wi::to_wide (op1); - if (known_eq (val, r.lower_bound ())) + if (known_eq (val, wi::to_wide (r.lbound ()))) { code = (code == EQ_EXPR) ? LE_EXPR : GT_EXPR; break; } - else if (known_eq (val, r.upper_bound ())) + else if (known_eq (val, wi::to_wide (r.ubound ()))) { code = (code == EQ_EXPR) ? GE_EXPR : LT_EXPR; break; diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index d1746c4b468..f166c3132cb 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -62,14 +62,6 @@ single_non_singleton_phi_for_edges (gimple_seq seq, edge e0, edge e1) { gimple_stmt_iterator i; gphi *phi = NULL; - if (gimple_seq_singleton_p (seq)) - { - phi = as_a <gphi *> (gsi_stmt (gsi_start (seq))); - /* Never return virtual phis. */ - if (virtual_operand_p (gimple_phi_result (phi))) - return NULL; - return phi; - } for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) { gphi *p = as_a <gphi *> (gsi_stmt (i)); @@ -1139,6 +1131,28 @@ value_replacement (basic_block cond_bb, basic_block middle_bb, enum tree_code code; bool empty_or_with_defined_p = true; + /* Virtual operands don't need to be handled. */ + if (virtual_operand_p (arg1)) + return 0; + + /* Special case A ? B : B as this will always simplify to B. */ + if (operand_equal_for_phi_arg_p (arg0, arg1)) + return 0; + + gcond *cond = as_a <gcond *> (*gsi_last_bb (cond_bb)); + code = gimple_cond_code (cond); + + /* This transformation is only valid for equality comparisons. */ + if (code != NE_EXPR && code != EQ_EXPR) + return 0; + + /* Do not make conditional undefs unconditional. */ + if ((TREE_CODE (arg0) == SSA_NAME + && ssa_name_maybe_undef_p (arg0)) + || (TREE_CODE (arg1) == SSA_NAME + && ssa_name_maybe_undef_p (arg1))) + return false; + /* If the type says honor signed zeros we cannot do this optimization. */ if (HONOR_SIGNED_ZEROS (arg1)) @@ -1169,13 +1183,6 @@ value_replacement (basic_block cond_bb, basic_block middle_bb, empty_or_with_defined_p = false; } - gcond *cond = as_a <gcond *> (*gsi_last_bb (cond_bb)); - code = gimple_cond_code (cond); - - /* This transformation is only valid for equality comparisons. */ - if (code != NE_EXPR && code != EQ_EXPR) - return 0; - /* We need to know which is the true edge and which is the false edge so that we know if have abs or negative abs. */ extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge); diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc index e09c9cc081f..61c3da22322 100644 --- a/gcc/tree-ssa-strlen.cc +++ b/gcc/tree-ssa-strlen.cc @@ -215,7 +215,7 @@ get_range (tree val, gimple *stmt, wide_int minmax[2], rvals = get_range_query (cfun); } - value_range vr; + Value_Range vr (TREE_TYPE (val)); if (!rvals->range_of_expr (vr, val, stmt)) return NULL_TREE; diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc index 8d9b533d50f..43c7881c640 100644 --- a/gcc/tree-vect-loop-manip.cc +++ b/gcc/tree-vect-loop-manip.cc @@ -1523,7 +1523,7 @@ slpeel_tree_duplicate_loop_to_edge_cfg (class loop *loop, edge loop_exit, exit_dest = exit->dest; was_imm_dom = (get_immediate_dominator (CDI_DOMINATORS, - exit_dest) == loop->header ? + exit_dest) == exit->src ? true : false); /* Also copy the pre-header, this avoids jumping through hoops to diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index a6cf0a5546c..29c03c246d4 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -8505,7 +8505,8 @@ vect_transform_reduction (loop_vec_info loop_vinfo, { gcc_assert (code == IFN_COND_ADD || code == IFN_COND_SUB || code == IFN_COND_MUL || code == IFN_COND_AND - || code == IFN_COND_IOR || code == IFN_COND_XOR); + || code == IFN_COND_IOR || code == IFN_COND_XOR + || code == IFN_COND_MIN || code == IFN_COND_MAX); gcc_assert (op.num_ops == 4 && (op.ops[reduc_index] == op.ops[internal_fn_else_index ((internal_fn) code)])); diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 4f491c6b833..87c2acff386 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -797,8 +797,7 @@ vect_split_statement (vec_info *vinfo, stmt_vec_info stmt2_info, tree new_rhs, HALF_TYPE and UNPROM will be set should the statement be found to be a widened operation. DIFF_STMT will be set to the MINUS_EXPR - statement that precedes the ABS_STMT unless vect_widened_op_tree - succeeds. + statement that precedes the ABS_STMT if it is a MINUS_EXPR.. */ static bool vect_recog_absolute_difference (vec_info *vinfo, gassign *abs_stmt, @@ -843,6 +842,12 @@ vect_recog_absolute_difference (vec_info *vinfo, gassign *abs_stmt, if (!diff_stmt_vinfo) return false; + gassign *diff = dyn_cast <gassign *> (STMT_VINFO_STMT (diff_stmt_vinfo)); + if (diff_stmt && diff + && gimple_assign_rhs_code (diff) == MINUS_EXPR + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (abs_oprnd))) + *diff_stmt = diff; + /* FORNOW. Can continue analyzing the def-use chain when this stmt in a phi inside the loop (in case we are analyzing an outer-loop). */ if (vect_widened_op_tree (vinfo, diff_stmt_vinfo, @@ -850,17 +855,6 @@ vect_recog_absolute_difference (vec_info *vinfo, gassign *abs_stmt, false, 2, unprom, half_type)) return true; - /* Failed to find a widen operation so we check for a regular MINUS_EXPR. */ - gassign *diff = dyn_cast <gassign *> (STMT_VINFO_STMT (diff_stmt_vinfo)); - if (diff_stmt && diff - && gimple_assign_rhs_code (diff) == MINUS_EXPR - && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (abs_oprnd))) - { - *diff_stmt = diff; - *half_type = NULL_TREE; - return true; - } - return false; } @@ -1499,27 +1493,22 @@ vect_recog_abd_pattern (vec_info *vinfo, tree out_type = TREE_TYPE (gimple_assign_lhs (last_stmt)); vect_unpromoted_value unprom[2]; - gassign *diff_stmt; - tree half_type; - if (!vect_recog_absolute_difference (vinfo, last_stmt, &half_type, + gassign *diff_stmt = NULL; + tree abd_in_type; + if (!vect_recog_absolute_difference (vinfo, last_stmt, &abd_in_type, unprom, &diff_stmt)) - return NULL; - - tree abd_in_type, abd_out_type; - - if (half_type) - { - abd_in_type = half_type; - abd_out_type = abd_in_type; - } - else { + /* We cannot try further without having a non-widening MINUS. */ + if (!diff_stmt) + return NULL; + unprom[0].op = gimple_assign_rhs1 (diff_stmt); unprom[1].op = gimple_assign_rhs2 (diff_stmt); abd_in_type = signed_type_for (out_type); - abd_out_type = abd_in_type; } + tree abd_out_type = abd_in_type; + tree vectype_in = get_vectype_for_scalar_type (vinfo, abd_in_type); if (!vectype_in) return NULL; diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 30589e19a17..133606fa6f3 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -888,6 +888,12 @@ vect_get_and_check_slp_defs (vec_info *vinfo, unsigned char swap, (*oprnds_info)[i+1]->def_stmts[stmt_num]); std::swap ((*oprnds_info)[i]->ops[stmt_num], (*oprnds_info)[i+1]->ops[stmt_num]); + /* After swapping some operands we lost track whether an + operand has any pattern defs so be conservative here. */ + if ((*oprnds_info)[i]->any_pattern + || (*oprnds_info)[i+1]->any_pattern) + (*oprnds_info)[i]->any_pattern + = (*oprnds_info)[i+1]->any_pattern = true; swapped = true; continue; } diff --git a/gcc/value-query.cc b/gcc/value-query.cc index eda71dc89d3..c2ab745a466 100644 --- a/gcc/value-query.cc +++ b/gcc/value-query.cc @@ -42,6 +42,18 @@ range_query::range_on_edge (vrange &r, edge, tree expr) } bool +range_query::range_on_entry (vrange &r, basic_block, tree expr) +{ + return range_of_expr (r, expr); +} + +bool +range_query::range_on_exit (vrange &r, basic_block, tree expr) +{ + return range_of_expr (r, expr); +} + +bool range_query::range_of_stmt (vrange &r, gimple *stmt, tree name) { if (!name) @@ -54,6 +66,9 @@ range_query::range_of_stmt (vrange &r, gimple *stmt, tree name) return false; } +// If the range of expr EXPR at STMT is a single value, return it. +// Otherwise return NULL_TREE. + tree range_query::value_of_expr (tree expr, gimple *stmt) { @@ -76,6 +91,9 @@ range_query::value_of_expr (tree expr, gimple *stmt) return NULL_TREE; } +// If the range on edge E for EXPR is a single value, return it. +// Otherwise return NULL_TREE. + tree range_query::value_on_edge (edge e, tree expr) { @@ -94,9 +112,11 @@ range_query::value_on_edge (edge e, tree expr) return t; } return NULL_TREE; - } +// If the range of STMT for NAME is a single value, return it. +// Otherwise return NULL_TREE. + tree range_query::value_of_stmt (gimple *stmt, tree name) { @@ -113,7 +133,44 @@ range_query::value_of_stmt (gimple *stmt, tree name) if (range_of_stmt (r, stmt, name) && r.singleton_p (&t)) return t; return NULL_TREE; +} + +// If the range on entry to BB for EXPR is a single value, return it. +// Otherwise return NULL_TREE. + +tree +range_query::value_on_entry (basic_block bb, tree expr) +{ + tree t; + + gcc_checking_assert (bb); + if (!Value_Range::supports_type_p (TREE_TYPE (expr))) + return NULL_TREE; + + Value_Range r (TREE_TYPE (expr)); + + if (range_on_entry (r, bb, expr) && r.singleton_p (&t)) + return t; + return NULL_TREE; +} + +// If the range on exit to BB for EXPR is a single value, return it. +// Otherwise return NULL_TREE. + +tree +range_query::value_on_exit (basic_block bb, tree expr) +{ + tree t; + gcc_checking_assert (bb); + if (!Value_Range::supports_type_p (TREE_TYPE (expr))) + return NULL_TREE; + + Value_Range r (TREE_TYPE (expr)); + + if (range_on_exit (r, bb, expr) && r.singleton_p (&t)) + return t; + return NULL_TREE; } void @@ -130,11 +187,36 @@ range_query::~range_query () { } -// Return a range in R for the tree EXPR. Return true if a range is -// representable, and UNDEFINED/false if not. +// This routine will invoke the equivalent of range_of_expr on +// either a gimple statement STMT, on entry to block BBENTRY, or on +// exit from block BBEXIT. Only one of these 3 fields may be set. +// It is valid for none of them to be set, in wqhich case there is no context. + +bool +range_query::invoke_range_of_expr (vrange &r, tree expr, gimple *stmt, + basic_block bbentry, basic_block bbexit) +{ + if (bbentry) + { + gcc_checking_assert (!stmt && !bbexit); + return range_on_entry (r, bbentry, expr); + } + if (bbexit) + { + gcc_checking_assert (!stmt); + return range_on_exit (r, bbexit, expr); + } + + return range_of_expr (r, expr, stmt); +} + +// Return a range in R for the tree EXPR. The context can be either a STMT, +// or on entry to block BBENTRY or exit from block BBEXIT. +// Return true if a range is representable, and UNDEFINED/false if not. bool -range_query::get_tree_range (vrange &r, tree expr, gimple *stmt) +range_query::get_tree_range (vrange &r, tree expr, gimple *stmt, + basic_block bbentry, basic_block bbexit) { tree type; if (TYPE_P (expr)) @@ -156,11 +238,9 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt) { case INTEGER_CST: { - irange &i = as_a <irange> (r); if (TREE_OVERFLOW_P (expr)) expr = drop_tree_overflow (expr); - wide_int w = wi::to_wide (expr); - i.set (TREE_TYPE (expr), w, w); + r.set (expr, expr); return true; } @@ -182,6 +262,9 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt) } case SSA_NAME: + // If this is not an abnormal or virtual ssa, invoke range_of_expr. + if (gimple_range_ssa_p (expr)) + return invoke_range_of_expr (r, expr, stmt, bbentry, bbexit); gimple_range_global (r, expr); return true; @@ -212,8 +295,8 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt) { Value_Range r0 (TREE_TYPE (op0)); Value_Range r1 (TREE_TYPE (op1)); - range_of_expr (r0, op0, stmt); - range_of_expr (r1, op1, stmt); + invoke_range_of_expr (r0, op0, stmt, bbentry, bbexit); + invoke_range_of_expr (r1, op1, stmt, bbentry, bbexit); if (!op.fold_range (r, type, r0, r1)) r.set_varying (type); } @@ -230,7 +313,8 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt) Value_Range r0 (TREE_TYPE (TREE_OPERAND (expr, 0))); Value_Range r1 (type); r1.set_varying (type); - range_of_expr (r0, TREE_OPERAND (expr, 0), stmt); + invoke_range_of_expr (r0, TREE_OPERAND (expr, 0), stmt, bbentry, + bbexit); if (!op.fold_range (r, type, r0, r1)) r.set_varying (type); } @@ -282,11 +366,15 @@ get_ssa_name_ptr_info_nonnull (const_tree name) // Update the global range for NAME into the SSA_RANGE_NAME_INFO and // Return the legacy global range for NAME if it has one, otherwise // return VARYING. +// See discussion here regarding why there use to be a wrapper function: +// https://gcc.gnu.org/pipermail/gcc-patches/2021-June/571709.html +// Legacy EVRP has been removed, leaving just this function. -static void -get_range_global (vrange &r, tree name, struct function *fun = cfun) +void +gimple_range_global (vrange &r, tree name, struct function *fun) { tree type = TREE_TYPE (name); + gcc_checking_assert (TREE_CODE (name) == SSA_NAME); if (SSA_NAME_IS_DEFAULT_DEF (name)) { @@ -334,36 +422,6 @@ get_range_global (vrange &r, tree name, struct function *fun = cfun) r.set_varying (type); } -// This is where the ranger picks up global info to seed initial -// requests. It is a slightly restricted version of -// get_range_global() above. -// -// The reason for the difference is that we can always pick the -// default definition of an SSA with no adverse effects, but for other -// SSAs, if we pick things up to early, we may prematurely eliminate -// builtin_unreachables. -// -// Without this restriction, the test in g++.dg/tree-ssa/pr61034.C has -// all of its unreachable calls removed too early. -// -// See discussion here: -// https://gcc.gnu.org/pipermail/gcc-patches/2021-June/571709.html - -void -gimple_range_global (vrange &r, tree name, struct function *fun) -{ - tree type = TREE_TYPE (name); - gcc_checking_assert (TREE_CODE (name) == SSA_NAME); - - if (SSA_NAME_IS_DEFAULT_DEF (name) || (fun && fun->after_inlining) - || is_a<gphi *> (SSA_NAME_DEF_STMT (name))) - { - get_range_global (r, name, fun); - return; - } - r.set_varying (type); -} - // ---------------------------------------------- // global_range_query implementation. @@ -375,7 +433,7 @@ global_range_query::range_of_expr (vrange &r, tree expr, gimple *stmt) if (!gimple_range_ssa_p (expr)) return get_tree_range (r, expr, stmt); - get_range_global (r, expr); + gimple_range_global (r, expr); return true; } diff --git a/gcc/value-query.h b/gcc/value-query.h index a1306e2bd25..4d2a7bce485 100644 --- a/gcc/value-query.h +++ b/gcc/value-query.h @@ -60,6 +60,8 @@ public: virtual tree value_of_expr (tree expr, gimple * = NULL); virtual tree value_on_edge (edge, tree expr); virtual tree value_of_stmt (gimple *, tree name = NULL); + virtual tree value_on_entry (basic_block, tree expr); + virtual tree value_on_exit (basic_block, tree expr); // These are the range equivalents of the value_* methods. Instead // of returning a singleton, they calculate a range and return it in @@ -70,6 +72,8 @@ public: virtual bool range_of_expr (vrange &r, tree expr, gimple * = NULL) = 0; virtual bool range_on_edge (vrange &r, edge, tree expr); virtual bool range_of_stmt (vrange &r, gimple *, tree name = NULL); + virtual bool range_on_entry (vrange &r, basic_block bb, tree expr); + virtual bool range_on_exit (vrange &r, basic_block bb, tree expr); // Query if there is any relation between SSA1 and SSA2. relation_kind query_relation (gimple *s, tree ssa1, tree ssa2, @@ -82,7 +86,10 @@ public: virtual void dump (FILE *); protected: - bool get_tree_range (vrange &v, tree expr, gimple *stmt); + bool get_tree_range (vrange &v, tree expr, gimple *stmt, + basic_block bbentry = NULL, basic_block bbexit = NULL); + bool invoke_range_of_expr (vrange &v, tree expr, gimple *stmt, + basic_block bbentry, basic_block bbexit); bool get_arith_expr_range (vrange &r, tree expr, gimple *stmt); relation_oracle *m_oracle; }; diff --git a/gcc/value-range-pretty-print.cc b/gcc/value-range-pretty-print.cc index c75cbea3955..b6d23dce6d2 100644 --- a/gcc/value-range-pretty-print.cc +++ b/gcc/value-range-pretty-print.cc @@ -30,6 +30,44 @@ along with GCC; see the file COPYING3. If not see #include "gimple-range.h" #include "value-range-pretty-print.h" +static void +print_int_bound (pretty_printer *pp, const wide_int &bound, tree type) +{ + wide_int type_min = wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type)); + wide_int type_max = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type)); + + if (INTEGRAL_TYPE_P (type) + && !TYPE_UNSIGNED (type) + && bound == type_min + && TYPE_PRECISION (type) != 1) + pp_string (pp, "-INF"); + else if (bound == type_max && TYPE_PRECISION (type) != 1) + pp_string (pp, "+INF"); + else + pp_wide_int (pp, bound, TYPE_SIGN (type)); +} + +static void +print_irange_bitmasks (pretty_printer *pp, const irange_bitmask &bm) +{ + if (bm.unknown_p ()) + return; + + pp_string (pp, " MASK "); + char buf[WIDE_INT_PRINT_BUFFER_SIZE], *p; + unsigned len_mask, len_val; + if (print_hex_buf_size (bm.mask (), &len_mask) + | print_hex_buf_size (bm.value (), &len_val)) + p = XALLOCAVEC (char, MAX (len_mask, len_val)); + else + p = buf; + print_hex (bm.mask (), p); + pp_string (pp, p); + pp_string (pp, " VALUE "); + print_hex (bm.value (), p); + pp_string (pp, p); +} + void vrange_printer::visit (const unsupported_range &r) const { @@ -66,51 +104,12 @@ vrange_printer::visit (const irange &r) const for (unsigned i = 0; i < r.num_pairs (); ++i) { pp_character (pp, '['); - print_irange_bound (r.lower_bound (i), r.type ()); + print_int_bound (pp, r.lower_bound (i), r.type ()); pp_string (pp, ", "); - print_irange_bound (r.upper_bound (i), r.type ()); + print_int_bound (pp, r.upper_bound (i), r.type ()); pp_character (pp, ']'); } - print_irange_bitmasks (r); -} - -void -vrange_printer::print_irange_bound (const wide_int &bound, tree type) const -{ - wide_int type_min = wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type)); - wide_int type_max = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type)); - - if (INTEGRAL_TYPE_P (type) - && !TYPE_UNSIGNED (type) - && bound == type_min - && TYPE_PRECISION (type) != 1) - pp_string (pp, "-INF"); - else if (bound == type_max && TYPE_PRECISION (type) != 1) - pp_string (pp, "+INF"); - else - pp_wide_int (pp, bound, TYPE_SIGN (type)); -} - -void -vrange_printer::print_irange_bitmasks (const irange &r) const -{ - irange_bitmask bm = r.m_bitmask; - if (bm.unknown_p ()) - return; - - pp_string (pp, " MASK "); - char buf[WIDE_INT_PRINT_BUFFER_SIZE], *p; - unsigned len_mask, len_val; - if (print_hex_buf_size (bm.mask (), &len_mask) - | print_hex_buf_size (bm.value (), &len_val)) - p = XALLOCAVEC (char, MAX (len_mask, len_val)); - else - p = buf; - print_hex (bm.mask (), p); - pp_string (pp, p); - pp_string (pp, " VALUE "); - print_hex (bm.value (), p); - pp_string (pp, p); + print_irange_bitmasks (pp, r.m_bitmask); } void diff --git a/gcc/value-range-pretty-print.h b/gcc/value-range-pretty-print.h index ca85fd6157c..44cd6e81298 100644 --- a/gcc/value-range-pretty-print.h +++ b/gcc/value-range-pretty-print.h @@ -29,8 +29,6 @@ public: void visit (const irange &) const override; void visit (const frange &) const override; private: - void print_irange_bound (const wide_int &w, tree type) const; - void print_irange_bitmasks (const irange &) const; void print_frange_nan (const frange &) const; void print_real_value (tree type, const REAL_VALUE_TYPE &r) const; diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc index f00474ad0e6..09a29776a0e 100644 --- a/gcc/value-range-storage.cc +++ b/gcc/value-range-storage.cc @@ -165,6 +165,19 @@ vrange_storage::set_vrange (const vrange &r) } else gcc_unreachable (); + + // Verify that reading back from the cache didn't drop bits. + if (flag_checking + // FIXME: Avoid checking frange, as it currently pessimizes some ranges: + // + // gfortran.dg/pr49472.f90 pessimizes [0.0, 1.0] into [-0.0, 1.0]. + && !is_a <frange> (r) + && !r.undefined_p ()) + { + Value_Range tmp (r); + get_vrange (tmp, r.type ()); + gcc_checking_assert (tmp == r); + } } // Restore R from storage. @@ -306,13 +319,6 @@ irange_storage::set_irange (const irange &r) irange_bitmask bm = r.m_bitmask; write_wide_int (val, len, bm.value ()); write_wide_int (val, len, bm.mask ()); - - if (flag_checking) - { - int_range_max tmp; - get_irange (tmp, r.type ()); - gcc_checking_assert (tmp == r); - } } static inline void diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h index d94c520aa73..5756de7e32d 100644 --- a/gcc/value-range-storage.h +++ b/gcc/value-range-storage.h @@ -75,10 +75,6 @@ private: static size_t size (const irange &r); const unsigned short *lengths_address () const; unsigned short *write_lengths_address (); - friend void gt_ggc_mx_irange_storage (void *); - friend void gt_pch_p_14irange_storage (void *, void *, - gt_pointer_operator, void *); - friend void gt_pch_nx_irange_storage (void *); // The shared precision of each number. unsigned short m_precision; diff --git a/gcc/value-range.cc b/gcc/value-range.cc index 70375f7abf9..7250115261f 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -31,36 +31,34 @@ along with GCC; see the file COPYING3. If not see #include "fold-const.h" #include "gimple-range.h" -void -irange::accept (const vrange_visitor &v) const -{ - v.visit (*this); -} +// Return the bitmask inherent in a range. -void -unsupported_range::accept (const vrange_visitor &v) const +static irange_bitmask +get_bitmask_from_range (tree type, + const wide_int &min, const wide_int &max) { - v.visit (*this); -} + unsigned prec = TYPE_PRECISION (type); -// Convenience function only available for integers and pointers. + // All the bits of a singleton are known. + if (min == max) + { + wide_int mask = wi::zero (prec); + wide_int value = min; + return irange_bitmask (value, mask); + } -wide_int -Value_Range::lower_bound () const -{ - if (is_a <irange> (*m_vrange)) - return as_a <irange> (*m_vrange).lower_bound (); - gcc_unreachable (); -} + wide_int xorv = min ^ max; -// Convenience function only available for integers and pointers. + if (xorv != 0) + xorv = wi::mask (prec - wi::clz (xorv), false, prec); -wide_int -Value_Range::upper_bound () const + return irange_bitmask (wi::zero (prec), min | xorv); +} + +void +irange::accept (const vrange_visitor &v) const { - if (is_a <irange> (*m_vrange)) - return as_a <irange> (*m_vrange).upper_bound (); - gcc_unreachable (); + v.visit (*this); } void @@ -86,53 +84,73 @@ debug (const irange_bitmask &bm) fprintf (stderr, "\n"); } -// Default vrange definitions. +// Definitions for unsupported_range. + +void +unsupported_range::accept (const vrange_visitor &v) const +{ + v.visit (*this); +} + +void +vrange::update_bitmask (const class irange_bitmask &) +{ +} + +irange_bitmask +vrange::get_bitmask () const +{ + // Return all unknown bits for the given precision. + return irange_bitmask (TYPE_PRECISION (type ())); +} bool -vrange::contains_p (tree) const +unsupported_range::contains_p (tree) const { return varying_p (); } bool -vrange::singleton_p (tree *) const +unsupported_range::singleton_p (tree *) const { return false; } void -vrange::set (tree min, tree, value_range_kind) +unsupported_range::set (tree min, tree, value_range_kind) { set_varying (TREE_TYPE (min)); } tree -vrange::type () const +unsupported_range::type () const { return void_type_node; } bool -vrange::supports_type_p (const_tree) const +unsupported_range::supports_type_p (const_tree) const { return false; } void -vrange::set_undefined () +unsupported_range::set_undefined () { m_kind = VR_UNDEFINED; } void -vrange::set_varying (tree) +unsupported_range::set_varying (tree) { m_kind = VR_VARYING; } bool -vrange::union_ (const vrange &r) +unsupported_range::union_ (const vrange &v) { + const unsupported_range &r = as_a <unsupported_range> (v); + if (r.undefined_p () || varying_p ()) return false; if (undefined_p () || r.varying_p ()) @@ -145,8 +163,10 @@ vrange::union_ (const vrange &r) } bool -vrange::intersect (const vrange &r) +unsupported_range::intersect (const vrange &v) { + const unsupported_range &r = as_a <unsupported_range> (v); + if (undefined_p () || r.varying_p ()) return false; if (r.undefined_p ()) @@ -164,41 +184,65 @@ vrange::intersect (const vrange &r) } bool -vrange::zero_p () const +unsupported_range::zero_p () const { return false; } bool -vrange::nonzero_p () const +unsupported_range::nonzero_p () const { return false; } void -vrange::set_nonzero (tree type) +unsupported_range::set_nonzero (tree type) { set_varying (type); } void -vrange::set_zero (tree type) +unsupported_range::set_zero (tree type) { set_varying (type); } void -vrange::set_nonnegative (tree type) +unsupported_range::set_nonnegative (tree type) { set_varying (type); } bool -vrange::fits_p (const vrange &) const +unsupported_range::fits_p (const vrange &) const { return true; } +unsupported_range & +unsupported_range::operator= (const unsupported_range &r) +{ + if (r.undefined_p ()) + set_undefined (); + else if (r.varying_p ()) + set_varying (void_type_node); + else + gcc_unreachable (); + return *this; +} + +tree +unsupported_range::lbound () const +{ + return NULL; +} + +tree +unsupported_range::ubound () const +{ + return NULL; +} + // Assignment operator for generic ranges. Copying incompatible types // is not allowed. @@ -359,6 +403,12 @@ frange::accept (const vrange_visitor &v) const v.visit (*this); } +bool +frange::fits_p (const vrange &) const +{ + return true; +} + // Flush denormal endpoints to the appropriate 0.0. void @@ -939,6 +989,18 @@ frange::set_nonnegative (tree type) set (type, dconst0, frange_val_max (type)); } +tree +frange::lbound () const +{ + return build_real (type (), lower_bound ()); +} + +tree +frange::ubound () const +{ + return build_real (type (), upper_bound ()); +} + // Here we copy between any two irange's. irange & @@ -970,7 +1032,7 @@ irange::operator= (const irange &src) return *this; } -value_range_kind +static value_range_kind get_legacy_range (const irange &r, tree &min, tree &max) { if (r.undefined_p ()) @@ -1007,6 +1069,21 @@ get_legacy_range (const irange &r, tree &min, tree &max) return VR_RANGE; } +// Given a range in V, return an old-style legacy range consisting of +// a value_range_kind with a MIN/MAX. This is to maintain +// compatibility with passes that still depend on VR_ANTI_RANGE, and +// only works for integers and pointers. + +value_range_kind +get_legacy_range (const vrange &v, tree &min, tree &max) +{ + if (is_a <irange> (v)) + return get_legacy_range (as_a <irange> (v), min, max); + + gcc_unreachable (); + return VR_UNDEFINED; +} + /* Set value range to the canonical form of {VRTYPE, MIN, MAX, EQUIV}. This means adjusting VRTYPE, MIN and MAX representing the case of a wrapping range with MAX < MIN covering [MIN, type_max] U [type_min, MAX] @@ -1832,31 +1909,6 @@ irange::invert () verify_range (); } -// Return the bitmask inherent in the range. - -irange_bitmask -irange::get_bitmask_from_range () const -{ - unsigned prec = TYPE_PRECISION (type ()); - wide_int min = lower_bound (); - wide_int max = upper_bound (); - - // All the bits of a singleton are known. - if (min == max) - { - wide_int mask = wi::zero (prec); - wide_int value = lower_bound (); - return irange_bitmask (value, mask); - } - - wide_int xorv = min ^ max; - - if (xorv != 0) - xorv = wi::mask (prec - wi::clz (xorv), false, prec); - - return irange_bitmask (wi::zero (prec), min | xorv); -} - // Remove trailing ranges that this bitmask indicates can't exist. void @@ -1978,7 +2030,8 @@ irange::get_bitmask () const // in the mask. // // See also the note in irange_bitmask::intersect. - irange_bitmask bm = get_bitmask_from_range (); + irange_bitmask bm + = get_bitmask_from_range (type (), lower_bound (), upper_bound ()); if (!m_bitmask.unknown_p ()) bm.intersect (m_bitmask); return bm; @@ -1988,7 +2041,7 @@ irange::get_bitmask () const // normalize the range if anything changed. void -irange::set_nonzero_bits (const wide_int &bits) +vrange::set_nonzero_bits (const wide_int &bits) { gcc_checking_assert (!undefined_p ()); irange_bitmask bm (wi::zero (TYPE_PRECISION (type ())), bits); @@ -1998,7 +2051,7 @@ irange::set_nonzero_bits (const wide_int &bits) // Return the nonzero bits in R. wide_int -irange::get_nonzero_bits () const +vrange::get_nonzero_bits () const { gcc_checking_assert (!undefined_p ()); irange_bitmask bm = get_bitmask (); @@ -2018,7 +2071,8 @@ irange::intersect_bitmask (const irange &r) irange_bitmask bm = get_bitmask (); irange_bitmask save = bm; - if (!bm.intersect (r.get_bitmask ())) + bm.intersect (r.get_bitmask ()); + if (save == bm) return false; m_bitmask = bm; @@ -2050,7 +2104,8 @@ irange::union_bitmask (const irange &r) irange_bitmask bm = get_bitmask (); irange_bitmask save = bm; - if (!bm.union_ (r.get_bitmask ())) + bm.union_ (r.get_bitmask ()); + if (save == bm) return false; m_bitmask = bm; @@ -2068,10 +2123,23 @@ irange::union_bitmask (const irange &r) return true; } +tree +irange::lbound () const +{ + return wide_int_to_tree (type (), lower_bound ()); +} + +tree +irange::ubound () const +{ + return wide_int_to_tree (type (), upper_bound ()); +} + void irange_bitmask::verify_mask () const { gcc_assert (m_value.get_precision () == m_mask.get_precision ()); + gcc_checking_assert (wi::bit_and (m_mask, m_value) == 0); } void @@ -2119,79 +2187,6 @@ vrp_operand_equal_p (const_tree val1, const_tree val2) return true; } -void -gt_ggc_mx (irange *x) -{ - if (!x->undefined_p ()) - gt_ggc_mx (x->m_type); -} - -void -gt_pch_nx (irange *x) -{ - if (!x->undefined_p ()) - gt_pch_nx (x->m_type); -} - -void -gt_pch_nx (irange *x, gt_pointer_operator op, void *cookie) -{ - for (unsigned i = 0; i < x->m_num_ranges; ++i) - { - op (&x->m_base[i * 2], NULL, cookie); - op (&x->m_base[i * 2 + 1], NULL, cookie); - } -} - -void -gt_ggc_mx (frange *x) -{ - gt_ggc_mx (x->m_type); -} - -void -gt_pch_nx (frange *x) -{ - gt_pch_nx (x->m_type); -} - -void -gt_pch_nx (frange *x, gt_pointer_operator op, void *cookie) -{ - op (&x->m_type, NULL, cookie); -} - -void -gt_ggc_mx (vrange *x) -{ - if (is_a <irange> (*x)) - return gt_ggc_mx ((irange *) x); - if (is_a <frange> (*x)) - return gt_ggc_mx ((frange *) x); - gcc_unreachable (); -} - -void -gt_pch_nx (vrange *x) -{ - if (is_a <irange> (*x)) - return gt_pch_nx ((irange *) x); - if (is_a <frange> (*x)) - return gt_pch_nx ((frange *) x); - gcc_unreachable (); -} - -void -gt_pch_nx (vrange *x, gt_pointer_operator op, void *cookie) -{ - if (is_a <irange> (*x)) - gt_pch_nx ((irange *) x, op, cookie); - else if (is_a <frange> (*x)) - gt_pch_nx ((frange *) x, op, cookie); - else - gcc_unreachable (); -} - #define DEFINE_INT_RANGE_INSTANCE(N) \ template int_range<N>::int_range(tree_node *, \ const wide_int &, \ @@ -2459,7 +2454,8 @@ range_tests_misc () ASSERT_TRUE (not_255 == range_uchar (0, 254)); // Test that NOT(0) is [1..255] in 8-bit land. - int_range<2> not_zero = range_nonzero (unsigned_char_type_node); + int_range<2> not_zero; + not_zero.set_nonzero (unsigned_char_type_node); ASSERT_TRUE (not_zero == range_uchar (1, 255)); // Check that [0,127][0x..ffffff80,0x..ffffff] @@ -2538,7 +2534,7 @@ range_tests_misc () ASSERT_TRUE (r0 == r2); // Test that booleans and their inverse work as expected. - r0 = range_zero (boolean_type_node); + r0.set_zero (boolean_type_node); ASSERT_TRUE (r0 == range_false ()); r0.invert (); ASSERT_TRUE (r0 == range_true ()); @@ -2546,7 +2542,7 @@ range_tests_misc () // Make sure NULL and non-NULL of pointer types work, and that // inverses of them are consistent. tree voidp = build_pointer_type (void_type_node); - r0 = range_zero (voidp); + r0.set_zero (voidp); r1 = r0; r0.invert (); r0.invert (); diff --git a/gcc/value-range.h b/gcc/value-range.h index 9531df56988..f1c638f8cd0 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -72,7 +72,7 @@ enum value_range_discriminator // if (f.supports_type_p (type)) ... // } -class GTY((user)) vrange +class vrange { template <typename T> friend bool is_a (vrange &); friend class Value_Range; @@ -80,21 +80,28 @@ class GTY((user)) vrange friend class range_op_handler; public: virtual void accept (const class vrange_visitor &v) const = 0; - virtual void set (tree, tree, value_range_kind = VR_RANGE); - virtual tree type () const; - virtual bool supports_type_p (const_tree type) const; - virtual void set_varying (tree type); - virtual void set_undefined (); - virtual bool union_ (const vrange &); - virtual bool intersect (const vrange &); - virtual bool singleton_p (tree *result = NULL) const; - virtual bool contains_p (tree cst) const; - virtual bool zero_p () const; - virtual bool nonzero_p () const; - virtual void set_nonzero (tree type); - virtual void set_zero (tree type); - virtual void set_nonnegative (tree type); - virtual bool fits_p (const vrange &r) const; + virtual void set (tree, tree, value_range_kind = VR_RANGE) = 0; + virtual tree type () const = 0; + virtual bool supports_type_p (const_tree type) const = 0; + virtual void set_varying (tree type) = 0; + virtual void set_undefined () = 0; + virtual bool union_ (const vrange &) = 0; + virtual bool intersect (const vrange &) = 0; + virtual bool singleton_p (tree *result = NULL) const = 0; + virtual bool contains_p (tree cst) const = 0; + virtual bool zero_p () const = 0; + virtual bool nonzero_p () const = 0; + virtual void set_nonzero (tree type) = 0; + virtual void set_zero (tree type) = 0; + virtual void set_nonnegative (tree type) = 0; + virtual bool fits_p (const vrange &r) const = 0; + virtual ~vrange () { } + virtual tree lbound () const = 0; + virtual tree ubound () const = 0; + virtual void update_bitmask (const class irange_bitmask &); + virtual irange_bitmask get_bitmask () const; + wide_int get_nonzero_bits () const; + void set_nonzero_bits (const wide_int &bits); bool varying_p () const; bool undefined_p () const; @@ -132,8 +139,8 @@ public: void set_unknown (unsigned prec); bool unknown_p () const; unsigned get_precision () const; - bool union_ (const irange_bitmask &src); - bool intersect (const irange_bitmask &src); + void union_ (const irange_bitmask &src); + void intersect (const irange_bitmask &src); bool operator== (const irange_bitmask &src) const; bool operator!= (const irange_bitmask &src) const { return !(*this == src); } void verify_mask () const; @@ -226,29 +233,18 @@ irange_bitmask::operator== (const irange_bitmask &src) const return m_value == src.m_value && m_mask == src.m_mask; } -inline bool -irange_bitmask::union_ (const irange_bitmask &orig_src) +inline void +irange_bitmask::union_ (const irange_bitmask &src) { - // Normalize mask. - irange_bitmask src (orig_src.m_value & ~orig_src.m_mask, orig_src.m_mask); - m_value &= ~m_mask; - - irange_bitmask save (*this); m_mask = (m_mask | src.m_mask) | (m_value ^ src.m_value); m_value = m_value & src.m_value; if (flag_checking) verify_mask (); - return *this != save; } -inline bool -irange_bitmask::intersect (const irange_bitmask &orig_src) +inline void +irange_bitmask::intersect (const irange_bitmask &src) { - // Normalize mask. - irange_bitmask src (orig_src.m_value & ~orig_src.m_mask, orig_src.m_mask); - m_value &= ~m_mask; - - irange_bitmask save (*this); // If we have two known bits that are incompatible, the resulting // bit is undefined. It is unclear whether we should set the entire // range to UNDEFINED, or just a subset of it. For now, set the @@ -267,14 +263,12 @@ irange_bitmask::intersect (const irange_bitmask &orig_src) } if (flag_checking) verify_mask (); - return *this != save; } // An integer range without any storage. -class GTY((user)) irange : public vrange +class irange : public vrange { - friend value_range_kind get_legacy_range (const irange &, tree &, tree &); friend class irange_storage; friend class vrange_printer; public: @@ -297,6 +291,8 @@ public: wide_int lower_bound (unsigned = 0) const; wide_int upper_bound (unsigned) const; wide_int upper_bound () const; + virtual tree lbound () const override; + virtual tree ubound () const override; // Predicates. virtual bool zero_p () const override; @@ -321,11 +317,8 @@ public: virtual bool fits_p (const vrange &r) const override; virtual void accept (const vrange_visitor &v) const override; - void update_bitmask (const irange_bitmask &); - irange_bitmask get_bitmask () const; - // Nonzero masks. - wide_int get_nonzero_bits () const; - void set_nonzero_bits (const wide_int &bits); + virtual void update_bitmask (const class irange_bitmask &) override; + virtual irange_bitmask get_bitmask () const override; protected: void maybe_resize (int needed); @@ -344,14 +337,9 @@ protected: // Hard limit on max ranges allowed. static const int HARD_MAX_RANGES = 255; private: - friend void gt_ggc_mx (irange *); - friend void gt_pch_nx (irange *); - friend void gt_pch_nx (irange *, gt_pointer_operator, void *); - bool varying_compatible_p () const; bool intersect_bitmask (const irange &r); bool union_bitmask (const irange &r); - irange_bitmask get_bitmask_from_range () const; bool set_range_from_bitmask (); bool intersect (const wide_int& lb, const wide_int& ub); @@ -373,7 +361,7 @@ protected: // HARD_MAX_RANGES. This new storage is freed upon destruction. template<unsigned N, bool RESIZABLE = false> -class GTY((user)) int_range : public irange +class int_range : public irange { public: int_range (); @@ -382,7 +370,7 @@ public: int_range (tree type); int_range (const int_range &); int_range (const irange &); - virtual ~int_range (); + ~int_range () final override; int_range& operator= (const int_range &); protected: int_range (tree, tree, value_range_kind = VR_RANGE); @@ -401,11 +389,30 @@ public: { set_undefined (); } - virtual void set_undefined () final override + unsupported_range (const unsupported_range &src) + : vrange (VR_UNKNOWN) { - m_kind = VR_UNDEFINED; + unsupported_range::operator= (src); } - virtual void accept (const vrange_visitor &v) const override; + void set (tree min, tree, value_range_kind = VR_RANGE) final override; + tree type () const final override; + bool supports_type_p (const_tree) const final override; + void set_varying (tree) final override; + void set_undefined () final override; + void accept (const vrange_visitor &v) const final override; + bool union_ (const vrange &r) final override; + bool intersect (const vrange &r) final override; + bool singleton_p (tree * = NULL) const final override; + bool contains_p (tree) const final override; + bool zero_p () const final override; + bool nonzero_p () const final override; + void set_nonzero (tree type) final override; + void set_zero (tree type) final override; + void set_nonnegative (tree type) final override; + bool fits_p (const vrange &) const final override; + unsupported_range& operator= (const unsupported_range &r); + tree lbound () const final override; + tree ubound () const final override; }; // The NAN state as an opaque object. @@ -464,13 +471,10 @@ nan_state::neg_p () const // The representation is a type with a couple of endpoints, unioned // with the set of { -NAN, +Nan }. -class GTY((user)) frange : public vrange +class frange : public vrange { friend class frange_storage; friend class vrange_printer; - friend void gt_ggc_mx (frange *); - friend void gt_pch_nx (frange *); - friend void gt_pch_nx (frange *, gt_pointer_operator, void *); public: frange (); frange (const frange &); @@ -507,11 +511,14 @@ public: virtual void set_nonzero (tree type) override; virtual void set_zero (tree type) override; virtual void set_nonnegative (tree type) override; + virtual bool fits_p (const vrange &) const override; frange& operator= (const frange &); bool operator== (const frange &) const; bool operator!= (const frange &r) const { return !(*this == r); } const REAL_VALUE_TYPE &lower_bound () const; const REAL_VALUE_TYPE &upper_bound () const; + virtual tree lbound () const override; + virtual tree ubound () const override; nan_state get_nan_state () const; void update_nan (); void update_nan (bool sign); @@ -677,6 +684,16 @@ typedef int_range<2> value_range; // This is an "infinite" precision range object for use in temporary // calculations for any of the handled types. The object can be // transparently used as a vrange. +// +// Using any of the various constructors initializes the object +// appropriately, but the default constructor is uninitialized and +// must be initialized either with set_type() or by assigning into it. +// +// Assigning between incompatible types is allowed. For example if a +// temporary holds an irange, you can assign an frange into it, and +// all the right things will happen. However, before passing this +// object to a function accepting a vrange, the correct type must be +// set. If it isn't, you can do so with set_type(). class Value_Range { @@ -686,6 +703,7 @@ public: Value_Range (tree type); Value_Range (tree, tree, value_range_kind kind = VR_RANGE); Value_Range (const Value_Range &); + ~Value_Range (); void set_type (tree type); vrange& operator= (const vrange &); Value_Range& operator= (const Value_Range &); @@ -696,7 +714,6 @@ public: void dump (FILE *) const; static bool supports_type_p (const_tree type); - // Convenience methods for vrange compatibility. tree type () { return m_vrange->type (); } bool varying_p () const { return m_vrange->varying_p (); } bool undefined_p () const { return m_vrange->undefined_p (); } @@ -712,21 +729,37 @@ public: { init (type); return m_vrange->set_nonzero (type); } bool nonzero_p () const { return m_vrange->nonzero_p (); } bool zero_p () const { return m_vrange->zero_p (); } - wide_int lower_bound () const; // For irange/prange comparability. - wide_int upper_bound () const; // For irange/prange comparability. + tree lbound () const { return m_vrange->lbound (); } + tree ubound () const { return m_vrange->ubound (); } + irange_bitmask get_bitmask () const { return m_vrange->get_bitmask (); } + void update_bitmask (const class irange_bitmask &bm) + { return m_vrange->update_bitmask (bm); } void accept (const vrange_visitor &v) const { m_vrange->accept (v); } private: void init (tree type); - unsupported_range m_unsupported; + void init (const vrange &); + vrange *m_vrange; - int_range_max m_irange; - frange m_frange; + // The buffer must be at least the size of the largest range. + static_assert (sizeof (int_range_max) > sizeof (frange)); + char m_buffer[sizeof (int_range_max)]; }; +// The default constructor is uninitialized and must be initialized +// with either set_type() or with an assignment into it. + inline Value_Range::Value_Range () { - m_vrange = &m_unsupported; + m_vrange = NULL; +} + +// Copy constructor. + +inline +Value_Range::Value_Range (const Value_Range &r) +{ + init (*r.m_vrange); } // Copy constructor from a vrange. @@ -734,11 +767,11 @@ Value_Range::Value_Range () inline Value_Range::Value_Range (const vrange &r) { - *this = r; + init (r); } -// Copy constructor from a TYPE. The range of the temporary is set to -// UNDEFINED. +// Construct an UNDEFINED range that can hold ranges of TYPE. If TYPE +// is not supported, default to unsupported_range. inline Value_Range::Value_Range (tree type) @@ -746,6 +779,9 @@ Value_Range::Value_Range (tree type) init (type); } +// Construct a range that can hold a range of [MIN, MAX], where MIN +// and MAX are trees. + inline Value_Range::Value_Range (tree min, tree max, value_range_kind kind) { @@ -754,13 +790,25 @@ Value_Range::Value_Range (tree min, tree max, value_range_kind kind) } inline -Value_Range::Value_Range (const Value_Range &r) +Value_Range::~Value_Range () { - *this = *r.m_vrange; + if (m_vrange) + m_vrange->~vrange (); } -// Initialize object so it is possible to store temporaries of TYPE -// into it. +// Initialize object to an UNDEFINED range that can hold ranges of +// TYPE. Clean-up memory if there was a previous object. + +inline void +Value_Range::set_type (tree type) +{ + if (m_vrange) + m_vrange->~vrange (); + init (type); +} + +// Initialize object to an UNDEFINED range that can hold ranges of +// TYPE. inline void Value_Range::init (tree type) @@ -768,71 +816,45 @@ Value_Range::init (tree type) gcc_checking_assert (TYPE_P (type)); if (irange::supports_p (type)) - m_vrange = &m_irange; + m_vrange = new (&m_buffer) int_range_max (); else if (frange::supports_p (type)) - m_vrange = &m_frange; + m_vrange = new (&m_buffer) frange (); else - m_vrange = &m_unsupported; + m_vrange = new (&m_buffer) unsupported_range (); } -// Set the temporary to allow storing temporaries of TYPE. The range -// of the temporary is set to UNDEFINED. +// Initialize object with a copy of R. inline void -Value_Range::set_type (tree type) +Value_Range::init (const vrange &r) { - init (type); - m_vrange->set_undefined (); + if (is_a <irange> (r)) + m_vrange = new (&m_buffer) int_range_max (as_a <irange> (r)); + else if (is_a <frange> (r)) + m_vrange = new (&m_buffer) frange (as_a <frange> (r)); + else + m_vrange = new (&m_buffer) unsupported_range (as_a <unsupported_range> (r)); } -// Assignment operator for temporaries. Copying incompatible types is -// allowed. +// Assignment operator. Copying incompatible types is allowed. That +// is, assigning an frange to an object holding an irange does the +// right thing. inline vrange & Value_Range::operator= (const vrange &r) { - if (is_a <irange> (r)) - { - m_irange = as_a <irange> (r); - m_vrange = &m_irange; - } - else if (is_a <frange> (r)) - { - m_frange = as_a <frange> (r); - m_vrange = &m_frange; - } - else if (is_a <unsupported_range> (r)) - { - m_unsupported = as_a <unsupported_range> (r); - m_vrange = &m_unsupported; - } - else - gcc_unreachable (); - + if (m_vrange) + m_vrange->~vrange (); + init (r); return *m_vrange; } inline Value_Range & Value_Range::operator= (const Value_Range &r) { - if (r.m_vrange == &r.m_irange) - { - m_irange = r.m_irange; - m_vrange = &m_irange; - } - else if (r.m_vrange == &r.m_frange) - { - m_frange = r.m_frange; - m_vrange = &m_frange; - } - else if (r.m_vrange == &r.m_unsupported) - { - m_unsupported = r.m_unsupported; - m_vrange = &m_unsupported; - } - else - gcc_unreachable (); - + // No need to call the m_vrange destructor here, as we will do so in + // the assignment below. + *this = *r.m_vrange; return *this; } @@ -868,7 +890,7 @@ Value_Range::supports_type_p (const_tree type) return irange::supports_p (type) || frange::supports_p (type); } -extern value_range_kind get_legacy_range (const irange &, tree &min, tree &max); +extern value_range_kind get_legacy_range (const vrange &, tree &min, tree &max); extern void dump_value_range (FILE *, const vrange *); extern bool vrp_operand_equal_p (const_tree, const_tree); inline REAL_VALUE_TYPE frange_val_min (const_tree type); @@ -954,47 +976,15 @@ irange::contains_p (tree cst) const } inline bool -range_includes_zero_p (const irange *vr) +range_includes_zero_p (const vrange &vr) { - if (vr->undefined_p ()) + if (vr.undefined_p ()) return false; - if (vr->varying_p ()) + if (vr.varying_p ()) return true; - wide_int zero = wi::zero (TYPE_PRECISION (vr->type ())); - return vr->contains_p (zero); -} - -extern void gt_ggc_mx (vrange *); -extern void gt_pch_nx (vrange *); -extern void gt_pch_nx (vrange *, gt_pointer_operator, void *); -extern void gt_ggc_mx (irange *); -extern void gt_pch_nx (irange *); -extern void gt_pch_nx (irange *, gt_pointer_operator, void *); -extern void gt_ggc_mx (frange *); -extern void gt_pch_nx (frange *); -extern void gt_pch_nx (frange *, gt_pointer_operator, void *); - -template<unsigned N> -inline void -gt_ggc_mx (int_range<N> *x) -{ - gt_ggc_mx ((irange *) x); -} - -template<unsigned N> -inline void -gt_pch_nx (int_range<N> *x) -{ - gt_pch_nx ((irange *) x); -} - -template<unsigned N> -inline void -gt_pch_nx (int_range<N> *x, gt_pointer_operator op, void *cookie) -{ - gt_pch_nx ((irange *) x, op, cookie); + return vr.contains_p (build_zero_cst (vr.type ())); } // Constructors for irange diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc index a7e291a16e5..0572bf6c8c7 100644 --- a/gcc/vr-values.cc +++ b/gcc/vr-values.cc @@ -310,7 +310,8 @@ tree simplify_using_ranges::fold_cond_with_ops (enum tree_code code, tree op0, tree op1, gimple *s) { - int_range_max r0, r1; + Value_Range r0 (TREE_TYPE (op0)); + Value_Range r1 (TREE_TYPE (op1)); if (!query->range_of_expr (r0, op0, s) || !query->range_of_expr (r1, op1, s)) return NULL_TREE; @@ -320,9 +321,9 @@ simplify_using_ranges::fold_cond_with_ops (enum tree_code code, range_op_handler handler (code); if (handler && handler.fold_range (res, type, r0, r1)) { - if (res == range_true (type)) + if (res == range_true ()) return boolean_true_node; - if (res == range_false (type)) + if (res == range_false ()) return boolean_false_node; } return NULL; diff --git a/libatomic/ChangeLog b/libatomic/ChangeLog index 41fbe2a88d6..6056af6a0d6 100644 --- a/libatomic/ChangeLog +++ b/libatomic/ChangeLog @@ -1,3 +1,8 @@ +2024-04-26 Wilco Dijkstra <wilco.dijkstra@arm.com> + + * config/linux/aarch64/atomic_16.S: Add __libat_ prefix in the + LSE2/LSE128/CORE macros, remove elsewhere. Add ATOMIC macro. + 2024-04-05 Jakub Jelinek <jakub@redhat.com> * configure: Regenerate. diff --git a/libatomic/config/linux/aarch64/atomic_16.S b/libatomic/config/linux/aarch64/atomic_16.S index 4e3fa870b03..b63e97ac5a2 100644 --- a/libatomic/config/linux/aarch64/atomic_16.S +++ b/libatomic/config/linux/aarch64/atomic_16.S @@ -45,7 +45,7 @@ # define HAVE_FEAT_LSE128 0 #endif -#define HAVE_FEAT_LSE2 HAVE_IFUNC +#define HAVE_FEAT_LSE2 HAVE_IFUNC #if HAVE_FEAT_LSE128 .arch armv9-a+lse128 @@ -53,31 +53,37 @@ .arch armv8-a+lse #endif -#define LSE128(NAME) NAME##_i1 -#define LSE2(NAME) NAME##_i2 -#define CORE(NAME) NAME +#define LSE128(NAME) libat_##NAME##_i1 +#define LSE2(NAME) libat_##NAME##_i2 +#define CORE(NAME) libat_##NAME +#define ATOMIC(NAME) __atomic_##NAME -#define ENTRY_FEAT(NAME, FEAT) \ - ENTRY (FEAT (NAME)) +#if HAVE_IFUNC +# define ENTRY(NAME) ENTRY2 (CORE (NAME), ) +# define ENTRY_FEAT(NAME, FEAT) ENTRY2 (FEAT (NAME), ) +# define END_FEAT(NAME, FEAT) END2 (FEAT (NAME)) +#else +/* Emit __atomic_* entrypoints if no ifuncs. */ +# define ENTRY(NAME) ENTRY2 (CORE (NAME), ALIAS (NAME, ATOMIC, CORE)) +#endif + +#define END(NAME) END2 (CORE (NAME)) -#define ENTRY(NAME) \ +#define ENTRY2(NAME, ALIASES) \ .global NAME; \ .hidden NAME; \ .type NAME,%function; \ .p2align 4; \ + ALIASES; \ NAME: \ - .cfi_startproc; \ - hint 34 // bti c - -#define END_FEAT(NAME, FEAT) \ - END (FEAT (NAME)) + .cfi_startproc; \ + hint 34; // bti c -#define END(NAME) \ +#define END2(NAME) \ .cfi_endproc; \ .size NAME, .-NAME; -#define ALIAS(NAME, FROM, TO) ALIAS1 (FROM (NAME),TO (NAME)) -#define ALIAS2(NAME) ALIAS1 (__atomic_##NAME, libat_##NAME) +#define ALIAS(NAME, FROM, TO) ALIAS1 (FROM (NAME), TO (NAME)) #define ALIAS1(ALIAS, NAME) \ .global ALIAS; \ @@ -116,7 +122,7 @@ NAME: \ #define SEQ_CST 5 -ENTRY (libat_load_16) +ENTRY (load_16) mov x5, x0 cbnz w1, 2f @@ -131,11 +137,11 @@ ENTRY (libat_load_16) stxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_load_16) +END (load_16) #if HAVE_FEAT_LSE2 -ENTRY_FEAT (libat_load_16, LSE2) +ENTRY_FEAT (load_16, LSE2) cbnz w1, 1f /* RELAXED. */ @@ -155,11 +161,11 @@ ENTRY_FEAT (libat_load_16, LSE2) ldp res0, res1, [x0] dmb ishld ret -END_FEAT (libat_load_16, LSE2) +END_FEAT (load_16, LSE2) #endif -ENTRY (libat_store_16) +ENTRY (store_16) cbnz w4, 2f /* RELAXED. */ @@ -173,11 +179,11 @@ ENTRY (libat_store_16) stlxp w4, in0, in1, [x0] cbnz w4, 2b ret -END (libat_store_16) +END (store_16) #if HAVE_FEAT_LSE2 -ENTRY_FEAT (libat_store_16, LSE2) +ENTRY_FEAT (store_16, LSE2) cbnz w4, 1f /* RELAXED. */ @@ -189,11 +195,11 @@ ENTRY_FEAT (libat_store_16, LSE2) stlxp w4, in0, in1, [x0] cbnz w4, 1b ret -END_FEAT (libat_store_16, LSE2) +END_FEAT (store_16, LSE2) #endif -ENTRY (libat_exchange_16) +ENTRY (exchange_16) mov x5, x0 cbnz w4, 2f @@ -217,11 +223,11 @@ ENTRY (libat_exchange_16) stlxp w4, in0, in1, [x5] cbnz w4, 4b ret -END (libat_exchange_16) +END (exchange_16) #if HAVE_FEAT_LSE128 -ENTRY_FEAT (libat_exchange_16, LSE128) +ENTRY_FEAT (exchange_16, LSE128) mov tmp0, x0 mov res0, in0 mov res1, in1 @@ -241,11 +247,11 @@ ENTRY_FEAT (libat_exchange_16, LSE128) /* RELEASE/ACQ_REL/SEQ_CST. */ 2: swppal res0, res1, [tmp0] ret -END_FEAT (libat_exchange_16, LSE128) +END_FEAT (exchange_16, LSE128) #endif -ENTRY (libat_compare_exchange_16) +ENTRY (compare_exchange_16) ldp exp0, exp1, [x1] cbz w4, 3f cmp w4, RELEASE @@ -289,11 +295,11 @@ ENTRY (libat_compare_exchange_16) stp tmp0, tmp1, [x1] 6: cset x0, eq ret -END (libat_compare_exchange_16) +END (compare_exchange_16) #if HAVE_FEAT_LSE2 -ENTRY_FEAT (libat_compare_exchange_16, LSE2) +ENTRY_FEAT (compare_exchange_16, LSE2) ldp exp0, exp1, [x1] mov tmp0, exp0 mov tmp1, exp1 @@ -326,11 +332,11 @@ ENTRY_FEAT (libat_compare_exchange_16, LSE2) /* ACQ_REL/SEQ_CST. */ 4: caspal exp0, exp1, in0, in1, [x0] b 0b -END_FEAT (libat_compare_exchange_16, LSE2) +END_FEAT (compare_exchange_16, LSE2) #endif -ENTRY (libat_fetch_add_16) +ENTRY (fetch_add_16) mov x5, x0 cbnz w4, 2f @@ -349,10 +355,10 @@ ENTRY (libat_fetch_add_16) stlxp w4, tmp0, tmp1, [x5] cbnz w4, 2b ret -END (libat_fetch_add_16) +END (fetch_add_16) -ENTRY (libat_add_fetch_16) +ENTRY (add_fetch_16) mov x5, x0 cbnz w4, 2f @@ -371,10 +377,10 @@ ENTRY (libat_add_fetch_16) stlxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_add_fetch_16) +END (add_fetch_16) -ENTRY (libat_fetch_sub_16) +ENTRY (fetch_sub_16) mov x5, x0 cbnz w4, 2f @@ -393,10 +399,10 @@ ENTRY (libat_fetch_sub_16) stlxp w4, tmp0, tmp1, [x5] cbnz w4, 2b ret -END (libat_fetch_sub_16) +END (fetch_sub_16) -ENTRY (libat_sub_fetch_16) +ENTRY (sub_fetch_16) mov x5, x0 cbnz w4, 2f @@ -415,10 +421,10 @@ ENTRY (libat_sub_fetch_16) stlxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_sub_fetch_16) +END (sub_fetch_16) -ENTRY (libat_fetch_or_16) +ENTRY (fetch_or_16) mov x5, x0 cbnz w4, 2f @@ -437,11 +443,11 @@ ENTRY (libat_fetch_or_16) stlxp w4, tmp0, tmp1, [x5] cbnz w4, 2b ret -END (libat_fetch_or_16) +END (fetch_or_16) #if HAVE_FEAT_LSE128 -ENTRY_FEAT (libat_fetch_or_16, LSE128) +ENTRY_FEAT (fetch_or_16, LSE128) mov tmp0, x0 mov res0, in0 mov res1, in1 @@ -461,11 +467,11 @@ ENTRY_FEAT (libat_fetch_or_16, LSE128) /* RELEASE/ACQ_REL/SEQ_CST. */ 2: ldsetpal res0, res1, [tmp0] ret -END_FEAT (libat_fetch_or_16, LSE128) +END_FEAT (fetch_or_16, LSE128) #endif -ENTRY (libat_or_fetch_16) +ENTRY (or_fetch_16) mov x5, x0 cbnz w4, 2f @@ -484,11 +490,11 @@ ENTRY (libat_or_fetch_16) stlxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_or_fetch_16) +END (or_fetch_16) #if HAVE_FEAT_LSE128 -ENTRY_FEAT (libat_or_fetch_16, LSE128) +ENTRY_FEAT (or_fetch_16, LSE128) cbnz w4, 1f mov tmp0, in0 mov tmp1, in1 @@ -513,11 +519,11 @@ ENTRY_FEAT (libat_or_fetch_16, LSE128) orr res0, in0, tmp0 orr res1, in1, tmp1 ret -END_FEAT (libat_or_fetch_16, LSE128) +END_FEAT (or_fetch_16, LSE128) #endif -ENTRY (libat_fetch_and_16) +ENTRY (fetch_and_16) mov x5, x0 cbnz w4, 2f @@ -536,11 +542,11 @@ ENTRY (libat_fetch_and_16) stlxp w4, tmp0, tmp1, [x5] cbnz w4, 2b ret -END (libat_fetch_and_16) +END (fetch_and_16) #if HAVE_FEAT_LSE128 -ENTRY_FEAT (libat_fetch_and_16, LSE128) +ENTRY_FEAT (fetch_and_16, LSE128) mov tmp0, x0 mvn res0, in0 mvn res1, in1 @@ -561,11 +567,11 @@ ENTRY_FEAT (libat_fetch_and_16, LSE128) /* RELEASE/ACQ_REL/SEQ_CST. */ 2: ldclrpal res0, res1, [tmp0] ret -END_FEAT (libat_fetch_and_16, LSE128) +END_FEAT (fetch_and_16, LSE128) #endif -ENTRY (libat_and_fetch_16) +ENTRY (and_fetch_16) mov x5, x0 cbnz w4, 2f @@ -584,11 +590,11 @@ ENTRY (libat_and_fetch_16) stlxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_and_fetch_16) +END (and_fetch_16) #if HAVE_FEAT_LSE128 -ENTRY_FEAT (libat_and_fetch_16, LSE128) +ENTRY_FEAT (and_fetch_16, LSE128) mvn tmp0, in0 mvn tmp0, in1 cbnz w4, 1f @@ -614,11 +620,11 @@ ENTRY_FEAT (libat_and_fetch_16, LSE128) and res0, tmp0, in0 and res1, tmp1, in1 ret -END_FEAT (libat_and_fetch_16, LSE128) +END_FEAT (and_fetch_16, LSE128) #endif -ENTRY (libat_fetch_xor_16) +ENTRY (fetch_xor_16) mov x5, x0 cbnz w4, 2f @@ -637,10 +643,10 @@ ENTRY (libat_fetch_xor_16) stlxp w4, tmp0, tmp1, [x5] cbnz w4, 2b ret -END (libat_fetch_xor_16) +END (fetch_xor_16) -ENTRY (libat_xor_fetch_16) +ENTRY (xor_fetch_16) mov x5, x0 cbnz w4, 2f @@ -659,10 +665,10 @@ ENTRY (libat_xor_fetch_16) stlxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_xor_fetch_16) +END (xor_fetch_16) -ENTRY (libat_fetch_nand_16) +ENTRY (fetch_nand_16) mov x5, x0 mvn in0, in0 mvn in1, in1 @@ -683,10 +689,10 @@ ENTRY (libat_fetch_nand_16) stlxp w4, tmp0, tmp1, [x5] cbnz w4, 2b ret -END (libat_fetch_nand_16) +END (fetch_nand_16) -ENTRY (libat_nand_fetch_16) +ENTRY (nand_fetch_16) mov x5, x0 mvn in0, in0 mvn in1, in1 @@ -707,12 +713,12 @@ ENTRY (libat_nand_fetch_16) stlxp w4, res0, res1, [x5] cbnz w4, 2b ret -END (libat_nand_fetch_16) +END (nand_fetch_16) /* __atomic_test_and_set is always inlined, so this entry is unused and only required for completeness. */ -ENTRY (libat_test_and_set_16) +ENTRY (test_and_set_16) /* RELAXED/ACQUIRE/CONSUME/RELEASE/ACQ_REL/SEQ_CST. */ mov x5, x0 @@ -720,70 +726,48 @@ ENTRY (libat_test_and_set_16) stlxrb w4, w2, [x5] cbnz w4, 1b ret -END (libat_test_and_set_16) +END (test_and_set_16) /* Alias entry points which are the same in LSE2 and LSE128. */ #if HAVE_IFUNC # if !HAVE_FEAT_LSE128 -ALIAS (libat_exchange_16, LSE128, LSE2) -ALIAS (libat_fetch_or_16, LSE128, LSE2) -ALIAS (libat_fetch_and_16, LSE128, LSE2) -ALIAS (libat_or_fetch_16, LSE128, LSE2) -ALIAS (libat_and_fetch_16, LSE128, LSE2) +ALIAS (exchange_16, LSE128, LSE2) +ALIAS (fetch_or_16, LSE128, LSE2) +ALIAS (fetch_and_16, LSE128, LSE2) +ALIAS (or_fetch_16, LSE128, LSE2) +ALIAS (and_fetch_16, LSE128, LSE2) # endif -ALIAS (libat_load_16, LSE128, LSE2) -ALIAS (libat_store_16, LSE128, LSE2) -ALIAS (libat_compare_exchange_16, LSE128, LSE2) -ALIAS (libat_fetch_add_16, LSE128, LSE2) -ALIAS (libat_add_fetch_16, LSE128, LSE2) -ALIAS (libat_fetch_sub_16, LSE128, LSE2) -ALIAS (libat_sub_fetch_16, LSE128, LSE2) -ALIAS (libat_fetch_xor_16, LSE128, LSE2) -ALIAS (libat_xor_fetch_16, LSE128, LSE2) -ALIAS (libat_fetch_nand_16, LSE128, LSE2) -ALIAS (libat_nand_fetch_16, LSE128, LSE2) -ALIAS (libat_test_and_set_16, LSE128, LSE2) +ALIAS (load_16, LSE128, LSE2) +ALIAS (store_16, LSE128, LSE2) +ALIAS (compare_exchange_16, LSE128, LSE2) +ALIAS (fetch_add_16, LSE128, LSE2) +ALIAS (add_fetch_16, LSE128, LSE2) +ALIAS (fetch_sub_16, LSE128, LSE2) +ALIAS (sub_fetch_16, LSE128, LSE2) +ALIAS (fetch_xor_16, LSE128, LSE2) +ALIAS (xor_fetch_16, LSE128, LSE2) +ALIAS (fetch_nand_16, LSE128, LSE2) +ALIAS (nand_fetch_16, LSE128, LSE2) +ALIAS (test_and_set_16, LSE128, LSE2) /* Alias entry points which are the same in baseline and LSE2. */ -ALIAS (libat_exchange_16, LSE2, CORE) -ALIAS (libat_fetch_add_16, LSE2, CORE) -ALIAS (libat_add_fetch_16, LSE2, CORE) -ALIAS (libat_fetch_sub_16, LSE2, CORE) -ALIAS (libat_sub_fetch_16, LSE2, CORE) -ALIAS (libat_fetch_or_16, LSE2, CORE) -ALIAS (libat_or_fetch_16, LSE2, CORE) -ALIAS (libat_fetch_and_16, LSE2, CORE) -ALIAS (libat_and_fetch_16, LSE2, CORE) -ALIAS (libat_fetch_xor_16, LSE2, CORE) -ALIAS (libat_xor_fetch_16, LSE2, CORE) -ALIAS (libat_fetch_nand_16, LSE2, CORE) -ALIAS (libat_nand_fetch_16, LSE2, CORE) -ALIAS (libat_test_and_set_16, LSE2, CORE) - -#else - -/* Emit __atomic_* entrypoints if no ifuncs. */ - -ALIAS2 (load_16) -ALIAS2 (store_16) -ALIAS2 (compare_exchange_16) -ALIAS2 (exchange_16) -ALIAS2 (fetch_add_16) -ALIAS2 (add_fetch_16) -ALIAS2 (fetch_sub_16) -ALIAS2 (sub_fetch_16) -ALIAS2 (fetch_or_16) -ALIAS2 (or_fetch_16) -ALIAS2 (fetch_and_16) -ALIAS2 (and_fetch_16) -ALIAS2 (fetch_xor_16) -ALIAS2 (xor_fetch_16) -ALIAS2 (fetch_nand_16) -ALIAS2 (nand_fetch_16) -ALIAS2 (test_and_set_16) +ALIAS (exchange_16, LSE2, CORE) +ALIAS (fetch_add_16, LSE2, CORE) +ALIAS (add_fetch_16, LSE2, CORE) +ALIAS (fetch_sub_16, LSE2, CORE) +ALIAS (sub_fetch_16, LSE2, CORE) +ALIAS (fetch_or_16, LSE2, CORE) +ALIAS (or_fetch_16, LSE2, CORE) +ALIAS (fetch_and_16, LSE2, CORE) +ALIAS (and_fetch_16, LSE2, CORE) +ALIAS (fetch_xor_16, LSE2, CORE) +ALIAS (xor_fetch_16, LSE2, CORE) +ALIAS (fetch_nand_16, LSE2, CORE) +ALIAS (nand_fetch_16, LSE2, CORE) +ALIAS (test_and_set_16, LSE2, CORE) #endif /* GNU_PROPERTY_AARCH64_* macros from elf.h for use in asm code. */ diff --git a/libbacktrace/ChangeLog b/libbacktrace/ChangeLog index 5f131146882..b6be5c8b059 100644 --- a/libbacktrace/ChangeLog +++ b/libbacktrace/ChangeLog @@ -1,3 +1,25 @@ +2024-04-28 Ian Lance Taylor <iant@golang.org> + + * configure.ac: Checked for tlhelp32.h + * pecoff.c: Include <tlhelp32.h> if available. + (backtrace_initialize): Use tlhelp32 api for a snapshot to + detect loaded modules. + (coff_add): New argument for the module handle of the file, + to get the base address. + * configure, config.h.in: Regenerate. + +2024-04-23 Ian Lance Taylor <iant@golang.org> + + * configure.ac: Test --compress-debug-sections=zlib-gnu and + --compress-debug-sections=zlib-gabi separately, setting new + automake conditionals. + * Makefile.am (ctestg, ctestg_alloc): Only build if + HAVE_COMPRESSED_DEBUG_ZLIB_GNU. + (ctesta, ctesta_alloc): Only build if + HAVE_COMPRESSED_DEBUG_ZLIB_GABI. + (ctestzstd_alloc): New test if HAVE_COMPRESSED_DEBUG_ZSTD. + * configure, Makefile.in: Regenerate. + 2024-03-08 Ian Lance Taylor <iant@golang.org> * elf.c (elf_uncompress_chdr): Don't assume compressed section is diff --git a/libbacktrace/Makefile.am b/libbacktrace/Makefile.am index 5677ecd8865..bed42c29329 100644 --- a/libbacktrace/Makefile.am +++ b/libbacktrace/Makefile.am @@ -493,19 +493,37 @@ endif HAVE_OBJCOPY_DEBUGLINK $< $(OBJCOPY) --strip-all $< $@ -if HAVE_COMPRESSED_DEBUG +if HAVE_COMPRESSED_DEBUG_ZLIB_GNU ctestg_SOURCES = btest.c testlib.c ctestg_CFLAGS = $(libbacktrace_TEST_CFLAGS) ctestg_LDFLAGS = -Wl,--compress-debug-sections=zlib-gnu $(libbacktrace_testing_ldflags) ctestg_LDADD = libbacktrace.la +ctestg_alloc_SOURCES = $(ctestg_SOURCES) +ctestg_alloc_CFLAGS = $(ctestg_CFLAGS) +ctestg_alloc_LDFLAGS = $(ctestg_LDFLAGS) $(libbacktrace_testing_ldflags) +ctestg_alloc_LDADD = libbacktrace_alloc.la + +BUILDTESTS += ctestg ctestg_alloc + +endif + +if HAVE_COMPRESSED_DEBUG_ZLIB_GABI + ctesta_SOURCES = btest.c testlib.c ctesta_CFLAGS = $(libbacktrace_TEST_CFLAGS) ctesta_LDFLAGS = -Wl,--compress-debug-sections=zlib-gabi $(libbacktrace_testing_ldflags) ctesta_LDADD = libbacktrace.la -BUILDTESTS += ctestg ctesta +ctesta_alloc_SOURCES = $(ctesta_SOURCES) +ctesta_alloc_CFLAGS = $(ctesta_CFLAGS) +ctesta_alloc_LDFLAGS = $(ctesta_LDFLAGS) $(libbacktrace_testing_ldflags) +ctesta_alloc_LDADD = libbacktrace_alloc.la + +BUILDTESTS += ctesta ctesta_alloc + +endif if HAVE_COMPRESSED_DEBUG_ZSTD @@ -514,21 +532,12 @@ ctestzstd_CFLAGS = $(libbacktrace_TEST_CFLAGS) ctestzstd_LDFLAGS = -Wl,--compress-debug-sections=zstd $(libbacktrace_testing_ldflags) ctestzstd_LDADD = libbacktrace.la -BUILDTESTS += ctestzstd - -endif - -ctestg_alloc_SOURCES = $(ctestg_SOURCES) -ctestg_alloc_CFLAGS = $(ctestg_CFLAGS) -ctestg_alloc_LDFLAGS = $(ctestg_LDFLAGS) $(libbacktrace_testing_ldflags) -ctestg_alloc_LDADD = libbacktrace_alloc.la - -ctesta_alloc_SOURCES = $(ctesta_SOURCES) -ctesta_alloc_CFLAGS = $(ctesta_CFLAGS) -ctesta_alloc_LDFLAGS = $(ctesta_LDFLAGS) $(libbacktrace_testing_ldflags) -ctesta_alloc_LDADD = libbacktrace_alloc.la +ctestzstd_alloc_SOURCES = $(ctestzstd_SOURCES) +ctestzstd_alloc_CFLAGS = $(ctestzstd_CFLAGS) +ctestzstd_alloc_LDFLAGS = $(ctestzstd_LDFLAGS) $(libbacktrace_testing_ldflags) +ctestzstd_alloc_LDADD = libbacktrace_alloc.la -BUILDTESTS += ctestg_alloc ctesta_alloc +BUILDTESTS += ctestzstd ctestzstd_alloc endif diff --git a/libbacktrace/Makefile.in b/libbacktrace/Makefile.in index 49852a21d37..0260ca81798 100644 --- a/libbacktrace/Makefile.in +++ b/libbacktrace/Makefile.in @@ -153,9 +153,9 @@ TESTS = $(am__append_4) $(MAKETESTS) $(am__EXEEXT_16) @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@@USE_DSYMUTIL_TRUE@ ttest.dSYM \ @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@@USE_DSYMUTIL_TRUE@ ttest_alloc.dSYM @HAVE_OBJCOPY_DEBUGLINK_TRUE@@NATIVE_TRUE@am__append_22 = btest_gnudebuglink btest_gnudebuglinkfull -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am__append_23 = ctestg ctesta -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am__append_24 = ctestzstd -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am__append_25 = ctestg_alloc ctesta_alloc +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@am__append_23 = ctestg ctestg_alloc +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@am__append_24 = ctesta ctesta_alloc +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am__append_25 = ctestzstd ctestzstd_alloc @HAVE_DWARF5_TRUE@@NATIVE_TRUE@am__append_26 = dwarf5 dwarf5_alloc @HAVE_DWARF5_TRUE@@NATIVE_TRUE@@USE_DSYMUTIL_TRUE@am__append_27 = \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@@USE_DSYMUTIL_TRUE@ dwarf5.dSYM \ @@ -239,12 +239,12 @@ libbacktrace_noformat_la_OBJECTS = \ @NATIVE_TRUE@am__EXEEXT_8 = edtest$(EXEEXT) edtest_alloc$(EXEEXT) @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@am__EXEEXT_9 = ttest$(EXEEXT) \ @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ ttest_alloc$(EXEEXT) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am__EXEEXT_10 = \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctestg$(EXEEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctesta$(EXEEXT) -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am__EXEEXT_11 = ctestzstd$(EXEEXT) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am__EXEEXT_12 = ctestg_alloc$(EXEEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctesta_alloc$(EXEEXT) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@am__EXEEXT_10 = ctestg$(EXEEXT) \ +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ ctestg_alloc$(EXEEXT) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@am__EXEEXT_11 = ctesta$(EXEEXT) \ +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ ctesta_alloc$(EXEEXT) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am__EXEEXT_12 = ctestzstd$(EXEEXT) \ +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ ctestzstd_alloc$(EXEEXT) @HAVE_DWARF5_TRUE@@NATIVE_TRUE@am__EXEEXT_13 = dwarf5$(EXEEXT) \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@ dwarf5_alloc$(EXEEXT) @NATIVE_TRUE@am__EXEEXT_14 = mtest$(EXEEXT) @@ -300,47 +300,53 @@ btest_lto_OBJECTS = $(am_btest_lto_OBJECTS) btest_lto_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(btest_lto_CFLAGS) \ $(CFLAGS) $(btest_lto_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am_ctesta_OBJECTS = ctesta-btest.$(OBJEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctesta-testlib.$(OBJEXT) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@am_ctesta_OBJECTS = ctesta-btest.$(OBJEXT) \ +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ ctesta-testlib.$(OBJEXT) ctesta_OBJECTS = $(am_ctesta_OBJECTS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_DEPENDENCIES = \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ libbacktrace.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_DEPENDENCIES = libbacktrace.la ctesta_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ctesta_CFLAGS) $(CFLAGS) \ $(ctesta_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am__objects_5 = ctesta_alloc-btest.$(OBJEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctesta_alloc-testlib.$(OBJEXT) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am_ctesta_alloc_OBJECTS = \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ $(am__objects_5) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@am__objects_5 = ctesta_alloc-btest.$(OBJEXT) \ +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ ctesta_alloc-testlib.$(OBJEXT) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@am_ctesta_alloc_OBJECTS = $(am__objects_5) ctesta_alloc_OBJECTS = $(am_ctesta_alloc_OBJECTS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_alloc_DEPENDENCIES = libbacktrace_alloc.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_alloc_DEPENDENCIES = libbacktrace_alloc.la ctesta_alloc_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ctesta_alloc_CFLAGS) \ $(CFLAGS) $(ctesta_alloc_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am_ctestg_OBJECTS = ctestg-btest.$(OBJEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctestg-testlib.$(OBJEXT) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@am_ctestg_OBJECTS = ctestg-btest.$(OBJEXT) \ +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ ctestg-testlib.$(OBJEXT) ctestg_OBJECTS = $(am_ctestg_OBJECTS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_DEPENDENCIES = \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ libbacktrace.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_DEPENDENCIES = libbacktrace.la ctestg_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ctestg_CFLAGS) $(CFLAGS) \ $(ctestg_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am__objects_6 = ctestg_alloc-btest.$(OBJEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ ctestg_alloc-testlib.$(OBJEXT) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@am_ctestg_alloc_OBJECTS = \ -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ $(am__objects_6) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@am__objects_6 = ctestg_alloc-btest.$(OBJEXT) \ +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ ctestg_alloc-testlib.$(OBJEXT) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@am_ctestg_alloc_OBJECTS = $(am__objects_6) ctestg_alloc_OBJECTS = $(am_ctestg_alloc_OBJECTS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_alloc_DEPENDENCIES = libbacktrace_alloc.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_alloc_DEPENDENCIES = libbacktrace_alloc.la ctestg_alloc_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ctestg_alloc_CFLAGS) \ $(CFLAGS) $(ctestg_alloc_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am_ctestzstd_OBJECTS = ctestzstd-btest.$(OBJEXT) \ -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ ctestzstd-testlib.$(OBJEXT) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am_ctestzstd_OBJECTS = ctestzstd-btest.$(OBJEXT) \ +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ ctestzstd-testlib.$(OBJEXT) ctestzstd_OBJECTS = $(am_ctestzstd_OBJECTS) -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_DEPENDENCIES = libbacktrace.la +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_DEPENDENCIES = \ +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ libbacktrace.la ctestzstd_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ctestzstd_CFLAGS) \ $(CFLAGS) $(ctestzstd_LDFLAGS) $(LDFLAGS) -o $@ +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am__objects_7 = ctestzstd_alloc-btest.$(OBJEXT) \ +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ ctestzstd_alloc-testlib.$(OBJEXT) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@am_ctestzstd_alloc_OBJECTS = $(am__objects_7) +ctestzstd_alloc_OBJECTS = $(am_ctestzstd_alloc_OBJECTS) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_alloc_DEPENDENCIES = libbacktrace_alloc.la +ctestzstd_alloc_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ + $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \ + $(ctestzstd_alloc_CFLAGS) $(CFLAGS) $(ctestzstd_alloc_LDFLAGS) \ + $(LDFLAGS) -o $@ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@am_dwarf5_OBJECTS = \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@ dwarf5-btest.$(OBJEXT) \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@ dwarf5-testlib.$(OBJEXT) @@ -349,11 +355,11 @@ dwarf5_OBJECTS = $(am_dwarf5_OBJECTS) dwarf5_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(dwarf5_CFLAGS) $(CFLAGS) \ $(dwarf5_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_DWARF5_TRUE@@NATIVE_TRUE@am__objects_7 = \ +@HAVE_DWARF5_TRUE@@NATIVE_TRUE@am__objects_8 = \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@ dwarf5_alloc-btest.$(OBJEXT) \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@ dwarf5_alloc-testlib.$(OBJEXT) @HAVE_DWARF5_TRUE@@NATIVE_TRUE@am_dwarf5_alloc_OBJECTS = \ -@HAVE_DWARF5_TRUE@@NATIVE_TRUE@ $(am__objects_7) +@HAVE_DWARF5_TRUE@@NATIVE_TRUE@ $(am__objects_8) dwarf5_alloc_OBJECTS = $(am_dwarf5_alloc_OBJECTS) @HAVE_DWARF5_TRUE@@NATIVE_TRUE@dwarf5_alloc_DEPENDENCIES = \ @HAVE_DWARF5_TRUE@@NATIVE_TRUE@ libbacktrace_alloc.la @@ -368,10 +374,10 @@ edtest_OBJECTS = $(am_edtest_OBJECTS) edtest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(edtest_CFLAGS) $(CFLAGS) \ $(edtest_LDFLAGS) $(LDFLAGS) -o $@ -@NATIVE_TRUE@am__objects_8 = edtest_alloc-edtest.$(OBJEXT) \ +@NATIVE_TRUE@am__objects_9 = edtest_alloc-edtest.$(OBJEXT) \ @NATIVE_TRUE@ edtest_alloc-edtest2_build.$(OBJEXT) \ @NATIVE_TRUE@ edtest_alloc-testlib.$(OBJEXT) -@NATIVE_TRUE@am_edtest_alloc_OBJECTS = $(am__objects_8) +@NATIVE_TRUE@am_edtest_alloc_OBJECTS = $(am__objects_9) edtest_alloc_OBJECTS = $(am_edtest_alloc_OBJECTS) @NATIVE_TRUE@edtest_alloc_DEPENDENCIES = libbacktrace_alloc.la edtest_alloc_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ @@ -390,8 +396,8 @@ stest_OBJECTS = $(am_stest_OBJECTS) stest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(stest_CFLAGS) $(CFLAGS) \ $(stest_LDFLAGS) $(LDFLAGS) -o $@ -@NATIVE_TRUE@am__objects_9 = stest_alloc-stest.$(OBJEXT) -@NATIVE_TRUE@am_stest_alloc_OBJECTS = $(am__objects_9) +@NATIVE_TRUE@am__objects_10 = stest_alloc-stest.$(OBJEXT) +@NATIVE_TRUE@am_stest_alloc_OBJECTS = $(am__objects_10) stest_alloc_OBJECTS = $(am_stest_alloc_OBJECTS) @NATIVE_TRUE@stest_alloc_DEPENDENCIES = libbacktrace_alloc.la stest_alloc_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ @@ -467,11 +473,11 @@ ttest_OBJECTS = $(am_ttest_OBJECTS) ttest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ttest_CFLAGS) $(CFLAGS) \ $(ttest_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_PTHREAD_TRUE@@NATIVE_TRUE@am__objects_10 = \ +@HAVE_PTHREAD_TRUE@@NATIVE_TRUE@am__objects_11 = \ @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ ttest_alloc-ttest.$(OBJEXT) \ @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ ttest_alloc-testlib.$(OBJEXT) @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@am_ttest_alloc_OBJECTS = \ -@HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ $(am__objects_10) +@HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ $(am__objects_11) ttest_alloc_OBJECTS = $(am_ttest_alloc_OBJECTS) @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ttest_alloc_DEPENDENCIES = \ @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ libbacktrace_alloc.la @@ -485,9 +491,9 @@ unittest_OBJECTS = $(am_unittest_OBJECTS) unittest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(unittest_CFLAGS) \ $(CFLAGS) $(unittest_LDFLAGS) $(LDFLAGS) -o $@ -@NATIVE_TRUE@am__objects_11 = unittest_alloc-unittest.$(OBJEXT) \ +@NATIVE_TRUE@am__objects_12 = unittest_alloc-unittest.$(OBJEXT) \ @NATIVE_TRUE@ unittest_alloc-testlib.$(OBJEXT) -@NATIVE_TRUE@am_unittest_alloc_OBJECTS = $(am__objects_11) +@NATIVE_TRUE@am_unittest_alloc_OBJECTS = $(am__objects_12) unittest_alloc_OBJECTS = $(am_unittest_alloc_OBJECTS) @NATIVE_TRUE@unittest_alloc_DEPENDENCIES = libbacktrace_alloc.la unittest_alloc_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ @@ -502,9 +508,9 @@ xztest_OBJECTS = $(am_xztest_OBJECTS) xztest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(xztest_CFLAGS) $(CFLAGS) \ $(xztest_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_ELF_TRUE@am__objects_12 = xztest_alloc-xztest.$(OBJEXT) \ +@HAVE_ELF_TRUE@am__objects_13 = xztest_alloc-xztest.$(OBJEXT) \ @HAVE_ELF_TRUE@ xztest_alloc-testlib.$(OBJEXT) -@HAVE_ELF_TRUE@am_xztest_alloc_OBJECTS = $(am__objects_12) +@HAVE_ELF_TRUE@am_xztest_alloc_OBJECTS = $(am__objects_13) xztest_alloc_OBJECTS = $(am_xztest_alloc_OBJECTS) @HAVE_ELF_TRUE@xztest_alloc_DEPENDENCIES = libbacktrace_alloc.la \ @HAVE_ELF_TRUE@ $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) @@ -521,11 +527,11 @@ zstdtest_OBJECTS = $(am_zstdtest_OBJECTS) zstdtest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(zstdtest_CFLAGS) \ $(CFLAGS) $(zstdtest_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_ELF_TRUE@@NATIVE_TRUE@am__objects_13 = \ +@HAVE_ELF_TRUE@@NATIVE_TRUE@am__objects_14 = \ @HAVE_ELF_TRUE@@NATIVE_TRUE@ zstdtest_alloc-zstdtest.$(OBJEXT) \ @HAVE_ELF_TRUE@@NATIVE_TRUE@ zstdtest_alloc-testlib.$(OBJEXT) @HAVE_ELF_TRUE@@NATIVE_TRUE@am_zstdtest_alloc_OBJECTS = \ -@HAVE_ELF_TRUE@@NATIVE_TRUE@ $(am__objects_13) +@HAVE_ELF_TRUE@@NATIVE_TRUE@ $(am__objects_14) zstdtest_alloc_OBJECTS = $(am_zstdtest_alloc_OBJECTS) @HAVE_ELF_TRUE@@NATIVE_TRUE@zstdtest_alloc_DEPENDENCIES = \ @HAVE_ELF_TRUE@@NATIVE_TRUE@ libbacktrace_alloc.la \ @@ -544,11 +550,11 @@ ztest_OBJECTS = $(am_ztest_OBJECTS) ztest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(ztest_CFLAGS) $(CFLAGS) \ $(ztest_LDFLAGS) $(LDFLAGS) -o $@ -@HAVE_ELF_TRUE@@NATIVE_TRUE@am__objects_14 = \ +@HAVE_ELF_TRUE@@NATIVE_TRUE@am__objects_15 = \ @HAVE_ELF_TRUE@@NATIVE_TRUE@ ztest_alloc-ztest.$(OBJEXT) \ @HAVE_ELF_TRUE@@NATIVE_TRUE@ ztest_alloc-testlib.$(OBJEXT) @HAVE_ELF_TRUE@@NATIVE_TRUE@am_ztest_alloc_OBJECTS = \ -@HAVE_ELF_TRUE@@NATIVE_TRUE@ $(am__objects_14) +@HAVE_ELF_TRUE@@NATIVE_TRUE@ $(am__objects_15) ztest_alloc_OBJECTS = $(am_ztest_alloc_OBJECTS) @HAVE_ELF_TRUE@@NATIVE_TRUE@ztest_alloc_DEPENDENCIES = \ @HAVE_ELF_TRUE@@NATIVE_TRUE@ libbacktrace_alloc.la \ @@ -598,7 +604,8 @@ SOURCES = $(libbacktrace_la_SOURCES) $(EXTRA_libbacktrace_la_SOURCES) \ $(b2test_SOURCES) $(b3test_SOURCES) $(btest_SOURCES) \ $(btest_alloc_SOURCES) $(btest_lto_SOURCES) $(ctesta_SOURCES) \ $(ctesta_alloc_SOURCES) $(ctestg_SOURCES) \ - $(ctestg_alloc_SOURCES) $(ctestzstd_SOURCES) $(dwarf5_SOURCES) \ + $(ctestg_alloc_SOURCES) $(ctestzstd_SOURCES) \ + $(ctestzstd_alloc_SOURCES) $(dwarf5_SOURCES) \ $(dwarf5_alloc_SOURCES) $(edtest_SOURCES) \ $(edtest_alloc_SOURCES) $(mtest_SOURCES) $(stest_SOURCES) \ $(stest_alloc_SOURCES) $(test_elf_32_SOURCES) \ @@ -1175,26 +1182,30 @@ libbacktrace_testing_ldflags = -no-install @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ttest_alloc_CFLAGS = $(ttest_CFLAGS) @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ttest_alloc_LDFLAGS = $(libbacktrace_testing_ldflags) @HAVE_PTHREAD_TRUE@@NATIVE_TRUE@ttest_alloc_LDADD = libbacktrace_alloc.la -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_SOURCES = btest.c testlib.c -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_CFLAGS = $(libbacktrace_TEST_CFLAGS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_LDFLAGS = -Wl,--compress-debug-sections=zlib-gnu $(libbacktrace_testing_ldflags) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_LDADD = libbacktrace.la -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_SOURCES = btest.c testlib.c -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_CFLAGS = $(libbacktrace_TEST_CFLAGS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_LDFLAGS = -Wl,--compress-debug-sections=zlib-gabi $(libbacktrace_testing_ldflags) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_LDADD = libbacktrace.la -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_SOURCES = btest.c testlib.c -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_CFLAGS = $(libbacktrace_TEST_CFLAGS) -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_LDFLAGS = -Wl,--compress-debug-sections=zstd $(libbacktrace_testing_ldflags) -@HAVE_COMPRESSED_DEBUG_TRUE@@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_LDADD = libbacktrace.la -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_alloc_SOURCES = $(ctestg_SOURCES) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_alloc_CFLAGS = $(ctestg_CFLAGS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_alloc_LDFLAGS = $(ctestg_LDFLAGS) $(libbacktrace_testing_ldflags) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctestg_alloc_LDADD = libbacktrace_alloc.la -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_alloc_SOURCES = $(ctesta_SOURCES) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_alloc_CFLAGS = $(ctesta_CFLAGS) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_alloc_LDFLAGS = $(ctesta_LDFLAGS) $(libbacktrace_testing_ldflags) -@HAVE_COMPRESSED_DEBUG_TRUE@@NATIVE_TRUE@ctesta_alloc_LDADD = libbacktrace_alloc.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_SOURCES = btest.c testlib.c +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_CFLAGS = $(libbacktrace_TEST_CFLAGS) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_LDFLAGS = -Wl,--compress-debug-sections=zlib-gnu $(libbacktrace_testing_ldflags) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_LDADD = libbacktrace.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_alloc_SOURCES = $(ctestg_SOURCES) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_alloc_CFLAGS = $(ctestg_CFLAGS) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_alloc_LDFLAGS = $(ctestg_LDFLAGS) $(libbacktrace_testing_ldflags) +@HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE@@NATIVE_TRUE@ctestg_alloc_LDADD = libbacktrace_alloc.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_SOURCES = btest.c testlib.c +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_CFLAGS = $(libbacktrace_TEST_CFLAGS) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_LDFLAGS = -Wl,--compress-debug-sections=zlib-gabi $(libbacktrace_testing_ldflags) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_LDADD = libbacktrace.la +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_alloc_SOURCES = $(ctesta_SOURCES) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_alloc_CFLAGS = $(ctesta_CFLAGS) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_alloc_LDFLAGS = $(ctesta_LDFLAGS) $(libbacktrace_testing_ldflags) +@HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE@@NATIVE_TRUE@ctesta_alloc_LDADD = libbacktrace_alloc.la +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_SOURCES = btest.c testlib.c +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_CFLAGS = $(libbacktrace_TEST_CFLAGS) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_LDFLAGS = -Wl,--compress-debug-sections=zstd $(libbacktrace_testing_ldflags) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_LDADD = libbacktrace.la +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_alloc_SOURCES = $(ctestzstd_SOURCES) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_alloc_CFLAGS = $(ctestzstd_CFLAGS) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_alloc_LDFLAGS = $(ctestzstd_LDFLAGS) $(libbacktrace_testing_ldflags) +@HAVE_COMPRESSED_DEBUG_ZSTD_TRUE@@NATIVE_TRUE@ctestzstd_alloc_LDADD = libbacktrace_alloc.la @HAVE_DWARF5_TRUE@@NATIVE_TRUE@dwarf5_SOURCES = btest.c testlib.c @HAVE_DWARF5_TRUE@@NATIVE_TRUE@dwarf5_CFLAGS = $(libbacktrace_TEST_CFLAGS) -gdwarf-5 @HAVE_DWARF5_TRUE@@NATIVE_TRUE@dwarf5_LDFLAGS = $(libbacktrace_testing_ldflags) @@ -1390,6 +1401,10 @@ ctestzstd$(EXEEXT): $(ctestzstd_OBJECTS) $(ctestzstd_DEPENDENCIES) $(EXTRA_ctest @rm -f ctestzstd$(EXEEXT) $(AM_V_CCLD)$(ctestzstd_LINK) $(ctestzstd_OBJECTS) $(ctestzstd_LDADD) $(LIBS) +ctestzstd_alloc$(EXEEXT): $(ctestzstd_alloc_OBJECTS) $(ctestzstd_alloc_DEPENDENCIES) $(EXTRA_ctestzstd_alloc_DEPENDENCIES) + @rm -f ctestzstd_alloc$(EXEEXT) + $(AM_V_CCLD)$(ctestzstd_alloc_LINK) $(ctestzstd_alloc_OBJECTS) $(ctestzstd_alloc_LDADD) $(LIBS) + dwarf5$(EXEEXT): $(dwarf5_OBJECTS) $(dwarf5_DEPENDENCIES) $(EXTRA_dwarf5_DEPENDENCIES) @rm -f dwarf5$(EXEEXT) $(AM_V_CCLD)$(dwarf5_LINK) $(dwarf5_OBJECTS) $(dwarf5_LDADD) $(LIBS) @@ -1633,6 +1648,18 @@ ctestzstd-testlib.o: testlib.c ctestzstd-testlib.obj: testlib.c $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ctestzstd_CFLAGS) $(CFLAGS) -c -o ctestzstd-testlib.obj `if test -f 'testlib.c'; then $(CYGPATH_W) 'testlib.c'; else $(CYGPATH_W) '$(srcdir)/testlib.c'; fi` +ctestzstd_alloc-btest.o: btest.c + $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ctestzstd_alloc_CFLAGS) $(CFLAGS) -c -o ctestzstd_alloc-btest.o `test -f 'btest.c' || echo '$(srcdir)/'`btest.c + +ctestzstd_alloc-btest.obj: btest.c + $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ctestzstd_alloc_CFLAGS) $(CFLAGS) -c -o ctestzstd_alloc-btest.obj `if test -f 'btest.c'; then $(CYGPATH_W) 'btest.c'; else $(CYGPATH_W) '$(srcdir)/btest.c'; fi` + +ctestzstd_alloc-testlib.o: testlib.c + $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ctestzstd_alloc_CFLAGS) $(CFLAGS) -c -o ctestzstd_alloc-testlib.o `test -f 'testlib.c' || echo '$(srcdir)/'`testlib.c + +ctestzstd_alloc-testlib.obj: testlib.c + $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(ctestzstd_alloc_CFLAGS) $(CFLAGS) -c -o ctestzstd_alloc-testlib.obj `if test -f 'testlib.c'; then $(CYGPATH_W) 'testlib.c'; else $(CYGPATH_W) '$(srcdir)/testlib.c'; fi` + dwarf5-btest.o: btest.c $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(dwarf5_CFLAGS) $(CFLAGS) -c -o dwarf5-btest.o `test -f 'btest.c' || echo '$(srcdir)/'`btest.c @@ -2361,6 +2388,13 @@ ctestg.log: ctestg$(EXEEXT) --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) +ctestg_alloc.log: ctestg_alloc$(EXEEXT) + @p='ctestg_alloc$(EXEEXT)'; \ + b='ctestg_alloc'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) ctesta.log: ctesta$(EXEEXT) @p='ctesta$(EXEEXT)'; \ b='ctesta'; \ @@ -2368,23 +2402,23 @@ ctesta.log: ctesta$(EXEEXT) --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) -ctestzstd.log: ctestzstd$(EXEEXT) - @p='ctestzstd$(EXEEXT)'; \ - b='ctestzstd'; \ +ctesta_alloc.log: ctesta_alloc$(EXEEXT) + @p='ctesta_alloc$(EXEEXT)'; \ + b='ctesta_alloc'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) -ctestg_alloc.log: ctestg_alloc$(EXEEXT) - @p='ctestg_alloc$(EXEEXT)'; \ - b='ctestg_alloc'; \ +ctestzstd.log: ctestzstd$(EXEEXT) + @p='ctestzstd$(EXEEXT)'; \ + b='ctestzstd'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) -ctesta_alloc.log: ctesta_alloc$(EXEEXT) - @p='ctesta_alloc$(EXEEXT)'; \ - b='ctesta_alloc'; \ +ctestzstd_alloc.log: ctestzstd_alloc$(EXEEXT) + @p='ctestzstd_alloc$(EXEEXT)'; \ + b='ctestzstd_alloc'; \ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ diff --git a/libbacktrace/config.h.in b/libbacktrace/config.h.in index ee2616335c7..9b8ab88ab63 100644 --- a/libbacktrace/config.h.in +++ b/libbacktrace/config.h.in @@ -101,6 +101,9 @@ /* Define to 1 if you have the <sys/types.h> header file. */ #undef HAVE_SYS_TYPES_H +/* Define to 1 if you have the <tlhelp32.h> header file. */ +#undef HAVE_TLHELP32_H + /* Define to 1 if you have the <unistd.h> header file. */ #undef HAVE_UNISTD_H diff --git a/libbacktrace/configure b/libbacktrace/configure index 7ade966b54d..ab94a85f45c 100755 --- a/libbacktrace/configure +++ b/libbacktrace/configure @@ -655,8 +655,10 @@ HAVE_COMPRESSED_DEBUG_ZSTD_FALSE HAVE_COMPRESSED_DEBUG_ZSTD_TRUE HAVE_ZSTD_FALSE HAVE_ZSTD_TRUE -HAVE_COMPRESSED_DEBUG_FALSE -HAVE_COMPRESSED_DEBUG_TRUE +HAVE_COMPRESSED_DEBUG_ZLIB_GABI_FALSE +HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE +HAVE_COMPRESSED_DEBUG_ZLIB_GNU_FALSE +HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE HAVE_BUILDID_FALSE HAVE_BUILDID_TRUE HAVE_ZLIB_FALSE @@ -11632,7 +11634,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11635 "configure" +#line 11637 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -11738,7 +11740,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11741 "configure" +#line 11743 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -13521,6 +13523,21 @@ fi done +for ac_header in tlhelp32.h +do : + ac_fn_c_check_header_compile "$LINENO" "tlhelp32.h" "ac_cv_header_tlhelp32_h" "#ifdef HAVE_WINDOWS_H +# include <windows.h> +#endif +" +if test "x$ac_cv_header_tlhelp32_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_TLHELP32_H 1 +_ACEOF + +fi + +done + # Check for the fcntl function. if test -n "${with_target_subdir}"; then @@ -13908,9 +13925,9 @@ else fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether --compress-debug-sections is supported" >&5 -$as_echo_n "checking whether --compress-debug-sections is supported... " >&6; } -if ${libgo_cv_ld_compress+:} false; then : +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether --compress-debug-sections=zlib-gnu is supported" >&5 +$as_echo_n "checking whether --compress-debug-sections=zlib-gnu is supported... " >&6; } +if ${libgo_cv_ld_compress_zlib_gnu+:} false; then : $as_echo_n "(cached) " >&6 else LDFLAGS_hold=$LDFLAGS @@ -13927,22 +13944,60 @@ main () } _ACEOF if ac_fn_c_try_link "$LINENO"; then : - libgo_cv_ld_compress=yes + libgo_cv_ld_compress_zlib_gnu=yes else - libgo_cv_ld_compress=no + libgo_cv_ld_compress_zlib_gnu=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=$LDFLAGS_hold fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libgo_cv_ld_compress" >&5 -$as_echo "$libgo_cv_ld_compress" >&6; } - if test "$libgo_cv_ld_compress" = yes; then - HAVE_COMPRESSED_DEBUG_TRUE= - HAVE_COMPRESSED_DEBUG_FALSE='#' +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libgo_cv_ld_compress_zlib_gnu" >&5 +$as_echo "$libgo_cv_ld_compress_zlib_gnu" >&6; } + if test "$libgo_cv_ld_compress_zlib_gnu" = yes; then + HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE= + HAVE_COMPRESSED_DEBUG_ZLIB_GNU_FALSE='#' else - HAVE_COMPRESSED_DEBUG_TRUE='#' - HAVE_COMPRESSED_DEBUG_FALSE= + HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE='#' + HAVE_COMPRESSED_DEBUG_ZLIB_GNU_FALSE= +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether --compress-debug-sections=zlib-gabi is supported" >&5 +$as_echo_n "checking whether --compress-debug-sections=zlib-gabi is supported... " >&6; } +if ${libgo_cv_ld_compress_zlib_gabi+:} false; then : + $as_echo_n "(cached) " >&6 +else + LDFLAGS_hold=$LDFLAGS +LDFLAGS="$LDFLAGS -Wl,--compress-debug-sections=zlib-gabi" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + libgo_cv_ld_compress_zlib_gabi=yes +else + libgo_cv_ld_compress_zlib_gabi=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LDFLAGS=$LDFLAGS_hold +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libgo_cv_ld_compress_zlib_gabi" >&5 +$as_echo "$libgo_cv_ld_compress_zlib_gabi" >&6; } + if test "$libgo_cv_ld_compress_zlib_gabi" = yes; then + HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE= + HAVE_COMPRESSED_DEBUG_ZLIB_GABI_FALSE='#' +else + HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE='#' + HAVE_COMPRESSED_DEBUG_ZLIB_GABI_FALSE= fi @@ -14585,8 +14640,12 @@ if test -z "${HAVE_BUILDID_TRUE}" && test -z "${HAVE_BUILDID_FALSE}"; then as_fn_error $? "conditional \"HAVE_BUILDID\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi -if test -z "${HAVE_COMPRESSED_DEBUG_TRUE}" && test -z "${HAVE_COMPRESSED_DEBUG_FALSE}"; then - as_fn_error $? "conditional \"HAVE_COMPRESSED_DEBUG\" was never defined. +if test -z "${HAVE_COMPRESSED_DEBUG_ZLIB_GNU_TRUE}" && test -z "${HAVE_COMPRESSED_DEBUG_ZLIB_GNU_FALSE}"; then + as_fn_error $? "conditional \"HAVE_COMPRESSED_DEBUG_ZLIB_GNU\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${HAVE_COMPRESSED_DEBUG_ZLIB_GABI_TRUE}" && test -z "${HAVE_COMPRESSED_DEBUG_ZLIB_GABI_FALSE}"; then + as_fn_error $? "conditional \"HAVE_COMPRESSED_DEBUG_ZLIB_GABI\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${HAVE_ZSTD_TRUE}" && test -z "${HAVE_ZSTD_FALSE}"; then diff --git a/libbacktrace/configure.ac b/libbacktrace/configure.ac index 0f61f2b28ab..59e9c415db8 100644 --- a/libbacktrace/configure.ac +++ b/libbacktrace/configure.ac @@ -380,6 +380,10 @@ if test "$have_loadquery" = "yes"; then fi AC_CHECK_HEADERS(windows.h) +AC_CHECK_HEADERS(tlhelp32.h, [], [], +[#ifdef HAVE_WINDOWS_H +# include <windows.h> +#endif]) # Check for the fcntl function. if test -n "${with_target_subdir}"; then @@ -502,16 +506,27 @@ AC_LINK_IFELSE([AC_LANG_PROGRAM(,)], LDFLAGS=$LDFLAGS_hold]) AM_CONDITIONAL(HAVE_BUILDID, test "$libbacktrace_cv_ld_buildid" = yes) -dnl Test whether the linker supports the --compress-debug-sections option. -AC_CACHE_CHECK([whether --compress-debug-sections is supported], -[libgo_cv_ld_compress], +dnl Test whether the linker supports the --compress-debug-sections=zlib-gnu +dnl option. +AC_CACHE_CHECK([whether --compress-debug-sections=zlib-gnu is supported], +[libgo_cv_ld_compress_zlib_gnu], [LDFLAGS_hold=$LDFLAGS LDFLAGS="$LDFLAGS -Wl,--compress-debug-sections=zlib-gnu" AC_LINK_IFELSE([AC_LANG_PROGRAM(,)], -[libgo_cv_ld_compress=yes], -[libgo_cv_ld_compress=no]) +[libgo_cv_ld_compress_zlib_gnu=yes], +[libgo_cv_ld_compress_zlib_gnu=no]) LDFLAGS=$LDFLAGS_hold]) -AM_CONDITIONAL(HAVE_COMPRESSED_DEBUG, test "$libgo_cv_ld_compress" = yes) +AM_CONDITIONAL(HAVE_COMPRESSED_DEBUG_ZLIB_GNU, test "$libgo_cv_ld_compress_zlib_gnu" = yes) + +AC_CACHE_CHECK([whether --compress-debug-sections=zlib-gabi is supported], +[libgo_cv_ld_compress_zlib_gabi], +[LDFLAGS_hold=$LDFLAGS +LDFLAGS="$LDFLAGS -Wl,--compress-debug-sections=zlib-gabi" +AC_LINK_IFELSE([AC_LANG_PROGRAM(,)], +[libgo_cv_ld_compress_zlib_gabi=yes], +[libgo_cv_ld_compress_zlib_gabi=no]) +LDFLAGS=$LDFLAGS_hold]) +AM_CONDITIONAL(HAVE_COMPRESSED_DEBUG_ZLIB_GABI, test "$libgo_cv_ld_compress_zlib_gabi" = yes) AC_CHECK_LIB([zstd], [ZSTD_compress], [AC_DEFINE(HAVE_ZSTD, 1, [Define if -lzstd is available.])]) diff --git a/libbacktrace/pecoff.c b/libbacktrace/pecoff.c index 9e437d810c7..4f267841178 100644 --- a/libbacktrace/pecoff.c +++ b/libbacktrace/pecoff.c @@ -49,6 +49,18 @@ POSSIBILITY OF SUCH DAMAGE. */ #endif #include <windows.h> + +#ifdef HAVE_TLHELP32_H +#include <tlhelp32.h> + +#ifdef UNICODE +/* If UNICODE is defined, all the symbols are replaced by a macro to use the + wide variant. But we need the ansi variant, so undef the macros. */ +#undef MODULEENTRY32 +#undef Module32First +#undef Module32Next +#endif +#endif #endif /* Coff file header. */ @@ -592,7 +604,8 @@ coff_syminfo (struct backtrace_state *state, uintptr_t addr, static int coff_add (struct backtrace_state *state, int descriptor, backtrace_error_callback error_callback, void *data, - fileline *fileline_fn, int *found_sym, int *found_dwarf) + fileline *fileline_fn, int *found_sym, int *found_dwarf, + uintptr_t module_handle ATTRIBUTE_UNUSED) { struct backtrace_view fhdr_view; off_t fhdr_off; @@ -870,12 +883,7 @@ coff_add (struct backtrace_state *state, int descriptor, } #ifdef HAVE_WINDOWS_H - { - uintptr_t module_handle; - - module_handle = (uintptr_t) GetModuleHandle (NULL); - base_address = module_handle - image_base; - } + base_address = module_handle - image_base; #endif if (!backtrace_dwarf_add (state, base_address, &dwarf_sections, @@ -917,12 +925,61 @@ backtrace_initialize (struct backtrace_state *state, int found_sym; int found_dwarf; fileline coff_fileline_fn; + uintptr_t module_handle = 0; +#ifdef HAVE_TLHELP32_H + fileline module_fileline_fn; + int module_found_sym; + HANDLE snapshot; +#endif + +#ifdef HAVE_WINDOWS_H + module_handle = (uintptr_t) GetModuleHandle (NULL); +#endif ret = coff_add (state, descriptor, error_callback, data, - &coff_fileline_fn, &found_sym, &found_dwarf); + &coff_fileline_fn, &found_sym, &found_dwarf, module_handle); if (!ret) return 0; +#ifdef HAVE_TLHELP32_H + do + { + snapshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0); + } + while (snapshot == INVALID_HANDLE_VALUE + && GetLastError () == ERROR_BAD_LENGTH); + + if (snapshot != INVALID_HANDLE_VALUE) + { + MODULEENTRY32 entry; + BOOL ok; + entry.dwSize = sizeof (MODULEENTRY32); + + for (ok = Module32First (snapshot, &entry); ok; ok = Module32Next (snapshot, &entry)) + { + if (strcmp (filename, entry.szExePath) == 0) + continue; + + module_handle = (uintptr_t) entry.hModule; + if (module_handle == 0) + continue; + + descriptor = backtrace_open (entry.szExePath, error_callback, data, + NULL); + if (descriptor < 0) + continue; + + coff_add (state, descriptor, error_callback, data, + &module_fileline_fn, &module_found_sym, &found_dwarf, + module_handle); + if (module_found_sym) + found_sym = 1; + } + + CloseHandle (snapshot); + } +#endif + if (!state->threaded) { if (found_sym) diff --git a/libcpp/ChangeLog b/libcpp/ChangeLog index eac81c0e4d5..2beee7f179a 100644 --- a/libcpp/ChangeLog +++ b/libcpp/ChangeLog @@ -1,3 +1,8 @@ +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + * init.cc (cpp_init_builtins): Change __STDC_VERSION__ + for C23 from 202000L to 202311L. + 2024-04-17 Christophe Lyon <christophe.lyon@linaro.org> PR preprocessor/114748 diff --git a/libcpp/init.cc b/libcpp/init.cc index 54fc9236d38..c457fa659e7 100644 --- a/libcpp/init.cc +++ b/libcpp/init.cc @@ -594,7 +594,7 @@ cpp_init_builtins (cpp_reader *pfile, int hosted) _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L"); else if (CPP_OPTION (pfile, lang) == CLK_STDC23 || CPP_OPTION (pfile, lang) == CLK_GNUC23) - _cpp_define_builtin (pfile, "__STDC_VERSION__ 202000L"); + _cpp_define_builtin (pfile, "__STDC_VERSION__ 202311L"); else if (CPP_OPTION (pfile, lang) == CLK_STDC17 || CPP_OPTION (pfile, lang) == CLK_GNUC17) _cpp_define_builtin (pfile, "__STDC_VERSION__ 201710L"); diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog index fd7b15d8508..1f9c7671282 100644 --- a/libgcc/ChangeLog +++ b/libgcc/ChangeLog @@ -1,3 +1,33 @@ +2024-04-30 Jakub Jelinek <jakub@redhat.com> + + * gthr.h (GTHREAD_USE_WEAK): Don't redefine to 0 for glibc 2.34+ + on GNU Hurd. + +2024-04-25 Jakub Jelinek <jakub@redhat.com> + + * gthr.h (GTHREAD_USE_WEAK): Redefine to 0 for GLIBC 2.34 or later. + +2024-04-21 Georg-Johann Lay <avr@gjlay.de> + + PR target/114794 + * config/avr/lib1funcs.S (__udivmodqi4): Tweak. + +2024-04-19 Jakub Jelinek <jakub@redhat.com> + + PR libgcc/114762 + * libgcc2.c (__divmodbitint4): Perform the decrement on negative + v with most significant limb all ones and the second least + significant limb with most significant bit clear always, regardless of + un < vn. + +2024-04-18 Jakub Jelinek <jakub@redhat.com> + + PR libgcc/114755 + * libgcc2.c (__divmodbitint4): Perform the decrement on negative + v with most significant limb all ones and the second least + significant limb with most significant bit clear always, regardless of + un < vn. + 2024-04-15 Jakub Jelinek <jakub@redhat.com> PR libgcc/114689 diff --git a/libgcc/config/avr/lib1funcs.S b/libgcc/config/avr/lib1funcs.S index 535510ab867..af4d7d97016 100644 --- a/libgcc/config/avr/lib1funcs.S +++ b/libgcc/config/avr/lib1funcs.S @@ -1339,9 +1339,9 @@ ENDF __umulsidi3 #if defined (L_udivmodqi4) DEFUN __udivmodqi4 - sub r_rem,r_rem ; clear remainder and carry - ldi r_cnt,9 ; init loop counter - rjmp __udivmodqi4_ep ; jump to entry point + clr r_rem ; clear remainder + ldi r_cnt,8 ; init loop counter + lsl r_arg1 ; shift dividend __udivmodqi4_loop: rol r_rem ; shift dividend into remainder cp r_rem,r_arg2 ; compare remainder & divisor diff --git a/libgcc/gthr.h b/libgcc/gthr.h index 31c404250b8..33c2d8ff630 100644 --- a/libgcc/gthr.h +++ b/libgcc/gthr.h @@ -141,6 +141,15 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #define GTHREAD_USE_WEAK 0 #endif +#ifdef __GLIBC_PREREQ +#if __GLIBC_PREREQ(2, 34) && !defined(__gnu_hurd__) +/* glibc 2.34 and later has all pthread_* APIs inside of libc, + no need to link separately with -lpthread. */ +#undef GTHREAD_USE_WEAK +#define GTHREAD_USE_WEAK 0 +#endif +#endif + #ifndef GTHREAD_USE_WEAK #define GTHREAD_USE_WEAK 1 #endif diff --git a/libgcc/libgcc2.c b/libgcc/libgcc2.c index 120d071a168..3fcb85c5b92 100644 --- a/libgcc/libgcc2.c +++ b/libgcc/libgcc2.c @@ -1715,11 +1715,18 @@ __divmodbitint4 (UBILtype *q, SItype qprec, && vn > 1 && (Wtype) v[BITINT_END (1, vn - 2)] >= 0) { - vp = 0; - --vn; + /* Unless all bits below the most significant limb are zero. */ + SItype vn2; + for (vn2 = vn - 2; vn2 >= 0; --vn2) + if (v[BITINT_END (vn - 1 - vn2, vn2)]) + { + vp = 0; + --vn; #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__ - ++v; + ++v; #endif + break; + } } if (__builtin_expect (un < vn, 0)) { diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index cdd9326d6af..0b669110ea6 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,8 @@ +2024-04-29 Francois-Xavier Coudert <fxcoudert@gcc.gnu.org> + + * gfortran.map: Add _gfortran_selected_logical_kind. + * intrinsics/selected_int_kind.f90: Add SELECTED_LOGICAL_KIND. + 2024-04-12 Ian McInerney <i.mcinerney17@imperial.ac.uk> * runtime/error.c (gf_vsnprintf): Fix compilation diff --git a/libgfortran/gfortran.map b/libgfortran/gfortran.map index db9b86cb183..4a5a037a906 100644 --- a/libgfortran/gfortran.map +++ b/libgfortran/gfortran.map @@ -1765,3 +1765,8 @@ GFORTRAN_13 { __ieee_exceptions_MOD_ieee_get_modes; __ieee_exceptions_MOD_ieee_set_modes; } GFORTRAN_12; + +GFORTRAN_14 { + global: + _gfortran_selected_logical_kind; +} GFORTRAN_13; diff --git a/libgfortran/intrinsics/selected_int_kind.f90 b/libgfortran/intrinsics/selected_int_kind.f90 index de657b1a264..3d63de3e7dd 100644 --- a/libgfortran/intrinsics/selected_int_kind.f90 +++ b/libgfortran/intrinsics/selected_int_kind.f90 @@ -24,7 +24,7 @@ function _gfortran_selected_int_kind (r) implicit none - integer, intent (in) :: r + integer, intent(in) :: r integer :: _gfortran_selected_int_kind integer :: i ! Integer kind_range table @@ -36,11 +36,37 @@ function _gfortran_selected_int_kind (r) include "selected_int_kind.inc" do i = 1, c - if (r <= int_infos (i) % range) then - _gfortran_selected_int_kind = int_infos (i) % kind + if (r <= int_infos(i)%range) then + _gfortran_selected_int_kind = int_infos(i)%kind return end if end do _gfortran_selected_int_kind = -1 return end function + + +! At this time, our logical and integer kinds are the same + +function _gfortran_selected_logical_kind (bits) + implicit none + integer, intent(in) :: bits + integer :: _gfortran_selected_logical_kind + integer :: i + ! Integer kind_range table + type :: int_info + integer :: kind + integer :: range + end type int_info + + include "selected_int_kind.inc" + + do i = 1, c + if (bits <= 8 * int_infos(i)%kind) then + _gfortran_selected_logical_kind = int_infos(i)%kind + return + end if + end do + _gfortran_selected_logical_kind = -1 + return +end function diff --git a/libgo/runtime/go-signal.c b/libgo/runtime/go-signal.c index aa1b6305ad0..c48c8ee58e3 100644 --- a/libgo/runtime/go-signal.c +++ b/libgo/runtime/go-signal.c @@ -216,6 +216,10 @@ getSiginfoCode(siginfo_t *info) return (uintptr)(info->si_code); } +#if defined(__sparc__) && defined(__arch64__) && defined(__linux__) + #define gregs mc_gregs +#endif + struct getSiginfoRet { uintptr sigaddr; uintptr sigpc; @@ -242,9 +246,9 @@ getSiginfo(siginfo_t *info, void *context __attribute__((unused))) // Use unportable code to pull it from context, and if that fails // try a stack backtrace across the signal handler. -#if defined(__x86_64__) && defined(__linux__) +#if defined(__x86_64__) && (defined(__linux__) || (defined(__sun__) && defined(__svr4__))) ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_RIP]; -#elif defined(__i386__) && defined(__linux__) +#elif defined(__i386__) && (defined(__linux__) || (defined(__sun__) && defined(__svr4__))) ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_EIP]; #elif defined(__alpha__) && defined(__linux__) ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.sc_pc; @@ -263,6 +267,9 @@ getSiginfo(siginfo_t *info, void *context __attribute__((unused))) #elif defined(__NetBSD__) ret.sigpc = _UC_MACHINE_PC(((ucontext_t*)(context))); #endif +#if defined(__sparc__) && (defined(__linux__) || (defined(__sun__) && defined(__svr4__))) + ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_PC]; +#endif if (ret.sigpc == 0) { // Skip getSiginfo/sighandler/sigtrampgo/sigtramp/handler. @@ -285,7 +292,7 @@ void dumpregs(siginfo_t *, void *) void dumpregs(siginfo_t *info __attribute__((unused)), void *context __attribute__((unused))) { -#if defined(__x86_64__) && defined(__linux__) +#if defined(__x86_64__) && (defined(__linux__) || (defined(__sun__) && defined(__svr4__))) { mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext; @@ -306,12 +313,22 @@ dumpregs(siginfo_t *info __attribute__((unused)), void *context __attribute__((u runtime_printf("r14 %X\n", m->gregs[REG_R14]); runtime_printf("r15 %X\n", m->gregs[REG_R15]); runtime_printf("rip %X\n", m->gregs[REG_RIP]); +#if defined(REG_EFL) runtime_printf("rflags %X\n", m->gregs[REG_EFL]); +#elif defined(REG_RFL) + runtime_printf("rflags %X\n", m->gregs[REG_RFL]); +#endif +#if defined(REG_CSGSFS) runtime_printf("cs %X\n", m->gregs[REG_CSGSFS] & 0xffff); runtime_printf("fs %X\n", (m->gregs[REG_CSGSFS] >> 16) & 0xffff); runtime_printf("gs %X\n", (m->gregs[REG_CSGSFS] >> 32) & 0xffff); +#elif defined(REG_CS) && defined(REG_FS) && defined(REG_GS) + runtime_printf("cs %X\n", m->gregs[REG_CS]); + runtime_printf("fs %X\n", m->gregs[REG_FS]); + runtime_printf("gs %X\n", m->gregs[REG_GS]); +#endif } -#elif defined(__i386__) && defined(__linux__) +#elif defined(__i386__) && (defined(__linux__) || (defined(__sun__) && defined(__svr4__))) { mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext; @@ -423,5 +440,43 @@ dumpregs(siginfo_t *info __attribute__((unused)), void *context __attribute__((u runtime_printf("pc %X\n", m->pc); runtime_printf("pstate %X\n", m->pstate); } +#elif defined(__sparc__) && (defined(__linux__) || (defined(__sun__) && defined(__svr4__))) + { + mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext; + +#ifdef __sparcv9 + #define REG_FMT "%X" +#else + #define REG_FMT "%x" +#endif + +#ifdef REG_CCR + runtime_printf("ccr " REG_FMT "\n", m->gregs[REG_CCR]); +#else + runtime_printf("psr " REG_FMT "\n", m->gregs[REG_PSR]); +#endif + runtime_printf("pc " REG_FMT "\n", m->gregs[REG_PC]); + runtime_printf("npc " REG_FMT "\n", m->gregs[REG_nPC]); + runtime_printf("y " REG_FMT "\n", m->gregs[REG_Y]); + runtime_printf("g1 " REG_FMT "\n", m->gregs[REG_G1]); + runtime_printf("g2 " REG_FMT "\n", m->gregs[REG_G2]); + runtime_printf("g3 " REG_FMT "\n", m->gregs[REG_G3]); + runtime_printf("g4 " REG_FMT "\n", m->gregs[REG_G4]); + runtime_printf("g5 " REG_FMT "\n", m->gregs[REG_G5]); + runtime_printf("g6 " REG_FMT "\n", m->gregs[REG_G6]); + runtime_printf("g7 " REG_FMT "\n", m->gregs[REG_G7]); + runtime_printf("o0 " REG_FMT "\n", m->gregs[REG_O0]); + runtime_printf("o1 " REG_FMT "\n", m->gregs[REG_O1]); + runtime_printf("o2 " REG_FMT "\n", m->gregs[REG_O2]); + runtime_printf("o3 " REG_FMT "\n", m->gregs[REG_O3]); + runtime_printf("o4 " REG_FMT "\n", m->gregs[REG_O4]); + runtime_printf("o5 " REG_FMT "\n", m->gregs[REG_O5]); + runtime_printf("o6 " REG_FMT "\n", m->gregs[REG_O6]); + runtime_printf("o7 " REG_FMT "\n", m->gregs[REG_O7]); +#if defined(REG_ASI) && defined(REG_FPRS) && !defined(__linux__) + runtime_printf("asi " REG_FMT "\n", m->gregs[REG_ASI]); + runtime_printf("fprs " REG_FMT "\n", m->gregs[REG_FPRS]); +#endif + } #endif } diff --git a/libgo/runtime/runtime.h b/libgo/runtime/runtime.h index 699770d53ad..da31e11bb77 100644 --- a/libgo/runtime/runtime.h +++ b/libgo/runtime/runtime.h @@ -7,6 +7,7 @@ #include "go-assert.h" #include <complex.h> #include <signal.h> +#include <stdbool.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -51,7 +52,6 @@ typedef uintptr uintreg; /* Defined types. */ -typedef _Bool bool; typedef uint8 byte; typedef struct g G; typedef struct mutex Lock; @@ -116,11 +116,6 @@ extern G* runtime_g(void) enum { - true = 1, - false = 0, -}; -enum -{ PtrSize = sizeof(void*), }; enum diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index 337a16bf098..4364ff96d0b 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,9 @@ +2024-04-26 Frederik Harwath <frederik@harwath.name> + + * plugin/plugin-gcn.c (isa_hsa_name): Handle EF_AMDGPU_MACH_AMDGCN_GFX90c. + (isa_code): Handle gfx90c. + (max_isa_vgprs): Handle EF_AMDGPU_MACH_AMDGCN_GFX90c. + 2024-04-16 Chung-Lin Tang <cltang@baylibre.com> * libgomp.h (REFCOUNT_ACC_MAP_DATA): Define as (REFCOUNT_SPECIAL | 2). diff --git a/libgomp/plugin/plugin-gcn.c b/libgomp/plugin/plugin-gcn.c index 27947801ccd..3cdc7ba929f 100644 --- a/libgomp/plugin/plugin-gcn.c +++ b/libgomp/plugin/plugin-gcn.c @@ -390,6 +390,7 @@ typedef enum { EF_AMDGPU_MACH_AMDGCN_GFX906 = 0x02f, EF_AMDGPU_MACH_AMDGCN_GFX908 = 0x030, EF_AMDGPU_MACH_AMDGCN_GFX90a = 0x03f, + EF_AMDGPU_MACH_AMDGCN_GFX90c = 0x032, EF_AMDGPU_MACH_AMDGCN_GFX1030 = 0x036, EF_AMDGPU_MACH_AMDGCN_GFX1036 = 0x045, EF_AMDGPU_MACH_AMDGCN_GFX1100 = 0x041, @@ -1679,6 +1680,7 @@ const static char *gcn_gfx900_s = "gfx900"; const static char *gcn_gfx906_s = "gfx906"; const static char *gcn_gfx908_s = "gfx908"; const static char *gcn_gfx90a_s = "gfx90a"; +const static char *gcn_gfx90c_s = "gfx90c"; const static char *gcn_gfx1030_s = "gfx1030"; const static char *gcn_gfx1036_s = "gfx1036"; const static char *gcn_gfx1100_s = "gfx1100"; @@ -1702,6 +1704,8 @@ isa_hsa_name (int isa) { return gcn_gfx908_s; case EF_AMDGPU_MACH_AMDGCN_GFX90a: return gcn_gfx90a_s; + case EF_AMDGPU_MACH_AMDGCN_GFX90c: + return gcn_gfx90c_s; case EF_AMDGPU_MACH_AMDGCN_GFX1030: return gcn_gfx1030_s; case EF_AMDGPU_MACH_AMDGCN_GFX1036: @@ -1749,6 +1753,9 @@ isa_code(const char *isa) { if (!strncmp (isa, gcn_gfx90a_s, gcn_isa_name_len)) return EF_AMDGPU_MACH_AMDGCN_GFX90a; + if (!strncmp (isa, gcn_gfx90c_s, gcn_isa_name_len)) + return EF_AMDGPU_MACH_AMDGCN_GFX90c; + if (!strncmp (isa, gcn_gfx1030_s, gcn_isa_name_len)) return EF_AMDGPU_MACH_AMDGCN_GFX1030; @@ -1778,6 +1785,8 @@ max_isa_vgprs (int isa) return 256; case EF_AMDGPU_MACH_AMDGCN_GFX90a: return 512; + case EF_AMDGPU_MACH_AMDGCN_GFX90c: + return 256; case EF_AMDGPU_MACH_AMDGCN_GFX1030: case EF_AMDGPU_MACH_AMDGCN_GFX1036: return 512; /* 512 SIMD32 = 256 wavefrontsize64. */ diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 507ae521983..6051dd3f1ab 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,137 @@ +2024-04-30 Christophe Lyon <christophe.lyon@linaro.org> + + * testsuite/lib/gdb-test.exp (gdb-test): Fix regexp. Quote + newlines in logs. + +2024-04-29 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + Backported from master: + 2024-04-29 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + * config/abi/post/i386-solaris/baseline_symbols.txt: Regenerate. + * config/abi/post/i386-solaris/amd64/baseline_symbols.txt: + Likewise. + * config/abi/post/sparc-solaris/baseline_symbols.txt: Likewise. + * config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt: + Likewise. + +2024-04-29 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + Backported from master: + 2024-04-29 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> + + * config/abi/post/i386-solaris/baseline_symbols.txt: Regenerate. + * config/abi/post/i386-solaris/amd64/baseline_symbols.txt: + Likewise. + * config/abi/post/sparc-solaris/baseline_symbols.txt: Likewise. + * config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt: + Likewise. + +2024-04-26 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/114863 + * include/std/format (__formatter_fp::format): Only use + _M_localized for finite values. + * testsuite/std/format/functions/format.cc: Check localized + formatting of NaN and initiny. + +2024-04-26 Jonathan Wakely <jwakely@redhat.com> + + * doc/html/manual/status.html: Regenerate. + * doc/xml/manual/status_cxx1998.xml: Adjust whitespace. + * doc/xml/manual/status_cxx2011.xml: Likewise. + * doc/xml/manual/status_cxx2014.xml: Likewise. + * doc/xml/manual/status_cxx2017.xml: Likewise. + * doc/xml/manual/status_cxx2020.xml: Likewise. + * doc/xml/manual/status_cxx2023.xml: Likewise. + * doc/xml/manual/status_cxxtr1.xml: Likewise. + * doc/xml/manual/status_cxxtr24733.xml: Likewise. + +2024-04-25 Jonathan Wakely <jwakely@redhat.com> + + * scripts/run_doxygen: Rename man pages for nested types. + +2024-04-25 Jonathan Wakely <jwakely@redhat.com> + + * include/std/chrono (tzdb_list): Fix typo in Doxygen comment. + +2024-04-25 Jonathan Wakely <jwakely@redhat.com> + + * scripts/run_doxygen: Adjust sed pattern to match '\fR' for + new man output that Doxygen 1.10 generates. + +2024-04-25 Jonathan Wakely <jwakely@redhat.com> + + * doc/doxygen/stdheader.cc (init_map): Add missing headers. + * doc/doxygen/user.cfg.in (EXCLUDE): Exclude generated files for + std::format and std::text_encoding. + +2024-04-25 Jonathan Wakely <jwakely@redhat.com> + + * include/std/variant: Add comment to #include. + +2024-04-22 Matthias Kretz <m.kretz@gsi.de> + + PR libstdc++/114803 + * include/experimental/bits/simd_builtin.h + (_SimdBase2::operator __vector_type_t): There is no __builtin() + function in _SimdWrapper, instead use its conversion operator. + * testsuite/experimental/simd/pr114803_vecbuiltin_cvt.cc: New + test. + +2024-04-22 Matthias Kretz <m.kretz@gsi.de> + + * include/experimental/bits/simd.h: Ignore -Wnarrowing for + arm_neon.h. + (__int_for_sizeof): Replace tautological compare with checking + for invalid template parameter value. + * include/experimental/bits/simd_builtin.h (__extract_part): + Remove tautological compare by combining two static_assert. + +2024-04-22 Jakub Jelinek <jakub@redhat.com> + + * testsuite/17_intro/names.cc (d, f): Undefine on s390*-linux*. + * testsuite/17_intro/headers/c++1998/all_attributes.cc (packed): Don't + define on s390. + * testsuite/17_intro/headers/c++2011/all_attributes.cc (packed): + Likewise. + * testsuite/17_intro/headers/c++2014/all_attributes.cc (packed): + Likewise. + * testsuite/17_intro/headers/c++2017/all_attributes.cc (packed): + Likewise. + * testsuite/17_intro/headers/c++2020/all_attributes.cc (packed): + Likewise. + +2024-04-19 Jonathan Wakely <jwakely@redhat.com> + + * include/bits/refwrap.h (operator<=>): Simplify constraints. + +2024-04-19 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/114770 + * src/c++20/tzdb.cc (do_locate_zone): Support links that have + another link as their target. + * testsuite/std/time/tzdb/1.cc: Check that all zones and links + can be found by locate_zone. + * testsuite/std/time/tzdb/links.cc: New test. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * testsuite/29_atomics/atomic/compare_exchange_padding.cc: + Disable SRA. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * testsuite/20_util/from_chars/8.cc: Skip float128_t testing + on aarch64-vxworks. + * testsuite/20_util/to_chars/float128_c++23.cc: Xfail run on + aarch64-vxworks. + +2024-04-18 Alexandre Oliva <oliva@adacore.com> + + * src/c++20/tzdb.cc (__gnu_cxx::zoneinfo_dir_override): Define + on VxWorks non-RTP. + 2024-04-17 Jonathan Wakely <jwakely@redhat.com> * include/std/ostream (println(ostream&)): Define new overload. diff --git a/libstdc++-v3/config/abi/post/i386-solaris/amd64/baseline_symbols.txt b/libstdc++-v3/config/abi/post/i386-solaris/amd64/baseline_symbols.txt index 9ff4ca45eb5..d8b8b7595b3 100644 --- a/libstdc++-v3/config/abi/post/i386-solaris/amd64/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/i386-solaris/amd64/baseline_symbols.txt @@ -488,6 +488,7 @@ FUNC:_ZNKSt11__timepunctIwE7_M_daysEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE8_M_am_pmEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE9_M_monthsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11logic_error4whatEv@@GLIBCXX_3.4 +FUNC:_ZNKSt12__basic_fileIcE13native_handleEv@@GLIBCXX_3.4.33 FUNC:_ZNKSt12__basic_fileIcE7is_openEv@@GLIBCXX_3.4 FUNC:_ZNKSt12__shared_ptrINSt10filesystem28recursive_directory_iterator10_Dir_stackELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 FUNC:_ZNKSt12__shared_ptrINSt10filesystem4_DirELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 @@ -3175,6 +3176,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_S_compareEmm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_capacityEm@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_S_allocateERS3_m@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC2EPcOS3_@@GLIBCXX_3.4.23 @@ -3327,6 +3329,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_replaceEmmPKwm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_S_compareEmm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_M_capacityEm@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_S_allocateERS3_m@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC2EPwOS3_@@GLIBCXX_3.4.23 @@ -4485,6 +4488,7 @@ FUNC:__cxa_allocate_exception@@CXXABI_1.3 FUNC:__cxa_bad_cast@@CXXABI_1.3 FUNC:__cxa_bad_typeid@@CXXABI_1.3 FUNC:__cxa_begin_catch@@CXXABI_1.3 +FUNC:__cxa_call_terminate@@CXXABI_1.3.15 FUNC:__cxa_call_unexpected@@CXXABI_1.3 FUNC:__cxa_current_exception_type@@CXXABI_1.3 FUNC:__cxa_deleted_virtual@@CXXABI_1.3.6 @@ -4528,6 +4532,7 @@ OBJECT:0:CXXABI_1.3.11 OBJECT:0:CXXABI_1.3.12 OBJECT:0:CXXABI_1.3.13 OBJECT:0:CXXABI_1.3.14 +OBJECT:0:CXXABI_1.3.15 OBJECT:0:CXXABI_1.3.2 OBJECT:0:CXXABI_1.3.3 OBJECT:0:CXXABI_1.3.4 @@ -4564,6 +4569,8 @@ OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 OBJECT:0:GLIBCXX_3.4.30 OBJECT:0:GLIBCXX_3.4.31 +OBJECT:0:GLIBCXX_3.4.32 +OBJECT:0:GLIBCXX_3.4.33 OBJECT:0:GLIBCXX_3.4.4 OBJECT:0:GLIBCXX_3.4.5 OBJECT:0:GLIBCXX_3.4.6 diff --git a/libstdc++-v3/config/abi/post/i386-solaris/baseline_symbols.txt b/libstdc++-v3/config/abi/post/i386-solaris/baseline_symbols.txt index 002c5f4d8ab..fb9444cc3c3 100644 --- a/libstdc++-v3/config/abi/post/i386-solaris/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/i386-solaris/baseline_symbols.txt @@ -488,6 +488,7 @@ FUNC:_ZNKSt11__timepunctIwE7_M_daysEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE8_M_am_pmEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE9_M_monthsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11logic_error4whatEv@@GLIBCXX_3.4 +FUNC:_ZNKSt12__basic_fileIcE13native_handleEv@@GLIBCXX_3.4.33 FUNC:_ZNKSt12__basic_fileIcE7is_openEv@@GLIBCXX_3.4 FUNC:_ZNKSt12__shared_ptrINSt10filesystem28recursive_directory_iterator10_Dir_stackELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 FUNC:_ZNKSt12__shared_ptrINSt10filesystem4_DirELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 @@ -3175,6 +3176,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEjjPKcj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_S_compareEjj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_capacityEj@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_S_allocateERS3_j@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC2EPcOS3_@@GLIBCXX_3.4.23 @@ -3327,6 +3329,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_replaceEjjPKwj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_S_compareEjj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_M_capacityEj@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_S_allocateERS3_j@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC2EPwOS3_@@GLIBCXX_3.4.23 @@ -4485,6 +4488,7 @@ FUNC:__cxa_allocate_exception@@CXXABI_1.3 FUNC:__cxa_bad_cast@@CXXABI_1.3 FUNC:__cxa_bad_typeid@@CXXABI_1.3 FUNC:__cxa_begin_catch@@CXXABI_1.3 +FUNC:__cxa_call_terminate@@CXXABI_1.3.15 FUNC:__cxa_call_unexpected@@CXXABI_1.3 FUNC:__cxa_current_exception_type@@CXXABI_1.3 FUNC:__cxa_deleted_virtual@@CXXABI_1.3.6 @@ -4528,6 +4532,7 @@ OBJECT:0:CXXABI_1.3.11 OBJECT:0:CXXABI_1.3.12 OBJECT:0:CXXABI_1.3.13 OBJECT:0:CXXABI_1.3.14 +OBJECT:0:CXXABI_1.3.15 OBJECT:0:CXXABI_1.3.2 OBJECT:0:CXXABI_1.3.3 OBJECT:0:CXXABI_1.3.4 @@ -4564,6 +4569,8 @@ OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 OBJECT:0:GLIBCXX_3.4.30 OBJECT:0:GLIBCXX_3.4.31 +OBJECT:0:GLIBCXX_3.4.32 +OBJECT:0:GLIBCXX_3.4.33 OBJECT:0:GLIBCXX_3.4.4 OBJECT:0:GLIBCXX_3.4.5 OBJECT:0:GLIBCXX_3.4.6 diff --git a/libstdc++-v3/config/abi/post/sparc-solaris/baseline_symbols.txt b/libstdc++-v3/config/abi/post/sparc-solaris/baseline_symbols.txt index c583ee0260b..1ec9405ae2e 100644 --- a/libstdc++-v3/config/abi/post/sparc-solaris/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/sparc-solaris/baseline_symbols.txt @@ -488,6 +488,7 @@ FUNC:_ZNKSt11__timepunctIwE7_M_daysEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE8_M_am_pmEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE9_M_monthsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11logic_error4whatEv@@GLIBCXX_3.4 +FUNC:_ZNKSt12__basic_fileIcE13native_handleEv@@GLIBCXX_3.4.33 FUNC:_ZNKSt12__basic_fileIcE7is_openEv@@GLIBCXX_3.4 FUNC:_ZNKSt12__shared_ptrINSt10filesystem28recursive_directory_iterator10_Dir_stackELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 FUNC:_ZNKSt12__shared_ptrINSt10filesystem4_DirELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 @@ -3175,6 +3176,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEjjPKcj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_S_compareEjj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_capacityEj@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_S_allocateERS3_j@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC2EPcOS3_@@GLIBCXX_3.4.23 @@ -3327,6 +3329,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_replaceEjjPKwj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_S_compareEjj@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_M_capacityEj@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_S_allocateERS3_j@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC2EPwOS3_@@GLIBCXX_3.4.23 @@ -4485,6 +4488,7 @@ FUNC:__cxa_allocate_exception@@CXXABI_1.3 FUNC:__cxa_bad_cast@@CXXABI_1.3 FUNC:__cxa_bad_typeid@@CXXABI_1.3 FUNC:__cxa_begin_catch@@CXXABI_1.3 +FUNC:__cxa_call_terminate@@CXXABI_1.3.15 FUNC:__cxa_call_unexpected@@CXXABI_1.3 FUNC:__cxa_current_exception_type@@CXXABI_1.3 FUNC:__cxa_deleted_virtual@@CXXABI_1.3.6 @@ -4528,6 +4532,7 @@ OBJECT:0:CXXABI_1.3.11 OBJECT:0:CXXABI_1.3.12 OBJECT:0:CXXABI_1.3.13 OBJECT:0:CXXABI_1.3.14 +OBJECT:0:CXXABI_1.3.15 OBJECT:0:CXXABI_1.3.2 OBJECT:0:CXXABI_1.3.3 OBJECT:0:CXXABI_1.3.4 @@ -4563,6 +4568,8 @@ OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 OBJECT:0:GLIBCXX_3.4.30 OBJECT:0:GLIBCXX_3.4.31 +OBJECT:0:GLIBCXX_3.4.32 +OBJECT:0:GLIBCXX_3.4.33 OBJECT:0:GLIBCXX_3.4.4 OBJECT:0:GLIBCXX_3.4.5 OBJECT:0:GLIBCXX_3.4.6 diff --git a/libstdc++-v3/config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt b/libstdc++-v3/config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt index 03acb0bac2c..2bf5c8522a1 100644 --- a/libstdc++-v3/config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/sparc-solaris/sparcv9/baseline_symbols.txt @@ -488,6 +488,7 @@ FUNC:_ZNKSt11__timepunctIwE7_M_daysEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE8_M_am_pmEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE9_M_monthsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11logic_error4whatEv@@GLIBCXX_3.4 +FUNC:_ZNKSt12__basic_fileIcE13native_handleEv@@GLIBCXX_3.4.33 FUNC:_ZNKSt12__basic_fileIcE7is_openEv@@GLIBCXX_3.4 FUNC:_ZNKSt12__shared_ptrINSt10filesystem28recursive_directory_iterator10_Dir_stackELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 FUNC:_ZNKSt12__shared_ptrINSt10filesystem4_DirELN9__gnu_cxx12_Lock_policyE2EEcvbEv@@GLIBCXX_3.4.31 @@ -3175,6 +3176,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_S_compareEmm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_capacityEm@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_S_allocateERS3_m@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC1EPcRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC2EPcOS3_@@GLIBCXX_3.4.23 @@ -3327,6 +3329,7 @@ FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_disposeEv@@GLIBCX FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_M_replaceEmmPKwm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE10_S_compareEmm@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_M_capacityEm@@GLIBCXX_3.4.21 +FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE11_S_allocateERS3_m@@GLIBCXX_3.4.32 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwOS3_@@GLIBCXX_3.4.23 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC1EPwRKS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_Alloc_hiderC2EPwOS3_@@GLIBCXX_3.4.23 @@ -4485,6 +4488,7 @@ FUNC:__cxa_allocate_exception@@CXXABI_1.3 FUNC:__cxa_bad_cast@@CXXABI_1.3 FUNC:__cxa_bad_typeid@@CXXABI_1.3 FUNC:__cxa_begin_catch@@CXXABI_1.3 +FUNC:__cxa_call_terminate@@CXXABI_1.3.15 FUNC:__cxa_call_unexpected@@CXXABI_1.3 FUNC:__cxa_current_exception_type@@CXXABI_1.3 FUNC:__cxa_deleted_virtual@@CXXABI_1.3.6 @@ -4528,6 +4532,7 @@ OBJECT:0:CXXABI_1.3.11 OBJECT:0:CXXABI_1.3.12 OBJECT:0:CXXABI_1.3.13 OBJECT:0:CXXABI_1.3.14 +OBJECT:0:CXXABI_1.3.15 OBJECT:0:CXXABI_1.3.2 OBJECT:0:CXXABI_1.3.3 OBJECT:0:CXXABI_1.3.4 @@ -4563,6 +4568,8 @@ OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 OBJECT:0:GLIBCXX_3.4.30 OBJECT:0:GLIBCXX_3.4.31 +OBJECT:0:GLIBCXX_3.4.32 +OBJECT:0:GLIBCXX_3.4.33 OBJECT:0:GLIBCXX_3.4.4 OBJECT:0:GLIBCXX_3.4.5 OBJECT:0:GLIBCXX_3.4.6 diff --git a/libstdc++-v3/doc/doxygen/stdheader.cc b/libstdc++-v3/doc/doxygen/stdheader.cc index 67f54eef02b..3ee825feb66 100644 --- a/libstdc++-v3/doc/doxygen/stdheader.cc +++ b/libstdc++-v3/doc/doxygen/stdheader.cc @@ -40,19 +40,25 @@ void init_map() headers["ranges_algo.h"] = "algorithm"; headers["ranges_algobase.h"] = "algorithm"; headers["heap.h"] = "algorithm"; + headers["chrono_io.h"] = "chrono"; + headers["parse_numbers.h"] = "chrono"; headers["exception_ptr.h"] = "exception"; headers["nested_exception.h"] = "exception"; headers["fs_dir.h"] = "filesystem"; headers["fs_fwd.h"] = "filesystem"; headers["fs_ops.h"] = "filesystem"; headers["fs_path.h"] = "filesystem"; + headers["unicode.h"] = "format"; + headers["unicode-data.h"] = "format"; headers["binders.h"] = "functional"; headers["function.h"] = "functional"; headers["functional_hash.h"] = "functional"; headers["mofunc_impl.h"] = "functional"; headers["move_only_function.h"] = "functional"; headers["invoke.h"] = "functional"; + headers["ranges_cmp.h"] = "functional"; headers["refwrap.h"] = "functional"; + headers["elements_of.h"] = "generator"; headers["quoted_string.h"] = "iomanip"; headers["ios_base.h"] = "ios"; headers["basic_ios.h"] = "ios"; @@ -64,6 +70,7 @@ void init_map() headers["stream_iterator.h"] = "iterator"; headers["streambuf_iterator.h"] = "iterator"; headers["iterator_concepts.h"] = "iterator"; + headers["max_size_type.h"] = "iterator"; headers["range_access.h"] = "iterator"; headers["codecvt.h"] = "locale"; headers["c++locale.h"] = "locale"; @@ -80,9 +87,11 @@ void init_map() headers["memoryfwd.h"] = "memory"; headers["align.h"] = "memory"; headers["alloc_traits.h"] = "memory"; + headers["allocated_ptr.h"] = "memory"; headers["auto_ptr.h"] = "memory"; headers["construct.h"] = "memory"; headers["allocator.h"] = "memory"; + headers["new_allocator.h"] = "memory"; headers["raw_storage_iter.h"] = "memory"; headers["tempbuf.h"] = "memory"; headers["uninitialized.h"] = "memory"; @@ -94,11 +103,15 @@ void init_map() headers["ptr_traits.h"] = "memory"; headers["uses_allocator.h"] = "memory"; headers["uses_allocator_args.h"] = "memory"; + headers["out_ptr.h"] = "memory"; + headers["memory_resource.h"] = "memory_resource"; headers["unique_lock.h"] = "mutex"; + headers["sat_arith.h"] = "numeric"; + headers["ostream_insert.h"] = "ostream"; headers["uniform_int_dist.h"] = "random"; headers["ranges_base.h"] = "ranges"; + headers["ranges_to.h"] = "ranges"; headers["ranges_util.h"] = "ranges"; - headers["ranges_cmp.h"] = "functional"; headers["regex_automaton.h"] = "regex"; headers["regex_automaton.tcc"] = "regex"; headers["regex_compiler.h"] = "regex"; @@ -122,6 +135,9 @@ void init_map() headers["string_view.tcc"] = "string_view"; headers["this_thread_sleep.h"] = "thread"; headers["tree.h"] = "map"; + headers["hashtable.h"] = "unordered_map"; + headers["hashtable_policy.h"] = "unordered_map"; + headers["move.h"] = "utility"; headers["pair.h"] = "utility"; headers["relops.h"] = "utility"; headers["gslice.h"] = "valarray"; @@ -142,30 +158,34 @@ void init_map() headers["abs.h"] = "cstdlib"; headers["specfun.h"] = "cmath"; - // This list is complete as of the October 2021 working draft. + // This list is complete as of the April 2024 working draft. std_headers = { "algorithm", "any", "array", "atomic", "barrier", "bit", "bitset", "charconv", "chrono", "codecvt", "compare", "complex", "concepts", "condition_variable", "coroutine", - "deque", - "exception", "execution", - "filesystem", "format", "forward_list", "fstream", - "functional", "future", + "debugging", "deque", + "exception", "execution", "expected", + "filesystem", "flat_set", "flat_map", "format", "forward_list", + "fstream", "functional", "future", + "generator", + "hazard_pointer", "initializer_list", "iomanip", "ios", "iosfwd", "iostream", "istream", "iterator", - "latch", "limits", "list", "locale", - "map", "memory", "memory_resource", "mutex", + "latch", "limits", "linalg", "list", "locale", + "map", "mdspan", "memory", "memory_resource", "mutex", "new", "numbers", "numeric", "optional", "ostream", + "print", "queue", - "random", "ranges", "ratio", "regex", + "random", "ranges", "ratio", "rcu", "regex", "scoped_allocator", "semaphore", "set", "shared_mutex", "source_location", "span", "spanstream", "sstream", - "stack", "stacktrace", "stdexcept", "stop_token", + "stack", "stacktrace", "stdexcept", "stdfloat", "stop_token", "streambuf", "string", "string_view", "strstream", "syncstream", "system_error", - "thread", "tuple", "typeindex", "typeinfo", "type_traits", + "text_encoding", "thread", "tuple", "type_traits", + "typeindex", "typeinfo", "unordered_map", "unordered_set", "utility", "valarray", "variant", "vector", "version", diff --git a/libstdc++-v3/doc/doxygen/user.cfg.in b/libstdc++-v3/doc/doxygen/user.cfg.in index 0905e0f48f2..8fe337adf75 100644 --- a/libstdc++-v3/doc/doxygen/user.cfg.in +++ b/libstdc++-v3/doc/doxygen/user.cfg.in @@ -862,9 +862,11 @@ INPUT = @srcdir@/doc/doxygen/doxygroups.cc \ include/expected \ include/filesystem \ include/forward_list \ + include/format \ include/fstream \ include/functional \ include/future \ + include/generator \ include/iomanip \ include/ios \ include/iosfwd \ @@ -883,6 +885,7 @@ INPUT = @srcdir@/doc/doxygen/doxygroups.cc \ include/numbers \ include/optional \ include/ostream \ + include/print \ include/queue \ include/random \ include/ranges \ @@ -1093,6 +1096,9 @@ RECURSIVE = NO # run. EXCLUDE = Makefile \ + include/unicode-data.h \ + include/text_encoding-data.h \ + include/text_encoding-win32.h \ include/experimental/bits/net.h # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html index 2e293d32f81..3d55e265272 100644 --- a/libstdc++-v3/doc/html/manual/status.html +++ b/libstdc++-v3/doc/html/manual/status.html @@ -5,8 +5,8 @@ </th><td width="20%" align="right"> <a accesskey="n" href="license.html">Next</a></td></tr></table><hr /></div><div class="chapter"><div class="titlepage"><div><div><h2 class="title"><a id="manual.intro.status"></a>Chapter 1. Status</h2></div></div></div><div class="toc"><p><strong>Table of Contents</strong></p><dl class="toc"><dt><span class="section"><a href="status.html#manual.intro.status.iso">Implementation Status</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#status.iso.1998">C++ 1998/2003</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.1998.status">Implementation Status</a></span></dt><dt><span class="section"><a href="status.html#iso.1998.specific">Implementation Specific Behavior</a></span></dt></dl></dd><dt><span class="section"><a href="status.html#status.iso.2011">C++ 2011</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.2011.specific">Implementation Specific Behavior</a></span></dt></dl></dd><dt><span class="section"><a href="status.html#status.iso.2014">C++ 2014</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.2014.specific">Implementation Specific Behavior</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.2014.filesystemts">Filesystem TS</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="status.html#status.iso.2017">C++ 2017</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.2017.specific">Implementation Specific Behavior</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.2017.par2ts">Parallelism 2 TS</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="status.html#status.iso.2020">C++ 2020</a></span></dt><dt><span class="section"><a href="status.html#status.iso.2023">C++ 2023</a></span></dt><dt><span class="section"><a href="status.html#status.iso.tr1">C++ TR1</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.tr1.specific">Implementation Specific Behavior</a></span></dt></dl></dd><dt><span class="section"><a href="status.html#status.iso.tr24733">C++ TR 24733</a></span></dt><dt><span class="section"><a href="status.html#status.iso.specfun">C++ IS 29124</a></span></dt><dd><dl><dt><span class="section"><a href="status.html#iso.specfun.specific">Implementation Specific Behavior</a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="license.html">License</a></span></dt><dd><dl><dt><span class="section"><a href="license.html#manual.intro.status.license.gpl">The Code: GPL</a></span></dt><dt><span class="section"><a href="license.html#manual.intro.status.license.fdl">The Documentation: GPL, FDL</a></span></dt></dl></dd><dt><span class="section"><a href="bugs.html">Bugs</a></span></dt><dd><dl><dt><span class="section"><a href="bugs.html#manual.intro.status.bugs.impl">Implementation Bugs</a></span></dt><dt><span class="section"><a href="bugs.html#manual.intro.status.bugs.iso">Standard Bugs</a></span></dt></dl></dd></dl></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="manual.intro.status.iso"></a>Implementation Status</h2></div></div></div><div class="section"><div class="titlepage"><div><div><h3 class="title"><a id="status.iso.1998"></a>C++ 1998/2003</h3></div></div></div><div class="section"><div class="titlepage"><div><div><h4 class="title"><a id="iso.1998.status"></a>Implementation Status</h4></div></div></div><p> This status table is based on the table of contents of ISO/IEC 14882:2003. </p><p> -This section describes the C++ support in mainline GCC, not in any -particular release. +This section describes the C++ support in +mainline GCC, not in any particular release. </p><div class="table"><a id="table.cxx98_status"></a><p class="title"><strong>Table 1.1. C++ 1998/2003 Implementation Status</strong></p><div class="table-contents"><table class="table" summary="C++ 1998/2003 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>18</em></span> </td><td colspan="3" align="left"> @@ -160,8 +160,8 @@ since that release. </p><p> This status table is based on the table of contents of ISO/IEC 14882:2011. </p><p> -This section describes the C++11 support in mainline GCC, not in any -particular release. +This section describes the C++11 support in +mainline GCC, not in any particular release. </p><div class="table"><a id="table.cxx11_status"></a><p class="title"><strong>Table 1.2. C++ 2011 Implementation Status</strong></p><div class="table-contents"><table class="table" summary="C++ 2011 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>18</em></span> </td><td colspan="3" align="left"> @@ -433,8 +433,8 @@ This status table is based on the table of contents of ISO/IEC 14882:2014. Some subclauses are not shown in the table where the content is unchanged since C++11 and the implementation is complete. </p><p> -This section describes the C++14 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++14 and library TS support in +mainline GCC, not in any particular release. </p><div class="table"><a id="table.cxx14_status"></a><p class="title"><strong>Table 1.3. C++ 2014 Implementation Status</strong></p><div class="table-contents"><table class="table" summary="C++ 2014 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>18</em></span> </td><td colspan="3" align="left"> @@ -578,8 +578,8 @@ GCC 9.1 was the first release with non-experimental C++17 support, so the API and ABI of features added in C++17 is only stable since that release. </p><p> -This section describes the C++17 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++17 and library TS support in +mainline GCC, not in any particular release. </p><p> The following table lists new library features that are included in the C++17 standard. The "Proposal" column provides a link to the @@ -1254,8 +1254,8 @@ options. The pre-defined symbol <code class="constant">__cplusplus</code> is used to check for the presence of the required flag. </p><p> -This section describes the C++20 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++20 and library TS support in +mainline GCC, not in any particular release. </p><p> The following table lists new library features that are included in the C++20 standard. The "Proposal" column provides a link to the @@ -1724,8 +1724,8 @@ options. The pre-defined symbol <code class="constant">__cplusplus</code> is used to check for the presence of the required flag. </p><p> -This section describes the C++23 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++23 and library TS support in +mainline GCC, not in any particular release. </p><p> The following table lists new library features that have been accepted into the C++23 working draft. The "Proposal" column provides a link to the @@ -2212,8 +2212,8 @@ In this implementation the header names are prefixed by <code class="code">tr1/</code>, for instance <code class="code"><tr1/functional></code>, <code class="code"><tr1/memory></code>, and so on. </p><p> -This page describes the TR1 support in mainline GCC, not in any particular -release. +This page describes the TR1 support in +mainline GCC, not in any particular release. </p><div class="table"><a id="table.tr1_status"></a><p class="title"><strong>Table 1.11. C++ TR1 Implementation Status</strong></p><div class="table-contents"><table class="table" summary="C++ TR1 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"><span class="emphasis"><em>2</em></span></td><td colspan="3" align="left"><span class="emphasis"><em>General Utilities</em></span></td></tr><tr><td align="left">2.1</td><td align="left">Reference wrappers</td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.1.1</td><td align="left">Additions to header <code class="code"><functional></code> synopsis</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2</td><td align="left">Class template <code class="code">reference_wrapper</code></td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.1.2.1</td><td align="left"><code class="code">reference_wrapper</code> construct/copy/destroy</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.2</td><td align="left"><code class="code">reference_wrapper</code> assignment</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.3</td><td align="left"><code class="code">reference_wrapper</code> access</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.4</td><td align="left"><code class="code">reference_wrapper</code> invocation</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.1.2.5</td><td align="left"><code class="code">reference_wrapper</code> helper functions</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2</td><td align="left">Smart pointers</td><td align="left"> </td><td align="left"> </td></tr><tr><td align="left">2.2.1</td><td align="left">Additions to header <code class="code"><memory></code> synopsis</td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2.2</td><td align="left">Class <code class="code">bad_weak_ptr</code></td><td align="left">Y</td><td align="left"> </td></tr><tr><td align="left">2.2.3</td><td align="left">Class template <code class="code">shared_ptr</code></td><td align="left"> </td><td align="left"> <p> Uses code from @@ -2233,8 +2233,8 @@ ISO/IEC TR 24733:2011, "Extensions for the programming language C++ to support decimal floating-point arithmetic". </p><p> -This page describes the TR 24733 support in mainline GCC, not in any -particular release. +This page describes the TR 24733 support in +mainline GCC, not in any particular release. </p><div class="table"><a id="table.decfp_status"></a><p class="title"><strong>Table 1.12. C++ TR 24733 Implementation Status</strong></p><div class="table-contents"><table class="table" summary="C++ TR 24733 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left"> <span class="emphasis"><em>0</em></span> </td><td colspan="3" align="left"> diff --git a/libstdc++-v3/doc/xml/manual/status_cxx1998.xml b/libstdc++-v3/doc/xml/manual/status_cxx1998.xml index 792272bcf26..6b84e7c36e2 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx1998.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx1998.xml @@ -18,8 +18,8 @@ This status table is based on the table of contents of ISO/IEC 14882:2003. </para> <para> -This section describes the C++ support in mainline GCC, not in any -particular release. +This section describes the C++ support in +mainline GCC, not in any particular release. </para> <!-- Status is Yes or No, Broken/Partial--> diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml index 7f589ad7f7a..17108e33af3 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml @@ -34,8 +34,8 @@ This status table is based on the table of contents of ISO/IEC 14882:2011. </para> <para> -This section describes the C++11 support in mainline GCC, not in any -particular release. +This section describes the C++11 support in +mainline GCC, not in any particular release. </para> <!-- Status is Yes or No, Broken/Partial--> diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2014.xml b/libstdc++-v3/doc/xml/manual/status_cxx2014.xml index 518a8973f72..9bed79bb9b2 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx2014.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx2014.xml @@ -29,8 +29,8 @@ since C++11 and the implementation is complete. </para> <para> -This section describes the C++14 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++14 and library TS support in +mainline GCC, not in any particular release. </para> <!-- Status is Yes or No, Broken/Partial--> diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml index 144b9909fac..48a0317950c 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml @@ -23,8 +23,8 @@ since that release. </para> <para> -This section describes the C++17 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++17 and library TS support in +mainline GCC, not in any particular release. </para> <para> diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2020.xml b/libstdc++-v3/doc/xml/manual/status_cxx2020.xml index d6359d50f42..0e3e4c3de7f 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx2020.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx2020.xml @@ -20,8 +20,8 @@ presence of the required flag. </para> <para> -This section describes the C++20 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++20 and library TS support in +mainline GCC, not in any particular release. </para> <para> diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2023.xml b/libstdc++-v3/doc/xml/manual/status_cxx2023.xml index 9b870d1dbdf..3c33a3596f6 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxx2023.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxx2023.xml @@ -20,8 +20,8 @@ presence of the required flag. </para> <para> -This section describes the C++23 and library TS support in mainline GCC, -not in any particular release. +This section describes the C++23 and library TS support in +mainline GCC, not in any particular release. </para> <para> diff --git a/libstdc++-v3/doc/xml/manual/status_cxxtr1.xml b/libstdc++-v3/doc/xml/manual/status_cxxtr1.xml index addfd1f2d86..9d22c55c57c 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxxtr1.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxxtr1.xml @@ -22,8 +22,8 @@ In this implementation the header names are prefixed by </para> <para> -This page describes the TR1 support in mainline GCC, not in any particular -release. +This page describes the TR1 support in +mainline GCC, not in any particular release. </para> <!-- Status is Yes or No, Broken/Partial--> diff --git a/libstdc++-v3/doc/xml/manual/status_cxxtr24733.xml b/libstdc++-v3/doc/xml/manual/status_cxxtr24733.xml index f64dc983c6e..073d291b52d 100644 --- a/libstdc++-v3/doc/xml/manual/status_cxxtr24733.xml +++ b/libstdc++-v3/doc/xml/manual/status_cxxtr24733.xml @@ -17,8 +17,8 @@ decimal floating-point arithmetic". </para> <para> -This page describes the TR 24733 support in mainline GCC, not in any -particular release. +This page describes the TR 24733 support in +mainline GCC, not in any particular release. </para> <!-- Status is Yes or No, Broken/Partial--> diff --git a/libstdc++-v3/include/bits/refwrap.h b/libstdc++-v3/include/bits/refwrap.h index fd1cc2b63e6..71ec2b297b7 100644 --- a/libstdc++-v3/include/bits/refwrap.h +++ b/libstdc++-v3/include/bits/refwrap.h @@ -384,23 +384,29 @@ _GLIBCXX_MEM_FN_TRAITS(&& noexcept, false_type, true_type) && requires { { __x.get() == __y.get() } -> convertible_to<bool>; } { return __x.get() == __y.get(); } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 4071. reference_wrapper comparisons are not SFINAE-friendly + [[nodiscard]] friend constexpr auto - operator<=>(reference_wrapper __x, reference_wrapper<_Tp> __y) - requires requires { __detail::__synth3way(__x.get(), __y.get()); } + operator<=>(reference_wrapper __x, reference_wrapper __y) + requires requires (const _Tp __t) { + { __t < __t } -> __detail::__boolean_testable; + } { return __detail::__synth3way(__x.get(), __y.get()); } [[nodiscard]] friend constexpr auto operator<=>(reference_wrapper __x, const _Tp& __y) - requires requires { __detail::__synth3way(__x.get(), __y); } + requires requires { { __y < __y } -> __detail::__boolean_testable; } { return __detail::__synth3way(__x.get(), __y); } [[nodiscard]] friend constexpr auto operator<=>(reference_wrapper __x, reference_wrapper<const _Tp> __y) - requires (!is_const_v<_Tp>) - && requires { __detail::__synth3way(__x.get(), __y.get()); } + requires (!is_const_v<_Tp>) && requires (const _Tp __t) { + { __t < __t } -> __detail::__boolean_testable; + } { return __detail::__synth3way(__x.get(), __y.get()); } #endif }; diff --git a/libstdc++-v3/include/experimental/bits/simd.h b/libstdc++-v3/include/experimental/bits/simd.h index 03c2e17a326..6ef9c955cfa 100644 --- a/libstdc++-v3/include/experimental/bits/simd.h +++ b/libstdc++-v3/include/experimental/bits/simd.h @@ -44,7 +44,12 @@ #if _GLIBCXX_SIMD_X86INTRIN #include <x86intrin.h> #elif _GLIBCXX_SIMD_HAVE_NEON +#pragma GCC diagnostic push +// narrowing conversion of '__a' from 'uint64_t' {aka 'long long unsigned int'} to +// 'int64x1_t' {aka 'long long int'} [-Wnarrowing] +#pragma GCC diagnostic ignored "-Wnarrowing" #include <arm_neon.h> +#pragma GCC diagnostic pop #endif #if _GLIBCXX_SIMD_HAVE_SVE #include <arm_sve.h> @@ -598,6 +603,7 @@ template <size_t _Bytes> constexpr auto __int_for_sizeof() { + static_assert(_Bytes > 0); if constexpr (_Bytes == sizeof(int)) return int(); #ifdef __clang__ @@ -663,7 +669,7 @@ template <size_t _Bytes> return _Ip{}; } else - static_assert(_Bytes != _Bytes, "this should be unreachable"); + static_assert(_Bytes == 0, "this should be unreachable"); } #pragma GCC diagnostic pop diff --git a/libstdc++-v3/include/experimental/bits/simd_builtin.h b/libstdc++-v3/include/experimental/bits/simd_builtin.h index af0c4886108..4ceeb423894 100644 --- a/libstdc++-v3/include/experimental/bits/simd_builtin.h +++ b/libstdc++-v3/include/experimental/bits/simd_builtin.h @@ -278,8 +278,7 @@ template <int _Index, int _Total, int _Combine = 1, size_t _Np> __extract_part(const _SimdWrapper<bool, _Np> __x) { static_assert(_Combine == 1, "_Combine != 1 not implemented"); - static_assert(__have_avx512f && _Np == _Np); - static_assert(_Total >= 2 && _Index + _Combine <= _Total && _Index >= 0); + static_assert(__have_avx512f && _Total >= 2 && _Index + _Combine <= _Total && _Index >= 0); return __x._M_data >> (_Index * _Np / _Total); } @@ -842,7 +841,7 @@ template <typename _Tp, typename _Mp, typename _Abi, size_t _Np> _GLIBCXX_SIMD_ALWAYS_INLINE explicit operator __vector_type_t<_Tp, _Np>() const - { return static_cast<const simd<_Tp, _Abi>*>(this)->_M_data.__builtin(); } + { return __data(*static_cast<const simd<_Tp, _Abi>*>(this)); } }; struct _SimdBase1 diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono index 3a9751781d2..b0aadf83b03 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -2780,7 +2780,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** Remove the tzdb object _after_ the one the iterator refers to. * - * Calling this function concurently with any of `front()`, `begin()`, + * Calling this function concurrently with any of `front()`, `begin()`, * or `end()` does not cause a data race, but in general this function * is not thread-safe. The behaviour may be undefined if erasing an * element from the list while another thread is calling the same diff --git a/libstdc++-v3/include/std/format b/libstdc++-v3/include/std/format index 22dcb5f24bd..48deba2bcb2 100644 --- a/libstdc++-v3/include/std/format +++ b/libstdc++-v3/include/std/format @@ -1734,7 +1734,7 @@ namespace __format } #endif - if (_M_spec._M_localized) + if (_M_spec._M_localized && __builtin_isfinite(__v)) { __wstr = _M_localize(__str, __expc, __fc.locale()); if (!__wstr.empty()) diff --git a/libstdc++-v3/include/std/generator b/libstdc++-v3/include/std/generator index 789016b5a88..1d5acc91420 100644 --- a/libstdc++-v3/include/std/generator +++ b/libstdc++-v3/include/std/generator @@ -322,8 +322,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Promise> auto await_suspend(std::coroutine_handle<_Promise> __c) noexcept { +#ifdef __glibcxx_is_pointer_interconvertible static_assert(is_pointer_interconvertible_base_of_v< _Promise_erased, _Promise>); +#endif auto& __n = __c.promise()._M_nest; return __n._M_pop(); @@ -344,8 +346,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Promise> void await_suspend(std::coroutine_handle<_Promise>) noexcept { +#ifdef __glibcxx_is_pointer_interconvertible static_assert(is_pointer_interconvertible_base_of_v< _Promise_erased, _Promise>); +#endif _M_bottom_value = ::std::addressof(_M_value); } @@ -375,8 +379,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::coroutine_handle<> await_suspend(std::coroutine_handle<_Promise> __p) noexcept { +#ifdef __glibcxx_is_pointer_interconvertible static_assert(is_pointer_interconvertible_base_of_v< _Promise_erased, _Promise>); +#endif auto __c = _Coro_handle::from_address(__p.address()); auto __t = _Coro_handle::from_address(this->_M_gen._M_coro.address()); @@ -685,8 +691,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return { coroutine_handle<promise_type>::from_promise(*this) }; } }; +#ifdef __glibcxx_is_pointer_interconvertible static_assert(is_pointer_interconvertible_base_of_v<_Erased_promise, promise_type>); +#endif generator(const generator&) = delete; diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant index f79d95db7a8..748e9bae1cb 100644 --- a/libstdc++-v3/include/std/variant +++ b/libstdc++-v3/include/std/variant @@ -42,7 +42,7 @@ #include <bits/exception_defines.h> #include <bits/functional_hash.h> #include <bits/invoke.h> -#include <bits/parse_numbers.h> +#include <bits/parse_numbers.h> // _Select_int #include <bits/stl_iterator_base_funcs.h> #include <bits/stl_construct.h> #include <bits/utility.h> // in_place_index_t diff --git a/libstdc++-v3/scripts/run_doxygen b/libstdc++-v3/scripts/run_doxygen index fbd601b11cc..11f24b058af 100644 --- a/libstdc++-v3/scripts/run_doxygen +++ b/libstdc++-v3/scripts/run_doxygen @@ -294,7 +294,11 @@ $gxx $cppflags $cxxflags ${srcdir}/doc/doxygen/stdheader.cc -o ./stdheader || ex problematic=`grep -E -l '#include <.*h>' [a-z]*.3` for f in $problematic; do # this is also slow, but safe and easy to debug - oldh=`sed -n '/fC#include </s/.*<\(.*\)>.*/\1/p' $f` + oldh=`sed -n '/f[CR]#include </s/.*<\(.*\)>.*/\1/p' $f` + if [ "$oldh" == "" ]; then + echo "ERROR: Doxygen man page formatting changed" 2>&1 + continue + fi newh=`echo $oldh | sed 's/\\\\&\\././g' | ./stdheader` sed "s=${oldh/\\/.}=${newh}=" $f > TEMP && mv TEMP $f done @@ -411,8 +415,21 @@ for f in __cxxabiv1_*; do mv $f $newname done +mv std::__unspecified___exception_ptr.3 std::exception_ptr.3 + # Then piecemeal nested classes +for f in std*distribution_param_type.3; do + newname=`echo $f | sed 's/distribution_param_type/distribution::param_type/'` + mv $f $newname +done + +for f in std*filesystem::path_iterator.3; do + newname=`echo $f | sed 's/path_iterator/path::iterator/'` + mv $f $newname +done + +mv std::chrono::tzdb_list_const_iterator.3 std::chrono::tzdb_list::const_iterator.3 # Generic removal bits, where there are things in the generated man # pages that need to be killed. diff --git a/libstdc++-v3/src/c++20/tzdb.cc b/libstdc++-v3/src/c++20/tzdb.cc index 639d1c440ba..c7c7cc9deee 100644 --- a/libstdc++-v3/src/c++20/tzdb.cc +++ b/libstdc++-v3/src/c++20/tzdb.cc @@ -1599,7 +1599,7 @@ namespace std::chrono const time_zone* do_locate_zone(const vector<time_zone>& zones, const vector<time_zone_link>& links, - string_view tz_name) noexcept + string_view tz_name) { // Lambda mangling changed between -fabi-version=2 and -fabi-version=18 auto search = []<class Vec>(const Vec& v, string_view name) { @@ -1610,13 +1610,62 @@ namespace std::chrono return ptr; }; + // Search zones first. if (auto tz = search(zones, tz_name)) return tz; + // Search links second. if (auto tz_l = search(links, tz_name)) - return search(zones, tz_l->target()); + { + // Handle the common case of a link that has a zone as the target. + if (auto tz = search(zones, tz_l->target())) [[likely]] + return tz; + + // Either tz_l->target() doesn't exist, or we have a chain of links. + // Use Floyd's cycle-finding algorithm to avoid infinite loops, + // at the cost of extra lookups. In the common case we expect a + // chain of links to be short so the loop won't run many times. + // In particular, the duplicate lookups to move the tortoise + // never happen unless the chain has four or more links. + // When a chain contains a cycle we do multiple duplicate lookups, + // but that case should never happen with correct tzdata.zi, + // so there's no need to optimize cycle detection. + + const time_zone_link* tortoise = tz_l; + const time_zone_link* hare = search(links, tz_l->target()); + while (hare) + { + // Chains should be short, so first check if it ends here: + if (auto tz = search(zones, hare->target())) [[likely]] + return tz; + + // Otherwise follow the chain: + hare = search(links, hare->target()); + if (!hare) + break; + + // Again, first check if the chain ends at a zone here: + if (auto tz = search(zones, hare->target())) [[likely]] + return tz; + + // Follow the chain again: + hare = search(links, hare->target()); + + if (hare == tortoise) + { + string_view err = "std::chrono::tzdb: link cycle: "; + string str; + str.reserve(err.size() + tz_name.size()); + str += err; + str += tz_name; + __throw_runtime_error(str.c_str()); + } + // Plod along the chain one step: + tortoise = search(links, tortoise->target()); + } + } - return nullptr; + return nullptr; // not found } } // namespace @@ -1626,7 +1675,7 @@ namespace std::chrono { if (auto tz = do_locate_zone(zones, links, tz_name)) return tz; - string_view err = "tzdb: cannot locate zone: "; + string_view err = "std::chrono::tzdb: cannot locate zone: "; string str; str.reserve(err.size() + tz_name.size()); str += err; diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++1998/all_attributes.cc b/libstdc++-v3/testsuite/17_intro/headers/c++1998/all_attributes.cc index ae81846b9a3..0c38259b74e 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++1998/all_attributes.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++1998/all_attributes.cc @@ -29,7 +29,11 @@ # define noreturn 1 # define visibility 1 #endif +#ifndef __s390__ +// kernel-headers <asm/types.h> uses __attribute__((packed,aligned(4))) on +// S390. #define packed 1 +#endif #define pure 1 // glibc's sysdeps/unix/sysv/linux/arm/sys/ucontext.h uses this on ARM. #ifndef __arm__ diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++2011/all_attributes.cc b/libstdc++-v3/testsuite/17_intro/headers/c++2011/all_attributes.cc index 5f7f31ad5da..cc34a35ae4d 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++2011/all_attributes.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++2011/all_attributes.cc @@ -29,7 +29,11 @@ # define visibility 1 #endif #define no_unique_address 1 +#ifndef __s390__ +// kernel-headers <asm/types.h> uses __attribute__((packed,aligned(4))) on +// S390. #define packed 1 +#endif #define pure 1 // glibc's sysdeps/unix/sysv/linux/arm/sys/ucontext.h uses this on ARM. #ifndef __arm__ diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++2014/all_attributes.cc b/libstdc++-v3/testsuite/17_intro/headers/c++2014/all_attributes.cc index befc1ca8bfb..80d0852453b 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++2014/all_attributes.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++2014/all_attributes.cc @@ -29,7 +29,11 @@ # define visibility 1 #endif #define no_unique_address 1 +#ifndef __s390__ +// kernel-headers <asm/types.h> uses __attribute__((packed,aligned(4))) on +// S390. #define packed 1 +#endif #define pure 1 // glibc's sysdeps/unix/sysv/linux/arm/sys/ucontext.h uses this on ARM. #ifndef __arm__ diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++2017/all_attributes.cc b/libstdc++-v3/testsuite/17_intro/headers/c++2017/all_attributes.cc index a59fe1be5fa..4f8ba4d10ba 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++2017/all_attributes.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++2017/all_attributes.cc @@ -28,7 +28,11 @@ # define visibility 1 #endif #define no_unique_address 1 +#ifndef __s390__ +// kernel-headers <asm/types.h> uses __attribute__((packed,aligned(4))) on +// S390. #define packed 1 +#endif #define pure 1 // glibc's sysdeps/unix/sysv/linux/arm/sys/ucontext.h uses this on ARM. #ifndef __arm__ diff --git a/libstdc++-v3/testsuite/17_intro/headers/c++2020/all_attributes.cc b/libstdc++-v3/testsuite/17_intro/headers/c++2020/all_attributes.cc index 0c54ab6421d..3de1488a737 100644 --- a/libstdc++-v3/testsuite/17_intro/headers/c++2020/all_attributes.cc +++ b/libstdc++-v3/testsuite/17_intro/headers/c++2020/all_attributes.cc @@ -27,7 +27,11 @@ # define cold 1 # define visibility 1 #endif +#ifndef __s390__ +// kernel-headers <asm/types.h> uses __attribute__((packed,aligned(4))) on +// S390. #define packed 1 +#endif #define pure 1 // glibc's sysdeps/unix/sysv/linux/arm/sys/ucontext.h uses this on ARM. #ifndef __arm__ diff --git a/libstdc++-v3/testsuite/17_intro/names.cc b/libstdc++-v3/testsuite/17_intro/names.cc index 784da9a7352..9b0ffcb50b2 100644 --- a/libstdc++-v3/testsuite/17_intro/names.cc +++ b/libstdc++-v3/testsuite/17_intro/names.cc @@ -270,6 +270,12 @@ #undef u #endif +#if defined (__linux__) && defined (__s390__) +// <sys/ucontext.h> defines fpreg_t::d and fpreg_t::f +#undef d +#undef f +#endif + #if defined (__linux__) && defined (__sparc__) #undef y #endif diff --git a/libstdc++-v3/testsuite/experimental/simd/pr114803_vecbuiltin_cvt.cc b/libstdc++-v3/testsuite/experimental/simd/pr114803_vecbuiltin_cvt.cc new file mode 100644 index 00000000000..103dd19394c --- /dev/null +++ b/libstdc++-v3/testsuite/experimental/simd/pr114803_vecbuiltin_cvt.cc @@ -0,0 +1,105 @@ +// { dg-options "-std=gnu++17" } +// { dg-do compile { target c++17 } } + +#include <experimental/simd> + +template <typename T> + void + maybe_test() + { + using V = std::experimental::simd<T, std::experimental::simd_abi::_VecBuiltin<16>>; + if constexpr (std::is_destructible_v<V>) + { + using V2 [[gnu::vector_size(16)]] = T; + V x = {}; + V2 x2 = static_cast<V2>(x); + x = static_cast<V>(x2); + for (unsigned i = 0; i < V::size(); ++i) + { + if (x2[i] != 0) + __builtin_abort(); + } +#ifdef __SSE__ + if constexpr (std::is_same_v<T, float>) + x = static_cast<V>(static_cast<__m128>(x)); + else if constexpr (std::is_same_v<T, double>) + x = static_cast<V>(static_cast<__m128d>(x)); + else if constexpr (std::is_integral_v<T>) + x = static_cast<V>(static_cast<__m128i>(x)); +#elif __ALTIVEC__ + if constexpr (std::is_same_v<T, float>) + x = static_cast<V>(static_cast<__vector float>(x)); +#ifdef __VSX__ + else if constexpr (std::is_same_v<T, double>) + x = static_cast<V>(static_cast<__vector double>(x)); +#endif + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(signed char) + && std::is_signed_v<T>) + x = static_cast<V>(static_cast<__vector signed char>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(signed char)) + x = static_cast<V>(static_cast<__vector unsigned char>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(short) + && std::is_signed_v<T>) + x = static_cast<V>(static_cast<__vector signed short>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(short)) + x = static_cast<V>(static_cast<__vector unsigned short>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(int) + && std::is_signed_v<T>) + x = static_cast<V>(static_cast<__vector signed int>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(int)) + x = static_cast<V>(static_cast<__vector unsigned int>(x)); +#ifdef __VSX__ + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(long long) + && std::is_signed_v<T>) + x = static_cast<V>(static_cast<__vector signed long long>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(long long)) + x = static_cast<V>(static_cast<__vector unsigned long long>(x)); +#endif +#elif __ARM_NEON + if constexpr (std::is_same_v<T, float>) + x = static_cast<V>(static_cast<float32x4_t>(x)); +#ifdef __aarch64__ + else if constexpr (std::is_same_v<T, double>) + x = static_cast<V>(static_cast<float64x2_t>(x)); +#endif + else if constexpr (std::is_integral_v<T> && sizeof(T) == 1 && std::is_signed_v<T>) + x = static_cast<V>(static_cast<int8x16_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 1) + x = static_cast<V>(static_cast<uint8x16_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 2 && std::is_signed_v<T>) + x = static_cast<V>(static_cast<int16x8_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 2) + x = static_cast<V>(static_cast<uint16x8_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 4 && std::is_signed_v<T>) + x = static_cast<V>(static_cast<int32x4_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 4) + x = static_cast<V>(static_cast<uint32x4_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 8 && std::is_signed_v<T>) + x = static_cast<V>(static_cast<int64x2_t>(x)); + else if constexpr (std::is_integral_v<T> && sizeof(T) == 8) + x = static_cast<V>(static_cast<uint64x2_t>(x)); +#endif + } + } + +int main() +{ + maybe_test<char>(); + maybe_test<wchar_t>(); + maybe_test<char16_t>(); + maybe_test<char32_t>(); + + maybe_test<signed char>(); + maybe_test<unsigned char>(); + maybe_test<short>(); + maybe_test<unsigned short>(); + maybe_test<int>(); + maybe_test<unsigned int>(); + maybe_test<long>(); + maybe_test<unsigned long>(); + maybe_test<long long>(); + maybe_test<unsigned long long>(); + maybe_test<float>(); + maybe_test<double>(); + maybe_test<long double>(); +} diff --git a/libstdc++-v3/testsuite/lib/gdb-test.exp b/libstdc++-v3/testsuite/lib/gdb-test.exp index 31206f2fc32..2ec5596983d 100644 --- a/libstdc++-v3/testsuite/lib/gdb-test.exp +++ b/libstdc++-v3/testsuite/lib/gdb-test.exp @@ -194,8 +194,11 @@ proc gdb-test { marker {selector {}} {load_xmethods 0} } { set test_counter 0 remote_expect target [timeout_value] { - -re {^(type|\$([0-9]+)) = ([^\n\r]*)[\n\r]+} { - send_log "got: $expect_out(buffer)" + -re {^[\n\r]*(type|\$([0-9]+)) = ([^\n\r]*)[\n\r]+} { + # Escape newlines so that we can print them. + set escaped [string map {"\n" "\\n"} $expect_out(buffer)] + set escaped2 [string map {"\r" "\\r"} $escaped] + send_log "got: $escaped2" incr test_counter set first $expect_out(3,string) @@ -251,7 +254,10 @@ proc gdb-test { marker {selector {}} {load_xmethods 0} } { } -re {^[^$][^\n\r]*[\n\r]+} { - send_log "skipping: $expect_out(buffer)" + # Escape newlines so that we can print them. + set escaped [string map {"\n" "\\n"} $expect_out(buffer)] + set escaped2 [string map {"\r" "\\r"} $escaped] + send_log "skipping: $escaped2" exp_continue } diff --git a/libstdc++-v3/testsuite/std/format/functions/format.cc b/libstdc++-v3/testsuite/std/format/functions/format.cc index 4499397aaf9..78cc1ab482a 100644 --- a/libstdc++-v3/testsuite/std/format/functions/format.cc +++ b/libstdc++-v3/testsuite/std/format/functions/format.cc @@ -248,6 +248,14 @@ test_locale() s = std::format(cloc, "{:05L}", -1.0); // PR libstdc++/110968 VERIFY( s == "-0001" ); + // PR libstdc++/114863 grouping applied to nan and inf + double inf = std::numeric_limits<double>::infinity(); + s = std::format(eloc, "{0:Le} {0:Lf} {0:Lg}", -inf); + VERIFY( s == "-inf -inf -inf" ); + double nan = std::numeric_limits<double>::quiet_NaN(); + s = std::format(eloc, "{0:Le} {0:Lf} {0:Lg}", -nan); + VERIFY( s == "-nan -nan -nan" ); + // Restore std::locale::global(cloc); } diff --git a/libstdc++-v3/testsuite/std/time/tzdb/1.cc b/libstdc++-v3/testsuite/std/time/tzdb/1.cc index cf9df952577..796f3a8b425 100644 --- a/libstdc++-v3/testsuite/std/time/tzdb/1.cc +++ b/libstdc++-v3/testsuite/std/time/tzdb/1.cc @@ -47,6 +47,18 @@ test_locate() VERIFY( db.locate_zone(db.current_zone()->name()) == db.current_zone() ); } +void +test_all_zones() +{ + const tzdb& db = get_tzdb(); + + for (const auto& zone : db.zones) + VERIFY( locate_zone(zone.name())->name() == zone.name() ); + + for (const auto& link : db.links) + VERIFY( locate_zone(link.name()) == locate_zone(link.target()) ); +} + int main() { test_version(); diff --git a/libstdc++-v3/testsuite/std/time/tzdb/links.cc b/libstdc++-v3/testsuite/std/time/tzdb/links.cc new file mode 100644 index 00000000000..0ba214846c6 --- /dev/null +++ b/libstdc++-v3/testsuite/std/time/tzdb/links.cc @@ -0,0 +1,215 @@ +// { dg-do run { target c++20 } } +// { dg-require-effective-target tzdb } +// { dg-require-effective-target cxx11_abi } +// { dg-xfail-run-if "no weak override on AIX" { powerpc-ibm-aix* } } + +#include <chrono> +#include <fstream> +#include <testsuite_hooks.h> + +static bool override_used = false; + +namespace __gnu_cxx +{ + const char* zoneinfo_dir_override() { + override_used = true; + return "./"; + } +} + +using namespace std::chrono; + +void +test_link_chains() +{ + std::ofstream("tzdata.zi") << R"(# version test_1 +Link Greenwich G_M_T +Link Etc/GMT Greenwich +Zone Etc/GMT 0 - GMT +Zone A_Zone 1 - ZON +Link A_Zone L1 +Link L1 L2 +Link L2 L3 +Link L3 L4 +Link L4 L5 +Link L5 L6 +Link L3 L7 +)"; + + const auto& db = reload_tzdb(); + VERIFY( override_used ); // If this fails then XFAIL for the target. + VERIFY( db.version == "test_1" ); + + // Simple case of a link with a zone as its target. + VERIFY( locate_zone("Greenwich")->name() == "Etc/GMT" ); + // Chains of links, where the target may be another link. + VERIFY( locate_zone("G_M_T")->name() == "Etc/GMT" ); + VERIFY( locate_zone("L1")->name() == "A_Zone" ); + VERIFY( locate_zone("L2")->name() == "A_Zone" ); + VERIFY( locate_zone("L3")->name() == "A_Zone" ); + VERIFY( locate_zone("L4")->name() == "A_Zone" ); + VERIFY( locate_zone("L5")->name() == "A_Zone" ); + VERIFY( locate_zone("L6")->name() == "A_Zone" ); + VERIFY( locate_zone("L7")->name() == "A_Zone" ); +} + +void +test_bad_links() +{ + // The zic(8) man page says + // > the behavior is unspecified if multiple zone or link lines + // > define the same name" + // For libstdc++ the expected behaviour is described and tested below. + std::ofstream("tzdata.zi") << R"(# version test_2 +Zone A_Zone 1 - ZA +Zone B_Zone 2 - ZB +Link A_Zone B_Zone +Link B_Zone C_Link +Link C_Link D_Link +Link D_Link E_Link +)"; + + const auto& db2 = reload_tzdb(); + VERIFY( override_used ); // If this fails then XFAIL for the target. + VERIFY( db2.version == "test_2" ); + + // The standard requires locate_zone(name) to search for a zone first, + // so this finds the zone B_Zone, not the link that points to zone A_Zone. + VERIFY( locate_zone("B_Zone")->name() == "B_Zone" ); + // And libstdc++ does the same at every step when following chained links: + VERIFY( locate_zone("C_Link")->name() == "B_Zone" ); + VERIFY( locate_zone("D_Link")->name() == "B_Zone" ); + VERIFY( locate_zone("E_Link")->name() == "B_Zone" ); + + // The zic(8) man page says + // > the behavior is unspecified if a chain of one or more links + // > does not terminate in a Zone name. + // For libstdc++ we throw std::runtime_error if locate_zone finds an + // unterminated chain, including the case of a chain that includes a cycle. + std::ofstream("tzdata.zi") << R"(# version test_3 +Zone A_Zone 1 - ZON +Link A_Zone GoodLink +Link No_Zone BadLink +Link LinkSelf LinkSelf +Link LinkSelf Link1 +Link Link1 Link2 +Link Cycle2_A Cycle2_B +Link Cycle2_B Cycle2_A +Link Cycle3_A Cycle3_B +Link Cycle3_B Cycle3_C +Link Cycle3_C Cycle3_A +Link Cycle3_C Cycle3_D +Link Cycle4_A Cycle4_B +Link Cycle4_B Cycle4_C +Link Cycle4_C Cycle4_D +Link Cycle4_D Cycle4_A +)"; + + const auto& db3 = reload_tzdb(); + VERIFY( db3.version == "test_3" ); + + // Lookup for valid links should still work even if other links are bad. + VERIFY( locate_zone("GoodLink")->name() == "A_Zone" ); + +#if __cpp_exceptions + try { + locate_zone("BadLink"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("cannot locate zone: BadLink") ); + } + + // LinkSelf forms a link cycle with itself. + try { + locate_zone("LinkSelf"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: LinkSelf") ); + } + + // Any chain that leads to LinkSelf reaches a cycle. + try { + locate_zone("Link1"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Link1") ); + } + + try { + locate_zone("Link2"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Link2") ); + } + + // Cycle2_A and Cycle2_B form a cycle of length two. + try { + locate_zone("Cycle2_A"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle2_A") ); + } + + try { + locate_zone("Cycle2_B"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle2_B") ); + } + + // Cycle3_A, Cycle3_B and Cycle3_C form a cycle of length three. + try { + locate_zone("Cycle3_A"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle3_A") ); + } + + try { + locate_zone("Cycle3_B"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle3_B") ); + } + + try { + locate_zone("Cycle3_C"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle3_C") ); + } + + // Cycle3_D isn't part of the cycle, but it leads to it. + try { + locate_zone("Cycle3_D"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle3_D") ); + } + + // Cycle4_* links form a cycle of length four. + try { + locate_zone("Cycle4_A"); + VERIFY( false ); + } catch (const std::runtime_error& e) { + std::string_view what(e.what()); + VERIFY( what.ends_with("link cycle: Cycle4_A") ); + } +#endif +} + +int main() +{ + test_link_chains(); + test_bad_links(); +} diff --git a/maintainer-scripts/ChangeLog b/maintainer-scripts/ChangeLog index 5608e52f459..d54d685b3e9 100644 --- a/maintainer-scripts/ChangeLog +++ b/maintainer-scripts/ChangeLog @@ -1,3 +1,8 @@ +2024-04-26 Jakub Jelinek <jakub@redhat.com> + + * crontab: Snapshots from trunk are now GCC 15 related. + Add GCC 14 snapshots from the respective branch. + 2023-11-14 Sam James <sam@gentoo.org> * gcc_release: Cleanup whitespace. diff --git a/maintainer-scripts/crontab b/maintainer-scripts/crontab index 6fedb5d1ef5..322778ab23f 100644 --- a/maintainer-scripts/crontab +++ b/maintainer-scripts/crontab @@ -1,7 +1,8 @@ 16 0 * * * sh /home/gccadmin/scripts/update_version_git 50 0 * * * sh /home/gccadmin/scripts/update_web_docs_git 55 0 * * * sh /home/gccadmin/scripts/update_web_docs_libstdcxx_git -32 22 * * 4 sh /home/gccadmin/scripts/gcc_release -s 11:releases/gcc-11 -l -d /sourceware/snapshot-tmp/gcc all -32 22 * * 5 sh /home/gccadmin/scripts/gcc_release -s 12:releases/gcc-12 -l -d /sourceware/snapshot-tmp/gcc all -32 22 * * 6 sh /home/gccadmin/scripts/gcc_release -s 13:releases/gcc-13 -l -d /sourceware/snapshot-tmp/gcc all -32 22 * * 7 sh /home/gccadmin/scripts/gcc_release -s 14:master -l -d /sourceware/snapshot-tmp/gcc all +32 22 * * 3 sh /home/gccadmin/scripts/gcc_release -s 11:releases/gcc-11 -l -d /sourceware/snapshot-tmp/gcc all +32 22 * * 4 sh /home/gccadmin/scripts/gcc_release -s 12:releases/gcc-12 -l -d /sourceware/snapshot-tmp/gcc all +32 22 * * 5 sh /home/gccadmin/scripts/gcc_release -s 13:releases/gcc-13 -l -d /sourceware/snapshot-tmp/gcc all +32 22 * * 6 sh /home/gccadmin/scripts/gcc_release -s 14:releases/gcc-14 -l -d /sourceware/snapshot-tmp/gcc all +32 22 * * 7 sh /home/gccadmin/scripts/gcc_release -s 15:master -l -d /sourceware/snapshot-tmp/gcc all |