diff options
| author | Iain Sandoe <iain@sandoe.co.uk> | 2022-04-29 17:54:39 +0100 |
|---|---|---|
| committer | Iain Sandoe <iain@sandoe.co.uk> | 2022-04-29 17:54:39 +0100 |
| commit | 3e5f7ca352c26a222bb588741b7c700a3052a372 (patch) | |
| tree | 283aec084274668fe34c23c49ab2999390ed9778 | |
| parent | 2ce0608ca3dca30518bec525c435f7bc4d7f9b70 (diff) | |
| parent | b85e79dce149df68b92ef63ca2a40ff1dfa61396 (diff) | |
Merge master r12-8312.devel/c++-coroutines
* Merge master r12-8312-gb85e79dce149.
611 files changed, 20223 insertions, 4887 deletions
diff --git a/ChangeLog b/ChangeLog index bbb29b0955c..55fedd0b485 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2022-04-19 Richard Henderson <rth@gcc.gnu.org> + + * MAINTAINERS: Update my email address. + 2022-04-01 Qian Jianhua <qianjh@fujitsu.com> * MAINTAINERS: Update my email address. diff --git a/MAINTAINERS b/MAINTAINERS index 30f81b3dd52..15973503722 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -53,7 +53,7 @@ aarch64 port Richard Earnshaw <richard.earnshaw@arm.com> aarch64 port Richard Sandiford <richard.sandiford@arm.com> aarch64 port Marcus Shawcroft <marcus.shawcroft@arm.com> aarch64 port Kyrylo Tkachov <kyrylo.tkachov@arm.com> -alpha port Richard Henderson <rth@twiddle.net> +alpha port Richard Henderson <rth@gcc.gnu.org> amdgcn port Julian Brown <julian@codesourcery.com> amdgcn port Andrew Stubbs <ams@codesourcery.com> arc port Joern Rennecke <gnu@amylaar.uk> diff --git a/contrib/ChangeLog b/contrib/ChangeLog index 4ba5286e94a..c35edcc0e44 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,13 @@ +2022-04-25 Martin Liska <mliska@suse.cz> + + * filter-clang-warnings.py: Filter out + -Wc++20-attribute-extensions in lex.cc. + +2022-04-25 Martin Liska <mliska@suse.cz> + + * filter-clang-warnings.py: Filter out + -Wbitwise-instead-of-logical. + 2022-04-04 Martin Liska <mliska@suse.cz> * gcc-changelog/git_update_version.py: Ignore the revision. diff --git a/contrib/filter-clang-warnings.py b/contrib/filter-clang-warnings.py index e00570b42cf..942cd30b659 100755 --- a/contrib/filter-clang-warnings.py +++ b/contrib/filter-clang-warnings.py @@ -38,7 +38,8 @@ def skip_warning(filename, message): 'when in C++ mode, this behavior is deprecated', '-Wignored-attributes', '-Wgnu-zero-variadic-macro-arguments', '-Wformat-security', '-Wundefined-internal', - '-Wunknown-warning-option', '-Wc++20-extensions'], + '-Wunknown-warning-option', '-Wc++20-extensions', + '-Wbitwise-instead-of-logical'], 'insn-modes.cc': ['-Wshift-count-overflow'], 'insn-emit.cc': ['-Wtautological-compare'], 'insn-attrtab.cc': ['-Wparentheses-equality'], @@ -52,7 +53,8 @@ def skip_warning(filename, message): 'genautomata.cc': ['-Wstring-plus-int'], 'fold-const-call.cc': ['-Wreturn-type'], 'gfortran.texi': [''], - 'libtool': [''] + 'libtool': [''], + 'lex.cc': ['-Wc++20-attribute-extensions'], } for name, ignores in ignores.items(): diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8376a11537d..a93b56ce00d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,838 @@ +2022-04-27 Lulu Cheng <chenglulu@loongson.cn> + + * config/loongarch/loongarch.md: Add fdiv define_expand template, + then generate floating-point division and floating-point reciprocal + instructions. + +2022-04-27 Lulu Cheng <chenglulu@loongson.cn> + + * config/loongarch/loongarch.md: Add '(clobber (mem:BLK (scratch)))' + to PLV instruction templates. + +2022-04-27 Richard Biener <rguenther@suse.de> + + PR middle-end/104492 + * gimple-ssa-warn-access.cc + (pass_waccess::warn_invalid_pointer): Exclude equality compare + diagnostics for all kind of invalidations. + (pass_waccess::check_dangling_uses): Fix post-dominator query. + (pass_waccess::check_pointer_uses): Likewise. + +2022-04-27 Andreas Krebbel <krebbel@linux.ibm.com> + + PR target/102024 + * config/s390/s390-protos.h (s390_function_arg_vector): Remove + prototype. + * config/s390/s390.cc (s390_single_field_struct_p): New function. + (s390_function_arg_vector): Invoke s390_single_field_struct_p. + (s390_function_arg_float): Likewise. + +2022-04-27 Jakub Jelinek <jakub@redhat.com> + + PR sanitizer/105396 + * asan.cc (asan_redzone_buffer::emit_redzone_byte): Handle the case + where offset is bigger than off but smaller than m_prev_offset + 32 + bits by pushing one or more 0 bytes. Sink the + m_shadow_bytes.safe_push (value); flush_if_full (); statements from + all cases to the end of the function. + +2022-04-27 Kewen Lin <linkw@linux.ibm.com> + + PR target/105271 + * config/rs6000/rs6000-builtins.def (NEG_V2DI): Move to [power8-vector] + stanza. + +2022-04-26 Thomas Schwinge <thomas@codesourcery.com> + + * config/gcn/gcn.cc (gcn_print_lds_decl): Make "gang-private + data-share memory exhausted" error more verbose. + +2022-04-26 Martin Liska <mliska@suse.cz> + + PR lto/105364 + * lto-wrapper.cc (print_lto_docs_link): Use global_dc. + (run_gcc): Parse OPT_fdiagnostics_urls_. + (main): Initialize global_dc. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/105314 + * ifcvt.cc (noce_try_store_flag_mask): Don't require that the non-zero + operand is equal to if_info->x, instead use the non-zero operand + as one of the operands of AND with if_info->x as target. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105374 + * tree-ssa-reassoc.cc (eliminate_redundant_comparison): Punt if + !fold_convertible_p rather than assuming fold_convert must succeed. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR target/105367 + * config/i386/i386.cc (ix86_veclibabi_svml, ix86_veclibabi_acml): Pass + el_mode == DFmode ? double_type_node : float_type_node instead of + TREE_TYPE (type_in) as first arguments to mathfn_built_in. + +2022-04-25 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/104308 + * gimple-fold.cc (gimple_fold_builtin_memory_op): Explicitly set + the location of new_stmt in all places that don't already set it, + whether explicitly, or via a call to gsi_replace. + +2022-04-25 Paul A. Clarke <pc@us.ibm.com> + + * doc/extend.texi (Other Builtins): Correct reference to 'modff'. + +2022-04-25 Andrew MacLeod <amacleod@redhat.com> + + PR tree-optimization/105276 + * gimple-range.cc (gimple_ranger::prefill_stmt_dependencies): Include + existing global range with calculated value. + +2022-04-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105368 + * tree-ssa-math-opts.cc (powi_cost): Use absu_hwi. + +2022-04-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/100810 + * tree-ssa-loop-ivopts.cc (struct iv_cand): Add involves_undefs flag. + (find_ssa_undef): New function. + (add_candidate_1): Avoid adding derived candidates with + undefined SSA names and mark the original ones. + (determine_group_iv_cost_generic): Reject rewriting + uses with a different IV when that involves undefined SSA names. + +2022-04-25 Steven G. Kargl <kargl@gcc.gnu.org> + + PR target/89125 + * config/freebsd.h: Define TARGET_LIBC_HAS_FUNCTION to be + bsd_libc_has_function. + * targhooks.cc (bsd_libc_has_function): New function. + Expand the supported math functions to inclue C99 libm. + * targhooks.h (bsd_libc_has_function): New Prototype. + +2022-04-25 Richard Biener <rguenther@suse.de> + + PR rtl-optimization/105231 + * combine.cc (distribute_notes): Assert that a REG_EH_REGION + with landing pad > 0 is from i3. Put any REG_EH_REGION note + on i3 or drop it if the insn can not trap. + (try_combine): Ensure that we can merge REG_EH_REGION notes + with non-call exceptions. Ensure we are not splitting a + trapping part of an insn with non-call exceptions when there + is any REG_EH_REGION note to preserve. + +2022-04-25 Hongyu Wang <hongyu.wang@intel.com> + + PR target/105339 + * config/i386/avx512fintrin.h (_mm512_scalef_round_pd): + Add parentheses for parameters and djust format. + (_mm512_mask_scalef_round_pd): Ditto. + (_mm512_maskz_scalef_round_pd): Ditto. + (_mm512_scalef_round_ps): Ditto. + (_mm512_mask_scalef_round_ps): Ditto. + (_mm512_maskz_scalef_round_ps): Ditto. + (_mm_scalef_round_sd): Use _mm_undefined_pd. + (_mm_scalef_round_ss): Use _mm_undefined_ps. + (_mm_mask_scalef_round_sd): New macro. + (_mm_mask_scalef_round_ss): Ditto. + (_mm_maskz_scalef_round_sd): Ditto. + (_mm_maskz_scalef_round_ss): Ditto. + +2022-04-23 Jakub Jelinek <jakub@redhat.com> + + PR target/105338 + * config/i386/i386-expand.cc (ix86_expand_int_movcc): Handle + op0 == cst1 ? op0 : op3 like op0 == cst1 ? cst1 : op3 for the non-cmov + cases. + +2022-04-22 Segher Boessenkool <segher@kernel.crashing.org> + + PR target/105334 + * config/rs6000/rs6000.md (pack<mode> for FMOVE128): New expander. + (pack<mode> for FMOVE128): Rename and split the insn_and_split to... + (pack<mode>_hard for FMOVE128): ... this... + (pack<mode>_soft for FMOVE128): ... and this. + +2022-04-22 Paul A. Clarke <pc@us.ibm.com> + + * doc/extend.texi: Correct "This" to "These". + +2022-04-22 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/105333 + * rtlanal.cc (replace_rtx): Use simplify_subreg or + simplify_unary_operation if CONST_SCALAR_INT_P rather than just + CONST_INT_P. + +2022-04-21 Segher Boessenkool <segher@kernel.crashing.org> + + PR target/103197 + PR target/102146 + * config/rs6000/rs6000.md (zero_extendqi<mode>2 for EXTQI): Disparage + the "Z" alternatives in {l,st}{f,xs}iwzx. + (zero_extendhi<mode>2 for EXTHI): Ditto. + (zero_extendsi<mode>2 for EXTSI): Ditto. + (*movsi_internal1): Ditto. + (*mov<mode>_internal1 for QHI): Ditto. + (movsd_hardfloat): Ditto. + +2022-04-21 Martin Liska <mliska@suse.cz> + + * configure.ac: Enable compressed debug sections for mold + linker. + * configure: Regenerate. + +2022-04-21 Jakub Jelinek <jakub@redhat.com> + + PR debug/105203 + * emit-rtl.cc (emit_copy_of_insn_after): Don't call mark_jump_label + on DEBUG_INSNs. + +2022-04-20 Richard Biener <rguenther@suse.de> + + PR tree-optimization/104912 + * tree-vect-loop-manip.cc (vect_loop_versioning): Split + the cost model check to a separate BB to make sure it is + checked first and not combined with other version checks. + +2022-04-20 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105312 + * gimple-isel.cc (gimple_expand_vec_cond_expr): Query both + VCOND and VCONDU for EQ and NE. + +2022-04-20 Jan Hubicka <hubicka@ucw.cz> + + PR ipa/103818 + * ipa-modref-tree.cc (modref_access_node::closer_pair_p): Use + poly_offset_int to avoid overflow. + (modref_access_node::update2): likewise. + +2022-04-20 Jakub Jelinek <jakub@redhat.com> + + PR ipa/105306 + * cgraph.cc (cgraph_node::create): Set node->semantic_interposition + to opt_for_fn (decl, flag_semantic_interposition). + * cgraphclones.cc (cgraph_node::create_clone): Copy over + semantic_interposition flag. + +2022-04-19 Sergei Trofimovich <siarheit@google.com> + + PR gcov-profile/105282 + * value-prof.cc (stream_out_histogram_value): Allow negative counts + on HIST_TYPE_INDIR_CALL. + +2022-04-19 Jakub Jelinek <jakub@redhat.com> + + PR target/105257 + * config/sparc/sparc.cc (epilogue_renumber): If ORIGINAL_REGNO, + use gen_raw_REG instead of gen_rtx_REG and copy over also + ORIGINAL_REGNO. Use return 0; instead of /* fallthrough */. + +2022-04-19 Richard Biener <rguenther@suse.de> + + PR tree-optimization/104010 + PR tree-optimization/103941 + * tree-vect-slp.cc (vect_bb_slp_scalar_cost): When + we run into stmts in patterns continue walking those + for uses outside of the vectorized region instead of + marking the lane live. + +2022-04-18 Hans-Peter Nilsson <hp@axis.com> + + * doc/install.texi <CRIS>: Remove references to removed websites and + adjust for cris-*-elf being the only remaining toolchain. + +2022-04-18 Hans-Peter Nilsson <hp@axis.com> + + * doc/invoke.texi <CRIS>: Remove references to options for removed + subtarget cris-axis-linux-gnu and tweak wording accordingly. + +2022-04-16 Gerald Pfeifer <gerald@pfeifer.com> + + * doc/install.texi (Specific): Adjust mingw-w64 download link. + +2022-04-15 Hongyu Wang <hongyu.wang@intel.com> + + * config/i386/smmintrin.h: Correct target pragma from sse4.1 + and sse4.2 to crc32 for crc32 intrinsics. + +2022-04-14 Indu Bhagat <indu.bhagat@oracle.com> + + PR debug/105089 + * ctfc.cc (ctf_dvd_ignore_insert): New function. + (ctf_dvd_ignore_lookup): Likewise. + (ctf_add_variable): Keep track of non-defining decl DIEs. + (new_ctf_container): Initialize the new hash-table. + (ctfc_delete_container): Empty hash-table. + * ctfc.h (struct ctf_container): Add new hash-table. + (ctf_dvd_ignore_lookup): New declaration. + (ctf_add_variable): Add additional argument. + * ctfout.cc (ctf_dvd_preprocess_cb): Skip adding CTF variable + record for non-defining decl for which a defining decl exists + in the same TU. + (ctf_preprocess): Defer updating the number of global objts + until here. + (output_ctf_header): Use ctfc_vars_list_count as some CTF + variables may not make it to the final output. + (output_ctf_vars): Likewise. + * dwarf2ctf.cc (gen_ctf_variable): Skip generating CTF variable + if this is known to be a non-defining decl DIE. + +2022-04-14 Indu Bhagat <indu.bhagat@oracle.com> + + * ctfc.h (struct ctf_container): Introduce a new member. + * ctfout.cc (ctf_list_add_ctf_vars): Use it instead of static + variable. + +2022-04-14 Jakub Jelinek <jakub@redhat.com> + + PR target/105247 + * simplify-rtx.cc (simplify_const_binary_operation): For shifts + or rotates by VOIDmode constant integer shift count use word_mode + for the operand if int_mode is narrower than word. + +2022-04-14 Robin Dapp <rdapp@linux.ibm.com> + + * config/s390/s390.cc (s390_get_sched_attrmask): Add z16. + (s390_get_unit_mask): Likewise. + (s390_is_fpd): Likewise. + (s390_is_fxd): Likewise. + * config/s390/s390.h (s390_tune_attr): Set max tune level to z16. + * config/s390/s390.md (z900,z990,z9_109,z9_ec,z10,z196,zEC12,z13,z14,z15): + Add z16. + (z900,z990,z9_109,z9_ec,z10,z196,zEC12,z13,z14,z15,z16): + Likewise. + * config/s390/3931.md: New file. + +2022-04-13 Richard Sandiford <richard.sandiford@arm.com> + + PR tree-optimization/105254 + * config/aarch64/aarch64.cc + (aarch64_vector_costs::determine_suggested_unroll_factor): Take a + loop_vec_info as argument. Restrict the unroll factor to values + that divide the VF. + (aarch64_vector_costs::finish_cost): Update call accordingly. + +2022-04-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105263 + * tree-ssa-reassoc.cc (try_special_add_to_ops): Do not consume + negates in multiplication chains with DFP. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/105253 + * tree.cc (tree_builtin_call_types_compatible_p): If PROP_gimple, + use useless_type_conversion_p checks instead of TYPE_MAIN_VARIANT + comparisons or tree_nop_conversion_p checks. + +2022-04-13 Hongyu Wang <hongyu.wang@intel.com> + + PR target/103069 + * config/i386/i386-expand.cc (ix86_expand_cmpxchg_loop): + Add missing set to target_val at pause label. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + PR target/105234 + * attribs.cc (decl_attributes): Don't set + DECL_FUNCTION_SPECIFIC_TARGET if target_option_default_node is + NULL. + +2022-04-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105250 + * fold-const.cc (fold_convertible_p): Revert + r12-7979-geaaf77dd85c333, instead check for size equality + of the vector types involved. + +2022-04-13 Richard Biener <rguenther@suse.de> + + Revert: + 2022-04-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/104912 + * tree-vect-loop-manip.cc (vect_loop_versioning): Split + the cost model check to a separate BB to make sure it is + checked first and not combined with other version checks. + +2022-04-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/104912 + * tree-vect-loop-manip.cc (vect_loop_versioning): Split + the cost model check to a separate BB to make sure it is + checked first and not combined with other version checks. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + * tree-scalar-evolution.cc (expression_expensive_p): Fix a comment typo. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104072 + * reginfo.cc: New functions (clear_global_regs_cache, + reginfo_cc_finalize) to avoid an issue where compiling the same + code multiple times gives an error about assigning the same + register to 2 global variables. + * rtl.h: New function (reginfo_cc_finalize). + * toplev.cc: Call it. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104071 + * toplev.cc: Call the new function tree_cc_finalize in + toplev::finalize. + * tree.cc: New functions (clear_nonstandard_integer_type_cache + and tree_cc_finalize) to clear the cache of non-standard integer + types to avoid having issues with some optimizations of + bitcast where the SSA_NAME will have a size of a cached + integer type that should have been invalidated, causing a + comparison of integer constant to fail. + * tree.h: New function (tree_cc_finalize). + +2022-04-12 Thomas Schwinge <thomas@codesourcery.com> + + PR target/97348 + * config/nvptx/nvptx.h (ASM_SPEC): Don't set. + * config/nvptx/nvptx.opt (misa): Adjust comment. + +2022-04-12 Thomas Schwinge <thomas@codesourcery.com> + + Revert: + 2022-03-03 Tom de Vries <tdevries@suse.de> + + * config/nvptx/nvptx.h (ASM_SPEC): Add %{misa=sm_30:--no-verify}. + +2022-04-12 Thomas Schwinge <thomas@codesourcery.com> + + Revert: + 2022-03-31 Tom de Vries <tdevries@suse.de> + + * config/nvptx/nvptx.h (ASM_SPEC): Use "-m sm_35" for -misa=sm_30. + +2022-04-12 Richard Biener <rguenther@suse.de> + + PR ipa/104303 + * tree-ssa-dce.cc (mark_stmt_if_obviously_necessary): Do not + include local escaped memory as obviously necessary stores. + +2022-04-12 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105235 + * tree-ssa-math-opts.cc (execute_cse_conv_1): Clean EH and + return whether the CFG changed. + (execute_cse_sincos_1): Adjust. + +2022-04-12 Przemyslaw Wirkus <Przemyslaw.Wirkus@arm.com> + + PR target/104144 + * config/arm/t-aprofile (MULTI_ARCH_OPTS_A): Remove Armv9-a options. + (MULTI_ARCH_DIRS_A): Remove Armv9-a diretories. + (MULTILIB_REQUIRED): Don't require Armv9-a libraries. + (MULTILIB_MATCHES): Treat Armv9-a as equivalent to Armv8-a. + (MULTILIB_REUSE): Remove remap rules for Armv9-a. + * config/arm/t-multilib (v9_a_nosimd_variants): Delete. + (MULTILIB_MATCHES): Remove mappings for v9_a_nosimd_variants. + +2022-04-12 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105232 + * tree.cc (component_ref_size): Bail out for too large + or non-constant sizes. + +2022-04-12 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105226 + * tree-vect-loop-manip.cc (vect_loop_versioning): Verify + we can split the exit of an outer loop we choose to version. + +2022-04-12 Jakub Jelinek <jakub@redhat.com> + + * config/i386/i386-expand.cc (ix86_emit_i387_sinh, ix86_emit_i387_cosh, + ix86_emit_i387_tanh, ix86_emit_i387_asinh, ix86_emit_i387_acosh, + ix86_emit_i387_atanh, ix86_emit_i387_log1p, ix86_emit_i387_round, + ix86_emit_swdivsf, ix86_emit_swsqrtsf, + ix86_expand_atomic_fetch_op_loop, ix86_expand_cmpxchg_loop): + Formatting fix. + * config/i386/i386.cc (warn_once_call_ms2sysv_xlogues): Likewise. + +2022-04-12 Jakub Jelinek <jakub@redhat.com> + + PR target/105214 + * config/i386/i386-expand.cc (ix86_emit_i387_log1p): Call + do_pending_stack_adjust. + +2022-04-12 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/105211 + * builtins.cc (expand_builtin_int_roundingfn_2): If mathfn_built_in_1 + fails for TREE_TYPE (arg), retry it with + TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl))) and if even that + fails, emit call normally. + +2022-04-12 Andreas Krebbel <krebbel@linux.ibm.com> + + * common/config/s390/s390-common.cc: Rename PF_ARCH14 to PF_Z16. + * config.gcc: Add z16 as march/mtune switch. + * config/s390/driver-native.cc (s390_host_detect_local_cpu): + Recognize z16 with -march=native. + * config/s390/s390-opts.h (enum processor_type): Rename + PROCESSOR_ARCH14 to PROCESSOR_3931_Z16. + * config/s390/s390.cc (PROCESSOR_ARCH14): Rename to ... + (PROCESSOR_3931_Z16): ... throughout the file. + (s390_processor processor_table): Add z16 as cpu string. + * config/s390/s390.h (enum processor_flags): Rename PF_ARCH14 to + PF_Z16. + (TARGET_CPU_ARCH14): Rename to ... + (TARGET_CPU_Z16): ... this. + (TARGET_CPU_ARCH14_P): Rename to ... + (TARGET_CPU_Z16_P): ... this. + (TARGET_ARCH14): Rename to ... + (TARGET_Z16): ... this. + (TARGET_ARCH14_P): Rename to ... + (TARGET_Z16_P): ... this. + * config/s390/s390.md (cpu_facility): Rename arch14 to z16 and + check TARGET_Z16 instead of TARGET_ARCH14. + * config/s390/s390.opt: Add z16 to processor_type. + * doc/invoke.texi: Document z16 and arch14. + +2022-04-12 chenglulu <chenglulu@loongson.cn> + + * config/loongarch/loongarch.cc: Fix bug for + tmpdir-g++.dg-struct-layout-1/t033. + +2022-04-11 Peter Bergner <bergner@linux.ibm.com> + + PR target/104894 + * config/rs6000/rs6000.cc (rs6000_sibcall_aix): Handle pcrel sibcalls + to longcall functions. + +2022-04-11 Jason Merrill <jason@redhat.com> + + * ipa-free-lang-data.cc (free_lang_data_in_decl): Fix typos. + +2022-04-11 Segher Boessenkool <segher@kernel.crashing.org> + + PR target/105213 + PR target/103623 + * config/rs6000/rs6000.md (unpack<mode>_nodm): Add m,r,i alternative. + +2022-04-11 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105218 + * tree-ssa-phiopt.cc (value_replacement): If middle_bb has + more than one predecessor or phi's bb more than 2 predecessors, + reset phi result uses instead of adding a debug temp. + +2022-04-11 Kito Cheng <kito.cheng@sifive.com> + + PR target/104853 + * config.gcc: Pass -misa-spec to arch-canonicalize and + multilib-generator. + * config/riscv/arch-canonicalize: Adding -misa-spec option. + (SUPPORTED_ISA_SPEC): New. + (arch_canonicalize): New argument `isa_spec`. + Handle multiple ISA spec versions. + * config/riscv/multilib-generator: Adding -misa-spec option. + +2022-04-11 Kito Cheng <kito.cheng@sifive.com> + + * config/riscv/arch-canonicalize: Add TODO item. + (IMPLIED_EXT): Sync. + (arch_canonicalize): Checking until no change. + +2022-04-11 Tamar Christina <tamar.christina@arm.com> + + PR target/105197 + * tree-vect-stmts.cc (vectorizable_condition): Prevent cond swap when + not masked. + +2022-04-11 Jason Merrill <jason@redhat.com> + + PR c++/100370 + * pointer-query.cc (compute_objsize_r) [POINTER_PLUS_EXPR]: Require + deref == -1. + +2022-04-11 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/104639 + * tree-ssa-phiopt.cc: Include tree-ssa-propagate.h. + (value_replacement): Optimize (x != cst1 ? x : cst2) != cst3 + into x != cst3. + +2022-04-11 Jeff Law <jeffreyalaw@gmail.com> + + * config/bfin/bfin.md (rol_one): Fix pattern to indicate the + sign bit of the source ends up in CC. + +2022-04-09 Jan Hubicka <hubicka@ucw.cz> + + PR ipa/103376 + * cgraphunit.cc (cgraph_node::analyze): update semantic_interposition + flag. + +2022-04-09 Jan Hubicka <hubicka@ucw.cz> + + * ipa-modref.cc (ipa_merge_modref_summary_after_inlining): Propagate + nondeterministic and side_effects flags. + +2022-04-08 Andre Vieira <andre.simoesdiasvieira@arm.com> + + PR target/105157 + * config.gcc: Shift ext_mask by TARGET_CPU_NBITS. + * config/aarch64/aarch64.h (TARGET_CPU_NBITS): New macro. + (TARGET_CPU_MASK): Likewise. + (TARGET_CPU_DEFAULT): Use TARGET_CPU_NBITS. + * config/aarch64/aarch64.cc (aarch64_get_tune_cpu): Use TARGET_CPU_MASK. + (aarch64_get_arch): Likewise. + (aarch64_override_options): Use TARGET_CPU_NBITS. + +2022-04-08 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105198 + * tree-predcom.cc (find_looparound_phi): Check whether + the found memory location of the entry value is clobbered + inbetween the value we want to use and loop entry. + +2022-04-08 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105189 + * fold-const.cc (make_range_step): Fix up handling of + (unsigned) x +[low, -] ranges for signed x if low fits into + typeof (x). + +2022-04-08 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105175 + * tree-vect-stmts.cc (vectorizable_operation): Suppress + -Wvector-operation-performance if using emulated vectors. + * tree-vect-generic.cc (expand_vector_piecewise): Do not diagnose + -Wvector-operation-performance when suppressed. + (expand_vector_parallel): Likewise. + (expand_vector_comparison): Likewise. + (expand_vector_condition): Likewise. + (lower_vec_perm): Likewise. + (expand_vector_conversion): Likewise. + +2022-04-07 Tamar Christina <tamar.christina@arm.com> + + PR target/104409 + * config/aarch64/aarch64-builtins.cc (handle_arm_acle_h): New. + (aarch64_general_init_builtins): Move LS64 code. + * config/aarch64/aarch64-c.cc (aarch64_pragma_aarch64): Support + arm_acle.h + * config/aarch64/aarch64-protos.h (handle_arm_acle_h): New. + * config/aarch64/arm_acle.h: Add pragma GCC aarch64 "arm_acle.h". + +2022-04-07 Richard Biener <rguenther@suse.de> + Jan Hubicka <hubicka@ucw.cz> + + PR ipa/104303 + * tree-ssa-alias.h (ptr_deref_may_alias_global_p, + ref_may_alias_global_p, ref_may_alias_global_p, + stmt_may_clobber_global_p, pt_solution_includes_global): Add + bool parameters indicating whether escaped locals should be + considered global. + * tree-ssa-structalias.cc (pt_solution_includes_global): + When the new escaped_nonlocal_p flag is true also consider + pt->vars_contains_escaped. + * tree-ssa-alias.cc (ptr_deref_may_alias_global_p): + Pass down new escaped_nonlocal_p flag. + (ref_may_alias_global_p): Likewise. + (stmt_may_clobber_global_p): Likewise. + (ref_may_alias_global_p_1): Likewise. For decls also + query the escaped solution if true. + (ref_may_access_global_memory_p): Remove. + (modref_may_conflict): Use ref_may_alias_global_p with + escaped locals considered global. + (ref_maybe_used_by_stmt_p): Adjust. + * ipa-fnsummary.cc (points_to_local_or_readonly_memory_p): + Likewise. + * tree-ssa-dse.cc (dse_classify_store): Likewise. + * trans-mem.cc (thread_private_new_memory): Likewise, but + consider escaped locals global. + * tree-ssa-dce.cc (mark_stmt_if_obviously_necessary): Likewise. + +2022-04-07 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105185 + * tree-ssa-sccvn.cc (visit_reference_op_call): Simplify + modref query again. + +2022-04-07 Tamar Christina <tamar.christina@arm.com> + + PR target/104049 + * config/aarch64/aarch64-simd.md + (aarch64_reduc_plus_internal<mode>): Fix RTL and rename to... + (reduc_plus_scal_<mode>): ... This. + (reduc_plus_scal_v4sf): Moved. + (aarch64_reduc_plus_internalv2si): Fix RTL and rename to... + (reduc_plus_scal_v2si): ... This. + +2022-04-07 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/102586 + * langhooks.h (struct lang_hooks_for_types): Add classtype_as_base + langhook. + * langhooks-def.h (LANG_HOOKS_CLASSTYPE_AS_BASE): Define. + (LANG_HOOKS_FOR_TYPES_INITIALIZER): Add it. + * gimple-fold.cc (clear_padding_type): Use ftype instead of + TREE_TYPE (field) some more. For artificial FIELD_DECLs without + name try the lang_hooks.types.classtype_as_base langhook and + if it returns non-NULL, use that instead of ftype for recursive call. + +2022-04-07 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105150 + * tree.cc (tree_builtin_call_types_compatible_p): New function. + (get_call_combined_fn): Use it. + +2022-04-07 Richard Biener <rguenther@suse.de> + + PR middle-end/105165 + * tree-complex.cc (expand_complex_asm): Sorry for asm goto + _Complex outputs. + +2022-04-07 liuhongt <hongtao.liu@intel.com> + + * config/i386/sse.md (<sse2_avx2>_andnot<mode>3_mask): + Removed. + (<sse>_andnot<mode>3<mask_name>): Disable V*HFmode patterns + for mask_applied. + (<code><mode>3<mask_name>): Ditto. + (*<code><mode>3<mask_name>): Ditto. + (VFB_128_256): Adjust condition of V8HF/V16HFmode according to + real instruction. + (VFB_512): Ditto. + (VFB): Ditto. + +2022-04-06 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/104985 + * combine.cc (struct undo): Add where.regno member. + (do_SUBST_MODE): Rename to ... + (subst_mode): ... this. Change first argument from rtx * into int, + operate on regno_reg_rtx[regno] and save regno into where.regno. + (SUBST_MODE): Remove. + (try_combine): Use subst_mode instead of SUBST_MODE, change first + argument from regno_reg_rtx[whatever] to whatever. For UNDO_MODE, use + regno_reg_rtx[undo->where.regno] instead of *undo->where.r. + (undo_to_marker): For UNDO_MODE, use regno_reg_rtx[undo->where.regno] + instead of *undo->where.r. + (simplify_set): Use subst_mode instead of SUBST_MODE, change first + argument from regno_reg_rtx[whatever] to whatever. + +2022-04-06 Jakub Jelinek <jakub@redhat.com> + + PR target/105069 + * config/sh/sh.opt (mdiv=): Add Save. + +2022-04-06 Martin Liska <mliska@suse.cz> + + PR driver/105096 + * common.opt: Document properly based on what it does. + * gcc.cc (display_help): Unify with what we have in common.opt. + * opts.cc (common_handle_option): Do not print undocumented + options. + +2022-04-06 Xi Ruoyao <xry111@mengyan1223.wang> + + * config/mips/mips.cc (mips_fpr_return_fields): Ignore + cxx17_empty_base_field_p fields and set an indicator. + (mips_return_in_msb): Adjust for mips_fpr_return_fields change. + (mips_function_value_1): Inform psABI change about C++17 empty + bases. + +2022-04-06 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105150 + * gimple.cc (gimple_builtin_call_types_compatible_p): Use + builtin_decl_explicit here... + (gimple_call_builtin_p, gimple_call_combined_fn): ... rather than + here. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105173 + * tree-ssa-reassoc.cc (find_insert_point): Get extra + insert_before output argument and compute it. + (insert_stmt_before_use): Adjust. + (rewrite_expr_tree): Likewise. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR ipa/105166 + * ipa-modref-tree.cc (modref_access_node::get_ao_ref ): Bail + out for non-pointer arguments. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105163 + * tree-ssa-reassoc.cc (repropagate_negates): Avoid propagating + negated abnormals. + +2022-04-06 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105150 + * gimple.cc (gimple_call_builtin_p, gimple_call_combined_fn): + For BUILT_IN_NORMAL calls, call gimple_builtin_call_types_compatible_p + preferrably on builtin_decl_explicit decl rather than fndecl. + * tree-ssa-strlen.cc (valid_builtin_call): Don't call + gimple_builtin_call_types_compatible_p here. + +2022-04-06 Richard Sandiford <richard.sandiford@arm.com> + + PR tree-optimization/103761 + * tree-vect-stmts.cc (check_load_store_for_partial_vectors): Replace + the ncopies parameter with an slp_node parameter. Calculate the + number of vectors based on it and vectype. Rename lambda to + group_memory_nvectors. + (vectorizable_store, vectorizable_load): Update calls accordingly. + +2022-04-06 Martin Liska <mliska@suse.cz> + + * doc/invoke.texi: Document it. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105148 + * tree-ssa-loop-ivopts.cc (idx_record_use): Walk raw operands + 2 and 3 of ARRAY_REFs. + +2022-04-06 Roger Sayle <roger@nextmovesoftware.com> + + * config/i386/sse.md (ANDNOT_MODE): New mode iterator for TF and V1TI. + (*andnottf3): Replace with... + (*andnot<mode>3): New define_insn using ANDNOT_MODE. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105142 + * gimple-fold.h (maybe_fold_and_comparisons): Add defaulted + basic-block parameter. + (maybe_fold_or_comparisons): Likewise. + * gimple-fold.cc (follow_outer_ssa_edges): New. + (maybe_fold_comparisons_from_match_pd): Use follow_outer_ssa_edges + when an outer condition basic-block is specified. + (and_comparisons_1, and_var_with_comparison, + and_var_with_comparison_1, or_comparisons_1, + or_var_with_comparison, or_var_with_comparison_1): Receive and pass + down the outer condition basic-block. + * tree-ssa-ifcombine.cc (ifcombine_ifandif): Pass down the + basic-block of the outer condition. + +2022-04-06 Kewen Lin <linkw@linux.ibm.com> + + PR target/105002 + * config/rs6000/rs6000.cc (rs6000_maybe_emit_maxc_minc): Support more + comparison codes UNLT/UNLE/UNGT/UNGE. + 2022-04-05 David Malcolm <dmalcolm@redhat.com> * doc/extend.texi (Common Function Attributes): Document that diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index d9e2507b6b2..04ee20dc4e2 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20220406 +20220428 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 932a666a38f..3a7b8ed8f92 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,14 @@ +2022-04-27 Sebastian Huber <sebastian.huber@embedded-brains.de> + + * tracebak.c: Add support for ARM RTEMS. Add support for RTEMS to PPC + ELF. Add support for RTEMS to SPARC. Merge aarch64 support of Linux + and RTEMS. + +2022-04-27 Pierre-Marie de Rodat <derodat@adacore.com> + + PR ada/104027 + * gnat1drv.adb: Remove the goto End_Of_Program. + 2022-03-24 Pascal Obry <obry@adacore.com> PR ada/104767 diff --git a/gcc/ada/gnat1drv.adb b/gcc/ada/gnat1drv.adb index f85bc13414c..0a11619db9f 100644 --- a/gcc/ada/gnat1drv.adb +++ b/gcc/ada/gnat1drv.adb @@ -1429,11 +1429,6 @@ begin Ecode := E_Success; Back_End.Gen_Or_Update_Object_File; - -- Use a goto instead of calling Exit_Program so that finalization - -- occurs normally. - - goto End_Of_Program; - -- Otherwise the unit is missing a crucial piece that prevents code -- generation. diff --git a/gcc/ada/tracebak.c b/gcc/ada/tracebak.c index 54e547d2414..6cc5d301737 100644 --- a/gcc/ada/tracebak.c +++ b/gcc/ada/tracebak.c @@ -316,6 +316,13 @@ __gnat_backtrace (void **array, #define PC_ADJUST -2 #define USING_ARM_UNWINDING 1 +/*---------------------- ARM RTEMS ------------------------------------ -*/ +#elif (defined (__arm__) && defined (__rtems__)) + +#define USE_GCC_UNWINDER +#define PC_ADJUST -2 +#define USING_ARM_UNWINDING 1 + /*---------------------- PPC AIX/PPC Lynx 178/Older Darwin --------------*/ #elif ((defined (_POWER) && defined (_AIX)) || \ (defined (__powerpc__) && defined (__Lynx__) && !defined(__ELF__)) || \ @@ -370,11 +377,12 @@ extern void __runnit(); /* thread entry point. */ #define BASE_SKIP 1 -/*----------- PPC ELF (GNU/Linux & VxWorks & Lynx178e) -------------------*/ +/*----------- PPC ELF (GNU/Linux & VxWorks & Lynx178e & RTEMS ) ----------*/ #elif (defined (_ARCH_PPC) && defined (__vxworks)) || \ (defined (__powerpc__) && defined (__Lynx__) && defined(__ELF__)) || \ - (defined (__linux__) && defined (__powerpc__)) + (defined (__linux__) && defined (__powerpc__)) || \ + (defined (__powerpc__) && defined (__rtems__)) #if defined (_ARCH_PPC64) && !defined (__USING_SJLJ_EXCEPTIONS__) #define USE_GCC_UNWINDER @@ -404,9 +412,9 @@ struct layout #define BASE_SKIP 1 -/*-------------------------- SPARC Solaris -----------------------------*/ +/*-------------------------- SPARC Solaris or RTEMS --------------------*/ -#elif defined (__sun__) && defined (__sparc__) +#elif (defined (__sun__) || defined (__rtems__)) && defined (__sparc__) #define USE_GENERIC_UNWINDER @@ -551,21 +559,9 @@ is_return_from(void *symbol_addr, void *ret_addr) #error Unhandled QNX architecture. #endif -/*---------------------------- RTEMS ---------------------------------*/ - -#elif defined (__rtems__) - -#define USE_GCC_UNWINDER - -#if defined (__aarch64__) -#define PC_ADJUST -4 -#else -#error Unhandled RTEMS architecture. -#endif - -/*------------------- aarch64-linux ----------------------------------*/ +/*------------------- aarch64-linux or aarch64-rtems -----------------*/ -#elif (defined (__aarch64__) && defined (__linux__)) +#elif (defined (__aarch64__) && (defined (__linux__) || defined (__rtems__))) #define USE_GCC_UNWINDER #define PC_ADJUST -4 diff --git a/gcc/analyzer/ChangeLog b/gcc/analyzer/ChangeLog index 123e8cbd554..9ab6169da21 100644 --- a/gcc/analyzer/ChangeLog +++ b/gcc/analyzer/ChangeLog @@ -1,3 +1,77 @@ +2022-04-25 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/105365 + PR analyzer/105366 + * svalue.cc + (cmp_cst): Rename to... + (cmp_csts_same_type): ...this. Convert all recursive calls to + calls to... + (cmp_csts_and_types): ....this new function. + (svalue::cmp_ptr): Update for renaming of cmp_cst + +2022-04-14 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/105264 + * region-model-reachability.cc (reachable_regions::handle_parm): + Use maybe_get_deref_base_region rather than just region_svalue, to + handle pointer arithmetic also. + * svalue.cc (svalue::maybe_get_deref_base_region): New. + * svalue.h (svalue::maybe_get_deref_base_region): New decl. + +2022-04-14 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/105252 + * svalue.cc (cmp_cst): When comparing VECTOR_CSTs, compare the + types of the encoded elements before calling cmp_cst on them. + +2022-04-09 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/103892 + * region-model-manager.cc + (region_model_manager::get_unknown_symbolic_region): New, + extracted from... + (region_model_manager::get_field_region): ...here. + (region_model_manager::get_element_region): Use it here. + (region_model_manager::get_offset_region): Likewise. + (region_model_manager::get_sized_region): Likewise. + (region_model_manager::get_cast_region): Likewise. + (region_model_manager::get_bit_range): Likewise. + * region-model.h + (region_model_manager::get_unknown_symbolic_region): New decl. + * region.cc (symbolic_region::symbolic_region): Handle sval_ptr + having NULL type. + (symbolic_region::dump_to_pp): Handle having NULL type. + +2022-04-07 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/102208 + * store.cc (binding_map::remove_overlapping_bindings): Add + "always_overlap" param, using it to generalize to the case where + we want to remove all bindings. Update "uncertainty" logic to + only record maybe-bound values for cases where there is a symbolic + write involved. + (binding_cluster::mark_region_as_unknown): Split param "reg" into + "reg_to_bind" and "reg_for_overlap". + (binding_cluster::maybe_get_compound_binding): Pass "false" to + binding_map::remove_overlapping_bindings new "always_overlap" param. + (binding_cluster::remove_overlapping_bindings): Determine + "always_overlap" and pass it to + binding_map::remove_overlapping_bindings. + (store::set_value): Pass uncertainty to remove_overlapping_bindings + call. Update for new param of + binding_cluster::mark_region_as_unknown, passing both the base + region of the iter_cluster, and the lhs_reg. + (store::mark_region_as_unknown): Update for new param of + binding_cluster::mark_region_as_unknown, passing "reg" for both. + (store::remove_overlapping_bindings): Add param "uncertainty", and + pass it on to call to + binding_cluster::remove_overlapping_bindings. + * store.h (binding_map::remove_overlapping_bindings): Add + "always_overlap" param. + (binding_cluster::mark_region_as_unknown): Split param "reg" into + "reg_to_bind" and "reg_for_overlap". + (store::remove_overlapping_bindings): Add param "uncertainty". + 2022-03-29 David Malcolm <dmalcolm@redhat.com> PR testsuite/105085 diff --git a/gcc/analyzer/region-model-manager.cc b/gcc/analyzer/region-model-manager.cc index 56d60768749..4ec275ecd43 100644 --- a/gcc/analyzer/region-model-manager.cc +++ b/gcc/analyzer/region-model-manager.cc @@ -1362,6 +1362,19 @@ region_model_manager::get_region_for_global (tree expr) return reg; } +/* Return the region for an unknown access of type REGION_TYPE, + creating it if necessary. + This is a symbolic_region, where the pointer is an unknown_svalue + of type ®ION_TYPE. */ + +const region * +region_model_manager::get_unknown_symbolic_region (tree region_type) +{ + tree ptr_type = region_type ? build_pointer_type (region_type) : NULL_TREE; + const svalue *unknown_ptr = get_or_create_unknown_svalue (ptr_type); + return get_symbolic_region (unknown_ptr); +} + /* Return the region that describes accessing field FIELD of PARENT, creating it if necessary. */ @@ -1372,12 +1385,7 @@ region_model_manager::get_field_region (const region *parent, tree field) /* (*UNKNOWN_PTR).field is (*UNKNOWN_PTR_OF_&FIELD_TYPE). */ if (parent->symbolic_for_unknown_ptr_p ()) - { - tree ptr_to_field_type = build_pointer_type (TREE_TYPE (field)); - const svalue *unknown_ptr_to_field - = get_or_create_unknown_svalue (ptr_to_field_type); - return get_symbolic_region (unknown_ptr_to_field); - } + return get_unknown_symbolic_region (TREE_TYPE (field)); field_region::key_t key (parent, field); if (field_region *reg = m_field_regions.get (key)) @@ -1397,6 +1405,10 @@ region_model_manager::get_element_region (const region *parent, tree element_type, const svalue *index) { + /* (UNKNOWN_PTR[IDX]) is (UNKNOWN_PTR). */ + if (parent->symbolic_for_unknown_ptr_p ()) + return get_unknown_symbolic_region (element_type); + element_region::key_t key (parent, element_type, index); if (element_region *reg = m_element_regions.get (key)) return reg; @@ -1416,6 +1428,10 @@ region_model_manager::get_offset_region (const region *parent, tree type, const svalue *byte_offset) { + /* (UNKNOWN_PTR + OFFSET) is (UNKNOWN_PTR). */ + if (parent->symbolic_for_unknown_ptr_p ()) + return get_unknown_symbolic_region (type); + /* If BYTE_OFFSET is zero, return PARENT. */ if (tree cst_offset = byte_offset->maybe_get_constant ()) if (zerop (cst_offset)) @@ -1451,6 +1467,9 @@ region_model_manager::get_sized_region (const region *parent, tree type, const svalue *byte_size_sval) { + if (parent->symbolic_for_unknown_ptr_p ()) + return get_unknown_symbolic_region (type); + if (byte_size_sval->get_type () != size_type_node) byte_size_sval = get_or_create_cast (size_type_node, byte_size_sval); @@ -1486,6 +1505,9 @@ region_model_manager::get_cast_region (const region *original_region, if (type == original_region->get_type ()) return original_region; + if (original_region->symbolic_for_unknown_ptr_p ()) + return get_unknown_symbolic_region (type); + cast_region::key_t key (original_region, type); if (cast_region *reg = m_cast_regions.get (key)) return reg; @@ -1558,6 +1580,9 @@ region_model_manager::get_bit_range (const region *parent, tree type, { gcc_assert (parent); + if (parent->symbolic_for_unknown_ptr_p ()) + return get_unknown_symbolic_region (type); + bit_range_region::key_t key (parent, type, bits); if (bit_range_region *reg = m_bit_range_regions.get (key)) return reg; diff --git a/gcc/analyzer/region-model-reachability.cc b/gcc/analyzer/region-model-reachability.cc index b876b8f0363..12d09c3e500 100644 --- a/gcc/analyzer/region-model-reachability.cc +++ b/gcc/analyzer/region-model-reachability.cc @@ -252,12 +252,8 @@ reachable_regions::handle_parm (const svalue *sval, tree param_type) m_mutable_svals.add (sval); else m_reachable_svals.add (sval); - if (const region_svalue *parm_ptr - = sval->dyn_cast_region_svalue ()) - { - const region *pointee_reg = parm_ptr->get_pointee (); - add (pointee_reg, is_mutable); - } + if (const region *base_reg = sval->maybe_get_deref_base_region ()) + add (base_reg, is_mutable); /* Treat all svalues within a compound_svalue as reachable. */ if (const compound_svalue *compound_sval = sval->dyn_cast_compound_svalue ()) diff --git a/gcc/analyzer/region-model.h b/gcc/analyzer/region-model.h index 23841718b5c..eff3d4930f9 100644 --- a/gcc/analyzer/region-model.h +++ b/gcc/analyzer/region-model.h @@ -327,6 +327,8 @@ public: const region *get_bit_range (const region *parent, tree type, const bit_range &bits); + const region *get_unknown_symbolic_region (tree region_type); + const region * get_region_for_unexpected_tree_code (region_model_context *ctxt, tree t, diff --git a/gcc/analyzer/region.cc b/gcc/analyzer/region.cc index 749e6182b06..1a7949b3f09 100644 --- a/gcc/analyzer/region.cc +++ b/gcc/analyzer/region.cc @@ -1016,7 +1016,9 @@ root_region::dump_to_pp (pretty_printer *pp, bool simple) const symbolic_region::symbolic_region (unsigned id, region *parent, const svalue *sval_ptr) : region (complexity::from_pair (parent, sval_ptr), id, parent, - TREE_TYPE (sval_ptr->get_type ())), + (sval_ptr->get_type () + ? TREE_TYPE (sval_ptr->get_type ()) + : NULL_TREE)), m_sval_ptr (sval_ptr) { } @@ -1045,8 +1047,11 @@ symbolic_region::dump_to_pp (pretty_printer *pp, bool simple) const { pp_string (pp, "symbolic_region("); get_parent_region ()->dump_to_pp (pp, simple); - pp_string (pp, ", "); - print_quoted_type (pp, get_type ()); + if (get_type ()) + { + pp_string (pp, ", "); + print_quoted_type (pp, get_type ()); + } pp_string (pp, ", "); m_sval_ptr->dump_to_pp (pp, simple); pp_string (pp, ")"); diff --git a/gcc/analyzer/store.cc b/gcc/analyzer/store.cc index 0014633c335..35f66a4b6fc 100644 --- a/gcc/analyzer/store.cc +++ b/gcc/analyzer/store.cc @@ -997,27 +997,61 @@ binding_map::get_overlapping_bindings (const binding_key *key, value: {BITS_WITHIN(bytes 4-7, inner_val: INIT_VAL((*INIT_VAL(p_33(D))).arr))} If UNCERTAINTY is non-NULL, use it to record any svalues that - were removed, as being maybe-bound. */ + were removed, as being maybe-bound. + + If ALWAYS_OVERLAP, then assume that DROP_KEY can overlap anything + in the map, due to one or both of the underlying clusters being + symbolic (but not the same symbolic region). Hence even if DROP_KEY is a + concrete binding it could actually be referring to the same memory as + distinct concrete bindings in the map. Remove all bindings, but + register any svalues with *UNCERTAINTY. */ void binding_map::remove_overlapping_bindings (store_manager *mgr, const binding_key *drop_key, - uncertainty_t *uncertainty) + uncertainty_t *uncertainty, + bool always_overlap) { + /* Get the bindings of interest within this map. */ auto_vec<const binding_key *> bindings; - get_overlapping_bindings (drop_key, &bindings); + if (always_overlap) + for (auto iter : *this) + bindings.safe_push (iter.first); /* Add all bindings. */ + else + /* Just add overlapping bindings. */ + get_overlapping_bindings (drop_key, &bindings); unsigned i; const binding_key *iter_binding; FOR_EACH_VEC_ELT (bindings, i, iter_binding) { + /* Record any svalues that were removed to *UNCERTAINTY as being + maybe-bound, provided at least some part of the binding is symbolic. + + Specifically, if at least one of the bindings is symbolic, or we + have ALWAYS_OVERLAP for the case where we have possibly aliasing + regions, then we don't know that the svalue has been overwritten, + and should record that to *UNCERTAINTY. + + However, if we have concrete keys accessing within the same symbolic + region, then we *know* that the symbolic region has been overwritten, + so we don't record it to *UNCERTAINTY, as this could be a genuine + leak. */ const svalue *old_sval = get (iter_binding); - if (uncertainty) + if (uncertainty + && (drop_key->symbolic_p () + || iter_binding->symbolic_p () + || always_overlap)) uncertainty->on_maybe_bound_sval (old_sval); /* Begin by removing the old binding. */ m_map.remove (iter_binding); + /* Don't attempt to handle prefixes/suffixes for the + "always_overlap" case; everything's being removed. */ + if (always_overlap) + continue; + /* Now potentially add the prefix and suffix. */ if (const concrete_binding *drop_ckey = drop_key->dyn_cast_concrete_binding ()) @@ -1335,22 +1369,30 @@ binding_cluster::zero_fill_region (store_manager *mgr, const region *reg) fill_region (mgr, reg, zero_sval); } -/* Mark REG within this cluster as being unknown. +/* Mark REG_TO_BIND within this cluster as being unknown. + + Remove any bindings overlapping REG_FOR_OVERLAP. If UNCERTAINTY is non-NULL, use it to record any svalues that - had bindings to them removed, as being maybe-bound. */ + had bindings to them removed, as being maybe-bound. + + REG_TO_BIND and REG_FOR_OVERLAP are the same for + store::mark_region_as_unknown, but are different in + store::set_value's alias handling, for handling the case where + we have a write to a symbolic REG_FOR_OVERLAP. */ void binding_cluster::mark_region_as_unknown (store_manager *mgr, - const region *reg, + const region *reg_to_bind, + const region *reg_for_overlap, uncertainty_t *uncertainty) { - remove_overlapping_bindings (mgr, reg, uncertainty); + remove_overlapping_bindings (mgr, reg_for_overlap, uncertainty); /* Add a default binding to "unknown". */ region_model_manager *sval_mgr = mgr->get_svalue_manager (); const svalue *sval - = sval_mgr->get_or_create_unknown_svalue (reg->get_type ()); - bind (mgr, reg, sval); + = sval_mgr->get_or_create_unknown_svalue (reg_to_bind->get_type ()); + bind (mgr, reg_to_bind, sval); } /* Purge state involving SVAL. */ @@ -1595,7 +1637,7 @@ binding_cluster::maybe_get_compound_binding (store_manager *mgr, it overlaps with offset_concrete_key. */ default_map.remove_overlapping_bindings (mgr, offset_concrete_key, - NULL); + NULL, false); } else if (bound_range.contains_p (reg_range, &subrange)) { @@ -1629,7 +1671,7 @@ binding_cluster::maybe_get_compound_binding (store_manager *mgr, it overlaps with overlap_concrete_key. */ default_map.remove_overlapping_bindings (mgr, overlap_concrete_key, - NULL); + NULL, false); } } else @@ -1652,7 +1694,13 @@ binding_cluster::maybe_get_compound_binding (store_manager *mgr, } /* Remove, truncate, and/or split any bindings within this map that - overlap REG. + could overlap REG. + + If REG's base region or this cluster is symbolic and they're different + base regions, then remove everything in this cluster's map, on the + grounds that REG could be referring to the same memory as anything + in the map. + If UNCERTAINTY is non-NULL, use it to record any svalues that were removed, as being maybe-bound. */ @@ -1663,7 +1711,19 @@ binding_cluster::remove_overlapping_bindings (store_manager *mgr, { const binding_key *reg_binding = binding_key::make (mgr, reg); - m_map.remove_overlapping_bindings (mgr, reg_binding, uncertainty); + const region *cluster_base_reg = get_base_region (); + const region *other_base_reg = reg->get_base_region (); + /* If at least one of the base regions involved is symbolic, and they're + not the same base region, then consider everything in the map as + potentially overlapping with reg_binding (even if it's a concrete + binding and things in the map are concrete - they could be referring + to the same memory when the symbolic base regions are taken into + account). */ + bool always_overlap = (cluster_base_reg != other_base_reg + && (cluster_base_reg->get_kind () == RK_SYMBOLIC + || other_base_reg->get_kind () == RK_SYMBOLIC)); + m_map.remove_overlapping_bindings (mgr, reg_binding, uncertainty, + always_overlap); } /* Attempt to merge CLUSTER_A and CLUSTER_B into OUT_CLUSTER, using @@ -2368,7 +2428,7 @@ store::set_value (store_manager *mgr, const region *lhs_reg, logger *logger = mgr->get_logger (); LOG_SCOPE (logger); - remove_overlapping_bindings (mgr, lhs_reg); + remove_overlapping_bindings (mgr, lhs_reg, uncertainty); rhs_sval = simplify_for_binding (rhs_sval); @@ -2438,8 +2498,14 @@ store::set_value (store_manager *mgr, const region *lhs_reg, lhs_reg->dump_to_pp (pp, true); logger->end_log_line (); } - iter_cluster->mark_region_as_unknown (mgr, iter_base_reg, - uncertainty); + /* Mark all of iter_cluster's iter_base_reg as unknown, + using LHS_REG when considering overlaps, to handle + symbolic vs concrete issues. */ + iter_cluster->mark_region_as_unknown + (mgr, + iter_base_reg, /* reg_to_bind */ + lhs_reg, /* reg_for_overlap */ + uncertainty); break; case tristate::TS_TRUE: @@ -2603,7 +2669,7 @@ store::mark_region_as_unknown (store_manager *mgr, const region *reg, || !base_reg->tracked_p ()) return; binding_cluster *cluster = get_or_create_cluster (base_reg); - cluster->mark_region_as_unknown (mgr, reg, uncertainty); + cluster->mark_region_as_unknown (mgr, reg, reg, uncertainty); } /* Purge state involving SVAL. */ @@ -2826,10 +2892,14 @@ store::get_representative_path_vars (const region_model *model, } /* Remove all bindings overlapping REG within this store, removing - any clusters that become redundant. */ + any clusters that become redundant. + + If UNCERTAINTY is non-NULL, use it to record any svalues that + were removed, as being maybe-bound. */ void -store::remove_overlapping_bindings (store_manager *mgr, const region *reg) +store::remove_overlapping_bindings (store_manager *mgr, const region *reg, + uncertainty_t *uncertainty) { const region *base_reg = reg->get_base_region (); if (binding_cluster **cluster_slot = m_cluster_map.get (base_reg)) @@ -2842,7 +2912,7 @@ store::remove_overlapping_bindings (store_manager *mgr, const region *reg) delete cluster; return; } - cluster->remove_overlapping_bindings (mgr, reg, NULL); + cluster->remove_overlapping_bindings (mgr, reg, uncertainty); } } diff --git a/gcc/analyzer/store.h b/gcc/analyzer/store.h index 89bb352f6a5..17485b783b8 100644 --- a/gcc/analyzer/store.h +++ b/gcc/analyzer/store.h @@ -509,7 +509,8 @@ public: void remove_overlapping_bindings (store_manager *mgr, const binding_key *drop_key, - uncertainty_t *uncertainty); + uncertainty_t *uncertainty, + bool always_overlap); private: void get_overlapping_bindings (const binding_key *key, @@ -574,7 +575,9 @@ public: void purge_region (store_manager *mgr, const region *reg); void fill_region (store_manager *mgr, const region *reg, const svalue *sval); void zero_fill_region (store_manager *mgr, const region *reg); - void mark_region_as_unknown (store_manager *mgr, const region *reg, + void mark_region_as_unknown (store_manager *mgr, + const region *reg_to_bind, + const region *reg_for_overlap, uncertainty_t *uncertainty); void purge_state_involving (const svalue *sval, region_model_manager *sval_mgr); @@ -765,7 +768,8 @@ public: region_model_manager *mgr); private: - void remove_overlapping_bindings (store_manager *mgr, const region *reg); + void remove_overlapping_bindings (store_manager *mgr, const region *reg, + uncertainty_t *uncertainty); tristate eval_alias_1 (const region *base_reg_a, const region *base_reg_b) const; diff --git a/gcc/analyzer/svalue.cc b/gcc/analyzer/svalue.cc index 553edae7250..ed289c6fc31 100644 --- a/gcc/analyzer/svalue.cc +++ b/gcc/analyzer/svalue.cc @@ -59,6 +59,8 @@ along with GCC; see the file COPYING3. If not see namespace ana { +static int cmp_csts_and_types (const_tree cst1, const_tree cst2); + /* class svalue and its various subclasses. */ /* class svalue. */ @@ -304,7 +306,7 @@ svalue::implicitly_live_p (const svalue_set *, const region_model *) const of the same type. */ static int -cmp_cst (const_tree cst1, const_tree cst2) +cmp_csts_same_type (const_tree cst1, const_tree cst2) { gcc_assert (TREE_TYPE (cst1) == TREE_TYPE (cst2)); gcc_assert (TREE_CODE (cst1) == TREE_CODE (cst2)); @@ -323,9 +325,10 @@ cmp_cst (const_tree cst1, const_tree cst2) TREE_REAL_CST_PTR (cst2), sizeof (real_value)); case COMPLEX_CST: - if (int cmp_real = cmp_cst (TREE_REALPART (cst1), TREE_REALPART (cst2))) + if (int cmp_real = cmp_csts_and_types (TREE_REALPART (cst1), + TREE_REALPART (cst2))) return cmp_real; - return cmp_cst (TREE_IMAGPART (cst1), TREE_IMAGPART (cst2)); + return cmp_csts_and_types (TREE_IMAGPART (cst1), TREE_IMAGPART (cst2)); case VECTOR_CST: if (int cmp_log2_npatterns = ((int)VECTOR_CST_LOG2_NPATTERNS (cst1) @@ -337,13 +340,29 @@ cmp_cst (const_tree cst1, const_tree cst2) return cmp_nelts_per_pattern; unsigned encoded_nelts = vector_cst_encoded_nelts (cst1); for (unsigned i = 0; i < encoded_nelts; i++) - if (int el_cmp = cmp_cst (VECTOR_CST_ENCODED_ELT (cst1, i), - VECTOR_CST_ENCODED_ELT (cst2, i))) - return el_cmp; + { + const_tree elt1 = VECTOR_CST_ENCODED_ELT (cst1, i); + const_tree elt2 = VECTOR_CST_ENCODED_ELT (cst2, i); + if (int el_cmp = cmp_csts_and_types (elt1, elt2)) + return el_cmp; + } return 0; } } +/* Comparator for imposing a deterministic order on constants that might + not be of the same type. */ + +static int +cmp_csts_and_types (const_tree cst1, const_tree cst2) +{ + int t1 = TYPE_UID (TREE_TYPE (cst1)); + int t2 = TYPE_UID (TREE_TYPE (cst2)); + if (int cmp_type = t1 - t2) + return cmp_type; + return cmp_csts_same_type (cst1, cst2); +} + /* Comparator for imposing a deterministic order on svalues. */ int @@ -375,7 +394,7 @@ svalue::cmp_ptr (const svalue *sval1, const svalue *sval2) const constant_svalue *constant_sval2 = (const constant_svalue *)sval2; const_tree cst1 = constant_sval1->get_constant (); const_tree cst2 = constant_sval2->get_constant (); - return cmp_cst (cst1, cst2); + return cmp_csts_same_type (cst1, cst2); } break; case SK_UNKNOWN: @@ -644,6 +663,48 @@ svalue::all_zeroes_p () const return false; } +/* If this svalue is a pointer, attempt to determine the base region it points + to. Return NULL on any problems. */ + +const region * +svalue::maybe_get_deref_base_region () const +{ + const svalue *iter = this; + while (1) + { + switch (iter->get_kind ()) + { + default: + return NULL; + + case SK_REGION: + { + const region_svalue *region_sval + = as_a <const region_svalue *> (iter); + return region_sval->get_pointee ()->get_base_region (); + } + + case SK_BINOP: + { + const binop_svalue *binop_sval + = as_a <const binop_svalue *> (iter); + switch (binop_sval->get_op ()) + { + case POINTER_PLUS_EXPR: + /* If we have a symbolic value expressing pointer arithmetic, + use the LHS. */ + iter = binop_sval->get_arg0 (); + continue; + + default: + return NULL; + } + return NULL; + } + } + } +} + /* class region_svalue : public svalue. */ /* Implementation of svalue::dump_to_pp vfunc for region_svalue. */ diff --git a/gcc/analyzer/svalue.h b/gcc/analyzer/svalue.h index 4bbe8588b8d..29ea2ee6408 100644 --- a/gcc/analyzer/svalue.h +++ b/gcc/analyzer/svalue.h @@ -175,6 +175,8 @@ public: per-type and thus it's meaningless for them to "have state". */ virtual bool can_have_associated_state_p () const { return true; } + const region *maybe_get_deref_base_region () const; + protected: svalue (complexity c, tree type) : m_complexity (c), m_type (type) diff --git a/gcc/asan.cc b/gcc/asan.cc index 7c57cbca99c..ef59b77ebc2 100644 --- a/gcc/asan.cc +++ b/gcc/asan.cc @@ -1497,10 +1497,14 @@ asan_redzone_buffer::emit_redzone_byte (HOST_WIDE_INT offset, HOST_WIDE_INT off = m_prev_offset + ASAN_SHADOW_GRANULARITY * m_shadow_bytes.length (); if (off == offset) + /* Consecutive shadow memory byte. */; + else if (offset < m_prev_offset + (HOST_WIDE_INT) (ASAN_SHADOW_GRANULARITY + * RZ_BUFFER_SIZE) + && !m_shadow_bytes.is_empty ()) { - /* Consecutive shadow memory byte. */ - m_shadow_bytes.safe_push (value); - flush_if_full (); + /* Shadow memory byte with a small gap. */ + for (; off < offset; off += ASAN_SHADOW_GRANULARITY) + m_shadow_bytes.safe_push (0); } else { @@ -1521,9 +1525,9 @@ asan_redzone_buffer::emit_redzone_byte (HOST_WIDE_INT offset, m_shadow_mem = adjust_address (m_shadow_mem, VOIDmode, diff >> ASAN_SHADOW_SHIFT); m_prev_offset = offset; - m_shadow_bytes.safe_push (value); - flush_if_full (); } + m_shadow_bytes.safe_push (value); + flush_if_full (); } /* Emit RTX emission of the content of the buffer. */ diff --git a/gcc/attribs.cc b/gcc/attribs.cc index 497dcff84df..b219f878042 100644 --- a/gcc/attribs.cc +++ b/gcc/attribs.cc @@ -636,15 +636,20 @@ decl_attributes (tree *node, tree attributes, int flags, && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)) { DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node; - tree cur_tree - = build_target_option_node (&global_options, &global_options_set); - tree old_tree = DECL_FUNCTION_SPECIFIC_TARGET (*node); - if (!old_tree) - old_tree = target_option_default_node; - /* The changes on optimization options can cause the changes in - target options, update it accordingly if it's changed. */ - if (old_tree != cur_tree) - DECL_FUNCTION_SPECIFIC_TARGET (*node) = cur_tree; + /* Don't set DECL_FUNCTION_SPECIFIC_TARGET for targets that don't + support #pragma GCC target or target attribute. */ + if (target_option_default_node) + { + tree cur_tree + = build_target_option_node (&global_options, &global_options_set); + tree old_tree = DECL_FUNCTION_SPECIFIC_TARGET (*node); + if (!old_tree) + old_tree = target_option_default_node; + /* The changes on optimization options can cause the changes in + target options, update it accordingly if it's changed. */ + if (old_tree != cur_tree) + DECL_FUNCTION_SPECIFIC_TARGET (*node) = cur_tree; + } } /* If this is a function and the user used #pragma GCC target, add the diff --git a/gcc/builtins.cc b/gcc/builtins.cc index 4c6c2939053..5b085e3a14f 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -2967,16 +2967,28 @@ expand_builtin_int_roundingfn_2 (tree exp, rtx target) BUILT_IN_IROUND and if __builtin_iround is called directly, emit a call to lround in the hope that the target provides at least some C99 functions. This should result in the best user experience for - not full C99 targets. */ - tree fallback_fndecl = mathfn_built_in_1 - (TREE_TYPE (arg), as_combined_fn (fallback_fn), 0); - - exp = build_call_nofold_loc (EXPR_LOCATION (exp), - fallback_fndecl, 1, arg); + not full C99 targets. + As scalar float conversions with same mode are useless in GIMPLE, + we can end up e.g. with _Float32 argument passed to float builtin, + try to get the type from the builtin prototype first. */ + tree fallback_fndecl = NULL_TREE; + if (tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl))) + fallback_fndecl + = mathfn_built_in_1 (TREE_VALUE (argtypes), + as_combined_fn (fallback_fn), 0); + if (fallback_fndecl == NULL_TREE) + fallback_fndecl + = mathfn_built_in_1 (TREE_TYPE (arg), + as_combined_fn (fallback_fn), 0); + if (fallback_fndecl) + { + exp = build_call_nofold_loc (EXPR_LOCATION (exp), + fallback_fndecl, 1, arg); - target = expand_call (exp, NULL_RTX, target == const0_rtx); - target = maybe_emit_group_store (target, TREE_TYPE (exp)); - return convert_to_mode (mode, target, 0); + target = expand_call (exp, NULL_RTX, target == const0_rtx); + target = maybe_emit_group_store (target, TREE_TYPE (exp)); + return convert_to_mode (mode, target, 0); + } } return expand_call (exp, target, target == const0_rtx); diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 5ca3182088b..d7447d07afb 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,16 @@ +2022-04-26 Patrick Palka <ppalka@redhat.com> + + PR c++/105304 + * c-common.cc (verify_tree) [restart]: Move up to before the + NULL test. + +2022-04-11 Jakub Jelinek <jakub@redhat.com> + + PR c++/105186 + * c-common.cc (c_common_nodes_and_builtins): After registering __int%d + and __int%d__ builtin types, initialize corresponding ridpointers + entry. + 2022-03-30 Marek Polacek <polacek@redhat.com> PR c++/101030 diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index d034837bb5b..bb0544eeaea 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -2009,12 +2009,12 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp, enum tree_code code; enum tree_code_class cl; + restart: /* X may be NULL if it is the operand of an empty statement expression ({ }). */ if (x == NULL) return; - restart: code = TREE_CODE (x); cl = TREE_CODE_CLASS (code); @@ -4278,6 +4278,8 @@ c_common_nodes_and_builtins (void) sprintf (name, "__int%d__", int_n_data[i].bitsize); record_builtin_type ((enum rid)(RID_FIRST_INT_N + i), name, int_n_trees[i].signed_type); + ridpointers[RID_FIRST_INT_N + i] + = DECL_NAME (TYPE_NAME (int_n_trees[i].signed_type)); sprintf (name, "__int%d unsigned", int_n_data[i].bitsize); record_builtin_type (RID_MAX, name, int_n_trees[i].unsigned_type); diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index ea25ddb8854..b0fef44e35f 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,8 @@ +2022-04-08 Jakub Jelinek <jakub@redhat.com> + + PR c/105149 + * c-typeck.cc (c_build_va_arg): Reject function types. + 2022-03-22 Marek Polacek <polacek@redhat.com> PR c/82283 diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index 6c4af5e4cde..e130196a3a7 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -15896,6 +15896,12 @@ c_build_va_arg (location_t loc1, tree expr, location_t loc2, tree type) "type %qT", type); return error_mark_node; } + else if (TREE_CODE (type) == FUNCTION_TYPE) + { + error_at (loc2, "second argument to %<va_arg%> is a function type %qT", + type); + return error_mark_node; + } else if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE) warning_at (loc2, OPT_Wc___compat, "C++ requires promoted type, not enum type, in %<va_arg%>"); diff --git a/gcc/cgraph.cc b/gcc/cgraph.cc index b923a59ab0c..0159eaa768b 100644 --- a/gcc/cgraph.cc +++ b/gcc/cgraph.cc @@ -507,6 +507,7 @@ cgraph_node::create (tree decl) gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); node->decl = decl; + node->semantic_interposition = opt_for_fn (decl, flag_semantic_interposition); if ((flag_openacc || flag_openmp) && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl))) @@ -3487,7 +3488,11 @@ cgraph_node::verify_node (void) "returns a pointer"); error_found = true; } - if (definition && externally_visible + if (definition + && externally_visible + /* For aliases in lto1 free_lang_data doesn't guarantee preservation + of opt_for_fn (decl, flag_semantic_interposition). See PR105399. */ + && (!alias || !in_lto_p) && semantic_interposition != opt_for_fn (decl, flag_semantic_interposition)) { diff --git a/gcc/cgraphclones.cc b/gcc/cgraphclones.cc index 60da1e867c8..eb0fa87b554 100644 --- a/gcc/cgraphclones.cc +++ b/gcc/cgraphclones.cc @@ -394,6 +394,7 @@ cgraph_node::create_clone (tree new_decl, profile_count prof_count, new_node->versionable = versionable; new_node->can_change_signature = can_change_signature; new_node->redefined_extern_inline = redefined_extern_inline; + new_node->semantic_interposition = semantic_interposition; new_node->tm_may_enter_irr = tm_may_enter_irr; new_node->externally_visible = false; new_node->no_reorder = no_reorder; diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc index 01f4e28204e..bc3dc754481 100644 --- a/gcc/cgraphunit.cc +++ b/gcc/cgraphunit.cc @@ -621,6 +621,7 @@ cgraph_node::analyze (void) tree decl = this->decl; location_t saved_loc = input_location; input_location = DECL_SOURCE_LOCATION (decl); + semantic_interposition = opt_for_fn (decl, flag_semantic_interposition); if (thunk) { diff --git a/gcc/combine.cc b/gcc/combine.cc index 53dcac92abc..9a34ef847aa 100644 --- a/gcc/combine.cc +++ b/gcc/combine.cc @@ -2569,6 +2569,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, rtx new_other_notes; int i; scalar_int_mode dest_mode, temp_mode; + bool has_non_call_exception = false; /* Immediately return if any of I0,I1,I2 are the same insn (I3 can never be). */ @@ -2951,6 +2952,32 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, return 0; } + /* With non-call exceptions we can end up trying to combine multiple + insns with possible EH side effects. Make sure we can combine + that to a single insn which means there must be at most one insn + in the combination with an EH side effect. */ + if (cfun->can_throw_non_call_exceptions) + { + if (find_reg_note (i3, REG_EH_REGION, NULL_RTX) + || find_reg_note (i2, REG_EH_REGION, NULL_RTX) + || (i1 && find_reg_note (i1, REG_EH_REGION, NULL_RTX)) + || (i0 && find_reg_note (i0, REG_EH_REGION, NULL_RTX))) + { + has_non_call_exception = true; + if (insn_could_throw_p (i3) + + insn_could_throw_p (i2) + + (i1 ? insn_could_throw_p (i1) : 0) + + (i0 ? insn_could_throw_p (i0) : 0) > 1) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "Can't combine multiple insns with EH " + "side-effects\n"); + undo_all (); + return 0; + } + } + } + /* Record whether i2 and i3 are trivial moves. */ i2_was_move = is_just_move (i2); i3_was_move = is_just_move (i3); @@ -3685,7 +3712,13 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, || !modified_between_p (*split, i2, i3)) /* We can't overwrite I2DEST if its value is still used by NEWPAT. */ - && ! reg_referenced_p (i2dest, newpat)) + && ! reg_referenced_p (i2dest, newpat) + /* We should not split a possibly trapping part when we + care about non-call EH and have REG_EH_REGION notes + to distribute. */ + && ! (cfun->can_throw_non_call_exceptions + && has_non_call_exception + && may_trap_p (*split))) { rtx newdest = i2dest; enum rtx_code split_code = GET_CODE (*split); @@ -14175,23 +14208,35 @@ distribute_notes (rtx notes, rtx_insn *from_insn, rtx_insn *i3, rtx_insn *i2, break; case REG_EH_REGION: - /* These notes must remain with the call or trapping instruction. */ - if (CALL_P (i3)) - place = i3; - else if (i2 && CALL_P (i2)) - place = i2; - else - { - gcc_assert (cfun->can_throw_non_call_exceptions); - if (may_trap_p (i3)) - place = i3; - else if (i2 && may_trap_p (i2)) - place = i2; - /* ??? Otherwise assume we've combined things such that we - can now prove that the instructions can't trap. Drop the - note in this case. */ - } - break; + { + /* The landing pad handling needs to be kept in sync with the + prerequisite checking in try_combine. */ + int lp_nr = INTVAL (XEXP (note, 0)); + /* A REG_EH_REGION note transfering control can only ever come + from i3. */ + if (lp_nr > 0) + gcc_assert (from_insn == i3); + /* We are making sure there is a single effective REG_EH_REGION + note and it's valid to put it on i3. */ + if (!insn_could_throw_p (from_insn)) + /* Throw away stra notes on insns that can never throw. */ + ; + else + { + if (CALL_P (i3)) + place = i3; + else + { + gcc_assert (cfun->can_throw_non_call_exceptions); + /* If i3 can still trap preserve the note, otherwise we've + combined things such that we can now prove that the + instructions can't trap. Drop the note in this case. */ + if (may_trap_p (i3)) + place = i3; + } + } + break; + } case REG_ARGS_SIZE: /* ??? How to distribute between i3-i1. Assume i3 contains the diff --git a/gcc/common/config/s390/s390-common.cc b/gcc/common/config/s390/s390-common.cc index caec2f14c6c..72a5ef47eaa 100644 --- a/gcc/common/config/s390/s390-common.cc +++ b/gcc/common/config/s390/s390-common.cc @@ -50,10 +50,10 @@ EXPORTED_CONST int processor_flags_table[] = /* z15 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP | PF_Z10 | PF_Z196 | PF_ZEC12 | PF_TX | PF_Z13 | PF_VX | PF_VXE | PF_Z14 | PF_VXE2 | PF_Z15, - /* arch14 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT + /* z16 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP | PF_Z10 | PF_Z196 | PF_ZEC12 | PF_TX | PF_Z13 | PF_VX | PF_VXE | PF_Z14 | PF_VXE2 | PF_Z15 - | PF_NNPA | PF_ARCH14 + | PF_NNPA | PF_Z16 }; /* Change optimizations to be performed, depending on the diff --git a/gcc/config.gcc b/gcc/config.gcc index 7b58e1314ff..c5064dd3766 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -4261,7 +4261,7 @@ case "${target}" in ext_val=`echo $ext_val | sed -e 's/[a-z0-9]\+//'` done - ext_mask="(("$ext_mask") << 6)" + ext_mask="(("$ext_mask") << TARGET_CPU_NBITS)" if [ x"$base_id" != x ]; then target_cpu_cname="TARGET_CPU_$base_id | $ext_mask" fi @@ -4717,7 +4717,7 @@ case "${target}" in esac PYTHON=`which python || which python3 || which python2` if test "x${PYTHON}" != x; then - with_arch=`${PYTHON} ${srcdir}/config/riscv/arch-canonicalize ${with_arch}` + with_arch=`${PYTHON} ${srcdir}/config/riscv/arch-canonicalize -misa-spec=${with_isa_spec} ${with_arch}` fi tm_defines="${tm_defines} TARGET_RISCV_DEFAULT_ARCH=${with_arch}" @@ -4766,6 +4766,7 @@ case "${target}" in case "${target}" in riscv*-*-elf*) if ${srcdir}/config/riscv/multilib-generator \ + -misa-spec=${with_isa_spec} \ `echo ${with_multilib_generator} | sed 's/;/ /g'`\ > t-multilib-config; then @@ -5531,7 +5532,7 @@ case "${target}" in for which in arch tune; do eval "val=\$with_$which" case ${val} in - "" | native | z900 | z990 | z9-109 | z9-ec | z10 | z196 | zEC12 | z13 | z14 | z15 | arch5 | arch6 | arch7 | arch8 | arch9 | arch10 | arch11 | arch12 | arch13 | arch14 ) + "" | native | z900 | z990 | z9-109 | z9-ec | z10 | z196 | zEC12 | z13 | z14 | z15 | z16 | arch5 | arch6 | arch7 | arch8 | arch9 | arch10 | arch11 | arch12 | arch13 | arch14 ) # OK ;; *) diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc index 6ebeee75d0a..c21476d7ae9 100644 --- a/gcc/config/aarch64/aarch64-builtins.cc +++ b/gcc/config/aarch64/aarch64-builtins.cc @@ -1664,6 +1664,14 @@ aarch64_init_ls64_builtins (void) = aarch64_general_add_builtin (data[i].name, data[i].type, data[i].code); } +/* Implement #pragma GCC aarch64 "arm_acle.h". */ +void +handle_arm_acle_h (void) +{ + if (TARGET_LS64) + aarch64_init_ls64_builtins (); +} + /* Initialize fpsr fpcr getters and setters. */ static void @@ -1755,9 +1763,6 @@ aarch64_general_init_builtins (void) if (TARGET_MEMTAG) aarch64_init_memtag_builtins (); - - if (TARGET_LS64) - aarch64_init_ls64_builtins (); } /* Implement TARGET_BUILTIN_DECL for the AARCH64_BUILTIN_GENERAL group. */ diff --git a/gcc/config/aarch64/aarch64-c.cc b/gcc/config/aarch64/aarch64-c.cc index caf8e332ea0..767ee0c763c 100644 --- a/gcc/config/aarch64/aarch64-c.cc +++ b/gcc/config/aarch64/aarch64-c.cc @@ -302,6 +302,8 @@ aarch64_pragma_aarch64 (cpp_reader *) aarch64_sve::handle_arm_sve_h (); else if (strcmp (name, "arm_neon.h") == 0) handle_arm_neon_h (); + else if (strcmp (name, "arm_acle.h") == 0) + handle_arm_acle_h (); else error ("unknown %<#pragma GCC aarch64%> option %qs", name); } diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h index c6f13ee836c..2ac781dff4a 100644 --- a/gcc/config/aarch64/aarch64-protos.h +++ b/gcc/config/aarch64/aarch64-protos.h @@ -995,6 +995,7 @@ rtx aarch64_general_expand_builtin (unsigned int, tree, rtx, int); tree aarch64_general_builtin_decl (unsigned, bool); tree aarch64_general_builtin_rsqrt (unsigned int); tree aarch64_builtin_vectorized_function (unsigned int, tree, tree); +void handle_arm_acle_h (void); void handle_arm_neon_h (void); namespace aarch64_sve { diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md index 18733428f3f..a00e1c6ef8d 100644 --- a/gcc/config/aarch64/aarch64-simd.md +++ b/gcc/config/aarch64/aarch64-simd.md @@ -3385,20 +3385,6 @@ ;; 'across lanes' add. -(define_expand "reduc_plus_scal_<mode>" - [(match_operand:<VEL> 0 "register_operand") - (unspec:VDQ_I [(match_operand:VDQ_I 1 "register_operand")] - UNSPEC_ADDV)] - "TARGET_SIMD" - { - rtx elt = aarch64_endian_lane_rtx (<MODE>mode, 0); - rtx scratch = gen_reg_rtx (<MODE>mode); - emit_insn (gen_aarch64_reduc_plus_internal<mode> (scratch, operands[1])); - emit_insn (gen_aarch64_get_lane<mode> (operands[0], scratch, elt)); - DONE; - } -) - (define_insn "aarch64_faddp<mode>" [(set (match_operand:VHSDF 0 "register_operand" "=w") (unspec:VHSDF [(match_operand:VHSDF 1 "register_operand" "w") @@ -3409,31 +3395,22 @@ [(set_attr "type" "neon_fp_reduc_add_<stype><q>")] ) -(define_insn "aarch64_reduc_plus_internal<mode>" - [(set (match_operand:VDQV 0 "register_operand" "=w") - (unspec:VDQV [(match_operand:VDQV 1 "register_operand" "w")] +(define_insn "reduc_plus_scal_<mode>" + [(set (match_operand:<VEL> 0 "register_operand" "=w") + (unspec:<VEL> [(match_operand:VDQV 1 "register_operand" "w")] UNSPEC_ADDV))] "TARGET_SIMD" "add<VDQV:vp>\\t%<Vetype>0, %1.<Vtype>" [(set_attr "type" "neon_reduc_add<q>")] ) -(define_insn "aarch64_<su>addlv<mode>" - [(set (match_operand:<VWIDE_S> 0 "register_operand" "=w") - (unspec:<VWIDE_S> [(match_operand:VDQV_L 1 "register_operand" "w")] - USADDLV))] - "TARGET_SIMD" - "<su>addl<vp>\\t%<Vwstype>0<Vwsuf>, %1.<Vtype>" - [(set_attr "type" "neon_reduc_add<q>")] -) - -(define_insn "aarch64_<su>addlp<mode>" - [(set (match_operand:<VDBLW> 0 "register_operand" "=w") - (unspec:<VDBLW> [(match_operand:VDQV_L 1 "register_operand" "w")] - USADDLP))] +(define_insn "reduc_plus_scal_v2si" + [(set (match_operand:SI 0 "register_operand" "=w") + (unspec:SI [(match_operand:V2SI 1 "register_operand" "w")] + UNSPEC_ADDV))] "TARGET_SIMD" - "<su>addlp\\t%0.<Vwhalf>, %1.<Vtype>" - [(set_attr "type" "neon_reduc_add<q>")] + "addp\\t%0.2s, %1.2s, %1.2s" + [(set_attr "type" "neon_reduc_add")] ) ;; ADDV with result zero-extended to SI/DImode (for popcount). @@ -3447,15 +3424,6 @@ [(set_attr "type" "neon_reduc_add<VDQV_E:q>")] ) -(define_insn "aarch64_reduc_plus_internalv2si" - [(set (match_operand:V2SI 0 "register_operand" "=w") - (unspec:V2SI [(match_operand:V2SI 1 "register_operand" "w")] - UNSPEC_ADDV))] - "TARGET_SIMD" - "addp\\t%0.2s, %1.2s, %1.2s" - [(set_attr "type" "neon_reduc_add")] -) - (define_insn "reduc_plus_scal_<mode>" [(set (match_operand:<VEL> 0 "register_operand" "=w") (unspec:<VEL> [(match_operand:V2F 1 "register_operand" "w")] @@ -3467,7 +3435,7 @@ (define_expand "reduc_plus_scal_v4sf" [(set (match_operand:SF 0 "register_operand") - (unspec:V4SF [(match_operand:V4SF 1 "register_operand")] + (unspec:SF [(match_operand:V4SF 1 "register_operand")] UNSPEC_FADDV))] "TARGET_SIMD" { @@ -3479,6 +3447,24 @@ DONE; }) +(define_insn "aarch64_<su>addlv<mode>" + [(set (match_operand:<VWIDE_S> 0 "register_operand" "=w") + (unspec:<VWIDE_S> [(match_operand:VDQV_L 1 "register_operand" "w")] + USADDLV))] + "TARGET_SIMD" + "<su>addl<vp>\\t%<Vwstype>0<Vwsuf>, %1.<Vtype>" + [(set_attr "type" "neon_reduc_add<q>")] +) + +(define_insn "aarch64_<su>addlp<mode>" + [(set (match_operand:<VDBLW> 0 "register_operand" "=w") + (unspec:<VDBLW> [(match_operand:VDQV_L 1 "register_operand" "w")] + USADDLP))] + "TARGET_SIMD" + "<su>addlp\\t%0.<Vwhalf>, %1.<Vtype>" + [(set_attr "type" "neon_reduc_add<q>")] +) + (define_insn "clrsb<mode>2" [(set (match_operand:VDQ_BHSI 0 "register_operand" "=w") (clrsb:VDQ_BHSI (match_operand:VDQ_BHSI 1 "register_operand" "w")))] diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 3e2a6fb6472..f650abbc4ce 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -15637,7 +15637,7 @@ private: unsigned int adjust_body_cost (loop_vec_info, const aarch64_vector_costs *, unsigned int); bool prefer_unrolled_loop () const; - unsigned int determine_suggested_unroll_factor (); + unsigned int determine_suggested_unroll_factor (loop_vec_info); /* True if we have performed one-time initialization based on the vec_info. */ @@ -16746,7 +16746,8 @@ adjust_body_cost_sve (const aarch64_vec_op_count *ops, } unsigned int -aarch64_vector_costs::determine_suggested_unroll_factor () +aarch64_vector_costs:: +determine_suggested_unroll_factor (loop_vec_info loop_vinfo) { bool sve = m_vec_flags & VEC_ANY_SVE; /* If we are trying to unroll an Advanced SIMD main loop that contains @@ -16760,6 +16761,7 @@ aarch64_vector_costs::determine_suggested_unroll_factor () return 1; unsigned int max_unroll_factor = 1; + auto vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo); for (auto vec_ops : m_ops) { aarch64_simd_vec_issue_info const *vec_issue @@ -16768,7 +16770,8 @@ aarch64_vector_costs::determine_suggested_unroll_factor () return 1; /* Limit unroll factor to a value adjustable by the user, the default value is 4. */ - unsigned int unroll_factor = aarch64_vect_unroll_limit; + unsigned int unroll_factor = MIN (aarch64_vect_unroll_limit, + (int) known_alignment (vf)); unsigned int factor = vec_ops.reduction_latency > 1 ? vec_ops.reduction_latency : 1; unsigned int temp; @@ -16946,7 +16949,8 @@ aarch64_vector_costs::finish_cost (const vector_costs *uncast_scalar_costs) { m_costs[vect_body] = adjust_body_cost (loop_vinfo, scalar_costs, m_costs[vect_body]); - m_suggested_unroll_factor = determine_suggested_unroll_factor (); + m_suggested_unroll_factor + = determine_suggested_unroll_factor (loop_vinfo); } /* Apply the heuristic described above m_stp_sequence_cost. Prefer @@ -18053,6 +18057,9 @@ aarch64_validate_mtune (const char *str, const struct processor **res) return false; } +static_assert (TARGET_CPU_generic < TARGET_CPU_MASK, + "TARGET_CPU_NBITS is big enough"); + /* Return the CPU corresponding to the enum CPU. If it doesn't specify a cpu, return the default. */ @@ -18062,12 +18069,12 @@ aarch64_get_tune_cpu (enum aarch64_processor cpu) if (cpu != aarch64_none) return &all_cores[cpu]; - /* The & 0x3f is to extract the bottom 6 bits that encode the - default cpu as selected by the --with-cpu GCC configure option + /* The & TARGET_CPU_MASK is to extract the bottom TARGET_CPU_NBITS bits that + encode the default cpu as selected by the --with-cpu GCC configure option in config.gcc. ???: The whole TARGET_CPU_DEFAULT and AARCH64_CPU_DEFAULT_FLAGS flags mechanism should be reworked to make it more sane. */ - return &all_cores[TARGET_CPU_DEFAULT & 0x3f]; + return &all_cores[TARGET_CPU_DEFAULT & TARGET_CPU_MASK]; } /* Return the architecture corresponding to the enum ARCH. @@ -18079,7 +18086,8 @@ aarch64_get_arch (enum aarch64_arch arch) if (arch != aarch64_no_arch) return &all_architectures[arch]; - const struct processor *cpu = &all_cores[TARGET_CPU_DEFAULT & 0x3f]; + const struct processor *cpu + = &all_cores[TARGET_CPU_DEFAULT & TARGET_CPU_MASK]; return &all_architectures[cpu->arch]; } @@ -18166,7 +18174,7 @@ aarch64_override_options (void) { /* Get default configure-time CPU. */ selected_cpu = aarch64_get_tune_cpu (aarch64_none); - aarch64_isa_flags = TARGET_CPU_DEFAULT >> 6; + aarch64_isa_flags = TARGET_CPU_DEFAULT >> TARGET_CPU_NBITS; } if (selected_tune) diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index efa46ac0b87..359b6e8561f 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -813,10 +813,16 @@ enum target_cpus TARGET_CPU_generic }; +/* Define how many bits are used to represent the CPU in TARGET_CPU_DEFAULT. + This needs to be big enough to fit the value of TARGET_CPU_generic. + All bits after this are used to represent the AARCH64_CPU_DEFAULT_FLAGS. */ +#define TARGET_CPU_NBITS 8 +#define TARGET_CPU_MASK ((1 << TARGET_CPU_NBITS) - 1) + /* If there is no CPU defined at configure, use generic as default. */ #ifndef TARGET_CPU_DEFAULT #define TARGET_CPU_DEFAULT \ - (TARGET_CPU_generic | (AARCH64_CPU_DEFAULT_FLAGS << 6)) + (TARGET_CPU_generic | (AARCH64_CPU_DEFAULT_FLAGS << TARGET_CPU_NBITS)) #endif /* If inserting NOP before a mult-accumulate insn remember to adjust the diff --git a/gcc/config/aarch64/arm_acle.h b/gcc/config/aarch64/arm_acle.h index ecd852f8a46..9775a48c658 100644 --- a/gcc/config/aarch64/arm_acle.h +++ b/gcc/config/aarch64/arm_acle.h @@ -29,6 +29,8 @@ #include <stdint.h> +#pragma GCC aarch64 "arm_acle.h" + #ifdef __cplusplus extern "C" { #endif diff --git a/gcc/config/arm/t-aprofile b/gcc/config/arm/t-aprofile index 574951c5f0b..fe2ec88d92d 100644 --- a/gcc/config/arm/t-aprofile +++ b/gcc/config/arm/t-aprofile @@ -26,8 +26,8 @@ # Arch and FPU variants to build libraries with -MULTI_ARCH_OPTS_A = march=armv7-a/march=armv7-a+fp/march=armv7-a+simd/march=armv7ve+simd/march=armv8-a/march=armv8-a+simd/march=armv9-a/march=armv9-a+simd -MULTI_ARCH_DIRS_A = v7-a v7-a+fp v7-a+simd v7ve+simd v8-a v8-a+simd v9-a v9-a+simd +MULTI_ARCH_OPTS_A = march=armv7-a/march=armv7-a+fp/march=armv7-a+simd/march=armv7ve+simd/march=armv8-a/march=armv8-a+simd +MULTI_ARCH_DIRS_A = v7-a v7-a+fp v7-a+simd v7ve+simd v8-a v8-a+simd # ARMv7-A - build nofp, fp-d16 and SIMD variants @@ -46,11 +46,6 @@ MULTILIB_REQUIRED += mthumb/march=armv8-a/mfloat-abi=soft MULTILIB_REQUIRED += mthumb/march=armv8-a+simd/mfloat-abi=hard MULTILIB_REQUIRED += mthumb/march=armv8-a+simd/mfloat-abi=softfp -# Armv9-A - build nofp and SIMD variants. -MULTILIB_REQUIRED += mthumb/march=armv9-a/mfloat-abi=soft -MULTILIB_REQUIRED += mthumb/march=armv9-a+simd/mfloat-abi=hard -MULTILIB_REQUIRED += mthumb/march=armv9-a+simd/mfloat-abi=softfp - # Matches # Arch Matches @@ -135,14 +130,12 @@ MULTILIB_MATCHES += $(foreach ARCH, $(v8_6_a_simd_variants), \ march?armv8-a+simd=march?armv8.6-a$(ARCH)) # Armv9 without SIMD: map down to base architecture -MULTILIB_MATCHES += $(foreach ARCH, $(v9_a_nosimd_variants), \ - march?armv9-a=march?armv9-a$(ARCH)) +MULTILIB_MATCHES += march?armv8-a=march?armv9-a +# No variants without SIMD. # Armv9 with SIMD: map down to base arch + simd -MULTILIB_MATCHES += march?armv9-a+simd=march?armv9-a+crc+simd \ - $(foreach ARCH, $(filter-out +simd, $(v9_a_simd_variants)), \ - march?armv9-a+simd=march?armv9-a$(ARCH) \ - march?armv9-a+simd=march?armv9-a+crc$(ARCH)) +MULTILIB_MATCHES += $(foreach ARCH, $(v9_a_simd_variants), \ + march?armv8-a+simd=march?armv9-a$(ARCH)) # Use Thumb libraries for everything. @@ -150,13 +143,11 @@ MULTILIB_REUSE += mthumb/march.armv7-a/mfloat-abi.soft=marm/march.armv7-a/mfloa MULTILIB_REUSE += mthumb/march.armv8-a/mfloat-abi.soft=marm/march.armv8-a/mfloat-abi.soft -MULTILIB_REUSE += mthumb/march.armv9-a/mfloat-abi.soft=marm/march.armv9-a/mfloat-abi.soft - MULTILIB_REUSE += $(foreach ABI, hard softfp, \ - $(foreach ARCH, armv7-a+fp armv7-a+simd armv7ve+simd armv8-a+simd armv9-a+simd, \ + $(foreach ARCH, armv7-a+fp armv7-a+simd armv7ve+simd armv8-a+simd, \ mthumb/march.$(ARCH)/mfloat-abi.$(ABI)=marm/march.$(ARCH)/mfloat-abi.$(ABI))) # Softfp but no FP, use the soft-float libraries. MULTILIB_REUSE += $(foreach MODE, arm thumb, \ - $(foreach ARCH, armv7-a armv8-a armv9-a, \ + $(foreach ARCH, armv7-a armv8-a, \ mthumb/march.$(ARCH)/mfloat-abi.soft=m$(MODE)/march.$(ARCH)/mfloat-abi.softfp)) diff --git a/gcc/config/arm/t-multilib b/gcc/config/arm/t-multilib index ea258b1c210..6bb58d39ea9 100644 --- a/gcc/config/arm/t-multilib +++ b/gcc/config/arm/t-multilib @@ -78,7 +78,6 @@ v8_4_a_simd_variants := $(call all_feat_combs, simd fp16 crypto i8mm bf16) v8_5_a_simd_variants := $(call all_feat_combs, simd fp16 crypto i8mm bf16) v8_6_a_simd_variants := $(call all_feat_combs, simd fp16 crypto i8mm bf16) v8_r_nosimd_variants := +crc -v9_a_nosimd_variants := +crc v9_a_simd_variants := $(call all_feat_combs, simd fp16 crypto i8mm bf16) ifneq (,$(HAS_APROFILE)) @@ -206,14 +205,10 @@ MULTILIB_MATCHES += $(foreach ARCH, $(v8_6_a_simd_variants), \ # Armv9 MULTILIB_MATCHES += march?armv7=march?armv9-a -MULTILIB_MATCHES += $(foreach ARCH, $(v9_a_nosimd_variants), \ - march?armv7=march?armv9-a$(ARCH)) # Armv9 with SIMD -MULTILIB_MATCHES += march?armv7+fp=march?armv9-a+crc+simd \ - $(foreach ARCH, $(v9_a_simd_variants), \ - march?armv7+fp=march?armv9-a$(ARCH) \ - march?armv7+fp=march?armv9-a+crc$(ARCH)) +MULTILIB_MATCHES += $(foreach ARCH, $(v9_a_simd_variants), \ + march?armv7+fp=march?armv9-a$(ARCH)) endif # Not APROFILE. # Use Thumb libraries for everything. diff --git a/gcc/config/bfin/bfin.md b/gcc/config/bfin/bfin.md index 0e44653d7cb..56b24726bc2 100644 --- a/gcc/config/bfin/bfin.md +++ b/gcc/config/bfin/bfin.md @@ -1741,7 +1741,7 @@ (ior:SI (ashift:SI (match_operand:SI 1 "register_operand" "d") (const_int 1)) (zero_extend:SI (reg:BI REG_CC)))) (set (reg:BI REG_CC) - (zero_extract:BI (match_dup 1) (const_int 31) (const_int 0)))] + (zero_extract:BI (match_dup 1) (const_int 1) (const_int 31)))] "" "%0 = ROT %1 BY 1%!" [(set_attr "type" "dsp32shiftimm")]) diff --git a/gcc/config/freebsd.h b/gcc/config/freebsd.h index 28ebcad88d4..d89ee7dfc97 100644 --- a/gcc/config/freebsd.h +++ b/gcc/config/freebsd.h @@ -55,7 +55,7 @@ along with GCC; see the file COPYING3. If not see #endif #undef TARGET_LIBC_HAS_FUNCTION -#define TARGET_LIBC_HAS_FUNCTION no_c99_libc_has_function +#define TARGET_LIBC_HAS_FUNCTION bsd_libc_has_function /* Use --as-needed -lgcc_s for eh support. */ #ifdef HAVE_LD_AS_NEEDED diff --git a/gcc/config/gcn/gcn.cc b/gcc/config/gcn/gcn.cc index 402f0256411..e2e9335ad75 100644 --- a/gcc/config/gcn/gcn.cc +++ b/gcc/config/gcn/gcn.cc @@ -5588,8 +5588,9 @@ gcn_print_lds_decl (FILE *f, tree var) fprintf (f, "%u", gang_private_hwm); gang_private_hwm += size; if (gang_private_hwm > gang_private_size_opt) - error ("gang-private data-share memory exhausted (increase with " - "%<-mgang-private-size=<number>%>)"); + error ("%d bytes of gang-private data-share memory exhausted" + " (increase with %<-mgang-private-size=%d%>, for example)", + gang_private_size_opt, gang_private_hwm); } } diff --git a/gcc/config/i386/avx512fintrin.h b/gcc/config/i386/avx512fintrin.h index 29511fd2831..77d6249c2bc 100644 --- a/gcc/config/i386/avx512fintrin.h +++ b/gcc/config/i386/avx512fintrin.h @@ -3286,31 +3286,67 @@ _mm_maskz_scalef_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R) (__mmask8) __U, __R); } #else -#define _mm512_scalef_round_pd(A, B, C) \ - (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C) - -#define _mm512_mask_scalef_round_pd(W, U, A, B, C) \ - (__m512d)__builtin_ia32_scalefpd512_mask(A, B, W, U, C) - -#define _mm512_maskz_scalef_round_pd(U, A, B, C) \ - (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C) +#define _mm512_scalef_round_pd(A, B, C) \ + ((__m512d) \ + __builtin_ia32_scalefpd512_mask((A), (B), \ + (__v8df) _mm512_undefined_pd(), \ + -1, (C))) + +#define _mm512_mask_scalef_round_pd(W, U, A, B, C) \ + ((__m512d) __builtin_ia32_scalefpd512_mask((A), (B), (W), (U), (C))) + +#define _mm512_maskz_scalef_round_pd(U, A, B, C) \ + ((__m512d) \ + __builtin_ia32_scalefpd512_mask((A), (B), \ + (__v8df) _mm512_setzero_pd(), \ + (U), (C))) + +#define _mm512_scalef_round_ps(A, B, C) \ + ((__m512) \ + __builtin_ia32_scalefps512_mask((A), (B), \ + (__v16sf) _mm512_undefined_ps(), \ + -1, (C))) + +#define _mm512_mask_scalef_round_ps(W, U, A, B, C) \ + ((__m512) __builtin_ia32_scalefps512_mask((A), (B), (W), (U), (C))) + +#define _mm512_maskz_scalef_round_ps(U, A, B, C) \ + ((__m512) \ + __builtin_ia32_scalefps512_mask((A), (B), \ + (__v16sf) _mm512_setzero_ps(), \ + (U), (C))) + +#define _mm_scalef_round_sd(A, B, C) \ + ((__m128d) \ + __builtin_ia32_scalefsd_mask_round ((A), (B), \ + (__v2df) _mm_undefined_pd (), \ + -1, (C))) -#define _mm512_scalef_round_ps(A, B, C) \ - (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C) +#define _mm_scalef_round_ss(A, B, C) \ + ((__m128) \ + __builtin_ia32_scalefss_mask_round ((A), (B), \ + (__v4sf) _mm_undefined_ps (), \ + -1, (C))) -#define _mm512_mask_scalef_round_ps(W, U, A, B, C) \ - (__m512)__builtin_ia32_scalefps512_mask(A, B, W, U, C) +#define _mm_mask_scalef_round_sd(W, U, A, B, C) \ + ((__m128d) \ + __builtin_ia32_scalefsd_mask_round ((A), (B), (W), (U), (C))) -#define _mm512_maskz_scalef_round_ps(U, A, B, C) \ - (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C) +#define _mm_mask_scalef_round_ss(W, U, A, B, C) \ + ((__m128) \ + __builtin_ia32_scalefss_mask_round ((A), (B), (W), (U), (C))) -#define _mm_scalef_round_sd(A, B, C) \ - (__m128d)__builtin_ia32_scalefsd_mask_round (A, B, \ - (__v2df)_mm_setzero_pd (), -1, C) +#define _mm_maskz_scalef_round_sd(U, A, B, C) \ + ((__m128d) \ + __builtin_ia32_scalefsd_mask_round ((A), (B), \ + (__v2df) _mm_setzero_pd (), \ + (U), (C))) -#define _mm_scalef_round_ss(A, B, C) \ - (__m128)__builtin_ia32_scalefss_mask_round (A, B, \ - (__v4sf)_mm_setzero_ps (), -1, C) +#define _mm_maskz_scalef_round_ss(U, A, B, C) \ + ((__m128) \ + __builtin_ia32_scalefss_mask_round ((A), (B), \ + (__v4sf) _mm_setzero_ps (), \ + (U), (C))) #endif #define _mm_mask_scalef_sd(W, U, A, B) \ diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc index 794315ee2f7..31780b6daf7 100644 --- a/gcc/config/i386/i386-expand.cc +++ b/gcc/config/i386/i386-expand.cc @@ -3136,6 +3136,8 @@ ix86_expand_int_movcc (rtx operands[]) bool sign_bit_compare_p = false; rtx op0 = XEXP (operands[1], 0); rtx op1 = XEXP (operands[1], 1); + rtx op2 = operands[2]; + rtx op3 = operands[3]; if (GET_MODE (op0) == TImode || (GET_MODE (op0) == DImode @@ -3153,17 +3155,29 @@ ix86_expand_int_movcc (rtx operands[]) || (op1 == constm1_rtx && (code == GT || code == LE))) sign_bit_compare_p = true; + /* op0 == op1 ? op0 : op3 is equivalent to op0 == op1 ? op1 : op3, + but if op1 is a constant, the latter form allows more optimizations, + either through the last 2 ops being constant handling, or the one + constant and one variable cases. On the other side, for cmov the + former might be better as we don't need to load the constant into + another register. */ + if (code == EQ && CONST_INT_P (op1) && rtx_equal_p (op0, op2)) + op2 = op1; + /* Similarly for op0 != op1 ? op2 : op0 and op0 != op1 ? op2 : op1. */ + else if (code == NE && CONST_INT_P (op1) && rtx_equal_p (op0, op3)) + op3 = op1; + /* Don't attempt mode expansion here -- if we had to expand 5 or 6 HImode insns, we'd be swallowed in word prefix ops. */ if ((mode != HImode || TARGET_FAST_PREFIX) && (mode != (TARGET_64BIT ? TImode : DImode)) - && CONST_INT_P (operands[2]) - && CONST_INT_P (operands[3])) + && CONST_INT_P (op2) + && CONST_INT_P (op3)) { rtx out = operands[0]; - HOST_WIDE_INT ct = INTVAL (operands[2]); - HOST_WIDE_INT cf = INTVAL (operands[3]); + HOST_WIDE_INT ct = INTVAL (op2); + HOST_WIDE_INT cf = INTVAL (op3); HOST_WIDE_INT diff; diff = ct - cf; @@ -3559,6 +3573,9 @@ ix86_expand_int_movcc (rtx operands[]) if (BRANCH_COST (optimize_insn_for_speed_p (), false) <= 2) return false; + operands[2] = op2; + operands[3] = op3; + /* If one of the two operands is an interesting constant, load a constant with the above and mask it in with a logical operation. */ @@ -17036,7 +17053,8 @@ ix86_emit_fp_unordered_jump (rtx label) /* Output code to perform an sinh XFmode calculation. */ -void ix86_emit_i387_sinh (rtx op0, rtx op1) +void +ix86_emit_i387_sinh (rtx op0, rtx op1) { rtx e1 = gen_reg_rtx (XFmode); rtx e2 = gen_reg_rtx (XFmode); @@ -17084,7 +17102,8 @@ void ix86_emit_i387_sinh (rtx op0, rtx op1) /* Output code to perform an cosh XFmode calculation. */ -void ix86_emit_i387_cosh (rtx op0, rtx op1) +void +ix86_emit_i387_cosh (rtx op0, rtx op1) { rtx e1 = gen_reg_rtx (XFmode); rtx e2 = gen_reg_rtx (XFmode); @@ -17106,7 +17125,8 @@ void ix86_emit_i387_cosh (rtx op0, rtx op1) /* Output code to perform an tanh XFmode calculation. */ -void ix86_emit_i387_tanh (rtx op0, rtx op1) +void +ix86_emit_i387_tanh (rtx op0, rtx op1) { rtx e1 = gen_reg_rtx (XFmode); rtx e2 = gen_reg_rtx (XFmode); @@ -17152,7 +17172,8 @@ void ix86_emit_i387_tanh (rtx op0, rtx op1) /* Output code to perform an asinh XFmode calculation. */ -void ix86_emit_i387_asinh (rtx op0, rtx op1) +void +ix86_emit_i387_asinh (rtx op0, rtx op1) { rtx e1 = gen_reg_rtx (XFmode); rtx e2 = gen_reg_rtx (XFmode); @@ -17204,7 +17225,8 @@ void ix86_emit_i387_asinh (rtx op0, rtx op1) /* Output code to perform an acosh XFmode calculation. */ -void ix86_emit_i387_acosh (rtx op0, rtx op1) +void +ix86_emit_i387_acosh (rtx op0, rtx op1) { rtx e1 = gen_reg_rtx (XFmode); rtx e2 = gen_reg_rtx (XFmode); @@ -17230,7 +17252,8 @@ void ix86_emit_i387_acosh (rtx op0, rtx op1) /* Output code to perform an atanh XFmode calculation. */ -void ix86_emit_i387_atanh (rtx op0, rtx op1) +void +ix86_emit_i387_atanh (rtx op0, rtx op1) { rtx e1 = gen_reg_rtx (XFmode); rtx e2 = gen_reg_rtx (XFmode); @@ -17281,7 +17304,8 @@ void ix86_emit_i387_atanh (rtx op0, rtx op1) /* Output code to perform a log1p XFmode calculation. */ -void ix86_emit_i387_log1p (rtx op0, rtx op1) +void +ix86_emit_i387_log1p (rtx op0, rtx op1) { rtx_code_label *label1 = gen_label_rtx (); rtx_code_label *label2 = gen_label_rtx (); @@ -17291,6 +17315,11 @@ void ix86_emit_i387_log1p (rtx op0, rtx op1) rtx cst, cstln2, cst1; rtx_insn *insn; + /* The emit_jump call emits pending stack adjust, make sure it is emitted + before the conditional jump, otherwise the stack adjustment will be + only conditional. */ + do_pending_stack_adjust (); + cst = const_double_from_real_value (REAL_VALUE_ATOF ("0.29289321881345247561810596348408353", XFmode), XFmode); cstln2 = force_reg (XFmode, standard_80387_constant_rtx (4)); /* fldln2 */ @@ -17320,7 +17349,8 @@ void ix86_emit_i387_log1p (rtx op0, rtx op1) } /* Emit code for round calculation. */ -void ix86_emit_i387_round (rtx op0, rtx op1) +void +ix86_emit_i387_round (rtx op0, rtx op1) { machine_mode inmode = GET_MODE (op1); machine_mode outmode = GET_MODE (op0); @@ -17434,7 +17464,8 @@ void ix86_emit_i387_round (rtx op0, rtx op1) /* Output code to perform a Newton-Rhapson approximation of a single precision floating point divide [http://en.wikipedia.org/wiki/N-th_root_algorithm]. */ -void ix86_emit_swdivsf (rtx res, rtx a, rtx b, machine_mode mode) +void +ix86_emit_swdivsf (rtx res, rtx a, rtx b, machine_mode mode) { rtx x0, x1, e0, e1; @@ -17485,7 +17516,8 @@ void ix86_emit_swdivsf (rtx res, rtx a, rtx b, machine_mode mode) /* Output code to perform a Newton-Rhapson approximation of a single precision floating point [reciprocal] square root. */ -void ix86_emit_swsqrtsf (rtx res, rtx a, machine_mode mode, bool recip) +void +ix86_emit_swsqrtsf (rtx res, rtx a, machine_mode mode, bool recip) { rtx x0, e0, e1, e2, e3, mthree, mhalf; REAL_VALUE_TYPE r; @@ -23240,9 +23272,10 @@ ix86_expand_divmod_libfunc (rtx libfunc, machine_mode mode, *rem_p = rem; } -void ix86_expand_atomic_fetch_op_loop (rtx target, rtx mem, rtx val, - enum rtx_code code, bool after, - bool doubleword) +void +ix86_expand_atomic_fetch_op_loop (rtx target, rtx mem, rtx val, + enum rtx_code code, bool after, + bool doubleword) { rtx old_reg, new_reg, old_mem, success; machine_mode mode = GET_MODE (target); @@ -23286,10 +23319,11 @@ void ix86_expand_atomic_fetch_op_loop (rtx target, rtx mem, rtx val, it will be relaxed to an atomic load + compare, and skip cmpxchg instruction if mem != exp_input. */ -void ix86_expand_cmpxchg_loop (rtx *ptarget_bool, rtx target_val, - rtx mem, rtx exp_input, rtx new_input, - rtx mem_model, bool doubleword, - rtx_code_label *loop_label) +void +ix86_expand_cmpxchg_loop (rtx *ptarget_bool, rtx target_val, + rtx mem, rtx exp_input, rtx new_input, + rtx mem_model, bool doubleword, + rtx_code_label *loop_label) { rtx_code_label *cmp_label = NULL; rtx_code_label *done_label = NULL; @@ -23388,6 +23422,7 @@ void ix86_expand_cmpxchg_loop (rtx *ptarget_bool, rtx target_val, /* If mem is not expected, pause and loop back. */ emit_label (cmp_label); + emit_move_insn (target_val, new_mem); emit_insn (gen_pause ()); emit_jump_insn (gen_jump (loop_label)); emit_barrier (); diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index c959b7144de..b16df5b183e 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -4891,6 +4891,7 @@ ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p, { int i, prev_size = 0; tree temp = create_tmp_var (type, "va_arg_tmp"); + TREE_ADDRESSABLE (temp) = 1; /* addr = &temp; */ t = build1 (ADDR_EXPR, build_pointer_type (type), temp); @@ -6524,7 +6525,8 @@ ix86_initial_elimination_offset (int from, int to) } /* Emits a warning for unsupported msabi to sysv pro/epilogues. */ -void warn_once_call_ms2sysv_xlogues (const char *feature) +void +warn_once_call_ms2sysv_xlogues (const char *feature) { static bool warned_once = false; if (!warned_once) @@ -18806,7 +18808,8 @@ ix86_veclibabi_svml (combined_fn fn, tree type_out, tree type_in) return NULL_TREE; } - tree fndecl = mathfn_built_in (TREE_TYPE (type_in), fn); + tree fndecl = mathfn_built_in (el_mode == DFmode + ? double_type_node : float_type_node, fn); bname = IDENTIFIER_POINTER (DECL_NAME (fndecl)); if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_LOGF) @@ -18898,7 +18901,8 @@ ix86_veclibabi_acml (combined_fn fn, tree type_out, tree type_in) return NULL_TREE; } - tree fndecl = mathfn_built_in (TREE_TYPE (type_in), fn); + tree fndecl = mathfn_built_in (el_mode == DFmode + ? double_type_node : float_type_node, fn); bname = IDENTIFIER_POINTER (DECL_NAME (fndecl)); sprintf (name + 7, "%s", bname+10); diff --git a/gcc/config/i386/smmintrin.h b/gcc/config/i386/smmintrin.h index b42b212300f..eb6a451c10a 100644 --- a/gcc/config/i386/smmintrin.h +++ b/gcc/config/i386/smmintrin.h @@ -810,17 +810,11 @@ _mm_cmpgt_epi64 (__m128i __X, __m128i __Y) #include <popcntintrin.h> -#ifndef __SSE4_1__ +#ifndef __CRC32__ #pragma GCC push_options -#pragma GCC target("sse4.1") -#define __DISABLE_SSE4_1__ -#endif /* __SSE4_1__ */ - -#ifndef __SSE4_2__ -#pragma GCC push_options -#pragma GCC target("sse4.2") -#define __DISABLE_SSE4_2__ -#endif /* __SSE4_1__ */ +#pragma GCC target("crc32") +#define __DISABLE_CRC32__ +#endif /* __CRC32__ */ /* Accumulate CRC32 (polynomial 0x11EDC6F41) value. */ extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__)) @@ -849,14 +843,9 @@ _mm_crc32_u64 (unsigned long long __C, unsigned long long __V) } #endif -#ifdef __DISABLE_SSE4_2__ -#undef __DISABLE_SSE4_2__ +#ifdef __DISABLE_CRC32__ +#undef __DISABLE_CRC32__ #pragma GCC pop_options -#endif /* __DISABLE_SSE4_2__ */ - -#ifdef __DISABLE_SSE4_1__ -#undef __DISABLE_SSE4_1__ -#pragma GCC pop_options -#endif /* __DISABLE_SSE4_1__ */ +#endif /* __DISABLE_CRC32__ */ #endif /* _SMMINTRIN_H_INCLUDED */ diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index a852c166a58..5e93aa23b47 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -327,9 +327,7 @@ ;; 128-, 256- and 512-bit float vector modes for bitwise operations (define_mode_iterator VFB - [(V32HF "TARGET_AVX512FP16") - (V16HF "TARGET_AVX512FP16") - (V8HF "TARGET_AVX512FP16") + [(V32HF "TARGET_AVX512F") (V16HF "TARGET_AVX") (V8HF "TARGET_SSE2") (V16SF "TARGET_AVX512F") (V8SF "TARGET_AVX") V4SF (V8DF "TARGET_AVX512F") (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")]) @@ -340,8 +338,7 @@ ;; 128- and 256-bit float vector modes for bitwise operations (define_mode_iterator VFB_128_256 - [(V16HF "TARGET_AVX512FP16") - (V8HF "TARGET_AVX512FP16") + [(V16HF "TARGET_AVX") (V8HF "TARGET_SSE2") (V8SF "TARGET_AVX") V4SF (V4DF "TARGET_AVX") (V2DF "TARGET_SSE2")]) @@ -399,7 +396,7 @@ ;; All 512bit vector float modes for bitwise operations (define_mode_iterator VFB_512 - [(V32HF "TARGET_AVX512FP16") V16SF V8DF]) + [V32HF V16SF V8DF]) (define_mode_iterator VI48_AVX512VL [V16SI (V8SI "TARGET_AVX512VL") (V4SI "TARGET_AVX512VL") @@ -4581,7 +4578,8 @@ (not:VFB_128_256 (match_operand:VFB_128_256 1 "register_operand" "0,x,v,v")) (match_operand:VFB_128_256 2 "vector_operand" "xBm,xm,vm,vm")))] - "TARGET_SSE && <mask_avx512vl_condition>" + "TARGET_SSE && <mask_avx512vl_condition> + && (!<mask_applied> || <ssescalarmode>mode != HFmode)" { char buf[128]; const char *ops; @@ -4648,7 +4646,7 @@ (not:VFB_512 (match_operand:VFB_512 1 "register_operand" "v")) (match_operand:VFB_512 2 "nonimmediate_operand" "vm")))] - "TARGET_AVX512F" + "TARGET_AVX512F && (!<mask_applied> || <ssescalarmode>mode != HFmode)" { char buf[128]; const char *ops; @@ -4683,7 +4681,8 @@ (any_logic:VFB_128_256 (match_operand:VFB_128_256 1 "vector_operand") (match_operand:VFB_128_256 2 "vector_operand")))] - "TARGET_SSE && <mask_avx512vl_condition>" + "TARGET_SSE && <mask_avx512vl_condition> + && (!<mask_applied> || <ssescalarmode>mode != HFmode)" "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);") (define_expand "<code><mode>3<mask_name>" @@ -4691,7 +4690,7 @@ (any_logic:VFB_512 (match_operand:VFB_512 1 "nonimmediate_operand") (match_operand:VFB_512 2 "nonimmediate_operand")))] - "TARGET_AVX512F" + "TARGET_AVX512F && (!<mask_applied> || <ssescalarmode>mode != HFmode)" "ix86_fixup_binary_operands_no_copy (<CODE>, <MODE>mode, operands);") (define_insn "*<code><mode>3<mask_name>" @@ -4700,6 +4699,7 @@ (match_operand:VFB_128_256 1 "vector_operand" "%0,x,v,v") (match_operand:VFB_128_256 2 "vector_operand" "xBm,xm,vm,vm")))] "TARGET_SSE && <mask_avx512vl_condition> + && (!<mask_applied> || <ssescalarmode>mode != HFmode) && !(MEM_P (operands[1]) && MEM_P (operands[2]))" { char buf[128]; @@ -4766,7 +4766,8 @@ (any_logic:VFB_512 (match_operand:VFB_512 1 "nonimmediate_operand" "%v") (match_operand:VFB_512 2 "nonimmediate_operand" "vm")))] - "TARGET_AVX512F && !(MEM_P (operands[1]) && MEM_P (operands[2]))" + "TARGET_AVX512F && !(MEM_P (operands[1]) && MEM_P (operands[2])) + && (!<mask_applied> || <ssescalarmode>mode != HFmode)" { char buf[128]; const char *ops; @@ -16741,17 +16742,6 @@ (match_operand:<avx512fmaskmode> 4 "register_operand")))] "TARGET_AVX512F") -(define_expand "<sse2_avx2>_andnot<mode>3_mask" - [(set (match_operand:VI12_AVX512VL 0 "register_operand") - (vec_merge:VI12_AVX512VL - (and:VI12_AVX512VL - (not:VI12_AVX512VL - (match_operand:VI12_AVX512VL 1 "register_operand")) - (match_operand:VI12_AVX512VL 2 "nonimmediate_operand")) - (match_operand:VI12_AVX512VL 3 "nonimm_or_0_operand") - (match_operand:<avx512fmaskmode> 4 "register_operand")))] - "TARGET_AVX512BW") - (define_insn "*andnot<mode>3" [(set (match_operand:VI 0 "register_operand" "=x,x,v") (and:VI diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc index 6e24111a79d..80046b64006 100644 --- a/gcc/config/loongarch/loongarch.cc +++ b/gcc/config/loongarch/loongarch.cc @@ -329,6 +329,9 @@ loongarch_flatten_aggregate_field (const_tree type, if (!TYPE_P (TREE_TYPE (f))) return -1; + if (DECL_SIZE (f) && integer_zerop (DECL_SIZE (f))) + continue; + HOST_WIDE_INT pos = offset + int_byte_position (f); n = loongarch_flatten_aggregate_field (TREE_TYPE (f), fields, n, pos); @@ -473,13 +476,14 @@ loongarch_pass_aggregate_in_fpr_and_gpr_p (const_tree type, static rtx loongarch_pass_fpr_single (machine_mode type_mode, unsigned regno, - machine_mode value_mode) + machine_mode value_mode, + HOST_WIDE_INT offset) { rtx x = gen_rtx_REG (value_mode, regno); if (type_mode != value_mode) { - x = gen_rtx_EXPR_LIST (VOIDmode, x, const0_rtx); + x = gen_rtx_EXPR_LIST (VOIDmode, x, GEN_INT (offset)); x = gen_rtx_PARALLEL (type_mode, gen_rtvec (1, x)); } return x; @@ -539,7 +543,8 @@ loongarch_get_arg_info (struct loongarch_arg_info *info, { case 1: return loongarch_pass_fpr_single (mode, fregno, - TYPE_MODE (fields[0].type)); + TYPE_MODE (fields[0].type), + fields[0].offset); case 2: return loongarch_pass_fpr_pair (mode, fregno, diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md index 6c57c8b7025..d3c809e25f3 100644 --- a/gcc/config/loongarch/loongarch.md +++ b/gcc/config/loongarch/loongarch.md @@ -713,6 +713,12 @@ ;; ;; Float division and modulus. +(define_expand "div<mode>3" + [(set (match_operand:ANYF 0 "register_operand") + (div:ANYF (match_operand:ANYF 1 "reg_or_1_operand") + (match_operand:ANYF 2 "register_operand")))] + "") + (define_insn "*div<mode>3" [(set (match_operand:ANYF 0 "register_operand" "=f") (div:ANYF (match_operand:ANYF 1 "register_operand" "f") @@ -2047,13 +2053,17 @@ (define_insn "loongarch_ibar" [(unspec_volatile:SI - [(match_operand 0 "const_uimm15_operand")] UNSPECV_IBAR)] + [(match_operand 0 "const_uimm15_operand")] + UNSPECV_IBAR) + (clobber (mem:BLK (scratch)))] "" "ibar\t%0") (define_insn "loongarch_dbar" [(unspec_volatile:SI - [(match_operand 0 "const_uimm15_operand")] UNSPECV_DBAR)] + [(match_operand 0 "const_uimm15_operand")] + UNSPECV_DBAR) + (clobber (mem:BLK (scratch)))] "" "dbar\t%0") @@ -2072,13 +2082,17 @@ (define_insn "loongarch_syscall" [(unspec_volatile:SI - [(match_operand 0 "const_uimm15_operand")] UNSPECV_SYSCALL)] + [(match_operand 0 "const_uimm15_operand")] + UNSPECV_SYSCALL) + (clobber (mem:BLK (scratch)))] "" "syscall\t%0") (define_insn "loongarch_break" [(unspec_volatile:SI - [(match_operand 0 "const_uimm15_operand")] UNSPECV_BREAK)] + [(match_operand 0 "const_uimm15_operand")] + UNSPECV_BREAK) + (clobber (mem:BLK (scratch)))] "" "break\t%0") @@ -2103,7 +2117,8 @@ (define_insn "loongarch_csrrd_<d>" [(set (match_operand:GPR 0 "register_operand" "=r") (unspec_volatile:GPR [(match_operand 1 "const_uimm14_operand")] - UNSPECV_CSRRD))] + UNSPECV_CSRRD)) + (clobber (mem:BLK (scratch)))] "" "csrrd\t%0,%1" [(set_attr "type" "load") @@ -2114,7 +2129,8 @@ (unspec_volatile:GPR [(match_operand:GPR 1 "register_operand" "0") (match_operand 2 "const_uimm14_operand")] - UNSPECV_CSRWR))] + UNSPECV_CSRWR)) + (clobber (mem:BLK (scratch)))] "" "csrwr\t%0,%2" [(set_attr "type" "store") @@ -2126,7 +2142,8 @@ [(match_operand:GPR 1 "register_operand" "0") (match_operand:GPR 2 "register_operand" "q") (match_operand 3 "const_uimm14_operand")] - UNSPECV_CSRXCHG))] + UNSPECV_CSRXCHG)) + (clobber (mem:BLK (scratch)))] "" "csrxchg\t%0,%2,%3" [(set_attr "type" "load") @@ -2135,7 +2152,8 @@ (define_insn "loongarch_iocsrrd_<size>" [(set (match_operand:QHWD 0 "register_operand" "=r") (unspec_volatile:QHWD [(match_operand:SI 1 "register_operand" "r")] - UNSPECV_IOCSRRD))] + UNSPECV_IOCSRRD)) + (clobber (mem:BLK (scratch)))] "" "iocsrrd.<size>\t%0,%1" [(set_attr "type" "load") @@ -2144,7 +2162,8 @@ (define_insn "loongarch_iocsrwr_<size>" [(unspec_volatile:QHWD [(match_operand:QHWD 0 "register_operand" "r") (match_operand:SI 1 "register_operand" "r")] - UNSPECV_IOCSRWR)] + UNSPECV_IOCSRWR) + (clobber (mem:BLK (scratch)))] "" "iocsrwr.<size>\t%0,%1" [(set_attr "type" "load") @@ -2154,7 +2173,8 @@ [(unspec_volatile:X [(match_operand 0 "const_uimm5_operand") (match_operand:X 1 "register_operand" "r") (match_operand 2 "const_imm12_operand")] - UNSPECV_CACOP)] + UNSPECV_CACOP) + (clobber (mem:BLK (scratch)))] "" "cacop\t%0,%1,%2" [(set_attr "type" "load") @@ -2164,7 +2184,8 @@ [(unspec_volatile:X [(match_operand:X 0 "register_operand" "r") (match_operand:X 1 "register_operand" "r") (match_operand 2 "const_uimm5_operand")] - UNSPECV_LDDIR)] + UNSPECV_LDDIR) + (clobber (mem:BLK (scratch)))] "" "lddir\t%0,%1,%2" [(set_attr "type" "load") @@ -2173,7 +2194,8 @@ (define_insn "loongarch_ldpte_<d>" [(unspec_volatile:X [(match_operand:X 0 "register_operand" "r") (match_operand 1 "const_uimm5_operand")] - UNSPECV_LDPTE)] + UNSPECV_LDPTE) + (clobber (mem:BLK (scratch)))] "" "ldpte\t%0,%1" [(set_attr "type" "load") diff --git a/gcc/config/nvptx/nvptx.h b/gcc/config/nvptx/nvptx.h index 3b06f33032f..ed72c253191 100644 --- a/gcc/config/nvptx/nvptx.h +++ b/gcc/config/nvptx/nvptx.h @@ -29,25 +29,6 @@ #define STARTFILE_SPEC "%{mmainkernel:crt0.o}" -/* Newer versions of CUDA no longer support sm_30, and nvptx-tools as - currently doesn't handle that gracefully when verifying - ( https://github.com/MentorEmbedded/nvptx-tools/issues/30 ). Work around - this by verifying with sm_35 when having misa=sm_30 (either implicitly - or explicitly). */ -#define ASM_SPEC \ - "%{" \ - /* Explict misa=sm_30. */ \ - "misa=sm_30:-m sm_35" \ - /* Separator. */ \ - "; " \ - /* Catch-all. */ \ - "misa=*:-m %*" \ - /* Separator. */ \ - "; " \ - /* Implicit misa=sm_30. */ \ - ":-m sm_35" \ - "}" - #define TARGET_CPU_CPP_BUILTINS() nvptx_cpu_cpp_builtins () /* Avoid the default in ../../gcc.cc, which adds "-pthread", which is not diff --git a/gcc/config/nvptx/nvptx.opt b/gcc/config/nvptx/nvptx.opt index 55a10572dd1..c5a5668fce5 100644 --- a/gcc/config/nvptx/nvptx.opt +++ b/gcc/config/nvptx/nvptx.opt @@ -52,7 +52,6 @@ mgomp Target Mask(GOMP) Generate code for OpenMP offloading: enables -msoft-stack and -muniform-simt. -; Default needs to be in sync with default in ASM_SPEC in nvptx.h. misa= Target RejectNegative ToLower Joined Enum(ptx_isa) Var(ptx_isa_option) Init(PTX_ISA_SM30) Specify the PTX ISA target architecture to use. diff --git a/gcc/config/riscv/arch-canonicalize b/gcc/config/riscv/arch-canonicalize index 49a6204b9cb..f36a2ca4593 100755 --- a/gcc/config/riscv/arch-canonicalize +++ b/gcc/config/riscv/arch-canonicalize @@ -20,14 +20,18 @@ # along with GCC; see the file COPYING3. If not see # <http://www.gnu.org/licenses/>. +# TODO: Extract riscv_subset_t from riscv-common.cc and make it can be compiled +# standalone to replace this script, that also prevents us implementing +# that twice and keep sync again and again. from __future__ import print_function import sys +import argparse import collections import itertools from functools import reduce - +SUPPORTED_ISA_SPEC = ["2.2", "20190608", "20191213"] CANONICAL_ORDER = "imafdgqlcbjktpvn" LONG_EXT_PREFIXES = ['z', 's', 'h', 'x'] @@ -35,29 +39,42 @@ LONG_EXT_PREFIXES = ['z', 's', 'h', 'x'] # IMPLIED_EXT(ext) -> implied extension list. # IMPLIED_EXT = { - "d" : ["f"], - "zk" : ["zkn"], - "zk" : ["zkr"], - "zk" : ["zkt"], - "zkn" : ["zbkb"], - "zkn" : ["zbkc"], - "zkn" : ["zbkx"], - "zkn" : ["zkne"], - "zkn" : ["zknd"], - "zkn" : ["zknh"], - "zks" : ["zbkb"], - "zks" : ["zbkc"], - "zks" : ["zbkx"], - "zks" : ["zksed"], - "zks" : ["zksh"], + "d" : ["f", "zicsr"], + "f" : ["zicsr"], + "zk" : ["zkn", "zkr", "zkt"], + "zkn" : ["zbkb", "zbkc", "zbkx", "zkne", "zknd", "zknh"], + "zks" : ["zbkb", "zbkc", "zbkx", "zksed", "zksh"], + + "v" : ["zvl128b", "zve64d"], + "zve32x" : ["zvl32b"], + "zve64x" : ["zve32x", "zvl64b"], + "zve32f" : ["f", "zve32x"], + "zve64f" : ["f", "zve32f", "zve64x"], + "zve64d" : ["d", "zve64f"], + + "zvl64b" : ["zvl32b"], + "zvl128b" : ["zvl64b"], + "zvl256b" : ["zvl128b"], + "zvl512b" : ["zvl256b"], + "zvl1024b" : ["zvl512b"], + "zvl2048b" : ["zvl1024b"], + "zvl4096b" : ["zvl2048b"], + "zvl8192b" : ["zvl4096b"], + "zvl16384b" : ["zvl8192b"], + "zvl32768b" : ["zvl16384b"], + "zvl65536b" : ["zvl32768b"], } -def arch_canonicalize(arch): +def arch_canonicalize(arch, isa_spec): # TODO: Support extension version. + is_isa_spec_2p2 = isa_spec == '2.2' new_arch = "" + extra_long_ext = [] if arch[:5] in ['rv32e', 'rv32i', 'rv32g', 'rv64i', 'rv64g']: - # TODO: We should expand g to imad_zifencei once we support newer spec. new_arch = arch[:5].replace("g", "imafd") + if arch[:5] in ['rv32g', 'rv64g']: + if not is_isa_spec_2p2: + extra_long_ext = ['zicsr', 'zifencei'] else: raise Exception("Unexpected arch: `%s`" % arch[:5]) @@ -74,15 +91,24 @@ def arch_canonicalize(arch): long_exts = [] std_exts = list(arch[5:]) + long_exts += extra_long_ext + # # Handle implied extensions. # - for ext in std_exts + long_exts: - if ext in IMPLIED_EXT: - implied_exts = IMPLIED_EXT[ext] - for implied_ext in implied_exts: - if implied_ext not in std_exts + long_exts: - long_exts.append(implied_ext) + any_change = True + while any_change: + any_change = False + for ext in std_exts + long_exts: + if ext in IMPLIED_EXT: + implied_exts = IMPLIED_EXT[ext] + for implied_ext in implied_exts: + if implied_ext == 'zicsr' and is_isa_spec_2p2: + continue + + if implied_ext not in std_exts + long_exts: + long_exts.append(implied_ext) + any_change = True # Single letter extension might appear in the long_exts list, # becasue we just append extensions list to the arch string. @@ -99,6 +125,9 @@ def arch_canonicalize(arch): return (exts.startswith("x"), exts.startswith("zxm"), LONG_EXT_PREFIXES.index(exts[0]), canonical_sort, exts[1:]) + # Removing duplicates. + long_exts = list(set(long_exts)) + # Multi-letter extension must be in lexicographic order. long_exts = list(sorted(filter(lambda x:len(x) != 1, long_exts), key=longext_sort)) @@ -118,11 +147,20 @@ def arch_canonicalize(arch): # Concat rest of the multi-char extensions. if long_exts: new_arch += "_" + "_".join(long_exts) + return new_arch if len(sys.argv) < 2: print ("Usage: %s <arch_str> [<arch_str>*]" % sys.argv) sys.exit(1) -for arg in sys.argv[1:]: - print (arch_canonicalize(arg)) +parser = argparse.ArgumentParser() +parser.add_argument('-misa-spec', type=str, + default='20191213', + choices=SUPPORTED_ISA_SPEC) +parser.add_argument('arch_strs', nargs=argparse.REMAINDER) + +args = parser.parse_args() + +for arch in args.arch_strs: + print (arch_canonicalize(arch, args.misa_spec)) diff --git a/gcc/config/riscv/multilib-generator b/gcc/config/riscv/multilib-generator index 1ea2fb25566..36698d48f56 100755 --- a/gcc/config/riscv/multilib-generator +++ b/gcc/config/riscv/multilib-generator @@ -46,16 +46,18 @@ import argparse # TODO: Add test for this script. # +SUPPORTED_ISA_SPEC = ["2.2", "20190608", "20191213"] arches = collections.OrderedDict() abis = collections.OrderedDict() required = [] reuse = [] -def arch_canonicalize(arch): +def arch_canonicalize(arch, isa_spec): this_file = os.path.abspath(os.path.join( __file__)) arch_can_script = \ os.path.join(os.path.dirname(this_file), "arch-canonicalize") - proc = subprocess.Popen([sys.executable, arch_can_script, arch], + proc = subprocess.Popen([sys.executable, arch_can_script, + '-misa-spec=%s' % isa_spec, arch], stdout=subprocess.PIPE) out, err = proc.communicate() return out.decode().strip() @@ -133,6 +135,9 @@ options = filter(lambda x:x.startswith("--"), sys.argv[1:]) parser = argparse.ArgumentParser() parser.add_argument("--cmodel", type=str) +parser.add_argument('-misa-spec', type=str, + default='20191213', + choices=SUPPORTED_ISA_SPEC) parser.add_argument("cfgs", type=str, nargs='*') args = parser.parse_args() @@ -158,13 +163,14 @@ for cmodel in cmodels: if cmodel == "compact" and arch.startswith("rv32"): continue - arch = arch_canonicalize (arch) + arch = arch_canonicalize (arch, args.misa_spec) arches[arch] = 1 abis[abi] = 1 extra = list(filter(None, extra.split(','))) ext_combs = expand_combination(ext) alts = sum([[x] + [x + y for y in ext_combs] for x in [arch] + extra], []) - alts = list(map(arch_canonicalize, alts)) + alts = filter(lambda x: len(x) != 0, alts) + alts = list(map(lambda a : arch_canonicalize(a, args.misa_spec), alts)) # Drop duplicated entry. alts = unique(alts) diff --git a/gcc/config/rs6000/rs6000-builtins.def b/gcc/config/rs6000/rs6000-builtins.def index 0f527c5d78f..f4a9f24bcc5 100644 --- a/gcc/config/rs6000/rs6000-builtins.def +++ b/gcc/config/rs6000/rs6000-builtins.def @@ -1190,9 +1190,6 @@ const vd __builtin_altivec_neg_v2df (vd); NEG_V2DF negv2df2 {} - const vsll __builtin_altivec_neg_v2di (vsll); - NEG_V2DI negv2di2 {} - void __builtin_altivec_stvx_v2df (vd, signed long, void *); STVX_V2DF altivec_stvx_v2df {stvec} @@ -2136,6 +2133,9 @@ const vus __builtin_altivec_nand_v8hi_uns (vus, vus); NAND_V8HI_UNS nandv8hi3 {} + const vsll __builtin_altivec_neg_v2di (vsll); + NEG_V2DI negv2di2 {} + const vsc __builtin_altivec_orc_v16qi (vsc, vsc); ORC_V16QI orcv16qi3 {} diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc index ceaddafd33b..bc619592b9e 100644 --- a/gcc/config/rs6000/rs6000.cc +++ b/gcc/config/rs6000/rs6000.cc @@ -25678,11 +25678,20 @@ rs6000_sibcall_aix (rtx value, rtx func_desc, rtx tlsarg, rtx cookie) rtx r12 = NULL_RTX; rtx func_addr = func_desc; - gcc_assert (INTVAL (cookie) == 0); - if (global_tlsarg) tlsarg = global_tlsarg; + /* Handle longcall attributes. */ + if (INTVAL (cookie) & CALL_LONG && SYMBOL_REF_P (func_desc)) + { + /* PCREL can do a sibling call to a longcall function + because we don't need to restore the TOC register. */ + gcc_assert (rs6000_pcrel_p ()); + func_desc = rs6000_longcall_ref (func_desc, tlsarg); + } + else + gcc_assert (INTVAL (cookie) == 0); + /* For ELFv2, r12 and CTR need to hold the function address for an indirect call. */ if (GET_CODE (func_desc) != SYMBOL_REF && DEFAULT_ABI == ABI_ELFv2) diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index fdfbc6566a5..64049a6e521 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -835,8 +835,8 @@ ;; complex forms. Basic data transfer is done later. (define_insn "zero_extendqi<mode>2" - [(set (match_operand:EXTQI 0 "gpc_reg_operand" "=r,r,^wa,^v") - (zero_extend:EXTQI (match_operand:QI 1 "reg_or_mem_operand" "m,r,Z,v")))] + [(set (match_operand:EXTQI 0 "gpc_reg_operand" "=r,r,wa,^v") + (zero_extend:EXTQI (match_operand:QI 1 "reg_or_mem_operand" "m,r,?Z,v")))] "" "@ lbz%U1%X1 %0,%1 @@ -889,8 +889,8 @@ (define_insn "zero_extendhi<mode>2" - [(set (match_operand:EXTHI 0 "gpc_reg_operand" "=r,r,^wa,^v") - (zero_extend:EXTHI (match_operand:HI 1 "reg_or_mem_operand" "m,r,Z,v")))] + [(set (match_operand:EXTHI 0 "gpc_reg_operand" "=r,r,wa,^v") + (zero_extend:EXTHI (match_operand:HI 1 "reg_or_mem_operand" "m,r,?Z,v")))] "" "@ lhz%U1%X1 %0,%1 @@ -944,7 +944,7 @@ (define_insn "zero_extendsi<mode>2" [(set (match_operand:EXTSI 0 "gpc_reg_operand" "=r,r,d,wa,wa,r,wa") - (zero_extend:EXTSI (match_operand:SI 1 "reg_or_mem_operand" "m,r,Z,Z,r,wa,wa")))] + (zero_extend:EXTSI (match_operand:SI 1 "reg_or_mem_operand" "m,r,?Z,?Z,r,wa,wa")))] "" "@ lwz%U1%X1 %0,%1 @@ -7496,7 +7496,7 @@ [(set (match_operand:SI 0 "nonimmediate_operand" "=r, r, r, d, v, - m, Z, Z, + m, ?Z, ?Z, r, r, r, r, wa, wa, wa, v, wa, v, v, @@ -7504,7 +7504,7 @@ r, *h, *h") (match_operand:SI 1 "input_operand" "r, U, - m, Z, Z, + m, ?Z, ?Z, r, d, v, I, L, eI, n, wa, O, wM, wB, @@ -7785,11 +7785,11 @@ ;; MTVSRWZ MF%1 MT%1 NOP (define_insn "*mov<mode>_internal" [(set (match_operand:QHI 0 "nonimmediate_operand" - "=r, r, wa, m, Z, r, + "=r, r, wa, m, ?Z, r, wa, wa, wa, v, ?v, r, wa, r, *c*l, *h") (match_operand:QHI 1 "input_operand" - "r, m, Z, r, wa, i, + "r, m, ?Z, r, wa, i, wa, O, wM, wB, wS, wa, r, *h, r, 0"))] "gpc_reg_operand (operands[0], <MODE>mode) @@ -7973,10 +7973,10 @@ ;; FMR MR MT%0 MF%1 NOP (define_insn "movsd_hardfloat" [(set (match_operand:SD 0 "nonimmediate_operand" - "=!r, d, m, Z, ?d, ?r, + "=!r, d, m, ?Z, ?d, ?r, f, !r, *c*l, !r, *h") (match_operand:SD 1 "input_operand" - "m, Z, r, wx, r, d, + "m, ?Z, r, wx, r, d, f, r, r, *h, 0"))] "(register_operand (operands[0], SDmode) || register_operand (operands[1], SDmode)) @@ -14580,10 +14580,10 @@ [(set_attr "type" "fp,fpstore,mtvsr,mfvsr,store")]) (define_insn_and_split "unpack<mode>_nodm" - [(set (match_operand:<FP128_64> 0 "nonimmediate_operand" "=d,m") + [(set (match_operand:<FP128_64> 0 "nonimmediate_operand" "=d,m,m") (unspec:<FP128_64> - [(match_operand:FMOVE128 1 "register_operand" "d,d") - (match_operand:QI 2 "const_0_to_1_operand" "i,i")] + [(match_operand:FMOVE128 1 "register_operand" "d,d,r") + (match_operand:QI 2 "const_0_to_1_operand" "i,i,i")] UNSPEC_UNPACK_128BIT))] "(!TARGET_POWERPC64 || !TARGET_DIRECT_MOVE) && FLOAT128_2REG_P (<MODE>mode)" "#" @@ -14600,15 +14600,28 @@ operands[3] = gen_rtx_REG (<FP128_64>mode, fp_regno); } - [(set_attr "type" "fp,fpstore")]) + [(set_attr "type" "fp,fpstore,store")]) -(define_insn_and_split "pack<mode>" +(define_expand "pack<mode>" + [(use (match_operand:FMOVE128 0 "register_operand")) + (use (match_operand:<FP128_64> 1 "register_operand")) + (use (match_operand:<FP128_64> 2 "register_operand"))] + "FLOAT128_2REG_P (<MODE>mode)" +{ + if (TARGET_HARD_FLOAT) + emit_insn (gen_pack<mode>_hard (operands[0], operands[1], operands[2])); + else + emit_insn (gen_pack<mode>_soft (operands[0], operands[1], operands[2])); + DONE; +}) + +(define_insn_and_split "pack<mode>_hard" [(set (match_operand:FMOVE128 0 "register_operand" "=&d") (unspec:FMOVE128 [(match_operand:<FP128_64> 1 "register_operand" "d") (match_operand:<FP128_64> 2 "register_operand" "d")] UNSPEC_PACK_128BIT))] - "FLOAT128_2REG_P (<MODE>mode)" + "FLOAT128_2REG_P (<MODE>mode) && TARGET_HARD_FLOAT" "#" "&& reload_completed" [(set (match_dup 3) (match_dup 1)) @@ -14626,6 +14639,34 @@ [(set_attr "type" "fp") (set_attr "length" "8")]) +(define_insn_and_split "pack<mode>_soft" + [(set (match_operand:FMOVE128 0 "register_operand" "=&r") + (unspec:FMOVE128 + [(match_operand:<FP128_64> 1 "register_operand" "r") + (match_operand:<FP128_64> 2 "register_operand" "r")] + UNSPEC_PACK_128BIT))] + "FLOAT128_2REG_P (<MODE>mode) && TARGET_SOFT_FLOAT" + "#" + "&& reload_completed" + [(set (match_dup 3) (match_dup 1)) + (set (match_dup 4) (match_dup 2))] +{ + unsigned dest_hi = REGNO (operands[0]); + unsigned dest_lo = dest_hi + (TARGET_POWERPC64 ? 1 : 2); + + gcc_assert (!IN_RANGE (REGNO (operands[1]), dest_hi, dest_lo)); + gcc_assert (!IN_RANGE (REGNO (operands[2]), dest_hi, dest_lo)); + + operands[3] = gen_rtx_REG (<FP128_64>mode, dest_hi); + operands[4] = gen_rtx_REG (<FP128_64>mode, dest_lo); +} + [(set_attr "type" "integer") + (set (attr "length") + (if_then_else + (match_test "TARGET_POWERPC64") + (const_string "8") + (const_string "16")))]) + (define_insn "unpack<mode>" [(set (match_operand:DI 0 "register_operand" "=wa,wa") (unspec:DI [(match_operand:FMOVE128_VSX 1 "register_operand" "0,wa") diff --git a/gcc/config/s390/3931.md b/gcc/config/s390/3931.md new file mode 100644 index 00000000000..bc97bc50b78 --- /dev/null +++ b/gcc/config/s390/3931.md @@ -0,0 +1,2562 @@ +;; Scheduling description for z16. +;; Copyright (C) 2022 Free Software Foundation, Inc. +;; Contributed by Robin Dapp (rdapp@linux.ibm.com) + +;; 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_attr "z16_unit_fpd" "" +(cond [(eq_attr "mnemonic" +"ddb, +ddbr, +deb, +debr, +dxbr, +sqdb, +sqdbr, +sqeb, +sqebr, +sqxbr, +vfddb, +vfdsb, +vfsqdb, +vfsqsb, +wfddb, +wfdsb, +wfdxb, +wfsqdb, +wfsqxb" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_unit_fxa" "" +(cond [(eq_attr "mnemonic" +"a, +afi, +ag, +agf, +agfi, +agfr, +agh, +aghi, +aghik, +agr, +agrk, +ah, +ahi, +ahik, +ahy, +al, +alc, +alcg, +alcgr, +alcr, +alfi, +alg, +algf, +algfi, +algfr, +alghsik, +algr, +algrk, +alhsik, +alr, +alrk, +aly, +ar, +ark, +ay, +bras, +brasl, +etnd, +exrl, +flogr, +ic, +icm, +icmh, +icmy, +icy, +iihf, +iilf, +ipm, +la, +larl, +lay, +lb, +lbr, +lcgr, +lcr, +lgb, +lgbr, +lgf, +lgfi, +lgfr, +lgfrl, +lgh, +lghi, +lghr, +lghrl, +lgr, +lh, +lhi, +lhr, +lhrl, +lhy, +llcr, +llgcr, +llgfr, +llghr, +llgtr, +llhr, +llihf, +llihh, +llihl, +llilf, +llilh, +llill, +lngr, +lnr, +loc, +locg, +locghi, +locgr, +lochi, +locr, +lpgr, +lpr, +lr, +lrv, +lrvg, +lrvgr, +lrvh, +lrvr, +lt, +ltg, +ltgf, +ltgfr, +ltgr, +ltr, +m, +mfy, +mg, +mgh, +mghi, +mgrk, +mh, +mhi, +mhy, +ml, +mlg, +mlgr, +mlr, +mr, +ms, +msc, +msfi, +msg, +msgc, +msgf, +msgfi, +msgfr, +msgr, +msgrkc, +msr, +msrkc, +msy, +n, +ncgrk, +ncrk, +ng, +ngr, +ngrk, +nihf, +nihh, +nihl, +nilf, +nilh, +nill, +nngrk, +nnrk, +nogrk, +nork, +nr, +nrk, +nxgrk, +nxrk, +ny, +o, +ocgrk, +ocrk, +og, +ogr, +ogrk, +oihf, +oihh, +oihl, +oilf, +oilh, +oill, +or, +ork, +oy, +pfpo, +popcnt, +risbg, +risbgn, +rll, +rllg, +s, +selgr, +selr, +sg, +sgf, +sgfr, +sgh, +sgr, +sgrk, +sh, +shy, +sl, +slb, +slbg, +slbgr, +slbr, +slfi, +slg, +slgf, +slgfi, +slgfr, +slgr, +slgrk, +sll, +sllg, +sllk, +slr, +slrk, +sly, +sr, +sra, +srag, +srak, +srk, +srl, +srlg, +srlk, +sy, +x, +xg, +xgr, +xgrk, +xihf, +xilf, +xr, +xrk, +xy" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_unit_fxb" "" +(cond [(eq_attr "mnemonic" +"agsi, +algsi, +alsi, +asi, +b, +bc, +bcr, +bi, +br, +brcl, +c, +cfi, +cg, +cgf, +cgfi, +cgfr, +cgfrl, +cgh, +cghi, +cghrl, +cghsi, +cgit, +cgr, +cgrl, +cgrt, +ch, +chi, +chrl, +chsi, +chy, +cit, +cl, +clfhsi, +clfi, +clfit, +clg, +clgf, +clgfi, +clgfr, +clgfrl, +clghrl, +clghsi, +clgit, +clgr, +clgrl, +clgrt, +clgt, +clhhsi, +clhrl, +cli, +cliy, +clm, +clmy, +clr, +clrl, +clrt, +clt, +cly, +cr, +crl, +crt, +cy, +j, +jg, +laa, +laag, +lan, +lang, +lao, +laog, +lat, +lax, +laxg, +lcdfr, +ldgr, +ldr, +lgat, +lgdr, +lndfr, +lpdfr, +lzdr, +lzer, +mvghi, +mvhhi, +mvhi, +mvi, +mviy, +ni, +niy, +nop, +nopr, +ntstg, +oi, +oiy, +ppa, +st, +stc, +stcy, +std, +stdy, +ste, +stey, +stg, +stgrl, +sth, +sthrl, +sthy, +stoc, +stocg, +strl, +strv, +strvg, +strvh, +sty, +tend, +tm, +tmh, +tmhh, +tmhl, +tml, +tmlh, +tmll, +tmy, +vlgvb, +vlgvf, +vlgvg, +vlgvh, +vlr, +vlvgb, +vlvgf, +vlvgg, +vlvgh, +vlvgp, +vst, +vstbr, +vstbrf, +vstbrg, +vstbrh, +vstbrq, +vstebrf, +vstebrg, +vstef, +vsteg, +vsterf, +vsterg, +vsterh, +vstl, +vstrl, +vstrlr, +xi, +xiy" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_unit_fxd" "" +(cond [(eq_attr "mnemonic" +"dlgr, +dlr, +dr, +dsgfr, +dsgr" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_unit_lsu" "" +(cond [(eq_attr "mnemonic" +"a, +adb, +aeb, +ag, +agf, +agh, +agsi, +ah, +ahy, +al, +alc, +alcg, +alg, +algf, +algsi, +alsi, +aly, +asi, +ay, +c, +cdb, +ceb, +cg, +cgf, +cgfrl, +cgh, +cghrl, +cghsi, +cgrl, +ch, +chrl, +chsi, +chy, +cl, +clc, +clfhsi, +clg, +clgf, +clgfrl, +clghrl, +clghsi, +clgrl, +clgt, +clhhsi, +clhrl, +cli, +cliy, +clm, +clmy, +clrl, +clt, +cly, +crl, +cy, +ddb, +deb, +ear, +ic, +icm, +icmh, +icmy, +icy, +kdb, +keb, +l, +laa, +laag, +lan, +lang, +lao, +laog, +lat, +lax, +laxg, +lb, +lcbb, +ld, +lde, +ldeb, +ldy, +le, +ley, +lg, +lgat, +lgb, +lgf, +lgfrl, +lgh, +lghrl, +lgrl, +lh, +lhrl, +lhy, +llc, +llgc, +llgf, +llgfrl, +llgh, +llghrl, +llgt, +llh, +llhrl, +loc, +locg, +lrl, +lrv, +lrvg, +lrvh, +lt, +ltg, +ltgf, +ly, +m, +madb, +maeb, +mdb, +meeb, +mfy, +mg, +mgh, +mh, +mhy, +ml, +mlg, +ms, +msc, +msdb, +mseb, +msg, +msgc, +msgf, +msy, +mvghi, +mvhhi, +mvhi, +mvi, +mviy, +n, +ng, +ni, +niy, +ntstg, +ny, +o, +og, +oi, +oiy, +oy, +s, +sar, +sdb, +seb, +sfpc, +sg, +sgf, +sgh, +sh, +shy, +sl, +slb, +slbg, +slg, +slgf, +sly, +sqdb, +sqeb, +st, +stc, +stcy, +std, +stdy, +ste, +stey, +stg, +stgrl, +sth, +sthrl, +sthy, +stoc, +stocg, +strl, +strv, +strvg, +strvh, +sty, +sy, +tabort, +tm, +tmy, +vl, +vlbb, +vlbr, +vlbrf, +vlbrg, +vlbrh, +vlbrq, +vlbrrepf, +vlbrrepg, +vlbrreph, +vleb, +vlebrf, +vlebrg, +vlebrh, +vlef, +vleg, +vleh, +vlerf, +vlerg, +vlerh, +vll, +vllebrzf, +vllebrzg, +vllebrzh, +vllezb, +vllezf, +vllezg, +vllezh, +vllezlf, +vlrepb, +vlrepf, +vlrepg, +vlreph, +vlrl, +vlrlr, +vst, +vstbr, +vstbrf, +vstbrg, +vstbrh, +vstbrq, +vstebrf, +vstebrg, +vstef, +vsteg, +vsterf, +vsterg, +vsterh, +vstl, +vstrl, +vstrlr, +x, +xg, +xi, +xiy, +xy" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_unit_vfu" "" +(cond [(eq_attr "mnemonic" +"adb, +adbr, +adtr, +aeb, +aebr, +axbr, +axtr, +cdb, +cdbr, +cdtr, +ceb, +cebr, +cpsdr, +cxbr, +cxtr, +ddtr, +dxtr, +fidbr, +fidbra, +fidtr, +fiebr, +fiebra, +fixbr, +fixbra, +fixtr, +kdb, +kdbr, +kdtr, +keb, +kebr, +kxbr, +kxtr, +lcdbr, +lcebr, +lcxbr, +ldeb, +ldebr, +ldetr, +le, +ledbr, +ledtr, +ler, +ley, +lndbr, +lnebr, +lnxbr, +lpdbr, +lpebr, +lpxbr, +ltdbr, +ltdtr, +ltebr, +ltxbr, +ltxtr, +lxdb, +lxdbr, +lxdtr, +lxeb, +lxebr, +madb, +madbr, +maeb, +maebr, +mdb, +mdbr, +mdtr, +meeb, +meebr, +msdb, +msdbr, +mseb, +msebr, +mxbr, +mxtr, +sdb, +sdbr, +sdtr, +seb, +sebr, +sxbr, +sxtr, +tcdb, +tceb, +tcxb, +tdcdt, +tdcet, +tdcxt, +vab, +vaccb, +vacccq, +vaccf, +vaccg, +vacch, +vaccq, +vacq, +vaf, +vag, +vah, +vaq, +vavgb, +vavgf, +vavgg, +vavgh, +vavglb, +vavglf, +vavglg, +vavglh, +vbperm, +vcdgb, +vcdlgb, +vcefb, +vcelfb, +vceqb, +vceqbs, +vceqf, +vceqfs, +vceqg, +vceqgs, +vceqh, +vceqhs, +vcfeb, +vcfn, +vcgdb, +vchb, +vchbs, +vchf, +vchfs, +vchg, +vchgs, +vchh, +vchhs, +vchlb, +vchlbs, +vchlf, +vchlfs, +vchlg, +vchlgs, +vchlh, +vchlhs, +vcksm, +vclfeb, +vclfnh, +vclfnl, +vclgdb, +vclzb, +vclzf, +vclzg, +vclzh, +vcnf, +vcrnf, +vctzb, +vctzf, +vctzg, +vctzh, +verimb, +verimf, +verimg, +verimh, +verllb, +verllf, +verllg, +verllh, +verllvb, +verllvf, +verllvg, +verllvh, +veslb, +veslf, +veslg, +veslh, +veslvb, +veslvf, +veslvg, +veslvh, +vesrab, +vesraf, +vesrag, +vesrah, +vesravb, +vesravf, +vesravg, +vesravh, +vesrlb, +vesrlf, +vesrlg, +vesrlh, +vesrlvb, +vesrlvf, +vesrlvg, +vesrlvh, +vfadb, +vfasb, +vfcedb, +vfcedbs, +vfcesb, +vfcesbs, +vfchdb, +vfchdbs, +vfchedb, +vfchedbs, +vfchesb, +vfchesbs, +vfchsb, +vfchsbs, +vfeeb, +vfeef, +vfeeh, +vfeezbs, +vfeezfs, +vfeezhs, +vfeneb, +vfenef, +vfeneh, +vfenezb, +vfenezf, +vfenezh, +vfidb, +vfisb, +vfkedb, +vfkesb, +vfkhdb, +vfkhedb, +vfkhesb, +vfkhsb, +vflcdb, +vflcsb, +vflndb, +vflnsb, +vflpdb, +vflpsb, +vfmadb, +vfmasb, +vfmaxdb, +vfmaxsb, +vfmdb, +vfmindb, +vfminsb, +vfmsb, +vfmsdb, +vfmssb, +vfnmadb, +vfnmasb, +vfnmsdb, +vfnmssb, +vfsdb, +vfssb, +vftcidb, +vftcisb, +vgbm, +vgfmab, +vgfmaf, +vgfmag, +vgfmah, +vgfmb, +vgfmf, +vgfmg, +vgfmh, +vgm, +vgmb, +vgmf, +vgmg, +vgmh, +vistrb, +vistrbs, +vistrf, +vistrfs, +vistrh, +vistrhs, +vlcb, +vlcf, +vlcg, +vlch, +vldeb, +vleb, +vlebrf, +vlebrg, +vlebrh, +vledb, +vlef, +vleg, +vleh, +vleib, +vleif, +vleig, +vleih, +vlpb, +vlpf, +vlpg, +vlph, +vmaeb, +vmaef, +vmaeh, +vmahb, +vmahf, +vmahh, +vmalb, +vmaleb, +vmalef, +vmaleh, +vmalf, +vmalhb, +vmalhf, +vmalhh, +vmalhw, +vmalob, +vmalof, +vmaloh, +vmaob, +vmaof, +vmaoh, +vmeb, +vmef, +vmeh, +vmhb, +vmhf, +vmhh, +vmlb, +vmleb, +vmlef, +vmleh, +vmlf, +vmlhb, +vmlhf, +vmlhh, +vmlhw, +vmlob, +vmlof, +vmloh, +vmnb, +vmnf, +vmng, +vmnh, +vmnlb, +vmnlf, +vmnlg, +vmnlh, +vmob, +vmof, +vmoh, +vmrhb, +vmrhf, +vmrhg, +vmrhh, +vmrlb, +vmrlf, +vmrlg, +vmrlh, +vmslg, +vmxb, +vmxf, +vmxg, +vmxh, +vmxlb, +vmxlf, +vmxlg, +vmxlh, +vn, +vnc, +vnn, +vno, +vnot, +vnx, +vo, +voc, +vone, +vpdi, +vperm, +vpkf, +vpkg, +vpkh, +vpklsf, +vpklsfs, +vpklsg, +vpklsgs, +vpklsh, +vpklshs, +vpksf, +vpksfs, +vpksg, +vpksgs, +vpksh, +vpkshs, +vpopct, +vpopctb, +vpopctf, +vpopctg, +vpopcth, +vrepb, +vrepf, +vrepg, +vreph, +vrepi, +vrepib, +vrepif, +vrepig, +vrepih, +vsb, +vsbcbiq, +vsbiq, +vscbib, +vscbif, +vscbig, +vscbih, +vscbiq, +vsegb, +vsegf, +vsegh, +vsel, +vsf, +vsg, +vsh, +vsl, +vslb, +vsld, +vsldb, +vsq, +vsra, +vsrab, +vsrd, +vsrl, +vsrlb, +vsumb, +vsumgf, +vsumgh, +vsumh, +vsumqf, +vsumqg, +vtm, +vuphb, +vuphf, +vuphh, +vuplb, +vuplf, +vuplhb, +vuplhf, +vuplhh, +vuplhw, +vupllb, +vupllf, +vupllh, +vx, +vzero, +wcdgb, +wcdlgb, +wcefb, +wcelfb, +wcfeb, +wcgdb, +wclfeb, +wclgdb, +wfadb, +wfasb, +wfaxb, +wfcdb, +wfcedb, +wfcesb, +wfcexb, +wfcexbs, +wfchdb, +wfchedb, +wfchesb, +wfchexb, +wfchexbs, +wfchsb, +wfchxb, +wfchxbs, +wfcsb, +wfcxb, +wfidb, +wfisb, +wfixb, +wfkdb, +wfkedb, +wfkesb, +wfkexb, +wfkhdb, +wfkhedb, +wfkhesb, +wfkhexb, +wfkhsb, +wfkhxb, +wfksb, +wfkxb, +wflcdb, +wflcsb, +wflcxb, +wflld, +wflndb, +wflnsb, +wflnxb, +wflpdb, +wflpsb, +wflpxb, +wflrx, +wfmadb, +wfmasb, +wfmaxb, +wfmaxxb, +wfmdb, +wfminxb, +wfmsb, +wfmsdb, +wfmssb, +wfmsxb, +wfmxb, +wfnmaxb, +wfnmsxb, +wfsdb, +wfssb, +wfsxb, +wftcixb, +wldeb, +wledb" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_cracked" "" +(cond [(eq_attr "mnemonic" +"bas, +basr, +cdfbr, +cdftr, +cdgbr, +cdgtr, +cdlfbr, +cdlftr, +cdlgbr, +cdlgtr, +cefbr, +cegbr, +celfbr, +celgbr, +cfdbr, +cfebr, +cfxbr, +cgdbr, +cgdtr, +cgebr, +cgxbr, +cgxtr, +chhsi, +clfdbr, +clfdtr, +clfebr, +clfxbr, +clfxtr, +clgdbr, +clgdtr, +clgebr, +clgxbr, +clgxtr, +cs, +csg, +csy, +d, +efpc, +ex, +lcgfr, +lngfr, +lpgfr, +lpq, +lxr, +lzxr, +rxsbg, +stpq, +vgef, +vgeg, +vscef, +vsceg, +vsteb, +vstebrh, +vsteh" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_expanded" "" +(cond [(eq_attr "mnemonic" +"cds, +cdsg, +cdsy, +cxfbr, +cxftr, +cxgbr, +cxgtr, +cxlfbr, +cxlftr, +cxlgbr, +cxlgtr, +dl, +dlg, +dsg, +dsgf, +lam, +lm, +lmg, +lmy, +sldl, +srda, +srdl, +stam, +stm, +stmg, +stmy, +tbegin, +tbeginc" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_groupalone" "" +(cond [(eq_attr "mnemonic" +"alc, +alcg, +alcgr, +alcr, +axbr, +axtr, +clc, +cxbr, +cxtr, +dlgr, +dlr, +dr, +dsgfr, +dsgr, +dxbr, +dxtr, +fixbr, +fixbra, +fixtr, +flogr, +kxbr, +kxtr, +lcxbr, +lnxbr, +lpxbr, +ltxbr, +ltxtr, +lxdb, +lxdbr, +lxdtr, +lxeb, +lxebr, +m, +madb, +maeb, +maebr, +mfy, +mg, +mgrk, +ml, +mlg, +mlgr, +mlr, +mr, +msdb, +mseb, +msebr, +mvc, +mxbr, +mxtr, +nc, +oc, +ppa, +sfpc, +slb, +slbg, +slbgr, +slbr, +sqxbr, +sxbr, +sxtr, +tabort, +tcxb, +tdcxt, +tend, +xc" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_endgroup" "" +(cond [(eq_attr "mnemonic" +"bras, +brasl, +exrl, +ipm" +) + (const_int 1)] (const_int 0))) + +(define_attr "z16_groupoftwo" "" +(cond [(eq_attr "mnemonic" +"vacccq, +vacq, +vfmadb, +vfmasb, +vfmsdb, +vfmssb, +vfnmadb, +vfnmasb, +vfnmsdb, +vfnmssb, +vgfmab, +vgfmaf, +vgfmag, +vgfmah, +vmaeb, +vmaef, +vmaeh, +vmahb, +vmahf, +vmahh, +vmalb, +vmaleb, +vmalef, +vmaleh, +vmalf, +vmalhb, +vmalhf, +vmalhh, +vmalhw, +vmalob, +vmalof, +vmaloh, +vmaob, +vmaof, +vmaoh, +vmslg, +vperm, +vsbcbiq, +vsbiq, +vsel, +wfmadb, +wfmasb, +wfmaxb, +wfmsdb, +wfmssb, +wfmsxb, +wfnmaxb, +wfnmsxb" +) + (const_int 1)] (const_int 0))) + +(define_insn_reservation "z16_0" 0 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"a, +afi, +ag, +agfi, +aghi, +aghik, +agr, +agrk, +ahi, +ahik, +al, +alfi, +alg, +algf, +algfi, +algfr, +alghsik, +algr, +algrk, +alhsik, +alr, +alrk, +aly, +ar, +ark, +ay, +b, +bc, +bcr, +bi, +br, +bras, +brasl, +brcl, +c, +cfi, +cg, +cgfi, +cghi, +cghsi, +cgit, +cgr, +cgrl, +cgrt, +chi, +chsi, +cit, +cl, +clfhsi, +clfi, +clfit, +clg, +clgf, +clgfi, +clgfr, +clgfrl, +clghrl, +clghsi, +clgit, +clgr, +clgrl, +clgrt, +clgt, +clhhsi, +clhrl, +cli, +cliy, +clr, +clrl, +clrt, +clt, +cly, +cr, +crl, +crt, +cy, +etnd, +exrl, +ic, +icm, +icmh, +icmy, +icy, +iihf, +iilf, +j, +jg, +la, +larl, +lat, +lay, +lb, +lbr, +lcdfr, +lcgr, +lcr, +ldgr, +ldr, +lgat, +lgb, +lgbr, +lgf, +lgfi, +lgfr, +lgfrl, +lgh, +lghi, +lghr, +lghrl, +lgr, +lh, +lhi, +lhr, +lhrl, +lhy, +llcr, +llgcr, +llgfr, +llghr, +llgtr, +llhr, +llihf, +llihh, +llihl, +llilf, +llilh, +llill, +lndfr, +lngr, +lnr, +lpdfr, +lpgr, +lpr, +lr, +lrv, +lrvg, +lrvgr, +lrvh, +lrvr, +lt, +ltg, +ltgf, +ltgfr, +ltgr, +ltr, +lzdr, +lzer, +n, +ncgrk, +ncrk, +ng, +ngr, +ngrk, +nihf, +nihh, +nihl, +nilf, +nilh, +nill, +nngrk, +nnrk, +nogrk, +nop, +nopr, +nork, +nr, +nrk, +nxgrk, +nxrk, +ny, +o, +ocgrk, +ocrk, +og, +ogr, +ogrk, +oihf, +oihh, +oihl, +oilf, +oilh, +oill, +or, +ork, +oy, +pfpo, +risbg, +risbgn, +rll, +rllg, +rnsbg, +rosbg, +s, +sg, +sgr, +sgrk, +sl, +sldl, +slfi, +slg, +slgf, +slgfi, +slgfr, +slgr, +slgrk, +sll, +sllg, +sllk, +slr, +slrk, +sly, +sr, +sra, +srag, +srak, +srda, +srdl, +srk, +srl, +srlg, +srlk, +sy, +tm, +tmh, +tmhh, +tmhl, +tml, +tmlh, +tmll, +tmy, +vlr, +vlvgb, +vlvgf, +vlvgg, +vlvgh, +x, +xg, +xgr, +xgrk, +xihf, +xilf, +xr, +xrk, +xy" +)) "nothing") + +(define_insn_reservation "z16_1" 1 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"agf, +agfr, +agh, +agsi, +ah, +ahy, +algsi, +alsi, +asi, +cgf, +cgfr, +cgfrl, +cgh, +cghrl, +ch, +chrl, +chy, +clm, +clmy, +cpsdr, +laa, +laag, +lan, +lang, +lao, +laog, +lax, +laxg, +le, +ler, +ley, +loc, +locg, +locghi, +locgr, +lochi, +locr, +mvghi, +mvhhi, +mvhi, +mvi, +mviy, +ni, +niy, +ntstg, +oi, +oiy, +selgr, +selr, +sgf, +sgfr, +sgh, +sh, +shy, +st, +stc, +stcy, +stg, +stgrl, +sth, +sthrl, +sthy, +stoc, +stocg, +strl, +strv, +strvg, +strvh, +sty, +vab, +vaccb, +vacccq, +vaccf, +vaccg, +vacch, +vaccq, +vacq, +vaf, +vag, +vah, +vaq, +vavgb, +vavgf, +vavgg, +vavgh, +vavglb, +vavglf, +vavglg, +vavglh, +vbperm, +vceqb, +vceqf, +vceqg, +vceqh, +vcfn, +vchb, +vchf, +vchg, +vchh, +vchlb, +vchlf, +vchlg, +vchlh, +vclfnh, +vclfnl, +vclzb, +vclzf, +vclzg, +vclzh, +vcnf, +vcrnf, +vctzb, +vctzf, +vctzg, +vctzh, +verimb, +verimf, +verimg, +verimh, +verllb, +verllf, +verllg, +verllh, +verllvb, +verllvf, +verllvg, +verllvh, +veslb, +veslf, +veslg, +veslh, +veslvb, +veslvf, +veslvg, +veslvh, +vesrab, +vesraf, +vesrag, +vesrah, +vesravb, +vesravf, +vesravg, +vesravh, +vesrlb, +vesrlf, +vesrlg, +vesrlh, +vesrlvb, +vesrlvf, +vesrlvg, +vesrlvh, +vfcedb, +vfcesb, +vfchdb, +vfchedb, +vfchesb, +vfchsb, +vfkedb, +vfkesb, +vfkhdb, +vfkhedb, +vfkhesb, +vfkhsb, +vflcdb, +vflcsb, +vflndb, +vflnsb, +vflpdb, +vflpsb, +vfmaxdb, +vfmaxsb, +vfmindb, +vfminsb, +vgbm, +vgm, +vgmb, +vgmf, +vgmg, +vgmh, +vlcb, +vlcf, +vlcg, +vlch, +vleb, +vlebrf, +vlebrg, +vlebrh, +vlef, +vleg, +vleh, +vleib, +vleif, +vleig, +vleih, +vlpb, +vlpf, +vlpg, +vlph, +vmnb, +vmnf, +vmng, +vmnh, +vmnlb, +vmnlf, +vmnlg, +vmnlh, +vmrhb, +vmrhf, +vmrhg, +vmrhh, +vmrlb, +vmrlf, +vmrlg, +vmrlh, +vmxb, +vmxf, +vmxg, +vmxh, +vmxlb, +vmxlf, +vmxlg, +vmxlh, +vn, +vnc, +vnn, +vno, +vnot, +vnx, +vo, +voc, +vone, +vpdi, +vperm, +vpkf, +vpkg, +vpkh, +vpklsf, +vpklsg, +vpklsh, +vpksf, +vpksg, +vpksh, +vpopct, +vpopctb, +vpopctf, +vpopctg, +vpopcth, +vrepb, +vrepf, +vrepg, +vreph, +vrepi, +vrepib, +vrepif, +vrepig, +vrepih, +vsb, +vsbcbiq, +vsbiq, +vscbib, +vscbif, +vscbig, +vscbih, +vscbiq, +vsegb, +vsegf, +vsegh, +vsel, +vsf, +vsg, +vsh, +vsl, +vslb, +vsld, +vsldb, +vsq, +vsra, +vsrab, +vsrd, +vsrl, +vsrlb, +vuphb, +vuphf, +vuphh, +vuplb, +vuplf, +vuplhb, +vuplhf, +vuplhh, +vuplhw, +vupllb, +vupllf, +vupllh, +vx, +vzero, +wfcedb, +wfcesb, +wfcexb, +wfchdb, +wfchedb, +wfchesb, +wfchexb, +wfchsb, +wfchxb, +wfkedb, +wfkesb, +wfkexb, +wfkhdb, +wfkhedb, +wfkhesb, +wfkhexb, +wfkhsb, +wfkhxb, +wflcdb, +wflcsb, +wflcxb, +wflndb, +wflnsb, +wflnxb, +wflpdb, +wflpsb, +wflpxb, +wfmaxxb, +wfminxb, +xi, +xiy" +)) "nothing") + +(define_insn_reservation "z16_2" 2 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cdb, +cdbr, +ceb, +cebr, +ear, +ipm, +kdb, +kdbr, +keb, +kebr, +l, +lcbb, +lcdbr, +lcebr, +ld, +lde, +ldy, +lg, +lgdr, +lgrl, +llc, +llgc, +llgf, +llgfrl, +llgh, +llghrl, +llgt, +llh, +llhrl, +lm, +lmg, +lmy, +lndbr, +lnebr, +lpdbr, +lpebr, +lrl, +ltdbr, +ltebr, +ly, +popcnt, +sar, +tcdb, +tceb, +vceqbs, +vceqfs, +vceqgs, +vceqhs, +vchbs, +vchfs, +vchgs, +vchhs, +vchlbs, +vchlfs, +vchlgs, +vchlhs, +vfcedbs, +vfcesbs, +vfchdbs, +vfchedbs, +vfchesbs, +vfchsbs, +vfeeb, +vfeef, +vfeeh, +vfeneb, +vfenef, +vfeneh, +vfenezb, +vfenezf, +vfenezh, +vftcidb, +vftcisb, +vistrb, +vistrf, +vistrh, +vlbrrepf, +vlbrrepg, +vlbrreph, +vlgvb, +vlgvf, +vlgvg, +vlgvh, +vllebrzf, +vllebrzg, +vllebrzh, +vllezb, +vllezf, +vllezg, +vllezh, +vllezlf, +vlrepb, +vlrepf, +vlrepg, +vlreph, +vlrl, +vlvgp, +vpklsfs, +vpklsgs, +vpklshs, +vpksfs, +vpksgs, +vpkshs, +wfcdb, +wfcexbs, +wfchexbs, +wfchxbs, +wfcsb, +wfcxb, +wfkdb, +wfksb, +wfkxb, +wftcixb" +)) "nothing") + +(define_insn_reservation "z16_3" 3 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cds, +cdsy, +mgh, +mghi, +mh, +mhi, +mhy, +std, +stdy, +ste, +stey, +vcksm, +vfeezbs, +vfeezfs, +vfeezhs, +vgfmab, +vgfmaf, +vgfmag, +vgfmah, +vgfmb, +vgfmf, +vgfmg, +vgfmh, +vistrbs, +vistrfs, +vistrhs, +vl, +vlbb, +vlbr, +vlbrf, +vlbrg, +vlbrh, +vlbrq, +vlerf, +vlerg, +vlerh, +vll, +vlrlr, +vmaeb, +vmaef, +vmaeh, +vmahb, +vmahf, +vmahh, +vmalb, +vmaleb, +vmalef, +vmaleh, +vmalf, +vmalhb, +vmalhf, +vmalhh, +vmalhw, +vmalob, +vmalof, +vmaloh, +vmaob, +vmaof, +vmaoh, +vmeb, +vmef, +vmeh, +vmhb, +vmhf, +vmhh, +vmlb, +vmleb, +vmlef, +vmleh, +vmlf, +vmlhb, +vmlhf, +vmlhh, +vmlhw, +vmlob, +vmlof, +vmloh, +vmob, +vmof, +vmoh, +vsumb, +vsumgf, +vsumgh, +vsumh, +vsumqf, +vsumqg, +vtm" +)) "nothing") + +(define_insn_reservation "z16_4" 4 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"bas, +basr, +chhsi, +clc, +ex, +lam, +lcgfr, +lngfr, +lpgfr, +lxr, +lzxr, +ms, +msfi, +msgf, +msgfi, +msgfr, +msr, +msy, +mvc, +nc, +oc, +ppa, +rxsbg, +tabort, +tbegin, +tbeginc, +tend, +vst, +vstbr, +vstbrf, +vstbrg, +vstbrh, +vstbrq, +vstebrf, +vstebrg, +vstef, +vsteg, +vsterf, +vsterg, +vsterh, +vstl, +vstrl, +vstrlr, +xc" +)) "nothing") + +(define_insn_reservation "z16_5" 5 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"adb, +adbr, +aeb, +aebr, +alc, +alcg, +alcgr, +alcr, +cs, +csg, +csy, +fidbr, +fidbra, +fiebr, +fiebra, +ldeb, +ldebr, +ledbr, +madbr, +mdb, +mdbr, +meeb, +meebr, +msc, +msdbr, +msrkc, +sdb, +sdbr, +seb, +sebr, +slb, +slbg, +slbgr, +slbr, +stm, +stmg, +stmy, +vcdgb, +vcdlgb, +vcefb, +vcelfb, +vcfeb, +vcgdb, +vclfeb, +vclgdb, +vfadb, +vfasb, +vfidb, +vfisb, +vfmadb, +vfmasb, +vfmdb, +vfmsb, +vfmsdb, +vfmssb, +vfnmadb, +vfnmasb, +vfnmsdb, +vfnmssb, +vfsdb, +vfssb, +vldeb, +vledb, +vmslg, +wcdgb, +wcdlgb, +wcefb, +wcelfb, +wcfeb, +wcgdb, +wclfeb, +wclgdb, +wfadb, +wfasb, +wfidb, +wfisb, +wflld, +wfmadb, +wfmasb, +wfmdb, +wfmsb, +wfmsdb, +wfmssb, +wfsdb, +wfssb, +wldeb, +wledb" +)) "nothing") + +(define_insn_reservation "z16_6" 6 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"msg, +msgr, +sfpc" +)) "nothing") + +(define_insn_reservation "z16_7" 7 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"adtr, +cdtr, +fidtr, +kdtr, +ldetr, +ltdtr, +msgc, +msgrkc, +sdtr, +tdcdt, +tdcet, +vgef, +vgeg" +)) "nothing") + +(define_insn_reservation "z16_8" 8 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cdsg, +flogr, +lpq, +stpq, +vsteb, +vstebrh, +vsteh" +)) "nothing") + +(define_insn_reservation "z16_9" 9 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cdfbr, +cdgbr, +cdlfbr, +cdlgbr, +cefbr, +cegbr, +celfbr, +celgbr, +cxfbr, +cxgbr, +cxlfbr, +cxlgbr, +m, +madb, +maeb, +maebr, +mfy, +ml, +mlr, +mr, +msdb, +mseb, +msebr, +stam, +wfaxb, +wfixb, +wflrx, +wfsxb" +)) "nothing") + +(define_insn_reservation "z16_10" 10 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"lxdb, +lxdbr, +lxeb, +lxebr, +vscef, +vsceg" +)) "nothing") + +(define_insn_reservation "z16_11" 11 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cfdbr, +cfebr, +cgdbr, +cgebr, +clfdbr, +clfebr, +clgdbr, +clgebr, +mg, +mgrk, +mlg, +mlgr" +)) "nothing") + +(define_insn_reservation "z16_12" 12 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cxbr, +cxftr, +cxlftr, +cxtr, +kxbr, +kxtr, +tcxb, +tdcxt" +)) "nothing") + +(define_insn_reservation "z16_13" 13 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"axbr, +axtr, +fixbr, +fixbra, +fixtr, +lcxbr, +lnxbr, +lpxbr, +ltxbr, +ltxtr, +lxdtr, +sxbr, +sxtr" +)) "nothing") + +(define_insn_reservation "z16_14" 14 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cfxbr, +cgxbr, +clfxbr, +clgxbr, +ledtr" +)) "nothing") + +(define_insn_reservation "z16_16" 16 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cdftr, +cdlftr" +)) "nothing") + +(define_insn_reservation "z16_20" 20 + (and (eq_attr "cpu" "z16") +(eq_attr "mnemonic" +"cdgtr, +cdlgtr, +cgdtr, +cgxtr, +clfdtr, +clfxtr, +clgdtr, +clgxtr, +cxgtr, +cxlgtr, +d, +ddb, +ddbr, +ddtr, +deb, +debr, +dl, +dlg, +dlgr, +dlr, +dr, +dsg, +dsgf, +dsgfr, +dsgr, +dxbr, +dxtr, +efpc, +mdtr, +mxbr, +mxtr, +sqdb, +sqdbr, +sqeb, +sqebr, +sqxbr, +vfddb, +vfdsb, +vfsqdb, +vfsqsb, +wfddb, +wfdsb, +wfdxb, +wfmaxb, +wfmsxb, +wfmxb, +wfnmaxb, +wfnmsxb, +wfsqdb, +wfsqxb" +)) "nothing") + diff --git a/gcc/config/s390/driver-native.cc b/gcc/config/s390/driver-native.cc index 48524c49251..b5eb222872d 100644 --- a/gcc/config/s390/driver-native.cc +++ b/gcc/config/s390/driver-native.cc @@ -123,8 +123,12 @@ s390_host_detect_local_cpu (int argc, const char **argv) case 0x8562: cpu = "z15"; break; + case 0x3931: + case 0x3932: + cpu = "z16"; + break; default: - cpu = "arch14"; + cpu = "z16"; break; } } diff --git a/gcc/config/s390/s390-opts.h b/gcc/config/s390/s390-opts.h index 1ec84631a5f..4ef82ac5d34 100644 --- a/gcc/config/s390/s390-opts.h +++ b/gcc/config/s390/s390-opts.h @@ -38,7 +38,7 @@ enum processor_type PROCESSOR_2964_Z13, PROCESSOR_3906_Z14, PROCESSOR_8561_Z15, - PROCESSOR_ARCH14, + PROCESSOR_3931_Z16, PROCESSOR_NATIVE, PROCESSOR_max }; diff --git a/gcc/config/s390/s390-protos.h b/gcc/config/s390/s390-protos.h index e6251595870..fd4acaae44a 100644 --- a/gcc/config/s390/s390-protos.h +++ b/gcc/config/s390/s390-protos.h @@ -49,7 +49,6 @@ extern void s390_function_profiler (FILE *, int); extern void s390_set_has_landing_pad_p (bool); extern bool s390_hard_regno_rename_ok (unsigned int, unsigned int); extern int s390_class_max_nregs (enum reg_class, machine_mode); -extern bool s390_function_arg_vector (machine_mode, const_tree); extern bool s390_return_addr_from_memory(void); extern bool s390_fma_allowed_p (machine_mode); #if S390_USE_TARGET_ATTRIBUTE diff --git a/gcc/config/s390/s390.cc b/gcc/config/s390/s390.cc index d2af6d8813d..7c3bd6cbe7f 100644 --- a/gcc/config/s390/s390.cc +++ b/gcc/config/s390/s390.cc @@ -337,7 +337,7 @@ const struct s390_processor processor_table[] = { "z13", "z13", PROCESSOR_2964_Z13, &zEC12_cost, 11 }, { "z14", "arch12", PROCESSOR_3906_Z14, &zEC12_cost, 12 }, { "z15", "arch13", PROCESSOR_8561_Z15, &zEC12_cost, 13 }, - { "arch14", "arch14", PROCESSOR_ARCH14, &zEC12_cost, 14 }, + { "z16", "arch14", PROCESSOR_3931_Z16, &zEC12_cost, 14 }, { "native", "", PROCESSOR_NATIVE, NULL, 0 } }; @@ -853,12 +853,6 @@ s390_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, error ("Builtin %qF requires z15 or higher", fndecl); return const0_rtx; } - - if ((bflags & B_NNPA) && !TARGET_NNPA) - { - error ("Builtin %qF requires arch14 or higher.", fndecl); - return const0_rtx; - } } if (fcode >= S390_OVERLOADED_BUILTIN_VAR_OFFSET && fcode < S390_ALL_BUILTIN_MAX) @@ -8525,7 +8519,7 @@ s390_issue_rate (void) case PROCESSOR_2827_ZEC12: case PROCESSOR_2964_Z13: case PROCESSOR_3906_Z14: - case PROCESSOR_ARCH14: + case PROCESSOR_3931_Z16: default: return 1; } @@ -12148,29 +12142,26 @@ s390_function_arg_size (machine_mode mode, const_tree type) gcc_unreachable (); } -/* Return true if a function argument of type TYPE and mode MODE - is to be passed in a vector register, if available. */ +/* Return true if a variable of TYPE should be passed as single value + with type CODE. If STRICT_SIZE_CHECK_P is true the sizes of the + record type and the field type must match. -bool -s390_function_arg_vector (machine_mode mode, const_tree type) + The ABI says that record types with a single member are treated + just like that member would be. This function is a helper to + detect such cases. The function also produces the proper + diagnostics for cases where the outcome might be different + depending on the GCC version. */ +static bool +s390_single_field_struct_p (enum tree_code code, const_tree type, + bool strict_size_check_p) { - if (!TARGET_VX_ABI) - return false; - - if (s390_function_arg_size (mode, type) > 16) - return false; - - /* No type info available for some library calls ... */ - if (!type) - return VECTOR_MODE_P (mode); - - /* The ABI says that record types with a single member are treated - just like that member would be. */ int empty_base_seen = 0; + bool zero_width_bf_skipped_p = false; const_tree orig_type = type; + while (TREE_CODE (type) == RECORD_TYPE) { - tree field, single = NULL_TREE; + tree field, single_type = NULL_TREE; for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) { @@ -12187,48 +12178,108 @@ s390_function_arg_vector (machine_mode mode, const_tree type) continue; } - if (single == NULL_TREE) - single = TREE_TYPE (field); + if (DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (field)) + { + zero_width_bf_skipped_p = true; + continue; + } + + if (single_type == NULL_TREE) + single_type = TREE_TYPE (field); else return false; } - if (single == NULL_TREE) + if (single_type == NULL_TREE) return false; - else - { - /* If the field declaration adds extra byte due to - e.g. padding this is not accepted as vector type. */ - if (int_size_in_bytes (single) <= 0 - || int_size_in_bytes (single) != int_size_in_bytes (type)) - return false; - type = single; - } + + /* Reaching this point we have a struct with a single member and + zero or more zero-sized bit-fields which have been skipped in the + past. */ + + /* If ZERO_WIDTH_BF_SKIPPED_P then the struct will not be accepted. In case + we are not supposed to emit a warning exit early. */ + if (zero_width_bf_skipped_p && !warn_psabi) + return false; + + /* If the field declaration adds extra bytes due to padding this + is not accepted with STRICT_SIZE_CHECK_P. */ + if (strict_size_check_p + && (int_size_in_bytes (single_type) <= 0 + || int_size_in_bytes (single_type) != int_size_in_bytes (type))) + return false; + + type = single_type; } - if (!VECTOR_TYPE_P (type)) + if (TREE_CODE (type) != code) return false; - if (warn_psabi && empty_base_seen) + if (warn_psabi) { - static unsigned last_reported_type_uid; unsigned uid = TYPE_UID (TYPE_MAIN_VARIANT (orig_type)); - if (uid != last_reported_type_uid) - { - const char *url = CHANGES_ROOT_URL "gcc-10/changes.html#empty_base"; - last_reported_type_uid = uid; - if (empty_base_seen & 1) - inform (input_location, - "parameter passing for argument of type %qT when C++17 " - "is enabled changed to match C++14 %{in GCC 10.1%}", - orig_type, url); - else - inform (input_location, - "parameter passing for argument of type %qT with " - "%<[[no_unique_address]]%> members changed " - "%{in GCC 10.1%}", orig_type, url); + + if (empty_base_seen) + { + static unsigned last_reported_type_uid_empty_base; + if (uid != last_reported_type_uid_empty_base) + { + last_reported_type_uid_empty_base = uid; + const char *url = CHANGES_ROOT_URL "gcc-10/changes.html#empty_base"; + if (empty_base_seen & 1) + inform (input_location, + "parameter passing for argument of type %qT when C++17 " + "is enabled changed to match C++14 %{in GCC 10.1%}", + orig_type, url); + else + inform (input_location, + "parameter passing for argument of type %qT with " + "%<[[no_unique_address]]%> members changed " + "%{in GCC 10.1%}", orig_type, url); + } + } + + /* For C++ older GCCs ignored zero width bitfields and therefore + passed structs more often as single values than GCC 12 does. + So diagnostics are only required in cases where we do NOT + accept the struct to be passed as single value. */ + if (zero_width_bf_skipped_p) + { + static unsigned last_reported_type_uid_zero_width; + if (uid != last_reported_type_uid_zero_width) + { + last_reported_type_uid_zero_width = uid; + inform (input_location, + "parameter passing for argument of type %qT with " + "zero-width bit fields members changed in GCC 12", + orig_type); + } } } + + return !zero_width_bf_skipped_p; +} + + +/* Return true if a function argument of type TYPE and mode MODE + is to be passed in a vector register, if available. */ + +static bool +s390_function_arg_vector (machine_mode mode, const_tree type) +{ + if (!TARGET_VX_ABI) + return false; + + if (s390_function_arg_size (mode, type) > 16) + return false; + + /* No type info available for some library calls ... */ + if (!type) + return VECTOR_MODE_P (mode); + + if (!s390_single_field_struct_p (VECTOR_TYPE, type, true)) + return false; + return true; } @@ -12249,64 +12300,9 @@ s390_function_arg_float (machine_mode mode, const_tree type) if (!type) return mode == SFmode || mode == DFmode || mode == SDmode || mode == DDmode; - /* The ABI says that record types with a single member are treated - just like that member would be. */ - int empty_base_seen = 0; - const_tree orig_type = type; - while (TREE_CODE (type) == RECORD_TYPE) - { - tree field, single = NULL_TREE; - - for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) - { - if (TREE_CODE (field) != FIELD_DECL) - continue; - if (DECL_FIELD_ABI_IGNORED (field)) - { - if (lookup_attribute ("no_unique_address", - DECL_ATTRIBUTES (field))) - empty_base_seen |= 2; - else - empty_base_seen |= 1; - continue; - } - - if (single == NULL_TREE) - single = TREE_TYPE (field); - else - return false; - } - - if (single == NULL_TREE) - return false; - else - type = single; - } - - if (TREE_CODE (type) != REAL_TYPE) + if (!s390_single_field_struct_p (REAL_TYPE, type, false)) return false; - if (warn_psabi && empty_base_seen) - { - static unsigned last_reported_type_uid; - unsigned uid = TYPE_UID (TYPE_MAIN_VARIANT (orig_type)); - if (uid != last_reported_type_uid) - { - const char *url = CHANGES_ROOT_URL "gcc-10/changes.html#empty_base"; - last_reported_type_uid = uid; - if (empty_base_seen & 1) - inform (input_location, - "parameter passing for argument of type %qT when C++17 " - "is enabled changed to match C++14 %{in GCC 10.1%}", - orig_type, url); - else - inform (input_location, - "parameter passing for argument of type %qT with " - "%<[[no_unique_address]]%> members changed " - "%{in GCC 10.1%}", orig_type, url); - } - } - return true; } @@ -14879,7 +14875,6 @@ s390_get_sched_attrmask (rtx_insn *insn) mask |= S390_SCHED_ATTR_MASK_GROUPOFTWO; break; case PROCESSOR_8561_Z15: - case PROCESSOR_ARCH14: if (get_attr_z15_cracked (insn)) mask |= S390_SCHED_ATTR_MASK_CRACKED; if (get_attr_z15_expanded (insn)) @@ -14891,6 +14886,18 @@ s390_get_sched_attrmask (rtx_insn *insn) if (get_attr_z15_groupoftwo (insn)) mask |= S390_SCHED_ATTR_MASK_GROUPOFTWO; break; + case PROCESSOR_3931_Z16: + if (get_attr_z16_cracked (insn)) + mask |= S390_SCHED_ATTR_MASK_CRACKED; + if (get_attr_z16_expanded (insn)) + mask |= S390_SCHED_ATTR_MASK_EXPANDED; + if (get_attr_z16_endgroup (insn)) + mask |= S390_SCHED_ATTR_MASK_ENDGROUP; + if (get_attr_z16_groupalone (insn)) + mask |= S390_SCHED_ATTR_MASK_GROUPALONE; + if (get_attr_z16_groupoftwo (insn)) + mask |= S390_SCHED_ATTR_MASK_GROUPOFTWO; + break; default: gcc_unreachable (); } @@ -14927,7 +14934,6 @@ s390_get_unit_mask (rtx_insn *insn, int *units) mask |= 1 << 3; break; case PROCESSOR_8561_Z15: - case PROCESSOR_ARCH14: *units = 4; if (get_attr_z15_unit_lsu (insn)) mask |= 1 << 0; @@ -14938,6 +14944,17 @@ s390_get_unit_mask (rtx_insn *insn, int *units) if (get_attr_z15_unit_vfu (insn)) mask |= 1 << 3; break; + case PROCESSOR_3931_Z16: + *units = 4; + if (get_attr_z16_unit_lsu (insn)) + mask |= 1 << 0; + if (get_attr_z16_unit_fxa (insn)) + mask |= 1 << 1; + if (get_attr_z16_unit_fxb (insn)) + mask |= 1 << 2; + if (get_attr_z16_unit_vfu (insn)) + mask |= 1 << 3; + break; default: gcc_unreachable (); } @@ -14951,7 +14968,7 @@ s390_is_fpd (rtx_insn *insn) return false; return get_attr_z13_unit_fpd (insn) || get_attr_z14_unit_fpd (insn) - || get_attr_z15_unit_fpd (insn); + || get_attr_z15_unit_fpd (insn) || get_attr_z16_unit_fpd (insn); } static bool @@ -14961,7 +14978,7 @@ s390_is_fxd (rtx_insn *insn) return false; return get_attr_z13_unit_fxd (insn) || get_attr_z14_unit_fxd (insn) - || get_attr_z15_unit_fxd (insn); + || get_attr_z15_unit_fxd (insn) || get_attr_z16_unit_fxd (insn); } /* Returns TRUE if INSN is a long-running instruction. */ diff --git a/gcc/config/s390/s390.h b/gcc/config/s390/s390.h index 5a64048a5a1..2e1bc71e73a 100644 --- a/gcc/config/s390/s390.h +++ b/gcc/config/s390/s390.h @@ -43,12 +43,12 @@ enum processor_flags PF_VXE2 = 8192, PF_Z15 = 16384, PF_NNPA = 32768, - PF_ARCH14 = 65536 + PF_Z16 = 65536 }; /* This is necessary to avoid a warning about comparing different enum types. */ -#define s390_tune_attr ((enum attr_cpu)(s390_tune > PROCESSOR_8561_Z15 ? PROCESSOR_8561_Z15 : s390_tune )) +#define s390_tune_attr ((enum attr_cpu)(s390_tune > PROCESSOR_3931_Z16 ? PROCESSOR_3931_Z16 : s390_tune )) /* These flags indicate that the generated code should run on a cpu providing the respective hardware facility regardless of the @@ -110,10 +110,10 @@ enum processor_flags (s390_arch_flags & PF_VXE2) #define TARGET_CPU_VXE2_P(opts) \ (opts->x_s390_arch_flags & PF_VXE2) -#define TARGET_CPU_ARCH14 \ - (s390_arch_flags & PF_ARCH14) -#define TARGET_CPU_ARCH14_P(opts) \ - (opts->x_s390_arch_flags & PF_ARCH14) +#define TARGET_CPU_Z16 \ + (s390_arch_flags & PF_Z16) +#define TARGET_CPU_Z16_P(opts) \ + (opts->x_s390_arch_flags & PF_Z16) #define TARGET_CPU_NNPA \ (s390_arch_flags & PF_NNPA) #define TARGET_CPU_NNPA_P(opts) \ @@ -177,9 +177,9 @@ enum processor_flags (TARGET_VX && TARGET_CPU_VXE2) #define TARGET_VXE2_P(opts) \ (TARGET_VX_P (opts) && TARGET_CPU_VXE2_P (opts)) -#define TARGET_ARCH14 (TARGET_ZARCH && TARGET_CPU_ARCH14) -#define TARGET_ARCH14_P(opts) \ - (TARGET_ZARCH_P (opts->x_target_flags) && TARGET_CPU_ARCH14_P (opts)) +#define TARGET_Z16 (TARGET_ZARCH && TARGET_CPU_Z16) +#define TARGET_Z16_P(opts) \ + (TARGET_ZARCH_P (opts->x_target_flags) && TARGET_CPU_Z16_P (opts)) #define TARGET_NNPA \ (TARGET_ZARCH && TARGET_CPU_NNPA) #define TARGET_NNPA_P(opts) \ diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md index d0f233e016b..55c0064bba8 100644 --- a/gcc/config/s390/s390.md +++ b/gcc/config/s390/s390.md @@ -518,11 +518,11 @@ ;; Processor type. This attribute must exactly match the processor_type ;; enumeration in s390.h. -(define_attr "cpu" "z900,z990,z9_109,z9_ec,z10,z196,zEC12,z13,z14,z15" +(define_attr "cpu" "z900,z990,z9_109,z9_ec,z10,z196,zEC12,z13,z14,z15,z16" (const (symbol_ref "s390_tune_attr"))) (define_attr "cpu_facility" - "standard,ieee,zarch,cpu_zarch,longdisp,extimm,dfp,z10,z196,zEC12,vx,z13,z14,vxe,z15,vxe2,arch14,nnpa" + "standard,ieee,zarch,cpu_zarch,longdisp,extimm,dfp,z10,z196,zEC12,vx,z13,z14,vxe,z15,vxe2,z16,nnpa" (const_string "standard")) (define_attr "enabled" "" @@ -588,8 +588,8 @@ (match_test "TARGET_VXE2")) (const_int 1) - (and (eq_attr "cpu_facility" "arch14") - (match_test "TARGET_ARCH14")) + (and (eq_attr "cpu_facility" "z16") + (match_test "TARGET_Z16")) (const_int 1) (and (eq_attr "cpu_facility" "nnpa") @@ -629,6 +629,9 @@ ;; Pipeline description for z15 (include "8561.md") +;; Pipeline description for z16 +(include "3931.md") + ;; Predicates (include "predicates.md") diff --git a/gcc/config/s390/s390.opt b/gcc/config/s390/s390.opt index 50684868692..9e8d3bfd404 100644 --- a/gcc/config/s390/s390.opt +++ b/gcc/config/s390/s390.opt @@ -116,7 +116,10 @@ EnumValue Enum(processor_type) String(arch13) Value(PROCESSOR_8561_Z15) EnumValue -Enum(processor_type) String(arch14) Value(PROCESSOR_ARCH14) +Enum(processor_type) String(arch14) Value(PROCESSOR_3931_Z16) + +EnumValue +Enum(processor_type) String(z16) Value(PROCESSOR_3931_Z16) EnumValue Enum(processor_type) String(native) Value(PROCESSOR_NATIVE) DriverOnly diff --git a/gcc/config/sparc/sparc.cc b/gcc/config/sparc/sparc.cc index bb4ce886785..467a9f171d2 100644 --- a/gcc/config/sparc/sparc.cc +++ b/gcc/config/sparc/sparc.cc @@ -8884,8 +8884,20 @@ epilogue_renumber (rtx *where, int test) if (REGNO (*where) >= 8 && REGNO (*where) < 24) /* oX or lX */ return 1; if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32) - *where = gen_rtx_REG (GET_MODE (*where), OUTGOING_REGNO (REGNO(*where))); - /* fallthrough */ + { + if (ORIGINAL_REGNO (*where)) + { + rtx n = gen_raw_REG (GET_MODE (*where), + OUTGOING_REGNO (REGNO (*where))); + ORIGINAL_REGNO (n) = ORIGINAL_REGNO (*where); + *where = n; + } + else + *where = gen_rtx_REG (GET_MODE (*where), + OUTGOING_REGNO (REGNO (*where))); + } + return 0; + case SCRATCH: case PC: case CONST_INT: diff --git a/gcc/configure b/gcc/configure index 7717863ae65..8e685ffa62a 100755 --- a/gcc/configure +++ b/gcc/configure @@ -30625,7 +30625,10 @@ $as_echo_n "checking linker for compressed debug sections... " >&6; } # In binutils 2.26, gld gained support for the ELF gABI format. if test $in_tree_ld = yes ; then gcc_cv_ld_compress_debug=0 - if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 19 -o "$gcc_cv_gld_major_version" -gt 2 \ + if test $ld_is_mold = yes; then + gcc_cv_ld_compress_debug=3 + gcc_cv_ld_compress_debug_option="--compress-debug-sections" + elif test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 19 -o "$gcc_cv_gld_major_version" -gt 2 \ && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then gcc_cv_ld_compress_debug=2 gcc_cv_ld_compress_debug_option="--compress-debug-sections" @@ -30638,7 +30641,10 @@ if test $in_tree_ld = yes ; then gcc_cv_ld_compress_debug=1 fi elif echo "$ld_ver" | grep GNU > /dev/null; then - if test "$ld_vers_major" -lt 2 \ + if test $ld_is_mold = yes; then + gcc_cv_ld_compress_debug=3 + gcc_cv_ld_compress_debug_option="--compress-debug-sections" + elif test "$ld_vers_major" -lt 2 \ || test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then gcc_cv_ld_compress_debug=0 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then diff --git a/gcc/configure.ac b/gcc/configure.ac index 54c8445e489..d3b07c0d623 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -6266,7 +6266,10 @@ AC_MSG_CHECKING(linker for compressed debug sections) # In binutils 2.26, gld gained support for the ELF gABI format. if test $in_tree_ld = yes ; then gcc_cv_ld_compress_debug=0 - if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 19 -o "$gcc_cv_gld_major_version" -gt 2 \ + if test $ld_is_mold = yes; then + gcc_cv_ld_compress_debug=3 + gcc_cv_ld_compress_debug_option="--compress-debug-sections" + elif test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 19 -o "$gcc_cv_gld_major_version" -gt 2 \ && test $in_tree_ld_is_elf = yes && test $ld_is_gold = yes; then gcc_cv_ld_compress_debug=2 gcc_cv_ld_compress_debug_option="--compress-debug-sections" @@ -6279,7 +6282,10 @@ if test $in_tree_ld = yes ; then gcc_cv_ld_compress_debug=1 fi elif echo "$ld_ver" | grep GNU > /dev/null; then - if test "$ld_vers_major" -lt 2 \ + if test $ld_is_mold = yes; then + gcc_cv_ld_compress_debug=3 + gcc_cv_ld_compress_debug_option="--compress-debug-sections" + elif test "$ld_vers_major" -lt 2 \ || test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 21; then gcc_cv_ld_compress_debug=0 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 26; then diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 5db636add14..3ef9e8959a9 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,280 @@ +2022-04-27 Jason Merrill <jason@redhat.com> + + * tree.cc (strip_typedefs): Add default argument comments. + +2022-04-27 Marek Polacek <polacek@redhat.com> + + PR c++/105398 + * pt.cc (uses_template_parms): Return false for any NAMESPACE_DECL. + +2022-04-26 Jason Merrill <jason@redhat.com> + + PR c++/102629 + * pt.cc (gen_elem_of_pack_expansion_instantiation): Clear + TEMPLATE_TYPE_PARAMETER_PACK on auto. + +2022-04-26 Patrick Palka <ppalka@redhat.com> + + PR c++/105386 + * semantics.cc (finish_decltype_type): Pass tf_decltype to + instantiate_non_dependent_expr_sfinae. + +2022-04-26 Jason Merrill <jason@redhat.com> + + PR c++/104624 + * pt.cc (check_for_bare_parameter_packs): Check for lambda + function parameter pack. + +2022-04-26 Patrick Palka <ppalka@redhat.com> + + PR c++/105289 + PR c++/86193 + * pt.cc (process_partial_specialization): Downgrade "partial + specialization isn't more specialized" diagnostic from permerror + to an on-by-default pedwarn. + (unify) <case TEMPLATE_PARM_INDEX>: When substituting into the + NTTP type a second time, use the original type not the + substituted type. + +2022-04-25 Marek Polacek <polacek@redhat.com> + + PR c++/105353 + * typeck.cc (build_x_shufflevector): Use + instantiation_dependent_expression_p except for the first two + arguments. + +2022-04-21 Marek Polacek <polacek@redhat.com> + + * constexpr.cc (cxx_eval_logical_expression): Remove unused + parameter. + (cxx_eval_constant_expression) <case TRUTH_ANDIF_EXPR>, + <case TRUTH_OR_EXPR>: Adjust calls to cxx_eval_logical_expression. + +2022-04-21 Marek Polacek <polacek@redhat.com> + + PR c++/105321 + * constexpr.cc (cxx_eval_logical_expression): Always pass false for lval + to cxx_eval_constant_expression. + +2022-04-20 Ed Catmur <ed@catmur.uk> + + PR c++/104996 + * call.cc (compare_ics): When comparing list-initialization + sequences, do not return early. + +2022-04-19 Jakub Jelinek <jakub@redhat.com> + + PR c++/105256 + * typeck2.cc (process_init_constructor_array, + process_init_constructor_record, process_init_constructor_union): Move + CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag from CONSTRUCTOR elements to the + containing CONSTRUCTOR. + +2022-04-15 Marek Polacek <polacek@redhat.com> + + PR c++/105268 + * parser.cc (cp_parser_placeholder_type_specifier): Return + error_mark_node when trying to build up a constrained parameter in + a default argument. + +2022-04-15 Jason Merrill <jason@redhat.com> + + PR c++/102804 + * decl.cc (grokdeclarator): Drop typedef used with 'unsigned'. + +2022-04-15 Jason Merrill <jason@redhat.com> + + PR c++/102987 + * error.cc (dump_expr): Handle USING_DECL. + [VIEW_CONVERT_EXPR]: Just look through location wrapper. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/104646 + * constexpr.cc (maybe_save_constexpr_fundef): Don't do extra + checks for defaulted ctors. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/82980 + * lambda.cc (type_deducible_expression_p): New. + (lambda_capture_field_type): Check it. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/65211 + * pt.cc (tsubst_decl) [TYPE_DECL]: Copy TYPE_ALIGN. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/97219 + * name-lookup.cc (dependent_local_decl_p): New. + * cp-tree.h (dependent_local_decl_p): Declare. + * semantics.cc (finish_call_expr): Use it. + * pt.cc (tsubst_arg_types): Also substitute default args + for local externs. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/101698 + * pt.cc (tsubst_baselink): Also check dependent optype. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/101442 + * decl.cc (cp_finish_decl): Don't pass decl to push_cleanup. + * init.cc (perform_member_init): Likewise. + * semantics.cc (push_cleanup): Adjust comment. + +2022-04-13 Jason Merrill <jason@redhat.com> + + PR c++/105245 + PR c++/100111 + * constexpr.cc (cxx_eval_store_expression): Build a CONSTRUCTOR + as needed in empty base handling. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + PR c++/105233 + * decl2.cc (cp_check_const_attributes): For aligned attribute + pass manifestly_const_eval=true to fold_non_dependent_expr. + +2022-04-13 Marek Polacek <polacek@redhat.com> + + PR c++/97296 + * call.cc (direct_reference_binding): strip_top_quals when creating + a ck_qual. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/104669 + * decl.cc (decls_match): Compare versions even if not recording. + (duplicate_decls): Propagate attributes to alias. + * decl2.cc (find_last_decl): Give up if versioned. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/102071 + * init.cc (build_new_1): Check array_p for alignment. + +2022-04-12 Patrick Palka <ppalka@redhat.com> + + PR c++/103105 + * pt.cc (build_extra_args): Call preserve_args. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/104142 + * decl.cc (check_initializer): Check TREE_SIDE_EFFECTS. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/105223 + PR c++/92918 + * class.cc (finish_struct): Always using op=. + +2022-04-11 Jason Merrill <jason@redhat.com> + + PR c++/98249 + * call.cc (build_operator_new_call): Just look in ::. + +2022-04-11 Alexandre Oliva <oliva@adacore.com> + + * constexpr.cc (cxx_eval_call_expression): Disregard dtor + result. + +2022-04-11 Alexandre Oliva <oliva@adacore.com> + + * semantics.cc (set_cleanup_locs): Propagate locus to call + wrapped in cast-to-void. + +2022-04-11 Jason Merrill <jason@redhat.com> + + PR c++/100370 + * init.cc (warn_placement_new_too_small): Check deref. + +2022-04-09 Jason Merrill <jason@redhat.com> + + PR c++/105191 + PR c++/92385 + * tree.cc (build_vec_init_elt): Do {}-init for aggregates. + * constexpr.cc (cxx_eval_vec_init): Only treat {} as value-init + for non-aggregate types. + (build_vec_init_expr): Also check constancy of explicit + initializer elements. + +2022-04-09 Jason Merrill <jason@redhat.com> + + PR c++/91618 + PR c++/96604 + * name-lookup.cc (set_decl_namespace): Set + DECL_IMPLICIT_INSTANTIATION if no non-template match. + * pt.cc (check_explicit_specialization): Check it. + * decl2.cc (check_classfn): Call it. + +2022-04-07 Patrick Palka <ppalka@redhat.com> + + PR c++/99479 + * name-lookup.cc (name_lookup::using_queue): Change to an + auto_vec (with 16 elements of internal storage). + (name_lookup::queue_namespace): Change return type to void, + take queue parameter by reference and adjust function body + accordingly. + (name_lookup::do_queue_usings): Inline into ... + (name_lookup::queue_usings): ... here. As in queue_namespace. + (name_lookup::search_unqualified): Don't make queue static, + remove length variable, and adjust function body accordingly. + +2022-04-07 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/102586 + * cp-objcp-common.h (cp_classtype_as_base): Declare. + (LANG_HOOKS_CLASSTYPE_AS_BASE): Redefine. + * cp-objcp-common.cc (cp_classtype_as_base): New function. + +2022-04-07 Jason Merrill <jason@redhat.com> + + PR c++/101051 + * decl.cc (grokdeclarator): Reject conversion with trailing return + sooner. + +2022-04-07 Jason Merrill <jason@redhat.com> + + PR c++/101717 + * lambda.cc (lambda_expr_this_capture): Check all enclosing + lambdas for completeness. + +2022-04-07 Jason Merrill <jason@redhat.com> + + PR c++/105187 + * typeck2.cc (store_init_value): Allow TREE_HAS_CONSTRUCTOR for + vectors. + +2022-04-06 Jakub Jelinek <jakub@redhat.com> + + PR c++/104668 + * decl2.cc (splice_template_attributes): Return NULL if *p is + error_mark_node. + (cplus_decl_attributes): Return early if attributes is + error_mark_node. Don't check that later. + +2022-04-06 Patrick Palka <ppalka@redhat.com> + + PR c++/105143 + * pt.cc (do_class_deduction): Check complain before attempting + to issue a -Wctad-maybe-unsupported warning. + +2022-04-06 Jason Merrill <jason@redhat.com> + + PR c++/104702 + * init.cc (build_vec_init): Use a reference for the result. + +2022-04-06 Jason Merrill <jason@redhat.com> + + PR c++/100608 + * name-lookup.cc (check_local_shadow): Use -Wshadow=local + if exactly one of 'old' and 'decl' is a type. + 2022-04-05 Jason Merrill <jason@redhat.com> PR c++/103852 diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index 73fede5a3df..fa18d7f8f9d 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -1680,8 +1680,19 @@ direct_reference_binding (tree type, conversion *conv) because the types "int *" and "const int *const" are reference-related and we were binding both directly and they had the same rank. To break it up, we add a ck_qual under the - ck_ref_bind so that conversion sequence ranking chooses #1. */ - conv = build_conv (ck_qual, t, conv); + ck_ref_bind so that conversion sequence ranking chooses #1. + + We strip_top_quals here which is also what standard_conversion + does. Failure to do so would confuse comp_cv_qual_signature + into thinking that in + + void f(const int * const &); // #1 + void f(const int *); // #2 + int *x; + f(x); + + #2 is a better match than #1 even though they're ambiguous (97296). */ + conv = build_conv (ck_qual, strip_top_quals (t), conv); return build_conv (ck_ref_bind, type, conv); } @@ -4899,8 +4910,7 @@ build_operator_new_call (tree fnname, vec<tree, va_gc> **args, up in the global scope. we disregard block-scope declarations of "operator new". */ - fns = lookup_name (fnname, LOOK_where::NAMESPACE); - fns = lookup_arg_dependent (fnname, fns, *args); + fns = lookup_qualified_name (global_namespace, fnname); if (align_arg) { @@ -11536,12 +11546,9 @@ compare_ics (conversion *ics1, conversion *ics2) P0388R4.) */ else if (t1->kind == ck_aggr && TREE_CODE (t1->type) == ARRAY_TYPE - && TREE_CODE (t2->type) == ARRAY_TYPE) + && TREE_CODE (t2->type) == ARRAY_TYPE + && same_type_p (TREE_TYPE (t1->type), TREE_TYPE (t2->type))) { - /* The type of the array elements must be the same. */ - if (!same_type_p (TREE_TYPE (t1->type), TREE_TYPE (t2->type))) - return 0; - tree n1 = nelts_initialized_by_list_init (t1); tree n2 = nelts_initialized_by_list_init (t2); if (tree_int_cst_lt (n1, n2)) diff --git a/gcc/cp/class.cc b/gcc/cp/class.cc index 40e17140db5..bfda0065bf4 100644 --- a/gcc/cp/class.cc +++ b/gcc/cp/class.cc @@ -7723,17 +7723,14 @@ finish_struct (tree t, tree attributes) lookup not to fail or recurse into bases. This isn't added to the template decl list so we drop this at instantiation time. */ - if (!get_class_binding_direct (t, assign_op_identifier, false)) - { - tree ass_op = build_lang_decl (USING_DECL, assign_op_identifier, - NULL_TREE); - DECL_CONTEXT (ass_op) = t; - USING_DECL_SCOPE (ass_op) = t; - DECL_DEPENDENT_P (ass_op) = true; - DECL_ARTIFICIAL (ass_op) = true; - DECL_CHAIN (ass_op) = TYPE_FIELDS (t); - TYPE_FIELDS (t) = ass_op; - } + tree ass_op = build_lang_decl (USING_DECL, assign_op_identifier, + NULL_TREE); + DECL_CONTEXT (ass_op) = t; + USING_DECL_SCOPE (ass_op) = t; + DECL_DEPENDENT_P (ass_op) = true; + DECL_ARTIFICIAL (ass_op) = true; + DECL_CHAIN (ass_op) = TYPE_FIELDS (t); + TYPE_FIELDS (t) = ass_op; TYPE_SIZE (t) = bitsize_zero_node; TYPE_SIZE_UNIT (t) = size_zero_node; diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index 9c40b051574..47d5113ace2 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -920,7 +920,8 @@ maybe_save_constexpr_fundef (tree fun) if (!potential && complain) require_potential_rvalue_constant_expression (massaged); - if (DECL_CONSTRUCTOR_P (fun) && potential) + if (DECL_CONSTRUCTOR_P (fun) && potential + && !DECL_DEFAULTED_FN (fun)) { if (cx_check_missing_mem_inits (DECL_CONTEXT (fun), massaged, complain)) @@ -2889,7 +2890,8 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t, else { result = *ctx->global->values.get (res); - if (result == NULL_TREE && !*non_constant_p) + if (result == NULL_TREE && !*non_constant_p + && !DECL_DESTRUCTOR_P (fun)) { if (!ctx->quiet) error ("%<constexpr%> call flows off the end " @@ -4564,19 +4566,18 @@ cxx_eval_bit_cast (const constexpr_ctx *ctx, tree t, bool *non_constant_p, static tree cxx_eval_logical_expression (const constexpr_ctx *ctx, tree t, tree bailout_value, tree continue_value, - bool lval, bool *non_constant_p, bool *overflow_p) { tree r; tree lhs = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 0), - lval, - non_constant_p, overflow_p); + /*lval*/false, non_constant_p, + overflow_p); VERIFY_CONSTANT (lhs); if (tree_int_cst_equal (lhs, bailout_value)) return lhs; gcc_assert (tree_int_cst_equal (lhs, continue_value)); r = cxx_eval_constant_expression (ctx, TREE_OPERAND (t, 1), - lval, non_constant_p, + /*lval*/false, non_constant_p, overflow_p); VERIFY_CONSTANT (r); return r; @@ -5008,7 +5009,8 @@ cxx_eval_vec_init (const constexpr_ctx *ctx, tree t, bool value_init = VEC_INIT_EXPR_VALUE_INIT (t); if (!init || !BRACE_ENCLOSED_INITIALIZER_P (init)) ; - else if (CONSTRUCTOR_NELTS (init) == 0) + else if (CONSTRUCTOR_NELTS (init) == 0 + && !CP_AGGREGATE_TYPE_P (strip_array_types (atype))) { /* Handle {} as value-init. */ init = NULL_TREE; @@ -5931,6 +5933,12 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t, { /* See above on initialization of empty bases. */ gcc_assert (is_empty_class (TREE_TYPE (init)) && !lval); + if (!*valp) + { + /* But do make sure we have something in *valp. */ + *valp = build_constructor (type, nullptr); + CONSTRUCTOR_NO_CLEARING (*valp) = no_zero_init; + } return init; } else @@ -7097,7 +7105,6 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, case TRUTH_ANDIF_EXPR: r = cxx_eval_logical_expression (ctx, t, boolean_false_node, boolean_true_node, - lval, non_constant_p, overflow_p); break; @@ -7105,7 +7112,6 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, case TRUTH_ORIF_EXPR: r = cxx_eval_logical_expression (ctx, t, boolean_true_node, boolean_false_node, - lval, non_constant_p, overflow_p); break; diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc index cdf6503c4d3..551ddc9cc41 100644 --- a/gcc/cp/coroutines.cc +++ b/gcc/cp/coroutines.cc @@ -513,8 +513,14 @@ coro_promise_type_found_p (tree fndecl, location_t loc) coro_info->promise_type); inform (DECL_SOURCE_LOCATION (BASELINK_FUNCTIONS (has_ret_void)), "%<return_void%> declared here"); - inform (DECL_SOURCE_LOCATION (BASELINK_FUNCTIONS (has_ret_val)), - "%<return_value%> declared here"); + has_ret_val = BASELINK_FUNCTIONS (has_ret_val); + const char *message = "%<return_value%> declared here"; + if (TREE_CODE (has_ret_val) == OVERLOAD) + { + has_ret_val = OVL_FIRST (has_ret_val); + message = "%<return_value%> first declared here"; + } + inform (DECL_SOURCE_LOCATION (has_ret_val), message); coro_info->coro_co_return_error_emitted = true; return false; } @@ -877,13 +883,14 @@ coro_diagnose_throwing_fn (tree fndecl) static bool coro_diagnose_throwing_final_aw_expr (tree expr) { - tree t = TARGET_EXPR_INITIAL (expr); + if (TREE_CODE (expr) == TARGET_EXPR) + expr = TARGET_EXPR_INITIAL (expr); tree fn = NULL_TREE; - if (TREE_CODE (t) == CALL_EXPR) - fn = CALL_EXPR_FN(t); - else if (TREE_CODE (t) == AGGR_INIT_EXPR) - fn = AGGR_INIT_EXPR_FN (t); - else if (TREE_CODE (t) == CONSTRUCTOR) + if (TREE_CODE (expr) == CALL_EXPR) + fn = CALL_EXPR_FN (expr); + else if (TREE_CODE (expr) == AGGR_INIT_EXPR) + fn = AGGR_INIT_EXPR_FN (expr); + else if (TREE_CODE (expr) == CONSTRUCTOR) return false; else { @@ -1148,10 +1155,13 @@ finish_co_await_expr (location_t kw, tree expr) extraneous warnings during substitution. */ suppress_warning (current_function_decl, OPT_Wreturn_type); - /* If we don't know the promise type, we can't proceed, build the - co_await with the expression unchanged. */ - tree functype = TREE_TYPE (current_function_decl); - if (dependent_type_p (functype) || type_dependent_expression_p (expr)) + /* Defer expansion when we are processing a template. + FIXME: If the coroutine function's type is not dependent, and the operand + is not dependent, we should determine the type of the co_await expression + using the DEPENDENT_EXPR wrapper machinery. That allows us to determine + the subexpression type, but leave its operand unchanged and then + instantiate it later. */ + if (processing_template_decl) { tree aw_expr = build5_loc (kw, CO_AWAIT_EXPR, unknown_type_node, expr, NULL_TREE, NULL_TREE, NULL_TREE, @@ -1222,10 +1232,9 @@ finish_co_yield_expr (location_t kw, tree expr) extraneous warnings during substitution. */ suppress_warning (current_function_decl, OPT_Wreturn_type); - /* If we don't know the promise type, we can't proceed, build the - co_await with the expression unchanged. */ - tree functype = TREE_TYPE (current_function_decl); - if (dependent_type_p (functype) || type_dependent_expression_p (expr)) + /* Defer expansion when we are processing a template; see FIXME in the + co_await code. */ + if (processing_template_decl) return build2_loc (kw, CO_YIELD_EXPR, unknown_type_node, expr, NULL_TREE); if (!coro_promise_type_found_p (current_function_decl, kw)) @@ -1307,10 +1316,9 @@ finish_co_return_stmt (location_t kw, tree expr) && check_for_bare_parameter_packs (expr)) return error_mark_node; - /* If we don't know the promise type, we can't proceed, build the - co_return with the expression unchanged. */ - tree functype = TREE_TYPE (current_function_decl); - if (dependent_type_p (functype) || type_dependent_expression_p (expr)) + /* Defer expansion when we are processing a template; see FIXME in the + co_await code. */ + if (processing_template_decl) { /* co_return expressions are always void type, regardless of the expression type. */ @@ -3109,7 +3117,7 @@ maybe_promote_temps (tree *stmt, void *d) If the initializer is a conditional expression, we need to collect and declare any promoted variables nested within it. DTORs for such variables must be run conditionally too. */ - if (t->var && DECL_NAME (t->var)) + if (t->var) { tree var = t->var; DECL_CHAIN (var) = vlist; @@ -3310,7 +3318,7 @@ add_var_to_bind (tree& bind, tree var_type, tree b_vars = BIND_EXPR_VARS (bind); /* Build a variable to hold the condition, this will be included in the frame as a local var. */ - char *nam = xasprintf ("%s.%d", nam_root, nam_vers); + char *nam = xasprintf ("__%s_%d", nam_root, nam_vers); tree newvar = build_lang_decl (VAR_DECL, get_identifier (nam), var_type); free (nam); DECL_CHAIN (newvar) = b_vars; @@ -3955,7 +3963,7 @@ register_local_var_uses (tree *stmt, int *do_subtree, void *d) scopes with identically named locals and still be able to identify them in the coroutine frame. */ tree lvname = DECL_NAME (lvar); - char *buf; + char *buf = NULL; /* The outermost bind scope contains the artificial variables that we inject to implement the coro state machine. We want to be able @@ -3965,14 +3973,14 @@ register_local_var_uses (tree *stmt, int *do_subtree, void *d) else if (lvname != NULL_TREE) buf = xasprintf ("%s_%u_%u", IDENTIFIER_POINTER (lvname), lvd->nest_depth, lvd->bind_indx); - else - buf = xasprintf ("_D%u_%u_%u", DECL_UID (lvar), lvd->nest_depth, - lvd->bind_indx); /* TODO: Figure out if we should build a local type that has any excess alignment or size from the original decl. */ - local_var.field_id - = coro_make_frame_entry (lvd->field_list, buf, lvtype, lvd->loc); - free (buf); + if (buf) + { + local_var.field_id = coro_make_frame_entry (lvd->field_list, buf, + lvtype, lvd->loc); + free (buf); + } /* We don't walk any of the local var sub-trees, they won't contain any bind exprs. */ } diff --git a/gcc/cp/cp-objcp-common.cc b/gcc/cp/cp-objcp-common.cc index 8f748021561..0b70d5567e4 100644 --- a/gcc/cp/cp-objcp-common.cc +++ b/gcc/cp/cp-objcp-common.cc @@ -280,6 +280,22 @@ cp_unit_size_without_reusable_padding (tree type) return TYPE_SIZE_UNIT (type); } +/* Returns type corresponding to FIELD's type when FIELD is a C++ base class + i.e., type without virtual base classes or tail padding. Returns + NULL_TREE otherwise. */ + +tree +cp_classtype_as_base (const_tree field) +{ + if (DECL_FIELD_IS_BASE (field)) + { + tree type = TREE_TYPE (field); + if (TYPE_LANG_SPECIFIC (type)) + return CLASSTYPE_AS_BASE (type); + } + return NULL_TREE; +} + /* Stubs to keep c-opts.cc happy. */ void push_file_scope (void) diff --git a/gcc/cp/cp-objcp-common.h b/gcc/cp/cp-objcp-common.h index 4c137313525..3c04e5c0265 100644 --- a/gcc/cp/cp-objcp-common.h +++ b/gcc/cp/cp-objcp-common.h @@ -31,6 +31,7 @@ extern int cp_decl_dwarf_attribute (const_tree, int); extern int cp_type_dwarf_attribute (const_tree, int); extern void cp_common_init_ts (void); extern tree cp_unit_size_without_reusable_padding (tree); +extern tree cp_classtype_as_base (const_tree); extern tree cp_get_global_decls (); extern tree cp_pushdecl (tree); extern void cp_register_dumps (gcc::dump_manager *); @@ -167,6 +168,8 @@ extern tree cxx_simulate_record_decl (location_t, const char *, #define LANG_HOOKS_TYPE_DWARF_ATTRIBUTE cp_type_dwarf_attribute #undef LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING #define LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING cp_unit_size_without_reusable_padding +#undef LANG_HOOKS_CLASSTYPE_AS_BASE +#define LANG_HOOKS_CLASSTYPE_AS_BASE cp_classtype_as_base #undef LANG_HOOKS_OMP_PREDETERMINED_SHARING #define LANG_HOOKS_OMP_PREDETERMINED_SHARING cxx_omp_predetermined_sharing diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 2f718852ac1..e9a3d09ac4c 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -8243,6 +8243,7 @@ extern tree fold_builtin_source_location (location_t); /* in name-lookup.cc */ extern tree strip_using_decl (tree); extern void diagnose_name_conflict (tree, tree); +extern bool dependent_local_decl_p (tree); /* Tell the binding oracle what kind of binding we are looking for. */ diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 0ff13e99595..2852093d624 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -1069,11 +1069,14 @@ decls_match (tree newdecl, tree olddecl, bool record_versions /* = true */) if (types_match && !DECL_EXTERN_C_P (newdecl) && !DECL_EXTERN_C_P (olddecl) - && record_versions - && maybe_version_functions (newdecl, olddecl, - (!DECL_FUNCTION_VERSIONED (newdecl) - || !DECL_FUNCTION_VERSIONED (olddecl)))) - return 0; + && targetm.target_option.function_versions (newdecl, olddecl)) + { + if (record_versions) + maybe_version_functions (newdecl, olddecl, + (!DECL_FUNCTION_VERSIONED (newdecl) + || !DECL_FUNCTION_VERSIONED (olddecl))); + return 0; + } } else if (TREE_CODE (newdecl) == TEMPLATE_DECL) { @@ -2598,7 +2601,12 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding, bool was_hidden) else { retrofit_lang_decl (newdecl); - DECL_LOCAL_DECL_ALIAS (newdecl) = DECL_LOCAL_DECL_ALIAS (olddecl); + tree alias = DECL_LOCAL_DECL_ALIAS (newdecl) + = DECL_LOCAL_DECL_ALIAS (olddecl); + DECL_ATTRIBUTES (alias) + = (*targetm.merge_decl_attributes) (alias, newdecl); + if (TREE_CODE (newdecl) == FUNCTION_DECL) + merge_attribute_bits (newdecl, alias); } } @@ -7444,6 +7452,10 @@ check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups) if (init && init != error_mark_node) init_code = build2 (INIT_EXPR, type, decl, init); + if (init_code && !TREE_SIDE_EFFECTS (init_code) + && init_code != error_mark_node) + init_code = NULL_TREE; + if (init_code) { /* We might have set these in cp_finish_decl. */ @@ -8542,7 +8554,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, { for (tree t : *cleanups) { - push_cleanup (decl, t, false); + push_cleanup (NULL_TREE, t, false); /* As in initialize_local_var. */ wrap_temporary_cleanups (init, t); } @@ -12231,6 +12243,8 @@ grokdeclarator (const cp_declarator *declarator, pedwarn (loc, OPT_Wpedantic, "%qs specified with %qT", key, type); ok = !flag_pedantic_errors; + type = DECL_ORIGINAL_TYPE (typedef_decl); + typedef_decl = NULL_TREE; } else if (declspecs->decltype_p) error_at (loc, "%qs specified with %<decltype%>", key); @@ -12866,6 +12880,11 @@ grokdeclarator (const cp_declarator *declarator, "type specifier", name); return error_mark_node; } + if (late_return_type && sfk == sfk_conversion) + { + error ("a conversion function cannot have a trailing return type"); + return error_mark_node; + } type = splice_late_return_type (type, late_return_type); if (type == error_mark_node) return error_mark_node; @@ -13030,8 +13049,6 @@ grokdeclarator (const cp_declarator *declarator, maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION); explicitp = 2; } - if (late_return_type_p) - error ("a conversion function cannot have a trailing return type"); } else if (sfk == sfk_deduction_guide) { diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc index dc2c924c472..d2b29208ed5 100644 --- a/gcc/cp/decl2.cc +++ b/gcc/cp/decl2.cc @@ -734,11 +734,15 @@ check_classfn (tree ctype, tree function, tree template_parms) tree pushed_scope = push_scope (ctype); tree matched = NULL_TREE; tree fns = get_class_binding (ctype, DECL_NAME (function)); - + bool saw_template = false; + for (ovl_iterator iter (fns); !matched && iter; ++iter) { tree fndecl = *iter; + if (TREE_CODE (fndecl) == TEMPLATE_DECL) + saw_template = true; + /* A member template definition only matches a member template declaration. */ if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL)) @@ -788,6 +792,23 @@ check_classfn (tree ctype, tree function, tree template_parms) matched = fndecl; } + if (!matched && !is_template && saw_template + && !processing_template_decl && DECL_UNIQUE_FRIEND_P (function)) + { + /* "[if no non-template match is found,] each remaining function template + is replaced with the specialization chosen by deduction from the + friend declaration or discarded if deduction fails." + + So ask check_explicit_specialization to find a matching template. */ + SET_DECL_IMPLICIT_INSTANTIATION (function); + tree spec = check_explicit_specialization (DECL_NAME (function), + function, /* tcount */0, + /* friend flag */4, + /* attrlist */NULL_TREE); + if (spec != error_mark_node) + matched = spec; + } + if (!matched) { if (!COMPLETE_TYPE_P (ctype)) @@ -1513,12 +1534,19 @@ cp_check_const_attributes (tree attributes) for (attr = attributes; attr; attr = TREE_CHAIN (attr)) { tree arg; + /* As we implement alignas using gnu::aligned attribute and + alignas argument is a constant expression, force manifestly + constant evaluation of aligned attribute argument. */ + bool manifestly_const_eval + = is_attribute_p ("aligned", get_attribute_name (attr)); for (arg = TREE_VALUE (attr); arg && TREE_CODE (arg) == TREE_LIST; arg = TREE_CHAIN (arg)) { tree expr = TREE_VALUE (arg); if (EXPR_P (expr)) - TREE_VALUE (arg) = fold_non_dependent_expr (expr); + TREE_VALUE (arg) + = fold_non_dependent_expr (expr, tf_warning_or_error, + manifestly_const_eval); } } } @@ -1616,8 +1644,16 @@ find_last_decl (tree decl) if (TREE_CODE (*iter) == OVERLOAD) continue; - if (decls_match (decl, *iter, /*record_decls=*/false)) - return *iter; + tree d = *iter; + + /* We can't compare versions in the middle of processing the + attribute that has the version. */ + if (TREE_CODE (d) == FUNCTION_DECL + && DECL_FUNCTION_VERSIONED (d)) + return NULL_TREE; + + if (decls_match (decl, d, /*record_decls=*/false)) + return d; } return NULL_TREE; } diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc index e76842e1a2a..1e944ca3f75 100644 --- a/gcc/cp/error.cc +++ b/gcc/cp/error.cc @@ -2203,6 +2203,7 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags) case WILDCARD_DECL: case OVERLOAD: case TYPE_DECL: + case USING_DECL: case IDENTIFIER_NODE: dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE |TFF_TEMPLATE_HEADER)) @@ -2584,6 +2585,13 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags) case VIEW_CONVERT_EXPR: { tree op = TREE_OPERAND (t, 0); + + if (location_wrapper_p (t)) + { + dump_expr (pp, op, flags); + break; + } + tree ttype = TREE_TYPE (t); tree optype = TREE_TYPE (op); diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc index c20ed211f1d..75ab965a218 100644 --- a/gcc/cp/init.cc +++ b/gcc/cp/init.cc @@ -1066,7 +1066,7 @@ perform_member_init (tree member, tree init, hash_set<tree> &uninitialized) init = build2 (INIT_EXPR, type, decl, init); finish_expr_stmt (init); FOR_EACH_VEC_ELT (*cleanups, i, t) - push_cleanup (decl, t, false); + push_cleanup (NULL_TREE, t, false); } else if (type_build_ctor_call (type) || (init && CLASS_TYPE_P (strip_array_types (type)))) @@ -2811,6 +2811,11 @@ warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper) if (!objsize) return; + /* We can only draw conclusions if ref.deref == -1, + i.e. oper is the address of the object. */ + if (ref.deref != -1) + return; + offset_int bytes_avail = wi::to_offset (objsize); offset_int bytes_need; @@ -3287,7 +3292,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts, { unsigned align = TYPE_ALIGN_UNIT (elt_type); /* Also consider the alignment of the cookie, if any. */ - if (TYPE_VEC_NEW_USES_COOKIE (elt_type)) + if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type)) align = MAX (align, TYPE_ALIGN_UNIT (size_type_node)); align_arg = build_int_cst (align_type_node, align); } diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc index 4cc3a47f9c2..65579edc316 100644 --- a/gcc/cp/lambda.cc +++ b/gcc/cp/lambda.cc @@ -183,6 +183,24 @@ lambda_function (tree lambda) return lambda; } +/* True if EXPR is an expression whose type can be used directly in lambda + capture. Not to be used for 'auto'. */ + +static bool +type_deducible_expression_p (tree expr) +{ + if (!type_dependent_expression_p (expr)) + return true; + if (BRACE_ENCLOSED_INITIALIZER_P (expr) + || TREE_CODE (expr) == EXPR_PACK_EXPANSION) + return false; + tree t = non_reference (TREE_TYPE (expr)); + if (!t) return false; + while (TREE_CODE (t) == POINTER_TYPE) + t = TREE_TYPE (t); + return currently_open_class (t); +} + /* Returns the type to use for the FIELD_DECL corresponding to the capture of EXPR. EXPLICIT_INIT_P indicates whether this is a C++14 init capture, and BY_REFERENCE_P indicates whether we're @@ -211,7 +229,7 @@ lambda_capture_field_type (tree expr, bool explicit_init_p, else type = do_auto_deduction (type, expr, auto_node); } - else if (type_dependent_expression_p (expr)) + else if (!type_deducible_expression_p (expr)) { type = cxx_make_type (DECLTYPE_TYPE); DECLTYPE_TYPE_EXPR (type) = expr; @@ -741,6 +759,7 @@ lambda_expr_this_capture (tree lambda, int add_capture_p) { tree lambda_stack = NULL_TREE; tree init = NULL_TREE; + bool saw_complete = false; /* If we are in a lambda function, we can move out until we hit: 1. a non-lambda function or NSDMI, @@ -759,6 +778,11 @@ lambda_expr_this_capture (tree lambda, int add_capture_p) lambda_stack); tree closure = LAMBDA_EXPR_CLOSURE (tlambda); + if (COMPLETE_TYPE_P (closure)) + /* We're instantiating a generic lambda op(), the containing + scope may be gone. */ + saw_complete = true; + tree containing_function = decl_function_context (TYPE_NAME (closure)); @@ -768,7 +792,7 @@ lambda_expr_this_capture (tree lambda, int add_capture_p) /* Lambda in an NSDMI. We don't have a function to look up 'this' in, but we can find (or rebuild) the fake one from inject_this_parameter. */ - if (!containing_function && !COMPLETE_TYPE_P (closure)) + if (!containing_function && !saw_complete) /* If we're parsing a lambda in a non-local class, we can find the fake 'this' in scope_chain. */ init = scope_chain->x_current_class_ptr; diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc index d16c577c029..7b0638d3166 100644 --- a/gcc/cp/name-lookup.cc +++ b/gcc/cp/name-lookup.cc @@ -429,7 +429,7 @@ class name_lookup { public: typedef std::pair<tree, tree> using_pair; - typedef vec<using_pair, va_heap, vl_embed> using_queue; + typedef auto_vec<using_pair, 16> using_queue; public: tree name; /* The identifier being looked for. */ @@ -528,16 +528,8 @@ private: bool search_usings (tree scope); private: - using_queue *queue_namespace (using_queue *queue, int depth, tree scope); - using_queue *do_queue_usings (using_queue *queue, int depth, - vec<tree, va_gc> *usings); - using_queue *queue_usings (using_queue *queue, int depth, - vec<tree, va_gc> *usings) - { - if (usings) - queue = do_queue_usings (queue, depth, usings); - return queue; - } + void queue_namespace (using_queue& queue, int depth, tree scope); + void queue_usings (using_queue& queue, int depth, vec<tree, va_gc> *usings); private: void add_fns (tree); @@ -1084,39 +1076,35 @@ name_lookup::search_qualified (tree scope, bool usings) /* Add SCOPE to the unqualified search queue, recursively add its inlines and those via using directives. */ -name_lookup::using_queue * -name_lookup::queue_namespace (using_queue *queue, int depth, tree scope) +void +name_lookup::queue_namespace (using_queue& queue, int depth, tree scope) { if (see_and_mark (scope)) - return queue; + return; /* Record it. */ tree common = scope; while (SCOPE_DEPTH (common) > depth) common = CP_DECL_CONTEXT (common); - vec_safe_push (queue, using_pair (common, scope)); + queue.safe_push (using_pair (common, scope)); /* Queue its inline children. */ if (vec<tree, va_gc> *inlinees = DECL_NAMESPACE_INLINEES (scope)) for (unsigned ix = inlinees->length (); ix--;) - queue = queue_namespace (queue, depth, (*inlinees)[ix]); + queue_namespace (queue, depth, (*inlinees)[ix]); /* Queue its using targets. */ - queue = queue_usings (queue, depth, NAMESPACE_LEVEL (scope)->using_directives); - - return queue; + queue_usings (queue, depth, NAMESPACE_LEVEL (scope)->using_directives); } /* Add the namespaces in USINGS to the unqualified search queue. */ -name_lookup::using_queue * -name_lookup::do_queue_usings (using_queue *queue, int depth, - vec<tree, va_gc> *usings) +void +name_lookup::queue_usings (using_queue& queue, int depth, vec<tree, va_gc> *usings) { - for (unsigned ix = usings->length (); ix--;) - queue = queue_namespace (queue, depth, (*usings)[ix]); - - return queue; + if (usings) + for (unsigned ix = usings->length (); ix--;) + queue_namespace (queue, depth, (*usings)[ix]); } /* Unqualified namespace lookup in SCOPE. @@ -1128,15 +1116,12 @@ name_lookup::do_queue_usings (using_queue *queue, int depth, bool name_lookup::search_unqualified (tree scope, cp_binding_level *level) { - /* Make static to avoid continual reallocation. We're not - recursive. */ - static using_queue *queue = NULL; + using_queue queue; bool found = false; - int length = vec_safe_length (queue); /* Queue local using-directives. */ for (; level->kind != sk_namespace; level = level->level_chain) - queue = queue_usings (queue, SCOPE_DEPTH (scope), level->using_directives); + queue_usings (queue, SCOPE_DEPTH (scope), level->using_directives); for (; !found; scope = CP_DECL_CONTEXT (scope)) { @@ -1144,19 +1129,19 @@ name_lookup::search_unqualified (tree scope, cp_binding_level *level) int depth = SCOPE_DEPTH (scope); /* Queue namespaces reachable from SCOPE. */ - queue = queue_namespace (queue, depth, scope); + queue_namespace (queue, depth, scope); /* Search every queued namespace where SCOPE is the common ancestor. Adjust the others. */ - unsigned ix = length; + unsigned ix = 0; do { - using_pair &pair = (*queue)[ix]; + using_pair &pair = queue[ix]; while (pair.first == scope) { found |= search_namespace_only (pair.second); - pair = queue->pop (); - if (ix == queue->length ()) + pair = queue.pop (); + if (ix == queue.length ()) goto done; } /* The depth is the same as SCOPE, find the parent scope. */ @@ -1164,7 +1149,7 @@ name_lookup::search_unqualified (tree scope, cp_binding_level *level) pair.first = CP_DECL_CONTEXT (pair.first); ix++; } - while (ix < queue->length ()); + while (ix < queue.length ()); done:; if (scope == global_namespace) break; @@ -1181,9 +1166,6 @@ name_lookup::search_unqualified (tree scope, cp_binding_level *level) dedup (false); - /* Restore to incoming length. */ - vec_safe_truncate (queue, length); - return found; } @@ -5916,6 +5898,7 @@ set_decl_namespace (tree decl, tree scope, bool friendp) tree found = NULL_TREE; bool hidden_p = false; + bool saw_template = false; for (lkp_iterator iter (old); iter; ++iter) { @@ -5940,6 +5923,20 @@ set_decl_namespace (tree decl, tree scope, bool friendp) found = ofn; hidden_p = iter.hidden_p (); } + else if (TREE_CODE (decl) == FUNCTION_DECL + && TREE_CODE (ofn) == TEMPLATE_DECL) + saw_template = true; + } + + if (!found && friendp && saw_template) + { + /* "[if no non-template match is found,] each remaining function template + is replaced with the specialization chosen by deduction from the + friend declaration or discarded if deduction fails." + + So tell check_explicit_specialization to look for a match. */ + SET_DECL_IMPLICIT_INSTANTIATION (decl); + return; } if (found) @@ -8979,4 +8976,22 @@ cp_emit_debug_info_for_using (tree t, tree context) } } +/* True if D is a local declaration in dependent scope. Assumes that it is + (part of) the current lookup result for its name. */ + +bool +dependent_local_decl_p (tree d) +{ + if (!DECL_LOCAL_DECL_P (d)) + return false; + + cxx_binding *b = IDENTIFIER_BINDING (DECL_NAME (d)); + cp_binding_level *l = b->scope; + while (!l->this_entity) + l = l->level_chain; + return uses_template_parms (l->this_entity); +} + + + #include "gt-cp-name-lookup.h" diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index bfd16e1ef62..2235da10c7c 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -20041,7 +20041,16 @@ cp_parser_placeholder_type_specifier (cp_parser *parser, location_t loc, /* In a template parameter list, a type-parameter can be introduced by type-constraints alone. */ if (processing_template_parmlist && !placeholder) - return build_constrained_parameter (con, proto, args); + { + /* In a default argument we may not be creating new parameters. */ + if (parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN) + { + /* If this assert turns out to be false, do error() instead. */ + gcc_assert (tentative); + return error_mark_node; + } + return build_constrained_parameter (con, proto, args); + } /* Diagnose issues placeholder issues. */ if (!flag_concepts_ts @@ -25924,6 +25933,7 @@ cp_parser_class_specifier_1 (cp_parser* parser) case CPP_OPEN_PAREN: case CPP_CLOSE_PAREN: case CPP_COMMA: + case CPP_SCOPE: want_semicolon = false; break; diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 63794a40d5d..e785c5db142 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -2863,7 +2863,9 @@ check_explicit_specialization (tree declarator, specialization = 1; SET_DECL_TEMPLATE_SPECIALIZATION (decl); } - else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR) + else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR + || (DECL_LANG_SPECIFIC (decl) + && DECL_IMPLICIT_INSTANTIATION (decl))) { if (is_friend) /* This could be something like: @@ -4339,7 +4341,9 @@ check_for_bare_parameter_packs (tree t, location_t loc /* = UNKNOWN_LOCATION */) parameter_packs = TREE_CHAIN (parameter_packs)) { tree pack = TREE_VALUE (parameter_packs); - if (is_capture_proxy (pack)) + if (is_capture_proxy (pack) + || (TREE_CODE (pack) == PARM_DECL + && DECL_CONTEXT (DECL_CONTEXT (pack)) == lam)) break; } @@ -5225,8 +5229,9 @@ process_partial_specialization (tree decl) && !get_partial_spec_bindings (maintmpl, maintmpl, specargs)) { auto_diagnostic_group d; - if (permerror (input_location, "partial specialization %qD is not " - "more specialized than", decl)) + if (pedwarn (input_location, 0, + "partial specialization %qD is not more specialized than", + decl)) inform (DECL_SOURCE_LOCATION (maintmpl), "primary template %qD", maintmpl); } @@ -10900,7 +10905,7 @@ uses_template_parms (tree t) || uses_template_parms (TREE_CHAIN (t))); else if (TREE_CODE (t) == TYPE_DECL) dependent_p = dependent_type_p (TREE_TYPE (t)); - else if (t == error_mark_node) + else if (t == error_mark_node || TREE_CODE (t) == NAMESPACE_DECL) dependent_p = false; else dependent_p = instantiation_dependent_expression_p (t); @@ -12677,7 +12682,13 @@ gen_elem_of_pack_expansion_instantiation (tree pattern, t = tsubst_expr (pattern, args, complain, in_decl, /*integral_constant_expression_p=*/false); else - t = tsubst (pattern, args, complain, in_decl); + { + t = tsubst (pattern, args, complain, in_decl); + if (is_auto (t) && !ith_elem_is_expansion) + /* When expanding the fake auto... pack expansion from add_capture, we + need to mark that the expansion is no longer a pack. */ + TEMPLATE_TYPE_PARAMETER_PACK (t) = false; + } /* If the Ith argument pack element is a pack expansion, then the Ith element resulting from the substituting is going to @@ -13046,7 +13057,7 @@ build_extra_args (tree pattern, tree args, tsubst_flags_t complain) { /* Make a copy of the extra arguments so that they won't get changed out from under us. */ - tree extra = copy_template_args (args); + tree extra = preserve_args (copy_template_args (args), /*cow_p=*/false); if (local_specializations) if (tree locals = extract_local_specs (pattern, complain)) extra = tree_cons (NULL_TREE, extra, locals); @@ -15082,6 +15093,12 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) { DECL_ORIGINAL_TYPE (r) = NULL_TREE; set_underlying_type (r); + + /* common_handle_aligned_attribute doesn't apply the alignment + to DECL_ORIGINAL_TYPE. */ + if (TYPE_USER_ALIGN (TREE_TYPE (t))) + TREE_TYPE (r) = build_aligned_type (TREE_TYPE (r), + TYPE_ALIGN (TREE_TYPE (t))); } layout_decl (r, 0); @@ -15180,7 +15197,9 @@ tsubst_arg_types (tree arg_types, /* Except that we do substitute default arguments under tsubst_lambda_expr, since the new op() won't have any associated template arguments for us to refer to later. */ - if (lambda_fn_in_template_p (in_decl)) + if (lambda_fn_in_template_p (in_decl) + || (in_decl && TREE_CODE (in_decl) == FUNCTION_DECL + && DECL_LOCAL_DECL_P (in_decl))) default_arg = tsubst_copy_and_build (default_arg, args, complain, in_decl, false/*fn*/, false/*constexpr*/); @@ -16468,7 +16487,8 @@ tsubst_baselink (tree baselink, tree object_type, tree binfo_type = BINFO_TYPE (BASELINK_BINFO (baselink)); binfo_type = tsubst (binfo_type, args, complain, in_decl); - bool dependent_p = binfo_type != BINFO_TYPE (BASELINK_BINFO (baselink)); + bool dependent_p = (binfo_type != BINFO_TYPE (BASELINK_BINFO (baselink)) + || optype != BASELINK_OPTYPE (baselink)); if (dependent_p) { @@ -24288,7 +24308,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict, /* Now check whether the type of this parameter is still dependent, and give up if so. */ ++processing_template_decl; - tparm = tsubst (tparm, targs, tf_none, NULL_TREE); + tparm = tsubst (TREE_TYPE (parm), targs, tf_none, NULL_TREE); --processing_template_decl; if (uses_template_parms (tparm)) return unify_success (explain_p); diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index a7f6449dafd..ab48f11c9be 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -609,7 +609,17 @@ set_cleanup_locs (tree stmts, location_t loc) { if (TREE_CODE (stmts) == CLEANUP_STMT) { - protected_set_expr_location (CLEANUP_EXPR (stmts), loc); + tree t = CLEANUP_EXPR (stmts); + protected_set_expr_location (t, loc); + /* Avoid locus differences for C++ cdtor calls depending on whether + cdtor_returns_this: a conversion to void is added to discard the return + value, and this conversion ends up carrying the location, and when it + gets discarded, the location is lost. So hold it in the call as + well. */ + if (TREE_CODE (t) == NOP_EXPR + && TREE_TYPE (t) == void_type_node + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) + protected_set_expr_location (TREE_OPERAND (t, 0), loc); set_cleanup_locs (CLEANUP_BODY (stmts), loc); } else if (TREE_CODE (stmts) == STATEMENT_LIST) @@ -656,7 +666,8 @@ do_pushlevel (scope_kind sk) /* Queue a cleanup. CLEANUP is an expression/statement to be executed when the current scope is exited. EH_ONLY is true when this is not - meant to apply to normal control flow transfer. */ + meant to apply to normal control flow transfer. DECL is the VAR_DECL + being cleaned up, if any, or null for temporaries or subobjects. */ void push_cleanup (tree decl, tree cleanup, bool eh_only) @@ -2679,13 +2690,13 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual, if (processing_template_decl) { - /* If FN is a local extern declaration or set thereof, look them up - again at instantiation time. */ + /* If FN is a local extern declaration (or set thereof) in a template, + look it up again at instantiation time. */ if (is_overloaded_fn (fn)) { tree ifn = get_first_fn (fn); if (TREE_CODE (ifn) == FUNCTION_DECL - && DECL_LOCAL_DECL_P (ifn)) + && dependent_local_decl_p (ifn)) orig_fn = DECL_NAME (ifn); } @@ -11241,7 +11252,7 @@ finish_decltype_type (tree expr, bool id_expression_or_member_access_p, } else if (processing_template_decl) { - expr = instantiate_non_dependent_expr_sfinae (expr, complain); + expr = instantiate_non_dependent_expr_sfinae (expr, complain|tf_decltype); if (expr == error_mark_node) return error_mark_node; /* Keep processing_template_decl cleared for the rest of the function diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index 780a8d89165..ed0d0d22950 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -740,7 +740,7 @@ build_cplus_new (tree type, tree init, tsubst_flags_t complain) constructor calls until gimplification time; now we only do it to set VEC_INIT_EXPR_IS_CONSTEXPR. - We assume that init is either NULL_TREE, void_type_node (indicating + We assume that init is either NULL_TREE, {}, void_type_node (indicating value-initialization), or another array to copy. */ static tree @@ -752,7 +752,20 @@ build_vec_init_elt (tree type, tree init, tsubst_flags_t complain) || !CLASS_TYPE_P (inner_type)) /* No interesting initialization to do. */ return integer_zero_node; - else if (init == void_type_node) + if (init && BRACE_ENCLOSED_INITIALIZER_P (init)) + { + /* Even if init has initializers for some array elements, + we're interested in the {}-init of trailing elements. */ + if (CP_AGGREGATE_TYPE_P (inner_type)) + { + tree empty = build_constructor (init_list_type_node, nullptr); + return digest_init (inner_type, empty, complain); + } + else + /* It's equivalent to value-init. */ + init = void_type_node; + } + if (init == void_type_node) return build_value_init (inner_type, complain); releasing_vec argvec; @@ -808,9 +821,13 @@ build_vec_init_expr (tree type, tree init, tsubst_flags_t complain) TREE_SIDE_EFFECTS (init) = true; SET_EXPR_LOCATION (init, input_location); - if (cxx_dialect >= cxx11 - && potential_constant_expression (elt_init)) - VEC_INIT_EXPR_IS_CONSTEXPR (init) = true; + if (cxx_dialect >= cxx11) + { + bool cx = potential_constant_expression (elt_init); + if (BRACE_ENCLOSED_INITIALIZER_P (init)) + cx &= potential_constant_expression (init); + VEC_INIT_EXPR_IS_CONSTEXPR (init) = cx; + } VEC_INIT_EXPR_VALUE_INIT (init) = value_init; return init; @@ -1566,7 +1583,8 @@ apply_identity_attributes (tree result, tree attribs, bool *remove_attributes) stripped. */ tree -strip_typedefs (tree t, bool *remove_attributes, unsigned int flags) +strip_typedefs (tree t, bool *remove_attributes /* = NULL */, + unsigned int flags /* = 0 */) { tree result = NULL, type = NULL, t0 = NULL; diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index 26a7cb4b50d..0da6f2485d0 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -6315,7 +6315,9 @@ build_x_shufflevector (location_t loc, vec<tree, va_gc> *args, if (processing_template_decl) { for (unsigned i = 0; i < args->length (); ++i) - if (type_dependent_expression_p ((*args)[i])) + if (i <= 1 + ? type_dependent_expression_p ((*args)[i]) + : instantiation_dependent_expression_p ((*args)[i])) { tree exp = build_min_nt_call_vec (NULL, args); CALL_EXPR_IFN (exp) = IFN_SHUFFLEVECTOR; diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc index cebe6acf487..63d95c1529a 100644 --- a/gcc/cp/typeck2.cc +++ b/gcc/cp/typeck2.cc @@ -922,6 +922,7 @@ store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags) here it should have been digested into an actual value for the type. */ gcc_checking_assert (TREE_CODE (value) != CONSTRUCTOR || processing_template_decl + || TREE_CODE (type) == VECTOR_TYPE || !TREE_HAS_CONSTRUCTOR (value)); /* If the initializer is not a constant, fill in DECL_INITIAL with @@ -1514,6 +1515,14 @@ process_init_constructor_array (tree type, tree init, int nested, int flags, strip_array_types (TREE_TYPE (ce->value))))); picflags |= picflag_from_initializer (ce->value); + /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer + CONSTRUCTOR. */ + if (TREE_CODE (ce->value) == CONSTRUCTOR + && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value)) + { + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1; + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value) = 0; + } } /* No more initializers. If the array is unbounded, we are done. Otherwise, @@ -1559,6 +1568,14 @@ process_init_constructor_array (tree type, tree init, int nested, int flags, } picflags |= picflag_from_initializer (next); + /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer + CONSTRUCTOR. */ + if (TREE_CODE (next) == CONSTRUCTOR + && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next)) + { + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1; + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next) = 0; + } if (len > i+1) { tree range = build2 (RANGE_EXPR, size_type_node, @@ -1753,6 +1770,13 @@ process_init_constructor_record (tree type, tree init, int nested, int flags, if (fldtype != TREE_TYPE (field)) next = cp_convert_and_check (TREE_TYPE (field), next, complain); picflags |= picflag_from_initializer (next); + /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR. */ + if (TREE_CODE (next) == CONSTRUCTOR + && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next)) + { + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1; + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next) = 0; + } CONSTRUCTOR_APPEND_ELT (v, field, next); } @@ -1893,6 +1917,14 @@ process_init_constructor_union (tree type, tree init, int nested, int flags, ce->value = massage_init_elt (TREE_TYPE (ce->index), ce->value, nested, flags, complain); + /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR. */ + if (ce->value + && TREE_CODE (ce->value) == CONSTRUCTOR + && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value)) + { + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1; + CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value) = 0; + } return picflag_from_initializer (ce->value); } diff --git a/gcc/ctfc.cc b/gcc/ctfc.cc index 6fe44d2e8d4..f24e7bff948 100644 --- a/gcc/ctfc.cc +++ b/gcc/ctfc.cc @@ -179,6 +179,40 @@ ctf_dvd_lookup (const ctf_container_ref ctfc, dw_die_ref die) return NULL; } +/* Insert a dummy CTF variable into the list of variables to be ignored. */ + +static void +ctf_dvd_ignore_insert (ctf_container_ref ctfc, ctf_dvdef_ref dvd) +{ + bool existed = false; + ctf_dvdef_ref entry = dvd; + + ctf_dvdef_ref * item = ctfc->ctfc_ignore_vars->find_slot (entry, INSERT); + if (*item == NULL) + *item = dvd; + else + existed = true; + /* Duplicate variable records not expected to be inserted. */ + gcc_assert (!existed); +} + +/* Lookup the dummy CTF variable given the DWARF die for the non-defining + decl to be ignored. */ + +bool +ctf_dvd_ignore_lookup (const ctf_container_ref ctfc, dw_die_ref die) +{ + ctf_dvdef_t entry; + entry.dvd_key = die; + + ctf_dvdef_ref * slot = ctfc->ctfc_ignore_vars->find_slot (&entry, NO_INSERT); + + if (slot) + return true; + + return false; +} + /* Append member definition to the list. Member list is a singly-linked list with list start pointing to the head. */ @@ -666,9 +700,10 @@ ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou, int ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_id_t ref, - dw_die_ref die, unsigned int external_vis) + dw_die_ref die, unsigned int external_vis, + dw_die_ref die_var_decl) { - ctf_dvdef_ref dvd; + ctf_dvdef_ref dvd, dvd_ignore; gcc_assert (name); @@ -680,6 +715,24 @@ ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_id_t ref, dvd->dvd_name = ctf_add_string (ctfc, name, &(dvd->dvd_name_offset)); dvd->dvd_visibility = external_vis; dvd->dvd_type = ref; + + /* If DW_AT_specification attribute exists, keep track of it as this is + the non-defining declaration corresponding to the variable. We will + skip emitting CTF variable for such incomplete, non-defining + declarations. + There could be some non-defining declarations, however, for which a + defining declaration does not show up in the same CU. For such + cases, the compiler continues to emit CTF variable record as + usual. */ + if (die_var_decl) + { + dvd_ignore = ggc_cleared_alloc<ctf_dvdef_t> (); + dvd_ignore->dvd_key = die_var_decl; + /* It's alright to leave other fields as zero. No valid CTF + variable will be added for these DW_TAG_variable DIEs. */ + ctf_dvd_ignore_insert (ctfc, dvd_ignore); + } + ctf_dvd_insert (ctfc, dvd); if (strcmp (name, "")) @@ -900,6 +953,8 @@ new_ctf_container (void) = hash_table<ctfc_dtd_hasher>::create_ggc (100); tu_ctfc->ctfc_vars = hash_table<ctfc_dvd_hasher>::create_ggc (100); + tu_ctfc->ctfc_ignore_vars + = hash_table<ctfc_dvd_hasher>::create_ggc (10); return tu_ctfc; } @@ -952,6 +1007,9 @@ ctfc_delete_container (ctf_container_ref ctfc) ctfc->ctfc_vars->empty (); ctfc->ctfc_types = NULL; + ctfc->ctfc_ignore_vars->empty (); + ctfc->ctfc_ignore_vars = NULL; + ctfc_delete_strtab (&ctfc->ctfc_strtable); ctfc_delete_strtab (&ctfc->ctfc_aux_strtable); if (ctfc->ctfc_vars_list) diff --git a/gcc/ctfc.h b/gcc/ctfc.h index 18c93c802a0..001e544ef08 100644 --- a/gcc/ctfc.h +++ b/gcc/ctfc.h @@ -274,6 +274,8 @@ typedef struct GTY (()) ctf_container hash_table <ctfc_dtd_hasher> * GTY (()) ctfc_types; /* CTF variables. */ hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_vars; + /* CTF variables to be ignored. */ + hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_ignore_vars; /* CTF string table. */ ctf_strtable_t ctfc_strtable; @@ -301,6 +303,8 @@ typedef struct GTY (()) ctf_container /* List of pre-processed CTF Variables. CTF requires that the variables appear in the sorted order of their names. */ ctf_dvdef_t ** GTY ((length ("0"))) ctfc_vars_list; + /* Count of pre-processed CTF Variables in the list. */ + uint64_t ctfc_vars_list_count; /* List of pre-processed CTF types. CTF requires that a shared type must appear before the type that uses it. For the compiler, this means types are emitted in sorted order of their type IDs. */ @@ -392,6 +396,8 @@ extern ctf_dtdef_ref ctf_dtd_lookup (const ctf_container_ref ctfc, dw_die_ref die); extern ctf_dvdef_ref ctf_dvd_lookup (const ctf_container_ref ctfc, dw_die_ref die); +extern bool ctf_dvd_ignore_lookup (const ctf_container_ref ctfc, + dw_die_ref die); extern const char * ctf_add_string (ctf_container_ref, const char *, uint32_t *, int); @@ -428,7 +434,7 @@ extern int ctf_add_member_offset (ctf_container_ref, dw_die_ref, const char *, extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref, const char *, ctf_id_t); extern int ctf_add_variable (ctf_container_ref, const char *, ctf_id_t, - dw_die_ref, unsigned int); + dw_die_ref, unsigned int, dw_die_ref); extern ctf_id_t ctf_lookup_tree_type (ctf_container_ref, const tree); extern ctf_id_t get_btf_id (ctf_id_t); diff --git a/gcc/ctfout.cc b/gcc/ctfout.cc index a23d3775801..3cf89b94f99 100644 --- a/gcc/ctfout.cc +++ b/gcc/ctfout.cc @@ -173,9 +173,7 @@ ctf_calc_num_vbytes (ctf_dtdef_ref ctftype) static void ctf_list_add_ctf_vars (ctf_container_ref ctfc, ctf_dvdef_ref var) { - /* FIXME - static may not fly with multiple CUs. */ - static int num_vars_added = 0; - ctfc->ctfc_vars_list[num_vars_added++] = var; + ctfc->ctfc_vars_list[ctfc->ctfc_vars_list_count++] = var; } /* Initialize the various sections and labels for CTF output. */ @@ -214,6 +212,13 @@ ctf_dvd_preprocess_cb (ctf_dvdef_ref * slot, void * arg) ctf_dvdef_ref var = (ctf_dvdef_ref) *slot; ctf_container_ref arg_ctfc = dvd_arg->dvd_arg_ctfc; + /* If the CTF variable corresponds to an extern variable declaration with + a defining declaration later on, skip it. Only CTF variable + corresponding to the defining declaration for the extern variable is + desirable. */ + if (ctf_dvd_ignore_lookup (arg_ctfc, var->dvd_key)) + return 1; + ctf_preprocess_var (arg_ctfc, var); /* Keep track of global objts. */ @@ -278,16 +283,16 @@ static void ctf_preprocess (ctf_container_ref ctfc) { size_t num_ctf_types = ctfc->ctfc_types->elements (); + size_t num_ctf_vars = ctfc_get_num_ctf_vars (ctfc); /* Initialize an array to keep track of the CTF variables at global - scope. */ - size_t num_global_objts = ctfc->ctfc_num_global_objts; + scope. At this time, size it conservatively. */ + size_t num_global_objts = num_ctf_vars; if (num_global_objts) { ctfc->ctfc_gobjts_list = ggc_vec_alloc<ctf_dvdef_t*>(num_global_objts); } - size_t num_ctf_vars = ctfc_get_num_ctf_vars (ctfc); if (num_ctf_vars) { ctf_dvd_preprocess_arg_t dvd_arg; @@ -301,8 +306,11 @@ ctf_preprocess (ctf_container_ref ctfc) list for sorting. */ ctfc->ctfc_vars->traverse<void *, ctf_dvd_preprocess_cb> (&dvd_arg); /* Sort the list. */ - qsort (ctfc->ctfc_vars_list, num_ctf_vars, sizeof (ctf_dvdef_ref), - ctf_varent_compare); + qsort (ctfc->ctfc_vars_list, ctfc->ctfc_vars_list_count, + sizeof (ctf_dvdef_ref), ctf_varent_compare); + /* Update the actual number of the generated CTF variables at global + scope. */ + ctfc->ctfc_num_global_objts = dvd_arg.dvd_global_obj_idx; } /* Initialize an array to keep track of the CTF functions types for global @@ -478,7 +486,7 @@ output_ctf_header (ctf_container_ref ctfc) /* Vars appear after function index. */ varoff = funcidxoff + ctfc->ctfc_num_global_funcs * sizeof (uint32_t); /* CTF types appear after vars. */ - typeoff = varoff + ctfc_get_num_ctf_vars (ctfc) * sizeof (ctf_varent_t); + typeoff = varoff + (ctfc->ctfc_vars_list_count) * sizeof (ctf_varent_t); /* The total number of bytes for CTF types is the sum of the number of times struct ctf_type_t, struct ctf_stype_t are written, plus the amount of variable length data after each one of these. */ @@ -597,7 +605,7 @@ static void output_ctf_vars (ctf_container_ref ctfc) { size_t i; - size_t num_ctf_vars = ctfc_get_num_ctf_vars (ctfc); + unsigned int num_ctf_vars = ctfc->ctfc_vars_list_count; if (num_ctf_vars) { /* Iterate over the list of sorted vars and output the asm. */ diff --git a/gcc/d/ChangeLog b/gcc/d/ChangeLog index f1afaf20331..bb179bcf7e9 100644 --- a/gcc/d/ChangeLog +++ b/gcc/d/ChangeLog @@ -1,3 +1,19 @@ +2022-04-21 Iain Buclaw <ibuclaw@gdcproject.org> + + * dmd/MERGE: Merge upstream dmd eb7bee331. + * dmd/VERSION: Update version to v2.100.0-beta.1. + * d-lang.cc (d_handle_option): Handle OPT_frevert_dip1000. + * lang.opt (frevert=dip1000): New option. + +2022-04-13 Iain Buclaw <ibuclaw@gdcproject.org> + + * Make-lang.in (D_FRONTEND_OBJS): Add d/common-bitfields.o, + d/mustuse.o. + * d-ctfloat.cc (CTFloat::isIdentical): Don't treat NaN values as + identical. + * dmd/MERGE: Merge upstream dmd 4d1bfcf14. + * expr.cc (ExprVisitor::visit (VoidInitExp *)): New. + 2022-04-03 Iain Buclaw <ibuclaw@gdcproject.org> * d-lang.cc: Include dmd/template.h. diff --git a/gcc/d/Make-lang.in b/gcc/d/Make-lang.in index 6c90657d65f..f3e34c54015 100644 --- a/gcc/d/Make-lang.in +++ b/gcc/d/Make-lang.in @@ -89,6 +89,7 @@ D_FRONTEND_OBJS = \ d/canthrow.o \ d/chkformat.o \ d/clone.o \ + d/common-bitfields.o \ d/common-file.o \ d/common-outbuffer.o \ d/common-string.o \ @@ -143,6 +144,7 @@ D_FRONTEND_OBJS = \ d/lambdacomp.o \ d/lexer.o \ d/mtype.o \ + d/mustuse.o \ d/nogc.o \ d/nspace.o \ d/ob.o \ diff --git a/gcc/d/d-ctfloat.cc b/gcc/d/d-ctfloat.cc index 6e6d10ff0a4..c4d9a44c59b 100644 --- a/gcc/d/d-ctfloat.cc +++ b/gcc/d/d-ctfloat.cc @@ -55,8 +55,7 @@ CTFloat::isIdentical (real_t x, real_t y) { real_value rx = x.rv (); real_value ry = y.rv (); - return (REAL_VALUE_ISNAN (rx) && REAL_VALUE_ISNAN (ry)) - || real_identical (&rx, &ry); + return real_identical (&rx, &ry); } /* Return true if real_t value R is NaN. */ diff --git a/gcc/d/d-lang.cc b/gcc/d/d-lang.cc index 69571628336..9adcabdf7cf 100644 --- a/gcc/d/d-lang.cc +++ b/gcc/d/d-lang.cc @@ -637,12 +637,17 @@ d_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value, break; case OPT_frevert_all: + global.params.useDIP1000 = FeatureState::disabled; global.params.useDIP25 = FeatureState::disabled; global.params.dtorFields = FeatureState::disabled; global.params.fix16997 = !value; global.params.markdown = !value; break; + case OPT_frevert_dip1000: + global.params.useDIP1000 = FeatureState::disabled; + break; + case OPT_frevert_dip25: global.params.useDIP25 = FeatureState::disabled; break; diff --git a/gcc/d/d-port.cc b/gcc/d/d-port.cc index a0e06b37683..a908cc8dbb0 100644 --- a/gcc/d/d-port.cc +++ b/gcc/d/d-port.cc @@ -31,11 +31,11 @@ along with GCC; see the file COPYING3. If not see /* Compare the first N bytes of S1 and S2 without regard to the case. */ int -Port::memicmp (const char *s1, const char *s2, size_t n) +Port::memicmp (const char *s1, const char *s2, d_size_t n) { int result = 0; - for (size_t i = 0; i < n; i++) + for (d_size_t i = 0; i < n; i++) { char c1 = s1[i]; char c2 = s2[i]; @@ -143,9 +143,9 @@ Port::readlongBE (const void *buffer) /* Write an SZ-byte sized VALUE to BUFFER, ignoring endian-ness. */ void -Port::valcpy (void *buffer, uint64_t value, size_t sz) +Port::valcpy (void *buffer, uint64_t value, d_size_t sz) { - gcc_assert (((size_t) buffer) % sz == 0); + gcc_assert (((d_size_t) buffer) % sz == 0); switch (sz) { diff --git a/gcc/d/dmd/MERGE b/gcc/d/dmd/MERGE index ca409df346d..d18119193d4 100644 --- a/gcc/d/dmd/MERGE +++ b/gcc/d/dmd/MERGE @@ -1,4 +1,4 @@ -47871363d804f54b29ccfd444b082c19716c2301 +313d28b3db7523e67880ae3baf8ef28ce9abe9bd The first line of this file holds the git revision number of the last merge done from the dlang/dmd repository. diff --git a/gcc/d/dmd/README.md b/gcc/d/dmd/README.md index f613ab28577..b14310312cd 100644 --- a/gcc/d/dmd/README.md +++ b/gcc/d/dmd/README.md @@ -130,6 +130,8 @@ Note that these groups have no strict meaning, the category assignments are a bi | [impcnvtab.d](https://github.com/dlang/dmd/blob/master/src/dmd/impcnvtab.d) | Define an implicit conversion table for basic types | | [importc.d](https://github.com/dlang/dmd/blob/master/src/dmd/importc.d) | Helpers specific to ImportC | | [sideeffect.d](https://github.com/dlang/dmd/blob/master/src/dmd/sideeffect.d) | Extract side-effects of expressions for certain lowerings. | +| [mustuse.d](https://github.com/dlang/dmd/blob/master/src/dmd/mustuse.d) | Helpers related to the `@mustuse` attribute | + **Compile Time Function Execution (CTFE)** diff --git a/gcc/d/dmd/VERSION b/gcc/d/dmd/VERSION index 16f49a73f4d..2450fd55ef8 100644 --- a/gcc/d/dmd/VERSION +++ b/gcc/d/dmd/VERSION @@ -1 +1 @@ -v2.099.1-beta.1 +v2.100.0-beta.1 diff --git a/gcc/d/dmd/aggregate.d b/gcc/d/dmd/aggregate.d index 8895aa5e2bd..f4b5e8af7ff 100644 --- a/gcc/d/dmd/aggregate.d +++ b/gcc/d/dmd/aggregate.d @@ -58,6 +58,28 @@ enum ClassKind : ubyte } /** + * Give a nice string for a class kind for error messages + * Params: + * c = class kind + * Returns: + * 0-terminated string for `c` + */ +const(char)* toChars(ClassKind c) +{ + final switch (c) + { + case ClassKind.d: + return "D"; + case ClassKind.cpp: + return "C++"; + case ClassKind.objc: + return "Objective-C"; + case ClassKind.c: + return "C"; + } +} + +/** * If an aggregate has a pargma(mangle, ...) this holds the information * to mangle. */ diff --git a/gcc/d/dmd/arrayop.d b/gcc/d/dmd/arrayop.d index 52f39d34d0f..16cbe620bc5 100644 --- a/gcc/d/dmd/arrayop.d +++ b/gcc/d/dmd/arrayop.d @@ -158,7 +158,7 @@ Expression arrayOp(BinExp e, Scope* sc) /// ditto Expression arrayOp(BinAssignExp e, Scope* sc) { - //printf("BinAssignExp.arrayOp() %s\n", toChars()); + //printf("BinAssignExp.arrayOp() %s\n", e.toChars()); /* Check that the elements of e1 can be assigned to */ diff --git a/gcc/d/dmd/astenums.d b/gcc/d/dmd/astenums.d index 1a2cf8b0641..bf196934aed 100644 --- a/gcc/d/dmd/astenums.d +++ b/gcc/d/dmd/astenums.d @@ -28,6 +28,7 @@ enum Baseok : ubyte enum MODFlags : int { + none = 0, // default (mutable) const_ = 1, // type is const immutable_ = 4, // type is immutable shared_ = 2, // type is shared diff --git a/gcc/d/dmd/attrib.d b/gcc/d/dmd/attrib.d index 9c2bbd672a7..1e84b55d181 100644 --- a/gcc/d/dmd/attrib.d +++ b/gcc/d/dmd/attrib.d @@ -44,7 +44,6 @@ import dmd.mtype; import dmd.objc; // for objc.addSymbols import dmd.common.outbuffer; import dmd.root.array; // for each -import dmd.target; // for target.systemLinkage import dmd.tokens; import dmd.visitor; @@ -399,7 +398,7 @@ extern (C++) final class LinkDeclaration : AttribDeclaration { super(loc, null, decl); //printf("LinkDeclaration(linkage = %d, decl = %p)\n", linkage, decl); - this.linkage = (linkage == LINK.system) ? target.systemLinkage() : linkage; + this.linkage = linkage; } static LinkDeclaration create(const ref Loc loc, LINK p, Dsymbols* decl) @@ -994,7 +993,7 @@ extern (C++) class ConditionalDeclaration : AttribDeclaration // Decide if 'then' or 'else' code should be included override Dsymbols* include(Scope* sc) { - //printf("ConditionalDeclaration::include(sc = %p) scope = %p\n", sc, scope); + //printf("ConditionalDeclaration::include(sc = %p) scope = %p\n", sc, _scope); if (errors) return null; @@ -1057,7 +1056,7 @@ extern (C++) final class StaticIfDeclaration : ConditionalDeclaration */ override Dsymbols* include(Scope* sc) { - //printf("StaticIfDeclaration::include(sc = %p) scope = %p\n", sc, scope); + //printf("StaticIfDeclaration::include(sc = %p) scope = %p\n", sc, _scope); if (errors || onStack) return null; @@ -1496,12 +1495,7 @@ extern (C++) final class UserAttributeDeclaration : AttribDeclaration if (global.params.cplusplus < CppStdRevision.cpp11) return; - // Avoid `if` at the call site - if (sym.userAttribDecl is null || sym.userAttribDecl.atts is null) - return; - - foreach (exp; *sym.userAttribDecl.atts) - { + foreachUdaNoSemantic(sym, (exp) { if (isGNUABITag(exp)) { if (sym.isCPPNamespaceDeclaration() || sym.isNspace()) @@ -1515,9 +1509,10 @@ extern (C++) final class UserAttributeDeclaration : AttribDeclaration sym.errors = true; } // Only one `@gnuAbiTag` is allowed by semantic2 - return; + return 1; // break } - } + return 0; // continue + }); } } @@ -1544,14 +1539,14 @@ bool isCoreUda(Dsymbol sym, Identifier ident) /** * Iterates the UDAs attached to the given symbol. * - * If `dg` returns `!= 0`, it will stop the iteration and return that - * value, otherwise it will return 0. - * * Params: * sym = the symbol to get the UDAs from * sc = scope to use for semantic analysis of UDAs - * dg = called once for each UDA. If `dg` returns `!= 0`, it will stop the - * iteration and return that value, otherwise it will return `0`. + * dg = called once for each UDA + * + * Returns: + * If `dg` returns `!= 0`, stops the iteration and returns that value. + * Otherwise, returns 0. */ int foreachUda(Dsymbol sym, Scope* sc, int delegate(Expression) dg) { @@ -1577,3 +1572,32 @@ int foreachUda(Dsymbol sym, Scope* sc, int delegate(Expression) dg) }); }); } + +/** + * Iterates the UDAs attached to the given symbol, without performing semantic + * analysis. + * + * Use this function instead of `foreachUda` if semantic analysis of `sym` is + * still in progress. + * + * Params: + * sym = the symbol to get the UDAs from + * dg = called once for each UDA + * + * Returns: + * If `dg` returns `!= 0`, stops the iteration and returns that value. + * Otherwise, returns 0. + */ +int foreachUdaNoSemantic(Dsymbol sym, int delegate(Expression) dg) +{ + if (sym.userAttribDecl is null || sym.userAttribDecl.atts is null) + return 0; + + foreach (exp; *sym.userAttribDecl.atts) + { + if (auto result = dg(exp)) + return result; + } + + return 0; +} diff --git a/gcc/d/dmd/blockexit.d b/gcc/d/dmd/blockexit.d index afd7ac052ad..22c9dde5f7e 100644 --- a/gcc/d/dmd/blockexit.d +++ b/gcc/d/dmd/blockexit.d @@ -139,16 +139,21 @@ int blockExit(Statement s, FuncDeclaration func, bool mustNotThrow) // Allow if last case/default was empty CaseStatement sc = slast.isCaseStatement(); DefaultStatement sd = slast.isDefaultStatement(); - if (sc && (!sc.statement.hasCode() || sc.statement.isCaseStatement() || sc.statement.isErrorStatement())) - { - } - else if (sd && (!sd.statement.hasCode() || sd.statement.isCaseStatement() || sd.statement.isErrorStatement())) + auto sl = (sc ? sc.statement : (sd ? sd.statement : null)); + + if (sl && (!sl.hasCode() || sl.isErrorStatement())) { } else if (func.getModule().filetype != FileType.c) { const(char)* gototype = s.isCaseStatement() ? "case" : "default"; - s.error("switch case fallthrough - use 'goto %s;' if intended", gototype); + // @@@DEPRECATED_2.110@@@ https://issues.dlang.org/show_bug.cgi?id=22999 + // Deprecated in 2.100 + // Make an error in 2.110 + if (sl && sl.isCaseStatement()) + s.deprecation("switch case fallthrough - use 'goto %s;' if intended", gototype); + else + s.error("switch case fallthrough - use 'goto %s;' if intended", gototype); } } } diff --git a/gcc/d/dmd/clone.d b/gcc/d/dmd/clone.d index 2ed0dc7bdd1..9c8c1c316bf 100644 --- a/gcc/d/dmd/clone.d +++ b/gcc/d/dmd/clone.d @@ -912,8 +912,8 @@ void buildDtors(AggregateDeclaration ad, Scope* sc) ex = new DotVarExp(loc, ex, v); // This is a hack so we can call destructors on const/immutable objects. - // Do it as a type 'paint'. - ex = new CastExp(loc, ex, v.type.mutableOf()); + // Do it as a type 'paint', `cast()` + ex = new CastExp(loc, ex, MODFlags.none); if (stc & STC.safe) stc = (stc & ~STC.safe) | STC.trusted; @@ -1588,7 +1588,7 @@ private bool needCopyCtor(StructDeclaration sd, out bool hasCpCtor) auto tf = ctorDecl.type.toTypeFunction(); const dim = tf.parameterList.length; - if (dim == 1) + if (dim == 1 || (dim > 1 && tf.parameterList[1].defaultArg)) { auto param = tf.parameterList[0]; if (param.type.mutableOf().unSharedOf() == sd.type.mutableOf().unSharedOf()) diff --git a/gcc/d/dmd/common/README.md b/gcc/d/dmd/common/README.md index a9b65c3dd8d..fb282dcf0a1 100644 --- a/gcc/d/dmd/common/README.md +++ b/gcc/d/dmd/common/README.md @@ -2,6 +2,7 @@ | File | Purpose | |------------------------------------------------------------------------------------|-----------------------------------------------------------------| +| [bitfields.d](https://github.com/dlang/dmd/blob/master/src/dmd/common/bitfields.d) | Pack multiple boolean fields into bit fields | | [file.d](https://github.com/dlang/dmd/blob/master/src/dmd/common/file.d) | Functions and objects dedicated to file I/O and management | | [outbuffer.d](https://github.com/dlang/dmd/blob/master/src/dmd/common/outbuffer.d) | An expandable buffer in which you can write text or binary data | | [string.d](https://github.com/dlang/dmd/blob/master/src/dmd/common/string.d) | Common string functions including filename manipulation | diff --git a/gcc/d/dmd/common/bitfields.d b/gcc/d/dmd/common/bitfields.d new file mode 100644 index 00000000000..d17983d66b4 --- /dev/null +++ b/gcc/d/dmd/common/bitfields.d @@ -0,0 +1,70 @@ +/** + * A library bitfields utility + * + * Copyright: Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved + * Authors: Dennis Korpel + * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) + * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/common/bitfields.d, common/bitfields.d) + * Documentation: https://dlang.org/phobos/dmd_common_bitfields.html + * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/common/bitfields.d + */ +module dmd.common.bitfields; + +/** + * Generate code for bit fields inside a struct/class body + * Params: + * S = type of a struct with only boolean fields, which should become bit fields + * T = type of bit fields variable, must have enough bits to store all booleans + * Returns: D code with a bit fields variable and getter / setter functions + */ +extern (D) string generateBitFields(S, T)() +if (__traits(isUnsigned, T)) +{ + string result = "extern (C++) pure nothrow @nogc @safe final {"; + enum structName = __traits(identifier, S); + + foreach (size_t i, mem; __traits(allMembers, S)) + { + static assert(is(typeof(__traits(getMember, S, mem)) == bool)); + static assert(i < T.sizeof * 8, "too many fields for bit field storage of type `"~T.stringof~"`"); + enum mask = "(1 << "~i.stringof~")"; + result ~= " + /// set or get the corresponding "~structName~" member + bool "~mem~"() const { return !!(bitFields & "~mask~"); } + /// ditto + bool "~mem~"(bool v) + { + v ? (bitFields |= "~mask~") : (bitFields &= ~"~mask~"); + return v; + }"; + } + return result ~ "}\n private "~T.stringof~" bitFields;\n"; +} + +/// +unittest +{ + static struct B + { + bool x; + bool y; + bool z; + } + + static struct S + { + mixin(generateBitFields!(B, ubyte)); + } + + S s; + assert(!s.x); + s.x = true; + assert(s.x); + s.x = false; + assert(!s.x); + + s.y = true; + assert(s.y); + assert(!s.x); + assert(!s.z); +} diff --git a/gcc/d/dmd/common/file.d b/gcc/d/dmd/common/file.d index e4483d5f947..8f34b5319a9 100644 --- a/gcc/d/dmd/common/file.d +++ b/gcc/d/dmd/common/file.d @@ -25,6 +25,8 @@ import core.sys.posix.unistd; import dmd.common.string; +nothrow: + /** Encapsulated management of a memory-mapped file. @@ -52,6 +54,8 @@ struct FileMapping(Datum) private const(char)* name; // state } + nothrow: + /** Open `filename` and map it in memory. If `Datum` is `const`, opens for read-only and maps the content in memory; no error is issued if the file diff --git a/gcc/d/dmd/common/outbuffer.d b/gcc/d/dmd/common/outbuffer.d index 0705c1880c0..7e46d294f3d 100644 --- a/gcc/d/dmd/common/outbuffer.d +++ b/gcc/d/dmd/common/outbuffer.d @@ -16,6 +16,8 @@ import core.stdc.stdio; import core.stdc.string; import core.stdc.stdlib; +nothrow: + // In theory these functions should also restore errno, but we don't care because // we abort application on error anyway. extern (C) private pure @system @nogc nothrow @@ -54,6 +56,8 @@ struct OutBuffer int level; // state } + nothrow: + /** Construct given size. */ diff --git a/gcc/d/dmd/common/string.d b/gcc/d/dmd/common/string.d index d3bc24f2667..48bf9bb5b55 100644 --- a/gcc/d/dmd/common/string.d +++ b/gcc/d/dmd/common/string.d @@ -10,6 +10,8 @@ */ module dmd.common.string; +nothrow: + /** Defines a temporary array using a fixed-length buffer as back store. If the length of the buffer suffices, it is readily used. Otherwise, `malloc` is used to @@ -26,6 +28,8 @@ struct SmallBuffer(T) private T[] _extent; private bool needsFree; + nothrow: + @disable this(); // no default ctor @disable this(ref const SmallBuffer!T); // noncopyable, nonassignable diff --git a/gcc/d/dmd/constfold.d b/gcc/d/dmd/constfold.d index 75ba9ea1e0a..bf66408f1d4 100644 --- a/gcc/d/dmd/constfold.d +++ b/gcc/d/dmd/constfold.d @@ -936,7 +936,7 @@ UnionExp Identity(EXP op, const ref Loc loc, Type type, Expression e1, Expressio { if (e1.type.isreal()) { - cmp = RealIdentical(e1.toReal(), e2.toReal()); + cmp = CTFloat.isIdentical(e1.toReal(), e2.toReal()); } else if (e1.type.isimaginary()) { diff --git a/gcc/d/dmd/cparse.d b/gcc/d/dmd/cparse.d index bb12aa7c995..2b2046f3da3 100644 --- a/gcc/d/dmd/cparse.d +++ b/gcc/d/dmd/cparse.d @@ -213,16 +213,12 @@ final class CParser(AST) : Parser!AST goto Lexp; case TOK.leftParenthesis: - { - /* If tokens look like a function call, assume it is one, - * As any type-name won't be resolved until semantic, this - * could be rewritten later. - */ - auto tk = &token; - if (isFunctionCall(tk)) - goto Lexp; - goto default; - } + if (auto pt = lookupTypedef(token.ident)) + { + if (*pt) + goto Ldeclaration; + } + goto Lexp; // function call default: { @@ -259,6 +255,7 @@ final class CParser(AST) : Parser!AST case TOK.plusPlus: case TOK.minusMinus: case TOK.sizeof_: + case TOK._Generic: Lexp: auto exp = cparseExpression(); if (token.value == TOK.identifier && exp.op == EXP.identifier) @@ -1625,10 +1622,21 @@ final class CParser(AST) : Parser!AST */ if (token.value == TOK.semicolon) { - nextToken(); if (!tspec) + { + nextToken(); return; // accept empty declaration as an extension + } + if (auto ti = tspec.isTypeIdentifier()) + { + // C11 6.7.2-2 + error("type-specifier missing for declaration of `%s`", ti.ident.toChars()); + nextToken(); + return; + } + + nextToken(); auto tt = tspec.isTypeTag(); if (!tt || !tt.id && (tt.tok == TOK.struct_ || tt.tok == TOK.union_)) @@ -1660,6 +1668,22 @@ final class CParser(AST) : Parser!AST specifier.mod &= ~MOD.xnone; // 'used' it } + void scanPastSemicolon() + { + while (token.value != TOK.semicolon && token.value != TOK.endOfFile) + nextToken(); + nextToken(); + } + + if (token.value == TOK.assign && tspec && tspec.isTypeIdentifier()) + { + /* C11 6.7.2-2 + * Special check for `const b = 1;` because some compilers allow it + */ + error("type-specifier omitted for declaration of `%s`", tspec.isTypeIdentifier().ident.toChars()); + return scanPastSemicolon(); + } + bool first = true; while (1) { @@ -1879,10 +1903,7 @@ final class CParser(AST) : Parser!AST default: error("`=`, `;` or `,` expected to end declaration instead of `%s`", token.toChars()); Lend: - while (token.value != TOK.semicolon && token.value != TOK.endOfFile) - nextToken(); - nextToken(); - return; + return scanPastSemicolon(); } } } @@ -2399,15 +2420,13 @@ final class CParser(AST) : Parser!AST if (idx.length > 2 && idx[0] == '_' && idx[1] == '_') // leading double underscore importBuiltins = true; // probably one of those compiler extensions t = null; - if (scw & SCW.xtypedef) - { - /* Punch through to what the typedef is, to support things like: - * typedef T* T; - */ - auto pt = lookupTypedef(previd); - if (pt && *pt) // if previd is a known typedef - t = *pt; - } + + /* Punch through to what the typedef is, to support things like: + * typedef T* T; + */ + auto pt = lookupTypedef(previd); + if (pt && *pt) // if previd is a known typedef + t = *pt; if (!t) t = new AST.TypeIdentifier(loc, previd); @@ -2529,7 +2548,14 @@ final class CParser(AST) : Parser!AST default: if (declarator == DTR.xdirect) { - error("identifier or `(` expected"); // ) + if (!t || t.isTypeIdentifier()) + { + // const arr[1]; + error("no type-specifier for declarator"); + t = AST.Type.tint32; + } + else + error("identifier or `(` expected"); // ) panic(); } ts = t; @@ -2745,6 +2771,16 @@ final class CParser(AST) : Parser!AST Specifier specifier; specifier.packalign.setDefault(); auto tspec = cparseSpecifierQualifierList(LVL.global, specifier); + if (!tspec) + { + error("type-specifier is missing"); + tspec = AST.Type.tint32; + } + if (tspec && specifier.mod & MOD.xconst) + { + tspec = toConst(tspec); + specifier.mod = MOD.xnone; // 'used' it + } Identifier id; return cparseDeclarator(DTR.xabstract, tspec, id, specifier); } @@ -2825,8 +2861,18 @@ final class CParser(AST) : Parser!AST Specifier specifier; specifier.packalign.setDefault(); auto tspec = cparseDeclarationSpecifiers(LVL.prototype, specifier); - if (tspec && specifier.mod & MOD.xconst) + if (!tspec) { + error("no type-specifier for parameter"); + tspec = AST.Type.tint32; + } + + if (specifier.mod & MOD.xconst) + { + if ((token.value == TOK.rightParenthesis || token.value == TOK.comma) && + tspec.isTypeIdentifier()) + error("type-specifier omitted for parameter `%s`", tspec.isTypeIdentifier().ident.toChars()); + tspec = toConst(tspec); specifier.mod = MOD.xnone; // 'used' it } @@ -3396,7 +3442,12 @@ final class CParser(AST) : Parser!AST Specifier specifier; specifier.packalign = this.packalign; auto tspec = cparseSpecifierQualifierList(LVL.member, specifier); - if (tspec && specifier.mod & MOD.xconst) + if (!tspec) + { + error("no type-specifier for struct member"); + tspec = AST.Type.tint32; + } + if (specifier.mod & MOD.xconst) { tspec = toConst(tspec); specifier.mod = MOD.xnone; // 'used' it @@ -3409,7 +3460,13 @@ final class CParser(AST) : Parser!AST nextToken(); auto tt = tspec.isTypeTag(); if (!tt) + { + if (auto ti = tspec.isTypeIdentifier()) + { + error("type-specifier omitted before declaration of `%s`", ti.ident.toChars()); + } return; // legal but meaningless empty declaration + } /* If anonymous struct declaration * struct { ... members ... }; @@ -3449,6 +3506,12 @@ final class CParser(AST) : Parser!AST AST.Type dt; if (token.value == TOK.colon) { + if (auto ti = tspec.isTypeIdentifier()) + { + error("type-specifier omitted before bit field declaration of `%s`", ti.ident.toChars()); + tspec = AST.Type.tint32; + } + // C11 6.7.2.1-12 unnamed bit-field id = Identifier.generateAnonymousId("BitField"); dt = tspec; diff --git a/gcc/d/dmd/ctfeexpr.d b/gcc/d/dmd/ctfeexpr.d index 32aed16e796..11229d4bd4f 100644 --- a/gcc/d/dmd/ctfeexpr.d +++ b/gcc/d/dmd/ctfeexpr.d @@ -1269,7 +1269,7 @@ private int ctfeRawCmp(const ref Loc loc, Expression e1, Expression e2, bool ide real_t r1 = e1.type.isreal() ? e1.toReal() : e1.toImaginary(); real_t r2 = e1.type.isreal() ? e2.toReal() : e2.toImaginary(); if (identity) - return !RealIdentical(r1, r2); + return !CTFloat.isIdentical(r1, r2); if (CTFloat.isNaN(r1) || CTFloat.isNaN(r2)) // if unordered { return 1; // they are not equal @@ -1399,7 +1399,7 @@ bool ctfeIdentity(const ref Loc loc, EXP op, Expression e1, Expression e2) cmp = (es1.var == es2.var && es1.offset == es2.offset); } else if (e1.type.isreal()) - cmp = RealIdentical(e1.toReal(), e2.toReal()); + cmp = CTFloat.isIdentical(e1.toReal(), e2.toReal()); else if (e1.type.isimaginary()) cmp = RealIdentical(e1.toImaginary(), e2.toImaginary()); else if (e1.type.iscomplex()) diff --git a/gcc/d/dmd/dcast.d b/gcc/d/dmd/dcast.d index 685987b734d..83978391e42 100644 --- a/gcc/d/dmd/dcast.d +++ b/gcc/d/dmd/dcast.d @@ -432,7 +432,7 @@ MATCH implicitConvTo(Expression e, Type t) return MATCH.nomatch; goto case Tuns8; case Tuns8: - //printf("value = %llu %llu\n", (dinteger_t)(unsigned char)value, value); + //printf("value = %llu %llu\n", cast(dinteger_t)cast(ubyte)value, value); if (cast(ubyte)value != value) return MATCH.nomatch; break; @@ -492,8 +492,8 @@ MATCH implicitConvTo(Expression e, Type t) break; case Tpointer: - //printf("type = %s\n", type.toBasetype()->toChars()); - //printf("t = %s\n", t.toBasetype()->toChars()); + //printf("type = %s\n", type.toBasetype().toChars()); + //printf("t = %s\n", t.toBasetype().toChars()); if (ty == Tpointer && e.type.toBasetype().nextOf().ty == t.toBasetype().nextOf().ty) { /* Allow things like: @@ -1107,6 +1107,10 @@ MATCH implicitConvTo(Expression e, Type t) MATCH visitCond(CondExp e) { + auto result = visit(e); + if (result != MATCH.nomatch) + return result; + MATCH m1 = e.e1.implicitConvTo(t); MATCH m2 = e.e2.implicitConvTo(t); //printf("CondExp: m1 %d m2 %d\n", m1, m2); @@ -2077,7 +2081,7 @@ Expression castTo(Expression e, Scope* sc, Type t, Type att = null) if (auto tsa = tb.isTypeSArray()) { size_t dim2 = cast(size_t)tsa.dim.toInteger(); - //printf("dim from = %d, to = %d\n", (int)se.len, (int)dim2); + //printf("dim from = %d, to = %d\n", cast(int)se.len, cast(int)dim2); // Changing dimensions if (dim2 != se.len) diff --git a/gcc/d/dmd/declaration.d b/gcc/d/dmd/declaration.d index c0e40a5263a..a533d30ca80 100644 --- a/gcc/d/dmd/declaration.d +++ b/gcc/d/dmd/declaration.d @@ -379,7 +379,7 @@ extern (C++) abstract class Declaration : Dsymbol if (e1 && e1.op == EXP.this_ && isField()) { - VarDeclaration vthis = (cast(ThisExp)e1).var; + VarDeclaration vthis = e1.isThisExp().var; for (Scope* scx = sc; scx; scx = scx.enclosing) { if (scx.func == vthis.parent && (scx.flags & SCOPE.contract)) @@ -656,9 +656,8 @@ extern (C++) final class TupleDeclaration : Declaration if (o.dyncast() == DYNCAST.expression) { Expression e = cast(Expression)o; - if (e.op == EXP.dSymbol) + if (DsymbolExp ve = e.isDsymbolExp()) { - DsymbolExp ve = cast(DsymbolExp)e; Declaration d = ve.s.isDeclaration(); if (d && d.needThis()) { @@ -1083,29 +1082,12 @@ extern (C++) class VarDeclaration : Declaration bool isArgDtorVar; /// temporary created to handle scope destruction of a function argument } - private ushort bitFields; // stores multiple booleans for BitFields + import dmd.common.bitfields : generateBitFields; + mixin(generateBitFields!(BitFields, ushort)); + byte canassign; // it can be assigned to ubyte isdataseg; // private data for isDataseg 0 unset, 1 true, 2 false - // Generate getter and setter functions for `bitFields` - extern (D) mixin(() { - string result = "extern (C++) pure nothrow @nogc @safe final {"; - foreach (size_t i, mem; __traits(allMembers, BitFields)) - { - result ~= " - /// set or get the corresponding BitFields member - bool "~mem~"() const { return !!(bitFields & (1 << "~i.stringof~")); } - /// ditto - bool "~mem~"(bool v) - { - v ? (bitFields |= (1 << "~i.stringof~")) : (bitFields &= ~(1 << "~i.stringof~")); - return v; - }"; - } - return result ~ "}"; - }()); - - final extern (D) this(const ref Loc loc, Type type, Identifier ident, Initializer _init, StorageClass storage_class = STC.undefined_) in { @@ -1160,7 +1142,7 @@ extern (C++) class VarDeclaration : Declaration assert(o.dyncast() == DYNCAST.expression); Expression e = cast(Expression)o; assert(e.op == EXP.dSymbol); - DsymbolExp se = cast(DsymbolExp)e; + DsymbolExp se = e.isDsymbolExp(); se.s.setFieldOffset(ad, fieldState, isunion); } return; @@ -1458,16 +1440,17 @@ extern (C++) class VarDeclaration : Declaration const sdsz = sd.type.size(); assert(sdsz != SIZE_INVALID && sdsz != 0); const n = sz / sdsz; - e = new SliceExp(loc, e, new IntegerExp(loc, 0, Type.tsize_t), new IntegerExp(loc, n, Type.tsize_t)); + SliceExp se = new SliceExp(loc, e, new IntegerExp(loc, 0, Type.tsize_t), + new IntegerExp(loc, n, Type.tsize_t)); // Prevent redundant bounds check - (cast(SliceExp)e).upperIsInBounds = true; - (cast(SliceExp)e).lowerIsLessThanUpper = true; + se.upperIsInBounds = true; + se.lowerIsLessThanUpper = true; // This is a hack so we can call destructors on const/immutable objects. - e.type = sd.type.arrayOf(); + se.type = sd.type.arrayOf(); - e = new CallExp(loc, new IdentifierExp(loc, Id.__ArrayDtor), e); + e = new CallExp(loc, new IdentifierExp(loc, Id.__ArrayDtor), se); } return e; } diff --git a/gcc/d/dmd/dmangle.d b/gcc/d/dmd/dmangle.d index c3662a734d8..1f895e03af0 100644 --- a/gcc/d/dmd/dmangle.d +++ b/gcc/d/dmd/dmangle.d @@ -340,7 +340,6 @@ public: final switch (t.linkage) { case LINK.default_: - case LINK.system: case LINK.d: mc = 'F'; break; @@ -356,6 +355,8 @@ public: case LINK.objc: mc = 'Y'; break; + case LINK.system: + assert(0); } buf.writeByte(mc); @@ -1340,7 +1341,9 @@ extern (D) const(char)[] externallyMangledIdentifier(Declaration d) { if (d.linkage != LINK.d && d.localNum) d.error("the same declaration cannot be in multiple scopes with non-D linkage"); - final switch (d.linkage) + + const l = d.linkage == LINK.system ? target.systemLinkage() : d.linkage; + final switch (l) { case LINK.d: break; @@ -1354,9 +1357,10 @@ extern (D) const(char)[] externallyMangledIdentifier(Declaration d) return p.toDString(); } case LINK.default_: - case LINK.system: d.error("forward declaration"); return d.ident.toString(); + case LINK.system: + assert(0); } } return null; diff --git a/gcc/d/dmd/dmodule.d b/gcc/d/dmd/dmodule.d index c7e6418bf46..2d9f6510ba5 100644 --- a/gcc/d/dmd/dmodule.d +++ b/gcc/d/dmd/dmodule.d @@ -69,7 +69,7 @@ void semantic3OnDependencies(Module m) /** * Remove generated .di files on error and exit */ -void removeHdrFilesAndFail(ref Param params, ref Modules modules) +void removeHdrFilesAndFail(ref Param params, ref Modules modules) nothrow { if (params.doHdrGeneration) { @@ -94,7 +94,7 @@ void removeHdrFilesAndFail(ref Param params, ref Modules modules) * Returns: * the filename of the child package or module */ -private const(char)[] getFilename(Identifier[] packages, Identifier ident) +private const(char)[] getFilename(Identifier[] packages, Identifier ident) nothrow { const(char)[] filename = ident.toString(); @@ -157,14 +157,14 @@ extern (C++) class Package : ScopeDsymbol uint tag; // auto incremented tag, used to mask package tree in scopes Module mod; // !=null if isPkgMod == PKG.module_ - final extern (D) this(const ref Loc loc, Identifier ident) + final extern (D) this(const ref Loc loc, Identifier ident) nothrow { super(loc, ident); __gshared uint packageTag; this.tag = packageTag++; } - override const(char)* kind() const + override const(char)* kind() const nothrow { return "package"; } @@ -664,7 +664,7 @@ extern (C++) final class Module : Package //printf("Module::read('%s') file '%s'\n", toChars(), srcfile.toChars()); if (auto result = global.fileManager.lookup(srcfile)) { - this.src = result.data; + this.src = result; if (global.params.emitMakeDeps) global.params.makeDeps.push(srcfile.toChars()); return true; @@ -1133,8 +1133,10 @@ extern (C++) final class Module : Package // If it isn't there, some compiler rewrites, like // classinst == classinst -> .object.opEquals(classinst, classinst) // would fail inside object.d. - if (members.dim == 0 || (*members)[0].ident != Id.object || - (*members)[0].isImport() is null) + if (filetype != FileType.c && + (members.dim == 0 || + (*members)[0].ident != Id.object || + (*members)[0].isImport() is null)) { auto im = new Import(Loc.initial, null, Id.object, null, 0); members.shift(im); @@ -1380,7 +1382,7 @@ extern (C++) final class Module : Package a.setDim(0); } - extern (D) static void clearCache() + extern (D) static void clearCache() nothrow { foreach (Module m; amodules) m.searchCacheIdent = null; @@ -1391,7 +1393,7 @@ extern (C++) final class Module : Package * return true if it imports m. * Can be used to detect circular imports. */ - int imports(Module m) + int imports(Module m) nothrow { //printf("%s Module::imports(%s)\n", toChars(), m.toChars()); version (none) @@ -1414,14 +1416,14 @@ extern (C++) final class Module : Package return false; } - bool isRoot() + bool isRoot() nothrow { return this.importedFrom == this; } // true if the module source file is directly // listed in command line. - bool isCoreModule(Identifier ident) + bool isCoreModule(Identifier ident) nothrow { return this.ident == ident && parent && parent.ident == Id.core && !parent.parent; } @@ -1440,7 +1442,7 @@ extern (C++) final class Module : Package uint[uint] ctfe_cov; /// coverage information from ctfe execution_count[line] - override inout(Module) isModule() inout + override inout(Module) isModule() inout nothrow { return this; } @@ -1455,7 +1457,7 @@ extern (C++) final class Module : Package * Params: * buf = The buffer to write to */ - void fullyQualifiedName(ref OutBuffer buf) + void fullyQualifiedName(ref OutBuffer buf) nothrow { buf.writestring(ident.toString()); @@ -1469,7 +1471,7 @@ extern (C++) final class Module : Package /** Lazily initializes and returns the escape table. Turns out it eats a lot of memory. */ - extern(D) Escape* escapetable() + extern(D) Escape* escapetable() nothrow { if (!_escapetable) _escapetable = new Escape(); diff --git a/gcc/d/dmd/dscope.d b/gcc/d/dmd/dscope.d index c3a1d05cd7b..6339a9e36ba 100644 --- a/gcc/d/dmd/dscope.d +++ b/gcc/d/dmd/dscope.d @@ -457,6 +457,8 @@ struct Scope if (sc.scopesym.isModule()) flags |= SearchUnqualifiedModule; // tell Module.search() that SearchLocalsOnly is to be obeyed + else if (sc.flags & SCOPE.Cfile && sc.scopesym.isStructDeclaration()) + continue; // C doesn't have struct scope if (Dsymbol s = sc.scopesym.search(loc, ident, flags)) { diff --git a/gcc/d/dmd/dsymbol.d b/gcc/d/dmd/dsymbol.d index cb6c278fc44..74eaa1d8d7a 100644 --- a/gcc/d/dmd/dsymbol.d +++ b/gcc/d/dmd/dsymbol.d @@ -112,12 +112,12 @@ struct Ungag { uint oldgag; - extern (D) this(uint old) + extern (D) this(uint old) nothrow { this.oldgag = old; } - extern (C++) ~this() + extern (C++) ~this() nothrow { global.gag = oldgag; } @@ -255,27 +255,27 @@ extern (C++) class Dsymbol : ASTNode DeprecatedDeclaration depdecl; // customized deprecation message UserAttributeDeclaration userAttribDecl; // user defined attributes - final extern (D) this() + final extern (D) this() nothrow { //printf("Dsymbol::Dsymbol(%p)\n", this); loc = Loc(null, 0, 0); } - final extern (D) this(Identifier ident) + final extern (D) this(Identifier ident) nothrow { //printf("Dsymbol::Dsymbol(%p, ident)\n", this); this.loc = Loc(null, 0, 0); this.ident = ident; } - final extern (D) this(const ref Loc loc, Identifier ident) + final extern (D) this(const ref Loc loc, Identifier ident) nothrow { //printf("Dsymbol::Dsymbol(%p, ident)\n", this); this.loc = loc; this.ident = ident; } - static Dsymbol create(Identifier ident) + static Dsymbol create(Identifier ident) nothrow { return new Dsymbol(ident); } @@ -800,6 +800,22 @@ extern (C++) class Dsymbol : ASTNode if (isAliasDeclaration() && !_scope) setScope(sc); Dsymbol s2 = sds.symtabLookup(this,ident); + /* https://issues.dlang.org/show_bug.cgi?id=17434 + * + * If we are trying to add an import to the symbol table + * that has already been introduced, then keep the one with + * larger visibility. This is fine for imports because if + * we have multiple imports of the same file, if a single one + * is public then the symbol is reachable. + */ + if (auto i1 = isImport()) + { + if (auto i2 = s2.isImport()) + { + if (sc.explicitVisibility && sc.visibility > i2.visibility) + sds.symtab.update(this); + } + } // If using C tag/prototype/forward declaration rules if (sc.flags & SCOPE.Cfile && !this.isImport()) @@ -822,7 +838,8 @@ extern (C++) class Dsymbol : ASTNode } if (sds.isAggregateDeclaration() || sds.isEnumDeclaration()) { - if (ident == Id.__sizeof || ident == Id.__xalignof || ident == Id._mangleof) + if (ident == Id.__sizeof || + !(sc && sc.flags & SCOPE.Cfile) && (ident == Id.__xalignof || ident == Id._mangleof)) { error("`.%s` property cannot be redefined", ident.toChars()); errors = true; @@ -933,14 +950,7 @@ extern (C++) class Dsymbol : ASTNode TemplateInstance ti = st.isTemplateInstance(); sm = s.search(loc, ti.name); if (!sm) - { - sm = s.search_correct(ti.name); - if (sm) - .error(loc, "template identifier `%s` is not a member of %s `%s`, did you mean %s `%s`?", ti.name.toChars(), s.kind(), s.toPrettyChars(), sm.kind(), sm.toChars()); - else - .error(loc, "template identifier `%s` is not a member of %s `%s`", ti.name.toChars(), s.kind(), s.toPrettyChars()); return null; - } sm = sm.toAlias(); TemplateDeclaration td = sm.isTemplateDeclaration(); if (!td) @@ -1381,16 +1391,16 @@ private: BitArray accessiblePackages, privateAccessiblePackages;// whitelists of accessible (imported) packages public: - final extern (D) this() + final extern (D) this() nothrow { } - final extern (D) this(Identifier ident) + final extern (D) this(Identifier ident) nothrow { super(ident); } - final extern (D) this(const ref Loc loc, Identifier ident) + final extern (D) this(const ref Loc loc, Identifier ident) nothrow { super(loc, ident); } @@ -1604,7 +1614,7 @@ public: return os; } - void importScope(Dsymbol s, Visibility visibility) + void importScope(Dsymbol s, Visibility visibility) nothrow { //printf("%s.ScopeDsymbol::importScope(%s, %d)\n", toChars(), s.toChars(), visibility); // No circular or redundant import's @@ -1631,7 +1641,7 @@ public: } } - extern (D) final void addAccessiblePackage(Package p, Visibility visibility) + extern (D) final void addAccessiblePackage(Package p, Visibility visibility) nothrow { auto pary = visibility.kind == Visibility.Kind.private_ ? &privateAccessiblePackages : &accessiblePackages; if (pary.length <= p.tag) @@ -1639,7 +1649,7 @@ public: (*pary)[p.tag] = true; } - bool isPackageAccessible(Package p, Visibility visibility, int flags = 0) + bool isPackageAccessible(Package p, Visibility visibility, int flags = 0) nothrow { if (p.tag < accessiblePackages.length && accessiblePackages[p.tag] || visibility.kind == Visibility.Kind.private_ && p.tag < privateAccessiblePackages.length && privateAccessiblePackages[p.tag]) @@ -1654,7 +1664,7 @@ public: return false; } - override final bool isforwardRef() + override final bool isforwardRef() nothrow { return (members is null); } @@ -1742,7 +1752,7 @@ public: * Returns: * null if already in table, `s` if inserted */ - Dsymbol symtabInsert(Dsymbol s) + Dsymbol symtabInsert(Dsymbol s) nothrow { return symtab.insert(s); } @@ -1755,7 +1765,7 @@ public: * Returns: * Dsymbol if found, null if not */ - Dsymbol symtabLookup(Dsymbol s, Identifier id) + Dsymbol symtabLookup(Dsymbol s, Identifier id) nothrow { return symtab.lookup(id); } @@ -1838,7 +1848,7 @@ extern (C++) final class WithScopeSymbol : ScopeDsymbol { WithStatement withstate; - extern (D) this(WithStatement withstate) + extern (D) this(WithStatement withstate) nothrow { this.withstate = withstate; } @@ -1898,7 +1908,7 @@ extern (C++) final class ArrayScopeSymbol : ScopeDsymbol private RootObject arrayContent; Scope* sc; - extern (D) this(Scope* sc, Expression exp) + extern (D) this(Scope* sc, Expression exp) nothrow { super(exp.loc, null); assert(exp.op == EXP.index || exp.op == EXP.slice || exp.op == EXP.array); @@ -1906,13 +1916,13 @@ extern (C++) final class ArrayScopeSymbol : ScopeDsymbol this.arrayContent = exp; } - extern (D) this(Scope* sc, TypeTuple type) + extern (D) this(Scope* sc, TypeTuple type) nothrow { this.sc = sc; this.arrayContent = type; } - extern (D) this(Scope* sc, TupleDeclaration td) + extern (D) this(Scope* sc, TupleDeclaration td) nothrow { this.sc = sc; this.arrayContent = td; @@ -2109,7 +2119,7 @@ extern (C++) final class OverloadSet : Dsymbol { Dsymbols a; // array of Dsymbols - extern (D) this(Identifier ident, OverloadSet os = null) + extern (D) this(Identifier ident, OverloadSet os = null) nothrow { super(ident); if (os) @@ -2118,7 +2128,7 @@ extern (C++) final class OverloadSet : Dsymbol } } - void push(Dsymbol s) + void push(Dsymbol s) nothrow { a.push(s); } @@ -2152,12 +2162,13 @@ extern (C++) final class ForwardingScopeDsymbol : ScopeDsymbol * Can be `null` before being lazily initialized. */ ScopeDsymbol forward; - extern (D) this(ScopeDsymbol forward) + extern (D) this(ScopeDsymbol forward) nothrow { super(null); this.forward = forward; } - override Dsymbol symtabInsert(Dsymbol s) + + override Dsymbol symtabInsert(Dsymbol s) nothrow { assert(forward); if (auto d = s.isDeclaration()) @@ -2188,7 +2199,7 @@ extern (C++) final class ForwardingScopeDsymbol : ScopeDsymbol * and * static foreach (i; [0]) { enum i = 2; } */ - override Dsymbol symtabLookup(Dsymbol s, Identifier id) + override Dsymbol symtabLookup(Dsymbol s, Identifier id) nothrow { assert(forward); // correctly diagnose clashing foreach loop variables. @@ -2219,7 +2230,7 @@ extern (C++) final class ForwardingScopeDsymbol : ScopeDsymbol override const(char)* kind()const{ return "local scope"; } - override inout(ForwardingScopeDsymbol) isForwardingScopeDsymbol() inout + override inout(ForwardingScopeDsymbol) isForwardingScopeDsymbol() inout nothrow { return this; } @@ -2234,13 +2245,13 @@ extern (C++) final class ForwardingScopeDsymbol : ScopeDsymbol extern (C++) final class ExpressionDsymbol : Dsymbol { Expression exp; - this(Expression exp) + this(Expression exp) nothrow { super(); this.exp = exp; } - override inout(ExpressionDsymbol) isExpressionDsymbol() inout + override inout(ExpressionDsymbol) isExpressionDsymbol() inout nothrow { return this; } @@ -2259,7 +2270,7 @@ extern (C++) final class AliasAssign : Dsymbol Dsymbol aliassym; /// replace previous RHS of AliasDeclaration with `aliassym` /// only one of type and aliassym can be != null - extern (D) this(const ref Loc loc, Identifier ident, Type type, Dsymbol aliassym) + extern (D) this(const ref Loc loc, Identifier ident, Type type, Dsymbol aliassym) nothrow { super(loc, null); this.ident = ident; @@ -2299,6 +2310,8 @@ extern (C++) final class DsymbolTable : RootObject { AssocArray!(Identifier, Dsymbol) tab; + nothrow: + /*************************** * Look up Identifier in symbol table * Params: @@ -2511,6 +2524,7 @@ Dsymbol handleSymbolRedeclarations(ref Scope sc, Dsymbol s, Dsymbol s2, ScopeDsy if (i1) // vd is the definition { + vd2.storage_class |= STC.extern_; // so toObjFile() won't emit it sds.symtab.update(vd); // replace vd2 with the definition return vd; } diff --git a/gcc/d/dmd/dsymbolsem.d b/gcc/d/dmd/dsymbolsem.d index c9906363cc8..5415401e0e4 100644 --- a/gcc/d/dmd/dsymbolsem.d +++ b/gcc/d/dmd/dsymbolsem.d @@ -51,6 +51,7 @@ import dmd.init; import dmd.initsem; import dmd.hdrgen; import dmd.mtype; +import dmd.mustuse; import dmd.nogc; import dmd.nspace; import dmd.objc; @@ -542,7 +543,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor Parameter arg = Parameter.getNth(tt.arguments, pos); arg.type = arg.type.typeSemantic(dsym.loc, sc); //printf("[%d] iexps.dim = %d, ", pos, iexps.dim); - //printf("e = (%s %s, %s), ", Token::tochars[e.op], e.toChars(), e.type.toChars()); + //printf("e = (%s %s, %s), ", Token.tochars[e.op], e.toChars(), e.type.toChars()); //printf("arg = (%s, %s)\n", arg.toChars(), arg.type.toChars()); if (e != ie) @@ -581,7 +582,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor arg = Parameter.getNth(tt.arguments, pos + u); arg.type = arg.type.typeSemantic(dsym.loc, sc); //printf("[%d+%d] exps.dim = %d, ", pos, u, exps.dim); - //printf("ee = (%s %s, %s), ", Token::tochars[ee.op], ee.toChars(), ee.type.toChars()); + //printf("ee = (%s %s, %s), ", Token.tochars[ee.op], ee.toChars(), ee.type.toChars()); //printf("arg = (%s, %s)\n", arg.toChars(), arg.type.toChars()); size_t iexps_dim = iexps.dim - 1 + exps.dim; @@ -2046,6 +2047,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor ed.semanticRun = PASS.semantic; UserAttributeDeclaration.checkGNUABITag(ed, sc.linkage); + checkMustUseReserved(ed); if (!ed.members && !ed.memtype) // enum ident; { @@ -2872,7 +2874,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor sc = sc.endCTFE(); resolved = resolved.ctfeInterpret(); StringExp name = resolved.toStringExp(); - TupleExp tup = name ? null : resolved.toTupleExp(); + TupleExp tup = name ? null : resolved.isTupleExp(); if (!tup && !name) { error(ns.loc, "expected string expression for namespace name, got `%s`", ns.identExp.toChars()); @@ -3017,7 +3019,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor if ((funcdecl.storage_class & STC.TYPECTOR) && !(ad || funcdecl.isNested())) funcdecl.storage_class &= ~STC.TYPECTOR; - //printf("function storage_class = x%llx, sc.stc = x%llx, %x\n", storage_class, sc.stc, Declaration::isFinal()); + //printf("function storage_class = x%llx, sc.stc = x%llx, %x\n", storage_class, sc.stc, Declaration.isFinal()); if (sc.flags & SCOPE.compile) funcdecl.flags |= FUNCFLAG.compileTimeOnly; // don't emit code for this function @@ -3056,6 +3058,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor funcdecl.visibility = sc.visibility; funcdecl.userAttribDecl = sc.userAttribDecl; UserAttributeDeclaration.checkGNUABITag(funcdecl, funcdecl.linkage); + checkMustUseReserved(funcdecl); if (!funcdecl.originalType) funcdecl.originalType = funcdecl.type.syntaxCopy(); @@ -4092,7 +4095,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor override void visit(PostBlitDeclaration pbd) { //printf("PostBlitDeclaration::semantic() %s\n", toChars()); - //printf("ident: %s, %s, %p, %p\n", ident.toChars(), Id::dtor.toChars(), ident, Id::dtor); + //printf("ident: %s, %s, %p, %p\n", ident.toChars(), Id.dtor.toChars(), ident, Id.dtor); //printf("stc = x%llx\n", sc.stc); if (pbd.semanticRun >= PASS.semanticdone) return; @@ -4129,7 +4132,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor override void visit(DtorDeclaration dd) { //printf("DtorDeclaration::semantic() %s\n", toChars()); - //printf("ident: %s, %s, %p, %p\n", ident.toChars(), Id::dtor.toChars(), ident, Id::dtor); + //printf("ident: %s, %s, %p, %p\n", ident.toChars(), Id.dtor.toChars(), ident, Id.dtor); if (dd.semanticRun >= PASS.semanticdone) return; if (dd._scope) @@ -4618,7 +4621,8 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor buildOpAssign(sd, sc2); buildOpEquals(sd, sc2); - if (global.params.useTypeInfo && Type.dtypeinfo) // these functions are used for TypeInfo + if (!(sc2.flags & SCOPE.Cfile) && + global.params.useTypeInfo && Type.dtypeinfo) // these functions are used for TypeInfo { sd.xeq = buildXopEquals(sd, sc2); sd.xcmp = buildXopCmp(sd, sc2); @@ -4770,6 +4774,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor } cldec.semanticRun = PASS.semantic; UserAttributeDeclaration.checkGNUABITag(cldec, sc.linkage); + checkMustUseReserved(cldec); if (cldec.baseok < Baseok.done) { @@ -5019,6 +5024,10 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor cldec.com = true; if (cldec.baseClass.isCPPclass()) cldec.classKind = ClassKind.cpp; + if (cldec.classKind != cldec.baseClass.classKind) + cldec.error("with %s linkage cannot inherit from class `%s` with %s linkage", + cldec.classKind.toChars(), cldec.baseClass.toChars(), cldec.baseClass.classKind.toChars()); + if (cldec.baseClass.stack) cldec.stack = true; cldec.enclosing = cldec.baseClass.enclosing; @@ -5475,6 +5484,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor idec.classKind = ClassKind.cpp; idec.cppnamespace = sc.namespace; UserAttributeDeclaration.checkGNUABITag(idec, sc.linkage); + checkMustUseReserved(idec); if (sc.linkage == LINK.objc) objc.setObjc(idec); diff --git a/gcc/d/dmd/dtemplate.d b/gcc/d/dmd/dtemplate.d index a5ec63ca763..fb41e2bd05f 100644 --- a/gcc/d/dmd/dtemplate.d +++ b/gcc/d/dmd/dtemplate.d @@ -2626,7 +2626,7 @@ void functionResolve(ref MatchAccumulator m, Dsymbol dstart, Loc loc, Scope* sc, printf("\t%s %s\n", arg.type.toChars(), arg.toChars()); //printf("\tty = %d\n", arg.type.ty); } - //printf("stc = %llx\n", dstart.scope.stc); + //printf("stc = %llx\n", dstart._scope.stc); //printf("match:t/f = %d/%d\n", ta_last, m.last); } @@ -4332,7 +4332,7 @@ MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplateParameters* param { TypeStruct tp = cast(TypeStruct)tparam; - //printf("\t%d\n", (MATCH) t.implicitConvTo(tp)); + //printf("\t%d\n", cast(MATCH) t.implicitConvTo(tp)); if (wm && t.deduceWild(tparam, false)) { result = MATCH.constant; @@ -4513,7 +4513,7 @@ MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplateParameters* param { TypeClass tp = cast(TypeClass)tparam; - //printf("\t%d\n", (MATCH) t.implicitConvTo(tp)); + //printf("\t%d\n", cast(MATCH) t.implicitConvTo(tp)); if (wm && t.deduceWild(tparam, false)) { result = MATCH.constant; diff --git a/gcc/d/dmd/errors.d b/gcc/d/dmd/errors.d index 114bd44e32c..62e86a1163c 100644 --- a/gcc/d/dmd/errors.d +++ b/gcc/d/dmd/errors.d @@ -434,8 +434,20 @@ else pragma(printf) extern (C++) void vdeprecationSupplemental(const ref Loc loc, const(char)* format, va_list ap); /** - * Call this after printing out fatal error messages to clean up and exit - * the compiler. + * The type of the fatal error handler + * Returns: true if error handling is done, false to do exit(EXIT_FAILURE) + */ +alias FatalErrorHandler = bool delegate(); + +/** + * The fatal error handler. + * If non-null it will be called for every fatal() call issued by the compiler. + */ +__gshared FatalErrorHandler fatalErrorHandler; + +/** + * Call this after printing out fatal error messages to clean up and exit the + * compiler. You can also set a fatalErrorHandler to override this behaviour. */ extern (C++) void fatal(); diff --git a/gcc/d/dmd/escape.d b/gcc/d/dmd/escape.d index 4196c05489d..44c3757248b 100644 --- a/gcc/d/dmd/escape.d +++ b/gcc/d/dmd/escape.d @@ -316,24 +316,27 @@ bool checkParamArgumentEscape(Scope* sc, FuncDeclaration fdc, Parameter par, Exp */ void unsafeAssign(VarDeclaration v, const char* desc) { - if (global.params.useDIP1000 == FeatureState.enabled && sc.func.setUnsafe()) + if (setUnsafeDIP1000(sc.func)) { if (!gag) { if (assertmsg) { - error(arg.loc, "%s `%s` assigned to non-scope parameter calling `assert()`", + previewErrorFunc(sc.isDeprecated(), global.params.useDIP1000) + (arg.loc, "%s `%s` assigned to non-scope parameter calling `assert()`", desc, v.toChars()); } else { - error(arg.loc, "%s `%s` assigned to non-scope parameter `%s` calling %s", + previewErrorFunc(sc.isDeprecated(), global.params.useDIP1000) + (arg.loc, "%s `%s` assigned to non-scope parameter `%s` calling %s", desc, v.toChars(), par ? par.toChars() : "this", fdc ? fdc.toPrettyChars() : "indirectly"); } } - result = true; + if (global.params.useDIP1000 == FeatureState.enabled) + result = true; } } @@ -440,22 +443,33 @@ bool checkParamArgumentEscape(Scope* sc, FuncDeclaration fdc, Parameter par, Exp * sc = used to determine current function and module * firstArg = `ref` argument through which `arg` may be assigned * arg = initializer for parameter + * param = parameter declaration corresponding to `arg` * gag = do not print error messages * Returns: * `true` if assignment to `firstArg` would cause an error */ -bool checkParamArgumentReturn(Scope* sc, Expression firstArg, Expression arg, bool gag) +bool checkParamArgumentReturn(Scope* sc, Expression firstArg, Expression arg, Parameter param, bool gag) { enum log = false; if (log) printf("checkParamArgumentReturn(firstArg: %s arg: %s)\n", firstArg.toChars(), arg.toChars()); //printf("type = %s, %d\n", arg.type.toChars(), arg.type.hasPointers()); - if (!arg.type.hasPointers()) + if (!(param.storageClass & STC.return_)) return false; + if (!arg.type.hasPointers() && !param.isReference()) + return false; + + // `byRef` needed for `assign(ref int* x, ref int i) {x = &i};` + // Note: taking address of scope pointer is not allowed + // `assign(ref int** x, return ref scope int* i) {x = &i};` + // Thus no return ref/return scope ambiguity here + const byRef = param.isReference() && !(param.storageClass & STC.scope_) + && !(param.storageClass & STC.returnScope); // fixme: it's possible to infer returnScope without scope with vaIsFirstRef + scope e = new AssignExp(arg.loc, firstArg, arg); - return checkAssignEscape(sc, e, gag); + return checkAssignEscape(sc, e, gag, byRef); } /***************************************************** @@ -496,23 +510,13 @@ bool checkConstructorEscape(Scope* sc, CallExp ce, bool gag) foreach (const i; 0 .. n) { Expression arg = (*ce.arguments)[i]; - if (!arg.type.hasPointers()) - continue; - //printf("\targ[%d]: %s\n", i, arg.toChars()); if (i - j < nparams && i >= j) { Parameter p = tf.parameterList[i - j]; - - if (p.storageClass & STC.return_) - { - /* Fake `dve.e1 = arg;` and look for scope violations - */ - scope e = new AssignExp(arg.loc, dve.e1, arg); - if (checkAssignEscape(sc, e, gag)) - return true; - } + if (checkParamArgumentReturn(sc, dve.e1, arg, p, gag)) + return true; } } @@ -529,13 +533,14 @@ bool checkConstructorEscape(Scope* sc, CallExp ce, bool gag) * sc = used to determine current function and module * e = `AssignExp` or `CatAssignExp` to check for any pointers to the stack * gag = do not print error messages + * byRef = set to `true` if `e1` of `e` gets assigned a reference to `e2` * Returns: * `true` if pointers to the stack can escape via assignment */ -bool checkAssignEscape(Scope* sc, Expression e, bool gag) +bool checkAssignEscape(Scope* sc, Expression e, bool gag, bool byRef) { enum log = false; - if (log) printf("checkAssignEscape(e: %s)\n", e.toChars()); + if (log) printf("checkAssignEscape(e: %s, byRef: %d)\n", e.toChars(), byRef); if (e.op != EXP.assign && e.op != EXP.blit && e.op != EXP.construct && e.op != EXP.concatenateAssign && e.op != EXP.concatenateElemAssign && e.op != EXP.concatenateDcharAssign) return false; @@ -561,7 +566,10 @@ bool checkAssignEscape(Scope* sc, Expression e, bool gag) EscapeByResults er; - escapeByValue(e2, &er); + if (byRef) + escapeByRef(e2, &er); + else + escapeByValue(e2, &er); if (!er.byref.dim && !er.byvalue.dim && !er.byfunc.dim && !er.byexp.dim) return false; @@ -769,7 +777,7 @@ bool checkAssignEscape(Scope* sc, Expression e, bool gag) if (v.isDataseg()) continue; - if (global.params.useDIP1000 == FeatureState.enabled) + if (global.params.useDIP1000 != FeatureState.disabled) { if (va && va.isScope() && !v.isReference()) { @@ -777,20 +785,36 @@ bool checkAssignEscape(Scope* sc, Expression e, bool gag) { va.doNotInferReturn = true; } - else if (fd.setUnsafe()) + else if (setUnsafeDIP1000(fd)) { if (!gag) - error(ae.loc, "address of local variable `%s` assigned to return scope `%s`", v.toChars(), va.toChars()); - result = true; - continue; + previewErrorFunc(sc.isDeprecated(), global.params.useDIP1000) + (ae.loc, "address of local variable `%s` assigned to return scope `%s`", v.toChars(), va.toChars()); + + + if (global.params.useDIP1000 == FeatureState.enabled) + { + result = true; + continue; + } } } } Dsymbol p = v.toParent2(); + if (vaIsFirstRef && v.isParameter() && + !(v.storage_class & STC.return_) && + fd.flags & FUNCFLAG.returnInprocess && + p == fd) + { + //if (log) printf("inferring 'return' for parameter %s in function %s\n", v.toChars(), fd.toChars()); + inferReturn(fd, v, /*returnScope:*/ false); + } + // If va's lifetime encloses v's, then error if (va && + !(vaIsFirstRef && (v.storage_class & STC.return_)) && (va.enclosesLifetimeOf(v) || (va.isReference() && !(va.storage_class & STC.temp)) || va.isDataseg()) && fd.setUnsafe()) { @@ -961,12 +985,11 @@ bool checkThrowEscape(Scope* sc, Expression e, bool gag) if (v.isScope() && !v.iscatchvar) // special case: allow catch var to be rethrown // despite being `scope` { + if (!gag) + previewErrorFunc(sc.isDeprecated(), global.params.useDIP1000) + (e.loc, "scope variable `%s` may not be thrown", v.toChars()); if (global.params.useDIP1000 == FeatureState.enabled) // https://issues.dlang.org/show_bug.cgi?id=17029 - { - if (!gag) - error(e.loc, "scope variable `%s` may not be thrown", v.toChars()); result = true; - } continue; } else @@ -1027,13 +1050,16 @@ bool checkNewEscape(Scope* sc, Expression e, bool gag) */ !(p.parent == sc.func)) { - if (global.params.useDIP1000 == FeatureState.enabled // https://issues.dlang.org/show_bug.cgi?id=17029 - && sc.func.setUnsafe()) // https://issues.dlang.org/show_bug.cgi?id=20868 + if (setUnsafeDIP1000(sc.func)) // https://issues.dlang.org/show_bug.cgi?id=20868 { + // Only look for errors if in module listed on command line if (!gag) - error(e.loc, "scope variable `%s` may not be copied into allocated memory", v.toChars()); - result = true; + previewErrorFunc(sc.isDeprecated(), global.params.useDIP1000) + (e.loc, "scope variable `%s` may not be copied into allocated memory", v.toChars()); + if (global.params.useDIP1000 == FeatureState.enabled) + result = true; } + continue; } } @@ -1243,11 +1269,13 @@ private bool checkReturnEscapeImpl(Scope* sc, Expression e, bool refs, bool gag) ) { // https://issues.dlang.org/show_bug.cgi?id=17029 - if (global.params.useDIP1000 == FeatureState.enabled && sc.func.setUnsafe()) + if (setUnsafeDIP1000(sc.func)) { if (!gag) - error(e.loc, "scope variable `%s` may not be returned", v.toChars()); - result = true; + previewErrorFunc(sc.isDeprecated(), global.params.useDIP1000) + (e.loc, "scope variable `%s` may not be returned", v.toChars()); + if (global.params.useDIP1000 == FeatureState.enabled) + result = true; } continue; } @@ -2326,3 +2354,11 @@ private void addMaybe(VarDeclaration va, VarDeclaration v) va.maybes = new VarDeclarations(); va.maybes.push(v); } + + +private bool setUnsafeDIP1000(FuncDeclaration f) +{ + return global.params.useDIP1000 == FeatureState.enabled + ? f.setUnsafe() + : f.isSafeBypassingInference(); +} diff --git a/gcc/d/dmd/expression.d b/gcc/d/dmd/expression.d index 07d885b0bee..107e85b0793 100644 --- a/gcc/d/dmd/expression.d +++ b/gcc/d/dmd/expression.d @@ -967,11 +967,6 @@ extern (C++) abstract class Expression : ASTNode return null; } - TupleExp toTupleExp() - { - return null; - } - /*************************************** * Return !=0 if expression is an lvalue. */ @@ -1660,6 +1655,7 @@ extern (C++) abstract class Expression : ASTNode inout(MixinExp) isMixinExp() { return op == EXP.mixin_ ? cast(typeof(return))this : null; } inout(ImportExp) isImportExp() { return op == EXP.import_ ? cast(typeof(return))this : null; } inout(AssertExp) isAssertExp() { return op == EXP.assert_ ? cast(typeof(return))this : null; } + inout(ThrowExp) isThrowExp() { return op == EXP.throw_ ? cast(typeof(return))this : null; } inout(DotIdExp) isDotIdExp() { return op == EXP.dotIdentifier ? cast(typeof(return))this : null; } inout(DotTemplateExp) isDotTemplateExp() { return op == EXP.dotTemplateDeclaration ? cast(typeof(return))this : null; } inout(DotVarExp) isDotVarExp() { return op == EXP.dotVariable ? cast(typeof(return))this : null; } @@ -1745,6 +1741,7 @@ extern (C++) abstract class Expression : ASTNode inout(ModuleInitExp) isModuleInitExp() { return op == EXP.moduleString ? cast(typeof(return))this : null; } inout(FuncInitExp) isFuncInitExp() { return op == EXP.functionString ? cast(typeof(return))this : null; } inout(PrettyFuncInitExp) isPrettyFuncInitExp() { return op == EXP.prettyFunction ? cast(typeof(return))this : null; } + inout(ObjcClassReferenceExp) isObjcClassReferenceExp() { return op == EXP.objcClassReference ? cast(typeof(return))this : null; } inout(ClassReferenceExp) isClassReferenceExp() { return op == EXP.classReference ? cast(typeof(return))this : null; } inout(ThrownExceptionExp) isThrownExceptionExp() { return op == EXP.thrownException ? cast(typeof(return))this : null; } @@ -2684,7 +2681,7 @@ extern (C++) final class StringExp : Expression const len2 = se2.len; assert(this.sz == se2.sz, "Comparing string expressions of different sizes"); - //printf("sz = %d, len1 = %d, len2 = %d\n", sz, (int)len1, (int)len2); + //printf("sz = %d, len1 = %d, len2 = %d\n", sz, cast(int)len1, cast(int)len2); if (len1 == len2) { switch (sz) @@ -2887,11 +2884,6 @@ extern (C++) final class TupleExp : Expression return new TupleExp(loc, exps); } - override TupleExp toTupleExp() - { - return this; - } - override TupleExp syntaxCopy() { return new TupleExp(loc, e0 ? e0.syntaxCopy() : null, arraySyntaxCopy(exps)); diff --git a/gcc/d/dmd/expression.h b/gcc/d/dmd/expression.h index 9522b23a3b1..330dcdb77ec 100644 --- a/gcc/d/dmd/expression.h +++ b/gcc/d/dmd/expression.h @@ -103,7 +103,6 @@ public: virtual real_t toImaginary(); virtual complex_t toComplex(); virtual StringExp *toStringExp(); - virtual TupleExp *toTupleExp(); virtual bool isLvalue(); virtual Expression *toLvalue(Scope *sc, Expression *e); virtual Expression *modifiableLvalue(Scope *sc, Expression *e); @@ -374,11 +373,11 @@ public: OwnedBy ownedByCtfe; static StringExp *create(const Loc &loc, const char *s); - static StringExp *create(const Loc &loc, const void *s, size_t len); + static StringExp *create(const Loc &loc, const void *s, d_size_t len); static void emplace(UnionExp *pue, const Loc &loc, const char *s); bool equals(const RootObject *o) const; - char32_t getCodeUnit(size_t i) const; - void setCodeUnit(size_t i, char32_t c); + char32_t getCodeUnit(d_size_t i) const; + void setCodeUnit(d_size_t i, char32_t c); StringExp *toStringExp(); StringExp *toUTF8(Scope *sc); Optional<bool> toBool(); @@ -406,7 +405,6 @@ public: Expressions *exps; static TupleExp *create(const Loc &loc, Expressions *exps); - TupleExp *toTupleExp(); TupleExp *syntaxCopy(); bool equals(const RootObject *o) const; diff --git a/gcc/d/dmd/expressionsem.d b/gcc/d/dmd/expressionsem.d index 7b7c489295a..d4e96bb0f09 100644 --- a/gcc/d/dmd/expressionsem.d +++ b/gcc/d/dmd/expressionsem.d @@ -56,6 +56,7 @@ import dmd.initsem; import dmd.inline; import dmd.intrange; import dmd.mtype; +import dmd.mustuse; import dmd.nspace; import dmd.opover; import dmd.optimize; @@ -713,7 +714,7 @@ private Expression resolveUFCSProperties(Scope* sc, Expression e1, Expression e2 */ Expression resolvePropertiesOnly(Scope* sc, Expression e1) { - //printf("e1 = %s %s\n", Token::toChars(e1.op), e1.toChars()); + //printf("e1 = %s %s\n", Token.toChars(e1.op), e1.toChars()); Expression handleOverloadSet(OverloadSet os) { @@ -2027,15 +2028,19 @@ private bool functionParameters(const ref Loc loc, Scope* sc, //printf("type: %s\n", arg.type.toChars()); //printf("param: %s\n", p.toChars()); - if (firstArg && p.storageClass & STC.return_) + const pStc = tf.parameterStorageClass(tthis, p); + + if (firstArg && (pStc & STC.return_)) { /* Argument value can be assigned to firstArg. * Check arg to see if it matters. */ if (global.params.useDIP1000 == FeatureState.enabled) - err |= checkParamArgumentReturn(sc, firstArg, arg, false); + err |= checkParamArgumentReturn(sc, firstArg, arg, p, false); } - else if (tf.parameterEscapes(tthis, p)) + // Allow 'lazy' to imply 'scope' - lazy parameters can be passed along + // as lazy parameters to the next function, but that isn't escaping. + else if (!(pStc & (STC.scope_ | STC.lazy_))) { /* Argument value can escape from the called function. * Check arg to see if it matters. @@ -2043,7 +2048,7 @@ private bool functionParameters(const ref Loc loc, Scope* sc, if (global.params.useDIP1000 == FeatureState.enabled) err |= checkParamArgumentEscape(sc, fd, p, arg, false, false); } - else if (!(p.storageClass & STC.return_)) + else if (!(pStc & STC.return_)) { /* Argument value cannot escape from the called function. */ @@ -3228,7 +3233,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor } Type t = cle.type.typeSemantic(cle.loc, sc); auto init = initializerSemantic(cle.initializer, sc, t, INITnointerpret); - auto e = initializerToExpression(init, t); + auto e = initializerToExpression(init, t, (sc.flags & SCOPE.Cfile) != 0); if (!e) { error(cle.loc, "cannot convert initializer `%s` to expression", init.toChars()); @@ -3261,7 +3266,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor // printf("apply fix for issue 9490: add `this.` to `%s`...\n", e.toChars()); e = new DotVarExp(exp.loc, new ThisExp(exp.loc), ve.var, false); } - //printf("e = %s %s\n", Token::toChars(e.op), e.toChars()); + //printf("e = %s %s\n", Token.toChars(e.op), e.toChars()); e = e.expressionSemantic(sc); } else if (t) @@ -5211,13 +5216,30 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor if (s.ident) { VarDeclaration v = s.isVarDeclaration(); - if (v && !(sc.flags & SCOPE.Cfile)) + if (v) { - /* Do semantic() on initializer first so this will be illegal: - * int a = a; - */ - e.declaration.dsymbolSemantic(sc); - s.parent = sc.parent; + if (sc.flags & SCOPE.Cfile) + { + /* Do semantic() on the type before inserting v into the symbol table + */ + if (!v.originalType) + v.originalType = v.type.syntaxCopy(); + Scope* sc2 = sc.push(); + sc2.stc |= v.storage_class & STC.FUNCATTR; + sc2.linkage = LINK.c; // account for the extern(C) in front of the declaration + v.inuse++; + v.type = v.type.typeSemantic(v.loc, sc2); + v.inuse--; + sc2.pop(); + } + else + { + /* Do semantic() on initializer first so this will be illegal: + * int a = a; + */ + e.declaration.dsymbolSemantic(sc); + s.parent = sc.parent; + } } if (!sc.insert(s)) @@ -6032,7 +6054,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor auto fileName = FileName(name.toDString); if (auto fmResult = global.fileManager.lookup(fileName)) { - se = new StringExp(e.loc, fmResult.data); + se = new StringExp(e.loc, fmResult); } else { @@ -6047,9 +6069,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor // take ownership of buffer (probably leaking) auto data = readResult.extractSlice(); se = new StringExp(e.loc, data); - - FileBuffer* fileBuffer = new FileBuffer(data); - global.fileManager.add(fileName, fileBuffer); + global.fileManager.add(fileName, data); } } } @@ -6388,7 +6408,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor static if (LOGSEMANTIC) { printf("DotIdExp::semantic(this = %p, '%s')\n", exp, exp.toChars()); - //printf("e1.op = %d, '%s'\n", e1.op, Token::toChars(e1.op)); + //printf("e1.op = %d, '%s'\n", e1.op, Token.toChars(e1.op)); } if (sc.flags & SCOPE.Cfile) @@ -8177,7 +8197,10 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor return; if (e.type is Type.tvoid) + { + checkMustUse(e.e1, sc); discardValue(e.e1); + } else if (!e.allowCommaExp && !e.isGenerated) e.error("Using the result of a comma expression is not allowed"); } @@ -8956,7 +8979,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor Parameter arg = Parameter.getNth(tt.arguments, u); //printf("[%d] iexps.dim = %d, ", u, iexps.dim); - //printf("e = (%s %s, %s), ", Token::tochars[e.op], e.toChars(), e.type.toChars()); + //printf("e = (%s %s, %s), ", Token.toChars[e.op], e.toChars(), e.type.toChars()); //printf("arg = (%s, %s)\n", arg.toChars(), arg.type.toChars()); if (!arg || !e.type.implicitConvTo(arg.type)) @@ -9849,7 +9872,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor * `reorderSettingAAElem` creates a tree of comma expressions, however, * `checkAssignExp` expects only AssignExps. */ - checkAssignEscape(sc, Expression.extractLast(res, tmp), false); + checkAssignEscape(sc, Expression.extractLast(res, tmp), false, false); if (auto ae = res.isConstructExp()) { @@ -10124,7 +10147,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor */ if (isRecursiveAliasThis(exp.att1, exp.e1.type)) return null; - //printf("att %s e1 = %s\n", Token::toChars(e.op), e.e1.type.toChars()); + //printf("att %s e1 = %s\n", Token.toChars(e.op), e.e1.type.toChars()); Expression e1 = new DotIdExp(exp.loc, exp.e1, ad1.aliasthis.ident); BinExp be = cast(BinExp)exp.copy(); be.e1 = e1; @@ -10142,7 +10165,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor */ if (isRecursiveAliasThis(exp.att2, exp.e2.type)) return null; - //printf("att %s e2 = %s\n", Token::toChars(e.op), e.e2.type.toChars()); + //printf("att %s e2 = %s\n", Token.toChars(e.op), e.e2.type.toChars()); Expression e2 = new DotIdExp(exp.loc, exp.e2, ad2.aliasthis.ident); BinExp be = cast(BinExp)exp.copy(); be.e2 = e2; @@ -10169,7 +10192,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor auto res = exp.reorderSettingAAElem(sc); if ((exp.op == EXP.concatenateElemAssign || exp.op == EXP.concatenateDcharAssign) && global.params.useDIP1000 == FeatureState.enabled) - checkAssignEscape(sc, res, false); + checkAssignEscape(sc, res, false, false); result = res; } @@ -12193,7 +12216,7 @@ Expression semanticX(DotIdExp exp, Scope* sc) if (Expression ex = unaSemantic(exp, sc)) return ex; - if (exp.ident == Id._mangleof) + if (!(sc.flags & SCOPE.Cfile) && exp.ident == Id._mangleof) { // symbol.mangleof @@ -12302,6 +12325,8 @@ Expression semanticY(DotIdExp exp, Scope* sc, int flag) //{ static int z; fflush(stdout); if (++z == 10) *(char*)0=0; } + const cfile = (sc.flags & SCOPE.Cfile) != 0; + /* Special case: rewrite this.id and super.id * to be classtype.id and baseclasstype.id * if we have no this pointer. @@ -12553,7 +12578,16 @@ Expression semanticY(DotIdExp exp, Scope* sc, int flag) exp.error("undefined identifier `%s` in %s `%s`", exp.ident.toChars(), ie.sds.kind(), ie.sds.toPrettyChars()); return ErrorExp.get(); } - else if (t1b.ty == Tpointer && exp.e1.type.ty != Tenum && exp.ident != Id._init && exp.ident != Id.__sizeof && exp.ident != Id.__xalignof && exp.ident != Id.offsetof && exp.ident != Id._mangleof && exp.ident != Id.stringof) + else if (t1b.ty == Tpointer && exp.e1.type.ty != Tenum && + !( + exp.ident == Id.__sizeof || + exp.ident == Id.__xalignof || + !cfile && + (exp.ident == Id._mangleof || + exp.ident == Id.offsetof || + exp.ident == Id._init || + exp.ident == Id.stringof) + )) { Type t1bn = t1b.nextOf(); if (flag) @@ -12588,7 +12622,7 @@ Expression semanticY(DotIdExp exp, Scope* sc, int flag) Expression e = new IntegerExp(exp.loc, actualAlignment, Type.tsize_t); return e; } - else if (sc.flags & SCOPE.Cfile && exp.ident == Id.__sizeof && exp.e1.isStringExp()) + else if (cfile && exp.ident == Id.__sizeof && exp.e1.isStringExp()) { // Sizeof string literal includes the terminating 0 auto se = exp.e1.isStringExp(); @@ -12803,129 +12837,125 @@ bool checkSharedAccess(Expression e, Scope* sc, bool returnRef = false) return false; } - //printf("checkSharedAccess() %s\n", e.toChars()); - - static extern(C++) final class SharedCheckVisitor : SemanticTimeTransitiveVisitor - { - /// In case we don't know which expression triggered it, - /// e.g. for `visit(Type)` overload - Expression original; - /// Where the result is stored (`true` == error) - bool result; - /// Whether we should allow one level of dereferencing - bool allowRef; + //printf("checkSharedAccess() `%s` returnRef: %d\n", e.toChars(), returnRef); - /// Ctor - this(Expression oe, bool allowRef_) - { - this.original = oe; - this.allowRef = allowRef_; - } + /* In case we don't know which expression triggered it, + * e.g. for `visit(Type)` overload + */ + Expression original = e; - void sharedError(Expression e) + bool check(Expression e, bool allowRef) + { + bool sharedError(Expression e) { // https://dlang.org/phobos/core_atomic.html e.error("direct access to shared `%s` is not allowed, see `core.atomic`", e.toChars()); - this.result = true; + return true; } - /// Introduce base class overrides - alias visit = SemanticTimeTransitiveVisitor.visit; - // Error by default - override void visit(Expression e) + bool visit(Expression e) { if (e.type.isShared()) - this.sharedError(e); + return sharedError(e); + return false; } - /// Ditto - override void visit(Type t) + bool visitNew(NewExp e) { + if (e.thisexp) + check(e.thisexp, false); // Note: This handles things like `new shared(Throwable).msg`, // where accessing `msg` would violate `shared`. - if (t.isShared()) - this.sharedError(this.original); + if (e.newtype.isShared()) + return sharedError(original); + return false; } - // Those have no indirections / can be ignored - override void visit(ErrorExp e) {} - override void visit(ComplexExp e) {} - override void visit(IntegerExp e) {} - override void visit(NullExp e) {} - - override void visit(VarExp e) + bool visitVar(VarExp e) { - if (!this.allowRef && e.var.type.isShared()) - this.sharedError(e); + if (!allowRef && e.var.type.isShared()) + return sharedError(e); + return false; } - override void visit(AddrExp e) + bool visitAddr(AddrExp e) { - this.allowRef = true; - e.e1.accept(this); + return check(e.e1, true); } - override void visit(PtrExp e) + bool visitPtr(PtrExp e) { - if (!this.allowRef && e.type.isShared()) - return this.sharedError(e); + if (!allowRef && e.type.isShared()) + return sharedError(e); if (e.e1.type.isShared()) - return this.sharedError(e); + return sharedError(e); - this.allowRef = false; - e.e1.accept(this); + return check(e.e1, false); } - override void visit(DotVarExp e) + bool visitDotVar(DotVarExp e) { auto fd = e.var.isFuncDeclaration(); const sharedFunc = fd && fd.type.isShared; - if (!this.allowRef && e.type.isShared() && !sharedFunc) - return this.sharedError(e); + if (!allowRef && e.type.isShared() && !sharedFunc) + return sharedError(e); - // Allow to use `DotVarExp` within value types - if (e.e1.type.ty == Tsarray || e.e1.type.ty == Tstruct) - return e.e1.accept(this); + // Allow using `DotVarExp` within value types + if (e.e1.type.isTypeSArray() || e.e1.type.isTypeStruct()) + return check(e.e1, allowRef); // If we end up with a single `VarExp`, it might be a `ref` param // `shared ref T` param == `shared(T)*`. if (auto ve = e.e1.isVarExp()) { - this.allowRef = this.allowRef && (ve.var.storage_class & STC.ref_); - return e.e1.accept(this); + return check(e.e1, allowRef && (ve.var.storage_class & STC.ref_)); } - this.allowRef = false; - return e.e1.accept(this); + return check(e.e1, false); } - override void visit(IndexExp e) + bool visitIndex(IndexExp e) { - if (!this.allowRef && e.type.isShared()) - return this.sharedError(e); + if (!allowRef && e.type.isShared()) + return sharedError(e); if (e.e1.type.isShared()) - return this.sharedError(e); + return sharedError(e); - this.allowRef = false; - e.e1.accept(this); + return check(e.e1, false); } - override void visit(CommaExp e) + bool visitComma(CommaExp e) { // Cannot be `return ref` since we can't use the return, // but it's better to show that error than an unrelated `shared` one - this.allowRef = true; - e.e2.accept(this); + return check(e.e2, true); + } + + switch (e.op) + { + default: return visit(e); + + // Those have no indirections / can be ignored + case EXP.call: + case EXP.error: + case EXP.complex80: + case EXP.int64: + case EXP.null_: return false; + + case EXP.variable: return visitVar(e.isVarExp()); + case EXP.new_: return visitNew(e.isNewExp()); + case EXP.address: return visitAddr(e.isAddrExp()); + case EXP.star: return visitPtr(e.isPtrExp()); + case EXP.dotVariable: return visitDotVar(e.isDotVarExp()); + case EXP.index: return visitIndex(e.isIndexExp()); } } - scope visitor = new SharedCheckVisitor(e, returnRef); - e.accept(visitor); - return visitor.result; + return check(e, returnRef); } diff --git a/gcc/d/dmd/file_manager.d b/gcc/d/dmd/file_manager.d index b86c7995562..9fe40bf0603 100644 --- a/gcc/d/dmd/file_manager.d +++ b/gcc/d/dmd/file_manager.d @@ -11,7 +11,7 @@ module dmd.file_manager; import dmd.root.stringtable : StringTable; -import dmd.root.file : File, FileBuffer; +import dmd.root.file : File, Buffer; import dmd.root.filename : FileName; import dmd.root.string : toDString; import dmd.globals; @@ -22,7 +22,7 @@ enum package_di = "package." ~ hdr_ext; final class FileManager { - private StringTable!(FileBuffer*) files; + private StringTable!(const(ubyte)[]) files; /// public this () nothrow @@ -146,7 +146,7 @@ nothrow: * Returns: the loaded source file if it was found in memory, * otherwise `null` */ - const(FileBuffer)* lookup(FileName filename) + const(ubyte)[] lookup(FileName filename) { const name = filename.toString; if (auto val = files.lookup(name)) @@ -154,7 +154,7 @@ nothrow: if (name == "__stdin.d") { - auto buffer = new FileBuffer(readFromStdin().extractSlice()); + auto buffer = readFromStdin().extractSlice(); if (this.files.insert(name, buffer) is null) assert(0, "stdin: Insert after lookup failure should never return `null`"); return buffer; @@ -167,7 +167,7 @@ nothrow: if (!readResult.success) return null; - FileBuffer* fb = new FileBuffer(readResult.extractSlice()); + auto fb = readResult.extractSlice(); if (files.insert(name, fb) is null) assert(0, "Insert after lookup failure should never return `null`"); @@ -187,17 +187,17 @@ nothrow: const(char)[][] lines; if (const buffer = lookup(file)) { - const slice = buffer.data[0 .. buffer.data.length]; + const slice = buffer; size_t start, end; - ubyte c; for (auto i = 0; i < slice.length; i++) { - c = slice[i]; + const c = slice[i]; if (c == '\n' || c == '\r') { if (i != 0) { end = i; + // Appending lines one at a time will certainly be slow lines ~= cast(const(char)[])slice[start .. end]; } // Check for Windows-style CRLF newlines @@ -234,18 +234,21 @@ nothrow: } /** - * Adds a FileBuffer to the table. - * - * Returns: The FileBuffer added, or null + * Adds the contents of a file to the table. + * Params: + * filename = name of the file + * buffer = contents of the file + * Returns: + * the buffer added, or null */ - FileBuffer* add(FileName filename, FileBuffer* filebuffer) + const(ubyte)[] add(FileName filename, const(ubyte)[] buffer) { - auto val = files.insert(filename.toString, filebuffer); + auto val = files.insert(filename.toString, buffer); return val == null ? null : val.value; } } -private FileBuffer readFromStdin() nothrow +private Buffer readFromStdin() nothrow { import core.stdc.stdio; import dmd.errors; @@ -277,7 +280,7 @@ private FileBuffer readFromStdin() nothrow // We're done assert(pos < sz + 2); buffer[pos .. pos + 4] = '\0'; - return FileBuffer(buffer[0 .. pos]); + return Buffer(buffer[0 .. pos]); } } while (pos < sz); diff --git a/gcc/d/dmd/hdrgen.d b/gcc/d/dmd/hdrgen.d index a3afbe50796..69fdf27e1db 100644 --- a/gcc/d/dmd/hdrgen.d +++ b/gcc/d/dmd/hdrgen.d @@ -1538,6 +1538,13 @@ public: } else if (hgs.tpltMember == 0 && global.params.hdrStripPlainFunctions) { + if (!f.fbody) + { + // this can happen on interfaces / abstract functions, see `allowsContractWithoutBody` + if (f.fensures || f.frequires) + buf.writenl(); + contractsToBuffer(f); + } buf.writeByte(';'); buf.writenl(); } @@ -1548,19 +1555,9 @@ public: bodyToBuffer(f); } - void bodyToBuffer(FuncDeclaration f) + /// Returns: whether `do` is needed to write the function body + bool contractsToBuffer(FuncDeclaration f) { - if (!f.fbody || (hgs.hdrgen && global.params.hdrStripPlainFunctions && !hgs.autoMember && !hgs.tpltMember)) - { - buf.writeByte(';'); - buf.writenl(); - return; - } - const savetlpt = hgs.tpltMember; - const saveauto = hgs.autoMember; - hgs.tpltMember = 0; - hgs.autoMember = 0; - buf.writenl(); bool requireDo = false; // in{} if (f.frequires) @@ -1619,6 +1616,29 @@ public: } } } + return requireDo; + } + + void bodyToBuffer(FuncDeclaration f) + { + if (!f.fbody || (hgs.hdrgen && global.params.hdrStripPlainFunctions && !hgs.autoMember && !hgs.tpltMember)) + { + if (!f.fbody && (f.fensures || f.frequires)) + { + buf.writenl(); + contractsToBuffer(f); + } + buf.writeByte(';'); + buf.writenl(); + return; + } + const savetlpt = hgs.tpltMember; + const saveauto = hgs.autoMember; + hgs.tpltMember = 0; + hgs.autoMember = 0; + buf.writenl(); + bool requireDo = contractsToBuffer(f); + if (requireDo) { buf.writestring("do"); @@ -1788,26 +1808,17 @@ public: } } -private extern (C++) final class ExpressionPrettyPrintVisitor : Visitor +/********************************************* + * Print expression to buffer. + */ +private void expressionPrettyPrint(Expression e, OutBuffer* buf, HdrGenState* hgs) { - alias visit = Visitor.visit; -public: - OutBuffer* buf; - HdrGenState* hgs; - - extern (D) this(OutBuffer* buf, HdrGenState* hgs) - { - this.buf = buf; - this.hgs = hgs; - } - - //////////////////////////////////////////////////////////////////////////// - override void visit(Expression e) + void visit(Expression e) { buf.writestring(EXPtoString(e.op)); } - override void visit(IntegerExp e) + void visitInteger(IntegerExp e) { const dinteger_t v = e.toInteger(); if (e.type) @@ -1907,12 +1918,12 @@ public: buf.print(v); } - override void visit(ErrorExp e) + void visitError(ErrorExp e) { buf.writestring("__error"); } - override void visit(VoidInitExp e) + void visitVoidInit(VoidInitExp e) { buf.writestring("__void"); } @@ -1922,12 +1933,12 @@ public: .floatToBuffer(type, value, buf, hgs.hdrgen); } - override void visit(RealExp e) + void visitReal(RealExp e) { floatToBuffer(e.type, e.value); } - override void visit(ComplexExp e) + void visitComplex(ComplexExp e) { /* Print as: * (re+imi) @@ -1939,7 +1950,7 @@ public: buf.writestring("i)"); } - override void visit(IdentifierExp e) + void visitIdentifier(IdentifierExp e) { if (hgs.hdrgen || hgs.ddoc) buf.writestring(e.ident.toHChars2()); @@ -1947,27 +1958,27 @@ public: buf.writestring(e.ident.toString()); } - override void visit(DsymbolExp e) + void visitDsymbol(DsymbolExp e) { buf.writestring(e.s.toChars()); } - override void visit(ThisExp e) + void visitThis(ThisExp e) { buf.writestring("this"); } - override void visit(SuperExp e) + void visitSuper(SuperExp e) { buf.writestring("super"); } - override void visit(NullExp e) + void visitNull(NullExp e) { buf.writestring("null"); } - override void visit(StringExp e) + void visitString(StringExp e) { buf.writeByte('"'); const o = buf.length; @@ -1982,14 +1993,14 @@ public: buf.writeByte(e.postfix); } - override void visit(ArrayLiteralExp e) + void visitArrayLiteral(ArrayLiteralExp e) { buf.writeByte('['); argsToBuffer(e.elements, buf, hgs, e.basis); buf.writeByte(']'); } - override void visit(AssocArrayLiteralExp e) + void visitAssocArrayLiteral(AssocArrayLiteralExp e) { buf.writeByte('['); foreach (i, key; *e.keys) @@ -2004,7 +2015,7 @@ public: buf.writeByte(']'); } - override void visit(StructLiteralExp e) + void visitStructLiteral(StructLiteralExp e) { buf.writestring(e.sd.toChars()); buf.writeByte('('); @@ -2024,7 +2035,7 @@ public: buf.writeByte(')'); } - override void visit(CompoundLiteralExp e) + void visitCompoundLiteral(CompoundLiteralExp e) { buf.writeByte('('); typeToBuffer(e.type, null, buf, hgs); @@ -2032,12 +2043,12 @@ public: e.initializer.initializerToBuffer(buf, hgs); } - override void visit(TypeExp e) + void visitType(TypeExp e) { typeToBuffer(e.type, null, buf, hgs); } - override void visit(ScopeExp e) + void visitScope(ScopeExp e) { if (e.sds.isTemplateInstance()) { @@ -2059,12 +2070,12 @@ public: } } - override void visit(TemplateExp e) + void visitTemplate(TemplateExp e) { buf.writestring(e.td.toChars()); } - override void visit(NewExp e) + void visitNew(NewExp e) { if (e.thisexp) { @@ -2081,7 +2092,7 @@ public: } } - override void visit(NewAnonClassExp e) + void visitNewAnonClass(NewAnonClassExp e) { if (e.thisexp) { @@ -2100,7 +2111,7 @@ public: e.cd.dsymbolToBuffer(buf, hgs); } - override void visit(SymOffExp e) + void visitSymOff(SymOffExp e) { if (e.offset) buf.printf("(& %s%+lld)", e.var.toChars(), e.offset); @@ -2110,22 +2121,22 @@ public: buf.printf("& %s", e.var.toChars()); } - override void visit(VarExp e) + void visitVar(VarExp e) { buf.writestring(e.var.toChars()); } - override void visit(OverExp e) + void visitOver(OverExp e) { buf.writestring(e.vars.ident.toString()); } - override void visit(TupleExp e) + void visitTuple(TupleExp e) { if (e.e0) { buf.writeByte('('); - e.e0.accept(this); + e.e0.expressionPrettyPrint(buf, hgs); buf.writestring(", tuple("); argsToBuffer(e.exps, buf, hgs); buf.writestring("))"); @@ -2138,13 +2149,13 @@ public: } } - override void visit(FuncExp e) + void visitFunc(FuncExp e) { e.fd.dsymbolToBuffer(buf, hgs); //buf.writestring(e.fd.toChars()); } - override void visit(DeclarationExp e) + void visitDeclaration(DeclarationExp e) { /* Normal dmd execution won't reach here - regular variable declarations * are handled in visit(ExpStatement), so here would be used only when @@ -2170,14 +2181,14 @@ public: } } - override void visit(TypeidExp e) + void visitTypeid(TypeidExp e) { buf.writestring("typeid("); objectToBuffer(e.obj, buf, hgs); buf.writeByte(')'); } - override void visit(TraitsExp e) + void visitTraits(TraitsExp e) { buf.writestring("__traits("); if (e.ident) @@ -2193,12 +2204,12 @@ public: buf.writeByte(')'); } - override void visit(HaltExp e) + void visitHalt(HaltExp e) { buf.writestring("halt"); } - override void visit(IsExp e) + void visitIs(IsExp e) { buf.writestring("is("); typeToBuffer(e.targ, e.id, buf, hgs); @@ -2223,13 +2234,13 @@ public: buf.writeByte(')'); } - override void visit(UnaExp e) + void visitUna(UnaExp e) { buf.writestring(EXPtoString(e.op)); expToBuffer(e.e1, precedence[e.op], buf, hgs); } - override void visit(BinExp e) + void visitBin(BinExp e) { expToBuffer(e.e1, precedence[e.op], buf, hgs); buf.writeByte(' '); @@ -2238,7 +2249,7 @@ public: expToBuffer(e.e2, cast(PREC)(precedence[e.op] + 1), buf, hgs); } - override void visit(CommaExp e) + void visitComma(CommaExp e) { // CommaExp is generated by the compiler so it shouldn't // appear in error messages or header files. @@ -2251,7 +2262,7 @@ public: // the old path if (!ve || !(ve.var.storage_class & STC.temp)) { - visit(cast(BinExp)e); + visitBin(cast(BinExp)e); return; } @@ -2281,25 +2292,25 @@ public: } // not one of the known cases, go on the old path - visit(cast(BinExp)e); + visitBin(cast(BinExp)e); return; } - override void visit(MixinExp e) + void visitMixin(MixinExp e) { buf.writestring("mixin("); argsToBuffer(e.exps, buf, hgs, null); buf.writeByte(')'); } - override void visit(ImportExp e) + void visitImport(ImportExp e) { buf.writestring("import("); expToBuffer(e.e1, PREC.assign, buf, hgs); buf.writeByte(')'); } - override void visit(AssertExp e) + void visitAssert(AssertExp e) { buf.writestring("assert("); expToBuffer(e.e1, PREC.assign, buf, hgs); @@ -2311,13 +2322,13 @@ public: buf.writeByte(')'); } - override void visit(ThrowExp e) + void visitThrow(ThrowExp e) { buf.writestring("throw "); expToBuffer(e.e1, PREC.unary, buf, hgs); } - override void visit(DotIdExp e) + void visitDotId(DotIdExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); if (e.arrow) @@ -2327,28 +2338,28 @@ public: buf.writestring(e.ident.toString()); } - override void visit(DotTemplateExp e) + void visitDotTemplate(DotTemplateExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('.'); buf.writestring(e.td.toChars()); } - override void visit(DotVarExp e) + void visitDotVar(DotVarExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('.'); buf.writestring(e.var.toChars()); } - override void visit(DotTemplateInstanceExp e) + void visitDotTemplateInstance(DotTemplateInstanceExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('.'); e.ti.dsymbolToBuffer(buf, hgs); } - override void visit(DelegateExp e) + void visitDelegate(DelegateExp e) { buf.writeByte('&'); if (!e.func.isNested() || e.func.needThis()) @@ -2359,14 +2370,14 @@ public: buf.writestring(e.func.toChars()); } - override void visit(DotTypeExp e) + void visitDotType(DotTypeExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('.'); buf.writestring(e.sym.toChars()); } - override void visit(CallExp e) + void visitCall(CallExp e) { if (e.e1.op == EXP.type) { @@ -2375,7 +2386,7 @@ public: * This is ok since types in constructor calls * can never depend on parens anyway */ - e.e1.accept(this); + e.e1.expressionPrettyPrint(buf, hgs); } else expToBuffer(e.e1, precedence[e.op], buf, hgs); @@ -2384,19 +2395,19 @@ public: buf.writeByte(')'); } - override void visit(PtrExp e) + void visitPtr(PtrExp e) { buf.writeByte('*'); expToBuffer(e.e1, precedence[e.op], buf, hgs); } - override void visit(DeleteExp e) + void visitDelete(DeleteExp e) { buf.writestring("delete "); expToBuffer(e.e1, precedence[e.op], buf, hgs); } - override void visit(CastExp e) + void visitCast(CastExp e) { buf.writestring("cast("); if (e.to) @@ -2409,7 +2420,7 @@ public: expToBuffer(e.e1, precedence[e.op], buf, hgs); } - override void visit(VectorExp e) + void visitVector(VectorExp e) { buf.writestring("cast("); typeToBuffer(e.to, null, buf, hgs); @@ -2417,13 +2428,13 @@ public: expToBuffer(e.e1, precedence[e.op], buf, hgs); } - override void visit(VectorArrayExp e) + void visitVectorArray(VectorArrayExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writestring(".array"); } - override void visit(SliceExp e) + void visitSlice(SliceExp e) { expToBuffer(e.e1, precedence[e.op], buf, hgs); buf.writeByte('['); @@ -2442,32 +2453,32 @@ public: buf.writeByte(']'); } - override void visit(ArrayLengthExp e) + void visitArrayLength(ArrayLengthExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writestring(".length"); } - override void visit(IntervalExp e) + void visitInterval(IntervalExp e) { expToBuffer(e.lwr, PREC.assign, buf, hgs); buf.writestring(".."); expToBuffer(e.upr, PREC.assign, buf, hgs); } - override void visit(DelegatePtrExp e) + void visitDelegatePtr(DelegatePtrExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writestring(".ptr"); } - override void visit(DelegateFuncptrExp e) + void visitDelegateFuncptr(DelegateFuncptrExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writestring(".funcptr"); } - override void visit(ArrayExp e) + void visitArray(ArrayExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('['); @@ -2475,14 +2486,14 @@ public: buf.writeByte(']'); } - override void visit(DotExp e) + void visitDot(DotExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('.'); expToBuffer(e.e2, PREC.primary, buf, hgs); } - override void visit(IndexExp e) + void visitIndex(IndexExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writeByte('['); @@ -2490,19 +2501,19 @@ public: buf.writeByte(']'); } - override void visit(PostExp e) + void visitPost(PostExp e) { expToBuffer(e.e1, precedence[e.op], buf, hgs); buf.writestring(EXPtoString(e.op)); } - override void visit(PreExp e) + void visitPre(PreExp e) { buf.writestring(EXPtoString(e.op)); expToBuffer(e.e1, precedence[e.op], buf, hgs); } - override void visit(RemoveExp e) + void visitRemove(RemoveExp e) { expToBuffer(e.e1, PREC.primary, buf, hgs); buf.writestring(".remove("); @@ -2510,7 +2521,7 @@ public: buf.writeByte(')'); } - override void visit(CondExp e) + void visitCond(CondExp e) { expToBuffer(e.econd, PREC.oror, buf, hgs); buf.writestring(" ? "); @@ -2519,15 +2530,90 @@ public: expToBuffer(e.e2, PREC.cond, buf, hgs); } - override void visit(DefaultInitExp e) + void visitDefaultInit(DefaultInitExp e) { buf.writestring(EXPtoString(e.op)); } - override void visit(ClassReferenceExp e) + void visitClassReference(ClassReferenceExp e) { buf.writestring(e.value.toChars()); } + + switch (e.op) + { + default: + if (auto be = e.isBinExp()) + return visitBin(be); + else if (auto ue = e.isUnaExp()) + return visitUna(ue); + else if (auto de = e.isDefaultInitExp()) + return visitDefaultInit(e.isDefaultInitExp()); + return visit(e); + + case EXP.int64: return visitInteger(e.isIntegerExp()); + case EXP.error: return visitError(e.isErrorExp()); + case EXP.void_: return visitVoidInit(e.isVoidInitExp()); + case EXP.float64: return visitReal(e.isRealExp()); + case EXP.complex80: return visitComplex(e.isComplexExp()); + case EXP.identifier: return visitIdentifier(e.isIdentifierExp()); + case EXP.dSymbol: return visitDsymbol(e.isDsymbolExp()); + case EXP.this_: return visitThis(e.isThisExp()); + case EXP.super_: return visitSuper(e.isSuperExp()); + case EXP.null_: return visitNull(e.isNullExp()); + case EXP.string_: return visitString(e.isStringExp()); + case EXP.arrayLiteral: return visitArrayLiteral(e.isArrayLiteralExp()); + case EXP.assocArrayLiteral: return visitAssocArrayLiteral(e.isAssocArrayLiteralExp()); + case EXP.structLiteral: return visitStructLiteral(e.isStructLiteralExp()); + case EXP.compoundLiteral: return visitCompoundLiteral(e.isCompoundLiteralExp()); + case EXP.type: return visitType(e.isTypeExp()); + case EXP.scope_: return visitScope(e.isScopeExp()); + case EXP.template_: return visitTemplate(e.isTemplateExp()); + case EXP.new_: return visitNew(e.isNewExp()); + case EXP.newAnonymousClass: return visitNewAnonClass(e.isNewAnonClassExp()); + case EXP.symbolOffset: return visitSymOff(e.isSymOffExp()); + case EXP.variable: return visitVar(e.isVarExp()); + case EXP.overloadSet: return visitOver(e.isOverExp()); + case EXP.tuple: return visitTuple(e.isTupleExp()); + case EXP.function_: return visitFunc(e.isFuncExp()); + case EXP.declaration: return visitDeclaration(e.isDeclarationExp()); + case EXP.typeid_: return visitTypeid(e.isTypeidExp()); + case EXP.traits: return visitTraits(e.isTraitsExp()); + case EXP.halt: return visitHalt(e.isHaltExp()); + case EXP.is_: return visitIs(e.isExp()); + case EXP.comma: return visitComma(e.isCommaExp()); + case EXP.mixin_: return visitMixin(e.isMixinExp()); + case EXP.import_: return visitImport(e.isImportExp()); + case EXP.assert_: return visitAssert(e.isAssertExp()); + case EXP.throw_: return visitThrow(e.isThrowExp()); + case EXP.dotIdentifier: return visitDotId(e.isDotIdExp()); + case EXP.dotTemplateDeclaration: return visitDotTemplate(e.isDotTemplateExp()); + case EXP.dotVariable: return visitDotVar(e.isDotVarExp()); + case EXP.dotTemplateInstance: return visitDotTemplateInstance(e.isDotTemplateInstanceExp()); + case EXP.delegate_: return visitDelegate(e.isDelegateExp()); + case EXP.dotType: return visitDotType(e.isDotTypeExp()); + case EXP.call: return visitCall(e.isCallExp()); + case EXP.star: return visitPtr(e.isPtrExp()); + case EXP.delete_: return visitDelete(e.isDeleteExp()); + case EXP.cast_: return visitCast(e.isCastExp()); + case EXP.vector: return visitVector(e.isVectorExp()); + case EXP.vectorArray: return visitVectorArray(e.isVectorArrayExp()); + case EXP.slice: return visitSlice(e.isSliceExp()); + case EXP.arrayLength: return visitArrayLength(e.isArrayLengthExp()); + case EXP.interval: return visitInterval(e.isIntervalExp()); + case EXP.delegatePointer: return visitDelegatePtr(e.isDelegatePtrExp()); + case EXP.delegateFunctionPointer: return visitDelegateFuncptr(e.isDelegateFuncptrExp()); + case EXP.array: return visitArray(e.isArrayExp()); + case EXP.dot: return visitDot(e.isDotExp()); + case EXP.index: return visitIndex(e.isIndexExp()); + case EXP.minusMinus: + case EXP.plusPlus: return visitPost(e.isPostExp()); + case EXP.preMinusMinus: + case EXP.prePlusPlus: return visitPre(e.isPreExp()); + case EXP.remove: return visitRemove(e.isRemoveExp()); + case EXP.question: return visitCond(e.isCondExp()); + case EXP.classReference: return visitClassReference(e.isClassReferenceExp()); + } } /** @@ -2547,7 +2633,7 @@ void floatToBuffer(Type type, const real_t value, OutBuffer* buf, const bool all (ie, 8 chars more than mantissa). Plus one for trailing \0. Plus one for rounding. */ const(size_t) BUFFER_LEN = value.sizeof * 3 + 8 + 1 + 1; - char[BUFFER_LEN] buffer; + char[BUFFER_LEN] buffer = void; CTFloat.sprint(buffer.ptr, 'g', value); assert(strlen(buffer.ptr) < BUFFER_LEN); if (allowHex) @@ -2754,7 +2840,7 @@ bool stcToBuffer(OutBuffer* buf, StorageClass stc) } if (stc & STC.returninferred) { - //buf.writestring("return-inferred "); + //buf.writestring((stc & STC.returnScope) ? "return-scope-inferred " : "return-ref-inferred "); stc &= ~(STC.return_ | STC.returninferred); } @@ -2958,8 +3044,7 @@ void functionToBufferWithIdent(TypeFunction tf, OutBuffer* buf, const(char)* ide void toCBuffer(const Expression e, OutBuffer* buf, HdrGenState* hgs) { - scope v = new ExpressionPrettyPrintVisitor(buf, hgs); - (cast() e).accept(v); + expressionPrettyPrint(cast()e, buf, hgs); } /************************************************** @@ -3221,8 +3306,7 @@ private void sizeToBuffer(Expression e, OutBuffer* buf, HdrGenState* hgs) private void expressionToBuffer(Expression e, OutBuffer* buf, HdrGenState* hgs) { - scope v = new ExpressionPrettyPrintVisitor(buf, hgs); - e.accept(v); + expressionPrettyPrint(e, buf, hgs); } /************************************************** diff --git a/gcc/d/dmd/id.d b/gcc/d/dmd/id.d index 2ec75ab2516..11455afe263 100644 --- a/gcc/d/dmd/id.d +++ b/gcc/d/dmd/id.d @@ -491,6 +491,7 @@ immutable Msgtable[] msgtable = { "udaGNUAbiTag", "gnuAbiTag" }, { "udaSelector", "selector" }, { "udaOptional", "optional"}, + { "udaMustUse", "mustuse" }, // C names, for undefined identifier error messages { "NULL" }, diff --git a/gcc/d/dmd/initsem.d b/gcc/d/dmd/initsem.d index 649d88e3d59..c84a9f69ffa 100644 --- a/gcc/d/dmd/initsem.d +++ b/gcc/d/dmd/initsem.d @@ -554,26 +554,39 @@ extern(C++) Initializer initializerSemantic(Initializer init, Scope* sc, ref Typ i.exp = e.optimize(WANTvalue); } } + { // Look for the case of statically initializing an array // with a single member. - if (tb.ty == Tsarray && !tb.nextOf().equals(ti.toBasetype().nextOf()) && i.exp.implicitConvTo(tb.nextOf())) + auto tba = tb.isTypeSArray(); + if (tba && !tba.next.equals(ti.toBasetype().nextOf()) && i.exp.implicitConvTo(tba.next)) { /* If the variable is not actually used in compile time, array creation is * redundant. So delay it until invocation of toExpression() or toDt(). */ t = tb.nextOf(); } + + auto tta = t.isTypeSArray(); if (i.exp.implicitConvTo(t)) { i.exp = i.exp.implicitCastTo(sc, t); } + else if (sc.flags & SCOPE.Cfile && i.exp.isStringExp() && + tta && (tta.next.ty == Tint8 || tta.next.ty == Tuns8) && + ti.ty == Tpointer && ti.nextOf().ty == Tchar) + { + /* unsigned char bbb[1] = ""; + * signed char ccc[1] = ""; + */ + i.exp = i.exp.castTo(sc, t); + } else { // Look for mismatch of compile-time known length to emit // better diagnostic message, as same as AssignExp::semantic. - if (tb.ty == Tsarray && i.exp.implicitConvTo(tb.nextOf().arrayOf()) > MATCH.nomatch) + if (tba && i.exp.implicitConvTo(tba.next.arrayOf()) > MATCH.nomatch) { - uinteger_t dim1 = tb.isTypeSArray().dim.toInteger(); + uinteger_t dim1 = tba.dim.toInteger(); uinteger_t dim2 = dim1; if (auto ale = i.exp.isArrayLiteralExp()) { @@ -596,6 +609,7 @@ extern(C++) Initializer initializerSemantic(Initializer init, Scope* sc, ref Typ if (global.endGagging(errors)) currExp.error("cannot implicitly convert expression `%s` of type `%s` to `%s`", currExp.toChars(), et.toChars(), t.toChars()); } + } L1: if (i.exp.op == EXP.error) { @@ -681,7 +695,7 @@ extern(C++) Initializer initializerSemantic(Initializer init, Scope* sc, ref Typ assert(sc); auto tm = vd.type.addMod(ts.mod); auto iz = di.initializer.initializerSemantic(sc, tm, needInterpret); - auto ex = iz.initializerToExpression(); + auto ex = iz.initializerToExpression(null, true); if (ex.op == EXP.error) { errors = true; @@ -1059,7 +1073,7 @@ Initializer inferType(Initializer init, Scope* sc) Initializer visitC(CInitializer i) { - //printf(CInitializer::inferType()\n"); + //printf("CInitializer.inferType()\n"); error(i.loc, "TODO C inferType initializers not supported yet"); return new ErrorInitializer(); } @@ -1086,6 +1100,8 @@ Initializer inferType(Initializer init, Scope* sc) */ extern (C++) Expression initializerToExpression(Initializer init, Type itype = null, const bool isCfile = false) { + //printf("initializerToExpression() isCfile: %d\n", isCfile); + Expression visitVoid(VoidInitializer) { return null; @@ -1183,7 +1199,7 @@ extern (C++) Expression initializerToExpression(Initializer init, Type itype = n assert(j < edim); if (Initializer iz = init.value[i]) { - if (Expression ex = iz.initializerToExpression()) + if (Expression ex = iz.initializerToExpression(null, isCfile)) { (*elements)[j] = ex; ++j; @@ -1271,7 +1287,7 @@ extern (C++) Expression initializerToExpression(Initializer init, Type itype = n Expression visitC(CInitializer i) { - //printf("CInitializer.initializerToExpression()\n"); + //printf("CInitializer.initializerToExpression(null, true)\n"); return null; } @@ -1331,6 +1347,10 @@ private bool hasNonConstPointers(Expression e) } if (auto ae = e.isAddrExp()) { + if (ae.type.nextOf().isImmutable() || ae.type.nextOf().isConst()) + { + return false; + } if (auto se = ae.e1.isStructLiteralExp()) { if (!(se.stageflags & stageSearchPointers)) diff --git a/gcc/d/dmd/json.d b/gcc/d/dmd/json.d index 3183c8dbb79..fc270390fa4 100644 --- a/gcc/d/dmd/json.d +++ b/gcc/d/dmd/json.d @@ -319,10 +319,7 @@ public: // Should not be printed //property(name, "d"); break; - case LINK.system: - // Should not be printed - //property(name, "system"); - break; + case LINK.system: return property(name, "system"); case LINK.c: return property(name, "c"); case LINK.cpp: return property(name, "cpp"); case LINK.windows: return property(name, "windows"); diff --git a/gcc/d/dmd/lexer.d b/gcc/d/dmd/lexer.d index 7cd4bfd5922..5945da32259 100644 --- a/gcc/d/dmd/lexer.d +++ b/gcc/d/dmd/lexer.d @@ -108,8 +108,8 @@ class Lexer size_t endoffset, bool doDocComment, bool commentToken) pure { scanloc = Loc(filename, 1, 1); - //printf("Lexer::Lexer(%p,%d)\n",base,length); - //printf("lexer.filename = %s\n", filename); + // debug printf("Lexer::Lexer(%p)\n", base); + // debug printf("lexer.filename = %s\n", filename); token = Token.init; this.base = base; this.end = base + endoffset; @@ -1236,28 +1236,47 @@ class Lexer { uint v = 0; int n = 0; - while (1) + if (Ccompile && ndigits == 2) { - if (isdigit(cast(char)c)) - c -= '0'; - else if (islower(c)) - c -= 'a' - 10; - else - c -= 'A' - 10; - v = v * 16 + c; - c = *++p; - if (++n == ndigits) - break; - if (!ishex(cast(char)c)) + /* C11 6.4.4.4-7 one to infinity hex digits + */ + do { - .error(loc, "escape hex sequence has %d hex digits instead of %d", n, ndigits); - break; - } + if (isdigit(cast(char)c)) + c -= '0'; + else if (islower(c)) + c -= 'a' - 10; + else + c -= 'A' - 10; + v = v * 16 + c; + c = *++p; + } while (ishex(cast(char)c)); } - if (ndigits != 2 && !utf_isValidDchar(v)) + else { - .error(loc, "invalid UTF character \\U%08x", v); - v = '?'; // recover with valid UTF character + while (1) + { + if (isdigit(cast(char)c)) + c -= '0'; + else if (islower(c)) + c -= 'a' - 10; + else + c -= 'A' - 10; + v = v * 16 + c; + c = *++p; + if (++n == ndigits) + break; + if (!ishex(cast(char)c)) + { + .error(loc, "escape hex sequence has %d hex digits instead of %d", n, ndigits); + break; + } + } + if (ndigits != 2 && !utf_isValidDchar(v)) + { + .error(loc, "invalid UTF character \\U%08x", v); + v = '?'; // recover with valid UTF character + } } c = v; } @@ -2122,7 +2141,7 @@ class Lexer // can't translate invalid octal value, just show a generic message error("octal literals larger than 7 are no longer supported"); else - error("octal literals `0%llo%.*s` are no longer supported, use `std.conv.octal!%llo%.*s` instead", + error("octal literals `0%llo%.*s` are no longer supported, use `std.conv.octal!\"%llo%.*s\"` instead", n, cast(int)(p - psuffix), psuffix, n, cast(int)(p - psuffix), psuffix); } TOK result; @@ -2926,7 +2945,7 @@ class Lexer */ static const(char)* combineComments(const(char)[] c1, const(char)[] c2, bool newParagraph) pure { - //printf("Lexer::combineComments('%s', '%s', '%i')\n", c1, c2, newParagraph); + //debug printf("Lexer::combineComments('%*.s', '%*.s', '%i')\n", cast(int) c1.length, c1.ptr, cast(int) c2.length, c2.ptr, newParagraph); const(int) newParagraphSize = newParagraph ? 1 : 0; // Size of the combining '\n' if (!c1) return c2.ptr; diff --git a/gcc/d/dmd/mtype.d b/gcc/d/dmd/mtype.d index b2c7aa461ca..13df0d71f3f 100644 --- a/gcc/d/dmd/mtype.d +++ b/gcc/d/dmd/mtype.d @@ -4200,27 +4200,28 @@ extern (C++) final class TypeFunction : TypeNext // These flags can be accessed like `bool` properties, // getters and setters are generated for them - private enum FunctionFlag : uint - { - none = 0, - isnothrow = 0x0001, // nothrow - isnogc = 0x0002, // is @nogc - isproperty = 0x0004, // can be called without parentheses - isref = 0x0008, // returns a reference - isreturn = 0x0010, // 'this' is returned by ref - isScopeQual = 0x0020, // 'this' is scope - isreturninferred= 0x0040, // 'this' is return from inference - isscopeinferred = 0x0080, // 'this' is scope from inference - islive = 0x0100, // is @live - incomplete = 0x0200, // return type or default arguments removed - isInOutParam = 0x0400, // inout on the parameters - isInOutQual = 0x0800, // inout on the qualifier - isctor = 0x1000, // the function is a constructor - isreturnscope = 0x2000, // `this` is returned by value - } + private extern (D) static struct BitFields + { + bool isnothrow; /// nothrow + bool isnogc; /// is @nogc + bool isproperty; /// can be called without parentheses + bool isref; /// returns a reference + bool isreturn; /// 'this' is returned by ref + bool isScopeQual; /// 'this' is scope + bool isreturninferred; /// 'this' is return from inference + bool isscopeinferred; /// 'this' is scope from inference + bool islive; /// is @live + bool incomplete; /// return type or default arguments removed + bool isInOutParam; /// inout on the parameters + bool isInOutQual; /// inout on the qualifier + bool isctor; /// the function is a constructor + bool isreturnscope; /// `this` is returned by value + } + + import dmd.common.bitfields : generateBitFields; + mixin(generateBitFields!(BitFields, ushort)); LINK linkage; // calling convention - FunctionFlag funcFlags; TRUST trust; // level of trust PURE purity = PURE.impure; byte inuse; @@ -4359,29 +4360,6 @@ extern (C++) final class TypeFunction : TypeNext return linkage == LINK.d && parameterList.varargs == VarArg.variadic; } - /*************************** - * Examine function signature for parameter p and see if - * the value of p can 'escape' the scope of the function. - * This is useful to minimize the needed annotations for the parameters. - * Params: - * tthis = type of `this` parameter, null if none - * p = parameter to this function - * Returns: - * true if escapes via assignment to global or through a parameter - */ - bool parameterEscapes(Type tthis, Parameter p) - { - /* Scope parameters do not escape. - * Allow 'lazy' to imply 'scope' - - * lazy parameters can be passed along - * as lazy parameters to the next function, but that isn't - * escaping. - */ - if (parameterStorageClass(tthis, p) & (STC.scope_ | STC.lazy_)) - return false; - return true; - } - /************************************ * Take the specified storage class for p, * and use the function signature to infer whether @@ -4409,7 +4387,7 @@ extern (C++) final class TypeFunction : TypeNext /* If haven't inferred the return type yet, can't infer storage classes */ - if (!nextOf()) + if (!nextOf() || !isnothrow()) return stc; purityLevel(); @@ -4460,37 +4438,12 @@ extern (C++) final class TypeFunction : TypeNext } } - /* Inferring STC.return_ here has false positives - * for pure functions, producing spurious error messages - * about escaping references. - * Give up on it for now. - */ - version (none) - { - stc |= STC.scope_; - - Type tret = nextOf().toBasetype(); - if (isref || tret.hasPointers()) - { - /* The result has references, so p could be escaping - * that way. - */ - stc |= STC.return_; - } - } + // Check escaping through return value + Type tret = nextOf().toBasetype(); + if (isref || tret.hasPointers()) + return stc | STC.scope_ | STC.return_ | STC.returnScope; else - { - // Check escaping through return value - Type tret = nextOf().toBasetype(); - if (isref || tret.hasPointers() || !isnothrow()) - { - return stc; - } - - stc |= STC.scope_; - } - - return stc; + return stc | STC.scope_; } override Type addStorageClass(StorageClass stc) @@ -4684,6 +4637,16 @@ extern (C++) final class TypeFunction : TypeNext match = MATCH.convert; // match ... with a "conversion" match level } + // https://issues.dlang.org/show_bug.cgi?id=22997 + if (parameterList.varargs == VarArg.none && nparams > nargs && !parameterList[nargs].defaultArg) + { + OutBuffer buf; + buf.printf("too few arguments, expected `%d`, got `%d`", cast(int)nparams, cast(int)nargs); + if (pMessage) + *pMessage = buf.extractChars(); + goto Nomatch; + } + foreach (u, p; parameterList) { if (u == nargs) @@ -4780,14 +4743,40 @@ extern (C++) final class TypeFunction : TypeNext m = MATCH.exact; else { - m = MATCH.nomatch; if (pMessage) { + /* https://issues.dlang.org/show_bug.cgi?id=22202 + * + * If a function was deduced by semantic on the CallExp, + * it means that resolveFuncCall completed succesfully. + * Therefore, there exists a callable copy constructor, + * however, it cannot be called because scope constraints + * such as purity, safety or nogc. + */ OutBuffer buf; - buf.printf("`struct %s` does not define a copy constructor for `%s` to `%s` copies", - argStruct.toChars(), targ.toChars(), tprm.toChars()); + auto callExp = e.isCallExp(); + if (auto f = callExp.f) + { + char[] s; + if (!f.isPure && sc.func.setImpure()) + s ~= "pure "; + if (!f.isSafe() && !f.isTrusted() && sc.func.setUnsafe()) + s ~= "@safe "; + if (!f.isNogc && sc.func.setGC()) + s ~= "nogc "; + s[$-1] = '\0'; + buf.printf("`%s` copy constructor cannot be called from a `%s` context", f.type.toChars(), s.ptr); + + } + else + { + buf.printf("`struct %s` does not define a copy constructor for `%s` to `%s` copies", + argStruct.toChars(), targ.toChars(), tprm.toChars()); + } + *pMessage = buf.extractChars(); } + m = MATCH.nomatch; goto Nomatch; } } @@ -5086,41 +5075,21 @@ extern (C++) final class TypeFunction : TypeNext return false; } - // Generate getter / setter functions for `FunctionFlag` members so they can be - // treated like regular `bool` fields, instead of requiring bit twiddling to read/write - extern (D) mixin(() { - string result = "extern(C++) pure nothrow @safe @nogc {"; - foreach (string mem; __traits(allMembers, FunctionFlag)) - { - result ~= " - /// set or get if the function has the FunctionFlag attribute of the same name - bool "~mem~"() const { return (funcFlags & FunctionFlag."~mem~") != 0; } - /// ditto - void "~mem~"(bool v) - { - if (v) funcFlags |= FunctionFlag."~mem~"; - else funcFlags &= ~FunctionFlag."~mem~"; - }"; - } - return result ~ "}\n"; - }()); /// Returns: `true` the function is `isInOutQual` or `isInOutParam` ,`false` otherwise. bool iswild() const pure nothrow @safe @nogc { - return (funcFlags & (FunctionFlag.isInOutParam | FunctionFlag.isInOutQual)) != 0; + return isInOutParam || isInOutQual; } /// Returns: whether `this` function type has the same attributes (`@safe`,...) as `other` bool attributesEqual(const scope TypeFunction other) const pure nothrow @safe @nogc { - enum attributes = FunctionFlag.isnothrow - | FunctionFlag.isnogc - | FunctionFlag.islive; - return this.trust == other.trust && this.purity == other.purity && - (this.funcFlags & attributes) == (other.funcFlags & attributes); + this.isnothrow == other.isnothrow && + this.isnogc == other.isnogc && + this.islive == other.islive; } override void accept(Visitor v) diff --git a/gcc/d/dmd/mtype.h b/gcc/d/dmd/mtype.h index 07c574d42b7..6ba47dfa34e 100644 --- a/gcc/d/dmd/mtype.h +++ b/gcc/d/dmd/mtype.h @@ -109,6 +109,7 @@ enum class TY : uint8_t */ enum MODFlags { + MODnone = 0, // default (mutable) MODconst = 1, // type is const MODimmutable = 4, // type is immutable MODshared = 2, // type is shared @@ -595,8 +596,8 @@ public: // .next is the return type ParameterList parameterList; // function parameters + uint16_t bitFields; LINK linkage; // calling convention - unsigned funcFlags; TRUST trust; // level of trust PURE purity; // PURExxxx char inuse; @@ -608,7 +609,6 @@ public: void purityLevel(); bool hasLazyParameters(); bool isDstyleVariadic() const; - bool parameterEscapes(Parameter *p); StorageClass parameterStorageClass(Parameter *p); Type *addStorageClass(StorageClass stc); diff --git a/gcc/d/dmd/mustuse.d b/gcc/d/dmd/mustuse.d new file mode 100644 index 00000000000..4eb422805db --- /dev/null +++ b/gcc/d/dmd/mustuse.d @@ -0,0 +1,244 @@ +/** + * Compile-time checks associated with the @mustuse attribute. + * + * Copyright: Copyright (C) 2022 by The D Language Foundation, All Rights Reserved + * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) + * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/mustuse.d, _mustuse.d) + * Documentation: https://dlang.org/phobos/dmd_mustuse.html + * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/mustuse.d + */ + +module dmd.mustuse; + +import dmd.dscope; +import dmd.dsymbol; +import dmd.expression; +import dmd.globals; +import dmd.identifier; + +// Used in isIncrementOrDecrement +private static const StringExp plusPlus, minusMinus; + +// Loc.initial cannot be used in static initializers, so +// these need a static constructor. +static this() +{ + plusPlus = new StringExp(Loc.initial, "++"); + minusMinus = new StringExp(Loc.initial, "--"); +} + +/** + * Check whether discarding an expression would violate the requirements of + * @mustuse. If so, emit an error. + * + * Params: + * e = the expression to check + * sc = scope in which `e` was semantically analyzed + * + * Returns: true on error, false on success. + */ +bool checkMustUse(Expression e, Scope* sc) +{ + import dmd.id : Id; + + assert(e.type); + if (auto sym = e.type.toDsymbol(sc)) + { + auto sd = sym.isStructDeclaration(); + // isStructDeclaration returns non-null for both structs and unions + if (sd && hasMustUseAttribute(sd, sc) && !isAssignment(e) && !isIncrementOrDecrement(e)) + { + e.error("ignored value of `@%s` type `%s`; prepend a `cast(void)` if intentional", + Id.udaMustUse.toChars(), e.type.toPrettyChars(true)); + return true; + } + } + return false; +} + +/** + * Called from a symbol's semantic to check for reserved usage of @mustuse. + * + * If such usage is found, emits an errror. + * + * Params: + * sym = symbol to check + */ +void checkMustUseReserved(Dsymbol sym) +{ + import dmd.attrib : foreachUdaNoSemantic; + import dmd.errors : error; + import dmd.id : Id; + + // Can't use foreachUda (and by extension hasMustUseAttribute) while + // semantic analysis of `sym` is still in progress + foreachUdaNoSemantic(sym, (exp) { + if (isMustUseAttribute(exp)) + { + if (sym.isFuncDeclaration()) + { + error(sym.loc, "`@%s` on functions is reserved for future use", + Id.udaMustUse.toChars()); + sym.errors = true; + } + else if (sym.isClassDeclaration() || sym.isEnumDeclaration()) + { + error(sym.loc, "`@%s` on `%s` types is reserved for future use", + Id.udaMustUse.toChars(), sym.kind()); + sym.errors = true; + } + } + return 0; // continue + }); +} + +/** + * Returns: true if the given expression is an assignment, either simple (a = b) + * or compound (a += b, etc). + */ +private bool isAssignment(Expression e) +{ + if (e.isAssignExp || e.isBinAssignExp) + return true; + if (auto ce = e.isCallExp()) + { + if (auto fd = ce.f) + { + auto id = fd.ident; + if (id && isAssignmentOpId(id)) + return true; + } + } + return false; +} + +/** + * Returns: true if id is the identifier of an assignment operator overload. + */ +private bool isAssignmentOpId(Identifier id) +{ + import dmd.id : Id; + + return id == Id.assign + || id == Id.addass + || id == Id.subass + || id == Id.mulass + || id == Id.divass + || id == Id.modass + || id == Id.andass + || id == Id.orass + || id == Id.xorass + || id == Id.shlass + || id == Id.shrass + || id == Id.ushrass + || id == Id.catass + || id == Id.indexass + || id == Id.slice + || id == Id.sliceass + || id == Id.opOpAssign + || id == Id.opIndexOpAssign + || id == Id.opSliceOpAssign + || id == Id.powass; +} + +/** + * Returns: true if the given expression is an increment (++) or decrement (--). + */ +private bool isIncrementOrDecrement(Expression e) +{ + import dmd.dtemplate : isExpression; + import dmd.globals : Loc; + import dmd.id : Id; + import dmd.tokens : EXP; + + if (e.op == EXP.plusPlus + || e.op == EXP.minusMinus + || e.op == EXP.prePlusPlus + || e.op == EXP.preMinusMinus) + return true; + if (auto call = e.isCallExp()) + { + // Check for overloaded preincrement + // e.g., a.opUnary!"++" + if (auto fd = call.f) + { + if (fd.ident == Id.opUnary && fd.parent) + { + if (auto ti = fd.parent.isTemplateInstance()) + { + auto tiargs = ti.tiargs; + if (tiargs && tiargs.length >= 1) + { + if (auto argExp = (*tiargs)[0].isExpression()) + { + auto op = argExp.isStringExp(); + if (op && (op.compare(plusPlus) == 0 || op.compare(minusMinus) == 0)) + return true; + } + } + } + } + } + } + else if (auto comma = e.isCommaExp()) + { + // Check for overloaded postincrement + // e.g., (auto tmp = a, ++a, tmp) + if (comma.e1) + { + if (auto left = comma.e1.isCommaExp()) + { + if (auto middle = left.e2) + { + if (middle && isIncrementOrDecrement(middle)) + return true; + } + } + } + } + return false; +} + +/** + * Returns: true if the given symbol has the @mustuse attribute. + */ +private bool hasMustUseAttribute(Dsymbol sym, Scope* sc) +{ + import dmd.attrib : foreachUda; + + bool result = false; + + foreachUda(sym, sc, (Expression uda) { + if (isMustUseAttribute(uda)) + { + result = true; + return 1; // break + } + return 0; // continue + }); + + return result; +} + +/** + * Returns: true if the given expression is core.attribute.mustuse. + */ +private bool isMustUseAttribute(Expression e) +{ + import dmd.attrib : isCoreUda; + import dmd.id : Id; + + // Logic based on dmd.objc.Supported.declaredAsOptionalCount + auto typeExp = e.isTypeExp; + if (!typeExp) + return false; + + auto typeEnum = typeExp.type.isTypeEnum(); + if (!typeEnum) + return false; + + if (isCoreUda(typeEnum.sym, Id.udaMustUse)) + return true; + + return false; +} diff --git a/gcc/d/dmd/opover.d b/gcc/d/dmd/opover.d index dbd761fed2f..4f6903cbab7 100644 --- a/gcc/d/dmd/opover.d +++ b/gcc/d/dmd/opover.d @@ -213,7 +213,7 @@ private Expression checkAliasThisForLhs(AggregateDeclaration ad, Scope* sc, BinE */ if (isRecursiveAliasThis(e.att1, e.e1.type)) return null; - //printf("att %s e1 = %s\n", Token::toChars(e.op), e.e1.type.toChars()); + //printf("att %s e1 = %s\n", Token.toChars(e.op), e.e1.type.toChars()); BinExp be = cast(BinExp)e.copy(); // Resolve 'alias this' but in case of assigment don't resolve properties yet // because 'e1 = e2' could mean 'e1(e2)' or 'e1() = e2' @@ -241,7 +241,7 @@ private Expression checkAliasThisForRhs(AggregateDeclaration ad, Scope* sc, BinE */ if (isRecursiveAliasThis(e.att2, e.e2.type)) return null; - //printf("att %s e2 = %s\n", Token::toChars(e.op), e.e2.type.toChars()); + //printf("att %s e2 = %s\n", Token.toChars(e.op), e.e2.type.toChars()); BinExp be = cast(BinExp)e.copy(); be.e2 = resolveAliasThis(sc, e.e2, true); if (!be.e2) diff --git a/gcc/d/dmd/optimize.d b/gcc/d/dmd/optimize.d index 3745a15da42..3cc36b49e01 100644 --- a/gcc/d/dmd/optimize.d +++ b/gcc/d/dmd/optimize.d @@ -271,7 +271,7 @@ package void setLengthVarIfKnown(VarDeclaration lengthVar, Type type) */ Expression Expression_optimize(Expression e, int result, bool keepLvalue) { - //printf("Expression_optimize() %s\n", e.toChars()); + //printf("Expression_optimize() e: %s result: %d keepLvalue %d\n", e.toChars(), result, keepLvalue); Expression ret = e; void error() @@ -426,7 +426,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) void visitAddr(AddrExp e) { - //printf("AddrExp::optimize(result = %d) %s\n", result, e.toChars()); + //printf("AddrExp::optimize(result = %d, keepLvalue = %d) %s\n", result, keepLvalue, e.toChars()); /* Rewrite &(a,b) as (a,&b) */ if (auto ce = e.e1.isCommaExp()) @@ -438,7 +438,8 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) } // Keep lvalue-ness if (expOptimize(e.e1, result, true)) - return; + return; // error return + // Convert &*ex to ex if (auto pe = e.e1.isPtrExp()) { @@ -515,6 +516,23 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) } } } + else if (auto ei = e.isIndexExp()) + { + if (auto ve = ei.e1.isVarExp()) + { + if (!ve.var.isReference() && + !ve.var.isImportedSymbol() && + ve.var.isDataseg() && + ve.var.isCsymbol()) + { + if (auto ie = ei.e2.isIntegerExp()) + { + var = ve.var.isVarDeclaration(); + offset += ie.toInteger() * ve.type.toBasetype().nextOf().size(); + } + } + } + } return false; } @@ -538,7 +556,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) return; } } - if (auto ae = e.e1.isIndexExp()) + else if (auto ae = e.e1.isIndexExp()) { // Convert &array[n] to &array+n if (ae.e2.isIntegerExp() && ae.e1.isVarExp()) @@ -551,9 +569,10 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) sinteger_t dim = ts.dim.toInteger(); if (index < 0 || index >= dim) { - /* 0 for C static arrays means size is unknown, no need to check + /* 0 for C static arrays means size is unknown, no need to check, + * and address one past the end is OK, too */ - if (!(dim == 0 && ve.var.isCsymbol())) + if (!((dim == 0 || dim == index) && ve.var.isCsymbol())) { e.error("array index %lld is out of bounds `[0..%lld]`", index, dim); return error(); @@ -574,7 +593,7 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) return; } } - // Convert &((a.b)[n]) to (&a.b)+n + // Convert &((a.b)[index]) to (&a.b)+index*elementsize else if (ae.e2.isIntegerExp() && ae.e1.isDotVarExp()) { sinteger_t index = ae.e2.toInteger(); @@ -585,18 +604,28 @@ Expression Expression_optimize(Expression e, int result, bool keepLvalue) sinteger_t dim = ts.dim.toInteger(); if (index < 0 || index >= dim) { - /* 0 for C static arrays means size is unknown, no need to check + /* 0 for C static arrays means size is unknown, no need to check, + * and address one past the end is OK, too */ - if (!(dim == 0 && ve.var.isCsymbol())) + if (!((dim == 0 || dim == index) && ve.var.isCsymbol())) { e.error("array index %lld is out of bounds `[0..%lld]`", index, dim); return error(); } } + import core.checkedint : mulu; + bool overflow; + const offset = mulu(index, ts.nextOf().size(e.loc), overflow); // index*elementsize + if (overflow) + { + e.error("array offset overflow"); + return error(); + } + auto pe = new AddrExp(e.loc, ve); pe.type = e.type; - ret = new AddExp(e.loc, pe, ae.e2); + ret = new AddExp(e.loc, pe, new IntegerExp(e.loc, offset, Type.tsize_t)); ret.type = e.type; return; } diff --git a/gcc/d/dmd/parse.d b/gcc/d/dmd/parse.d index 7b1b63cba82..4b9c0f2119f 100644 --- a/gcc/d/dmd/parse.d +++ b/gcc/d/dmd/parse.d @@ -987,23 +987,9 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer nextToken(); if (token.value == TOK.assign) { - nextToken(); - if (token.value == TOK.identifier) - s = new AST.DebugSymbol(token.loc, token.ident); - else if (token.value == TOK.int32Literal || token.value == TOK.int64Literal) - s = new AST.DebugSymbol(token.loc, cast(uint)token.unsvalue); - else - { - error("identifier or integer expected, not `%s`", token.toChars()); - s = null; - } - nextToken(); - if (token.value != TOK.semicolon) - error("semicolon expected"); - nextToken(); + s = parseDebugSpecification(); break; } - condition = parseDebugCondition(); goto Lcondition; @@ -1012,20 +998,7 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer nextToken(); if (token.value == TOK.assign) { - nextToken(); - if (token.value == TOK.identifier) - s = new AST.VersionSymbol(token.loc, token.ident); - else if (token.value == TOK.int32Literal || token.value == TOK.int64Literal) - s = new AST.VersionSymbol(token.loc, cast(uint)token.unsvalue); - else - { - error("identifier or integer expected, not `%s`", token.toChars()); - s = null; - } - nextToken(); - if (token.value != TOK.semicolon) - error("semicolon expected"); - nextToken(); + s = parseVersionSpecification(); break; } condition = parseVersionCondition(); @@ -2197,6 +2170,26 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer return qualified; } + private AST.DebugSymbol parseDebugSpecification() + { + AST.DebugSymbol s; + nextToken(); + if (token.value == TOK.identifier) + s = new AST.DebugSymbol(token.loc, token.ident); + else if (token.value == TOK.int32Literal || token.value == TOK.int64Literal) + s = new AST.DebugSymbol(token.loc, cast(uint)token.unsvalue); + else + { + error("identifier or integer expected, not `%s`", token.toChars()); + s = null; + } + nextToken(); + if (token.value != TOK.semicolon) + error("semicolon expected"); + nextToken(); + return s; + } + /************************************** * Parse a debug conditional */ @@ -2224,6 +2217,29 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer } /************************************** + * Parse a version specification + */ + private AST.VersionSymbol parseVersionSpecification() + { + AST.VersionSymbol s; + nextToken(); + if (token.value == TOK.identifier) + s = new AST.VersionSymbol(token.loc, token.ident); + else if (token.value == TOK.int32Literal || token.value == TOK.int64Literal) + s = new AST.VersionSymbol(token.loc, cast(uint)token.unsvalue); + else + { + error("identifier or integer expected, not `%s`", token.toChars()); + s = null; + } + nextToken(); + if (token.value != TOK.semicolon) + error("semicolon expected"); + nextToken(); + return s; + } + + /************************************** * Parse a version conditional */ private AST.Condition parseVersionCondition() @@ -6053,10 +6069,14 @@ LagainStc: nextToken(); if (token.value == TOK.assign) { - error("debug conditions can only be declared at module scope"); - nextToken(); - nextToken(); - goto Lerror; + if (auto ds = parseDebugSpecification()) + { + if (ds.ident) + ds.error("declaration must be at module level"); + else + ds.error("level declaration must be at module level"); + } + break; } cond = parseDebugCondition(); goto Lcondition; @@ -6065,10 +6085,14 @@ LagainStc: nextToken(); if (token.value == TOK.assign) { - error("version conditions can only be declared at module scope"); - nextToken(); - nextToken(); - goto Lerror; + if (auto vs = parseVersionSpecification()) + { + if (vs.ident) + vs.error("declaration must be at module level"); + else + vs.error("level declaration must be at module level"); + } + break; } cond = parseVersionCondition(); goto Lcondition; diff --git a/gcc/d/dmd/root/aav.d b/gcc/d/dmd/root/aav.d index ba5d3312d8a..beceb0f0707 100644 --- a/gcc/d/dmd/root/aav.d +++ b/gcc/d/dmd/root/aav.d @@ -14,6 +14,8 @@ module dmd.root.aav; import core.stdc.string; import dmd.root.rmem; +nothrow: + private size_t hash(size_t a) pure nothrow @nogc @safe { a ^= (a >> 20) ^ (a >> 12); diff --git a/gcc/d/dmd/root/array.d b/gcc/d/dmd/root/array.d index cd2d7096d3d..c2eb3e15c2c 100644 --- a/gcc/d/dmd/root/array.d +++ b/gcc/d/dmd/root/array.d @@ -137,7 +137,7 @@ public: void reserve(size_t nentries) pure nothrow { - //printf("Array::reserve: length = %d, data.length = %d, nentries = %d\n", (int)length, (int)data.length, (int)nentries); + //printf("Array::reserve: length = %d, data.length = %d, nentries = %d\n", cast(int)length, cast(int)data.length, cast(int)nentries); // Cold path void enlarge(size_t nentries) diff --git a/gcc/d/dmd/root/complex.d b/gcc/d/dmd/root/complex.d index d9a396d9677..a7a74381ef9 100644 --- a/gcc/d/dmd/root/complex.d +++ b/gcc/d/dmd/root/complex.d @@ -13,11 +13,15 @@ module dmd.root.complex; import dmd.root.ctfloat; +nothrow: + extern (C++) struct complex_t { real_t re; real_t im; + nothrow: + this() @disable; this(real_t re) diff --git a/gcc/d/dmd/root/file.d b/gcc/d/dmd/root/file.d index a01cfdc2aac..b40413c9ef1 100644 --- a/gcc/d/dmd/root/file.d +++ b/gcc/d/dmd/root/file.d @@ -26,11 +26,15 @@ import dmd.root.string; import dmd.common.file; import dmd.common.string; -/// Owns a (rmem-managed) file buffer. -struct FileBuffer +nothrow: + +/// Owns a (rmem-managed) buffer. +struct Buffer { ubyte[] data; + nothrow: + this(this) @disable; ~this() pure nothrow @@ -54,7 +58,7 @@ struct File static struct ReadResult { bool success; - FileBuffer buffer; + Buffer buffer; /// Transfers ownership of the buffer to the caller. ubyte[] extractSlice() pure nothrow @nogc @safe diff --git a/gcc/d/dmd/root/longdouble.d b/gcc/d/dmd/root/longdouble.d index 27fcf9c849f..d6753aa8490 100644 --- a/gcc/d/dmd/root/longdouble.d +++ b/gcc/d/dmd/root/longdouble.d @@ -29,6 +29,8 @@ nothrow: // Type used by the front-end for compile-time reals struct longdouble { +nothrow: +@nogc: extern (D) this(T)(T r) { this.set(cast(SetType!T)r); diff --git a/gcc/d/dmd/root/optional.d b/gcc/d/dmd/root/optional.d index f2f7389efd2..266846bcb0b 100644 --- a/gcc/d/dmd/root/optional.d +++ b/gcc/d/dmd/root/optional.d @@ -10,6 +10,8 @@ */ module dmd.root.optional; +nothrow: + /// unittest { @@ -45,6 +47,8 @@ extern (C++) struct Optional(T) /// whether `value` is set private bool present; + nothrow: + /// Creates an `Optional` with the given value this(T value) { diff --git a/gcc/d/dmd/root/port.h b/gcc/d/dmd/root/port.h index 069a365addf..66a67605b5c 100644 --- a/gcc/d/dmd/root/port.h +++ b/gcc/d/dmd/root/port.h @@ -13,12 +13,13 @@ // The idea is to minimize #ifdef's in the app code. #include "dsystem.h" +#include "dcompat.h" typedef unsigned char utf8_t; struct Port { - static int memicmp(const char *s1, const char *s2, size_t n); + static int memicmp(const char *s1, const char *s2, d_size_t n); static char *strupr(char *s); static bool isFloat32LiteralOutOfRange(const char *s); @@ -30,5 +31,5 @@ struct Port static unsigned readlongBE(const void *buffer); static unsigned readwordLE(const void *buffer); static unsigned readwordBE(const void *buffer); - static void valcpy(void *dst, uint64_t val, size_t size); + static void valcpy(void *dst, uint64_t val, d_size_t size); }; diff --git a/gcc/d/dmd/semantic2.d b/gcc/d/dmd/semantic2.d index b9029a16ef8..cd65920e38b 100644 --- a/gcc/d/dmd/semantic2.d +++ b/gcc/d/dmd/semantic2.d @@ -478,7 +478,7 @@ private extern(C++) final class Semantic2Visitor : Visitor i.mod.semantic2(null); if (i.mod.needmoduleinfo) { - //printf("module5 %s because of %s\n", sc.module.toChars(), mod.toChars()); + //printf("module5 %s because of %s\n", sc._module.toChars(), mod.toChars()); if (sc) sc._module.needmoduleinfo = 1; } diff --git a/gcc/d/dmd/statement.d b/gcc/d/dmd/statement.d index ae03b8a4c52..71713249009 100644 --- a/gcc/d/dmd/statement.d +++ b/gcc/d/dmd/statement.d @@ -315,6 +315,14 @@ extern (C++) abstract class Statement : ASTNode override void visit(ImportStatement s) { } + + override void visit(CaseStatement s) + { + } + + override void visit(DefaultStatement s) + { + } } scope HasCode hc = new HasCode(); diff --git a/gcc/d/dmd/statementsem.d b/gcc/d/dmd/statementsem.d index c2967d65d5f..2916bbc38dd 100644 --- a/gcc/d/dmd/statementsem.d +++ b/gcc/d/dmd/statementsem.d @@ -51,6 +51,7 @@ import dmd.importc; import dmd.init; import dmd.intrange; import dmd.mtype; +import dmd.mustuse; import dmd.nogc; import dmd.opover; import dmd.parse; @@ -211,7 +212,8 @@ package (dmd) extern (C++) final class StatementSemanticVisitor : Visitor if (f.checkForwardRef(s.exp.loc)) s.exp = ErrorExp.get(); } - + if (checkMustUse(s.exp, sc)) + s.exp = ErrorExp.get(); if (!(sc.flags & SCOPE.Cfile) && discardValue(s.exp)) s.exp = ErrorExp.get(); diff --git a/gcc/d/dmd/tokens.d b/gcc/d/dmd/tokens.d index 43feab15f22..03e80245a74 100644 --- a/gcc/d/dmd/tokens.d +++ b/gcc/d/dmd/tokens.d @@ -591,7 +591,7 @@ shared static this() nothrow Identifier.initTable(); foreach (kw; keywords) { - //printf("keyword[%d] = '%s'\n",kw, tochars[kw].ptr); + //printf("keyword[%d] = '%s'\n",kw, Token.tochars[kw].ptr); Identifier.idPool(Token.tochars[kw].ptr, Token.tochars[kw].length, cast(uint)kw); } } diff --git a/gcc/d/dmd/traits.d b/gcc/d/dmd/traits.d index 4b15e8c4739..04e1c47d16e 100644 --- a/gcc/d/dmd/traits.d +++ b/gcc/d/dmd/traits.d @@ -1278,7 +1278,7 @@ Expression semanticTraits(TraitsExp e, Scope* sc) { s = s.isImport().mod; } - //printf("getAttributes %s, attrs = %p, scope = %p\n", s.toChars(), s.userAttribDecl, s.scope); + //printf("getAttributes %s, attrs = %p, scope = %p\n", s.toChars(), s.userAttribDecl, s._scope); udad = s.userAttribDecl; } else @@ -1514,7 +1514,9 @@ Expression semanticTraits(TraitsExp e, Scope* sc) TypeFunction tf = toTypeFunction(o, fd); if (tf) - link = tf.linkage; + { + link = fd ? fd.linkage : tf.linkage; + } else { auto s = getDsymbol(o); @@ -1730,69 +1732,33 @@ Expression semanticTraits(TraitsExp e, Scope* sc) bool err = false; auto t = isType(o); - while (t) + auto ex = isExpression(o); + if (t) { - if (auto tm = t.isTypeMixin()) + Dsymbol s; + t.resolve(e.loc, sc2, ex, t, s); + if (t) { - /* The mixin string could be a type or an expression. - * Have to try compiling it to see. - */ - OutBuffer buf; - if (expressionsToString(buf, sc, tm.exps)) - { + t.typeSemantic(e.loc, sc2); + if (t.ty == Terror) err = true; - break; - } - const olderrors = global.errors; - const len = buf.length; - buf.writeByte(0); - const str = buf.extractSlice()[0 .. len]; - scope p = new Parser!ASTCodegen(e.loc, sc._module, str, false); - p.nextToken(); - //printf("p.loc.linnum = %d\n", p.loc.linnum); - - o = p.parseTypeOrAssignExp(TOK.endOfFile); - if (olderrors != global.errors || p.token.value != TOK.endOfFile) - { - err = true; - break; - } - t = o.isType(); } - else - break; + else if (s && s.errors) + err = true; } - - if (!err) + if (ex) { - auto ex = t ? t.typeToExpression() : isExpression(o); - if (!ex && t) - { - Dsymbol s; - t.resolve(e.loc, sc2, ex, t, s); - if (t) - { - t.typeSemantic(e.loc, sc2); - if (t.ty == Terror) - err = true; - } - else if (s && s.errors) - err = true; - } - if (ex) + ex = ex.expressionSemantic(sc2); + ex = resolvePropertiesOnly(sc2, ex); + ex = ex.optimize(WANTvalue); + if (sc2.func && sc2.func.type.ty == Tfunction) { - ex = ex.expressionSemantic(sc2); - ex = resolvePropertiesOnly(sc2, ex); - ex = ex.optimize(WANTvalue); - if (sc2.func && sc2.func.type.ty == Tfunction) - { - const tf = cast(TypeFunction)sc2.func.type; - err |= tf.isnothrow && canThrow(ex, sc2.func, false); - } - ex = checkGC(sc2, ex); - if (ex.op == EXP.error) - err = true; + const tf = cast(TypeFunction)sc2.func.type; + err |= tf.isnothrow && canThrow(ex, sc2.func, false); } + ex = checkGC(sc2, ex); + if (ex.op == EXP.error) + err = true; } // Carefully detach the scope from the parent and throw it away as diff --git a/gcc/d/dmd/transitivevisitor.d b/gcc/d/dmd/transitivevisitor.d index 615c49fd623..0acad6ae14a 100644 --- a/gcc/d/dmd/transitivevisitor.d +++ b/gcc/d/dmd/transitivevisitor.d @@ -17,7 +17,9 @@ import core.stdc.stdio; extern(C++) class ParseTimeTransitiveVisitor(AST) : PermissiveVisitor!AST { alias visit = PermissiveVisitor!AST.visit; - mixin ParseVisitMethods!AST; + + mixin ParseVisitMethods!AST __methods; + alias visit = __methods.visit; } /* This mixin implements the AST traversal logic for parse time AST nodes. The same code diff --git a/gcc/d/dmd/typesem.d b/gcc/d/dmd/typesem.d index bcdbec5fe2d..f63b17752ed 100644 --- a/gcc/d/dmd/typesem.d +++ b/gcc/d/dmd/typesem.d @@ -1220,6 +1220,9 @@ extern(C++) Type typeSemantic(Type type, const ref Loc loc, Scope* sc) tf.islive = true; tf.linkage = sc.linkage; + if (tf.linkage == LINK.system) + tf.linkage = target.systemLinkage(); + version (none) { /* If the parent is @safe, then this function defaults to safe @@ -1840,7 +1843,7 @@ extern(C++) Type typeSemantic(Type type, const ref Loc loc, Scope* sc) mtype.sym = e.isScopeExp().sds; break; case EXP.tuple: - TupleExp te = e.toTupleExp(); + TupleExp te = e.isTupleExp(); Objects* elems = new Objects(te.exps.dim); foreach (i; 0 .. elems.dim) { @@ -2281,10 +2284,7 @@ RootObject compileTypeMixin(TypeMixin tm, Loc loc, Scope* sc) return null; } - Type t = o.isType(); - Expression e = t ? t.typeToExpression() : o.isExpression(); - - return (!e && t) ? t : e; + return o; } @@ -2306,7 +2306,8 @@ extern (C++) Type merge(Type type) case Tident: case Tinstance: case Tmixin: - return type; + case Ttag: + return type; // don't merge placeholder types case Tsarray: // prevents generating the mangle if the array dim is not yet known @@ -3619,12 +3620,31 @@ Expression dotExp(Type mt, Scope* sc, Expression e, Identifier ident, int flag) e.error("`%s` is not an expression", e.toChars()); return ErrorExp.get(); } - else if (checkUnsafeDotExp(sc, e, ident, flag)) + else if (mt.dim.toUInteger() < 1 && checkUnsafeDotExp(sc, e, ident, flag)) { + // .ptr on static array is @safe unless size is 0 + // https://issues.dlang.org/show_bug.cgi?id=20853 return ErrorExp.get(); } e = e.castTo(sc, e.type.nextOf().pointerTo()); } + else if (ident == Id._tupleof) + { + if (e.isTypeExp()) + { + e.error("`.tupleof` cannot be used on type `%s`", mt.toChars); + return ErrorExp.get(); + } + else + { + const length = cast(size_t)mt.dim.toUInteger(); + auto exps = new Expressions(); + exps.reserve(length); + foreach (i; 0 .. length) + exps.push(new IndexExp(e.loc, e, new IntegerExp(e.loc, i, Type.tsize_t))); + e = new TupleExp(e.loc, exps); + } + } else { e = visitArray(mt); @@ -3885,7 +3905,7 @@ Expression dotExp(Type mt, Scope* sc, Expression e, Identifier ident, int flag) assert(e.op != EXP.dot); // https://issues.dlang.org/show_bug.cgi?id=14010 - if (ident == Id._mangleof) + if (!(sc.flags & SCOPE.Cfile) && ident == Id._mangleof) { return mt.getProperty(sc, e.loc, ident, flag & 1); } @@ -4637,7 +4657,7 @@ extern (C++) Expression defaultInit(Type mt, const ref Loc loc, const bool isCfi { static if (LOGDEFAULTINIT) { - printf("TypeBasic::defaultInit() '%s'\n", mt.toChars()); + printf("TypeBasic::defaultInit() '%s' isCfile: %d\n", mt.toChars(), isCfile); } dinteger_t value = 0; @@ -4695,7 +4715,7 @@ extern (C++) Expression defaultInit(Type mt, const ref Loc loc, const bool isCfi { static if (LOGDEFAULTINIT) { - printf("TypeSArray::defaultInit() '%s'\n", mt.toChars()); + printf("TypeSArray::defaultInit() '%s' isCfile %d\n", mt.toChars(), isCfile); } if (mt.next.ty == Tvoid) return mt.tuns8.defaultInit(loc, isCfile); diff --git a/gcc/d/dmd/utils.d b/gcc/d/dmd/utils.d index 67e4d86a43e..7f3fb64842d 100644 --- a/gcc/d/dmd/utils.d +++ b/gcc/d/dmd/utils.d @@ -19,6 +19,7 @@ import dmd.root.filename; import dmd.common.outbuffer; import dmd.root.string; +nothrow: /** * Normalize path by turning forward slashes into backslashes @@ -52,13 +53,13 @@ const(char)* toWinPath(const(char)* src) * loc = The line number information from where the call originates * filename = Path to file */ -FileBuffer readFile(Loc loc, const(char)* filename) +Buffer readFile(Loc loc, const(char)* filename) { return readFile(loc, filename.toDString()); } /// Ditto -FileBuffer readFile(Loc loc, const(char)[] filename) +Buffer readFile(Loc loc, const(char)[] filename) { auto result = File.read(filename); if (!result.success) @@ -66,7 +67,7 @@ FileBuffer readFile(Loc loc, const(char)[] filename) error(loc, "error reading file `%.*s`", cast(int)filename.length, filename.ptr); fatal(); } - return FileBuffer(result.extractSlice()); + return Buffer(result.extractSlice()); } @@ -83,7 +84,7 @@ extern (D) void writeFile(Loc loc, const(char)[] filename, const void[] data) ensurePathToNameExists(Loc.initial, filename); if (!File.update(filename, data)) { - error(loc, "Error writing file '%*.s'", cast(int) filename.length, filename.ptr); + error(loc, "Error writing file '%.*s'", cast(int) filename.length, filename.ptr); fatal(); } } diff --git a/gcc/d/expr.cc b/gcc/d/expr.cc index 61a2b50b149..c683d9da333 100644 --- a/gcc/d/expr.cc +++ b/gcc/d/expr.cc @@ -3006,6 +3006,16 @@ public: this->result_ = var; } + /* Build an uninitialized value, generated from void initializers. */ + + void visit (VoidInitExp *e) + { + /* The front-end only generates these for the initializer of globals. + Represent `void' as zeroes, regardless of the type's default value. */ + gcc_assert (this->constp_); + this->result_ = build_zero_cst (build_ctype (e->type)); + } + /* These expressions are mainly just a placeholders in the frontend. We shouldn't see them here. */ diff --git a/gcc/d/lang.opt b/gcc/d/lang.opt index 51e8e5c7e00..b4b81523c14 100644 --- a/gcc/d/lang.opt +++ b/gcc/d/lang.opt @@ -396,6 +396,10 @@ frevert=all D RejectNegative Turn off all revertable D language features. +frevert=dip1000 +D RejectNegative +Revert DIP1000: Scoped pointers. + frevert=dip25 D RejectNegative Revert DIP25: Sealed references. diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index e10b10bc1f1..84e6f6694ab 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -13460,7 +13460,7 @@ There are also built-in versions of the ISO C99 functions @code{expl}, @code{fabsf}, @code{fabsl}, @code{floorf}, @code{floorl}, @code{fmodf}, @code{fmodl}, @code{frexpf}, @code{frexpl}, @code{ldexpf}, @code{ldexpl}, @code{log10f}, @code{log10l}, @code{logf}, @code{logl}, -@code{modfl}, @code{modf}, @code{powf}, @code{powl}, @code{sinf}, +@code{modfl}, @code{modff}, @code{powf}, @code{powl}, @code{sinf}, @code{sinhf}, @code{sinhl}, @code{sinl}, @code{sqrtf}, @code{sqrtl}, @code{tanf}, @code{tanhf}, @code{tanhl} and @code{tanl} that are recognized in any mode since ISO C90 reserves these names for @@ -13525,7 +13525,7 @@ exceptions handling functions @code{fegetround}, @code{feclearexcept} and @code{feraiseexcept}. They may not be available for all targets, and because they need close interaction with libc internal values, they may not be available for all target libcs, but in all cases they will gracefully fallback to libc -calls. This built-in functions appear both with and without the +calls. These built-in functions appear both with and without the @code{__builtin_} prefix. @deftypefn {Built-in Function} void *__builtin_alloca (size_t size) diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index ab67a639836..10bfceffceb 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -287,7 +287,8 @@ section. @item @anchor{GDC-prerequisite}GDC In order to build GDC, the D compiler, you need a working GDC -compiler (GCC version 9.1 or later), as the D front end is written in D. +compiler (GCC version 9.1 or later) and D runtime library, +@samp{libphobos}, as the D front end is written in D. Versions of GDC prior to 12 can be built with an ISO C++11 compiler, which can then be installed and used to bootstrap newer versions of the D front end. @@ -303,6 +304,10 @@ front end does not make use of any GDC-specific extensions, or novel features of the D language, if too old a GDC version is installed and @option{--enable-languages=d} is used, the build will fail. +On some targets, @samp{libphobos} isn't enabled by default, but compiles +and works if @option{--enable-libphobos} is used. Specifics are +documented for affected targets. + @item A ``working'' POSIX compatible shell, or GNU bash Necessary when running @command{configure} because some @@ -2134,17 +2139,6 @@ Until all of the libraries are converted to use IEEE 128-bit floating point, it is not recommended to use @option{--with-long-double-format=ieee}. -On little endian PowerPC Linux systems, if you explicitly set the -@code{long double} type, it will build multilibs to allow you to -select either @code{long double} format, unless you disable multilibs -with the @code{--disable-multilib} option. At present, -@code{long double} multilibs are not built on big endian PowerPC Linux -systems. If you are building multilibs, you will need to configure -the compiler using the @option{--with-system-zlib} option. - -If you do not set the @code{long double} type explicitly, no multilibs -will be generated. - @item --enable-fdpic On SH Linux systems, generate ELF FDPIC code. @@ -3901,8 +3895,8 @@ configure GCC@ for building a CR16 uclinux cross-compiler. @end html @anchor{cris} @heading CRIS -CRIS is the CPU architecture in Axis Communications ETRAX system-on-a-chip -series. These are used in embedded applications. +CRIS is a CPU architecture in Axis Communications systems-on-a-chip, for +example the ETRAX series. These are used in embedded applications. @ifnothtml @xref{CRIS Options,, CRIS Options, gcc, Using the GNU Compiler @@ -3913,21 +3907,8 @@ See ``CRIS Options'' in the main manual @end ifhtml for a list of CRIS-specific options. -There are a few different CRIS targets: -@table @code -@item cris-axis-elf -Mainly for monolithic embedded systems. Includes a multilib for the -@samp{v10} core used in @samp{ETRAX 100 LX}. -@item cris-axis-linux-gnu -A GNU/Linux port for the CRIS architecture, currently targeting -@samp{ETRAX 100 LX} by default. -@end table - -Pre-packaged tools can be obtained from -@uref{ftp://ftp.axis.com/@/pub/@/axis/@/tools/@/cris/@/compiler-kit/}. More -information about this platform is available at -@uref{http://developer.axis.com/}. - +Use @samp{configure --target=cris-elf} to configure GCC@ for building +a cross-compiler for CRIS. @html <hr /> @end html @@ -4888,6 +4869,12 @@ GNU binutils. @samp{libstdc++} symbol versioning will be disabled if no appropriate version is found. Solaris @command{c++filt} from the Solaris Studio compilers does @emph{not} work. +In order to build the GNU D compiler, GDC, a working @samp{libphobos} is +needed. That library wasn't built by default in GCC 9--11 on SPARC, or +on x86 when the Solaris assembler is used, but can be enabled by +configuring with @option{--enable-libphobos}. Also, GDC 9.4.0 is +required on x86, while GDC 9.3.0 is known to work on SPARC. + The versions of the GNU Multiple Precision Library (GMP), the MPFR library and the MPC library bundled with Solaris 11.3 and later are usually recent enough to match GCC's requirements. There are two @@ -4901,6 +4888,7 @@ need to configure with @option{--with-gmp-include=/usr/include/gmp}. @item The version of the MPFR libary included in Solaris 11.3 is too old; you need to provide a more recent one. + @end itemize @html @@ -5141,7 +5129,7 @@ the Win32 subsystem that provides a subset of POSIX. @subheading Intel 64-bit versions GCC contains support for x86-64 using the mingw-w64 -runtime library, available from @uref{https://mingw-w64.org/doku.php}. +runtime library, available from @uref{https://www.mingw-w64.org/downloads/}. This library should be used with the target triple x86_64-pc-mingw32. @subheading Windows CE diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 1a51759e6e4..07b440190c3 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -854,12 +854,12 @@ Objective-C and Objective-C++ Dialects}. -msim -msdata=@var{sdata-type}} @emph{CRIS Options} -@gccoptlist{-mcpu=@var{cpu} -march=@var{cpu} -mtune=@var{cpu} @gol --mmax-stack-frame=@var{n} -melinux-stacksize=@var{n} @gol +@gccoptlist{-mcpu=@var{cpu} -march=@var{cpu} +-mtune=@var{cpu} -mmax-stack-frame=@var{n} @gol -metrax4 -metrax100 -mpdebug -mcc-init -mno-side-effects @gol -mstack-align -mdata-align -mconst-align @gol --m32-bit -m16-bit -m8-bit -mno-prologue-epilogue -mno-gotplt @gol --melf -maout -melinux -mlinux -sim -sim2 @gol +-m32-bit -m16-bit -m8-bit -mno-prologue-epilogue @gol +-melf -maout -sim -sim2 @gol -mmul-bug-workaround -mno-mul-bug-workaround} @emph{CR16 Options} @@ -22365,8 +22365,7 @@ These options are defined specifically for the CRIS ports. Generate code for the specified architecture. The choices for @var{architecture-type} are @samp{v3}, @samp{v8} and @samp{v10} for respectively ETRAX@w{ }4, ETRAX@w{ }100, and ETRAX@w{ }100@w{ }LX@. -Default is @samp{v0} except for cris-axis-linux-gnu, where the default is -@samp{v10}. +Default is @samp{v0}. @item -mtune=@var{architecture-type} @opindex mtune @@ -22450,27 +22449,13 @@ option only together with visual inspection of the compiled code: no warnings or errors are generated when call-saved registers must be saved, or storage for local variables needs to be allocated. -@item -mno-gotplt -@itemx -mgotplt -@opindex mno-gotplt -@opindex mgotplt -With @option{-fpic} and @option{-fPIC}, don't generate (do generate) -instruction sequences that load addresses for functions from the PLT part -of the GOT rather than (traditional on other architectures) calls to the -PLT@. The default is @option{-mgotplt}. - @item -melf @opindex melf -Legacy no-op option only recognized with the cris-axis-elf and -cris-axis-linux-gnu targets. - -@item -mlinux -@opindex mlinux -Legacy no-op option only recognized with the cris-axis-linux-gnu target. +Legacy no-op option. @item -sim @opindex sim -This option, recognized for the cris-axis-elf, arranges +This option arranges to link with input-output functions from a simulator library. Code, initialized data and zero-initialized data are allocated consecutively. @@ -29776,7 +29761,8 @@ system representing a certain processor type. Possible values for @var{cpu-type} are @samp{z900}/@samp{arch5}, @samp{z990}/@samp{arch6}, @samp{z9-109}, @samp{z9-ec}/@samp{arch7}, @samp{z10}/@samp{arch8}, @samp{z196}/@samp{arch9}, @samp{zEC12}, @samp{z13}/@samp{arch11}, -@samp{z14}/@samp{arch12}, @samp{z15}/@samp{arch13}, and @samp{native}. +@samp{z14}/@samp{arch12}, @samp{z15}/@samp{arch13}, +@samp{z16}/@samp{arch14}, and @samp{native}. The default is @option{-march=z900}. diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc index 747b2f66107..a6329ab6ee4 100644 --- a/gcc/dwarf2ctf.cc +++ b/gcc/dwarf2ctf.cc @@ -808,12 +808,26 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die) if (ctf_dvd_lookup (ctfc, die)) return; + /* Do not generate CTF variable records for non-defining incomplete + declarations. Such declarations can be known via the DWARF + DW_AT_specification attribute. */ + if (ctf_dvd_ignore_lookup (ctfc, die)) + return; + + /* The value of the DW_AT_specification attribute, if present, is a + reference to the debugging information entry representing the + non-defining declaration. */ + dw_die_ref decl = get_AT_ref (die, DW_AT_specification); + /* Add the type of the variable. */ var_type_id = gen_ctf_type (ctfc, var_type); /* Generate the new CTF variable and update global counter. */ - (void) ctf_add_variable (ctfc, var_name, var_type_id, die, external_vis); - ctfc->ctfc_num_global_objts += 1; + (void) ctf_add_variable (ctfc, var_name, var_type_id, die, external_vis, + decl); + /* Skip updating the number of global objects at this time. This is updated + later after pre-processing as some CTF variable records although + generated now, will not be emitted later. [PR105089]. */ } /* Add a CTF function record for the given input DWARF DIE. */ diff --git a/gcc/emit-rtl.cc b/gcc/emit-rtl.cc index f4404d7abe3..1e02ae254d0 100644 --- a/gcc/emit-rtl.cc +++ b/gcc/emit-rtl.cc @@ -6440,7 +6440,8 @@ emit_copy_of_insn_after (rtx_insn *insn, rtx_insn *after) } /* Update LABEL_NUSES. */ - mark_jump_label (PATTERN (new_rtx), new_rtx, 0); + if (NONDEBUG_INSN_P (insn)) + mark_jump_label (PATTERN (new_rtx), new_rtx, 0); INSN_LOCATION (new_rtx) = INSN_LOCATION (insn); diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc index fb08fa1dbc6..a57ad0739fb 100644 --- a/gcc/fold-const.cc +++ b/gcc/fold-const.cc @@ -2379,13 +2379,12 @@ build_zero_vector (tree type) return build_vector_from_val (type, t); } -/* Returns true, if ARG, an operand or a type, is convertible to TYPE - using a NOP_EXPR. */ +/* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */ bool fold_convertible_p (const_tree type, const_tree arg) { - const_tree orig = TYPE_P (arg) ? arg : TREE_TYPE (arg); + const_tree orig = TREE_TYPE (arg); if (type == orig) return true; @@ -2417,7 +2416,7 @@ fold_convertible_p (const_tree type, const_tree arg) return (VECTOR_TYPE_P (orig) && known_eq (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS (orig)) - && fold_convertible_p (TREE_TYPE (type), TREE_TYPE (orig))); + && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig))); default: return false; @@ -5212,7 +5211,7 @@ make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1, n_high = fold_convert_loc (loc, arg0_type, n_high); /* If we're converting arg0 from an unsigned type, to exp, - a signed type, we will be doing the comparison as unsigned. + a signed type, we will be doing the comparison as unsigned. The tests above have already verified that LOW and HIGH are both positive. @@ -5274,6 +5273,32 @@ make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1, } } + /* Otherwise, if we are converting arg0 from signed type, to exp, + an unsigned type, we will do the comparison as signed. If + high is non-NULL, we punt above if it doesn't fit in the signed + type, so if we get through here, +[-, high] or +[low, high] are + equivalent to +[-, n_high] or +[n_low, n_high]. Similarly, + +[-, -] or -[-, -] are equivalent too. But if low is specified and + high is not, the +[low, -] range is equivalent to union of + +[n_low, -] and +[-, -1] ranges, so +[low, -] is equivalent to + -[0, n_low-1] and similarly -[low, -] to +[0, n_low-1], except for + low being 0, which should be treated as [-, -]. */ + else if (TYPE_UNSIGNED (exp_type) + && !TYPE_UNSIGNED (arg0_type) + && low + && !high) + { + if (integer_zerop (low)) + n_low = NULL_TREE; + else + { + n_high = fold_build2_loc (loc, PLUS_EXPR, arg0_type, + n_low, build_int_cst (arg0_type, -1)); + n_low = build_zero_cst (arg0_type); + in_p = !in_p; + } + } + *p_low = n_low; *p_high = n_high; *p_in_p = in_p; diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 03283282c27..9b6e55a0f35 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,92 @@ +2022-04-27 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/103662 + PR fortran/105379 + * array.cc (compare_bounds): Use bool as return type. + Support non-constant expressions. + (gfc_compare_array_spec): Update call to compare_bounds. + +2022-04-27 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/102043 + PR fortran/105381 + * trans-array.cc (non_negative_strides_array_p): Inline variable + orig_decl and merge nested if conditions. Add condition to not + recurse if the next argument is the same as the current. + +2022-04-25 Jakub Jelinek <jakub@redhat.com> + Thomas Schwinge <thomas@codesourcery.com> + + PR fortran/104717 + * trans-openmp.cc (gfc_trans_oacc_construct): Wrap construct body + in an extra BIND_EXPR. + +2022-04-24 Mikael Morin <mikael@gcc.gnu.org> + Jakub Jelinek <jakub@redhat.com> + + PR fortran/103662 + * interface.cc (gfc_compare_derived_types): Support comparing + unlimited polymorphic fake symbols. Recursively compare class + descriptor types and virtual table types. + * resolve.cc (resolve_fl_derived): Add type to the types list + on unlimited polymorphic short-circuit return. + +2022-04-22 Mikael Morin <mikael@gcc.gnu.org> + Richard Biener <rguenther@suse.de> + + PR fortran/102043 + * trans.h (gfc_build_array_ref): Add non_negative_offset + argument. + * trans.cc (gfc_build_array_ref): Ditto. Use pointer arithmetic + if non_negative_offset is false. + * trans-expr.cc (gfc_conv_substring): Set flag in the call to + gfc_build_array_ref. + * trans-array.cc (gfc_get_cfi_dim_item, + gfc_conv_descriptor_dimension): Same. + (build_array_ref): Decide on whether to set the flag and update + the call. + (gfc_conv_scalarized_array_ref): Same. New argument tmp_array. + (gfc_conv_tmp_array_ref): Update call to + gfc_conv_scalarized_ref. + (non_negative_strides_array_p): New function. + +2022-04-22 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/102043 + * trans-array.cc (gfc_conv_expr_descriptor): Use + gfc_conv_tmp_array_ref. + +2022-04-22 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/102043 + * trans-io.cc: Add handling for the case where the array + is referenced using pointer arithmetic. + +2022-04-22 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/102043 + * trans-expr.cc: Pre-evaluate src and dest to variables + before using them. + +2022-04-21 Fritz Reese <foreese@gcc.gnu.org> + + PR fortran/105310 + * trans-expr.cc (gfc_conv_union_initializer): Pass vec* by reference. + +2022-04-13 Tobias Burnus <tobias@codesourcery.com> + + PR fortran/105242 + * match.cc (match_exit_cycle): Handle missing OMP LOOP, DO and SIMD + directives in the EXIT/CYCLE diagnostic. + +2022-04-10 Harald Anlauf <anlauf@gmx.de> + + PR fortran/105184 + * array.cc (match_subscript): Reject assumed size coarray + specification with missing lower bound. + * resolve.cc (resolve_allocate_expr): Fix logic for checking + allocate-coshape-spec in ALLOCATE statement. + 2022-04-05 Sandra Loosemore <sandra@codesourcery.com> * trans-openmp.cc (gfc_split_omp_clauses): Fix mask for diff --git a/gcc/fortran/array.cc b/gcc/fortran/array.cc index eb9ed8580a0..bbdb5b392fc 100644 --- a/gcc/fortran/array.cc +++ b/gcc/fortran/array.cc @@ -134,6 +134,13 @@ end_element: if (m == MATCH_ERROR) return MATCH_ERROR; + if (star && ar->start[i] == NULL) + { + gfc_error ("Missing lower bound in assumed size " + "coarray specification at %C"); + return MATCH_ERROR; + } + /* See if we have an optional stride. */ if (gfc_match_char (':') == MATCH_YES) { @@ -950,23 +957,28 @@ gfc_copy_array_spec (gfc_array_spec *src) } -/* Returns nonzero if the two expressions are equal. Only handles integer - constants. */ +/* Returns nonzero if the two expressions are equal. + We should not need to support more than constant values, as that’s what is + allowed in derived type component array spec. However, we may create types + with non-constant array spec for dummy variable class container types, for + which the _data component holds the array spec of the variable declaration. + So we have to support non-constant bounds as well. */ -static int +static bool compare_bounds (gfc_expr *bound1, gfc_expr *bound2) { if (bound1 == NULL || bound2 == NULL - || bound1->expr_type != EXPR_CONSTANT - || bound2->expr_type != EXPR_CONSTANT || bound1->ts.type != BT_INTEGER || bound2->ts.type != BT_INTEGER) gfc_internal_error ("gfc_compare_array_spec(): Array spec clobbered"); - if (mpz_cmp (bound1->value.integer, bound2->value.integer) == 0) - return 1; - else - return 0; + /* What qualifies as identical bounds? We could probably just check that the + expressions are exact clones. We avoid rewriting a specific comparison + function and re-use instead the rather involved gfc_dep_compare_expr which + is just a bit more permissive, as it can also detect identical values for + some mismatching expressions (extra parenthesis, swapped operands, unary + plus, etc). It probably only makes a difference in corner cases. */ + return gfc_dep_compare_expr (bound1, bound2) == 0; } @@ -999,10 +1011,10 @@ gfc_compare_array_spec (gfc_array_spec *as1, gfc_array_spec *as2) if (as1->type == AS_EXPLICIT) for (i = 0; i < as1->rank + as1->corank; i++) { - if (compare_bounds (as1->lower[i], as2->lower[i]) == 0) + if (!compare_bounds (as1->lower[i], as2->lower[i])) return 0; - if (compare_bounds (as1->upper[i], as2->upper[i]) == 0) + if (!compare_bounds (as1->upper[i], as2->upper[i])) return 0; } diff --git a/gcc/fortran/interface.cc b/gcc/fortran/interface.cc index 000a530cba4..7ed6e13711f 100644 --- a/gcc/fortran/interface.cc +++ b/gcc/fortran/interface.cc @@ -618,6 +618,14 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2) if (!derived1 || !derived2) gfc_internal_error ("gfc_compare_derived_types: invalid derived type"); + if (derived1->attr.unlimited_polymorphic + && derived2->attr.unlimited_polymorphic) + return true; + + if (derived1->attr.unlimited_polymorphic + != derived2->attr.unlimited_polymorphic) + return false; + /* Compare UNION types specially. */ if (derived1->attr.flavor == FL_UNION || derived2->attr.flavor == FL_UNION) return compare_union_types (derived1, derived2); @@ -630,10 +638,11 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2) && strcmp (derived1->module, derived2->module) == 0) return true; - /* Compare type via the rules of the standard. Both types must have - the SEQUENCE or BIND(C) attribute to be equal. STRUCTUREs are special - because they can be anonymous; therefore two structures with different - names may be equal. */ + /* Compare type via the rules of the standard. Both types must have the + SEQUENCE or BIND(C) attribute to be equal. We also compare types + recursively if they are class descriptors types or virtual tables types. + STRUCTUREs are special because they can be anonymous; therefore two + structures with different names may be equal. */ /* Compare names, but not for anonymous types such as UNION or MAP. */ if (!is_anonymous_dt (derived1) && !is_anonymous_dt (derived2) @@ -646,6 +655,8 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2) if (!(derived1->attr.sequence && derived2->attr.sequence) && !(derived1->attr.is_bind_c && derived2->attr.is_bind_c) + && !(derived1->attr.is_class && derived2->attr.is_class) + && !(derived1->attr.vtype && derived2->attr.vtype) && !(derived1->attr.pdt_type && derived2->attr.pdt_type)) return false; diff --git a/gcc/fortran/match.cc b/gcc/fortran/match.cc index 715a74eba51..205811bb969 100644 --- a/gcc/fortran/match.cc +++ b/gcc/fortran/match.cc @@ -2857,83 +2857,107 @@ match_exit_cycle (gfc_statement st, gfc_exec_op op) for (o = p, cnt = 0; o->state == COMP_DO && o->previous != NULL; cnt++) o = o->previous; + + int count = 1; if (cnt > 0 && o != NULL - && o->state == COMP_OMP_STRUCTURED_BLOCK - && (o->head->op == EXEC_OACC_LOOP - || o->head->op == EXEC_OACC_KERNELS_LOOP - || o->head->op == EXEC_OACC_PARALLEL_LOOP - || o->head->op == EXEC_OACC_SERIAL_LOOP)) - { - int collapse = 1; - gcc_assert (o->head->next != NULL - && (o->head->next->op == EXEC_DO - || o->head->next->op == EXEC_DO_WHILE) - && o->previous != NULL - && o->previous->tail->op == o->head->op); - if (o->previous->tail->ext.omp_clauses != NULL) - { - /* Both collapsed and tiled loops are lowered the same way, but are not - compatible. In gfc_trans_omp_do, the tile is prioritized. */ - if (o->previous->tail->ext.omp_clauses->tile_list) - { - collapse = 0; - gfc_expr_list *el = o->previous->tail->ext.omp_clauses->tile_list; - for ( ; el; el = el->next) - ++collapse; - } - else if (o->previous->tail->ext.omp_clauses->collapse > 1) - collapse = o->previous->tail->ext.omp_clauses->collapse; - } - if (st == ST_EXIT && cnt <= collapse) - { - gfc_error ("EXIT statement at %C terminating !$ACC LOOP loop"); - return MATCH_ERROR; - } - if (st == ST_CYCLE && cnt < collapse) - { - gfc_error (o->previous->tail->ext.omp_clauses->tile_list - ? G_("CYCLE statement at %C to non-innermost tiled" - " !$ACC LOOP loop") - : G_("CYCLE statement at %C to non-innermost collapsed" - " !$ACC LOOP loop")); - return MATCH_ERROR; - } - } - if (cnt > 0 - && o != NULL - && (o->state == COMP_OMP_STRUCTURED_BLOCK) - && (o->head->op == EXEC_OMP_DO - || o->head->op == EXEC_OMP_PARALLEL_DO - || o->head->op == EXEC_OMP_SIMD - || o->head->op == EXEC_OMP_DO_SIMD - || o->head->op == EXEC_OMP_PARALLEL_DO_SIMD)) - { - int count = 1; - gcc_assert (o->head->next != NULL + && o->state == COMP_OMP_STRUCTURED_BLOCK) + switch (o->head->op) + { + case EXEC_OACC_LOOP: + case EXEC_OACC_KERNELS_LOOP: + case EXEC_OACC_PARALLEL_LOOP: + case EXEC_OACC_SERIAL_LOOP: + gcc_assert (o->head->next != NULL + && (o->head->next->op == EXEC_DO + || o->head->next->op == EXEC_DO_WHILE) + && o->previous != NULL + && o->previous->tail->op == o->head->op); + if (o->previous->tail->ext.omp_clauses != NULL) + { + /* Both collapsed and tiled loops are lowered the same way, but are + not compatible. In gfc_trans_omp_do, the tile is prioritized. */ + if (o->previous->tail->ext.omp_clauses->tile_list) + { + count = 0; + gfc_expr_list *el + = o->previous->tail->ext.omp_clauses->tile_list; + for ( ; el; el = el->next) + ++count; + } + else if (o->previous->tail->ext.omp_clauses->collapse > 1) + count = o->previous->tail->ext.omp_clauses->collapse; + } + if (st == ST_EXIT && cnt <= count) + { + gfc_error ("EXIT statement at %C terminating !$ACC LOOP loop"); + return MATCH_ERROR; + } + if (st == ST_CYCLE && cnt < count) + { + gfc_error (o->previous->tail->ext.omp_clauses->tile_list + ? G_("CYCLE statement at %C to non-innermost tiled " + "!$ACC LOOP loop") + : G_("CYCLE statement at %C to non-innermost collapsed " + "!$ACC LOOP loop")); + return MATCH_ERROR; + } + break; + case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD: + case EXEC_OMP_TARGET_PARALLEL_DO_SIMD: + case EXEC_OMP_TARGET_SIMD: + case EXEC_OMP_TASKLOOP_SIMD: + case EXEC_OMP_PARALLEL_MASTER_TASKLOOP_SIMD: + case EXEC_OMP_MASTER_TASKLOOP_SIMD: + case EXEC_OMP_PARALLEL_MASKED_TASKLOOP_SIMD: + case EXEC_OMP_MASKED_TASKLOOP_SIMD: + case EXEC_OMP_PARALLEL_DO_SIMD: + case EXEC_OMP_DISTRIBUTE_SIMD: + case EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD: + case EXEC_OMP_TEAMS_DISTRIBUTE_SIMD: + case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD: + case EXEC_OMP_LOOP: + case EXEC_OMP_PARALLEL_LOOP: + case EXEC_OMP_TEAMS_LOOP: + case EXEC_OMP_TARGET_PARALLEL_LOOP: + case EXEC_OMP_TARGET_TEAMS_LOOP: + case EXEC_OMP_DO: + case EXEC_OMP_PARALLEL_DO: + case EXEC_OMP_SIMD: + case EXEC_OMP_DO_SIMD: + case EXEC_OMP_DISTRIBUTE_PARALLEL_DO: + case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO: + case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO: + case EXEC_OMP_TARGET_PARALLEL_DO: + case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD: + + gcc_assert (o->head->next != NULL && (o->head->next->op == EXEC_DO || o->head->next->op == EXEC_DO_WHILE) && o->previous != NULL && o->previous->tail->op == o->head->op); - if (o->previous->tail->ext.omp_clauses != NULL) - { - if (o->previous->tail->ext.omp_clauses->collapse > 1) - count = o->previous->tail->ext.omp_clauses->collapse; - if (o->previous->tail->ext.omp_clauses->orderedc) - count = o->previous->tail->ext.omp_clauses->orderedc; - } - if (st == ST_EXIT && cnt <= count) - { - gfc_error ("EXIT statement at %C terminating !$OMP DO loop"); - return MATCH_ERROR; - } - if (st == ST_CYCLE && cnt < count) - { - gfc_error ("CYCLE statement at %C to non-innermost collapsed" - " !$OMP DO loop"); - return MATCH_ERROR; - } - } + if (o->previous->tail->ext.omp_clauses != NULL) + { + if (o->previous->tail->ext.omp_clauses->collapse > 1) + count = o->previous->tail->ext.omp_clauses->collapse; + if (o->previous->tail->ext.omp_clauses->orderedc) + count = o->previous->tail->ext.omp_clauses->orderedc; + } + if (st == ST_EXIT && cnt <= count) + { + gfc_error ("EXIT statement at %C terminating !$OMP DO loop"); + return MATCH_ERROR; + } + if (st == ST_CYCLE && cnt < count) + { + gfc_error ("CYCLE statement at %C to non-innermost collapsed " + "!$OMP DO loop"); + return MATCH_ERROR; + } + break; + default: + break; + } /* Save the first statement in the construct - needed by the backend. */ new_st.ext.which_construct = p->construct; diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc index 21c8797c938..29df531cdb6 100644 --- a/gcc/fortran/resolve.cc +++ b/gcc/fortran/resolve.cc @@ -8108,12 +8108,13 @@ resolve_allocate_expr (gfc_expr *e, gfc_code *code, bool *array_alloc_wo_spec) goto failure; case DIMEN_RANGE: - if (ar->start[i] == 0 || ar->end[i] == 0) + /* F2018:R937: + * allocate-coshape-spec is [ lower-bound-expr : ] upper-bound-expr + */ + if (ar->start[i] == 0 || ar->end[i] == 0 || ar->stride[i] != NULL) { - /* If ar->stride[i] is NULL, we issued a previous error. */ - if (ar->stride[i] == NULL) - gfc_error ("Bad array specification in ALLOCATE statement " - "at %L", &e->where); + gfc_error ("Bad coarray specification in ALLOCATE statement " + "at %L", &e->where); goto failure; } else if (gfc_dep_compare_expr (ar->start[i], ar->end[i]) == 1) @@ -15150,7 +15151,10 @@ resolve_fl_derived (gfc_symbol *sym) /* Nothing more to do for unlimited polymorphic entities. */ if (data->ts.u.derived->attr.unlimited_polymorphic) - return true; + { + add_dt_to_dt_list (sym); + return true; + } else if (vptr->ts.u.derived == NULL) { gfc_symbol *vtab = gfc_find_derived_vtab (data->ts.u.derived); diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index b3f8871ff22..05134952db4 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -172,7 +172,7 @@ static tree gfc_get_cfi_dim_item (tree desc, tree idx, unsigned field_idx) { tree tmp = gfc_get_cfi_descriptor_field (desc, CFI_FIELD_DIM); - tmp = gfc_build_array_ref (tmp, idx, NULL); + tmp = gfc_build_array_ref (tmp, idx, NULL_TREE, true); tree field = gfc_advance_chain (TYPE_FIELDS (TREE_TYPE (tmp)), field_idx); gcc_assert (field != NULL_TREE); return fold_build3_loc (input_location, COMPONENT_REF, TREE_TYPE (field), @@ -424,7 +424,7 @@ gfc_conv_descriptor_dimension (tree desc, tree dim) tmp = gfc_get_descriptor_dimension (desc); - return gfc_build_array_ref (tmp, dim, NULL); + return gfc_build_array_ref (tmp, dim, NULL_TREE, true); } @@ -3664,10 +3664,52 @@ build_class_array_ref (gfc_se *se, tree base, tree index) } +/* Indicates that the tree EXPR is a reference to an array that can’t + have any negative stride. */ + +static bool +non_negative_strides_array_p (tree expr) +{ + if (expr == NULL_TREE) + return false; + + tree type = TREE_TYPE (expr); + if (POINTER_TYPE_P (type)) + type = TREE_TYPE (type); + + if (TYPE_LANG_SPECIFIC (type)) + { + gfc_array_kind array_kind = GFC_TYPE_ARRAY_AKIND (type); + + if (array_kind == GFC_ARRAY_ALLOCATABLE + || array_kind == GFC_ARRAY_ASSUMED_SHAPE_CONT) + return true; + } + + /* An array with descriptor can have negative strides. + We try to be conservative and return false by default here + if we don’t recognize a contiguous array instead of + returning false if we can identify a non-contiguous one. */ + if (!GFC_ARRAY_TYPE_P (type)) + return false; + + /* If the array was originally a dummy with a descriptor, strides can be + negative. */ + if (DECL_P (expr) + && DECL_LANG_SPECIFIC (expr) + && GFC_DECL_SAVED_DESCRIPTOR (expr) + && GFC_DECL_SAVED_DESCRIPTOR (expr) != expr) + return non_negative_strides_array_p (GFC_DECL_SAVED_DESCRIPTOR (expr)); + + return true; +} + + /* Build a scalarized reference to an array. */ static void -gfc_conv_scalarized_array_ref (gfc_se * se, gfc_array_ref * ar) +gfc_conv_scalarized_array_ref (gfc_se * se, gfc_array_ref * ar, + bool tmp_array = false) { gfc_array_info *info; tree decl = NULL_TREE; @@ -3717,7 +3759,10 @@ gfc_conv_scalarized_array_ref (gfc_se * se, gfc_array_ref * ar) decl = info->descriptor; } - se->expr = gfc_build_array_ref (base, index, decl); + bool non_negative_stride = tmp_array + || non_negative_strides_array_p (info->descriptor); + se->expr = gfc_build_array_ref (base, index, decl, + non_negative_stride); } @@ -3727,7 +3772,7 @@ void gfc_conv_tmp_array_ref (gfc_se * se) { se->string_length = se->ss->info->string_length; - gfc_conv_scalarized_array_ref (se, NULL); + gfc_conv_scalarized_array_ref (se, NULL, true); gfc_advance_se_ss_chain (se); } @@ -3779,7 +3824,9 @@ build_array_ref (tree desc, tree offset, tree decl, tree vptr) tmp = gfc_conv_array_data (desc); tmp = build_fold_indirect_ref_loc (input_location, tmp); - tmp = gfc_build_array_ref (tmp, offset, decl, vptr); + tmp = gfc_build_array_ref (tmp, offset, decl, + non_negative_strides_array_p (desc), + vptr); return tmp; } @@ -7723,7 +7770,7 @@ gfc_conv_expr_descriptor (gfc_se *se, gfc_expr *expr) lse.ss = loop.temp_ss; rse.ss = ss; - gfc_conv_scalarized_array_ref (&lse, NULL); + gfc_conv_tmp_array_ref (&lse); if (expr->ts.type == BT_CHARACTER) { gfc_conv_expr (&rse, expr); diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index 06713f24f95..850007fd2e1 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -2612,7 +2612,7 @@ gfc_conv_substring (gfc_se * se, gfc_ref * ref, int kind, /* For BIND(C), a BT_CHARACTER is not an ARRAY_TYPE. */ if (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE) { - tmp = gfc_build_array_ref (tmp, start.expr, NULL); + tmp = gfc_build_array_ref (tmp, start.expr, NULL_TREE, true); se->expr = gfc_build_addr_expr (type, tmp); } } @@ -8093,6 +8093,13 @@ gfc_trans_string_copy (stmtblock_t * block, tree dlength, tree dest, cond2 = fold_build2_loc (input_location, LT_EXPR, logical_type_node, slen, dlen); + /* Pre-evaluate pointers unless one of the IF arms will be optimized away. */ + if (!CONSTANT_CLASS_P (cond2)) + { + dest = gfc_evaluate_now (dest, block); + src = gfc_evaluate_now (src, block); + } + /* Copy and pad with spaces. */ tmp3 = build_call_expr_loc (input_location, builtin_decl_explicit (BUILT_IN_MEMMOVE), @@ -9194,8 +9201,8 @@ gfc_trans_structure_assign (tree dest, gfc_expr * expr, bool init, bool coarray) return gfc_finish_block (&block); } -void -gfc_conv_union_initializer (vec<constructor_elt, va_gc> *v, +static void +gfc_conv_union_initializer (vec<constructor_elt, va_gc> *&v, gfc_component *un, gfc_expr *init) { gfc_constructor *ctor; diff --git a/gcc/fortran/trans-io.cc b/gcc/fortran/trans-io.cc index 732221f848b..9f86815388c 100644 --- a/gcc/fortran/trans-io.cc +++ b/gcc/fortran/trans-io.cc @@ -737,7 +737,6 @@ set_parameter_ref (stmtblock_t *block, stmtblock_t *postblock, static void gfc_convert_array_to_string (gfc_se * se, gfc_expr * e) { - tree size; if (e->rank == 0) { @@ -755,12 +754,13 @@ gfc_convert_array_to_string (gfc_se * se, gfc_expr * e) array = sym->backend_decl; type = TREE_TYPE (array); + tree elts_count; if (GFC_ARRAY_TYPE_P (type)) - size = GFC_TYPE_ARRAY_SIZE (type); + elts_count = GFC_TYPE_ARRAY_SIZE (type); else { gcc_assert (GFC_DESCRIPTOR_TYPE_P (type)); - size = gfc_conv_array_stride (array, rank); + tree stride = gfc_conv_array_stride (array, rank); tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type, gfc_conv_array_ubound (array, rank), @@ -768,23 +768,49 @@ gfc_convert_array_to_string (gfc_se * se, gfc_expr * e) tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type, tmp, gfc_index_one_node); + elts_count = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, tmp, stride); + } + gcc_assert (elts_count); + + tree elt_size = TYPE_SIZE_UNIT (gfc_get_element_type (type)); + elt_size = fold_convert (gfc_array_index_type, elt_size); + + tree size; + if (TREE_CODE (se->expr) == ARRAY_REF) + { + tree index = TREE_OPERAND (se->expr, 1); + index = fold_convert (gfc_array_index_type, index); + + elts_count = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, + elts_count, index); + size = fold_build2_loc (input_location, MULT_EXPR, - gfc_array_index_type, tmp, size); + gfc_array_index_type, elts_count, elt_size); + } + else + { + gcc_assert (TREE_CODE (se->expr) == INDIRECT_REF); + tree ptr = TREE_OPERAND (se->expr, 0); + + gcc_assert (TREE_CODE (ptr) == POINTER_PLUS_EXPR); + tree offset = fold_convert_loc (input_location, gfc_array_index_type, + TREE_OPERAND (ptr, 1)); + + size = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, elts_count, elt_size); + size = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, size, offset); } gcc_assert (size); - size = fold_build2_loc (input_location, MINUS_EXPR, - gfc_array_index_type, size, - TREE_OPERAND (se->expr, 1)); se->expr = gfc_build_addr_expr (NULL_TREE, se->expr); - tmp = TYPE_SIZE_UNIT (gfc_get_element_type (type)); - size = fold_build2_loc (input_location, MULT_EXPR, - gfc_array_index_type, size, - fold_convert (gfc_array_index_type, tmp)); se->string_length = fold_convert (gfc_charlen_type_node, size); return; } + tree size; gfc_conv_array_parameter (se, e, true, NULL, NULL, &size); se->string_length = fold_convert (gfc_charlen_type_node, size); } diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc index 25dde826146..43d59abe9e0 100644 --- a/gcc/fortran/trans-openmp.cc +++ b/gcc/fortran/trans-openmp.cc @@ -4444,7 +4444,9 @@ gfc_trans_oacc_construct (gfc_code *code) gfc_start_block (&block); oacc_clauses = gfc_trans_omp_clauses (&block, code->ext.omp_clauses, code->loc, false, true); + pushlevel (); stmt = gfc_trans_omp_code (code->block->next, true); + stmt = build3_v (BIND_EXPR, NULL, stmt, poplevel (1, 0)); stmt = build2_loc (gfc_get_location (&code->loc), construct_code, void_type_node, stmt, oacc_clauses); gfc_add_expr_to_block (&block, stmt); diff --git a/gcc/fortran/trans.cc b/gcc/fortran/trans.cc index 333dfa69642..f0a5dfb50fc 100644 --- a/gcc/fortran/trans.cc +++ b/gcc/fortran/trans.cc @@ -446,10 +446,14 @@ gfc_build_spanned_array_ref (tree base, tree offset, tree span) } -/* Build an ARRAY_REF with its natural type. */ +/* Build an ARRAY_REF with its natural type. + NON_NEGATIVE_OFFSET indicates if it’s true that OFFSET can’t be negative, + and thus that an ARRAY_REF can safely be generated. If it’s false, we + have to play it safe and use pointer arithmetic. */ tree -gfc_build_array_ref (tree base, tree offset, tree decl, tree vptr) +gfc_build_array_ref (tree base, tree offset, tree decl, + bool non_negative_offset, tree vptr) { tree type = TREE_TYPE (base); tree span = NULL_TREE; @@ -495,10 +499,40 @@ gfc_build_array_ref (tree base, tree offset, tree decl, tree vptr) pointer arithmetic. */ if (span != NULL_TREE) return gfc_build_spanned_array_ref (base, offset, span); - /* Otherwise use a straightforward array reference. */ - else + /* Else use a straightforward array reference if possible. */ + else if (non_negative_offset) return build4_loc (input_location, ARRAY_REF, type, base, offset, NULL_TREE, NULL_TREE); + /* Otherwise use pointer arithmetic. */ + else + { + gcc_assert (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE); + tree min = NULL_TREE; + if (TYPE_DOMAIN (TREE_TYPE (base)) + && !integer_zerop (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (base))))) + min = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (base))); + + tree zero_based_index + = min ? fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, + fold_convert (gfc_array_index_type, offset), + fold_convert (gfc_array_index_type, min)) + : fold_convert (gfc_array_index_type, offset); + + tree elt_size = fold_convert (gfc_array_index_type, + TYPE_SIZE_UNIT (type)); + + tree offset_bytes = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, + zero_based_index, elt_size); + + tree base_addr = gfc_build_addr_expr (pvoid_type_node, base); + + tree ptr = fold_build_pointer_plus_loc (input_location, base_addr, + offset_bytes); + return build1_loc (input_location, INDIRECT_REF, type, + fold_convert (build_pointer_type (type), ptr)); + } } diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h index 738c7487a56..623aceed520 100644 --- a/gcc/fortran/trans.h +++ b/gcc/fortran/trans.h @@ -619,7 +619,9 @@ tree gfc_get_extern_function_decl (gfc_symbol *, tree gfc_build_addr_expr (tree, tree); /* Build an ARRAY_REF. */ -tree gfc_build_array_ref (tree, tree, tree, tree vptr = NULL_TREE); +tree gfc_build_array_ref (tree, tree, tree, + bool non_negative_offset = false, + tree vptr = NULL_TREE); /* Build an array ref using pointer arithmetic. */ tree gfc_build_spanned_array_ref (tree base, tree offset, tree span); diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc index 97880a5f790..863ee3d3912 100644 --- a/gcc/gimple-fold.cc +++ b/gcc/gimple-fold.cc @@ -1048,6 +1048,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi, gsi_replace (gsi, new_stmt, false); return true; } + gimple_set_location (new_stmt, loc); gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT); goto done; } @@ -1302,6 +1303,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi, new_stmt); gimple_assign_set_lhs (new_stmt, srcvar); gimple_set_vuse (new_stmt, gimple_vuse (stmt)); + gimple_set_location (new_stmt, loc); gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT); } new_stmt = gimple_build_assign (destvar, srcvar); @@ -1338,6 +1340,7 @@ set_vop_and_replace: gsi_replace (gsi, new_stmt, false); return true; } + gimple_set_location (new_stmt, loc); gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT); } @@ -4747,7 +4750,7 @@ clear_padding_type (clear_padding_struct *buf, tree type, "have well defined padding bits for %qs", field, "__builtin_clear_padding"); } - else if (is_empty_type (TREE_TYPE (field))) + else if (is_empty_type (ftype)) continue; else { @@ -4758,8 +4761,9 @@ clear_padding_type (clear_padding_struct *buf, tree type, gcc_assert (pos >= 0 && fldsz >= 0 && pos >= cur_pos); clear_padding_add_padding (buf, pos - cur_pos); cur_pos = pos; - clear_padding_type (buf, TREE_TYPE (field), - fldsz, for_auto_init); + if (tree asbase = lang_hooks.types.classtype_as_base (field)) + ftype = asbase; + clear_padding_type (buf, ftype, fldsz, for_auto_init); cur_pos += fldsz; } } diff --git a/gcc/gimple-isel.cc b/gcc/gimple-isel.cc index 3635585bf45..a8f7a0d25d0 100644 --- a/gcc/gimple-isel.cc +++ b/gcc/gimple-isel.cc @@ -245,6 +245,14 @@ gimple_expand_vec_cond_expr (struct function *fun, gimple_stmt_iterator *gsi, GET_MODE_NUNITS (cmp_op_mode))); icode = get_vcond_icode (mode, cmp_op_mode, unsignedp); + /* Some targets do not have vcondeq and only vcond with NE/EQ + but not vcondu, so make sure to also try vcond here as + vcond_icode_p would canonicalize the optab query to. */ + if (icode == CODE_FOR_nothing + && (tcode == NE_EXPR || tcode == EQ_EXPR) + && ((icode = get_vcond_icode (mode, cmp_op_mode, !unsignedp)) + != CODE_FOR_nothing)) + unsignedp = !unsignedp; if (icode == CODE_FOR_nothing) { if (tcode == LT_EXPR diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc index 04075a98a80..f0caefce2a3 100644 --- a/gcc/gimple-range.cc +++ b/gcc/gimple-range.cc @@ -394,6 +394,10 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) // Fold and save the value for NAME. stmt = SSA_NAME_DEF_STMT (name); fold_range_internal (r, stmt, name); + // Make sure we don't lose any current global info. + int_range_max tmp; + m_cache.get_global_range (tmp, name); + r.intersect (tmp); m_cache.set_global_range (name, r); } continue; diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc index 879dbcc1e52..39aa8186de6 100644 --- a/gcc/gimple-ssa-warn-access.cc +++ b/gcc/gimple-ssa-warn-access.cc @@ -3923,7 +3923,8 @@ pass_waccess::warn_invalid_pointer (tree ref, gimple *use_stmt, return; } - if ((maybe && warn_dangling_pointer < 2) + if (equality + || (maybe && warn_dangling_pointer < 2) || warning_suppressed_p (use_stmt, OPT_Wdangling_pointer_)) return; @@ -4241,7 +4242,7 @@ pass_waccess::check_pointer_uses (gimple *stmt, tree ptr, basic_block use_bb = gimple_bb (use_stmt); bool this_maybe = (maybe - || !dominated_by_p (CDI_POST_DOMINATORS, use_bb, stmt_bb)); + || !dominated_by_p (CDI_POST_DOMINATORS, stmt_bb, use_bb)); warn_invalid_pointer (*use_p->use, use_stmt, stmt, var, this_maybe, equality); continue; @@ -4486,7 +4487,7 @@ pass_waccess::check_dangling_uses (tree var, tree decl, bool maybe /* = false */ basic_block use_bb = gimple_bb (use_stmt); basic_block clob_bb = gimple_bb (*pclob); - maybe = maybe || !dominated_by_p (CDI_POST_DOMINATORS, use_bb, clob_bb); + maybe = maybe || !dominated_by_p (CDI_POST_DOMINATORS, clob_bb, use_bb); warn_invalid_pointer (var, use_stmt, *pclob, decl, maybe, false); } diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE index f93eaf48e28..ef20a0aafd6 100644 --- a/gcc/go/gofrontend/MERGE +++ b/gcc/go/gofrontend/MERGE @@ -1,4 +1,4 @@ -45108f37070afb696b069768700e39a269f1fecb +70ca85f08edf63f46c87d540fa99c45e2903edc2 The first line of this file holds the git revision number of the last merge done from the gofrontend repository. diff --git a/gcc/go/gofrontend/gogo.cc b/gcc/go/gofrontend/gogo.cc index 30d5c9fcb0b..d35c6baf582 100644 --- a/gcc/go/gofrontend/gogo.cc +++ b/gcc/go/gofrontend/gogo.cc @@ -1612,31 +1612,16 @@ Gogo::write_globals() // The initializer is constant if it is the zero-value of the // variable's type or if the initial value is an immutable value // that is not copied to the heap. - Expression* init = var->init(); - - // If we see "a = b; b = x", and x is a static - // initializer, just set a to x. - while (init != NULL && init->var_expression() != NULL) - { - Named_object* ino = init->var_expression()->named_object(); - if (!ino->is_variable() || ino->package() != NULL) - break; - Expression* ino_init = ino->var_value()->init(); - if (ino->var_value()->has_pre_init() - || ino_init == NULL - || !ino_init->is_static_initializer()) - break; - init = ino_init; - } - - bool is_static_initializer; - if (init == NULL) + bool is_static_initializer = false; + if (var->init() == NULL) is_static_initializer = true; else { Type* var_type = var->type(); - init = Expression::make_cast(var_type, init, var->location()); - is_static_initializer = init->is_static_initializer(); + Expression* init = var->init(); + Expression* init_cast = + Expression::make_cast(var_type, init, var->location()); + is_static_initializer = init_cast->is_static_initializer(); } // Non-constant variable initializations might need to create @@ -1655,15 +1640,7 @@ Gogo::write_globals() } var_init_fn = init_fndecl; } - - Bexpression* var_binit; - if (init == NULL) - var_binit = NULL; - else - { - Translate_context context(this, var_init_fn, NULL, NULL); - var_binit = init->get_backend(&context); - } + Bexpression* var_binit = var->get_init(this, var_init_fn); if (var_binit == NULL) ; diff --git a/gcc/ifcvt.cc b/gcc/ifcvt.cc index 22960a67f89..b983e87389f 100644 --- a/gcc/ifcvt.cc +++ b/gcc/ifcvt.cc @@ -1678,10 +1678,10 @@ noce_try_store_flag_mask (struct noce_if_info *if_info) reversep = 0; if ((if_info->a == const0_rtx - && rtx_equal_p (if_info->b, if_info->x)) + && (REG_P (if_info->b) || rtx_equal_p (if_info->b, if_info->x))) || ((reversep = (noce_reversed_cond_code (if_info) != UNKNOWN)) && if_info->b == const0_rtx - && rtx_equal_p (if_info->a, if_info->x))) + && (REG_P (if_info->a) || rtx_equal_p (if_info->a, if_info->x)))) { start_sequence (); target = noce_emit_store_flag (if_info, @@ -1689,7 +1689,7 @@ noce_try_store_flag_mask (struct noce_if_info *if_info) reversep, -1); if (target) target = expand_simple_binop (GET_MODE (if_info->x), AND, - if_info->x, + reversep ? if_info->a : if_info->b, target, if_info->x, 0, OPTAB_WIDEN); diff --git a/gcc/ipa-fnsummary.cc b/gcc/ipa-fnsummary.cc index 0d7e395c846..b12e7a1124d 100644 --- a/gcc/ipa-fnsummary.cc +++ b/gcc/ipa-fnsummary.cc @@ -2587,7 +2587,7 @@ points_to_local_or_readonly_memory_p (tree t) && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)) && t == ssa_default_def (cfun, DECL_RESULT (current_function_decl))) return true; - return !ptr_deref_may_alias_global_p (t); + return !ptr_deref_may_alias_global_p (t, false); } if (TREE_CODE (t) == ADDR_EXPR) return refs_local_or_readonly_memory_p (TREE_OPERAND (t, 0)); diff --git a/gcc/ipa-free-lang-data.cc b/gcc/ipa-free-lang-data.cc index f596eeff3ab..a742156858c 100644 --- a/gcc/ipa-free-lang-data.cc +++ b/gcc/ipa-free-lang-data.cc @@ -672,7 +672,7 @@ free_lang_data_in_decl (tree decl, class free_lang_data_d *fld) } } /* We need to keep field decls associated with their trees. Otherwise tree - merging may merge some fileds and keep others disjoint wich in turn will + merging may merge some fields and keep others disjoint which in turn will not do well with TREE_CHAIN pointers linking them. Also do not drop containing types for virtual methods and tables because diff --git a/gcc/ipa-modref-tree.cc b/gcc/ipa-modref-tree.cc index f19af8c2b55..44cb645954f 100644 --- a/gcc/ipa-modref-tree.cc +++ b/gcc/ipa-modref-tree.cc @@ -267,34 +267,42 @@ modref_access_node::closer_pair_p (const modref_access_node &a1, /* Now compute distance of the intervals. */ - poly_int64 dist1, dist2; + poly_offset_int dist1, dist2; if (known_le (offseta1, offsetb1)) { if (!known_size_p (a1.max_size)) dist1 = 0; else - dist1 = offsetb1 - offseta1 - a1.max_size; + dist1 = (poly_offset_int)offsetb1 + - (poly_offset_int)offseta1 + - (poly_offset_int)a1.max_size; } else { if (!known_size_p (b1.max_size)) dist1 = 0; else - dist1 = offseta1 - offsetb1 - b1.max_size; + dist1 = (poly_offset_int)offseta1 + - (poly_offset_int)offsetb1 + - (poly_offset_int)b1.max_size; } if (known_le (offseta2, offsetb2)) { if (!known_size_p (a2.max_size)) dist2 = 0; else - dist2 = offsetb2 - offseta2 - a2.max_size; + dist2 = (poly_offset_int)offsetb2 + - (poly_offset_int)offseta2 + - (poly_offset_int)a2.max_size; } else { if (!known_size_p (b2.max_size)) dist2 = 0; else - dist2 = offseta2 - offsetb2 - b2.max_size; + dist2 = offseta2 + - (poly_offset_int)offsetb2 + - (poly_offset_int)b2.max_size; } /* It may happen that intervals overlap in case size is different. Prefer the overlap to non-overlap. */ @@ -380,9 +388,16 @@ modref_access_node::update2 (poly_int64 parm_offset1, new_max_size = max_size2; else { - new_max_size = max_size2 + offset2 - offset1; - if (known_le (new_max_size, max_size1)) - new_max_size = max_size1; + poly_offset_int s = (poly_offset_int)max_size2 + + (poly_offset_int)offset2 + - (poly_offset_int)offset1; + if (s.to_shwi (&new_max_size)) + { + if (known_le (new_max_size, max_size1)) + new_max_size = max_size1; + } + else + new_max_size = -1; } update (parm_offset1, offset1, diff --git a/gcc/ipa-modref.cc b/gcc/ipa-modref.cc index acfd7d80ff8..556816ab429 100644 --- a/gcc/ipa-modref.cc +++ b/gcc/ipa-modref.cc @@ -5281,6 +5281,29 @@ ipa_merge_modref_summary_after_inlining (cgraph_edge *edge) if (!ignore_stores) to_info_lto->stores->collapse (); } + /* Merge side effects and non-determinism. + PURE/CONST flags makes functions deterministic and if there is + no LOOPING_CONST_OR_PURE they also have no side effects. */ + if (!(flags & (ECF_CONST | ECF_NOVOPS | ECF_PURE)) + || (flags & ECF_LOOPING_CONST_OR_PURE)) + { + if (to_info) + { + if (!callee_info || callee_info->side_effects) + to_info->side_effects = true; + if ((!callee_info || callee_info->nondeterministic) + && !ignore_nondeterminism_p (edge->caller->decl, flags)) + to_info->nondeterministic = true; + } + if (to_info_lto) + { + if (!callee_info_lto || callee_info_lto->side_effects) + to_info_lto->side_effects = true; + if ((!callee_info_lto || callee_info_lto->nondeterministic) + && !ignore_nondeterminism_p (edge->caller->decl, flags)) + to_info_lto->nondeterministic = true; + } + } if (callee_info || callee_info_lto) { auto_vec <modref_parm_map, 32> parm_map; diff --git a/gcc/jit/ChangeLog b/gcc/jit/ChangeLog index 535daa4d981..faab3a78c5e 100644 --- a/gcc/jit/ChangeLog +++ b/gcc/jit/ChangeLog @@ -1,3 +1,119 @@ +2022-04-14 Iain Sandoe <iain@sandoe.co.uk> + + * jit-playback.cc (new_bitcast): Cast values returned by tree_to_uhwi + to 'long' to match the print format. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104293 + * docs/_build/texinfo/libgccjit.texi: Regenerate. + * docs/topics/compatibility.rst (LIBGCCJIT_ABI_24): New ABI tag. + * docs/topics/expressions.rst: Add documentation for the + functions gcc_jit_lvalue_set_alignment and + gcc_jit_lvalue_get_alignment. + * jit-playback.h: New function (set_alignment). + * jit-recording.cc: New function (set_alignment). + * jit-recording.h: New functions (set_alignment, get_alignment) + and new field (m_alignment). + * libgccjit.cc: New functions (gcc_jit_lvalue_get_alignment, + gcc_jit_lvalue_set_alignment) + * libgccjit.h: New functions (gcc_jit_lvalue_get_alignment, + gcc_jit_lvalue_set_alignment) + * libgccjit.map (LIBGCCJIT_ABI_24): New ABI tag. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104073 + * docs/_build/texinfo/libgccjit.texi: Regenerate. + * docs/topics/compatibility.rst (LIBGCCJIT_ABI_23): New ABI tag. + * docs/topics/contexts.rst: Add documentation for the new + function gcc_jit_context_set_bool_print_errors_to_stderr. + * jit-common.h: New enum value + (INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR). + * jit-recording.cc: Handle the new option + INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR. + * libgccjit.cc: New function + (gcc_jit_context_set_bool_print_errors_to_stderr). + * libgccjit.h: New function + (gcc_jit_context_set_bool_print_errors_to_stderr). + * libgccjit.map (LIBGCCJIT_ABI_23): New ABI tag. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104072 + * docs/_build/texinfo/libgccjit.texi: Regenerate. + * docs/topics/compatibility.rst (LIBGCCJIT_ABI_22): New ABI tag. + * docs/topics/expressions.rst: Add documentation for the + function gcc_jit_lvalue_set_register_name. + * jit-playback.h: New function (set_register_name). + * jit-recording.cc: New function (set_register_name) and add + support for register variables. + * jit-recording.h: New field (m_reg_name) and new function + (set_register_name). + * libgccjit.cc: New function (gcc_jit_lvalue_set_register_name). + * libgccjit.h: New function (gcc_jit_lvalue_set_register_name). + * libgccjit.map (LIBGCCJIT_ABI_22): New ABI tag. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104071 + * docs/_build/texinfo/libgccjit.texi: Regenerate. + * docs/topics/compatibility.rst (LIBGCCJIT_ABI_21): New ABI tag. + * docs/topics/expressions.rst: Add documentation for the + function gcc_jit_context_new_bitcast. + * jit-playback.cc: New function (new_bitcast). + * jit-playback.h: New function (new_bitcast). + * jit-recording.cc: New functions (new_bitcast, + bitcast::replay_into, bitcast::visit_children, + bitcast::make_debug_string, bitcast::write_reproducer). + * jit-recording.h: New class (bitcast) and new function + (new_bitcast, bitcast::replay_into, bitcast::visit_children, + bitcast::make_debug_string, bitcast::write_reproducer, + bitcast::get_precedence). + * libgccjit.cc: New function (gcc_jit_context_new_bitcast) + * libgccjit.h: New function (gcc_jit_context_new_bitcast) + * libgccjit.map (LIBGCCJIT_ABI_21): New ABI tag. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR target/95325 + * docs/_build/texinfo/libgccjit.texi: Regenerate + * docs/topics/compatibility.rst (LIBGCCJIT_ABI_20): New ABI tag. + * docs/topics/types.rst: Add documentation for the new types + GCC_JIT_TYPE_UINT8_T, GCC_JIT_TYPE_UINT16_T, + GCC_JIT_TYPE_UINT32_T, GCC_JIT_TYPE_UINT64_T, + GCC_JIT_TYPE_UINT128_T, GCC_JIT_TYPE_INT8_T, GCC_JIT_TYPE_INT16_T, + GCC_JIT_TYPE_INT32_T, GCC_JIT_TYPE_INT64_T, GCC_JIT_TYPE_INT128_T and + new functions (gcc_jit_compatible_types, gcc_jit_type_get_size). + * jit-builtins.cc: Add support for BT_UINT128. + * jit-common.h: Update the value of NUM_GCC_JIT_TYPES. + * jit-playback.cc: Add support for the sized integer types. + * jit-recording.cc: Add support for the sized integer types. + * jit-recording.h: Add support for comparing integer types + and new function (is_signed). + * libgccjit.cc (gcc_jit_compatible_types): New. + (gcc_jit_type_get_size) New. + * libgccjit.h: New enum variants for gcc_jit_types + (GCC_JIT_TYPE_UINT8_T, GCC_JIT_TYPE_UINT16_T, + GCC_JIT_TYPE_UINT32_T, GCC_JIT_TYPE_UINT64_T, + GCC_JIT_TYPE_UINT128_T, GCC_JIT_TYPE_INT8_T, + GCC_JIT_TYPE_INT16_T, GCC_JIT_TYPE_INT32_T, + GCC_JIT_TYPE_INT64_T, GCC_JIT_TYPE_INT128_T) and new functions + (gcc_jit_compatible_types, gcc_jit_type_get_size). + * libgccjit.map (LIBGCCJIT_ABI_20): New ABI tag. + +2022-04-06 David Malcolm <dmalcolm@redhat.com> + + PR jit/102824 + * docs/_build/texinfo/factorial.png: Move to... + * docs/_build/texinfo/libgccjit-figures/factorial.png: ...here. + * docs/_build/texinfo/factorial1.png: Move to... + * docs/_build/texinfo/libgccjit-figures/factorial1.png: ...here. + * docs/_build/texinfo/sum-of-squares.png: Move to... + * docs/_build/texinfo/libgccjit-figures/sum-of-squares.png: ...here. + * docs/_build/texinfo/sum-of-squares1.png: Move to... + * docs/_build/texinfo/libgccjit-figures/sum-of-squares1.png: ...here. + 2022-04-01 David Malcolm <dmalcolm@redhat.com> * docs/topics/expressions.rst: Fix formatting. diff --git a/gcc/jit/docs/_build/texinfo/factorial.png b/gcc/jit/docs/_build/texinfo/libgccjit-figures/factorial.png Binary files differindex dff47ce2767..dff47ce2767 100644 --- a/gcc/jit/docs/_build/texinfo/factorial.png +++ b/gcc/jit/docs/_build/texinfo/libgccjit-figures/factorial.png diff --git a/gcc/jit/docs/_build/texinfo/factorial1.png b/gcc/jit/docs/_build/texinfo/libgccjit-figures/factorial1.png Binary files differindex dff47ce2767..dff47ce2767 100644 --- a/gcc/jit/docs/_build/texinfo/factorial1.png +++ b/gcc/jit/docs/_build/texinfo/libgccjit-figures/factorial1.png diff --git a/gcc/jit/docs/_build/texinfo/sum-of-squares.png b/gcc/jit/docs/_build/texinfo/libgccjit-figures/sum-of-squares.png Binary files differindex 7a3b4afff38..7a3b4afff38 100644 --- a/gcc/jit/docs/_build/texinfo/sum-of-squares.png +++ b/gcc/jit/docs/_build/texinfo/libgccjit-figures/sum-of-squares.png diff --git a/gcc/jit/docs/_build/texinfo/sum-of-squares1.png b/gcc/jit/docs/_build/texinfo/libgccjit-figures/sum-of-squares1.png Binary files differindex 7a3b4afff38..7a3b4afff38 100644 --- a/gcc/jit/docs/_build/texinfo/sum-of-squares1.png +++ b/gcc/jit/docs/_build/texinfo/libgccjit-figures/sum-of-squares1.png diff --git a/gcc/jit/docs/_build/texinfo/libgccjit.texi b/gcc/jit/docs/_build/texinfo/libgccjit.texi index c1ca5aaf7f6..9c90de39f63 100644 --- a/gcc/jit/docs/_build/texinfo/libgccjit.texi +++ b/gcc/jit/docs/_build/texinfo/libgccjit.texi @@ -21,7 +21,7 @@ @copying @quotation -libgccjit 12.0.1 (experimental 20220331), Mar 31, 2022 +libgccjit 12.0.1 (experimental 20220411), Apr 12, 2022 David Malcolm @@ -260,6 +260,11 @@ ABI symbol tags * LIBGCCJIT_ABI_17:: * LIBGCCJIT_ABI_18:: * LIBGCCJIT_ABI_19:: +* LIBGCCJIT_ABI_20:: +* LIBGCCJIT_ABI_21:: +* LIBGCCJIT_ABI_22:: +* LIBGCCJIT_ABI_23:: +* LIBGCCJIT_ABI_24:: Performance @@ -5022,8 +5027,24 @@ its presence using @end example @end deffn +@geindex gcc_jit_context_set_bool_print_errors_to_stderr (C function) +@anchor{topics/contexts c gcc_jit_context_set_bool_print_errors_to_stderr}@anchor{6f} +@deffn {C Function} void gcc_jit_context_set_bool_print_errors_to_stderr (gcc_jit_context@w{ }*ctxt, int@w{ }enabled) + +By default, libgccjit will print errors to stderr. + +This entrypoint can be used to disable the printing. + +This entrypoint was added in @ref{70,,LIBGCCJIT_ABI_23}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr +@end example +@end deffn + @node Integer options,Additional command-line options,Boolean options,Options<2> -@anchor{topics/contexts integer-options}@anchor{6f} +@anchor{topics/contexts integer-options}@anchor{71} @subsubsection Integer options @@ -5034,7 +5055,7 @@ its presence using Set an integer option of the context. @geindex gcc_jit_int_option (C type) -@anchor{topics/contexts c gcc_jit_int_option}@anchor{70} +@anchor{topics/contexts c gcc_jit_int_option}@anchor{72} @deffn {C Type} enum gcc_jit_int_option @end deffn @@ -5054,12 +5075,12 @@ The default value is 0 (unoptimized). @end deffn @node Additional command-line options,,Integer options,Options<2> -@anchor{topics/contexts additional-command-line-options}@anchor{71} +@anchor{topics/contexts additional-command-line-options}@anchor{73} @subsubsection Additional command-line options @geindex gcc_jit_context_add_command_line_option (C function) -@anchor{topics/contexts c gcc_jit_context_add_command_line_option}@anchor{72} +@anchor{topics/contexts c gcc_jit_context_add_command_line_option}@anchor{74} @deffn {C Function} void gcc_jit_context_add_command_line_option (gcc_jit_context@w{ }*ctxt, const char@w{ }*optname) Add an arbitrary gcc command-line option to the context, for use @@ -5085,7 +5106,7 @@ Note that only some options are likely to be meaningful; there is no “frontend” within libgccjit, so typically only those affecting optimization and code-generation are likely to be useful. -This entrypoint was added in @ref{73,,LIBGCCJIT_ABI_1}; you can test for +This entrypoint was added in @ref{75,,LIBGCCJIT_ABI_1}; you can test for its presence using @example @@ -5094,7 +5115,7 @@ its presence using @end deffn @geindex gcc_jit_context_add_driver_option (C function) -@anchor{topics/contexts c gcc_jit_context_add_driver_option}@anchor{74} +@anchor{topics/contexts c gcc_jit_context_add_driver_option}@anchor{76} @deffn {C Function} void gcc_jit_context_add_driver_option (gcc_jit_context@w{ }*ctxt, const char@w{ }*optname) Add an arbitrary gcc driver option to the context, for use by @@ -5125,7 +5146,7 @@ Note that only some options are likely to be meaningful; there is no “frontend” within libgccjit, so typically only those affecting assembler and linker are likely to be useful. -This entrypoint was added in @ref{75,,LIBGCCJIT_ABI_11}; you can test for +This entrypoint was added in @ref{77,,LIBGCCJIT_ABI_11}; you can test for its presence using @example @@ -5151,7 +5172,7 @@ its presence using @c <https://www.gnu.org/licenses/>. @node Objects,Types,Compilation contexts,Topic Reference -@anchor{topics/objects doc}@anchor{76}@anchor{topics/objects objects}@anchor{77} +@anchor{topics/objects doc}@anchor{78}@anchor{topics/objects objects}@anchor{79} @section Objects @@ -5209,7 +5230,7 @@ gcc_jit_object *obj = gcc_jit_type_as_object (int_type); The object “base class” has the following operations: @geindex gcc_jit_object_get_context (C function) -@anchor{topics/objects c gcc_jit_object_get_context}@anchor{78} +@anchor{topics/objects c gcc_jit_object_get_context}@anchor{7a} @deffn {C Function} gcc_jit_context *gcc_jit_object_get_context (gcc_jit_object@w{ }*obj) Which context is “obj” within? @@ -5261,7 +5282,7 @@ object’s context is released. @c <https://www.gnu.org/licenses/>. @node Types,Expressions,Objects,Topic Reference -@anchor{topics/types doc}@anchor{79}@anchor{topics/types types}@anchor{7a} +@anchor{topics/types doc}@anchor{7b}@anchor{topics/types types}@anchor{7c} @section Types @@ -5296,7 +5317,7 @@ See @ref{b,,gcc_jit_context_get_type()} for the available types. @item derived types can be accessed by using functions such as -@ref{7b,,gcc_jit_type_get_pointer()} and @ref{7c,,gcc_jit_type_get_const()}: +@ref{7d,,gcc_jit_type_get_pointer()} and @ref{7e,,gcc_jit_type_get_const()}: @example gcc_jit_type *const_int_star = gcc_jit_type_get_pointer (gcc_jit_type_get_const (int_type)); @@ -5318,7 +5339,7 @@ by creating structures (see below). @end menu @node Standard types,Pointers const and volatile,,Types -@anchor{topics/types standard-types}@anchor{7d} +@anchor{topics/types standard-types}@anchor{7f} @subsection Standard types @@ -5454,6 +5475,86 @@ C99’s @code{unsigned long long} @item +@code{GCC_JIT_TYPE_UINT8_T} + +@tab + +C99’s @code{uint8_t} + +@item + +@code{GCC_JIT_TYPE_UINT16_T} + +@tab + +C99’s @code{uint16_t} + +@item + +@code{GCC_JIT_TYPE_UINT32_T} + +@tab + +C99’s @code{uint32_t} + +@item + +@code{GCC_JIT_TYPE_UINT64_T} + +@tab + +C99’s @code{uint64_t} + +@item + +@code{GCC_JIT_TYPE_UINT128_T} + +@tab + +C99’s @code{__uint128_t} + +@item + +@code{GCC_JIT_TYPE_INT8_T} + +@tab + +C99’s @code{int8_t} + +@item + +@code{GCC_JIT_TYPE_INT16_T} + +@tab + +C99’s @code{int16_t} + +@item + +@code{GCC_JIT_TYPE_INT32_T} + +@tab + +C99’s @code{int32_t} + +@item + +@code{GCC_JIT_TYPE_INT64_T} + +@tab + +C99’s @code{int64_t} + +@item + +@code{GCC_JIT_TYPE_INT128_T} + +@tab + +C99’s @code{__int128_t} + +@item + @code{GCC_JIT_TYPE_FLOAT} @tab @@ -5523,47 +5624,47 @@ C99’s @code{_Complex long double} @end deffn @geindex gcc_jit_context_get_int_type (C function) -@anchor{topics/types c gcc_jit_context_get_int_type}@anchor{7e} +@anchor{topics/types c gcc_jit_context_get_int_type}@anchor{80} @deffn {C Function} gcc_jit_type * gcc_jit_context_get_int_type (gcc_jit_context@w{ }*ctxt, int@w{ }num_bytes, int@w{ }is_signed) Access the integer type of the given size. @end deffn @node Pointers const and volatile,Vector types,Standard types,Types -@anchor{topics/types pointers-const-and-volatile}@anchor{7f} +@anchor{topics/types pointers-const-and-volatile}@anchor{81} @subsection Pointers, @cite{const}, and @cite{volatile} @geindex gcc_jit_type_get_pointer (C function) -@anchor{topics/types c gcc_jit_type_get_pointer}@anchor{7b} +@anchor{topics/types c gcc_jit_type_get_pointer}@anchor{7d} @deffn {C Function} gcc_jit_type *gcc_jit_type_get_pointer (gcc_jit_type@w{ }*type) Given type “T”, get type “T*”. @end deffn @geindex gcc_jit_type_get_const (C function) -@anchor{topics/types c gcc_jit_type_get_const}@anchor{7c} +@anchor{topics/types c gcc_jit_type_get_const}@anchor{7e} @deffn {C Function} gcc_jit_type *gcc_jit_type_get_const (gcc_jit_type@w{ }*type) Given type “T”, get type “const T”. @end deffn @geindex gcc_jit_type_get_volatile (C function) -@anchor{topics/types c gcc_jit_type_get_volatile}@anchor{80} +@anchor{topics/types c gcc_jit_type_get_volatile}@anchor{82} @deffn {C Function} gcc_jit_type *gcc_jit_type_get_volatile (gcc_jit_type@w{ }*type) Given type “T”, get type “volatile T”. @end deffn @geindex gcc_jit_context_new_array_type (C function) -@anchor{topics/types c gcc_jit_context_new_array_type}@anchor{81} +@anchor{topics/types c gcc_jit_context_new_array_type}@anchor{83} @deffn {C Function} gcc_jit_type * gcc_jit_context_new_array_type (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*element_type, int@w{ }num_elements) Given non-@cite{void} type “T”, get type “T[N]” (for a constant N). @end deffn @geindex gcc_jit_type_get_aligned (C function) -@anchor{topics/types c gcc_jit_type_get_aligned}@anchor{82} +@anchor{topics/types c gcc_jit_type_get_aligned}@anchor{84} @deffn {C Function} gcc_jit_type * gcc_jit_type_get_aligned (gcc_jit_type@w{ }*type, size_t@w{ }alignment_in_bytes) Given non-@cite{void} type “T”, get type: @@ -5574,7 +5675,7 @@ T __attribute__ ((aligned (ALIGNMENT_IN_BYTES))) The alignment must be a power of two. -This entrypoint was added in @ref{83,,LIBGCCJIT_ABI_7}; you can test for +This entrypoint was added in @ref{85,,LIBGCCJIT_ABI_7}; you can test for its presence using @example @@ -5583,12 +5684,12 @@ its presence using @end deffn @node Vector types,Structures and unions,Pointers const and volatile,Types -@anchor{topics/types vector-types}@anchor{84} +@anchor{topics/types vector-types}@anchor{86} @subsection Vector types @geindex gcc_jit_type_get_vector (C function) -@anchor{topics/types c gcc_jit_type_get_vector}@anchor{85} +@anchor{topics/types c gcc_jit_type_get_vector}@anchor{87} @deffn {C Function} gcc_jit_type * gcc_jit_type_get_vector (gcc_jit_type@w{ }*type, size_t@w{ }num_units) Given type “T”, get type: @@ -5618,7 +5719,7 @@ gcc_jit_type *int_type = gcc_jit_context_get_type (ctxt, gcc_jit_type *v4si_type = gcc_jit_type_get_vector (int_type, 4); @end example -This API entrypoint was added in @ref{86,,LIBGCCJIT_ABI_8}; you can test +This API entrypoint was added in @ref{88,,LIBGCCJIT_ABI_8}; you can test for its presence using @example @@ -5626,30 +5727,30 @@ for its presence using @end example Vector rvalues can be generated using -@ref{87,,gcc_jit_context_new_rvalue_from_vector()}. +@ref{89,,gcc_jit_context_new_rvalue_from_vector()}. @end deffn @node Structures and unions,Function pointer types,Vector types,Types -@anchor{topics/types structures-and-unions}@anchor{88} +@anchor{topics/types structures-and-unions}@anchor{8a} @subsection Structures and unions @geindex gcc_jit_struct (C type) -@anchor{topics/types c gcc_jit_struct}@anchor{89} +@anchor{topics/types c gcc_jit_struct}@anchor{8b} @deffn {C Type} gcc_jit_struct @end deffn A compound type analagous to a C @cite{struct}. @geindex gcc_jit_field (C type) -@anchor{topics/types c gcc_jit_field}@anchor{8a} +@anchor{topics/types c gcc_jit_field}@anchor{8c} @deffn {C Type} gcc_jit_field @end deffn -A field within a @ref{89,,gcc_jit_struct}. +A field within a @ref{8b,,gcc_jit_struct}. -You can model C @cite{struct} types by creating @ref{89,,gcc_jit_struct} and -@ref{8a,,gcc_jit_field} instances, in either order: +You can model C @cite{struct} types by creating @ref{8b,,gcc_jit_struct} and +@ref{8c,,gcc_jit_field} instances, in either order: @itemize * @@ -5698,7 +5799,7 @@ gcc_jit_struct_set_fields (node, NULL, 2, fields); @end itemize @geindex gcc_jit_context_new_field (C function) -@anchor{topics/types c gcc_jit_context_new_field}@anchor{8b} +@anchor{topics/types c gcc_jit_context_new_field}@anchor{8d} @deffn {C Function} gcc_jit_field * gcc_jit_context_new_field (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, const char@w{ }*name) Construct a new field, with the given type and name. @@ -5711,7 +5812,7 @@ buffer. @end deffn @geindex gcc_jit_context_new_bitfield (C function) -@anchor{topics/types c gcc_jit_context_new_bitfield}@anchor{8c} +@anchor{topics/types c gcc_jit_context_new_bitfield}@anchor{8e} @deffn {C Function} gcc_jit_field * gcc_jit_context_new_bitfield (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, int@w{ }width, const char@w{ }*name) Construct a new bit field, with the given type width and name. @@ -5725,7 +5826,7 @@ The parameter @code{type} must be an integer type. The parameter @code{width} must be a positive integer that does not exceed the size of @code{type}. -This API entrypoint was added in @ref{8d,,LIBGCCJIT_ABI_12}; you can test +This API entrypoint was added in @ref{8f,,LIBGCCJIT_ABI_12}; you can test for its presence using @example @@ -5734,14 +5835,14 @@ for its presence using @end deffn @geindex gcc_jit_field_as_object (C function) -@anchor{topics/types c gcc_jit_field_as_object}@anchor{8e} +@anchor{topics/types c gcc_jit_field_as_object}@anchor{90} @deffn {C Function} gcc_jit_object * gcc_jit_field_as_object (gcc_jit_field@w{ }*field) Upcast from field to object. @end deffn @geindex gcc_jit_context_new_struct_type (C function) -@anchor{topics/types c gcc_jit_context_new_struct_type}@anchor{8f} +@anchor{topics/types c gcc_jit_context_new_struct_type}@anchor{91} @deffn {C Function} gcc_jit_struct *gcc_jit_context_new_struct_type (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, const char@w{ }*name, int@w{ }num_fields, gcc_jit_field@w{ }**fields) @quotation @@ -5755,13 +5856,13 @@ on-stack buffer. @end deffn @geindex gcc_jit_context_new_opaque_struct (C function) -@anchor{topics/types c gcc_jit_context_new_opaque_struct}@anchor{90} +@anchor{topics/types c gcc_jit_context_new_opaque_struct}@anchor{92} @deffn {C Function} gcc_jit_struct * gcc_jit_context_new_opaque_struct (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, const char@w{ }*name) Construct a new struct type, with the given name, but without specifying the fields. The fields can be omitted (in which case the size of the struct is not known), or later specified using -@ref{91,,gcc_jit_struct_set_fields()}. +@ref{93,,gcc_jit_struct_set_fields()}. The parameter @code{name} must be non-NULL. The call takes a copy of the underlying string, so it is valid to pass in a pointer to an @@ -5769,14 +5870,14 @@ on-stack buffer. @end deffn @geindex gcc_jit_struct_as_type (C function) -@anchor{topics/types c gcc_jit_struct_as_type}@anchor{92} +@anchor{topics/types c gcc_jit_struct_as_type}@anchor{94} @deffn {C Function} gcc_jit_type * gcc_jit_struct_as_type (gcc_jit_struct@w{ }*struct_type) Upcast from struct to type. @end deffn @geindex gcc_jit_struct_set_fields (C function) -@anchor{topics/types c gcc_jit_struct_set_fields}@anchor{91} +@anchor{topics/types c gcc_jit_struct_set_fields}@anchor{93} @deffn {C Function} void gcc_jit_struct_set_fields (gcc_jit_struct@w{ }*struct_type, gcc_jit_location@w{ }*loc, int@w{ }num_fields, gcc_jit_field@w{ }**fields) Populate the fields of a formerly-opaque struct type. @@ -5785,7 +5886,7 @@ This can only be called once on a given struct type. @end deffn @geindex gcc_jit_context_new_union_type (C function) -@anchor{topics/types c gcc_jit_context_new_union_type}@anchor{93} +@anchor{topics/types c gcc_jit_context_new_union_type}@anchor{95} @deffn {C Function} gcc_jit_type * gcc_jit_context_new_union_type (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, const char@w{ }*name, int@w{ }num_fields, gcc_jit_field@w{ }**fields) Construct a new union type, with the given name and fields. @@ -5873,104 +5974,104 @@ create_code (gcc_jit_context *ctxt, void *user_data) @end deffn @node Function pointer types,Reflection API,Structures and unions,Types -@anchor{topics/types function-pointer-types}@anchor{94} +@anchor{topics/types function-pointer-types}@anchor{96} @subsection Function pointer types Function pointer types can be created using -@ref{95,,gcc_jit_context_new_function_ptr_type()}. +@ref{97,,gcc_jit_context_new_function_ptr_type()}. @node Reflection API,,Function pointer types,Types -@anchor{topics/types reflection-api}@anchor{96} +@anchor{topics/types reflection-api}@anchor{98} @subsection Reflection API @geindex gcc_jit_type_dyncast_array (C function) -@anchor{topics/types c gcc_jit_type_dyncast_array}@anchor{97} +@anchor{topics/types c gcc_jit_type_dyncast_array}@anchor{99} @deffn {C Function} gcc_jit_type * gcc_jit_type_dyncast_array (gcc_jit_type@w{ }*type) Get the element type of an array type or NULL if it’s not an array. @end deffn @geindex gcc_jit_type_is_bool (C function) -@anchor{topics/types c gcc_jit_type_is_bool}@anchor{98} +@anchor{topics/types c gcc_jit_type_is_bool}@anchor{9a} @deffn {C Function} int gcc_jit_type_is_bool (gcc_jit_type@w{ }*type) Return non-zero if the type is a bool. @end deffn @geindex gcc_jit_type_dyncast_function_ptr_type (C function) -@anchor{topics/types c gcc_jit_type_dyncast_function_ptr_type}@anchor{99} +@anchor{topics/types c gcc_jit_type_dyncast_function_ptr_type}@anchor{9b} @deffn {C Function} gcc_jit_function_type * gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type@w{ }*type) Return the function type if it is one or NULL. @end deffn @geindex gcc_jit_function_type_get_return_type (C function) -@anchor{topics/types c gcc_jit_function_type_get_return_type}@anchor{9a} +@anchor{topics/types c gcc_jit_function_type_get_return_type}@anchor{9c} @deffn {C Function} gcc_jit_type * gcc_jit_function_type_get_return_type (gcc_jit_function_type@w{ }*function_type) Given a function type, return its return type. @end deffn @geindex gcc_jit_function_type_get_param_count (C function) -@anchor{topics/types c gcc_jit_function_type_get_param_count}@anchor{9b} +@anchor{topics/types c gcc_jit_function_type_get_param_count}@anchor{9d} @deffn {C Function} size_t gcc_jit_function_type_get_param_count (gcc_jit_function_type@w{ }*function_type) Given a function type, return its number of parameters. @end deffn @geindex gcc_jit_function_type_get_param_type (C function) -@anchor{topics/types c gcc_jit_function_type_get_param_type}@anchor{9c} +@anchor{topics/types c gcc_jit_function_type_get_param_type}@anchor{9e} @deffn {C Function} gcc_jit_type * gcc_jit_function_type_get_param_type (gcc_jit_function_type@w{ }*function_type, size_t@w{ }index) Given a function type, return the type of the specified parameter. @end deffn @geindex gcc_jit_type_is_integral (C function) -@anchor{topics/types c gcc_jit_type_is_integral}@anchor{9d} +@anchor{topics/types c gcc_jit_type_is_integral}@anchor{9f} @deffn {C Function} int gcc_jit_type_is_integral (gcc_jit_type@w{ }*type) Return non-zero if the type is an integral. @end deffn @geindex gcc_jit_type_is_pointer (C function) -@anchor{topics/types c gcc_jit_type_is_pointer}@anchor{9e} +@anchor{topics/types c gcc_jit_type_is_pointer}@anchor{a0} @deffn {C Function} gcc_jit_type * gcc_jit_type_is_pointer (gcc_jit_type@w{ }*type) Return the type pointed by the pointer type or NULL if it’s not a pointer. @end deffn @geindex gcc_jit_type_dyncast_vector (C function) -@anchor{topics/types c gcc_jit_type_dyncast_vector}@anchor{9f} +@anchor{topics/types c gcc_jit_type_dyncast_vector}@anchor{a1} @deffn {C Function} gcc_jit_vector_type * gcc_jit_type_dyncast_vector (gcc_jit_type@w{ }*type) Given a type, return a dynamic cast to a vector type or NULL. @end deffn @geindex gcc_jit_type_is_struct (C function) -@anchor{topics/types c gcc_jit_type_is_struct}@anchor{a0} +@anchor{topics/types c gcc_jit_type_is_struct}@anchor{a2} @deffn {C Function} gcc_jit_struct * gcc_jit_type_is_struct (gcc_jit_type@w{ }*type) Given a type, return a dynamic cast to a struct type or NULL. @end deffn @geindex gcc_jit_vector_type_get_num_units (C function) -@anchor{topics/types c gcc_jit_vector_type_get_num_units}@anchor{a1} +@anchor{topics/types c gcc_jit_vector_type_get_num_units}@anchor{a3} @deffn {C Function} size_t gcc_jit_vector_type_get_num_units (gcc_jit_vector_type@w{ }*vector_type) Given a vector type, return the number of units it contains. @end deffn @geindex gcc_jit_vector_type_get_element_type (C function) -@anchor{topics/types c gcc_jit_vector_type_get_element_type}@anchor{a2} +@anchor{topics/types c gcc_jit_vector_type_get_element_type}@anchor{a4} @deffn {C Function} gcc_jit_type * gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *@w{ }vector_type) Given a vector type, return the type of its elements. @end deffn @geindex gcc_jit_type_unqualified (C function) -@anchor{topics/types c gcc_jit_type_unqualified}@anchor{a3} +@anchor{topics/types c gcc_jit_type_unqualified}@anchor{a5} @deffn {C Function} gcc_jit_type * gcc_jit_type_unqualified (gcc_jit_type@w{ }*type) Given a type, return the unqualified type, removing “const”, “volatile” and @@ -5978,14 +6079,14 @@ alignment qualifiers. @end deffn @geindex gcc_jit_struct_get_field (C function) -@anchor{topics/types c gcc_jit_struct_get_field}@anchor{a4} +@anchor{topics/types c gcc_jit_struct_get_field}@anchor{a6} @deffn {C Function} gcc_jit_field * gcc_jit_struct_get_field (gcc_jit_struct@w{ }*struct_type, size_t@w{ }index) Get a struct field by index. @end deffn @geindex gcc_jit_struct_get_field_count (C function) -@anchor{topics/types c gcc_jit_struct_get_field_count}@anchor{a5} +@anchor{topics/types c gcc_jit_struct_get_field_count}@anchor{a7} @deffn {C Function} size_t gcc_jit_struct_get_field_count (gcc_jit_struct@w{ }*struct_type) @quotation @@ -6001,53 +6102,53 @@ The API entrypoints related to the reflection API: @itemize * @item -@ref{9a,,gcc_jit_function_type_get_return_type()} +@ref{9c,,gcc_jit_function_type_get_return_type()} @item -@ref{9b,,gcc_jit_function_type_get_param_count()} +@ref{9d,,gcc_jit_function_type_get_param_count()} @item -@ref{9c,,gcc_jit_function_type_get_param_type()} +@ref{9e,,gcc_jit_function_type_get_param_type()} @item -@ref{a3,,gcc_jit_type_unqualified()} +@ref{a5,,gcc_jit_type_unqualified()} @item -@ref{97,,gcc_jit_type_dyncast_array()} +@ref{99,,gcc_jit_type_dyncast_array()} @item -@ref{98,,gcc_jit_type_is_bool()} +@ref{9a,,gcc_jit_type_is_bool()} @item -@ref{99,,gcc_jit_type_dyncast_function_ptr_type()} +@ref{9b,,gcc_jit_type_dyncast_function_ptr_type()} @item -@ref{9d,,gcc_jit_type_is_integral()} +@ref{9f,,gcc_jit_type_is_integral()} @item -@ref{9e,,gcc_jit_type_is_pointer()} +@ref{a0,,gcc_jit_type_is_pointer()} @item -@ref{9f,,gcc_jit_type_dyncast_vector()} +@ref{a1,,gcc_jit_type_dyncast_vector()} @item -@ref{a2,,gcc_jit_vector_type_get_element_type()} +@ref{a4,,gcc_jit_vector_type_get_element_type()} @item -@ref{a1,,gcc_jit_vector_type_get_num_units()} +@ref{a3,,gcc_jit_vector_type_get_num_units()} @item -@ref{a4,,gcc_jit_struct_get_field()} +@ref{a6,,gcc_jit_struct_get_field()} @item -@ref{a0,,gcc_jit_type_is_struct()} +@ref{a2,,gcc_jit_type_is_struct()} @item -@ref{a5,,gcc_jit_struct_get_field_count()} +@ref{a7,,gcc_jit_struct_get_field_count()} @end itemize @end quotation -were added in @ref{a6,,LIBGCCJIT_ABI_16}; you can test for their presence +were added in @ref{a8,,LIBGCCJIT_ABI_16}; you can test for their presence using @example @@ -6055,11 +6156,51 @@ using @end example @geindex gcc_jit_case (C type) -@anchor{topics/types c gcc_jit_case}@anchor{a7} +@anchor{topics/types c gcc_jit_case}@anchor{a9} @deffn {C Type} gcc_jit_case @end deffn @end deffn +@geindex gcc_jit_compatible_types (C function) +@anchor{topics/types c gcc_jit_compatible_types}@anchor{aa} +@deffn {C Function} int gcc_jit_compatible_types (gcc_jit_type@w{ }*ltype, gcc_jit_type@w{ }*rtype) + +@quotation + +Return non-zero if the two types are compatible. For instance, +if @code{GCC_JIT_TYPE_UINT64_T} and @code{GCC_JIT_TYPE_UNSIGNED_LONG} +are the same size on the target, this will return non-zero. +The parameters @code{ltype} and @code{rtype} must be non-NULL. +Return 0 on errors. +@end quotation + +This entrypoint was added in @ref{ab,,LIBGCCJIT_ABI_20}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS +@end example +@end deffn + +@geindex gcc_jit_type_get_size (C function) +@anchor{topics/types c gcc_jit_type_get_size}@anchor{ac} +@deffn {C Function} ssize_t gcc_jit_type_get_size (gcc_jit_type@w{ }*type) + +@quotation + +Return the size of a type, in bytes. It only works on integer types for now. +The parameter @code{type} must be non-NULL. +Return -1 on errors. +@end quotation + +This entrypoint was added in @ref{ab,,LIBGCCJIT_ABI_20}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS +@end example +@end deffn + @c Copyright (C) 2014-2022 Free Software Foundation, Inc. @c Originally contributed by David Malcolm <dmalcolm@redhat.com> @c @@ -6078,7 +6219,7 @@ using @c <https://www.gnu.org/licenses/>. @node Expressions,Creating and using functions,Types,Topic Reference -@anchor{topics/expressions doc}@anchor{a8}@anchor{topics/expressions expressions}@anchor{a9} +@anchor{topics/expressions doc}@anchor{ad}@anchor{topics/expressions expressions}@anchor{ae} @section Expressions @@ -6090,7 +6231,7 @@ using @end menu @node Rvalues,Lvalues,,Expressions -@anchor{topics/expressions rvalues}@anchor{aa} +@anchor{topics/expressions rvalues}@anchor{af} @subsection Rvalues @@ -6144,7 +6285,7 @@ Every rvalue has an associated type, and the API will check to ensure that types match up correctly (otherwise the context will emit an error). @geindex gcc_jit_rvalue_get_type (C function) -@anchor{topics/expressions c gcc_jit_rvalue_get_type}@anchor{ab} +@anchor{topics/expressions c gcc_jit_rvalue_get_type}@anchor{b0} @deffn {C Function} gcc_jit_type *gcc_jit_rvalue_get_type (gcc_jit_rvalue@w{ }*rvalue) Get the type of this rvalue. @@ -6171,7 +6312,7 @@ Upcast the given rvalue to be an object. @end menu @node Simple expressions,Constructor expressions,,Rvalues -@anchor{topics/expressions simple-expressions}@anchor{ac} +@anchor{topics/expressions simple-expressions}@anchor{b1} @subsubsection Simple expressions @@ -6184,7 +6325,7 @@ the given constant @code{int} value. @end deffn @geindex gcc_jit_context_new_rvalue_from_long (C function) -@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_long}@anchor{ad} +@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_long}@anchor{b2} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_long (gcc_jit_context@w{ }*ctxt, gcc_jit_type@w{ }*numeric_type, long@w{ }value) Given a numeric type (integer or floating point), build an rvalue for @@ -6224,14 +6365,14 @@ the given constant @code{double} value. @end deffn @geindex gcc_jit_context_new_rvalue_from_ptr (C function) -@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_ptr}@anchor{ae} +@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_ptr}@anchor{b3} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context@w{ }*ctxt, gcc_jit_type@w{ }*pointer_type, void@w{ }*value) Given a pointer type, build an rvalue for the given address. @end deffn @geindex gcc_jit_context_null (C function) -@anchor{topics/expressions c gcc_jit_context_null}@anchor{af} +@anchor{topics/expressions c gcc_jit_context_null}@anchor{b4} @deffn {C Function} gcc_jit_rvalue *gcc_jit_context_null (gcc_jit_context@w{ }*ctxt, gcc_jit_type@w{ }*pointer_type) Given a pointer type, build an rvalue for @code{NULL}. Essentially this @@ -6243,7 +6384,7 @@ gcc_jit_context_new_rvalue_from_ptr (ctxt, pointer_type, NULL) @end deffn @geindex gcc_jit_context_new_string_literal (C function) -@anchor{topics/expressions c gcc_jit_context_new_string_literal}@anchor{b0} +@anchor{topics/expressions c gcc_jit_context_new_string_literal}@anchor{b5} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_string_literal (gcc_jit_context@w{ }*ctxt, const char@w{ }*value) Generate an rvalue for the given NIL-terminated string, of type @@ -6255,7 +6396,7 @@ buffer. @end deffn @node Constructor expressions,Vector expressions,Simple expressions,Rvalues -@anchor{topics/expressions constructor-expressions}@anchor{b1} +@anchor{topics/expressions constructor-expressions}@anchor{b6} @subsubsection Constructor expressions @@ -6266,7 +6407,7 @@ types. The constructor rvalue can be used for assignment to locals. It can be used to initialize global variables with -@ref{b2,,gcc_jit_global_set_initializer_rvalue()}. It can also be used as a +@ref{b7,,gcc_jit_global_set_initializer_rvalue()}. It can also be used as a temporary value for function calls and return values, but its address can’t be taken. @@ -6280,7 +6421,7 @@ The constructor can contain nested constructors. Note that a string literal rvalue can’t be used to construct a char array; the latter needs one rvalue for each char. -These entrypoints were added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for +These entrypoints were added in @ref{b8,,LIBGCCJIT_ABI_19}; you can test for their presence using: @example @@ -6289,7 +6430,7 @@ their presence using: @end quotation @geindex gcc_jit_context_new_array_constructor (C function) -@anchor{topics/expressions c gcc_jit_context_new_array_constructor}@anchor{b4} +@anchor{topics/expressions c gcc_jit_context_new_array_constructor}@anchor{b9} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_array_constructor (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, size_t@w{ }num_values, gcc_jit_rvalue@w{ }**values) Create a constructor for an array as an rvalue. @@ -6313,7 +6454,7 @@ array type’s element type. If @code{num_values} is 0, the @code{values} parameter will be ignored and zero initialization will be used. -This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its +This entrypoint was added in @ref{b8,,LIBGCCJIT_ABI_19}; you can test for its presence using: @example @@ -6322,7 +6463,7 @@ presence using: @end deffn @geindex gcc_jit_context_new_struct_constructor (C function) -@anchor{topics/expressions c gcc_jit_context_new_struct_constructor}@anchor{b5} +@anchor{topics/expressions c gcc_jit_context_new_struct_constructor}@anchor{ba} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_struct_constructor (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, size_t@w{ }num_values, gcc_jit_field@w{ }**fields, gcc_jit_rvalue@w{ }**values) Create a constructor for a struct as an rvalue. @@ -6359,7 +6500,7 @@ of the corresponding field. If @code{num_values} is 0, the array parameters will be ignored and zero initialization will be used. -This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its +This entrypoint was added in @ref{b8,,LIBGCCJIT_ABI_19}; you can test for its presence using: @example @@ -6368,7 +6509,7 @@ presence using: @end deffn @geindex gcc_jit_context_new_union_constructor (C function) -@anchor{topics/expressions c gcc_jit_context_new_union_constructor}@anchor{b6} +@anchor{topics/expressions c gcc_jit_context_new_union_constructor}@anchor{bb} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_union_constructor (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*type, gcc_jit_field@w{ }*field, gcc_jit_rvalue@w{ }*value) Create a constructor for a union as an rvalue. @@ -6388,7 +6529,7 @@ If @code{value} is NULL, zero initialization will be used. Each value has to have have the same unqualified type as the field it is applied to. -This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its +This entrypoint was added in @ref{b8,,LIBGCCJIT_ABI_19}; you can test for its presence using: @example @@ -6397,22 +6538,22 @@ presence using: @end deffn @node Vector expressions,Unary Operations,Constructor expressions,Rvalues -@anchor{topics/expressions vector-expressions}@anchor{b7} +@anchor{topics/expressions vector-expressions}@anchor{bc} @subsubsection Vector expressions @geindex gcc_jit_context_new_rvalue_from_vector (C function) -@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_vector}@anchor{87} +@anchor{topics/expressions c gcc_jit_context_new_rvalue_from_vector}@anchor{89} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_vector (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*vec_type, size_t@w{ }num_elements, gcc_jit_rvalue@w{ }**elements) Build a vector rvalue from an array of elements. “vec_type” should be a vector type, created using -@ref{85,,gcc_jit_type_get_vector()}. +@ref{87,,gcc_jit_type_get_vector()}. “num_elements” should match that of the vector type. -This entrypoint was added in @ref{b8,,LIBGCCJIT_ABI_10}; you can test for +This entrypoint was added in @ref{bd,,LIBGCCJIT_ABI_10}; you can test for its presence using @example @@ -6421,12 +6562,12 @@ its presence using @end deffn @node Unary Operations,Binary Operations,Vector expressions,Rvalues -@anchor{topics/expressions unary-operations}@anchor{b9} +@anchor{topics/expressions unary-operations}@anchor{be} @subsubsection Unary Operations @geindex gcc_jit_context_new_unary_op (C function) -@anchor{topics/expressions c gcc_jit_context_new_unary_op}@anchor{ba} +@anchor{topics/expressions c gcc_jit_context_new_unary_op}@anchor{bf} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_unary_op (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, enum gcc_jit_unary_op@w{ }op, gcc_jit_type@w{ }*result_type, gcc_jit_rvalue@w{ }*rvalue) Build a unary operation out of an input rvalue. @@ -6435,7 +6576,7 @@ The parameter @code{result_type} must be a numeric type. @end deffn @geindex gcc_jit_unary_op (C type) -@anchor{topics/expressions c gcc_jit_unary_op}@anchor{bb} +@anchor{topics/expressions c gcc_jit_unary_op}@anchor{c0} @deffn {C Type} enum gcc_jit_unary_op @end deffn @@ -6453,7 +6594,7 @@ C equivalent @item -@ref{bc,,GCC_JIT_UNARY_OP_MINUS} +@ref{c1,,GCC_JIT_UNARY_OP_MINUS} @tab @@ -6461,7 +6602,7 @@ C equivalent @item -@ref{bd,,GCC_JIT_UNARY_OP_BITWISE_NEGATE} +@ref{c2,,GCC_JIT_UNARY_OP_BITWISE_NEGATE} @tab @@ -6469,7 +6610,7 @@ C equivalent @item -@ref{be,,GCC_JIT_UNARY_OP_LOGICAL_NEGATE} +@ref{c3,,GCC_JIT_UNARY_OP_LOGICAL_NEGATE} @tab @@ -6477,7 +6618,7 @@ C equivalent @item -@ref{bf,,GCC_JIT_UNARY_OP_ABS} +@ref{c4,,GCC_JIT_UNARY_OP_ABS} @tab @@ -6487,7 +6628,7 @@ C equivalent @geindex GCC_JIT_UNARY_OP_MINUS (C macro) -@anchor{topics/expressions c GCC_JIT_UNARY_OP_MINUS}@anchor{bc} +@anchor{topics/expressions c GCC_JIT_UNARY_OP_MINUS}@anchor{c1} @deffn {C Macro} GCC_JIT_UNARY_OP_MINUS Negate an arithmetic value; analogous to: @@ -6500,7 +6641,7 @@ in C. @end deffn @geindex GCC_JIT_UNARY_OP_BITWISE_NEGATE (C macro) -@anchor{topics/expressions c GCC_JIT_UNARY_OP_BITWISE_NEGATE}@anchor{bd} +@anchor{topics/expressions c GCC_JIT_UNARY_OP_BITWISE_NEGATE}@anchor{c2} @deffn {C Macro} GCC_JIT_UNARY_OP_BITWISE_NEGATE Bitwise negation of an integer value (one’s complement); analogous @@ -6514,7 +6655,7 @@ in C. @end deffn @geindex GCC_JIT_UNARY_OP_LOGICAL_NEGATE (C macro) -@anchor{topics/expressions c GCC_JIT_UNARY_OP_LOGICAL_NEGATE}@anchor{be} +@anchor{topics/expressions c GCC_JIT_UNARY_OP_LOGICAL_NEGATE}@anchor{c3} @deffn {C Macro} GCC_JIT_UNARY_OP_LOGICAL_NEGATE Logical negation of an arithmetic or pointer value; analogous to: @@ -6527,7 +6668,7 @@ in C. @end deffn @geindex GCC_JIT_UNARY_OP_ABS (C macro) -@anchor{topics/expressions c GCC_JIT_UNARY_OP_ABS}@anchor{bf} +@anchor{topics/expressions c GCC_JIT_UNARY_OP_ABS}@anchor{c4} @deffn {C Macro} GCC_JIT_UNARY_OP_ABS Absolute value of an arithmetic expression; analogous to: @@ -6540,7 +6681,7 @@ in C. @end deffn @node Binary Operations,Comparisons,Unary Operations,Rvalues -@anchor{topics/expressions binary-operations}@anchor{c0} +@anchor{topics/expressions binary-operations}@anchor{c5} @subsubsection Binary Operations @@ -6554,7 +6695,7 @@ The parameter @code{result_type} must be a numeric type. @end deffn @geindex gcc_jit_binary_op (C type) -@anchor{topics/expressions c gcc_jit_binary_op}@anchor{c1} +@anchor{topics/expressions c gcc_jit_binary_op}@anchor{c6} @deffn {C Type} enum gcc_jit_binary_op @end deffn @@ -6572,7 +6713,7 @@ C equivalent @item -@ref{c2,,GCC_JIT_BINARY_OP_PLUS} +@ref{c7,,GCC_JIT_BINARY_OP_PLUS} @tab @@ -6580,7 +6721,7 @@ C equivalent @item -@ref{c3,,GCC_JIT_BINARY_OP_MINUS} +@ref{c8,,GCC_JIT_BINARY_OP_MINUS} @tab @@ -6588,7 +6729,7 @@ C equivalent @item -@ref{c4,,GCC_JIT_BINARY_OP_MULT} +@ref{c9,,GCC_JIT_BINARY_OP_MULT} @tab @@ -6596,7 +6737,7 @@ C equivalent @item -@ref{c5,,GCC_JIT_BINARY_OP_DIVIDE} +@ref{ca,,GCC_JIT_BINARY_OP_DIVIDE} @tab @@ -6604,7 +6745,7 @@ C equivalent @item -@ref{c6,,GCC_JIT_BINARY_OP_MODULO} +@ref{cb,,GCC_JIT_BINARY_OP_MODULO} @tab @@ -6612,7 +6753,7 @@ C equivalent @item -@ref{c7,,GCC_JIT_BINARY_OP_BITWISE_AND} +@ref{cc,,GCC_JIT_BINARY_OP_BITWISE_AND} @tab @@ -6620,7 +6761,7 @@ C equivalent @item -@ref{c8,,GCC_JIT_BINARY_OP_BITWISE_XOR} +@ref{cd,,GCC_JIT_BINARY_OP_BITWISE_XOR} @tab @@ -6628,7 +6769,7 @@ C equivalent @item -@ref{c9,,GCC_JIT_BINARY_OP_BITWISE_OR} +@ref{ce,,GCC_JIT_BINARY_OP_BITWISE_OR} @tab @@ -6636,7 +6777,7 @@ C equivalent @item -@ref{ca,,GCC_JIT_BINARY_OP_LOGICAL_AND} +@ref{cf,,GCC_JIT_BINARY_OP_LOGICAL_AND} @tab @@ -6644,7 +6785,7 @@ C equivalent @item -@ref{cb,,GCC_JIT_BINARY_OP_LOGICAL_OR} +@ref{d0,,GCC_JIT_BINARY_OP_LOGICAL_OR} @tab @@ -6652,7 +6793,7 @@ C equivalent @item -@ref{cc,,GCC_JIT_BINARY_OP_LSHIFT} +@ref{d1,,GCC_JIT_BINARY_OP_LSHIFT} @tab @@ -6660,7 +6801,7 @@ C equivalent @item -@ref{cd,,GCC_JIT_BINARY_OP_RSHIFT} +@ref{d2,,GCC_JIT_BINARY_OP_RSHIFT} @tab @@ -6670,7 +6811,7 @@ C equivalent @geindex GCC_JIT_BINARY_OP_PLUS (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_PLUS}@anchor{c2} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_PLUS}@anchor{c7} @deffn {C Macro} GCC_JIT_BINARY_OP_PLUS Addition of arithmetic values; analogous to: @@ -6681,11 +6822,11 @@ Addition of arithmetic values; analogous to: in C. -For pointer addition, use @ref{ce,,gcc_jit_context_new_array_access()}. +For pointer addition, use @ref{d3,,gcc_jit_context_new_array_access()}. @end deffn @geindex GCC_JIT_BINARY_OP_MINUS (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_MINUS}@anchor{c3} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_MINUS}@anchor{c8} @deffn {C Macro} GCC_JIT_BINARY_OP_MINUS Subtraction of arithmetic values; analogous to: @@ -6698,7 +6839,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_MULT (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_MULT}@anchor{c4} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_MULT}@anchor{c9} @deffn {C Macro} GCC_JIT_BINARY_OP_MULT Multiplication of a pair of arithmetic values; analogous to: @@ -6711,7 +6852,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_DIVIDE (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_DIVIDE}@anchor{c5} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_DIVIDE}@anchor{ca} @deffn {C Macro} GCC_JIT_BINARY_OP_DIVIDE Quotient of division of arithmetic values; analogous to: @@ -6728,7 +6869,7 @@ a floating-point result type indicates floating-point division. @end deffn @geindex GCC_JIT_BINARY_OP_MODULO (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_MODULO}@anchor{c6} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_MODULO}@anchor{cb} @deffn {C Macro} GCC_JIT_BINARY_OP_MODULO Remainder of division of arithmetic values; analogous to: @@ -6741,7 +6882,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_BITWISE_AND (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_AND}@anchor{c7} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_AND}@anchor{cc} @deffn {C Macro} GCC_JIT_BINARY_OP_BITWISE_AND Bitwise AND; analogous to: @@ -6754,7 +6895,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_BITWISE_XOR (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_XOR}@anchor{c8} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_XOR}@anchor{cd} @deffn {C Macro} GCC_JIT_BINARY_OP_BITWISE_XOR Bitwise exclusive OR; analogous to: @@ -6767,7 +6908,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_BITWISE_OR (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_OR}@anchor{c9} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_BITWISE_OR}@anchor{ce} @deffn {C Macro} GCC_JIT_BINARY_OP_BITWISE_OR Bitwise inclusive OR; analogous to: @@ -6780,7 +6921,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_LOGICAL_AND (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_AND}@anchor{ca} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_AND}@anchor{cf} @deffn {C Macro} GCC_JIT_BINARY_OP_LOGICAL_AND Logical AND; analogous to: @@ -6793,7 +6934,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_LOGICAL_OR (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_OR}@anchor{cb} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_LOGICAL_OR}@anchor{d0} @deffn {C Macro} GCC_JIT_BINARY_OP_LOGICAL_OR Logical OR; analogous to: @@ -6806,7 +6947,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_LSHIFT (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_LSHIFT}@anchor{cc} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_LSHIFT}@anchor{d1} @deffn {C Macro} GCC_JIT_BINARY_OP_LSHIFT Left shift; analogous to: @@ -6819,7 +6960,7 @@ in C. @end deffn @geindex GCC_JIT_BINARY_OP_RSHIFT (C macro) -@anchor{topics/expressions c GCC_JIT_BINARY_OP_RSHIFT}@anchor{cd} +@anchor{topics/expressions c GCC_JIT_BINARY_OP_RSHIFT}@anchor{d2} @deffn {C Macro} GCC_JIT_BINARY_OP_RSHIFT Right shift; analogous to: @@ -6832,7 +6973,7 @@ in C. @end deffn @node Comparisons,Function calls,Binary Operations,Rvalues -@anchor{topics/expressions comparisons}@anchor{cf} +@anchor{topics/expressions comparisons}@anchor{d4} @subsubsection Comparisons @@ -6844,7 +6985,7 @@ Build a boolean rvalue out of the comparison of two other rvalues. @end deffn @geindex gcc_jit_comparison (C type) -@anchor{topics/expressions c gcc_jit_comparison}@anchor{d0} +@anchor{topics/expressions c gcc_jit_comparison}@anchor{d5} @deffn {C Type} enum gcc_jit_comparison @end deffn @@ -6910,12 +7051,12 @@ C equivalent @node Function calls,Function pointers,Comparisons,Rvalues -@anchor{topics/expressions function-calls}@anchor{d1} +@anchor{topics/expressions function-calls}@anchor{d6} @subsubsection Function calls @geindex gcc_jit_context_new_call (C function) -@anchor{topics/expressions c gcc_jit_context_new_call}@anchor{d2} +@anchor{topics/expressions c gcc_jit_context_new_call}@anchor{d7} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_call (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_function@w{ }*func, int@w{ }numargs, gcc_jit_rvalue@w{ }**args) Given a function and the given table of argument rvalues, construct a @@ -6923,7 +7064,7 @@ call to the function, with the result as an rvalue. @cartouche @quotation Note -@ref{d2,,gcc_jit_context_new_call()} merely builds a +@ref{d7,,gcc_jit_context_new_call()} merely builds a @ref{13,,gcc_jit_rvalue} i.e. an expression that can be evaluated, perhaps as part of a more complicated expression. The call @emph{won’t} happen unless you add a statement to a function @@ -6931,7 +7072,7 @@ that evaluates the expression. For example, if you want to call a function and discard the result (or to call a function with @code{void} return type), use -@ref{d3,,gcc_jit_block_add_eval()}: +@ref{d8,,gcc_jit_block_add_eval()}: @example /* Add "(void)printf (arg0, arg1);". */ @@ -6948,28 +7089,28 @@ gcc_jit_block_add_eval ( @end deffn @geindex gcc_jit_context_new_call_through_ptr (C function) -@anchor{topics/expressions c gcc_jit_context_new_call_through_ptr}@anchor{d4} +@anchor{topics/expressions c gcc_jit_context_new_call_through_ptr}@anchor{d9} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_call_through_ptr (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*fn_ptr, int@w{ }numargs, gcc_jit_rvalue@w{ }**args) Given an rvalue of function pointer type (e.g. from -@ref{95,,gcc_jit_context_new_function_ptr_type()}), and the given table of +@ref{97,,gcc_jit_context_new_function_ptr_type()}), and the given table of argument rvalues, construct a call to the function pointer, with the result as an rvalue. @cartouche @quotation Note -The same caveat as for @ref{d2,,gcc_jit_context_new_call()} applies. +The same caveat as for @ref{d7,,gcc_jit_context_new_call()} applies. @end quotation @end cartouche @end deffn @geindex gcc_jit_rvalue_set_bool_require_tail_call (C function) -@anchor{topics/expressions c gcc_jit_rvalue_set_bool_require_tail_call}@anchor{d5} +@anchor{topics/expressions c gcc_jit_rvalue_set_bool_require_tail_call}@anchor{da} @deffn {C Function} void gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue@w{ }*call, int@w{ }require_tail_call) Given an @ref{13,,gcc_jit_rvalue} for a call created through -@ref{d2,,gcc_jit_context_new_call()} or -@ref{d4,,gcc_jit_context_new_call_through_ptr()}, mark/clear the +@ref{d7,,gcc_jit_context_new_call()} or +@ref{d9,,gcc_jit_context_new_call_through_ptr()}, mark/clear the call as needing tail-call optimization. The optimizer will attempt to optimize the call into a jump instruction; if it is unable to do do, an error will be emitted. @@ -6981,7 +7122,7 @@ languages), in which every function “returns” by calling a guaranteed to be implemented as a jump, otherwise the program could consume an arbitrary amount of stack space as it executed. -This entrypoint was added in @ref{d6,,LIBGCCJIT_ABI_6}; you can test for +This entrypoint was added in @ref{db,,LIBGCCJIT_ABI_6}; you can test for its presence using @example @@ -6990,7 +7131,7 @@ its presence using @end deffn @node Function pointers,Type-coercion,Function calls,Rvalues -@anchor{topics/expressions function-pointers}@anchor{d7} +@anchor{topics/expressions function-pointers}@anchor{dc} @subsubsection Function pointers @@ -7003,23 +7144,23 @@ Function pointers can be obtained: @item from a @ref{29,,gcc_jit_function} using -@ref{d8,,gcc_jit_function_get_address()}, or +@ref{dd,,gcc_jit_function_get_address()}, or @item from an existing function using -@ref{ae,,gcc_jit_context_new_rvalue_from_ptr()}, +@ref{b3,,gcc_jit_context_new_rvalue_from_ptr()}, using a function pointer type obtained using -@ref{95,,gcc_jit_context_new_function_ptr_type()}. +@ref{97,,gcc_jit_context_new_function_ptr_type()}. @end itemize @end quotation @node Type-coercion,,Function pointers,Rvalues -@anchor{topics/expressions type-coercion}@anchor{d9} +@anchor{topics/expressions type-coercion}@anchor{de} @subsubsection Type-coercion @geindex gcc_jit_context_new_cast (C function) -@anchor{topics/expressions c gcc_jit_context_new_cast}@anchor{da} +@anchor{topics/expressions c gcc_jit_context_new_cast}@anchor{df} @deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_cast (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue, gcc_jit_type@w{ }*type) Given an rvalue of T, construct another rvalue of another type. @@ -7043,8 +7184,26 @@ P* <-> Q*, for pointer types P and Q @end quotation @end deffn +@geindex gcc_jit_context_new_bitcast (C function) +@anchor{topics/expressions c gcc_jit_context_new_bitcast}@anchor{e0} +@deffn {C Function} gcc_jit_rvalue * gcc_jit_context_new_bitcast (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue, gcc_jit_type@w{ }*type) + +Given an rvalue of T, bitcast it to another type, meaning that this will +generate a new rvalue by interpreting the bits of @code{rvalue} to the layout +of @code{type}. + +The type of rvalue must be the same size as the size of @code{type}. + +This entrypoint was added in @ref{e1,,LIBGCCJIT_ABI_21}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast +@end example +@end deffn + @node Lvalues,Working with pointers structs and unions,Rvalues,Expressions -@anchor{topics/expressions lvalues}@anchor{db} +@anchor{topics/expressions lvalues}@anchor{e2} @subsection Lvalues @@ -7058,21 +7217,21 @@ a storage area (such as a variable). It is also usable as an rvalue, where the rvalue is computed by reading from the storage area. @geindex gcc_jit_lvalue_as_object (C function) -@anchor{topics/expressions c gcc_jit_lvalue_as_object}@anchor{dc} +@anchor{topics/expressions c gcc_jit_lvalue_as_object}@anchor{e3} @deffn {C Function} gcc_jit_object * gcc_jit_lvalue_as_object (gcc_jit_lvalue@w{ }*lvalue) Upcast an lvalue to be an object. @end deffn @geindex gcc_jit_lvalue_as_rvalue (C function) -@anchor{topics/expressions c gcc_jit_lvalue_as_rvalue}@anchor{dd} +@anchor{topics/expressions c gcc_jit_lvalue_as_rvalue}@anchor{e4} @deffn {C Function} gcc_jit_rvalue * gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue@w{ }*lvalue) Upcast an lvalue to be an rvalue. @end deffn @geindex gcc_jit_lvalue_get_address (C function) -@anchor{topics/expressions c gcc_jit_lvalue_get_address}@anchor{de} +@anchor{topics/expressions c gcc_jit_lvalue_get_address}@anchor{e5} @deffn {C Function} gcc_jit_rvalue * gcc_jit_lvalue_get_address (gcc_jit_lvalue@w{ }*lvalue, gcc_jit_location@w{ }*loc) Take the address of an lvalue; analogous to: @@ -7085,7 +7244,7 @@ in C. @end deffn @geindex gcc_jit_lvalue_set_tls_model (C function) -@anchor{topics/expressions c gcc_jit_lvalue_set_tls_model}@anchor{df} +@anchor{topics/expressions c gcc_jit_lvalue_set_tls_model}@anchor{e6} @deffn {C Function} void gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue@w{ }*lvalue, enum gcc_jit_tls_model@w{ }model) Make a variable a thread-local variable. @@ -7093,34 +7252,34 @@ Make a variable a thread-local variable. The “model” parameter determines the thread-local storage model of the “lvalue”: @geindex gcc_jit_tls_model (C type) -@anchor{topics/expressions c gcc_jit_tls_model}@anchor{e0} +@anchor{topics/expressions c gcc_jit_tls_model}@anchor{e7} @deffn {C Type} enum gcc_jit_tls_model @end deffn @geindex GCC_JIT_TLS_MODEL_NONE (C macro) -@anchor{topics/expressions c GCC_JIT_TLS_MODEL_NONE}@anchor{e1} +@anchor{topics/expressions c GCC_JIT_TLS_MODEL_NONE}@anchor{e8} @deffn {C Macro} GCC_JIT_TLS_MODEL_NONE Don’t set the TLS model. @end deffn @geindex GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC (C macro) -@anchor{topics/expressions c GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC}@anchor{e2} +@anchor{topics/expressions c GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC}@anchor{e9} @deffn {C Macro} GCC_JIT_TLS_MODEL_GLOBAL_DYNAMIC @end deffn @geindex GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC (C macro) -@anchor{topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC}@anchor{e3} +@anchor{topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC}@anchor{ea} @deffn {C Macro} GCC_JIT_TLS_MODEL_LOCAL_DYNAMIC @end deffn @geindex GCC_JIT_TLS_MODEL_INITIAL_EXEC (C macro) -@anchor{topics/expressions c GCC_JIT_TLS_MODEL_INITIAL_EXEC}@anchor{e4} +@anchor{topics/expressions c GCC_JIT_TLS_MODEL_INITIAL_EXEC}@anchor{eb} @deffn {C Macro} GCC_JIT_TLS_MODEL_INITIAL_EXEC @end deffn @geindex GCC_JIT_TLS_MODEL_LOCAL_EXEC (C macro) -@anchor{topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_EXEC}@anchor{e5} +@anchor{topics/expressions c GCC_JIT_TLS_MODEL_LOCAL_EXEC}@anchor{ec} @deffn {C Macro} GCC_JIT_TLS_MODEL_LOCAL_EXEC @end deffn @@ -7132,7 +7291,7 @@ _Thread_local int foo __attribute__ ((tls_model("MODEL"))); in C. -This entrypoint was added in @ref{e6,,LIBGCCJIT_ABI_17}; you can test for +This entrypoint was added in @ref{ed,,LIBGCCJIT_ABI_17}; you can test for its presence using @example @@ -7141,7 +7300,7 @@ its presence using @end deffn @geindex gcc_jit_lvalue_set_link_section (C function) -@anchor{topics/expressions c gcc_jit_lvalue_set_link_section}@anchor{e7} +@anchor{topics/expressions c gcc_jit_lvalue_set_link_section}@anchor{ee} @deffn {C Function} void gcc_jit_lvalue_set_link_section (gcc_jit_lvalue@w{ }*lvalue, const char@w{ }*section_name) Set the link section of a variable. @@ -7154,7 +7313,7 @@ int variable __attribute__((section(".section"))); in C. -This entrypoint was added in @ref{e8,,LIBGCCJIT_ABI_18}; you can test for +This entrypoint was added in @ref{ef,,LIBGCCJIT_ABI_18}; you can test for its presence using @example @@ -7162,18 +7321,80 @@ its presence using @end example @end deffn + +@deffn {C Function} void gcc_jit_lvalue_set_register_name (gcc_jit_lvalue *lvalue, const char *reg_name); + +Set the register name of a variable. +The parameter @code{reg_name} must be non-NULL. Analogous to: + +@example +register int variable asm ("r12"); +@end example + +in C. + +This entrypoint was added in @ref{f0,,LIBGCCJIT_ABI_22}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name +@end example +@end deffn + +@geindex gcc_jit_lvalue_set_alignment (C function) +@anchor{topics/expressions c gcc_jit_lvalue_set_alignment}@anchor{f1} +@deffn {C Function} void gcc_jit_lvalue_set_alignment (gcc_jit_lvalue@w{ }*lvalue, unsigned@w{ }bytes) + +Set the alignment of a variable, in bytes. +Analogous to: + +@example +int variable __attribute__((aligned (16))); +@end example + +in C. + +This entrypoint was added in @ref{f2,,LIBGCCJIT_ABI_24}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_ALIGNMENT +@end example +@end deffn + +@geindex gcc_jit_lvalue_get_alignment (C function) +@anchor{topics/expressions c gcc_jit_lvalue_get_alignment}@anchor{f3} +@deffn {C Function} unsigned gcc_jit_lvalue_get_alignment (gcc_jit_lvalue@w{ }*lvalue) + +Return the alignment of a variable set by @code{gcc_jit_lvalue_set_alignment}. +Return 0 if the alignment was not set. Analogous to: + +@example +_Alignof (variable) +@end example + +in C. + +This entrypoint was added in @ref{f2,,LIBGCCJIT_ABI_24}; you can test for +its presence using + +@example +#ifdef LIBGCCJIT_HAVE_ALIGNMENT +@end example +@end deffn + @menu * Global variables:: @end menu @node Global variables,,,Lvalues -@anchor{topics/expressions global-variables}@anchor{e9} +@anchor{topics/expressions global-variables}@anchor{f4} @subsubsection Global variables @geindex gcc_jit_context_new_global (C function) -@anchor{topics/expressions c gcc_jit_context_new_global}@anchor{ea} +@anchor{topics/expressions c gcc_jit_context_new_global}@anchor{f5} @deffn {C Function} gcc_jit_lvalue * gcc_jit_context_new_global (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, enum gcc_jit_global_kind@w{ }kind, gcc_jit_type@w{ }*type, const char@w{ }*name) Add a new global variable of the given type and name to the context. @@ -7188,22 +7409,22 @@ The “kind” parameter determines the visibility of the “global” outside of the @ref{16,,gcc_jit_result}: @geindex gcc_jit_global_kind (C type) -@anchor{topics/expressions c gcc_jit_global_kind}@anchor{eb} +@anchor{topics/expressions c gcc_jit_global_kind}@anchor{f6} @deffn {C Type} enum gcc_jit_global_kind @end deffn @geindex GCC_JIT_GLOBAL_EXPORTED (C macro) -@anchor{topics/expressions c GCC_JIT_GLOBAL_EXPORTED}@anchor{ec} +@anchor{topics/expressions c GCC_JIT_GLOBAL_EXPORTED}@anchor{f7} @deffn {C Macro} GCC_JIT_GLOBAL_EXPORTED Global is defined by the client code and is visible by name outside of this JIT context via -@ref{ed,,gcc_jit_result_get_global()} (and this value is required for +@ref{f8,,gcc_jit_result_get_global()} (and this value is required for the global to be accessible via that entrypoint). @end deffn @geindex GCC_JIT_GLOBAL_INTERNAL (C macro) -@anchor{topics/expressions c GCC_JIT_GLOBAL_INTERNAL}@anchor{ee} +@anchor{topics/expressions c GCC_JIT_GLOBAL_INTERNAL}@anchor{f9} @deffn {C Macro} GCC_JIT_GLOBAL_INTERNAL Global is defined by the client code, but is invisible @@ -7213,7 +7434,7 @@ context and within child contexts. @end deffn @geindex GCC_JIT_GLOBAL_IMPORTED (C macro) -@anchor{topics/expressions c GCC_JIT_GLOBAL_IMPORTED}@anchor{ef} +@anchor{topics/expressions c GCC_JIT_GLOBAL_IMPORTED}@anchor{fa} @deffn {C Macro} GCC_JIT_GLOBAL_IMPORTED Global is not defined by the client code; we’re merely @@ -7223,7 +7444,7 @@ header file. @end deffn @geindex gcc_jit_global_set_initializer (C function) -@anchor{topics/expressions c gcc_jit_global_set_initializer}@anchor{f0} +@anchor{topics/expressions c gcc_jit_global_set_initializer}@anchor{fb} @deffn {C Function} gcc_jit_lvalue * gcc_jit_global_set_initializer (gcc_jit_lvalue@w{ }*global, const void@w{ }*blob, size_t@w{ }num_bytes) Set an initializer for @code{global} using the memory content pointed @@ -7235,7 +7456,7 @@ pointed by @code{blob} for @code{num_bytes} bytes, so it is valid to pass in a pointer to an on-stack buffer. The content will be stored in the compilation unit and used as initialization value of the array. -This entrypoint was added in @ref{f1,,LIBGCCJIT_ABI_14}; you can test for +This entrypoint was added in @ref{fc,,LIBGCCJIT_ABI_14}; you can test for its presence using @example @@ -7244,14 +7465,14 @@ its presence using @end deffn @geindex gcc_jit_global_set_initializer_rvalue (C function) -@anchor{topics/expressions c gcc_jit_global_set_initializer_rvalue}@anchor{b2} +@anchor{topics/expressions c gcc_jit_global_set_initializer_rvalue}@anchor{b7} @deffn {C Function} gcc_jit_lvalue * gcc_jit_global_set_initializer_rvalue (gcc_jit_lvalue@w{ }*global, gcc_jit_rvalue@w{ }*init_value) Set the initial value of a global with an rvalue. The rvalue needs to be a constant expression, e.g. no function calls. -The global can’t have the @code{kind} @ref{ef,,GCC_JIT_GLOBAL_IMPORTED}. +The global can’t have the @code{kind} @ref{fa,,GCC_JIT_GLOBAL_IMPORTED}. As a non-comprehensive example it is OK to do the equivalent of: @@ -7263,13 +7484,13 @@ const int baz = 3; /* rvalue from gcc_jit_context_rvalue_from_int. */ int boz = baz; /* rvalue from gcc_jit_lvalue_as_rvalue. */ @end example -Use together with @ref{b5,,gcc_jit_context_new_struct_constructor()}, -@ref{b6,,gcc_jit_context_new_union_constructor()}, @ref{b4,,gcc_jit_context_new_array_constructor()} +Use together with @ref{ba,,gcc_jit_context_new_struct_constructor()}, +@ref{bb,,gcc_jit_context_new_union_constructor()}, @ref{b9,,gcc_jit_context_new_array_constructor()} to initialize structs, unions and arrays. On success, returns the @code{global} parameter unchanged. Otherwise, @code{NULL}. -This entrypoint was added in @ref{b3,,LIBGCCJIT_ABI_19}; you can test for its +This entrypoint was added in @ref{b8,,LIBGCCJIT_ABI_19}; you can test for its presence using: @example @@ -7278,12 +7499,12 @@ presence using: @end deffn @node Working with pointers structs and unions,,Lvalues,Expressions -@anchor{topics/expressions working-with-pointers-structs-and-unions}@anchor{f2} +@anchor{topics/expressions working-with-pointers-structs-and-unions}@anchor{fd} @subsection Working with pointers, structs and unions @geindex gcc_jit_rvalue_dereference (C function) -@anchor{topics/expressions c gcc_jit_rvalue_dereference}@anchor{f3} +@anchor{topics/expressions c gcc_jit_rvalue_dereference}@anchor{fe} @deffn {C Function} gcc_jit_lvalue * gcc_jit_rvalue_dereference (gcc_jit_rvalue@w{ }*rvalue, gcc_jit_location@w{ }*loc) Given an rvalue of pointer type @code{T *}, dereferencing the pointer, @@ -7299,7 +7520,7 @@ in C. Field access is provided separately for both lvalues and rvalues. @geindex gcc_jit_lvalue_access_field (C function) -@anchor{topics/expressions c gcc_jit_lvalue_access_field}@anchor{f4} +@anchor{topics/expressions c gcc_jit_lvalue_access_field}@anchor{ff} @deffn {C Function} gcc_jit_lvalue * gcc_jit_lvalue_access_field (gcc_jit_lvalue@w{ }*struct_, gcc_jit_location@w{ }*loc, gcc_jit_field@w{ }*field) Given an lvalue of struct or union type, access the given field, @@ -7313,7 +7534,7 @@ in C. @end deffn @geindex gcc_jit_rvalue_access_field (C function) -@anchor{topics/expressions c gcc_jit_rvalue_access_field}@anchor{f5} +@anchor{topics/expressions c gcc_jit_rvalue_access_field}@anchor{100} @deffn {C Function} gcc_jit_rvalue * gcc_jit_rvalue_access_field (gcc_jit_rvalue@w{ }*struct_, gcc_jit_location@w{ }*loc, gcc_jit_field@w{ }*field) Given an rvalue of struct or union type, access the given field @@ -7327,7 +7548,7 @@ in C. @end deffn @geindex gcc_jit_rvalue_dereference_field (C function) -@anchor{topics/expressions c gcc_jit_rvalue_dereference_field}@anchor{f6} +@anchor{topics/expressions c gcc_jit_rvalue_dereference_field}@anchor{101} @deffn {C Function} gcc_jit_lvalue * gcc_jit_rvalue_dereference_field (gcc_jit_rvalue@w{ }*ptr, gcc_jit_location@w{ }*loc, gcc_jit_field@w{ }*field) Given an rvalue of pointer type @code{T *} where T is of struct or union @@ -7341,7 +7562,7 @@ in C, itself equivalent to @code{(*EXPR).FIELD}. @end deffn @geindex gcc_jit_context_new_array_access (C function) -@anchor{topics/expressions c gcc_jit_context_new_array_access}@anchor{ce} +@anchor{topics/expressions c gcc_jit_context_new_array_access}@anchor{d3} @deffn {C Function} gcc_jit_lvalue * gcc_jit_context_new_array_access (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*ptr, gcc_jit_rvalue@w{ }*index) Given an rvalue of pointer type @code{T *}, get at the element @cite{T} at @@ -7374,7 +7595,7 @@ in C (or, indeed, to @code{PTR + INDEX}). @c <https://www.gnu.org/licenses/>. @node Creating and using functions,Function pointers<2>,Expressions,Topic Reference -@anchor{topics/functions doc}@anchor{f7}@anchor{topics/functions creating-and-using-functions}@anchor{f8} +@anchor{topics/functions doc}@anchor{102}@anchor{topics/functions creating-and-using-functions}@anchor{103} @section Creating and using functions @@ -7387,7 +7608,7 @@ in C (or, indeed, to @code{PTR + INDEX}). @end menu @node Params,Functions,,Creating and using functions -@anchor{topics/functions params}@anchor{f9} +@anchor{topics/functions params}@anchor{104} @subsection Params @@ -7416,28 +7637,28 @@ Parameters are lvalues, and thus are also rvalues (and objects), so the following upcasts are available: @geindex gcc_jit_param_as_lvalue (C function) -@anchor{topics/functions c gcc_jit_param_as_lvalue}@anchor{fa} +@anchor{topics/functions c gcc_jit_param_as_lvalue}@anchor{105} @deffn {C Function} gcc_jit_lvalue * gcc_jit_param_as_lvalue (gcc_jit_param@w{ }*param) Upcasting from param to lvalue. @end deffn @geindex gcc_jit_param_as_rvalue (C function) -@anchor{topics/functions c gcc_jit_param_as_rvalue}@anchor{fb} +@anchor{topics/functions c gcc_jit_param_as_rvalue}@anchor{106} @deffn {C Function} gcc_jit_rvalue * gcc_jit_param_as_rvalue (gcc_jit_param@w{ }*param) Upcasting from param to rvalue. @end deffn @geindex gcc_jit_param_as_object (C function) -@anchor{topics/functions c gcc_jit_param_as_object}@anchor{fc} +@anchor{topics/functions c gcc_jit_param_as_object}@anchor{107} @deffn {C Function} gcc_jit_object * gcc_jit_param_as_object (gcc_jit_param@w{ }*param) Upcasting from param to object. @end deffn @node Functions,Blocks,Params,Creating and using functions -@anchor{topics/functions functions}@anchor{fd} +@anchor{topics/functions functions}@anchor{108} @subsection Functions @@ -7456,7 +7677,7 @@ creating ourselves, or one that we’re referencing. Create a gcc_jit_function with the given name and parameters. @geindex gcc_jit_function_kind (C type) -@anchor{topics/functions c gcc_jit_function_kind}@anchor{fe} +@anchor{topics/functions c gcc_jit_function_kind}@anchor{109} @deffn {C Type} enum gcc_jit_function_kind @end deffn @@ -7466,7 +7687,7 @@ values: @quotation @geindex GCC_JIT_FUNCTION_EXPORTED (C macro) -@anchor{topics/functions c GCC_JIT_FUNCTION_EXPORTED}@anchor{ff} +@anchor{topics/functions c GCC_JIT_FUNCTION_EXPORTED}@anchor{10a} @deffn {C Macro} GCC_JIT_FUNCTION_EXPORTED Function is defined by the client code and visible @@ -7478,7 +7699,7 @@ for this function from a @ref{16,,gcc_jit_result} via @end deffn @geindex GCC_JIT_FUNCTION_INTERNAL (C macro) -@anchor{topics/functions c GCC_JIT_FUNCTION_INTERNAL}@anchor{100} +@anchor{topics/functions c GCC_JIT_FUNCTION_INTERNAL}@anchor{10b} @deffn {C Macro} GCC_JIT_FUNCTION_INTERNAL Function is defined by the client code, but is invisible @@ -7486,7 +7707,7 @@ outside of the JIT. Analogous to a “static” function. @end deffn @geindex GCC_JIT_FUNCTION_IMPORTED (C macro) -@anchor{topics/functions c GCC_JIT_FUNCTION_IMPORTED}@anchor{101} +@anchor{topics/functions c GCC_JIT_FUNCTION_IMPORTED}@anchor{10c} @deffn {C Macro} GCC_JIT_FUNCTION_IMPORTED Function is not defined by the client code; we’re merely @@ -7495,7 +7716,7 @@ header file. @end deffn @geindex GCC_JIT_FUNCTION_ALWAYS_INLINE (C macro) -@anchor{topics/functions c GCC_JIT_FUNCTION_ALWAYS_INLINE}@anchor{102} +@anchor{topics/functions c GCC_JIT_FUNCTION_ALWAYS_INLINE}@anchor{10d} @deffn {C Macro} GCC_JIT_FUNCTION_ALWAYS_INLINE Function is only ever inlined into other functions, and is @@ -7516,7 +7737,7 @@ buffer. @end deffn @geindex gcc_jit_context_get_builtin_function (C function) -@anchor{topics/functions c gcc_jit_context_get_builtin_function}@anchor{103} +@anchor{topics/functions c gcc_jit_context_get_builtin_function}@anchor{10e} @deffn {C Function} gcc_jit_function * gcc_jit_context_get_builtin_function (gcc_jit_context@w{ }*ctxt, const char@w{ }*name) Get the @ref{29,,gcc_jit_function} for the built-in function with the @@ -7540,14 +7761,14 @@ the context. @end deffn @geindex gcc_jit_function_as_object (C function) -@anchor{topics/functions c gcc_jit_function_as_object}@anchor{104} +@anchor{topics/functions c gcc_jit_function_as_object}@anchor{10f} @deffn {C Function} gcc_jit_object * gcc_jit_function_as_object (gcc_jit_function@w{ }*func) Upcasting from function to object. @end deffn @geindex gcc_jit_function_get_param (C function) -@anchor{topics/functions c gcc_jit_function_get_param}@anchor{105} +@anchor{topics/functions c gcc_jit_function_get_param}@anchor{110} @deffn {C Function} gcc_jit_param * gcc_jit_function_get_param (gcc_jit_function@w{ }*func, int@w{ }index) Get the param of the given index (0-based). @@ -7575,14 +7796,14 @@ buffer. @end deffn @geindex gcc_jit_function_get_param_count (C function) -@anchor{topics/functions c gcc_jit_function_get_param_count}@anchor{106} +@anchor{topics/functions c gcc_jit_function_get_param_count}@anchor{111} @deffn {C Function} size_t gcc_jit_function_get_param_count (gcc_jit_function@w{ }*func) Get the number of parameters of the function. @end deffn @geindex gcc_jit_function_get_return_type (C function) -@anchor{topics/functions c gcc_jit_function_get_return_type}@anchor{107} +@anchor{topics/functions c gcc_jit_function_get_return_type}@anchor{112} @deffn {C Function} gcc_jit_type * gcc_jit_function_get_return_type (gcc_jit_function@w{ }*func) Get the return type of the function. @@ -7596,14 +7817,14 @@ types: @itemize * @item -@ref{107,,gcc_jit_function_get_return_type()} +@ref{112,,gcc_jit_function_get_return_type()} @item -@ref{106,,gcc_jit_function_get_param_count()} +@ref{111,,gcc_jit_function_get_param_count()} @end itemize @end quotation -were added in @ref{a6,,LIBGCCJIT_ABI_16}; you can test for their presence +were added in @ref{a8,,LIBGCCJIT_ABI_16}; you can test for their presence using @example @@ -7611,13 +7832,13 @@ using @end example @geindex gcc_jit_case (C type) -@anchor{topics/functions c gcc_jit_case}@anchor{108} +@anchor{topics/functions c gcc_jit_case}@anchor{113} @deffn {C Type} gcc_jit_case @end deffn @end deffn @node Blocks,Statements,Functions,Creating and using functions -@anchor{topics/functions blocks}@anchor{109} +@anchor{topics/functions blocks}@anchor{114} @subsection Blocks @@ -7641,7 +7862,7 @@ one function. @end deffn @geindex gcc_jit_function_new_block (C function) -@anchor{topics/functions c gcc_jit_function_new_block}@anchor{10a} +@anchor{topics/functions c gcc_jit_function_new_block}@anchor{115} @deffn {C Function} gcc_jit_block * gcc_jit_function_new_block (gcc_jit_function@w{ }*func, const char@w{ }*name) Create a basic block of the given name. The name may be NULL, but @@ -7661,26 +7882,26 @@ for (pc = 0; pc < fn->fn_num_ops; pc++) @end deffn @geindex gcc_jit_block_as_object (C function) -@anchor{topics/functions c gcc_jit_block_as_object}@anchor{10b} +@anchor{topics/functions c gcc_jit_block_as_object}@anchor{116} @deffn {C Function} gcc_jit_object * gcc_jit_block_as_object (gcc_jit_block@w{ }*block) Upcast from block to object. @end deffn @geindex gcc_jit_block_get_function (C function) -@anchor{topics/functions c gcc_jit_block_get_function}@anchor{10c} +@anchor{topics/functions c gcc_jit_block_get_function}@anchor{117} @deffn {C Function} gcc_jit_function * gcc_jit_block_get_function (gcc_jit_block@w{ }*block) Which function is this block within? @end deffn @node Statements,,Blocks,Creating and using functions -@anchor{topics/functions statements}@anchor{10d} +@anchor{topics/functions statements}@anchor{118} @subsection Statements @geindex gcc_jit_block_add_eval (C function) -@anchor{topics/functions c gcc_jit_block_add_eval}@anchor{d3} +@anchor{topics/functions c gcc_jit_block_add_eval}@anchor{d8} @deffn {C Function} void gcc_jit_block_add_eval (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue) Add evaluation of an rvalue, discarding the result @@ -7777,7 +7998,7 @@ block, boolval, on_true, and on_false must be non-NULL. @end deffn @geindex gcc_jit_block_end_with_jump (C function) -@anchor{topics/functions c gcc_jit_block_end_with_jump}@anchor{10e} +@anchor{topics/functions c gcc_jit_block_end_with_jump}@anchor{119} @deffn {C Function} void gcc_jit_block_end_with_jump (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_block@w{ }*target) Terminate a block by adding a jump to the given target block. @@ -7790,7 +8011,7 @@ goto target; @end deffn @geindex gcc_jit_block_end_with_return (C function) -@anchor{topics/functions c gcc_jit_block_end_with_return}@anchor{10f} +@anchor{topics/functions c gcc_jit_block_end_with_return}@anchor{11a} @deffn {C Function} void gcc_jit_block_end_with_return (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*rvalue) Terminate a block by adding evaluation of an rvalue, returning the value. @@ -7803,7 +8024,7 @@ return expression; @end deffn @geindex gcc_jit_block_end_with_void_return (C function) -@anchor{topics/functions c gcc_jit_block_end_with_void_return}@anchor{110} +@anchor{topics/functions c gcc_jit_block_end_with_void_return}@anchor{11b} @deffn {C Function} void gcc_jit_block_end_with_void_return (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc) Terminate a block by adding a valueless return, for use within a function @@ -7817,7 +8038,7 @@ return; @end deffn @geindex gcc_jit_block_end_with_switch (C function) -@anchor{topics/functions c gcc_jit_block_end_with_switch}@anchor{111} +@anchor{topics/functions c gcc_jit_block_end_with_switch}@anchor{11c} @deffn {C Function} void gcc_jit_block_end_with_switch (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, gcc_jit_rvalue@w{ }*expr, gcc_jit_block@w{ }*default_block, int@w{ }num_cases, gcc_jit_case@w{ }**cases) Terminate a block by adding evalation of an rvalue, then performing @@ -7863,17 +8084,17 @@ The API entrypoints relating to switch statements and cases: @itemize * @item -@ref{111,,gcc_jit_block_end_with_switch()} +@ref{11c,,gcc_jit_block_end_with_switch()} @item -@ref{112,,gcc_jit_case_as_object()} +@ref{11d,,gcc_jit_case_as_object()} @item -@ref{113,,gcc_jit_context_new_case()} +@ref{11e,,gcc_jit_context_new_case()} @end itemize @end quotation -were added in @ref{114,,LIBGCCJIT_ABI_3}; you can test for their presence +were added in @ref{11f,,LIBGCCJIT_ABI_3}; you can test for their presence using @example @@ -7887,14 +8108,14 @@ using A @cite{gcc_jit_case} represents a case within a switch statement, and is created within a particular @ref{8,,gcc_jit_context} using -@ref{113,,gcc_jit_context_new_case()}. +@ref{11e,,gcc_jit_context_new_case()}. Each case expresses a multivalued range of integer values. You can express single-valued cases by passing in the same value for both @cite{min_value} and @cite{max_value}. @geindex gcc_jit_context_new_case (C function) -@anchor{topics/functions c gcc_jit_context_new_case}@anchor{113} +@anchor{topics/functions c gcc_jit_context_new_case}@anchor{11e} @deffn {C Function} gcc_jit_case * gcc_jit_context_new_case (gcc_jit_context@w{ }*ctxt, gcc_jit_rvalue@w{ }*min_value, gcc_jit_rvalue@w{ }*max_value, gcc_jit_block@w{ }*dest_block) Create a new gcc_jit_case instance for use in a switch statement. @@ -7906,7 +8127,7 @@ statement. @end deffn @geindex gcc_jit_case_as_object (C function) -@anchor{topics/functions c gcc_jit_case_as_object}@anchor{112} +@anchor{topics/functions c gcc_jit_case_as_object}@anchor{11d} @deffn {C Function} gcc_jit_object * gcc_jit_case_as_object (gcc_jit_case@w{ }*case_) Upcast from a case to an object. @@ -8020,7 +8241,7 @@ create_code (gcc_jit_context *ctxt, void *user_data) @end quotation @end deffn -See also @ref{115,,gcc_jit_extended_asm} for entrypoints for adding inline +See also @ref{120,,gcc_jit_extended_asm} for entrypoints for adding inline assembler statements to a function. @c Copyright (C) 2017-2022 Free Software Foundation, Inc. @@ -8041,26 +8262,26 @@ assembler statements to a function. @c <https://www.gnu.org/licenses/>. @node Function pointers<2>,Source Locations,Creating and using functions,Topic Reference -@anchor{topics/function-pointers doc}@anchor{116}@anchor{topics/function-pointers function-pointers}@anchor{117} +@anchor{topics/function-pointers doc}@anchor{121}@anchor{topics/function-pointers function-pointers}@anchor{122} @section Function pointers You can generate calls that use a function pointer via -@ref{d4,,gcc_jit_context_new_call_through_ptr()}. +@ref{d9,,gcc_jit_context_new_call_through_ptr()}. To do requires a @ref{13,,gcc_jit_rvalue} of the correct function pointer type. Function pointers for a @ref{29,,gcc_jit_function} can be obtained -via @ref{d8,,gcc_jit_function_get_address()}. +via @ref{dd,,gcc_jit_function_get_address()}. @geindex gcc_jit_function_get_address (C function) -@anchor{topics/function-pointers c gcc_jit_function_get_address}@anchor{d8} +@anchor{topics/function-pointers c gcc_jit_function_get_address}@anchor{dd} @deffn {C Function} gcc_jit_rvalue * gcc_jit_function_get_address (gcc_jit_function@w{ }*fn, gcc_jit_location@w{ }*loc) Get the address of a function as an rvalue, of function pointer type. -This entrypoint was added in @ref{118,,LIBGCCJIT_ABI_9}; you can test +This entrypoint was added in @ref{123,,LIBGCCJIT_ABI_9}; you can test for its presence using @example @@ -8070,8 +8291,8 @@ for its presence using Alternatively, given an existing function, you can obtain a pointer to it in @ref{13,,gcc_jit_rvalue} form using -@ref{ae,,gcc_jit_context_new_rvalue_from_ptr()}, using a function pointer -type obtained using @ref{95,,gcc_jit_context_new_function_ptr_type()}. +@ref{b3,,gcc_jit_context_new_rvalue_from_ptr()}, using a function pointer +type obtained using @ref{97,,gcc_jit_context_new_function_ptr_type()}. Here’s an example of creating a function pointer type corresponding to C’s @code{void (*) (int, int, int)}: @@ -8095,7 +8316,7 @@ gcc_jit_type *fn_ptr_type = @end example @geindex gcc_jit_context_new_function_ptr_type (C function) -@anchor{topics/function-pointers c gcc_jit_context_new_function_ptr_type}@anchor{95} +@anchor{topics/function-pointers c gcc_jit_context_new_function_ptr_type}@anchor{97} @deffn {C Function} gcc_jit_type * gcc_jit_context_new_function_ptr_type (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, gcc_jit_type@w{ }*return_type, int@w{ }num_params, gcc_jit_type@w{ }**param_types, int@w{ }is_variadic) Generate a @ref{a,,gcc_jit_type} for a function pointer with the @@ -8122,7 +8343,7 @@ Each of @cite{param_types} must be non-@cite{void}; @cite{return_type} may be @c @c <https://www.gnu.org/licenses/>. @node Source Locations,Compiling a context,Function pointers<2>,Topic Reference -@anchor{topics/locations doc}@anchor{119}@anchor{topics/locations source-locations}@anchor{11a} +@anchor{topics/locations doc}@anchor{124}@anchor{topics/locations source-locations}@anchor{125} @section Source Locations @@ -8170,7 +8391,7 @@ on-stack buffer. @end menu @node Faking it,,,Source Locations -@anchor{topics/locations faking-it}@anchor{11b} +@anchor{topics/locations faking-it}@anchor{126} @subsection Faking it @@ -8206,7 +8427,7 @@ file, giving you @emph{something} you can step through in the debugger. @c <https://www.gnu.org/licenses/>. @node Compiling a context,ABI and API compatibility,Source Locations,Topic Reference -@anchor{topics/compilation doc}@anchor{11c}@anchor{topics/compilation compiling-a-context}@anchor{11d} +@anchor{topics/compilation doc}@anchor{127}@anchor{topics/compilation compiling-a-context}@anchor{128} @section Compiling a context @@ -8225,7 +8446,7 @@ prevent any future compilation of that context. @end menu @node In-memory compilation,Ahead-of-time compilation,,Compiling a context -@anchor{topics/compilation in-memory-compilation}@anchor{11e} +@anchor{topics/compilation in-memory-compilation}@anchor{129} @subsection In-memory compilation @@ -8260,7 +8481,7 @@ Functions are looked up by name. For this to succeed, a function with a name matching @cite{funcname} must have been created on @cite{result}’s context (or a parent context) via a call to @ref{11,,gcc_jit_context_new_function()} with @cite{kind} -@ref{ff,,GCC_JIT_FUNCTION_EXPORTED}: +@ref{10a,,GCC_JIT_FUNCTION_EXPORTED}: @example gcc_jit_context_new_function (ctxt, @@ -8288,7 +8509,7 @@ to a segmentation fault. @end deffn @geindex gcc_jit_result_get_global (C function) -@anchor{topics/compilation c gcc_jit_result_get_global}@anchor{ed} +@anchor{topics/compilation c gcc_jit_result_get_global}@anchor{f8} @deffn {C Function} void * gcc_jit_result_get_global (gcc_jit_result@w{ }*result, const char@w{ }*name) Locate a given global within the built machine code. @@ -8296,8 +8517,8 @@ Locate a given global within the built machine code. Globals are looked up by name. For this to succeed, a global with a name matching @cite{name} must have been created on @cite{result}’s context (or a parent context) via a call to -@ref{ea,,gcc_jit_context_new_global()} with @cite{kind} -@ref{ec,,GCC_JIT_GLOBAL_EXPORTED}. +@ref{f5,,gcc_jit_context_new_global()} with @cite{kind} +@ref{f7,,GCC_JIT_GLOBAL_EXPORTED}. If the global is found, the result will need to be cast to a pointer of the correct type before it can be called. @@ -8341,11 +8562,11 @@ Once we’re done with the code, this unloads the built .so file. This cleans up the result; after calling this, it’s no longer valid to use the result, or any code or globals that were obtained by calling @ref{17,,gcc_jit_result_get_code()} or -@ref{ed,,gcc_jit_result_get_global()} on it. +@ref{f8,,gcc_jit_result_get_global()} on it. @end deffn @node Ahead-of-time compilation,,In-memory compilation,Compiling a context -@anchor{topics/compilation ahead-of-time-compilation}@anchor{11f} +@anchor{topics/compilation ahead-of-time-compilation}@anchor{12a} @subsection Ahead-of-time compilation @@ -8354,7 +8575,7 @@ can also be used for implementing more traditional ahead-of-time compilers, via the @ref{4a,,gcc_jit_context_compile_to_file()} API entrypoint. -For linking in object files, use @ref{74,,gcc_jit_context_add_driver_option()}. +For linking in object files, use @ref{76,,gcc_jit_context_add_driver_option()}. @geindex gcc_jit_context_compile_to_file (C function) @anchor{topics/compilation c gcc_jit_context_compile_to_file}@anchor{4a} @@ -8376,7 +8597,7 @@ suffix of the output file when determining what to do. @end cartouche @geindex gcc_jit_output_kind (C type) -@anchor{topics/compilation c gcc_jit_output_kind}@anchor{120} +@anchor{topics/compilation c gcc_jit_output_kind}@anchor{12b} @deffn {C Type} enum gcc_jit_output_kind @end deffn @@ -8394,7 +8615,7 @@ Typical suffix @item -@ref{121,,GCC_JIT_OUTPUT_KIND_ASSEMBLER} +@ref{12c,,GCC_JIT_OUTPUT_KIND_ASSEMBLER} @tab @@ -8402,7 +8623,7 @@ Typical suffix @item -@ref{122,,GCC_JIT_OUTPUT_KIND_OBJECT_FILE} +@ref{12d,,GCC_JIT_OUTPUT_KIND_OBJECT_FILE} @tab @@ -8410,7 +8631,7 @@ Typical suffix @item -@ref{123,,GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY} +@ref{12e,,GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY} @tab @@ -8418,7 +8639,7 @@ Typical suffix @item -@ref{124,,GCC_JIT_OUTPUT_KIND_EXECUTABLE} +@ref{12f,,GCC_JIT_OUTPUT_KIND_EXECUTABLE} @tab @@ -8428,28 +8649,28 @@ None, or .exe @geindex GCC_JIT_OUTPUT_KIND_ASSEMBLER (C macro) -@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_ASSEMBLER}@anchor{121} +@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_ASSEMBLER}@anchor{12c} @deffn {C Macro} GCC_JIT_OUTPUT_KIND_ASSEMBLER Compile the context to an assembler file. @end deffn @geindex GCC_JIT_OUTPUT_KIND_OBJECT_FILE (C macro) -@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_OBJECT_FILE}@anchor{122} +@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_OBJECT_FILE}@anchor{12d} @deffn {C Macro} GCC_JIT_OUTPUT_KIND_OBJECT_FILE Compile the context to an object file. @end deffn @geindex GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY (C macro) -@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}@anchor{123} +@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY}@anchor{12e} @deffn {C Macro} GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY Compile the context to a dynamic library. @end deffn @geindex GCC_JIT_OUTPUT_KIND_EXECUTABLE (C macro) -@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_EXECUTABLE}@anchor{124} +@anchor{topics/compilation c GCC_JIT_OUTPUT_KIND_EXECUTABLE}@anchor{12f} @deffn {C Macro} GCC_JIT_OUTPUT_KIND_EXECUTABLE Compile the context to an executable. @@ -8473,7 +8694,7 @@ Compile the context to an executable. @c <https://www.gnu.org/licenses/>. @node ABI and API compatibility,Performance,Compiling a context,Topic Reference -@anchor{topics/compatibility doc}@anchor{125}@anchor{topics/compatibility abi-and-api-compatibility}@anchor{126} +@anchor{topics/compatibility doc}@anchor{130}@anchor{topics/compatibility abi-and-api-compatibility}@anchor{131} @section ABI and API compatibility @@ -8495,7 +8716,7 @@ it. For ABI compatiblity, we avoid bumping the SONAME, and instead use symbol versioning to tag each symbol, so that a binary linked against libgccjit.so is tagged according to the symbols that it uses. -For example, @ref{72,,gcc_jit_context_add_command_line_option()} was added in +For example, @ref{74,,gcc_jit_context_add_command_line_option()} was added in @code{LIBGCCJIT_ABI_1}. If a client program uses it, this can be detected from metadata by using @code{objdump}: @@ -8529,21 +8750,21 @@ Version definitions: @end menu @node Programmatically checking version,ABI symbol tags,,ABI and API compatibility -@anchor{topics/compatibility programmatically-checking-version}@anchor{127} +@anchor{topics/compatibility programmatically-checking-version}@anchor{132} @subsection Programmatically checking version Client code can programmatically check libgccjit version using: @geindex gcc_jit_version_major (C function) -@anchor{topics/compatibility c gcc_jit_version_major}@anchor{128} +@anchor{topics/compatibility c gcc_jit_version_major}@anchor{133} @deffn {C Function} int gcc_jit_version_major (void) Return libgccjit major version. This is analogous to __GNUC__ in C code. @end deffn @geindex gcc_jit_version_minor (C function) -@anchor{topics/compatibility c gcc_jit_version_minor}@anchor{129} +@anchor{topics/compatibility c gcc_jit_version_minor}@anchor{134} @deffn {C Function} int gcc_jit_version_minor (void) Return libgccjit minor version. This is analogous to @@ -8551,7 +8772,7 @@ __GNUC_MINOR__ in C code. @end deffn @geindex gcc_jit_version_patchlevel (C function) -@anchor{topics/compatibility c gcc_jit_version_patchlevel}@anchor{12a} +@anchor{topics/compatibility c gcc_jit_version_patchlevel}@anchor{135} @deffn {C Function} int gcc_jit_version_patchlevel (void) Return libgccjit patchlevel version. This is analogous to @@ -8566,7 +8787,7 @@ These entry points has been added with @code{LIBGCCJIT_ABI_13} @end cartouche @node ABI symbol tags,,Programmatically checking version,ABI and API compatibility -@anchor{topics/compatibility abi-symbol-tags}@anchor{12b} +@anchor{topics/compatibility abi-symbol-tags}@anchor{136} @subsection ABI symbol tags @@ -8595,11 +8816,16 @@ Newer releases use the following tags. * LIBGCCJIT_ABI_17:: * LIBGCCJIT_ABI_18:: * LIBGCCJIT_ABI_19:: +* LIBGCCJIT_ABI_20:: +* LIBGCCJIT_ABI_21:: +* LIBGCCJIT_ABI_22:: +* LIBGCCJIT_ABI_23:: +* LIBGCCJIT_ABI_24:: @end menu @node LIBGCCJIT_ABI_0,LIBGCCJIT_ABI_1,,ABI symbol tags -@anchor{topics/compatibility id1}@anchor{12c}@anchor{topics/compatibility libgccjit-abi-0}@anchor{12d} +@anchor{topics/compatibility id1}@anchor{137}@anchor{topics/compatibility libgccjit-abi-0}@anchor{138} @subsubsection @code{LIBGCCJIT_ABI_0} @@ -8611,15 +8837,15 @@ continue to work, with this being handled transparently by the linker (see this post@footnote{https://gcc.gnu.org/ml/gcc-patches/2015-06/msg02126.html}) @node LIBGCCJIT_ABI_1,LIBGCCJIT_ABI_2,LIBGCCJIT_ABI_0,ABI symbol tags -@anchor{topics/compatibility id2}@anchor{12e}@anchor{topics/compatibility libgccjit-abi-1}@anchor{73} +@anchor{topics/compatibility id2}@anchor{139}@anchor{topics/compatibility libgccjit-abi-1}@anchor{75} @subsubsection @code{LIBGCCJIT_ABI_1} @code{LIBGCCJIT_ABI_1} covers the addition of -@ref{72,,gcc_jit_context_add_command_line_option()} +@ref{74,,gcc_jit_context_add_command_line_option()} @node LIBGCCJIT_ABI_2,LIBGCCJIT_ABI_3,LIBGCCJIT_ABI_1,ABI symbol tags -@anchor{topics/compatibility id3}@anchor{12f}@anchor{topics/compatibility libgccjit-abi-2}@anchor{6c} +@anchor{topics/compatibility id3}@anchor{13a}@anchor{topics/compatibility libgccjit-abi-2}@anchor{6c} @subsubsection @code{LIBGCCJIT_ABI_2} @@ -8627,7 +8853,7 @@ continue to work, with this being handled transparently by the linker @ref{6b,,gcc_jit_context_set_bool_allow_unreachable_blocks()} @node LIBGCCJIT_ABI_3,LIBGCCJIT_ABI_4,LIBGCCJIT_ABI_2,ABI symbol tags -@anchor{topics/compatibility id4}@anchor{130}@anchor{topics/compatibility libgccjit-abi-3}@anchor{114} +@anchor{topics/compatibility id4}@anchor{13b}@anchor{topics/compatibility libgccjit-abi-3}@anchor{11f} @subsubsection @code{LIBGCCJIT_ABI_3} @@ -8640,18 +8866,18 @@ entrypoints: @itemize * @item -@ref{111,,gcc_jit_block_end_with_switch()} +@ref{11c,,gcc_jit_block_end_with_switch()} @item -@ref{112,,gcc_jit_case_as_object()} +@ref{11d,,gcc_jit_case_as_object()} @item -@ref{113,,gcc_jit_context_new_case()} +@ref{11e,,gcc_jit_context_new_case()} @end itemize @end quotation @node LIBGCCJIT_ABI_4,LIBGCCJIT_ABI_5,LIBGCCJIT_ABI_3,ABI symbol tags -@anchor{topics/compatibility id5}@anchor{131}@anchor{topics/compatibility libgccjit-abi-4}@anchor{132} +@anchor{topics/compatibility id5}@anchor{13c}@anchor{topics/compatibility libgccjit-abi-4}@anchor{13d} @subsubsection @code{LIBGCCJIT_ABI_4} @@ -8664,30 +8890,30 @@ entrypoints: @itemize * @item -@ref{133,,gcc_jit_context_get_timer()} +@ref{13e,,gcc_jit_context_get_timer()} @item -@ref{134,,gcc_jit_context_set_timer()} +@ref{13f,,gcc_jit_context_set_timer()} @item -@ref{135,,gcc_jit_timer_new()} +@ref{140,,gcc_jit_timer_new()} @item -@ref{136,,gcc_jit_timer_release()} +@ref{141,,gcc_jit_timer_release()} @item -@ref{137,,gcc_jit_timer_push()} +@ref{142,,gcc_jit_timer_push()} @item -@ref{138,,gcc_jit_timer_pop()} +@ref{143,,gcc_jit_timer_pop()} @item -@ref{139,,gcc_jit_timer_print()} +@ref{144,,gcc_jit_timer_print()} @end itemize @end quotation @node LIBGCCJIT_ABI_5,LIBGCCJIT_ABI_6,LIBGCCJIT_ABI_4,ABI symbol tags -@anchor{topics/compatibility id6}@anchor{13a}@anchor{topics/compatibility libgccjit-abi-5}@anchor{6e} +@anchor{topics/compatibility id6}@anchor{145}@anchor{topics/compatibility libgccjit-abi-5}@anchor{6e} @subsubsection @code{LIBGCCJIT_ABI_5} @@ -8695,63 +8921,63 @@ entrypoints: @ref{6d,,gcc_jit_context_set_bool_use_external_driver()} @node LIBGCCJIT_ABI_6,LIBGCCJIT_ABI_7,LIBGCCJIT_ABI_5,ABI symbol tags -@anchor{topics/compatibility id7}@anchor{13b}@anchor{topics/compatibility libgccjit-abi-6}@anchor{d6} +@anchor{topics/compatibility id7}@anchor{146}@anchor{topics/compatibility libgccjit-abi-6}@anchor{db} @subsubsection @code{LIBGCCJIT_ABI_6} @code{LIBGCCJIT_ABI_6} covers the addition of -@ref{d5,,gcc_jit_rvalue_set_bool_require_tail_call()} +@ref{da,,gcc_jit_rvalue_set_bool_require_tail_call()} @node LIBGCCJIT_ABI_7,LIBGCCJIT_ABI_8,LIBGCCJIT_ABI_6,ABI symbol tags -@anchor{topics/compatibility id8}@anchor{13c}@anchor{topics/compatibility libgccjit-abi-7}@anchor{83} +@anchor{topics/compatibility id8}@anchor{147}@anchor{topics/compatibility libgccjit-abi-7}@anchor{85} @subsubsection @code{LIBGCCJIT_ABI_7} @code{LIBGCCJIT_ABI_7} covers the addition of -@ref{82,,gcc_jit_type_get_aligned()} +@ref{84,,gcc_jit_type_get_aligned()} @node LIBGCCJIT_ABI_8,LIBGCCJIT_ABI_9,LIBGCCJIT_ABI_7,ABI symbol tags -@anchor{topics/compatibility id9}@anchor{13d}@anchor{topics/compatibility libgccjit-abi-8}@anchor{86} +@anchor{topics/compatibility id9}@anchor{148}@anchor{topics/compatibility libgccjit-abi-8}@anchor{88} @subsubsection @code{LIBGCCJIT_ABI_8} @code{LIBGCCJIT_ABI_8} covers the addition of -@ref{85,,gcc_jit_type_get_vector()} +@ref{87,,gcc_jit_type_get_vector()} @node LIBGCCJIT_ABI_9,LIBGCCJIT_ABI_10,LIBGCCJIT_ABI_8,ABI symbol tags -@anchor{topics/compatibility id10}@anchor{13e}@anchor{topics/compatibility libgccjit-abi-9}@anchor{118} +@anchor{topics/compatibility id10}@anchor{149}@anchor{topics/compatibility libgccjit-abi-9}@anchor{123} @subsubsection @code{LIBGCCJIT_ABI_9} @code{LIBGCCJIT_ABI_9} covers the addition of -@ref{d8,,gcc_jit_function_get_address()} +@ref{dd,,gcc_jit_function_get_address()} @node LIBGCCJIT_ABI_10,LIBGCCJIT_ABI_11,LIBGCCJIT_ABI_9,ABI symbol tags -@anchor{topics/compatibility id11}@anchor{13f}@anchor{topics/compatibility libgccjit-abi-10}@anchor{b8} +@anchor{topics/compatibility id11}@anchor{14a}@anchor{topics/compatibility libgccjit-abi-10}@anchor{bd} @subsubsection @code{LIBGCCJIT_ABI_10} @code{LIBGCCJIT_ABI_10} covers the addition of -@ref{87,,gcc_jit_context_new_rvalue_from_vector()} +@ref{89,,gcc_jit_context_new_rvalue_from_vector()} @node LIBGCCJIT_ABI_11,LIBGCCJIT_ABI_12,LIBGCCJIT_ABI_10,ABI symbol tags -@anchor{topics/compatibility id12}@anchor{140}@anchor{topics/compatibility libgccjit-abi-11}@anchor{75} +@anchor{topics/compatibility id12}@anchor{14b}@anchor{topics/compatibility libgccjit-abi-11}@anchor{77} @subsubsection @code{LIBGCCJIT_ABI_11} @code{LIBGCCJIT_ABI_11} covers the addition of -@ref{74,,gcc_jit_context_add_driver_option()} +@ref{76,,gcc_jit_context_add_driver_option()} @node LIBGCCJIT_ABI_12,LIBGCCJIT_ABI_13,LIBGCCJIT_ABI_11,ABI symbol tags -@anchor{topics/compatibility id13}@anchor{141}@anchor{topics/compatibility libgccjit-abi-12}@anchor{8d} +@anchor{topics/compatibility id13}@anchor{14c}@anchor{topics/compatibility libgccjit-abi-12}@anchor{8f} @subsubsection @code{LIBGCCJIT_ABI_12} @code{LIBGCCJIT_ABI_12} covers the addition of -@ref{8c,,gcc_jit_context_new_bitfield()} +@ref{8e,,gcc_jit_context_new_bitfield()} @node LIBGCCJIT_ABI_13,LIBGCCJIT_ABI_14,LIBGCCJIT_ABI_12,ABI symbol tags -@anchor{topics/compatibility id14}@anchor{142}@anchor{topics/compatibility libgccjit-abi-13}@anchor{143} +@anchor{topics/compatibility id14}@anchor{14d}@anchor{topics/compatibility libgccjit-abi-13}@anchor{14e} @subsubsection @code{LIBGCCJIT_ABI_13} @@ -8764,26 +8990,26 @@ entrypoints: @itemize * @item -@ref{128,,gcc_jit_version_major()} +@ref{133,,gcc_jit_version_major()} @item -@ref{129,,gcc_jit_version_minor()} +@ref{134,,gcc_jit_version_minor()} @item -@ref{12a,,gcc_jit_version_patchlevel()} +@ref{135,,gcc_jit_version_patchlevel()} @end itemize @end quotation @node LIBGCCJIT_ABI_14,LIBGCCJIT_ABI_15,LIBGCCJIT_ABI_13,ABI symbol tags -@anchor{topics/compatibility id15}@anchor{144}@anchor{topics/compatibility libgccjit-abi-14}@anchor{f1} +@anchor{topics/compatibility id15}@anchor{14f}@anchor{topics/compatibility libgccjit-abi-14}@anchor{fc} @subsubsection @code{LIBGCCJIT_ABI_14} @code{LIBGCCJIT_ABI_14} covers the addition of -@ref{f0,,gcc_jit_global_set_initializer()} +@ref{fb,,gcc_jit_global_set_initializer()} @node LIBGCCJIT_ABI_15,LIBGCCJIT_ABI_16,LIBGCCJIT_ABI_14,ABI symbol tags -@anchor{topics/compatibility id16}@anchor{145}@anchor{topics/compatibility libgccjit-abi-15}@anchor{146} +@anchor{topics/compatibility id16}@anchor{150}@anchor{topics/compatibility libgccjit-abi-15}@anchor{151} @subsubsection @code{LIBGCCJIT_ABI_15} @@ -8796,36 +9022,36 @@ embedding assembler instructions: @itemize * @item -@ref{147,,gcc_jit_block_add_extended_asm()} +@ref{152,,gcc_jit_block_add_extended_asm()} @item -@ref{148,,gcc_jit_block_end_with_extended_asm_goto()} +@ref{153,,gcc_jit_block_end_with_extended_asm_goto()} @item -@ref{149,,gcc_jit_extended_asm_as_object()} +@ref{154,,gcc_jit_extended_asm_as_object()} @item -@ref{14a,,gcc_jit_extended_asm_set_volatile_flag()} +@ref{155,,gcc_jit_extended_asm_set_volatile_flag()} @item -@ref{14b,,gcc_jit_extended_asm_set_inline_flag()} +@ref{156,,gcc_jit_extended_asm_set_inline_flag()} @item -@ref{14c,,gcc_jit_extended_asm_add_output_operand()} +@ref{157,,gcc_jit_extended_asm_add_output_operand()} @item -@ref{14d,,gcc_jit_extended_asm_add_input_operand()} +@ref{158,,gcc_jit_extended_asm_add_input_operand()} @item -@ref{14e,,gcc_jit_extended_asm_add_clobber()} +@ref{159,,gcc_jit_extended_asm_add_clobber()} @item -@ref{14f,,gcc_jit_context_add_top_level_asm()} +@ref{15a,,gcc_jit_context_add_top_level_asm()} @end itemize @end quotation @node LIBGCCJIT_ABI_16,LIBGCCJIT_ABI_17,LIBGCCJIT_ABI_15,ABI symbol tags -@anchor{topics/compatibility id17}@anchor{150}@anchor{topics/compatibility libgccjit-abi-16}@anchor{a6} +@anchor{topics/compatibility id17}@anchor{15b}@anchor{topics/compatibility libgccjit-abi-16}@anchor{a8} @subsubsection @code{LIBGCCJIT_ABI_16} @@ -8838,60 +9064,60 @@ entrypoints: @itemize * @item -@ref{107,,gcc_jit_function_get_return_type()} +@ref{112,,gcc_jit_function_get_return_type()} @item -@ref{106,,gcc_jit_function_get_param_count()} +@ref{111,,gcc_jit_function_get_param_count()} @item -@ref{97,,gcc_jit_type_dyncast_array()} +@ref{99,,gcc_jit_type_dyncast_array()} @item -@ref{98,,gcc_jit_type_is_bool()} +@ref{9a,,gcc_jit_type_is_bool()} @item -@ref{9d,,gcc_jit_type_is_integral()} +@ref{9f,,gcc_jit_type_is_integral()} @item -@ref{9e,,gcc_jit_type_is_pointer()} +@ref{a0,,gcc_jit_type_is_pointer()} @item -@ref{a0,,gcc_jit_type_is_struct()} +@ref{a2,,gcc_jit_type_is_struct()} @item -@ref{9f,,gcc_jit_type_dyncast_vector()} +@ref{a1,,gcc_jit_type_dyncast_vector()} @item -@ref{a3,,gcc_jit_type_unqualified()} +@ref{a5,,gcc_jit_type_unqualified()} @item -@ref{99,,gcc_jit_type_dyncast_function_ptr_type()} +@ref{9b,,gcc_jit_type_dyncast_function_ptr_type()} @item -@ref{9a,,gcc_jit_function_type_get_return_type()} +@ref{9c,,gcc_jit_function_type_get_return_type()} @item -@ref{9b,,gcc_jit_function_type_get_param_count()} +@ref{9d,,gcc_jit_function_type_get_param_count()} @item -@ref{9c,,gcc_jit_function_type_get_param_type()} +@ref{9e,,gcc_jit_function_type_get_param_type()} @item -@ref{a1,,gcc_jit_vector_type_get_num_units()} +@ref{a3,,gcc_jit_vector_type_get_num_units()} @item -@ref{a2,,gcc_jit_vector_type_get_element_type()} +@ref{a4,,gcc_jit_vector_type_get_element_type()} @item -@ref{a4,,gcc_jit_struct_get_field()} +@ref{a6,,gcc_jit_struct_get_field()} @item -@ref{a5,,gcc_jit_struct_get_field_count()} +@ref{a7,,gcc_jit_struct_get_field_count()} @end itemize @end quotation @node LIBGCCJIT_ABI_17,LIBGCCJIT_ABI_18,LIBGCCJIT_ABI_16,ABI symbol tags -@anchor{topics/compatibility id18}@anchor{151}@anchor{topics/compatibility libgccjit-abi-17}@anchor{e6} +@anchor{topics/compatibility id18}@anchor{15c}@anchor{topics/compatibility libgccjit-abi-17}@anchor{ed} @subsubsection @code{LIBGCCJIT_ABI_17} @@ -8904,12 +9130,12 @@ thread-local storage model of a variable: @itemize * @item -@ref{df,,gcc_jit_lvalue_set_tls_model()} +@ref{e6,,gcc_jit_lvalue_set_tls_model()} @end itemize @end quotation @node LIBGCCJIT_ABI_18,LIBGCCJIT_ABI_19,LIBGCCJIT_ABI_17,ABI symbol tags -@anchor{topics/compatibility id19}@anchor{152}@anchor{topics/compatibility libgccjit-abi-18}@anchor{e8} +@anchor{topics/compatibility id19}@anchor{15d}@anchor{topics/compatibility libgccjit-abi-18}@anchor{ef} @subsubsection @code{LIBGCCJIT_ABI_18} @@ -8922,12 +9148,12 @@ section of a variable: @itemize * @item -@ref{e7,,gcc_jit_lvalue_set_link_section()} +@ref{ee,,gcc_jit_lvalue_set_link_section()} @end itemize @end quotation -@node LIBGCCJIT_ABI_19,,LIBGCCJIT_ABI_18,ABI symbol tags -@anchor{topics/compatibility id20}@anchor{153}@anchor{topics/compatibility libgccjit-abi-19}@anchor{b3} +@node LIBGCCJIT_ABI_19,LIBGCCJIT_ABI_20,LIBGCCJIT_ABI_18,ABI symbol tags +@anchor{topics/compatibility id20}@anchor{15e}@anchor{topics/compatibility libgccjit-abi-19}@anchor{b8} @subsubsection @code{LIBGCCJIT_ABI_19} @@ -8940,16 +9166,142 @@ of a global with an rvalue and to use constructors: @itemize * @item -@ref{b4,,gcc_jit_context_new_array_constructor()} +@ref{b9,,gcc_jit_context_new_array_constructor()} + +@item +@ref{ba,,gcc_jit_context_new_struct_constructor()} + +@item +@ref{bb,,gcc_jit_context_new_union_constructor()} + +@item +@ref{b7,,gcc_jit_global_set_initializer_rvalue()} +@end itemize +@end quotation + +@node LIBGCCJIT_ABI_20,LIBGCCJIT_ABI_21,LIBGCCJIT_ABI_19,ABI symbol tags +@anchor{topics/compatibility id21}@anchor{15f}@anchor{topics/compatibility libgccjit-abi-20}@anchor{ab} +@subsubsection @code{LIBGCCJIT_ABI_20} + + +@code{LIBGCCJIT_ABI_20} covers the addition of sized integer types, including +128-bit integers and helper functions for types: + +@quotation + + +@itemize * + +@item +@ref{aa,,gcc_jit_compatible_types()} + +@item +@ref{ac,,gcc_jit_type_get_size()} + +@item +@code{GCC_JIT_TYPE_UINT8_T} + +@item +@code{GCC_JIT_TYPE_UINT16_T} + +@item +@code{GCC_JIT_TYPE_UINT32_T} + +@item +@code{GCC_JIT_TYPE_UINT64_T} + +@item +@code{GCC_JIT_TYPE_UINT128_T} + +@item +@code{GCC_JIT_TYPE_INT8_T} + +@item +@code{GCC_JIT_TYPE_INT16_T} + +@item +@code{GCC_JIT_TYPE_INT32_T} + +@item +@code{GCC_JIT_TYPE_INT64_T} + +@item +@code{GCC_JIT_TYPE_INT128_T} +@end itemize +@end quotation + +@node LIBGCCJIT_ABI_21,LIBGCCJIT_ABI_22,LIBGCCJIT_ABI_20,ABI symbol tags +@anchor{topics/compatibility id22}@anchor{160}@anchor{topics/compatibility libgccjit-abi-21}@anchor{e1} +@subsubsection @code{LIBGCCJIT_ABI_21} + + +@code{LIBGCCJIT_ABI_21} covers the addition of an API entrypoint to bitcast a +value from one type to another: + +@quotation + + +@itemize * + +@item +@ref{e0,,gcc_jit_context_new_bitcast()} +@end itemize +@end quotation + +@node LIBGCCJIT_ABI_22,LIBGCCJIT_ABI_23,LIBGCCJIT_ABI_21,ABI symbol tags +@anchor{topics/compatibility id23}@anchor{161}@anchor{topics/compatibility libgccjit-abi-22}@anchor{f0} +@subsubsection @code{LIBGCCJIT_ABI_22} + + +@code{LIBGCCJIT_ABI_22} covers the addition of an API entrypoint to set the +register name of a variable: + +@quotation + + +@itemize * + +@item +@code{gcc_jit_lvalue_set_register_name()} +@end itemize +@end quotation + +@node LIBGCCJIT_ABI_23,LIBGCCJIT_ABI_24,LIBGCCJIT_ABI_22,ABI symbol tags +@anchor{topics/compatibility id24}@anchor{162}@anchor{topics/compatibility libgccjit-abi-23}@anchor{70} +@subsubsection @code{LIBGCCJIT_ABI_23} + + +@code{LIBGCCJIT_ABI_23} covers the addition of an API entrypoint to hide stderr +logs: + +@quotation + + +@itemize * @item -@ref{b5,,gcc_jit_context_new_struct_constructor()} +@ref{6f,,gcc_jit_context_set_bool_print_errors_to_stderr()} +@end itemize +@end quotation + +@node LIBGCCJIT_ABI_24,,LIBGCCJIT_ABI_23,ABI symbol tags +@anchor{topics/compatibility id25}@anchor{163}@anchor{topics/compatibility libgccjit-abi-24}@anchor{f2} +@subsubsection @code{LIBGCCJIT_ABI_24} + + +@code{LIBGCCJIT_ABI_24} covers the addition of functions to get and set the +alignment of a variable: + +@quotation + + +@itemize * @item -@ref{b6,,gcc_jit_context_new_union_constructor()} +@ref{f1,,gcc_jit_lvalue_set_alignment()} @item -@ref{b2,,gcc_jit_global_set_initializer_rvalue()} +@ref{f3,,gcc_jit_lvalue_get_alignment()} @end itemize @end quotation @@ -8971,7 +9323,7 @@ of a global with an rvalue and to use constructors: @c <https://www.gnu.org/licenses/>. @node Performance,Using Assembly Language with libgccjit,ABI and API compatibility,Topic Reference -@anchor{topics/performance doc}@anchor{154}@anchor{topics/performance performance}@anchor{155} +@anchor{topics/performance doc}@anchor{164}@anchor{topics/performance performance}@anchor{165} @section Performance @@ -8981,14 +9333,14 @@ of a global with an rvalue and to use constructors: @end menu @node The timing API,,,Performance -@anchor{topics/performance the-timing-api}@anchor{156} +@anchor{topics/performance the-timing-api}@anchor{166} @subsection The timing API As of GCC 6, libgccjit exposes a timing API, for printing reports on how long was spent in different parts of code. -You can create a @ref{157,,gcc_jit_timer} instance, which will +You can create a @ref{167,,gcc_jit_timer} instance, which will measure time spent since its creation. The timer maintains a stack of “timer items”: as control flow moves through your code, you can push and pop named items relating to your code onto the stack, and the timer @@ -9086,7 +9438,7 @@ Client items: The exact format is intended to be human-readable, and is subject to change. @geindex LIBGCCJIT_HAVE_TIMING_API (C macro) -@anchor{topics/performance c LIBGCCJIT_HAVE_TIMING_API}@anchor{158} +@anchor{topics/performance c LIBGCCJIT_HAVE_TIMING_API}@anchor{168} @deffn {C Macro} LIBGCCJIT_HAVE_TIMING_API The timer API was added to libgccjit in GCC 6. @@ -9103,21 +9455,21 @@ gcc_jit_context_set_timer (ctxt, t); @end deffn @geindex gcc_jit_timer (C type) -@anchor{topics/performance c gcc_jit_timer}@anchor{157} +@anchor{topics/performance c gcc_jit_timer}@anchor{167} @deffn {C Type} gcc_jit_timer @end deffn @geindex gcc_jit_timer_new (C function) -@anchor{topics/performance c gcc_jit_timer_new}@anchor{135} +@anchor{topics/performance c gcc_jit_timer_new}@anchor{140} @deffn {C Function} gcc_jit_timer * gcc_jit_timer_new (void) -Create a @ref{157,,gcc_jit_timer} instance, and start timing: +Create a @ref{167,,gcc_jit_timer} instance, and start timing: @example gcc_jit_timer *t = gcc_jit_timer_new (); @end example -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9126,10 +9478,10 @@ for its presence using @end deffn @geindex gcc_jit_timer_release (C function) -@anchor{topics/performance c gcc_jit_timer_release}@anchor{136} +@anchor{topics/performance c gcc_jit_timer_release}@anchor{141} @deffn {C Function} void gcc_jit_timer_release (gcc_jit_timer@w{ }*timer) -Release a @ref{157,,gcc_jit_timer} instance: +Release a @ref{167,,gcc_jit_timer} instance: @example gcc_jit_timer_release (t); @@ -9137,7 +9489,7 @@ gcc_jit_timer_release (t); This should be called exactly once on a timer. -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9146,10 +9498,10 @@ for its presence using @end deffn @geindex gcc_jit_context_set_timer (C function) -@anchor{topics/performance c gcc_jit_context_set_timer}@anchor{134} +@anchor{topics/performance c gcc_jit_context_set_timer}@anchor{13f} @deffn {C Function} void gcc_jit_context_set_timer (gcc_jit_context@w{ }*ctxt, gcc_jit_timer@w{ }*timer) -Associate a @ref{157,,gcc_jit_timer} instance with a context: +Associate a @ref{167,,gcc_jit_timer} instance with a context: @example gcc_jit_context_set_timer (ctxt, t); @@ -9162,7 +9514,7 @@ Timers have no locking, so if you have a multithreaded program, you must provide your own locks if more than one thread could be working with the same timer via timer-associated contexts. -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9171,12 +9523,12 @@ for its presence using @end deffn @geindex gcc_jit_context_get_timer (C function) -@anchor{topics/performance c gcc_jit_context_get_timer}@anchor{133} +@anchor{topics/performance c gcc_jit_context_get_timer}@anchor{13e} @deffn {C Function} gcc_jit_timer *gcc_jit_context_get_timer (gcc_jit_context@w{ }*ctxt) Get the timer associated with a context (if any). -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9185,7 +9537,7 @@ for its presence using @end deffn @geindex gcc_jit_timer_push (C function) -@anchor{topics/performance c gcc_jit_timer_push}@anchor{137} +@anchor{topics/performance c gcc_jit_timer_push}@anchor{142} @deffn {C Function} void gcc_jit_timer_push (gcc_jit_timer@w{ }*timer, const char@w{ }*item_name) Push the given item onto the timer’s stack: @@ -9196,7 +9548,7 @@ run_the_code (ctxt, result); gcc_jit_timer_pop (t, "running code"); @end example -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9205,7 +9557,7 @@ for its presence using @end deffn @geindex gcc_jit_timer_pop (C function) -@anchor{topics/performance c gcc_jit_timer_pop}@anchor{138} +@anchor{topics/performance c gcc_jit_timer_pop}@anchor{143} @deffn {C Function} void gcc_jit_timer_pop (gcc_jit_timer@w{ }*timer, const char@w{ }*item_name) Pop the top item from the timer’s stack. @@ -9213,7 +9565,7 @@ Pop the top item from the timer’s stack. If “item_name” is provided, it must match that of the top item. Alternatively, @code{NULL} can be passed in, to suppress checking. -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9222,13 +9574,13 @@ for its presence using @end deffn @geindex gcc_jit_timer_print (C function) -@anchor{topics/performance c gcc_jit_timer_print}@anchor{139} +@anchor{topics/performance c gcc_jit_timer_print}@anchor{144} @deffn {C Function} void gcc_jit_timer_print (gcc_jit_timer@w{ }*timer, FILE@w{ }*f_out) Print timing information to the given stream about activity since the timer was started. -This API entrypoint was added in @ref{132,,LIBGCCJIT_ABI_4}; you can test +This API entrypoint was added in @ref{13d,,LIBGCCJIT_ABI_4}; you can test for its presence using @example @@ -9254,7 +9606,7 @@ for its presence using @c <https://www.gnu.org/licenses/>. @node Using Assembly Language with libgccjit,,Performance,Topic Reference -@anchor{topics/asm doc}@anchor{159}@anchor{topics/asm using-assembly-language-with-libgccjit}@anchor{15a} +@anchor{topics/asm doc}@anchor{169}@anchor{topics/asm using-assembly-language-with-libgccjit}@anchor{16a} @section Using Assembly Language with libgccjit @@ -9264,7 +9616,7 @@ following assumes a familiarity with that functionality. See How to Use Inline Assembly Language in C Code@footnote{https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html} in GCC’s documentation, the “Extended Asm” section in particular. -These entrypoints were added in @ref{146,,LIBGCCJIT_ABI_15}; you can test +These entrypoints were added in @ref{151,,LIBGCCJIT_ABI_15}; you can test for their presence using @quotation @@ -9281,12 +9633,12 @@ for their presence using @end menu @node Adding assembler instructions within a function,Adding top-level assembler statements,,Using Assembly Language with libgccjit -@anchor{topics/asm adding-assembler-instructions-within-a-function}@anchor{15b} +@anchor{topics/asm adding-assembler-instructions-within-a-function}@anchor{16b} @subsection Adding assembler instructions within a function @geindex gcc_jit_extended_asm (C type) -@anchor{topics/asm c gcc_jit_extended_asm}@anchor{115} +@anchor{topics/asm c gcc_jit_extended_asm}@anchor{120} @deffn {C Type} gcc_jit_extended_asm A @cite{gcc_jit_extended_asm} represents an extended @code{asm} statement: a @@ -9295,21 +9647,21 @@ to outputs. To avoid having an API entrypoint with a very large number of parameters, an extended @code{asm} statement is made in stages: -an initial call to create the @ref{115,,gcc_jit_extended_asm}, +an initial call to create the @ref{120,,gcc_jit_extended_asm}, followed by calls to add operands and set other properties of the statement. -There are two API entrypoints for creating a @ref{115,,gcc_jit_extended_asm}: +There are two API entrypoints for creating a @ref{120,,gcc_jit_extended_asm}: @itemize * @item -@ref{147,,gcc_jit_block_add_extended_asm()} for an @code{asm} statement with +@ref{152,,gcc_jit_block_add_extended_asm()} for an @code{asm} statement with no control flow, and @item -@ref{148,,gcc_jit_block_end_with_extended_asm_goto()} for an @code{asm goto}. +@ref{153,,gcc_jit_block_end_with_extended_asm_goto()} for an @code{asm goto}. @end itemize For example, to create the equivalent of: @@ -9340,8 +9692,8 @@ extended @code{asm} statement (e.g. the @code{%0} and @code{%1} above), the equivalent to the C syntax is followed i.e. all output operands, then all input operands, regardless of what order the calls to -@ref{14c,,gcc_jit_extended_asm_add_output_operand()} and -@ref{14d,,gcc_jit_extended_asm_add_input_operand()} were made in. +@ref{157,,gcc_jit_extended_asm_add_output_operand()} and +@ref{158,,gcc_jit_extended_asm_add_input_operand()} were made in. @end quotation @end cartouche @@ -9369,10 +9721,10 @@ the following API calls could be used: @end deffn @geindex gcc_jit_block_add_extended_asm (C function) -@anchor{topics/asm c gcc_jit_block_add_extended_asm}@anchor{147} +@anchor{topics/asm c gcc_jit_block_add_extended_asm}@anchor{152} @deffn {C Function} gcc_jit_extended_asm * gcc_jit_block_add_extended_asm (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, const char@w{ }*asm_template) -Create a @ref{115,,gcc_jit_extended_asm} for an extended @code{asm} statement +Create a @ref{120,,gcc_jit_extended_asm} for an extended @code{asm} statement with no control flow (i.e. without the @code{goto} qualifier). The parameter @code{asm_template} corresponds to the @cite{AssemblerTemplate} @@ -9382,10 +9734,10 @@ an on-stack buffer. @end deffn @geindex gcc_jit_block_end_with_extended_asm_goto (C function) -@anchor{topics/asm c gcc_jit_block_end_with_extended_asm_goto}@anchor{148} +@anchor{topics/asm c gcc_jit_block_end_with_extended_asm_goto}@anchor{153} @deffn {C Function} gcc_jit_extended_asm * gcc_jit_block_end_with_extended_asm_goto (gcc_jit_block@w{ }*block, gcc_jit_location@w{ }*loc, const char@w{ }*asm_template, int@w{ }num_goto_blocks, gcc_jit_block@w{ }**goto_blocks, gcc_jit_block@w{ }*fallthrough_block) -Create a @ref{115,,gcc_jit_extended_asm} for an extended @code{asm} statement +Create a @ref{120,,gcc_jit_extended_asm} for an extended @code{asm} statement that may perform jumps, and use it to terminate the given block. This is equivalent to the @code{goto} qualifier in C’s extended @code{asm} syntax. @@ -9448,10 +9800,10 @@ would have happened in the C case. @end deffn @geindex gcc_jit_extended_asm_set_volatile_flag (C function) -@anchor{topics/asm c gcc_jit_extended_asm_set_volatile_flag}@anchor{14a} +@anchor{topics/asm c gcc_jit_extended_asm_set_volatile_flag}@anchor{155} @deffn {C Function} void gcc_jit_extended_asm_set_volatile_flag (gcc_jit_extended_asm@w{ }*ext_asm, int@w{ }flag) -Set whether the @ref{115,,gcc_jit_extended_asm} has side-effects, equivalent to the +Set whether the @ref{120,,gcc_jit_extended_asm} has side-effects, equivalent to the volatile@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Volatile} qualifier in C’s extended asm syntax. @@ -9480,11 +9832,11 @@ the following API calls could be used: gcc_jit_extended_asm_add_clobber (ext_asm, "rdx"); @end example -where the @ref{115,,gcc_jit_extended_asm} is flagged as volatile. +where the @ref{120,,gcc_jit_extended_asm} is flagged as volatile. @end deffn @geindex gcc_jit_extended_asm_set_inline_flag (C function) -@anchor{topics/asm c gcc_jit_extended_asm_set_inline_flag}@anchor{14b} +@anchor{topics/asm c gcc_jit_extended_asm_set_inline_flag}@anchor{156} @deffn {C Function} void gcc_jit_extended_asm_set_inline_flag (gcc_jit_extended_asm@w{ }*ext_asm, int@w{ }flag) Set the equivalent of the @@ -9493,7 +9845,7 @@ qualifier in C’s extended @code{asm} syntax. @end deffn @geindex gcc_jit_extended_asm_add_output_operand (C function) -@anchor{topics/asm c gcc_jit_extended_asm_add_output_operand}@anchor{14c} +@anchor{topics/asm c gcc_jit_extended_asm_add_output_operand}@anchor{157} @deffn {C Function} void gcc_jit_extended_asm_add_output_operand (gcc_jit_extended_asm@w{ }*ext_asm, const char@w{ }*asm_symbolic_name, const char@w{ }*constraint, gcc_jit_lvalue@w{ }*dest) Add an output operand to the extended @code{asm} statement. See the @@ -9527,7 +9879,7 @@ section of GCC’s “Extended Asm” documentation. @end deffn @geindex gcc_jit_extended_asm_add_input_operand (C function) -@anchor{topics/asm c gcc_jit_extended_asm_add_input_operand}@anchor{14d} +@anchor{topics/asm c gcc_jit_extended_asm_add_input_operand}@anchor{158} @deffn {C Function} void gcc_jit_extended_asm_add_input_operand (gcc_jit_extended_asm@w{ }*ext_asm, const char@w{ }*asm_symbolic_name, const char@w{ }*constraint, gcc_jit_rvalue@w{ }*src) Add an input operand to the extended @code{asm} statement. See the @@ -9558,7 +9910,7 @@ gcc_jit_extended_asm_add_input_operand (ext_asm, "aMask", "r", @end deffn @geindex gcc_jit_extended_asm_add_clobber (C function) -@anchor{topics/asm c gcc_jit_extended_asm_add_clobber}@anchor{14e} +@anchor{topics/asm c gcc_jit_extended_asm_add_clobber}@anchor{159} @deffn {C Function} void gcc_jit_extended_asm_add_clobber (gcc_jit_extended_asm@w{ }*ext_asm, const char@w{ }*victim) Add @cite{victim} to the list of registers clobbered by the extended @code{asm} @@ -9578,18 +9930,18 @@ gcc_jit_extended_asm_add_clobber (ext_asm, "memory"); @end example @end deffn -A @ref{115,,gcc_jit_extended_asm} is a @ref{e,,gcc_jit_object} “owned” by +A @ref{120,,gcc_jit_extended_asm} is a @ref{e,,gcc_jit_object} “owned” by the block’s context. The following upcast is available: @geindex gcc_jit_extended_asm_as_object (C function) -@anchor{topics/asm c gcc_jit_extended_asm_as_object}@anchor{149} +@anchor{topics/asm c gcc_jit_extended_asm_as_object}@anchor{154} @deffn {C Function} gcc_jit_object * gcc_jit_extended_asm_as_object (gcc_jit_extended_asm@w{ }*ext_asm) Upcast from extended @code{asm} to object. @end deffn @node Adding top-level assembler statements,,Adding assembler instructions within a function,Using Assembly Language with libgccjit -@anchor{topics/asm adding-top-level-assembler-statements}@anchor{15c} +@anchor{topics/asm adding-top-level-assembler-statements}@anchor{16c} @subsection Adding top-level assembler statements @@ -9598,7 +9950,7 @@ there is support for creating “top-level” assembler statements, outside of any function. @geindex gcc_jit_context_add_top_level_asm (C function) -@anchor{topics/asm c gcc_jit_context_add_top_level_asm}@anchor{14f} +@anchor{topics/asm c gcc_jit_context_add_top_level_asm}@anchor{15a} @deffn {C Function} void gcc_jit_context_add_top_level_asm (gcc_jit_context@w{ }*ctxt, gcc_jit_location@w{ }*loc, const char@w{ }*asm_stmts) Create a set of top-level asm statements, analogous to those created @@ -9651,7 +10003,7 @@ the following API calls could be used: @c <https://www.gnu.org/licenses/>. @node C++ bindings for libgccjit,Internals,Topic Reference,Top -@anchor{cp/index doc}@anchor{15d}@anchor{cp/index c-bindings-for-libgccjit}@anchor{15e} +@anchor{cp/index doc}@anchor{16d}@anchor{cp/index c-bindings-for-libgccjit}@anchor{16e} @chapter C++ bindings for libgccjit @@ -9691,7 +10043,7 @@ Contents: @end menu @node Tutorial<2>,Topic Reference<2>,,C++ bindings for libgccjit -@anchor{cp/intro/index doc}@anchor{15f}@anchor{cp/intro/index tutorial}@anchor{160} +@anchor{cp/intro/index doc}@anchor{16f}@anchor{cp/intro/index tutorial}@anchor{170} @section Tutorial @@ -9721,7 +10073,7 @@ Contents: @end menu @node Tutorial part 1 “Hello world”<2>,Tutorial part 2 Creating a trivial machine code function<2>,,Tutorial<2> -@anchor{cp/intro/tutorial01 doc}@anchor{161}@anchor{cp/intro/tutorial01 tutorial-part-1-hello-world}@anchor{162} +@anchor{cp/intro/tutorial01 doc}@anchor{171}@anchor{cp/intro/tutorial01 tutorial-part-1-hello-world}@anchor{172} @subsection Tutorial part 1: “Hello world” @@ -9884,7 +10236,7 @@ hello world @c <https://www.gnu.org/licenses/>. @node Tutorial part 2 Creating a trivial machine code function<2>,Tutorial part 3 Loops and variables<2>,Tutorial part 1 “Hello world”<2>,Tutorial<2> -@anchor{cp/intro/tutorial02 doc}@anchor{163}@anchor{cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function}@anchor{164} +@anchor{cp/intro/tutorial02 doc}@anchor{173}@anchor{cp/intro/tutorial02 tutorial-part-2-creating-a-trivial-machine-code-function}@anchor{174} @subsection Tutorial part 2: Creating a trivial machine code function @@ -9906,10 +10258,10 @@ First we need to include the relevant header: @end example All state associated with compilation is associated with a -@ref{165,,gccjit;;context}, which is a thin C++ wrapper around the C API’s +@ref{175,,gccjit;;context}, which is a thin C++ wrapper around the C API’s @ref{8,,gcc_jit_context *}. -Create one using @ref{166,,gccjit;;context;;acquire()}: +Create one using @ref{176,,gccjit;;context;;acquire()}: @example gccjit::context ctxt; @@ -9919,19 +10271,19 @@ ctxt = gccjit::context::acquire (); The JIT library has a system of types. It is statically-typed: every expression is of a specific type, fixed at compile-time. In our example, all of the expressions are of the C @cite{int} type, so let’s obtain this from -the context, as a @ref{167,,gccjit;;type}, using -@ref{168,,gccjit;;context;;get_type()}: +the context, as a @ref{177,,gccjit;;type}, using +@ref{178,,gccjit;;context;;get_type()}: @example gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT); @end example -@ref{167,,gccjit;;type} is an example of a “contextual” object: every -entity in the API is associated with a @ref{165,,gccjit;;context}. +@ref{177,,gccjit;;type} is an example of a “contextual” object: every +entity in the API is associated with a @ref{175,,gccjit;;context}. Memory management is easy: all such “contextual” objects are automatically cleaned up for you when the context is released, using -@ref{169,,gccjit;;context;;release()}: +@ref{179,,gccjit;;context;;release()}: @example ctxt.release (); @@ -9958,9 +10310,9 @@ The C++ class hierarchy within the @code{gccjit} namespace looks like this: +- param @end example -One thing you can do with a @ref{16a,,gccjit;;object} is +One thing you can do with a @ref{17a,,gccjit;;object} is to ask it for a human-readable description as a @code{std::string}, using -@ref{16b,,gccjit;;object;;get_debug_string()}: +@ref{17b,,gccjit;;object;;get_debug_string()}: @example printf ("obj: %s\n", obj.get_debug_string ().c_str ()); @@ -9976,7 +10328,7 @@ This is invaluable when debugging. Let’s create the function. To do so, we first need to construct its single parameter, specifying its type and giving it a name, -using @ref{16c,,gccjit;;context;;new_param()}: +using @ref{17c,,gccjit;;context;;new_param()}: @example gccjit::param param_i = ctxt.new_param (int_type, "i"); @@ -10017,7 +10369,7 @@ gccjit::block block = func.new_block (); Our basic block is relatively simple: it immediately terminates by returning the value of an expression. -We can build the expression using @ref{16d,,gccjit;;context;;new_binary_op()}: +We can build the expression using @ref{17d,,gccjit;;context;;new_binary_op()}: @example gccjit::rvalue expr = @@ -10026,9 +10378,9 @@ gccjit::rvalue expr = param_i, param_i); @end example -A @ref{16e,,gccjit;;rvalue} is another example of a -@ref{16a,,gccjit;;object} subclass. As before, we can print it with -@ref{16b,,gccjit;;object;;get_debug_string()}. +A @ref{17e,,gccjit;;rvalue} is another example of a +@ref{17a,,gccjit;;object} subclass. As before, we can print it with +@ref{17b,,gccjit;;object;;get_debug_string()}. @example printf ("expr: %s\n", expr.get_debug_string ().c_str ()); @@ -10040,7 +10392,7 @@ giving this output: expr: i * i @end example -Note that @ref{16e,,gccjit;;rvalue} provides numerous overloaded operators +Note that @ref{17e,,gccjit;;rvalue} provides numerous overloaded operators which can be used to dramatically reduce the amount of typing needed. We can build the above binary operation more directly with this one-liner: @@ -10057,7 +10409,7 @@ block.end_with_return (expr); @end example OK, we’ve populated the context. We can now compile it using -@ref{16f,,gccjit;;context;;compile()}: +@ref{17f,,gccjit;;context;;compile()}: @example gcc_jit_result *result; @@ -10099,12 +10451,12 @@ result: 25 @end menu @node Options<3>,Full example<3>,,Tutorial part 2 Creating a trivial machine code function<2> -@anchor{cp/intro/tutorial02 options}@anchor{170} +@anchor{cp/intro/tutorial02 options}@anchor{180} @subsubsection Options To get more information on what’s going on, you can set debugging flags -on the context using @ref{171,,gccjit;;context;;set_bool_option()}. +on the context using @ref{181,,gccjit;;context;;set_bool_option()}. @c (I'm deliberately not mentioning @c :c:macro:`GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE` here since I think @@ -10168,7 +10520,7 @@ square: By default, no optimizations are performed, the equivalent of GCC’s @cite{-O0} option. We can turn things up to e.g. @cite{-O3} by calling -@ref{172,,gccjit;;context;;set_int_option()} with +@ref{182,,gccjit;;context;;set_int_option()} with @ref{1f,,GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL}: @example @@ -10198,7 +10550,7 @@ square: Naturally this has only a small effect on such a trivial function. @node Full example<3>,,Options<3>,Tutorial part 2 Creating a trivial machine code function<2> -@anchor{cp/intro/tutorial02 full-example}@anchor{173} +@anchor{cp/intro/tutorial02 full-example}@anchor{183} @subsubsection Full example @@ -10336,7 +10688,7 @@ result: 25 @c <https://www.gnu.org/licenses/>. @node Tutorial part 3 Loops and variables<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>,Tutorial part 2 Creating a trivial machine code function<2>,Tutorial<2> -@anchor{cp/intro/tutorial03 doc}@anchor{174}@anchor{cp/intro/tutorial03 tutorial-part-3-loops-and-variables}@anchor{175} +@anchor{cp/intro/tutorial03 doc}@anchor{184}@anchor{cp/intro/tutorial03 tutorial-part-3-loops-and-variables}@anchor{185} @subsection Tutorial part 3: Loops and variables @@ -10392,7 +10744,7 @@ Here’s what the final control flow graph will look like: @end quotation As before, we include the libgccjit++ header and make a -@ref{165,,gccjit;;context}. +@ref{175,,gccjit;;context}. @example #include <libgccjit++.h> @@ -10446,18 +10798,18 @@ gccjit::function func = @end menu @node Expressions lvalues and rvalues<2>,Control flow<2>,,Tutorial part 3 Loops and variables<2> -@anchor{cp/intro/tutorial03 expressions-lvalues-and-rvalues}@anchor{176} +@anchor{cp/intro/tutorial03 expressions-lvalues-and-rvalues}@anchor{186} @subsubsection Expressions: lvalues and rvalues -The base class of expression is the @ref{16e,,gccjit;;rvalue}, +The base class of expression is the @ref{17e,,gccjit;;rvalue}, representing an expression that can be on the @emph{right}-hand side of an assignment: a value that can be computed somehow, and assigned @emph{to} a storage area (such as a variable). It has a specific -@ref{167,,gccjit;;type}. +@ref{177,,gccjit;;type}. -Anothe important class is @ref{177,,gccjit;;lvalue}. -A @ref{177,,gccjit;;lvalue}. is something that can of the @emph{left}-hand +Anothe important class is @ref{187,,gccjit;;lvalue}. +A @ref{187,,gccjit;;lvalue}. is something that can of the @emph{left}-hand side of an assignment: a storage area (such as a variable). In other words, every assignment can be thought of as: @@ -10466,8 +10818,8 @@ In other words, every assignment can be thought of as: LVALUE = RVALUE; @end example -Note that @ref{177,,gccjit;;lvalue} is a subclass of -@ref{16e,,gccjit;;rvalue}, where in an assignment of the form: +Note that @ref{187,,gccjit;;lvalue} is a subclass of +@ref{17e,,gccjit;;rvalue}, where in an assignment of the form: @example LVALUE_A = LVALUE_B; @@ -10497,7 +10849,7 @@ gccjit::rvalue expr = gccjit::rvalue expr = param_i * param_i; @end example -which is a @ref{16e,,gccjit;;rvalue}, and +which is a @ref{17e,,gccjit;;rvalue}, and @end quotation @@ -10505,15 +10857,15 @@ which is a @ref{16e,,gccjit;;rvalue}, and @item the various function parameters: @cite{param_i} and @cite{param_n}, instances of -@ref{178,,gccjit;;param}, which is a subclass of @ref{177,,gccjit;;lvalue} -(and, in turn, of @ref{16e,,gccjit;;rvalue}): +@ref{188,,gccjit;;param}, which is a subclass of @ref{187,,gccjit;;lvalue} +(and, in turn, of @ref{17e,,gccjit;;rvalue}): we can both read from and write to function parameters within the body of a function. @end enumerate Our new example has a new kind of expression: we have two local variables. We create them by calling -@ref{179,,gccjit;;function;;new_local()}, supplying a type and a name: +@ref{189,,gccjit;;function;;new_local()}, supplying a type and a name: @example /* Build locals: */ @@ -10521,7 +10873,7 @@ gccjit::lvalue i = func.new_local (the_type, "i"); gccjit::lvalue sum = func.new_local (the_type, "sum"); @end example -These are instances of @ref{177,,gccjit;;lvalue} - they can be read from +These are instances of @ref{187,,gccjit;;lvalue} - they can be read from and written to. Note that there is no precanned way to create @emph{and} initialize a variable @@ -10535,7 +10887,7 @@ Instead, having added the local to the function, we have to separately add an assignment of @cite{0} to @cite{local_i} at the beginning of the function. @node Control flow<2>,Visualizing the control flow graph<2>,Expressions lvalues and rvalues<2>,Tutorial part 3 Loops and variables<2> -@anchor{cp/intro/tutorial03 control-flow}@anchor{17a} +@anchor{cp/intro/tutorial03 control-flow}@anchor{18a} @subsubsection Control flow @@ -10558,8 +10910,8 @@ the body of the loop after the loop terminates (@cite{return sum}) @end enumerate -so we create these as @ref{17b,,gccjit;;block} instances within the -@ref{17c,,gccjit;;function}: +so we create these as @ref{18b,,gccjit;;block} instances within the +@ref{18c,,gccjit;;function}: @example gccjit::block b_initial = func.new_block ("initial"); @@ -10572,8 +10924,8 @@ We now populate each block with statements. The entry block @cite{b_initial} consists of initializations followed by a jump to the conditional. We assign @cite{0} to @cite{i} and to @cite{sum}, using -@ref{17d,,gccjit;;block;;add_assignment()} to add -an assignment statement, and using @ref{17e,,gccjit;;context;;zero()} to get +@ref{18d,,gccjit;;block;;add_assignment()} to add +an assignment statement, and using @ref{18e,,gccjit;;context;;zero()} to get the constant value @cite{0} for the relevant type for the right-hand side of the assignment: @@ -10594,9 +10946,9 @@ b_initial.end_with_jump (b_loop_cond); The conditional block is equivalent to the line @cite{while (i < n)} from our C example. It contains a single statement: a conditional, which jumps to one of two destination blocks depending on a boolean -@ref{16e,,gccjit;;rvalue}, in this case the comparison of @cite{i} and @cite{n}. +@ref{17e,,gccjit;;rvalue}, in this case the comparison of @cite{i} and @cite{n}. -We could build the comparison using @ref{17f,,gccjit;;context;;new_comparison()}: +We could build the comparison using @ref{18f,,gccjit;;context;;new_comparison()}: @example gccjit::rvalue guard = @@ -10605,7 +10957,7 @@ gccjit::rvalue guard = @end example and can then use this to add @cite{b_loop_cond}’s sole statement, via -@ref{180,,gccjit;;block;;end_with_conditional()}: +@ref{190,,gccjit;;block;;end_with_conditional()}: @example b_loop_cond.end_with_conditional (guard, @@ -10613,7 +10965,7 @@ b_loop_cond.end_with_conditional (guard, b_loop_body); // on_false @end example -However @ref{16e,,gccjit;;rvalue} has overloaded operators for this, so we +However @ref{17e,,gccjit;;rvalue} has overloaded operators for this, so we express the conditional as @example @@ -10633,7 +10985,7 @@ Next, we populate the body of the loop. The C statement @cite{sum += i * i;} is an assignment operation, where an lvalue is modified “in-place”. We use -@ref{181,,gccjit;;block;;add_assignment_op()} to handle these operations: +@ref{191,,gccjit;;block;;add_assignment_op()} to handle these operations: @example /* sum += i * i */ @@ -10657,7 +11009,7 @@ b_loop_body.add_assignment_op (i, @cartouche @quotation Note For numeric constants other than 0 or 1, we could use -@ref{182,,gccjit;;context;;new_rvalue()}, which has overloads +@ref{192,,gccjit;;context;;new_rvalue()}, which has overloads for both @code{int} and @code{double}. @end quotation @end cartouche @@ -10723,12 +11075,12 @@ result: 285 @end example @node Visualizing the control flow graph<2>,Full example<4>,Control flow<2>,Tutorial part 3 Loops and variables<2> -@anchor{cp/intro/tutorial03 visualizing-the-control-flow-graph}@anchor{183} +@anchor{cp/intro/tutorial03 visualizing-the-control-flow-graph}@anchor{193} @subsubsection Visualizing the control flow graph You can see the control flow graph of a function using -@ref{184,,gccjit;;function;;dump_to_dot()}: +@ref{194,,gccjit;;function;;dump_to_dot()}: @example func.dump_to_dot ("/tmp/sum-of-squares.dot"); @@ -10758,7 +11110,7 @@ install it with @cite{yum install python-xdot}): @end quotation @node Full example<4>,,Visualizing the control flow graph<2>,Tutorial part 3 Loops and variables<2> -@anchor{cp/intro/tutorial03 full-example}@anchor{185} +@anchor{cp/intro/tutorial03 full-example}@anchor{195} @subsubsection Full example @@ -10936,7 +11288,7 @@ loop_test returned: 285 @c <https://www.gnu.org/licenses/>. @node Tutorial part 4 Adding JIT-compilation to a toy interpreter<2>,,Tutorial part 3 Loops and variables<2>,Tutorial<2> -@anchor{cp/intro/tutorial04 doc}@anchor{186}@anchor{cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter}@anchor{187} +@anchor{cp/intro/tutorial04 doc}@anchor{196}@anchor{cp/intro/tutorial04 tutorial-part-4-adding-jit-compilation-to-a-toy-interpreter}@anchor{197} @subsection Tutorial part 4: Adding JIT-compilation to a toy interpreter @@ -10958,7 +11310,7 @@ to it. @end menu @node Our toy interpreter<2>,Compiling to machine code<2>,,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 our-toy-interpreter}@anchor{188} +@anchor{cp/intro/tutorial04 our-toy-interpreter}@anchor{198} @subsubsection Our toy interpreter @@ -11360,7 +11712,7 @@ toyvm_function::interpret (int arg, FILE *trace) @end quotation @node Compiling to machine code<2>,Setting things up<2>,Our toy interpreter<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 compiling-to-machine-code}@anchor{189} +@anchor{cp/intro/tutorial04 compiling-to-machine-code}@anchor{199} @subsubsection Compiling to machine code @@ -11430,7 +11782,7 @@ This means our compiler has the following state: @end quotation @node Setting things up<2>,Populating the function<2>,Compiling to machine code<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 setting-things-up}@anchor{18a} +@anchor{cp/intro/tutorial04 setting-things-up}@anchor{19a} @subsubsection Setting things up @@ -11520,7 +11872,7 @@ compilation_state::add_pop (gccjit::block block, @end quotation We will support single-stepping through the generated code in the -debugger, so we need to create @ref{18b,,gccjit;;location} instances, one +debugger, so we need to create @ref{19b,,gccjit;;location} instances, one per operation in the source code. These will reference the lines of e.g. @code{factorial.toy}. @@ -11580,7 +11932,7 @@ We create the locals within the function. @end quotation @node Populating the function<2>,Verifying the control flow graph<2>,Setting things up<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 populating-the-function}@anchor{18c} +@anchor{cp/intro/tutorial04 populating-the-function}@anchor{19c} @subsubsection Populating the function @@ -11693,7 +12045,7 @@ stack into @code{y} instead erroneously assigned it to @code{x}, leaving @code{y uninitialized. To track this kind of thing down, we can use -@ref{18d,,gccjit;;block;;add_comment()} to add descriptive comments +@ref{19d,,gccjit;;block;;add_comment()} to add descriptive comments to the internal representation. This is invaluable when looking through the generated IR for, say @code{factorial}: @@ -11833,14 +12185,14 @@ to the next block. This is analogous to simply incrementing the program counter. @node Verifying the control flow graph<2>,Compiling the context<2>,Populating the function<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 verifying-the-control-flow-graph}@anchor{18e} +@anchor{cp/intro/tutorial04 verifying-the-control-flow-graph}@anchor{19e} @subsubsection Verifying the control flow graph Having finished looping over the blocks, the context is complete. As before, we can verify that the control flow and statements are sane by -using @ref{184,,gccjit;;function;;dump_to_dot()}: +using @ref{194,,gccjit;;function;;dump_to_dot()}: @example fn.dump_to_dot ("/tmp/factorial.dot"); @@ -11862,7 +12214,7 @@ errors in our compiler. @end quotation @node Compiling the context<2>,Single-stepping through the generated code<2>,Verifying the control flow graph<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 compiling-the-context}@anchor{18f} +@anchor{cp/intro/tutorial04 compiling-the-context}@anchor{19f} @subsubsection Compiling the context @@ -11913,7 +12265,7 @@ private: @end quotation @node Single-stepping through the generated code<2>,Examining the generated code<2>,Compiling the context<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 single-stepping-through-the-generated-code}@anchor{190} +@anchor{cp/intro/tutorial04 single-stepping-through-the-generated-code}@anchor{1a0} @subsubsection Single-stepping through the generated code @@ -11927,14 +12279,14 @@ It’s possible to debug the generated code. To do this we need to both: @item Set up source code locations for our statements, so that we can meaningfully step through the code. We did this above by -calling @ref{191,,gccjit;;context;;new_location()} and using the +calling @ref{1a1,,gccjit;;context;;new_location()} and using the results. @item Enable the generation of debugging information, by setting @ref{42,,GCC_JIT_BOOL_OPTION_DEBUGINFO} on the -@ref{165,,gccjit;;context} via -@ref{171,,gccjit;;context;;set_bool_option()}: +@ref{175,,gccjit;;context} via +@ref{181,,gccjit;;context;;set_bool_option()}: @example ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1); @@ -11998,14 +12350,14 @@ optimization level in a regular compiler. @end cartouche @node Examining the generated code<2>,Putting it all together<2>,Single-stepping through the generated code<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 examining-the-generated-code}@anchor{192} +@anchor{cp/intro/tutorial04 examining-the-generated-code}@anchor{1a2} @subsubsection Examining the generated code How good is the optimized code? We can turn up optimizations, by calling -@ref{172,,gccjit;;context;;set_int_option()} with +@ref{182,,gccjit;;context;;set_int_option()} with @ref{1f,,GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL}: @example @@ -12173,7 +12525,7 @@ Note that the stack pushing and popping have been eliminated, as has the recursive call (in favor of an iteration). @node Putting it all together<2>,Behind the curtain How does our code get optimized?<2>,Examining the generated code<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 putting-it-all-together}@anchor{193} +@anchor{cp/intro/tutorial04 putting-it-all-together}@anchor{1a3} @subsubsection Putting it all together @@ -12204,7 +12556,7 @@ compiler result: 55 @end example @node Behind the curtain How does our code get optimized?<2>,,Putting it all together<2>,Tutorial part 4 Adding JIT-compilation to a toy interpreter<2> -@anchor{cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized}@anchor{194} +@anchor{cp/intro/tutorial04 behind-the-curtain-how-does-our-code-get-optimized}@anchor{1a4} @subsubsection Behind the curtain: How does our code get optimized? @@ -12382,7 +12734,7 @@ instr9: @} @end example -Note in the above how all the @ref{17b,,gccjit;;block} instances we +Note in the above how all the @ref{18b,,gccjit;;block} instances we created have been consolidated into just 3 blocks in GCC’s internal representation: @code{initial}, @code{instr4} and @code{instr9}. @@ -12393,7 +12745,7 @@ representation: @code{initial}, @code{instr4} and @code{instr9}. @end menu @node Optimizing away stack manipulation<2>,Elimination of tail recursion<2>,,Behind the curtain How does our code get optimized?<2> -@anchor{cp/intro/tutorial04 optimizing-away-stack-manipulation}@anchor{195} +@anchor{cp/intro/tutorial04 optimizing-away-stack-manipulation}@anchor{1a5} @subsubsection Optimizing away stack manipulation @@ -12657,7 +13009,7 @@ instr9: @end example @node Elimination of tail recursion<2>,,Optimizing away stack manipulation<2>,Behind the curtain How does our code get optimized?<2> -@anchor{cp/intro/tutorial04 elimination-of-tail-recursion}@anchor{196} +@anchor{cp/intro/tutorial04 elimination-of-tail-recursion}@anchor{1a6} @subsubsection Elimination of tail recursion @@ -12740,7 +13092,7 @@ instr9: @c <https://www.gnu.org/licenses/>. @node Topic Reference<2>,,Tutorial<2>,C++ bindings for libgccjit -@anchor{cp/topics/index doc}@anchor{197}@anchor{cp/topics/index topic-reference}@anchor{198} +@anchor{cp/topics/index doc}@anchor{1a7}@anchor{cp/topics/index topic-reference}@anchor{1a8} @section Topic Reference @@ -12774,22 +13126,22 @@ instr9: @end menu @node Compilation contexts<2>,Objects<2>,,Topic Reference<2> -@anchor{cp/topics/contexts doc}@anchor{199}@anchor{cp/topics/contexts compilation-contexts}@anchor{19a} +@anchor{cp/topics/contexts doc}@anchor{1a9}@anchor{cp/topics/contexts compilation-contexts}@anchor{1aa} @subsection Compilation contexts @geindex gccjit;;context (C++ class) -@anchor{cp/topics/contexts _CPPv4N6gccjit7contextE}@anchor{165}@anchor{cp/topics/contexts _CPPv3N6gccjit7contextE}@anchor{19b}@anchor{cp/topics/contexts _CPPv2N6gccjit7contextE}@anchor{19c}@anchor{cp/topics/contexts gccjit context}@anchor{19d} +@anchor{cp/topics/contexts _CPPv4N6gccjit7contextE}@anchor{175}@anchor{cp/topics/contexts _CPPv3N6gccjit7contextE}@anchor{1ab}@anchor{cp/topics/contexts _CPPv2N6gccjit7contextE}@anchor{1ac}@anchor{cp/topics/contexts gccjit context}@anchor{1ad} @deffn {C++ Class} gccjit::context @end deffn -The top-level of the C++ API is the @ref{165,,gccjit;;context} type. +The top-level of the C++ API is the @ref{175,,gccjit;;context} type. -A @ref{165,,gccjit;;context} instance encapsulates the state of a +A @ref{175,,gccjit;;context} instance encapsulates the state of a compilation. You can set up options on it, and add types, functions and code. -Invoking @ref{16f,,gccjit;;context;;compile()} on it gives you a +Invoking @ref{17f,,gccjit;;context;;compile()} on it gives you a @ref{16,,gcc_jit_result *}. It is a thin wrapper around the C API’s @ref{8,,gcc_jit_context *}. @@ -12804,7 +13156,7 @@ It is a thin wrapper around the C API’s @ref{8,,gcc_jit_context *}. @end menu @node Lifetime-management<2>,Thread-safety<2>,,Compilation contexts<2> -@anchor{cp/topics/contexts lifetime-management}@anchor{19e} +@anchor{cp/topics/contexts lifetime-management}@anchor{1ae} @subsubsection Lifetime-management @@ -12813,17 +13165,17 @@ have their lifetime bounded by the context they are created within, and cleanup of such objects is done for you when the context is released. @geindex gccjit;;context;;acquire (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context7acquireEv}@anchor{166}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7acquireEv}@anchor{19f}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7acquireEv}@anchor{1a0}@anchor{cp/topics/contexts gccjit context acquire}@anchor{1a1} -@deffn {C++ Function} gccjit::@ref{165,,context} gccjit::@ref{165,,context}::acquire () +@anchor{cp/topics/contexts _CPPv4N6gccjit7context7acquireEv}@anchor{176}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7acquireEv}@anchor{1af}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7acquireEv}@anchor{1b0}@anchor{cp/topics/contexts gccjit context acquire}@anchor{1b1} +@deffn {C++ Function} gccjit::@ref{175,,context} gccjit::@ref{175,,context}::acquire () -This function acquires a new @ref{165,,gccjit;;context} instance, +This function acquires a new @ref{175,,gccjit;;context} instance, which is independent of any others that may be present within this process. @end deffn @geindex gccjit;;context;;release (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context7releaseEv}@anchor{169}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7releaseEv}@anchor{1a2}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7releaseEv}@anchor{1a3}@anchor{cp/topics/contexts gccjit context release}@anchor{1a4} -@deffn {C++ Function} void gccjit::@ref{165,,context}::release () +@anchor{cp/topics/contexts _CPPv4N6gccjit7context7releaseEv}@anchor{179}@anchor{cp/topics/contexts _CPPv3N6gccjit7context7releaseEv}@anchor{1b2}@anchor{cp/topics/contexts _CPPv2N6gccjit7context7releaseEv}@anchor{1b3}@anchor{cp/topics/contexts gccjit context release}@anchor{1b4} +@deffn {C++ Function} void gccjit::@ref{175,,context}::release () This function releases all resources associated with the given context. Both the context itself and all of its @code{gccjit::object *} @@ -12839,8 +13191,8 @@ ctxt.release (); @end deffn @geindex gccjit;;context;;new_child_context (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context17new_child_contextEv}@anchor{1a5}@anchor{cp/topics/contexts _CPPv3N6gccjit7context17new_child_contextEv}@anchor{1a6}@anchor{cp/topics/contexts _CPPv2N6gccjit7context17new_child_contextEv}@anchor{1a7}@anchor{cp/topics/contexts gccjit context new_child_context}@anchor{1a8} -@deffn {C++ Function} gccjit::@ref{165,,context} gccjit::@ref{165,,context}::new_child_context () +@anchor{cp/topics/contexts _CPPv4N6gccjit7context17new_child_contextEv}@anchor{1b5}@anchor{cp/topics/contexts _CPPv3N6gccjit7context17new_child_contextEv}@anchor{1b6}@anchor{cp/topics/contexts _CPPv2N6gccjit7context17new_child_contextEv}@anchor{1b7}@anchor{cp/topics/contexts gccjit context new_child_context}@anchor{1b8} +@deffn {C++ Function} gccjit::@ref{175,,context} gccjit::@ref{175,,context}::new_child_context () Given an existing JIT context, create a child context. @@ -12871,16 +13223,16 @@ there will likely be a performance hit for such nesting. @end deffn @node Thread-safety<2>,Error-handling<3>,Lifetime-management<2>,Compilation contexts<2> -@anchor{cp/topics/contexts thread-safety}@anchor{1a9} +@anchor{cp/topics/contexts thread-safety}@anchor{1b9} @subsubsection Thread-safety -Instances of @ref{165,,gccjit;;context} created via -@ref{166,,gccjit;;context;;acquire()} are independent from each other: +Instances of @ref{175,,gccjit;;context} created via +@ref{176,,gccjit;;context;;acquire()} are independent from each other: only one thread may use a given context at once, but multiple threads could each have their own contexts without needing locks. -Contexts created via @ref{1a5,,gccjit;;context;;new_child_context()} are +Contexts created via @ref{1b5,,gccjit;;context;;new_child_context()} are related to their parent context. They can be partitioned by their ultimate ancestor into independent “family trees”. Only one thread within a process may use a given “family tree” of such contexts at once, @@ -12888,7 +13240,7 @@ and if you’re using multiple threads you should provide your own locking around entire such context partitions. @node Error-handling<3>,Debugging<2>,Thread-safety<2>,Compilation contexts<2> -@anchor{cp/topics/contexts error-handling}@anchor{1aa} +@anchor{cp/topics/contexts error-handling}@anchor{1ba} @subsubsection Error-handling @@ -12901,11 +13253,11 @@ NULL. You don’t have to check everywhere for NULL results, since the API gracefully handles a NULL being passed in for any argument. Errors are printed on stderr and can be queried using -@ref{1ab,,gccjit;;context;;get_first_error()}. +@ref{1bb,,gccjit;;context;;get_first_error()}. @geindex gccjit;;context;;get_first_error (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1ab}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1ac}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1ad}@anchor{cp/topics/contexts gccjit context get_first_error__gccjit contextP}@anchor{1ae} -@deffn {C++ Function} const char *gccjit::@ref{165,,context}::get_first_error (gccjit::context *ctxt) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1bb}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1bc}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15get_first_errorEPN6gccjit7contextE}@anchor{1bd}@anchor{cp/topics/contexts gccjit context get_first_error__gccjit contextP}@anchor{1be} +@deffn {C++ Function} const char *gccjit::@ref{175,,context}::get_first_error (gccjit::context *ctxt) Returns the first error message that occurred on the context. @@ -12916,18 +13268,18 @@ If no errors occurred, this will be NULL. @end deffn @node Debugging<2>,Options<4>,Error-handling<3>,Compilation contexts<2> -@anchor{cp/topics/contexts debugging}@anchor{1af} +@anchor{cp/topics/contexts debugging}@anchor{1bf} @subsubsection Debugging @geindex gccjit;;context;;dump_to_file (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1b0}@anchor{cp/topics/contexts _CPPv3N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1b1}@anchor{cp/topics/contexts _CPPv2N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1b2}@anchor{cp/topics/contexts gccjit context dump_to_file__ssCR i}@anchor{1b3} -@deffn {C++ Function} void gccjit::@ref{165,,context}::dump_to_file (const std::string &path, int update_locations) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1c0}@anchor{cp/topics/contexts _CPPv3N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1c1}@anchor{cp/topics/contexts _CPPv2N6gccjit7context12dump_to_fileERKNSt6stringEi}@anchor{1c2}@anchor{cp/topics/contexts gccjit context dump_to_file__ssCR i}@anchor{1c3} +@deffn {C++ Function} void gccjit::@ref{175,,context}::dump_to_file (const std::string &path, int update_locations) To help with debugging: dump a C-like representation to the given path, describing what’s been set up on the context. -If “update_locations” is true, then also set up @ref{18b,,gccjit;;location} +If “update_locations” is true, then also set up @ref{19b,,gccjit;;location} information throughout the context, pointing at the dump file as if it were a source file. This may be of use in conjunction with @code{GCCJIT::BOOL_OPTION_DEBUGINFO} to allow stepping through the @@ -12935,8 +13287,8 @@ code in a debugger. @end deffn @geindex gccjit;;context;;dump_reproducer_to_file (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1b4}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1b5}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1b6}@anchor{cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP}@anchor{1b7} -@deffn {C++ Function} void gccjit::@ref{165,,context}::dump_reproducer_to_file (gcc_jit_context *ctxt, const char *path) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1c4}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1c5}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23dump_reproducer_to_fileEP15gcc_jit_contextPKc}@anchor{1c6}@anchor{cp/topics/contexts gccjit context dump_reproducer_to_file__gcc_jit_contextP cCP}@anchor{1c7} +@deffn {C++ Function} void gccjit::@ref{175,,context}::dump_reproducer_to_file (gcc_jit_context *ctxt, const char *path) This is a thin wrapper around the C API @ref{5d,,gcc_jit_context_dump_reproducer_to_file()}, and hence works the @@ -12947,7 +13299,7 @@ for seeing what the C++ bindings are doing at the C level. @end deffn @node Options<4>,,Debugging<2>,Compilation contexts<2> -@anchor{cp/topics/contexts options}@anchor{1b8} +@anchor{cp/topics/contexts options}@anchor{1c8} @subsubsection Options @@ -12960,13 +13312,13 @@ for seeing what the C++ bindings are doing at the C level. @end menu @node String Options<2>,Boolean options<2>,,Options<4> -@anchor{cp/topics/contexts string-options}@anchor{1b9} +@anchor{cp/topics/contexts string-options}@anchor{1c9} @subsubsection String Options @geindex gccjit;;context;;set_str_option (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1ba}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1bb}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1bc}@anchor{cp/topics/contexts gccjit context set_str_option__gcc_jit_str_option cCP}@anchor{1bd} -@deffn {C++ Function} void gccjit::@ref{165,,context}::set_str_option (enum gcc_jit_str_option, const char *value) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1ca}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1cb}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_str_optionE18gcc_jit_str_optionPKc}@anchor{1cc}@anchor{cp/topics/contexts gccjit context set_str_option__gcc_jit_str_option cCP}@anchor{1cd} +@deffn {C++ Function} void gccjit::@ref{175,,context}::set_str_option (enum gcc_jit_str_option, const char *value) Set a string option of the context. @@ -12976,13 +13328,13 @@ meaning. @end deffn @node Boolean options<2>,Integer options<2>,String Options<2>,Options<4> -@anchor{cp/topics/contexts boolean-options}@anchor{1be} +@anchor{cp/topics/contexts boolean-options}@anchor{1ce} @subsubsection Boolean options @geindex gccjit;;context;;set_bool_option (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{171}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{1bf}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{1c0}@anchor{cp/topics/contexts gccjit context set_bool_option__gcc_jit_bool_option i}@anchor{1c1} -@deffn {C++ Function} void gccjit::@ref{165,,context}::set_bool_option (enum gcc_jit_bool_option, int value) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{181}@anchor{cp/topics/contexts _CPPv3N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{1cf}@anchor{cp/topics/contexts _CPPv2N6gccjit7context15set_bool_optionE19gcc_jit_bool_optioni}@anchor{1d0}@anchor{cp/topics/contexts gccjit context set_bool_option__gcc_jit_bool_option i}@anchor{1d1} +@deffn {C++ Function} void gccjit::@ref{175,,context}::set_bool_option (enum gcc_jit_bool_option, int value) Set a boolean option of the context. @@ -12992,8 +13344,8 @@ meaning. @end deffn @geindex gccjit;;context;;set_bool_allow_unreachable_blocks (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1c2}@anchor{cp/topics/contexts _CPPv3N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1c3}@anchor{cp/topics/contexts _CPPv2N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1c4}@anchor{cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i}@anchor{1c5} -@deffn {C++ Function} void gccjit::@ref{165,,context}::set_bool_allow_unreachable_blocks (int bool_value) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1d2}@anchor{cp/topics/contexts _CPPv3N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1d3}@anchor{cp/topics/contexts _CPPv2N6gccjit7context33set_bool_allow_unreachable_blocksEi}@anchor{1d4}@anchor{cp/topics/contexts gccjit context set_bool_allow_unreachable_blocks__i}@anchor{1d5} +@deffn {C++ Function} void gccjit::@ref{175,,context}::set_bool_allow_unreachable_blocks (int bool_value) By default, libgccjit will issue an error about unreachable blocks within a function. @@ -13011,8 +13363,8 @@ its presence using @end deffn @geindex gccjit;;context;;set_bool_use_external_driver (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context28set_bool_use_external_driverEi}@anchor{1c6}@anchor{cp/topics/contexts _CPPv3N6gccjit7context28set_bool_use_external_driverEi}@anchor{1c7}@anchor{cp/topics/contexts _CPPv2N6gccjit7context28set_bool_use_external_driverEi}@anchor{1c8}@anchor{cp/topics/contexts gccjit context set_bool_use_external_driver__i}@anchor{1c9} -@deffn {C++ Function} void gccjit::@ref{165,,context}::set_bool_use_external_driver (int bool_value) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context28set_bool_use_external_driverEi}@anchor{1d6}@anchor{cp/topics/contexts _CPPv3N6gccjit7context28set_bool_use_external_driverEi}@anchor{1d7}@anchor{cp/topics/contexts _CPPv2N6gccjit7context28set_bool_use_external_driverEi}@anchor{1d8}@anchor{cp/topics/contexts gccjit context set_bool_use_external_driver__i}@anchor{1d9} +@deffn {C++ Function} void gccjit::@ref{175,,context}::set_bool_use_external_driver (int bool_value) libgccjit internally generates assembler, and uses “driver” code for converting it to other formats (e.g. shared libraries). @@ -13033,13 +13385,13 @@ its presence using @end deffn @node Integer options<2>,Additional command-line options<2>,Boolean options<2>,Options<4> -@anchor{cp/topics/contexts integer-options}@anchor{1ca} +@anchor{cp/topics/contexts integer-options}@anchor{1da} @subsubsection Integer options @geindex gccjit;;context;;set_int_option (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{172}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1cb}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1cc}@anchor{cp/topics/contexts gccjit context set_int_option__gcc_jit_int_option i}@anchor{1cd} -@deffn {C++ Function} void gccjit::@ref{165,,context}::set_int_option (enum gcc_jit_int_option, int value) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{182}@anchor{cp/topics/contexts _CPPv3N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1db}@anchor{cp/topics/contexts _CPPv2N6gccjit7context14set_int_optionE18gcc_jit_int_optioni}@anchor{1dc}@anchor{cp/topics/contexts gccjit context set_int_option__gcc_jit_int_option i}@anchor{1dd} +@deffn {C++ Function} void gccjit::@ref{175,,context}::set_int_option (enum gcc_jit_int_option, int value) Set an integer option of the context. @@ -13049,21 +13401,21 @@ meaning. @end deffn @node Additional command-line options<2>,,Integer options<2>,Options<4> -@anchor{cp/topics/contexts additional-command-line-options}@anchor{1ce} +@anchor{cp/topics/contexts additional-command-line-options}@anchor{1de} @subsubsection Additional command-line options @geindex gccjit;;context;;add_command_line_option (C++ function) -@anchor{cp/topics/contexts _CPPv4N6gccjit7context23add_command_line_optionEPKc}@anchor{1cf}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23add_command_line_optionEPKc}@anchor{1d0}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23add_command_line_optionEPKc}@anchor{1d1}@anchor{cp/topics/contexts gccjit context add_command_line_option__cCP}@anchor{1d2} -@deffn {C++ Function} void gccjit::@ref{165,,context}::add_command_line_option (const char *optname) +@anchor{cp/topics/contexts _CPPv4N6gccjit7context23add_command_line_optionEPKc}@anchor{1df}@anchor{cp/topics/contexts _CPPv3N6gccjit7context23add_command_line_optionEPKc}@anchor{1e0}@anchor{cp/topics/contexts _CPPv2N6gccjit7context23add_command_line_optionEPKc}@anchor{1e1}@anchor{cp/topics/contexts gccjit context add_command_line_option__cCP}@anchor{1e2} +@deffn {C++ Function} void gccjit::@ref{175,,context}::add_command_line_option (const char *optname) Add an arbitrary gcc command-line option to the context for use when compiling. This is a thin wrapper around the C API -@ref{72,,gcc_jit_context_add_command_line_option()}. +@ref{74,,gcc_jit_context_add_command_line_option()}. -This entrypoint was added in @ref{73,,LIBGCCJIT_ABI_1}; you can test for +This entrypoint was added in @ref{75,,LIBGCCJIT_ABI_1}; you can test for its presence using @example @@ -13089,18 +13441,18 @@ its presence using @c <https://www.gnu.org/licenses/>. @node Objects<2>,Types<2>,Compilation contexts<2>,Topic Reference<2> -@anchor{cp/topics/objects doc}@anchor{1d3}@anchor{cp/topics/objects objects}@anchor{1d4} +@anchor{cp/topics/objects doc}@anchor{1e3}@anchor{cp/topics/objects objects}@anchor{1e4} @subsection Objects @geindex gccjit;;object (C++ class) -@anchor{cp/topics/objects _CPPv4N6gccjit6objectE}@anchor{16a}@anchor{cp/topics/objects _CPPv3N6gccjit6objectE}@anchor{1d5}@anchor{cp/topics/objects _CPPv2N6gccjit6objectE}@anchor{1d6}@anchor{cp/topics/objects gccjit object}@anchor{1d7} +@anchor{cp/topics/objects _CPPv4N6gccjit6objectE}@anchor{17a}@anchor{cp/topics/objects _CPPv3N6gccjit6objectE}@anchor{1e5}@anchor{cp/topics/objects _CPPv2N6gccjit6objectE}@anchor{1e6}@anchor{cp/topics/objects gccjit object}@anchor{1e7} @deffn {C++ Class} gccjit::object @end deffn Almost every entity in the API (with the exception of -@ref{165,,gccjit;;context} and @ref{16,,gcc_jit_result *}) is a -“contextual” object, a @ref{16a,,gccjit;;object}. +@ref{175,,gccjit;;context} and @ref{16,,gcc_jit_result *}) is a +“contextual” object, a @ref{17a,,gccjit;;object}. A JIT object: @@ -13110,7 +13462,7 @@ A JIT object: @itemize * @item -is associated with a @ref{165,,gccjit;;context}. +is associated with a @ref{175,,gccjit;;context}. @item is automatically cleaned up for you when its context is released so @@ -13135,18 +13487,18 @@ The C++ class hierarchy within the @code{gccjit} namespace looks like this: +- case_ @end example -The @ref{16a,,gccjit;;object} base class has the following operations: +The @ref{17a,,gccjit;;object} base class has the following operations: @geindex gccjit;;object;;get_context (C++ function) -@anchor{cp/topics/objects _CPPv4NK6gccjit6object11get_contextEv}@anchor{1d8}@anchor{cp/topics/objects _CPPv3NK6gccjit6object11get_contextEv}@anchor{1d9}@anchor{cp/topics/objects _CPPv2NK6gccjit6object11get_contextEv}@anchor{1da}@anchor{cp/topics/objects gccjit object get_contextC}@anchor{1db} -@deffn {C++ Function} gccjit::@ref{165,,context} gccjit::@ref{16a,,object}::get_context () const +@anchor{cp/topics/objects _CPPv4NK6gccjit6object11get_contextEv}@anchor{1e8}@anchor{cp/topics/objects _CPPv3NK6gccjit6object11get_contextEv}@anchor{1e9}@anchor{cp/topics/objects _CPPv2NK6gccjit6object11get_contextEv}@anchor{1ea}@anchor{cp/topics/objects gccjit object get_contextC}@anchor{1eb} +@deffn {C++ Function} gccjit::@ref{175,,context} gccjit::@ref{17a,,object}::get_context () const Which context is the obj within? @end deffn @geindex gccjit;;object;;get_debug_string (C++ function) -@anchor{cp/topics/objects _CPPv4NK6gccjit6object16get_debug_stringEv}@anchor{16b}@anchor{cp/topics/objects _CPPv3NK6gccjit6object16get_debug_stringEv}@anchor{1dc}@anchor{cp/topics/objects _CPPv2NK6gccjit6object16get_debug_stringEv}@anchor{1dd}@anchor{cp/topics/objects gccjit object get_debug_stringC}@anchor{1de} -@deffn {C++ Function} std::string gccjit::@ref{16a,,object}::get_debug_string () const +@anchor{cp/topics/objects _CPPv4NK6gccjit6object16get_debug_stringEv}@anchor{17b}@anchor{cp/topics/objects _CPPv3NK6gccjit6object16get_debug_stringEv}@anchor{1ec}@anchor{cp/topics/objects _CPPv2NK6gccjit6object16get_debug_stringEv}@anchor{1ed}@anchor{cp/topics/objects gccjit object get_debug_stringC}@anchor{1ee} +@deffn {C++ Function} std::string gccjit::@ref{17a,,object}::get_debug_string () const Generate a human-readable description for the given object. @@ -13181,16 +13533,16 @@ obj: 4.0 * (float)i @c <https://www.gnu.org/licenses/>. @node Types<2>,Expressions<2>,Objects<2>,Topic Reference<2> -@anchor{cp/topics/types doc}@anchor{1df}@anchor{cp/topics/types types}@anchor{1e0} +@anchor{cp/topics/types doc}@anchor{1ef}@anchor{cp/topics/types types}@anchor{1f0} @subsection Types @geindex gccjit;;type (C++ class) -@anchor{cp/topics/types _CPPv4N6gccjit4typeE}@anchor{167}@anchor{cp/topics/types _CPPv3N6gccjit4typeE}@anchor{1e1}@anchor{cp/topics/types _CPPv2N6gccjit4typeE}@anchor{1e2}@anchor{cp/topics/types gccjit type}@anchor{1e3} +@anchor{cp/topics/types _CPPv4N6gccjit4typeE}@anchor{177}@anchor{cp/topics/types _CPPv3N6gccjit4typeE}@anchor{1f1}@anchor{cp/topics/types _CPPv2N6gccjit4typeE}@anchor{1f2}@anchor{cp/topics/types gccjit type}@anchor{1f3} @deffn {C++ Class} gccjit::type gccjit::type represents a type within the library. It is a subclass -of @ref{16a,,gccjit;;object}. +of @ref{17a,,gccjit;;object}. @end deffn Types can be created in several ways: @@ -13200,7 +13552,7 @@ Types can be created in several ways: @item fundamental types can be accessed using -@ref{168,,gccjit;;context;;get_type()}: +@ref{178,,gccjit;;context;;get_type()}: @example gccjit::type int_type = ctxt.get_type (GCC_JIT_TYPE_INT); @@ -13216,7 +13568,7 @@ See @ref{b,,gcc_jit_context_get_type()} for the available types. @item derived types can be accessed by using functions such as -@ref{1e4,,gccjit;;type;;get_pointer()} and @ref{1e5,,gccjit;;type;;get_const()}: +@ref{1f4,,gccjit;;type;;get_pointer()} and @ref{1f5,,gccjit;;type;;get_const()}: @example gccjit::type const_int_star = int_type.get_const ().get_pointer (); @@ -13236,28 +13588,28 @@ by creating structures (see below). @end menu @node Standard types<2>,Pointers const and volatile<2>,,Types<2> -@anchor{cp/topics/types standard-types}@anchor{1e6} +@anchor{cp/topics/types standard-types}@anchor{1f6} @subsubsection Standard types @geindex gccjit;;context;;get_type (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit7context8get_typeE13gcc_jit_types}@anchor{168}@anchor{cp/topics/types _CPPv3N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1e7}@anchor{cp/topics/types _CPPv2N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1e8}@anchor{cp/topics/types gccjit context get_type__gcc_jit_types}@anchor{1e9} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{165,,context}::get_type (enum gcc_jit_types) +@anchor{cp/topics/types _CPPv4N6gccjit7context8get_typeE13gcc_jit_types}@anchor{178}@anchor{cp/topics/types _CPPv3N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1f7}@anchor{cp/topics/types _CPPv2N6gccjit7context8get_typeE13gcc_jit_types}@anchor{1f8}@anchor{cp/topics/types gccjit context get_type__gcc_jit_types}@anchor{1f9} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{175,,context}::get_type (enum gcc_jit_types) Access a specific type. This is a thin wrapper around @ref{b,,gcc_jit_context_get_type()}; the parameter has the same meaning. @end deffn @geindex gccjit;;context;;get_int_type (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit7context12get_int_typeE6size_ti}@anchor{1ea}@anchor{cp/topics/types _CPPv3N6gccjit7context12get_int_typeE6size_ti}@anchor{1eb}@anchor{cp/topics/types _CPPv2N6gccjit7context12get_int_typeE6size_ti}@anchor{1ec}@anchor{cp/topics/types gccjit context get_int_type__s i}@anchor{1ed} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{165,,context}::get_int_type (size_t num_bytes, int is_signed) +@anchor{cp/topics/types _CPPv4N6gccjit7context12get_int_typeE6size_ti}@anchor{1fa}@anchor{cp/topics/types _CPPv3N6gccjit7context12get_int_typeE6size_ti}@anchor{1fb}@anchor{cp/topics/types _CPPv2N6gccjit7context12get_int_typeE6size_ti}@anchor{1fc}@anchor{cp/topics/types gccjit context get_int_type__s i}@anchor{1fd} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{175,,context}::get_int_type (size_t num_bytes, int is_signed) Access the integer type of the given size. @end deffn @geindex gccjit;;context;;get_int_type<T> (C++ function) -@anchor{cp/topics/types _CPPv4IEN6gccjit7context12get_int_typeI1TEEN6gccjit4typeEv}@anchor{1ee}@anchor{cp/topics/types _CPPv3IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1ef}@anchor{cp/topics/types _CPPv2IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1f0} -@deffn {C++ Function} template<>gccjit::@ref{167,,type} gccjit::@ref{165,,context}::get_int_type<T> () +@anchor{cp/topics/types _CPPv4IEN6gccjit7context12get_int_typeI1TEEN6gccjit4typeEv}@anchor{1fe}@anchor{cp/topics/types _CPPv3IEN6gccjit7context12get_int_typeI1TEEv}@anchor{1ff}@anchor{cp/topics/types _CPPv2IEN6gccjit7context12get_int_typeI1TEEv}@anchor{200} +@deffn {C++ Function} template<>gccjit::@ref{177,,type} gccjit::@ref{175,,context}::get_int_type<T> () Access the given integer type. For example, you could map the @code{unsigned short} type into a gccjit::type via: @@ -13268,34 +13620,34 @@ gccjit::type t = ctxt.get_int_type <unsigned short> (); @end deffn @node Pointers const and volatile<2>,Vector types<2>,Standard types<2>,Types<2> -@anchor{cp/topics/types pointers-const-and-volatile}@anchor{1f1} +@anchor{cp/topics/types pointers-const-and-volatile}@anchor{201} @subsubsection Pointers, @cite{const}, and @cite{volatile} @geindex gccjit;;type;;get_pointer (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit4type11get_pointerEv}@anchor{1e4}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_pointerEv}@anchor{1f2}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_pointerEv}@anchor{1f3}@anchor{cp/topics/types gccjit type get_pointer}@anchor{1f4} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_pointer () +@anchor{cp/topics/types _CPPv4N6gccjit4type11get_pointerEv}@anchor{1f4}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_pointerEv}@anchor{202}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_pointerEv}@anchor{203}@anchor{cp/topics/types gccjit type get_pointer}@anchor{204} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{177,,type}::get_pointer () Given type “T”, get type “T*”. @end deffn @geindex gccjit;;type;;get_const (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit4type9get_constEv}@anchor{1e5}@anchor{cp/topics/types _CPPv3N6gccjit4type9get_constEv}@anchor{1f5}@anchor{cp/topics/types _CPPv2N6gccjit4type9get_constEv}@anchor{1f6}@anchor{cp/topics/types gccjit type get_const}@anchor{1f7} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_const () +@anchor{cp/topics/types _CPPv4N6gccjit4type9get_constEv}@anchor{1f5}@anchor{cp/topics/types _CPPv3N6gccjit4type9get_constEv}@anchor{205}@anchor{cp/topics/types _CPPv2N6gccjit4type9get_constEv}@anchor{206}@anchor{cp/topics/types gccjit type get_const}@anchor{207} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{177,,type}::get_const () Given type “T”, get type “const T”. @end deffn @geindex gccjit;;type;;get_volatile (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit4type12get_volatileEv}@anchor{1f8}@anchor{cp/topics/types _CPPv3N6gccjit4type12get_volatileEv}@anchor{1f9}@anchor{cp/topics/types _CPPv2N6gccjit4type12get_volatileEv}@anchor{1fa}@anchor{cp/topics/types gccjit type get_volatile}@anchor{1fb} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_volatile () +@anchor{cp/topics/types _CPPv4N6gccjit4type12get_volatileEv}@anchor{208}@anchor{cp/topics/types _CPPv3N6gccjit4type12get_volatileEv}@anchor{209}@anchor{cp/topics/types _CPPv2N6gccjit4type12get_volatileEv}@anchor{20a}@anchor{cp/topics/types gccjit type get_volatile}@anchor{20b} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{177,,type}::get_volatile () Given type “T”, get type “volatile T”. @end deffn @geindex gccjit;;type;;get_aligned (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit4type11get_alignedE6size_t}@anchor{1fc}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_alignedE6size_t}@anchor{1fd}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_alignedE6size_t}@anchor{1fe}@anchor{cp/topics/types gccjit type get_aligned__s}@anchor{1ff} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_aligned (size_t alignment_in_bytes) +@anchor{cp/topics/types _CPPv4N6gccjit4type11get_alignedE6size_t}@anchor{20c}@anchor{cp/topics/types _CPPv3N6gccjit4type11get_alignedE6size_t}@anchor{20d}@anchor{cp/topics/types _CPPv2N6gccjit4type11get_alignedE6size_t}@anchor{20e}@anchor{cp/topics/types gccjit type get_aligned__s}@anchor{20f} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{177,,type}::get_aligned (size_t alignment_in_bytes) Given type “T”, get type: @@ -13307,21 +13659,21 @@ The alignment must be a power of two. @end deffn @geindex gccjit;;context;;new_array_type (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{200}@anchor{cp/topics/types _CPPv3N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{201}@anchor{cp/topics/types _CPPv2N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{202}@anchor{cp/topics/types gccjit context new_array_type__gccjit type i gccjit location}@anchor{203} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{165,,context}::new_array_type (gccjit::type element_type, int num_elements, gccjit::location loc) +@anchor{cp/topics/types _CPPv4N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{210}@anchor{cp/topics/types _CPPv3N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{211}@anchor{cp/topics/types _CPPv2N6gccjit7context14new_array_typeEN6gccjit4typeEiN6gccjit8locationE}@anchor{212}@anchor{cp/topics/types gccjit context new_array_type__gccjit type i gccjit location}@anchor{213} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{175,,context}::new_array_type (gccjit::type element_type, int num_elements, gccjit::location loc) Given type “T”, get type “T[N]” (for a constant N). Param “loc” is optional. @end deffn @node Vector types<2>,Structures and unions<2>,Pointers const and volatile<2>,Types<2> -@anchor{cp/topics/types vector-types}@anchor{204} +@anchor{cp/topics/types vector-types}@anchor{214} @subsubsection Vector types @geindex gccjit;;type;;get_vector (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit4type10get_vectorE6size_t}@anchor{205}@anchor{cp/topics/types _CPPv3N6gccjit4type10get_vectorE6size_t}@anchor{206}@anchor{cp/topics/types _CPPv2N6gccjit4type10get_vectorE6size_t}@anchor{207}@anchor{cp/topics/types gccjit type get_vector__s}@anchor{208} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{167,,type}::get_vector (size_t num_units) +@anchor{cp/topics/types _CPPv4N6gccjit4type10get_vectorE6size_t}@anchor{215}@anchor{cp/topics/types _CPPv3N6gccjit4type10get_vectorE6size_t}@anchor{216}@anchor{cp/topics/types _CPPv2N6gccjit4type10get_vectorE6size_t}@anchor{217}@anchor{cp/topics/types gccjit type get_vector__s}@anchor{218} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{177,,type}::get_vector (size_t num_units) Given type “T”, get type: @@ -13333,31 +13685,31 @@ T must be integral or floating point; num_units must be a power of two. @end deffn @node Structures and unions<2>,,Vector types<2>,Types<2> -@anchor{cp/topics/types structures-and-unions}@anchor{209} +@anchor{cp/topics/types structures-and-unions}@anchor{219} @subsubsection Structures and unions @geindex gccjit;;struct_ (C++ class) -@anchor{cp/topics/types _CPPv4N6gccjit7struct_E}@anchor{20a}@anchor{cp/topics/types _CPPv3N6gccjit7struct_E}@anchor{20b}@anchor{cp/topics/types _CPPv2N6gccjit7struct_E}@anchor{20c}@anchor{cp/topics/types gccjit struct_}@anchor{20d} +@anchor{cp/topics/types _CPPv4N6gccjit7struct_E}@anchor{21a}@anchor{cp/topics/types _CPPv3N6gccjit7struct_E}@anchor{21b}@anchor{cp/topics/types _CPPv2N6gccjit7struct_E}@anchor{21c}@anchor{cp/topics/types gccjit struct_}@anchor{21d} @deffn {C++ Class} gccjit::struct_ @end deffn A compound type analagous to a C @cite{struct}. -@ref{20a,,gccjit;;struct_} is a subclass of @ref{167,,gccjit;;type} (and thus -of @ref{16a,,gccjit;;object} in turn). +@ref{21a,,gccjit;;struct_} is a subclass of @ref{177,,gccjit;;type} (and thus +of @ref{17a,,gccjit;;object} in turn). @geindex gccjit;;field (C++ class) -@anchor{cp/topics/types _CPPv4N6gccjit5fieldE}@anchor{20e}@anchor{cp/topics/types _CPPv3N6gccjit5fieldE}@anchor{20f}@anchor{cp/topics/types _CPPv2N6gccjit5fieldE}@anchor{210}@anchor{cp/topics/types gccjit field}@anchor{211} +@anchor{cp/topics/types _CPPv4N6gccjit5fieldE}@anchor{21e}@anchor{cp/topics/types _CPPv3N6gccjit5fieldE}@anchor{21f}@anchor{cp/topics/types _CPPv2N6gccjit5fieldE}@anchor{220}@anchor{cp/topics/types gccjit field}@anchor{221} @deffn {C++ Class} gccjit::field @end deffn -A field within a @ref{20a,,gccjit;;struct_}. +A field within a @ref{21a,,gccjit;;struct_}. -@ref{20e,,gccjit;;field} is a subclass of @ref{16a,,gccjit;;object}. +@ref{21e,,gccjit;;field} is a subclass of @ref{17a,,gccjit;;object}. -You can model C @cite{struct} types by creating @ref{20a,,gccjit;;struct_} and -@ref{20e,,gccjit;;field} instances, in either order: +You can model C @cite{struct} types by creating @ref{21a,,gccjit;;struct_} and +@ref{21e,,gccjit;;field} instances, in either order: @itemize * @@ -13405,15 +13757,15 @@ node.set_fields (fields); @c FIXME: the above API doesn't seem to exist yet @geindex gccjit;;context;;new_field (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{212}@anchor{cp/topics/types _CPPv3N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{213}@anchor{cp/topics/types _CPPv2N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{214}@anchor{cp/topics/types gccjit context new_field__gccjit type cCP gccjit location}@anchor{215} -@deffn {C++ Function} gccjit::@ref{20e,,field} gccjit::@ref{165,,context}::new_field (gccjit::type type, const char *name, gccjit::location loc) +@anchor{cp/topics/types _CPPv4N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{222}@anchor{cp/topics/types _CPPv3N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{223}@anchor{cp/topics/types _CPPv2N6gccjit7context9new_fieldEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{224}@anchor{cp/topics/types gccjit context new_field__gccjit type cCP gccjit location}@anchor{225} +@deffn {C++ Function} gccjit::@ref{21e,,field} gccjit::@ref{175,,context}::new_field (gccjit::type type, const char *name, gccjit::location loc) Construct a new field, with the given type and name. @end deffn @geindex gccjit;;context;;new_struct_type (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{216}@anchor{cp/topics/types _CPPv3N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{217}@anchor{cp/topics/types _CPPv2N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{218}@anchor{cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location}@anchor{219} -@deffn {C++ Function} gccjit::@ref{20a,,struct_} gccjit::@ref{165,,context}::new_struct_type (const std::string &name, std::vector<field> &fields, gccjit::location loc) +@anchor{cp/topics/types _CPPv4N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{226}@anchor{cp/topics/types _CPPv3N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{227}@anchor{cp/topics/types _CPPv2N6gccjit7context15new_struct_typeERKNSt6stringERNSt6vectorI5fieldEEN6gccjit8locationE}@anchor{228}@anchor{cp/topics/types gccjit context new_struct_type__ssCR std vector field R gccjit location}@anchor{229} +@deffn {C++ Function} gccjit::@ref{21a,,struct_} gccjit::@ref{175,,context}::new_struct_type (const std::string &name, std::vector<field> &fields, gccjit::location loc) @quotation @@ -13422,13 +13774,13 @@ Construct a new struct type, with the given name and fields. @end deffn @geindex gccjit;;context;;new_opaque_struct (C++ function) -@anchor{cp/topics/types _CPPv4N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{21a}@anchor{cp/topics/types _CPPv3N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{21b}@anchor{cp/topics/types _CPPv2N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{21c}@anchor{cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location}@anchor{21d} -@deffn {C++ Function} gccjit::@ref{20a,,struct_} gccjit::@ref{165,,context}::new_opaque_struct (const std::string &name, gccjit::location loc) +@anchor{cp/topics/types _CPPv4N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{22a}@anchor{cp/topics/types _CPPv3N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{22b}@anchor{cp/topics/types _CPPv2N6gccjit7context17new_opaque_structERKNSt6stringEN6gccjit8locationE}@anchor{22c}@anchor{cp/topics/types gccjit context new_opaque_struct__ssCR gccjit location}@anchor{22d} +@deffn {C++ Function} gccjit::@ref{21a,,struct_} gccjit::@ref{175,,context}::new_opaque_struct (const std::string &name, gccjit::location loc) Construct a new struct type, with the given name, but without specifying the fields. The fields can be omitted (in which case the size of the struct is not known), or later specified using -@ref{91,,gcc_jit_struct_set_fields()}. +@ref{93,,gcc_jit_struct_set_fields()}. @end deffn @c Copyright (C) 2014-2022 Free Software Foundation, Inc. @@ -13449,7 +13801,7 @@ size of the struct is not known), or later specified using @c <https://www.gnu.org/licenses/>. @node Expressions<2>,Creating and using functions<2>,Types<2>,Topic Reference<2> -@anchor{cp/topics/expressions doc}@anchor{21e}@anchor{cp/topics/expressions expressions}@anchor{21f} +@anchor{cp/topics/expressions doc}@anchor{22e}@anchor{cp/topics/expressions expressions}@anchor{22f} @subsection Expressions @@ -13461,17 +13813,17 @@ size of the struct is not known), or later specified using @end menu @node Rvalues<2>,Lvalues<2>,,Expressions<2> -@anchor{cp/topics/expressions rvalues}@anchor{220} +@anchor{cp/topics/expressions rvalues}@anchor{230} @subsubsection Rvalues @geindex gccjit;;rvalue (C++ class) -@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalueE}@anchor{16e}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalueE}@anchor{221}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalueE}@anchor{222}@anchor{cp/topics/expressions gccjit rvalue}@anchor{223} +@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalueE}@anchor{17e}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalueE}@anchor{231}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalueE}@anchor{232}@anchor{cp/topics/expressions gccjit rvalue}@anchor{233} @deffn {C++ Class} gccjit::rvalue @end deffn -A @ref{16e,,gccjit;;rvalue} is an expression that can be computed. It is a -subclass of @ref{16a,,gccjit;;object}, and is a thin wrapper around +A @ref{17e,,gccjit;;rvalue} is an expression that can be computed. It is a +subclass of @ref{17a,,gccjit;;object}, and is a thin wrapper around @ref{13,,gcc_jit_rvalue *} from the C API. It can be simple, e.g.: @@ -13517,8 +13869,8 @@ Every rvalue has an associated type, and the API will check to ensure that types match up correctly (otherwise the context will emit an error). @geindex gccjit;;rvalue;;get_type (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue8get_typeEv}@anchor{224}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue8get_typeEv}@anchor{225}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue8get_typeEv}@anchor{226}@anchor{cp/topics/expressions gccjit rvalue get_type}@anchor{227} -@deffn {C++ Function} gccjit::@ref{167,,type} gccjit::@ref{16e,,rvalue}::get_type () +@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue8get_typeEv}@anchor{234}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue8get_typeEv}@anchor{235}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue8get_typeEv}@anchor{236}@anchor{cp/topics/expressions gccjit rvalue get_type}@anchor{237} +@deffn {C++ Function} gccjit::@ref{177,,type} gccjit::@ref{17e,,rvalue}::get_type () Get the type of this rvalue. @end deffn @@ -13536,29 +13888,29 @@ Get the type of this rvalue. @end menu @node Simple expressions<2>,Vector expressions<2>,,Rvalues<2> -@anchor{cp/topics/expressions simple-expressions}@anchor{228} +@anchor{cp/topics/expressions simple-expressions}@anchor{238} @subsubsection Simple expressions @geindex gccjit;;context;;new_rvalue (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{182}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{229}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{22a}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type iC}@anchor{22b} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type numeric_type, int value) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{192}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{239}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEi}@anchor{23a}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type iC}@anchor{23b} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_rvalue (gccjit::type numeric_type, int value) const Given a numeric type (integer or floating point), build an rvalue for the given constant @code{int} value. @end deffn @geindex gccjit;;context;;new_rvalue (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{22c}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{22d}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{22e}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type lC}@anchor{22f} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type numeric_type, long value) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{23c}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{23d}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEl}@anchor{23e}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type lC}@anchor{23f} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_rvalue (gccjit::type numeric_type, long value) const Given a numeric type (integer or floating point), build an rvalue for the given constant @code{long} value. @end deffn @geindex gccjit;;context;;zero (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{17e}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{230}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{231}@anchor{cp/topics/expressions gccjit context zero__gccjit typeC}@anchor{232} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::zero (gccjit::type numeric_type) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{18e}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{240}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context4zeroEN6gccjit4typeE}@anchor{241}@anchor{cp/topics/expressions gccjit context zero__gccjit typeC}@anchor{242} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::zero (gccjit::type numeric_type) const Given a numeric type (integer or floating point), get the rvalue for zero. Essentially this is just a shortcut for: @@ -13569,8 +13921,8 @@ ctxt.new_rvalue (numeric_type, 0) @end deffn @geindex gccjit;;context;;one (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context3oneEN6gccjit4typeE}@anchor{233}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context3oneEN6gccjit4typeE}@anchor{234}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context3oneEN6gccjit4typeE}@anchor{235}@anchor{cp/topics/expressions gccjit context one__gccjit typeC}@anchor{236} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::one (gccjit::type numeric_type) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context3oneEN6gccjit4typeE}@anchor{243}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context3oneEN6gccjit4typeE}@anchor{244}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context3oneEN6gccjit4typeE}@anchor{245}@anchor{cp/topics/expressions gccjit context one__gccjit typeC}@anchor{246} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::one (gccjit::type numeric_type) const Given a numeric type (integer or floating point), get the rvalue for one. Essentially this is just a shortcut for: @@ -13581,36 +13933,36 @@ ctxt.new_rvalue (numeric_type, 1) @end deffn @geindex gccjit;;context;;new_rvalue (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{237}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{238}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{239}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC}@anchor{23a} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type numeric_type, double value) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{247}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{248}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEd}@anchor{249}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type doubleC}@anchor{24a} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_rvalue (gccjit::type numeric_type, double value) const Given a numeric type (integer or floating point), build an rvalue for the given constant @code{double} value. @end deffn @geindex gccjit;;context;;new_rvalue (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{23b}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{23c}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{23d}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC}@anchor{23e} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type pointer_type, void *value) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{24b}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{24c}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeEPv}@anchor{24d}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type voidPC}@anchor{24e} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_rvalue (gccjit::type pointer_type, void *value) const Given a pointer type, build an rvalue for the given address. @end deffn @geindex gccjit;;context;;new_rvalue (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{23f}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{240}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{241}@anchor{cp/topics/expressions gccjit context new_rvalue__ssCRC}@anchor{242} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (const std::string &value) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{24f}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{250}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueERKNSt6stringE}@anchor{251}@anchor{cp/topics/expressions gccjit context new_rvalue__ssCRC}@anchor{252} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_rvalue (const std::string &value) const Generate an rvalue of type @code{GCC_JIT_TYPE_CONST_CHAR_PTR} for the given string. This is akin to a string literal. @end deffn @node Vector expressions<2>,Unary Operations<2>,Simple expressions<2>,Rvalues<2> -@anchor{cp/topics/expressions vector-expressions}@anchor{243} +@anchor{cp/topics/expressions vector-expressions}@anchor{253} @subsubsection Vector expressions @geindex gccjit;;context;;new_rvalue (C++ function) -@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{244}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{245}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{246}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type std vector gccjit rvalue C}@anchor{247} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_rvalue (gccjit::type vector_type, std::vector<gccjit::rvalue> elements) const +@anchor{cp/topics/expressions _CPPv4NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{254}@anchor{cp/topics/expressions _CPPv3NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{255}@anchor{cp/topics/expressions _CPPv2NK6gccjit7context10new_rvalueEN6gccjit4typeENSt6vectorIN6gccjit6rvalueEEE}@anchor{256}@anchor{cp/topics/expressions gccjit context new_rvalue__gccjit type std vector gccjit rvalue C}@anchor{257} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_rvalue (gccjit::type vector_type, std::vector<gccjit::rvalue> elements) const Given a vector type, and a vector of scalar rvalue elements, generate a vector rvalue. @@ -13619,20 +13971,20 @@ The number of elements needs to match that of the vector type. @end deffn @node Unary Operations<2>,Binary Operations<2>,Vector expressions<2>,Rvalues<2> -@anchor{cp/topics/expressions unary-operations}@anchor{248} +@anchor{cp/topics/expressions unary-operations}@anchor{258} @subsubsection Unary Operations @geindex gccjit;;context;;new_unary_op (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{249}@anchor{cp/topics/expressions _CPPv3N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24b}@anchor{cp/topics/expressions gccjit context new_unary_op__gcc_jit_unary_op gccjit type gccjit rvalue gccjit location}@anchor{24c} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_unary_op (enum gcc_jit_unary_op, gccjit::type result_type, gccjit::rvalue rvalue, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{259}@anchor{cp/topics/expressions _CPPv3N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context12new_unary_opE16gcc_jit_unary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25b}@anchor{cp/topics/expressions gccjit context new_unary_op__gcc_jit_unary_op gccjit type gccjit rvalue gccjit location}@anchor{25c} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_unary_op (enum gcc_jit_unary_op, gccjit::type result_type, gccjit::rvalue rvalue, gccjit::location loc) Build a unary operation out of an input rvalue. Parameter @code{loc} is optional. This is a thin wrapper around the C API’s -@ref{ba,,gcc_jit_context_new_unary_op()} and the available unary +@ref{bf,,gcc_jit_context_new_unary_op()} and the available unary operations are documented there. @end deffn @@ -13640,8 +13992,8 @@ There are shorter ways to spell the various specific kinds of unary operation: @geindex gccjit;;context;;new_minus (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{24f}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location}@anchor{250} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{25f}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit location}@anchor{260} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc) Negate an arithmetic value; for example: @@ -13657,8 +14009,8 @@ builds the equivalent of this C expression: @end deffn @geindex new_bitwise_negate (C++ function) -@anchor{cp/topics/expressions _CPPv418new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{251}@anchor{cp/topics/expressions _CPPv318new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{252}@anchor{cp/topics/expressions _CPPv218new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{253}@anchor{cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location}@anchor{254} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} new_bitwise_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv418new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{261}@anchor{cp/topics/expressions _CPPv318new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{262}@anchor{cp/topics/expressions _CPPv218new_bitwise_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{263}@anchor{cp/topics/expressions new_bitwise_negate__gccjit type gccjit rvalue gccjit location}@anchor{264} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} new_bitwise_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc) Bitwise negation of an integer value (one’s complement); for example: @@ -13674,8 +14026,8 @@ builds the equivalent of this C expression: @end deffn @geindex new_logical_negate (C++ function) -@anchor{cp/topics/expressions _CPPv418new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{255}@anchor{cp/topics/expressions _CPPv318new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{256}@anchor{cp/topics/expressions _CPPv218new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{257}@anchor{cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location}@anchor{258} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} new_logical_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv418new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{265}@anchor{cp/topics/expressions _CPPv318new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{266}@anchor{cp/topics/expressions _CPPv218new_logical_negateN6gccjit4typeEN6gccjit6rvalueEN6gccjit8locationE}@anchor{267}@anchor{cp/topics/expressions new_logical_negate__gccjit type gccjit rvalue gccjit location}@anchor{268} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} new_logical_negate (gccjit::type result_type, gccjit::rvalue a, gccjit::location loc) Logical negation of an arithmetic or pointer value; for example: @@ -13693,8 +14045,8 @@ builds the equivalent of this C expression: The most concise way to spell them is with overloaded operators: @geindex operator- (C++ function) -@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueE}@anchor{259}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueE}@anchor{25a}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueE}@anchor{25b}@anchor{cp/topics/expressions sub-operator__gccjit rvalue}@anchor{25c} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator@w{-} (gccjit::rvalue a) +@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueE}@anchor{269}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueE}@anchor{26a}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueE}@anchor{26b}@anchor{cp/topics/expressions sub-operator__gccjit rvalue}@anchor{26c} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator@w{-} (gccjit::rvalue a) @example gccjit::rvalue negpi = -pi; @@ -13702,8 +14054,8 @@ gccjit::rvalue negpi = -pi; @end deffn @geindex operator~ (C++ function) -@anchor{cp/topics/expressions _CPPv4coN6gccjit6rvalueE}@anchor{25d}@anchor{cp/topics/expressions _CPPv3coN6gccjit6rvalueE}@anchor{25e}@anchor{cp/topics/expressions _CPPv2coN6gccjit6rvalueE}@anchor{25f}@anchor{cp/topics/expressions inv-operator__gccjit rvalue}@anchor{260} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator~ (gccjit::rvalue a) +@anchor{cp/topics/expressions _CPPv4coN6gccjit6rvalueE}@anchor{26d}@anchor{cp/topics/expressions _CPPv3coN6gccjit6rvalueE}@anchor{26e}@anchor{cp/topics/expressions _CPPv2coN6gccjit6rvalueE}@anchor{26f}@anchor{cp/topics/expressions inv-operator__gccjit rvalue}@anchor{270} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator~ (gccjit::rvalue a) @example gccjit::rvalue mask = ~a; @@ -13711,8 +14063,8 @@ gccjit::rvalue mask = ~a; @end deffn @geindex operator! (C++ function) -@anchor{cp/topics/expressions _CPPv4ntN6gccjit6rvalueE}@anchor{261}@anchor{cp/topics/expressions _CPPv3ntN6gccjit6rvalueE}@anchor{262}@anchor{cp/topics/expressions _CPPv2ntN6gccjit6rvalueE}@anchor{263}@anchor{cp/topics/expressions not-operator__gccjit rvalue}@anchor{264} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator! (gccjit::rvalue a) +@anchor{cp/topics/expressions _CPPv4ntN6gccjit6rvalueE}@anchor{271}@anchor{cp/topics/expressions _CPPv3ntN6gccjit6rvalueE}@anchor{272}@anchor{cp/topics/expressions _CPPv2ntN6gccjit6rvalueE}@anchor{273}@anchor{cp/topics/expressions not-operator__gccjit rvalue}@anchor{274} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator! (gccjit::rvalue a) @example gccjit::rvalue guard = !cond; @@ -13720,13 +14072,13 @@ gccjit::rvalue guard = !cond; @end deffn @node Binary Operations<2>,Comparisons<2>,Unary Operations<2>,Rvalues<2> -@anchor{cp/topics/expressions binary-operations}@anchor{265} +@anchor{cp/topics/expressions binary-operations}@anchor{275} @subsubsection Binary Operations @geindex gccjit;;context;;new_binary_op (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{16d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{266}@anchor{cp/topics/expressions _CPPv2N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{267}@anchor{cp/topics/expressions gccjit context new_binary_op__gcc_jit_binary_op gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{268} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_binary_op (enum gcc_jit_binary_op, gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{17d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{276}@anchor{cp/topics/expressions _CPPv2N6gccjit7context13new_binary_opE17gcc_jit_binary_opN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{277}@anchor{cp/topics/expressions gccjit context new_binary_op__gcc_jit_binary_op gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{278} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_binary_op (enum gcc_jit_binary_op, gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) Build a binary operation out of two constituent rvalues. @@ -13741,60 +14093,60 @@ There are shorter ways to spell the various specific kinds of binary operation: @geindex gccjit;;context;;new_plus (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{269}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26b}@anchor{cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{26c} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_plus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{279}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_plusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27b}@anchor{cp/topics/expressions gccjit context new_plus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{27c} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_plus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_minus (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{26f}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{270} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context9new_minusEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27f}@anchor{cp/topics/expressions gccjit context new_minus__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{280} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_minus (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_mult (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{271}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{272}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{273}@anchor{cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{274} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_mult (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{281}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{282}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_multEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{283}@anchor{cp/topics/expressions gccjit context new_mult__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{284} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_mult (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_divide (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{275}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{276}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{277}@anchor{cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{278} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_divide (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{285}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{286}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_divideEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{287}@anchor{cp/topics/expressions gccjit context new_divide__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{288} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_divide (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_modulo (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{279}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27b}@anchor{cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{27c} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_modulo (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{289}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_moduloEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28b}@anchor{cp/topics/expressions gccjit context new_modulo__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{28c} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_modulo (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_bitwise_and (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{27f}@anchor{cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{280} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_bitwise_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28f}@anchor{cp/topics/expressions gccjit context new_bitwise_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{290} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_bitwise_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_bitwise_xor (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{281}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{282}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{283}@anchor{cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{284} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_bitwise_xor (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{291}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{292}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_bitwise_xorEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{293}@anchor{cp/topics/expressions gccjit context new_bitwise_xor__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{294} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_bitwise_xor (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_bitwise_or (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{285}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{286}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{287}@anchor{cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{288} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_bitwise_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{295}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{296}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_bitwise_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{297}@anchor{cp/topics/expressions gccjit context new_bitwise_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{298} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_bitwise_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_logical_and (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{289}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28b}@anchor{cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{28c} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_logical_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{299}@anchor{cp/topics/expressions _CPPv3N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context15new_logical_andEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29b}@anchor{cp/topics/expressions gccjit context new_logical_and__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{29c} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_logical_and (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_logical_or (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{28f}@anchor{cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{290} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_logical_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29d}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29e}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_logical_orEN6gccjit4typeEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{29f}@anchor{cp/topics/expressions gccjit context new_logical_or__gccjit type gccjit rvalue gccjit rvalue gccjit location}@anchor{2a0} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_logical_or (gccjit::type result_type, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn The most concise way to spell them is with overloaded operators: @geindex operator+ (C++ function) -@anchor{cp/topics/expressions _CPPv4plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{291}@anchor{cp/topics/expressions _CPPv3plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{292}@anchor{cp/topics/expressions _CPPv2plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{293}@anchor{cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue}@anchor{294} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator+ (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a1}@anchor{cp/topics/expressions _CPPv3plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a2}@anchor{cp/topics/expressions _CPPv2plN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a3}@anchor{cp/topics/expressions add-operator__gccjit rvalue gccjit rvalue}@anchor{2a4} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator+ (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue sum = a + b; @@ -13802,8 +14154,8 @@ gccjit::rvalue sum = a + b; @end deffn @geindex operator- (C++ function) -@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{295}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{296}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{297}@anchor{cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue}@anchor{298} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator@w{-} (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a5}@anchor{cp/topics/expressions _CPPv3miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a6}@anchor{cp/topics/expressions _CPPv2miN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a7}@anchor{cp/topics/expressions sub-operator__gccjit rvalue gccjit rvalue}@anchor{2a8} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator@w{-} (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue diff = a - b; @@ -13811,8 +14163,8 @@ gccjit::rvalue diff = a - b; @end deffn @geindex operator* (C++ function) -@anchor{cp/topics/expressions _CPPv4mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{299}@anchor{cp/topics/expressions _CPPv3mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29a}@anchor{cp/topics/expressions _CPPv2mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29b}@anchor{cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue}@anchor{29c} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator* (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a9}@anchor{cp/topics/expressions _CPPv3mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2aa}@anchor{cp/topics/expressions _CPPv2mlN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ab}@anchor{cp/topics/expressions mul-operator__gccjit rvalue gccjit rvalue}@anchor{2ac} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator* (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue prod = a * b; @@ -13820,8 +14172,8 @@ gccjit::rvalue prod = a * b; @end deffn @geindex operator/ (C++ function) -@anchor{cp/topics/expressions _CPPv4dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29d}@anchor{cp/topics/expressions _CPPv3dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29e}@anchor{cp/topics/expressions _CPPv2dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{29f}@anchor{cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue}@anchor{2a0} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator/ (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ad}@anchor{cp/topics/expressions _CPPv3dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ae}@anchor{cp/topics/expressions _CPPv2dvN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2af}@anchor{cp/topics/expressions div-operator__gccjit rvalue gccjit rvalue}@anchor{2b0} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator/ (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue result = a / b; @@ -13829,8 +14181,8 @@ gccjit::rvalue result = a / b; @end deffn @geindex operator% (C++ function) -@anchor{cp/topics/expressions _CPPv4rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a1}@anchor{cp/topics/expressions _CPPv3rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a2}@anchor{cp/topics/expressions _CPPv2rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a3}@anchor{cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue}@anchor{2a4} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator% (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b1}@anchor{cp/topics/expressions _CPPv3rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b2}@anchor{cp/topics/expressions _CPPv2rmN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b3}@anchor{cp/topics/expressions mod-operator__gccjit rvalue gccjit rvalue}@anchor{2b4} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator% (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue mod = a % b; @@ -13838,8 +14190,8 @@ gccjit::rvalue mod = a % b; @end deffn @geindex operator& (C++ function) -@anchor{cp/topics/expressions _CPPv4anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a5}@anchor{cp/topics/expressions _CPPv3anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a6}@anchor{cp/topics/expressions _CPPv2anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a7}@anchor{cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue}@anchor{2a8} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator& (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b5}@anchor{cp/topics/expressions _CPPv3anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b6}@anchor{cp/topics/expressions _CPPv2anN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b7}@anchor{cp/topics/expressions and-operator__gccjit rvalue gccjit rvalue}@anchor{2b8} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator& (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue x = a & b; @@ -13847,8 +14199,8 @@ gccjit::rvalue x = a & b; @end deffn @geindex operator^ (C++ function) -@anchor{cp/topics/expressions _CPPv4eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2a9}@anchor{cp/topics/expressions _CPPv3eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2aa}@anchor{cp/topics/expressions _CPPv2eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ab}@anchor{cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue}@anchor{2ac} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator^ (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b9}@anchor{cp/topics/expressions _CPPv3eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ba}@anchor{cp/topics/expressions _CPPv2eoN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2bb}@anchor{cp/topics/expressions xor-operator__gccjit rvalue gccjit rvalue}@anchor{2bc} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator^ (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue x = a ^ b; @@ -13856,8 +14208,8 @@ gccjit::rvalue x = a ^ b; @end deffn @geindex operator| (C++ function) -@anchor{cp/topics/expressions _CPPv4orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ad}@anchor{cp/topics/expressions _CPPv3orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ae}@anchor{cp/topics/expressions _CPPv2orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2af}@anchor{cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue}@anchor{2b0} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator| (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2bd}@anchor{cp/topics/expressions _CPPv3orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2be}@anchor{cp/topics/expressions _CPPv2orN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2bf}@anchor{cp/topics/expressions or-operator__gccjit rvalue gccjit rvalue}@anchor{2c0} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator| (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue x = a | b; @@ -13865,8 +14217,8 @@ gccjit::rvalue x = a | b; @end deffn @geindex operator&& (C++ function) -@anchor{cp/topics/expressions _CPPv4aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b1}@anchor{cp/topics/expressions _CPPv3aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b2}@anchor{cp/topics/expressions _CPPv2aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b3}@anchor{cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue}@anchor{2b4} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator&& (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c1}@anchor{cp/topics/expressions _CPPv3aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c2}@anchor{cp/topics/expressions _CPPv2aaN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c3}@anchor{cp/topics/expressions sand-operator__gccjit rvalue gccjit rvalue}@anchor{2c4} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator&& (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = a && b; @@ -13874,8 +14226,8 @@ gccjit::rvalue cond = a && b; @end deffn @geindex operator|| (C++ function) -@anchor{cp/topics/expressions _CPPv4ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b5}@anchor{cp/topics/expressions _CPPv3ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b6}@anchor{cp/topics/expressions _CPPv2ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2b7}@anchor{cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue}@anchor{2b8} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator|| (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c5}@anchor{cp/topics/expressions _CPPv3ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c6}@anchor{cp/topics/expressions _CPPv2ooN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2c7}@anchor{cp/topics/expressions sor-operator__gccjit rvalue gccjit rvalue}@anchor{2c8} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator|| (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = a || b; @@ -13893,13 +14245,13 @@ gccjit::rvalue discriminant = (b * b) - (four * a * c); @end quotation @node Comparisons<2>,Function calls<2>,Binary Operations<2>,Rvalues<2> -@anchor{cp/topics/expressions comparisons}@anchor{2b9} +@anchor{cp/topics/expressions comparisons}@anchor{2c9} @subsubsection Comparisons @geindex gccjit;;context;;new_comparison (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{17f}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ba}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2bb}@anchor{cp/topics/expressions gccjit context new_comparison__gcc_jit_comparison gccjit rvalue gccjit rvalue gccjit location}@anchor{2bc} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_comparison (enum gcc_jit_comparison, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{18f}@anchor{cp/topics/expressions _CPPv3N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ca}@anchor{cp/topics/expressions _CPPv2N6gccjit7context14new_comparisonE18gcc_jit_comparisonN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cb}@anchor{cp/topics/expressions gccjit context new_comparison__gcc_jit_comparison gccjit rvalue gccjit rvalue gccjit location}@anchor{2cc} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_comparison (enum gcc_jit_comparison, gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) Build a boolean rvalue out of the comparison of two other rvalues. @@ -13914,40 +14266,40 @@ There are shorter ways to spell the various specific kinds of binary operation: @geindex gccjit;;context;;new_eq (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2bd}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2be}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2bf}@anchor{cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location}@anchor{2c0} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_eq (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cd}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ce}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_eqEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cf}@anchor{cp/topics/expressions gccjit context new_eq__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d0} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_eq (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_ne (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c3}@anchor{cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location}@anchor{2c4} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_ne (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_neEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d3}@anchor{cp/topics/expressions gccjit context new_ne__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d4} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_ne (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_lt (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c5}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c6}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c7}@anchor{cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2c8} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_lt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d5}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d6}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_ltEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d7}@anchor{cp/topics/expressions gccjit context new_lt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d8} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_lt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_le (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2c9}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ca}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cb}@anchor{cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location}@anchor{2cc} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_le (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d9}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2da}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_leEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2db}@anchor{cp/topics/expressions gccjit context new_le__gccjit rvalue gccjit rvalue gccjit location}@anchor{2dc} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_le (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_gt (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cd}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2ce}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2cf}@anchor{cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d0} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_gt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2dd}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2de}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_gtEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2df}@anchor{cp/topics/expressions gccjit context new_gt__gccjit rvalue gccjit rvalue gccjit location}@anchor{2e0} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_gt (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn @geindex gccjit;;context;;new_ge (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2d3}@anchor{cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location}@anchor{2d4} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_ge (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2e1}@anchor{cp/topics/expressions _CPPv3N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2e2}@anchor{cp/topics/expressions _CPPv2N6gccjit7context6new_geEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2e3}@anchor{cp/topics/expressions gccjit context new_ge__gccjit rvalue gccjit rvalue gccjit location}@anchor{2e4} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_ge (gccjit::rvalue a, gccjit::rvalue b, gccjit::location loc) @end deffn The most concise way to spell them is with overloaded operators: @geindex operator== (C++ function) -@anchor{cp/topics/expressions _CPPv4eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d5}@anchor{cp/topics/expressions _CPPv3eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d6}@anchor{cp/topics/expressions _CPPv2eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d7}@anchor{cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue}@anchor{2d8} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator== (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e5}@anchor{cp/topics/expressions _CPPv3eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e6}@anchor{cp/topics/expressions _CPPv2eqN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e7}@anchor{cp/topics/expressions eq-operator__gccjit rvalue gccjit rvalue}@anchor{2e8} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator== (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = (a == ctxt.zero (t_int)); @@ -13955,8 +14307,8 @@ gccjit::rvalue cond = (a == ctxt.zero (t_int)); @end deffn @geindex operator!= (C++ function) -@anchor{cp/topics/expressions _CPPv4neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2d9}@anchor{cp/topics/expressions _CPPv3neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2da}@anchor{cp/topics/expressions _CPPv2neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2db}@anchor{cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue}@anchor{2dc} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator!= (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e9}@anchor{cp/topics/expressions _CPPv3neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ea}@anchor{cp/topics/expressions _CPPv2neN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2eb}@anchor{cp/topics/expressions neq-operator__gccjit rvalue gccjit rvalue}@anchor{2ec} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator!= (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = (i != j); @@ -13964,8 +14316,8 @@ gccjit::rvalue cond = (i != j); @end deffn @geindex operator< (C++ function) -@anchor{cp/topics/expressions _CPPv4ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2dd}@anchor{cp/topics/expressions _CPPv3ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2de}@anchor{cp/topics/expressions _CPPv2ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2df}@anchor{cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue}@anchor{2e0} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator< (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ed}@anchor{cp/topics/expressions _CPPv3ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ee}@anchor{cp/topics/expressions _CPPv2ltN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ef}@anchor{cp/topics/expressions lt-operator__gccjit rvalue gccjit rvalue}@anchor{2f0} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator< (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = i < n; @@ -13973,8 +14325,8 @@ gccjit::rvalue cond = i < n; @end deffn @geindex operator<= (C++ function) -@anchor{cp/topics/expressions _CPPv4leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e1}@anchor{cp/topics/expressions _CPPv3leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e2}@anchor{cp/topics/expressions _CPPv2leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e3}@anchor{cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue}@anchor{2e4} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator<= (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f1}@anchor{cp/topics/expressions _CPPv3leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f2}@anchor{cp/topics/expressions _CPPv2leN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f3}@anchor{cp/topics/expressions lte-operator__gccjit rvalue gccjit rvalue}@anchor{2f4} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator<= (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = i <= n; @@ -13982,8 +14334,8 @@ gccjit::rvalue cond = i <= n; @end deffn @geindex operator> (C++ function) -@anchor{cp/topics/expressions _CPPv4gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e5}@anchor{cp/topics/expressions _CPPv3gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e6}@anchor{cp/topics/expressions _CPPv2gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e7}@anchor{cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue}@anchor{2e8} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator> (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f5}@anchor{cp/topics/expressions _CPPv3gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f6}@anchor{cp/topics/expressions _CPPv2gtN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f7}@anchor{cp/topics/expressions gt-operator__gccjit rvalue gccjit rvalue}@anchor{2f8} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator> (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = (ch > limit); @@ -13991,8 +14343,8 @@ gccjit::rvalue cond = (ch > limit); @end deffn @geindex operator>= (C++ function) -@anchor{cp/topics/expressions _CPPv4geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2e9}@anchor{cp/topics/expressions _CPPv3geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2ea}@anchor{cp/topics/expressions _CPPv2geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2eb}@anchor{cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue}@anchor{2ec} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} operator>= (gccjit::rvalue a, gccjit::rvalue b) +@anchor{cp/topics/expressions _CPPv4geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2f9}@anchor{cp/topics/expressions _CPPv3geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2fa}@anchor{cp/topics/expressions _CPPv2geN6gccjit6rvalueEN6gccjit6rvalueE}@anchor{2fb}@anchor{cp/topics/expressions gte-operator__gccjit rvalue gccjit rvalue}@anchor{2fc} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} operator>= (gccjit::rvalue a, gccjit::rvalue b) @example gccjit::rvalue cond = (score >= ctxt.new_rvalue (t_int, 100)); @@ -14002,12 +14354,12 @@ gccjit::rvalue cond = (score >= ctxt.new_rvalue (t_int, 100)); @c TODO: beyond this point @node Function calls<2>,Function pointers<3>,Comparisons<2>,Rvalues<2> -@anchor{cp/topics/expressions function-calls}@anchor{2ed} +@anchor{cp/topics/expressions function-calls}@anchor{2fd} @subsubsection Function calls @geindex gcc_jit_context_new_call (C++ function) -@anchor{cp/topics/expressions _CPPv424gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2ee}@anchor{cp/topics/expressions _CPPv324gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2ef}@anchor{cp/topics/expressions _CPPv224gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2f0}@anchor{cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP}@anchor{2f1} +@anchor{cp/topics/expressions _CPPv424gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2fe}@anchor{cp/topics/expressions _CPPv324gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{2ff}@anchor{cp/topics/expressions _CPPv224gcc_jit_context_new_callP15gcc_jit_contextP16gcc_jit_locationP16gcc_jit_functioniPP14gcc_jit_rvalue}@anchor{300}@anchor{cp/topics/expressions gcc_jit_context_new_call__gcc_jit_contextP gcc_jit_locationP gcc_jit_functionP i gcc_jit_rvaluePP}@anchor{301} @deffn {C++ Function} gcc_jit_rvalue *gcc_jit_context_new_call (gcc_jit_context *ctxt, gcc_jit_location *loc, gcc_jit_function *func, int numargs, gcc_jit_rvalue **args) Given a function and the given table of argument rvalues, construct a @@ -14016,14 +14368,14 @@ call to the function, with the result as an rvalue. @cartouche @quotation Note @code{gccjit::context::new_call()} merely builds a -@ref{16e,,gccjit;;rvalue} i.e. an expression that can be evaluated, +@ref{17e,,gccjit;;rvalue} i.e. an expression that can be evaluated, perhaps as part of a more complicated expression. The call @emph{won’t} happen unless you add a statement to a function that evaluates the expression. For example, if you want to call a function and discard the result (or to call a function with @code{void} return type), use -@ref{2f2,,gccjit;;block;;add_eval()}: +@ref{302,,gccjit;;block;;add_eval()}: @example /* Add "(void)printf (arg0, arg1);". */ @@ -14034,26 +14386,26 @@ block.add_eval (ctxt.new_call (printf_func, arg0, arg1)); @end deffn @node Function pointers<3>,Type-coercion<2>,Function calls<2>,Rvalues<2> -@anchor{cp/topics/expressions function-pointers}@anchor{2f3} +@anchor{cp/topics/expressions function-pointers}@anchor{303} @subsubsection Function pointers @geindex gccjit;;function;;get_address (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2f4}@anchor{cp/topics/expressions _CPPv3N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2f5}@anchor{cp/topics/expressions _CPPv2N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{2f6}@anchor{cp/topics/expressions gccjit function get_address__gccjit location}@anchor{2f7} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{17c,,function}::get_address (gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{304}@anchor{cp/topics/expressions _CPPv3N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{305}@anchor{cp/topics/expressions _CPPv2N6gccjit8function11get_addressEN6gccjit8locationE}@anchor{306}@anchor{cp/topics/expressions gccjit function get_address__gccjit location}@anchor{307} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{18c,,function}::get_address (gccjit::location loc) Get the address of a function as an rvalue, of function pointer type. @end deffn @node Type-coercion<2>,,Function pointers<3>,Rvalues<2> -@anchor{cp/topics/expressions type-coercion}@anchor{2f8} +@anchor{cp/topics/expressions type-coercion}@anchor{308} @subsubsection Type-coercion @geindex gccjit;;context;;new_cast (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2f9}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2fa}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{2fb}@anchor{cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location}@anchor{2fc} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{165,,context}::new_cast (gccjit::rvalue rvalue, gccjit::type type, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{309}@anchor{cp/topics/expressions _CPPv3N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{30a}@anchor{cp/topics/expressions _CPPv2N6gccjit7context8new_castEN6gccjit6rvalueEN6gccjit4typeEN6gccjit8locationE}@anchor{30b}@anchor{cp/topics/expressions gccjit context new_cast__gccjit rvalue gccjit type gccjit location}@anchor{30c} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{175,,context}::new_cast (gccjit::rvalue rvalue, gccjit::type type, gccjit::location loc) Given an rvalue of T, construct another rvalue of another type. @@ -14077,25 +14429,25 @@ P* <-> Q*, for pointer types P and Q @end deffn @node Lvalues<2>,Working with pointers structs and unions<2>,Rvalues<2>,Expressions<2> -@anchor{cp/topics/expressions lvalues}@anchor{2fd} +@anchor{cp/topics/expressions lvalues}@anchor{30d} @subsubsection Lvalues @geindex gccjit;;lvalue (C++ class) -@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalueE}@anchor{177}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalueE}@anchor{2fe}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalueE}@anchor{2ff}@anchor{cp/topics/expressions gccjit lvalue}@anchor{300} +@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalueE}@anchor{187}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalueE}@anchor{30e}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalueE}@anchor{30f}@anchor{cp/topics/expressions gccjit lvalue}@anchor{310} @deffn {C++ Class} gccjit::lvalue @end deffn An lvalue is something that can of the @emph{left}-hand side of an assignment: a storage area (such as a variable). It is a subclass of -@ref{16e,,gccjit;;rvalue}, where the rvalue is computed by reading from the +@ref{17e,,gccjit;;rvalue}, where the rvalue is computed by reading from the storage area. It iss a thin wrapper around @ref{24,,gcc_jit_lvalue *} from the C API. @geindex gccjit;;lvalue;;get_address (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{301}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{302}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{303}@anchor{cp/topics/expressions gccjit lvalue get_address__gccjit location}@anchor{304} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{177,,lvalue}::get_address (gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{311}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{312}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue11get_addressEN6gccjit8locationE}@anchor{313}@anchor{cp/topics/expressions gccjit lvalue get_address__gccjit location}@anchor{314} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{187,,lvalue}::get_address (gccjit::location loc) Take the address of an lvalue; analogous to: @@ -14114,28 +14466,28 @@ Parameter “loc” is optional. @end menu @node Global variables<2>,,,Lvalues<2> -@anchor{cp/topics/expressions global-variables}@anchor{305} +@anchor{cp/topics/expressions global-variables}@anchor{315} @subsubsection Global variables @geindex gccjit;;context;;new_global (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{306}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{307}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{308}@anchor{cp/topics/expressions gccjit context new_global__gcc_jit_global_kind gccjit type cCP gccjit location}@anchor{309} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{165,,context}::new_global (enum gcc_jit_global_kind, gccjit::type type, const char *name, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{316}@anchor{cp/topics/expressions _CPPv3N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{317}@anchor{cp/topics/expressions _CPPv2N6gccjit7context10new_globalE19gcc_jit_global_kindN6gccjit4typeEPKcN6gccjit8locationE}@anchor{318}@anchor{cp/topics/expressions gccjit context new_global__gcc_jit_global_kind gccjit type cCP gccjit location}@anchor{319} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{175,,context}::new_global (enum gcc_jit_global_kind, gccjit::type type, const char *name, gccjit::location loc) Add a new global variable of the given type and name to the context. -This is a thin wrapper around @ref{ea,,gcc_jit_context_new_global()} from +This is a thin wrapper around @ref{f5,,gcc_jit_context_new_global()} from the C API; the “kind” parameter has the same meaning as there. @end deffn @node Working with pointers structs and unions<2>,,Lvalues<2>,Expressions<2> -@anchor{cp/topics/expressions working-with-pointers-structs-and-unions}@anchor{30a} +@anchor{cp/topics/expressions working-with-pointers-structs-and-unions}@anchor{31a} @subsubsection Working with pointers, structs and unions @geindex gccjit;;rvalue;;dereference (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{30b}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{30c}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{30d}@anchor{cp/topics/expressions gccjit rvalue dereference__gccjit location}@anchor{30e} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{16e,,rvalue}::dereference (gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{31b}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{31c}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue11dereferenceEN6gccjit8locationE}@anchor{31d}@anchor{cp/topics/expressions gccjit rvalue dereference__gccjit location}@anchor{31e} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{17e,,rvalue}::dereference (gccjit::location loc) Given an rvalue of pointer type @code{T *}, dereferencing the pointer, getting an lvalue of type @code{T}. Analogous to: @@ -14153,8 +14505,8 @@ If you don’t need to specify the location, this can also be expressed using an overloaded operator: @geindex gccjit;;rvalue;;operator* (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6rvaluemlEv}@anchor{30f}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvaluemlEv}@anchor{310}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvaluemlEv}@anchor{311}@anchor{cp/topics/expressions gccjit rvalue mul-operator}@anchor{312} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{16e,,rvalue}::operator* () +@anchor{cp/topics/expressions _CPPv4N6gccjit6rvaluemlEv}@anchor{31f}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvaluemlEv}@anchor{320}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvaluemlEv}@anchor{321}@anchor{cp/topics/expressions gccjit rvalue mul-operator}@anchor{322} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{17e,,rvalue}::operator* () @example gccjit::lvalue content = *ptr; @@ -14164,8 +14516,8 @@ gccjit::lvalue content = *ptr; Field access is provided separately for both lvalues and rvalues: @geindex gccjit;;lvalue;;access_field (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{313}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{314}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{315}@anchor{cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location}@anchor{316} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{177,,lvalue}::access_field (gccjit::field field, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{323}@anchor{cp/topics/expressions _CPPv3N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{324}@anchor{cp/topics/expressions _CPPv2N6gccjit6lvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{325}@anchor{cp/topics/expressions gccjit lvalue access_field__gccjit field gccjit location}@anchor{326} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{187,,lvalue}::access_field (gccjit::field field, gccjit::location loc) Given an lvalue of struct or union type, access the given field, getting an lvalue of the field’s type. Analogous to: @@ -14178,8 +14530,8 @@ in C. @end deffn @geindex gccjit;;rvalue;;access_field (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{317}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{318}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{319}@anchor{cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location}@anchor{31a} -@deffn {C++ Function} gccjit::@ref{16e,,rvalue} gccjit::@ref{16e,,rvalue}::access_field (gccjit::field field, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{327}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{328}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue12access_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{329}@anchor{cp/topics/expressions gccjit rvalue access_field__gccjit field gccjit location}@anchor{32a} +@deffn {C++ Function} gccjit::@ref{17e,,rvalue} gccjit::@ref{17e,,rvalue}::access_field (gccjit::field field, gccjit::location loc) Given an rvalue of struct or union type, access the given field as an rvalue. Analogous to: @@ -14192,8 +14544,8 @@ in C. @end deffn @geindex gccjit;;rvalue;;dereference_field (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{31b}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{31c}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{31d}@anchor{cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location}@anchor{31e} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{16e,,rvalue}::dereference_field (gccjit::field field, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{32b}@anchor{cp/topics/expressions _CPPv3N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{32c}@anchor{cp/topics/expressions _CPPv2N6gccjit6rvalue17dereference_fieldEN6gccjit5fieldEN6gccjit8locationE}@anchor{32d}@anchor{cp/topics/expressions gccjit rvalue dereference_field__gccjit field gccjit location}@anchor{32e} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{17e,,rvalue}::dereference_field (gccjit::field field, gccjit::location loc) Given an rvalue of pointer type @code{T *} where T is of struct or union type, access the given field as an lvalue. Analogous to: @@ -14206,8 +14558,8 @@ in C, itself equivalent to @code{(*EXPR).FIELD}. @end deffn @geindex gccjit;;context;;new_array_access (C++ function) -@anchor{cp/topics/expressions _CPPv4N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{31f}@anchor{cp/topics/expressions _CPPv3N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{320}@anchor{cp/topics/expressions _CPPv2N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{321}@anchor{cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location}@anchor{322} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{165,,context}::new_array_access (gccjit::rvalue ptr, gccjit::rvalue index, gccjit::location loc) +@anchor{cp/topics/expressions _CPPv4N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{32f}@anchor{cp/topics/expressions _CPPv3N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{330}@anchor{cp/topics/expressions _CPPv2N6gccjit7context16new_array_accessEN6gccjit6rvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{331}@anchor{cp/topics/expressions gccjit context new_array_access__gccjit rvalue gccjit rvalue gccjit location}@anchor{332} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{175,,context}::new_array_access (gccjit::rvalue ptr, gccjit::rvalue index, gccjit::location loc) Given an rvalue of pointer type @code{T *}, get at the element @cite{T} at the given index, using standard C array indexing rules i.e. each @@ -14223,7 +14575,7 @@ in C (or, indeed, to @code{PTR + INDEX}). Parameter “loc” is optional. @end deffn -For array accesses where you don’t need to specify a @ref{18b,,gccjit;;location}, +For array accesses where you don’t need to specify a @ref{19b,,gccjit;;location}, two overloaded operators are available: @quotation @@ -14259,7 +14611,7 @@ gccjit::lvalue element = array[0]; @c <https://www.gnu.org/licenses/>. @node Creating and using functions<2>,Source Locations<2>,Expressions<2>,Topic Reference<2> -@anchor{cp/topics/functions doc}@anchor{323}@anchor{cp/topics/functions creating-and-using-functions}@anchor{324} +@anchor{cp/topics/functions doc}@anchor{333}@anchor{cp/topics/functions creating-and-using-functions}@anchor{334} @subsection Creating and using functions @@ -14272,36 +14624,36 @@ gccjit::lvalue element = array[0]; @end menu @node Params<2>,Functions<2>,,Creating and using functions<2> -@anchor{cp/topics/functions params}@anchor{325} +@anchor{cp/topics/functions params}@anchor{335} @subsubsection Params @geindex gccjit;;param (C++ class) -@anchor{cp/topics/functions _CPPv4N6gccjit5paramE}@anchor{178}@anchor{cp/topics/functions _CPPv3N6gccjit5paramE}@anchor{326}@anchor{cp/topics/functions _CPPv2N6gccjit5paramE}@anchor{327}@anchor{cp/topics/functions gccjit param}@anchor{328} +@anchor{cp/topics/functions _CPPv4N6gccjit5paramE}@anchor{188}@anchor{cp/topics/functions _CPPv3N6gccjit5paramE}@anchor{336}@anchor{cp/topics/functions _CPPv2N6gccjit5paramE}@anchor{337}@anchor{cp/topics/functions gccjit param}@anchor{338} @deffn {C++ Class} gccjit::param A @cite{gccjit::param} represents a parameter to a function. @end deffn @geindex gccjit;;context;;new_param (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{16c}@anchor{cp/topics/functions _CPPv3N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{329}@anchor{cp/topics/functions _CPPv2N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{32a}@anchor{cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location}@anchor{32b} -@deffn {C++ Function} gccjit::@ref{178,,param} gccjit::@ref{165,,context}::new_param (gccjit::type type, const char *name, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{17c}@anchor{cp/topics/functions _CPPv3N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{339}@anchor{cp/topics/functions _CPPv2N6gccjit7context9new_paramEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{33a}@anchor{cp/topics/functions gccjit context new_param__gccjit type cCP gccjit location}@anchor{33b} +@deffn {C++ Function} gccjit::@ref{188,,param} gccjit::@ref{175,,context}::new_param (gccjit::type type, const char *name, gccjit::location loc) In preparation for creating a function, create a new parameter of the given type and name. @end deffn -@ref{178,,gccjit;;param} is a subclass of @ref{177,,gccjit;;lvalue} (and thus -of @ref{16e,,gccjit;;rvalue} and @ref{16a,,gccjit;;object}). It is a thin +@ref{188,,gccjit;;param} is a subclass of @ref{187,,gccjit;;lvalue} (and thus +of @ref{17e,,gccjit;;rvalue} and @ref{17a,,gccjit;;object}). It is a thin wrapper around the C API’s @ref{25,,gcc_jit_param *}. @node Functions<2>,Blocks<2>,Params<2>,Creating and using functions<2> -@anchor{cp/topics/functions functions}@anchor{32c} +@anchor{cp/topics/functions functions}@anchor{33c} @subsubsection Functions @geindex gccjit;;function (C++ class) -@anchor{cp/topics/functions _CPPv4N6gccjit8functionE}@anchor{17c}@anchor{cp/topics/functions _CPPv3N6gccjit8functionE}@anchor{32d}@anchor{cp/topics/functions _CPPv2N6gccjit8functionE}@anchor{32e}@anchor{cp/topics/functions gccjit function}@anchor{32f} +@anchor{cp/topics/functions _CPPv4N6gccjit8functionE}@anchor{18c}@anchor{cp/topics/functions _CPPv3N6gccjit8functionE}@anchor{33d}@anchor{cp/topics/functions _CPPv2N6gccjit8functionE}@anchor{33e}@anchor{cp/topics/functions gccjit function}@anchor{33f} @deffn {C++ Class} gccjit::function A @cite{gccjit::function} represents a function - either one that we’re @@ -14309,8 +14661,8 @@ creating ourselves, or one that we’re referencing. @end deffn @geindex gccjit;;context;;new_function (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{330}@anchor{cp/topics/functions _CPPv3N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{331}@anchor{cp/topics/functions _CPPv2N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{332}@anchor{cp/topics/functions gccjit context new_function__gcc_jit_function_kind gccjit type cCP std vector param R i gccjit location}@anchor{333} -@deffn {C++ Function} gccjit::@ref{17c,,function} gccjit::@ref{165,,context}::new_function (enum gcc_jit_function_kind, gccjit::type return_type, const char *name, std::vector<param> ¶ms, int is_variadic, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{340}@anchor{cp/topics/functions _CPPv3N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{341}@anchor{cp/topics/functions _CPPv2N6gccjit7context12new_functionE21gcc_jit_function_kindN6gccjit4typeEPKcRNSt6vectorI5paramEEiN6gccjit8locationE}@anchor{342}@anchor{cp/topics/functions gccjit context new_function__gcc_jit_function_kind gccjit type cCP std vector param R i gccjit location}@anchor{343} +@deffn {C++ Function} gccjit::@ref{18c,,function} gccjit::@ref{175,,context}::new_function (enum gcc_jit_function_kind, gccjit::type return_type, const char *name, std::vector<param> ¶ms, int is_variadic, gccjit::location loc) Create a gcc_jit_function with the given name and parameters. @@ -14320,49 +14672,49 @@ This is a wrapper around the C API’s @ref{11,,gcc_jit_context_new_function()}. @end deffn @geindex gccjit;;context;;get_builtin_function (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit7context20get_builtin_functionEPKc}@anchor{334}@anchor{cp/topics/functions _CPPv3N6gccjit7context20get_builtin_functionEPKc}@anchor{335}@anchor{cp/topics/functions _CPPv2N6gccjit7context20get_builtin_functionEPKc}@anchor{336}@anchor{cp/topics/functions gccjit context get_builtin_function__cCP}@anchor{337} -@deffn {C++ Function} gccjit::@ref{17c,,function} gccjit::@ref{165,,context}::get_builtin_function (const char *name) +@anchor{cp/topics/functions _CPPv4N6gccjit7context20get_builtin_functionEPKc}@anchor{344}@anchor{cp/topics/functions _CPPv3N6gccjit7context20get_builtin_functionEPKc}@anchor{345}@anchor{cp/topics/functions _CPPv2N6gccjit7context20get_builtin_functionEPKc}@anchor{346}@anchor{cp/topics/functions gccjit context get_builtin_function__cCP}@anchor{347} +@deffn {C++ Function} gccjit::@ref{18c,,function} gccjit::@ref{175,,context}::get_builtin_function (const char *name) This is a wrapper around the C API’s -@ref{103,,gcc_jit_context_get_builtin_function()}. +@ref{10e,,gcc_jit_context_get_builtin_function()}. @end deffn @geindex gccjit;;function;;get_param (C++ function) -@anchor{cp/topics/functions _CPPv4NK6gccjit8function9get_paramEi}@anchor{338}@anchor{cp/topics/functions _CPPv3NK6gccjit8function9get_paramEi}@anchor{339}@anchor{cp/topics/functions _CPPv2NK6gccjit8function9get_paramEi}@anchor{33a}@anchor{cp/topics/functions gccjit function get_param__iC}@anchor{33b} -@deffn {C++ Function} gccjit::@ref{178,,param} gccjit::@ref{17c,,function}::get_param (int index) const +@anchor{cp/topics/functions _CPPv4NK6gccjit8function9get_paramEi}@anchor{348}@anchor{cp/topics/functions _CPPv3NK6gccjit8function9get_paramEi}@anchor{349}@anchor{cp/topics/functions _CPPv2NK6gccjit8function9get_paramEi}@anchor{34a}@anchor{cp/topics/functions gccjit function get_param__iC}@anchor{34b} +@deffn {C++ Function} gccjit::@ref{188,,param} gccjit::@ref{18c,,function}::get_param (int index) const Get the param of the given index (0-based). @end deffn @geindex gccjit;;function;;dump_to_dot (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit8function11dump_to_dotEPKc}@anchor{184}@anchor{cp/topics/functions _CPPv3N6gccjit8function11dump_to_dotEPKc}@anchor{33c}@anchor{cp/topics/functions _CPPv2N6gccjit8function11dump_to_dotEPKc}@anchor{33d}@anchor{cp/topics/functions gccjit function dump_to_dot__cCP}@anchor{33e} -@deffn {C++ Function} void gccjit::@ref{17c,,function}::dump_to_dot (const char *path) +@anchor{cp/topics/functions _CPPv4N6gccjit8function11dump_to_dotEPKc}@anchor{194}@anchor{cp/topics/functions _CPPv3N6gccjit8function11dump_to_dotEPKc}@anchor{34c}@anchor{cp/topics/functions _CPPv2N6gccjit8function11dump_to_dotEPKc}@anchor{34d}@anchor{cp/topics/functions gccjit function dump_to_dot__cCP}@anchor{34e} +@deffn {C++ Function} void gccjit::@ref{18c,,function}::dump_to_dot (const char *path) Emit the function in graphviz format to the given path. @end deffn @geindex gccjit;;function;;new_local (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{179}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{33f}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{340}@anchor{cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location}@anchor{341} -@deffn {C++ Function} gccjit::@ref{177,,lvalue} gccjit::@ref{17c,,function}::new_local (gccjit::type type, const char *name, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{189}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{34f}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_localEN6gccjit4typeEPKcN6gccjit8locationE}@anchor{350}@anchor{cp/topics/functions gccjit function new_local__gccjit type cCP gccjit location}@anchor{351} +@deffn {C++ Function} gccjit::@ref{187,,lvalue} gccjit::@ref{18c,,function}::new_local (gccjit::type type, const char *name, gccjit::location loc) Create a new local variable within the function, of the given type and name. @end deffn @node Blocks<2>,Statements<2>,Functions<2>,Creating and using functions<2> -@anchor{cp/topics/functions blocks}@anchor{342} +@anchor{cp/topics/functions blocks}@anchor{352} @subsubsection Blocks @geindex gccjit;;block (C++ class) -@anchor{cp/topics/functions _CPPv4N6gccjit5blockE}@anchor{17b}@anchor{cp/topics/functions _CPPv3N6gccjit5blockE}@anchor{343}@anchor{cp/topics/functions _CPPv2N6gccjit5blockE}@anchor{344}@anchor{cp/topics/functions gccjit block}@anchor{345} +@anchor{cp/topics/functions _CPPv4N6gccjit5blockE}@anchor{18b}@anchor{cp/topics/functions _CPPv3N6gccjit5blockE}@anchor{353}@anchor{cp/topics/functions _CPPv2N6gccjit5blockE}@anchor{354}@anchor{cp/topics/functions gccjit block}@anchor{355} @deffn {C++ Class} gccjit::block A @cite{gccjit::block} represents a basic block within a function i.e. a sequence of statements with a single entry point and a single exit point. -@ref{17b,,gccjit;;block} is a subclass of @ref{16a,,gccjit;;object}. +@ref{18b,,gccjit;;block} is a subclass of @ref{17a,,gccjit;;object}. The first basic block that you create within a function will be the entrypoint. @@ -14376,8 +14728,8 @@ one function. @end deffn @geindex gccjit;;function;;new_block (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_blockEPKc}@anchor{346}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_blockEPKc}@anchor{347}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_blockEPKc}@anchor{348}@anchor{cp/topics/functions gccjit function new_block__cCP}@anchor{349} -@deffn {C++ Function} gccjit::@ref{17b,,block} gccjit::@ref{17c,,function}::new_block (const char *name) +@anchor{cp/topics/functions _CPPv4N6gccjit8function9new_blockEPKc}@anchor{356}@anchor{cp/topics/functions _CPPv3N6gccjit8function9new_blockEPKc}@anchor{357}@anchor{cp/topics/functions _CPPv2N6gccjit8function9new_blockEPKc}@anchor{358}@anchor{cp/topics/functions gccjit function new_block__cCP}@anchor{359} +@deffn {C++ Function} gccjit::@ref{18b,,block} gccjit::@ref{18c,,function}::new_block (const char *name) Create a basic block of the given name. The name may be NULL, but providing meaningful names is often helpful when debugging: it may @@ -14386,13 +14738,13 @@ messages. @end deffn @node Statements<2>,,Blocks<2>,Creating and using functions<2> -@anchor{cp/topics/functions statements}@anchor{34a} +@anchor{cp/topics/functions statements}@anchor{35a} @subsubsection Statements @geindex gccjit;;block;;add_eval (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{2f2}@anchor{cp/topics/functions _CPPv3N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34b}@anchor{cp/topics/functions _CPPv2N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34c}@anchor{cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location}@anchor{34d} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_eval (gccjit::rvalue rvalue, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{302}@anchor{cp/topics/functions _CPPv3N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35b}@anchor{cp/topics/functions _CPPv2N6gccjit5block8add_evalEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35c}@anchor{cp/topics/functions gccjit block add_eval__gccjit rvalue gccjit location}@anchor{35d} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::add_eval (gccjit::rvalue rvalue, gccjit::location loc) Add evaluation of an rvalue, discarding the result (e.g. a function call that “returns” void). @@ -14405,8 +14757,8 @@ This is equivalent to this C code: @end deffn @geindex gccjit;;block;;add_assignment (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{17d}@anchor{cp/topics/functions _CPPv3N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34e}@anchor{cp/topics/functions _CPPv2N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{34f}@anchor{cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location}@anchor{350} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_assignment (gccjit::lvalue lvalue, gccjit::rvalue rvalue, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{18d}@anchor{cp/topics/functions _CPPv3N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35e}@anchor{cp/topics/functions _CPPv2N6gccjit5block14add_assignmentEN6gccjit6lvalueEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35f}@anchor{cp/topics/functions gccjit block add_assignment__gccjit lvalue gccjit rvalue gccjit location}@anchor{360} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::add_assignment (gccjit::lvalue lvalue, gccjit::rvalue rvalue, gccjit::location loc) Add evaluation of an rvalue, assigning the result to the given lvalue. @@ -14419,8 +14771,8 @@ lvalue = rvalue; @end deffn @geindex gccjit;;block;;add_assignment_op (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{181}@anchor{cp/topics/functions _CPPv3N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{351}@anchor{cp/topics/functions _CPPv2N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{352}@anchor{cp/topics/functions gccjit block add_assignment_op__gccjit lvalue gcc_jit_binary_op gccjit rvalue gccjit location}@anchor{353} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_assignment_op (gccjit::lvalue lvalue, enum gcc_jit_binary_op, gccjit::rvalue rvalue, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{191}@anchor{cp/topics/functions _CPPv3N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{361}@anchor{cp/topics/functions _CPPv2N6gccjit5block17add_assignment_opEN6gccjit6lvalueE17gcc_jit_binary_opN6gccjit6rvalueEN6gccjit8locationE}@anchor{362}@anchor{cp/topics/functions gccjit block add_assignment_op__gccjit lvalue gcc_jit_binary_op gccjit rvalue gccjit location}@anchor{363} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::add_assignment_op (gccjit::lvalue lvalue, enum gcc_jit_binary_op, gccjit::rvalue rvalue, gccjit::location loc) Add evaluation of an rvalue, using the result to modify an lvalue. @@ -14445,8 +14797,8 @@ loop_body.add_assignment_op ( @end deffn @geindex gccjit;;block;;add_comment (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{18d}@anchor{cp/topics/functions _CPPv3N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{354}@anchor{cp/topics/functions _CPPv2N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{355}@anchor{cp/topics/functions gccjit block add_comment__cCP gccjit location}@anchor{356} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::add_comment (const char *text, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{19d}@anchor{cp/topics/functions _CPPv3N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{364}@anchor{cp/topics/functions _CPPv2N6gccjit5block11add_commentEPKcN6gccjit8locationE}@anchor{365}@anchor{cp/topics/functions gccjit block add_comment__cCP gccjit location}@anchor{366} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::add_comment (const char *text, gccjit::location loc) Add a no-op textual comment to the internal representation of the code. It will be optimized away, but will be visible in the dumps @@ -14459,8 +14811,8 @@ Parameter “loc” is optional. @end deffn @geindex gccjit;;block;;end_with_conditional (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{180}@anchor{cp/topics/functions _CPPv3N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{357}@anchor{cp/topics/functions _CPPv2N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{358}@anchor{cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location}@anchor{359} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_conditional (gccjit::rvalue boolval, gccjit::block on_true, gccjit::block on_false, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{190}@anchor{cp/topics/functions _CPPv3N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{367}@anchor{cp/topics/functions _CPPv2N6gccjit5block20end_with_conditionalEN6gccjit6rvalueEN6gccjit5blockEN6gccjit5blockEN6gccjit8locationE}@anchor{368}@anchor{cp/topics/functions gccjit block end_with_conditional__gccjit rvalue gccjit block gccjit block gccjit location}@anchor{369} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::end_with_conditional (gccjit::rvalue boolval, gccjit::block on_true, gccjit::block on_false, gccjit::location loc) Terminate a block by adding evaluation of an rvalue, branching on the result to the appropriate successor block. @@ -14478,8 +14830,8 @@ block, boolval, on_true, and on_false must be non-NULL. @end deffn @geindex gccjit;;block;;end_with_jump (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{35a}@anchor{cp/topics/functions _CPPv3N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{35b}@anchor{cp/topics/functions _CPPv2N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{35c}@anchor{cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location}@anchor{35d} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_jump (gccjit::block target, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{36a}@anchor{cp/topics/functions _CPPv3N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{36b}@anchor{cp/topics/functions _CPPv2N6gccjit5block13end_with_jumpEN6gccjit5blockEN6gccjit8locationE}@anchor{36c}@anchor{cp/topics/functions gccjit block end_with_jump__gccjit block gccjit location}@anchor{36d} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::end_with_jump (gccjit::block target, gccjit::location loc) Terminate a block by adding a jump to the given target block. @@ -14491,8 +14843,8 @@ goto target; @end deffn @geindex gccjit;;block;;end_with_return (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35e}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{35f}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{360}@anchor{cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location}@anchor{361} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_return (gccjit::rvalue rvalue, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{36e}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{36f}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_returnEN6gccjit6rvalueEN6gccjit8locationE}@anchor{370}@anchor{cp/topics/functions gccjit block end_with_return__gccjit rvalue gccjit location}@anchor{371} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::end_with_return (gccjit::rvalue rvalue, gccjit::location loc) Terminate a block. @@ -14521,8 +14873,8 @@ return; @end deffn @geindex gccjit;;block;;end_with_switch (C++ function) -@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{362}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{363}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{364}@anchor{cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location}@anchor{365} -@deffn {C++ Function} void gccjit::@ref{17b,,block}::end_with_switch (gccjit::rvalue expr, gccjit::block default_block, std::vector<gccjit::case_> cases, gccjit::location loc) +@anchor{cp/topics/functions _CPPv4N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{372}@anchor{cp/topics/functions _CPPv3N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{373}@anchor{cp/topics/functions _CPPv2N6gccjit5block15end_with_switchEN6gccjit6rvalueEN6gccjit5blockENSt6vectorIN6gccjit5case_EEEN6gccjit8locationE}@anchor{374}@anchor{cp/topics/functions gccjit block end_with_switch__gccjit rvalue gccjit block std vector gccjit case_ gccjit location}@anchor{375} +@deffn {C++ Function} void gccjit::@ref{18b,,block}::end_with_switch (gccjit::rvalue expr, gccjit::block default_block, std::vector<gccjit::case_> cases, gccjit::location loc) Terminate a block by adding evalation of an rvalue, then performing a multiway branch. @@ -14562,14 +14914,14 @@ The API entrypoints relating to switch statements and cases: @itemize * @item -@ref{362,,gccjit;;block;;end_with_switch()} +@ref{372,,gccjit;;block;;end_with_switch()} @item @code{gccjit::context::new_case()} @end itemize @end quotation -were added in @ref{114,,LIBGCCJIT_ABI_3}; you can test for their presence +were added in @ref{11f,,LIBGCCJIT_ABI_3}; you can test for their presence using @example @@ -14577,9 +14929,9 @@ using @end example A @cite{gccjit::case_} represents a case within a switch statement, and -is created within a particular @ref{165,,gccjit;;context} using +is created within a particular @ref{175,,gccjit;;context} using @code{gccjit::context::new_case()}. It is a subclass of -@ref{16a,,gccjit;;object}. +@ref{17a,,gccjit;;object}. Each case expresses a multivalued range of integer values. You can express single-valued cases by passing in the same value for @@ -14682,12 +15034,12 @@ create_code (gcc_jit_context *c_ctxt, void *user_data) @c <https://www.gnu.org/licenses/>. @node Source Locations<2>,Compiling a context<2>,Creating and using functions<2>,Topic Reference<2> -@anchor{cp/topics/locations doc}@anchor{366}@anchor{cp/topics/locations source-locations}@anchor{367} +@anchor{cp/topics/locations doc}@anchor{376}@anchor{cp/topics/locations source-locations}@anchor{377} @subsection Source Locations @geindex gccjit;;location (C++ class) -@anchor{cp/topics/locations _CPPv4N6gccjit8locationE}@anchor{18b}@anchor{cp/topics/locations _CPPv3N6gccjit8locationE}@anchor{368}@anchor{cp/topics/locations _CPPv2N6gccjit8locationE}@anchor{369}@anchor{cp/topics/locations gccjit location}@anchor{36a} +@anchor{cp/topics/locations _CPPv4N6gccjit8locationE}@anchor{19b}@anchor{cp/topics/locations _CPPv3N6gccjit8locationE}@anchor{378}@anchor{cp/topics/locations _CPPv2N6gccjit8locationE}@anchor{379}@anchor{cp/topics/locations gccjit location}@anchor{37a} @deffn {C++ Class} gccjit::location A @cite{gccjit::location} encapsulates a source code location, so that @@ -14698,10 +15050,10 @@ single-step through your language. @cite{gccjit::location} instances are optional: you can always omit them from any C++ API entrypoint accepting one. -You can construct them using @ref{191,,gccjit;;context;;new_location()}. +You can construct them using @ref{1a1,,gccjit;;context;;new_location()}. You need to enable @ref{42,,GCC_JIT_BOOL_OPTION_DEBUGINFO} on the -@ref{165,,gccjit;;context} for these locations to actually be usable by +@ref{175,,gccjit;;context} for these locations to actually be usable by the debugger: @example @@ -14710,8 +15062,8 @@ ctxt.set_bool_option (GCC_JIT_BOOL_OPTION_DEBUGINFO, 1); @end deffn @geindex gccjit;;context;;new_location (C++ function) -@anchor{cp/topics/locations _CPPv4N6gccjit7context12new_locationEPKcii}@anchor{191}@anchor{cp/topics/locations _CPPv3N6gccjit7context12new_locationEPKcii}@anchor{36b}@anchor{cp/topics/locations _CPPv2N6gccjit7context12new_locationEPKcii}@anchor{36c}@anchor{cp/topics/locations gccjit context new_location__cCP i i}@anchor{36d} -@deffn {C++ Function} gccjit::@ref{18b,,location} gccjit::@ref{165,,context}::new_location (const char *filename, int line, int column) +@anchor{cp/topics/locations _CPPv4N6gccjit7context12new_locationEPKcii}@anchor{1a1}@anchor{cp/topics/locations _CPPv3N6gccjit7context12new_locationEPKcii}@anchor{37b}@anchor{cp/topics/locations _CPPv2N6gccjit7context12new_locationEPKcii}@anchor{37c}@anchor{cp/topics/locations gccjit context new_location__cCP i i}@anchor{37d} +@deffn {C++ Function} gccjit::@ref{19b,,location} gccjit::@ref{175,,context}::new_location (const char *filename, int line, int column) Create a @cite{gccjit::location} instance representing the given source location. @@ -14723,13 +15075,13 @@ location. @end menu @node Faking it<2>,,,Source Locations<2> -@anchor{cp/topics/locations faking-it}@anchor{36e} +@anchor{cp/topics/locations faking-it}@anchor{37e} @subsubsection Faking it If you don’t have source code for your internal representation, but need to debug, you can generate a C-like representation of the functions in -your context using @ref{1b0,,gccjit;;context;;dump_to_file()}: +your context using @ref{1c0,,gccjit;;context;;dump_to_file()}: @example ctxt.dump_to_file ("/tmp/something.c", @@ -14759,13 +15111,13 @@ file, giving you @emph{something} you can step through in the debugger. @c <https://www.gnu.org/licenses/>. @node Compiling a context<2>,Using Assembly Language with libgccjit++,Source Locations<2>,Topic Reference<2> -@anchor{cp/topics/compilation doc}@anchor{36f}@anchor{cp/topics/compilation compiling-a-context}@anchor{370} +@anchor{cp/topics/compilation doc}@anchor{37f}@anchor{cp/topics/compilation compiling-a-context}@anchor{380} @subsection Compiling a context -Once populated, a @ref{165,,gccjit;;context} can be compiled to -machine code, either in-memory via @ref{16f,,gccjit;;context;;compile()} or -to disk via @ref{371,,gccjit;;context;;compile_to_file()}. +Once populated, a @ref{175,,gccjit;;context} can be compiled to +machine code, either in-memory via @ref{17f,,gccjit;;context;;compile()} or +to disk via @ref{381,,gccjit;;context;;compile_to_file()}. You can compile a context multiple times (using either form of compilation), although any errors that occur on the context will @@ -14778,13 +15130,13 @@ prevent any future compilation of that context. @end menu @node In-memory compilation<2>,Ahead-of-time compilation<2>,,Compiling a context<2> -@anchor{cp/topics/compilation in-memory-compilation}@anchor{372} +@anchor{cp/topics/compilation in-memory-compilation}@anchor{382} @subsubsection In-memory compilation @geindex gccjit;;context;;compile (C++ function) -@anchor{cp/topics/compilation _CPPv4N6gccjit7context7compileEv}@anchor{16f}@anchor{cp/topics/compilation _CPPv3N6gccjit7context7compileEv}@anchor{373}@anchor{cp/topics/compilation _CPPv2N6gccjit7context7compileEv}@anchor{374}@anchor{cp/topics/compilation gccjit context compile}@anchor{375} -@deffn {C++ Function} gcc_jit_result *gccjit::@ref{165,,context}::compile () +@anchor{cp/topics/compilation _CPPv4N6gccjit7context7compileEv}@anchor{17f}@anchor{cp/topics/compilation _CPPv3N6gccjit7context7compileEv}@anchor{383}@anchor{cp/topics/compilation _CPPv2N6gccjit7context7compileEv}@anchor{384}@anchor{cp/topics/compilation gccjit context compile}@anchor{385} +@deffn {C++ Function} gcc_jit_result *gccjit::@ref{175,,context}::compile () This calls into GCC and builds the code, returning a @cite{gcc_jit_result *}. @@ -14794,19 +15146,19 @@ This is a thin wrapper around the @end deffn @node Ahead-of-time compilation<2>,,In-memory compilation<2>,Compiling a context<2> -@anchor{cp/topics/compilation ahead-of-time-compilation}@anchor{376} +@anchor{cp/topics/compilation ahead-of-time-compilation}@anchor{386} @subsubsection Ahead-of-time compilation Although libgccjit is primarily aimed at just-in-time compilation, it can also be used for implementing more traditional ahead-of-time -compilers, via the @ref{371,,gccjit;;context;;compile_to_file()} method. +compilers, via the @ref{381,,gccjit;;context;;compile_to_file()} method. @geindex gccjit;;context;;compile_to_file (C++ function) -@anchor{cp/topics/compilation _CPPv4N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{371}@anchor{cp/topics/compilation _CPPv3N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{377}@anchor{cp/topics/compilation _CPPv2N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{378}@anchor{cp/topics/compilation gccjit context compile_to_file__gcc_jit_output_kind cCP}@anchor{379} -@deffn {C++ Function} void gccjit::@ref{165,,context}::compile_to_file (enum gcc_jit_output_kind, const char *output_path) +@anchor{cp/topics/compilation _CPPv4N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{381}@anchor{cp/topics/compilation _CPPv3N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{387}@anchor{cp/topics/compilation _CPPv2N6gccjit7context15compile_to_fileE19gcc_jit_output_kindPKc}@anchor{388}@anchor{cp/topics/compilation gccjit context compile_to_file__gcc_jit_output_kind cCP}@anchor{389} +@deffn {C++ Function} void gccjit::@ref{175,,context}::compile_to_file (enum gcc_jit_output_kind, const char *output_path) -Compile the @ref{165,,gccjit;;context} to a file of the given +Compile the @ref{175,,gccjit;;context} to a file of the given kind. This is a thin wrapper around the @@ -14831,7 +15183,7 @@ This is a thin wrapper around the @c <https://www.gnu.org/licenses/>. @node Using Assembly Language with libgccjit++,,Compiling a context<2>,Topic Reference<2> -@anchor{cp/topics/asm doc}@anchor{37a}@anchor{cp/topics/asm using-assembly-language-with-libgccjit}@anchor{37b} +@anchor{cp/topics/asm doc}@anchor{38a}@anchor{cp/topics/asm using-assembly-language-with-libgccjit}@anchor{38b} @subsection Using Assembly Language with libgccjit++ @@ -14841,7 +15193,7 @@ following assumes a familiarity with that functionality. See How to Use Inline Assembly Language in C Code@footnote{https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html} in GCC’s documentation, the “Extended Asm” section in particular. -These entrypoints were added in @ref{146,,LIBGCCJIT_ABI_15}; you can test +These entrypoints were added in @ref{151,,LIBGCCJIT_ABI_15}; you can test for their presence using @quotation @@ -14858,38 +15210,38 @@ for their presence using @end menu @node Adding assembler instructions within a function<2>,Adding top-level assembler statements<2>,,Using Assembly Language with libgccjit++ -@anchor{cp/topics/asm adding-assembler-instructions-within-a-function}@anchor{37c} +@anchor{cp/topics/asm adding-assembler-instructions-within-a-function}@anchor{38c} @subsubsection Adding assembler instructions within a function @geindex gccjit;;extended_asm (C++ class) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asmE}@anchor{37d}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asmE}@anchor{37e}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asmE}@anchor{37f}@anchor{cp/topics/asm gccjit extended_asm}@anchor{380} +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asmE}@anchor{38d}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asmE}@anchor{38e}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asmE}@anchor{38f}@anchor{cp/topics/asm gccjit extended_asm}@anchor{390} @deffn {C++ Class} gccjit::extended_asm A @cite{gccjit::extended_asm} represents an extended @code{asm} statement: a series of low-level instructions inside a function that convert inputs to outputs. -@ref{37d,,gccjit;;extended_asm} is a subclass of @ref{16a,,gccjit;;object}. -It is a thin wrapper around the C API’s @ref{115,,gcc_jit_extended_asm *}. +@ref{38d,,gccjit;;extended_asm} is a subclass of @ref{17a,,gccjit;;object}. +It is a thin wrapper around the C API’s @ref{120,,gcc_jit_extended_asm *}. To avoid having an API entrypoint with a very large number of parameters, an extended @code{asm} statement is made in stages: -an initial call to create the @ref{37d,,gccjit;;extended_asm}, +an initial call to create the @ref{38d,,gccjit;;extended_asm}, followed by calls to add operands and set other properties of the statement. -There are two API entrypoints for creating a @ref{37d,,gccjit;;extended_asm}: +There are two API entrypoints for creating a @ref{38d,,gccjit;;extended_asm}: @itemize * @item -@ref{381,,gccjit;;block;;add_extended_asm()} for an @code{asm} statement with +@ref{391,,gccjit;;block;;add_extended_asm()} for an @code{asm} statement with no control flow, and @item -@ref{382,,gccjit;;block;;end_with_extended_asm_goto()} for an @code{asm goto}. +@ref{392,,gccjit;;block;;end_with_extended_asm_goto()} for an @code{asm goto}. @end itemize For example, to create the equivalent of: @@ -14917,8 +15269,8 @@ extended @code{asm} statement (e.g. the @code{%0} and @code{%1} above), the equivalent to the C syntax is followed i.e. all output operands, then all input operands, regardless of what order the calls to -@ref{383,,gccjit;;extended_asm;;add_output_operand()} and -@ref{384,,gccjit;;extended_asm;;add_input_operand()} were made in. +@ref{393,,gccjit;;extended_asm;;add_output_operand()} and +@ref{394,,gccjit;;extended_asm;;add_input_operand()} were made in. @end quotation @end cartouche @@ -14943,10 +15295,10 @@ the following API calls could be used: @end deffn @geindex gccjit;;block;;add_extended_asm (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{381}@anchor{cp/topics/asm _CPPv3N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{385}@anchor{cp/topics/asm _CPPv2N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{386}@anchor{cp/topics/asm gccjit block add_extended_asm__ssCR gccjit location}@anchor{387} -@deffn {C++ Function} @ref{37d,,extended_asm} gccjit::@ref{17b,,block}::add_extended_asm (const std::string &asm_template, gccjit::location loc = location()) +@anchor{cp/topics/asm _CPPv4N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{391}@anchor{cp/topics/asm _CPPv3N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{395}@anchor{cp/topics/asm _CPPv2N6gccjit5block16add_extended_asmERKNSt6stringEN6gccjit8locationE}@anchor{396}@anchor{cp/topics/asm gccjit block add_extended_asm__ssCR gccjit location}@anchor{397} +@deffn {C++ Function} @ref{38d,,extended_asm} gccjit::@ref{18b,,block}::add_extended_asm (const std::string &asm_template, gccjit::location loc = location()) -Create a @ref{37d,,gccjit;;extended_asm} for an extended @code{asm} statement +Create a @ref{38d,,gccjit;;extended_asm} for an extended @code{asm} statement with no control flow (i.e. without the @code{goto} qualifier). The parameter @code{asm_template} corresponds to the @cite{AssemblerTemplate} @@ -14956,10 +15308,10 @@ an on-stack buffer. @end deffn @geindex gccjit;;block;;end_with_extended_asm_goto (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{382}@anchor{cp/topics/asm _CPPv3N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{388}@anchor{cp/topics/asm _CPPv2N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{389}@anchor{cp/topics/asm gccjit block end_with_extended_asm_goto__ssCR std vector block blockP location}@anchor{38a} -@deffn {C++ Function} @ref{37d,,extended_asm} gccjit::@ref{17b,,block}::end_with_extended_asm_goto (const std::string &asm_template, std::vector<block> goto_blocks, block *fallthrough_block, location loc = location()) +@anchor{cp/topics/asm _CPPv4N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{392}@anchor{cp/topics/asm _CPPv3N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{398}@anchor{cp/topics/asm _CPPv2N6gccjit5block26end_with_extended_asm_gotoERKNSt6stringENSt6vectorI5blockEEP5block8location}@anchor{399}@anchor{cp/topics/asm gccjit block end_with_extended_asm_goto__ssCR std vector block blockP location}@anchor{39a} +@deffn {C++ Function} @ref{38d,,extended_asm} gccjit::@ref{18b,,block}::end_with_extended_asm_goto (const std::string &asm_template, std::vector<block> goto_blocks, block *fallthrough_block, location loc = location()) -Create a @ref{37d,,gccjit;;extended_asm} for an extended @code{asm} statement +Create a @ref{38d,,gccjit;;extended_asm} for an extended @code{asm} statement that may perform jumps, and use it to terminate the given block. This is equivalent to the @code{goto} qualifier in C’s extended @code{asm} syntax. @@ -15008,7 +15360,7 @@ to fall through to after the statement. @cartouche @quotation Note -This is needed since each @ref{17b,,gccjit;;block} must have a +This is needed since each @ref{18b,,gccjit;;block} must have a single exit point, as a basic block: you can’t jump from the middle of a block. A “goto” is implicitly added after the asm to handle the fallthrough case, which is equivalent to what @@ -15018,10 +15370,10 @@ would have happened in the C case. @end deffn @geindex gccjit;;extended_asm;;set_volatile_flag (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17set_volatile_flagEb}@anchor{38b}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17set_volatile_flagEb}@anchor{38c}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17set_volatile_flagEb}@anchor{38d}@anchor{cp/topics/asm gccjit extended_asm set_volatile_flag__b}@anchor{38e} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::set_volatile_flag (bool flag) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17set_volatile_flagEb}@anchor{39b}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17set_volatile_flagEb}@anchor{39c}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17set_volatile_flagEb}@anchor{39d}@anchor{cp/topics/asm gccjit extended_asm set_volatile_flag__b}@anchor{39e} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::set_volatile_flag (bool flag) -Set whether the @ref{37d,,gccjit;;extended_asm} has side-effects, equivalent to the +Set whether the @ref{38d,,gccjit;;extended_asm} has side-effects, equivalent to the volatile@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#Volatile} qualifier in C’s extended asm syntax. @@ -15049,12 +15401,12 @@ the following API calls could be used: .add_clobber ("rdx"); @end example -where the @ref{37d,,gccjit;;extended_asm} is flagged as volatile. +where the @ref{38d,,gccjit;;extended_asm} is flagged as volatile. @end deffn @geindex gccjit;;extended_asm;;set_inline_flag (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm15set_inline_flagEb}@anchor{38f}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm15set_inline_flagEb}@anchor{390}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm15set_inline_flagEb}@anchor{391}@anchor{cp/topics/asm gccjit extended_asm set_inline_flag__b}@anchor{392} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::set_inline_flag (bool flag) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm15set_inline_flagEb}@anchor{39f}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm15set_inline_flagEb}@anchor{3a0}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm15set_inline_flagEb}@anchor{3a1}@anchor{cp/topics/asm gccjit extended_asm set_inline_flag__b}@anchor{3a2} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::set_inline_flag (bool flag) Set the equivalent of the inline@footnote{https://gcc.gnu.org/onlinedocs/gcc/Size-of-an-asm.html#Size-of-an-asm} @@ -15062,8 +15414,8 @@ qualifier in C’s extended @code{asm} syntax. @end deffn @geindex gccjit;;extended_asm;;add_output_operand (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{383}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{393}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{394}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR ssCR gccjit lvalue}@anchor{395} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_output_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::lvalue dest) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{393}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{3a3}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringERKNSt6stringEN6gccjit6lvalueE}@anchor{3a4}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR ssCR gccjit lvalue}@anchor{3a5} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::add_output_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::lvalue dest) Add an output operand to the extended @code{asm} statement. See the Output Operands@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#OutputOperands} @@ -15093,8 +15445,8 @@ section of GCC’s “Extended Asm” documentation. @end deffn @geindex gccjit;;extended_asm;;add_output_operand (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{396}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{397}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{398}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR gccjit lvalue}@anchor{399} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_output_operand (const std::string &constraint, gccjit::lvalue dest) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{3a6}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{3a7}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm18add_output_operandERKNSt6stringEN6gccjit6lvalueE}@anchor{3a8}@anchor{cp/topics/asm gccjit extended_asm add_output_operand__ssCR gccjit lvalue}@anchor{3a9} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::add_output_operand (const std::string &constraint, gccjit::lvalue dest) As above, but don’t supply a symbolic name for the operand. @@ -15106,8 +15458,8 @@ ext_asm.add_output_operand ("=r", dst); @end deffn @geindex gccjit;;extended_asm;;add_input_operand (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{384}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{39a}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{39b}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR ssCR gccjit rvalue}@anchor{39c} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_input_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::rvalue src) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{394}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{3aa}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringERKNSt6stringEN6gccjit6rvalueE}@anchor{3ab}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR ssCR gccjit rvalue}@anchor{3ac} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::add_input_operand (const std::string &asm_symbolic_name, const std::string &constraint, gccjit::rvalue src) Add an input operand to the extended @code{asm} statement. See the Input Operands@footnote{https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands} @@ -15131,8 +15483,8 @@ ext_asm.add_input_operand ("aMask", "r", mask); @end deffn @geindex gccjit;;extended_asm;;add_input_operand (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{39d}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{39e}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{39f}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR gccjit rvalue}@anchor{3a0} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_input_operand (const std::string &constraint, gccjit::rvalue src) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{3ad}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{3ae}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm17add_input_operandERKNSt6stringEN6gccjit6rvalueE}@anchor{3af}@anchor{cp/topics/asm gccjit extended_asm add_input_operand__ssCR gccjit rvalue}@anchor{3b0} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::add_input_operand (const std::string &constraint, gccjit::rvalue src) As above, but don’t supply a symbolic name for the operand. @@ -15144,8 +15496,8 @@ ext_asm.add_input_operand ("r", src); @end deffn @geindex gccjit;;extended_asm;;add_clobber (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3a1}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3a2}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3a3}@anchor{cp/topics/asm gccjit extended_asm add_clobber__ssCR}@anchor{3a4} -@deffn {C++ Function} gccjit::@ref{37d,,extended_asm} &gccjit::@ref{37d,,extended_asm}::add_clobber (const std::string &victim) +@anchor{cp/topics/asm _CPPv4N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3b1}@anchor{cp/topics/asm _CPPv3N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3b2}@anchor{cp/topics/asm _CPPv2N6gccjit12extended_asm11add_clobberERKNSt6stringE}@anchor{3b3}@anchor{cp/topics/asm gccjit extended_asm add_clobber__ssCR}@anchor{3b4} +@deffn {C++ Function} gccjit::@ref{38d,,extended_asm} &gccjit::@ref{38d,,extended_asm}::add_clobber (const std::string &victim) Add @cite{victim} to the list of registers clobbered by the extended @code{asm} statement. See the @@ -15163,7 +15515,7 @@ ext_asm.add_clobber ("r0").add_clobber ("cc").add_clobber ("memory"); @end deffn @node Adding top-level assembler statements<2>,,Adding assembler instructions within a function<2>,Using Assembly Language with libgccjit++ -@anchor{cp/topics/asm adding-top-level-assembler-statements}@anchor{3a5} +@anchor{cp/topics/asm adding-top-level-assembler-statements}@anchor{3b5} @subsubsection Adding top-level assembler statements @@ -15172,8 +15524,8 @@ there is support for creating “top-level” assembler statements, outside of any function. @geindex gccjit;;context;;add_top_level_asm (C++ function) -@anchor{cp/topics/asm _CPPv4N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3a6}@anchor{cp/topics/asm _CPPv3N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3a7}@anchor{cp/topics/asm _CPPv2N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3a8}@anchor{cp/topics/asm gccjit context add_top_level_asm__cCP gccjit location}@anchor{3a9} -@deffn {C++ Function} void gccjit::@ref{165,,context}::add_top_level_asm (const char *asm_stmts, gccjit::location loc = location()) +@anchor{cp/topics/asm _CPPv4N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3b6}@anchor{cp/topics/asm _CPPv3N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3b7}@anchor{cp/topics/asm _CPPv2N6gccjit7context17add_top_level_asmEPKcN6gccjit8locationE}@anchor{3b8}@anchor{cp/topics/asm gccjit context add_top_level_asm__cCP gccjit location}@anchor{3b9} +@deffn {C++ Function} void gccjit::@ref{175,,context}::add_top_level_asm (const char *asm_stmts, gccjit::location loc = location()) Create a set of top-level asm statements, analogous to those created by GCC’s “basic” @code{asm} syntax in C at file scope. @@ -15224,7 +15576,7 @@ the following API calls could be used: @c <https://www.gnu.org/licenses/>. @node Internals,Indices and tables,C++ bindings for libgccjit,Top -@anchor{internals/index doc}@anchor{3aa}@anchor{internals/index internals}@anchor{3ab} +@anchor{internals/index doc}@anchor{3ba}@anchor{internals/index internals}@anchor{3bb} @chapter Internals @@ -15240,7 +15592,7 @@ the following API calls could be used: @end menu @node Working on the JIT library,Running the test suite,,Internals -@anchor{internals/index working-on-the-jit-library}@anchor{3ac} +@anchor{internals/index working-on-the-jit-library}@anchor{3bc} @section Working on the JIT library @@ -15273,7 +15625,7 @@ gcc/libgccjit.so.0.0.1: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), Here’s what those configuration options mean: @geindex command line option; --enable-host-shared -@anchor{internals/index cmdoption-enable-host-shared}@anchor{3ad} +@anchor{internals/index cmdoption-enable-host-shared}@anchor{3bd} @deffn {Option} @w{-}@w{-}enable@w{-}host@w{-}shared Configuring with this option means that the compiler is built as @@ -15282,7 +15634,7 @@ but it necessary for a shared library. @end deffn @geindex command line option; --enable-languages=jit@comma{}c++ -@anchor{internals/index cmdoption-enable-languages}@anchor{3ae} +@anchor{internals/index cmdoption-enable-languages}@anchor{3be} @deffn {Option} @w{-}@w{-}enable@w{-}languages=jit,c++ This specifies which frontends to build. The JIT library looks like @@ -15299,7 +15651,7 @@ c++: error trying to exec 'cc1plus': execvp: No such file or directory @end deffn @geindex command line option; --disable-bootstrap -@anchor{internals/index cmdoption-disable-bootstrap}@anchor{3af} +@anchor{internals/index cmdoption-disable-bootstrap}@anchor{3bf} @deffn {Option} @w{-}@w{-}disable@w{-}bootstrap For hacking on the “jit” subdirectory, performing a full @@ -15309,7 +15661,7 @@ the compiler can still bootstrap itself. @end deffn @geindex command line option; --enable-checking=release -@anchor{internals/index cmdoption-enable-checking}@anchor{3b0} +@anchor{internals/index cmdoption-enable-checking}@anchor{3c0} @deffn {Option} @w{-}@w{-}enable@w{-}checking=release The compile can perform extensive self-checking as it runs, useful when @@ -15320,7 +15672,7 @@ disable this self-checking. @end deffn @node Running the test suite,Environment variables,Working on the JIT library,Internals -@anchor{internals/index running-the-test-suite}@anchor{3b1} +@anchor{internals/index running-the-test-suite}@anchor{3c1} @section Running the test suite @@ -15378,7 +15730,7 @@ and once a test has been compiled, you can debug it directly: @end menu @node Running under valgrind,,,Running the test suite -@anchor{internals/index running-under-valgrind}@anchor{3b2} +@anchor{internals/index running-under-valgrind}@anchor{3c2} @subsection Running under valgrind @@ -15427,7 +15779,7 @@ When running under valgrind, it’s best to have configured gcc with various known false positives. @node Environment variables,Packaging notes,Running the test suite,Internals -@anchor{internals/index environment-variables}@anchor{3b3} +@anchor{internals/index environment-variables}@anchor{3c3} @section Environment variables @@ -15435,7 +15787,7 @@ When running client code against a locally-built libgccjit, three environment variables need to be set up: @geindex environment variable; LD_LIBRARY_PATH -@anchor{internals/index envvar-LD_LIBRARY_PATH}@anchor{3b4} +@anchor{internals/index envvar-LD_LIBRARY_PATH}@anchor{3c4} @deffn {Environment Variable} LD_LIBRARY_PATH @quotation @@ -15455,7 +15807,7 @@ libgccjit.so.0.0.1: ELF 64-bit LSB shared object, x86-64, version 1 (GNU/Linux), @end deffn @geindex environment variable; PATH -@anchor{internals/index envvar-PATH}@anchor{3b5} +@anchor{internals/index envvar-PATH}@anchor{3c5} @deffn {Environment Variable} PATH The library uses a driver executable for converting from .s assembler @@ -15474,7 +15826,7 @@ of development. @end deffn @geindex environment variable; LIBRARY_PATH -@anchor{internals/index envvar-LIBRARY_PATH}@anchor{3b6} +@anchor{internals/index envvar-LIBRARY_PATH}@anchor{3c6} @deffn {Environment Variable} LIBRARY_PATH The driver executable invokes the linker, and the latter needs to locate @@ -15506,11 +15858,11 @@ hello world @end example @node Packaging notes,Overview of code structure,Environment variables,Internals -@anchor{internals/index packaging-notes}@anchor{3b7} +@anchor{internals/index packaging-notes}@anchor{3c7} @section Packaging notes -The configure-time option @ref{3ad,,--enable-host-shared} is needed when +The configure-time option @ref{3bd,,--enable-host-shared} is needed when building the jit in order to get position-independent code. This will slow down the regular compiler by a few percent. Hence when packaging gcc with libgccjit, please configure and build twice: @@ -15521,10 +15873,10 @@ with libgccjit, please configure and build twice: @itemize * @item -once without @ref{3ad,,--enable-host-shared} for most languages, and +once without @ref{3bd,,--enable-host-shared} for most languages, and @item -once with @ref{3ad,,--enable-host-shared} for the jit +once with @ref{3bd,,--enable-host-shared} for the jit @end itemize @end quotation @@ -15566,7 +15918,7 @@ popd @end example @node Overview of code structure,Design notes,Packaging notes,Internals -@anchor{internals/index overview-of-code-structure}@anchor{3b8} +@anchor{internals/index overview-of-code-structure}@anchor{3c8} @section Overview of code structure @@ -16035,7 +16387,7 @@ JIT: gcc::jit::logger::~logger() @end example @node Design notes,Submitting patches,Overview of code structure,Internals -@anchor{internals/index design-notes}@anchor{3b9} +@anchor{internals/index design-notes}@anchor{3c9} @section Design notes @@ -16048,7 +16400,7 @@ close as possible to the error; failing that, a good place is within @code{recording::context::validate ()} in jit-recording.cc. @node Submitting patches,,Design notes,Internals -@anchor{internals/index submitting-patches}@anchor{3ba} +@anchor{internals/index submitting-patches}@anchor{3ca} @section Submitting patches @@ -16182,7 +16534,7 @@ large and inconsequential (e.g. anchor renumbering), rather like generated committing to svn. @node Indices and tables,Index,Internals,Top -@anchor{index indices-and-tables}@anchor{3bb} +@anchor{index indices-and-tables}@anchor{3cb} @unnumbered Indices and tables diff --git a/gcc/jit/docs/topics/compatibility.rst b/gcc/jit/docs/topics/compatibility.rst index 03e3f3402a1..27845ea9a84 100644 --- a/gcc/jit/docs/topics/compatibility.rst +++ b/gcc/jit/docs/topics/compatibility.rst @@ -314,3 +314,60 @@ of a global with an rvalue and to use constructors: * :func:`gcc_jit_context_new_struct_constructor` * :func:`gcc_jit_context_new_union_constructor` * :func:`gcc_jit_global_set_initializer_rvalue` + +.. _LIBGCCJIT_ABI_20: + +``LIBGCCJIT_ABI_20`` +----------------------- +``LIBGCCJIT_ABI_20`` covers the addition of sized integer types, including +128-bit integers and helper functions for types: + + * :func:`gcc_jit_compatible_types` + * :func:`gcc_jit_type_get_size` + * :c:macro:`GCC_JIT_TYPE_UINT8_T` + * :c:macro:`GCC_JIT_TYPE_UINT16_T` + * :c:macro:`GCC_JIT_TYPE_UINT32_T` + * :c:macro:`GCC_JIT_TYPE_UINT64_T` + * :c:macro:`GCC_JIT_TYPE_UINT128_T` + * :c:macro:`GCC_JIT_TYPE_INT8_T` + * :c:macro:`GCC_JIT_TYPE_INT16_T` + * :c:macro:`GCC_JIT_TYPE_INT32_T` + * :c:macro:`GCC_JIT_TYPE_INT64_T` + * :c:macro:`GCC_JIT_TYPE_INT128_T` + +.. _LIBGCCJIT_ABI_21: + +``LIBGCCJIT_ABI_21`` +-------------------- +``LIBGCCJIT_ABI_21`` covers the addition of an API entrypoint to bitcast a +value from one type to another: + + * :func:`gcc_jit_context_new_bitcast` + +.. _LIBGCCJIT_ABI_22: + +``LIBGCCJIT_ABI_22`` +-------------------- +``LIBGCCJIT_ABI_22`` covers the addition of an API entrypoint to set the +register name of a variable: + + * :func:`gcc_jit_lvalue_set_register_name` + +.. _LIBGCCJIT_ABI_23: + +``LIBGCCJIT_ABI_23`` +-------------------- +``LIBGCCJIT_ABI_23`` covers the addition of an API entrypoint to hide stderr +logs: + + * :func:`gcc_jit_context_set_bool_print_errors_to_stderr` + +.. _LIBGCCJIT_ABI_24: + +``LIBGCCJIT_ABI_24`` +-------------------- +``LIBGCCJIT_ABI_24`` covers the addition of functions to get and set the +alignment of a variable: + + * :func:`gcc_jit_lvalue_set_alignment` + * :func:`gcc_jit_lvalue_get_alignment` diff --git a/gcc/jit/docs/topics/contexts.rst b/gcc/jit/docs/topics/contexts.rst index 14ee57e2e54..dfbe968e127 100644 --- a/gcc/jit/docs/topics/contexts.rst +++ b/gcc/jit/docs/topics/contexts.rst @@ -489,6 +489,21 @@ Boolean options #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_use_external_driver +.. function:: void \ + gcc_jit_context_set_bool_print_errors_to_stderr (gcc_jit_context *ctxt, \ + int enabled) + + By default, libgccjit will print errors to stderr. + + This entrypoint can be used to disable the printing. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_23`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr + Integer options *************** diff --git a/gcc/jit/docs/topics/expressions.rst b/gcc/jit/docs/topics/expressions.rst index d51264af73f..91ee8a9c74a 100644 --- a/gcc/jit/docs/topics/expressions.rst +++ b/gcc/jit/docs/topics/expressions.rst @@ -653,6 +653,25 @@ Type-coercion * int <-> bool * P* <-> Q*, for pointer types P and Q +.. function:: gcc_jit_rvalue *\ + gcc_jit_context_new_bitcast (gcc_jit_context *ctxt,\ + gcc_jit_location *loc,\ + gcc_jit_rvalue *rvalue,\ + gcc_jit_type *type) + + Given an rvalue of T, bitcast it to another type, meaning that this will + generate a new rvalue by interpreting the bits of ``rvalue`` to the layout + of ``type``. + + The type of rvalue must be the same size as the size of ``type``. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_21`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast + Lvalues ------- @@ -742,6 +761,65 @@ where the rvalue is computed by reading from the storage area. #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_link_section +.. function:: void\ + gcc_jit_lvalue_set_register_name (gcc_jit_lvalue *lvalue,\ + const char *reg_name); + + Set the register name of a variable. + The parameter ``reg_name`` must be non-NULL. Analogous to: + + .. code-block:: c + + register int variable asm ("r12"); + + in C. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_22`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name + +.. function:: void\ + gcc_jit_lvalue_set_alignment (gcc_jit_lvalue *lvalue,\ + unsigned bytes) + + Set the alignment of a variable, in bytes. + Analogous to: + + .. code-block:: c + + int variable __attribute__((aligned (16))); + + in C. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_24`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_ALIGNMENT + +.. function:: unsigned\ + gcc_jit_lvalue_get_alignment (gcc_jit_lvalue *lvalue) + + Return the alignment of a variable set by ``gcc_jit_lvalue_set_alignment``. + Return 0 if the alignment was not set. Analogous to: + + .. code-block:: c + + _Alignof (variable) + + in C. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_24`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_ALIGNMENT + Global variables **************** diff --git a/gcc/jit/docs/topics/types.rst b/gcc/jit/docs/topics/types.rst index c2082c0ef3e..db7fac6b267 100644 --- a/gcc/jit/docs/topics/types.rst +++ b/gcc/jit/docs/topics/types.rst @@ -76,6 +76,16 @@ Standard types :c:data:`GCC_JIT_TYPE_UNSIGNED_LONG` C's ``unsigned long`` :c:data:`GCC_JIT_TYPE_LONG_LONG` C99's ``long long`` (signed) :c:data:`GCC_JIT_TYPE_UNSIGNED_LONG_LONG` C99's ``unsigned long long`` + :c:data:`GCC_JIT_TYPE_UINT8_T` C99's ``uint8_t`` + :c:data:`GCC_JIT_TYPE_UINT16_T` C99's ``uint16_t`` + :c:data:`GCC_JIT_TYPE_UINT32_T` C99's ``uint32_t`` + :c:data:`GCC_JIT_TYPE_UINT64_T` C99's ``uint64_t`` + :c:data:`GCC_JIT_TYPE_UINT128_T` C99's ``__uint128_t`` + :c:data:`GCC_JIT_TYPE_INT8_T` C99's ``int8_t`` + :c:data:`GCC_JIT_TYPE_INT16_T` C99's ``int16_t`` + :c:data:`GCC_JIT_TYPE_INT32_T` C99's ``int32_t`` + :c:data:`GCC_JIT_TYPE_INT64_T` C99's ``int64_t`` + :c:data:`GCC_JIT_TYPE_INT128_T` C99's ``__int128_t`` :c:data:`GCC_JIT_TYPE_FLOAT` :c:data:`GCC_JIT_TYPE_DOUBLE` :c:data:`GCC_JIT_TYPE_LONG_DOUBLE` @@ -467,3 +477,34 @@ Reflection API #ifdef LIBGCCJIT_HAVE_REFLECTION .. type:: gcc_jit_case + +.. function:: int\ + gcc_jit_compatible_types (gcc_jit_type *ltype,\ + gcc_jit_type *rtype) + + Return non-zero if the two types are compatible. For instance, + if :c:data:`GCC_JIT_TYPE_UINT64_T` and :c:data:`GCC_JIT_TYPE_UNSIGNED_LONG` + are the same size on the target, this will return non-zero. + The parameters ``ltype`` and ``rtype`` must be non-NULL. + Return 0 on errors. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_20`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS + +.. function:: ssize_t\ + gcc_jit_type_get_size (gcc_jit_type *type) + + Return the size of a type, in bytes. It only works on integer types for now. + The parameter ``type`` must be non-NULL. + Return -1 on errors. + + This entrypoint was added in :ref:`LIBGCCJIT_ABI_20`; you can test for + its presence using + + .. code-block:: c + + #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS diff --git a/gcc/jit/jit-builtins.cc b/gcc/jit/jit-builtins.cc index 71c38eb0948..b949b734332 100644 --- a/gcc/jit/jit-builtins.cc +++ b/gcc/jit/jit-builtins.cc @@ -483,6 +483,7 @@ builtins_manager::make_primitive_type (enum jit_builtin_type type_id) case BT_UINT16: return m_ctxt->get_int_type (2, false); case BT_UINT32: return m_ctxt->get_int_type (4, false); case BT_UINT64: return m_ctxt->get_int_type (8, false); + case BT_UINT128: return m_ctxt->get_int_type (16, false); // case BT_WORD: // case BT_UNWINDWORD: case BT_FLOAT: return m_ctxt->get_type (GCC_JIT_TYPE_FLOAT); diff --git a/gcc/jit/jit-common.h b/gcc/jit/jit-common.h index 1a8cd8bac7b..3ff7447fbf3 100644 --- a/gcc/jit/jit-common.h +++ b/gcc/jit/jit-common.h @@ -36,7 +36,7 @@ along with GCC; see the file COPYING3. If not see #endif #endif -const int NUM_GCC_JIT_TYPES = GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE + 1; +const int NUM_GCC_JIT_TYPES = GCC_JIT_TYPE_INT128_T + 1; /* This comment is included by the docs. @@ -198,6 +198,7 @@ enum inner_bool_option { INNER_BOOL_OPTION_ALLOW_UNREACHABLE_BLOCKS, INNER_BOOL_OPTION_USE_EXTERNAL_DRIVER, + INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR, NUM_INNER_BOOL_OPTIONS }; diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc index d1835c79863..6be6bdf8dea 100644 --- a/gcc/jit/jit-playback.cc +++ b/gcc/jit/jit-playback.cc @@ -237,6 +237,38 @@ get_tree_node_for_type (enum gcc_jit_types type_) case GCC_JIT_TYPE_UNSIGNED_INT: return unsigned_type_node; + case GCC_JIT_TYPE_UINT8_T: + return unsigned_intQI_type_node; + case GCC_JIT_TYPE_UINT16_T: + return uint16_type_node; + case GCC_JIT_TYPE_UINT32_T: + return uint32_type_node; + case GCC_JIT_TYPE_UINT64_T: + return uint64_type_node; + case GCC_JIT_TYPE_UINT128_T: + if (targetm.scalar_mode_supported_p (TImode)) + return uint128_type_node; + + add_error (NULL, "gcc_jit_types value unsupported on this target: %i", + type_); + return NULL; + + case GCC_JIT_TYPE_INT8_T: + return intQI_type_node; + case GCC_JIT_TYPE_INT16_T: + return intHI_type_node; + case GCC_JIT_TYPE_INT32_T: + return intSI_type_node; + case GCC_JIT_TYPE_INT64_T: + return intDI_type_node; + case GCC_JIT_TYPE_INT128_T: + if (targetm.scalar_mode_supported_p (TImode)) + return intTI_type_node; + + add_error (NULL, "gcc_jit_types value unsupported on this target: %i", + type_); + return NULL; + case GCC_JIT_TYPE_LONG: return long_integer_type_node; case GCC_JIT_TYPE_UNSIGNED_LONG: @@ -268,6 +300,9 @@ get_tree_node_for_type (enum gcc_jit_types type_) return complex_long_double_type_node; } + add_error (NULL, "unrecognized (enum gcc_jit_types) value: %i", + type_); + return NULL; } @@ -280,10 +315,7 @@ get_type (enum gcc_jit_types type_) { tree type_node = get_tree_node_for_type (type_); if (type_node == NULL) - { - add_error (NULL, "unrecognized (enum gcc_jit_types) value: %i", type_); - return NULL; - } + return NULL; return new type (type_node); } @@ -1390,6 +1422,36 @@ new_cast (playback::location *loc, return new rvalue (this, t_cast); } +/* Construct a playback::rvalue instance (wrapping a tree) for a + bitcast. */ + +playback::rvalue * +playback::context:: +new_bitcast (location *loc, + rvalue *expr, + type *type_) +{ + tree expr_size = TYPE_SIZE (expr->get_type ()->as_tree ()); + tree type_size = TYPE_SIZE (type_->as_tree ()); + tree t_expr = expr->as_tree (); + tree t_dst_type = type_->as_tree (); + if (expr_size != type_size) + { + active_playback_ctxt->add_error (loc, + "bitcast with types of different sizes"); + fprintf (stderr, "input expression (size: %ld):\n", + (long) tree_to_uhwi (expr_size)); + debug_tree (t_expr); + fprintf (stderr, "requested type (size: %ld):\n", + (long) tree_to_uhwi (type_size)); + debug_tree (t_dst_type); + } + tree t_bitcast = build1 (VIEW_CONVERT_EXPR, t_dst_type, t_expr); + if (loc) + set_tree_location (t_bitcast, loc); + return new rvalue (this, t_bitcast); +} + /* Construct a playback::lvalue instance (wrapping a tree) for an array access. */ diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h index c93d7055d43..b18aa4d38da 100644 --- a/gcc/jit/jit-playback.h +++ b/gcc/jit/jit-playback.h @@ -24,6 +24,7 @@ along with GCC; see the file COPYING3. If not see #include <utility> // for std::pair #include "timevar.h" +#include "varasm.h" #include "jit-recording.h" @@ -180,6 +181,11 @@ public: rvalue *expr, type *type_); + rvalue * + new_bitcast (location *loc, + rvalue *expr, + type *type_); + lvalue * new_array_access (location *loc, rvalue *ptr, @@ -701,6 +707,21 @@ public: set_decl_section_name (as_tree (), name); } + void + set_register_name (const char* reg_name) + { + set_user_assembler_name (as_tree (), reg_name); + DECL_REGISTER (as_tree ()) = 1; + DECL_HARD_REGISTER (as_tree ()) = 1; + } + + void + set_alignment (int alignment) + { + SET_DECL_ALIGN (as_tree (), alignment * BITS_PER_UNIT); + DECL_USER_ALIGN (as_tree ()) = 1; + } + private: bool mark_addressable (location *loc); }; diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc index 1e3fadfacd7..a31720f043e 100644 --- a/gcc/jit/jit-recording.cc +++ b/gcc/jit/jit-recording.cc @@ -592,6 +592,7 @@ recording::context::context (context *parent_ctxt) memset (m_int_options, 0, sizeof (m_int_options)); memset (m_bool_options, 0, sizeof (m_bool_options)); memset (m_inner_bool_options, 0, sizeof (m_inner_bool_options)); + m_inner_bool_options[INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR] = true; } memset (m_basic_types, 0, sizeof (m_basic_types)); @@ -822,6 +823,10 @@ recording::context::get_int_type (int num_bytes, int is_signed) return get_type (is_signed ? GCC_JIT_TYPE_LONG_LONG : GCC_JIT_TYPE_UNSIGNED_LONG_LONG); + if (num_bits == 128) + return get_type (is_signed + ? GCC_JIT_TYPE_INT128_T + : GCC_JIT_TYPE_UINT128_T); /* Some other size, not corresponding to the C int types. */ /* To be written: support arbitrary other sizes, sharing by @@ -1242,6 +1247,22 @@ recording::context::new_cast (recording::location *loc, return result; } +/* Create a recording::bitcast instance and add it to this context's list + of mementos. + + Implements the post-error-checking part of + gcc_jit_context_new_bitcast. */ + +recording::rvalue * +recording::context::new_bitcast (location *loc, + rvalue *expr, + type *type_) +{ + recording::rvalue *result = new bitcast (this, loc, expr, type_); + record (result); + return result; +} + /* Create a recording::call instance and add it to this context's list of mementos. @@ -1551,15 +1572,20 @@ recording::context::add_error_va (location *loc, const char *fmt, va_list ap) if (!ctxt_progname) ctxt_progname = "libgccjit.so"; - if (loc) - fprintf (stderr, "%s: %s: error: %s\n", - ctxt_progname, - loc->get_debug_string (), - errmsg); - else - fprintf (stderr, "%s: error: %s\n", - ctxt_progname, - errmsg); + bool print_errors_to_stderr = + get_inner_bool_option (INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR); + if (print_errors_to_stderr) + { + if (loc) + fprintf (stderr, "%s: %s: error: %s\n", + ctxt_progname, + loc->get_debug_string (), + errmsg); + else + fprintf (stderr, "%s: error: %s\n", + ctxt_progname, + errmsg); + } if (!m_error_count) { @@ -1687,7 +1713,8 @@ static const char * const static const char * const inner_bool_option_reproducer_strings[NUM_INNER_BOOL_OPTIONS] = { "gcc_jit_context_set_bool_allow_unreachable_blocks", - "gcc_jit_context_set_bool_use_external_driver" + "gcc_jit_context_set_bool_use_external_driver", + "gcc_jit_context_set_bool_print_errors_to_stderr", }; /* Write the current value of all options to the log file (if any). */ @@ -2325,6 +2352,26 @@ recording::memento_of_get_type::get_size () case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: size = LONG_LONG_TYPE_SIZE; break; + case GCC_JIT_TYPE_UINT8_T: + case GCC_JIT_TYPE_INT8_T: + size = 8; + break; + case GCC_JIT_TYPE_UINT16_T: + case GCC_JIT_TYPE_INT16_T: + size = 16; + break; + case GCC_JIT_TYPE_UINT32_T: + case GCC_JIT_TYPE_INT32_T: + size = 32; + break; + case GCC_JIT_TYPE_UINT64_T: + case GCC_JIT_TYPE_INT64_T: + size = 64; + break; + case GCC_JIT_TYPE_UINT128_T: + case GCC_JIT_TYPE_INT128_T: + size = 128; + break; case GCC_JIT_TYPE_FLOAT: size = FLOAT_TYPE_SIZE; break; @@ -2334,6 +2381,9 @@ recording::memento_of_get_type::get_size () case GCC_JIT_TYPE_LONG_DOUBLE: size = LONG_DOUBLE_TYPE_SIZE; break; + case GCC_JIT_TYPE_SIZE_T: + size = MAX_BITS_PER_WORD; + break; default: /* As this function is called by 'gcc_jit_global_set_initializer' and @@ -2373,6 +2423,16 @@ recording::memento_of_get_type::dereference () case GCC_JIT_TYPE_UNSIGNED_LONG: case GCC_JIT_TYPE_LONG_LONG: case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: + case GCC_JIT_TYPE_UINT8_T: + case GCC_JIT_TYPE_UINT16_T: + case GCC_JIT_TYPE_UINT32_T: + case GCC_JIT_TYPE_UINT64_T: + case GCC_JIT_TYPE_UINT128_T: + case GCC_JIT_TYPE_INT8_T: + case GCC_JIT_TYPE_INT16_T: + case GCC_JIT_TYPE_INT32_T: + case GCC_JIT_TYPE_INT64_T: + case GCC_JIT_TYPE_INT128_T: case GCC_JIT_TYPE_FLOAT: case GCC_JIT_TYPE_DOUBLE: case GCC_JIT_TYPE_LONG_DOUBLE: @@ -2425,6 +2485,16 @@ recording::memento_of_get_type::is_int () const case GCC_JIT_TYPE_UNSIGNED_LONG: case GCC_JIT_TYPE_LONG_LONG: case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: + case GCC_JIT_TYPE_UINT8_T: + case GCC_JIT_TYPE_UINT16_T: + case GCC_JIT_TYPE_UINT32_T: + case GCC_JIT_TYPE_UINT64_T: + case GCC_JIT_TYPE_UINT128_T: + case GCC_JIT_TYPE_INT8_T: + case GCC_JIT_TYPE_INT16_T: + case GCC_JIT_TYPE_INT32_T: + case GCC_JIT_TYPE_INT64_T: + case GCC_JIT_TYPE_INT128_T: return true; case GCC_JIT_TYPE_FLOAT: @@ -2448,6 +2518,60 @@ recording::memento_of_get_type::is_int () const } } +/* Implementation of pure virtual hook recording::type::is_signed for + recording::memento_of_get_type. */ + +bool +recording::memento_of_get_type::is_signed () const +{ + switch (m_kind) + { + default: gcc_unreachable (); + + case GCC_JIT_TYPE_SIGNED_CHAR: + case GCC_JIT_TYPE_CHAR: + case GCC_JIT_TYPE_SHORT: + case GCC_JIT_TYPE_INT: + case GCC_JIT_TYPE_LONG: + case GCC_JIT_TYPE_LONG_LONG: + case GCC_JIT_TYPE_INT8_T: + case GCC_JIT_TYPE_INT16_T: + case GCC_JIT_TYPE_INT32_T: + case GCC_JIT_TYPE_INT64_T: + case GCC_JIT_TYPE_INT128_T: + return true; + + case GCC_JIT_TYPE_VOID: + case GCC_JIT_TYPE_VOID_PTR: + case GCC_JIT_TYPE_BOOL: + case GCC_JIT_TYPE_UNSIGNED_CHAR: + case GCC_JIT_TYPE_UNSIGNED_SHORT: + case GCC_JIT_TYPE_UNSIGNED_INT: + case GCC_JIT_TYPE_UNSIGNED_LONG: + case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: + case GCC_JIT_TYPE_UINT8_T: + case GCC_JIT_TYPE_UINT16_T: + case GCC_JIT_TYPE_UINT32_T: + case GCC_JIT_TYPE_UINT64_T: + case GCC_JIT_TYPE_UINT128_T: + + case GCC_JIT_TYPE_FLOAT: + case GCC_JIT_TYPE_DOUBLE: + case GCC_JIT_TYPE_LONG_DOUBLE: + + case GCC_JIT_TYPE_CONST_CHAR_PTR: + + case GCC_JIT_TYPE_SIZE_T: + + case GCC_JIT_TYPE_FILE_PTR: + + case GCC_JIT_TYPE_COMPLEX_FLOAT: + case GCC_JIT_TYPE_COMPLEX_DOUBLE: + case GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE: + return false; + } +} + /* Implementation of pure virtual hook recording::type::is_float for recording::memento_of_get_type. */ @@ -2478,6 +2602,16 @@ recording::memento_of_get_type::is_float () const case GCC_JIT_TYPE_UNSIGNED_LONG: case GCC_JIT_TYPE_LONG_LONG: case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: + case GCC_JIT_TYPE_UINT8_T: + case GCC_JIT_TYPE_UINT16_T: + case GCC_JIT_TYPE_UINT32_T: + case GCC_JIT_TYPE_UINT64_T: + case GCC_JIT_TYPE_UINT128_T: + case GCC_JIT_TYPE_INT8_T: + case GCC_JIT_TYPE_INT16_T: + case GCC_JIT_TYPE_INT32_T: + case GCC_JIT_TYPE_INT64_T: + case GCC_JIT_TYPE_INT128_T: return false; case GCC_JIT_TYPE_FLOAT: @@ -2531,6 +2665,16 @@ recording::memento_of_get_type::is_bool () const case GCC_JIT_TYPE_UNSIGNED_LONG: case GCC_JIT_TYPE_LONG_LONG: case GCC_JIT_TYPE_UNSIGNED_LONG_LONG: + case GCC_JIT_TYPE_UINT8_T: + case GCC_JIT_TYPE_UINT16_T: + case GCC_JIT_TYPE_UINT32_T: + case GCC_JIT_TYPE_UINT64_T: + case GCC_JIT_TYPE_UINT128_T: + case GCC_JIT_TYPE_INT8_T: + case GCC_JIT_TYPE_INT16_T: + case GCC_JIT_TYPE_INT32_T: + case GCC_JIT_TYPE_INT64_T: + case GCC_JIT_TYPE_INT128_T: return false; case GCC_JIT_TYPE_FLOAT: @@ -2601,7 +2745,18 @@ static const char * const get_type_strings[] = { "complex float", /* GCC_JIT_TYPE_COMPLEX_FLOAT */ "complex double", /* GCC_JIT_TYPE_COMPLEX_DOUBLE */ - "complex long double" /* GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE */ + "complex long double", /* GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE */ + + "__uint8_t", /* GCC_JIT_TYPE_UINT8_T */ + "__uint16_t", /* GCC_JIT_TYPE_UINT16_T */ + "__uint32_t", /* GCC_JIT_TYPE_UINT32_T */ + "__uint64_t", /* GCC_JIT_TYPE_UINT64_T */ + "__uint128_t", /* GCC_JIT_TYPE_UINT128_T */ + "__int8_t", /* GCC_JIT_TYPE_INT8_T */ + "__int16_t", /* GCC_JIT_TYPE_INT16_T */ + "__int32_t", /* GCC_JIT_TYPE_INT32_T */ + "__int64_t", /* GCC_JIT_TYPE_INT64_T */ + "__int128_t", /* GCC_JIT_TYPE_INT128_T */ }; @@ -2637,7 +2792,17 @@ static const char * const get_type_enum_strings[] = { "GCC_JIT_TYPE_FILE_PTR", "GCC_JIT_TYPE_COMPLEX_FLOAT", "GCC_JIT_TYPE_COMPLEX_DOUBLE", - "GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE" + "GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE", + "GCC_JIT_TYPE_UINT8_T", + "GCC_JIT_TYPE_UINT16_T", + "GCC_JIT_TYPE_UINT32_T", + "GCC_JIT_TYPE_UINT64_T", + "GCC_JIT_TYPE_UINT128_T", + "GCC_JIT_TYPE_INT8_T", + "GCC_JIT_TYPE_INT16_T", + "GCC_JIT_TYPE_INT32_T", + "GCC_JIT_TYPE_INT64_T", + "GCC_JIT_TYPE_INT128_T", }; void @@ -3807,6 +3972,16 @@ void recording::lvalue::set_link_section (const char *name) m_link_section = new_string (name); } +void recording::lvalue::set_register_name (const char *reg_name) +{ + m_reg_name = new_string (reg_name); +} + +void recording::lvalue::set_alignment (unsigned bytes) +{ + m_alignment = bytes; +} + /* The implementation of class gcc::jit::recording::param. */ /* Implementation of pure virtual hook recording::memento::replay_into @@ -4673,6 +4848,12 @@ recording::global::replay_into (replayer *r) if (m_link_section != NULL) global->set_link_section (m_link_section->c_str ()); + if (m_reg_name != NULL) + global->set_register_name (m_reg_name->c_str ()); + + if (m_alignment != 0) + global->set_alignment (m_alignment); + set_playback_obj (global); } @@ -5740,6 +5921,56 @@ recording::cast::write_reproducer (reproducer &r) r.get_identifier_as_type (get_type ())); } +/* Implementation of pure virtual hook recording::memento::replay_into + for recording::bitcast. */ + +void +recording::bitcast::replay_into (replayer *r) +{ + set_playback_obj (r->new_bitcast (playback_location (r, m_loc), + m_rvalue->playback_rvalue (), + get_type ()->playback_type ())); +} + +/* Implementation of pure virtual hook recording::rvalue::visit_children + for recording::bitcast. */ +void +recording::bitcast::visit_children (rvalue_visitor *v) +{ + v->visit (m_rvalue); +} + +/* Implementation of recording::memento::make_debug_string for + casts. */ + +recording::string * +recording::bitcast::make_debug_string () +{ + enum precedence prec = get_precedence (); + return string::from_printf (m_ctxt, + "bitcast(%s, %s)", + m_rvalue->get_debug_string_parens (prec), + get_type ()->get_debug_string ()); +} + +/* Implementation of recording::memento::write_reproducer for casts. */ + +void +recording::bitcast::write_reproducer (reproducer &r) +{ + const char *id = r.make_identifier (this, "rvalue"); + r.write (" gcc_jit_rvalue *%s =\n" + " gcc_jit_context_new_bitcast (%s,\n" + " %s, /* gcc_jit_location *loc */\n" + " %s, /* gcc_jit_rvalue *rvalue */\n" + " %s); /* gcc_jit_type *type */\n", + id, + r.get_identifier (get_context ()), + r.get_identifier (m_loc), + r.get_identifier_as_rvalue (m_rvalue), + r.get_identifier_as_type (get_type ())); +} + /* The implementation of class gcc::jit::recording::base_call. */ /* The constructor for gcc::jit::recording::base_call. */ @@ -6343,11 +6574,18 @@ recording::function_pointer::write_reproducer (reproducer &r) void recording::local::replay_into (replayer *r) { - set_playback_obj ( - m_func->playback_function () + playback::lvalue *obj = m_func->playback_function () ->new_local (playback_location (r, m_loc), m_type->playback_type (), - playback_string (m_name))); + playback_string (m_name)); + + if (m_reg_name != NULL) + obj->set_register_name (m_reg_name->c_str ()); + + if (m_alignment != 0) + obj->set_alignment (m_alignment); + + set_playback_obj (obj); } /* Override the default implementation of diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index 846d65cb202..78ee36488c7 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -205,6 +205,11 @@ public: rvalue *expr, type *type_); + rvalue * + new_bitcast (location *loc, + rvalue *expr, + type *type_); + lvalue * new_array_access (location *loc, rvalue *ptr, @@ -564,6 +569,7 @@ public: virtual bool is_void () const { return false; } virtual vector_type *is_vector () { return NULL; } virtual bool has_known_size () const { return true; } + virtual bool is_signed () const = 0; bool is_numeric () const { @@ -604,12 +610,21 @@ public: bool accepts_writes_from (type *rtype) FINAL OVERRIDE { if (m_kind == GCC_JIT_TYPE_VOID_PTR) - if (rtype->is_pointer ()) - { - /* LHS (this) is type (void *), and the RHS is a pointer: - accept it: */ - return true; - } + { + if (rtype->is_pointer ()) + { + /* LHS (this) is type (void *), and the RHS is a pointer: + accept it: */ + return true; + } + } else if (is_int () + && rtype->is_int () + && get_size () == rtype->get_size () + && is_signed () == rtype->is_signed ()) + { + /* LHS (this) is an integer of the same size and sign as rtype. */ + return true; + } return type::accepts_writes_from (rtype); } @@ -620,6 +635,7 @@ public: type *is_pointer () FINAL OVERRIDE { return dereference (); } type *is_array () FINAL OVERRIDE { return NULL; } bool is_void () const FINAL OVERRIDE { return m_kind == GCC_JIT_TYPE_VOID; } + bool is_signed () const FINAL OVERRIDE; public: void replay_into (replayer *r) FINAL OVERRIDE; @@ -653,6 +669,7 @@ public: bool is_bool () const FINAL OVERRIDE { return false; } type *is_pointer () FINAL OVERRIDE { return m_other_type; } type *is_array () FINAL OVERRIDE { return NULL; } + bool is_signed () const FINAL OVERRIDE { return false; } private: string * make_debug_string () FINAL OVERRIDE; @@ -674,12 +691,15 @@ public: type *dereference () FINAL OVERRIDE { return m_other_type->dereference (); } + size_t get_size () FINAL OVERRIDE { return m_other_type->get_size (); }; + bool is_int () const FINAL OVERRIDE { return m_other_type->is_int (); } bool is_float () const FINAL OVERRIDE { return m_other_type->is_float (); } bool is_bool () const FINAL OVERRIDE { return m_other_type->is_bool (); } type *is_pointer () FINAL OVERRIDE { return m_other_type->is_pointer (); } type *is_array () FINAL OVERRIDE { return m_other_type->is_array (); } struct_ *is_struct () FINAL OVERRIDE { return m_other_type->is_struct (); } + bool is_signed () const FINAL OVERRIDE { return m_other_type->is_signed (); } protected: type *m_other_type; @@ -811,6 +831,7 @@ class array_type : public type type *is_pointer () FINAL OVERRIDE { return NULL; } type *is_array () FINAL OVERRIDE { return m_element_type; } int num_elements () { return m_num_elements; } + bool is_signed () const FINAL OVERRIDE { return false; } void replay_into (replayer *) FINAL OVERRIDE; @@ -844,6 +865,7 @@ public: bool is_bool () const FINAL OVERRIDE { return false; } type *is_pointer () FINAL OVERRIDE { return NULL; } type *is_array () FINAL OVERRIDE { return NULL; } + bool is_signed () const FINAL OVERRIDE { return false; } void replay_into (replayer *) FINAL OVERRIDE; @@ -957,6 +979,7 @@ public: bool is_bool () const FINAL OVERRIDE { return false; } type *is_pointer () FINAL OVERRIDE { return NULL; } type *is_array () FINAL OVERRIDE { return NULL; } + bool is_signed () const FINAL OVERRIDE { return false; } bool has_known_size () const FINAL OVERRIDE { return m_fields != NULL; } @@ -1146,10 +1169,12 @@ public: lvalue (context *ctxt, location *loc, type *type_) - : rvalue (ctxt, loc, type_), + : rvalue (ctxt, loc, type_), + m_link_section (NULL), + m_reg_name (NULL), m_tls_model (GCC_JIT_TLS_MODEL_NONE), - m_link_section (NULL) - {} + m_alignment (0) + {} playback::lvalue * playback_lvalue () const @@ -1172,10 +1197,15 @@ public: virtual bool is_global () const { return false; } void set_tls_model (enum gcc_jit_tls_model model); void set_link_section (const char *name); + void set_register_name (const char *reg_name); + void set_alignment (unsigned bytes); + unsigned get_alignment () const { return m_alignment; } protected: - enum gcc_jit_tls_model m_tls_model; string *m_link_section; + string *m_reg_name; + enum gcc_jit_tls_model m_tls_model; + unsigned m_alignment; }; class param : public lvalue @@ -1691,6 +1721,33 @@ private: rvalue *m_rvalue; }; +class bitcast : public rvalue +{ +public: + bitcast (context *ctxt, + location *loc, + rvalue *a, + type *type_) + : rvalue (ctxt, loc, type_), + m_rvalue (a) + {} + + void replay_into (replayer *r) FINAL OVERRIDE; + + void visit_children (rvalue_visitor *v) FINAL OVERRIDE; + +private: + string * make_debug_string () FINAL OVERRIDE; + void write_reproducer (reproducer &r) FINAL OVERRIDE; + enum precedence get_precedence () const FINAL OVERRIDE + { + return PRECEDENCE_CAST; + } + +private: + rvalue *m_rvalue; +}; + class base_call : public rvalue { public: diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc index 4c352e8c93d..cc6486c9cad 100644 --- a/gcc/jit/libgccjit.cc +++ b/gcc/jit/libgccjit.cc @@ -352,6 +352,17 @@ compatible_types (gcc::jit::recording::type *ltype, return ltype->accepts_writes_from (rtype); } +/* Public entrypoint wrapping compatible_types. */ + +int +gcc_jit_compatible_types (gcc_jit_type *ltype, + gcc_jit_type *rtype) +{ + RETURN_VAL_IF_FAIL (ltype, 0, NULL, NULL, "NULL ltype"); + RETURN_VAL_IF_FAIL (rtype, 0, NULL, NULL, "NULL rtype"); + return compatible_types (ltype, rtype); +} + /* Public entrypoint for acquiring a gcc_jit_context. Note that this creates a new top-level context; contrast with gcc_jit_context_new_child_context below. @@ -456,7 +467,7 @@ gcc_jit_context_get_type (gcc_jit_context *ctxt, JIT_LOG_FUNC (ctxt->get_logger ()); RETURN_NULL_IF_FAIL_PRINTF1 ( (type >= GCC_JIT_TYPE_VOID - && type <= GCC_JIT_TYPE_FILE_PTR), + && type < NUM_GCC_JIT_TYPES), ctxt, NULL, "unrecognized value for enum gcc_jit_types: %i", type); @@ -526,6 +537,22 @@ gcc_jit_type_get_volatile (gcc_jit_type *type) /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the + gcc::jit::recording::type::get_size method, in + jit-recording.cc. */ + +ssize_t +gcc_jit_type_get_size (gcc_jit_type *type) +{ + RETURN_VAL_IF_FAIL (type, -1, NULL, NULL, "NULL type"); + RETURN_VAL_IF_FAIL + (type->is_int (), -1, NULL, NULL, + "only getting the size of an integer type is supported for now"); + return type->get_size (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the gcc::jit::recording::type::is_array method, in jit-recording.cc. */ @@ -2119,7 +2146,8 @@ gcc_jit_context_new_binary_op (gcc_jit_context *ctxt, RETURN_NULL_IF_FAIL (a, ctxt, loc, "NULL a"); RETURN_NULL_IF_FAIL (b, ctxt, loc, "NULL b"); RETURN_NULL_IF_FAIL_PRINTF4 ( - a->get_type ()->unqualified () == b->get_type ()->unqualified (), + compatible_types (a->get_type ()->unqualified (), + b->get_type ()->unqualified ()), ctxt, loc, "mismatching types for binary op:" " a: %s (type: %s) b: %s (type: %s)", @@ -2408,6 +2436,28 @@ gcc_jit_context_new_cast (gcc_jit_context *ctxt, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the + gcc::jit::recording::context::new_bitcast method in jit-recording.c. */ + +gcc_jit_rvalue * +gcc_jit_context_new_bitcast (gcc_jit_context *ctxt, + gcc_jit_location *loc, + gcc_jit_rvalue *rvalue, + gcc_jit_type *type) +{ + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + JIT_LOG_FUNC (ctxt->get_logger ()); + /* LOC can be NULL. */ + RETURN_NULL_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); + RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type"); + /* We cannot check if the size of rvalue matches the size of type here, so + we'll do it at playback. */ + + return static_cast <gcc_jit_rvalue *> (ctxt->new_bitcast (loc, rvalue, type)); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the gcc::jit::recording::context::new_array_access method in jit-recording.cc. */ @@ -2652,6 +2702,47 @@ gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the + gcc::jit::recording::lvalue::get_alignment method in jit-recording.cc. */ + +unsigned +gcc_jit_lvalue_get_alignment (gcc_jit_lvalue *lvalue) +{ + RETURN_VAL_IF_FAIL (lvalue, 0, NULL, NULL, "NULL lvalue"); + return lvalue->get_alignment (); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::lvalue::set_alignment method in jit-recording.cc. */ + +void +gcc_jit_lvalue_set_alignment (gcc_jit_lvalue *lvalue, + unsigned bytes) +{ + RETURN_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue"); + RETURN_IF_FAIL ((bytes & (bytes - 1)) == 0, NULL, NULL, + "alignment is not a power of 2"); + lvalue->set_alignment (bytes); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::lvalue::set_register_name method in jit-recording.cc. */ + +void +gcc_jit_lvalue_set_register_name (gcc_jit_lvalue *lvalue, + const char *reg_name) +{ + RETURN_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue"); + RETURN_IF_FAIL (reg_name, NULL, NULL, "NULL reg_name"); + lvalue->set_register_name (reg_name); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the gcc::jit::recording::function::new_local method in jit-recording.cc. */ gcc_jit_lvalue * @@ -3437,6 +3528,23 @@ gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt, gcc::jit::recording::context::set_inner_bool_option method in jit-recording.cc. */ +void +gcc_jit_context_set_bool_print_errors_to_stderr (gcc_jit_context *ctxt, + int enabled) +{ + RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + JIT_LOG_FUNC (ctxt->get_logger ()); + ctxt->set_inner_bool_option ( + gcc::jit::INNER_BOOL_OPTION_PRINT_ERRORS_TO_STDERR, + enabled); +} + +/* Public entrypoint. See description in libgccjit.h. + + After error-checking, the real work is done by the + gcc::jit::recording::context::set_inner_bool_option method in + jit-recording.cc. */ + extern void gcc_jit_context_set_bool_use_external_driver (gcc_jit_context *ctxt, int bool_value) diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h index 95d60f845db..062f06d691a 100644 --- a/gcc/jit/libgccjit.h +++ b/gcc/jit/libgccjit.h @@ -293,6 +293,24 @@ gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt, tested for with #ifdef. */ #define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_allow_unreachable_blocks +/* By default, libgccjit will print errors to stderr. + + This option can be used to disable the printing. + + This entrypoint was added in LIBGCCJIT_ABI_23; you can test for + its presence using + #ifdef LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr +*/ + +extern void +gcc_jit_context_set_bool_print_errors_to_stderr (gcc_jit_context *ctxt, + int enabled); + +/* Pre-canned feature macro to indicate the presence of + gcc_jit_context_set_bool_print_errors_to_stderr. This can be + tested for with #ifdef. */ +#define LIBGCCJIT_HAVE_gcc_jit_context_set_bool_print_errors_to_stderr + /* Implementation detail: libgccjit internally generates assembler, and uses "driver" code for converting it to other formats (e.g. shared libraries). @@ -574,8 +592,19 @@ enum gcc_jit_types /* Complex numbers. */ GCC_JIT_TYPE_COMPLEX_FLOAT, GCC_JIT_TYPE_COMPLEX_DOUBLE, - GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE - + GCC_JIT_TYPE_COMPLEX_LONG_DOUBLE, + + /* Sized integer types. */ + GCC_JIT_TYPE_UINT8_T, + GCC_JIT_TYPE_UINT16_T, + GCC_JIT_TYPE_UINT32_T, + GCC_JIT_TYPE_UINT64_T, + GCC_JIT_TYPE_UINT128_T, + GCC_JIT_TYPE_INT8_T, + GCC_JIT_TYPE_INT16_T, + GCC_JIT_TYPE_INT32_T, + GCC_JIT_TYPE_INT64_T, + GCC_JIT_TYPE_INT128_T }; extern gcc_jit_type * @@ -601,6 +630,23 @@ gcc_jit_type_get_const (gcc_jit_type *type); extern gcc_jit_type * gcc_jit_type_get_volatile (gcc_jit_type *type); +#define LIBGCCJIT_HAVE_SIZED_INTEGERS + +/* Given types LTYPE and RTYPE, return non-zero if they are compatible. + This API entrypoint was added in LIBGCCJIT_ABI_20; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS */ +extern int +gcc_jit_compatible_types (gcc_jit_type *ltype, + gcc_jit_type *rtype); + +/* Given type "T", get its size. + This API entrypoint was added in LIBGCCJIT_ABI_20; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_SIZED_INTEGERS */ +extern ssize_t +gcc_jit_type_get_size (gcc_jit_type *type); + /* Given type "T", get type "T[N]" (for a constant N). */ extern gcc_jit_type * gcc_jit_context_new_array_type (gcc_jit_context *ctxt, @@ -1206,6 +1252,40 @@ gcc_jit_context_new_cast (gcc_jit_context *ctxt, gcc_jit_rvalue *rvalue, gcc_jit_type *type); +/* Reinterpret a value as another type. + +#define LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast + + The types must be of the same size. + + This API entrypoint was added in LIBGCCJIT_ABI_21; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_gcc_jit_context_new_bitcast */ +extern gcc_jit_rvalue * +gcc_jit_context_new_bitcast (gcc_jit_context *ctxt, + gcc_jit_location *loc, + gcc_jit_rvalue *rvalue, + gcc_jit_type *type); + +#define LIBGCCJIT_HAVE_ALIGNMENT + +/* Set the alignment of a variable. + + This API entrypoint was added in LIBGCCJIT_ABI_24; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_ALIGNMENT */ +extern void +gcc_jit_lvalue_set_alignment (gcc_jit_lvalue *lvalue, + unsigned bytes); + +/* Get the alignment of a variable. + + This API entrypoint was added in LIBGCCJIT_ABI_24; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_ALIGNMENT */ +extern unsigned +gcc_jit_lvalue_get_alignment (gcc_jit_lvalue *lvalue); + extern gcc_jit_lvalue * gcc_jit_context_new_array_access (gcc_jit_context *ctxt, gcc_jit_location *loc, @@ -1277,6 +1357,18 @@ extern void gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, const char *section_name); +#define LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name + +/* Make this variable a register variable and set its register name. + + This API entrypoint was added in LIBGCCJIT_ABI_22; you can test for its + presence using + #ifdef LIBGCCJIT_HAVE_gcc_jit_lvalue_set_register_name +*/ +void +gcc_jit_lvalue_set_register_name (gcc_jit_lvalue *lvalue, + const char *reg_name); + extern gcc_jit_lvalue * gcc_jit_function_new_local (gcc_jit_function *func, gcc_jit_location *loc, diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map index f373fd39ac7..cc22b2b414e 100644 --- a/gcc/jit/libgccjit.map +++ b/gcc/jit/libgccjit.map @@ -238,8 +238,36 @@ LIBGCCJIT_ABI_18 { } LIBGCCJIT_ABI_17; LIBGCCJIT_ABI_19 { + global: gcc_jit_context_new_array_constructor; gcc_jit_context_new_struct_constructor; gcc_jit_context_new_union_constructor; gcc_jit_global_set_initializer_rvalue; } LIBGCCJIT_ABI_18; + +LIBGCCJIT_ABI_20 { + global: + gcc_jit_compatible_types; + gcc_jit_type_get_size; +} LIBGCCJIT_ABI_19; + +LIBGCCJIT_ABI_21 { + global: + gcc_jit_context_new_bitcast; +} LIBGCCJIT_ABI_20; + +LIBGCCJIT_ABI_22 { + global: + gcc_jit_lvalue_set_register_name; +} LIBGCCJIT_ABI_21; + +LIBGCCJIT_ABI_23 { + global: + gcc_jit_context_set_bool_print_errors_to_stderr; +} LIBGCCJIT_ABI_22; + +LIBGCCJIT_ABI_24 { + global: + gcc_jit_lvalue_set_alignment; + gcc_jit_lvalue_get_alignment; +} LIBGCCJIT_ABI_23; diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h index 49c8f5820cf..e2263951709 100644 --- a/gcc/langhooks-def.h +++ b/gcc/langhooks-def.h @@ -216,6 +216,7 @@ extern tree lhd_unit_size_without_reusable_padding (tree); #define LANG_HOOKS_GET_FIXED_POINT_TYPE_INFO NULL #define LANG_HOOKS_TYPE_DWARF_ATTRIBUTE lhd_type_dwarf_attribute #define LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING lhd_unit_size_without_reusable_padding +#define LANG_HOOKS_CLASSTYPE_AS_BASE hook_tree_const_tree_null #define LANG_HOOKS_FOR_TYPES_INITIALIZER { \ LANG_HOOKS_MAKE_TYPE, \ @@ -243,7 +244,8 @@ extern tree lhd_unit_size_without_reusable_padding (tree); LANG_HOOKS_GET_DEBUG_TYPE, \ LANG_HOOKS_GET_FIXED_POINT_TYPE_INFO, \ LANG_HOOKS_TYPE_DWARF_ATTRIBUTE, \ - LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING \ + LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING, \ + LANG_HOOKS_CLASSTYPE_AS_BASE \ } /* Declaration hooks. */ diff --git a/gcc/langhooks.h b/gcc/langhooks.h index 0eec1b0f7ad..4731f089a2e 100644 --- a/gcc/langhooks.h +++ b/gcc/langhooks.h @@ -188,6 +188,11 @@ struct lang_hooks_for_types /* Returns a tree for the unit size of T excluding tail padding that might be used by objects inheriting from T. */ tree (*unit_size_without_reusable_padding) (tree); + + /* Returns type corresponding to FIELD's type when FIELD is a C++ base class + i.e., type without virtual base classes or tail padding. Returns + NULL_TREE otherwise. */ + tree (*classtype_as_base) (const_tree); }; /* Language hooks related to decls and the symbol table. */ diff --git a/gcc/lto-wrapper.cc b/gcc/lto-wrapper.cc index 6027fd9efdd..285e6e96af5 100644 --- a/gcc/lto-wrapper.cc +++ b/gcc/lto-wrapper.cc @@ -1364,14 +1364,17 @@ jobserver_active_p (void) void print_lto_docs_link () { - const char *url = get_option_url (NULL, OPT_flto); + bool print_url = global_dc->printer->url_format != URL_FORMAT_NONE; + const char *url = global_dc->get_option_url (global_dc, OPT_flto); pretty_printer pp; pp.url_format = URL_FORMAT_DEFAULT; pp_string (&pp, "see the "); - pp_begin_url (&pp, url); + if (print_url) + pp_begin_url (&pp, url); pp_string (&pp, "%<-flto%> option documentation"); - pp_end_url (&pp); + if (print_url) + pp_end_url (&pp); pp_string (&pp, " for more information"); inform (UNKNOWN_LOCATION, pp_formatted_text (&pp)); } @@ -1573,6 +1576,14 @@ run_gcc (unsigned argc, char *argv[]) incoming_dumppfx = dumppfx = option->arg; break; + case OPT_fdiagnostics_urls_: + diagnostic_urls_init (global_dc, option->value); + break; + + case OPT_fdiagnostics_color_: + diagnostic_color_init (global_dc, option->value); + break; + default: break; } @@ -2130,6 +2141,9 @@ main (int argc, char *argv[]) gcc_init_libintl (); diagnostic_initialize (global_dc, 0); + diagnostic_color_init (global_dc); + diagnostic_urls_init (global_dc); + global_dc->get_option_url = get_option_url; if (atexit (lto_wrapper_cleanup) != 0) fatal_error (input_location, "%<atexit%> failed"); diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index fff168c057b..be2dd570046 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,11 @@ +2022-04-26 Joseph Myers <joseph@codesourcery.com> + + * sv.po: Update. + +2022-04-14 Joseph Myers <joseph@codesourcery.com> + + * de.po, fr.po, sv.po: Update. + 2022-04-05 Joseph Myers <joseph@codesourcery.com> * be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po, diff --git a/gcc/po/de.po b/gcc/po/de.po index 41f77e122d6..edf4f902d04 100644 --- a/gcc/po/de.po +++ b/gcc/po/de.po @@ -8,10 +8,10 @@ # Roland Illig <roland.illig@gmx.de>, 2015, 2017-2022. msgid "" msgstr "" -"Project-Id-Version: gcc 12.1-b20220213\n" +"Project-Id-Version: gcc 12.1-b20220403\n" "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n" "POT-Creation-Date: 2022-04-01 17:30+0000\n" -"PO-Revision-Date: 2022-03-12 08:20+0100\n" +"PO-Revision-Date: 2022-04-06 02:26+0200\n" "Last-Translator: Roland Illig <roland.illig@gmx.de>\n" "Language-Team: German <translation-team-de@lists.sourceforge.net>\n" "Language: de\n" @@ -2709,10 +2709,9 @@ msgid "Support dynamic initialization of thread-local variables in a different t msgstr "Dynamische Initialisierung thread-lokaler Variablen in anderer Übersetzungseinheit unterstützen." #: c-family/c.opt:1728 -#, fuzzy, no-c-format -#| msgid "invalid call to non-function" +#, no-c-format msgid "Fold calls to simple inline functions." -msgstr "ungültiger Aufruf einer Nicht-Funktion" +msgstr "Aufrufe von einfachen inline-Funktionen zusammenfalten." #: c-family/c.opt:1735 #, no-c-format @@ -3531,8 +3530,7 @@ msgid "Add comments for ignored declarations in the generated C++ header." msgstr "Kommentare hinzufügen, wenn Deklarationen im generierten C++-Header ignoriert werden." #: d/lang.opt:280 -#, fuzzy, no-c-format -#| msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <file>." +#, no-c-format msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <filename>." msgstr "-fdump-cxx-spec=<Dateiname>\tAlle Deklarationen als C++-Code nach <Dateiname> schreiben." @@ -3622,8 +3620,7 @@ msgid "Use field-wise comparisons for struct equality." msgstr "Feldweisen Vergleich für Strukturgleichheit verwenden." #: d/lang.opt:373 -#, fuzzy, no-c-format -#| msgid "When a symbol is resolved, check alias this scope before going to upper scopes." +#, no-c-format msgid "When a symbol is resolved, check `alias this' scope before going to upper scopes." msgstr "Wenn ein Symbol aufgelöst wird, den Gültigkeitsbereich »alias this« prüfen, erst danach zu den höheren Bereichen gehen." @@ -4115,7 +4112,7 @@ msgstr "Gesamtgraphen des Analysierers nach SRCFILE.supergraph.dot wegschreiben. #: analyzer/analyzer.opt:255 #, no-c-format msgid "Emit custom warnings with internal details intended for analyzer developers." -msgstr "" +msgstr "Benutzerdefinierte Warnungen mit internen Details ausgeben, die für Entwickler von Analyseprogrammen bestimmt sind." #: config/vms/vms.opt:27 #, no-c-format @@ -5482,7 +5479,7 @@ msgstr "Konstante memset-Größe in Bytes, ab der die MOPS-Sequenz verwendet wer #: config/aarch64/aarch64.opt:298 #, no-c-format msgid "Limit how much the autovectorizer may unroll a loop." -msgstr "" +msgstr "Begrenzen, wie weit der Autovektorisierer eine Schleife abrollen darf." #: config/linux.opt:24 #, no-c-format @@ -7326,16 +7323,14 @@ msgid "Support multi-threading." msgstr "Multi-Threading unterstützen." #: config/nvptx/nvptx-gen.opt:24 -#, fuzzy, no-c-format -#| msgid "Known ARM architectures (for use with the -march= option):" +#, no-c-format msgid "Known PTX ISA target architectures (for use with the -misa= option):" -msgstr "Bekannte ARM-Architekturen (für Verwendung mit Option -march=):" +msgstr "Bekannte PTX-ISA-Architekturen (für Verwendung mit Option -misa=):" #: config/nvptx/nvptx.opt:28 -#, fuzzy, no-c-format -#| msgid "Does nothing. Preserved for backward compatibility." +#, no-c-format msgid "Ignored, but preserved for backward compatibility. Only 64-bit ABI is supported." -msgstr "Tut nichts. Für Rückwärtskompatibilität erhalten." +msgstr "Tut nichts. Für Rückwärtskompatibilität erhalten. Nur die 64-Bit-ABI wird unterstützt." #: config/nvptx/nvptx.opt:33 #, no-c-format @@ -7368,33 +7363,29 @@ msgid "Generate code for OpenMP offloading: enables -msoft-stack and -muniform-s msgstr "Code für OpenMP-Auslagerung erzeugen: schaltet »-msoft-stack« und »-muniform-simt« ein." #: config/nvptx/nvptx.opt:58 -#, fuzzy, no-c-format -#| msgid "Specify the target architecture." +#, no-c-format msgid "Specify the PTX ISA target architecture to use." -msgstr "Ziel-Architektur angeben." +msgstr "Die zu verwendende PTX-ISA-Ziel-Architektur angeben." #: config/nvptx/nvptx.opt:62 #, no-c-format msgid "Alias:" -msgstr "" +msgstr "Alias:" #: config/nvptx/nvptx.opt:117 -#, fuzzy, no-c-format -#| msgid "Known PTX versions (for use with the -mptx= option):" +#, no-c-format msgid "Known PTX ISA versions (for use with the -mptx= option):" -msgstr "Bekannte PTX-Versionen (für Verwendung mit Option -mptx=):" +msgstr "Bekannte PTX-ISA-Versionen (für Verwendung mit Option -mptx=):" #: config/nvptx/nvptx.opt:136 -#, fuzzy, no-c-format -#| msgid "Specify the version of the ptx version to use." +#, no-c-format msgid "Specify the PTX ISA version to use." -msgstr "Die Version der PTX angeben, die verwendet wird." +msgstr "Die Version der PTX-ISA angeben, die verwendet wird." #: config/nvptx/nvptx.opt:140 -#, fuzzy, no-c-format -#| msgid "Use fp registers." +#, no-c-format msgid "Initialize ptx registers." -msgstr "FP-Register verwenden." +msgstr "PTX-Register initialisieren." #: config/vxworks.opt:36 #, no-c-format @@ -9122,18 +9113,17 @@ msgstr "Benutzerdefinierte Befehle einschalten." #: config/loongarch/loongarch.opt:47 #, no-c-format msgid "Basic ISAs of LoongArch:" -msgstr "" +msgstr "Grundlegende ISAs von LoongArch:" #: config/loongarch/loongarch.opt:56 #, no-c-format msgid "FPU types of LoongArch:" -msgstr "" +msgstr "FPU-Typen von LoongArch:" #: config/loongarch/loongarch.opt:69 -#, fuzzy, no-c-format -#| msgid "-march=ISA\tGenerate code for the given ISA." +#, no-c-format msgid "-mfpu=FPU\tGenerate code for the given FPU." -msgstr "-march=ISA\tCode für das gegebene ISA erzeugen." +msgstr "-mfpu=FPU\tCode für die angegebene FPU erzeugen." #: config/loongarch/loongarch.opt:76 config/mips/mips.opt:377 #, no-c-format @@ -9153,30 +9143,27 @@ msgstr "Hardware-Gleitkommabefehle erlauben, um 32-Bit- und 64-Bit-Befehle abzud #: config/loongarch/loongarch.opt:90 #, no-c-format msgid "LoongArch CPU types:" -msgstr "" +msgstr "CPU-Typen für LoongArch:" #: config/loongarch/loongarch.opt:103 -#, fuzzy, no-c-format -#| msgid "-march=ISA\tGenerate code for the given ISA." +#, no-c-format msgid "-march=PROCESSOR\tGenerate code for the given PROCESSOR ISA." -msgstr "-march=ISA\tCode für das gegebene ISA erzeugen." +msgstr "-march=<Prozessor>\tCode für die angegebene <Prozessor>-ISA erzeugen." #: config/loongarch/loongarch.opt:107 -#, fuzzy, no-c-format -#| msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR." +#, no-c-format msgid "-mtune=PROCESSOR\tGenerate optimized code for PROCESSOR." -msgstr "-mtune=PROZESSOR\tAusgabe für PROZESSOR optimieren." +msgstr "-mtune=<Prozessor>\tCode für <Prozessor> optimieren." #: config/loongarch/loongarch.opt:116 #, no-c-format msgid "Base ABI types for LoongArch:" -msgstr "" +msgstr "Basis-ABI-Typen für LoongArch:" #: config/loongarch/loongarch.opt:129 -#, fuzzy, no-c-format -#| msgid "-mabi=ABI\tGenerate code that conforms to the given ABI." +#, no-c-format msgid "-mabi=BASEABI\tGenerate code that conforms to the given BASEABI." -msgstr "-mabi=ABI\tCode erzeugen, der zum angegebenen ABI passt." +msgstr "-mabi=<Basis-ABI>\tCode erzeugen, der zur angegebenen Basis-ABI passt." #: config/loongarch/loongarch.opt:138 config/mips/mips.opt:71 #, no-c-format @@ -9191,22 +9178,22 @@ msgstr "Ganzzahldivision durch Null abfangen." #: config/loongarch/loongarch.opt:146 #, no-c-format msgid "Conditional moves for integral are enabled." -msgstr "" +msgstr "Bedingte Kopierbefehle für Ganzzahlen aktivieren." #: config/loongarch/loongarch.opt:150 #, no-c-format msgid "Conditional moves for float are enabled." -msgstr "" +msgstr "Bedingte Kopierbefehle für Gleitkommazahlen aktivieren." #: config/loongarch/loongarch.opt:154 #, no-c-format msgid "Prevent optimizing block moves, which is also the default behavior of -Os." -msgstr "" +msgstr "Die Optimierung von Blockkopieraktionen verhindern, was auch das Standardverhalten von -Os ist." #: config/loongarch/loongarch.opt:162 #, no-c-format msgid "-mmax-inline-memcpy-size=SIZE\tSet the max size of memcpy to inline, default is 1024." -msgstr "" +msgstr "-mmax-inline-memcpy-size=SIZE\tDie maximale Größe von inline-memcpy festlegen, Standard ist 1024." #: config/or1k/elf.opt:28 #, no-c-format @@ -12721,10 +12708,9 @@ msgid "Warn whenever a trampoline is generated." msgstr "Warnen, wenn ein Trampolin generiert wird." #: common.opt:806 -#, fuzzy, no-c-format -#| msgid "Warn about maybe uninitialized automatic variables." +#, no-c-format msgid "Warn about cases where -ftrivial-auto-var-init cannot initialize an auto variable." -msgstr "Bei möglicherweise nicht initialisierten automatischen Variablen warnen." +msgstr "Vor Fällen warnen, in denen -ftrivial-auto-var-init eine Auto-Variable nicht initialisieren kann." #: common.opt:810 #, no-c-format @@ -15307,8 +15293,7 @@ msgid "Recursive cloning only when the probability of call being executed exceed msgstr "Rekursives Klonen nur dann, wenn die Wahrscheinlichkeit, dass der Aufruf ausgeführt wird, den Parameter überschreitet." #: params.opt:254 -#, fuzzy, no-c-format -#| msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that that bring back an unchanged value by this factor." +#, no-c-format msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that bring back an unchanged value by this factor." msgstr "Bei der Weitergabe von IPA-CP-Effektschätzungen werden die Häufigkeiten der rekursiven Kanten, die einen unveränderten Wert zurückbringen, mit diesem Faktor multipliziert." @@ -15673,10 +15658,9 @@ msgid "Maximum loop depth of a call which is considered for inlining functions c msgstr "Maximale Schleifentiefe eines Aufrufs, der beim inlinen von Funktionen, die nur einmal aufgerufen werden, berücksichtigt wird." #: params.opt:554 -#, fuzzy, no-c-format -#| msgid "Maximum combinaed size of caller and callee wich is inlined if callee is called once." +#, no-c-format msgid "Maximum combined size of caller and callee which is inlined if callee is called once." -msgstr "Maximale Gesamtgröße von aufrufender und aufgerufener Funktion, für den Fall, dass die aufgerufene Funktion in die aufrufende eingereiht wird." +msgstr "Maximale Gesamtgröße von aufrufender und aufgerufener Funktion, für den Fall, dass die aufgerufene Funktion in die aufrufende eingereiht wird und die aufgerufene Funktion nur von einer Stelle aus aufgerufen wird." #: params.opt:558 #, no-c-format @@ -15756,7 +15740,7 @@ msgstr "Die Höchstzahl der Versuche zur Rückverfolgung bei Modulo-Planung von #: params.opt:618 #, no-c-format msgid "Minimum page size for warning purposes." -msgstr "" +msgstr "Mindestseitengröße für Warnzwecke." #: params.opt:622 #, no-c-format @@ -16365,10 +16349,9 @@ msgid "The maximum factor which the loop vectorizer applies to the cost of state msgstr "Der maximale Faktor, den der Schleifenvektorisierer auf die Kosten der Anweisungen in einer inneren Schleife im Verhältnis zur vektorisierten Schleife anwendet." #: params.opt:1185 -#, fuzzy, no-c-format -#| msgid "Enable loop vectorization on trees." +#, no-c-format msgid "Enable loop vectorization of floating point inductions." -msgstr "Schleifenvektorisierung auf Bäumen einschalten." +msgstr "Schleifenvektorisierung von Gleitkommabefehlen einschalten." #: params.opt:1189 #, no-c-format @@ -22753,7 +22736,7 @@ msgstr "Interner Fehler: loop %d%'s latch is marked as part of irreducible regio #: cfgloop.cc:1573 #, gcc-internal-format msgid "loop %d%'s number of iterations %qE references the released SSA name %qE" -msgstr "" +msgstr "die Anzahl der Iterationen der Schleife %d %qE verweist auf den freigegebenen SSA-Namen %qE" #: cfgloop.cc:1606 #, gcc-internal-format, gfc-internal-format @@ -26246,7 +26229,7 @@ msgstr "Anweisung wird niemals ausgeführt" #: gimplify.cc:2132 #, gcc-internal-format msgid "%qs cannot be initialized with%<-ftrivial-auto-var_init%>" -msgstr "" +msgstr "%qs kann nicht mit %<-ftrivial-auto-var_init%> initialisiert werden" #: gimplify.cc:2524 gimplify.cc:2532 #, gcc-internal-format @@ -27778,10 +27761,9 @@ msgid "location of OpenACC %<kernels%>" msgstr "Stelle des OpenACC-%<kernels%>" #: omp-oacc-kernels-decompose.cc:1288 -#, fuzzy, gcc-internal-format -#| msgid "%<ancestor%> not yet supported" +#, gcc-internal-format msgid "%qs not yet supported" -msgstr "%<ancestor%> wird noch nicht unterstützt" +msgstr "%qs wird noch nicht unterstützt" #: omp-oacc-neuter-broadcast.cc:1764 #, gcc-internal-format @@ -28473,12 +28455,10 @@ msgstr "%s kann nicht in Plugin %s gefunden werden: %s" msgid "failed to initialize plugin %s" msgstr "Plugin %s kann nicht initialisiert werden" -# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90148 #: plugin.cc:1009 -#, fuzzy, gcc-internal-format -#| msgid "%<-iplugindir%> <dir> option not passed from the gcc driver" +#, gcc-internal-format msgid "%<-iplugindir%> option not passed from the gcc driver" -msgstr "Option %<-iplugindir <Verz>%> nicht vom GCC-Treiber übergeben" +msgstr "Option %<-iplugindir%> nicht vom GCC-Treiber übergeben" #: pointer-query.cc:1202 #, gcc-internal-format @@ -29413,16 +29393,14 @@ msgid "%qs is not supported for this target" msgstr "%qs wird auf diesem Ziel nicht unterstützt" #: toplev.cc:1685 -#, fuzzy, gcc-internal-format -#| msgid "%<-fsanitize=address%> not supported for this target" +#, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> not supported in current platform" -msgstr "%<-fsanitize=address%> wird für dieses Ziel nicht unterstützt" +msgstr "%<-fsanitize=shadow-call-stack%> wird für dieses Ziel nicht unterstützt" #: toplev.cc:1688 -#, fuzzy, gcc-internal-format -#| msgid "%<-fsanitize-address-use-after-scope%> requires %<-fstack-reuse=none%> option" +#, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-fno-exceptions%>" -msgstr "%<-fsanitize-address-use-after-scope%> erfordert %<-fstack-reuse=none%>" +msgstr "%<-fsanitize=shadow-call-stack%> erfordert %<-fno-exceptions%>" #: toplev.cc:2026 #, gcc-internal-format @@ -35690,10 +35668,9 @@ msgid "unknown switch %<-mlong-double-%s%>" msgstr "unbekannter Schalter %<-mlong-double-%s%>" #: common/config/rs6000/rs6000-common.cc:234 -#, fuzzy, gcc-internal-format -#| msgid "unknown switch %<-mlong-double-%s%>" +#, gcc-internal-format msgid "option %<%s%> requires %<-mlong-double-128%>" -msgstr "unbekannter Schalter %<-mlong-double-%s%>" +msgstr "Option %<%s%> erfordert %<-mlong-double-128%>" #: common/config/rs6000/rs6000-common.cc:268 #, gcc-internal-format @@ -35929,10 +35906,9 @@ msgid "embedded NUL in CFString literal" msgstr "eingebettetes NUL in CFString-Literal" #: config/host-darwin.cc:107 -#, fuzzy, gcc-internal-format -#| msgid "PCH memory not available %m" +#, gcc-internal-format msgid "PCH memory is not available: %m" -msgstr "PCH-Speicher nicht verfügbar %m" +msgstr "PCH-Speicher nicht verfügbar: %m" #: config/sol2-c.cc:91 config/sol2-c.cc:107 #, gcc-internal-format @@ -36525,7 +36501,7 @@ msgstr "%qs ist in %qs kein gültiger Offset" #: config/aarch64/aarch64.cc:17580 #, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>" -msgstr "" +msgstr "%<-fsanitize=shadow-call-stack%> erfordert %<-ffixed-x18%>" #: config/aarch64/aarch64.cc:17670 #, gcc-internal-format @@ -36631,14 +36607,12 @@ msgid "missing name in %<target(\"arch=\")%> pragma or attribute" msgstr "fehlender Name für Pragma oder Attribut %<target(\"arch=\")%>" #: config/aarch64/aarch64.cc:18511 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"arch=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute" msgstr "ungültiger Name %qs für Pragma oder Attribut %<target(\"arch=\")%>" #: config/aarch64/aarch64.cc:18515 -#, fuzzy, gcc-internal-format -#| msgid "invalid feature modifier %s of value (%qs) in %<target()%> pragma or attribute" +#, gcc-internal-format msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute" msgstr "ungültiger Featuremodifizierer %qs mit Wert %qs in Pragma oder Attribut %<target()%>" @@ -36648,14 +36622,12 @@ msgid "missing name in %<target(\"cpu=\")%> pragma or attribute" msgstr "fehlender Name für Pragma oder Attribut %<target(\"cpu=\")%>" #: config/aarch64/aarch64.cc:18553 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"cpu=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute" msgstr "ungültiger Name %qs für Pragma oder Attribut %<target(\"cpu=\")%>" #: config/aarch64/aarch64.cc:18557 config/aarch64/aarch64.cc:18664 -#, fuzzy, gcc-internal-format -#| msgid "invalid feature modifier %s of value (%qs) in %<target()%> pragma or attribute" +#, gcc-internal-format msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute" msgstr "ungültiger Featuremodifizierer %qs mit Wert %qs in Pragma oder Attribut %<target()%>" @@ -36665,14 +36637,12 @@ msgid "missing argument to %<target(\"branch-protection=\")%> pragma or attribut msgstr "fehlendes Argument für Pragma oder Attribut %<target(\"branch-protection=\")%>" #: config/aarch64/aarch64.cc:18584 -#, fuzzy, gcc-internal-format -#| msgid "invalid protection type (%qs) in %<target(\"branch-protection=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid protection type %qs in %<target(\"branch-protection=\")%> pragma or attribute" msgstr "ungültiger Schutztyp %qs in Pragma oder Attribut %<target(\"branch-protection=\")%>" #: config/aarch64/aarch64.cc:18619 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"tune=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute" msgstr "ungültiger Name %qs für Pragma oder Attribut %<target(\"tune=\")%>" @@ -36738,10 +36708,8 @@ msgid "parameter passing for argument of type %qT when C++17 is enabled changed msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich, sofern C++17 aktiviert ist, so geändert, dass es C++14 %{in GCC 10.1%} entspricht" #: config/aarch64/aarch64.cc:20403 config/arm/arm.cc:6592 -#, fuzzy -#| msgid "parameter passing for argument of type %qT changed in GCC 9.1" msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}" -msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich in GCC 9.1 geändert" +msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich %{mit GCC 12.1%} geändert" #: config/aarch64/aarch64.cc:21552 config/aarch64/aarch64.cc:21555 #, gcc-internal-format @@ -37205,30 +37173,25 @@ msgstr "Maske muss »immediate« sein" msgid "the range of mask should be in 0 to 255" msgstr "der Wertebereich der Maske ist 0 bis 255" -# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104794 #: config/arm/arm-builtins.cc:3924 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 32; please check the intrinsic %<_mm_ror_pi16%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 32; please check the intrinsic %qs in code" -msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 16 sein; bitte das intrinsische %<_mm_ror_pi16%> im Code prüfen" +msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 32 sein; bitte das intrinsische %qs im Code prüfen" #: config/arm/arm-builtins.cc:3932 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_ror_si64%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 16; please check the intrinsic %qs in code" -msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 64 sein; bitte das intrinsische %<_mm_ror_pi64%> im Code prüfen" +msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 16 sein; bitte das intrinsische %qs im Code prüfen" #: config/arm/arm-builtins.cc:3940 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_ror_si64%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 64; please check the intrinsic %qs in code" -msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 64 sein; bitte das intrinsische %<_mm_ror_pi64%> im Code prüfen" +msgstr "der Wertebereich des Zählers sollte im Bereich 0 bis 64 sein; bitte das intrinsische %qs im Code prüfen" #: config/arm/arm-builtins.cc:4003 -#, fuzzy, gcc-internal-format -#| msgid "the count should be no less than 0; please check the intrinsic %<_mm_srl_pi16%> in code" +#, gcc-internal-format msgid "the count should be no less than 0; please check the intrinsic %qs in code" -msgstr "der Zähler darf nicht kleiner als 0 sein; bitte das intrinsische %<_mm_srl_pi16%> im Code prüfen" +msgstr "der Zähler sollte nicht kleiner als 0 sein; bitte das intrinsische %qs im Code prüfen" #: config/arm/arm-c.cc:108 #, gcc-internal-format @@ -37381,10 +37344,8 @@ msgstr "%<-freorder-blocks-and-partition%> wird auf dieser Architektur nicht unt msgid "selected fp16 options are incompatible" msgstr "die ausgewählten fp16-Optionen sind inkompatibel" -# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104794 #: config/arm/arm.cc:3883 -#, fuzzy, gcc-internal-format -#| msgid "%'-mstack-protector-guard=tls%' needs a hardware TLS register" +#, gcc-internal-format msgid "%<-mstack-protector-guard=tls%> needs a hardware TLS register" msgstr "%<-mstack-protector-guard=tls%> erfordert ein Hardware-TLS-Register" @@ -37875,8 +37836,7 @@ msgid "multiple function type attributes specified" msgstr "mehrere Funktionstypattribute angegeben" #: config/bfin/bfin.cc:4766 -#, fuzzy, gcc-internal-format -#| msgid "cannott apply both longcall and shortcall attributes to the same function" +#, gcc-internal-format msgid "cannot apply both %<longcall%> and %<shortcall%> attributes to the same function" msgstr "Die Attribute %<longcall%> und %<shortcall%> können nicht beide gleichzeitig für eine Funktion verwendet werden" @@ -38313,16 +38273,14 @@ msgid "%<-mn%> is not supported for linux targets" msgstr "%<-mn%> wird für Linux-Ziele nicht unterstützt" #: config/i386/host-cygwin.cc:64 -#, fuzzy, gcc-internal-format -#| msgid "can%'t extend PCH file: %m" +#, gcc-internal-format msgid "cannot extend PCH file: %m" msgstr "PCH-Datei kann nicht erweitert werden: %m" #: config/i386/host-cygwin.cc:75 -#, fuzzy, gcc-internal-format -#| msgid "cannot get position in PCH file: %m" +#, gcc-internal-format msgid "cannot set position in PCH file: %m" -msgstr "Position in PCH-Datei kann nicht ermittelt werden: %m" +msgstr "Position in PCH-Datei kann nicht festgelegt werden: %m" #: config/i386/i386-builtins.cc:2058 #, gcc-internal-format @@ -38660,16 +38618,14 @@ msgid "CPU you selected does not support x86-64 instruction set" msgstr "Die ausgewählte CPU unterstützt nicht den x86-64-Befehlssatz" #: config/i386/i386-options.cc:2215 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<-march=%> switch" +#, gcc-internal-format msgid "bad value %qs for %<-march=%> switch" -msgstr "falscher Wert (%qs) für Schalter %<-march=%>" +msgstr "falscher Wert %qs für Schalter %<-march=%>" #: config/i386/i386-options.cc:2216 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<target(\"arch=\")%> attribute" +#, gcc-internal-format msgid "bad value %qs for %<target(\"arch=\")%> attribute" -msgstr "unbekannter Wert (%qs) für %<target(\"arch=\")%>-Attribut" +msgstr "unbekannter Wert %qs für Attribut %<target(\"arch=\")%>" #: config/i386/i386-options.cc:2238 #, gcc-internal-format @@ -38692,16 +38648,14 @@ msgid "valid arguments to %<target(\"arch=\")%> attribute are: %s" msgstr "gültige Argumente für %<target(\"arch=\")%> sind: %s" #: config/i386/i386-options.cc:2295 -#, fuzzy, gcc-internal-format -#| msgid "bad value %qs for %<-mtune%> switch" +#, gcc-internal-format msgid "bad value %qs for %<-mtune=%> switch" -msgstr "falscher Wert %qs für Schalter %<-mtune%>" +msgstr "falscher Wert %qs für Schalter %<-mtune=%>" #: config/i386/i386-options.cc:2296 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute" +#, gcc-internal-format msgid "bad value %qs for %<target(\"tune=\")%> attribute" -msgstr "unbekannter Wert %qs für %<target(\"tune=\")%>-Attribut" +msgstr "falscher Wert %qs für Attribut %<target(\"tune=\")%>" #: config/i386/i386-options.cc:2317 #, gcc-internal-format @@ -39141,16 +39095,14 @@ msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt servic msgstr "Dynamic Realign Argument Pointer (DRAP) wird in Interrupt-Service-Routinen nicht unterstützt. Ein Workaround ist, Funktionen mit Aggregat-Rückgabetypen zu vermeiden." #: config/i386/i386.cc:9458 -#, fuzzy, gcc-internal-format -#| msgid "%qs attribute not supported in %<__builtin_has_attribute%>" +#, gcc-internal-format msgid "Stack realignment not supported with %<__builtin_eh_return%>" -msgstr "Attribut %qs wird in %<__builtin_has_attribute%> nicht unterstützt" +msgstr "Stapel-Neuausrichtung mit %<__builtin_eh_return%> wird nicht unterstützt" #: config/i386/i386.cc:9463 -#, fuzzy, gcc-internal-format -#| msgid "nested functions not supported on this target" +#, gcc-internal-format msgid "regparm nested function not supported with %<__builtin_eh_return%>" -msgstr "geschachtelte Funktionen werden auf diesem Ziel nicht unterstützt" +msgstr "geschachtelte Funktion mit regparm wird mit %<__builtin_eh_return%> nicht unterstützt" #: config/i386/i386.cc:9849 #, gcc-internal-format @@ -39320,89 +39272,85 @@ msgid "%<PRINT_OPERAND%> null pointer" msgstr "%<PRINT_OPERAND%> Null-Zeiger" #: config/loongarch/loongarch-cpu.cc:111 -#, fuzzy, gcc-internal-format -#| msgid "unknown core architecture %qs specified with %qs" +#, gcc-internal-format msgid "unknown base architecture %<0x%x%>, %qs failed" -msgstr "Unbekannte Kernarchitektur %qs in %qs angegeben" +msgstr "unbekannte Basisarchitektur %<0x%x%>, %qs fehlgeschlagen" #: config/loongarch/loongarch-cpu.cc:138 #, gcc-internal-format msgid "unknown FPU type %<0x%x%>, %qs failed" -msgstr "" +msgstr "unbekannter FPU-Typ %<0x%x%>, %qs fehlgeschlagen" #: config/loongarch/loongarch-cpu.cc:189 #, gcc-internal-format msgid "unknown processor ID %<0x%x%>, some tuning parameters will fall back to default" -msgstr "" +msgstr "unbekannte Prozessor-ID %<0x%x%>, einige Tuning-Parameter werden auf die Standardwerte zurückgesetzt" #: config/loongarch/loongarch-opts.cc:196 #, gcc-internal-format msgid "%<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs" -msgstr "" +msgstr "%<-m%s%> setzt %<-m%s=%s%> außer Kraft, die ABI wird auf %qs angepasst" #: config/loongarch/loongarch-opts.cc:211 #, gcc-internal-format msgid "ABI changed (%qs to %qs) while multilib is disabled" -msgstr "" +msgstr "ABI geändert (von %qs auf %qs), während Multilib ausgeschaltet ist" #: config/loongarch/loongarch-opts.cc:233 #: config/loongarch/loongarch-opts.cc:238 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs does not work on a cross compiler" -msgstr "%qT ist kein Klassentyp" +msgstr "%qs funktioniert nicht auf einem Cross-Compiler" #: config/loongarch/loongarch-opts.cc:278 -#, fuzzy, gcc-internal-format -#| msgid "the %qs architecture does not support %<-m%s=2008%>" +#, gcc-internal-format msgid "your native CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>" -msgstr "die Architektur %qs unterstützt %<-m%s=2008%>" +msgstr "Ihre native CPU-Architektur %qs unterstützt die ABI %qs nicht, stattdessen wird %<-m%s=%s%> verwendet" #: config/loongarch/loongarch-opts.cc:283 -#, fuzzy, gcc-internal-format -#| msgid "the %qs architecture does not support %<-m%s=2008%>" +#, gcc-internal-format msgid "default CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>" -msgstr "die Architektur %qs unterstützt %<-m%s=2008%>" +msgstr "die Standard-CPU-Architektur %qs unterstützt die ABI %qs nicht, stattdessen wird %<-m%s=%s%> verwendet" #: config/loongarch/loongarch-opts.cc:314 #, gcc-internal-format msgid "unable to implement ABI %qs with instruction set %qs" -msgstr "" +msgstr "ABI %qs kann nicht mit Befehlssatz %qs implementiert werden" #: config/loongarch/loongarch-opts.cc:336 #, gcc-internal-format msgid "ABI %qs cannot be implemented due to limited instruction set %qs, falling back to %qs" -msgstr "" +msgstr "ABI %qs kann aufgrund des begrenzten Befehlssatzes %qs nicht implementiert werden, stattdessen wird %qs verwendet" #: config/loongarch/loongarch-opts.cc:347 #, gcc-internal-format msgid "instruction set %qs cannot implement default ABI %qs, falling back to %qs" -msgstr "" +msgstr "Befehlssatz %qs kann Standard-ABI %qs nicht implementieren, stattdessen wird %qs verwendet" #: config/loongarch/loongarch-opts.cc:352 #, gcc-internal-format msgid "no multilib-enabled ABI (%qs) can be implemented with instruction set %qs, falling back to %qs" -msgstr "" +msgstr "keine Multilib-fähige ABI %qs kann mit dem Befehlssatz %qs implementiert werden, stattdessen wird %qs verwendet" #: config/loongarch/loongarch-opts.cc:368 #, gcc-internal-format msgid "ABI %qs is not enabled at configure-time, the linker might report an error" -msgstr "" +msgstr "ABI %qs ist zur Konfigurationszeit nicht aktiviert, der Linker meldet möglicherweise einen Fehler" #: config/loongarch/loongarch-opts.cc:371 #, gcc-internal-format, gfc-internal-format msgid "ABI with startfiles: %s" -msgstr "" +msgstr "ABI mit Startdateien: %s" #: config/loongarch/loongarch.cc:3458 #, gcc-internal-format msgid "Normal symbol loading not implemented in extreme mode." -msgstr "" +msgstr "Normales Laden von Symbolen ist im extremen Modus nicht implementiert." #: config/loongarch/loongarch.cc:5507 -#, fuzzy, gcc-internal-format -#| msgid "code model %s does not support PIC mode" +#, gcc-internal-format msgid "code model %qs and %qs not support %s mode" -msgstr "Codemodell %s unterstützt keinen PIC-Modus" +msgstr "die Codemodelle %qs und %qs unterstützen den Modus %qs nicht" #: config/m32c/m32c-pragma.cc:54 #, gcc-internal-format @@ -39583,16 +39531,12 @@ msgid "argument to %qE attribute is not intstack" msgstr "Argument des Attributes %qE ist nicht »intstack«" #: config/mips/mips.cc:6089 -#, fuzzy -#| msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}" msgid "the ABI for passing a value containing zero-width fields before an adjacent 64-bit floating-point field was changed in GCC %{12.1%}" -msgstr "das ABI der C-Strukturübergabe mit Bitfeldern der Breite 0 hat sich in GCC %{12.1%} geändert" +msgstr "die ABI für die Übergabe eines Wertes, der Felder mit Null-Breite vor einem benachbarten 64-Bit-Gleitkommafeld enthält, wurde %{mit GCC 12.1%} geändert" #: config/mips/mips.cc:6490 -#, fuzzy -#| msgid "ELFv2 parameter passing for an argument containing zero-width bit fields but that is otherwise a homogeneous aggregate was corrected in GCC 12" msgid "the ABI for returning a value containing zero-width bit-fields but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}" -msgstr "ELFv2-Parameterübergabe für ein Argument, das Bitfelder der Breite 0 enthält, aber ansonsten ein homogenes Aggregat ist, wurde in GCC 12 korrigiert" +msgstr "die ABI für die Rückgabe eines Wertes, der Bit-Felder mit der Breite Null enthält, aber ansonsten ein Aggregat mit nur einem oder zwei Fließkomma-Feldern ist, wurde %{mit GCC 12.1%} geändert" #: config/mips/mips.cc:7831 #, gcc-internal-format @@ -40487,10 +40431,9 @@ msgid "option %s is not supported together with %<-fopenacc%>" msgstr "Option »%s« wird zusammen mit %<-fopenacc%> nicht unterstützt" #: config/nvptx/nvptx.cc:326 -#, fuzzy, gcc-internal-format -#| msgid "PTX version (-mptx) needs to be at least %s to support selected -misa (sm_%s)" +#, gcc-internal-format msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)" -msgstr "PTX-Version in »-mptx« muss mindestens %s sein, um die ausgewählte »-misa« (sm_%s) zu unterstützen" +msgstr "PTX-Version %<-mptx%> muss mindestens %s sein, um die ausgewählte %<-misa%> (sm_%s) zu unterstützen" #: config/nvptx/nvptx.cc:359 #, gcc-internal-format @@ -40543,16 +40486,14 @@ msgid "variable %qD adjusted for OpenACC privatization level: %qs" msgstr "Variable %qD angepasst für OpenACC-Privatisierungsgrad: %qs" #: config/nvptx/nvptx.cc:7455 -#, fuzzy, gcc-internal-format -#| msgid "alias definitions not supported in this configuration" +#, gcc-internal-format msgid "weak alias definitions not supported in this configuration" -msgstr "Alias-Definitionen werden in dieser Konfiguration nicht unterstützt" +msgstr "schwache Alias-Definitionen werden in dieser Konfiguration nicht unterstützt" #: config/nvptx/nvptx.cc:7468 -#, fuzzy, gcc-internal-format -#| msgid "alias definitions not supported in this configuration" +#, gcc-internal-format msgid "non-function alias definitions not supported in this configuration" -msgstr "Alias-Definitionen werden in dieser Konfiguration nicht unterstützt" +msgstr "Alias-Definitionen werden in dieser Konfiguration nur für Funktionen unterstützt" #: config/or1k/or1k.cc:1311 #, gcc-internal-format, gfc-internal-format @@ -40886,10 +40827,9 @@ msgid "%qs requires %<long double%> to be IBM 128-bit format" msgstr "%qs erfordert, dass %<long double%> das IBM-128-Bit-Format ist" #: config/rs6000/rs6000-builtin.cc:3429 -#, fuzzy, gcc-internal-format -#| msgid "%qs requires VSX support" +#, gcc-internal-format msgid "%qs requires %<__ibm128%> type support" -msgstr "%qs erfordert VSX-Unterstützung" +msgstr "%qs erfordert Unterstützung des Typs %<__ibm128%>" #: config/rs6000/rs6000-builtin.cc:3584 #, gcc-internal-format, gfc-internal-format @@ -40967,10 +40907,9 @@ msgid "%<vec_lvsr%> is deprecated for little endian; use assignment for unaligne msgstr "%<vec_lvsr%> ist für Little-Endian veraltet; verwenden Sie Zuweisungen für unausgerichtete Speicherzugriffe" #: config/rs6000/rs6000-c.cc:1795 -#, fuzzy, gcc-internal-format -#| msgid "passing argument %d of %qE discards %qv qualifier from pointer target type" +#, gcc-internal-format msgid "passing argument %d of %qE discards %qs qualifier from pointer target type" -msgstr "Übergabe des Arguments %d von %qE entfernt Kennzeichner %qv von Zeiger-Ziel-Typ" +msgstr "Übergabe des Arguments %d von %qE entfernt Kennzeichner %qs von Zeiger-Zieltyp" #: config/rs6000/rs6000-c.cc:1881 config/rs6000/rs6000-c.cc:2037 #, gcc-internal-format @@ -41142,10 +41081,9 @@ msgid "%qs requires full ISA 3.0 support" msgstr "%qs erfordert vollständige Unterstützung von ISA 3.0" #: config/rs6000/rs6000.cc:4348 -#, fuzzy, gcc-internal-format -#| msgid "unknown vectorization library ABI type (%s) for -mveclibabi= switch" +#, gcc-internal-format msgid "unknown vectorization library ABI type in %<-mveclibabi=%s%>" -msgstr "unbekannte ABI-Typ (%s) für Vektorisierungsbibliothek bei Schalter -mveclibabi=" +msgstr "unbekannter ABI-Typ für Vektorisierungsbibliothek in %<-mveclibabi=%s%>" #: config/rs6000/rs6000.cc:4361 config/rs6000/rs6000.cc:4376 #, gcc-internal-format @@ -41274,10 +41212,9 @@ msgstr "mehrere schnelle Interruptroutinen gefunden: %qE und %qE" # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99297 #: config/rx/rx.cc:2480 -#, fuzzy, gcc-internal-format -#| msgid "invalid control register for mvtc: %d - using 'psw'" +#, gcc-internal-format msgid "invalid control register %d for mvtc; using %<psw%>" -msgstr "ungültiges Steuerregister %d für mvtc; »psw« wird verwendet" +msgstr "ungültiges Steuerregister %d für mvtc; %<psw%> wird verwendet" #: config/rx/rx.cc:2602 #, gcc-internal-format @@ -41677,8 +41614,7 @@ msgid "operand must be an immediate of the right size" msgstr "Operand muss »immediate« mit korrekter Größe sein" #: config/v850/v850-c.cc:67 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma%> GHS endXXXX found without previous startXXX" +#, gcc-internal-format msgid "%<#pragma%> GHS endXXX found without previous startXXX" msgstr "%<#pragma GHS endXXX%> ohne vorheriges %<startXXX%> gefunden" @@ -45042,8 +44978,7 @@ msgid "too many %<close%> modifiers" msgstr "zu viele %<close%>-Modifizierer" #: c/c-parser.cc:16232 cp/parser.cc:39440 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%>on %<map%> clause" +#, gcc-internal-format msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%> on %<map%> clause" msgstr "%<#pragma omp target%> mit Modifizierer außer %<always%> oder %<close%> an %<map%>-Klausel" @@ -47555,10 +47490,9 @@ msgid "edge not found" msgstr "Interner Fehler: edge not found" #: c/gimple-parser.cc:342 -#, fuzzy, gcc-internal-format -#| msgid "concept %qD has no definition" +#, gcc-internal-format msgid "SSA name %qE with version %d has no definition" -msgstr "Konzept %qD hat keine Definition" +msgstr "SSA-Name %qE mit Version %d hat keine Definition" #: c/gimple-parser.cc:482 c/gimple-parser.cc:488 #, gcc-internal-format @@ -48445,10 +48379,9 @@ msgid "%#qT declared here" msgstr "%#qT wird hier deklariert" #: cp/call.cc:10428 -#, fuzzy, gcc-internal-format -#| msgid "argument %u in call to function %qE has pointer to %qs type (%qT)" +#, gcc-internal-format msgid "argument %u in call to function %qE has pointer to a non-trivially-copyable type (%qT)" -msgstr "Argument %u in Aufruf von %qE darf kein Zeiger auf %qs sein (%qT)" +msgstr "Argument %u in Aufruf von %qE darf kein Zeiger auf nicht-trivial kopierbaren Typ %qT sein" #: cp/call.cc:10495 #, gcc-internal-format @@ -49583,16 +49516,14 @@ msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fco msgstr "Anzahl der Evaluierungsoperationen in %<constexpr%> überschreitet Höchstwert %wd (%<-fconstexpr-ops-limit=%> verwenden, um diesen zu erhöhen)" #: cp/constexpr.cc:6734 -#, fuzzy, gcc-internal-format -#| msgid "control passes through declaration of %qD with thread storage duration" +#, gcc-internal-format msgid "control passes through definition of %qD with thread storage duration" -msgstr "der Programmfluss geht durch die Deklaration von %qD mit thread-lokaler Speicherdauer" +msgstr "der Programmfluss geht durch die Definition von %qD mit thread-lokaler Speicherdauer" #: cp/constexpr.cc:6737 -#, fuzzy, gcc-internal-format -#| msgid "control passes through declaration of %qD with static storage duration" +#, gcc-internal-format msgid "control passes through definition of %qD with static storage duration" -msgstr "der Programmfluss geht durch die Deklaration von %qD mit statischer Speicherdauer" +msgstr "der Programmfluss geht durch die Definition von %qD mit statischer Speicherdauer" #: cp/constexpr.cc:6785 cp/constexpr.cc:9226 #, gcc-internal-format @@ -49725,16 +49656,14 @@ msgid "cast to non-integral type %qT in a constant expression" msgstr "Umwandlung in Nicht-Ganzzahltyp %qT in konstantem Ausdruck" #: cp/constexpr.cc:9195 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<thread_local%> in %<constexpr%> context" +#, gcc-internal-format msgid "%qD defined %<thread_local%> in %<constexpr%> context" -msgstr "%qD in %<constexpr%>-Kontext als %<thread_local%> deklariert" +msgstr "%qD in %<constexpr%>-Kontext als %<thread_local%> definiert" #: cp/constexpr.cc:9202 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<static%> in %<constexpr%> context" +#, gcc-internal-format msgid "%qD defined %<static%> in %<constexpr%> context" -msgstr "%qD in %<constexpr%>-Kontext als %<static%> deklariert" +msgstr "%qD in %<constexpr%>-Kontext als %<static%> definiert" #: cp/constexpr.cc:9275 #, gcc-internal-format @@ -49747,10 +49676,9 @@ msgid "%<delete[]%> is not a constant expression" msgstr "%<delete[]%> ist kein Konstantenausdruck" #: cp/constexpr.cc:9444 -#, fuzzy, gcc-internal-format -#| msgid "use of %<this%> in a constant expression" +#, gcc-internal-format msgid "neither branch of %<if%> is a constant expression" -msgstr "Verwendung von %<this%> in Konstantenausdruck" +msgstr "keiner der Zweige des %<if%> ist ein Konstantenausdruck" #: cp/constexpr.cc:9455 #, gcc-internal-format @@ -50042,64 +49970,54 @@ msgid " %qT is not a union" msgstr " %qT kein Vereinigungstyp ist" #: cp/constraint.cc:3658 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not an enum" +#, gcc-internal-format msgid " %qT is not an aggregate" -msgstr " %qT keine Aufzählung ist" +msgstr " %qT kein Aggregat ist" #: cp/constraint.cc:3661 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially copy assignable" +#, gcc-internal-format msgid " %qT is not trivially copyable" -msgstr " %qT nicht per trivialer Kopie zugewiesen werden kann" +msgstr " %qT nicht trivial kopierbar" #: cp/constraint.cc:3664 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not derived from %qT" +#, gcc-internal-format msgid " %qT is not assignable from %qT" -msgstr " %qT ist nicht vom Typ %qT abgeleitet" +msgstr " %qT nicht vom Typ %qT zugewiesen werden kann" #: cp/constraint.cc:3667 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially copy assignable" +#, gcc-internal-format msgid " %qT is not trivially assignable from %qT" -msgstr " %qT nicht per trivialer Kopie zugewiesen werden kann" +msgstr " %qT nicht per trivialer Kopie von %qT zugewiesen werden kann" #: cp/constraint.cc:3670 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not %<nothrow%> copy assignable" +#, gcc-internal-format msgid " %qT is not %<nothrow%> assignable from %qT" -msgstr " %qT nicht per %<nothrow%>-Kopie zuweisbar ist" +msgstr " %qT nicht per %<nothrow%>-Kopie von %qT zuweisbar ist" #: cp/constraint.cc:3674 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially default constructible" +#, gcc-internal-format msgid " %qT is not default constructible" -msgstr " %qT nicht trivial mit dem Standardkonstruktor erzeugt werden kann" +msgstr " %qT nicht mit dem Standardkonstruktor erzeugt werden kann" #: cp/constraint.cc:3676 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not derived from %qT" +#, gcc-internal-format msgid " %qT is not constructible from %qE" -msgstr " %qT ist nicht vom Typ %qT abgeleitet" +msgstr " %qT nicht von %qE konstruiert werden kann" #: cp/constraint.cc:3682 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially copy constructible" +#, gcc-internal-format msgid " %qT is not trivially constructible from %qE" -msgstr " %qT nicht per trivialer Kopie erzeugt werden kann" +msgstr " %qT nicht trivial von %qE konstruiert werden kann" #: cp/constraint.cc:3688 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not %<nothrow%> copy constructible" +#, gcc-internal-format msgid " %qT is not %<nothrow%> constructible from %qE" -msgstr " %qT nicht per %<nothrow%> mit dem Standardkonstruktor kopiert werden kann" +msgstr " %qT nicht per %<nothrow%> von %qE konstruiert werden kann" #: cp/constraint.cc:3691 -#, fuzzy, gcc-internal-format -#| msgid " %q+T does not have %<constexpr%> destructor" +#, gcc-internal-format msgid " %qT does not have unique object representations" -msgstr " %q+T hat keinen %<constexpr%>-Destruktor" +msgstr " %qT keine eindeutige Objektrepräsentationen hat" #: cp/constraint.cc:3717 #, gcc-internal-format @@ -50821,10 +50739,9 @@ msgid "old declaration %q#D" msgstr "alte Deklaration %q#D" #: cp/decl.cc:1493 -#, fuzzy, gcc-internal-format -#| msgid "redefinition of default argument for %q#D" +#, gcc-internal-format msgid "redefinition of default argument for %q+#D" -msgstr "Redefinition des Standardarguments für %q#D" +msgstr "Neudefinition des Standardarguments für %q+#D" #: cp/decl.cc:1495 #, gcc-internal-format @@ -51428,16 +51345,14 @@ msgid "block-scope extern declaration %q#D not permitted in module purview" msgstr "extern-Deklaration %q#D mit Gültigkeitsbereich Block ist im Zuständigkeitsbereich des Moduls nicht erlaubt" #: cp/decl.cc:5779 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" +#, gcc-internal-format msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<thread_local%> gekennzeichnet werden" +msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<thread_local%> definiert werden" #: cp/decl.cc:5785 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" +#, gcc-internal-format msgid "%qD defined %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<static%> gekennzeichnet werden" +msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++2b%> oder %<-std=gnu++2b%> als %<static%> definiert werden" #: cp/decl.cc:5850 #, gcc-internal-format @@ -59786,10 +59701,9 @@ msgid "concept %qE not in namespace scope" msgstr "das Konzept %qE ist nicht im Gültigkeitsbereich des Namensraums" #: cp/pt.cc:28824 -#, fuzzy, gcc-internal-format -#| msgid "definition of %q#T inside template parameter list" +#, gcc-internal-format msgid "concept %qE has multiple template parameter lists" -msgstr "Definition von %q#T in Templateparameterliste" +msgstr "das Konzept %qE hat mehrere Vorlagenparameterlisten" #: cp/pt.cc:28851 #, gcc-internal-format @@ -60128,10 +60042,9 @@ msgid "compound literal of non-object type %qT" msgstr "zusammengesetztes Literal vom Nicht-Objekt-Typ %qT" #: cp/semantics.cc:3156 -#, fuzzy, gcc-internal-format -#| msgid "a concept cannot be constrained" +#, gcc-internal-format msgid "%<auto{x}%> cannot be constrained" -msgstr "ein Konzept kann nicht eingeschränkt werden" +msgstr "%<auto{x}%> kann nicht eingeschränkt werden" #: cp/semantics.cc:3161 #, gcc-internal-format @@ -62035,10 +61948,9 @@ msgid "functional cast to array type %qT" msgstr "funktionale Umwandlung in Arraytyp %qT" #: cp/typeck2.cc:2319 -#, fuzzy, gcc-internal-format -#| msgid "a concept cannot be constrained" +#, gcc-internal-format msgid "%<auto(x)%> cannot be constrained" -msgstr "ein Konzept kann nicht eingeschränkt werden" +msgstr "%<auto(x)%> kann nicht eingeschränkt werden" #: cp/typeck2.cc:2324 #, gcc-internal-format @@ -66173,10 +66085,9 @@ msgid "The number of elements in the array constructor at %L requires an increas msgstr "Die Anzahl der Elemente im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>" #: fortran/expr.cc:1725 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Syntax error in array constructor at %C" +#, gcc-internal-format, gfc-internal-format msgid "Error in array constructor referenced at %L" -msgstr "Syntaxfehler in Feldkonstruktor bei %C" +msgstr "Fehler in Feldkonstruktor, auf den bei %L verwiesen wird" #: fortran/expr.cc:1829 fortran/primary.cc:2300 fortran/primary.cc:2444 #, gcc-internal-format, gfc-internal-format @@ -67717,10 +67628,8 @@ msgstr "Interner Fehler: do_check(): too many args" msgid "add_sym(): Bad sizing mode" msgstr "Interner Fehler: add_sym(): Bad sizing mode" -# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90148 #: fortran/intrinsic.cc:1184 -#, fuzzy, gcc-internal-format -#| msgid "The intrinsic %qs at %L is not included in the selected standard but %s and %qs will be treated as if declared EXTERNAL. Use an appropriate %<-std=%>* option or define %<-fall-intrinsics%> to allow this intrinsic." +#, gcc-internal-format msgid "The intrinsic %qs at %L is not included in the selected standard but %s and %qs will be treated as if declared EXTERNAL. Use an appropriate %<-std=%> option or define %<-fall-intrinsics%> to allow this intrinsic." msgstr "Das intrinsische %qs bei %L ist nicht im ausgewählten Standard enthalten, aber %s und %qs werden wie mit EXTERNAL deklariert behandelt. Passende Option %<-std=%> verwenden oder %<-fall-intrinsics%> definieren, um dies zuzulassen." @@ -68929,10 +68838,9 @@ msgid "STOP code at %C contains too many digits" msgstr "STOP-Code bei %C enthält zu viele Ziffern" #: fortran/match.cc:3079 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "NEWUNIT specifier at %L" +#, gcc-internal-format, gfc-internal-format msgid "QUIET= specifier for %s at %L" -msgstr "NEWUNIT-Spezifizierer bei %L" +msgstr "Spezifizierer QUIET= für %s bei %L" #: fortran/match.cc:3093 #, gcc-internal-format, gfc-internal-format @@ -68980,10 +68888,9 @@ msgid "STOP code at %L must be default integer KIND=%d" msgstr "STOP-Code bei %L muss Standardganzzahltyp KIND=%d sein" #: fortran/match.cc:3178 fortran/resolve.cc:11973 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "ASYNCHRONOUS= specifier at %L must be scalar" +#, gcc-internal-format, gfc-internal-format msgid "QUIET specifier at %L must be a scalar LOGICAL" -msgstr "Spezifikation ASYNCHRONOUS= bei %L muss skalar sein" +msgstr "der Spezifizierer QUIET bei %L muss ein skalarer LOGICAL sein" #: fortran/match.cc:3228 #, gcc-internal-format, gfc-internal-format @@ -70895,10 +70802,9 @@ msgid "Cray pointee %qs in SHARED clause at %L" msgstr "Cray-Zeigerziel %qs in Klausel SHARED bei %L" #: fortran/openmp.cc:6785 -#, fuzzy, gcc-internal-format -#| msgid "ASSOCIATE name %qs in SHARED clause at %L" +#, gcc-internal-format msgid "Associate name %qs in SHARED clause at %L" -msgstr "ASSOCIATE-Name %qs in SHARED-Klausel bei %L" +msgstr "Associate-Name %qs in SHARED-Klausel bei %L" #: fortran/openmp.cc:6791 #, gcc-internal-format @@ -71036,10 +70942,9 @@ msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct msgstr "%<inscan%> und nicht-%<inscan%>-%<reduction%>-Klauseln am selben Konstrukt bei %L" #: fortran/openmp.cc:7168 -#, fuzzy, gcc-internal-format -#| msgid "ASSOCIATE name %qs in %s clause at %L" +#, gcc-internal-format msgid "Associate name %qs in %s clause at %L" -msgstr "ASSOCIATE-Name %qs in %s-Klausel bei %L" +msgstr "Associate-Name %qs in %s-Klausel bei %L" #: fortran/openmp.cc:7175 #, gcc-internal-format @@ -71148,22 +71053,19 @@ msgid "%s must contain at least one MAP clause at %L" msgstr "%s bei %L muss mindestens eine MAP-Klausel enthalten" #: fortran/openmp.cc:7587 -#, fuzzy, gcc-internal-format -#| msgid "%qs at %L should be of type integer(kind=omp_event_handle_kind)" +#, gcc-internal-format msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)" -msgstr "%qs bei %L sollte vom Typ integer(kind=omp_event_handle_kind) sein" +msgstr "%qs bei %L sollte ein Skalar vom Typ integer(kind=omp_event_handle_kind) sein" #: fortran/openmp.cc:7592 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "The base name at %L must not be an entry name" +#, gcc-internal-format, gfc-internal-format msgid "The event handle at %L must not be an array element" -msgstr "Der Basisname bei %L darf kein Eintragsname sein" +msgstr "Das Ereignishandle bei %L darf kein Element eines Feldes sein" #: fortran/openmp.cc:7596 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "The base name at %L must not be a procedure pointer" +#, gcc-internal-format, gfc-internal-format msgid "The event handle at %L must not be part of a derived type or class" -msgstr "Der Basisname bei %L darf kein Prozedurzeiger sein" +msgstr "Das Ereignishandle bei %L darf nicht Teil eines abgeleiteten Typs oder einer abgeleiteten Klasse sein" #: fortran/openmp.cc:7600 #, gcc-internal-format @@ -72857,10 +72759,9 @@ msgid "The element in the structure constructor at %L, for pointer component %qs msgstr "Das Element im Strukturkonstruktor bei %L für Zeigerkomponente %qs ist %s, sollte aber %s sein" #: fortran/resolve.cc:1386 -#, fuzzy, gcc-internal-format -#| msgid "Unequal character lengths (%ld/%ld) in %s at %L" +#, gcc-internal-format msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L" -msgstr "Ungleiche Zeichenlängen (%ld, %ld) in %s bei %L" +msgstr "Ungleiche Zeichenlängen (%wd/%wd) für Zeigerkomponente %qs in Konstruktor bei %L" #: fortran/resolve.cc:1431 #, gcc-internal-format diff --git a/gcc/po/fr.po b/gcc/po/fr.po index b976c528cc3..eb8853b077f 100644 --- a/gcc/po/fr.po +++ b/gcc/po/fr.po @@ -97,10 +97,10 @@ # msgid "" msgstr "" -"Project-Id-Version: gcc 12.1-b20220213\n" +"Project-Id-Version: gcc 12.1-b20220403\n" "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n" "POT-Creation-Date: 2022-04-01 17:30+0000\n" -"PO-Revision-Date: 2022-03-12 20:56+0100\n" +"PO-Revision-Date: 2022-04-06 07:46+0200\n" "Last-Translator: Frédéric Marchal <fmarchal@perso.be>\n" "Language-Team: French <traduc@traduc.org>\n" "Language: fr\n" @@ -2797,10 +2797,9 @@ msgid "Support dynamic initialization of thread-local variables in a different t msgstr "Supporter l'initialisation dynamique de variables locales au thread dans une unité de traduction différente." #: c-family/c.opt:1728 -#, fuzzy, no-c-format -#| msgid "invalid call to non-function" +#, no-c-format msgid "Fold calls to simple inline functions." -msgstr "appel invalide à la non fonction" +msgstr "Incorporer les appels à de simples fonctions en-lignes." #: c-family/c.opt:1735 #, no-c-format @@ -3619,8 +3618,7 @@ msgid "Add comments for ignored declarations in the generated C++ header." msgstr "Ajouter des commentaires pour les déclarations ignorées dans l'en-tête C++ généré." #: d/lang.opt:280 -#, fuzzy, no-c-format -#| msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <file>." +#, no-c-format msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <filename>." msgstr "-fdump-cxx-spec=<fichier>\tÉcrire toutes les déclarations sous forme de code C++ dans le <fichier>." @@ -3710,10 +3708,9 @@ msgid "Use field-wise comparisons for struct equality." msgstr "Utiliser la comparaisons au niveau des champs dans l'égalité de structure." #: d/lang.opt:373 -#, fuzzy, no-c-format -#| msgid "When a symbol is resolved, check alias this scope before going to upper scopes." +#, no-c-format msgid "When a symbol is resolved, check `alias this' scope before going to upper scopes." -msgstr "Quand un symbole est résolu, vérifier les alias dans cette portée avant d'examiner les portées supérieures." +msgstr "Quand un symbole est résolu, vérifier la portée de « alias this » avant d'examiner les portées supérieures." #: d/lang.opt:377 #, no-c-format @@ -4203,7 +4200,7 @@ msgstr "Vidanger le supergraphe de l'analyseur dans un fichier FICHIERSRC.superg #: analyzer/analyzer.opt:255 #, no-c-format msgid "Emit custom warnings with internal details intended for analyzer developers." -msgstr "" +msgstr "Émettre des avertissements personnalisés contenant des détails internes à l'attention des développeurs de l'analyseur." #: config/vms/vms.opt:27 #, no-c-format @@ -5570,7 +5567,7 @@ msgstr "Taille de memset constante en octets au delà de laquelle commencer à u #: config/aarch64/aarch64.opt:298 #, no-c-format msgid "Limit how much the autovectorizer may unroll a loop." -msgstr "" +msgstr "Limiter le nombre de fois qu'une boucle peut être dépliée par l'auto vectoriseur. " #: config/linux.opt:24 #, no-c-format @@ -7415,16 +7412,14 @@ msgid "Support multi-threading." msgstr "Supporter le multi-threading." #: config/nvptx/nvptx-gen.opt:24 -#, fuzzy, no-c-format -#| msgid "Known ARM architectures (for use with the -march= option):" +#, no-c-format msgid "Known PTX ISA target architectures (for use with the -misa= option):" -msgstr "Architectures ARM connues (à utiliser avec l'option -march=):" +msgstr "Architectures PTX ISA cibles connues (à utiliser avec l'option -misa=):" #: config/nvptx/nvptx.opt:28 -#, fuzzy, no-c-format -#| msgid "Does nothing. Preserved for backward compatibility." +#, no-c-format msgid "Ignored, but preserved for backward compatibility. Only 64-bit ABI is supported." -msgstr "Ne fait rien. Préservé pour rétro-compatibilité." +msgstr "Ignoré mais préservé pour rétro-compatibilité. Seule l'ABI 64 bits est supportée." #: config/nvptx/nvptx.opt:33 #, no-c-format @@ -7457,33 +7452,29 @@ msgid "Generate code for OpenMP offloading: enables -msoft-stack and -muniform-s msgstr "Générer du code pour le déchargement vers OpenMP: active -msoft-stack et -muniform-simt." #: config/nvptx/nvptx.opt:58 -#, fuzzy, no-c-format -#| msgid "Specify the target architecture." +#, no-c-format msgid "Specify the PTX ISA target architecture to use." -msgstr "Spécifier l'architecture cible." +msgstr "Spécifier l'architecture PTX ISA cible à utiliser." #: config/nvptx/nvptx.opt:62 #, no-c-format msgid "Alias:" -msgstr "" +msgstr "Alias :" #: config/nvptx/nvptx.opt:117 -#, fuzzy, no-c-format -#| msgid "Known PTX versions (for use with the -mptx= option):" +#, no-c-format msgid "Known PTX ISA versions (for use with the -mptx= option):" -msgstr "Versions PTX connues (à utiliser avec l'option -mptx=) :" +msgstr "Versions PTX ISA connues (à utiliser avec l'option -mptx=) :" #: config/nvptx/nvptx.opt:136 -#, fuzzy, no-c-format -#| msgid "Specify the version of the ptx version to use." +#, no-c-format msgid "Specify the PTX ISA version to use." -msgstr "Spécifier la version de la version ptx à utiliser." +msgstr "Spécifier la version de la version PTX ISA à utiliser." #: config/nvptx/nvptx.opt:140 -#, fuzzy, no-c-format -#| msgid "Use fp registers." +#, no-c-format msgid "Initialize ptx registers." -msgstr "Utiliser les registres FP." +msgstr "Initialiser les registres ptx." #: config/vxworks.opt:36 #, no-c-format @@ -9215,18 +9206,17 @@ msgstr "Activer les instructions définies par l'utilisateur." #: config/loongarch/loongarch.opt:47 #, no-c-format msgid "Basic ISAs of LoongArch:" -msgstr "" +msgstr "ISA de base de LoongArch :" #: config/loongarch/loongarch.opt:56 #, no-c-format msgid "FPU types of LoongArch:" -msgstr "" +msgstr "Types FPU de LoongArch :" #: config/loongarch/loongarch.opt:69 -#, fuzzy, no-c-format -#| msgid "-march=ISA\tGenerate code for the given ISA." +#, no-c-format msgid "-mfpu=FPU\tGenerate code for the given FPU." -msgstr "-march=ISA\tGénérer le code pour l'ISA donnée." +msgstr "-mfpu=FPU\tGénérer le code pour le FPU donné." #: config/loongarch/loongarch.opt:76 config/mips/mips.opt:377 #, no-c-format @@ -9246,30 +9236,27 @@ msgstr "Autoriser les instructions en virgule flottante matérielles à couvrir #: config/loongarch/loongarch.opt:90 #, no-c-format msgid "LoongArch CPU types:" -msgstr "" +msgstr "Types de processeur LoongArch :" #: config/loongarch/loongarch.opt:103 -#, fuzzy, no-c-format -#| msgid "-march=ISA\tGenerate code for the given ISA." +#, no-c-format msgid "-march=PROCESSOR\tGenerate code for the given PROCESSOR ISA." -msgstr "-march=ISA\tGénérer le code pour l'ISA donnée." +msgstr "-march=PROCESSEUR\tGénérer le code pour le PROCESSEUR ISA donné." #: config/loongarch/loongarch.opt:107 -#, fuzzy, no-c-format -#| msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR." +#, no-c-format msgid "-mtune=PROCESSOR\tGenerate optimized code for PROCESSOR." -msgstr "-mtune=PROCESSEUR\tOptimiser la sortie pour le PROCESSEUR." +msgstr "-mtune=PROCESSEUR\tGénérer du code optimisé pour le PROCESSEUR." #: config/loongarch/loongarch.opt:116 #, no-c-format msgid "Base ABI types for LoongArch:" -msgstr "" +msgstr "Types d'ABI de base pour LoongArch :" #: config/loongarch/loongarch.opt:129 -#, fuzzy, no-c-format -#| msgid "-mabi=ABI\tGenerate code that conforms to the given ABI." +#, no-c-format msgid "-mabi=BASEABI\tGenerate code that conforms to the given BASEABI." -msgstr "-mabi=ABI\tGénérer du code conforme à l'ABI donnée." +msgstr "-mabi=BASEABI\tGénérer du code conforme à la BASEABI donnée." #: config/loongarch/loongarch.opt:138 config/mips/mips.opt:71 #, no-c-format @@ -9284,22 +9271,22 @@ msgstr "Intercepter les divisions par zéros sur des entiers." #: config/loongarch/loongarch.opt:146 #, no-c-format msgid "Conditional moves for integral are enabled." -msgstr "" +msgstr "Les déplacements conditionnels d'entiers sont activés." #: config/loongarch/loongarch.opt:150 #, no-c-format msgid "Conditional moves for float are enabled." -msgstr "" +msgstr "Les déplacements conditionnels de nombres en virgule flottante sont activés." #: config/loongarch/loongarch.opt:154 #, no-c-format msgid "Prevent optimizing block moves, which is also the default behavior of -Os." -msgstr "" +msgstr "Empêcher l'optimisation des déplacements de blocs, ceci est aussi le comportement par défaut de -Os." #: config/loongarch/loongarch.opt:162 #, no-c-format msgid "-mmax-inline-memcpy-size=SIZE\tSet the max size of memcpy to inline, default is 1024." -msgstr "" +msgstr "-mmax-inline-memcpy-size=TAILLE\tDéfinir la taille maximale de memcpy à mettre en-ligne, la valeur par défaut est 1024." #: config/or1k/elf.opt:28 #, no-c-format @@ -12816,10 +12803,9 @@ msgid "Warn whenever a trampoline is generated." msgstr "Avertir lorsqu'un trampoline est généré." #: common.opt:806 -#, fuzzy, no-c-format -#| msgid "Warn about maybe uninitialized automatic variables." +#, no-c-format msgid "Warn about cases where -ftrivial-auto-var-init cannot initialize an auto variable." -msgstr "Avertir à propos des variables automatiques qui pourraient ne pas être initialisées." +msgstr "Avertir à propos de cas où -ftrivial-auto-var-init ne peut pas initialiser une variable automatique." #: common.opt:810 #, no-c-format @@ -15406,8 +15392,7 @@ msgid "Recursive cloning only when the probability of call being executed exceed msgstr "Cloner récursivement uniquement quand la probabilité qu'un appel soit exécuté excède le paramètre." #: params.opt:254 -#, fuzzy, no-c-format -#| msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that that bring back an unchanged value by this factor." +#, no-c-format msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that bring back an unchanged value by this factor." msgstr "Lors de la propagation des estimations des effets IPA-CP, multiplier les fréquences des arêtes récursives qui ramènent une valeur inchangée par ce facteur." @@ -15773,8 +15758,7 @@ msgid "Maximum loop depth of a call which is considered for inlining functions c msgstr "Profondeur de boucle maximale pour un appel qui est considéré pour la mise en ligne de fonctions appelées une fois." #: params.opt:554 -#, fuzzy, no-c-format -#| msgid "Maximum combinaed size of caller and callee wich is inlined if callee is called once." +#, no-c-format msgid "Maximum combined size of caller and callee which is inlined if callee is called once." msgstr "Taille combinée maximale de l'appelant et de l'appelé qui est mise en ligne si l'appelé est appelé une fois." @@ -15856,7 +15840,7 @@ msgstr "Le nombre maximum de retours en arrière que l'ordonnanceur doit essayer #: params.opt:618 #, no-c-format msgid "Minimum page size for warning purposes." -msgstr "" +msgstr "Taille de page minimale pour les avertissements." #: params.opt:622 #, no-c-format @@ -16464,10 +16448,9 @@ msgid "The maximum factor which the loop vectorizer applies to the cost of state msgstr "Le facteur maximum appliqué par le vectoriseur de boucle sur le coût des instructions dans la boucle intérieure relativement à la boucle qui est vectorisée." #: params.opt:1185 -#, fuzzy, no-c-format -#| msgid "Enable loop vectorization on trees." +#, no-c-format msgid "Enable loop vectorization of floating point inductions." -msgstr "Activer la vectorisation des boucles sur les arbres." +msgstr "Activer la vectorisation sur les instructions en virgule flottante." #: params.opt:1189 #, no-c-format @@ -22833,7 +22816,7 @@ msgstr "le retour de la boucle %d est marqué comme faisant partie d'une région #: cfgloop.cc:1573 #, gcc-internal-format msgid "loop %d%'s number of iterations %qE references the released SSA name %qE" -msgstr "" +msgstr "la boucle %d a un nombre d'itérations %qE qui fait référence au nom SSA %qE libéré" #: cfgloop.cc:1606 #, gcc-internal-format, gfc-internal-format @@ -26330,7 +26313,7 @@ msgstr "l'instruction ne sera jamais exécutée" #: gimplify.cc:2132 #, gcc-internal-format msgid "%qs cannot be initialized with%<-ftrivial-auto-var_init%>" -msgstr "" +msgstr "%qs ne peut pas être initialisé avec %<-ftrivial-auto-var_init%>" # « fall through » dans le cas d'un switch/case qui n'est pas terminé par un break et enchaîne avec le case suivant #: gimplify.cc:2524 gimplify.cc:2532 @@ -27866,10 +27849,9 @@ msgid "location of OpenACC %<kernels%>" msgstr "emplacement de OpenACC %<kernels%>" #: omp-oacc-kernels-decompose.cc:1288 -#, fuzzy, gcc-internal-format -#| msgid "%<ancestor%> not yet supported" +#, gcc-internal-format msgid "%qs not yet supported" -msgstr "%<ancestor%> n'est pas encore supporté" +msgstr "%qs n'est pas encore supporté" #: omp-oacc-neuter-broadcast.cc:1764 #, gcc-internal-format @@ -28559,10 +28541,9 @@ msgid "failed to initialize plugin %s" msgstr "échec à l'initialisation du greffon %s" #: plugin.cc:1009 -#, fuzzy, gcc-internal-format -#| msgid "%<-iplugindir%> <dir> option not passed from the gcc driver" +#, gcc-internal-format msgid "%<-iplugindir%> option not passed from the gcc driver" -msgstr "l'option %<-iplugindir%> <rép> n'a pas été passée par le pilote gcc" +msgstr "l'option %<-iplugindir%> n'a pas été passée par le pilote gcc" #: pointer-query.cc:1202 #, gcc-internal-format @@ -29464,16 +29445,14 @@ msgid "%qs is not supported for this target" msgstr "%qs n'est pas supporté pour cette cible" #: toplev.cc:1685 -#, fuzzy, gcc-internal-format -#| msgid "%<-fsanitize=address%> not supported for this target" +#, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> not supported in current platform" -msgstr "%<-fsanitize=address%> n'est pas supporté pour cette cible" +msgstr "%<-fsanitize=shadow-call-stack%> n'est pas supporté pour la plateforme actuelle" #: toplev.cc:1688 -#, fuzzy, gcc-internal-format -#| msgid "%<-fsanitize-address-use-after-scope%> requires %<-fstack-reuse=none%> option" +#, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-fno-exceptions%>" -msgstr "%<-fsanitize-address-use-after-scope%> requiert l'option %<-fstack-reuse=none%>" +msgstr "%<-fsanitize=shadow-call-stack%> requiert %<-fno-exceptions%>" #: toplev.cc:2026 #, gcc-internal-format @@ -35704,10 +35683,9 @@ msgid "unknown switch %<-mlong-double-%s%>" msgstr "option %<-mlong-double-%s%> inconnue" #: common/config/rs6000/rs6000-common.cc:234 -#, fuzzy, gcc-internal-format -#| msgid "unknown switch %<-mlong-double-%s%>" +#, gcc-internal-format msgid "option %<%s%> requires %<-mlong-double-128%>" -msgstr "option %<-mlong-double-%s%> inconnue" +msgstr "l'option %<%s%> requiert %<-mlong-double-128%>" #: common/config/rs6000/rs6000-common.cc:268 #, gcc-internal-format @@ -35941,10 +35919,9 @@ msgid "embedded NUL in CFString literal" msgstr "NUL inclus dans une CFString littérale" #: config/host-darwin.cc:107 -#, fuzzy, gcc-internal-format -#| msgid "PCH memory not available %m" +#, gcc-internal-format msgid "PCH memory is not available: %m" -msgstr "la mémoire PCH n'est pas disponible %m" +msgstr "la mémoire PCH n'est pas disponible : %m" #: config/sol2-c.cc:91 config/sol2-c.cc:107 #, gcc-internal-format @@ -36535,7 +36512,7 @@ msgstr "%qs n'est pas un décalage valide dans %qs" #: config/aarch64/aarch64.cc:17580 #, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>" -msgstr "" +msgstr "%<-fsanitize=shadow-call-stack%> requiert %<-ffixed-x18%>" #: config/aarch64/aarch64.cc:17670 #, gcc-internal-format @@ -36638,16 +36615,14 @@ msgid "missing name in %<target(\"arch=\")%> pragma or attribute" msgstr "nom manquant dans le pragma ou l'attribut %<target(\"arch=\")%>" #: config/aarch64/aarch64.cc:18511 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"arch=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute" -msgstr "nom invalide (%qs) dans le pragma ou l'attribut %<target(\"arch=\")%>" +msgstr "nom %qs invalide dans le pragma ou l'attribut %<target(\"arch=\")%>" #: config/aarch64/aarch64.cc:18515 -#, fuzzy, gcc-internal-format -#| msgid "invalid feature modifier %s of value (%qs) in %<target()%> pragma or attribute" +#, gcc-internal-format msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute" -msgstr "modificateur de fonctionnalité %s invalide avec la valeur (%qs) dans le pragma ou l'attribut %<target()%>" +msgstr "modificateur de fonctionnalité %s invalide avec la valeur %qs dans le pragma ou l'attribut %<target()%>" #: config/aarch64/aarch64.cc:18550 #, gcc-internal-format @@ -36655,16 +36630,14 @@ msgid "missing name in %<target(\"cpu=\")%> pragma or attribute" msgstr "nom manquant dans le pragma ou l'attribut %<target(\"cpu=\")%>" #: config/aarch64/aarch64.cc:18553 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"cpu=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute" -msgstr "nom invalide (%qs) dans le pragma ou l'attribut %<target(\"cpu=\")%>" +msgstr "nom %qs invalide dans le pragma ou l'attribut %<target(\"cpu=\")%>" #: config/aarch64/aarch64.cc:18557 config/aarch64/aarch64.cc:18664 -#, fuzzy, gcc-internal-format -#| msgid "invalid feature modifier %s of value (%qs) in %<target()%> pragma or attribute" +#, gcc-internal-format msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute" -msgstr "modificateur de fonctionnalité %s invalide avec la valeur (%qs) dans le pragma ou l'attribut %<target()%>" +msgstr "modificateur de fonctionnalité %qs invalide avec la valeur %qs dans le pragma ou l'attribut %<target()%>" #: config/aarch64/aarch64.cc:18580 #, gcc-internal-format @@ -36672,16 +36645,14 @@ msgid "missing argument to %<target(\"branch-protection=\")%> pragma or attribut msgstr "argument manquant dans le pragma ou l'attribut %<target(\"branch-protection=\")%>" #: config/aarch64/aarch64.cc:18584 -#, fuzzy, gcc-internal-format -#| msgid "invalid protection type (%qs) in %<target(\"branch-protection=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid protection type %qs in %<target(\"branch-protection=\")%> pragma or attribute" -msgstr "type de protection (%qs) invalide dans le pragma ou l'attribut %<target(\"branch-protection=\")%>" +msgstr "type de protection %qs invalide dans le pragma ou l'attribut %<target(\"branch-protection=\")%>" #: config/aarch64/aarch64.cc:18619 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"tune=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute" -msgstr "nom invalide (%qs) dans le pragma ou l'attribut %<target(\"tune=\")%>" +msgstr "nom %qs invalide dans le pragma ou l'attribut %<target(\"tune=\")%>" #: config/aarch64/aarch64.cc:18660 #, gcc-internal-format @@ -36742,10 +36713,8 @@ msgid "parameter passing for argument of type %qT when C++17 is enabled changed msgstr "le passage par paramètre pour l'argument de type %qT quand C++17 est activé a changé pour correspondre à C++14 %{dans GCC 10.1%}" #: config/aarch64/aarch64.cc:20403 config/arm/arm.cc:6592 -#, fuzzy -#| msgid "parameter passing for argument of type %qT changed in GCC 9.1" msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}" -msgstr "le passage de paramètre pour l'argument de type %qT a changé dans GCC 9.1" +msgstr "le passage de paramètre pour l'argument de type %qT a changé dans %{GCC 12.1}%" #: config/aarch64/aarch64.cc:21552 config/aarch64/aarch64.cc:21555 #, gcc-internal-format @@ -37209,28 +37178,24 @@ msgid "the range of mask should be in 0 to 255" msgstr "la plage du masque doit être entre 0 et 255" #: config/arm/arm-builtins.cc:3924 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 32; please check the intrinsic %<_mm_ror_pi16%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 32; please check the intrinsic %qs in code" -msgstr "la plage du décompte doit être entre 0 et 32. Veuillez vérifier l'intrinsèque %<_mm_ror_pi16%> dans le code" +msgstr "la plage du décompte doit être entre 0 et 32. Veuillez vérifier l'intrinsèque %qs dans le code" #: config/arm/arm-builtins.cc:3932 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_ror_si64%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 16; please check the intrinsic %qs in code" -msgstr "la plage du décompte doit être entre 0 et 64. Veuillez vérifier l'intrinsèque %<_mm_ror_si64%> dans le code" +msgstr "la plage du décompte doit être entre 0 et 16. Veuillez vérifier l'intrinsèque %qs dans le code" #: config/arm/arm-builtins.cc:3940 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_ror_si64%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 64; please check the intrinsic %qs in code" -msgstr "la plage du décompte doit être entre 0 et 64. Veuillez vérifier l'intrinsèque %<_mm_ror_si64%> dans le code" +msgstr "la plage du décompte doit être entre 0 et 64. Veuillez vérifier l'intrinsèque %qs dans le code" #: config/arm/arm-builtins.cc:4003 -#, fuzzy, gcc-internal-format -#| msgid "the count should be no less than 0; please check the intrinsic %<_mm_srl_pi16%> in code" +#, gcc-internal-format msgid "the count should be no less than 0; please check the intrinsic %qs in code" -msgstr "le décompte ne devrait pas être inférieur à 0. Veuillez vérifier l'intrinsèque %<_mm_srl_pi16%> dans le code" +msgstr "le décompte ne devrait pas être inférieur à 0. Veuillez vérifier l'intrinsèque %qs dans le code" #: config/arm/arm-c.cc:108 #, gcc-internal-format @@ -37383,10 +37348,9 @@ msgid "selected fp16 options are incompatible" msgstr "les options fp16 sélectionnées sont incompatibles" #: config/arm/arm.cc:3883 -#, fuzzy, gcc-internal-format -#| msgid "%'-mstack-protector-guard=tls%' needs a hardware TLS register" +#, gcc-internal-format msgid "%<-mstack-protector-guard=tls%> needs a hardware TLS register" -msgstr "%'-mstack-protector-guard=tls%' a besoin d'un registre TLS matériel" +msgstr "%<-mstack-protector-guard=tls%> a besoin d'un registre TLS matériel" #: config/arm/arm.cc:3903 #, gcc-internal-format @@ -37876,10 +37840,9 @@ msgid "multiple function type attributes specified" msgstr "plusieurs attributs de type de fonction spécifiés" #: config/bfin/bfin.cc:4766 -#, fuzzy, gcc-internal-format -#| msgid "cannott apply both longcall and shortcall attributes to the same function" +#, gcc-internal-format msgid "cannot apply both %<longcall%> and %<shortcall%> attributes to the same function" -msgstr "ne peut appliquer à la fois les attributs longcall et shortcall à la même fonction" +msgstr "ne peut appliquer à la fois les attributs %<longcall%> et %<shortcall%> à la même fonction" #: config/bpf/bpf.cc:111 #, gcc-internal-format @@ -38314,16 +38277,14 @@ msgid "%<-mn%> is not supported for linux targets" msgstr "%<-mn%> n'est pas supporté sur les cibles linux" #: config/i386/host-cygwin.cc:64 -#, fuzzy, gcc-internal-format -#| msgid "can%'t extend PCH file: %m" +#, gcc-internal-format msgid "cannot extend PCH file: %m" -msgstr "ne peut étendre le fichier PCH: %m" +msgstr "ne peut étendre le fichier PCH : %m" #: config/i386/host-cygwin.cc:75 -#, fuzzy, gcc-internal-format -#| msgid "cannot get position in PCH file: %m" +#, gcc-internal-format msgid "cannot set position in PCH file: %m" -msgstr "ne peut obtenir la position dans le fichier PCH : %m" +msgstr "ne peut définir la position dans le fichier PCH : %m" #: config/i386/i386-builtins.cc:2058 #, gcc-internal-format @@ -38661,16 +38622,14 @@ msgid "CPU you selected does not support x86-64 instruction set" msgstr "le processeur sélectionné ne supporte pas le jeu d'instructions x86-64" #: config/i386/i386-options.cc:2215 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<-march=%> switch" +#, gcc-internal-format msgid "bad value %qs for %<-march=%> switch" -msgstr "valeur erronée (%qs) pour l'option %<-march=%>" +msgstr "valeur %qs erronée pour l'option %<-march=%>" #: config/i386/i386-options.cc:2216 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<target(\"arch=\")%> attribute" +#, gcc-internal-format msgid "bad value %qs for %<target(\"arch=\")%> attribute" -msgstr "valeur erronée (%qs) pour l'attribut %<target(\"arch=\")%>" +msgstr "valeur %qs erronée pour l'attribut %<target(\"arch=\")%>" #: config/i386/i386-options.cc:2238 #, gcc-internal-format @@ -38693,16 +38652,14 @@ msgid "valid arguments to %<target(\"arch=\")%> attribute are: %s" msgstr "les arguments valides pour l'attribut %<target(\"arch=\")%> sont: %s" #: config/i386/i386-options.cc:2295 -#, fuzzy, gcc-internal-format -#| msgid "bad value %qs for %<-mtune%> switch" +#, gcc-internal-format msgid "bad value %qs for %<-mtune=%> switch" -msgstr "valeur %qs erronée pour l'option %<-mtune%>" +msgstr "valeur %qs erronée pour l'option %<-mtune=%>" #: config/i386/i386-options.cc:2296 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute" +#, gcc-internal-format msgid "bad value %qs for %<target(\"tune=\")%> attribute" -msgstr "valeur erronée (%qs) pour l'attribut %<target(\"tune=\")%>" +msgstr "valeur %qs erronée pour l'attribut %<target(\"tune=\")%>" #: config/i386/i386-options.cc:2317 #, gcc-internal-format @@ -39141,16 +39098,14 @@ msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt servic msgstr "DRAP (Dynamic Realign Argument Pointer) n'est pas supporté dans une routine de service d'interruption. Ceci peut être contourné en évitant les fonctions avec un retour agrégé." #: config/i386/i386.cc:9458 -#, fuzzy, gcc-internal-format -#| msgid "%qs attribute not supported in %<__builtin_has_attribute%>" +#, gcc-internal-format msgid "Stack realignment not supported with %<__builtin_eh_return%>" -msgstr "l'attribut %qs n'est pas supporté dans %<__builtin_has_attribute%>" +msgstr "Le réalignement de pile n'est pas supporté avec %<__builtin_eh_return%>" #: config/i386/i386.cc:9463 -#, fuzzy, gcc-internal-format -#| msgid "nested functions not supported on this target" +#, gcc-internal-format msgid "regparm nested function not supported with %<__builtin_eh_return%>" -msgstr "fonctions imbriquées pas supportées sur cette cible" +msgstr "les fonctions regparm imbriquées ne sont pas supportées avec %<__builtin_eh_return%>" #: config/i386/i386.cc:9849 #, gcc-internal-format @@ -39319,90 +39274,85 @@ msgid "%<PRINT_OPERAND%> null pointer" msgstr "%<PRINT_OPERAND%> pointeur nul" #: config/loongarch/loongarch-cpu.cc:111 -#, fuzzy, gcc-internal-format -#| msgid "unknown core architecture %qs specified with %qs" +#, gcc-internal-format msgid "unknown base architecture %<0x%x%>, %qs failed" -msgstr "architecture de cœur %qs inconnue spécifiée avec %qs" +msgstr "architecture de base %<0x%x%> inconnue, %qs a échoué" #: config/loongarch/loongarch-cpu.cc:138 #, gcc-internal-format msgid "unknown FPU type %<0x%x%>, %qs failed" -msgstr "" +msgstr "type de FPU %<0x%x%> inconnu, %qs a échoué" #: config/loongarch/loongarch-cpu.cc:189 #, gcc-internal-format msgid "unknown processor ID %<0x%x%>, some tuning parameters will fall back to default" -msgstr "" +msgstr "ID de processeur %<0x%x%> inconnu, certains réglages vont utiliser la valeur par défaut" #: config/loongarch/loongarch-opts.cc:196 #, gcc-internal-format msgid "%<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs" -msgstr "" +msgstr "%<-m%s%> écrase %<-m%s=%s%>, ajustement du type d'ABI à %qs" #: config/loongarch/loongarch-opts.cc:211 #, gcc-internal-format msgid "ABI changed (%qs to %qs) while multilib is disabled" -msgstr "" +msgstr "ABI changé (%qs à %qs) pendant que multilib est désactivé" #: config/loongarch/loongarch-opts.cc:233 #: config/loongarch/loongarch-opts.cc:238 -#, fuzzy, gcc-internal-format -#| msgid "%s is not in a class scope" +#, gcc-internal-format msgid "%qs does not work on a cross compiler" -msgstr "%s n'est pas dans la portée d'une classe" +msgstr "%qs ne fonctionne pas sur un compilateur croisé" #: config/loongarch/loongarch-opts.cc:278 -#, fuzzy, gcc-internal-format -#| msgid "the %qs architecture does not support %<-m%s=2008%>" +#, gcc-internal-format msgid "your native CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>" -msgstr "l'architecture %qs ne supporte pas %<-m%s=2008%>" +msgstr "l'architecture de votre processeur natif (%qs) ne supporte pas l'ABI %qs, utilisation de %<-m%s=%s%>" #: config/loongarch/loongarch-opts.cc:283 -#, fuzzy, gcc-internal-format -#| msgid "the %qs architecture does not support %<-m%s=2008%>" +#, gcc-internal-format msgid "default CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>" -msgstr "l'architecture %qs ne supporte pas %<-m%s=2008%>" +msgstr "l'architecture du processeur par défaut (%qs) ne supporte pas l'ABI %qs, utilisation de %<-m%s=%s%>" #: config/loongarch/loongarch-opts.cc:314 #, gcc-internal-format msgid "unable to implement ABI %qs with instruction set %qs" -msgstr "" +msgstr "impossible d'implémenter l'ABI %qs avec le jeu d'instruction %qs" #: config/loongarch/loongarch-opts.cc:336 #, gcc-internal-format msgid "ABI %qs cannot be implemented due to limited instruction set %qs, falling back to %qs" -msgstr "" +msgstr "l'ABI %qs ne peut pas être implémentée à cause du jeu d'instruction limité %qs, utilisation de %qs" #: config/loongarch/loongarch-opts.cc:347 #, gcc-internal-format msgid "instruction set %qs cannot implement default ABI %qs, falling back to %qs" -msgstr "" +msgstr "le jeu d'instruction %qs ne sait pas implémenter l'ABI par défaut %qs, utilisation de %qs" #: config/loongarch/loongarch-opts.cc:352 #, gcc-internal-format msgid "no multilib-enabled ABI (%qs) can be implemented with instruction set %qs, falling back to %qs" -msgstr "" +msgstr "pas d'ABI avec multilib (%qs) peut être implémentée avec le jeu d'instruction %qs, utilisation de %qs" #: config/loongarch/loongarch-opts.cc:368 #, gcc-internal-format msgid "ABI %qs is not enabled at configure-time, the linker might report an error" -msgstr "" +msgstr "l'ABI %qs n'est pas activée durant la compilation, l'éditeur de lien pourrait signaler une erreur" #: config/loongarch/loongarch-opts.cc:371 #, gcc-internal-format, gfc-internal-format msgid "ABI with startfiles: %s" -msgstr "" +msgstr "ABI avec startfiles : %s" #: config/loongarch/loongarch.cc:3458 #, gcc-internal-format msgid "Normal symbol loading not implemented in extreme mode." -msgstr "" +msgstr "Le chargement des symboles normaux n'est pas implémenté en mode extrême." #: config/loongarch/loongarch.cc:5507 -#, fuzzy, gcc-internal-format -#| msgid "code model %s does not support PIC mode" +#, gcc-internal-format msgid "code model %qs and %qs not support %s mode" -msgstr "le modèle de code %s ne supporte pas le mode PIC" +msgstr "les modèles de code %qs et %qs ne supporte pas le mode %s" #: config/m32c/m32c-pragma.cc:54 #, gcc-internal-format @@ -39583,16 +39533,12 @@ msgid "argument to %qE attribute is not intstack" msgstr "l'argument de l'attribut %qE n'est pas « intstack »" #: config/mips/mips.cc:6089 -#, fuzzy -#| msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}" msgid "the ABI for passing a value containing zero-width fields before an adjacent 64-bit floating-point field was changed in GCC %{12.1%}" -msgstr "l'ABI pour passer des structures C avec des champs de bits de largeur zéro a changé dans GCC %{12.1%}" +msgstr "l'ABI pour passer une valeur contenant des champs de bits de largeur zéro avant un champ en virgule flottante 64 bits adjacent a changé dans GCC %{12.1%}" #: config/mips/mips.cc:6490 -#, fuzzy -#| msgid "ELFv2 parameter passing for an argument containing zero-width bit fields but that is otherwise a homogeneous aggregate was corrected in GCC 12" msgid "the ABI for returning a value containing zero-width bit-fields but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}" -msgstr "le passage d'un paramètre ELFv2 pour un argument contenant des champs de bits de largeur zéro qui est, par ailleurs, un agrégat homogène a été corrigé dans GCC 12" +msgstr "l'ABI pour retourner une valeur contenant des champs de bits de largeur zéro mais étant par ailleurs un agrégat avec uniquement un ou deux champs en virgule flottante a été changée dans GCC %{12.1%}" #: config/mips/mips.cc:7831 #, gcc-internal-format @@ -40483,10 +40429,9 @@ msgid "option %s is not supported together with %<-fopenacc%>" msgstr "l'option %s n'est pas supportée avec %<-fopenacc%>" #: config/nvptx/nvptx.cc:326 -#, fuzzy, gcc-internal-format -#| msgid "PTX version (-mptx) needs to be at least %s to support selected -misa (sm_%s)" +#, gcc-internal-format msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)" -msgstr "la version PTX (-mptx) doit être au moins %s pour supporter le -misa demandé (sm_%s)" +msgstr "la version PTX (%<-mptx%>) doit être au moins %s pour supporter le %<-misa%> demandé (sm_%s)" #: config/nvptx/nvptx.cc:359 #, gcc-internal-format @@ -40539,16 +40484,14 @@ msgid "variable %qD adjusted for OpenACC privatization level: %qs" msgstr "variable %qD ajustée pour le niveau de privatisation de OpenACC : %qs" #: config/nvptx/nvptx.cc:7455 -#, fuzzy, gcc-internal-format -#| msgid "alias definitions not supported in this configuration" +#, gcc-internal-format msgid "weak alias definitions not supported in this configuration" -msgstr "les définitions d'alias ne sont pas supportées dans cette configuration" +msgstr "les définitions d'alias faibles ne sont pas supportées dans cette configuration" #: config/nvptx/nvptx.cc:7468 -#, fuzzy, gcc-internal-format -#| msgid "alias definitions not supported in this configuration" +#, gcc-internal-format msgid "non-function alias definitions not supported in this configuration" -msgstr "les définitions d'alias ne sont pas supportées dans cette configuration" +msgstr "les définitions d'alias sur autre chose qu'une fonction ne sont pas supportées dans cette configuration" #: config/or1k/or1k.cc:1311 #, gcc-internal-format, gfc-internal-format @@ -40880,10 +40823,9 @@ msgid "%qs requires %<long double%> to be IBM 128-bit format" msgstr "%qs requiert que %<long double%> soit au format IBM 128 bits" #: config/rs6000/rs6000-builtin.cc:3429 -#, fuzzy, gcc-internal-format -#| msgid "%qs requires VSX support" +#, gcc-internal-format msgid "%qs requires %<__ibm128%> type support" -msgstr "%qs requiert le support VSX" +msgstr "%qs requiert le support du type %<__ibm128%>" #: config/rs6000/rs6000-builtin.cc:3584 #, gcc-internal-format, gfc-internal-format @@ -40961,10 +40903,9 @@ msgid "%<vec_lvsr%> is deprecated for little endian; use assignment for unaligne msgstr "%<vec_lvsr%> est déprécié pour les petits boutistes; utilisation d'une affectation pour des chargements et des stockages non alignés" #: config/rs6000/rs6000-c.cc:1795 -#, fuzzy, gcc-internal-format -#| msgid "passing argument %d of %qE discards %qv qualifier from pointer target type" +#, gcc-internal-format msgid "passing argument %d of %qE discards %qs qualifier from pointer target type" -msgstr "passer l'argument %d de %qE abandonne le qualificatif %qv du type pointé" +msgstr "passer l'argument %d de %qE abandonne le qualificatif %qs du type pointé" #: config/rs6000/rs6000-c.cc:1881 config/rs6000/rs6000-c.cc:2037 #, gcc-internal-format @@ -41137,10 +41078,9 @@ msgid "%qs requires full ISA 3.0 support" msgstr "%qs requiert le support ISA 3.0 complet" #: config/rs6000/rs6000.cc:4348 -#, fuzzy, gcc-internal-format -#| msgid "unknown vectorization library ABI type (%s) for -mveclibabi= switch" +#, gcc-internal-format msgid "unknown vectorization library ABI type in %<-mveclibabi=%s%>" -msgstr "type d'ABI de la bibliothèque de vectorisation (%s) inconnu pour l'option -mveclibabi=" +msgstr "type d'ABI de la bibliothèque de vectorisation inconnu dans %<-mveclibabi=%s%>" #: config/rs6000/rs6000.cc:4361 config/rs6000/rs6000.cc:4376 #, gcc-internal-format @@ -41268,10 +41208,9 @@ msgid "multiple fast interrupt routines seen: %qE and %qE" msgstr "plusieurs routines d'interruptions rapides vues: %qE et %qE" #: config/rx/rx.cc:2480 -#, fuzzy, gcc-internal-format -#| msgid "invalid control register for mvtc: %d - using 'psw'" +#, gcc-internal-format msgid "invalid control register %d for mvtc; using %<psw%>" -msgstr "registre de contrôle invalide pour mvtc : %d – utilisation de « psw »" +msgstr "registre de contrôle %d invalide pour mvtc : utilisation de %<psw%>" #: config/rx/rx.cc:2602 #, gcc-internal-format @@ -41668,10 +41607,9 @@ msgid "operand must be an immediate of the right size" msgstr "l'opérande doit être une valeur immédiate de la bonne taille" #: config/v850/v850-c.cc:67 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma%> GHS endXXXX found without previous startXXX" +#, gcc-internal-format msgid "%<#pragma%> GHS endXXX found without previous startXXX" -msgstr "%<#pragma%> GHS endXXXX repéré sans être précédé de startXXX" +msgstr "%<#pragma%> GHS endXXX repéré sans être précédé de startXXX" #: config/v850/v850-c.cc:70 #, gcc-internal-format @@ -45033,8 +44971,7 @@ msgid "too many %<close%> modifiers" msgstr "trop de modificateurs %<close%>" #: c/c-parser.cc:16232 cp/parser.cc:39440 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%>on %<map%> clause" +#, gcc-internal-format msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%> on %<map%> clause" msgstr "%<#pragma omp target%> avec un modificateur autre que %<always%> ou %<close%> sur une clause %<map%>" @@ -47546,10 +47483,9 @@ msgid "edge not found" msgstr "arête introuvable" #: c/gimple-parser.cc:342 -#, fuzzy, gcc-internal-format -#| msgid "concept %qD has no definition" +#, gcc-internal-format msgid "SSA name %qE with version %d has no definition" -msgstr "le concept %qD n'a pas de définition" +msgstr "le nom SSA %qE avec la version %d n'a pas de définition" #: c/gimple-parser.cc:482 c/gimple-parser.cc:488 #, gcc-internal-format @@ -48435,10 +48371,9 @@ msgid "%#qT declared here" msgstr "%#qT déclaré ici" #: cp/call.cc:10428 -#, fuzzy, gcc-internal-format -#| msgid "argument %u in call to function %qE has pointer to %qs type (%qT)" +#, gcc-internal-format msgid "argument %u in call to function %qE has pointer to a non-trivially-copyable type (%qT)" -msgstr "l'argument %u dans l'appel à la fonction %qE est un pointeur vers le type %qs (%qT)" +msgstr "l'argument %u dans l'appel à la fonction %qE est un pointeur vers un type non trivialement copiable (%qT)" #: cp/call.cc:10495 #, gcc-internal-format @@ -49575,16 +49510,14 @@ msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fco msgstr "le décompte des opérations d'évaluation de %<constexpr%> dépasse la limite permise %wd (utilisez %<-fconstexpr-ops-limit=%> pour augmenter la limite)" #: cp/constexpr.cc:6734 -#, fuzzy, gcc-internal-format -#| msgid "control passes through declaration of %qD with thread storage duration" +#, gcc-internal-format msgid "control passes through definition of %qD with thread storage duration" -msgstr "le contrôle passe au travers de la déclaration de %qD avec une durée de stockage limitée au thread" +msgstr "le contrôle passe au travers de la définition de %qD avec une durée de stockage limitée au thread" #: cp/constexpr.cc:6737 -#, fuzzy, gcc-internal-format -#| msgid "control passes through declaration of %qD with static storage duration" +#, gcc-internal-format msgid "control passes through definition of %qD with static storage duration" -msgstr "le contrôle passe au travers de la déclaration de %qD avec une durée de stockage statique" +msgstr "le contrôle passe au travers de la définition de %qD avec une durée de stockage statique" #: cp/constexpr.cc:6785 cp/constexpr.cc:9226 #, gcc-internal-format @@ -49717,16 +49650,14 @@ msgid "cast to non-integral type %qT in a constant expression" msgstr "transtypage vers le type non entier %qT dans une expression constante" #: cp/constexpr.cc:9195 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<thread_local%> in %<constexpr%> context" +#, gcc-internal-format msgid "%qD defined %<thread_local%> in %<constexpr%> context" -msgstr "%qD déclaré %<thread_local%> dans un contexte %<constexpr%>" +msgstr "%qD défini %<thread_local%> dans un contexte %<constexpr%>" #: cp/constexpr.cc:9202 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<static%> in %<constexpr%> context" +#, gcc-internal-format msgid "%qD defined %<static%> in %<constexpr%> context" -msgstr "%qD déclaré %<static%> dans un contexte %<constexpr%>" +msgstr "%qD défini %<static%> dans un contexte %<constexpr%>" #: cp/constexpr.cc:9275 #, gcc-internal-format @@ -49739,10 +49670,9 @@ msgid "%<delete[]%> is not a constant expression" msgstr "%<delete[]%> n'est pas une expression constante" #: cp/constexpr.cc:9444 -#, fuzzy, gcc-internal-format -#| msgid "use of %<this%> in a constant expression" +#, gcc-internal-format msgid "neither branch of %<if%> is a constant expression" -msgstr "utilisation de %<this%> dans une expression constante" +msgstr "aucune des branches de %<if%> est une expression constante" #: cp/constexpr.cc:9455 #, gcc-internal-format @@ -50033,64 +49963,54 @@ msgid " %qT is not a union" msgstr " %qT est une union" #: cp/constraint.cc:3658 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not an enum" +#, gcc-internal-format msgid " %qT is not an aggregate" -msgstr " %qT n'est pas une énumération" +msgstr " %qT n'est pas un agrégat" #: cp/constraint.cc:3661 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially copy assignable" +#, gcc-internal-format msgid " %qT is not trivially copyable" -msgstr " %qT n'est pas trivialement copiable par affectation" +msgstr " %qT n'est pas trivialement copiable" #: cp/constraint.cc:3664 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not derived from %qT" +#, gcc-internal-format msgid " %qT is not assignable from %qT" -msgstr " %qT n'est pas dérivé de %qT" +msgstr " %qT n'est pas assignable depuis %qT" #: cp/constraint.cc:3667 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially copy assignable" +#, gcc-internal-format msgid " %qT is not trivially assignable from %qT" -msgstr " %qT n'est pas trivialement copiable par affectation" +msgstr " %qT n'est pas trivialement assignable depuis %qT" #: cp/constraint.cc:3670 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not %<nothrow%> copy assignable" +#, gcc-internal-format msgid " %qT is not %<nothrow%> assignable from %qT" -msgstr " %qT n'est pas copiable par affectation avec %<nothrow%>" +msgstr " %qT n'est pas assignable avec %<nothrow%> depuis %qT" #: cp/constraint.cc:3674 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially default constructible" +#, gcc-internal-format msgid " %qT is not default constructible" -msgstr " %qT n'a pas de constructeur par défaut trivialement utilisable" +msgstr " %qT n'a pas de constructeur par défaut utilisable" #: cp/constraint.cc:3676 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not derived from %qT" +#, gcc-internal-format msgid " %qT is not constructible from %qE" -msgstr " %qT n'est pas dérivé de %qT" +msgstr " %qT ne peut pas être construit à partir de %qE" #: cp/constraint.cc:3682 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not trivially copy constructible" +#, gcc-internal-format msgid " %qT is not trivially constructible from %qE" -msgstr " %qT n'a pas de constructeur par copie trivialement utilisable" +msgstr " %qT ne peut pas être construit trivialement à partir de %qE" #: cp/constraint.cc:3688 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not %<nothrow%> copy constructible" +#, gcc-internal-format msgid " %qT is not %<nothrow%> constructible from %qE" -msgstr " %qT n'a pas de constructeur par copie avec %<nothrow%>" +msgstr " %qT ne peut pas être construit avec %<nothrow%> à partir de %qE" #: cp/constraint.cc:3691 -#, fuzzy, gcc-internal-format -#| msgid " %q+T does not have %<constexpr%> destructor" +#, gcc-internal-format msgid " %qT does not have unique object representations" -msgstr " %q+T n'a pas de destructeur %<constexpr%>" +msgstr " %qT n'a pas de représentation objet unique" #: cp/constraint.cc:3717 #, gcc-internal-format @@ -50812,10 +50732,9 @@ msgid "old declaration %q#D" msgstr "ancienne déclaration %q#D" #: cp/decl.cc:1493 -#, fuzzy, gcc-internal-format -#| msgid "redefinition of default argument for %q#D" +#, gcc-internal-format msgid "redefinition of default argument for %q+#D" -msgstr "redéfinition de l'argument par défaut pour %q#D" +msgstr "redéfinition de l'argument par défaut pour %q+#D" #: cp/decl.cc:1495 #, gcc-internal-format @@ -51420,16 +51339,14 @@ msgid "block-scope extern declaration %q#D not permitted in module purview" msgstr "la déclaration externe avec la portée bloc %q#D n'est pas permise dans le domaine du module" #: cp/decl.cc:5779 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" +#, gcc-internal-format msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%qD déclaré %<thread_local%> dans la fonction %qs est uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>" +msgstr "%qD défini %<thread_local%> dans la fonction %qs est uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>" #: cp/decl.cc:5785 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" +#, gcc-internal-format msgid "%qD defined %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%qD déclaré %<static%> dans la fonction %qs est uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>" +msgstr "%qD défini %<static%> dans la fonction %qs est uniquement disponible avec %<-std=c++2b%> ou %<-std=gnu++2b%>" #: cp/decl.cc:5850 #, gcc-internal-format @@ -59772,10 +59689,9 @@ msgid "concept %qE not in namespace scope" msgstr "le concept %qE n'est pas dans la portée de l'espace de noms" #: cp/pt.cc:28824 -#, fuzzy, gcc-internal-format -#| msgid "definition of %q#T inside template parameter list" +#, gcc-internal-format msgid "concept %qE has multiple template parameter lists" -msgstr "définition de %q#T à l'intérieur d'une liste de paramètres de patron" +msgstr "le concept %qE a plusieurs listes de paramètres de patrons" #: cp/pt.cc:28851 #, gcc-internal-format @@ -60114,10 +60030,9 @@ msgid "compound literal of non-object type %qT" msgstr "littéral composé du type non objet %qT" #: cp/semantics.cc:3156 -#, fuzzy, gcc-internal-format -#| msgid "a concept cannot be constrained" +#, gcc-internal-format msgid "%<auto{x}%> cannot be constrained" -msgstr "un concept ne peut être contraint" +msgstr "%<auto{x}%> ne peut être contraint" #: cp/semantics.cc:3161 #, gcc-internal-format @@ -62021,10 +61936,9 @@ msgid "functional cast to array type %qT" msgstr "transtypage fonctionnel vers le type tableau %qT" #: cp/typeck2.cc:2319 -#, fuzzy, gcc-internal-format -#| msgid "a concept cannot be constrained" +#, gcc-internal-format msgid "%<auto(x)%> cannot be constrained" -msgstr "un concept ne peut être contraint" +msgstr "%<auto(x)%> ne peut être contraint" #: cp/typeck2.cc:2324 #, gcc-internal-format @@ -66117,10 +66031,9 @@ msgid "The number of elements in the array constructor at %L requires an increas msgstr "Le nombre d'éléments dans le constructeur du tableau à %L requiert une augmentation de la limite supérieure autorisée %d. Consultez l'option %<-fmax-array-constructor%>" #: fortran/expr.cc:1725 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Syntax error in array constructor at %C" +#, gcc-internal-format, gfc-internal-format msgid "Error in array constructor referenced at %L" -msgstr "Erreur de syntaxe dans le constructeur du tableau à %C" +msgstr "Erreur dans le constructeur du tableau référencé à %L" #: fortran/expr.cc:1829 fortran/primary.cc:2300 fortran/primary.cc:2444 #, gcc-internal-format, gfc-internal-format @@ -67649,8 +67562,7 @@ msgid "add_sym(): Bad sizing mode" msgstr "add_sym(): Mauvais mode de dimensionnement" #: fortran/intrinsic.cc:1184 -#, fuzzy, gcc-internal-format -#| msgid "The intrinsic %qs at %L is not included in the selected standard but %s and %qs will be treated as if declared EXTERNAL. Use an appropriate %<-std=%>* option or define %<-fall-intrinsics%> to allow this intrinsic." +#, gcc-internal-format msgid "The intrinsic %qs at %L is not included in the selected standard but %s and %qs will be treated as if declared EXTERNAL. Use an appropriate %<-std=%> option or define %<-fall-intrinsics%> to allow this intrinsic." msgstr "L'intrinsèque %qs à %L n'est pas inclus dans le standard sélectionné mais %s et %qs seront traités comme s'ils avaient été déclarés EXTERNAL. Utilisez l'option %<-std=%> appropriée ou définissez %<-fall-intrinsics%> pour autoriser ces intrinsèques" @@ -68852,10 +68764,9 @@ msgid "STOP code at %C contains too many digits" msgstr "Le code de STOP à %C contient trop de chiffres" #: fortran/match.cc:3079 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "NEWUNIT specifier at %L" +#, gcc-internal-format, gfc-internal-format msgid "QUIET= specifier for %s at %L" -msgstr "Spécificateur NEWUNIT à %L" +msgstr "Spécificateur QUIET= pour %s à %L" #: fortran/match.cc:3093 #, gcc-internal-format, gfc-internal-format @@ -68903,10 +68814,9 @@ msgid "STOP code at %L must be default integer KIND=%d" msgstr "Le code STOP à %L doit être un entier par défaut avec KIND=%d" #: fortran/match.cc:3178 fortran/resolve.cc:11973 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "ASYNCHRONOUS= specifier at %L must be scalar" +#, gcc-internal-format, gfc-internal-format msgid "QUIET specifier at %L must be a scalar LOGICAL" -msgstr "Le spécificateur ASYNCHRONOUS= à %L doit être un scalaire" +msgstr "Le spécificateur QUIET à %L doit être un scalaire LOGICAL" #: fortran/match.cc:3228 #, gcc-internal-format, gfc-internal-format @@ -70807,10 +70717,9 @@ msgid "Cray pointee %qs in SHARED clause at %L" msgstr "Pointé Cray %qs dans la clause SHARED à %L" #: fortran/openmp.cc:6785 -#, fuzzy, gcc-internal-format -#| msgid "ASSOCIATE name %qs in SHARED clause at %L" +#, gcc-internal-format msgid "Associate name %qs in SHARED clause at %L" -msgstr "Nom ASSOCIATE %qs dans la clause SHARED à %L" +msgstr "Nom associé %qs dans la clause SHARED à %L" #: fortran/openmp.cc:6791 #, gcc-internal-format @@ -70949,10 +70858,9 @@ msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct msgstr "clauses %<inscan%> et non-%<inscan%> %<reduction%> sur la même construction à %L" #: fortran/openmp.cc:7168 -#, fuzzy, gcc-internal-format -#| msgid "ASSOCIATE name %qs in %s clause at %L" +#, gcc-internal-format msgid "Associate name %qs in %s clause at %L" -msgstr "Nom ASSOCIATE %qs dans la clause %s à %L" +msgstr "Nom associé %qs dans la clause %s à %L" #: fortran/openmp.cc:7175 #, gcc-internal-format @@ -71061,22 +70969,19 @@ msgid "%s must contain at least one MAP clause at %L" msgstr "%s doit contenir au moins une clause MAP à %L" #: fortran/openmp.cc:7587 -#, fuzzy, gcc-internal-format -#| msgid "%qs at %L should be of type integer(kind=omp_event_handle_kind)" +#, gcc-internal-format msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)" -msgstr "%qs à %L devrait être de type integer(kind=omp_event_handle_kind)" +msgstr "%qs à %L devrait être un type scalaire de type integer(kind=omp_event_handle_kind)" #: fortran/openmp.cc:7592 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "The base name at %L must not be an entry name" +#, gcc-internal-format, gfc-internal-format msgid "The event handle at %L must not be an array element" -msgstr "Le nom de base à %L ne doit pas un nom d'entrée" +msgstr "L'identificateur d'événement à %L ne doit pas être un élément de tableau" #: fortran/openmp.cc:7596 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "The base name at %L must not be a procedure pointer" +#, gcc-internal-format, gfc-internal-format msgid "The event handle at %L must not be part of a derived type or class" -msgstr "Le nom de base à %L ne doit pas être un pointeur de procédure" +msgstr "L'identificateur d'événement à %L ne doit pas faire partie d'un type dérivé ou d'une classe" #: fortran/openmp.cc:7600 #, gcc-internal-format @@ -72765,10 +72670,9 @@ msgid "The element in the structure constructor at %L, for pointer component %qs msgstr "L'élément dans le constructeur de structure à %L, pour le composant pointeur %qs, est %s mais il devrait être %s" #: fortran/resolve.cc:1386 -#, fuzzy, gcc-internal-format -#| msgid "Unequal character lengths (%ld/%ld) in %s at %L" +#, gcc-internal-format msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L" -msgstr "Longueurs de caractères inégales (%ld/%ld) dans %s à %L" +msgstr "Longueurs de caractères inégales (%wd/%wd) pour le composant pointeur %qs dans le constructeur à %L" #: fortran/resolve.cc:1431 #, gcc-internal-format diff --git a/gcc/po/sv.po b/gcc/po/sv.po index 901e5a11275..ea5bb5df36f 100644 --- a/gcc/po/sv.po +++ b/gcc/po/sv.po @@ -1,4 +1,4 @@ -# Swedish messages for GCCs. +# Swedish messages for Sc's. # Copyright © 2000, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Free Software Foundation, Inc. # This file is distributed under the same license as the gcc package. # Dennis Björklund <db@zigo.dhs.org>, 2000, 2001, 2002. @@ -26,10 +26,10 @@ # thunk snutt msgid "" msgstr "" -"Project-Id-Version: gcc 12.1-b20220213\n" +"Project-Id-Version: gcc 12.1-b20220403\n" "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n" "POT-Creation-Date: 2022-04-01 17:30+0000\n" -"PO-Revision-Date: 2022-04-03 17:33+0200\n" +"PO-Revision-Date: 2022-04-23 09:55+0200\n" "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n" "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n" "Language: sv\n" @@ -2724,10 +2724,9 @@ msgid "Support dynamic initialization of thread-local variables in a different t msgstr "Stöd dynamisk initiering av trådlokala variabler i en annan översättningsenhet." #: c-family/c.opt:1728 -#, fuzzy, no-c-format -#| msgid "call to non-function %qD" +#, no-c-format msgid "Fold calls to simple inline functions." -msgstr "anrop av icke-funktion %qD" +msgstr "Vikningsanrop till enkla inline-funktioner." #: c-family/c.opt:1735 #, no-c-format @@ -3546,10 +3545,9 @@ msgid "Add comments for ignored declarations in the generated C++ header." msgstr "Lägg till kommentarer om ignorerade deklarationer i det genererade C++-huvudet." #: d/lang.opt:280 -#, fuzzy, no-c-format -#| msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <file>." +#, no-c-format msgid "-fdump-cxx-spec=<filename>\tWrite all declarations as C++ code to <filename>." -msgstr "-fdump-cxx-spec=<filnamn>\tSkriv alla deklarationer com C++-kod till <fil>." +msgstr "-fdump-cxx-spec=<filnamn>\tSkriv alla deklarationer com C++-kod till <filnamn>." #: d/lang.opt:284 #, no-c-format @@ -3637,10 +3635,9 @@ msgid "Use field-wise comparisons for struct equality." msgstr "Använd fältvisa jämförelser för postlikhet." #: d/lang.opt:373 -#, fuzzy, no-c-format -#| msgid "When a symbol is resolved, check alias this scope before going to upper scopes." +#, no-c-format msgid "When a symbol is resolved, check `alias this' scope before going to upper scopes." -msgstr "När en symbol slås upp, kontrollera alias i denna räckvidd innan man går till övre räckvidder." +msgstr "När en symbol slås upp, kontrollera ”alias this”-räckvidd innan man går till övre räckvidder." #: d/lang.opt:377 #, no-c-format @@ -4130,7 +4127,7 @@ msgstr "Dumpa analyserarens supergraf till en fil KÄLLFIL.supergraph.dot." #: analyzer/analyzer.opt:255 #, no-c-format msgid "Emit custom warnings with internal details intended for analyzer developers." -msgstr "" +msgstr "Mata ut anpassade varningar med interna detaljer avsedda för analysatorutvecklare." #: config/vms/vms.opt:27 #, no-c-format @@ -5497,7 +5494,7 @@ msgstr "Konstant memset-storlek i byte över vilken MOPS-sekvenser skall använd #: config/aarch64/aarch64.opt:298 #, no-c-format msgid "Limit how much the autovectorizer may unroll a loop." -msgstr "" +msgstr "Begränsa hur mycket autovektoriseraren får rulla ut en slinga." #: config/linux.opt:24 #, no-c-format @@ -7342,16 +7339,14 @@ msgid "Support multi-threading." msgstr "Stöd multitrådning." #: config/nvptx/nvptx-gen.opt:24 -#, fuzzy, no-c-format -#| msgid "Known ARM architectures (for use with the -march= option):" +#, no-c-format msgid "Known PTX ISA target architectures (for use with the -misa= option):" -msgstr "Kända ARM-arkitekturer (att användas med flaggan -march=):" +msgstr "Kända PTX ISA-målarkitekturer (att användas med flaggan -misa=):" #: config/nvptx/nvptx.opt:28 -#, fuzzy, no-c-format -#| msgid "Does nothing. Preserved for backward compatibility." +#, no-c-format msgid "Ignored, but preserved for backward compatibility. Only 64-bit ABI is supported." -msgstr "Gör ingenting. Bevarad för bakåtkompatibilitet." +msgstr "Ignorerad, men bevarad för bakåtkompatibilitet. Endast 64-bitars ABI stödjs." #: config/nvptx/nvptx.opt:33 #, no-c-format @@ -7384,35 +7379,29 @@ msgid "Generate code for OpenMP offloading: enables -msoft-stack and -muniform-s msgstr "Generera kod för OpenMP-avlastning: aktiverar -msoft-stack och -muniform-simt." #: config/nvptx/nvptx.opt:58 -#, fuzzy, no-c-format -#| msgid "Specify the target architecture." +#, no-c-format msgid "Specify the PTX ISA target architecture to use." -msgstr "Ange målarkitekturen." +msgstr "Ange PTX ISA-målarkitekturen att använda." #: config/nvptx/nvptx.opt:62 #, no-c-format msgid "Alias:" -msgstr "" +msgstr "Alias:" #: config/nvptx/nvptx.opt:117 -#, fuzzy, no-c-format -#| msgid "Known PTX versions (for use with the -mptx= option):" +#, no-c-format msgid "Known PTX ISA versions (for use with the -mptx= option):" -msgstr "Kända PTX-versioner (att användas med flaggan -mptx=):" +msgstr "Kända PTX ISA-versioner (att användas med flaggan -mptx=):" -# Felet i originalet är rapporterat: -# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104818 #: config/nvptx/nvptx.opt:136 -#, fuzzy, no-c-format -#| msgid "Specify the version of the ptx version to use." +#, no-c-format msgid "Specify the PTX ISA version to use." -msgstr "Ange versionen av ptx att använda." +msgstr "Ange PTX-ISA-versionen att använda." #: config/nvptx/nvptx.opt:140 -#, fuzzy, no-c-format -#| msgid "Use fp registers." +#, no-c-format msgid "Initialize ptx registers." -msgstr "Använd fp-register." +msgstr "Initiera ptx-register." #: config/vxworks.opt:36 #, no-c-format @@ -9140,18 +9129,17 @@ msgstr "Använd användardefinierade instruktioner." #: config/loongarch/loongarch.opt:47 #, no-c-format msgid "Basic ISAs of LoongArch:" -msgstr "" +msgstr "Grundläggande ISA:er hos LoongArch:" #: config/loongarch/loongarch.opt:56 #, no-c-format msgid "FPU types of LoongArch:" -msgstr "" +msgstr "FPU-typer hos LoongArch:" #: config/loongarch/loongarch.opt:69 -#, fuzzy, no-c-format -#| msgid "-march=ISA\tGenerate code for the given ISA." +#, no-c-format msgid "-mfpu=FPU\tGenerate code for the given FPU." -msgstr "-march=ISA\tGenerera kod för den angivna ISA:n." +msgstr "-mfpu=FPU\tGenerera kod för den angivna FPU:n." #: config/loongarch/loongarch.opt:76 config/mips/mips.opt:377 #, no-c-format @@ -9171,30 +9159,27 @@ msgstr "Tillåt flyttalsinstruktioner i hårdvara att täcka både 32-bitars och #: config/loongarch/loongarch.opt:90 #, no-c-format msgid "LoongArch CPU types:" -msgstr "" +msgstr "LoongArch-CPU-typer:" #: config/loongarch/loongarch.opt:103 -#, fuzzy, no-c-format -#| msgid "-march=ISA\tGenerate code for the given ISA." +#, no-c-format msgid "-march=PROCESSOR\tGenerate code for the given PROCESSOR ISA." -msgstr "-march=ISA\tGenerera kod för den angivna ISA:n." +msgstr "-march=PROCESSOR\tGenerera kod för den angivna PROCESSOR-ISA:n." #: config/loongarch/loongarch.opt:107 -#, fuzzy, no-c-format -#| msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR." +#, no-c-format msgid "-mtune=PROCESSOR\tGenerate optimized code for PROCESSOR." -msgstr "-mtune=PROCESSOR\tOptimera utmatningen för PROCESSOR." +msgstr "-mtune=PROCESSOR\tGenerera optimerad kod för PROCESSOR." #: config/loongarch/loongarch.opt:116 #, no-c-format msgid "Base ABI types for LoongArch:" -msgstr "" +msgstr "Grund-ABI-typer för LoongArch:" #: config/loongarch/loongarch.opt:129 -#, fuzzy, no-c-format -#| msgid "-mabi=ABI\tGenerate code that conforms to the given ABI." +#, no-c-format msgid "-mabi=BASEABI\tGenerate code that conforms to the given BASEABI." -msgstr "-mabi=ABI\tGenerera kod som följer det angivna ABI:et." +msgstr "-mabi=BASABI\tGenerera kod som följer det angivna BASABI:et." #: config/loongarch/loongarch.opt:138 config/mips/mips.opt:71 #, no-c-format @@ -9209,22 +9194,22 @@ msgstr "Fånga heltalsdivision med noll." #: config/loongarch/loongarch.opt:146 #, no-c-format msgid "Conditional moves for integral are enabled." -msgstr "" +msgstr "Villkorliga flyttningar för heltal är aktiverade." #: config/loongarch/loongarch.opt:150 #, no-c-format msgid "Conditional moves for float are enabled." -msgstr "" +msgstr "Villkorliga flyttningar för flyttal är aktiverade." #: config/loongarch/loongarch.opt:154 #, no-c-format msgid "Prevent optimizing block moves, which is also the default behavior of -Os." -msgstr "" +msgstr "Förhindra optimering av blockförflyttningar, vilket även är standardbeteendet hos -Os." #: config/loongarch/loongarch.opt:162 #, no-c-format msgid "-mmax-inline-memcpy-size=SIZE\tSet the max size of memcpy to inline, default is 1024." -msgstr "" +msgstr "-mmax-inline-memcpy-size=STORLEK\tAnge den maximala stoleken att inline:a memcpy, standard är 1024." #: config/or1k/elf.opt:28 #, no-c-format @@ -12739,10 +12724,9 @@ msgid "Warn whenever a trampoline is generated." msgstr "Varna närhelst en trampolin genereras." #: common.opt:806 -#, fuzzy, no-c-format -#| msgid "Warn about maybe uninitialized automatic variables." +#, no-c-format msgid "Warn about cases where -ftrivial-auto-var-init cannot initialize an auto variable." -msgstr "Varna för eventuellt oinitierade automatiska variabler." +msgstr "Varna för fall där -ftrivial-auto-var-init inte kan initiera en auto-variabel." #: common.opt:810 #, no-c-format @@ -15326,8 +15310,7 @@ msgid "Recursive cloning only when the probability of call being executed exceed msgstr "Rekursiv kloning endast när sannolikheten för att ett anrop skall göras överskrider parametern." #: params.opt:254 -#, fuzzy, no-c-format -#| msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that that bring back an unchanged value by this factor." +#, no-c-format msgid "When propagating IPA-CP effect estimates, multiply frequencies of recursive edges that bring back an unchanged value by this factor." msgstr "Vid propagering av IPA-CP-effektuppskattningar, multiplicera frekvenser för rekursiva bågar som för tillbaka ett oförändrat värde med denna faktor." @@ -15692,8 +15675,7 @@ msgid "Maximum loop depth of a call which is considered for inlining functions c msgstr "Maximal slingdjup för ett anrop vilket övervägs för inline:ing av funktioner som endast anropas en gång." #: params.opt:554 -#, fuzzy, no-c-format -#| msgid "Maximum combinaed size of caller and callee wich is inlined if callee is called once." +#, no-c-format msgid "Maximum combined size of caller and callee which is inlined if callee is called once." msgstr "Maximal kombinerad storlek på anropare och anropad vilka inline:as om den anropade anropas en gång." @@ -15776,7 +15758,7 @@ msgstr "Det maximala antalet försök att gå tillbaka schemaläggaren skall gö #: params.opt:618 #, no-c-format msgid "Minimum page size for warning purposes." -msgstr "" +msgstr "Minsta sidstorlek för varningsändamål." #: params.opt:622 #, no-c-format @@ -16384,10 +16366,9 @@ msgid "The maximum factor which the loop vectorizer applies to the cost of state msgstr "Den maximala faktorn som slingvektoriseraren använder på kostnaden av satser i en inre sliga relativt slingan som vektoriseras." #: params.opt:1185 -#, fuzzy, no-c-format -#| msgid "Enable loop vectorization on trees." +#, no-c-format msgid "Enable loop vectorization of floating point inductions." -msgstr "Aktivera slingvektorisering i träd." +msgstr "Aktivera slingvektorisering av flyttalsinduktioner." #: params.opt:1189 #, no-c-format @@ -22758,7 +22739,7 @@ msgstr "slinga %d:s koppling är markerad som en del av en oreducerbar region" #: cfgloop.cc:1573 #, gcc-internal-format msgid "loop %d%'s number of iterations %qE references the released SSA name %qE" -msgstr "" +msgstr "slinga %d:s antal iterationer %qE refererar det släppta SSA-namnet %qE" #: cfgloop.cc:1606 #, gcc-internal-format, gfc-internal-format @@ -26249,7 +26230,7 @@ msgstr "satsen kommer aldrig utföras" #: gimplify.cc:2132 #, gcc-internal-format msgid "%qs cannot be initialized with%<-ftrivial-auto-var_init%>" -msgstr "" +msgstr "%qs får inte initieras med %<-ftrivial-auto-var_init%>" #: gimplify.cc:2524 gimplify.cc:2532 #, gcc-internal-format @@ -27780,10 +27761,9 @@ msgid "location of OpenACC %<kernels%>" msgstr "platsen för OpenACC %<kernels%>" #: omp-oacc-kernels-decompose.cc:1288 -#, fuzzy, gcc-internal-format -#| msgid "%<ancestor%> not yet supported" +#, gcc-internal-format msgid "%qs not yet supported" -msgstr "%<ancestor%> stödjs inte ännu" +msgstr "%qs stödjs inte ännu" #: omp-oacc-neuter-broadcast.cc:1764 #, gcc-internal-format @@ -28473,10 +28453,9 @@ msgid "failed to initialize plugin %s" msgstr "misslyckades att initiera insticksmodulen %s" #: plugin.cc:1009 -#, fuzzy, gcc-internal-format -#| msgid "%<-iplugindir%> <dir> option not passed from the gcc driver" +#, gcc-internal-format msgid "%<-iplugindir%> option not passed from the gcc driver" -msgstr "flaggan %<-iplugindir%> <kat> skickas inte från gcc-drivrutin" +msgstr "flaggan %<-iplugindir%> skickas inte från gcc-drivrutin" #: pointer-query.cc:1202 #, gcc-internal-format @@ -29376,16 +29355,14 @@ msgid "%qs is not supported for this target" msgstr "%qs stödjs inte för denna målarkitektur" #: toplev.cc:1685 -#, fuzzy, gcc-internal-format -#| msgid "%<-fsanitize=address%> not supported for this target" +#, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> not supported in current platform" -msgstr "%<-fsanitize=address%> stödjs inte för denna målarkitektur" +msgstr "%<-fsanitize=shadow-call-stack%> stödjs inte för den aktuella plattformen" #: toplev.cc:1688 -#, fuzzy, gcc-internal-format -#| msgid "%<-fsanitize-address-use-after-scope%> requires %<-fstack-reuse=none%> option" +#, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-fno-exceptions%>" -msgstr "%<-fsanitize-address-use-after-scope%> förutsätter flaggan %<-fstack-reuse=none%>" +msgstr "%<-fsanitize=shadow-call-stack%> förutsätter %<-fno-exceptions%>" #: toplev.cc:2026 #, gcc-internal-format @@ -35602,10 +35579,9 @@ msgid "unknown switch %<-mlong-double-%s%>" msgstr "okänd flagga %<-mlong-double-%s%>" #: common/config/rs6000/rs6000-common.cc:234 -#, fuzzy, gcc-internal-format -#| msgid "unknown switch %<-mlong-double-%s%>" +#, gcc-internal-format msgid "option %<%s%> requires %<-mlong-double-128%>" -msgstr "okänd flagga %<-mlong-double-%s%>" +msgstr "flaggan %<%s%> förutsätter %<-mlong-double-128%>" #: common/config/rs6000/rs6000-common.cc:268 #, gcc-internal-format @@ -35839,10 +35815,9 @@ msgid "embedded NUL in CFString literal" msgstr "inbäddad NUL i CFString-litteral" #: config/host-darwin.cc:107 -#, fuzzy, gcc-internal-format -#| msgid "PCH memory not available %m" +#, gcc-internal-format msgid "PCH memory is not available: %m" -msgstr "PCH-minne är inte tillgängligt %m" +msgstr "PCH-minne är inte tillgängligt: %m" #: config/sol2-c.cc:91 config/sol2-c.cc:107 #, gcc-internal-format @@ -36433,7 +36408,7 @@ msgstr "%qs är inte ett giltigt avstånd i %qs" #: config/aarch64/aarch64.cc:17580 #, gcc-internal-format msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>" -msgstr "" +msgstr "%<-fsanitize=shadow-call-stack%> kräver %<-ffixed-x18%>" #: config/aarch64/aarch64.cc:17670 #, gcc-internal-format @@ -36536,16 +36511,14 @@ msgid "missing name in %<target(\"arch=\")%> pragma or attribute" msgstr "namn saknas i pragmat eller attributet %<target(\"arch=\")%>" #: config/aarch64/aarch64.cc:18511 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"arch=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute" -msgstr "felaktigt namn (%qs) i pragmat eller attributet %<target(\"arch=\")%>" +msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"arch=\")%>" #: config/aarch64/aarch64.cc:18515 -#, fuzzy, gcc-internal-format -#| msgid "invalid feature modifier %s of value (%qs) in %<target()%> pragma or attribute" +#, gcc-internal-format msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute" -msgstr "felaktig funktionsmodifierare %s på värdet (%qs) i pragmat eller attributet %<target()%>" +msgstr "felaktig funktionsmodifierare %s på värdet %qs i pragmat eller attributet %<target()%>" #: config/aarch64/aarch64.cc:18550 #, gcc-internal-format @@ -36553,16 +36526,14 @@ msgid "missing name in %<target(\"cpu=\")%> pragma or attribute" msgstr "namn saknas i pragmat eller attributet %<target(\"cpu=\")%>" #: config/aarch64/aarch64.cc:18553 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"cpu=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute" -msgstr "felaktigt namn (%qs) i pragmat eller attributet %<target(\"cpu=\")%>" +msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"cpu=\")%>" #: config/aarch64/aarch64.cc:18557 config/aarch64/aarch64.cc:18664 -#, fuzzy, gcc-internal-format -#| msgid "invalid feature modifier %s of value (%qs) in %<target()%> pragma or attribute" +#, gcc-internal-format msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute" -msgstr "felaktig funktionsmodifierare %s på värdet (%qs) i pragmat eller attributet %<target()%>" +msgstr "felaktig funktionsmodifierare %s på värdet %qs i pragmat eller attributet %<target()%>" #: config/aarch64/aarch64.cc:18580 #, gcc-internal-format @@ -36570,16 +36541,14 @@ msgid "missing argument to %<target(\"branch-protection=\")%> pragma or attribut msgstr "argument saknas till pragmat eller attributet %<target(\"branch-protection=\")%>" #: config/aarch64/aarch64.cc:18584 -#, fuzzy, gcc-internal-format -#| msgid "invalid protection type (%qs) in %<target(\"branch-protection=\")%> pragma or attribute" +#, 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=\")%>" +msgstr "felaktig skyddstyp %qs i pragmat eller attributet %<target(\"branch-protection=\")%>" #: config/aarch64/aarch64.cc:18619 -#, fuzzy, gcc-internal-format -#| msgid "invalid name (%qs) in %<target(\"tune=\")%> pragma or attribute" +#, gcc-internal-format msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute" -msgstr "felaktigt namn (%qs) i pragmat eller attributet %<target(\"tune=\")%>" +msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"tune=\")%>" #: config/aarch64/aarch64.cc:18660 #, gcc-internal-format @@ -36640,10 +36609,8 @@ msgid "parameter passing for argument of type %qT when C++17 is enabled changed msgstr "parameterskickandet för argument av typen %qT när C++17 är aktiverat ändrades till att matcha C++14 %{i GCC 10.1%}" #: config/aarch64/aarch64.cc:20403 config/arm/arm.cc:6592 -#, fuzzy -#| msgid "parameter passing for argument of type %qT changed in GCC 9.1" msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}" -msgstr "parameterskickandet för argument av typen %qT ändrades i GCC 9.1" +msgstr "parameterskickandet för argument av typen %qT ändrades %{i GCC 12.1%}" #: config/aarch64/aarch64.cc:21552 config/aarch64/aarch64.cc:21555 #, gcc-internal-format @@ -37107,28 +37074,24 @@ msgid "the range of mask should be in 0 to 255" msgstr "intervallet för masken skall vara i 0 till 255" #: config/arm/arm-builtins.cc:3924 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 32; please check the intrinsic %<_mm_ror_pi16%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 32; please check the intrinsic %qs in code" -msgstr "intervallet för antal skall vara inom 0 till 32; kontrollera den inbyggda %<_mm_ror_pi16%> i koden" +msgstr "intervallet för antal skall vara inom 0 till 32; kontrollera den inbyggda %qs i koden" #: config/arm/arm-builtins.cc:3932 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_ror_si64%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 16; please check the intrinsic %qs in code" -msgstr "intervallet för antal skall vara inom 0 till 64; kontrollera den inbyggda %<_mm_ror_si64%> i koden" +msgstr "intervallet för antal skall vara inom 0 till 16; kontrollera den inbyggda %qs i koden" #: config/arm/arm-builtins.cc:3940 -#, fuzzy, gcc-internal-format -#| msgid "the range of count should be in 0 to 64; please check the intrinsic %<_mm_ror_si64%> in code" +#, gcc-internal-format msgid "the range of count should be in 0 to 64; please check the intrinsic %qs in code" -msgstr "intervallet för antal skall vara inom 0 till 64; kontrollera den inbyggda %<_mm_ror_si64%> i koden" +msgstr "intervallet för antal skall vara inom 0 till 64; kontrollera den inbyggda %qs i koden" #: config/arm/arm-builtins.cc:4003 -#, fuzzy, gcc-internal-format -#| msgid "the count should be no less than 0; please check the intrinsic %<_mm_srl_pi16%> in code" +#, gcc-internal-format msgid "the count should be no less than 0; please check the intrinsic %qs in code" -msgstr "antalet skall inte vara mindre än 0: kontrollera den inbyggda %<_mm_srl_pi16%> i koden" +msgstr "antalet skall inte vara mindre än 0: kontrollera den inbyggda %qs i koden" #: config/arm/arm-c.cc:108 #, gcc-internal-format @@ -37281,10 +37244,9 @@ msgid "selected fp16 options are incompatible" msgstr "valda fp16-alternativ är inkompatibla" #: config/arm/arm.cc:3883 -#, fuzzy, gcc-internal-format -#| msgid "%'-mstack-protector-guard=tls%' needs a hardware TLS register" +#, gcc-internal-format msgid "%<-mstack-protector-guard=tls%> needs a hardware TLS register" -msgstr "%'-mstack-protector-guard=tls%' behöver ett TLS-register i hårdvara" +msgstr "%<-mstack-protector-guard=tls%> behöver ett TLS-register i hårdvara" #: config/arm/arm.cc:3903 #, gcc-internal-format @@ -37771,10 +37733,9 @@ msgid "multiple function type attributes specified" msgstr "flera funktionstypsattribut angivna" #: config/bfin/bfin.cc:4766 -#, fuzzy, gcc-internal-format -#| msgid "cannott apply both longcall and shortcall attributes to the same function" +#, gcc-internal-format msgid "cannot apply both %<longcall%> and %<shortcall%> attributes to the same function" -msgstr "det går inte att tillämpa både attributet longcall och shortcall på samma funktion" +msgstr "det går inte att tillämpa både attributet %<longcall%> och %<shortcall%> på samma funktion" #: config/bpf/bpf.cc:111 #, gcc-internal-format @@ -38209,16 +38170,14 @@ msgid "%<-mn%> is not supported for linux targets" msgstr "%<-mn%> stödjs inte på linux-mål" #: config/i386/host-cygwin.cc:64 -#, fuzzy, gcc-internal-format -#| msgid "can%'t extend PCH file: %m" +#, gcc-internal-format msgid "cannot extend PCH file: %m" msgstr "det går inte att utöka PCH-fil: %m" #: config/i386/host-cygwin.cc:75 -#, fuzzy, gcc-internal-format -#| msgid "cannot get position in PCH file: %m" +#, gcc-internal-format msgid "cannot set position in PCH file: %m" -msgstr "kan inte avgöra position i PCH-fil: %m" +msgstr "kan inte sätta position i PCH-fil: %m" #: config/i386/i386-builtins.cc:2058 #, gcc-internal-format @@ -38560,16 +38519,14 @@ msgid "CPU you selected does not support x86-64 instruction set" msgstr "CPU:n du valde stödjer inte instruktionsuppsättningen x86-64" #: config/i386/i386-options.cc:2215 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<-march=%> switch" +#, gcc-internal-format msgid "bad value %qs for %<-march=%> switch" -msgstr "felaktigt värde (%qs) till flaggan %<-march=%>" +msgstr "felaktigt värde %qs till flaggan %<-march=%>" #: config/i386/i386-options.cc:2216 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<target(\"arch=\")%> attribute" +#, gcc-internal-format msgid "bad value %qs for %<target(\"arch=\")%> attribute" -msgstr "felaktigt värde (%qs) till attributet %<target(\"arch=\")%>" +msgstr "felaktigt värde %qs till attributet %<target(\"arch=\")%>" #: config/i386/i386-options.cc:2238 #, gcc-internal-format @@ -38592,16 +38549,14 @@ msgid "valid arguments to %<target(\"arch=\")%> attribute are: %s" msgstr "giltiga argument till attributet %<target(\"arch=\")%> är: %s" #: config/i386/i386-options.cc:2295 -#, fuzzy, gcc-internal-format -#| msgid "bad value %qs for %<-mtune%> switch" +#, gcc-internal-format msgid "bad value %qs for %<-mtune=%> switch" msgstr "felaktigt värde %qs till flaggan %<-mtune=%>" #: config/i386/i386-options.cc:2296 -#, fuzzy, gcc-internal-format -#| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute" +#, gcc-internal-format msgid "bad value %qs for %<target(\"tune=\")%> attribute" -msgstr "felaktigt värde (%qs) till attributet %<target(\"tune=\")%>" +msgstr "felaktigt värde %qs till attributet %<target(\"tune=\")%>" #: config/i386/i386-options.cc:2317 #, gcc-internal-format @@ -39041,16 +38996,14 @@ msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt servic msgstr "Dynamic Realign Argument Pointer (DRAP) stödjs inte i avbrottshanteringsrutiner. Detta kan gås runt genom att undvika funktioner med sammansatta returvärden." #: config/i386/i386.cc:9458 -#, fuzzy, gcc-internal-format -#| msgid "%qs attribute not supported in %<__builtin_has_attribute%>" +#, gcc-internal-format msgid "Stack realignment not supported with %<__builtin_eh_return%>" -msgstr "attributet %qs stödjs inte i %<__builtin_has_attribute%>" +msgstr "Stackomjustering stödjs inte med %<__builtin_eh_return%>" #: config/i386/i386.cc:9463 -#, fuzzy, gcc-internal-format -#| msgid "nested functions not supported on this target" +#, gcc-internal-format msgid "regparm nested function not supported with %<__builtin_eh_return%>" -msgstr "nästade funktioner stödjs inte på denna målarkitektur" +msgstr "regparm-nästade funktioner stödjs inte med %<__builtin_eh_return%>" #: config/i386/i386.cc:9849 #, gcc-internal-format @@ -39219,90 +39172,85 @@ msgid "%<PRINT_OPERAND%> null pointer" msgstr "%<PRINT_OPERAND%> null-pekare" #: config/loongarch/loongarch-cpu.cc:111 -#, fuzzy, gcc-internal-format -#| msgid "unknown core architecture %qs specified with %qs" +#, gcc-internal-format msgid "unknown base architecture %<0x%x%>, %qs failed" -msgstr "okänd kärnarkitektur %qs angiven till %qs" +msgstr "okänd basarkitektur %<0x%x%>, %qs misslyckades" #: config/loongarch/loongarch-cpu.cc:138 #, gcc-internal-format msgid "unknown FPU type %<0x%x%>, %qs failed" -msgstr "" +msgstr "okänd FPU-typ %<0x%x%>, %qs misslyckades" #: config/loongarch/loongarch-cpu.cc:189 #, gcc-internal-format msgid "unknown processor ID %<0x%x%>, some tuning parameters will fall back to default" -msgstr "" +msgstr "okänd processor-ID %<0x%x%>, några trimningsparametrar kommer återställas till standardvärden" #: config/loongarch/loongarch-opts.cc:196 #, gcc-internal-format msgid "%<-m%s%> overrides %<-m%s=%s%>, adjusting ABI to %qs" -msgstr "" +msgstr "%<-m%s%> åsidosätter %<-m%s=%s%>, justerar ABI:et till %qs" #: config/loongarch/loongarch-opts.cc:211 #, gcc-internal-format msgid "ABI changed (%qs to %qs) while multilib is disabled" -msgstr "" +msgstr "ABI:et ändrat (%qs till %qs) medans multilib är avaktiverat" #: config/loongarch/loongarch-opts.cc:233 #: config/loongarch/loongarch-opts.cc:238 -#, fuzzy, gcc-internal-format -#| msgid "%qE does not constrain a type" +#, gcc-internal-format msgid "%qs does not work on a cross compiler" -msgstr "%qE begränsar inte en typ" +msgstr "%qs fungerar inte med en korskompilator" #: config/loongarch/loongarch-opts.cc:278 -#, fuzzy, gcc-internal-format -#| msgid "the %qs architecture does not support %<-m%s=2008%>" +#, gcc-internal-format msgid "your native CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>" -msgstr "arkitekturen %qs stödjer inte %<-m%s=2008%>" +msgstr "din egna CPU-arkitektur (%qs) stödjer inte ABI:et %qs, återgår till %<-m%s=%s%>" #: config/loongarch/loongarch-opts.cc:283 -#, fuzzy, gcc-internal-format -#| msgid "the %qs architecture does not support %<-m%s=2008%>" +#, gcc-internal-format msgid "default CPU architecture (%qs) does not support %qs ABI, falling back to %<-m%s=%s%>" -msgstr "arkitekturen %qs stödjer inte %<-m%s=2008%>" +msgstr "standard-CPU-arkitekturen (%qs) stödjer inte ABI:et %qs, återgår till %<-m%s=%s%>" #: config/loongarch/loongarch-opts.cc:314 #, gcc-internal-format msgid "unable to implement ABI %qs with instruction set %qs" -msgstr "" +msgstr "kan inte implementera ABI %qs med instruktionsuppsättningen %qs" #: config/loongarch/loongarch-opts.cc:336 #, gcc-internal-format msgid "ABI %qs cannot be implemented due to limited instruction set %qs, falling back to %qs" -msgstr "" +msgstr "ABI %qs kan inte implementeras på grund av den begränsade instruktionsuppsättningen %qs, återgår till %qs" #: config/loongarch/loongarch-opts.cc:347 #, gcc-internal-format msgid "instruction set %qs cannot implement default ABI %qs, falling back to %qs" -msgstr "" +msgstr "instruktionsuppsättningen %qs kan inte implementera ABI %qs, återgår till %qs" #: config/loongarch/loongarch-opts.cc:352 #, gcc-internal-format msgid "no multilib-enabled ABI (%qs) can be implemented with instruction set %qs, falling back to %qs" -msgstr "" +msgstr "inget multilib-aktivt ABI (%qs) kan implementeras med instruktionsuppsättningen %qs, återgår till %qs" #: config/loongarch/loongarch-opts.cc:368 #, gcc-internal-format msgid "ABI %qs is not enabled at configure-time, the linker might report an error" -msgstr "" +msgstr "ABI %qs är aktiverades inte vid konfigurationstillfället, länkaren kan komma att rapportera ett fel" #: config/loongarch/loongarch-opts.cc:371 #, gcc-internal-format, gfc-internal-format msgid "ABI with startfiles: %s" -msgstr "" +msgstr "ABI med startfiler: %s" #: config/loongarch/loongarch.cc:3458 #, gcc-internal-format msgid "Normal symbol loading not implemented in extreme mode." -msgstr "" +msgstr "Normal symbolladdning är inte implementerad i extremt läge." #: config/loongarch/loongarch.cc:5507 -#, fuzzy, gcc-internal-format -#| msgid "code model %s does not support PIC mode" +#, gcc-internal-format msgid "code model %qs and %qs not support %s mode" -msgstr "kodmodellen %s stödjer inte PIC-läge" +msgstr "kodmodellerna %qs och %qs stödjer inte %s-läge" #: config/m32c/m32c-pragma.cc:54 #, gcc-internal-format @@ -39483,16 +39431,12 @@ msgid "argument to %qE attribute is not intstack" msgstr "argumentet till attributet %qE är inte intstack" #: config/mips/mips.cc:6089 -#, fuzzy -#| msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}" msgid "the ABI for passing a value containing zero-width fields before an adjacent 64-bit floating-point field was changed in GCC %{12.1%}" -msgstr "ABI:et för att skicka C-poster med bitfält med nollbredd har ändrats i GCC %{12.1%}" +msgstr "ABI:et för att skicka ett värde som innehåller fält med nollbredd före ett intillagandet 64-bitars flyttalsfält ändrades i GCC %{12.1%}" #: config/mips/mips.cc:6490 -#, fuzzy -#| msgid "ELFv2 parameter passing for an argument containing zero-width bit fields but that is otherwise a homogeneous aggregate was corrected in GCC 12" msgid "the ABI for returning a value containing zero-width bit-fields but otherwise an aggregate with only one or two floating-point fields was changed in GCC %{12.1%}" -msgstr "skickande av parametrar enligt ELFv2 för ett argument som innehåller bitfält med noll bredd men som i övrigt är ett homogent aggregat korrigerades i GCC 12" +msgstr "ABI:et för att returnera ett värde som innehåller bitfält med noll bredd men i övrigt ett aggregat med endast ett eller två flyttalsfält ändrades i GCC %{12.1%}" #: config/mips/mips.cc:7831 #, gcc-internal-format @@ -40383,10 +40327,9 @@ msgid "option %s is not supported together with %<-fopenacc%>" msgstr "flaggan %s stödjs inte tillsammans med %<-fopenacc%>" #: config/nvptx/nvptx.cc:326 -#, fuzzy, gcc-internal-format -#| msgid "PTX version (-mptx) needs to be at least %s to support selected -misa (sm_%s)" +#, gcc-internal-format msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)" -msgstr "PTX-version (-mptx) behöver vara åtminstone %s för att stödja -misa (sm_%s)" +msgstr "PTX-version (%<-mptx%>) behöver vara åtminstone %s för att stödja vald %<-misa%> (sm_%s)" #: config/nvptx/nvptx.cc:359 #, gcc-internal-format @@ -40439,16 +40382,14 @@ msgid "variable %qD adjusted for OpenACC privatization level: %qs" msgstr "variabeln %qD justerad för OpenACC privatiseringsnivå: %qs" #: config/nvptx/nvptx.cc:7455 -#, fuzzy, gcc-internal-format -#| msgid "alias definitions not supported in this configuration" +#, gcc-internal-format msgid "weak alias definitions not supported in this configuration" -msgstr "aliasdefinitioner stödjs inte i denna konfiguration" +msgstr "svaga aliasdefinitioner stödjs inte i denna konfiguration" #: config/nvptx/nvptx.cc:7468 -#, fuzzy, gcc-internal-format -#| msgid "alias definitions not supported in this configuration" +#, gcc-internal-format msgid "non-function alias definitions not supported in this configuration" -msgstr "aliasdefinitioner stödjs inte i denna konfiguration" +msgstr "aliasdefinitioner för annat än funktioner stödjs inte i denna konfiguration" #: config/or1k/or1k.cc:1311 #, gcc-internal-format, gfc-internal-format @@ -40782,10 +40723,9 @@ msgid "%qs requires %<long double%> to be IBM 128-bit format" msgstr "%qs kräver att %<long double%> är IBM:s 128-bitars format" #: config/rs6000/rs6000-builtin.cc:3429 -#, fuzzy, gcc-internal-format -#| msgid "%qs requires VSX support" +#, gcc-internal-format msgid "%qs requires %<__ibm128%> type support" -msgstr "%qs behöver VSX-stöd" +msgstr "%qs kräver %<__ibm128%>-typstöd" #: config/rs6000/rs6000-builtin.cc:3584 #, gcc-internal-format, gfc-internal-format @@ -40863,10 +40803,9 @@ msgid "%<vec_lvsr%> is deprecated for little endian; use assignment for unaligne msgstr "%<vec_lvsr%> bör undvikas för omvänd byteordning; använd tilldelning för ojusterade laddningar och lagringar" #: config/rs6000/rs6000-c.cc:1795 -#, fuzzy, gcc-internal-format -#| msgid "passing argument %d of %qE discards %qv qualifier from pointer target type" +#, gcc-internal-format msgid "passing argument %d of %qE discards %qs qualifier from pointer target type" -msgstr "att skicka argument %d till %qE kastar %qv-kvalificerare från pekarmåltyp" +msgstr "att skicka argument %d till %qE kastar %qs-kvalificerare från pekarmåltyp" #: config/rs6000/rs6000-c.cc:1881 config/rs6000/rs6000-c.cc:2037 #, gcc-internal-format @@ -41038,10 +40977,9 @@ msgid "%qs requires full ISA 3.0 support" msgstr "%qs behöver fullt ISA 3.0-stöd" #: config/rs6000/rs6000.cc:4348 -#, fuzzy, gcc-internal-format -#| msgid "Known vectorization library ABIs (for use with the -mveclibabi= option):" +#, gcc-internal-format msgid "unknown vectorization library ABI type in %<-mveclibabi=%s%>" -msgstr "Kända ABI:er till vektoriseringsbibliotek (att användas med flaggan -mveclibabi=):" +msgstr "okänd ABI-typ för vektoriseringsbibliotek i %<-mveclibabi=%s%>" #: config/rs6000/rs6000.cc:4361 config/rs6000/rs6000.cc:4376 #, gcc-internal-format @@ -41169,10 +41107,9 @@ msgid "multiple fast interrupt routines seen: %qE and %qE" msgstr "flera snabba avbrottsrutiner sedda: %qE och %qE" #: config/rx/rx.cc:2480 -#, fuzzy, gcc-internal-format -#| msgid "invalid control register for mvtc: %d - using 'psw'" +#, gcc-internal-format msgid "invalid control register %d for mvtc; using %<psw%>" -msgstr "felaktigt styrregister för mvtc: %d – använder ”psw”" +msgstr "felaktigt styrregister %d för mvtc; använder %<psw%>" #: config/rx/rx.cc:2602 #, gcc-internal-format @@ -41195,10 +41132,9 @@ msgid "RX FPU instructions do not support NaNs and infinities" msgstr "RX FPU-instruktioner stödjer inte NaN:er och oändligheter" #: config/s390/s390-c.cc:487 -#, fuzzy, gcc-internal-format -#| msgid "builtin vec_step can only be used on vector types." +#, gcc-internal-format msgid "builtin %qs can only be used on vector types" -msgstr "inbyggd vec_step kan endast användas på vektortyper." +msgstr "inbyggd %qs kan endast användas på vektortyper" #: config/s390/s390-c.cc:717 config/s390/s390.cc:922 #, gcc-internal-format @@ -41211,16 +41147,14 @@ msgid "valid values for builtin %qF argument %d are 64, 128, 256, 512, 1024, 204 msgstr "giltiga värden till inbyggd %qF argument %d är 64, 128, 256, 512, 1024, 2048 och 4096" #: config/s390/s390-c.cc:909 -#, fuzzy, gcc-internal-format -#| msgid "builtin %qF is for GCC internal use only." +#, gcc-internal-format msgid "builtin %qF is for GCC internal use only" -msgstr "inbyggd %qF är endast för GCC:s interna användning." +msgstr "inbyggd %qF är endast för GCC:s interna användning" #: config/s390/s390-c.cc:917 -#, fuzzy, gcc-internal-format -#| msgid "builtin %qF is deprecated." +#, gcc-internal-format msgid "builtin %qF is deprecated" -msgstr "inbyggd %qF bör undvikas." +msgstr "inbyggd %qF bör undvikas" #: config/s390/s390-c.cc:921 #, gcc-internal-format @@ -41263,10 +41197,9 @@ msgid "%qs matching variant requires z15 or higher" msgstr "%qs-matchning kräver z15 eller högre" #: config/s390/s390-c.cc:1025 -#, fuzzy, gcc-internal-format -#| msgid "%qs matching variant is deprecated." +#, gcc-internal-format msgid "%qs matching variant is deprecated" -msgstr "%qs-matchningsvariant bör undvikas." +msgstr "%qs-matchningsvariant bör undvikas" #: config/s390/s390-c.cc:1065 #, gcc-internal-format @@ -41279,40 +41212,34 @@ msgid "constant argument %d for builtin %qF is invalid (%s)" msgstr "det konstanta argumentet %d till den inbyggda %qF är ogiltigt (%s)" #: config/s390/s390.cc:769 -#, fuzzy, gcc-internal-format -#| msgid "constant argument %d for builtin %qF is out of range (0..%wu)" +#, gcc-internal-format msgid "constant argument %d for builtin %qF is out of range (0-%wu)" -msgstr "det konstanta argumentet %d till den inbyggda %qF ligger utanför intervallet (0..%wu)" +msgstr "det konstanta argumentet %d till den inbyggda %qF ligger utanför intervallet (0-%wu)" #: config/s390/s390.cc:785 -#, fuzzy, gcc-internal-format -#| msgid "constant argument %d for builtin %qF is out of range (%wd..%wd)" +#, gcc-internal-format msgid "constant argument %d for builtin %qF is out of range (%wd-%wd)" -msgstr "det konstanta argumentet %d till den inbyggda %qF ligger utanför intervallet (%wd..%wd)" +msgstr "det konstanta argumentet %d till den inbyggda %qF ligger utanför intervallet (%wd-%wd)" #: config/s390/s390.cc:834 -#, fuzzy, gcc-internal-format -#| msgid "builtin %qF is not supported without %<-mhtm%> (default with %<-march=zEC12%> and higher)." +#, gcc-internal-format msgid "builtin %qF is not supported without %<-mhtm%> (default with %<-march=zEC12%> and higher)" -msgstr "inbyggd %qF stödjs inte utan %<-mhtm%> (standard med %<-march=zEC12%> och högre)." +msgstr "inbyggd %qF stödjs inte utan %<-mhtm%> (standard med %<-march=zEC12%> och högre)" #: config/s390/s390.cc:840 -#, fuzzy, gcc-internal-format -#| msgid "builtin %qF requires %<-mvx%> (default with %<-march=z13%> and higher)." +#, gcc-internal-format msgid "builtin %qF requires %<-mvx%> (default with %<-march=z13%> and higher)" -msgstr "inbyggd %qF behöver %<-mvx%> (standard med %<-march=z13%> och högre)." +msgstr "inbyggd %qF behöver %<-mvx%> (standard med %<-march=z13%> och högre)" #: config/s390/s390.cc:847 -#, fuzzy, gcc-internal-format -#| msgid "Builtin %qF requires z14 or higher." +#, gcc-internal-format msgid "Builtin %qF requires z14 or higher" -msgstr "Inbyggd %qF kräver z14 eller högre." +msgstr "Inbyggd %qF kräver z14 eller högre" #: config/s390/s390.cc:853 -#, fuzzy, gcc-internal-format -#| msgid "Builtin %qF requires z15 or higher." +#, gcc-internal-format msgid "Builtin %qF requires z15 or higher" -msgstr "Inbyggd %qF kräver z15 eller högre." +msgstr "Inbyggd %qF kräver z15 eller högre" #: config/s390/s390.cc:859 #, gcc-internal-format @@ -41351,16 +41278,14 @@ msgid "total size of local variables exceeds architecture limit" msgstr "totala storleken på lokala variabler överskrider arkitekturens gräns" #: config/s390/s390.cc:11465 -#, fuzzy, gcc-internal-format -#| msgid "frame size of function %qs is %wd bytes exceeding user provided stack limit of %d bytes. An unconditional trap is added." +#, gcc-internal-format msgid "frame size of function %qs is %wd bytes exceeding user provided stack limit of %d bytes; an unconditional trap is added" -msgstr "ramstorleken för funktionen %qs är %wd byte vilket överskrider användarens valda stackgräns på %d byte. En ovillkorlig fälla läggs till." +msgstr "ramstorleken för funktionen %qs är %wd byte vilket överskrider användarens valda stackgräns på %d byte; en ovillkorlig fälla läggs till" #: config/s390/s390.cc:11481 -#, fuzzy, gcc-internal-format -#| msgid "frame size of function %qs is %wd bytes which is more than half the stack size. The dynamic check would not be reliable. No check emitted for this function." +#, gcc-internal-format msgid "frame size of function %qs is %wd bytes which is more than half the stack size; the dynamic check would not be reliable; no check emitted for this function" -msgstr "ramstorleken för funktionen %qs är %wd byte vilket är mer än hälften av stackstorleken. Den dynamiska kontrollen skulle inte vara pålitlig. Ingen kontroll läggs ut för denna funktion." +msgstr "ramstorleken för funktionen %qs är %wd byte vilket är mer än hälften av stackstorleken; den dynamiska kontrollen skulle inte vara pålitlig. Ingen kontroll läggs ut för denna funktion" #: config/s390/s390.cc:11509 #, gcc-internal-format @@ -41398,20 +41323,17 @@ msgid "hardware vector support not available with %<-msoft-float%>" msgstr "stöd för hårdvaruvektorer är inte tillgängligt med %<-msoft-float%>" #: config/s390/s390.cc:15560 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "hardware decimal floating point instructions not available on %s" +#, gcc-internal-format, gfc-internal-format msgid "hardware decimal floating-point instructions not available on %s" msgstr "hårdvaruinstruktioner för decimala flyttal är inte tillgängliga på %s" #: config/s390/s390.cc:15564 -#, fuzzy, gcc-internal-format -#| msgid "hardware decimal floating point instructions not available in ESA/390 mode" +#, gcc-internal-format msgid "hardware decimal floating-point instructions not available in ESA/390 mode" msgstr "hårdvaruinstruktioner för decimalflyttal är inte tillgängliga i läget ESA/390" #: config/s390/s390.cc:15576 -#, fuzzy, gcc-internal-format -#| msgid "%<-mhard-dfp%> can%'t be used in conjunction with %<-msoft-float%>" +#, gcc-internal-format msgid "%<-mhard-dfp%> cannot be used in conjunction with %<-msoft-float%>" msgstr "%<-mhard-dfp%> kan inte användas tillsammans med %<-msoft-float%>" @@ -41436,28 +41358,24 @@ msgid "%<-mstack-guard%> implies use of %<-mstack-size%>" msgstr "%<-mstack-guard%> implicerar användning av %<-mstack-size%>" #: config/s390/s390.cc:15609 -#, fuzzy, gcc-internal-format -#| msgid "-mtpf-trace-hook-prologue-check requires integer in range 0..4095" +#, gcc-internal-format msgid "%<-mtpf-trace-hook-prologue-check%> requires integer in range 0-4095" -msgstr "-mtpf-trace-hook-prologue-check behöver ett heltal i intervallet 0..4095" +msgstr "%<-mtpf-trace-hook-prologue-check%> behöver ett heltal i intervallet 0-4095" #: config/s390/s390.cc:15612 -#, fuzzy, gcc-internal-format -#| msgid "-mtpf-trace-hook-prologue-target requires integer in range 0..4095" +#, gcc-internal-format msgid "%<-mtpf-trace-hook-prologue-target%> requires integer in range 0-4095" -msgstr "-mtpf-trace-hook-prologue-target behöver ett heltal i intervallet 0..4095" +msgstr "%<-mtpf-trace-hook-prologue-target%> behöver ett heltal i intervallet 0-4095" #: config/s390/s390.cc:15615 -#, fuzzy, gcc-internal-format -#| msgid "-mtpf-trace-hook-epilogue-check requires integer in range 0..4095" +#, gcc-internal-format msgid "%<-mtpf-trace-hook-epilogue-check%> requires integer in range 0-4095" -msgstr "-mtpf-trace-hook-epilogue-check behöver ett heltal i intervallet 0..4095" +msgstr "%<-mtpf-trace-hook-epilogue-check%> behöver ett heltal i intervallet 0-4095" #: config/s390/s390.cc:15618 -#, fuzzy, gcc-internal-format -#| msgid "-mtpf-trace-hook-epilogue-target requires integer in range 0..4095" +#, gcc-internal-format msgid "%<-mtpf-trace-hook-epilogue-target%> requires integer in range 0-4095" -msgstr "-mtpf-trace-hook-epilogue-target behöver ett heltal i intervallet 0..4095" +msgstr "%<-mtpf-trace-hook-epilogue-target%> behöver ett heltal i intervallet 0-4095" #: config/s390/s390.cc:15671 #, gcc-internal-format @@ -41482,10 +41400,9 @@ msgstr "%<-mno-pic-data-is-text-relative%> kan inte användas utan %<-fpic%>/%<- #: config/s390/s390.cc:15906 config/s390/s390.cc:15956 #: config/s390/s390.cc:15973 -#, fuzzy, gcc-internal-format -#| msgid "attribute %qs argument %qs is unknown" +#, gcc-internal-format msgid "attribute %<target%> argument %qs is unknown" -msgstr "argument %2$qs till attribut %1$qs är okänt" +msgstr "argument %qs till attribut %<target%> är okänt" #. Value is not allowed for the target attribute. #: config/s390/s390.cc:15912 @@ -41559,16 +41476,14 @@ msgid "local variable memory requirements exceed capacity" msgstr "behovet av minne för lokala variabler överskrider kapaciteten" #: config/stormy16/stormy16.cc:1215 -#, fuzzy, gcc-internal-format -#| msgid "function_profiler support" +#, gcc-internal-format msgid "%<function_profiler%> support" -msgstr "stöd för function_profiler" +msgstr "stöd för %<function_profiler%>" #: config/stormy16/stormy16.cc:1309 -#, fuzzy, gcc-internal-format -#| msgid "cannot use va_start in interrupt function" +#, gcc-internal-format msgid "cannot use %<va_start%> in interrupt function" -msgstr "det går inte använda va_start i en avbrottsfunktion" +msgstr "det går inte använda %<va_start%> i en avbrottsfunktion" #: config/stormy16/stormy16.cc:1880 #, gcc-internal-format, gfc-internal-format @@ -41581,10 +41496,9 @@ msgid "%<__BELOW100__%> attribute only applies to variables" msgstr "attributet %<__BELOW100__%> är bara tillämpbart på variabler" #: config/stormy16/stormy16.cc:2259 -#, fuzzy, gcc-internal-format -#| msgid "__BELOW100__ attribute not allowed with auto storage class" +#, gcc-internal-format msgid "%<__BELOW100__%> attribute not allowed with auto storage class" -msgstr "attributet __BELOW100__ är inte tillåtet med lagringsklassen auto" +msgstr "attributet %<__BELOW100__%> är inte tillåtet med lagringsklassen auto" #: config/tilegx/tilegx.cc:3581 config/tilepro/tilepro.cc:3129 #, gcc-internal-format @@ -41592,16 +41506,14 @@ msgid "operand must be an immediate of the right size" msgstr "operanden måste vara en omedelbar av rätt storlek" #: config/v850/v850-c.cc:67 -#, fuzzy, gcc-internal-format -#| msgid "#pragma GHS endXXXX found without previous startXXX" +#, gcc-internal-format msgid "%<#pragma%> GHS endXXX found without previous startXXX" -msgstr "#pragma GHS endXXXX funnet utan föregående startXXX" +msgstr "%<#pragma%> GHS endXXXX funnet utan föregående startXXX" #: config/v850/v850-c.cc:70 -#, fuzzy, gcc-internal-format -#| msgid "#pragma GHS endXXX does not match previous startXXX" +#, gcc-internal-format msgid "%<#pragma%> GHS endXXX does not match previous startXXX" -msgstr "#pragma GHS endXXX stämmer inte med föregående startXXX" +msgstr "%<#pragma%> GHS endXXX stämmer inte med föregående startXXX" #: config/v850/v850-c.cc:96 #, gcc-internal-format @@ -41614,10 +41526,9 @@ msgid "cannot set interrupt attribute: no such identifier" msgstr "det går inte att sätta avbrottsattribut: det finns ingen sådan identifierare" #: config/v850/v850-c.cc:153 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs section" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs section" -msgstr "skräp vid slutet av #pragma ghs-sektion" +msgstr "skräp vid slutet av %<#pragma%> ghs-sektion" #: config/v850/v850-c.cc:170 #, gcc-internal-format @@ -41625,52 +41536,44 @@ msgid "unrecognized section name %qE" msgstr "okänt sektionsnamn %qE" #: config/v850/v850-c.cc:184 -#, fuzzy, gcc-internal-format -#| msgid "malformed #pragma ghs section" +#, gcc-internal-format msgid "malformed %<#pragma%> ghs section" -msgstr "felformaterat #pragma ghs section" +msgstr "felformaterat %<#pragma%> ghs section" #: config/v850/v850-c.cc:203 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs interrupt" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs interrupt" -msgstr "skräp vid slutet av #pragma ghs interrupt" +msgstr "skräp vid slutet av %<#pragma%> ghs interrupt" #: config/v850/v850-c.cc:214 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs starttda" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs starttda" -msgstr "skräp vid slutet av #pragma ghs starttda" +msgstr "skräp vid slutet av %<#pragma%> ghs starttda" #: config/v850/v850-c.cc:225 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs startsda" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs startsda" -msgstr "skräp vid slutet av #pragma ghs startsda" +msgstr "skräp vid slutet av %<#pragma%> ghs startsda" #: config/v850/v850-c.cc:236 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs startzda" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs startzda" -msgstr "skräp vid slutet av #pragma ghs startzda" +msgstr "skräp vid slutet av %<#pragma%> ghs startzda" #: config/v850/v850-c.cc:247 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs endtda" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs endtda" -msgstr "skräp vid slutet av #pragma ghs endtda" +msgstr "skräp vid slutet av %<#pragma%> ghs endtda" #: config/v850/v850-c.cc:258 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs endsda" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs endsda" -msgstr "skräp vid slutet av #pragma ghs endsda" +msgstr "skräp vid slutet av %<#pragma%> ghs endsda" #: config/v850/v850-c.cc:269 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma ghs endzda" +#, gcc-internal-format msgid "junk at end of %<#pragma%> ghs endzda" -msgstr "skräp vid slutet av #pragma ghs endzda" +msgstr "skräp vid slutet av %<#pragma%> ghs endzda" #: config/v850/v850.cc:2046 #, gcc-internal-format @@ -41725,16 +41628,14 @@ msgid "an interrupt handler cannot be compiled with %<-muser-mode%>" msgstr "en avbrottshanterare kan inte kompileras med %<-muser-mode%>" #: config/vms/vms-c.cc:44 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma __nostandard" +#, gcc-internal-format msgid "junk at end of %<#pragma __nostandard%>" -msgstr "skräp vid slutet av #pragma __nostandard" +msgstr "skräp vid slutet av %<#pragma __nostandard%>" #: config/vms/vms-c.cc:55 -#, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma __standard" +#, gcc-internal-format msgid "junk at end of %<#pragma __standard%>" -msgstr "skräp vid slutet av #pragma __standard" +msgstr "skräp vid slutet av %<#pragma __standard%>" #: config/vms/vms-c.cc:81 #, gcc-internal-format @@ -41788,10 +41689,9 @@ msgid "vms '#pragma __message' is ignored" msgstr "vms ”#pragma __message” ignoreras" #: config/vms/vms-c.cc:274 config/vms/vms-c.cc:280 -#, fuzzy, gcc-internal-format -#| msgid "malformed '#pragma __extern_prefix', ignoring" +#, gcc-internal-format msgid "malformed %<#pragma __extern_prefix%>, ignoring" -msgstr "felformaterat ”#pragma __extern_prefix”, ignorerar" +msgstr "felformaterat %<#pragma __extern_prefix%>, ignorerar" #: config/vms/vms-c.cc:313 config/vms/vms-c.cc:333 #, gcc-internal-format @@ -41819,10 +41719,9 @@ msgid "PIC is required but not supported with CONST16 instructions" msgstr "PIC krävs men stödjs inte med CONST16-instruktioner" #: config/xtensa/xtensa.cc:3664 -#, fuzzy, gcc-internal-format -#| msgid "only uninitialized variables can be placed in a .bss section" +#, gcc-internal-format msgid "only uninitialized variables can be placed in a %<.bss%> section" -msgstr "endast oinitierade variabler kan placeras i en .bss-sektion" +msgstr "endast oinitierade variabler kan placeras i en %<.bss%>-sektion" # Vissa felmeddelanden är roligare än andra! :-) #: ada/gcc-interface/misc.cc:155 @@ -41836,10 +41735,9 @@ msgid "%<-fexcess-precision=standard%> for Ada" msgstr "%<-fexcess-precision=standard%> för Ada" #: ada/gcc-interface/misc.cc:260 -#, fuzzy, gcc-internal-format -#| msgid "%<-fexcess-precision=standard%> for Ada" +#, gcc-internal-format msgid "%<-fexcess-precision=16%> for Ada" -msgstr "%<-fexcess-precision=standard%> för Ada" +msgstr "%<-fexcess-precision=16%> för Ada" #: ada/gcc-interface/trans.cc:332 #, gcc-internal-format, gfc-internal-format @@ -43241,10 +43139,9 @@ msgid "type %qT is too large" msgstr "typen %qT är för stor" #: c/c-decl.cc:8903 -#, fuzzy, gcc-internal-format -#| msgid "reverse scalar storage order" +#, gcc-internal-format msgid "type punning toggles scalar storage order" -msgstr "omvänd lagringsordning för skalärer" +msgstr "typstampning byter lagringsordning för skalärer" #: c/c-decl.cc:8970 #, gcc-internal-format @@ -44735,10 +44632,9 @@ msgid "expected %<none%> or %<present%>" msgstr "%<none%> eller %<present%> förväntades" #: c/c-parser.cc:13571 cp/parser.cc:37323 -#, fuzzy, gcc-internal-format -#| msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>" +#, gcc-internal-format msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>" -msgstr "%<simd%>, %<reduction%>, %<target%> eller %<variant%> förväntades" +msgstr "%<none%>, %<shared%>, %<private%> eller %<firstprivate%> förväntades" #: c/c-parser.cc:13692 cp/parser.cc:37435 #, gcc-internal-format @@ -44851,10 +44747,9 @@ msgid "%<tile%> argument needs positive integral constant" msgstr "argumentet till %<tile%> behöver en positiv heltalskonstant" #: c/c-parser.cc:14735 cp/parser.cc:38006 -#, fuzzy, gcc-internal-format -#| msgid "expected %<none%> or %<shared%>" +#, gcc-internal-format msgid "expected %<reproducible%> or %<unconstrained%>" -msgstr "%<none%> eller %<shared%> förväntades" +msgstr "%<reproducible%> eller %<unconstrained%> förväntades" #: c/c-parser.cc:14744 c/c-parser.cc:14750 cp/parser.cc:38015 #: cp/parser.cc:38025 @@ -44923,16 +44818,14 @@ msgid "%<aligned%> clause alignment expression must be positive constant integer msgstr "%<aligned%>-klausulens justeringsuttryck måste vara ett positivt konstant heltalsuttryck" #: c/c-parser.cc:15535 -#, fuzzy, gcc-internal-format -#| msgid "expected %<allocator%>" +#, gcc-internal-format msgid "expected %<allocator%> or %<align%>" -msgstr "%<allocator%> förväntades" +msgstr "%<allocator%> eller %<align%> förväntades" #: c/c-parser.cc:15542 -#, fuzzy, gcc-internal-format -#| msgid "duplicate %qs" +#, gcc-internal-format msgid "duplicate %qs modifier" -msgstr "dubblerad %qs" +msgstr "dubblerad %qs-modifierare" #: c/c-parser.cc:15590 cp/semantics.cc:7729 #, gcc-internal-format @@ -44940,10 +44833,9 @@ msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_a msgstr "%<allocate%>-klausulens allokeraruttryck har typen %qT istället för %<omp_allocator_handle_t%>" #: c/c-parser.cc:15601 cp/semantics.cc:7684 cp/semantics.cc:7700 -#, fuzzy, gcc-internal-format -#| msgid "%<aligned%> clause alignment expression must be positive constant integer expression" +#, gcc-internal-format msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression" -msgstr "%<aligned%>-klausulens justeringsuttryck måste vara ett positivt konstant heltalsuttryck" +msgstr "argumentet till modifieraren %<align%> av klausulen %<allocate%> argument måste vara ett positivt konstant heltalsuttryck som är en exponent av två" #: c/c-parser.cc:15677 #, gcc-internal-format @@ -44972,22 +44864,19 @@ msgid "invalid depend kind" msgstr "ogiltig depend-sort" #: c/c-parser.cc:16214 cp/parser.cc:39416 -#, fuzzy, gcc-internal-format -#| msgid "too many %<if%> clauses with %qs modifier" +#, gcc-internal-format msgid "too many %<always%> modifiers" -msgstr "för många %<if%>-klausuler med %qs-modifierare" +msgstr "för många %<always%>-modifierare" #: c/c-parser.cc:16224 cp/parser.cc:39429 -#, fuzzy, gcc-internal-format -#| msgid "too many %<if%> clauses with %qs modifier" +#, gcc-internal-format msgid "too many %<close%> modifiers" -msgstr "för många %<if%>-klausuler med %qs-modifierare" +msgstr "för många %<close%>-modifierare" #: c/c-parser.cc:16232 cp/parser.cc:39440 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp target enter data%> with map-type other than %<to%> or %<alloc%> on %<map%> clause" +#, gcc-internal-format msgid "%<#pragma omp target%> with modifier other than %<always%> or %<close%> on %<map%> clause" -msgstr "%<#pragma omp target enter data%> med en annan map-typ än %<to%> eller %<alloc%> på %<map%>-klausul" +msgstr "%<#pragma omp target%> med en annan modifierare än en %<always%>- eller %<close%>- eller %<map%>-klausul" #: c/c-parser.cc:16260 cp/parser.cc:39471 #, gcc-internal-format @@ -45000,16 +44889,14 @@ msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with msgstr "%<ancestor%>-enhetsmodifierare som inte föregås av ett %<requires%>-direktiv med en klausul %<reverse_offload%>" #: c/c-parser.cc:16324 cp/parser.cc:39541 -#, fuzzy, gcc-internal-format -#| msgid "expected %<none%> or %<present%>" +#, gcc-internal-format msgid "expected %<ancestor%> or %<device_num%>" -msgstr "%<none%> eller %<present%> förväntades" +msgstr "%<ancestor%> eller %<device_num%> förväntades" #: c/c-parser.cc:16347 cp/semantics.cc:7491 -#, fuzzy, gcc-internal-format -#| msgid "%<linear%> clause step expression must be integral" +#, gcc-internal-format msgid "the %<device%> clause expression must evaluate to %<1%>" -msgstr "%<linear%>-klausulens steguttryck måste vara heltal" +msgstr "%<device%>-klausulens uttryck måste beräknas till %<1%>" #: c/c-parser.cc:16380 cp/parser.cc:39612 #, gcc-internal-format @@ -45168,16 +45055,14 @@ msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause" msgstr "%<read%>-, %<write%>-, %<update%>- eller %<capture%>-klausul förväntades" #: c/c-parser.cc:18123 cp/parser.cc:40637 -#, fuzzy, gcc-internal-format -#| msgid "expected %<seq_cst%>, %<relaxed%> or %<acq_rel%>" +#, gcc-internal-format msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>" -msgstr "%<seq_cst%>, %<relaxed%> eller %<acq_rel%> förväntades" +msgstr "%<seq_cst%>, %<acquire%> eller %<relaxed%> förväntades" #: c/c-parser.cc:18147 cp/parser.cc:40666 -#, fuzzy, gcc-internal-format -#| msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause" +#, gcc-internal-format msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause" -msgstr "%<read%>-, %<write%>-, %<update%>-, %<capture%>-, %<seq_cst%>-, %<acq_rel%>-, %<release%>-, %<relaxed%>- eller %<hint%>-klausul förväntades" +msgstr "%<read%>-, %<write%>-, %<update%>-, %<capture%>-, %<compare%>-, %<weak%>-, %<fail%>-, %<seq_cst%>-, %<acq_rel%>-, %<release%>-, %<relaxed%>- eller %<hint%>-klausul förväntades" #: c/c-parser.cc:18162 cp/parser.cc:40681 #, gcc-internal-format @@ -45191,35 +45076,30 @@ msgstr "för många minnesordningsklausuler" #: c/c-parser.cc:18207 c/c-parser.cc:18214 cp/parser.cc:40726 #: cp/parser.cc:40733 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp atomic write%> incompatible with %<acq_rel%> or %<acquire%> clauses" +#, gcc-internal-format msgid "%qs clause is incompatible with %<read%> or %<write%> clauses" -msgstr "%<#pragma omp atomic write%> är inkompatibel med en %<acq_rel%>- eller %<acquire%>-klausul" +msgstr "en %qs-klausul är inkompatibel med en %<read%>- eller %<write%>-klausul" #: c/c-parser.cc:18220 c/c-parser.cc:18225 cp/parser.cc:40739 #: cp/parser.cc:40744 -#, fuzzy, gcc-internal-format -#| msgid "%qs requires %qs" +#, gcc-internal-format msgid "%qs clause requires %qs clause" -msgstr "%qs behöver %qs" +msgstr "en %qs-klausul behöver en %qs-klausul" #: c/c-parser.cc:18269 cp/parser.cc:40788 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp atomic read%> incompatible with %<acq_rel%> or %<release%> clauses" +#, gcc-internal-format msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause" -msgstr "%<#pragma omp atomic read%> är inkompatibel med en %<acq_rel%>- eller %<release%>-klausul" +msgstr "%<#pragma omp atomic read%> är inkompatibelt med en %<release%>-klausul" #: c/c-parser.cc:18279 cp/parser.cc:40798 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp atomic write%> incompatible with %<acq_rel%> or %<acquire%> clauses" +#, gcc-internal-format msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause" -msgstr "%<#pragma omp atomic write%> är inkompatibel med en %<acq_rel%>- eller %<acquire%>-klausul" +msgstr "%<#pragma omp atomic write%> är inkompatibelt en %<acquire%>-klausul" #: c/c-parser.cc:18402 cp/parser.cc:40898 -#, fuzzy, gcc-internal-format -#| msgid "expected %<;%> after union definition" +#, gcc-internal-format msgid "expected %<==%> comparison in %<if%> condition" -msgstr "%<;%> förväntades efter uniondefinition" +msgstr "en %<==%>-jämförelse förväntades i ett %<if%>-villkor" #: c/c-parser.cc:18409 cp/parser.cc:40905 #, gcc-internal-format @@ -45228,22 +45108,19 @@ msgstr "jämförelse med %<==%>, %<<%> eller %<>%> förväntades i %<if%>-villko #: c/c-parser.cc:18482 cp/parser.cc:40970 cp/parser.cc:41251 #: cp/parser.cc:41345 cp/parser.cc:41363 -#, fuzzy, gcc-internal-format -#| msgid "invalid form of %<#pragma omp atomic%>" +#, gcc-internal-format msgid "invalid form of %<#pragma omp atomic compare%>" -msgstr "ogiltig form på %<#pragma omp atomic%>" +msgstr "ogiltig form på %<#pragma omp atomic compare%>" #: c/c-parser.cc:18493 cp/parser.cc:40981 -#, fuzzy, gcc-internal-format -#| msgid "expected %<delete%>" +#, gcc-internal-format msgid "unexpected %<else%>" -msgstr "%<delete%> förväntades" +msgstr "oväntat %<else%>" #: c/c-parser.cc:18553 cp/parser.cc:41418 -#, fuzzy, gcc-internal-format -#| msgid "invalid form of %<#pragma omp atomic%>" +#, gcc-internal-format msgid "invalid form of %<pragma omp atomic compare%>" -msgstr "ogiltig form på %<#pragma omp atomic%>" +msgstr "ogiltig form på %<pragma omp atomic compare%>" #: c/c-parser.cc:18825 cp/parser.cc:41272 cp/parser.cc:41298 #, gcc-internal-format @@ -45281,10 +45158,9 @@ msgid "expected %<depend%>, %<destroy%> or %<update%> clause" msgstr "%<depend%>-, %<destroy%>- eller %<update%>-klausul förväntades" #: c/c-parser.cc:19093 cp/parser.cc:41629 -#, fuzzy, gcc-internal-format -#| msgid "expected %<acq_rel%>, %<release%> or %<acquire%>" +#, gcc-internal-format msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>" -msgstr "%<acq_rel%>, %<release%> eller %<acquire%> förväntades" +msgstr "%<seq_cst%>, %<acq_rel%>, %<release%> eller %<acquire%> förväntades" #: c/c-parser.cc:19101 cp/parser.cc:41637 #, gcc-internal-format @@ -45617,34 +45493,29 @@ msgid "variable sized type %qT in %<reduction%> clause" msgstr "typen %qT med variabel storlek i-%<reduction%>-klausul" #: c/c-parser.cc:22846 cp/parser.cc:46656 -#, fuzzy, gcc-internal-format -#| msgid "expected %<depend%>, %<destroy%> or %<update%> clause" +#, gcc-internal-format msgid "expected %<at%>, %<severity%> or %<message%> clause" -msgstr "%<depend%>-, %<destroy%>- eller %<update%>-klausul förväntades" +msgstr "%<at%>-, %<severity%>- eller %<message%>-klausul förväntades" #: c/c-parser.cc:22879 cp/parser.cc:46691 -#, fuzzy, gcc-internal-format -#| msgid "expected %<,%> or %<)%>" +#, gcc-internal-format msgid "expected %qs or %qs" -msgstr "%<,%> eller %<)%> förväntades" +msgstr "%qs eller %qs förväntades" #: c/c-parser.cc:22936 cp/parser.cc:46753 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements" +#, gcc-internal-format msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements" -msgstr "%<#pragma omp ordered%> med %<depend%>-klausul får bara användas i sammansatta satser" +msgstr "%<#pragma omp error%> med %<at(execution)%>-klausul får bara användas i sammansatta satser" #: c/c-parser.cc:22959 cp/parser.cc:46780 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp allocate%> not yet supported" +#, gcc-internal-format msgid "%<pragma omp error%> encountered: %s" -msgstr "%<#pragma omp allocate%> stödjs inte ännu" +msgstr "%<#pragma omp error%> påträffat: %s" #: c/c-parser.cc:22962 cp/parser.cc:46783 -#, fuzzy, gcc-internal-format -#| msgid "%<#pragma omp allocate%> not yet supported" +#, gcc-internal-format msgid "%<pragma omp error%> encountered" -msgstr "%<#pragma omp allocate%> stödjs inte ännu" +msgstr "%<#pragma omp errof%> påträffat" #: c/c-parser.cc:23109 cp/semantics.cc:9229 #, gcc-internal-format @@ -45748,10 +45619,9 @@ msgid "cannot mix operands of decimal floating and other floating types" msgstr "det går inte att blanda operander av typerna decimalt flyttal och annat flyttal" #: c/c-typeck.cc:1332 -#, fuzzy, gcc-internal-format -#| msgid "pointers to arrays with different qualifiers are incompatible in ISO C" +#, gcc-internal-format msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C2X" -msgstr "pekare till vektorer med olika kvalificerare är inkompatibla i ISO C" +msgstr "otillåten användning av pekare till vektorer med olika kvalificerare i ISO C före C2X" #: c/c-typeck.cc:1336 #, gcc-internal-format @@ -46132,10 +46002,9 @@ msgid "pointer to array loses qualifier in conditional expression" msgstr "pekare till vektor tappar kvalificerare i villkorsuttryck" #: c/c-typeck.cc:5453 -#, fuzzy, gcc-internal-format -#| msgid "pointer to array loses qualifier in conditional expression" +#, gcc-internal-format msgid "pointer to array loses qualifier in conditional expression in ISO C before C2X" -msgstr "pekare till vektor tappar kvalificerare i villkorsuttryck" +msgstr "pekare till vektor tappar kvalificerare i villkorsuttryck i ISO C före C2X" #: c/c-typeck.cc:5458 #, gcc-internal-format @@ -46795,10 +46664,9 @@ msgid "ISO C forbids %<goto *expr;%>" msgstr "ISO C förbjuder %<goto *expr;%>" #: c/c-typeck.cc:10830 -#, fuzzy, gcc-internal-format -#| msgid "argument %d of %qE must be a pointer type" +#, gcc-internal-format msgid "computed goto must be pointer type" -msgstr "argument %d till %qE måste vara en pekartyp" +msgstr "beräknat goto måste vara en pekartyp" #: c/c-typeck.cc:10859 c/gimple-parser.cc:2456 cp/typeck.cc:10441 #, gcc-internal-format @@ -46882,28 +46750,24 @@ msgid "expression statement has incomplete type" msgstr "uttryckssats har ofullständig typ" #: c/c-typeck.cc:11626 -#, fuzzy, gcc-internal-format -#| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL" +#, gcc-internal-format msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL" -msgstr "jämförelsen kommer alltid beräknas till %<false%> för adressen till %qD kommer aldrig att vara NULL" +msgstr "Jämförelsen Kommer Alltid Beräknas Till %<False%> För att pekaroperanden i %qE inte får vara NULL" #: c/c-typeck.cc:11631 -#, fuzzy, gcc-internal-format -#| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL" +#, gcc-internal-format msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL" -msgstr "jämförelsen kommer alltid beräknas till %<true%> för adressen till %qD kommer aldrig att vara NULL" +msgstr "jämförelsen kommer alltid beräknas till %<true%> för att pekaroperanden i %qE inte får vara NULL" #: c/c-typeck.cc:11649 c/c-typeck.cc:11686 -#, fuzzy, gcc-internal-format -#| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL" +#, gcc-internal-format msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL" -msgstr "jämförelsen kommer alltid beräknas till %<false%> för adressen till %qD kommer aldrig att vara NULL" +msgstr "jämförelsen kommer alltid beräknas till %<false%> för att adressen till %qE aldrig kommer att vara NULL" #: c/c-typeck.cc:11654 c/c-typeck.cc:11691 -#, fuzzy, gcc-internal-format -#| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL" +#, gcc-internal-format msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL" -msgstr "jämförelsen kommer alltid beräknas till %<true%> för adressen till %qD kommer aldrig att vara NULL" +msgstr "jämförelsen kommer alltid beräknas till %<true%> för att adressen till %qE aldrig kommer att vara NULL" #: c/c-typeck.cc:12277 c/c-typeck.cc:12413 cp/typeck.cc:5742 #, gcc-internal-format @@ -47263,10 +47127,9 @@ msgid "%qE is not a variable in clause %qs" msgstr "%qE är inte en variabel i klausul %qs" #: c/c-typeck.cc:14554 cp/semantics.cc:6977 -#, fuzzy, gcc-internal-format -#| msgid "%qD appears more than once in data clauses" +#, gcc-internal-format msgid "%qD appears more than once in data-sharing clauses" -msgstr "%qD förekommer mer än en gång i dataklausuler" +msgstr "%qD förekommer mer än en gång i datadelningsklausuler" #: c/c-typeck.cc:14565 cp/semantics.cc:6988 #, gcc-internal-format @@ -47352,10 +47215,9 @@ msgid "%<depend%> clause with %<depobj%> dependence type on array section" msgstr "klausulen %<depend%> med beroendetyp %<depobj%> på vektorsektion" #: c/c-typeck.cc:14838 cp/semantics.cc:7804 -#, fuzzy, gcc-internal-format -#| msgid "%qE is not lvalue expression nor array section in %<depend%> clause" +#, gcc-internal-format msgid "%qE is not lvalue expression nor array section in %qs clause" -msgstr "%qE är varken ett l-värdeuttryck eller en vektorsektion i en %<depend%>-klausul" +msgstr "%qE är varken ett l-värdeuttryck eller en vektorsektion i en %qs-klausul" #: c/c-typeck.cc:14859 cp/semantics.cc:7826 #, gcc-internal-format @@ -47522,10 +47384,9 @@ msgid "edge not found" msgstr "bågen finns inte" #: c/gimple-parser.cc:342 -#, fuzzy, gcc-internal-format -#| msgid "concept %qD has no definition" +#, gcc-internal-format msgid "SSA name %qE with version %d has no definition" -msgstr "konceptet %qD har ingen definition" +msgstr "SSA-namnet %qE med version %d har ingen definition" #: c/gimple-parser.cc:482 c/gimple-parser.cc:488 #, gcc-internal-format @@ -47573,10 +47434,9 @@ msgid "invalid source block specification" msgstr "ogiltig källkodsblockspecifikation" #: c/gimple-parser.cc:890 -#, fuzzy, gcc-internal-format -#| msgid "unexpected argument" +#, gcc-internal-format msgid "unexpected RHS for assignment" -msgstr "oväntat argument" +msgstr "oväntat högersida för tilldelning" #: c/gimple-parser.cc:994 #, gcc-internal-format @@ -47655,16 +47515,14 @@ msgid "anonymous SSA name cannot have default definition" msgstr "ett anonymt SSA-namn kan inte ha en standarddefinition" #: c/gimple-parser.cc:1770 -#, fuzzy, gcc-internal-format -#| msgid "call to non-function %qD" +#, gcc-internal-format msgid "invalid call to non-function" -msgstr "anrop av icke-funktion %qD" +msgstr "otillåtet anrop av icke-funktion" #: c/gimple-parser.cc:1824 -#, fuzzy, gcc-internal-format -#| msgid "dereferencing a null pointer" +#, gcc-internal-format msgid "dereference of non-pointer" -msgstr "derefererar en nollpekare" +msgstr "derefererar en icke-pekare" #: c/gimple-parser.cc:1949 #, gcc-internal-format @@ -47677,10 +47535,9 @@ msgid "invalid operation" msgstr "ogiltig operation" #: c/gimple-parser.cc:2152 -#, fuzzy, gcc-internal-format -#| msgid "bogus comparison result type" +#, gcc-internal-format msgid "comparison required" -msgstr "felaktig resultattyp i jämförelse" +msgstr "en jämförelse krävs" #: c/gimple-parser.cc:2204 #, gcc-internal-format @@ -48053,16 +47910,14 @@ msgid "comparison between %q#T and %q#T" msgstr "jämförelse mellan %q#T och %q#T" #: cp/call.cc:7020 -#, fuzzy, gcc-internal-format -#| msgid "no match for call to %<(%T) (%A)%>" +#, gcc-internal-format msgid "no match for call to %<%T::operator[] (%A)%>" -msgstr "ingen träff för anrop till %<(%T) (%A)%>" +msgstr "ingen träff för anrop till %<%T::operator[] (%A)%>" #: cp/call.cc:7034 -#, fuzzy, gcc-internal-format -#| msgid "call of %<(%T) (%A)%> is ambiguous" +#, gcc-internal-format msgid "call of %<%T::operator[] (%A)%> is ambiguous" -msgstr "anrop av %<(%T) (%A)%> är tvetydigt" +msgstr "anrop av %<%T::operator[] (%A)%> är tvetydigt" #: cp/call.cc:7309 #, gcc-internal-format @@ -48196,10 +48051,8 @@ msgstr "kan inte binda icke-const-l-värde av typen %qH till ett r-värde av typ #. extype is volatile #: cp/call.cc:8239 -#, fuzzy -#| msgid "cannot bind rvalue reference of type %qH to lvalue of type %qI" msgid "cannot bind lvalue reference of type %qH to an rvalue of type %qI" -msgstr "kan inte binda r-värdesreferens av typen %qH till ett l-värde av typ %qI" +msgstr "kan inte binda l-värdesreferens av typen %qH till ett r-värde av typen %qI" #: cp/call.cc:8252 msgid "cannot bind reference of type %qH to %qI due to different array bounds" @@ -48421,10 +48274,9 @@ msgid "%#qT declared here" msgstr "%#qT är deklarerad här" #: cp/call.cc:10428 -#, fuzzy, gcc-internal-format -#| msgid "argument %u in call to function %qE has pointer to %qs type (%qT)" +#, gcc-internal-format msgid "argument %u in call to function %qE has pointer to a non-trivially-copyable type (%qT)" -msgstr "argument %u i anropet av funktionen %qE har typen pekare på %qs (%qT)" +msgstr "argument %u i anropet av funktionen %qE har en pekare till en icke trivialt kopierbar typ (%qT)" #: cp/call.cc:10495 #, gcc-internal-format @@ -48920,16 +48772,14 @@ msgid "non-static const member %q#D in class without a constructor" msgstr "icke-statisk const-medlem %q#D i klass utan en konstruerare" #: cp/class.cc:6490 -#, fuzzy, gcc-internal-format -#| msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)" +#, gcc-internal-format msgid "offset of %qT base class for %<-std=c++14%> and up changes in %<-fabi-version=17%> (GCC 12)" -msgstr "den tomma klassen %qT parameterskickande ABI ändras i %<-fabi-version=12%> (GCC 8)" +msgstr "avståndet till %qT basklass för %<-std=c++14%> och uppåt ändras i %<-fabi-version=17%> (GCC 12)" #: cp/class.cc:6494 -#, fuzzy, gcc-internal-format -#| msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)" +#, gcc-internal-format msgid "offset of %qD for %<-std=c++14%> and up changes in %<-fabi-version=17%> (GCC 12)" -msgstr "den tomma klassen %qT parameterskickande ABI ändras i %<-fabi-version=12%> (GCC 8)" +msgstr "avståndet till %qD för %<-std=c++14%> och uppåt ändras i %<-fabi-version=17%> (GCC 12)" #: cp/class.cc:6534 #, gcc-internal-format @@ -49092,10 +48942,9 @@ msgid "the type %qT of %<constexpr%> variable %qD is not literal" msgstr "typen %qT för %<constexpr%>-variabeln %qD är inte en litteral" #: cp/constexpr.cc:121 -#, fuzzy, gcc-internal-format -#| msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>" +#, gcc-internal-format msgid "variable %qD of non-literal type %qT in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%<try%> i %<constexpr%>-funktioner är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>" +msgstr "variabeln %qD av den icke literala typen %qT i en %<constexpr%>-funktion är endast tillgängligt med %<-std=c++2b%> eller %<-std=gnu++2b%>" #: cp/constexpr.cc:134 #, gcc-internal-format @@ -49221,10 +49070,9 @@ msgstr "anrop av icke-%<constexpr%>-funktion %qD" #. 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:2321 -#, fuzzy, gcc-internal-format -#| msgid "cannot call member function %qD without object" +#, gcc-internal-format msgid "calling constexpr member function %qD through virtual base subobject" -msgstr "det går inte att anropa medlemsfunktion %qD utan ett objekt" +msgstr "anropar constexpr-medlemsfunktionen %qD via ett virtuell basunderobjekt" #: cp/constexpr.cc:2438 #, gcc-internal-format @@ -49528,10 +49376,9 @@ msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function i msgstr "endast oevaluerad inline:ad assembler är tillåten i en %<constexpr%>-funktion i C++20" #: cp/constexpr.cc:6408 -#, fuzzy, gcc-internal-format -#| msgid "invalid use of %qD" +#, gcc-internal-format msgid "use of %qD" -msgstr "ogiltigt användning av %qD" +msgstr "användning av %qD" #: cp/constexpr.cc:6412 #, gcc-internal-format @@ -49564,16 +49411,14 @@ msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fco msgstr "antalet %<constexpr%>-evalueringsoperationer överskrider gränsen på %wd (använd %<-fconstexpr-ops-limit=%> för att öka gränsen)" #: cp/constexpr.cc:6734 -#, fuzzy, gcc-internal-format -#| msgid "non-thread-local declaration of %q+D follows thread-local declaration" +#, gcc-internal-format msgid "control passes through definition of %qD with thread storage duration" -msgstr "icke trådlokal deklaration av %q+D följer på trådlokal deklaration" +msgstr "kontrollen skickas via definitionen av %qD med trådlagringsvaraktighet" #: cp/constexpr.cc:6737 -#, fuzzy, gcc-internal-format -#| msgid "capture of variable %qD with non-automatic storage duration" +#, gcc-internal-format msgid "control passes through definition of %qD with static storage duration" -msgstr "fångst av variabeln %qD med ej automatisk lagringsvaraktighet" +msgstr "kontrollen skickas via definitionen av %qD med statisk Lagringsvaraktighet" #: cp/constexpr.cc:6785 cp/constexpr.cc:9226 #, gcc-internal-format @@ -49706,16 +49551,14 @@ msgid "cast to non-integral type %qT in a constant expression" msgstr "typkonvertering till %qT som inte är en heltalstyp i ett konstant uttryck" #: cp/constexpr.cc:9195 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<thread_local%> in %<constexpr%> context" +#, gcc-internal-format msgid "%qD defined %<thread_local%> in %<constexpr%> context" -msgstr "%qD är deklarerad %<thread_local%> i en %<constexpr%>-kontext" +msgstr "%qD är definierad %<thread_local%> i en %<constexpr%>-kontext" #: cp/constexpr.cc:9202 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared %<static%> in %<constexpr%> context" +#, gcc-internal-format msgid "%qD defined %<static%> in %<constexpr%> context" -msgstr "%qD är deklarerad %<static%> i en %<constexpr%>-kontext" +msgstr "%qD är definierad %<static%> i en %<constexpr%>-kontext" #: cp/constexpr.cc:9275 #, gcc-internal-format @@ -49728,10 +49571,9 @@ msgid "%<delete[]%> is not a constant expression" msgstr "%<delete[]%> är inte ett konstant uttryck" #: cp/constexpr.cc:9444 -#, fuzzy, gcc-internal-format -#| msgid "use of %<this%> in a constant expression" +#, gcc-internal-format msgid "neither branch of %<if%> is a constant expression" -msgstr "%<this%> används i ett konstant uttryck" +msgstr "ingendera grenen av %<if%> är ett konstant uttryck" #: cp/constexpr.cc:9455 #, gcc-internal-format @@ -49739,10 +49581,9 @@ msgid "non-constant array initialization" msgstr "ickekonstant vektorinitierare" #: cp/constexpr.cc:9494 -#, fuzzy, gcc-internal-format -#| msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>" +#, gcc-internal-format msgid "label definition in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%<asm%> i en %<constexpr%>-funktion är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>" +msgstr "en etikettdefinition i en %<constexpr%>-funktion är endast tillgängligt med %<-std=c++2b%> eller %<-std=gnu++2b%>" # ast = abstract syntax tree #: cp/constexpr.cc:9524 @@ -49751,16 +49592,14 @@ msgid "unexpected AST of kind %s" msgstr "oväntat AST av sorten %s" #: cp/constraint.cc:166 -#, fuzzy, gcc-internal-format -#| msgid "%<~%> on an expression of type %<bool%>" +#, gcc-internal-format msgid "constraint expression does not have type %<bool%>" -msgstr "%<~%> på ett uttryck av typen %<bool%>" +msgstr "begränsningsuttrycket har inte typen %<bool%>" #: cp/constraint.cc:373 -#, fuzzy, gcc-internal-format -#| msgid "specialization of variable concept %q#D" +#, gcc-internal-format msgid "function call of variable concept %qE" -msgstr "specialisering av variabelkonceptet %q#D" +msgstr "funktionsarnrop av variabelkonceptet %qE" #: cp/constraint.cc:545 #, gcc-internal-format @@ -49773,34 +49612,29 @@ msgid "MAP %qD TO %qE" msgstr "AVBILDA %qD PÅ %qE" #: cp/constraint.cc:560 -#, fuzzy, gcc-internal-format -#| msgid "no arguments" +#, gcc-internal-format msgid "argument %qT" -msgstr "inga argument" +msgstr "argument %qT" #: cp/constraint.cc:562 -#, fuzzy, gcc-internal-format -#| msgid "directive argument %qE" +#, gcc-internal-format msgid "argument %qE" -msgstr "direktivargument %qE" +msgstr "argument %qE" #: cp/constraint.cc:1150 -#, fuzzy, gcc-internal-format -#| msgid "type of %qD does not match original declaration" +#, gcc-internal-format msgid "%qT does not match original declaration" -msgstr "typen på %qD stämmer inte med originaldeklarationen" +msgstr "%qT stämmer inte med originaldeklarationen" #: cp/constraint.cc:1153 -#, fuzzy, gcc-internal-format -#| msgid "variable template declared here" +#, gcc-internal-format msgid "original template declaration here" -msgstr "variabelmallen är deklarerad här" +msgstr "den ursprungliga mallen är deklarerad här" #: cp/constraint.cc:1352 -#, fuzzy, gcc-internal-format -#| msgid "no matching template for %qD found" +#, gcc-internal-format msgid "no matching concepts for %qE" -msgstr "det finns ingen matchande mall för %qD" +msgstr "inga matchande koncept för %qE" #: cp/constraint.cc:1653 #, gcc-internal-format @@ -49808,59 +49642,50 @@ msgid "%qE cannot be introduced with an ellipsis %<...%>" msgstr "%qE kan inte introduceras med en ellips %<...%>" #: cp/constraint.cc:1654 -#, fuzzy, gcc-internal-format -#| msgid "previously declared here" +#, gcc-internal-format msgid "prototype declared here" -msgstr "tidigare deklarerad här" +msgstr "prototypen deklarerad här" #: cp/constraint.cc:1741 -#, fuzzy, gcc-internal-format -#| msgid "template parameters cannot be friends" +#, gcc-internal-format msgid "all template parameters of %qD must be introduced" -msgstr "mallparametrar kan inte vara vänner" +msgstr "alla mallparametrar till %qD måste introduceras" #: cp/constraint.cc:1769 -#, fuzzy, gcc-internal-format -#| msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides" +#, gcc-internal-format msgid "cannot deduce template parameters from introduction list" -msgstr "kan inte härleda mallargument till %qT, eftersom den inte några användbara härledningsguider" +msgstr "kan inte härleda mallargument från introduktionslistan" #: cp/constraint.cc:1933 -#, fuzzy, gcc-internal-format -#| msgid "unexpected expression %qE of kind %s" +#, gcc-internal-format msgid "the required expression %qE is invalid, because" -msgstr "oväntat uttryck %qE av sorten %s" +msgstr "det nödvändiga uttrycket %qE är felaktigt, för att" #: cp/constraint.cc:1940 -#, fuzzy, gcc-internal-format -#| msgid "unexpected expression %qE of kind %s" +#, gcc-internal-format msgid "the required expression %qE is invalid" -msgstr "oväntat uttryck %qE av sorten %s" +msgstr "det nödvändiga uttrycket %qE är felaktigt" #. Replay the substitution error. #: cp/constraint.cc:1979 -#, fuzzy, gcc-internal-format -#| msgid "zero sized type %qT in %qs clause" +#, gcc-internal-format msgid "the required type %qT is invalid, because" -msgstr "nollstor typ %qT i %qs-klausul" +msgstr "den nödvändiga typen %qT är felaktig, för att" #: cp/constraint.cc:1983 -#, fuzzy, gcc-internal-format -#| msgid "size of type %s is invalid" +#, gcc-internal-format msgid "the required type %qT is invalid" -msgstr "storleken på typen %s är ogiltig" +msgstr "den nödvändiga typen %qT är felaktig" #: cp/constraint.cc:2036 cp/constraint.cc:2109 -#, fuzzy, gcc-internal-format -#| msgid "cannot convert %qH to %qI" +#, gcc-internal-format msgid "cannot convert %qE to %qT" -msgstr "det går inte att konvertera %qH till %qI" +msgstr "det går inte att konvertera %qE till %qT" #: cp/constraint.cc:2062 -#, fuzzy, gcc-internal-format -#| msgid "%qE is not a template" +#, gcc-internal-format msgid "%qE is not %<noexcept%>" -msgstr "%qE är inte en mall" +msgstr "%qE är inte %<noexcept%>" #: cp/constraint.cc:2086 #, gcc-internal-format @@ -49868,16 +49693,14 @@ msgid "%qE does not satisfy return-type-requirement, because" msgstr "%qE uppfyller inte returtypskravet, för att" #: cp/constraint.cc:2093 -#, fuzzy, gcc-internal-format -#| msgid "insn does not satisfy its constraints:" +#, gcc-internal-format msgid "%qE does not satisfy return-type-requirement" -msgstr "instruktionen håller inte sina begränsningar:" +msgstr "%qE uppfyller inte returtypskravet" #: cp/constraint.cc:2104 -#, fuzzy, gcc-internal-format -#| msgid "cannot convert %qH to %qI" +#, gcc-internal-format msgid "cannot convert %qE to %qT because" -msgstr "det går inte att konvertera %qH till %qI" +msgstr "det går inte att konvertera %qE till %qT för att" #. Replay the substitution error. #: cp/constraint.cc:2136 @@ -49886,22 +49709,19 @@ msgid "nested requirement %qE is not satisfied, because" msgstr "nästade krav %qE är inte uppfyllda, för att" #: cp/constraint.cc:2140 -#, fuzzy, gcc-internal-format -#| msgid "%qE attribute argument %qE is not recognised" +#, gcc-internal-format msgid "nested requirement %qE is not satisfied" -msgstr "argumentet %2$qE till attributet %1$qE är inte känt" +msgstr "det nästade kravet %qE är inte uppfyllt" #: cp/constraint.cc:2627 -#, fuzzy, gcc-internal-format -#| msgid "exception specification of %qD depends on itself" +#, gcc-internal-format msgid "satisfaction of atomic constraint %qE depends on itself" -msgstr "explicit specifikation av %qD beror på sig själv" +msgstr "uppfyllelsen av den atomära begränsningen %qE beror på sig själv" #: cp/constraint.cc:2673 -#, fuzzy, gcc-internal-format -#| msgid "conversion from %qT to %qT changes value from %qE to %qE" +#, gcc-internal-format msgid "satisfaction value of atomic constraint %qE changed from %qE to %qE" -msgstr "konvertering från %qT till %qT ändrar värdet från %qE till %qE" +msgstr "uppfyllelsevärdet av den atomära begränsningen %qE ändrades från %qE till %qE" #: cp/constraint.cc:2676 #, gcc-internal-format @@ -49919,16 +49739,14 @@ msgid "the operand %qE is unsatisfied because" msgstr "operanden %qE är ouppfylld för att" #: cp/constraint.cc:3439 -#, fuzzy, gcc-internal-format -#| msgid "in definition of macro %qs" +#, gcc-internal-format msgid "definition of concept %qD is empty" -msgstr "i definitionen av makrot %qs" +msgstr "definitionen av konceptet %qD är tom" #: cp/constraint.cc:3442 -#, fuzzy, gcc-internal-format -#| msgid "macro expands to multiple statements" +#, gcc-internal-format msgid "definition of concept %qD has multiple statements" -msgstr "makrot expanderar till flera satser" +msgstr "definitionen av konceptet %qD har flera satser" #: cp/constraint.cc:3588 #, gcc-internal-format @@ -49936,10 +49754,9 @@ msgid " %qT is not %<nothrow%> copy assignable" msgstr " %qT är inte %<nothrow%>-kopieringstilldelningsbar" #: cp/constraint.cc:3591 cp/constraint.cc:3686 -#, fuzzy, gcc-internal-format -#| msgid "%q#T has no user-provided default constructor" +#, gcc-internal-format msgid " %qT is not %<nothrow%> default constructible" -msgstr "%q#T har ingen användardefinierad standardkonstruerare" +msgstr " %qT är inte %<nothrow%>-standardkonstruerbart" #: cp/constraint.cc:3594 #, gcc-internal-format @@ -49947,208 +49764,174 @@ msgid " %qT is not %<nothrow%> copy constructible" msgstr " %qT är inte %<nothrow%>-kopieringskonstruerbar" #: cp/constraint.cc:3597 -#, fuzzy, gcc-internal-format -#| msgid "%qD is not a variable" +#, gcc-internal-format msgid " %qT is not trivially copy assignable" -msgstr "%qD är inte en variabel" +msgstr " %qT är inte en trivialt kopieringstilldelningsbart" #: cp/constraint.cc:3600 cp/constraint.cc:3680 -#, fuzzy, gcc-internal-format -#| msgid "%q#T has no user-provided default constructor" +#, gcc-internal-format msgid " %qT is not trivially default constructible" -msgstr "%q#T har ingen användardefinierad standardkonstruerare" +msgstr " %qT är inte trivialt standardkonstruerbart" #: cp/constraint.cc:3603 -#, fuzzy, gcc-internal-format -#| msgid " %q+T has a non-trivial destructor" +#, gcc-internal-format msgid " %qT is not trivially copy constructible" -msgstr " %q+T har en icke-trivial destruerare" +msgstr " %qT är inte trivialt kopieringskonstruerbart" #: cp/constraint.cc:3606 -#, fuzzy, gcc-internal-format -#| msgid " %q+T has a non-trivial destructor" +#, gcc-internal-format msgid " %qT is not trivially destructible" -msgstr " %q+T har en icke-trivial destruerare" +msgstr " %qT är inte trivialt destruerbart" #: cp/constraint.cc:3609 -#, fuzzy, gcc-internal-format -#| msgid " %q+T does not have %<constexpr%> destructor" +#, gcc-internal-format msgid " %qT does not have a virtual destructor" -msgstr " %q+T har inte en %<constexpr%>-destruerare" +msgstr " %qT har inte en virtuell destruerare" #: cp/constraint.cc:3612 -#, fuzzy, gcc-internal-format -#| msgid "%q#T is not a class" +#, gcc-internal-format msgid " %qT is not an abstract class" -msgstr "%q#T är inte en klass" +msgstr " %qT är inte en abstrakt klass" #: cp/constraint.cc:3615 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a base of %qT" +#, gcc-internal-format msgid " %qT is not a base of %qT" -msgstr "%qT är inte en basklass till %qT" +msgstr " %qT är inte en bas till %qT" #: cp/constraint.cc:3618 -#, fuzzy, gcc-internal-format -#| msgid "%q#T is not a class" +#, gcc-internal-format msgid " %qT is not a class" -msgstr "%q#T är inte en klass" +msgstr " %qT är inte en klass" #: cp/constraint.cc:3621 -#, fuzzy, gcc-internal-format -#| msgid "%q#T is not a class" +#, gcc-internal-format msgid " %qT is not an empty class" -msgstr "%q#T är inte en klass" +msgstr " %qT är inte en tom klass" #: cp/constraint.cc:3624 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a template" +#, gcc-internal-format msgid " %qT is not an enum" -msgstr "%qT är inte en mall" +msgstr " %qT är inte en uppräkningstyp" #: cp/constraint.cc:3627 -#, fuzzy, gcc-internal-format -#| msgid "%q#T is not a class" +#, gcc-internal-format msgid " %qT is not a final class" -msgstr "%q#T är inte en klass" +msgstr " %qT är inte en slutlig klass" #: cp/constraint.cc:3630 -#, fuzzy, gcc-internal-format -#| msgid "%qD is not compatible with %qD" +#, gcc-internal-format msgid " %qT is not layout compatible with %qT" -msgstr "%qD är inte kompatibel med %qD" +msgstr " %qT är inte layoutkompatibel med %qT" #: cp/constraint.cc:3633 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class type" +#, gcc-internal-format msgid " %qT is not a literal type" -msgstr "%qT är inte en klasstyp" +msgstr " %qT är inte en literal typ" #: cp/constraint.cc:3636 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not an accessible base of %qT" +#, gcc-internal-format msgid " %qT is not pointer-interconvertible base of %qT" -msgstr "%qT är inte en åtkomlig bas till %qT" +msgstr " %qT är inte en pekarinterkonvertibel bas till %qT" #: cp/constraint.cc:3640 -#, fuzzy, gcc-internal-format -#| msgid "%qD is not a type" +#, gcc-internal-format msgid " %qT is not a POD type" -msgstr "%qD är inte en typ" +msgstr " %qT är inte en POD-typ" #: cp/constraint.cc:3643 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class type" +#, gcc-internal-format msgid " %qT is not a polymorphic type" -msgstr "%qT är inte en klasstyp" +msgstr " %qT är inte en polymorf typ" #: cp/constraint.cc:3646 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a base of %qT" +#, gcc-internal-format msgid " %qT is not the same as %qT" -msgstr "%qT är inte en basklass till %qT" +msgstr " %qT är inte en detsamma som %qT" #: cp/constraint.cc:3649 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a template type" +#, gcc-internal-format msgid " %qT is not an standard layout type" -msgstr "%qT är inte en malltyp" +msgstr " %qT är inte en standardlayouttyp" #: cp/constraint.cc:3652 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class type" +#, gcc-internal-format msgid " %qT is not a trivial type" -msgstr "%qT är inte en klasstyp" +msgstr " %qT är inte en trivial typ" #: cp/constraint.cc:3655 -#, fuzzy, gcc-internal-format -#| msgid "%qs at %L is not a function" +#, gcc-internal-format msgid " %qT is not a union" -msgstr "%qs vid %L är inte en funktion" +msgstr " %qT är inte en union" #: cp/constraint.cc:3658 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a template" +#, gcc-internal-format msgid " %qT is not an aggregate" -msgstr "%qT är inte en mall" +msgstr " %qT är inte ett aggregat" #: cp/constraint.cc:3661 -#, fuzzy, gcc-internal-format -#| msgid "%qD is not a variable" +#, gcc-internal-format msgid " %qT is not trivially copyable" -msgstr "%qD är inte en variabel" +msgstr " %qT är inte trivialt kopierbar" #: cp/constraint.cc:3664 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not derived from %qT" +#, gcc-internal-format msgid " %qT is not assignable from %qT" -msgstr " %qT är inte härledd från %qT" +msgstr " %qT är inte tilldelningsbar från %qT" #: cp/constraint.cc:3667 -#, fuzzy, gcc-internal-format -#| msgid "%qD is not a variable" +#, gcc-internal-format msgid " %qT is not trivially assignable from %qT" -msgstr "%qD är inte en variabel" +msgstr " %qT är inte trivialt tilldelningsbar från %qT" #: cp/constraint.cc:3670 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not %<nothrow%> copy assignable" +#, gcc-internal-format msgid " %qT is not %<nothrow%> assignable from %qT" -msgstr " %qT är inte %<nothrow%>-kopieringstilldelningsbar" +msgstr " %qT är inte %<nothrow%>-tilldelningsbar från %qT" #: cp/constraint.cc:3674 -#, fuzzy, gcc-internal-format -#| msgid "%q#T has no user-provided default constructor" +#, gcc-internal-format msgid " %qT is not default constructible" -msgstr "%q#T har ingen användardefinierad standardkonstruerare" +msgstr " %qT är inte standardkonstruerbar" #: cp/constraint.cc:3676 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not derived from %qT" +#, gcc-internal-format msgid " %qT is not constructible from %qE" -msgstr " %qT är inte härledd från %qT" +msgstr " %qT är inte konstruerbar från %qE" #: cp/constraint.cc:3682 -#, fuzzy, gcc-internal-format -#| msgid " %q+T has a non-trivial destructor" +#, gcc-internal-format msgid " %qT is not trivially constructible from %qE" -msgstr " %q+T har en icke-trivial destruerare" +msgstr " %qT har en trivialt konstruerbar från %qE" #: cp/constraint.cc:3688 -#, fuzzy, gcc-internal-format -#| msgid " %qT is not %<nothrow%> copy constructible" +#, gcc-internal-format msgid " %qT is not %<nothrow%> constructible from %qE" -msgstr " %qT är inte %<nothrow%>-kopieringskonstruerbar" +msgstr " %qT är inte %<nothrow%>-konstruerbar från %qE" #: cp/constraint.cc:3691 -#, fuzzy, gcc-internal-format -#| msgid " %q+T does not have %<constexpr%> destructor" +#, gcc-internal-format msgid " %qT does not have unique object representations" -msgstr " %q+T har inte en %<constexpr%>-destruerare" +msgstr " %qT har inte unika objektrepresentationer" #: cp/constraint.cc:3717 -#, fuzzy, gcc-internal-format -#| msgid "invalid constant" +#, gcc-internal-format msgid "invalid constraints" -msgstr "ogiltig konstant" +msgstr "ogiltiga begränsningar" #: cp/constraint.cc:3742 -#, fuzzy, gcc-internal-format -#| msgid "concept must have type %<bool%>" +#, gcc-internal-format msgid "constraint %qE has type %qT, not %<bool%>" -msgstr "koncept måste ha typen %<bool%>" +msgstr "begränsningen %qE har typen %qT, inte %<bool%>" #: cp/constraint.cc:3745 -#, fuzzy, gcc-internal-format -#| msgid "%qE evaluates to false" +#, gcc-internal-format msgid "the expression %qE evaluated to %<false%>" -msgstr "%qE beräknas till falskt" +msgstr "uttrycket %qE beräknades till %<false%>" #: cp/constraint.cc:3796 -#, fuzzy, gcc-internal-format -#| msgid "placeholder constraints not satisfied" +#, gcc-internal-format msgid "constraints not satisfied" -msgstr "platshållarbegränsningar är inte uppfyllt" +msgstr "begränsningar är inte uppfyllda" #: cp/constraint.cc:3811 #, gcc-internal-format @@ -50191,83 +49974,71 @@ msgid "the coroutine promise type %qT declares both %<return_value%> and %<retur msgstr "korutunlöftestypen %qT deklarerar både %<return_value%> och %<return_void%>" #: cp/coroutines.cc:515 -#, fuzzy, gcc-internal-format -#| msgid "%qD target declared here" +#, gcc-internal-format msgid "%<return_void%> declared here" -msgstr "%qD målet deklarerades här" +msgstr "%<return_void%> deklarerades här" #: cp/coroutines.cc:517 -#, fuzzy, gcc-internal-format -#| msgid "routine %qD declared here" +#, gcc-internal-format msgid "%<return_value%> declared here" -msgstr "rutinen %qD är deklarerad här" +msgstr "%<return_value%> deklarerad här" #: cp/coroutines.cc:642 cp/coroutines.cc:720 cp/coroutines.cc:4280 -#, fuzzy, gcc-internal-format -#| msgid "no type named %q#T in %q#T" +#, gcc-internal-format msgid "no member named %qE in %qT" -msgstr "ingen typ med namnet %q#T i %q#T" +msgstr "ingen medlem med namnet %qE i %qT" #: cp/coroutines.cc:735 -#, fuzzy, gcc-internal-format -#| msgid "%qE cannot be used as a function" +#, gcc-internal-format msgid "%qs cannot be used outside a function" -msgstr "%qE kan inte användas som en funktion" +msgstr "%qs kan inte användas utanför en funktion" #. [basic.start.main] 3. The function main shall not be a coroutine. #: cp/coroutines.cc:743 -#, fuzzy, gcc-internal-format -#| msgid "%qE cannot be used as a function" +#, gcc-internal-format msgid "%qs cannot be used in the %<main%> function" -msgstr "%qE kan inte användas som en funktion" +msgstr "%qs kan inte användas funktionen %<main%>" #. [dcl.constexpr] 3.3 it shall not be a coroutine. #: cp/coroutines.cc:754 -#, fuzzy, gcc-internal-format -#| msgid "%qE cannot be used as a function" +#, gcc-internal-format msgid "%qs cannot be used in a %<constexpr%> function" -msgstr "%qE kan inte användas som en funktion" +msgstr "%qs kan inte användas i en %<constexpr%>-funktion" #: cp/coroutines.cc:765 -#, fuzzy, gcc-internal-format -#| msgid "virtual function cannot have deduced return type" +#, gcc-internal-format msgid "%qs cannot be used in a function with a deduced return type" -msgstr "en virtuell funktion kan inte ha härledd returtyp" +msgstr "%qs kan inte användas i en funktion med en härledd returtyp" #: cp/coroutines.cc:776 -#, fuzzy, gcc-internal-format -#| msgid "%qE cannot be used as a function" +#, gcc-internal-format msgid "%qs cannot be used in a varargs function" -msgstr "%qE kan inte användas som en funktion" +msgstr "%qs kan inte användas i en varargs-funktion" #. [class.ctor] 7. a constructor shall not be a coroutine. #: cp/coroutines.cc:783 -#, fuzzy, gcc-internal-format -#| msgid "%qE cannot be used as a function" +#, gcc-internal-format msgid "%qs cannot be used in a constructor" -msgstr "%qE kan inte användas som en funktion" +msgstr "%qs kan inte användas i en konstruerare" #. [class.dtor] 21. a destructor shall not be a coroutine. #: cp/coroutines.cc:790 -#, fuzzy, gcc-internal-format -#| msgid "%qE cannot be used as a function" +#, gcc-internal-format msgid "%qs cannot be used in a destructor" -msgstr "%qE kan inte användas som en funktion" +msgstr "%qs kan inte användas i en destruerare" #. TODO: record or extract positions of returns (and the first coro #. keyword) so that we can add notes to the diagnostic about where #. the bad keyword is and what made the function into a coro. #: cp/coroutines.cc:821 -#, fuzzy, gcc-internal-format -#| msgid "return-statement with no value, in function returning %qT" +#, gcc-internal-format msgid "a %<return%> statement is not allowed in coroutine; did you mean %<co_return%>?" -msgstr "return-sats utan värde i funktion som returnerar %qT" +msgstr "en %<return%>-sats är inte tillåten i en korutin; menade du %<co_return%>?" #: cp/coroutines.cc:869 -#, fuzzy, gcc-internal-format -#| msgid "integral expression %qE is not constant" +#, gcc-internal-format msgid "the expression %qE is required to be non-throwing" -msgstr "heltalsuttryck %qE är inte konstant" +msgstr "uttrycket %qE måste vara icke-kastande" #: cp/coroutines.cc:871 #, gcc-internal-format @@ -50275,10 +50046,9 @@ msgid "must be declared with %<noexcept(true)%>" msgstr "måste deklareras med %<noexcept(true)%>" #: cp/coroutines.cc:955 -#, fuzzy, gcc-internal-format -#| msgid "qualified type %qT does not match destructor name ~%qT" +#, gcc-internal-format msgid "awaitable type %qT is not a structure" -msgstr "kvalificerad typ %qT matchar inte destruerarnamnet ~%qT" +msgstr "den väntbara typen %qT är inte en post" #: cp/coroutines.cc:1066 #, gcc-internal-format @@ -50286,28 +50056,24 @@ msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle" msgstr "%<await_suspend%> måste returnera %<void%>, %<bool%> eller ett korutinhandtag" #: cp/coroutines.cc:1376 -#, fuzzy, gcc-internal-format -#| msgid "function declared %<noreturn%> has a %<return%> statement" +#, gcc-internal-format msgid "function declared %<noreturn%> has a %<co_return%> statement" -msgstr "funktion deklarerad %<noreturn%> har en %<return%>-sats" +msgstr "funktion deklarerad %<noreturn%> har en %<co_return%>-sats" #: cp/coroutines.cc:1414 -#, fuzzy, gcc-internal-format -#| msgid "third argument to %<__builtin_prefetch%> must be a constant" +#, gcc-internal-format msgid "the align argument to %<__builtin_coro_promise%> must be a constant" -msgstr "tredje argumentet till %<__builtin_prefetch%> måste vara en konstant" +msgstr "justeringsargumentet till %<__builtin_coro_promise%> måste vara en konstant" #: cp/coroutines.cc:1424 -#, fuzzy, gcc-internal-format -#| msgid "third argument to %<__builtin_prefetch%> must be a constant" +#, gcc-internal-format msgid "the direction argument to %<__builtin_coro_promise%> must be a constant" -msgstr "tredje argumentet till %<__builtin_prefetch%> måste vara en konstant" +msgstr "riktningsargumentet till %<__builtin_coro_promise%> måste vara en konstant" #: cp/coroutines.cc:1904 -#, fuzzy, gcc-internal-format -#| msgid "no previous prototype for %qD" +#, gcc-internal-format msgid "no suspend point info for %qD" -msgstr "ingen tidigare prototyp för %qD" +msgstr "ingen suspenderingspunktsinformation för %qD" #: cp/coroutines.cc:2102 cp/coroutines.cc:4653 #, gcc-internal-format @@ -50315,16 +50081,14 @@ msgid "%qE is provided by %qT but is not usable with the function signature %qD" msgstr "%qE tillhandahålls av %qT men är inte användbart med funktionssignaturen %qD" #: cp/coroutines.cc:2552 -#, fuzzy, gcc-internal-format -#| msgid "duplicate %qE" +#, gcc-internal-format msgid "duplicate info for %qE" -msgstr "dubblerad %qE" +msgstr "dubblerad information för %qE" #: cp/coroutines.cc:3703 -#, fuzzy, gcc-internal-format -#| msgid "pointers are not permitted as case values" +#, gcc-internal-format msgid "await expressions are not permitted in handlers" -msgstr "pekare är inte tillåtna case-värden" +msgstr "vänteuttryck är inte tillåtna i hanterare" #: cp/coroutines.cc:3934 #, gcc-internal-format @@ -50348,10 +50112,9 @@ msgstr "%qE tillhandahålls av %qT men %<std::nothrow%> finns inte" #. We can't initialize a non-class return value from void. #: cp/coroutines.cc:5088 -#, fuzzy, gcc-internal-format -#| msgid "cannot bind non-const lvalue reference of type %qH to an rvalue of type %qI" +#, gcc-internal-format msgid "cannot initialize a return object of type %qT with an rvalue of type %<void%>" -msgstr "kan inte binda icke-const-l-värde av typen %qH till ett r-värde av typ %qI" +msgstr "det går inte att initiera ett returobjekt av typen %qT med ett r-värde av typen %<void%>" #: cp/cp-gimplify.cc:155 #, gcc-internal-format @@ -50869,10 +50632,9 @@ msgid "old declaration %q#D" msgstr "gammal deklaration av %q#D" #: cp/decl.cc:1493 -#, fuzzy, gcc-internal-format -#| msgid "redefinition of default argument for %q#D" +#, gcc-internal-format msgid "redefinition of default argument for %q+#D" -msgstr "omdefinition av standardargument till %q#D" +msgstr "omdefinition av standardargument till %q+#D" #: cp/decl.cc:1495 #, gcc-internal-format @@ -51200,10 +50962,9 @@ msgid " enters %<constexpr if%> statement" msgstr " går in %<constexpr if%>-sats" #: cp/decl.cc:3555 cp/decl.cc:3693 -#, fuzzy, gcc-internal-format -#| msgid " enters %<constexpr if%> statement" +#, gcc-internal-format msgid " enters %<consteval if%> statement" -msgstr " går in %<constexpr if%>-sats" +msgstr " går in %<consteval if%>-sats" #: cp/decl.cc:3674 #, gcc-internal-format @@ -51296,10 +51057,9 @@ msgid "this flexibility is deprecated and will be removed" msgstr "denna flexibilitet bör undvikas och kommer tas bort" #: cp/decl.cc:5208 -#, fuzzy, gcc-internal-format -#| msgid "anonymous struct not inside named type" +#, gcc-internal-format msgid "anonymous struct with base classes" -msgstr "anonym post som inte är inuti en namngiven typ" +msgstr "anonym post med basklasser" #: cp/decl.cc:5220 #, gcc-internal-format @@ -51478,16 +51238,14 @@ msgid "block-scope extern declaration %q#D not permitted in module purview" msgstr "extern-deklaration %q#D med blockräckvidd är inte tillåtet i modulens räckvidd" #: cp/decl.cc:5779 -#, fuzzy, gcc-internal-format -#| msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>" +#, gcc-internal-format msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%<try%> i %<constexpr%>-funktioner är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>" +msgstr "%qD definierad %<thread_local%> i en %qs-funktion är endast tillgängligt med %<-std=c++2b%> eller %<-std=gnu++2b%>" #: cp/decl.cc:5785 -#, fuzzy, gcc-internal-format -#| msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>" +#, gcc-internal-format msgid "%qD defined %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>" -msgstr "%<asm%> i en %<constexpr%>-funktion är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>" +msgstr "%qD definierad %<static%> i en %qs-funktion är endast tillgängligt med %<-std=c++2b%> eller %<-std=gnu++2b%>" #: cp/decl.cc:5850 #, gcc-internal-format @@ -51620,10 +51378,9 @@ msgid "%qT has no non-static data member named %qD" msgstr "%qT har ingen icke-statisk medlem med namnet %qD" #: cp/decl.cc:6680 -#, fuzzy, gcc-internal-format -#| msgid "%qD is not a member of %qT" +#, gcc-internal-format msgid "%qD is not a direct member of %qT" -msgstr "%qD har inte en medlem av %qT" +msgstr "%qD har inte en direkt medlem i %qT" #: cp/decl.cc:6735 #, gcc-internal-format @@ -52108,10 +51865,9 @@ msgid "deduction guide %qD must be declared in the same scope as %qT" msgstr "härledningsguiden %qD måste deklareras med i samma räckvidd som %qT" #: cp/decl.cc:10314 -#, fuzzy, gcc-internal-format -#| msgid "deduction guide %qD must be declared in the same scope as %qT" +#, gcc-internal-format msgid "deduction guide %qD must have the same access as %qT" -msgstr "härledningsguiden %qD måste deklareras med i samma räckvidd som %qT" +msgstr "härledningsguiden %qD måste ha samma åtkomst som %qT" #: cp/decl.cc:10320 #, gcc-internal-format @@ -52284,16 +52040,14 @@ msgid "overflow in array dimension" msgstr "spill i vektordimension" #: cp/decl.cc:11238 -#, fuzzy, gcc-internal-format -#| msgid "%qD declared as array of %qT" +#, gcc-internal-format msgid "%qD declared as array of template placeholder type %qT" -msgstr "%qD är deklarerad som en vektor av %qT" +msgstr "%qD är deklarerad som en vektor av mallens platshållartyp %qT" #: cp/decl.cc:11241 -#, fuzzy, gcc-internal-format -#| msgid "creating pointer to member reference type %qT" +#, gcc-internal-format msgid "creating array of template placeholder type %qT" -msgstr "skapar pekare till medlemsreferenstyp %qT" +msgstr "skapar en vektor av mallens platshållartyp %qT" #: cp/decl.cc:11251 #, gcc-internal-format @@ -52346,10 +52100,9 @@ msgid "multidimensional array must have bounds for all dimensions except the fir msgstr "flerdimensionell vektor måste ha gränser för alla dimensioner utom den första" #: cp/decl.cc:11311 -#, fuzzy, gcc-internal-format -#| msgid "variable length array is used" +#, gcc-internal-format msgid "variable-length array of %<auto%>" -msgstr "vektor med variabel längd används" +msgstr "vektor med variabel av %<auto%>" #: cp/decl.cc:11387 #, gcc-internal-format @@ -52671,7 +52424,7 @@ msgstr "attributet ignorerat" #: cp/decl.cc:12646 #, gcc-internal-format msgid "an attribute that appertains to a type-specifier is ignored" -msgstr "Ett attribut som gäller en viss typspecificerare ignoreras" +msgstr "ett attribut som gäller en viss typspecificerare ignoreras" #: cp/decl.cc:12704 #, gcc-internal-format @@ -53170,10 +52923,9 @@ msgid "unnamed field is neither function nor member function; cannot be declared msgstr "ett namnlöst fält är varken en funktion eller medlemsfunktion, kan inte deklareras som vän" #: cp/decl.cc:14097 cp/parser.cc:20644 cp/parser.cc:27042 -#, fuzzy, gcc-internal-format -#| msgid "an attribute that appertains to a type-specifier is ignored" +#, gcc-internal-format msgid "an attribute that appertains to a friend declaration that is not a definition is ignored" -msgstr "Ett attribut som gäller en viss typspecificerare ignoreras" +msgstr "ett attribut som tillhör en vändeklaration som inte är en definition ignoreras" #: cp/decl.cc:14143 cp/decl.cc:14154 #, gcc-internal-format @@ -53510,10 +53262,9 @@ msgid "reference to %qD is ambiguous" msgstr "referens till %qD är tvetydig" #: cp/decl.cc:15629 -#, fuzzy, gcc-internal-format -#| msgid "function template %qD redeclared as a class template" +#, gcc-internal-format msgid "class template %qD redeclared as non-template" -msgstr "funktionsmall %qD omdeklarerad som en klassmall" +msgstr "klassmallen %qD omdeklarerad som en icke-mall" #: cp/decl.cc:15651 cp/name-lookup.cc:5421 #, gcc-internal-format @@ -53692,10 +53443,9 @@ msgid "name missing for member function" msgstr "namn saknas på medlemsfunktion" #: cp/decl2.cc:447 cp/decl2.cc:480 -#, fuzzy, gcc-internal-format -#| msgid "top-level comma expression in array subscript is deprecated" +#, gcc-internal-format msgid "top-level comma expression in array subscript changed meaning in C++23" -msgstr "kommauttryck på toppnivå i vektorindex bör undvikas" +msgstr "kommauttryck på toppnivå i vektorindex ändrade betydelse i C++23" #: cp/decl2.cc:470 #, gcc-internal-format @@ -53868,10 +53618,9 @@ msgid "%q+D static data member inside of declare target directive" msgstr "den statiska datamedlemmen %q+D är inuti deklarationsmålsdirektiv" #: cp/decl2.cc:1684 cp/name-lookup.cc:8546 -#, fuzzy, gcc-internal-format -#| msgid "%<this%> may not be used in this context" +#, gcc-internal-format msgid "%<omp::%E%> not allowed to be specified in this context" -msgstr "%<this%> kan inte användas i detta sammanhang" +msgstr "%<omp::%E%> är inte tillåtet att anges i detta sammanhang" #: cp/decl2.cc:1753 #, gcc-internal-format @@ -54169,10 +53918,9 @@ msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu+ msgstr "ärvande konstruerare är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>" #: cp/error.cc:4524 -#, fuzzy, gcc-internal-format -#| msgid "c++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>" +#, gcc-internal-format msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>" -msgstr "c++11-attribut är endast tillgängligt med %<-std=c++11%> eller %<-std=gnu++11%>" +msgstr "C++11-attribut är endast tillgängligt med %<-std=c++11%> eller %<-std=gnu++11%>" #: cp/error.cc:4529 #, gcc-internal-format @@ -54416,10 +54164,9 @@ msgid "reference %qD is not yet bound to a value when used here" msgstr "referensen %qD är inte ännu bunden till ett värde när den används här" #: cp/init.cc:898 -#, fuzzy, gcc-internal-format -#| msgid "%qD is used uninitialized" +#, gcc-internal-format msgid "member %qD is used uninitialized" -msgstr "%qD används oinitierad" +msgstr "medlemen %qD används oinitierad" #: cp/init.cc:946 #, gcc-internal-format @@ -54945,10 +54692,9 @@ msgid "mapper died by signal %s" msgstr "avbildaren dog av signalen %s" #: cp/mapper-client.cc:357 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "failed to get exit status: %m" +#, gcc-internal-format, gfc-internal-format msgid "mapper exit status %d" -msgstr "misslyckades att få slutstatus: %m" +msgstr "avbildarens slutstatus %d" #: cp/method.cc:855 cp/method.cc:2319 #, gcc-internal-format @@ -55157,16 +54903,14 @@ msgid "defaulted function %q+D with default argument" msgstr "standarddefinierad funktion %q+D med standardargument" #: cp/module.cc:1546 -#, fuzzy, gcc-internal-format -#| msgid "%s: section %s.%d is missing" +#, gcc-internal-format msgid "section %qs is missing or corrupted" -msgstr "%s: sektion %s.%d saknas" +msgstr "sektion %qs saknas eller är trasig" #: cp/module.cc:1548 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "missing or corrupt object.d" +#, gcc-internal-format, gfc-internal-format msgid "section #%u is missing or corrupted" -msgstr "saknad eller trasig object.d" +msgstr "sektion nr. %u saknas eller är trasig" # "Encapsulated Lazy Records of Named Declarations" är ett formatnamn, ungefär # som ELF (Executable and Linkable Format) @@ -55176,10 +54920,9 @@ msgid "not Encapsulated Lazy Records of Named Declarations" msgstr "inte Encapsulated Lazy Records of Named Declarations" #: cp/module.cc:1785 -#, fuzzy, gcc-internal-format -#| msgid "expected template-id for type" +#, gcc-internal-format msgid "unexpected encapsulation format or type" -msgstr "mall-id för typ förväntades" +msgstr "oväntat inkapslingsformat eller -typ" #: cp/module.cc:1794 #, gcc-internal-format @@ -55187,40 +54930,34 @@ msgid "encapsulation is malformed" msgstr "inkapslingen är felgjord" #: cp/module.cc:11083 -#, fuzzy, gcc-internal-format -#| msgid "conflicting declaration %q#D" +#, gcc-internal-format msgid "conflicting global module declaration %#qD" -msgstr "motstridande deklaration av %q#D" +msgstr "motstridande global moduldeklaration %#qD" #: cp/module.cc:11085 -#, fuzzy, gcc-internal-format -#| msgid "in declaration %q+D" +#, gcc-internal-format msgid "existing declaration %#qD" -msgstr "i deklaration %q+D" +msgstr "befintlig deklaration %#qD" #: cp/module.cc:12149 -#, fuzzy, gcc-internal-format -#| msgid "definition of %qD does not match %<#include <initializer_list>%>" +#, gcc-internal-format msgid "definition of %qD does not match" -msgstr "definitionen av %qD matchar inte %<#include <initializer_list>%>" +msgstr "definitionen av %qD matchar inte" #: cp/module.cc:12151 -#, fuzzy, gcc-internal-format -#| msgid "missing definition" +#, gcc-internal-format msgid "existing definition %qD" -msgstr "definition saknas" +msgstr "befintlig definition %qD" #: cp/module.cc:12163 -#, fuzzy, gcc-internal-format -#| msgid "redeclaration of enumerator %q+D" +#, gcc-internal-format msgid "... this enumerator %qD" -msgstr "omdeklaration av uppräkningstyp %q+D" +msgstr "… denna uppräkningstyp %qD" #: cp/module.cc:12165 -#, fuzzy, gcc-internal-format -#| msgid " template argument %qE does not match %qE" +#, gcc-internal-format msgid "enumerator %qD does not match ..." -msgstr " mallargument %qE stämmer inte med %qE" +msgstr "uppräkningstypen %qD stämmer inte med …" #: cp/module.cc:12171 #, gcc-internal-format @@ -55238,10 +54975,9 @@ msgid "%q#D references internal linkage entity %q#D" msgstr "%q#D refererar entiteten %q#D med intern länkning" #: cp/module.cc:13863 -#, fuzzy, gcc-internal-format -#| msgid "recursive expansion" +#, gcc-internal-format msgid "recursive lazy load" -msgstr "rekursiv expansion" +msgstr "rekursiv lat laddning" #. Cannot import the current module. #: cp/module.cc:13882 @@ -55250,16 +54986,14 @@ msgid "cannot import module in its own purview" msgstr "det går inte att importera en modul i sin egen räckvidd" #: cp/module.cc:13883 cp/module.cc:18966 -#, fuzzy, gcc-internal-format -#| msgid "routine %qD declared here" +#, gcc-internal-format msgid "module %qs declared here" -msgstr "rutinen %qD är deklarerad här" +msgstr "modulen %qs är deklarerad här" #: cp/module.cc:14228 -#, fuzzy, gcc-internal-format -#| msgid "cast from %qT is not allowed" +#, gcc-internal-format msgid "indirect import %qs is not already loaded" -msgstr "typkonvertering från %qT är inte tillåtet" +msgstr "indirekt import %qs är inte laddad redan" #: cp/module.cc:14234 #, gcc-internal-format @@ -55277,16 +55011,14 @@ msgid "not exporting %<#define %E%> as it is a keyword" msgstr "exporterar inte %<#define %E%> eftersom det är ett nyckelord" #: cp/module.cc:17083 -#, fuzzy, gcc-internal-format -#| msgid "previous definition of %qD here" +#, gcc-internal-format msgid "macro definitions of %qE corrupted" -msgstr "tidigare definition av %qD här" +msgstr "makrodefinitionen av %qE är trasig" #: cp/module.cc:17107 cp/module.cc:17110 -#, fuzzy, gcc-internal-format -#| msgid " inconsistent parameter pack deduction with %qT and %qT" +#, gcc-internal-format msgid "inconsistent imported macro definition %qE" -msgstr " inkonsistent härledning av parameterpaket med %qT och %qT" +msgstr "inkonsistent importerad makrodefinition %qE" #: cp/module.cc:17116 #, gcc-internal-format @@ -55299,28 +55031,24 @@ msgid "%<#define %s%>" msgstr "%<#define %s%>" #: cp/module.cc:17348 -#, fuzzy, gcc-internal-format -#| msgid "Cannot delete module file %qs: %s" +#, gcc-internal-format msgid "compiled module file is %qs" -msgstr "Kan inte radera modulfilen %qs: %s" +msgstr "kompilerad modulfil är %qs" #: cp/module.cc:17385 cp/module.cc:17390 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Compile release version." +#, gcc-internal-format, gfc-internal-format msgid "compiled module is %sversion %s" -msgstr "Kompilera utgåveversion." +msgstr "kompilerad modul är %sversion %s" #: cp/module.cc:17396 -#, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "collect2 version %s\n" +#, gcc-internal-format, gfc-internal-format msgid "compiler is %sversion %s%s%s" -msgstr "collect2 version %s\n" +msgstr "kompilatorn är %sversion %s%s%s" #: cp/module.cc:17426 -#, fuzzy, gcc-internal-format -#| msgid "no %qs getter found" +#, gcc-internal-format msgid "module %qs found" -msgstr "någon %qs-hämtare finns inte" +msgstr "modulen %qs finns inte" #: cp/module.cc:17428 #, gcc-internal-format @@ -55348,10 +55076,9 @@ msgid "language dialect differs %qs, expected %qs" msgstr "språkdialekten skiljer %qs, %qs förväntades" #: cp/module.cc:17486 -#, fuzzy, gcc-internal-format -#| msgid "exception handling disabled, use %<-fexceptions%> to enable" +#, gcc-internal-format msgid "module contains OpenMP, use %<-fopenmp%> to enable" -msgstr "undantagshantering avslagen, använd %<-fexceptions%> för att aktivera" +msgstr "modulen innehåller OpenMP, använd %<-fopenmp%> för att aktivera" #: cp/module.cc:17503 #, fuzzy, gcc-internal-format diff --git a/gcc/pointer-query.cc b/gcc/pointer-query.cc index 4390535ef56..d93657f3206 100644 --- a/gcc/pointer-query.cc +++ b/gcc/pointer-query.cc @@ -2299,9 +2299,10 @@ compute_objsize_r (tree ptr, gimple *stmt, bool addr, int ostype, if (!compute_objsize_r (ref, stmt, addr, ostype, pref, snlim, qry)) return false; - /* Clear DEREF since the offset is being applied to the target - of the dereference. */ - pref->deref = 0; + /* The below only makes sense if the offset is being applied to the + address of the object. */ + if (pref->deref != -1) + return false; offset_int orng[2]; tree off = pref->eval (TREE_OPERAND (ptr, 1)); diff --git a/gcc/reginfo.cc b/gcc/reginfo.cc index 67e30cab428..2ab7bbb7353 100644 --- a/gcc/reginfo.cc +++ b/gcc/reginfo.cc @@ -122,6 +122,24 @@ const char * reg_class_names[] = REG_CLASS_NAMES; reginfo has been initialized. */ static int no_global_reg_vars = 0; +static void +clear_global_regs_cache (void) +{ + for (size_t i = 0 ; i < FIRST_PSEUDO_REGISTER ; i++) + { + global_regs[i] = 0; + global_regs_decl[i] = NULL; + } +} + +void +reginfo_cc_finalize (void) +{ + clear_global_regs_cache (); + no_global_reg_vars = 0; + CLEAR_HARD_REG_SET (global_reg_set); +} + /* Given a register bitmap, turn on the bits in a HARD_REG_SET that correspond to the hard registers, if any, set in that map. This could be done far more efficiently by having all sorts of special-cases diff --git a/gcc/rtl.h b/gcc/rtl.h index 9df2fab622e..488016bb42a 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -3774,6 +3774,7 @@ extern bool resize_reg_info (void); extern void free_reg_info (void); extern void init_subregs_of_mode (void); extern void finish_subregs_of_mode (void); +extern void reginfo_cc_finalize (void); /* recog.cc */ extern rtx extract_asm_operands (rtx); diff --git a/gcc/rtlanal.cc b/gcc/rtlanal.cc index e1824bfefb7..c436c640c37 100644 --- a/gcc/rtlanal.cc +++ b/gcc/rtlanal.cc @@ -3390,7 +3390,7 @@ replace_rtx (rtx x, rtx from, rtx to, bool all_regs) { rtx new_rtx = replace_rtx (SUBREG_REG (x), from, to, all_regs); - if (CONST_INT_P (new_rtx)) + if (CONST_SCALAR_INT_P (new_rtx)) { x = simplify_subreg (GET_MODE (x), new_rtx, GET_MODE (SUBREG_REG (x)), @@ -3406,7 +3406,7 @@ replace_rtx (rtx x, rtx from, rtx to, bool all_regs) { rtx new_rtx = replace_rtx (XEXP (x, 0), from, to, all_regs); - if (CONST_INT_P (new_rtx)) + if (CONST_SCALAR_INT_P (new_rtx)) { x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x), new_rtx, GET_MODE (XEXP (x, 0))); diff --git a/gcc/simplify-rtx.cc b/gcc/simplify-rtx.cc index 5d4939c9206..e152918b0f1 100644 --- a/gcc/simplify-rtx.cc +++ b/gcc/simplify-rtx.cc @@ -5066,6 +5066,15 @@ simplify_const_binary_operation (enum rtx_code code, machine_mode mode, case SS_ASHIFT: case US_ASHIFT: { + /* The shift count might be in SImode while int_mode might + be narrower. On IA-64 it is even DImode. If the shift + count is too large and doesn't fit into int_mode, we'd + ICE. So, if int_mode is narrower than word, use + word_mode for the shift count. */ + if (GET_MODE (op1) == VOIDmode + && GET_MODE_PRECISION (int_mode) < BITS_PER_WORD) + pop1 = rtx_mode_t (op1, word_mode); + wide_int wop1 = pop1; if (SHIFT_COUNT_TRUNCATED) wop1 = wi::umod_trunc (wop1, GET_MODE_PRECISION (int_mode)); @@ -5112,6 +5121,15 @@ simplify_const_binary_operation (enum rtx_code code, machine_mode mode, case ROTATE: case ROTATERT: { + /* The rotate count might be in SImode while int_mode might + be narrower. On IA-64 it is even DImode. If the shift + count is too large and doesn't fit into int_mode, we'd + ICE. So, if int_mode is narrower than word, use + word_mode for the shift count. */ + if (GET_MODE (op1) == VOIDmode + && GET_MODE_PRECISION (int_mode) < BITS_PER_WORD) + pop1 = rtx_mode_t (op1, word_mode); + if (wi::neg_p (pop1)) return NULL_RTX; @@ -5208,7 +5226,11 @@ simplify_const_binary_operation (enum rtx_code code, machine_mode mode, case ASHIFT: if (CONST_SCALAR_INT_P (op1)) { - wide_int shift = rtx_mode_t (op1, mode); + wide_int shift + = rtx_mode_t (op1, + GET_MODE (op1) == VOIDmode + && GET_MODE_PRECISION (int_mode) < BITS_PER_WORD + ? word_mode : mode); if (SHIFT_COUNT_TRUNCATED) shift = wi::umod_trunc (shift, GET_MODE_PRECISION (int_mode)); else if (wi::geu_p (shift, GET_MODE_PRECISION (int_mode))) diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc index e22bc66a6c8..399d6f874dc 100644 --- a/gcc/targhooks.cc +++ b/gcc/targhooks.cc @@ -1843,6 +1843,20 @@ no_c99_libc_has_function (enum function_class fn_class ATTRIBUTE_UNUSED, return false; } +/* Assume some c99 functions are present at the runtime including sincos. */ +bool +bsd_libc_has_function (enum function_class fn_class, + tree type ATTRIBUTE_UNUSED) +{ + if (fn_class == function_c94 + || fn_class == function_c99_misc + || fn_class == function_sincos) + return true; + + return false; +} + + tree default_builtin_tm_load_store (tree ARG_UNUSED (type)) { diff --git a/gcc/targhooks.h b/gcc/targhooks.h index ecfa11287ef..ecce55ebe79 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -212,6 +212,7 @@ extern bool default_libc_has_function (enum function_class, tree); extern bool default_libc_has_fast_function (int fcode); extern bool no_c99_libc_has_function (enum function_class, tree); extern bool gnu_libc_has_function (enum function_class, tree); +extern bool bsd_libc_has_function (enum function_class, tree); extern tree default_builtin_tm_load_store (tree); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 3d70f27149e..d3022f1a6d7 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,856 @@ +2022-04-27 Thomas Koenig <tkoenig@gcc.gnu.org> + + * gfortran.dg/pr70673.f90: Removed second invalid + line. + +2022-04-27 Marek Polacek <polacek@redhat.com> + + PR c++/105398 + * g++.dg/cpp1y/lambda-generic-enum2.C: New test. + +2022-04-27 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/104492 + * g++.dg/warn/pr104492.C: New test. + +2022-04-27 Thomas Koenig <tkoenig@gcc.gnu.org> + + PR fortran/70673 + PR fortran/78054 + * gfortran.dg/pr70673.f90: Remove invalid statement. + * gfortran.dg/pr70673_2.f90: New test to check that + ICE does not re-appear. + +2022-04-27 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/103662 + PR fortran/105379 + * gfortran.dg/class_dummy_8.f90: New test. + * gfortran.dg/class_dummy_9.f90: New test. + +2022-04-27 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/102043 + PR fortran/105381 + * gfortran.dg/character_array_dummy_1.f90: New test. + +2022-04-27 Christophe Lyon <christophe.lyon@arm.com> + + PR tree-optimization/105374 + * gcc.target/arm/simd/pr105374.C: New. + +2022-04-27 Andreas Krebbel <krebbel@linux.ibm.com> + + PR target/102024 + * g++.target/s390/pr102024-1.C: New test. + * g++.target/s390/pr102024-2.C: New test. + * g++.target/s390/pr102024-3.C: New test. + * g++.target/s390/pr102024-4.C: New test. + * g++.target/s390/pr102024-5.C: New test. + * g++.target/s390/pr102024-6.C: New test. + +2022-04-27 Jakub Jelinek <jakub@redhat.com> + + PR sanitizer/105396 + * gcc.dg/asan/pr105396.c: New test. + +2022-04-27 Kewen Lin <linkw@linux.ibm.com> + + PR target/105271 + * gcc.target/powerpc/pr105271.c: New test. + +2022-04-26 Jason Merrill <jason@redhat.com> + + PR c++/102629 + * g++.dg/cpp2a/lambda-pack-init7.C: New test. + +2022-04-26 Patrick Palka <ppalka@redhat.com> + + PR c++/105386 + * g++.dg/cpp0x/decltype81.C: New test. + +2022-04-26 Segher Boessenkoool <segher@kernel.crashing.org> + + PR target/105349 + * lib/target-supports.exp (check_effective_target_has_arch_pwr5): Use + the specified dg-options. + (check_effective_target_has_arch_pwr6): Ditto. + (check_effective_target_has_arch_pwr7): Ditto. + (check_effective_target_has_arch_pwr8): Ditto. + (check_effective_target_has_arch_pwr9): Ditto. + (check_effective_target_has_arch_pwr10): Ditto. + (check_effective_target_has_arch_ppc64): Ditto. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/105314 + * gcc.target/riscv/pr105314.c: New test. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR c++/65211 + * g++.target/i386/vec-tmpl1.C: Add -Wno-psabi as + dg-additional-options. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR target/105367 + * gcc.target/i386/pr105367.c: New test. + +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR fortran/103662 + * lib/target-supports.exp (check_effective_target___OPTIMIZE__): Add + a var definition to avoid pedwarn about empty translation unit. + * gfortran.dg/unlimited_polymorphic_3.f03: Remove -ftree-dse from + dg-additional-options, guard scan-tree-dump-not directives on + __OPTIMIZE__ target. + +2022-04-26 Jason Merrill <jason@redhat.com> + + PR c++/104624 + * g++.dg/cpp1y/lambda-generic-variadic22.C: New test. + +2022-04-26 Patrick Palka <ppalka@redhat.com> + + PR c++/105304 + * g++.dg/cpp2a/concepts-requires30.C: New test. + +2022-04-26 Patrick Palka <ppalka@redhat.com> + + PR c++/105289 + PR c++/86193 + * g++.dg/template/partial-specialization11.C: New test. + * g++.dg/template/partial-specialization12.C: New test. + +2022-04-25 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/105365 + PR analyzer/105366 + * gcc.dg/analyzer/pr105365.c: New test. + * gcc.dg/analyzer/pr105366.c: New test. + +2022-04-25 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/104308 + * gcc.dg/analyzer/pr104308.c: Add test coverage. + +2022-04-25 Jakub Jelinek <jakub@redhat.com> + Thomas Schwinge <thomas@codesourcery.com> + + PR fortran/104717 + * gfortran.dg/goacc/pr104717.f90: New test. + * gfortran.dg/goacc/privatization-1-compute-loop.f90: Adjust. + +2022-04-25 Marek Polacek <polacek@redhat.com> + + PR c++/105353 + * g++.dg/ext/builtin-shufflevector-3.C: New test. + +2022-04-25 Andrew MacLeod <amacleod@redhat.com> + + PR tree-optimization/105276 + * g++.dg/pr105276.C: New. + +2022-04-25 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/103662 + * gfortran.dg/unlimited_polymorphic_3.f03: Force execution of + the DSE optimization pass. + +2022-04-25 Richard Biener <rguenther@suse.de> + + PR tree-optimization/100810 + * gcc.dg/torture/pr100810.c: New testcase. + * gcc.dg/torture/pr105337.c: Likewise. + +2022-04-25 Richard Biener <rguenther@suse.de> + + PR rtl-optimization/105231 + * gcc.dg/torture/pr105231.c: New testcase. + +2022-04-25 Hongyu Wang <hongyu.wang@intel.com> + + PR target/105339 + * gcc.target/i386/sse-14.c: Add tests for new macro. + +2022-04-24 Jeff Law <jeffreyalaw@gmail.com> + + * gcc.dg/lto/pr94157_0.c: Also request executable stack from + the linker. + +2022-04-24 Mikael Morin <mikael@gcc.gnu.org> + Jakub Jelinek <jakub@redhat.com> + + PR fortran/103662 + * gfortran.dg/unlimited_polymorphic_3.f03 (foo): Separate + bind(c) and sequence checks to... + (foo_bc, foo_sq): ... two different procedures. + (main, foo*): Change type declarations so that type name, + component name, and either bind(c) or sequence attribute match + between the main type declarations and the procedure type + declarations. + (toplevel): Add optimization dump checks. + +2022-04-23 Jakub Jelinek <jakub@redhat.com> + + PR target/105338 + * gcc.target/i386/pr105338.c: New test. + +2022-04-22 Mikael Morin <mikael@gcc.gnu.org> + Richard Biener <rguenther@suse.de> + + PR fortran/102043 + * gfortran.dg/array_reference_3.f90: New. + * gfortran.dg/negative_stride_1.f90: New. + * gfortran.dg/vector_subscript_8.f90: New. + * gfortran.dg/vector_subscript_9.f90: New. + * gfortran.dg/c_loc_test_22.f90: Update dump patterns. + * gfortran.dg/finalize_10.f90: Same. + +2022-04-22 Mikael Morin <mikael@gcc.gnu.org> + + PR fortran/102043 + * gfortran.dg/dependency_49.f90: Update variable occurence + count. + +2022-04-22 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/105333 + * gcc.dg/pr105333.c: New test. + +2022-04-21 Segher Boessenkool <segher@kernel.crashing.org> + + PR target/103197 + PR target/102146 + * gcc.target/powerpc/bswap-brw.c: Add xfail on scan-assembler for -m32. + +2022-04-21 Segher Boessenkool <segher@kernel.crashing.org> + + * lib/target-supports.exp (check_effective_target_has_arch_ppc64): New. + +2022-04-21 Marek Polacek <polacek@redhat.com> + + PR c++/105321 + * g++.dg/cpp0x/constexpr-105321.C: New test. + +2022-04-21 Fritz Reese <foreese@gcc.gnu.org> + + PR fortran/105310 + * gfortran.dg/dec_union_12.f90: New test. + +2022-04-21 Jakub Jelinek <jakub@redhat.com> + + PR debug/105203 + * gfortran.dg/g77/pr105203.f: New test. + +2022-04-20 Ed Catmur <ed@catmur.uk> + + PR c++/104996 + * g++.dg/cpp0x/initlist129.C: New test. + +2022-04-20 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105312 + * gcc.target/arm/pr105312.c: New testcase. + +2022-04-20 Jan Hubicka <hubicka@ucw.cz> + + * gcc.c-torture/compile/103818.c: New test. + +2022-04-20 Jakub Jelinek <jakub@redhat.com> + + PR ipa/105306 + * g++.dg/opt/pr105306.C: New test. + +2022-04-19 Jakub Jelinek <jakub@redhat.com> + + PR target/105257 + * gcc.dg/pr105257.c: New test. + +2022-04-19 Jakub Jelinek <jakub@redhat.com> + + PR c++/105256 + * g++.dg/cpp0x/pr105256.C: New test. + +2022-04-19 Richard Biener <rguenther@suse.de> + + PR tree-optimization/104010 + PR tree-optimization/103941 + * gcc.target/i386/pr103941-1.c: New testcase. + * gcc.target/i386/pr103941-2.c: Likewise. + +2022-04-19 Richard Biener <rguenther@suse.de> + + PR tree-optimization/104880 + * g++.dg/opt/pr104880.cc: Rename to ... + * g++.dg/opt/pr104880.C: ... this. + +2022-04-18 Kewen Lin <linkw@linux.ibm.com> + + PR testsuite/105266 + * gcc.dg/pr105250.c: Skip for powerpc*-*-* and s390*-*-*. + +2022-04-15 Paul A. Clarke <pc@us.ibm.com> + + * g++.dg/debug/dwarf2/const2.C: Move to g++.target/powerpc. + * g++.dg/other/darwin-minversion-1.C: Likewise. + * g++.dg/eh/ppc64-sighandle-cr.C: Likewise. + * g++.dg/eh/simd-5.C: Likewise. + * g++.dg/eh/simd-4.C: Move to g++.target/powerpc, adjust dg directives. + * g++.dg/eh/uncaught3.C: Likewise. + * g++.dg/other/spu2vmx-1.C: Likewise. + * g++.target/powerpc/const2.C: New file. + * g++.target/powerpc/darwin-minversion-1.C: New file. + * g++.target/powerpc/ppc64-sighandle-cr.C: New file. + * g++.target/powerpc/simd-4.C: New file. + * g++.target/powerpc/simd-5.C: New file. + * g++.target/powerpc/spu2vmx-1.C: New file. + * g++.target/powerpc/uncaught3.C: New file. + +2022-04-15 Marek Polacek <polacek@redhat.com> + + PR c++/105268 + * g++.dg/concepts/variadic6.C: New test. + +2022-04-15 Hongyu Wang <hongyu.wang@intel.com> + + * gcc.target/i386/crc32-6.c: Adjust dg-error message. + * gcc.target/i386/crc32-7.c: New test. + +2022-04-15 Jason Merrill <jason@redhat.com> + + PR c++/102804 + * g++.dg/ext/unsigned-typedef1.C: New test. + +2022-04-15 Jason Merrill <jason@redhat.com> + + PR c++/102987 + * g++.dg/diagnostic/using1.C: New test. + +2022-04-14 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/105264 + * gcc.dg/analyzer/torture/symbolic-10.c: New test. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/104646 + * g++.dg/cpp0x/constexpr-fno-elide-ctors1.C: New test. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/82980 + * g++.dg/cpp0x/lambda/lambda-current-inst1.C: New test. + +2022-04-14 Indu Bhagat <indu.bhagat@oracle.com> + + PR debug/105089 + * gcc.dg/debug/ctf/ctf-array-2.c: Refactor testcase. Move some + checks ... + * gcc.dg/debug/ctf/ctf-array-5.c: ... to here. + * gcc.dg/debug/ctf/ctf-variables-3.c: ... and here. Add + additional checks for one CTF variable and one CTF object info + record. + +2022-04-14 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/105252 + * gcc.dg/analyzer/pr105252.c: New test. + +2022-04-14 Jakub Jelinek <jakub@redhat.com> + + PR target/105247 + * gcc.c-torture/compile/pr105247.c: New test. + +2022-04-14 Robin Dapp <rdapp@linux.ibm.com> + + * gcc.target/s390/pr80725.c: Add -Wno-int-to-pointer-cast. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/65211 + * g++.target/i386/vec-tmpl1.C: New test. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/97219 + * g++.dg/cpp1y/lambda-generic-local-fn1.C: New test. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/101698 + * g++.dg/template/conv19.C: New test. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/101442 + * g++.dg/cpp0x/initlist-nrv1.C: New test. + +2022-04-14 Jason Merrill <jason@redhat.com> + + PR c++/105265 + PR c++/100838 + * g++.dg/cpp0x/initlist-new6.C: New test. + +2022-04-13 Richard Sandiford <richard.sandiford@arm.com> + + PR tree-optimization/105254 + * g++.dg/vect/pr105254.cc: New test. + +2022-04-13 Tobias Burnus <tobias@codesourcery.com> + + PR fortran/105242 + * gfortran.dg/gomp/loop-exit.f90: New test. + +2022-04-13 Jason Merrill <jason@redhat.com> + + PR c++/105245 + PR c++/100111 + * g++.dg/cpp1y/constexpr-empty2.C: Add -fno-elide-constructors. + +2022-04-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105263 + * gcc.dg/pr105263.c: New testcase. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + PR middle-end/105253 + * gcc.target/i386/pr105253.c: New test. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + PR c++/105233 + * g++.dg/cpp2a/is-constant-evaluated13.C: New test. + +2022-04-13 Martin Jambor <mjambor@suse.cz> + + PR testsuite/105183 + * gcc.dg/ipa/remref-7.c: Add --param max-inline-insns-auto=100 to options. + +2022-04-13 Marek Polacek <polacek@redhat.com> + + PR c++/97296 + * g++.dg/cpp0x/ref-bind4.C: Add dg-error. + * g++.dg/cpp0x/ref-bind8.C: New test. + +2022-04-13 Richard Biener <rguenther@suse.de> + + PR middle-end/105259 + * gcc.target/i386/auto-init-4.c: Adjust. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + PR target/105234 + * gcc.c-torture/compile/pr105234.c: New test. + +2022-04-13 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105250 + * gcc.dg/pr105250.c: New testcase. + +2022-04-13 Alexandre Oliva <oliva@adacore.com> + + * gcc.target/powerpc/pr60203.c: Skip on no 128-bit long double. + +2022-04-13 Alexandre Oliva <oliva@adacore.com> + + PR target/102146 + * gcc.target/powerpc/pr56605.c: Accept SImode compare operand. + +2022-04-13 Xi Ruoyao <xry111@mengyan1223.wang> + + * gcc.target/mips/pr102024-4.c (dg-options): Add + -ffat-lto-objects. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104293 + * jit.dg/all-non-failing-tests.h: Mention + test-setting-alignment. + * jit.dg/test-setting-alignment.c: New test. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104072 + * jit.dg/all-non-failing-tests.h: Add new + test-register-variable. + * jit.dg/harness.h: Add -fdiagnostics-color=never to context's + command-line options. + * jit.dg/test-error-register-variable-bad-name.c: New test. + * jit.dg/test-error-register-variable-size-mismatch.c: New test. + * jit.dg/test-register-variable.c: New test. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR jit/104071 + * jit.dg/all-non-failing-tests.h: Add new test-bitcast. + * jit.dg/test-bitcast.c: New test. + * jit.dg/test-error-bad-bitcast.c: New test. + * jit.dg/test-error-bad-bitcast2.c: New test. + +2022-04-12 Antoni Boucher <bouanto@zoho.com> + + PR target/95325 + * jit.dg/test-types.c: Add tests for sized integer types. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/104669 + * g++.target/i386/mv31.C: New test. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/102071 + * g++.dg/cpp1z/aligned-new9.C: Add single-object test. + +2022-04-12 Patrick Palka <ppalka@redhat.com> + + PR c++/103105 + * g++.dg/cpp2a/concepts-requires29.C: New test. + * g++.dg/cpp2a/concepts-requires29a.C: New test. + +2022-04-12 Richard Earnshaw <rearnsha@arm.com> + + PR target/101755 + * gcc.target/arm/reg_equal_test.c: Convert to gimple test. Restrict + to architectures with MOVW/MOVT. + +2022-04-12 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105235 + * g++.dg/opt/pr105235-1.C: New testcase. + +2022-04-12 Przemyslaw Wirkus <Przemyslaw.Wirkus@arm.com> + + PR target/104144 + * gcc.target/arm/multilib.exp: Updated tests. + +2022-04-12 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105226 + * gcc.dg/pr105226.c: New testcase. + +2022-04-12 Jakub Jelinek <jakub@redhat.com> + + PR target/105214 + * gcc.dg/asan/pr105214.c: New test. + +2022-04-12 Jakub Jelinek <jakub@redhat.com> + + PR rtl-optimization/105211 + * gcc.dg/pr105211.c: New test. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/104142 + * g++.dg/opt/const7.C: New test. + +2022-04-12 Jason Merrill <jason@redhat.com> + + PR c++/105223 + PR c++/92918 + * g++.dg/template/using31.C: New test. + +2022-04-11 Peter Bergner <bergner@linux.ibm.com> + + PR target/104894 + * gcc.target/powerpc/pr104894.c: New test. + * gcc.target/powerpc/pr104894-2.c: New test. + +2022-04-11 Jason Merrill <jason@redhat.com> + + PR c++/98249 + * g++.dg/lookup/new3.C: New test. + +2022-04-11 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105218 + * gcc.dg/pr105218.c: New test. + +2022-04-11 Alexandre Oliva <oliva@adacore.com> + + PR target/104253 + * gcc.target/powerpc/pr104253.c: Add missing dg- before + require-effective-target. Prune warning about -mfloat128 + possibly not being fully supported. + +2022-04-11 Tamar Christina <tamar.christina@arm.com> + + PR target/105197 + * gcc.target/aarch64/sve/pr105197-1.c: New test. + * gcc.target/aarch64/sve/pr105197-2.c: New test. + +2022-04-11 Jason Merrill <jason@redhat.com> + + PR c++/100370 + * g++.dg/warn/Wplacement-new-size-11.C: New test. + +2022-04-11 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/104639 + * gcc.dg/tree-ssa/pr104639-1.c: New test. + * gcc.dg/tree-ssa/pr104639-2.c: New test. + +2022-04-11 Jakub Jelinek <jakub@redhat.com> + + PR c++/105186 + * c-c++-common/pr105186.c: New test. + +2022-04-11 Kewen Lin <linkw@linux.ibm.com> + + PR testsuite/103196 + * gcc.target/powerpc/p9-vec-length-epil-7.c: Add option + -fdisable-tree-cunroll. + * gcc.target/powerpc/p9-vec-length-full-7.c: Likewise. + +2022-04-10 Harald Anlauf <anlauf@gmx.de> + + PR fortran/105184 + * gfortran.dg/coarray_44.f90: Adjust expected output. + * gfortran.dg/coarray_allocate_11.f90: Likewise. + * gfortran.dg/coarray_allocate_12.f90: New test. + +2022-04-09 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/103892 + * gcc.dg/analyzer/pr103892.c: New test. + * gcc.dg/analyzer/pr96841.c: Drop redundant + -Wno-analyzer-too-complex. + +2022-04-09 Jan Hubicka <hubicka@ucw.cz> + + PR ipa/103376 + * gcc.c-torture/compile/pr103376.c: New test. + +2022-04-09 Jan Hubicka <hubicka@ucw.cz> + + * gcc.dg/ipa/pr105160.c: New test. + +2022-04-09 Xi Ruoyao <xry111@mengyan1223.wang> + + * gcc.dg/stack-usage-1.c: Adjust for LoongArch LP64. + +2022-04-09 Xi Ruoyao <xry111@mengyan1223.wang> + + * gcc.dg/builtin-apply2.c (dg-skip-if): Add loongarch*-*-*. + +2022-04-09 Jason Merrill <jason@redhat.com> + + PR c++/105191 + PR c++/92385 + * g++.dg/cpp0x/constexpr-array28.C: New test. + +2022-04-09 Jason Merrill <jason@redhat.com> + + PR c++/91618 + PR c++/96604 + * g++.dg/cpp0x/friend7.C: Remove xfail. + * g++.dg/template/friend72.C: New test. + * g++.dg/template/friend72a.C: New test. + * g++.dg/template/friend73.C: New test. + +2022-04-08 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105198 + * gcc.dg/torture/pr105198.c: New testcase. + +2022-04-08 Jakub Jelinek <jakub@redhat.com> + + PR c++/105187 + * c-c++-common/torture/20050113-1.c: Add dg-additional-options + -Wno-psabi. + +2022-04-08 Jakub Jelinek <jakub@redhat.com> + + PR c/105149 + * gcc.dg/pr105149.c: New test. + +2022-04-08 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105189 + * g++.dg/torture/pr105189.C: New test. + +2022-04-08 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105175 + * gcc.dg/pr105175.c: New testcase. + +2022-04-07 Michael Meissner <meissner@linux.ibm.com> + + PR target/104253 + * lib/target-supports.exp (check_ppc_float128_sw_available): Do + not run float128 tests on VxWorks. + (check_ppc_float128_hw_available): Likewise. + (check_effective_target_ppc_ieee128_ok): Likewise. + +2022-04-07 Tamar Christina <tamar.christina@arm.com> + + PR testsuite/105196 + * gcc.dg/vect/complex/fast-math-complex-add-pattern-float.c: Remove slp1 check. + +2022-04-07 Richard Biener <rguenther@suse.de> + Jan Hubicka <hubicka@ucw.cz> + + PR ipa/104303 + * gnat.dg/concat5.adb: New. + * gnat.dg/concat5_pkg1.adb: Likewise. + * gnat.dg/concat5_pkg1.ads: Likewise. + * gnat.dg/concat5_pkg2.adb: Likewise. + * gnat.dg/concat5_pkg2.ads: Likewise. + +2022-04-07 David Malcolm <dmalcolm@redhat.com> + + PR analyzer/102208 + * gcc.dg/analyzer/symbolic-9.c: New test. + * gcc.dg/analyzer/torture/leak-pr102308-1.c: New test. + * gcc.dg/analyzer/torture/leak-pr102308-2.c: New test. + +2022-04-07 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105185 + * gcc.dg/torture/pr105185.c: New testcase. + +2022-04-07 Tamar Christina <tamar.christina@arm.com> + + PR target/104049 + * gcc.target/aarch64/vadd_reduc-1.c: New test. + * gcc.target/aarch64/vadd_reduc-2.c: New test. + +2022-04-07 Tamar Christina <tamar.christina@arm.com> + + PR testsuite/105095 + * gcc.dg/vect/complex/fast-math-complex-add-double.c: Update for codegen. + * gcc.dg/vect/complex/fast-math-complex-add-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-add-half-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-add-pattern-double.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-add-pattern-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-add-pattern-half-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mla-half-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mls-double.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mls-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mls-half-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mul-double.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mul-float.c: Likewise. + * gcc.dg/vect/complex/fast-math-complex-mul-half-float.c: Likewise. + * gcc.dg/vect/vect.exp: Add extra letter to filter. + +2022-04-07 Tamar Christina <tamar.christina@arm.com> + + * gcc.target/aarch64/pr103350-1.c: Skip on BE. + * gcc.target/aarch64/pr103350-2.c: Likewise. + +2022-04-07 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/102586 + * g++.dg/torture/builtin-clear-padding-5.C: New test. + * g++.dg/cpp2a/builtin-clear-padding1.C (bar): Uncomment one + call that is now accepted. + +2022-04-07 Jakub Jelinek <jakub@redhat.com> + + PR tree-optimization/105150 + * gcc.dg/pr105150.c: New test. + +2022-04-07 Richard Biener <rguenther@suse.de> + + PR middle-end/105165 + * gcc.dg/pr105165.c: New testcase. + +2022-04-07 Andreas Krebbel <krebbel@linux.ibm.com> + + PR target/105147 + * gcc.dg/pr105140.c: Skip for s390*-*-*. + +2022-04-07 Jason Merrill <jason@redhat.com> + + PR c++/101051 + * g++.dg/cpp0x/trailing15.C: New test. + +2022-04-07 Jason Merrill <jason@redhat.com> + + PR c++/101717 + * g++.dg/cpp1y/lambda-generic-this4.C: New test. + +2022-04-07 Jason Merrill <jason@redhat.com> + + PR c++/105187 + * gcc.c-torture/compile/20050113-1.c: Moved to... + * c-c++-common/torture/20050113-1.c: ...here. + +2022-04-06 Jakub Jelinek <jakub@redhat.com> + + PR c++/104668 + * g++.dg/cpp0x/pr104668.C: New test. + +2022-04-06 Patrick Palka <ppalka@redhat.com> + + PR c++/105143 + * g++.dg/cpp2a/nodiscard1.C: New test. + * g++.dg/warn/Wctad-maybe-unsupported4.C: New test. + +2022-04-06 Segher Boessenkool <segher@kernel.crashing.org> + + PR target/105147 + * gcc.dg/pr105140.c: Skip for powerpc*-*-*. + +2022-04-06 Jason Merrill <jason@redhat.com> + + PR c++/104702 + * g++.dg/warn/Wunused-19.C: New test. + +2022-04-06 Xi Ruoyao <xry111@mengyan1223.wang> + + * g++.target/mips/cxx17_empty_base.C: New test. + +2022-04-06 Jason Merrill <jason@redhat.com> + + PR c++/100608 + * g++.dg/warn/Wshadow-compatible-local-3.C: New test. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105173 + * gcc.dg/pr105173.c: New testcase. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR ipa/105166 + * gcc.dg/torture/pr105166.c: New testcase. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105163 + * gcc.dg/torture/pr105163.c: New testcase. + +2022-04-06 Richard Sandiford <richard.sandiford@arm.com> + + PR tree-optimization/103761 + * gcc.dg/vect/pr103761.c: New test. + * gcc.target/aarch64/sve/pr103761.c: Likewise. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105148 + * gcc.dg/torture/pr105148.c: New testcase. + +2022-04-06 Roger Sayle <roger@nextmovesoftware.com> + + * gcc.target/i386/sse2-v1ti-andnot.c: New test case. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR tree-optimization/105142 + * g++.dg/torture/pr105142.C: New testcase. + +2022-04-06 Richard Biener <rguenther@suse.de> + + PR testsuite/105122 + * gcc.dg/memcpy-6.c: Adjust. + * gcc.dg/strlenopt-73.c: Likewise. + * gcc.dg/strlenopt-80.c: Likewise. + 2022-04-05 Sandra Loosemore <sandra@codesourcery.com> * gfortran.dg/gomp/masked-taskloop.f90: New. diff --git a/gcc/testsuite/c-c++-common/pr105186.c b/gcc/testsuite/c-c++-common/pr105186.c new file mode 100644 index 00000000000..ea687eacc4c --- /dev/null +++ b/gcc/testsuite/c-c++-common/pr105186.c @@ -0,0 +1,5 @@ +/* PR c++/105186 */ +/* { dg-do compile } */ + +__attribute__((__int128)) int i; /* { dg-warning "'__int128' attribute directive ignored" } */ +__attribute__((__int128__)) int j; /* { dg-warning "'__int128' attribute directive ignored" } */ diff --git a/gcc/testsuite/gcc.c-torture/compile/20050113-1.c b/gcc/testsuite/c-c++-common/torture/20050113-1.c index 6e36ed6fd7c..8ec4935352c 100644 --- a/gcc/testsuite/gcc.c-torture/compile/20050113-1.c +++ b/gcc/testsuite/c-c++-common/torture/20050113-1.c @@ -1,4 +1,5 @@ /* PR c/17297 */ +/* { dg-additional-options "-Wno-psabi" } */ typedef float V2SF __attribute__ ((vector_size (8))); diff --git a/gcc/testsuite/g++.dg/concepts/variadic6.C b/gcc/testsuite/g++.dg/concepts/variadic6.C new file mode 100644 index 00000000000..0b386b0cd6d --- /dev/null +++ b/gcc/testsuite/g++.dg/concepts/variadic6.C @@ -0,0 +1,20 @@ +// PR c++/105268 +// { dg-do compile { target concepts } } + +template<typename> concept C_one = true; +template<typename...> concept C_many = true; + +template<bool B> struct S { }; + +template<typename T = S<C_one<int>>> void f(); +template<typename T = S<C_many<int>>> void g(); + +void +fn (auto a = S<C_one<int>>{}) +{ +} + +void +fn2 (auto a = S<C_many<int>>{}) +{ +} diff --git a/gcc/testsuite/g++.dg/coroutines/pr103868.C b/gcc/testsuite/g++.dg/coroutines/pr103868.C new file mode 100644 index 00000000000..8687effb563 --- /dev/null +++ b/gcc/testsuite/g++.dg/coroutines/pr103868.C @@ -0,0 +1,150 @@ +// { dg-additional-options "-fpreprocessed -std=gnu++20 -w -fconcepts" } +int _M_invoke___functor; +namespace std { +template <int __v> struct integral_constant { + static constexpr bool value = __v; +}; +template <typename> struct decay { typedef int type; }; +template <bool, typename> struct enable_if; +template <typename _Tp> struct enable_if<true, _Tp> { typedef _Tp type; }; +template <typename, typename _Fn, typename... _Args> +void __invoke_impl(_Fn __f, _Args... __args) { + __f(__args...); +} +template <typename, typename _Callable, typename... _Args> +void __invoke_r(_Callable __fn, _Args... __args) { + using __result = int; + using __type = __result; + __invoke_impl<__type>(__fn, __args...); +} +template <typename> class function; +template <typename _Functor> struct _Base_manager { + static _Functor *_M_get_pointer(int) {} +}; +template <typename, typename> class _Function_handler; +template <typename _Res, typename _Functor, typename... _ArgTypes> +struct _Function_handler<_Res(_ArgTypes...), _Functor> { + static _Res _M_invoke(_ArgTypes... __args) { + auto __trans_tmp_1 = + _Base_manager<_Functor>::_M_get_pointer(_M_invoke___functor); + __invoke_r<_Res>(*__trans_tmp_1, __args...); + } +}; +template <typename _Res, typename... _ArgTypes> +struct function<_Res(_ArgTypes...)> { + template <typename _Functor> function(_Functor) { + _Function_handler<_Res(_ArgTypes...), _Functor>::_M_invoke; + } +}; +template <typename _Tp> struct __shared_ptr_access { + using element_type = _Tp; + element_type *operator->(); +}; +template <typename> void make_shared(); +} // namespace std +namespace boost { +using std::decay; +using std::enable_if; +using std::integral_constant; +namespace asio { +namespace detail { +template <typename> struct is_completion_signature; +template <typename R, typename... Args> +struct is_completion_signature<R(Args...)> : integral_constant<true> {}; +} // namespace detail +template <typename T> +concept completion_signature = detail::is_completion_signature<T>::value; +template <typename...> struct async_result; +namespace detail { +template <completion_signature> +struct async_result_has_initiate_memfn : integral_constant<1> {}; +} // namespace detail +template <typename CompletionToken, completion_signature... Signatures, + typename Initiation> +enable_if<detail::async_result_has_initiate_memfn<Signatures...>::value, + decltype(async_result<typename decay<CompletionToken>::type, + Signatures...>::initiate(0))>::type +async_initiate(Initiation) {} +} // namespace asio +} // namespace boost +namespace malloy::websocket { +struct connection { + auto read(auto, auto done) { + auto wrapper = [] {}; + return boost::asio::async_initiate<decltype(done), void()>(wrapper); + } +}; +} // namespace malloy::websocket +namespace std { +template <typename...> struct coroutine_traits; +template <typename = void> struct coroutine_handle { + operator coroutine_handle<>(); +}; +struct suspend_always { + bool await_ready(); + void await_suspend(coroutine_handle<>); + void await_resume(); +}; +} // namespace std +namespace boost { +namespace asio { +namespace detail { +using std::coroutine_handle; +using std::suspend_always; +template <typename> class awaitable_frame; +} // namespace detail +template <typename, typename = int> struct awaitable { + bool await_ready(); + template <class U> + void await_suspend(detail::coroutine_handle<detail::awaitable_frame<U>>); + void await_resume(); +}; +namespace detail { +struct awaitable_frame_base { + auto initial_suspend() { return suspend_always(); } + auto final_suspend() noexcept { + struct result { + bool await_ready() noexcept; + void await_suspend(coroutine_handle<>) noexcept; + void await_resume() noexcept; + }; + return result{}; + } + void unhandled_exception(); + template <typename T> auto await_transform(T a) { return a; } +}; +template <> struct awaitable_frame<void> : awaitable_frame_base { + void get_return_object(); +}; +} // namespace detail +} // namespace asio +} // namespace boost +namespace std { +template <typename T, typename Executor, typename... Args> +struct coroutine_traits<boost::asio::awaitable<T, Executor>, Args...> { + typedef boost::asio::detail::awaitable_frame<T> promise_type; +}; +} // namespace std +namespace boost { +namespace asio { +struct use_awaitable_t { + use_awaitable_t(char, int, char); +} use_awaitable(0, 0, 0); +template <typename Executor, typename R, typename... Args> +struct async_result<Executor, R(Args...)> { + template <typename Initiation> static awaitable<int> initiate(Initiation); +}; +} // namespace asio +} // namespace boost +namespace malloy::test { +void roundtrip_coro(std::function<void(int)>); +} +using boost::asio::awaitable; +template <int> awaitable<void> client_ws_handler_coro() { + std::__shared_ptr_access<malloy::websocket::connection> conn; + auto buffer = std::make_shared<int>; + co_await conn->read(buffer, boost::asio::use_awaitable); +} +void port() { + malloy::test::roundtrip_coro([](auto) { client_ws_handler_coro<false>; }); +} diff --git a/gcc/testsuite/g++.dg/coroutines/pr104051.C b/gcc/testsuite/g++.dg/coroutines/pr104051.C new file mode 100644 index 00000000000..ce7ae55405a --- /dev/null +++ b/gcc/testsuite/g++.dg/coroutines/pr104051.C @@ -0,0 +1,29 @@ +// { dg-additional-options "-fsyntax-only" } +#include <coroutine> +#include <vector> +template <typename> struct promise { + struct final_awaitable { + bool await_ready() noexcept; + template <typename Promise> + std::coroutine_handle<> + await_suspend(std::coroutine_handle<Promise>) noexcept; + void await_resume() noexcept; + }; + auto get_return_object() { + return std::coroutine_handle<promise>::from_promise(*this); + } + auto initial_suspend() { return std::suspend_always(); } + auto final_suspend() noexcept { return true; } + void unhandled_exception(); +}; +template <typename T> struct task { + using promise_type = promise<T>; + task(std::coroutine_handle<promise<T>>); + bool await_ready(); + std::coroutine_handle<> await_suspend(std::coroutine_handle<>); + T await_resume(); +}; +task<std::vector<int>> foo() { // { dg-error {awaitable type 'bool' is not a structure} } + while ((co_await foo()).empty()) + ; +} diff --git a/gcc/testsuite/g++.dg/coroutines/pr105287.C b/gcc/testsuite/g++.dg/coroutines/pr105287.C new file mode 100644 index 00000000000..9790945287d --- /dev/null +++ b/gcc/testsuite/g++.dg/coroutines/pr105287.C @@ -0,0 +1,48 @@ +// { dg-additional-options "-fanalyzer" } +// { dg-excess-errors "lots of analyzer output, but no ICE" } +namespace std { +template <typename _Result> struct coroutine_traits : _Result {}; +template <typename = void> struct coroutine_handle { + operator coroutine_handle<>(); +}; +} +struct coro1 { + using handle_type = std::coroutine_handle<>; + coro1(handle_type); + struct suspend_always_prt { + bool await_ready() noexcept; + void await_suspend(handle_type) noexcept; + void await_resume() noexcept; + }; + struct promise_type { + std::coroutine_handle<> ch_; + auto get_return_object() { return ch_; } + auto initial_suspend() { return suspend_always_prt{}; } + auto final_suspend() noexcept { return suspend_always_prt{}; } + void unhandled_exception(); + }; +}; +struct BoolAwaiter { + BoolAwaiter(bool); + bool await_ready(); + void await_suspend(std::coroutine_handle<>); + bool await_resume(); +}; +struct IntAwaiter { + IntAwaiter(int); + bool await_ready(); + void await_suspend(std::coroutine_handle<>); + int await_resume(); +}; +coro1 my_coro() { + int a = 1; + if (a == 0) { + int b = 5; + + } + { + int c = 10; + } + co_await BoolAwaiter(true) && co_await IntAwaiter(a); + + } diff --git a/gcc/testsuite/g++.dg/coroutines/pr105301.C b/gcc/testsuite/g++.dg/coroutines/pr105301.C new file mode 100644 index 00000000000..33a0b03cf5d --- /dev/null +++ b/gcc/testsuite/g++.dg/coroutines/pr105301.C @@ -0,0 +1,49 @@ +// { dg-additional-options "-fsyntax-only" } +namespace std { +template <class T, class = void> +struct traits_sfinae_base {}; + +template <class Ret, class... Args> +struct coroutine_traits : public traits_sfinae_base<Ret> {}; +} + +template<typename Promise> struct coro {}; +template <typename Promise, typename... Ps> +struct std::coroutine_traits<coro<Promise>, Ps...> { + using promise_type = Promise; +}; + +struct awaitable { + bool await_ready() noexcept; + template <typename F> + void await_suspend(F) noexcept; + void await_resume() noexcept; +} a; + +struct suspend_always { + bool await_ready() noexcept { return false; } + template <typename F> + void await_suspend(F) noexcept; + void await_resume() noexcept {} +}; + +namespace std { +template <class PromiseType = void> +struct coroutine_handle {}; +} + +struct bad_promise_6 { + coro<bad_promise_6> get_return_object(); + suspend_always initial_suspend(); + suspend_always final_suspend() noexcept; + void unhandled_exception(); + void return_void(); + void return_value(int) const; + void return_value(int); +}; + +coro<bad_promise_6> +bad_implicit_return() // { dg-error {.aka 'bad_promise_6'. declares both 'return_value' and 'return_void'} } +{ + co_await a; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-105321.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-105321.C new file mode 100644 index 00000000000..adb6830ff22 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-105321.C @@ -0,0 +1,18 @@ +// PR c++/105321 +// { dg-do compile { target c++11 } } + +bool handle_error(); + +constexpr int echo(int value, bool yes = true) noexcept +{ + return (yes || handle_error()), value; +} + +static_assert(echo(10) == 10, ""); + +constexpr int echo2(int value, bool no = false) noexcept +{ + return (!no || handle_error()), value; +} + +static_assert(echo2(10) == 10, ""); diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-array28.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-array28.C new file mode 100644 index 00000000000..d7706b9f0b4 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-array28.C @@ -0,0 +1,21 @@ +// PR c++/105191 +// { dg-do compile { target c++11 } } + +struct A { + const char* message = ""; +}; + +enum class B { }; + +struct C { + A a; + B b; +}; + +struct D { + C cs[1]; +}; + +constexpr D ds[4] = { + D{}, +}; diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-fno-elide-ctors1.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-fno-elide-ctors1.C new file mode 100644 index 00000000000..71c76fa0247 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-fno-elide-ctors1.C @@ -0,0 +1,89 @@ +// PR c++/104646 +// { dg-do compile { target c++11 } } +// { dg-additional-options -fno-elide-constructors } + +template <typename _T1> struct pair { + _T1 first; + int second; +}; +template <typename _Iterator> class __normal_iterator { + _Iterator __traits_type; + +public: + constexpr __normal_iterator() {} +}; +template <typename> class allocator; +template <typename> struct allocator_traits; +template <typename _Tp> struct allocator_traits<allocator<_Tp>> { + using value_type = _Tp; + template <typename _Up> using rebind_alloc = allocator<_Up>; +}; +template <typename _Alloc> struct __alloc_traits { + typedef allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type &const_reference; + template <typename _Tp> struct rebind { + typedef typename _Base_type::template rebind_alloc<_Tp> other; + }; +}; +template <typename _Tp, typename _Alloc> struct _Vector_base { + typedef typename __alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type; +}; +template <typename _Tp, typename _Alloc = allocator<_Tp>> class vector { +public: + typename __alloc_traits< + typename _Vector_base<_Tp, _Alloc>::_Tp_alloc_type>::const_reference + operator[](long); +}; +enum match_flag_type {}; +template <typename, typename> class Trans_NS___cxx11_basic_regex; +class Trans_NS___cxx11_match_results; +enum _RegexExecutorPolicy { _S_auto }; +template <typename, typename, typename _CharT, typename _TraitsT, + _RegexExecutorPolicy, bool> +bool __regex_algo_impl(Trans_NS___cxx11_match_results &, + const Trans_NS___cxx11_basic_regex<_CharT, _TraitsT> &); +template <typename, typename, typename, bool> class _Executor; +template <typename _Ch_type, typename = _Ch_type> +class Trans_NS___cxx11_basic_regex {}; +class Trans_NS___cxx11_match_results : vector<int> { + template <typename, typename, typename _Cp, typename _Rp, + _RegexExecutorPolicy, bool> + friend bool __regex_algo_impl(Trans_NS___cxx11_match_results &, + const Trans_NS___cxx11_basic_regex<_Cp, _Rp> &); +}; +template <typename _Bi_iter, typename _Alloc, typename _Ch_type, + typename _Rx_traits> +void regex_search(_Bi_iter, _Alloc, + Trans_NS___cxx11_basic_regex<_Ch_type, _Rx_traits>) { + __regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits, _S_auto, false>; +} +match_flag_type __regex_algo_impl___flags; +template <typename, typename, typename _CharT, typename _TraitsT, + _RegexExecutorPolicy, bool> +bool __regex_algo_impl( + Trans_NS___cxx11_match_results &__m, + const Trans_NS___cxx11_basic_regex<_CharT, _TraitsT> &__re) { + __normal_iterator<const char *> __e, __s; + _Executor<int, int, _TraitsT, false> __executor(__s, __e, __m, __re, + __regex_algo_impl___flags); + __executor._M_match(); + return false; +} +template <typename, typename, typename, bool> class _Executor { +public: + _Executor(__normal_iterator<const char *>, __normal_iterator<const char *>, + vector<int>, Trans_NS___cxx11_basic_regex<char>, match_flag_type); + void _M_match() { _M_dfs(); } + void _M_dfs(); + vector<pair<__normal_iterator<char *>>> _M_rep_count; +}; +long _M_rep_once_more___i; +template <typename _BiIter, typename _Alloc, typename _TraitsT, bool __dfs_mode> +void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::_M_dfs() { + auto __rep_count = _M_rep_count[_M_rep_once_more___i]; +} +char main___trans_tmp_1; +void main___trans_tmp_2() { + Trans_NS___cxx11_basic_regex<char> re; + regex_search(main___trans_tmp_1, main___trans_tmp_2, re); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/decltype81.C b/gcc/testsuite/g++.dg/cpp0x/decltype81.C new file mode 100644 index 00000000000..7d25db39d9c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/decltype81.C @@ -0,0 +1,15 @@ +// PR c++/105386 +// { dg-do compile { target c++11 } } + +template<class T> struct NoInst { + static_assert(sizeof(T) == 9999, "NoInst instantiated"); +}; + +template<class T> NoInst<T> f(T); + +template<class> +struct A { + using type = decltype(f(0)); +}; + +A<int> a; diff --git a/gcc/testsuite/g++.dg/cpp0x/friend7.C b/gcc/testsuite/g++.dg/cpp0x/friend7.C index e1d5f449f5c..4d0961c0397 100644 --- a/gcc/testsuite/g++.dg/cpp0x/friend7.C +++ b/gcc/testsuite/g++.dg/cpp0x/friend7.C @@ -21,7 +21,7 @@ struct S { friend class __attribute__((deprecated)) N3; [[deprecated]] friend void foo<>(int, int); // { dg-warning "attribute ignored" } [[deprecated]] friend void ::foo(int, int); // { dg-warning "attribute ignored" } - // { dg-bogus "should have" "PR100339" { xfail *-*-* } .-1 } + // { dg-bogus "should have" "PR100339" } }; template<typename T> diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist-new6.C b/gcc/testsuite/g++.dg/cpp0x/initlist-new6.C new file mode 100644 index 00000000000..0ef27806acf --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist-new6.C @@ -0,0 +1,39 @@ +// PR c++/105265 +// { dg-do run { target c++11 } } + +int c; + +class Block +{ +public: + Block(int n) : data{new char[n]}, size{n} + { + ++c; + } + + ~Block() + { + --c; + delete[] data; + } + +private: + char* data; + int size; +}; + +struct Cargo +{ + Block const& block; +}; + +int main() +{ + { + Cargo* c = new Cargo{{4000}}; + delete c; + } + if (c != 0) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist-nrv1.C b/gcc/testsuite/g++.dg/cpp0x/initlist-nrv1.C new file mode 100644 index 00000000000..e44dbecfece --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist-nrv1.C @@ -0,0 +1,34 @@ +// PR c++/101442 +// { dg-do run { target c++11 } } + +bool destroyed = false; + +struct A +{ + A() {} + A(const A &) = delete; + A &operator=(const A &) = delete; + ~A() {destroyed = true;} +}; + +struct B +{ + const A &a; + struct string { + string(const char*) { } + ~string() { } + } s; +}; + +B foo() +{ + B ret{ A{}, "" }; + return ret; +} + +int main() +{ + B b = foo(); + if (!destroyed) + __builtin_abort(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist129.C b/gcc/testsuite/g++.dg/cpp0x/initlist129.C new file mode 100644 index 00000000000..4d4faa9e08d --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist129.C @@ -0,0 +1,6 @@ +// PR c++/104996 +// { dg-do compile { target c++11 } } + +template<unsigned size> char f(int (&&)[size]); +template<unsigned size> int f(int const (&)[size]); +static_assert(sizeof(f({1, 2, 3})) == 1, ""); diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-current-inst1.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-current-inst1.C new file mode 100644 index 00000000000..a6631c5ca99 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-current-inst1.C @@ -0,0 +1,18 @@ +// PR c++/82980 +// { dg-do compile { target c++11 } } + +template <class T> +struct Outer +{ + template <class U> + void f(); + + void bar(Outer outer) { + [outer](){ outer.f<int>(); }; + } + void baz(Outer *p) { + [&](){ p->f<int>(); }; + } +}; + +int main() { } diff --git a/gcc/testsuite/g++.dg/cpp0x/pr105256.C b/gcc/testsuite/g++.dg/cpp0x/pr105256.C new file mode 100644 index 00000000000..98ce5e8b7bf --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/pr105256.C @@ -0,0 +1,18 @@ +// PR c++/105256 +// { dg-do compile { target c++11 } } + +int bar (int &); + +struct S { + struct T { + struct U { + int i = bar (i); + } u; + }; +}; + +void +foo (S::T *p) +{ + *p = {}; +}; diff --git a/gcc/testsuite/g++.dg/cpp0x/ref-bind4.C b/gcc/testsuite/g++.dg/cpp0x/ref-bind4.C index 85ac9fbfd79..d296d7c3b72 100644 --- a/gcc/testsuite/g++.dg/cpp0x/ref-bind4.C +++ b/gcc/testsuite/g++.dg/cpp0x/ref-bind4.C @@ -51,6 +51,6 @@ g (int *p, const int *pc, const int **q) similar types T1 and T2 (_conv.qual_), respectively, and the cv- qualification signature of type T1 is a proper subset of the cv- qualification signature of type T2 */ - f8 (q); + f8 (q); // { dg-error "call of overloaded" } f9 (q); } diff --git a/gcc/testsuite/g++.dg/cpp0x/ref-bind8.C b/gcc/testsuite/g++.dg/cpp0x/ref-bind8.C new file mode 100644 index 00000000000..eee78fd5e74 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/ref-bind8.C @@ -0,0 +1,10 @@ +// PR c++/97296 +// { dg-do compile } + +void f(const int * const &); +void f(const int *); +int *x; +int main() +{ + f(x); // { dg-error "call of overloaded" } +} diff --git a/gcc/testsuite/g++.dg/cpp0x/trailing15.C b/gcc/testsuite/g++.dg/cpp0x/trailing15.C new file mode 100644 index 00000000000..3fa74d08e39 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/trailing15.C @@ -0,0 +1,14 @@ +// PR c++/101051 +// { dg-do compile { target c++11 } } + +template <class T> +class Foo +{ + constexpr operator T() -> T {} // { dg-error "trailing return" } +}; + +struct S { + operator int() const -> double; // { dg-error "trailing return" } +}; + +class A { operator auto*() -> int; }; // { dg-error "auto|trailing return" } diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-empty2.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-empty2.C index 2acfa98364b..9768b89904e 100644 --- a/gcc/testsuite/g++.dg/cpp1y/constexpr-empty2.C +++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-empty2.C @@ -1,4 +1,5 @@ // { dg-do compile { target c++14 } } +// { dg-additional-options -fno-elide-constructors } struct A { diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-enum2.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-enum2.C new file mode 100644 index 00000000000..77cf0bb9d02 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-enum2.C @@ -0,0 +1,15 @@ +// PR c++/105398 +// { dg-do compile { target c++14 } } + +auto f = [](auto &&m) { + enum E { _,e3,e2,e1,C4,C3,C2,C1 }; + static constexpr int x_coeffs[3][4] = { + {e1,C2,C3,C4}, + {e2,C1,C3,C4}, + {e3,C1,C2,C4}, + }; +}; + +int main() { + f(0); +} diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-local-fn1.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-local-fn1.C new file mode 100644 index 00000000000..06919c535d8 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-local-fn1.C @@ -0,0 +1,17 @@ +// PR c++/97219 +// { dg-do compile { target c++14 } } + +struct B; + +template <typename T> +auto f(T *) { + void q(B *, void * = static_cast<T *>(0)); + return [](auto *p) { q(p); }; +} + +void q(void *) = delete; + +int main(void) { + B *bp = 0; + f(bp)(bp); +} diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-this4.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-this4.C new file mode 100644 index 00000000000..38d582bec5e --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-this4.C @@ -0,0 +1,7 @@ +// PR c++/101717 +// { dg-do compile { target c++14 } } + +struct x { + static void f() { } + void (*_)() = [] { [=](auto) { f(); }(0); }; +}; diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-variadic22.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-variadic22.C new file mode 100644 index 00000000000..670c598a865 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-variadic22.C @@ -0,0 +1,15 @@ +// PR c++/104624 +// { dg-do compile { target c++14 } } + +template <typename T> +auto f (T) +{ + auto a = [](auto ... i) // { dg-prune-output "incomplete type" } + { + int x[][i] = { 0 }; // { dg-error "not expanded" } + }(); +} +void g () +{ + f(0); +} diff --git a/gcc/testsuite/g++.dg/cpp1z/aligned-new9.C b/gcc/testsuite/g++.dg/cpp1z/aligned-new9.C index 7854299419a..3fa0ed996bd 100644 --- a/gcc/testsuite/g++.dg/cpp1z/aligned-new9.C +++ b/gcc/testsuite/g++.dg/cpp1z/aligned-new9.C @@ -23,4 +23,8 @@ int main() X *p = new X[n]; if (nalign != align) __builtin_abort (); + + X *p2 = new X; + if (nalign != alignof (X)) + __builtin_abort (); } diff --git a/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C b/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C index 7b1282e7798..ed74ebf19c3 100644 --- a/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C +++ b/gcc/testsuite/g++.dg/cpp2a/builtin-clear-padding1.C @@ -43,7 +43,7 @@ bar () __builtin_clear_padding (&c2); __builtin_clear_padding (&c3); __builtin_clear_padding (&c4); -// __builtin_clear_padding (&c5); + __builtin_clear_padding (&c5); __builtin_clear_padding (&c6); __builtin_clear_padding (&c7); __builtin_clear_padding (&c8); diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-requires29.C b/gcc/testsuite/g++.dg/cpp2a/concepts-requires29.C new file mode 100644 index 00000000000..2cf69433d99 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-requires29.C @@ -0,0 +1,18 @@ +// PR c++/103105 +// { dg-do compile { target c++20 } } + +template<bool> struct A; + +template<class... Ts> +using wrap = A<1 != (0 + ... + requires { Ts(); })>; + +template<class... Ts> using type = wrap<Ts...>; + +using ty0 = type<>; +using ty0 = A<true>; + +using ty1 = type<int>; +using ty1 = A<false>; + +using ty2 = type<int, int>; +using ty2 = A<true>; diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-requires29a.C b/gcc/testsuite/g++.dg/cpp2a/concepts-requires29a.C new file mode 100644 index 00000000000..84c226918f5 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-requires29a.C @@ -0,0 +1,23 @@ +// PR c++/103105 +// { dg-do compile { target c++20 } } + +template<class...> struct list; + +template<bool> struct A; + +template<class T, class... Ts> +using wrap = A<1 != (0 + ... + requires { T() = Ts(); })>; + +template<class... Ts> using type = list<wrap<Ts, Ts...>...>; + +using ty0 = type<>; +using ty0 = list<>; + +using ty1 = type<int>; +using ty1 = list<A<true>>; + +using ty2 = type<int, int>; +using ty2 = list<A<true>, A<true>>; + +using ty3 = type<int, int, int>; +using ty3 = list<A<true>, A<true>, A<true>>; diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-requires30.C b/gcc/testsuite/g++.dg/cpp2a/concepts-requires30.C new file mode 100644 index 00000000000..f500af3f616 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-requires30.C @@ -0,0 +1,10 @@ +// PR c++/105304 +// { dg-do compile { target c++20 } } +// { dg-additional-options "-Wall -Wsequence-point" } + +struct A { }; + +int main() { + if (requires { A(); }) + ; +} diff --git a/gcc/testsuite/g++.dg/cpp2a/is-constant-evaluated13.C b/gcc/testsuite/g++.dg/cpp2a/is-constant-evaluated13.C new file mode 100644 index 00000000000..4a8af29b086 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/is-constant-evaluated13.C @@ -0,0 +1,19 @@ +// PR c++/105233 +// { dg-do compile { target c++14 } } + +template <typename T> +constexpr T +foo (T x) noexcept +{ + bool a = __builtin_is_constant_evaluated (); + T b = 4 * alignof (int); + return x < b ? b : x; +} + +template <typename T> +struct A { T a, b, c; }; + +template <typename T> +struct alignas (foo (sizeof (A<T>))) B { A<T> d; }; + +B<int> e; diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-pack-init7.C b/gcc/testsuite/g++.dg/cpp2a/lambda-pack-init7.C new file mode 100644 index 00000000000..f3c3899e97a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-pack-init7.C @@ -0,0 +1,18 @@ +// PR c++/102629 +// { dg-do compile { target c++20 } } + +template <class T> T&& forward(T&); +template <class T> T&& forward(T&&); + +struct S {}; + +template <typename... Args> +void foo(Args&&... args) { + [...args = forward<Args> /*(args)*/] { // { dg-error "" } + [](auto...) { } (forward<Args>(args)...); + }; +} + +void bar( ) { + foo(S{}); +} diff --git a/gcc/testsuite/g++.dg/diagnostic/using1.C b/gcc/testsuite/g++.dg/diagnostic/using1.C new file mode 100644 index 00000000000..eb4f18d1d8b --- /dev/null +++ b/gcc/testsuite/g++.dg/diagnostic/using1.C @@ -0,0 +1,16 @@ +// PR c++/102987 +// { dg-do compile { target c++11 } } + +struct a { + bool b(); +}; +template <typename c> struct d : c { + using c::e; + using f = d; + constexpr int g(decltype(e.b())) { return buh; } // { dg-error "buh" } +}; +struct h { + a e; +}; +using i = d<h>; +auto j = i{}.g(1); diff --git a/gcc/testsuite/g++.dg/ext/builtin-shufflevector-3.C b/gcc/testsuite/g++.dg/ext/builtin-shufflevector-3.C new file mode 100644 index 00000000000..0f3cbbee563 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/builtin-shufflevector-3.C @@ -0,0 +1,23 @@ +// PR c++/105353 +// { dg-do compile { target c++17 } } +// { dg-additional-options "-Wno-psabi" } + +typedef unsigned char Simd128U8VectT __attribute__((__vector_size__(16))); + +template<int ShuffleIndex> +static inline Simd128U8VectT ShufFunc(Simd128U8VectT vect) noexcept { + if constexpr(unsigned(ShuffleIndex) >= 16) + return Simd128U8VectT { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + else if constexpr(ShuffleIndex == 0) + return vect; + else + return __builtin_shufflevector(vect, vect, ShuffleIndex, ShuffleIndex + 1, + ShuffleIndex + 2, ShuffleIndex + 3, ShuffleIndex + 4, ShuffleIndex + 5, + ShuffleIndex + 6, ShuffleIndex + 7, ShuffleIndex + 8, ShuffleIndex + 9, + ShuffleIndex + 10, ShuffleIndex + 11, ShuffleIndex + 12, ShuffleIndex + 13, + ShuffleIndex + 14, ShuffleIndex + 15); +} + +auto func1(Simd128U8VectT vect) noexcept { + return ShufFunc<5>(vect); +} diff --git a/gcc/testsuite/g++.dg/ext/unsigned-typedef1.C b/gcc/testsuite/g++.dg/ext/unsigned-typedef1.C new file mode 100644 index 00000000000..360b5f81edf --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/unsigned-typedef1.C @@ -0,0 +1,9 @@ +// PR c++/102804 +// { dg-do compile { target c++11 } } +// { dg-options "-Wpedantic" } + +using int32_t = int; +enum: unsigned int32_t { foo }; // { dg-warning "int32_t" } +int f(int) = delete; +int f(unsigned); +auto x = f(1 ? foo : 1); diff --git a/gcc/testsuite/g++.dg/lookup/new3.C b/gcc/testsuite/g++.dg/lookup/new3.C new file mode 100644 index 00000000000..36afb5b48e2 --- /dev/null +++ b/gcc/testsuite/g++.dg/lookup/new3.C @@ -0,0 +1,10 @@ +// PR c++/98249 + +#include <new> +struct Incomplete; +template<class T> struct Holder { T t; }; +Holder<Incomplete> *p; +void test() { + ::new (p) int; + new (p) int; +} diff --git a/gcc/testsuite/g++.dg/lto/pr105399_0.C b/gcc/testsuite/g++.dg/lto/pr105399_0.C new file mode 100644 index 00000000000..fc9149a7aa2 --- /dev/null +++ b/gcc/testsuite/g++.dg/lto/pr105399_0.C @@ -0,0 +1,9 @@ +// PR lto/105399 +// { dg-lto-do link } +// { dg-lto-options { { -fPIC -flto -Ofast } } } +// { dg-require-effective-target shared } +// { dg-require-effective-target fpic } +// { dg-extra-ld-options "-shared -O2" } + +struct S { S (); }; +S::S () {} diff --git a/gcc/testsuite/g++.dg/opt/const7.C b/gcc/testsuite/g++.dg/opt/const7.C new file mode 100644 index 00000000000..5bcf94897a8 --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/const7.C @@ -0,0 +1,7 @@ +// PR c++/104142 +// { dg-do compile { target c++11 } } +// { dg-additional-options -Wunused-variable } + +struct B { B()=default; }; +static const B b_var; // { dg-bogus "" } +// { dg-final { scan-assembler-symbol-section {b_var} {^\.(const|rodata)|\[RO\]} } } diff --git a/gcc/testsuite/g++.dg/opt/pr104880.cc b/gcc/testsuite/g++.dg/opt/pr104880.C index de56a5acfd4..de56a5acfd4 100644 --- a/gcc/testsuite/g++.dg/opt/pr104880.cc +++ b/gcc/testsuite/g++.dg/opt/pr104880.C diff --git a/gcc/testsuite/g++.dg/opt/pr105235-1.C b/gcc/testsuite/g++.dg/opt/pr105235-1.C new file mode 100644 index 00000000000..b74d2034f5b --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/pr105235-1.C @@ -0,0 +1,12 @@ +// PR tree-optimization/105235 +// { dg-do compile } +// { dg-options "-O -fno-tree-dominator-opts -fexceptions -fnon-call-exceptions -fno-tree-fre" } + +struct S { ~S (); }; + +double +foo (double d) +{ + S s; + return __builtin_ilogbl (d) + __builtin_sinl (d); +} diff --git a/gcc/testsuite/g++.dg/opt/pr105306.C b/gcc/testsuite/g++.dg/opt/pr105306.C new file mode 100644 index 00000000000..552d37491bc --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/pr105306.C @@ -0,0 +1,13 @@ +// PR ipa/105306 +// { dg-do compile } +// { dg-options "-Ofast" } + +#pragma GCC optimize 0 +template <typename T> void foo (T); +struct B { ~B () {} }; +struct C { B f; }; +template <typename> struct E { + void bar () { foo (g); } + C g; +}; +template class E<char>; diff --git a/gcc/testsuite/g++.dg/parse/qualified6.C b/gcc/testsuite/g++.dg/parse/qualified6.C new file mode 100644 index 00000000000..68b51f771ec --- /dev/null +++ b/gcc/testsuite/g++.dg/parse/qualified6.C @@ -0,0 +1,10 @@ +// PR c++/90107 +// { dg-do compile } + +struct A; +namespace N { extern A a; } +struct A {} ::N::a; + +struct A1; +struct B { static A1 a1; }; +struct A1 {} ::B::a1; diff --git a/gcc/testsuite/g++.dg/pr105276.C b/gcc/testsuite/g++.dg/pr105276.C new file mode 100644 index 00000000000..ad0e9dd7e09 --- /dev/null +++ b/gcc/testsuite/g++.dg/pr105276.C @@ -0,0 +1,18 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +bool +foo(unsigned i) +{ + bool result = true; + while (i) + { + i = i % 3; + i = i - (i == 2 ? 2 : i ? 1 : 0); + result = !result; + } + return result; +} + +/* We should be able to eliminate the i - operation. */ +/* { dg-final { scan-tree-dump-not "i_.* - " "optimized" } } */ diff --git a/gcc/testsuite/g++.dg/template/conv19.C b/gcc/testsuite/g++.dg/template/conv19.C new file mode 100644 index 00000000000..7a3da939c1f --- /dev/null +++ b/gcc/testsuite/g++.dg/template/conv19.C @@ -0,0 +1,34 @@ +// PR c++/101698 +// { dg-do compile { target c++11 } } + +class Base { + public: + template <class T> + operator const T&() const = delete; + + virtual operator const int&() const { + static int res; + return res; + } +}; + +template <class T> +class Derive : public Base { + public: + operator const T&() const override { + using Y = int; + //static_assert(__is_same_as(T,Y), ""); + + static int res; + + res = Base::operator const Y&(); // OK + res = Base::operator const T&(); // { dg-bogus "deleted" } + return res; + } +}; + +int main() { + Derive<int> a; + const int& b = a; + (void)b; +} diff --git a/gcc/testsuite/g++.dg/template/friend72.C b/gcc/testsuite/g++.dg/template/friend72.C new file mode 100644 index 00000000000..b499909076d --- /dev/null +++ b/gcc/testsuite/g++.dg/template/friend72.C @@ -0,0 +1,15 @@ +// PR c++/91618 +// { dg-do link } + +template <class T> int f(T t) +{ return t.i; } + +class A { + friend int ::f(A); + int i; +}; + +int main() +{ + f(A()); // link error, trying to call non-template function +} diff --git a/gcc/testsuite/g++.dg/template/friend72a.C b/gcc/testsuite/g++.dg/template/friend72a.C new file mode 100644 index 00000000000..ef6834aae2d --- /dev/null +++ b/gcc/testsuite/g++.dg/template/friend72a.C @@ -0,0 +1,14 @@ +// PR c++/91618 + +template <class T> int f(T t, int) +{ return t.i; } + +class A { + friend int ::f(A); // { dg-error "" } + int i; +}; + +int main() +{ + f(A()); // { dg-error "no match" } +} diff --git a/gcc/testsuite/g++.dg/template/friend73.C b/gcc/testsuite/g++.dg/template/friend73.C new file mode 100644 index 00000000000..d009ec7a990 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/friend73.C @@ -0,0 +1,5 @@ +// PR c++/96604 + +struct A { template<typename T> operator T(); }; +struct X {}; +struct B { friend A::operator X(); }; diff --git a/gcc/testsuite/g++.dg/template/partial-specialization11.C b/gcc/testsuite/g++.dg/template/partial-specialization11.C new file mode 100644 index 00000000000..556224a3104 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/partial-specialization11.C @@ -0,0 +1,11 @@ +// PR c++/86193 +// CWG 455 (active) +// { dg-options "" } // clear -pedantic-errors + +template<class T> struct value_type; + +template<class T, typename value_type<T>::type V> +struct A; + +template<class T, int V> +struct A<T*, V> { }; // { dg-warning "not more specialized" } diff --git a/gcc/testsuite/g++.dg/template/partial-specialization12.C b/gcc/testsuite/g++.dg/template/partial-specialization12.C new file mode 100644 index 00000000000..5f51e8a27de --- /dev/null +++ b/gcc/testsuite/g++.dg/template/partial-specialization12.C @@ -0,0 +1,12 @@ +// PR c++/105289 +// CWG 455 (active) +// { dg-do compile { target c++11 } } + +template<class T> +struct value_type; + +template<class List, typename value_type<List>::type Element> +struct push_front_vlist; + +template<template<class X, X...> class XList, class T, T Arg, T... Vs> +struct push_front_vlist<XList<T, Vs...>, Arg> { }; // { dg-error "not more specialized" } diff --git a/gcc/testsuite/g++.dg/template/using31.C b/gcc/testsuite/g++.dg/template/using31.C new file mode 100644 index 00000000000..bfeb94f2788 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/using31.C @@ -0,0 +1,16 @@ +// PR c++/105223 + +struct ServiceReferenceBase { + void operator=(int); +}; + +template<class> +struct ServiceReference : ServiceReferenceBase { + void foo() { operator=(0); } + using ServiceReferenceBase::operator=; +}; + +int main() { + ServiceReference<int> sr; + sr.foo(); +} diff --git a/gcc/testsuite/g++.dg/torture/builtin-clear-padding-5.C b/gcc/testsuite/g++.dg/torture/builtin-clear-padding-5.C new file mode 100644 index 00000000000..b5f01914781 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/builtin-clear-padding-5.C @@ -0,0 +1,44 @@ +// PR tree-optimization/102586 +// { dg-options "-Wno-inaccessible-base" } + +struct C0 {}; +struct C1 {}; +struct C2 : C1, virtual C0 {}; +struct C3 : virtual C2, C1 { virtual int foo () { return 1; } }; +struct C4 : virtual C3, C1 { virtual int foo () { return 2; } }; +struct C5 : C4 { virtual int foo () { return 3; } }; +struct C6 { char c; }; +struct C7 : virtual C6, virtual C3, C1 { virtual int foo () { return 4; } }; +struct C8 : C7 { virtual int foo () { return 5; } }; + +__attribute__((noipa)) int +bar (C5 *p) +{ + return p->foo (); +} + +__attribute__((noipa)) int +baz (C3 *p) +{ + return p->foo (); +} + +__attribute__((noipa)) int +qux (C8 *p) +{ + return p->foo (); +} + +int +main () +{ + C5 c5; + C8 c8; + c8.c = 42; + __builtin_clear_padding (&c5); + __builtin_clear_padding (&c8); + if (bar (&c5) != 3 || baz (&c5) != 3) + __builtin_abort (); + if (qux (&c8) != 5 || baz (&c8) != 5 || c8.c != 42) + __builtin_abort (); +} diff --git a/gcc/testsuite/g++.dg/torture/pr105189.C b/gcc/testsuite/g++.dg/torture/pr105189.C new file mode 100644 index 00000000000..a3870772cfe --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr105189.C @@ -0,0 +1,19 @@ +// PR tree-optimization/105189 +// { dg-do run } + +int +foo () +{ + return -1; +} + +int +main () +{ + int c = foo () >= 0U && 1; + if (c != 1) + __builtin_abort (); + int d = foo () >= 3U && 1; + if (d != 1) + __builtin_abort (); +} diff --git a/gcc/testsuite/g++.dg/vect/pr105254.cc b/gcc/testsuite/g++.dg/vect/pr105254.cc new file mode 100644 index 00000000000..34814671a54 --- /dev/null +++ b/gcc/testsuite/g++.dg/vect/pr105254.cc @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-fvect-cost-model=dynamic -mcpu=zeus" { target aarch64*-*-* } } */ + +template <typename> +struct complex; + +template <> +struct complex<double> { + void operator+= (complex r) { v_ += r.v_; } + _Complex v_; +}; + +template <typename T> +void +bar (T); + +void +foo (complex<double> *x) +{ + complex<double> s = {0.0}; + + for (int i = 0; i < 16; ++i) + s += x[i]; + + bar<complex<double> > (s); +} diff --git a/gcc/testsuite/g++.dg/warn/Wplacement-new-size-11.C b/gcc/testsuite/g++.dg/warn/Wplacement-new-size-11.C new file mode 100644 index 00000000000..a6fe82e90ae --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wplacement-new-size-11.C @@ -0,0 +1,15 @@ +// PR c++/100370 +// { dg-do compile { target c++11 } } + +using size_t = decltype(sizeof(1)); +inline void *operator new (size_t s, void *p) { return p; } + +int main() +{ + struct s1 { int iv[4]; }; + struct s2 { union { char* cp; int* ip; }; }; + + s2 b; + b.ip=new int[8]; + new (b.ip+4) s1; // { dg-bogus "-Wplacement-new" } +} diff --git a/gcc/testsuite/g++.dg/warn/pr104492.C b/gcc/testsuite/g++.dg/warn/pr104492.C new file mode 100644 index 00000000000..229414d6dd3 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/pr104492.C @@ -0,0 +1,115 @@ +// PR middle-end/104492 +// { dg-do compile { target c++14 } } +// { dg-options "-O3 -Wall" } + +namespace std { +typedef decltype (sizeof 0) size_t; +template <typename _Tp, _Tp __v> struct integral_constant { + static constexpr _Tp value = __v; +}; +template <typename _Tp, typename _Up> +struct is_same : integral_constant<bool, __is_same(_Tp, _Up)> {}; +template <bool, typename> struct enable_if; +template <typename _Tp> _Tp forward; +} +class QString; +struct random_access_iterator_tag {}; +template <typename> struct iterator_traits { + typedef random_access_iterator_tag iterator_category; +}; +template <typename _Iter> +typename iterator_traits<_Iter>::iterator_category __iterator_category(_Iter); +namespace __gnu_cxx { +namespace __ops { +template <typename> struct _Iter_equals_val { + template <typename _Iterator> bool operator()(_Iterator); +}; +template <typename _Value> _Iter_equals_val<_Value> __iter_equals_val(_Value); +} +} +namespace std { +template <typename _RandomAccessIterator, typename _Predicate> +_RandomAccessIterator __find_if(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Predicate __pred, + random_access_iterator_tag) { + if (__pred(__first)) + return __first; + return __last; +} +template <typename _Iterator, typename _Predicate> +_Iterator __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) { + return __find_if(__first, __last, __pred, __iterator_category(__first)); +} +template <typename _Tp, size_t _Nm> _Tp *begin(_Tp (&__arr)[_Nm]) { + return __arr; +} +template <typename _Tp, size_t _Nm> _Tp *end(_Tp (&__arr)[_Nm]) { + return __arr + _Nm; +} +template <typename _InputIterator, typename _Tp> +_InputIterator find(_InputIterator __first, _InputIterator __last, _Tp __val) { + return __find_if(__first, __last, __gnu_cxx::__ops::__iter_equals_val(__val)); +} +} +struct QStringView { + template <typename T> + using if_compatible_qstring_like = std::enable_if<std::is_same<T, QString>::value, bool>; + template <typename String> QStringView(String); +}; +template <typename Haystack, typename> struct QStringTokenizerBase { + class sentinel {}; + struct iterator { + Haystack operator*(); + iterator operator++(int); + bool operator!=(sentinel); + }; + iterator begin(); + template <bool = std::is_same<iterator, sentinel>::value> sentinel end(); +}; +namespace QtPrivate { +namespace Tok { +template <typename Haystack, typename Needle> +using TokenizerBase = QStringTokenizerBase<Haystack, Needle>; +} +} +template <typename Haystack, typename Needle> +struct QStringTokenizer + : public QtPrivate::Tok::TokenizerBase<Haystack, Needle> { + QStringTokenizer(Haystack, Needle); +}; +namespace QtPrivate { +namespace Tok { +template <typename Haystack, typename Needle> +using TokenizerResult = QStringTokenizer<Haystack, Needle>; +} +} +template <typename Haystack, typename Needle> +auto qTokenize(Haystack, Needle) + -> decltype(QtPrivate::Tok::TokenizerResult<Haystack, Needle>{ + std::forward<Haystack>, std::forward<Needle>}); +struct QLatin1String { + QLatin1String(const char *) {} +}; +class QString {}; +class QLibrary { + bool isLibrary(const QString &); +}; + +bool QLibrary::isLibrary(const QString &fileName) +{ + QString completeSuffix = fileName; + auto isValidSuffix = [](QStringView s) { + const QLatin1String candidates[] = { + QLatin1String("so"), + }; + return std::find(std::begin(candidates), std::end(candidates), s) != std::end(candidates); + }; + auto suffixes = qTokenize(completeSuffix, u'.'); + auto it = suffixes.begin(); + const auto end = suffixes.end(); + while (it != end) { + if (isValidSuffix(*it++)) // { dg-bogus "dangling pointer to .candidates. may be used" } + return true; + } + return false; +} diff --git a/gcc/testsuite/g++.target/i386/mv31.C b/gcc/testsuite/g++.target/i386/mv31.C new file mode 100644 index 00000000000..70a40f1e28a --- /dev/null +++ b/gcc/testsuite/g++.target/i386/mv31.C @@ -0,0 +1,11 @@ +// PR c++/104669 +// { dg-require-ifunc "" } + +void bar() +{ + int foo(void); + int foo(void) __attribute__((target("sse"))); + int foo(void) __attribute__((target("default"))); + int (*p)(void) = &foo; + return; +} diff --git a/gcc/testsuite/g++.target/i386/vec-tmpl1.C b/gcc/testsuite/g++.target/i386/vec-tmpl1.C new file mode 100644 index 00000000000..e0865e3515b --- /dev/null +++ b/gcc/testsuite/g++.target/i386/vec-tmpl1.C @@ -0,0 +1,17 @@ +// PR c++/65211 +// { dg-additional-options "-Wno-psabi" } +// { dg-final { scan-assembler-not "movdqa" } } + +typedef unsigned v4ui __attribute__ ((vector_size(16), aligned (16))); + +template<int I> +static v4ui t1(unsigned *dest_data) +{ + typedef unsigned v4ui_1 __attribute__ ((vector_size (16), aligned (4))); + return ((const v4ui_1*)dest_data)[0]; +} + +v4ui f(unsigned int *array) +{ + return t1<1>(array+7); +} diff --git a/gcc/testsuite/g++.dg/debug/dwarf2/const2.C b/gcc/testsuite/g++.target/powerpc/const2.C index 27f4c265851..27f4c265851 100644 --- a/gcc/testsuite/g++.dg/debug/dwarf2/const2.C +++ b/gcc/testsuite/g++.target/powerpc/const2.C diff --git a/gcc/testsuite/g++.dg/other/darwin-minversion-1.C b/gcc/testsuite/g++.target/powerpc/darwin-minversion-1.C index cbf5ff1d20b..cbf5ff1d20b 100644 --- a/gcc/testsuite/g++.dg/other/darwin-minversion-1.C +++ b/gcc/testsuite/g++.target/powerpc/darwin-minversion-1.C diff --git a/gcc/testsuite/g++.dg/eh/ppc64-sighandle-cr.C b/gcc/testsuite/g++.target/powerpc/ppc64-sighandle-cr.C index 32561736077..32561736077 100644 --- a/gcc/testsuite/g++.dg/eh/ppc64-sighandle-cr.C +++ b/gcc/testsuite/g++.target/powerpc/ppc64-sighandle-cr.C diff --git a/gcc/testsuite/g++.dg/eh/simd-4.C b/gcc/testsuite/g++.target/powerpc/simd-4.C index 8c9b58bf868..a01f19c2736 100644 --- a/gcc/testsuite/g++.dg/eh/simd-4.C +++ b/gcc/testsuite/g++.target/powerpc/simd-4.C @@ -1,4 +1,4 @@ -/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-do run { target *-*-darwin* } } */ /* { dg-options "-fexceptions -fnon-call-exceptions -O -maltivec" } */ #include <cstdlib> diff --git a/gcc/testsuite/g++.dg/eh/simd-5.C b/gcc/testsuite/g++.target/powerpc/simd-5.C index 71e117ead2a..71e117ead2a 100644 --- a/gcc/testsuite/g++.dg/eh/simd-5.C +++ b/gcc/testsuite/g++.target/powerpc/simd-5.C diff --git a/gcc/testsuite/g++.dg/other/spu2vmx-1.C b/gcc/testsuite/g++.target/powerpc/spu2vmx-1.C index d9c8faf9459..496b46c22c9 100644 --- a/gcc/testsuite/g++.dg/other/spu2vmx-1.C +++ b/gcc/testsuite/g++.target/powerpc/spu2vmx-1.C @@ -1,4 +1,4 @@ -/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-do compile } */ /* { dg-require-effective-target powerpc_spu } */ /* { dg-options "-maltivec" } */ diff --git a/gcc/testsuite/g++.dg/eh/uncaught3.C b/gcc/testsuite/g++.target/powerpc/uncaught3.C index 1b3333eaab3..f891401584e 100644 --- a/gcc/testsuite/g++.dg/eh/uncaught3.C +++ b/gcc/testsuite/g++.target/powerpc/uncaught3.C @@ -1,4 +1,4 @@ -// { dg-do compile { target powerpc*-*-darwin* } } +// { dg-do compile { target *-*-darwin* } } // { dg-final { scan-assembler-not "__cxa_get_exception" } } // { dg-options "-mmacosx-version-min=10.4" } // { dg-additional-options "-Wno-deprecated" { target c++17 } } diff --git a/gcc/testsuite/g++.target/s390/pr102024-1.C b/gcc/testsuite/g++.target/s390/pr102024-1.C new file mode 100644 index 00000000000..a2cdd40df2a --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr102024-1.C @@ -0,0 +1,12 @@ +// PR target/102024 +// { dg-do compile } + +struct S { float a; int : 0; }; +void foo (struct S x); + +void +bar (void) +{ + struct S s = { 0.0f }; + foo (s); // { dg-message "with zero-width bit fields members changed in GCC 12" } +} diff --git a/gcc/testsuite/g++.target/s390/pr102024-2.C b/gcc/testsuite/g++.target/s390/pr102024-2.C new file mode 100644 index 00000000000..3ca7ce666d9 --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr102024-2.C @@ -0,0 +1,14 @@ +// PR target/102024 +// { dg-do compile } + +/* struct would never be passed in an FPR so no warning expected. */ + +struct S { float a; int :0; float b; }; +void foo (struct S x); + +void +bar (void) +{ + struct S s = { 0.0f }; + foo (s); // { dg-bogus "with zero-width bit fields members changed in GCC 12" } +} diff --git a/gcc/testsuite/g++.target/s390/pr102024-3.C b/gcc/testsuite/g++.target/s390/pr102024-3.C new file mode 100644 index 00000000000..51514c3fcf5 --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr102024-3.C @@ -0,0 +1,15 @@ +// PR target/102024 +// { dg-do compile } + +/* struct S would not be passed as single value anyway so no warning expected. */ + +struct T { float a; float b; }; +struct S { struct T t; int :0; }; +void foo (struct S x); + +void +bar (void) +{ + struct S s = { { 0.0f, 0.0f } }; + foo (s); // { dg-bogus "with zero-width bit fields members changed in GCC 12" } +} diff --git a/gcc/testsuite/g++.target/s390/pr102024-4.C b/gcc/testsuite/g++.target/s390/pr102024-4.C new file mode 100644 index 00000000000..075d5713f49 --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr102024-4.C @@ -0,0 +1,15 @@ +// PR target/102024 +// { dg-do compile } + +/* struct S would not be passed as single value anyway so no warning expected. */ + +struct T { float a; int :0; }; +struct S { struct T t; int x; }; +void foo (struct S x); + +void +bar (void) +{ + struct S s = { { 0.0f }, 0 }; + foo (s); // { dg-bogus "with zero-width bit fields members changed in GCC 12" } +} diff --git a/gcc/testsuite/g++.target/s390/pr102024-5.C b/gcc/testsuite/g++.target/s390/pr102024-5.C new file mode 100644 index 00000000000..a4355e71da2 --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr102024-5.C @@ -0,0 +1,14 @@ +// PR target/102024 +// { dg-do compile } + +struct U { float a; int :0; }; +struct T { struct U u; }; +struct S { struct T t; }; +void foo (struct S x); + +void +bar (void) +{ + struct S s = { { { 0.0f } } }; + foo (s); // { dg-message "with zero-width bit fields members changed in GCC 12" } +} diff --git a/gcc/testsuite/g++.target/s390/pr102024-6.C b/gcc/testsuite/g++.target/s390/pr102024-6.C new file mode 100644 index 00000000000..9dd506e59c8 --- /dev/null +++ b/gcc/testsuite/g++.target/s390/pr102024-6.C @@ -0,0 +1,12 @@ +// PR target/102024 +// { dg-do compile } + +struct S { int :0; float a; }; +void foo (struct S x); + +void +bar (void) +{ + struct S s = { 0.0f }; + foo (s); // { dg-message "with zero-width bit fields members changed in GCC 12" } +} diff --git a/gcc/testsuite/gcc.c-torture/compile/103818.c b/gcc/testsuite/gcc.c-torture/compile/103818.c new file mode 100644 index 00000000000..e6cbe7860cf --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/103818.c @@ -0,0 +1,12 @@ +/* { dg-do compile { target lp64 } } */ +struct A { int b[1]; }; + +void +foo (struct A *d) +{ + d->b[0] = d->b[-144115188075855873LL] + d->b[11] * d->b[2] + + d->b[0] % d->b[1025] + d->b[5]; + d->b[0] = d->b[144678138029277184LL] + d->b[0] & d->b[-3] * d->b[053] + + d->b[7] ^ d->b[-9] + d->b[14] + d->b[9] % d->b[49] + + d->b[024] + d->b[82] & d->b[4096]; +} diff --git a/gcc/testsuite/gcc.c-torture/compile/pr103376.c b/gcc/testsuite/gcc.c-torture/compile/pr103376.c new file mode 100644 index 00000000000..8c14c3ded38 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr103376.c @@ -0,0 +1,9 @@ +/* { dg-additional-options "-Ofast" } */ +__attribute__ ((optimize ("no-associative-math"))) double +fn3 (double h, double l) +{ + return h + l; +} + +double fn3 (double, double) __attribute__ ((optimize ("O2,no-associative-math"))); + diff --git a/gcc/testsuite/gcc.c-torture/compile/pr105234.c b/gcc/testsuite/gcc.c-torture/compile/pr105234.c new file mode 100644 index 00000000000..3fdfed8b562 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr105234.c @@ -0,0 +1,14 @@ +/* PR target/105234 */ +/* { dg-do compile } */ + +static inline __attribute__((always_inline)) int foo (int x) { return x + 1; } +#pragma GCC push_options +static inline __attribute__((always_inline)) int bar (int x) { return x + 2; } +#pragma GCC pop_options +static inline __attribute__((always_inline)) int baz (int x) { return x + 3; } + +int +qux (void) +{ + return foo (bar (baz (42))); +} diff --git a/gcc/testsuite/gcc.c-torture/compile/pr105247.c b/gcc/testsuite/gcc.c-torture/compile/pr105247.c new file mode 100644 index 00000000000..88892d98453 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr105247.c @@ -0,0 +1,10 @@ +/* PR target/105247 */ + +int a; + +void +foo (void) +{ + int y = -8; + a = 1 << y; +} diff --git a/gcc/testsuite/gcc.dg/analyzer/pr103892.c b/gcc/testsuite/gcc.dg/analyzer/pr103892.c new file mode 100644 index 00000000000..e9775b69ad0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/pr103892.c @@ -0,0 +1,75 @@ +/* { dg-additional-options "-O2" } */ + +extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__)); + +enum pipecmd_tag +{ + PIPECMD_PROCESS, + PIPECMD_SEQUENCE +}; + +struct pipecmd { + enum pipecmd_tag tag; + union { + struct pipecmd_process { + int argc; + int argv_max; + char **argv; + } process; + struct pipecmd_sequence { + int ncommands; + int commands_max; + struct pipecmd **commands; + } sequence; + } u; +}; + +static char *argstr_get_word (const char **argstr) +{ + while (**argstr) { + switch (**argstr) { + case ' ': + case '\t': + return (void *) 0; + } + } + return (void *) 0; +} + +struct pipecmd *pipecmd_new_argstr (const char *argstr) +{ + argstr_get_word (&argstr); + return (void *) 0; +} + +void pipecmd_free (struct pipecmd *cmd) +{ + int i; + + if (!cmd) + return; + + switch (cmd->tag) { + case PIPECMD_PROCESS: { + struct pipecmd_process *cmdp = &cmd->u.process; + + for (i = 0; i < cmdp->argc; ++i) + free (cmdp->argv[i]); + free (cmdp->argv); + + break; + } + + case PIPECMD_SEQUENCE: { + struct pipecmd_sequence *cmds = &cmd->u.sequence; + + for (i = 0; i < cmds->ncommands; ++i) + pipecmd_free (cmds->commands[i]); + free (cmds->commands); + + break; + } + } + + free (cmd); +} diff --git a/gcc/testsuite/gcc.dg/analyzer/pr104308.c b/gcc/testsuite/gcc.dg/analyzer/pr104308.c index 9cd5ee6feee..a3a0cbb7317 100644 --- a/gcc/testsuite/gcc.dg/analyzer/pr104308.c +++ b/gcc/testsuite/gcc.dg/analyzer/pr104308.c @@ -1,8 +1,19 @@ +/* Verify that we have source locations for + -Wanalyzer-use-of-uninitialized-value warnings involving folded + memory ops. */ + #include <string.h> -int main() +int test_memmove_within_uninit (void) { char s[5]; /* { dg-message "region created on stack here" } */ memmove(s, s + 1, 2); /* { dg-warning "use of uninitialized value" } */ return 0; } + +int test_memcpy_from_uninit (void) +{ + char a1[5]; + char a2[5]; /* { dg-message "region created on stack here" } */ + return (memcpy(a1, a2, 5) == a1); /* { dg-warning "use of uninitialized value" } */ +} diff --git a/gcc/testsuite/gcc.dg/analyzer/pr105252.c b/gcc/testsuite/gcc.dg/analyzer/pr105252.c new file mode 100644 index 00000000000..a093eababc5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/pr105252.c @@ -0,0 +1,20 @@ +/* { dg-additional-options "-fnon-call-exceptions -O" } */ + +typedef unsigned char C; +typedef unsigned char __attribute__((__vector_size__ (4))) V; + +C m; + +static inline void +bar (C c, V v, V *r) +{ + v %= (c | v) % m; + *r = v; +} + +void +foo (void) +{ + V x; + bar (0, (V){2}, &x); +} diff --git a/gcc/testsuite/gcc.dg/analyzer/pr105365.c b/gcc/testsuite/gcc.dg/analyzer/pr105365.c new file mode 100644 index 00000000000..aa576d08632 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/pr105365.c @@ -0,0 +1,17 @@ +/* { dg-require-effective-target int128 } */ + +typedef _Float32 f32; +typedef _Complex _Float32 cf32; +_Float32 g; +__int128 i; + +extern void bar(int); + +void +foo(_Float32 k) { + f32 f = 0; + f /= (_Complex char)__builtin_llround(g); + k /= (cf32)__builtin_copysignf(0, i); + bar(f + k); + foo(0); +} diff --git a/gcc/testsuite/gcc.dg/analyzer/pr105366.c b/gcc/testsuite/gcc.dg/analyzer/pr105366.c new file mode 100644 index 00000000000..3dba870e4e9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/pr105366.c @@ -0,0 +1,19 @@ +/* { dg-require-effective-target int128 } */ +/* { dg-additional-options "-O" } */ + +extern void bar(int); +extern void baz(void); + +typedef unsigned u32; + +void +foo(u32 u, __int128 i) { + baz(); + _Complex int c = i; + c /= (u32)(__UINTPTR_TYPE__)foo; + short s = (short)(__UINTPTR_TYPE__)foo; + u /= (_Complex short)s; + u32 r = u + c; + bar(r); + foo(0, 0); +} diff --git a/gcc/testsuite/gcc.dg/analyzer/pr96841.c b/gcc/testsuite/gcc.dg/analyzer/pr96841.c index c76658288b7..14f3f7a86a3 100644 --- a/gcc/testsuite/gcc.dg/analyzer/pr96841.c +++ b/gcc/testsuite/gcc.dg/analyzer/pr96841.c @@ -1,4 +1,4 @@ -/* { dg-additional-options "-Wno-analyzer-too-complex -O1 -Wno-builtin-declaration-mismatch" } */ +/* { dg-additional-options "-O1 -Wno-builtin-declaration-mismatch" } */ int l8 (void); diff --git a/gcc/testsuite/gcc.dg/analyzer/symbolic-9.c b/gcc/testsuite/gcc.dg/analyzer/symbolic-9.c new file mode 100644 index 00000000000..54ed30f132c --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/symbolic-9.c @@ -0,0 +1,197 @@ +#include "analyzer-decls.h" + +struct st +{ + void *ptr[10]; + int arr[10]; +}; + +/* Various combinations of a pair of writes, involving + symbolic vs concrete clusters, with symbolic vs concrete keys + within them. */ + +struct st g; + +/* "ptr" write: fully concrete. */ + +struct st +test_conc_conc_ptr_conc_conc_arr (void) +{ + struct st s; + s.ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + s.arr[5] = 42; + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + __analyzer_describe (0, s.arr[5]); /* { dg-warning "42" } */ + return s; +} + +struct st +test_conc_conc_ptr_conc_sym_arr (int j) +{ + struct st s; + s.ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + s.arr[j] = 42; + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, s.arr[j]); /* { dg-warning "42" } */ + return s; +} + +struct st +test_conc_conc_ptr_sym_conc_arr (struct st *p) +{ + struct st s; + s.ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + p->arr[5] = 42; + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + __analyzer_describe (0, p->arr[5]); /* { dg-warning "42" } */ + return s; +} + +struct st +test_conc_conc_ptr_sym_sym_arr (struct st *p, int j) +{ + struct st s; + s.ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + p->arr[j] = 42; + __analyzer_describe (0, s.ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + __analyzer_describe (0, p->arr[j]); /* { dg-warning "42" } */ + return s; +} + +/* "ptr" write: symbolic region, but at concrete offset. */ + +void +test_sym_conc_ptr_conc_conc_arr (struct st *p) +{ + p->ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + g.arr[5] = 42; + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, g.arr[5]); /* { dg-warning "42" } */ +} + +void +test_sym_conc_ptr_conc_sym_arr (struct st *p, int j) +{ + p->ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + g.arr[j] = 42; + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, g.arr[j]); /* { dg-warning "42" } */ +} + +void +test_sym_conc_ptr_sym_conc_arr (struct st *p, struct st *q) +{ + p->ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + q->arr[5] = 42; + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, q->arr[5]); /* { dg-warning "42" } */ +} + +void +test_sym_conc_ptr_sym_sym_arr (struct st *p, struct st *q, int j) +{ + p->ptr[1] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + q->arr[j] = 42; + __analyzer_describe (0, p->ptr[1]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, q->arr[j]); /* { dg-warning "42" } */ +} + +/* "ptr" write: concrete region, but at symbolic offset. */ + +struct st +test_conc_sym_ptr_conc_conc_arr (int i) +{ + struct st s; + s.ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + s.arr[5] = 42; + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, s.arr[5]); /* { dg-warning "42" } */ + return s; +} + +struct st +test_conc_sym_ptr_conc_sym_arr (int i, int j) +{ + struct st s; + s.ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + s.arr[j] = 42; + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, s.arr[j]); /* { dg-warning "42" } */ + return s; +} + +struct st +test_conc_sym_ptr_sym_conc_arr (int i, struct st *p) +{ + struct st s; + s.ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + p->arr[5] = 42; + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + __analyzer_describe (0, p->arr[5]); /* { dg-warning "42" } */ + return s; +} /* { dg-bogus "leak" "PR analyzer/105190" { xfail *-*-* } } */ + +struct st +test_conc_sym_ptr_sym_sym_arr (int i, struct st *p, int j) +{ + struct st s; + s.ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + p->arr[j] = 42; + __analyzer_describe (0, s.ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + __analyzer_describe (0, p->arr[j]); /* { dg-warning "42" } */ + return s; +} /* { dg-bogus "leak" "PR analyzer/105190" { xfail *-*-* } } */ + +/* "ptr" write: symbolic region, with symbolic offset. */ + +void +test_sym_sym_ptr_conc_conc_arr (struct st *p, int i) +{ + p->ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + g.arr[5] = 42; + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, g.arr[5]); /* { dg-warning "42" } */ +} + +void +test_sym_sym_ptr_conc_sym_arr (struct st *p, int i, int j) +{ + p->ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + g.arr[j] = 42; + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, g.arr[j]); /* { dg-warning "42" } */ +} + +void +test_sym_sym_ptr_sym_conc_arr (struct st *p, int i, struct st *q) +{ + p->ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + q->arr[5] = 42; + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, q->arr[5]); /* { dg-warning "42" } */ +} + +void +test_sym_sym_ptr_sym_sym_arr (struct st *p, int i, struct st *q, int j) +{ + p->ptr[i] = __builtin_malloc (1024); + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "HEAP_ALLOCATED_REGION" } */ + q->arr[j] = 42; + __analyzer_describe (0, p->ptr[i]); /* { dg-warning "UNKNOWN" } */ + __analyzer_describe (0, q->arr[j]); /* { dg-warning "42" } */ +} diff --git a/gcc/testsuite/gcc.dg/analyzer/torture/leak-pr102308-1.c b/gcc/testsuite/gcc.dg/analyzer/torture/leak-pr102308-1.c new file mode 100644 index 00000000000..31747168505 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/torture/leak-pr102308-1.c @@ -0,0 +1,19 @@ +#include <stdlib.h> + +struct s { + char *p; + int arr[2]; +}; + +int main(void) { + struct s *s = malloc(sizeof *s); + if (s) { + s->p = malloc(1); + for (int i = 0; i < 2; i++) + s->arr[i] = -1; /* { dg-bogus "leak" } */ + } + if (s) { + free(s->p); + free(s); + } +} diff --git a/gcc/testsuite/gcc.dg/analyzer/torture/leak-pr102308-2.c b/gcc/testsuite/gcc.dg/analyzer/torture/leak-pr102308-2.c new file mode 100644 index 00000000000..d65f1768a26 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/torture/leak-pr102308-2.c @@ -0,0 +1,12 @@ +#include <stdlib.h> +struct s { + char *p; + int arr[1]; +}; +int main(void) { + struct s s; + s.p = malloc(1); + for (int i = 0; i < 1; i++) + s.arr[i] = -1; /* { dg-bogus "leak" } */ + free(s.p); +} diff --git a/gcc/testsuite/gcc.dg/analyzer/torture/symbolic-10.c b/gcc/testsuite/gcc.dg/analyzer/torture/symbolic-10.c new file mode 100644 index 00000000000..b2f3a8a1d86 --- /dev/null +++ b/gcc/testsuite/gcc.dg/analyzer/torture/symbolic-10.c @@ -0,0 +1,40 @@ +/* Verify that -fanalyzer considers that mmfs escapes when passing either: + *(mmfs + i) + and + (&mmfs[i]) + to an external function (for symbolic i). */ + +typedef struct s_mmfile { + char *ptr; + long size; +} mmfile_t; + +void init_mmfile(mmfile_t *ptr); + +long test__init_via_ptr_arith__read_via_array_idx(int i) +{ + mmfile_t mmfs[3]; + init_mmfile(mmfs + i); + return mmfs[i].size; /* { dg-bogus "uninit" } */ +} + +long test__init_via_array_idx__read_via_ptr_arith(int i) +{ + mmfile_t mmfs[3]; + init_mmfile(&mmfs[i]); + return (mmfs + i)->size; /* { dg-bogus "uninit" } */ +} + +long test__ptr_arith_for_both(int i) +{ + mmfile_t mmfs[3]; + init_mmfile(mmfs + i); + return (mmfs + i)->size; /* { dg-bogus "uninit" } */ +} + +long test__array_idx_for_both(int i) +{ + mmfile_t mmfs[3]; + init_mmfile(&mmfs[i]); + return mmfs[i].size; /* { dg-bogus "uninit" } */ +} diff --git a/gcc/testsuite/gcc.dg/asan/pr105214.c b/gcc/testsuite/gcc.dg/asan/pr105214.c new file mode 100644 index 00000000000..a755336c7d8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/asan/pr105214.c @@ -0,0 +1,16 @@ +/* PR target/105214 */ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "*" } { "-O2" } } */ +/* { dg-options "-Ofast -fnon-call-exceptions -fexceptions -fstack-check=generic -fsanitize=address -fno-finite-math-only -fsignaling-nans -fno-associative-math" } */ + +float f; +void bar (int *); + +void +foo (void) +{ + int a[1600], b[1]; + f += __builtin_log1pf (f); + bar (a); + bar (b); +} diff --git a/gcc/testsuite/gcc.dg/asan/pr105396.c b/gcc/testsuite/gcc.dg/asan/pr105396.c new file mode 100644 index 00000000000..d4bd7f12476 --- /dev/null +++ b/gcc/testsuite/gcc.dg/asan/pr105396.c @@ -0,0 +1,19 @@ +/* PR sanitizer/105396 */ +/* { dg-do run } */ +/* { dg-skip-if "" { *-*-* } { "*" } { "-O0" } } */ +/* { dg-shouldfail "asan" } */ + +int +main () +{ + int a; + int *b[1]; + int c[10]; + int d[1][1]; + for (a = 0; a < 1; a++) + d[1][a] = 0; + return 0; +} + +/* { dg-output "ERROR: AddressSanitizer: stack-buffer-overflow on address.*(\n|\r\n|\r)" } */ +/* { dg-output "WRITE of size.*" } */ diff --git a/gcc/testsuite/gcc.dg/builtin-apply2.c b/gcc/testsuite/gcc.dg/builtin-apply2.c index 9049af5821f..0f350f4ac16 100644 --- a/gcc/testsuite/gcc.dg/builtin-apply2.c +++ b/gcc/testsuite/gcc.dg/builtin-apply2.c @@ -1,7 +1,7 @@ /* { dg-do run } */ /* { dg-require-effective-target untyped_assembly } */ /* { dg-skip-if "Variadic funcs have all args on stack. Normal funcs have args in registers." { "avr-*-* nds32*-*-* amdgcn-*-*" } } */ -/* { dg-skip-if "Variadic funcs use different argument passing from normal funcs." { "csky*-*-* riscv*-*-* or1k*-*-* msp430-*-* pru-*-*" } } */ +/* { dg-skip-if "Variadic funcs use different argument passing from normal funcs." { "csky*-*-* riscv*-*-* or1k*-*-* msp430-*-* pru-*-* loongarch*-*-*" } } */ /* { dg-skip-if "Variadic funcs use Base AAPCS. Normal funcs use VFP variant." { arm*-*-* && arm_hf_eabi } } */ /* PR target/12503 */ diff --git a/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-2.c b/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-2.c index 2a19da050fe..4721c4fb2f9 100644 --- a/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-2.c +++ b/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-2.c @@ -5,34 +5,26 @@ TBD_CTF_FORMAT_OPEN_ISSUES (1) - This testcase makes a note of the case of a probable misrepresentation. - See Note 1 and Note 2 below. + See Note 1 below. In the CTF section, these types are encoded as : Variables: - _CTF_NEWSTR -> 7: const char [0] (size 0x0) - _CTF_SECTION -> 6: const char [5] (size 0x5) - b1 -> 2: int [0] (size 0x0) - b2 -> 3: int [0] (size 0x0) + b1 -> 3: int [0] (size 0x0) + b2 -> 5: int [0] (size 0x0) Note 1 : There is misrepresentation in that b1 and b2 are specified differently by the user. - Note 2 : It is arguable though whether the representation for - _CTF_NEWSTR is incorrect. */ + + In this testcase, two CTF array records each of type int [0] is expected. */ /* { dg-do compile ) */ /* { dg-options "-O0 -gctf -dA" } */ -/* { dg-final { scan-assembler-times "0x12000000\[\t \]+\[^\n\]*ctt_info" 5 } } */ +/* { dg-final { scan-assembler-times "0x12000000\[\t \]+\[^\n\]*ctt_info" 2 } } */ -/* { dg-final { scan-assembler-times "\[\t \]0\[\t \]+\[^\n\]*cta_nelems" 3 } } */ -/* { dg-final { scan-assembler-times "\[\t \]0x5\[\t \]+\[^\n\]*cta_nelems" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]0\[\t \]+\[^\n\]*cta_nelems" 2 } } */ static int b1[] = {}; int b2[0]; - -const char _CTF_SECTION[] = ".ctf"; - -extern const char _CTF_NEWSTR[]; -const char _CTF_NEWSTR[] = "ctfinfo"; diff --git a/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-5.c b/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-5.c new file mode 100644 index 00000000000..ec504412ef5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/debug/ctf/ctf-array-5.c @@ -0,0 +1,17 @@ +/* CTF generation for unsized (but initialized) arrays + + In this testcase, one CTF array type record of size 5 is expected. + + Variables: + _CTF_SECTION -> 5: const const char [5] (size 0x5) -> 4: const char [5] (size 0x5) + +*/ + +/* { dg-do compile ) */ +/* { dg-options "-O0 -gctf -dA" } */ + +/* { dg-final { scan-assembler-times "0x12000000\[\t \]+\[^\n\]*ctt_info" 1 } } */ + +/* { dg-final { scan-assembler-times "\[\t \]0x5\[\t \]+\[^\n\]*cta_nelems" 1 } } */ + +const char _CTF_SECTION[] = ".ctf"; diff --git a/gcc/testsuite/gcc.dg/debug/ctf/ctf-variables-3.c b/gcc/testsuite/gcc.dg/debug/ctf/ctf-variables-3.c new file mode 100644 index 00000000000..8aea1e82749 --- /dev/null +++ b/gcc/testsuite/gcc.dg/debug/ctf/ctf-variables-3.c @@ -0,0 +1,22 @@ +/* CTF generation for extern variable with defining and non-defining decl + in the same CU. + + This testcase checks the case when a non-defining decl is followed by + a defining decl for the same variable. See PR debug/105089. + + In this testcase, although two CTF array types are generated, only a + single CTF variable and a single entry in the CTF object info section + are expected. */ + +/* { dg-do compile ) */ +/* { dg-options "-O0 -gctf -dA" } */ + +/* { dg-final { scan-assembler-times "0x12000000\[\t \]+\[^\n\]*ctt_info" 2 } } */ + +/* { dg-final { scan-assembler-times "\[\t \]0\[\t \]+\[^\n\]*cta_nelems" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]0x8\[\t \]+\[^\n\]*cta_nelems" 1 } } */ +/* { dg-final { scan-assembler-times "ctv_name" 1 } } */ +/* { dg-final { scan-assembler-times "objtinfo_var_type" 1 } } */ + +extern const char _CTF_NEWSTR[]; +const char _CTF_NEWSTR[] = "ctfinfo"; diff --git a/gcc/testsuite/gcc.dg/ipa/pr105160.c b/gcc/testsuite/gcc.dg/ipa/pr105160.c new file mode 100644 index 00000000000..ea80545b102 --- /dev/null +++ b/gcc/testsuite/gcc.dg/ipa/pr105160.c @@ -0,0 +1,77 @@ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-ipa-modref" } */ +#define sysreg_read(regname) \ +({ \ + unsigned long __sr_val; \ + asm volatile(""); \ + \ + __sr_val; \ +}) + +#define sysreg_write(regname, __sw_val) \ +do { \ + asm volatile(""); \ +} while (0) + +#define isb() \ +do { \ + asm volatile( \ + "isb" \ + : \ + : \ + : "memory"); \ +} while (0) + +static unsigned long sctlr_read(void) +{ + return sysreg_read(sctlr_el1); +} + +static void sctlr_write(unsigned long val) +{ + sysreg_write(sctlr_el1, val); +} + +static void sctlr_rmw(void) +{ + unsigned long val; + + val = sctlr_read(); + val |= 1UL << 7; + sctlr_write(val); +} + +void sctlr_read_multiple(void) +{ + sctlr_read(); + sctlr_read(); + sctlr_read(); + sctlr_read(); +} + +void sctlr_write_multiple(void) +{ + sctlr_write(0); + sctlr_write(0); + sctlr_write(0); + sctlr_write(0); + sctlr_write(0); +} + +void sctlr_rmw_multiple(void) +{ + sctlr_rmw(); + sctlr_rmw(); + sctlr_rmw(); + sctlr_rmw(); +} + +void function(void) +{ + sctlr_read_multiple(); + sctlr_write_multiple(); + sctlr_rmw_multiple(); + + isb(); +} +/* { dg-final { scan-ipa-dump-not "Function found to be const" "modref" } } */ diff --git a/gcc/testsuite/gcc.dg/ipa/remref-7.c b/gcc/testsuite/gcc.dg/ipa/remref-7.c index b2c26ab7fd5..152b9d0ca94 100644 --- a/gcc/testsuite/gcc.dg/ipa/remref-7.c +++ b/gcc/testsuite/gcc.dg/ipa/remref-7.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -fno-early-inlining -fno-ipa-sra -fdump-ipa-inline" } */ +/* { dg-options "-O2 -fno-early-inlining -fno-ipa-sra -fdump-ipa-inline --param max-inline-insns-auto=100" } */ int rglobal = 0; int g; diff --git a/gcc/testsuite/gcc.dg/lto/pr94157_0.c b/gcc/testsuite/gcc.dg/lto/pr94157_0.c index a6e308b855b..a76141b1809 100644 --- a/gcc/testsuite/gcc.dg/lto/pr94157_0.c +++ b/gcc/testsuite/gcc.dg/lto/pr94157_0.c @@ -1,6 +1,6 @@ /* { dg-lto-do link } */ /* { dg-require-effective-target gas } */ -/* { dg-lto-options { { -O0 -fipa-vrp -flto -Wa,--noexecstack -Wa,--noexecstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack } } } */ +/* { dg-lto-options { { -O0 -fipa-vrp -flto -Wa,--noexecstack -Wa,--noexecstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wa,--execstack -Wl,-z,execstack} } } */ int main() { diff --git a/gcc/testsuite/gcc.dg/pr105140.c b/gcc/testsuite/gcc.dg/pr105140.c index da34e7ad656..7d30985e850 100644 --- a/gcc/testsuite/gcc.dg/pr105140.c +++ b/gcc/testsuite/gcc.dg/pr105140.c @@ -1,6 +1,6 @@ /* { dg-do compile } */ /* { dg-options "-Os -w -Wno-psabi" } */ -/* { dg-skip-if "PR105147" { powerpc*-*-* } } */ +/* { dg-skip-if "PR105147" { powerpc*-*-* s390*-*-* } } */ typedef char __attribute__((__vector_size__ (16 * sizeof (char)))) U; typedef int __attribute__((__vector_size__ (16 * sizeof (int)))) V; diff --git a/gcc/testsuite/gcc.dg/pr105149.c b/gcc/testsuite/gcc.dg/pr105149.c new file mode 100644 index 00000000000..b748f454d6d --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105149.c @@ -0,0 +1,16 @@ +/* PR c/105149 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +#include <stdarg.h> + +void +foo (int s, ...) +{ + int e; + va_list ap; + + va_start (ap, s); + e = va_arg (ap, int (void)) (); /* { dg-error "second argument to 'va_arg' is a function type" } */ + va_end (ap); +} diff --git a/gcc/testsuite/gcc.dg/pr105150.c b/gcc/testsuite/gcc.dg/pr105150.c new file mode 100644 index 00000000000..900460c1555 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105150.c @@ -0,0 +1,8 @@ +/* PR tree-optimization/105150 */ +/* { dg-options "-w -Ofast" } */ + +#define A(name) __typeof (__builtin_##name (0)) name (); \ + float name##1 () { return !name (1); } \ + double name##2 () { return name (1.0L); } +#define B(name) A(name) A(name##l) +B (sqrt) diff --git a/gcc/testsuite/gcc.dg/pr105165.c b/gcc/testsuite/gcc.dg/pr105165.c new file mode 100644 index 00000000000..055a10528b5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105165.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +unsigned int _Complex a0; +unsigned int _Complex +foo (unsigned int _Complex a1, unsigned int _Complex a2) +{ + unsigned int _Complex x; + asm goto ("" : "=r" (x) : : : lab); /* { dg-message "sorry, unimplemented" } */ + a0 = x; + lab: + return x + a1 + a2 + 1; +} diff --git a/gcc/testsuite/gcc.dg/pr105175.c b/gcc/testsuite/gcc.dg/pr105175.c new file mode 100644 index 00000000000..d8d7edb942a --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105175.c @@ -0,0 +1,16 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -Wvector-operation-performance" } */ +/* { dg-additional-options "-mno-sse" { target x86_64-*-* i?86-*-* } } */ + +enum { QEMU_MIGRATION_COOKIE_PERSISTENT = 1 }; +struct { + unsigned flags; + unsigned flagsMandatory; +} qemuMigrationCookieGetPersistent_mig; +void qemuMigrationCookieGetPersistent() +{ + qemuMigrationCookieGetPersistent_mig.flags &= /* { dg-bogus "will be expanded" } */ + QEMU_MIGRATION_COOKIE_PERSISTENT; + qemuMigrationCookieGetPersistent_mig.flagsMandatory &= + QEMU_MIGRATION_COOKIE_PERSISTENT; +} diff --git a/gcc/testsuite/gcc.dg/pr105211.c b/gcc/testsuite/gcc.dg/pr105211.c new file mode 100644 index 00000000000..9bafe6feb19 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105211.c @@ -0,0 +1,11 @@ +/* PR rtl-optimization/105211 */ +/* { dg-do compile } */ +/* { dg-options "-Os -ffast-math" } */ +/* { dg-add-options float32 } */ +/* { dg-require-effective-target float32 } */ + +short +foo (_Float32 f) +{ + return __builtin_roundf (f); +} diff --git a/gcc/testsuite/gcc.dg/pr105218.c b/gcc/testsuite/gcc.dg/pr105218.c new file mode 100644 index 00000000000..0070057c32d --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105218.c @@ -0,0 +1,16 @@ +/* PR tree-optimization/105218 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -g" } */ + +int a, c; +void bar (void); + +void +foo (void) +{ + int b = 131; + if (a) + b = c == 2 ? 1 : c; + while (b) + bar (); +} diff --git a/gcc/testsuite/gcc.dg/pr105226.c b/gcc/testsuite/gcc.dg/pr105226.c new file mode 100644 index 00000000000..9c4941dc6fc --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105226.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-Ofast" } */ +/* { dg-require-effective-target indirect_jumps } */ + +#include <setjmp.h> +struct longjmp_buf { + jmp_buf buf; +}; +void g (); +void f () +{ + int i, n; + long *a; + long *args; + struct longjmp_buf b; + setjmp (b.buf); + for (;;) + { + for (i = 0; i < n; i++) + a[i] = args[i]; + g (); + } +} diff --git a/gcc/testsuite/gcc.dg/pr105250.c b/gcc/testsuite/gcc.dg/pr105250.c new file mode 100644 index 00000000000..4683e0e63a2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105250.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-options "-w -Wno-psabi -O2" } */ +/* { dg-skip-if "PR105266" { powerpc*-*-* s390*-*-* } } */ + +typedef int __attribute__((__vector_size__(4))) T; +typedef int __attribute__((__vector_size__(8))) U; +typedef int __attribute__((__vector_size__(16))) V; +typedef int __attribute__((__vector_size__(32))) W; +typedef _Float32 __attribute__((__vector_size__(16))) F; +typedef _Float64 __attribute__((__vector_size__(32))) G; +void foo(); + +foo(int, int, int, int, U, U, V, V, W, W, int, + T, int, U, U, V, V, W, W, T, + T, int, U, U, V, V, W, W, T, + T, int, W, W, T, T, int, int, int, + int, int, int, W, int, int, int, int, int, int, + V, W, T, int, int, U, F, int, int, int, + int, int, int, G) +{ + foo(0, 0, 0, 0, (U){}, (U){}, (V){}, (V){}, (W){}, + (W){}, 2, (T){}, 0, 0, 0, 0, (U){}, (U){}, + (V){}, (V){}, (W){}, (W){}, (T){}, + (T){}, 0, 0, 0, 0, (U){}, (U){}, (V){}, + (V){}, (W){}, (W){}, (T){}, (T){}, 0, 0, 0, + 0, 0, 0, (T){}, + (T){}, (W){}, + (W){}, (T){}, (T){}, 0, 0, 0, 0, 0, 0, (W){}, + (V){}, (W){}, (T){}, 0, 0, (U){}, (F){}); +} diff --git a/gcc/testsuite/gcc.dg/pr105257.c b/gcc/testsuite/gcc.dg/pr105257.c new file mode 100644 index 00000000000..4232942d791 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105257.c @@ -0,0 +1,16 @@ +/* PR target/105257 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-additional-options "-fpic" { target fpic } } */ + +extern int sigsetjmp (void **, int); +void *buf[32]; +void (*fn) (void); + +const char * +bar (void) +{ + sigsetjmp (buf, 0); + fn (); + return ""; +} diff --git a/gcc/testsuite/gcc.dg/pr105263.c b/gcc/testsuite/gcc.dg/pr105263.c new file mode 100644 index 00000000000..5cb7fcd09a2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105263.c @@ -0,0 +1,15 @@ +/* { dg-do compile { target dfp } } */ +/* { dg-options "-O -ffast-math -w -Wno-psabi" } */ + +typedef _Decimal64 __attribute__((__vector_size__ (8))) U; +typedef _Decimal64 __attribute__((__vector_size__ (16))) V; + +V v; + +U +foo (U u) +{ + u *= u; + u *= -(U){ v[1] }; + return u; +} diff --git a/gcc/testsuite/gcc.dg/pr105331.c b/gcc/testsuite/gcc.dg/pr105331.c new file mode 100644 index 00000000000..06cf6d6d901 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105331.c @@ -0,0 +1,11 @@ +/* PR target/105331 */ +/* { dg-do compile } */ +/* { dg-options "-O -Wuninitialized" } */ + +#include <stdarg.h> + +int +foo (va_list *va) +{ + return va_arg (*va, double _Complex); /* { dg-bogus "may be used uninitialized" } */ +} diff --git a/gcc/testsuite/gcc.dg/pr105333.c b/gcc/testsuite/gcc.dg/pr105333.c new file mode 100644 index 00000000000..bd8bd4cd56c --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr105333.c @@ -0,0 +1,21 @@ +/* PR rtl-optimization/105333 */ +/* { dg-do compile { target int128 } } */ +/* { dg-options "-Og -fno-tree-coalesce-vars -fno-tree-fre" } */ + +int g; +short s; + +static inline unsigned short +bar (short a, __int128 b) +{ + b ^= (unsigned long) -a; + __builtin_strncpy ((void *) &s, (void *) &a, 1); + b *= 14; + return b; +} + +void +foo (void) +{ + g *= (__int128) bar (1, 1); +} diff --git a/gcc/testsuite/gcc.dg/stack-usage-1.c b/gcc/testsuite/gcc.dg/stack-usage-1.c index 1d7d1fee435..21cce0f440c 100644 --- a/gcc/testsuite/gcc.dg/stack-usage-1.c +++ b/gcc/testsuite/gcc.dg/stack-usage-1.c @@ -105,6 +105,8 @@ # define SIZE 252 #elif defined (__CRIS__) # define SIZE 252 +#elif defined (__loongarch_lp64) +# define SIZE 240 /* 256 - 8 bytes for $fp, and 8 bytes for a temp value */ #else # define SIZE 256 #endif diff --git a/gcc/testsuite/gcc.dg/torture/pr100810.c b/gcc/testsuite/gcc.dg/torture/pr100810.c new file mode 100644 index 00000000000..63566f530f7 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr100810.c @@ -0,0 +1,34 @@ +/* { dg-do run } */ + +int a, b = 1, c = 1, e, f = 1, g, h, j; +volatile int d; +static void k() +{ + int i; + h = b; + if (c && a >= 0) { + while (a) { + i++; + h--; + } + if (g) + for (h = 0; h < 2; h++) + ; + if (!b) + i &&d; + } +} +static void l() +{ + for (; j < 1; j++) + if (!e && c && f) + k(); +} +int main() +{ + if (f) + l(); + if (h != 1) + __builtin_abort(); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr104676.c b/gcc/testsuite/gcc.dg/torture/pr104676.c index 50845bb9e15..0991b78f758 100644 --- a/gcc/testsuite/gcc.dg/torture/pr104676.c +++ b/gcc/testsuite/gcc.dg/torture/pr104676.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-additional-options "-ftree-loop-distribution -ftree-parallelize-loops=2" } */ +/* { dg-additional-options "-ftree-loop-distribution -ftree-parallelize-loops=2" { target pthread } } */ struct S { int f; diff --git a/gcc/testsuite/gcc.dg/torture/pr105185.c b/gcc/testsuite/gcc.dg/torture/pr105185.c new file mode 100644 index 00000000000..6ab32360de1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr105185.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ + +int foo (fmt) +char* fmt; +{ + return (__builtin_strchr (fmt, '*') != 0 + || __builtin_strchr (fmt, 'n') != 0); +} +void bar () +{ + if (foo ()) + __builtin_abort (); +} diff --git a/gcc/testsuite/gcc.dg/torture/pr105198.c b/gcc/testsuite/gcc.dg/torture/pr105198.c new file mode 100644 index 00000000000..91f92afc163 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr105198.c @@ -0,0 +1,26 @@ +/* { dg-do run } */ +/* { dg-additional-options "-fno-tree-pre -fpredictive-commoning" } */ + +static __attribute__ ((noipa)) void +next_set(int *x, int n, int k) +{ + int j = k - 1; + int tmp = x[j]++; + while (j > 0) + { + if (x[j] < n - (k - 1 -j)) + break; + j--; + x[j]++; + tmp = x[j]; + } + if (tmp != 2 || j != 1 || x[0] != 0 || x[1] != 2 || x[2] != 5) + __builtin_abort (); +} + +int main() +{ + int x[3] = {0, 1, 4}; + next_set(x, 5, 3); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr105231.c b/gcc/testsuite/gcc.dg/torture/pr105231.c new file mode 100644 index 00000000000..00121fd8d1e --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr105231.c @@ -0,0 +1,15 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target lp64 } */ +/* { dg-require-effective-target dfp } */ +/* { dg-additional-options "-fsanitize-coverage=trace-pc -fnon-call-exceptions --param=max-cse-insns=1 -frounding-math" } */ +/* { dg-additional-options "-mstack-arg-probe" { target x86_64-*-* i?86-*-* } } */ + +void baz (int *); +void bar (double, double, _Decimal64); + +void +foo (void) +{ + int s __attribute__((cleanup (baz))); + bar (0xfffffffffffffffe, 0xebf3fff2fbebaf7f, 0xffffffffffffff); +} diff --git a/gcc/testsuite/gcc.dg/torture/pr105337.c b/gcc/testsuite/gcc.dg/torture/pr105337.c new file mode 100644 index 00000000000..4a0bdf0363c --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr105337.c @@ -0,0 +1,31 @@ +/* { dg-do run } */ + +__attribute__((noipa)) void +bar (int x) +{ + (void) x; +} + +int a; + +int +foo (void) +{ + int b, c; + for (b = 0; b < 3; b++) + { + if (!a) + break; + c--; + bar (c); + } + return b; +} + +int +main () +{ + if (foo ()) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr104639-1.c b/gcc/testsuite/gcc.dg/tree-ssa/pr104639-1.c new file mode 100644 index 00000000000..183fa374afc --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr104639-1.c @@ -0,0 +1,13 @@ +/* PR tree-optimization/104639 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -g -fdump-tree-optimized" } */ +/* { dg-final { scan-tree-dump-not "PHI <" "optimized" } } */ +/* { dg-final { scan-tree-dump-times "i_\[0-9]*\\\(D\\\) != 0;" 1 "optimized" } } */ + +_Bool +foo (int i) +{ + while (i == 4) + i += 2; + return i; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr104639-2.c b/gcc/testsuite/gcc.dg/tree-ssa/pr104639-2.c new file mode 100644 index 00000000000..e2511470675 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr104639-2.c @@ -0,0 +1,54 @@ +/* PR tree-optimization/104639 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fno-tree-pre -g -fdump-tree-optimized" } */ +/* { dg-final { scan-tree-dump-not "PHI <" "optimized" } } */ +/* { dg-final { scan-tree-dump-times "x_\[0-9]*\\\(D\\\) != 42;" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "y_\[0-9]*\\\(D\\\) > 6;" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "z_\[0-9]*\\\(D\\\) > 9;" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "u_\[0-9]*\\\(D\\\) <= 7;" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "v_\[0-9]*\\\(D\\\) <= 42;" 1 "optimized" } } */ + +int +f1 (int x) +{ + if (x == 4) + x = 6; + int xd = x; + return x != 42; +} + +int +f2 (int y) +{ + if (y == 4) + y = 6; + int yd = y; + return y > 6; +} + +int +f3 (int z) +{ + if (z == 4) + z = 6; + int zd = z; + return z >= 10; +} + +int +f4 (int u) +{ + if (u == 4) + u = 6; + int ud = u; + return u < 8; +} + +int +f5 (int v) +{ + if (v == 4) + v = 6; + int vd = v; + return v <= 42; +} diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-double.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-double.c index f935405e3d9..5cff373b80d 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-double.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-double.c @@ -6,7 +6,7 @@ #define N 200 #include "complex-add-template.c" -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 2 "vect" { target { vect_complex_add_double } } } } */ -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 2 "vect" { target { vect_complex_add_double } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { target { vect_complex_add_double } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "vect" { target { vect_complex_add_double } } } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "vect" } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-float.c index 71f391db7bb..312df88ee68 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-float.c @@ -6,7 +6,7 @@ #define N 200 #include "complex-add-template.c" -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 2 "vect" { target { vect_complex_add_float } } } } */ -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 2 "vect" { target { vect_complex_add_float } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { target { vect_complex_add_float } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "vect" { target { vect_complex_add_float } } } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "vect" } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c index e5b826f1ca7..c656a2f6d56 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-half-float.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_half } */ /* { dg-require-effective-target float16 } */ /* { dg-add-options arm_v8_3a_fp16_complex_neon } */ @@ -6,5 +7,7 @@ #define N 200 #include "complex-add-template.c" -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 2 "vect" { target { vect_complex_add_half } } } } */ -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 2 "vect" { target { vect_complex_add_half } } } } */ +/* Vectorization is failing for these cases. They should work but for now ignore. */ + +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "slp1" { xfail *-*-* } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "slp1" { xfail *-*-* } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-double.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-double.c index 5b70d834c24..9c8b99bc003 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-double.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-double.c @@ -6,8 +6,7 @@ #define N 200 #include "complex-add-pattern-template.c" -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 4 "vect" { target { vect_complex_add_double } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "vect" { target { vect_complex_add_double } } } } */ /* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { target { vect_complex_add_double } } } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "vect" } } */ -/* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "slp1" } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-float.c index 3ef05645a2c..ca5f5b257d3 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-float.c @@ -6,8 +6,7 @@ #define N 200 #include "complex-add-pattern-template.c" -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 4 "vect" { target { vect_complex_add_float } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "vect" { target { vect_complex_add_float } } } } */ /* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { target { vect_complex_add_float } } } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "vect" } } */ -/* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "slp1" } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-half-float.c index 06a9216add7..c6617f5dad0 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-half-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-add-pattern-half-float.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-require-effective-target vect_float } */ +/* { dg-require-effective-target vect_complex_add_half } */ /* { dg-require-effective-target float16 } */ /* { dg-add-options arm_v8_3a_fp16_complex_neon } */ @@ -7,10 +7,8 @@ #define N 200 #include "complex-add-pattern-template.c" -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 4 "vect" { target { vect_complex_add_half } } } } */ -/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { target { vect_complex_add_half } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT90" 1 "vect" { target { vect_complex_add_half } } } } */ +/* { dg-final { scan-tree-dump-times "stmt.*COMPLEX_ADD_ROT270" 1 "vect" { target { vect_complex_add_half } && ! target { arm*-*-* } } } } */ -/* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "slp1" } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT270" "vect" } } */ -/* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "slp1" } } */ /* { dg-final { scan-tree-dump "Found COMPLEX_ADD_ROT90" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mla-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mla-half-float.c index 34146f3d1e7..7beb6b8b5d8 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mla-half-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mla-half-float.c @@ -1,5 +1,7 @@ /* { dg-do compile } */ /* { dg-add-options arm_v8_3a_fp16_complex_neon } */ +/* { dg-require-effective-target vect_complex_add_half } */ +/* { dg-require-effective-target float16 } */ #define TYPE _Float16 #define N 200 diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-double.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-double.c index 0982a2b8ead..fc4cd6151c7 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-double.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-double.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_double } */ /* { dg-add-options arm_v8_3a_complex_neon } */ #define TYPE double diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-float.c index a069533b22a..a931ca61387 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-float.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_float } */ /* { dg-add-options arm_v8_3a_complex_neon } */ #define TYPE float diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-half-float.c index 89ac54c2a42..dd153e49902 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-half-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mls-half-float.c @@ -1,4 +1,6 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_half } */ +/* { dg-require-effective-target float16 } */ /* { dg-add-options arm_v8_3a_fp16_complex_neon } */ #define TYPE _Float16 diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-double.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-double.c index 56a8ea4ae02..b6b21529a10 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-double.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-double.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_double } */ /* { dg-add-options arm_v8_3a_complex_neon } */ #define TYPE double diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-float.c index 969416d7dc7..aa8efb4c2db 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-float.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_float } */ /* { dg-add-options arm_v8_3a_complex_neon } */ #define TYPE float diff --git a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-half-float.c b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-half-float.c index da1b9213a6b..51331625745 100644 --- a/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-half-float.c +++ b/gcc/testsuite/gcc.dg/vect/complex/fast-math-complex-mul-half-float.c @@ -1,4 +1,6 @@ /* { dg-do compile } */ +/* { dg-require-effective-target vect_complex_add_half } */ +/* { dg-require-effective-target float16 } */ /* { dg-add-options arm_v8_3a_fp16_complex_neon } */ #define TYPE _Float16 diff --git a/gcc/testsuite/gcc.dg/vect/pr105219.c b/gcc/testsuite/gcc.dg/vect/pr105219.c new file mode 100644 index 00000000000..0cb7ae2f4d6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr105219.c @@ -0,0 +1,29 @@ +/* { dg-do run } */ +/* { dg-additional-options "-O3" } */ +/* { dg-additional-options "-mtune=intel" { target x86_64-*-* i?86-*-* } } */ + +#include "tree-vect.h" + +int data[128]; + +void __attribute((noipa)) +foo (int *data, int n) +{ + for (int i = 0; i < n; ++i) + data[i] = i; +} + +int main() +{ + check_vect (); + for (int start = 0; start < 16; ++start) + for (int n = 1; n < 3*16; ++n) + { + __builtin_memset (data, 0, sizeof (data)); + foo (&data[start], n); + for (int j = 0; j < n; ++j) + if (data[start + j] != j) + __builtin_abort (); + } + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/vect.exp b/gcc/testsuite/gcc.dg/vect/vect.exp index 5271608cde5..dcaef1e0a37 100644 --- a/gcc/testsuite/gcc.dg/vect/vect.exp +++ b/gcc/testsuite/gcc.dg/vect/vect.exp @@ -121,7 +121,7 @@ et-dg-runtest dg-runtest [lsort \ set DEFAULT_VECTCFLAGS $SAVED_DEFAULT_VECTCFLAGS lappend DEFAULT_VECTCFLAGS "-ffast-math" et-dg-runtest dg-runtest [lsort \ - [glob -nocomplain $srcdir/$subdir/fast-math-\[ipsv\]*.\[cS\]]] \ + [glob -nocomplain $srcdir/$subdir/fast-math-\[ipsvc\]*.\[cS\]]] \ "" $DEFAULT_VECTCFLAGS # -ffast-math SLP tests diff --git a/gcc/testsuite/gcc.target/aarch64/pr103350-1.c b/gcc/testsuite/gcc.target/aarch64/pr103350-1.c index 61c796dc6e8..a0e764e8653 100644 --- a/gcc/testsuite/gcc.target/aarch64/pr103350-1.c +++ b/gcc/testsuite/gcc.target/aarch64/pr103350-1.c @@ -1,4 +1,4 @@ -/* { dg-do run } */ +/* { dg-do run { target le } } */ /* { dg-additional-options "-Os -fno-tree-ter -save-temps -fdump-rtl-ree-all -free -std=c99 -w" } */ typedef unsigned char u8; diff --git a/gcc/testsuite/gcc.target/aarch64/pr103350-2.c b/gcc/testsuite/gcc.target/aarch64/pr103350-2.c index 2696212710b..f799dfc77ce 100644 --- a/gcc/testsuite/gcc.target/aarch64/pr103350-2.c +++ b/gcc/testsuite/gcc.target/aarch64/pr103350-2.c @@ -1,4 +1,4 @@ -/* { dg-do run } */ +/* { dg-do run { target le } } */ /* { dg-additional-options "-O2 -save-temps -fdump-rtl-ree-all -free -std=c99 -w" } */ typedef unsigned char __attribute__((__vector_size__ (8))) v64u8; diff --git a/gcc/testsuite/gcc.target/aarch64/sve/pr105197-1.c b/gcc/testsuite/gcc.target/aarch64/sve/pr105197-1.c new file mode 100644 index 00000000000..e33532d8bed --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sve/pr105197-1.c @@ -0,0 +1,20 @@ +/* { dg-do run { target aarch64_sve_hw } } */ +/* { dg-additional-options "-O -ftree-vectorize" } */ + +unsigned char arr_7[9][3]; +unsigned char (*main_arr_7)[3] = arr_7; +int main() { + char arr_2[9]; + int arr_6[9]; + int x; + unsigned i; + for (i = 0; i < 9; ++i) { + arr_2[i] = 21; + arr_6[i] = 6; + } + for (i = arr_2[8] - 21; i < 2; i++) + x = arr_6[i] ? (main_arr_7[8][i] ? main_arr_7[8][i] : 8) : (char)arr_6[i]; + if (x != 8) + __builtin_abort (); +} + diff --git a/gcc/testsuite/gcc.target/aarch64/sve/pr105197-2.c b/gcc/testsuite/gcc.target/aarch64/sve/pr105197-2.c new file mode 100644 index 00000000000..5eec5cd837d --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sve/pr105197-2.c @@ -0,0 +1,9 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-O -ftree-vectorize" } */ + +void f(int n, int y, char *arr_2, char *arr_6) { + for (int i = y; i < n; i++) + arr_6[i] = arr_6[i] ? (arr_2[i] ? 3 : 8) : 1; +} + +/* { dg-final { scan-assembler-not {\tand\tp[0-9]+.b} } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vadd_reduc-1.c b/gcc/testsuite/gcc.target/aarch64/vadd_reduc-1.c new file mode 100644 index 00000000000..271a1c3e8c3 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vadd_reduc-1.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-O3" } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +#include <arm_neon.h> + +typedef int v4si __attribute__ ((vector_size (16))); + +/* +**bar: +** ... +** addv s0, v0.4s +** fmov w0, s0 +** lsr w1, w0, 16 +** add w0, w1, w0, uxth +** ret +*/ +int bar (v4si x) +{ + unsigned int sum = vaddvq_s32 (x); + return (((uint16_t)(sum & 0xffff)) + ((uint32_t)sum >> 16)); +} diff --git a/gcc/testsuite/gcc.target/aarch64/vadd_reduc-2.c b/gcc/testsuite/gcc.target/aarch64/vadd_reduc-2.c new file mode 100644 index 00000000000..0ad96954ff7 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vadd_reduc-2.c @@ -0,0 +1,34 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-O3 -std=c99" } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +#include <stdint.h> + +#pragma GCC target "+nosve" + +/* +**test: +** ... +** addv s0, v0.4s +** fmov w0, s0 +** and w1, w0, 65535 +** add w0, w1, w0, lsr 16 +** lsr w0, w0, 1 +** ret +*/ +int test (uint8_t *p, uint32_t t[1][1], int n) { + + int sum = 0; + uint32_t a0; + for (int i = 0; i < 4; i++, p++) + t[i][0] = p[0]; + + for (int i = 0; i < 4; i++) { + { + int t0 = t[0][i] + t[0][i]; + a0 = t0; + }; + sum += a0; + } + return (((uint16_t)sum) + ((uint32_t)sum >> 16)) >> 1; +} diff --git a/gcc/testsuite/gcc.target/arm/multilib.exp b/gcc/testsuite/gcc.target/arm/multilib.exp index ddbb4439314..2fa648c61da 100644 --- a/gcc/testsuite/gcc.target/arm/multilib.exp +++ b/gcc/testsuite/gcc.target/arm/multilib.exp @@ -135,14 +135,17 @@ if {[multilib_config "aprofile"] } { {-march=armv8.6-a+simd+fp16 -mfloat-abi=softfp} "thumb/v8-a+simd/softfp" {-march=armv8.6-a+simd+fp16+nofp -mfloat-abi=softfp} "thumb/v8-a/nofp" {-march=armv8.6-a+simd+nofp+fp16 -mfloat-abi=softfp} "thumb/v8-a+simd/softfp" - {-march=armv9-a+crypto -mfloat-abi=soft} "thumb/v9-a/nofp" - {-march=armv9-a+simd+crypto -mfloat-abi=softfp} "thumb/v9-a+simd/softfp" - {-march=armv9-a+simd+crypto+nofp -mfloat-abi=softfp} "thumb/v9-a/nofp" - {-march=armv9-a+simd+nofp+crypto -mfloat-abi=softfp} "thumb/v9-a+simd/softfp" - {-march=armv9-a+fp16 -mfloat-abi=soft} "thumb/v9-a/nofp" - {-march=armv9-a+simd+fp16 -mfloat-abi=softfp} "thumb/v9-a+simd/softfp" - {-march=armv9-a+simd+fp16+nofp -mfloat-abi=softfp} "thumb/v9-a/nofp" - {-march=armv9-a+simd+nofp+fp16 -mfloat-abi=softfp} "thumb/v9-a+simd/softfp" + {-march=armv9-a+crypto -mfloat-abi=soft} "thumb/v8-a/nofp" + {-march=armv9-a+simd+crypto -mfloat-abi=softfp} "thumb/v8-a+simd/softfp" + {-march=armv9-a+simd+crypto+nofp -mfloat-abi=softfp} "thumb/v8-a/nofp" + {-march=armv9-a+simd+nofp+crypto -mfloat-abi=softfp} "thumb/v8-a+simd/softfp" + {-march=armv9-a+fp16 -mfloat-abi=soft} "thumb/v8-a/nofp" + {-march=armv9-a+simd+fp16 -mfloat-abi=softfp} "thumb/v8-a+simd/softfp" + {-march=armv9-a+simd+fp16+nofp -mfloat-abi=softfp} "thumb/v8-a/nofp" + {-march=armv9-a+simd+nofp+fp16 -mfloat-abi=softfp} "thumb/v8-a+simd/softfp" + {-march=armv9-a+simd -mfpu=auto -mfloat-abi=hard} "thumb/v8-a+simd/hard" + {-march=armv9-a+simd -mfpu=auto -mfloat-abi=hard -marm} "thumb/v8-a+simd/hard" + {-march=armv9-a+simd -mfpu=auto -mfloat-abi=hard -mthumb} "thumb/v8-a+simd/hard" {-mcpu=cortex-a53+crypto -mfloat-abi=hard} "thumb/v8-a+simd/hard" {-mcpu=cortex-a53+nofp -mfloat-abi=softfp} "thumb/v8-a/nofp" {-march=armv8-a+crc -mfloat-abi=hard -mfpu=vfp} "thumb/v8-a+simd/hard" diff --git a/gcc/testsuite/gcc.target/arm/pr105312.c b/gcc/testsuite/gcc.target/arm/pr105312.c new file mode 100644 index 00000000000..a02831bcbcf --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/pr105312.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-options "-mcpu=cortex-a15" } */ +/* { dg-add-options arm_neon } */ + +typedef float stress_matrix_type_t; +typedef unsigned int size_t; +static void __attribute__((optimize("-O3"))) stress_matrix_xy_identity( + const size_t n, + stress_matrix_type_t a[restrict n][n], + stress_matrix_type_t b[restrict n][n], + stress_matrix_type_t r[restrict n][n]) +{ + register size_t i; + (void)a; + (void)b; + for (i = 0; i < n; i++) { + register size_t j; + for (j = 0; j < n; j++) + r[i][j] = (i == j) ? 1.0 : 0.0; + return; + } +} diff --git a/gcc/testsuite/gcc.target/arm/reg_equal_test.c b/gcc/testsuite/gcc.target/arm/reg_equal_test.c index 58fa9dd9b94..d87c75cc27c 100644 --- a/gcc/testsuite/gcc.target/arm/reg_equal_test.c +++ b/gcc/testsuite/gcc.target/arm/reg_equal_test.c @@ -1,24 +1,15 @@ /* { dg-do compile } */ -/* { dg-options "-O1 -fdump-rtl-expand" } */ +/* { dg-options "-fgimple -O1 -fdump-rtl-expand" } */ +/* { dg-skip-if "" { ! { arm_thumb2_ok || arm_thumb1_movt_ok } } } */ -extern void abort (void); -unsigned int a = 1; - -int -main (void) +void __GIMPLE (ssa,startwith ("expand")) +x () { - unsigned int b, c, d; - - if (sizeof (int) != 4 || (int) 0xc7d24b5e > 0) - return 0; - - c = 0xc7d24b5e; - d = a | -2; - b = (d == 0) ? c : (c % d); - if (b != c) - abort (); + unsigned int d; - return 0; + __BB(2,guessed_local(1073741824)): + d_1 = 3352447838u; + return; } /* { dg-final { scan-rtl-dump "expr_list:REG_EQUAL \\(const_int -942519458" "expand" } } */ diff --git a/gcc/testsuite/gcc.target/arm/simd/pr105374.C b/gcc/testsuite/gcc.target/arm/simd/pr105374.C new file mode 100644 index 00000000000..2b9096f1f52 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/simd/pr105374.C @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-options "-O3" } */ +/* { dg-require-effective-target arm_v8_1m_mve_ok } */ +/* { dg-add-options arm_v8_1m_mve } */ + +typedef float v4f __attribute__((vector_size(4 * sizeof(float)))); +v4f f_x, f_y; +long f() { return (f_x < f_y | f_x <= f_y)[2]; } diff --git a/gcc/testsuite/gcc.target/i386/auto-init-4.c b/gcc/testsuite/gcc.target/i386/auto-init-4.c index 1803dd45842..5b4fd870c36 100644 --- a/gcc/testsuite/gcc.target/i386/auto-init-4.c +++ b/gcc/testsuite/gcc.target/i386/auto-init-4.c @@ -15,5 +15,6 @@ long double foo() } -/* { dg-final { scan-assembler-times "long\t-16843010" 5 { target { ! ia32 } } } } */ -/* { dg-final { scan-assembler-times "long\t-16843010" 3 { target { ia32 } } } } */ +/* The long double init isn't expanded optimally, see PR105259. For ia32 + it uses zero-initialization. */ +/* { dg-final { scan-assembler-times "long\t-16843010" 3 } } */ diff --git a/gcc/testsuite/gcc.target/i386/crc32-6.c b/gcc/testsuite/gcc.target/i386/crc32-6.c index 464e3444069..7f2b42df3a2 100644 --- a/gcc/testsuite/gcc.target/i386/crc32-6.c +++ b/gcc/testsuite/gcc.target/i386/crc32-6.c @@ -10,4 +10,4 @@ test_mm_crc32_u8 (unsigned int CRC, unsigned char V) return _mm_crc32_u8 (CRC, V); } -/* { dg-error "needs isa option -mcrc32" "" { target *-*-* } 0 } */ +/* { dg-error "target specific option mismatch" "" { target *-*-* } 0 } */ diff --git a/gcc/testsuite/gcc.target/i386/crc32-7.c b/gcc/testsuite/gcc.target/i386/crc32-7.c new file mode 100644 index 00000000000..2e310e38b82 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/crc32-7.c @@ -0,0 +1,34 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -mcrc32" } */ +/* { dg-final { scan-assembler "crc32b\[^\\n\]*eax" } } */ +/* { dg-final { scan-assembler "crc32w\[^\\n\]*eax" } } */ +/* { dg-final { scan-assembler "crc32l\[^\\n\]*eax" } } */ +/* { dg-final { scan-assembler "crc32q\[^\\n\]*rax" { target { ! ia32 } } } } */ + +#include <immintrin.h> + +unsigned int +test_mm_crc32_u8 (unsigned int CRC, unsigned char V) +{ + return _mm_crc32_u8 (CRC, V); +} + +unsigned int +test_mm_crc32_u16 (unsigned int CRC, unsigned short V) +{ + return _mm_crc32_u16 (CRC, V); +} + +unsigned int +test_mm_crc32_u32 (unsigned int CRC, unsigned int V) +{ + return _mm_crc32_u32 (CRC, V); +} + +#ifdef __x86_64__ +unsigned long long +test_mm_crc32_u64 (unsigned long long CRC, unsigned long long V) +{ + return _mm_crc32_u64 (CRC, V); +} +#endif diff --git a/gcc/testsuite/gcc.target/i386/memcpy-strategy-10.c b/gcc/testsuite/gcc.target/i386/memcpy-strategy-10.c index 970aa741971..860fcc9f801 100644 --- a/gcc/testsuite/gcc.target/i386/memcpy-strategy-10.c +++ b/gcc/testsuite/gcc.target/i386/memcpy-strategy-10.c @@ -1,7 +1,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -march=skylake -mno-sse" } */ -/* { dg-final { scan-assembler "jmp\tmemcpy" { target { ! ia32 } } } } */ -/* { dg-final { scan-assembler "call\tmemcpy" { target ia32 } } } */ +/* { dg-final { scan-assembler "jmp\t_?memcpy" { target { ! ia32 } } } } */ +/* { dg-final { scan-assembler "call\t_?memcpy" { target ia32 } } } */ /* { dg-final { scan-assembler-not "rep movsb" } } */ void diff --git a/gcc/testsuite/gcc.target/i386/memcpy-strategy-5.c b/gcc/testsuite/gcc.target/i386/memcpy-strategy-5.c index 83c333b551d..833e37fa325 100644 --- a/gcc/testsuite/gcc.target/i386/memcpy-strategy-5.c +++ b/gcc/testsuite/gcc.target/i386/memcpy-strategy-5.c @@ -1,7 +1,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -march=tigerlake -mno-sse" } */ -/* { dg-final { scan-assembler "jmp\tmemcpy" { target { ! ia32 } } } } */ -/* { dg-final { scan-assembler "call\tmemcpy" { target ia32 } } } */ +/* { dg-final { scan-assembler "jmp\t_?memcpy" { target { ! ia32 } } } } */ +/* { dg-final { scan-assembler "call\t_?memcpy" { target ia32 } } } */ /* { dg-final { scan-assembler-not "rep movsb" } } */ void diff --git a/gcc/testsuite/gcc.target/i386/memset-strategy-5.c b/gcc/testsuite/gcc.target/i386/memset-strategy-5.c index dc1de8e79c2..73ce2df6060 100644 --- a/gcc/testsuite/gcc.target/i386/memset-strategy-5.c +++ b/gcc/testsuite/gcc.target/i386/memset-strategy-5.c @@ -1,7 +1,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -march=tigerlake -mno-sse" } */ -/* { dg-final { scan-assembler "jmp\tmemset" { target { ! ia32 } } } } */ -/* { dg-final { scan-assembler "call\tmemset" { target ia32 } } } */ +/* { dg-final { scan-assembler "jmp\t_?memset" { target { ! ia32 } } } } */ +/* { dg-final { scan-assembler "call\t_?memset" { target ia32 } } } */ /* { dg-final { scan-assembler-not "rep stosb" } } */ void diff --git a/gcc/testsuite/gcc.target/i386/memset-strategy-7.c b/gcc/testsuite/gcc.target/i386/memset-strategy-7.c index 07c2816910c..653829e6fc7 100644 --- a/gcc/testsuite/gcc.target/i386/memset-strategy-7.c +++ b/gcc/testsuite/gcc.target/i386/memset-strategy-7.c @@ -1,7 +1,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -march=skylake -mno-sse" } */ -/* { dg-final { scan-assembler "jmp\tmemset" { target { ! ia32 } } } } */ -/* { dg-final { scan-assembler "call\tmemset" { target ia32 } } } */ +/* { dg-final { scan-assembler "jmp\t_?memset" { target { ! ia32 } } } } */ +/* { dg-final { scan-assembler "call\t_?memset" { target ia32 } } } */ /* { dg-final { scan-assembler-not "rep stosb" } } */ void diff --git a/gcc/testsuite/gcc.target/i386/pr103941-1.c b/gcc/testsuite/gcc.target/i386/pr103941-1.c new file mode 100644 index 00000000000..524fdd0b4b1 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr103941-1.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -msse2" } */ + +unsigned char ur[16], ua[16], ub[16]; + +void avgu_v2qi (void) +{ + int i; + + for (i = 0; i < 2; i++) + ur[i] = (ua[i] + ub[i] + 1) >> 1; +} + +/* { dg-final { scan-assembler "pavgb" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr103941-2.c b/gcc/testsuite/gcc.target/i386/pr103941-2.c new file mode 100644 index 00000000000..972a32be997 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr103941-2.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -msse2" } */ + +void foo (int *c, float *x, float *y) +{ + c[0] = x[0] < y[0]; + c[1] = x[1] < y[1]; + c[2] = x[2] < y[2]; + c[3] = x[3] < y[3]; +} + +/* { dg-final { scan-assembler "cmpltps" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr105253.c b/gcc/testsuite/gcc.target/i386/pr105253.c new file mode 100644 index 00000000000..79444e5b28b --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr105253.c @@ -0,0 +1,17 @@ +/* PR middle-end/105253 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mno-popcnt" } */ +/* { dg-final { scan-assembler-not "__popcount\[sd]i2" } } */ + +int +foo (unsigned long long *p) +{ + int i, cnt = 0; + unsigned long long elem; + for (i = 0; i < 4; i++) + { + for (elem = p[i]; elem; cnt++) + elem &= elem - 1; + } + return cnt; +} diff --git a/gcc/testsuite/gcc.target/i386/pr105338.c b/gcc/testsuite/gcc.target/i386/pr105338.c new file mode 100644 index 00000000000..a7b879444f4 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr105338.c @@ -0,0 +1,26 @@ +/* PR target/105338 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fno-ipa-icf -masm=att" } */ +/* { dg-final { scan-assembler-times "\tnegl\t" 3 } } */ +/* { dg-final { scan-assembler-times "\tsbbl\t" 3 } } */ +/* { dg-final { scan-assembler-times "\tandl\t" 3 } } */ + +int +foo (int i) +{ + return i ? 5 : 0; +} + +int +bar (int b) +{ + return !!b * 5; +} + +int +baz (int b) +{ + if (!b) + return 0; + return 5; +} diff --git a/gcc/testsuite/gcc.target/i386/pr105367.c b/gcc/testsuite/gcc.target/i386/pr105367.c new file mode 100644 index 00000000000..558e3e58e4e --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr105367.c @@ -0,0 +1,12 @@ +/* PR target/105367 */ +/* { dg-do compile } */ +/* { dg-options "-Ofast -mveclibabi=acml" } */ + +_Float64 g; + +void +foo (void) +{ + _Float64 f = __builtin_sin (g); + g = __builtin_fmax (__builtin_sin (f), f); +} diff --git a/gcc/testsuite/gcc.target/i386/sse-14.c b/gcc/testsuite/gcc.target/i386/sse-14.c index 956a9d16f84..f41493b93f3 100644 --- a/gcc/testsuite/gcc.target/i386/sse-14.c +++ b/gcc/testsuite/gcc.target/i386/sse-14.c @@ -430,7 +430,9 @@ test_3 (_mm_maskz_mul_round_sd, __m128d, __mmask8, __m128d, __m128d, 9) test_3 (_mm512_maskz_mul_round_ps, __m512, __mmask16, __m512, __m512, 9) test_3 (_mm_maskz_mul_round_ss, __m128, __mmask8, __m128, __m128, 9) test_3 (_mm512_maskz_scalef_round_pd, __m512d, __mmask8, __m512d, __m512d, 9) +test_3 (_mm_maskz_scalef_round_sd, __m128d, __mmask8, __m128d, __m128d, 9) test_3 (_mm512_maskz_scalef_round_ps, __m512, __mmask16, __m512, __m512, 9) +test_3 (_mm_maskz_scalef_round_ss, __m128, __mmask8, __m128, __m128, 9) test_3 (_mm512_maskz_shuffle_f32x4, __m512, __mmask16, __m512, __m512, 1) test_3 (_mm512_maskz_shuffle_f64x2, __m512d, __mmask8, __m512d, __m512d, 1) test_3 (_mm512_maskz_shuffle_i32x4, __m512i, __mmask16, __m512i, __m512i, 1) @@ -545,7 +547,9 @@ test_4 (_mm_mask_mul_round_sd, __m128d, __m128d, __mmask8, __m128d, __m128d, 9) test_4 (_mm512_mask_mul_round_ps, __m512, __m512, __mmask16, __m512, __m512, 9) test_4 (_mm_mask_mul_round_ss, __m128, __m128, __mmask8, __m128, __m128, 9) test_4 (_mm512_mask_scalef_round_pd, __m512d, __m512d, __mmask8, __m512d, __m512d, 9) +test_4 (_mm_mask_scalef_round_sd, __m128d, __m128d, __mmask8, __m128d, __m128d, 9) test_4 (_mm512_mask_scalef_round_ps, __m512, __m512, __mmask16, __m512, __m512, 9) +test_4 (_mm_mask_scalef_round_ss, __m128, __m128, __mmask8, __m128, __m128, 9) test_4 (_mm512_mask_shuffle_f32x4, __m512, __m512, __mmask16, __m512, __m512, 1) test_4 (_mm512_mask_shuffle_f64x2, __m512d, __m512d, __mmask8, __m512d, __m512d, 1) test_4 (_mm512_mask_shuffle_i32x4, __m512i, __m512i, __mmask16, __m512i, __m512i, 1) diff --git a/gcc/testsuite/gcc.target/loongarch/zero-size-field-pass.c b/gcc/testsuite/gcc.target/loongarch/zero-size-field-pass.c new file mode 100644 index 00000000000..999dc913a71 --- /dev/null +++ b/gcc/testsuite/gcc.target/loongarch/zero-size-field-pass.c @@ -0,0 +1,30 @@ +/* Test that LoongArch backend ignores zero-sized fields of aggregates in + argument passing. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mdouble-float -mabi=lp64d" } */ +/* { dg-final { scan-assembler "\\\$f1" } } */ + +struct test +{ + int empty1[0]; + double empty2[0]; + int : 0; + float x; + long empty3[0]; + long : 0; + float y; + unsigned : 0; + char empty4[0]; +}; + +extern void callee (struct test); + +void +caller (void) +{ + struct test test; + test.x = 114; + test.y = 514; + callee (test); +} diff --git a/gcc/testsuite/gcc.target/loongarch/zero-size-field-ret.c b/gcc/testsuite/gcc.target/loongarch/zero-size-field-ret.c new file mode 100644 index 00000000000..40137d97555 --- /dev/null +++ b/gcc/testsuite/gcc.target/loongarch/zero-size-field-ret.c @@ -0,0 +1,28 @@ +/* Test that LoongArch backend ignores zero-sized fields of aggregates in + returning. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mdouble-float -mabi=lp64d" } */ +/* { dg-final { scan-assembler-not "\\\$r4" } } */ + +struct test +{ + int empty1[0]; + double empty2[0]; + int : 0; + float x; + long empty3[0]; + long : 0; + float y; + unsigned : 0; + char empty4[0]; +}; + +extern struct test callee (void); + +float +caller (void) +{ + struct test test = callee (); + return test.x + test.y; +} diff --git a/gcc/testsuite/gcc.target/mips/pr102024-4.c b/gcc/testsuite/gcc.target/mips/pr102024-4.c index 2147cc769d0..ea49e890ee5 100644 --- a/gcc/testsuite/gcc.target/mips/pr102024-4.c +++ b/gcc/testsuite/gcc.target/mips/pr102024-4.c @@ -1,5 +1,5 @@ // { dg-do compile } -// { dg-options "-mabi=64 -mhard-float" } +// { dg-options "-mabi=64 -mhard-float -ffat-lto-objects" } struct __attribute__((aligned(16))) test { int x[0]; diff --git a/gcc/testsuite/gcc.target/powerpc/bswap-brw.c b/gcc/testsuite/gcc.target/powerpc/bswap-brw.c index b3f923eea84..0ed2a7bd1d2 100644 --- a/gcc/testsuite/gcc.target/powerpc/bswap-brw.c +++ b/gcc/testsuite/gcc.target/powerpc/bswap-brw.c @@ -17,6 +17,6 @@ bswap_int_dbl (unsigned int a) /* Force the value to be loaded into a vector register. */ __asm__ (" # %x0" : "+wa" (b)); - /* { dg-final { scan-assembler {\mxxbrw\M} } } */ + /* { dg-final { scan-assembler {\mxxbrw\M} {xfail {has_arch_pwr10 && {! has_arch_ppc64}}} } } */ return (double) __builtin_bswap32 (b); } diff --git a/gcc/testsuite/gcc.target/powerpc/p9-vec-length-epil-7.c b/gcc/testsuite/gcc.target/powerpc/p9-vec-length-epil-7.c index a27ee347ca1..011b731f7c5 100644 --- a/gcc/testsuite/gcc.target/powerpc/p9-vec-length-epil-7.c +++ b/gcc/testsuite/gcc.target/powerpc/p9-vec-length-epil-7.c @@ -1,5 +1,7 @@ /* { dg-do compile { target { lp64 && powerpc_p9vector_ok } } } */ -/* { dg-options "-mdejagnu-cpu=power9 -O2 -ftree-vectorize -fno-vect-cost-model -fno-unroll-loops -ffast-math" } */ +/* Pass cunroll isn't disabled by -fno-unroll-loops, so use explicit + disabling option for it. */ +/* { dg-options "-mdejagnu-cpu=power9 -O2 -ftree-vectorize -fno-vect-cost-model -fno-unroll-loops -ffast-math -fdisable-tree-cunroll" } */ /* { dg-additional-options "--param=vect-partial-vector-usage=1" } */ diff --git a/gcc/testsuite/gcc.target/powerpc/p9-vec-length-full-7.c b/gcc/testsuite/gcc.target/powerpc/p9-vec-length-full-7.c index 89ff38443e7..e0e51d9a972 100644 --- a/gcc/testsuite/gcc.target/powerpc/p9-vec-length-full-7.c +++ b/gcc/testsuite/gcc.target/powerpc/p9-vec-length-full-7.c @@ -1,5 +1,7 @@ /* { dg-do compile { target { lp64 && powerpc_p9vector_ok } } } */ -/* { dg-options "-mdejagnu-cpu=power9 -O2 -ftree-vectorize -fno-vect-cost-model -fno-unroll-loops -ffast-math" } */ +/* Pass cunroll isn't disabled by -fno-unroll-loops, so use explicit + disabling option for it. */ +/* { dg-options "-mdejagnu-cpu=power9 -O2 -ftree-vectorize -fno-vect-cost-model -fno-unroll-loops -ffast-math -fdisable-tree-cunroll" } */ /* { dg-additional-options "--param=vect-partial-vector-usage=2" } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr104253.c b/gcc/testsuite/gcc.target/powerpc/pr104253.c index 02049cc978f..e5f9499b7c8 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr104253.c +++ b/gcc/testsuite/gcc.target/powerpc/pr104253.c @@ -6,8 +6,9 @@ */ /* { dg-do run } */ -/* { require-effective-target ppc_float128_sw } */ +/* { dg-require-effective-target ppc_float128_sw } */ /* { dg-options "-O2 -mvsx -mfloat128" } */ +/* { dg-prune-output ".-mfloat128. option may not be fully supported" } */ /* * PR target/104253 diff --git a/gcc/testsuite/gcc.target/powerpc/pr104894-2.c b/gcc/testsuite/gcc.target/powerpc/pr104894-2.c new file mode 100644 index 00000000000..d1a011ef4d9 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr104894-2.c @@ -0,0 +1,22 @@ +/* PR target/104894 */ +/* { dg-require-effective-target powerpc_elfv2 } */ +/* { dg-require-effective-target power10_ok } */ +/* { dg-options "-O2 -mdejagnu-cpu=power10 -fno-plt" } */ + +/* Verify we do not ICE on the following test case and that we emit one + indirect call and one indirect sibcall, with r12 and CTR containing + the function addresses. */ + +void foo (void); + +void +bar (void) +{ + foo (); + foo (); +} + +/* { dg-final { scan-assembler-times {\mmtctr 12\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mbctrl\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mbctr\M} 1 } } */ +/* { dg-final { scan-assembler-not {\mbl\M} } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr104894.c b/gcc/testsuite/gcc.target/powerpc/pr104894.c new file mode 100644 index 00000000000..f46fe88168f --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr104894.c @@ -0,0 +1,20 @@ +/* PR target/104894 */ +/* { dg-require-effective-target powerpc_elfv2 } */ +/* { dg-require-effective-target power10_ok } */ +/* { dg-options "-O2 -mdejagnu-cpu=power10 -fno-plt" } */ + +/* Verify we do not ICE on the following test case and that we emit an + indirect sibcall, with r12 and CTR containing the function address. */ + +void foo (void); + +void +bar (void) +{ + foo (); +} + +/* { dg-final { scan-assembler-times {\mmtctr 12\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mbctr\M} 1 } } */ +/* { dg-final { scan-assembler-not {\mbl\M} } } */ +/* { dg-final { scan-assembler-not {\mbctrl\M} } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr105271.c b/gcc/testsuite/gcc.target/powerpc/pr105271.c new file mode 100644 index 00000000000..1c5f88cadcf --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr105271.c @@ -0,0 +1,14 @@ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mdejagnu-cpu=power7" } */ + +/* It's to verify no ICE here, ignore error messages about + the required options for vec_neg here. */ +/* { dg-excess-errors "pr105271" } */ + +#include <altivec.h> + +vector signed long long +test (vector signed long long x) +{ + return vec_neg (x); +} diff --git a/gcc/testsuite/gcc.target/powerpc/pr105334.c b/gcc/testsuite/gcc.target/powerpc/pr105334.c new file mode 100644 index 00000000000..7664e033dd0 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr105334.c @@ -0,0 +1,31 @@ +/* Skip this on aix, since it takes soft-float and long-double-128 + incompatible and warns it. */ +/* { dg-skip-if "aix long-double-128 soft-float" { powerpc*-*-aix* } } */ +/* { dg-options "-mlong-double-128 -msoft-float" } */ + +/* Verify there is no ICE. */ + +#include <stddef.h> +#include <stdlib.h> +#include <math.h> + +#define PACK __builtin_pack_ibm128 +#define UNPACK __builtin_unpack_ibm128 +#define LDOUBLE __ibm128 + +extern LDOUBLE bar (LDOUBLE); + +int +main (void) +{ + double high = pow (2.0, 60); + double low = 2.0; + LDOUBLE a = ((LDOUBLE) high) + ((LDOUBLE) low); + double x0 = UNPACK (a, 0); + double x1 = UNPACK (a, 1); + LDOUBLE b = PACK (x0, x1); + LDOUBLE c = bar (b); + + return c > a; +} + diff --git a/gcc/testsuite/gcc.target/powerpc/pr56605.c b/gcc/testsuite/gcc.target/powerpc/pr56605.c index fdedbfc573d..7695f87db6f 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr56605.c +++ b/gcc/testsuite/gcc.target/powerpc/pr56605.c @@ -11,5 +11,5 @@ void foo (short* __restrict sb, int* __restrict ia) ia[i] = (int) sb[i]; } -/* { dg-final { scan-rtl-dump-times {\(compare:CC \((?:and|zero_extend):(?:DI) \((?:sub)?reg:[SD]I} 1 "combine" } } */ +/* { dg-final { scan-rtl-dump-times {\(compare:CC \((?:and|zero_extend):(?:[SD]I) \((?:sub)?reg:[SD]I} 1 "combine" } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr60203.c b/gcc/testsuite/gcc.target/powerpc/pr60203.c index 7ada64a32db..a5a574a8837 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr60203.c +++ b/gcc/testsuite/gcc.target/powerpc/pr60203.c @@ -1,5 +1,6 @@ /* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ /* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-require-effective-target longdouble128 } */ /* { dg-require-effective-target powerpc_p8vector_ok } */ /* { dg-options "-mdejagnu-cpu=power8 -O3" } */ diff --git a/gcc/testsuite/gcc.target/riscv/pr105314.c b/gcc/testsuite/gcc.target/riscv/pr105314.c new file mode 100644 index 00000000000..7a54577e9a9 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr105314.c @@ -0,0 +1,12 @@ +/* PR rtl-optimization/105314 */ +/* { dg-do compile } * +/* { dg-options "-O2" } */ +/* { dg-final { scan-assembler-not "\tbeq\t" } } */ + +long +foo (long a, long b, long c) +{ + if (c) + a = 0; + return a; +} diff --git a/gcc/testsuite/gcc.target/s390/pr80725.c b/gcc/testsuite/gcc.target/s390/pr80725.c index d556e6ba7ca..18f1427b25e 100644 --- a/gcc/testsuite/gcc.target/s390/pr80725.c +++ b/gcc/testsuite/gcc.target/s390/pr80725.c @@ -1,7 +1,7 @@ /* Regression test for PR/80725. */ /* { dg-do compile } */ -/* { dg-options "-O2 -march=zEC12" } */ +/* { dg-options "-O2 -march=zEC12 -Wno-int-to-pointer-cast" } */ int a, e; const char b; diff --git a/gcc/testsuite/gdc.test/compilable/betterCarray.d b/gcc/testsuite/gdc.test/compilable/betterCarray.d index 3e9a881c3d6..72dcc6b5ee3 100644 --- a/gcc/testsuite/gdc.test/compilable/betterCarray.d +++ b/gcc/testsuite/gdc.test/compilable/betterCarray.d @@ -26,3 +26,10 @@ void issue19234() A[10] b; b[] = a[]; } + +/**********************************************/ +// https://issues.dlang.org/show_bug.cgi?id=22922 +void issue22922() +{ + int[] x = []; +} diff --git a/gcc/testsuite/gdc.test/compilable/extra-files/header1.d b/gcc/testsuite/gdc.test/compilable/extra-files/header1.d index 3c2e90ab8ac..93f05a50c31 100644 --- a/gcc/testsuite/gdc.test/compilable/extra-files/header1.d +++ b/gcc/testsuite/gdc.test/compilable/extra-files/header1.d @@ -607,3 +607,13 @@ T throwStuff(T)(T t) if (false) test13x(1, throw new Exception(""), 2); return t ? t : throw new Exception("Bad stuff happens!"); } + +class C12344 +{ + abstract int c12344(int x) in(x > 0) out(result) {assert(result > 0);}; +} + +interface I12344 +{ + int i12344(int x) in(x > 0) out(result) {assert(result > 0);}; +} diff --git a/gcc/testsuite/gdc.test/compilable/imports/imp17434a.d b/gcc/testsuite/gdc.test/compilable/imports/imp17434a.d new file mode 100644 index 00000000000..5046cbb31ce --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/imports/imp17434a.d @@ -0,0 +1 @@ +module imp17434a.test1; diff --git a/gcc/testsuite/gdc.test/compilable/imports/imp17434b.d b/gcc/testsuite/gdc.test/compilable/imports/imp17434b.d new file mode 100644 index 00000000000..88c37ab488a --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/imports/imp17434b.d @@ -0,0 +1,6 @@ +module imp.imports17434b; + +void testing() +{ + return; +} diff --git a/gcc/testsuite/gdc.test/compilable/interpret3.d b/gcc/testsuite/gdc.test/compilable/interpret3.d index ff85856b62e..2c9a84eddfb 100644 --- a/gcc/testsuite/gdc.test/compilable/interpret3.d +++ b/gcc/testsuite/gdc.test/compilable/interpret3.d @@ -2473,12 +2473,12 @@ static assert(checkPass("foobar") == 1); struct Toq { - const(char)* m; + char* m; } Toq ptrRet(bool b) { - string x = "abc"; + char[] x = "abc".dup; return Toq(b ? x[0 .. 1].ptr : null); } @@ -7808,3 +7808,101 @@ int test9937() } static assert(test9937()); + +/************************************************/ +// static array .tupleof + +struct SArrayTupleEquiv(T) +{ + T f1; + T f2; +} + +// basic .tupleof invariants +bool testSArrayTupleA() +{ + int[2] xs; + assert(xs.tupleof == TypeTuple!(0, 0)); + assert(xs.tupleof == (cast(int[2])[0, 0]).tupleof); + + xs.tupleof = TypeTuple!(1, 2); + assert(xs.tupleof == TypeTuple!(1, 2)); + + auto ys = SArrayTupleEquiv!int(1, 2); + assert(xs.tupleof == ys.tupleof); + + return true; +} +static assert(testSArrayTupleA()); + +// tuples with side effects +bool testSArrayTupleB() +{ + // Counter records lifetime events in copies/dtors, as a cheap way to check that .tupleof for + // static arrays exhibit all the same side effects as an equivalent struct's .tupleof + int[int] copies; + int[int] dtors; + struct Counter + { + int id = -1; + + this(this) + { + copies[id] = copies.get(id, 0) + 1; + } + + ~this() + { + dtors[id] = dtors.get(id, 0) + 1; + } + } + + void consume(Counter, Counter) {} + Counter[2] produce(int id1, int id2) + { + return [Counter(id1), Counter(id2)]; + } + + // first sample expected behavior from struct .tupleof + // braces create a subscope, shortening lifetimes + { + auto a = SArrayTupleEquiv!Counter(Counter(0), Counter(1)); + + typeof(a) b; + b.tupleof = a.tupleof; + + Counter x, y; + TypeTuple!(x, y) = a.tupleof; + + a.tupleof[0] = Counter(2); + a.tupleof[1] = Counter(3); + consume(a.tupleof); + + a.tupleof = produce(4, 5).tupleof; + } + int[int][2] expected = [copies.dup, dtors.dup]; + copies = null; // .clear is not CTFE friendly + dtors = null; + + // the real test -- sample behavior of array .tupleof + { + Counter[2] a = [Counter(0), Counter(1)]; + + typeof(a) b; + b.tupleof = a.tupleof; + + Counter x, y; + TypeTuple!(x, y) = a.tupleof; + + a.tupleof[0] = Counter(2); + a.tupleof[1] = Counter(3); + consume(a.tupleof); + + a.tupleof = produce(4, 5).tupleof; + } + assert(expected[0] == copies); + assert(expected[1] == dtors); + + return true; +} +static assert(testSArrayTupleB()); diff --git a/gcc/testsuite/gdc.test/compilable/json.d b/gcc/testsuite/gdc.test/compilable/json.d index 73d3101b835..f4d68e7dc8c 100644 --- a/gcc/testsuite/gdc.test/compilable/json.d +++ b/gcc/testsuite/gdc.test/compilable/json.d @@ -203,14 +203,14 @@ extern(C) int vlinakgeC; extern(C++) __gshared int vlinkageCpp; extern(Windows) int vlinkageWindows; extern(Objective-C) int vlinkageObjc; - +extern(System) int vlinkageSystem; extern int flinkageDefault(); extern(D) int flinkageD(); extern(C) int linakgeC(); extern(C++) int flinkageCpp(); extern(Windows) int flinkageWindows(); extern(Objective-C) int flinkageObjc(); - +extern(System) int flinkageSystem(); mixin template test18211(int n) { static foreach (i; 0 .. n>10 ? 10 : n) diff --git a/gcc/testsuite/gdc.test/compilable/mixintype2.d b/gcc/testsuite/gdc.test/compilable/mixintype2.d index d160bd410ad..a61adc570fa 100644 --- a/gcc/testsuite/gdc.test/compilable/mixintype2.d +++ b/gcc/testsuite/gdc.test/compilable/mixintype2.d @@ -115,3 +115,9 @@ void test_statements_22356() mixin("int") y22356, z22356; static assert(is(typeof(y22356) == int) && is(typeof(z22356) == int)); } + +/**************************************************/ +// https://issues.dlang.org/show_bug.cgi?id=22969 + +enum e = 0; +alias a = mixin("e"); diff --git a/gcc/testsuite/gdc.test/compilable/must_use_assign.d b/gcc/testsuite/gdc.test/compilable/must_use_assign.d new file mode 100644 index 00000000000..bd1983a40e6 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/must_use_assign.d @@ -0,0 +1,9 @@ +import core.attribute; + +@mustuse struct S {} + +void test() +{ + S a, b; + a = b; +} diff --git a/gcc/testsuite/gdc.test/compilable/must_use_not_reserved.d b/gcc/testsuite/gdc.test/compilable/must_use_not_reserved.d new file mode 100644 index 00000000000..c6001198489 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/must_use_not_reserved.d @@ -0,0 +1,5 @@ +import core.attribute; + +@mustuse int n; +@mustuse alias A = int; +@mustuse template tpl() {} diff --git a/gcc/testsuite/gdc.test/compilable/must_use_opassign.d b/gcc/testsuite/gdc.test/compilable/must_use_opassign.d new file mode 100644 index 00000000000..8e877dd69b6 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/must_use_opassign.d @@ -0,0 +1,15 @@ +import core.attribute; + +@mustuse struct S +{ + ref S opAssign(S rhs) return + { + return this; + } +} + +void test() +{ + S a, b; + a = b; +} diff --git a/gcc/testsuite/gdc.test/compilable/must_use_opopassign.d b/gcc/testsuite/gdc.test/compilable/must_use_opopassign.d new file mode 100644 index 00000000000..0176354ed1d --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/must_use_opopassign.d @@ -0,0 +1,15 @@ +import core.attribute; + +@mustuse struct S +{ + ref S opOpAssign(string op)(S rhs) return + { + return this; + } +} + +void test() +{ + S a, b; + a += b; +} diff --git a/gcc/testsuite/gdc.test/compilable/must_use_opunary.d b/gcc/testsuite/gdc.test/compilable/must_use_opunary.d new file mode 100644 index 00000000000..fc9650ebed5 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/must_use_opunary.d @@ -0,0 +1,18 @@ +import core.attribute; + +@mustuse struct S +{ + ref S opUnary(string op)() return + { + return this; + } +} + +void test() +{ + S s; + ++s; + --s; + s++; + s--; +} diff --git a/gcc/testsuite/gdc.test/compilable/must_use_suppress.d b/gcc/testsuite/gdc.test/compilable/must_use_suppress.d new file mode 100644 index 00000000000..63ad75c2928 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/must_use_suppress.d @@ -0,0 +1,10 @@ +import core.attribute; + +@mustuse struct S {} + +S fun() { return S(); } + +void test() +{ + cast(void) fun(); +} diff --git a/gcc/testsuite/gdc.test/compilable/revert_dip1000.d b/gcc/testsuite/gdc.test/compilable/revert_dip1000.d new file mode 100644 index 00000000000..ad6a6d8aade --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/revert_dip1000.d @@ -0,0 +1,7 @@ +/* +REQUIRED_ARGS: -revert=dip1000 +TEST_OUTPUT: +--- +--- +*/ +int* oops(scope int* p) @safe { return p; } diff --git a/gcc/testsuite/gdc.test/compilable/test17419.d b/gcc/testsuite/gdc.test/compilable/test17419.d index e34e7da5444..1a92a1c9112 100644 --- a/gcc/testsuite/gdc.test/compilable/test17419.d +++ b/gcc/testsuite/gdc.test/compilable/test17419.d @@ -17,10 +17,7 @@ static assert(__traits(getLinkage, food) == "D"); static assert(__traits(getLinkage, foocpp) == "C++"); static assert(__traits(getLinkage, foow) == "Windows"); static assert(__traits(getLinkage, fooobjc) == "Objective-C"); -version (Windows) - static assert(__traits(getLinkage, foos) == "Windows"); -else - static assert(__traits(getLinkage, foos) == "C"); +static assert(__traits(getLinkage, foos) == "System"); extern (C) int global; static assert(__traits(getLinkage, global) == "C"); diff --git a/gcc/testsuite/gdc.test/compilable/test17434.d b/gcc/testsuite/gdc.test/compilable/test17434.d new file mode 100644 index 00000000000..82bfa570b5f --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/test17434.d @@ -0,0 +1,11 @@ +// https://issues.dlang.org/show_bug.cgi?id=17434 + +// EXTRA_FILES: test17434a.d imports/imp17434a.d imports/imp17434b.d +module test17434; + +import test17434a; + +void main() +{ + imports.imp17434b.testing(); +} diff --git a/gcc/testsuite/gdc.test/compilable/test17434a.d b/gcc/testsuite/gdc.test/compilable/test17434a.d new file mode 100644 index 00000000000..c9175fe385b --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/test17434a.d @@ -0,0 +1,5 @@ +// EXTRA_FILES: imports/imp17434a.d imports/imp17434b.d +module test17434a; + +private import imports.imp17434a; +public import imports.imp17434b; diff --git a/gcc/testsuite/gdc.test/compilable/test18216.d b/gcc/testsuite/gdc.test/compilable/test18216.d new file mode 100644 index 00000000000..43f5629a3c7 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/test18216.d @@ -0,0 +1,40 @@ +// https://issues.dlang.org/show_bug.cgi?id=18216 + +struct Node +{ + mixin Type!(); + Pointer left; +} + +mixin template Type() +{ + alias Base = typeof(this); + + static struct Proxy + { + struct Node + { + Base m_payload; + } + static immutable default_value = Base.init; // just remove this will work + } + + alias pNode = shared(Proxy.Node)*; + + static struct Pointer + { + Base* _ptr; + auto ptr() + { + return cast(pNode) _ptr; + } + + void opAssign(ref Pointer other) {} // just remove this will work + + alias getThis this; // just remove this will work + ref auto getThis() return + { + return ptr.m_payload; + } + } +} diff --git a/gcc/testsuite/gdc.test/compilable/test19097.d b/gcc/testsuite/gdc.test/compilable/test19097.d index 19e189caf5d..a6d30024881 100644 --- a/gcc/testsuite/gdc.test/compilable/test19097.d +++ b/gcc/testsuite/gdc.test/compilable/test19097.d @@ -21,3 +21,43 @@ void foo(scope int* pf) betty(rf, pf); boop(rf, pf); } + +// https://issues.dlang.org/show_bug.cgi?id=22801 +struct Wrapper +{ + int* ptr; + + this(return ref int var) @safe + { + this.ptr = &var; + } +} + +void main() @safe +{ + int i; + auto w = Wrapper(i); + auto wt = WrapperT!()(i); +} + +void assign(ref scope int* x, return ref int y) @safe +{ + x = &y; +} + +// https://issues.dlang.org/show_bug.cgi?id=22967 +// inference of `return ref` when assigned to first parameter +struct WrapperT() +{ + int* ptr; + + this(ref int var) @safe + { + this.ptr = &var; + } + + static void assignInferred(ref scope int* xi, ref int yi) @safe + { + xi = &yi; + } +} diff --git a/gcc/testsuite/gdc.test/compilable/test22635.d b/gcc/testsuite/gdc.test/compilable/test22635.d new file mode 100644 index 00000000000..c2abc837956 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/test22635.d @@ -0,0 +1,13 @@ +// https://issues.dlang.org/show_bug.cgi?id=22635 +// opCast prevent calling destructor for const this + +struct Foo +{ + bool opCast(T : bool)() const { assert(0); } + ~this() {} +} + +struct Bar +{ + const Foo foo; +} diff --git a/gcc/testsuite/gdc.test/compilable/test22988.d b/gcc/testsuite/gdc.test/compilable/test22988.d new file mode 100644 index 00000000000..6be3921e67b --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/test22988.d @@ -0,0 +1,15 @@ +// https://issues.dlang.org/show_bug.cgi?id=22988 + +enum a1 = 0; +enum b1 = a1 ? 1 << a1 - 1 : 0; + +enum l = 0; +enum int[l] a2 = []; +enum b2 = l ? a2[l - 1] : 0; + +enum a3 = 0 ? 1 << -1 : 0; + +enum int[0] a4 = []; +enum b4 = 0 ? a4[0] : 0; + +enum b5 = false ? (1 << -1) : 0; diff --git a/gcc/testsuite/gdc.test/compilable/test22997.d b/gcc/testsuite/gdc.test/compilable/test22997.d new file mode 100644 index 00000000000..3cad527b4c2 --- /dev/null +++ b/gcc/testsuite/gdc.test/compilable/test22997.d @@ -0,0 +1,14 @@ +// https://issues.dlang.org/show_bug.cgi?id=22997 + +struct Forward {} + +struct Foo +{ + this(ref typeof(this) rhs) + { + this(rhs, Forward.init); + } + + this(ref typeof(this) rhs, Forward) {} + this(typeof(this) rhs, int i, double d, string s) {} +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/diag11198.d b/gcc/testsuite/gdc.test/fail_compilation/diag11198.d index ebefa4dc6af..279d62a5496 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/diag11198.d +++ b/gcc/testsuite/gdc.test/fail_compilation/diag11198.d @@ -1,8 +1,12 @@ /* TEST_OUTPUT: --- -fail_compilation/diag11198.d(11): Error: version conditions can only be declared at module scope -fail_compilation/diag11198.d(12): Error: debug conditions can only be declared at module scope +fail_compilation/diag11198.d(15): Error: version `blah` declaration must be at module level +fail_compilation/diag11198.d(16): Error: debug `blah` declaration must be at module level +fail_compilation/diag11198.d(17): Error: version `1` level declaration must be at module level +fail_compilation/diag11198.d(18): Error: debug `2` level declaration must be at module level +fail_compilation/diag11198.d(19): Error: identifier or integer expected, not `""` +fail_compilation/diag11198.d(20): Error: identifier or integer expected, not `""` --- */ @@ -10,4 +14,8 @@ void main() { version = blah; debug = blah; + version = 1; + debug = 2; + version = ""; + debug = ""; } diff --git a/gcc/testsuite/gdc.test/fail_compilation/diag14235.d b/gcc/testsuite/gdc.test/fail_compilation/diag14235.d index 3c8a98e6e35..29261b4ea1c 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/diag14235.d +++ b/gcc/testsuite/gdc.test/fail_compilation/diag14235.d @@ -2,8 +2,8 @@ EXTRA_FILES: imports/a14235.d TEST_OUTPUT: --- -fail_compilation/diag14235.d(12): Error: template identifier `Undefined` is not a member of module `imports.a14235` -fail_compilation/diag14235.d(13): Error: template identifier `Something` is not a member of module `imports.a14235`, did you mean struct `SomeThing(T...)`? +fail_compilation/diag14235.d(12): Error: undefined identifier `Undefined` in module `imports.a14235` +fail_compilation/diag14235.d(13): Error: undefined identifier `Something` in module `imports.a14235`, did you mean struct `SomeThing(T...)`? fail_compilation/diag14235.d(14): Error: `imports.a14235.SomeClass` is not a template, it is a class --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/diag8101.d b/gcc/testsuite/gdc.test/fail_compilation/diag8101.d index 282665ff8d5..301472ca28a 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/diag8101.d +++ b/gcc/testsuite/gdc.test/fail_compilation/diag8101.d @@ -2,7 +2,7 @@ TEST_OUTPUT: --- fail_compilation/diag8101.d(57): Error: function `diag8101.f_0(int)` is not callable using argument types `()` -fail_compilation/diag8101.d(57): missing argument for parameter #1: `int` +fail_compilation/diag8101.d(57): too few arguments, expected `1`, got `0` fail_compilation/diag8101.d(58): Error: none of the overloads of `f_1` are callable using argument types `()` fail_compilation/diag8101.d(33): Candidates are: `diag8101.f_1(int)` fail_compilation/diag8101.d(34): `diag8101.f_1(int, int)` diff --git a/gcc/testsuite/gdc.test/fail_compilation/diag_funclit.d b/gcc/testsuite/gdc.test/fail_compilation/diag_funclit.d index b46c562e87d..1279d7c2a2a 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/diag_funclit.d +++ b/gcc/testsuite/gdc.test/fail_compilation/diag_funclit.d @@ -2,7 +2,7 @@ TEST_OUTPUT: --- fail_compilation/diag_funclit.d(103): Error: function literal `__lambda1(x, y, z)` is not callable using argument types `()` -fail_compilation/diag_funclit.d(103): missing argument for parameter #1: `x` +fail_compilation/diag_funclit.d(103): too few arguments, expected `3`, got `0` fail_compilation/diag_funclit.d(106): Error: function literal `__lambda2(x, y, z)` is not callable using argument types `(int, string, int, int)` fail_compilation/diag_funclit.d(106): too many arguments, expected `3`, got `4` fail_compilation/diag_funclit.d(108): Error: function literal `__lambda3(x, y, string z = "Hello")` is not callable using argument types `(int, int, string, string)` diff --git a/gcc/testsuite/gdc.test/fail_compilation/diagin.d b/gcc/testsuite/gdc.test/fail_compilation/diagin.d index eb88a23151a..1418ced43a2 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/diagin.d +++ b/gcc/testsuite/gdc.test/fail_compilation/diagin.d @@ -3,7 +3,7 @@ PERMUTE_ARGS: -preview=in TEST_OUTPUT: --- fail_compilation/diagin.d(14): Error: function `diagin.foo(in int)` is not callable using argument types `()` -fail_compilation/diagin.d(14): missing argument for parameter #1: `in int` +fail_compilation/diagin.d(14): too few arguments, expected `1`, got `0` fail_compilation/diagin.d(16): Error: none of the overloads of template `diagin.foo1` are callable using argument types `!()(bool[])` fail_compilation/diagin.d(20): Candidate is: `foo1(T)(in T v, string)` --- diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail22202.d b/gcc/testsuite/gdc.test/fail_compilation/fail22202.d new file mode 100644 index 00000000000..167d3624879 --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/fail22202.d @@ -0,0 +1,22 @@ +// https://issues.dlang.org/show_bug.cgi?id=22202 + +/* +TEST_OUTPUT: +--- +fail_compilation/fail22202.d(21): Error: function `fail22202.fun(SystemCopy _param_0)` is not callable using argument types `(SystemCopy)` +fail_compilation/fail22202.d(21): `inout ref inout(SystemCopy)(ref inout(SystemCopy) other)` copy constructor cannot be called from a `pure @safe nogc` context +--- +*/ + +struct SystemCopy +{ + this(ref inout SystemCopy other) inout {} +} + +void fun(SystemCopy) @safe pure @nogc {} + +void main() @safe pure @nogc +{ + SystemCopy s; + fun(s); +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail23036.d b/gcc/testsuite/gdc.test/fail_compilation/fail23036.d new file mode 100644 index 00000000000..8920586c67a --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/fail23036.d @@ -0,0 +1,22 @@ +// https://issues.dlang.org/show_bug.cgi?id=23036 + +/* +TEST_OUTPUT: +--- +fail_compilation/fail23036.d(12): Error: `struct S` may not define both a rvalue constructor and a copy constructor +fail_compilation/fail23036.d(15): rvalue constructor defined here +fail_compilation/fail23036.d(14): copy constructor defined here +--- +*/ + +struct S +{ + this(ref S) {} + this(S, int a = 2) {} +} + +void main() +{ + S a; + S b = a; +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail2656.d b/gcc/testsuite/gdc.test/fail_compilation/fail2656.d index ffd38de4502..520c1b14bfb 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/fail2656.d +++ b/gcc/testsuite/gdc.test/fail_compilation/fail2656.d @@ -1,20 +1,20 @@ /* TEST_OUTPUT: --- -fail_compilation/fail2656.d(21): Error: octal literals `0123` are no longer supported, use `std.conv.octal!123` instead -fail_compilation/fail2656.d(22): Error: octal literals `01000000000000000000000` are no longer supported, use `std.conv.octal!1000000000000000000000` instead -fail_compilation/fail2656.d(23): Error: octal literals `0100000L` are no longer supported, use `std.conv.octal!100000L` instead -fail_compilation/fail2656.d(24): Error: octal literals `01777777777777777777777u` are no longer supported, use `std.conv.octal!1777777777777777777777u` instead -fail_compilation/fail2656.d(25): Error: octal literals `017777777777uL` are no longer supported, use `std.conv.octal!17777777777uL` instead -fail_compilation/fail2656.d(26): Error: octal literals `0177777` are no longer supported, use `std.conv.octal!177777` instead -fail_compilation/fail2656.d(27): Error: octal literals `020000000000L` are no longer supported, use `std.conv.octal!20000000000L` instead -fail_compilation/fail2656.d(28): Error: octal literals `0200000u` are no longer supported, use `std.conv.octal!200000u` instead -fail_compilation/fail2656.d(29): Error: octal literals `037777777777uL` are no longer supported, use `std.conv.octal!37777777777uL` instead -fail_compilation/fail2656.d(30): Error: octal literals `040000000000` are no longer supported, use `std.conv.octal!40000000000` instead -fail_compilation/fail2656.d(31): Error: octal literals `0777777777777777777777L` are no longer supported, use `std.conv.octal!777777777777777777777L` instead -fail_compilation/fail2656.d(32): Error: octal literals `077777u` are no longer supported, use `std.conv.octal!77777u` instead -fail_compilation/fail2656.d(33): Error: octal literals `077777uL` are no longer supported, use `std.conv.octal!77777uL` instead -fail_compilation/fail2656.d(34): Error: octal literals `077777uL` are no longer supported, use `std.conv.octal!77777uL` instead +fail_compilation/fail2656.d(21): Error: octal literals `0123` are no longer supported, use `std.conv.octal!"123"` instead +fail_compilation/fail2656.d(22): Error: octal literals `01000000000000000000000` are no longer supported, use `std.conv.octal!"1000000000000000000000"` instead +fail_compilation/fail2656.d(23): Error: octal literals `0100000L` are no longer supported, use `std.conv.octal!"100000L"` instead +fail_compilation/fail2656.d(24): Error: octal literals `01777777777777777777777u` are no longer supported, use `std.conv.octal!"1777777777777777777777u"` instead +fail_compilation/fail2656.d(25): Error: octal literals `017777777777uL` are no longer supported, use `std.conv.octal!"17777777777uL"` instead +fail_compilation/fail2656.d(26): Error: octal literals `0177777` are no longer supported, use `std.conv.octal!"177777"` instead +fail_compilation/fail2656.d(27): Error: octal literals `020000000000L` are no longer supported, use `std.conv.octal!"20000000000L"` instead +fail_compilation/fail2656.d(28): Error: octal literals `0200000u` are no longer supported, use `std.conv.octal!"200000u"` instead +fail_compilation/fail2656.d(29): Error: octal literals `037777777777uL` are no longer supported, use `std.conv.octal!"37777777777uL"` instead +fail_compilation/fail2656.d(30): Error: octal literals `040000000000` are no longer supported, use `std.conv.octal!"40000000000"` instead +fail_compilation/fail2656.d(31): Error: octal literals `0777777777777777777777L` are no longer supported, use `std.conv.octal!"777777777777777777777L"` instead +fail_compilation/fail2656.d(32): Error: octal literals `077777u` are no longer supported, use `std.conv.octal!"77777u"` instead +fail_compilation/fail2656.d(33): Error: octal literals `077777uL` are no longer supported, use `std.conv.octal!"77777uL"` instead +fail_compilation/fail2656.d(34): Error: octal literals `077777uL` are no longer supported, use `std.conv.octal!"77777uL"` instead --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail99.d b/gcc/testsuite/gdc.test/fail_compilation/fail99.d index c147b810ee6..e4cba9530bf 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/fail99.d +++ b/gcc/testsuite/gdc.test/fail_compilation/fail99.d @@ -2,7 +2,7 @@ TEST_OUTPUT: --- fail_compilation/fail99.d(13): Error: delegate `dg(int)` is not callable using argument types `()` -fail_compilation/fail99.d(13): missing argument for parameter #1: `int` +fail_compilation/fail99.d(13): too few arguments, expected `1`, got `0` --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/fail_scope.d b/gcc/testsuite/gdc.test/fail_compilation/fail_scope.d index 41a8c2d85e3..07c3766d490 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/fail_scope.d +++ b/gcc/testsuite/gdc.test/fail_compilation/fail_scope.d @@ -2,6 +2,13 @@ REQUIRED_ARGS: TEST_OUTPUT: --- +fail_compilation/fail_scope.d(29): Deprecation: scope variable `da` may not be returned +fail_compilation/fail_scope.d(31): Deprecation: scope variable `o` may not be returned +fail_compilation/fail_scope.d(32): Deprecation: scope variable `dg` may not be returned +fail_compilation/fail_scope.d(34): Deprecation: scope variable `da` may not be returned +fail_compilation/fail_scope.d(36): Deprecation: scope variable `o` may not be returned +fail_compilation/fail_scope.d(37): Deprecation: scope variable `dg` may not be returned +fail_compilation/fail_scope.d(39): Deprecation: scope variable `p` may not be returned fail_compilation/fail_scope.d(44): Error: returning `cast(char[])string` escapes a reference to local variable `string` fail_compilation/fail_scope.d(62): Error: returning `s.bar()` escapes a reference to local variable `s` fail_compilation/fail_scope.d(73): Error: `fail_scope.foo8` called with argument types `(int)` matches both: @@ -15,26 +22,19 @@ fail_compilation/fail_scope.d(107): Deprecation: escaping reference to outer loc fail_compilation/fail_scope.d(126): Error: returning `s.bar()` escapes a reference to local variable `s` fail_compilation/fail_scope.d(136): Error: returning `foo16226(i)` escapes a reference to local variable `i` --- -//fail_compilation/fail_scope.d(30): Error: scope variable `da` may not be returned -//fail_compilation/fail_scope.d(32): Error: scope variable `o` may not be returned -//fail_compilation/fail_scope.d(33): Error: scope variable `dg` may not be returned -//fail_compilation/fail_scope.d(35): Error: scope variable `da` may not be returned -//fail_compilation/fail_scope.d(37): Error: scope variable `o` may not be returned -//fail_compilation/fail_scope.d(38): Error: scope variable `dg` may not be returned -//fail_compilation/fail_scope.d(40): Error: scope variable `p` may not be returned */ alias int delegate() dg_t; -int[] checkEscapeScope1(scope int[] da) { return da; } -int[3] checkEscapeScope2(scope int[3] sa) { return sa; } -Object checkEscapeScope3(scope Object o) { return o; } -dg_t checkEscapeScope4(scope dg_t dg) { return dg; } +int[] checkEscapeScope1(scope int[] da) @safe { return da; } +int[3] checkEscapeScope2(scope int[3] sa) @safe { return sa; } +Object checkEscapeScope3(scope Object o) @safe { return o; } +dg_t checkEscapeScope4(scope dg_t dg) @safe { return dg; } -int[] checkEscapeScope1() { scope int[] da = []; return da; } -int[3] checkEscapeScope2() { scope int[3] sa = [1,2,3]; return sa; } -Object checkEscapeScope3() { scope Object o = new Object; return o; } // same with fail7294.d -dg_t checkEscapeScope4() { scope dg_t dg = () => 1; return dg; } +int[] checkEscapeScope1() @safe { scope int[] da = []; return da; } +int[3] checkEscapeScope2() @safe { scope int[3] sa = [1,2,3]; return sa; } +Object checkEscapeScope3() @safe { scope Object o = new Object; return o; } // same with fail7294.d +dg_t checkEscapeScope4() @safe { scope dg_t dg = () => 1; return dg; } int* test(scope int* p) @safe { return p; } diff --git a/gcc/testsuite/gdc.test/fail_compilation/fix19059.d b/gcc/testsuite/gdc.test/fail_compilation/fix19059.d index 0be003a2f3b..b6bd9d33cf9 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/fix19059.d +++ b/gcc/testsuite/gdc.test/fail_compilation/fix19059.d @@ -5,7 +5,7 @@ fail_compilation/fix19059.d(16): Error: octal digit expected, not `8` fail_compilation/fix19059.d(16): Error: octal literals larger than 7 are no longer supported fail_compilation/fix19059.d(17): Error: octal digit expected, not `9` fail_compilation/fix19059.d(17): Error: octal literals larger than 7 are no longer supported -fail_compilation/fix19059.d(18): Error: octal literals `010` are no longer supported, use `std.conv.octal!10` instead +fail_compilation/fix19059.d(18): Error: octal literals `010` are no longer supported, use `std.conv.octal!"10"` instead --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/ice10922.d b/gcc/testsuite/gdc.test/fail_compilation/ice10922.d index c227ee55eb4..f3a7a57a689 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/ice10922.d +++ b/gcc/testsuite/gdc.test/fail_compilation/ice10922.d @@ -2,7 +2,7 @@ TEST_OUTPUT: --- fail_compilation/ice10922.d(10): Error: function `ice10922.__lambda4(in uint n)` is not callable using argument types `()` -fail_compilation/ice10922.d(10): missing argument for parameter #1: `in uint n` +fail_compilation/ice10922.d(10): too few arguments, expected `1`, got `0` --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/ice9540.d b/gcc/testsuite/gdc.test/fail_compilation/ice9540.d index f95cb974c79..ce705078ac0 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/ice9540.d +++ b/gcc/testsuite/gdc.test/fail_compilation/ice9540.d @@ -2,7 +2,7 @@ TEST_OUTPUT: --- fail_compilation/ice9540.d(35): Error: function `ice9540.A.test.AddFront!(this, f).AddFront.dg(int _param_0)` is not callable using argument types `()` -fail_compilation/ice9540.d(35): missing argument for parameter #1: `int _param_0` +fail_compilation/ice9540.d(35): too few arguments, expected `1`, got `0` fail_compilation/ice9540.d(26): Error: template instance `ice9540.A.test.AddFront!(this, f)` error instantiating --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/must_use.d b/gcc/testsuite/gdc.test/fail_compilation/must_use.d new file mode 100644 index 00000000000..e3b5fedfd4d --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/must_use.d @@ -0,0 +1,16 @@ +/+ +TEST_OUTPUT: +--- +fail_compilation/must_use.d(15): Error: ignored value of `@mustuse` type `must_use.S`; prepend a `cast(void)` if intentional +--- ++/ +import core.attribute; + +@mustuse struct S {} + +S fun() { return S(); } + +void test() +{ + fun(); +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/must_use_comma.d b/gcc/testsuite/gdc.test/fail_compilation/must_use_comma.d new file mode 100644 index 00000000000..4621ab5ec29 --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/must_use_comma.d @@ -0,0 +1,17 @@ +/+ +TEST_OUTPUT: +--- +fail_compilation/must_use_comma.d(16): Error: ignored value of `@mustuse` type `must_use_comma.S`; prepend a `cast(void)` if intentional +--- ++/ +import core.attribute; + +@mustuse struct S {} + +S fun() { return S(); } +void sideEffect() {} + +void test() +{ + (fun(), sideEffect()); +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/must_use_opunary.d b/gcc/testsuite/gdc.test/fail_compilation/must_use_opunary.d new file mode 100644 index 00000000000..59248a969c4 --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/must_use_opunary.d @@ -0,0 +1,21 @@ +/+ +TEST_OUTPUT: +--- +fail_compilation/must_use_opunary.d(20): Error: ignored value of `@mustuse` type `must_use_opunary.S`; prepend a `cast(void)` if intentional +--- ++/ +import core.attribute; + +@mustuse struct S +{ + ref S opUnary(string op)() return + { + return this; + } +} + +void test() +{ + S s; + -s; +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/must_use_reserved.d b/gcc/testsuite/gdc.test/fail_compilation/must_use_reserved.d new file mode 100644 index 00000000000..96edbd3cbe4 --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/must_use_reserved.d @@ -0,0 +1,20 @@ +/+ +TEST_OUTPUT: +--- +fail_compilation/must_use_reserved.d(14): Error: `@mustuse` on `class` types is reserved for future use +fail_compilation/must_use_reserved.d(15): Error: `@mustuse` on `interface` types is reserved for future use +fail_compilation/must_use_reserved.d(16): Error: `@mustuse` on `enum` types is reserved for future use +fail_compilation/must_use_reserved.d(17): Error: `@mustuse` on functions is reserved for future use +fail_compilation/must_use_reserved.d(19): Error: `@mustuse` on `class` types is reserved for future use +fail_compilation/must_use_reserved.d(20): Error: template instance `must_use_reserved.CT!int` error instantiating +--- ++/ +import core.attribute; + +@mustuse class C {} +@mustuse interface I {} +@mustuse enum E { x } +@mustuse int fun() { return 0; } + +@mustuse class CT(T) {} +alias _ = CT!int; diff --git a/gcc/testsuite/gdc.test/fail_compilation/must_use_template.d b/gcc/testsuite/gdc.test/fail_compilation/must_use_template.d new file mode 100644 index 00000000000..eeaa774ea20 --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/must_use_template.d @@ -0,0 +1,16 @@ +/+ +TEST_OUTPUT: +--- +fail_compilation/must_use_template.d(15): Error: ignored value of `@mustuse` type `must_use_template.S!int`; prepend a `cast(void)` if intentional +--- ++/ +import core.attribute; + +@mustuse struct S(T) {} + +S!int fun() { return S!int(); } + +void test() +{ + fun(); +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/must_use_union.d b/gcc/testsuite/gdc.test/fail_compilation/must_use_union.d new file mode 100644 index 00000000000..d42b324ee9b --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/must_use_union.d @@ -0,0 +1,16 @@ +/+ +TEST_OUTPUT: +--- +fail_compilation/must_use_union.d(15): Error: ignored value of `@mustuse` type `must_use_union.U`; prepend a `cast(void)` if intentional +--- ++/ +import core.attribute; + +@mustuse union U {} + +U fun() { return U(); } + +void test() +{ + fun(); +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/retscope6.d b/gcc/testsuite/gdc.test/fail_compilation/retscope6.d index 7e68bfc4702..6d5807b641a 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/retscope6.d +++ b/gcc/testsuite/gdc.test/fail_compilation/retscope6.d @@ -201,8 +201,8 @@ void hmac(scope ubyte[] secret) /* TEST_OUTPUT: --- -fail_compilation/retscope6.d(12011): Error: reference to local variable `x` assigned to non-scope parameter `r` calling retscope6.escape_m_20150 -fail_compilation/retscope6.d(12022): Error: reference to local variable `x` assigned to non-scope parameter `r` calling retscope6.escape_c_20150 +fail_compilation/retscope6.d(12011): Error: returning `escape_m_20150(& x)` escapes a reference to local variable `x` +fail_compilation/retscope6.d(12022): Error: returning `escape_c_20150(& x)` escapes a reference to local variable `x` --- */ @@ -210,23 +210,23 @@ fail_compilation/retscope6.d(12022): Error: reference to local variable `x` assi // https://issues.dlang.org/show_bug.cgi?id=20150 -int* escape_m_20150(int* r) @safe pure +int* escape_m_20150(int* r) @safe pure nothrow { return r; } -int* f_m_20150() @safe +int* f_m_20150() @safe nothrow { int x = 42; return escape_m_20150(&x); } -const(int)* escape_c_20150(const int* r) @safe pure +const(int)* escape_c_20150(const int* r) @safe pure nothrow { return r; } -const(int)* f_c_20150() @safe +const(int)* f_c_20150() @safe nothrow { int x = 42; return escape_c_20150(&x); @@ -251,3 +251,39 @@ void escape_throw_20150() @safe immutable(char)[4] str; f_throw(str[]); } + +/* TEST_OUTPUT: +--- +fail_compilation/retscope6.d(14019): Error: scope variable `scopePtr` assigned to non-scope parameter `x` calling retscope6.noInfer23021 +fail_compilation/retscope6.d(14022): Error: scope variable `scopePtr` may not be returned +--- +*/ + +#line 14000 +// https://issues.dlang.org/show_bug.cgi?id=23021 + +ref int infer23021(ref int* x) @safe pure nothrow +{ + return *x; +} + +ref int noInfer23021(ref int* x, const(int)** escapeHole = null) @safe pure nothrow +{ + *escapeHole = x; + return *x; +} + +ref int escape23021() @safe +{ + scope int* scopePtr; + int* nonScopePtr = null; + + // don't infer scope + cast(void) noInfer23021(scopePtr); // error + + // ensure we infer return scope + return infer23021(scopePtr); // error + + // ensure we do not infer return ref + return infer23021(nonScopePtr); // no error +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/test11176.d b/gcc/testsuite/gdc.test/fail_compilation/test11176.d index cf60b80fd7a..5ef7324ce8c 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/test11176.d +++ b/gcc/testsuite/gdc.test/fail_compilation/test11176.d @@ -12,6 +12,10 @@ fail_compilation/test11176.d(16): Error: `b.ptr` cannot be used in `@safe` code, return *b.ptr; } -@safe ubyte oops(ubyte[3] b) { +@safe ubyte oops(ubyte[0] b) { + return *b.ptr; +} + +@safe ubyte cool(ubyte[1] b) { return *b.ptr; } diff --git a/gcc/testsuite/gdc.test/fail_compilation/test17284.d b/gcc/testsuite/gdc.test/fail_compilation/test17284.d index 713be42e595..5bb3c2cc9f6 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/test17284.d +++ b/gcc/testsuite/gdc.test/fail_compilation/test17284.d @@ -1,8 +1,8 @@ +/* TEST_OUTPUT: --- -fail_compilation/test17284.d(1): Error: no identifier for declarator `TEST_OUTPUT` -fail_compilation/test17284.d(1): Error: declaration expected, not `:` -fail_compilation/test17284.d(12): Error: unmatched closing brace +fail_compilation/test17284.d(16): Error: field `U.c` cannot access pointers in `@safe` code that overlap other fields +pure nothrow @safe void(U t) --- */ diff --git a/gcc/testsuite/gdc.test/fail_compilation/test19097.d b/gcc/testsuite/gdc.test/fail_compilation/test19097.d index 034813b5316..9c025a83ff0 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/test19097.d +++ b/gcc/testsuite/gdc.test/fail_compilation/test19097.d @@ -1,12 +1,19 @@ /* REQUIRED_ARGS: -preview=dip1000 * TEST_OUTPUT: --- -fail_compilation/test19097.d(37): Error: scope variable `s` may not be returned -fail_compilation/test19097.d(66): Error: scope variable `z` assigned to `refPtr` with longer lifetime -fail_compilation/test19097.d(97): Error: scope variable `s` may not be returned +fail_compilation/test19097.d(44): Error: scope variable `s` may not be returned +fail_compilation/test19097.d(48): Error: scope variable `s1` may not be returned +fail_compilation/test19097.d(77): Error: scope variable `z` assigned to `refPtr` with longer lifetime +fail_compilation/test19097.d(108): Error: scope variable `s4` may not be returned +fail_compilation/test19097.d(126): Error: scope variable `s5c` may not be returned +fail_compilation/test19097.d(130): Error: scope variable `s5m` may not be returned +fail_compilation/test19097.d(147): Error: scope variable `s6c` may not be returned +fail_compilation/test19097.d(151): Error: scope variable `s6m` may not be returned --- */ +// Test extended return-scope / return-ref semantics, e.g. assigning to `this` or the first parameter + // https://issues.dlang.org/show_bug.cgi?id=19097 @safe: @@ -35,6 +42,10 @@ S thorin() int i; S s = S(&i); // should infer scope for s return s; // so this should error + + S s1; + s1.mem(&i); + return s1; } /************************/ @@ -93,6 +104,49 @@ struct S4 int* escape2() { int x; - auto s = S4(0, &x); - return s.p; + auto s4 = S4(0, &x); + return s4.p; +} + +/************************/ +// https://issues.dlang.org/show_bug.cgi?id=22801 +struct S5 +{ + int* a; + this(return ref int b) { a = &b; } + + int* c; + void mem(return ref int d) scope { c = &d; } +} + +S5 frerin() +{ + int i; + S5 s5c = S5(i); // should infer scope for s + return s5c; // so this should error + + S5 s5m; + s5m.mem(i); + return s5m; +} + + +struct S6 +{ + int** a; + this(return ref int* b) { a = &b; } + + int** c; + void mem(return ref int* d) scope { c = &d; } +} + +S6 dis() +{ + int* i = null; + S6 s6c = S6(i); // should infer scope for s + return s6c; // so this should error + + S6 s6m; + s6m.mem(i); + return s6m; } diff --git a/gcc/testsuite/gdc.test/fail_compilation/test21008.d b/gcc/testsuite/gdc.test/fail_compilation/test21008.d index d5cf96a6c3a..998cf1752d0 100644 --- a/gcc/testsuite/gdc.test/fail_compilation/test21008.d +++ b/gcc/testsuite/gdc.test/fail_compilation/test21008.d @@ -5,12 +5,12 @@ fail_compilation/test21008.d(110): Error: function `test21008.C.after` circular fail_compilation/test21008.d(117): Error: need `this` for `toString` of type `string()` fail_compilation/test21008.d(117): Error: need `this` for `toHash` of type `nothrow @trusted $?:32=uint|64=ulong$()` fail_compilation/test21008.d(117): Error: function `object.Object.opCmp(Object o)` is not callable using argument types `()` -fail_compilation/test21008.d(117): missing argument for parameter #1: `Object o` +fail_compilation/test21008.d(117): too few arguments, expected `1`, got `0` fail_compilation/test21008.d(117): Error: function `object.Object.opEquals(Object o)` is not callable using argument types `()` -fail_compilation/test21008.d(117): missing argument for parameter #1: `Object o` +fail_compilation/test21008.d(117): too few arguments, expected `1`, got `0` fail_compilation/test21008.d(117): Error: `Monitor` has no effect fail_compilation/test21008.d(117): Error: function `object.Object.factory(string classname)` is not callable using argument types `()` -fail_compilation/test21008.d(117): missing argument for parameter #1: `string classname` +fail_compilation/test21008.d(117): too few arguments, expected `1`, got `0` fail_compilation/test21008.d(105): called from here: `handleMiddlewareAnnotation()` fail_compilation/test21008.d(108): Error: class `test21008.C` no size because of forward reference --- diff --git a/gcc/testsuite/gdc.test/fail_compilation/test22999.d b/gcc/testsuite/gdc.test/fail_compilation/test22999.d new file mode 100644 index 00000000000..99dfe70378b --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/test22999.d @@ -0,0 +1,27 @@ +/* +REQUIRED_ARGS: -de +TEST_OUTPUT: +--- +fail_compilation/test22999.d(18): Deprecation: switch case fallthrough - use 'goto default;' if intended +fail_compilation/test22999.d(25): Deprecation: switch case fallthrough - use 'goto case;' if intended +--- +*/ + +// no switch fallthrough error with multi-valued case +// https://issues.dlang.org/show_bug.cgi?id=22999 +void main() +{ + int i; + switch (0) + { + case 0, 1: i = 20; + default: assert(0); + } + + switch (0) + { + default: + case 0, 1: i = 20; + case 2, 3: i = 30; + } +} diff --git a/gcc/testsuite/gdc.test/fail_compilation/test23017.d b/gcc/testsuite/gdc.test/fail_compilation/test23017.d new file mode 100644 index 00000000000..743789a6b52 --- /dev/null +++ b/gcc/testsuite/gdc.test/fail_compilation/test23017.d @@ -0,0 +1,20 @@ +/* +TEST_OUTPUT: +--- +fail_compilation/test23017.d(16): Error: class `test23017.CppChildA` with C++ linkage cannot inherit from class `DClass` with D linkage +--- +*/ + +// https://issues.dlang.org/show_bug.cgi?id=23017 +// C++ class may not derive from D class +extern(D) class DClass {} +extern(C++) class CppClass +{ + void foo(); +} + +extern(C++) class CppChildA : DClass {} // error +extern(C++) class CppChildB : CppClass {} + +extern(D) class DChildA : DClass {} +extern(D) class DChildB : CppClass {} // automatically made extern(C++) diff --git a/gcc/testsuite/gdc.test/runnable/test20603.d b/gcc/testsuite/gdc.test/runnable/test20603.d new file mode 100644 index 00000000000..47fd3985555 --- /dev/null +++ b/gcc/testsuite/gdc.test/runnable/test20603.d @@ -0,0 +1,31 @@ +// https://issues.dlang.org/show_bug.cgi?id=20603 + +enum immutable(int)* x = new int(3); +enum const(int)* y = new int(5); + +struct Base { + union { + int overlap; + immutable(Sub)* sub; + } + + this(Sub) { + sub = new Sub; + } +} + +struct Sub { + Base base; +} + +immutable c0 = Base(Sub.init); + +void main() +{ + enum const(int)* z = new int(9); + + assert(*x == 3); + assert(*y == 5); + assert(*z == 9); + assert(c0.sub.base.sub == null); +} diff --git a/gcc/testsuite/gdc.test/runnable/testscope.d b/gcc/testsuite/gdc.test/runnable/testscope.d index 32d66b58c76..0ca04df188d 100644 --- a/gcc/testsuite/gdc.test/runnable/testscope.d +++ b/gcc/testsuite/gdc.test/runnable/testscope.d @@ -242,22 +242,6 @@ void test7435() { /********************************************/ -char[] dup12()(char[] a) // although inferred pure, don't infer a is 'return' -{ - char[] res; - foreach (ref e; a) - {} - return res; -} - -char[] foo12() -{ - char[10] buf; - return dup12(buf); -} - -/********************************************/ - void test7049() @safe { int count = 0; diff --git a/gcc/testsuite/gdc.test/runnable/xtest46.d b/gcc/testsuite/gdc.test/runnable/xtest46.d index eeaa1dbe72d..8ae08ad2e47 100644 --- a/gcc/testsuite/gdc.test/runnable/xtest46.d +++ b/gcc/testsuite/gdc.test/runnable/xtest46.d @@ -3816,8 +3816,8 @@ void test153() /***************************************************/ // https://issues.dlang.org/show_bug.cgi?id=3632 - -void test154() { +void test154() +{ float f; assert(f is float.init); double d; @@ -3832,6 +3832,87 @@ void test154() { /***************************************************/ +__gshared int global3632 = 1; + +void test3632() +{ + int test(T)() + { + static struct W + { + T f; + this(T g) { if (__ctfe || global3632) f = g; } + } + auto nan = W(T.nan); + auto nan2 = W(T.nan); + auto init = W(T.init); + auto init2 = W(T.init); + auto zero = W(cast(T)0); + auto zero2 = W(cast(T)0); + auto nzero2 = W(-cast(T)0); + + // Struct equality + assert(!(nan == nan2)); + assert(!(nan == init2)); + assert(!(init == init2)); + assert( (zero == zero2)); + assert( (zero == nzero2)); + + // Float equality + assert(!(nan.f == nan2.f)); + assert(!(nan.f == init2.f)); + assert(!(init.f == init2.f)); + assert( (zero.f == zero2.f)); + assert( (zero.f == nzero2.f)); + + // Struct identity + assert( (nan is nan2)); + assert( (nan is init2)); + assert( (init is init2)); + assert( (zero is zero2)); + assert(!(zero is nzero2)); + + // Float identity + assert( (nan.f is nan2.f)); + assert( (nan.f is init2.f)); + assert( (init.f is init2.f)); + assert( (zero.f is zero2.f)); + assert(!(zero.f is nzero2.f)); + + // Struct !identity + assert(!(nan !is nan2)); + assert( (nan is init2)); + assert(!(init !is init2)); + assert(!(zero !is zero2)); + assert( (zero !is nzero2)); + + // float !identity + assert(!(nan.f !is nan2.f)); + assert( (nan.f is init2.f)); + assert(!(init.f !is init2.f)); + assert(!(zero.f !is zero2.f)); + assert( (zero.f !is nzero2.f)); + + // .init identity + assert(W.init is W.init); + + return 1; + } + + auto rtF = test!float(); + enum ctF = test!float(); + auto rtD = test!double(); + enum ctD = test!double(); + auto rtR = test!real(); + enum ctR = test!real(); + + assert(float.nan !is -float.nan); + assert(double.nan !is -double.nan); + assert(real.nan !is -real.nan); +} + +/***************************************************/ + void test6545() { static int[] func() @@ -8142,6 +8223,7 @@ int main() test155(); test156(); test658(); + test3632(); test4258(); test4539(); test4963(); diff --git a/gcc/testsuite/gfortran.dg/array_reference_3.f90 b/gcc/testsuite/gfortran.dg/array_reference_3.f90 new file mode 100644 index 00000000000..85fa3317d98 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/array_reference_3.f90 @@ -0,0 +1,195 @@ +! { dg-do run } +! { dg-additional-options "-fdump-tree-original" } +! +! PR fortran/102043 +! Array indexing was causing the middle-end to conclude the index +! to be non-negative, which can be wrong for arrays with a "reversed-order" +! descriptor. This was fixed by using pointer arithmetic when +! the index can be negative. +! +! This test checks the code generated for array references of various kinds +! of arrays, using either array indexing or pointer arithmetic. + +program p + implicit none + call check_assumed_shape_elem + call check_assumed_shape_scalarized + call check_descriptor_dim + call check_cfi_dim + call check_substring + call check_ptr_elem + call check_ptr_scalarized + call check_explicit_shape_elem + call check_explicit_shape_scalarized + call check_tmp_array + call check_allocatable_array_elem + call check_allocatable_array_scalarized +contains + subroutine cases(assumed_shape_x) + integer :: assumed_shape_x(:) + assumed_shape_x(2) = 10 + end subroutine cases + subroutine check_assumed_shape_elem + integer :: x(3) + x = 0 + call cases(x) + if (any(x /= (/ 0, 10, 0 /))) stop 10 + ! Assumed shape array are referenced with pointer arithmetic. + ! { dg-final { scan-tree-dump-times "\\*\\(\\(integer\\(kind=4\\) \\*\\) assumed_shape_x.\\d+ \\+ \\(sizetype\\) \\(\\(stride.\\d+ \\* 2 \\+ offset.\\d+\\) \\* 4\\)\\) = 10;" 1 "original" } } + end subroutine check_assumed_shape_elem + subroutine casss(assumed_shape_y) + integer :: assumed_shape_y(:) + assumed_shape_y = 11 + end subroutine casss + subroutine check_assumed_shape_scalarized + integer :: y(3) + call casss(y) + if (any(y /= 11)) stop 11 + ! Assumed shape array are referenced with pointer arithmetic. + ! { dg-final { scan-tree-dump-times "\\*\\(\\(integer\\(kind=4\\) \\*\\) assumed_shape_y.\\d+ \\+ \\(sizetype\\) \\(\\(S.\\d+ \\* D.\\d+ \\+ D.\\d+\\) \\* 4\\)\\) = 11;" 1 "original" } } + end subroutine check_assumed_shape_scalarized + subroutine check_descriptor_dim + integer, allocatable :: descriptor(:) + allocate(descriptor(4)) + descriptor(:) = 12 + if (any(descriptor /= 12)) stop 12 + ! The descriptor’s dim array is referenced with array indexing. + ! { dg-final { scan-tree-dump-times "descriptor\\.dim\\\[0\\\]\\.ubound = 4;" 1 "original" } } + end subroutine check_descriptor_dim + subroutine ccfis(cfi_descriptor) bind(c) + integer :: cfi_descriptor(:) + cfi_descriptor = 13 + end subroutine ccfis + subroutine check_cfi_dim + integer :: x(5) + call ccfis(x) + if (any(x /= 13)) stop 13 + ! The cfi descriptor’s dim array is referenced with array indexing. + ! { dg-final { scan-tree-dump-times "cfi_descriptor->dim\\\[idx.\\d+\\\]\\.ubound = _cfi_descriptor->dim\\\[idx.\\d+\\\]\\.extent \\+ \\(cfi_descriptor->dim\\\[idx.\\d+\\\]\\.lbound \\+ -1\\);" 1 "original" } } + end subroutine check_cfi_dim + subroutine css(c) bind(c) + character :: c + c = 'k' + end subroutine css + subroutine check_substring + character(5) :: x + x = 'abcde' + call css(x(3:3)) + if (x /= 'abkde') stop 14 + ! Substrings use array indexing + ! { dg-final { scan-tree-dump-times "css \\(\\(character\\(kind=1\\)\\\[\\d+:\\d+\\\] \\*\\) &x\\\[3\\\].lb: \\d+ sz: \\d+.\\);" 1 "original" } } + end subroutine check_substring + subroutine check_ptr_elem + integer, target :: x(7) + integer, pointer :: ptr_x(:) + x = 0 + ptr_x => x + ptr_x(4) = 16 + if (any(ptr_x /= (/ 0, 0, 0, 16, 0, 0, 0 /))) stop 16 + ! pointers are referenced with pointer arithmetic. + ! { dg-final { scan-tree-dump-times "\\*\\(integer\\(kind=4\\) \\*\\) \\(ptr_x\\.data \\+ \\(sizetype\\) \\(\\(ptr_x\\.offset \\+ ptr_x\\.dim\\\[0\\\]\\.stride \\* 4\\) \\* ptr_x\\.span\\)\\) = 16;" 1 "original" } } + end subroutine check_ptr_elem + subroutine check_ptr_scalarized + integer, target :: y(8) + integer, pointer :: ptr_y(:) + y = 0 + ptr_y => y + ptr_y = 17 + if (any(ptr_y /= 17)) stop 17 + ! pointers are referenced with pointer arithmetic. + ! { dg-final { scan-tree-dump-times "\\*\\(\\(integer\\(kind=4\\) \\*\\) D.\\d+ \\+ \\(sizetype\\) \\(\\(S.\\d+ \\* D.\\d+ \\+ D.\\d+\\) \\* ptr_y\\.span\\)\\) = 17;" 1 "original" } } + end subroutine check_ptr_scalarized + subroutine check_explicit_shape_elem + integer :: explicit_shape_x(9) + explicit_shape_x = 0 + explicit_shape_x(5) = 18 + if (any(explicit_shape_x /= (/ 0, 0, 0, 0, 18, 0, 0, 0, 0 /))) stop 18 + ! Explicit shape arrays are referenced with array indexing. + ! { dg-final { scan-tree-dump-times "explicit_shape_x\\\[4\\\] = 18;" 1 "original" } } + end subroutine check_explicit_shape_elem + subroutine check_explicit_shape_scalarized + integer :: explicit_shape_y(3) + explicit_shape_y = 19 + if (any(explicit_shape_y /= 19)) stop 19 + ! Explicit shape arrays are referenced with array indexing. + ! { dg-final { scan-tree-dump-times "explicit_shape_y\\\[S.\\d+ \\+ -1\\\] = 19;" 1 "original" } } + end subroutine check_explicit_shape_scalarized + subroutine check_tmp_array + integer :: non_tmp(6) + non_tmp = 15 + non_tmp(2:5) = non_tmp(1:4) + non_tmp(3:6) + if (any(non_tmp /= (/ 15, 30, 30, 30, 30, 15 /))) stop 15 + ! temporary arrays use array indexing + ! { dg-final { scan-tree-dump-times "\\(*\\(integer\\(kind=4\\)\\\[4\\\] \\* restrict\\) atmp.\\d+\\.data\\)\\\[S.\\d+\\\] = non_tmp\\\[S.\\d+\\\] \\+ non_tmp\\\[S.\\d+ \\+ 2\\\];" 1 "original" } } + ! { dg-final { scan-tree-dump-times "non_tmp\\\[S.\\d+ \\+ 1\\\] = \\(\\*\\(integer\\(kind=4\\)\\\[4\\\] \\* restrict\\) atmp.\\d+\\.data\\)\\\[S.\\d+\\\];" 1 "original" } } + end subroutine check_tmp_array + subroutine check_allocatable_array_elem + integer, allocatable :: allocatable_x(:) + allocate(allocatable_x(4),source=0) + allocatable_x(2) = 20 + if (any(allocatable_x /= (/ 0, 20, 0, 0 /))) stop 20 + ! Allocatable arrays are referenced with array indexing. + ! { dg-final { scan-tree-dump-times "\\(\\*\\(integer\\(kind=4\\)\\\[0:\\\] \\* restrict\\) allocatable_x\\.data\\)\\\[allocatable_x\\.offset \\+ 2\\\] = 20;" 1 "original" } } + end subroutine check_allocatable_array_elem + subroutine check_allocatable_array_scalarized + integer, allocatable :: allocatable_y(:) + allocate(allocatable_y(5),source=0) + allocatable_y = 21 + if (any(allocatable_y /= 21)) stop 21 + ! Allocatable arrays are referenced with array indexing. + ! { dg-final { scan-tree-dump-times "\\(\\*D.\\d+\\)\\\[S.\\d+ \\+ \\D.\\d+\\\] = 21;" 1 "original" } } + end subroutine check_allocatable_array_scalarized + subroutine cares(assumed_rank_x) + integer :: assumed_rank_x(..) + select rank(rank_1_var_x => assumed_rank_x) + rank(1) + rank_1_var_x(3) = 22 + end select + end subroutine cares + subroutine check_assumed_rank_elem + integer :: x(6) + x = 0 + call cares(x) + if (any(x /= (/ 0, 0, 22, 0, 0, 0 /))) stop 22 + ! Assumed rank arrays are referenced with pointer arithmetic. + ! { dg-final { scan-tree-dump-times "\\*\\(\\(integer\\(kind=4\\) \\*\\) __tmp_INTEGER_4_rank_1\\.data \\+ \\(sizetype\\) \\(\\(__tmp_INTEGER_4_rank_1\\.offset \\+ __tmp_INTEGER_4_rank_1\\.dim\\\[0\\\]\\.stride \\* 3\\) \\* 4\\)\\) = 22;" 1 "original" } } + end subroutine check_assumed_rank_elem + subroutine carss(assumed_rank_y) + integer :: assumed_rank_y(..) + select rank(rank_1_var_y => assumed_rank_y) + rank(1) + rank_1_var_y = 23 + end select + end subroutine carss + subroutine check_assumed_rank_scalarized + integer :: y(7) + call carss(y) + if (any(y /= 23)) stop 23 + ! Assumed rank arrays are referenced with pointer arithmetic. + ! { dg-final { scan-tree-dump-times "\\*\\(\\(integer\\(kind=4\\) \\*\\) D.\\d+ \\+ \\(sizetype\\) \\(\\(S.\\d+ \\* D.\\d+ \\+ D.\\d+\\) \\* 4\\)\\) = 23;" 1 "original" } } + end subroutine check_assumed_rank_scalarized + subroutine casces(assumed_shape_cont_x) + integer, dimension(:), contiguous :: assumed_shape_cont_x + assumed_shape_cont_x(4) = 24 + end subroutine casces + subroutine check_assumed_shape_cont_elem + integer :: x(8) + x = 0 + call casces(x) + if (any(x /= (/ 0, 0, 0, 24, 0, 0, 0, 0 /))) stop 24 + ! Contiguous assumed shape arrays are referenced with array indexing. + ! { dg-final { scan-tree-dump-times "\\(\\*assumed_shape_cont_x.\\d+\\)\\\[stride.\\d+ \\* 4 \\+ offset.\\d+\\\] = 24;" 1 "original" } } + end subroutine check_assumed_shape_cont_elem + subroutine cascss(assumed_shape_cont_y) + integer, dimension(:), contiguous :: assumed_shape_cont_y + assumed_shape_cont_y = 25 + end subroutine cascss + subroutine check_assumed_shape_cont_scalarized + integer :: y(9) + call cascss(y) + if (any(y /= 25)) stop 25 + ! Contiguous assumed shape arrays are referenced with array indexing. + ! { dg-final { scan-tree-dump-times "\\(\\*assumed_shape_cont_y.\\d+\\)\\\[S.\\d+ \\* D.\\d+ \\+ D.\\d+\\\] = 25;" 1 "original" } } + end subroutine check_assumed_shape_cont_scalarized +end program p + diff --git a/gcc/testsuite/gfortran.dg/c_loc_test_22.f90 b/gcc/testsuite/gfortran.dg/c_loc_test_22.f90 index 9c40b26d830..7b1149aaa45 100644 --- a/gcc/testsuite/gfortran.dg/c_loc_test_22.f90 +++ b/gcc/testsuite/gfortran.dg/c_loc_test_22.f90 @@ -17,7 +17,7 @@ end ! { dg-final { scan-tree-dump-not " _gfortran_internal_pack" "original" } } ! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void .\\) &\\(.xxx.\[0-9\]+\\)\\\[0\\\];" 1 "original" } } ! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void .\\) &\\(.xxx.\[0-9\]+\\)\\\[D.\[0-9\]+ \\* 4\\\];" 1 "original" } } -! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void .\\) &\\(.yyy.\[0-9\]+\\)\\\[0\\\];" 1 "original" } } -! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void .\\) &\\(.yyy.\[0-9\]+\\)\\\[D.\[0-9\]+ \\* 4\\\];" 1 "original" } } +! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void .\\) yyy.\[0-9\]+;" 1 "original" } } +! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void .\\) yyy.\[0-9\]+ \\+ \\(sizetype\\) \\(D.\[0-9\]+ \\* 16\\);" 1 "original" } } ! { dg-final { scan-tree-dump-times "D.\[0-9\]+ = parm.\[0-9\]+.data;\[^;]+ptr\[1-4\] = D.\[0-9\]+;" 4 "original" } } diff --git a/gcc/testsuite/gfortran.dg/character_array_dummy_1.f90 b/gcc/testsuite/gfortran.dg/character_array_dummy_1.f90 new file mode 100644 index 00000000000..da5ed636f4f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/character_array_dummy_1.f90 @@ -0,0 +1,21 @@ +! { dg-do compile } +! +! PR fortran/105381 +! Infinite recursion with array references of character dummy arguments. +! +! Contributed by Harald Anlauf <anlauf@gmx.de> + +MODULE m + implicit none + integer, parameter :: ncrit = 8 + integer, parameter :: nterm = 7 +contains + + subroutine new_thin_rule (rule1) + character(*),intent(in) ,optional :: rule1(ncrit) + character(len=8) :: rules (ncrit,nterm) + rules = '' + if (present (rule1)) rules(:,1) = rule1 ! <-- compile time hog + end subroutine new_thin_rule + +end module m diff --git a/gcc/testsuite/gfortran.dg/class_dummy_8.f90 b/gcc/testsuite/gfortran.dg/class_dummy_8.f90 new file mode 100644 index 00000000000..0976a725866 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/class_dummy_8.f90 @@ -0,0 +1,20 @@ +! { dg-do compile } +! +! PR fortran/105379 +! Type comparison of class containers used to trigger an ICE when one of the +! class containers had a non-constant array spec. +! +! Contributed by Gerhard Steinmetz <gscfq@t-online.de>. + +program p + type t + end type +contains + subroutine s1(x) + class(t) :: x(3) + end + subroutine s2(n, x) + integer :: n + class(t) :: x(n) + end +end diff --git a/gcc/testsuite/gfortran.dg/class_dummy_9.f90 b/gcc/testsuite/gfortran.dg/class_dummy_9.f90 new file mode 100644 index 00000000000..0fd98c05be2 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/class_dummy_9.f90 @@ -0,0 +1,20 @@ +! { dg-do compile } +! +! PR fortran/105379 +! Type comparison of class containers used to trigger an ICE when one of the +! class containers had a non-constant array spec. +! +! Contributed by Gerhard Steinmetz <gscfq@t-online.de>. + +program p + type t + end type + integer :: m = 3 +contains + subroutine s1(x) + class(t) :: x(3) + end + subroutine s3(x) + class(t) :: x(m) + end +end diff --git a/gcc/testsuite/gfortran.dg/coarray_44.f90 b/gcc/testsuite/gfortran.dg/coarray_44.f90 index 15fb8c76ce4..545b5462251 100644 --- a/gcc/testsuite/gfortran.dg/coarray_44.f90 +++ b/gcc/testsuite/gfortran.dg/coarray_44.f90 @@ -10,3 +10,5 @@ program pr70071 allocate (z(2)[1::2,*]) ! { dg-error "Bad array dimension" } allocate (z(1::2)[2,*]) ! { dg-error "Bad array specification in ALLOCATE" } end program pr70071 + +! { dg-prune-output "Bad coarray specification in ALLOCATE statement" } diff --git a/gcc/testsuite/gfortran.dg/coarray_allocate_11.f90 b/gcc/testsuite/gfortran.dg/coarray_allocate_11.f90 index 0e806f0955b..0e4f64e1e3d 100644 --- a/gcc/testsuite/gfortran.dg/coarray_allocate_11.f90 +++ b/gcc/testsuite/gfortran.dg/coarray_allocate_11.f90 @@ -3,10 +3,10 @@ program p integer, allocatable :: z[:,:] integer :: i - allocate (z[1:,*]) ! { dg-error "Bad array specification in ALLOCATE statement" } - allocate (z[:2,*]) ! { dg-error "Bad array specification in ALLOCATE statement" } + allocate (z[1:,*]) ! { dg-error "Bad coarray specification in ALLOCATE statement" } + allocate (z[:2,*]) ! { dg-error "Bad coarray specification in ALLOCATE statement" } allocate (z[2:1,*]) ! { dg-error "Upper cobound is less than lower cobound" } - allocate (z[:0,*]) ! { dg-error "Bad array specification in ALLOCATE statement" } + allocate (z[:0,*]) ! { dg-error "Bad coarray specification in ALLOCATE statement" } allocate (z[0,*]) ! { dg-error "Upper cobound is less than lower cobound" } allocate (z[1,*]) ! This is OK allocate (z[1:1,*]) ! This is OK diff --git a/gcc/testsuite/gfortran.dg/coarray_allocate_12.f90 b/gcc/testsuite/gfortran.dg/coarray_allocate_12.f90 new file mode 100644 index 00000000000..2169aa19998 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray_allocate_12.f90 @@ -0,0 +1,19 @@ +! { dg-do compile } +! { dg-options "-fcoarray=single" } +! +! PR fortran/105184 +! Based on testcases by Gerhard Steinmetz + +program p + real, allocatable :: x[:,:] + integer :: n = 2 + allocate (x[ n, *]) + allocate (x[1:n, *]) + allocate (x[n:n, *]) + allocate (x[n, 5:*]) + allocate (x[ :n, *]) ! { dg-error "Bad coarray specification" } + allocate (x[::n, *]) ! { dg-error "Bad coarray specification" } + allocate (x[ :1:1, *]) ! { dg-error "Bad coarray specification" } + allocate (x[1:n:n, *]) ! { dg-error "Bad coarray specification" } + allocate (x[1, : *]) ! { dg-error "Missing lower bound" } +end diff --git a/gcc/testsuite/gfortran.dg/dec_union_12.f90 b/gcc/testsuite/gfortran.dg/dec_union_12.f90 new file mode 100755 index 00000000000..26671230b05 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/dec_union_12.f90 @@ -0,0 +1,43 @@ +! { dg-do compile } +! { dg-options "-std=legacy -ffree-form -finit-local-zero -finit-derived -fdec-structure" } +! +! PR fortran/105310 +! +! Test that gfc_conv_union_initializer does not cause an ICE when called +! to build the constructor for a field which triggers a vector resize. +! + +program dec_union_12 + implicit none +STRUCTURE /foo8u/ + ! 8 fields + INTEGER(4) :: a,b,c,d,e,f,g,h + UNION + MAP + ENDMAP + ENDUNION +ENDSTRUCTURE +STRUCTURE /foo16u/ + ! 16 fields + INTEGER(4) :: a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p + UNION + MAP + ENDMAP + ENDUNION +ENDSTRUCTURE +STRUCTURE /foo32u/ + ! 32 fields + INTEGER(4) :: a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p + INTEGER(4) :: aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap + UNION + MAP + ENDMAP + ENDUNION +ENDSTRUCTURE + record /foo8u/ bar8u + record /foo16u/ bar16u + record /foo32u/ bar32u + bar8u.a = 1 + bar16u.a = 1 + bar32u.a = 1 +end diff --git a/gcc/testsuite/gfortran.dg/dependency_49.f90 b/gcc/testsuite/gfortran.dg/dependency_49.f90 index 73d517e8f76..9638f65c069 100644 --- a/gcc/testsuite/gfortran.dg/dependency_49.f90 +++ b/gcc/testsuite/gfortran.dg/dependency_49.f90 @@ -11,4 +11,5 @@ program main a%x = a%x(2:3) print *,a%x end program main -! { dg-final { scan-tree-dump-times "__var_1" 4 "original" } } +! The temporary var appears three times: declaration, copy-in and copy-out +! { dg-final { scan-tree-dump-times "__var_1" 3 "original" } } diff --git a/gcc/testsuite/gfortran.dg/finalize_10.f90 b/gcc/testsuite/gfortran.dg/finalize_10.f90 index 937dff5a167..c0e4170fd66 100644 --- a/gcc/testsuite/gfortran.dg/finalize_10.f90 +++ b/gcc/testsuite/gfortran.dg/finalize_10.f90 @@ -31,7 +31,7 @@ end subroutine foo ! { dg-final { scan-tree-dump-times "x->_vptr->_copy \\(" 1 "original" } } ! FINALIZE TYPE: -! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void \\*\\) &\\(\\*aa.\[0-9\]+\\)\\\[0\\\];" 1 "original" } } +! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void \\*\\) aa.\[0-9\]+;" 1 "original" } } ! { dg-final { scan-tree-dump-times "__final_m_T2 \\(&parm.\[0-9\]+, 0, 0\\);" 1 "original" } } ! { dg-final { scan-tree-dump-times "desc.\[0-9\]+.data = \\(void \\* restrict\\) bb;" 1 "original" } } ! { dg-final { scan-tree-dump-times "__final_m_T2 \\(&desc.\[0-9\]+, 0, 0\\);" 1 "original" } } diff --git a/gcc/testsuite/gfortran.dg/g77/pr105203.f b/gcc/testsuite/gfortran.dg/g77/pr105203.f new file mode 100644 index 00000000000..3b47210fb40 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/g77/pr105203.f @@ -0,0 +1,20 @@ +C Test case for PR debug/105203 +C Origin: kmccarty@princeton.edu +C +C { dg-do compile } +C { dg-options "-O2 -fcompare-debug -ftracer -w" } +C { dg-additional-options "-fPIC" { target fpic } } + SUBROUTINE FOO (B) + + 10 CALL BAR (A) + ASSIGN 20 TO M + IF (100.LT.A) GOTO 10 + GOTO 40 +C + 20 IF (B.LT.ABS(A)) GOTO 10 + ASSIGN 30 TO M + GOTO 40 +C + 30 ASSIGN 10 TO M + 40 GOTO M,(10,20,30) + END diff --git a/gcc/testsuite/gfortran.dg/goacc/pr104717.f90 b/gcc/testsuite/gfortran.dg/goacc/pr104717.f90 new file mode 100644 index 00000000000..4ef16187c84 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/goacc/pr104717.f90 @@ -0,0 +1,22 @@ +! Extracted from 'libgomp.oacc-fortran/privatized-ref-2.f90'. + +! { dg-additional-options "-O1 -fstack-arrays -fipa-pta" } + +program main + implicit none (type, external) + integer :: j + integer, allocatable :: A(:) + + A = [(3*j, j=1, 10)] + call foo (A, size(A)) + deallocate (A) +contains + subroutine foo (array, nn) + integer :: i, nn + integer :: array(nn) + + !$acc parallel copyout(array) + array = [(-i, i = 1, nn)] + !$acc end parallel + end subroutine foo +end diff --git a/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90 b/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90 index 4dfeb7e07a2..13772c185ce 100644 --- a/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90 +++ b/gcc/testsuite/gfortran.dg/goacc/privatization-1-compute-loop.f90 @@ -13,7 +13,7 @@ ! passed to 'incr' may be unset, and in that case, it will be set to [...]", ! so to maintain compatibility with earlier Tcl releases, we manually ! initialize counter variables: -! { dg-line l_dummy[variable c_loop 0] } +! { dg-line l_dummy[variable c_compute 0 c_loop 0] } ! { dg-message "dummy" "" { target iN-VAl-Id } l_dummy } to avoid ! "WARNING: dg-line var l_dummy defined, but not used". @@ -26,7 +26,7 @@ contains integer, parameter :: c = 3 integer, external :: g - !$acc parallel + !$acc parallel ! { dg-line l_compute[incr c_compute] } !$acc loop collapse(2) private(a) private(x, y) ! { dg-line l_loop[incr c_loop] } do i = 1, 20 do j = 1, 25 @@ -46,6 +46,8 @@ contains y = a end do end do + !$acc end parallel + ! { dg-note {variable 'count\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } ! { dg-note {variable 'count\.[0-9]+' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } ! { dg-note {variable 'i' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } ! { dg-note {variable 'j' in 'private' clause isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_loop$c_loop } @@ -54,6 +56,5 @@ contains ! { dg-note {variable 'y' in 'private' clause is candidate for adjusting OpenACC privatization level} "" { target *-*-* } l_loop$c_loop } ! { dg-note {variable 'C\.[0-9]+' declared in block potentially has improper OpenACC privatization level: 'const_decl'} "TODO" { target *-*-* } l_loop$c_loop } ! { dg-note {variable 'y' ought to be adjusted for OpenACC privatization level: 'vector'} "" { target *-*-* } l_loop$c_loop } - !$acc end parallel end subroutine f end module m diff --git a/gcc/testsuite/gfortran.dg/gomp/loop-exit.f90 b/gcc/testsuite/gfortran.dg/gomp/loop-exit.f90 new file mode 100644 index 00000000000..81eebcba66a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/loop-exit.f90 @@ -0,0 +1,674 @@ +subroutine sub1 +!$omp do +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub2 +!$omp parallel do +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub3 +!$omp simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub4 +!$omp do simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub5 +!$omp parallel do simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub6 +!$omp distribute simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub7 +!$omp distribute parallel do +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub8 +!$omp distribute parallel do simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub9 +!$omp teams distribute simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub10 +!$omp target teams distribute simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub11 +!$omp teams distribute parallel do +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub12 +!$omp target teams distribute parallel do +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub13 +!$omp teams distribute parallel do simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub14 +!$omp target teams distribute parallel do simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub15 +!$omp target parallel do +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub16 +!$omp target parallel do simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub17 +!$omp target simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub18 +!$omp taskloop simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub19 +!$omp parallel master taskloop simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub20 +!$omp master taskloop simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub21 +!$omp parallel masked taskloop simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub22 +!$omp masked taskloop simd +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub23 +!$omp loop +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub24 +!$omp parallel loop +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub25 +!$omp teams loop +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub26 +!$omp target parallel loop +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub27 +!$omp target teams loop +outer: do i = 1, 5 + inner: do j = 1, 5 + if (k == 5) exit ! ok + if (k == 7) exit inner ! ok + if (k == 9) exit outer ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do inner +end do outer +end + +subroutine sub28 +!$omp do collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub29 +!$omp parallel do collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub30 +!$omp simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub31 +!$omp do simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub32 +!$omp parallel do simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub33 +!$omp distribute simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub34 +!$omp distribute parallel do collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub35 +!$omp distribute parallel do simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub36 +!$omp teams distribute simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub37 +!$omp target teams distribute simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub38 +!$omp teams distribute parallel do collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub39 +!$omp target teams distribute parallel do collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub40 +!$omp teams distribute parallel do simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub41 +!$omp target teams distribute parallel do simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub42 +!$omp target parallel do collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub43 +!$omp target parallel do simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub44 +!$omp target simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub45 +!$omp taskloop simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub46 +!$omp parallel master taskloop simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub47 +!$omp master taskloop simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub48 +!$omp parallel masked taskloop simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub49 +!$omp masked taskloop simd collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub50 +!$omp loop collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub51 +!$omp parallel loop collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub52 +!$omp teams loop collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub53 +!$omp target parallel loop collapse(3) +do ii = i1, i2 +do jj = j1, j2 +do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end + +subroutine sub54 +!$omp target teams loop collapse(3) +do ii = i1, i2 + do jj = j1, j2 + do kk = k1, k2 + if (kk > 5) then + k = 0 + end if + if (kk == 7) exit ! { dg-error "EXIT statement at .1. terminating !.OMP DO loop" } + end do + end do +end do +end diff --git a/gcc/testsuite/gfortran.dg/negative_stride_1.f90 b/gcc/testsuite/gfortran.dg/negative_stride_1.f90 new file mode 100644 index 00000000000..45da92a223f --- /dev/null +++ b/gcc/testsuite/gfortran.dg/negative_stride_1.f90 @@ -0,0 +1,25 @@ +! { dg-do run } +! +! PR fortran/102043 +! The middle-end used to conclude from array indexing that the index +! should be non-negative and thus that array accesses to reversed arrays +! (i.e. with negative strides) only access the last element of the array, +! as the access involves a pointer to array that is initialized to point +! to the last element in the case of a reversed array. + +program main + implicit none + integer :: a(3, 3) + integer :: i + a = 0 + call s(a(3:1:-1,:)) + if (any(a(:,1) /= (/ 7, 5, 3 /))) stop 1 + if (any(a(:,2) /= (/ 17, 13, 11 /))) stop 2 + if (any(a(:,3) /= (/ 29, 23, 19 /))) stop 3 +contains + subroutine s(b) + implicit none + integer, dimension(:,:) :: b + b = reshape((/ 3, 5, 7, 11, 13, 17, 19, 23, 29 /), (/ 3, 3 /)) + end subroutine s +end program main diff --git a/gcc/testsuite/gfortran.dg/pr70673.f90 b/gcc/testsuite/gfortran.dg/pr70673.f90 index fa4bd2fe02b..6eb9e7fa1b7 100644 --- a/gcc/testsuite/gfortran.dg/pr70673.f90 +++ b/gcc/testsuite/gfortran.dg/pr70673.f90 @@ -9,14 +9,12 @@ contains subroutine s(inp) character(*), intent(in) :: inp character(:), allocatable :: a - a = a ! This used to ICE. a = inp a = a ! This used to ICE too if ((len (a) .ne. 5) .or. (a .ne. "hello")) STOP 1 a = a(2:3) ! Make sure that temporary creation is not broken. if ((len (a) .ne. 2) .or. (a .ne. "el")) STOP 2 deallocate (a) - a = a ! This would ICE too. end subroutine s end module m diff --git a/gcc/testsuite/gfortran.dg/pr70673_2.f90 b/gcc/testsuite/gfortran.dg/pr70673_2.f90 new file mode 100644 index 00000000000..ba2ce2f2a96 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr70673_2.f90 @@ -0,0 +1,25 @@ +! { dg-do compile } +! +! Test the fix for PR70673 +! +! Contributed by David Kinniburgh <davidgkinniburgh@yahoo.co.uk> +! +module m +contains + subroutine s(inp) + character(*), intent(in) :: inp + character(:), allocatable :: a + a = a ! This used to ICE. + a = inp + a = a ! This used to ICE too + if ((len (a) .ne. 5) .or. (a .ne. "hello")) STOP 1 + a = a(2:3) ! Make sure that temporary creation is not broken. + if ((len (a) .ne. 2) .or. (a .ne. "el")) STOP 2 + deallocate (a) + a = a ! This would ICE too. + end subroutine s +end module m + + use m + call s("hello") +end diff --git a/gcc/testsuite/gfortran.dg/unlimited_polymorphic_3.f03 b/gcc/testsuite/gfortran.dg/unlimited_polymorphic_3.f03 index 075d6d727e2..00dd2ae1199 100644 --- a/gcc/testsuite/gfortran.dg/unlimited_polymorphic_3.f03 +++ b/gcc/testsuite/gfortran.dg/unlimited_polymorphic_3.f03 @@ -1,4 +1,5 @@ ! { dg-do run } +! { dg-additional-options "-fdump-tree-dse-details" } ! ! Check that pointer assignments allowed by F2003:C717 ! work and check null initialization of CLASS(*) pointers. @@ -7,20 +8,31 @@ ! program main interface - subroutine foo(z) + subroutine foo_bc(z) class(*), pointer, intent(in) :: z - end subroutine foo + end subroutine foo_bc + subroutine foo_sq(z) + class(*), pointer, intent(in) :: z + end subroutine foo_sq end interface + type, bind(c) :: bc + integer :: i + end type bc type sq sequence - integer :: i + integer :: k end type sq + type(bc), target :: w type(sq), target :: x class(*), pointer :: y, z - x%i = 42 + w%i = 23 + y => w + z => y ! unlimited => unlimited allowed + call foo_bc(z) + x%k = 42 y => x z => y ! unlimited => unlimited allowed - call foo (z) + call foo_sq(z) call bar contains subroutine bar @@ -33,21 +45,31 @@ contains end program main - -subroutine foo(tgt) +subroutine foo_bc(tgt) use iso_c_binding class(*), pointer, intent(in) :: tgt - type, bind(c) :: s - integer (c_int) :: k - end type s - type t + type, bind(c) :: bc + integer (c_int) :: i + end type bc + type(bc), pointer :: ptr1 + ptr1 => tgt ! bind(c) => unlimited allowed + if (ptr1%i .ne. 23) STOP 2 +end subroutine foo_bc + +subroutine foo_sq(tgt) + class(*), pointer, intent(in) :: tgt + type sq sequence integer :: k - end type t - type(s), pointer :: ptr1 - type(t), pointer :: ptr2 - ptr1 => tgt ! bind(c) => unlimited allowed - if (ptr1%k .ne. 42) STOP 2 + end type sq + type(sq), pointer :: ptr2 ptr2 => tgt ! sequence type => unlimited allowed if (ptr2%k .ne. 42) STOP 3 -end subroutine foo +end subroutine foo_sq + +! PR fortran/103662 +! We used to produce multiple independant types for the unlimited polymorphic +! descriptors (types for class(*)) which caused stores to them to be seen as +! useless. +! { dg-final { scan-tree-dump-not "Deleted dead store: z._data = &w" "dse1" { target __OPTIMIZE__ } } } +! { dg-final { scan-tree-dump-not "Deleted dead store: z._data = &x" "dse1" { target __OPTIMIZE__ } } } diff --git a/gcc/testsuite/gfortran.dg/vector_subscript_8.f90 b/gcc/testsuite/gfortran.dg/vector_subscript_8.f90 new file mode 100644 index 00000000000..e90450b2f1b --- /dev/null +++ b/gcc/testsuite/gfortran.dg/vector_subscript_8.f90 @@ -0,0 +1,16 @@ +! { dg-do run } +! +! PR fortran/102043 +! The middle-end used to conclude from array indexing that the index +! should be non-negative and thus that array accesses to reversed arrays +! (i.e. with negative strides) only access the last element of the array, +! as the access involves a pointer to array that is initialized to point +! to the last element in the case of a reversed array. + +program main + integer, dimension (4) :: idx, a, b + a = (/ 11, 13, 17, 19 /) + idx = (/ 1, 2, 3, 4 /) + a(idx(4:1:-1)) = idx + if (a(1).ne.4) STOP 1 +end program main diff --git a/gcc/testsuite/gfortran.dg/vector_subscript_9.f90 b/gcc/testsuite/gfortran.dg/vector_subscript_9.f90 new file mode 100644 index 00000000000..d70a773287d --- /dev/null +++ b/gcc/testsuite/gfortran.dg/vector_subscript_9.f90 @@ -0,0 +1,21 @@ +! { dg-do run } +! +! PR fortran/102043 +! The middle-end used to conclude from array indexing that the index +! should be non-negative and thus that array accesses to reversed arrays +! (i.e. with negative strides) only access the last element of the array, +! as the access involves a pointer to array that is initialized to point +! to the last element in the case of a reversed array. + +program main + integer, dimension (2) :: idx, a, b + a = (/ 3, 4 /) + idx = (/ 1, 2 /) + call check_values(a(idx(2:1:-1)), (/ 4, 3 /)) +contains + subroutine check_values(values, expected) + integer, dimension(:) :: values, expected + if (size(values) /= size(expected)) stop 1 + if (any(values /= expected)) stop 2 + end subroutine check_values +end program main diff --git a/gcc/testsuite/gnat.dg/concat5.adb b/gcc/testsuite/gnat.dg/concat5.adb new file mode 100644 index 00000000000..fabf24865d6 --- /dev/null +++ b/gcc/testsuite/gnat.dg/concat5.adb @@ -0,0 +1,9 @@ +-- { dg-do run } +-- { dg-options "-O" } + +with Concat5_Pkg1; use Concat5_Pkg1; + +procedure Concat5 is +begin + Scan ("-RTS=none"); +end; diff --git a/gcc/testsuite/gnat.dg/concat5_pkg1.adb b/gcc/testsuite/gnat.dg/concat5_pkg1.adb new file mode 100644 index 00000000000..c32f5af314e --- /dev/null +++ b/gcc/testsuite/gnat.dg/concat5_pkg1.adb @@ -0,0 +1,18 @@ +with Concat5_Pkg2; use Concat5_Pkg2; + +package body Concat5_Pkg1 is + + procedure Make_Failed (S : String); + pragma No_Inline (Make_Failed); + + procedure Make_Failed (S : String) is + begin + Compare (S); + end; + + procedure Scan (S : String) is + begin + Make_Failed ("option " & S & " should start with '--'"); + end; + +end Concat5_Pkg1; diff --git a/gcc/testsuite/gnat.dg/concat5_pkg1.ads b/gcc/testsuite/gnat.dg/concat5_pkg1.ads new file mode 100644 index 00000000000..7f46d87f6e6 --- /dev/null +++ b/gcc/testsuite/gnat.dg/concat5_pkg1.ads @@ -0,0 +1,5 @@ +package Concat5_Pkg1 is + + procedure Scan (S : String); + +end Concat5_Pkg1; diff --git a/gcc/testsuite/gnat.dg/concat5_pkg2.adb b/gcc/testsuite/gnat.dg/concat5_pkg2.adb new file mode 100644 index 00000000000..98bd38826b2 --- /dev/null +++ b/gcc/testsuite/gnat.dg/concat5_pkg2.adb @@ -0,0 +1,10 @@ +package body Concat5_Pkg2 is + + procedure Compare (S : String) is + begin + if S /= "option -RTS=none should start with '--'" then + raise Program_Error; + end if; + end; + +end Concat5_Pkg2; diff --git a/gcc/testsuite/gnat.dg/concat5_pkg2.ads b/gcc/testsuite/gnat.dg/concat5_pkg2.ads new file mode 100644 index 00000000000..2931ffd5d5a --- /dev/null +++ b/gcc/testsuite/gnat.dg/concat5_pkg2.ads @@ -0,0 +1,5 @@ +package Concat5_Pkg2 is + + procedure Compare (S : String); + +end Concat5_Pkg2; diff --git a/gcc/testsuite/go.test/test/fixedbugs/issue10441.go b/gcc/testsuite/go.test/test/fixedbugs/issue10441.go index 9bc4948b15b..7cd26d841b6 100644 --- a/gcc/testsuite/go.test/test/fixedbugs/issue10441.go +++ b/gcc/testsuite/go.test/test/fixedbugs/issue10441.go @@ -1,4 +1,4 @@ -// build +// compile // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style diff --git a/gcc/testsuite/jit.dg/all-non-failing-tests.h b/gcc/testsuite/jit.dg/all-non-failing-tests.h index 29afe064db6..80606076e78 100644 --- a/gcc/testsuite/jit.dg/all-non-failing-tests.h +++ b/gcc/testsuite/jit.dg/all-non-failing-tests.h @@ -77,6 +77,13 @@ /* test-builtin-unreachable.c: We don't add this one, since it touches the optimization level of the context as a whole. */ +/* test-bitcast.c */ +#define create_code create_code_bitcast +#define verify_code verify_code_bitcast +#include "test-bitcast.c" +#undef create_code +#undef verify_code + /* test-calling-external-function.c */ #define create_code create_code_calling_external_function #define verify_code verify_code_calling_external_function @@ -306,6 +313,12 @@ #undef create_code #undef verify_code +/* test-register-variable.c: This can't be in the testcases array as it + is target-specific. */ + +/* test-setting-alignment.c: This can't be in the testcases array as it + is target-specific. */ + /* test-string-literal.c */ #define create_code create_code_string_literal #define verify_code verify_code_string_literal @@ -400,6 +413,9 @@ const struct testcase testcases[] = { {"builtin-memcpy", create_code_builtin_memcpy, verify_code_builtin_memcpy}, + {"bitcast", + create_code_bitcast, + verify_code_bitcast}, {"calling_external_function", create_code_calling_external_function, verify_code_calling_external_function}, diff --git a/gcc/testsuite/jit.dg/harness.h b/gcc/testsuite/jit.dg/harness.h index 0dc5ed1dad0..7b70ce73dd5 100644 --- a/gcc/testsuite/jit.dg/harness.h +++ b/gcc/testsuite/jit.dg/harness.h @@ -262,6 +262,10 @@ static void set_options (gcc_jit_context *ctxt, const char *argv0) ctxt, GCC_JIT_BOOL_OPTION_DUMP_SUMMARY, 0); + /* Make it easier to compare error messages by disabling colorization, + rather then have them be affected by whether stderr is going to a tty. */ + gcc_jit_context_add_command_line_option + (ctxt, "-fdiagnostics-color=never"); } #endif /* #ifndef TEST_ESCHEWS_SET_OPTIONS */ diff --git a/gcc/testsuite/jit.dg/test-bitcast.c b/gcc/testsuite/jit.dg/test-bitcast.c new file mode 100644 index 00000000000..2f80045293f --- /dev/null +++ b/gcc/testsuite/jit.dg/test-bitcast.c @@ -0,0 +1,61 @@ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <stdint.h> + +#include "libgccjit.h" + +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Let's try to inject the equivalent of: +int32_t +my_bitcast (float x) +{ + return bitcast(x, int32_t); +} + */ + gcc_jit_type *int32 = + gcc_jit_context_get_int_type (ctxt, 4, 1); + gcc_jit_type *float_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_FLOAT); + + gcc_jit_param *x = + gcc_jit_context_new_param ( + ctxt, + NULL, + float_type, "x"); + gcc_jit_param *params[1] = {x}; + gcc_jit_function *func = + gcc_jit_context_new_function (ctxt, + NULL, + GCC_JIT_FUNCTION_EXPORTED, + int32, + "my_bitcast", + 1, params, 0); + + gcc_jit_block *initial = + gcc_jit_function_new_block (func, "initial"); + + gcc_jit_block_end_with_return(initial, NULL, + gcc_jit_context_new_bitcast(ctxt, + NULL, + gcc_jit_param_as_rvalue(x), + int32 + )); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + typedef int32_t (*my_bitcast_fn_type) (float); + CHECK_NON_NULL (result); + my_bitcast_fn_type my_bitcast = + (my_bitcast_fn_type)gcc_jit_result_get_code (result, "my_bitcast"); + CHECK_NON_NULL (my_bitcast); + int32_t val = my_bitcast (3.1415927f); + note ("my_bitcast returned: 0x%x", val); + CHECK_VALUE (val, 0x40490FDB); +} diff --git a/gcc/testsuite/jit.dg/test-error-bad-bitcast.c b/gcc/testsuite/jit.dg/test-error-bad-bitcast.c new file mode 100644 index 00000000000..642890605ad --- /dev/null +++ b/gcc/testsuite/jit.dg/test-error-bad-bitcast.c @@ -0,0 +1,62 @@ +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" + +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Let's try to inject the equivalent of: + + int + test_fn () + { + char f[4096]; + return bitcast(f, int); + } + + and verify that the API complains about the bad cast. + */ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_type *char_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CHAR); + + + gcc_jit_type *array_type = + gcc_jit_context_new_array_type (ctxt, NULL, char_type, 4096); + + gcc_jit_function *test_fn = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + int_type, + "test_fn", + 0, NULL, + 0); + gcc_jit_lvalue *f = + gcc_jit_function_new_local ( + test_fn, + NULL, + array_type, "f"); + + gcc_jit_block *block = gcc_jit_function_new_block (test_fn, NULL); + + gcc_jit_block_end_with_return ( + block, NULL, + gcc_jit_context_new_bitcast (ctxt, NULL, + gcc_jit_lvalue_as_rvalue (f), + int_type)); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + CHECK_VALUE (result, NULL); + + /* Verify that the correct error message was emitted. */ + CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt), + "bitcast with types of different sizes"); +} + diff --git a/gcc/testsuite/jit.dg/test-error-bad-bitcast2.c b/gcc/testsuite/jit.dg/test-error-bad-bitcast2.c new file mode 100644 index 00000000000..602ae407076 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-error-bad-bitcast2.c @@ -0,0 +1,62 @@ +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" + +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Let's try to inject the equivalent of: + + char[4096] + test_fn () + { + int f; + return bitcast(f, char[4096]); + } + + and verify that the API complains about the bad cast. + */ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_type *char_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_CHAR); + + + gcc_jit_type *array_type = + gcc_jit_context_new_array_type (ctxt, NULL, char_type, 4096); + + gcc_jit_function *test_fn = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + array_type, + "test_fn", + 0, NULL, + 0); + gcc_jit_lvalue *f = + gcc_jit_function_new_local ( + test_fn, + NULL, + int_type, "f"); + + gcc_jit_block *block = gcc_jit_function_new_block (test_fn, NULL); + + gcc_jit_block_end_with_return ( + block, NULL, + gcc_jit_context_new_bitcast (ctxt, NULL, + gcc_jit_lvalue_as_rvalue (f), + array_type)); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + CHECK_VALUE (result, NULL); + + /* Verify that the correct error message was emitted. */ + CHECK_STRING_VALUE (gcc_jit_context_get_first_error (ctxt), + "bitcast with types of different sizes"); +} + diff --git a/gcc/testsuite/jit.dg/test-error-register-variable-bad-name.c b/gcc/testsuite/jit.dg/test-error-register-variable-bad-name.c new file mode 100644 index 00000000000..f2496861eec --- /dev/null +++ b/gcc/testsuite/jit.dg/test-error-register-variable-bad-name.c @@ -0,0 +1,35 @@ +/* + + Test that the proper error is triggered when we build a register variable + with a register name that doesn't exist. + +*/ + +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_lvalue *global_variable = + gcc_jit_context_new_global ( + ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, int_type, "global_variable"); + gcc_jit_lvalue_set_register_name(global_variable, "this_is_not_a_register"); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + /* Ensure that the bad API usage prevents the API giving a bogus + result back. */ + CHECK_VALUE (result, NULL); + + /* Verify that the correct error message was emitted. */ + CHECK_STRING_VALUE (gcc_jit_context_get_last_error (ctxt), + "invalid register name for 'global_variable'"); +} diff --git a/gcc/testsuite/jit.dg/test-error-register-variable-size-mismatch.c b/gcc/testsuite/jit.dg/test-error-register-variable-size-mismatch.c new file mode 100644 index 00000000000..edea50f8104 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-error-register-variable-size-mismatch.c @@ -0,0 +1,38 @@ +/* + + Test that the proper error is triggered when we build a register variable + with a register name that doesn't exist. + +*/ + +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_type *array_type = + gcc_jit_context_new_array_type (ctxt, NULL, int_type, 4096); + gcc_jit_lvalue *global_variable = + gcc_jit_context_new_global ( + ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, array_type, "global_variable"); + gcc_jit_lvalue_set_register_name(global_variable, "r12"); +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + /* Ensure that the bad API usage prevents the API giving a bogus + result back. */ + CHECK_VALUE (result, NULL); + + /* Verify that the correct error message was emitted. */ + CHECK_STRING_VALUE + (gcc_jit_context_get_last_error (ctxt), + "data type of 'global_variable' isn't suitable for a register"); +} diff --git a/gcc/testsuite/jit.dg/test-register-variable.c b/gcc/testsuite/jit.dg/test-register-variable.c new file mode 100644 index 00000000000..ce6dcaa9213 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-register-variable.c @@ -0,0 +1,56 @@ +/* { dg-do compile { target x86_64-*-* } } */ + +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" + +/* We don't want set_options() in harness.h to set -O3 so our little local + is optimized away. */ +#define TEST_ESCHEWS_SET_OPTIONS +static void set_options (gcc_jit_context *ctxt, const char *argv0) +{ +} + +#define TEST_COMPILING_TO_FILE +#define OUTPUT_KIND GCC_JIT_OUTPUT_KIND_ASSEMBLER +#define OUTPUT_FILENAME "output-of-test-link-section-assembler.c.s" +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Let's try to inject the equivalent of: + register int global_variable asm ("r13"); + int main() { + register int variable asm ("r12"); + return 0; + } + */ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_lvalue *global_variable = + gcc_jit_context_new_global ( + ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, int_type, "global_variable"); + gcc_jit_lvalue_set_register_name(global_variable, "r13"); + + gcc_jit_function *func_main = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + int_type, + "main", + 0, NULL, + 0); + gcc_jit_lvalue *variable = gcc_jit_function_new_local(func_main, NULL, int_type, "variable"); + gcc_jit_lvalue_set_register_name(variable, "r12"); + gcc_jit_rvalue *two = gcc_jit_context_new_rvalue_from_int (ctxt, int_type, 2); + gcc_jit_rvalue *one = gcc_jit_context_one (ctxt, int_type); + gcc_jit_block *block = gcc_jit_function_new_block (func_main, NULL); + gcc_jit_block_add_assignment(block, NULL, variable, one); + gcc_jit_block_add_assignment(block, NULL, global_variable, two); + gcc_jit_block_end_with_return (block, NULL, gcc_jit_lvalue_as_rvalue(variable)); +} + +/* { dg-final { jit-verify-output-file-was-created "" } } */ +/* { dg-final { jit-verify-assembler-output "movl \\\$1, %r12d" } } */ +/* { dg-final { jit-verify-assembler-output "movl \\\$2, %r13d" } } */ diff --git a/gcc/testsuite/jit.dg/test-setting-alignment.c b/gcc/testsuite/jit.dg/test-setting-alignment.c new file mode 100644 index 00000000000..8489df9c6b9 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-setting-alignment.c @@ -0,0 +1,66 @@ +/* { dg-do compile { target x86_64-*-* } } */ + +#include <stdlib.h> +#include <stdio.h> + +#include "libgccjit.h" + +/* We don't want set_options() in harness.h to set -O3 so our little local + is optimized away. */ +#define TEST_ESCHEWS_SET_OPTIONS +static void set_options (gcc_jit_context *ctxt, const char *argv0) +{ +} + +#define TEST_COMPILING_TO_FILE +#define OUTPUT_KIND GCC_JIT_OUTPUT_KIND_ASSEMBLER +#define OUTPUT_FILENAME "output-of-test-setting-alignment.c.s" +#include "harness.h" + +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Let's try to inject the equivalent of: + int foo __attribute__((aligned (8))); + + int main (void) { + int bar __attribute__((aligned (16))); + } + */ + gcc_jit_type *int_type = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_lvalue *foo = + gcc_jit_context_new_global ( + ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED, int_type, "foo"); + gcc_jit_lvalue_set_alignment(foo, 8); + + gcc_jit_field *field = gcc_jit_context_new_field (ctxt, + NULL, + int_type, + "a"); + gcc_jit_struct *struct_type = + gcc_jit_context_new_struct_type(ctxt, NULL, "Type", 1, &field); + gcc_jit_function *func_main = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + int_type, + "main", + 0, NULL, + 0); + gcc_jit_lvalue *bar = + gcc_jit_function_new_local ( + func_main, NULL, + gcc_jit_struct_as_type (struct_type), + "bar"); + CHECK_VALUE (gcc_jit_lvalue_get_alignment (bar), 0); + gcc_jit_lvalue_set_alignment (bar, 16); + CHECK_VALUE (gcc_jit_lvalue_get_alignment (bar), 16); + gcc_jit_block *block = gcc_jit_function_new_block (func_main, NULL); + gcc_jit_rvalue *return_value = + gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue_access_field (bar, NULL, field)); + gcc_jit_block_end_with_return (block, NULL, return_value); +} + +/* { dg-final { jit-verify-output-file-was-created "" } } */ +/* { dg-final { jit-verify-assembler-output ".comm foo,4,8" } } */ +/* { dg-final { jit-verify-assembler-output "movl -16\\\(%rbp\\\), %eax" } } */ diff --git a/gcc/testsuite/jit.dg/test-types.c b/gcc/testsuite/jit.dg/test-types.c index 8debcd7eb82..6836597d14e 100644 --- a/gcc/testsuite/jit.dg/test-types.c +++ b/gcc/testsuite/jit.dg/test-types.c @@ -1,3 +1,4 @@ +#include <stdint.h> #include <stdlib.h> #include <stdio.h> #include <stddef.h> @@ -29,6 +30,21 @@ struct zoo long long m_long_long; unsigned long long m_unsigned_long_long; + uint8_t m_u8; + uint16_t m_u16; + uint32_t m_u32; + uint64_t m_u64; + + int8_t m_i8; + int16_t m_i16; + int32_t m_i32; + int64_t m_i64; + +#ifdef __SIZEOF_INT128__ + __uint128_t m_u128; + __int128_t m_i128; +#endif + int m_sized_int_type; float m_float; @@ -101,6 +117,31 @@ create_code (gcc_jit_context *ctxt, void *user_data) gcc_jit_field *field_m_unsigned_long_long = CREATE_FIELD (GCC_JIT_TYPE_UNSIGNED_LONG_LONG, "m_unsigned_long_long"); + gcc_jit_field *field_m_u8 = + CREATE_FIELD (GCC_JIT_TYPE_UINT8_T, "m_u8"); + gcc_jit_field *field_m_u16 = + CREATE_FIELD (GCC_JIT_TYPE_UINT16_T, "m_u16"); + gcc_jit_field *field_m_u32 = + CREATE_FIELD (GCC_JIT_TYPE_UINT32_T, "m_u32"); + gcc_jit_field *field_m_u64 = + CREATE_FIELD (GCC_JIT_TYPE_UINT64_T, "m_u64"); + + gcc_jit_field *field_m_i8 = + CREATE_FIELD (GCC_JIT_TYPE_INT8_T, "m_i8"); + gcc_jit_field *field_m_i16 = + CREATE_FIELD (GCC_JIT_TYPE_INT16_T, "m_i16"); + gcc_jit_field *field_m_i32 = + CREATE_FIELD (GCC_JIT_TYPE_INT32_T, "m_i32"); + gcc_jit_field *field_m_i64 = + CREATE_FIELD (GCC_JIT_TYPE_INT64_T, "m_i64"); + +#ifdef __SIZEOF_INT128__ + gcc_jit_field *field_m_u128 = + CREATE_FIELD (GCC_JIT_TYPE_UINT128_T, "m_u128"); + gcc_jit_field *field_m_i128 = + CREATE_FIELD (GCC_JIT_TYPE_INT128_T, "m_i128"); +#endif + /* Signed int type with sizeof (int): */ gcc_jit_type *sized_int_type = gcc_jit_context_get_int_type (ctxt, sizeof (int), 1); @@ -147,6 +188,21 @@ create_code (gcc_jit_context *ctxt, void *user_data) field_m_long_long, field_m_unsigned_long_long, + field_m_u8, + field_m_u16, + field_m_u32, + field_m_u64, + + field_m_i8, + field_m_i16, + field_m_i32, + field_m_i64, + +#ifdef __SIZEOF_INT128__ + field_m_u128, + field_m_i128, +#endif + field_m_sized_int_type, field_m_float, @@ -266,6 +322,61 @@ create_code (gcc_jit_context *ctxt, void *user_data) gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UNSIGNED_LONG_LONG), 123456789)) + ASSIGN(field_m_u8, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT8_T), + 123)) + ASSIGN(field_m_u16, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT16_T), + 12345)) + ASSIGN(field_m_u32, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT32_T), + 123456789)) + ASSIGN(field_m_u64, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT64_T), + 123456789)) + + ASSIGN(field_m_i8, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT8_T), + -1)) + ASSIGN(field_m_i16, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT16_T), + -2)) + ASSIGN(field_m_i32, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT32_T), + -3)) + ASSIGN(field_m_i64, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT64_T), + -4)) + +#ifdef __SIZEOF_INT128__ + ASSIGN(field_m_u128, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UINT128_T), + 123456789)) + ASSIGN(field_m_i128, + gcc_jit_context_new_rvalue_from_int ( + ctxt, + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT128_T), + -5)) +#endif + ASSIGN(field_m_sized_int_type, gcc_jit_context_new_rvalue_from_int ( ctxt, @@ -347,6 +458,21 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) CHECK_VALUE (z.m_long_long, -42); CHECK_VALUE (z.m_unsigned_long_long, 123456789); + CHECK_VALUE (z.m_u8, 123); + CHECK_VALUE (z.m_u16, 12345); + CHECK_VALUE (z.m_u32, 123456789); + CHECK_VALUE (z.m_u64, 123456789); + + CHECK_VALUE (z.m_i8, -1); + CHECK_VALUE (z.m_i16, -2); + CHECK_VALUE (z.m_i32, -3); + CHECK_VALUE (z.m_i64, -4); + +#ifdef __SIZEOF_INT128__ + CHECK_VALUE (z.m_u128, 123456789); + CHECK_VALUE (z.m_i128, -5); +#endif + CHECK_VALUE (z.m_sized_int_type, 500); CHECK_VALUE (z.m_float, 3.141f); @@ -358,4 +484,9 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) CHECK_VALUE (z.m_size_t, sizeof (struct zoo)); CHECK_VALUE (z.m_FILE_ptr, stderr); + + if (sizeof(long) == 8) + CHECK (gcc_jit_compatible_types ( + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG), + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT64_T))); } diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index ff8edbd3e17..2d5d0539bb4 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -2318,8 +2318,9 @@ proc check_ppc_mma_hw_available { } { proc check_ppc_float128_sw_available { } { return [check_cached_effective_target ppc_float128_sw_available { # Some simulators are known to not support VSX/power8/power9 - # instructions. For now, disable on Darwin. - if { [istarget powerpc-*-eabi] + # instructions. For now, disable on Darwin and VxWorks. + if { [istarget *-*-vxworks*] + || [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] || [istarget *-*-darwin*]} { expr 0 @@ -2345,7 +2346,8 @@ proc check_ppc_float128_hw_available { } { return [check_cached_effective_target ppc_float128_hw_available { # Some simulators are known to not support VSX/power8/power9 # instructions. For now, disable on Darwin. - if { [istarget powerpc-*-eabi] + if { [istarget *-*-vxworks*] + || [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] || [istarget *-*-darwin*]} { expr 0 @@ -2370,8 +2372,9 @@ proc check_ppc_float128_hw_available { } { # See if the __ieee128 keyword is understood. proc check_effective_target_ppc_ieee128_ok { } { return [check_cached_effective_target ppc_ieee128_ok { - # disable on AIX. - if { [istarget *-*-aix*] } { + # disable on AIX and VxWorks. + if { [istarget *-*-aix*] + || [istarget *-*-vxworks*]} { expr 0 } else { set options "-mfloat128" @@ -6316,63 +6319,73 @@ proc check_effective_target_powerpc_p9modulo_ok { } { # return 1 if our compiler returns the ARCH_PWR defines with the options # as provided by the test. proc check_effective_target_has_arch_pwr5 { } { - return [check_no_compiler_messages arch_pwr5 assembly { + return [check_no_compiler_messages_nocache arch_pwr5 assembly { #ifndef _ARCH_PWR5 #error does not have power5 support. #else /* "has power5 support" */ #endif - }] + } [current_compiler_flags]] } proc check_effective_target_has_arch_pwr6 { } { - return [check_no_compiler_messages arch_pwr6 assembly { + return [check_no_compiler_messages_nocache arch_pwr6 assembly { #ifndef _ARCH_PWR6 #error does not have power6 support. #else /* "has power6 support" */ #endif - }] + } [current_compiler_flags]] } proc check_effective_target_has_arch_pwr7 { } { - return [check_no_compiler_messages arch_pwr7 assembly { + return [check_no_compiler_messages_nocache arch_pwr7 assembly { #ifndef _ARCH_PWR7 #error does not have power7 support. #else /* "has power7 support" */ #endif - }] + } [current_compiler_flags]] } proc check_effective_target_has_arch_pwr8 { } { - return [check_no_compiler_messages arch_pwr8 assembly { + return [check_no_compiler_messages_nocache arch_pwr8 assembly { #ifndef _ARCH_PWR8 #error does not have power8 support. #else /* "has power8 support" */ #endif - }] + } [current_compiler_flags]] } proc check_effective_target_has_arch_pwr9 { } { - return [check_no_compiler_messages arch_pwr9 assembly { + return [check_no_compiler_messages_nocache arch_pwr9 assembly { #ifndef _ARCH_PWR9 #error does not have power9 support. #else /* "has power9 support" */ #endif - }] + } [current_compiler_flags]] } proc check_effective_target_has_arch_pwr10 { } { - return [check_no_compiler_messages arch_pwr10 assembly { + return [check_no_compiler_messages_nocache arch_pwr10 assembly { #ifndef _ARCH_PWR10 #error does not have power10 support. #else /* "has power10 support" */ #endif - }] + } [current_compiler_flags]] +} + +proc check_effective_target_has_arch_ppc64 { } { + return [check_no_compiler_messages_nocache arch_ppc64 assembly { + #ifndef _ARCH_PPC64 + #error does not have ppc64 support. + #else + /* "has ppc64 support" */ + #endif + } [current_compiler_flags]] } # Return 1 if this is a PowerPC target supporting -mcpu=power10. @@ -11757,6 +11770,8 @@ proc check_effective_target___OPTIMIZE__ {} { #ifndef __OPTIMIZE__ # error nein #endif + /* Avoid pedwarn about empty TU. */ + int dummy; } [current_compiler_flags]] } diff --git a/gcc/toplev.cc b/gcc/toplev.cc index 2d432fb2d84..ed546b2cad8 100644 --- a/gcc/toplev.cc +++ b/gcc/toplev.cc @@ -2378,6 +2378,8 @@ toplev::finalize (void) gcse_cc_finalize (); ipa_cp_cc_finalize (); ira_costs_cc_finalize (); + tree_cc_finalize (); + reginfo_cc_finalize (); /* save_decoded_options uses opts_obstack, so these must be cleaned up together. */ diff --git a/gcc/trans-mem.cc b/gcc/trans-mem.cc index e9feac2321c..ae2921f808e 100644 --- a/gcc/trans-mem.cc +++ b/gcc/trans-mem.cc @@ -1400,7 +1400,7 @@ thread_private_new_memory (basic_block entry_block, tree x) /* Search DEF chain to find the original definition of this address. */ do { - if (ptr_deref_may_alias_global_p (x)) + if (ptr_deref_may_alias_global_p (x, true)) { /* Address escapes. This is not thread-private. */ retval = mem_non_local; diff --git a/gcc/tree-complex.cc b/gcc/tree-complex.cc index 8f03b236094..42db96a132b 100644 --- a/gcc/tree-complex.cc +++ b/gcc/tree-complex.cc @@ -41,6 +41,7 @@ along with GCC; see the file COPYING3. If not see #include "cfgloop.h" #include "cfganal.h" #include "gimple-fold.h" +#include "diagnostic-core.h" /* For each complex ssa name, a lattice value. We're interested in finding @@ -1614,6 +1615,7 @@ expand_complex_asm (gimple_stmt_iterator *gsi) { gasm *stmt = as_a <gasm *> (gsi_stmt (*gsi)); unsigned int i; + bool diagnosed_p = false; for (i = 0; i < gimple_asm_noutputs (stmt); ++i) { @@ -1622,6 +1624,20 @@ expand_complex_asm (gimple_stmt_iterator *gsi) if (TREE_CODE (op) == SSA_NAME && TREE_CODE (TREE_TYPE (op)) == COMPLEX_TYPE) { + if (gimple_asm_nlabels (stmt) > 0) + { + if (!diagnosed_p) + { + sorry_at (gimple_location (stmt), + "%<asm goto%> with complex typed outputs"); + diagnosed_p = true; + } + /* Make sure to not ICE later, see PR105165. */ + tree zero = build_zero_cst (TREE_TYPE (TREE_TYPE (op))); + set_component_ssa_name (op, false, zero); + set_component_ssa_name (op, true, zero); + continue; + } tree type = TREE_TYPE (op); tree inner_type = TREE_TYPE (type); tree r = build1 (REALPART_EXPR, inner_type, op); diff --git a/gcc/tree-predcom.cc b/gcc/tree-predcom.cc index bb3a1cb68fc..fb457250bbd 100644 --- a/gcc/tree-predcom.cc +++ b/gcc/tree-predcom.cc @@ -1377,7 +1377,6 @@ gphi * pcom_worker::find_looparound_phi (dref ref, dref root) { tree name, init, init_ref; - gphi *phi = NULL; gimple *init_stmt; edge latch = loop_latch_edge (m_loop); struct data_reference init_dr; @@ -1395,14 +1394,19 @@ pcom_worker::find_looparound_phi (dref ref, dref root) if (!name) return NULL; + tree entry_vuse = NULL_TREE; + gphi *phi = NULL; for (psi = gsi_start_phis (m_loop->header); !gsi_end_p (psi); gsi_next (&psi)) { - phi = psi.phi (); - if (PHI_ARG_DEF_FROM_EDGE (phi, latch) == name) + gphi *p = psi.phi (); + if (PHI_ARG_DEF_FROM_EDGE (p, latch) == name) + phi = p; + else if (virtual_operand_p (gimple_phi_result (p))) + entry_vuse = PHI_ARG_DEF_FROM_EDGE (p, loop_preheader_edge (m_loop)); + if (phi && entry_vuse) break; } - - if (gsi_end_p (psi)) + if (!phi || !entry_vuse) return NULL; init = PHI_ARG_DEF_FROM_EDGE (phi, loop_preheader_edge (m_loop)); @@ -1430,6 +1434,30 @@ pcom_worker::find_looparound_phi (dref ref, dref root) if (!valid_initializer_p (&init_dr, ref->distance + 1, root->ref)) return NULL; + /* Make sure nothing clobbers the location we re-use the initial value + from. */ + if (entry_vuse != gimple_vuse (init_stmt)) + { + ao_ref ref; + ao_ref_init (&ref, init_ref); + unsigned limit = param_sccvn_max_alias_queries_per_access; + tree vdef = entry_vuse; + do + { + gimple *def = SSA_NAME_DEF_STMT (vdef); + if (limit-- == 0 || gimple_code (def) == GIMPLE_PHI) + return NULL; + if (stmt_may_clobber_ref_p_1 (def, &ref)) + /* When the stmt is an assign to init_ref we could in theory + use its RHS for the initial value of the looparound PHI + we replace in prepare_initializers_chain, but we have + no convenient place to store this info at the moment. */ + return NULL; + vdef = gimple_vuse (def); + } + while (vdef != gimple_vuse (init_stmt)); + } + return phi; } diff --git a/gcc/tree-scalar-evolution.cc b/gcc/tree-scalar-evolution.cc index 61d72c278a1..44157265ce8 100644 --- a/gcc/tree-scalar-evolution.cc +++ b/gcc/tree-scalar-evolution.cc @@ -3395,7 +3395,7 @@ expression_expensive_p (tree expr, hash_map<tree, uint64_t> &cache, call_expr_arg_iterator iter; /* Even though is_inexpensive_builtin might say true, we will get a library call for popcount when backend does not have an instruction - to do so. We consider this to be expenseive and generate + to do so. We consider this to be expensive and generate __builtin_popcount only when backend defines it. */ combined_fn cfn = get_call_combined_fn (expr); switch (cfn) diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc index 50bd47b31f3..063f1893851 100644 --- a/gcc/tree-ssa-alias.cc +++ b/gcc/tree-ssa-alias.cc @@ -210,10 +210,12 @@ dump_alias_stats (FILE *s) } -/* Return true, if dereferencing PTR may alias with a global variable. */ +/* Return true, if dereferencing PTR may alias with a global variable. + When ESCAPED_LOCAL_P is true escaped local memory is also considered + global. */ bool -ptr_deref_may_alias_global_p (tree ptr) +ptr_deref_may_alias_global_p (tree ptr, bool escaped_local_p) { struct ptr_info_def *pi; @@ -230,7 +232,7 @@ ptr_deref_may_alias_global_p (tree ptr) return true; /* ??? This does not use TBAA to prune globals ptr may not access. */ - return pt_solution_includes_global (&pi->pt); + return pt_solution_includes_global (&pi->pt, escaped_local_p); } /* Return true if dereferencing PTR may alias DECL. @@ -480,37 +482,44 @@ ptrs_compare_unequal (tree ptr1, tree ptr2) return false; } -/* Returns whether reference REF to BASE may refer to global memory. */ +/* Returns whether reference REF to BASE may refer to global memory. + When ESCAPED_LOCAL_P is true escaped local memory is also considered + global. */ static bool -ref_may_alias_global_p_1 (tree base) +ref_may_alias_global_p_1 (tree base, bool escaped_local_p) { if (DECL_P (base)) - return is_global_var (base); + return (is_global_var (base) + || (escaped_local_p + && pt_solution_includes (&cfun->gimple_df->escaped, base))); else if (TREE_CODE (base) == MEM_REF || TREE_CODE (base) == TARGET_MEM_REF) - return ptr_deref_may_alias_global_p (TREE_OPERAND (base, 0)); + return ptr_deref_may_alias_global_p (TREE_OPERAND (base, 0), + escaped_local_p); return true; } bool -ref_may_alias_global_p (ao_ref *ref) +ref_may_alias_global_p (ao_ref *ref, bool escaped_local_p) { tree base = ao_ref_base (ref); - return ref_may_alias_global_p_1 (base); + return ref_may_alias_global_p_1 (base, escaped_local_p); } bool -ref_may_alias_global_p (tree ref) +ref_may_alias_global_p (tree ref, bool escaped_local_p) { tree base = get_base_address (ref); - return ref_may_alias_global_p_1 (base); + return ref_may_alias_global_p_1 (base, escaped_local_p); } -/* Return true whether STMT may clobber global memory. */ +/* Return true whether STMT may clobber global memory. + When ESCAPED_LOCAL_P is true escaped local memory is also considered + global. */ bool -stmt_may_clobber_global_p (gimple *stmt) +stmt_may_clobber_global_p (gimple *stmt, bool escaped_local_p) { tree lhs; @@ -531,7 +540,7 @@ stmt_may_clobber_global_p (gimple *stmt) case GIMPLE_ASSIGN: lhs = gimple_assign_lhs (stmt); return (TREE_CODE (lhs) != SSA_NAME - && ref_may_alias_global_p (lhs)); + && ref_may_alias_global_p (lhs, escaped_local_p)); case GIMPLE_CALL: return true; default: @@ -2567,30 +2576,6 @@ refs_output_dependent_p (tree store1, tree store2) return refs_may_alias_p_1 (&r1, &r2, false); } -/* Return ture if REF may access global memory. */ - -bool -ref_may_access_global_memory_p (ao_ref *ref) -{ - if (!ref->ref) - return true; - tree base = ao_ref_base (ref); - if (TREE_CODE (base) == MEM_REF - || TREE_CODE (base) == TARGET_MEM_REF) - { - if (ptr_deref_may_alias_global_p (TREE_OPERAND (base, 0))) - return true; - } - else - { - if (!auto_var_in_fn_p (base, current_function_decl) - || pt_solution_includes (&cfun->gimple_df->escaped, - base)) - return true; - } - return false; -} - /* Returns true if and only if REF may alias any access stored in TT. IF TBAA_P is true, use TBAA oracle. */ @@ -2654,7 +2639,7 @@ modref_may_conflict (const gcall *stmt, { if (global_memory_ok) continue; - if (ref_may_access_global_memory_p (ref)) + if (ref_may_alias_global_p (ref, true)) return true; global_memory_ok = true; num_tests++; @@ -2990,7 +2975,7 @@ ref_maybe_used_by_stmt_p (gimple *stmt, ao_ref *ref, bool tbaa_p) return is_global_var (base); else if (TREE_CODE (base) == MEM_REF || TREE_CODE (base) == TARGET_MEM_REF) - return ptr_deref_may_alias_global_p (TREE_OPERAND (base, 0)); + return ptr_deref_may_alias_global_p (TREE_OPERAND (base, 0), false); return false; } diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h index dfb21275657..fa081ab0173 100644 --- a/gcc/tree-ssa-alias.h +++ b/gcc/tree-ssa-alias.h @@ -121,18 +121,18 @@ extern tree ao_ref_alias_ptr_type (ao_ref *); extern tree ao_ref_base_alias_ptr_type (ao_ref *); extern bool ao_ref_alignment (ao_ref *, unsigned int *, unsigned HOST_WIDE_INT *); -extern bool ptr_deref_may_alias_global_p (tree); +extern bool ptr_deref_may_alias_global_p (tree, bool); extern bool ptr_derefs_may_alias_p (tree, tree); extern bool ptrs_compare_unequal (tree, tree); -extern bool ref_may_alias_global_p (tree); -extern bool ref_may_alias_global_p (ao_ref *); +extern bool ref_may_alias_global_p (tree, bool); +extern bool ref_may_alias_global_p (ao_ref *, bool); extern bool refs_may_alias_p (tree, tree, bool = true); extern bool refs_may_alias_p_1 (ao_ref *, ao_ref *, bool); extern bool refs_anti_dependent_p (tree, tree); extern bool refs_output_dependent_p (tree, tree); extern bool ref_maybe_used_by_stmt_p (gimple *, tree, bool = true); extern bool ref_maybe_used_by_stmt_p (gimple *, ao_ref *, bool = true); -extern bool stmt_may_clobber_global_p (gimple *); +extern bool stmt_may_clobber_global_p (gimple *, bool); extern bool stmt_may_clobber_ref_p (gimple *, tree, bool = true); extern bool stmt_may_clobber_ref_p_1 (gimple *, ao_ref *, bool = true); extern bool call_may_clobber_ref_p (gcall *, tree, bool = true); @@ -171,7 +171,7 @@ extern void dump_alias_stats (FILE *); extern unsigned int compute_may_aliases (void); extern bool pt_solution_empty_p (const pt_solution *); extern bool pt_solution_singleton_or_null_p (struct pt_solution *, unsigned *); -extern bool pt_solution_includes_global (struct pt_solution *); +extern bool pt_solution_includes_global (struct pt_solution *, bool); extern bool pt_solution_includes (struct pt_solution *, const_tree); extern bool pt_solutions_intersect (struct pt_solution *, struct pt_solution *); extern void pt_solution_reset (struct pt_solution *); diff --git a/gcc/tree-ssa-dce.cc b/gcc/tree-ssa-dce.cc index 2a13ea34829..2067b711d5b 100644 --- a/gcc/tree-ssa-dce.cc +++ b/gcc/tree-ssa-dce.cc @@ -315,7 +315,7 @@ mark_stmt_if_obviously_necessary (gimple *stmt, bool aggressive) } if ((gimple_vdef (stmt) && keep_all_vdefs_p ()) - || stmt_may_clobber_global_p (stmt)) + || stmt_may_clobber_global_p (stmt, false)) { mark_stmt_necessary (stmt, true); return; diff --git a/gcc/tree-ssa-dse.cc b/gcc/tree-ssa-dse.cc index 3beaed3ad38..881a2d0f98d 100644 --- a/gcc/tree-ssa-dse.cc +++ b/gcc/tree-ssa-dse.cc @@ -1030,7 +1030,7 @@ dse_classify_store (ao_ref *ref, gimple *stmt, just pretend the stmt makes itself dead. Otherwise fail. */ if (defs.is_empty ()) { - if (ref_may_alias_global_p (ref)) + if (ref_may_alias_global_p (ref, false)) return DSE_STORE_LIVE; if (by_clobber_p) @@ -1062,7 +1062,7 @@ dse_classify_store (ao_ref *ref, gimple *stmt, { /* But if the store is to global memory it is definitely not dead. */ - if (ref_may_alias_global_p (ref)) + if (ref_may_alias_global_p (ref, false)) return DSE_STORE_LIVE; defs.unordered_remove (i); } diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc index 581f92b059b..81b536f9304 100644 --- a/gcc/tree-ssa-loop-ivopts.cc +++ b/gcc/tree-ssa-loop-ivopts.cc @@ -452,6 +452,7 @@ struct iv_cand unsigned id; /* The number of the candidate. */ bool important; /* Whether this is an "important" candidate, i.e. such that it should be considered by all uses. */ + bool involves_undefs; /* Whether the IV involves undefined values. */ ENUM_BITFIELD(iv_position) pos : 8; /* Where it is computed. */ gimple *incremented_at;/* For original biv, the statement where it is incremented. */ @@ -3070,6 +3071,19 @@ get_loop_invariant_expr (struct ivopts_data *data, tree inv_expr) return *slot; } +/* Find the first undefined SSA name in *TP. */ + +static tree +find_ssa_undef (tree *tp, int *walk_subtrees, void *) +{ + if (TREE_CODE (*tp) == SSA_NAME + && ssa_undefined_value_p (*tp, false)) + return *tp; + if (!EXPR_P (*tp)) + *walk_subtrees = 0; + return NULL; +} + /* Adds a candidate BASE + STEP * i. Important field is set to IMPORTANT and position to POS. If USE is not NULL, the candidate is set as related to it. If both BASE and STEP are NULL, we add a pseudocandidate for the @@ -3097,6 +3111,17 @@ add_candidate_1 (struct ivopts_data *data, tree base, tree step, bool important, if (flag_keep_gc_roots_live && POINTER_TYPE_P (TREE_TYPE (base))) return NULL; + /* If BASE contains undefined SSA names make sure we only record + the original IV. */ + bool involves_undefs = false; + if (walk_tree (&base, find_ssa_undef, NULL, NULL)) + { + if (pos != IP_ORIGINAL) + return NULL; + important = false; + involves_undefs = true; + } + /* For non-original variables, make sure their values are computed in a type that does not invoke undefined behavior on overflows (since in general, we cannot prove that these induction variables are non-wrapping). */ @@ -3145,6 +3170,7 @@ add_candidate_1 (struct ivopts_data *data, tree base, tree step, bool important, cand->var_after = cand->var_before; } cand->important = important; + cand->involves_undefs = involves_undefs; cand->incremented_at = incremented_at; cand->doloop_p = doloop; data->vcands.safe_push (cand); @@ -4958,6 +4984,11 @@ determine_group_iv_cost_generic (struct ivopts_data *data, the candidate. */ if (cand->pos == IP_ORIGINAL && cand->incremented_at == use->stmt) cost = no_cost; + /* If the IV candidate involves undefined SSA values and is not the + same IV as on the USE avoid using that candidate here. */ + else if (cand->involves_undefs + && (!use->iv || !operand_equal_p (cand->iv->base, use->iv->base, 0))) + return false; else cost = get_computation_cost (data, use, cand, false, &inv_vars, NULL, &inv_expr); diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index ac277756d24..7555793948e 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -1113,7 +1113,7 @@ make_pass_cse_reciprocals (gcc::context *ctxt) conversions. Return the prevailing name. */ static tree -execute_cse_conv_1 (tree name) +execute_cse_conv_1 (tree name, bool *cfg_changed) { if (SSA_NAME_IS_DEFAULT_DEF (name) || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)) @@ -1189,15 +1189,18 @@ execute_cse_conv_1 (tree name) || !types_compatible_p (TREE_TYPE (name), TREE_TYPE (lhs))) continue; - if (gimple_bb (def_stmt) == gimple_bb (use_stmt) - || dominated_by_p (CDI_DOMINATORS, gimple_bb (use_stmt), - gimple_bb (def_stmt))) + basic_block use_bb = gimple_bb (use_stmt); + if (gimple_bb (def_stmt) == use_bb + || dominated_by_p (CDI_DOMINATORS, use_bb, gimple_bb (def_stmt))) { sincos_stats.conv_removed++; gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt); replace_uses_by (lhs, name); - gsi_remove (&gsi, true); + if (gsi_remove (&gsi, true) + && gimple_purge_dead_eh_edges (use_bb)) + *cfg_changed = true; + release_defs (use_stmt); } } @@ -1252,7 +1255,7 @@ execute_cse_sincos_1 (tree name) int i; bool cfg_changed = false; - name = execute_cse_conv_1 (name); + name = execute_cse_conv_1 (name, &cfg_changed); FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, name) { @@ -1459,7 +1462,7 @@ powi_cost (HOST_WIDE_INT n) return 0; /* Ignore the reciprocal when calculating the cost. */ - val = (n < 0) ? -n : n; + val = absu_hwi (n); /* Initialize the exponent cache. */ memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool)); diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index 4a0c9dd656d..3eda825672c 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -52,6 +52,7 @@ along with GCC; see the file COPYING3. If not see #include "gimple-range.h" #include "gimple-match.h" #include "dbgcnt.h" +#include "tree-ssa-propagate.h" static unsigned int tree_ssa_phiopt_worker (bool, bool, bool); static bool two_value_replacement (basic_block, basic_block, edge, gphi *, @@ -1327,7 +1328,17 @@ value_replacement (basic_block cond_bb, basic_block middle_bb, We now need to verify that the two arguments in the PHI node match the two arguments to the equality comparison. */ - if (operand_equal_for_value_replacement (arg0, arg1, &code, cond)) + bool equal_p = operand_equal_for_value_replacement (arg0, arg1, &code, cond); + bool maybe_equal_p = false; + if (!equal_p + && empty_or_with_defined_p + && TREE_CODE (gimple_cond_rhs (cond)) == INTEGER_CST + && (operand_equal_for_phi_arg_p (gimple_cond_lhs (cond), arg0) + ? TREE_CODE (arg1) == INTEGER_CST + : (operand_equal_for_phi_arg_p (gimple_cond_lhs (cond), arg1) + && TREE_CODE (arg0) == INTEGER_CST))) + maybe_equal_p = true; + if (equal_p || maybe_equal_p) { edge e; tree arg; @@ -1358,11 +1369,136 @@ value_replacement (basic_block cond_bb, basic_block middle_bb, && single_non_singleton_phi_for_edges (phi_nodes (gimple_bb (phi)), e0, e1) == phi) { - replace_phi_edge_with_variable (cond_bb, e1, phi, arg); - /* Note that we optimized this PHI. */ - return 2; + use_operand_p use_p; + gimple *use_stmt; + + /* Even if arg0/arg1 isn't equal to second operand of cond, we + can optimize away the bb if we can prove it doesn't care whether + phi result is arg0/arg1 or second operand of cond. Consider: + <bb 2> [local count: 118111600]: + if (i_2(D) == 4) + goto <bb 4>; [97.00%] + else + goto <bb 3>; [3.00%] + + <bb 3> [local count: 3540129]: + + <bb 4> [local count: 118111600]: + # i_6 = PHI <i_2(D)(3), 6(2)> + _3 = i_6 != 0; + Here, carg is 4, oarg is 6, crhs is 0, and because + (4 != 0) == (6 != 0), we don't care if i_6 is 4 or 6, both + have the same outcome. So, can can optimize this to: + _3 = i_2(D) != 0; + If the single imm use of phi result >, >=, < or <=, similarly + we can check if both carg and oarg compare the same against + crhs using ccode. */ + if (maybe_equal_p + && TREE_CODE (arg) != INTEGER_CST + && single_imm_use (gimple_phi_result (phi), &use_p, &use_stmt)) + { + enum tree_code ccode = ERROR_MARK; + tree clhs = NULL_TREE, crhs = NULL_TREE; + tree carg = gimple_cond_rhs (cond); + tree oarg = e0 == e ? arg1 : arg0; + if (is_gimple_assign (use_stmt) + && (TREE_CODE_CLASS (gimple_assign_rhs_code (use_stmt)) + == tcc_comparison)) + { + ccode = gimple_assign_rhs_code (use_stmt); + clhs = gimple_assign_rhs1 (use_stmt); + crhs = gimple_assign_rhs2 (use_stmt); + } + else if (gimple_code (use_stmt) == GIMPLE_COND) + { + ccode = gimple_cond_code (use_stmt); + clhs = gimple_cond_lhs (use_stmt); + crhs = gimple_cond_rhs (use_stmt); + } + if (ccode != ERROR_MARK + && clhs == gimple_phi_result (phi) + && TREE_CODE (crhs) == INTEGER_CST) + switch (ccode) + { + case EQ_EXPR: + case NE_EXPR: + if (!tree_int_cst_equal (crhs, carg) + && !tree_int_cst_equal (crhs, oarg)) + equal_p = true; + break; + case GT_EXPR: + if (tree_int_cst_lt (crhs, carg) + == tree_int_cst_lt (crhs, oarg)) + equal_p = true; + break; + case GE_EXPR: + if (tree_int_cst_le (crhs, carg) + == tree_int_cst_le (crhs, oarg)) + equal_p = true; + break; + case LT_EXPR: + if (tree_int_cst_lt (carg, crhs) + == tree_int_cst_lt (oarg, crhs)) + equal_p = true; + break; + case LE_EXPR: + if (tree_int_cst_le (carg, crhs) + == tree_int_cst_le (oarg, crhs)) + equal_p = true; + break; + default: + break; + } + if (equal_p && MAY_HAVE_DEBUG_BIND_STMTS) + { + imm_use_iterator imm_iter; + tree phires = gimple_phi_result (phi); + tree temp = NULL_TREE; + bool reset_p = false; + + /* Add # DEBUG D#1 => arg != carg ? arg : oarg. */ + FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, phires) + { + if (!is_gimple_debug (use_stmt)) + continue; + if (temp == NULL_TREE) + { + if (!single_pred_p (middle_bb) + || EDGE_COUNT (gimple_bb (phi)->preds) != 2) + { + /* But only if middle_bb has a single + predecessor and phi bb has two, otherwise + we could use a SSA_NAME not usable in that + place or wrong-debug. */ + reset_p = true; + break; + } + gimple_stmt_iterator gsi + = gsi_after_labels (gimple_bb (phi)); + tree type = TREE_TYPE (phires); + temp = build_debug_expr_decl (type); + tree t = build2 (NE_EXPR, boolean_type_node, + arg, carg); + t = build3 (COND_EXPR, type, t, arg, oarg); + gimple *g = gimple_build_debug_bind (temp, t, phi); + gsi_insert_before (&gsi, g, GSI_SAME_STMT); + } + FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) + replace_exp (use_p, temp); + update_stmt (use_stmt); + } + if (reset_p) + reset_debug_uses (phi); + } + } + if (equal_p) + { + replace_phi_edge_with_variable (cond_bb, e1, phi, arg); + /* Note that we optimized this PHI. */ + return 2; + } } - else + else if (equal_p) { if (!single_pred_p (middle_bb)) return 0; diff --git a/gcc/tree-ssa-reassoc.cc b/gcc/tree-ssa-reassoc.cc index 4ab3c3361f9..43b25371d4b 100644 --- a/gcc/tree-ssa-reassoc.cc +++ b/gcc/tree-ssa-reassoc.cc @@ -2254,7 +2254,11 @@ eliminate_redundant_comparison (enum tree_code opcode, BIT_AND_EXPR or BIT_IOR_EXPR was of a wider integer type, we need to convert. */ if (!useless_type_conversion_p (TREE_TYPE (curr->op), TREE_TYPE (t))) - t = fold_convert (TREE_TYPE (curr->op), t); + { + if (!fold_convertible_p (TREE_TYPE (curr->op), t)) + continue; + t = fold_convert (TREE_TYPE (curr->op), t); + } if (TREE_CODE (t) != INTEGER_CST && !operand_equal_p (t, curr->op, 0)) @@ -5857,7 +5861,9 @@ try_special_add_to_ops (vec<operand_entry *> *ops, && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR && !HONOR_SNANS (TREE_TYPE (op)) && (!HONOR_SIGNED_ZEROS (TREE_TYPE (op)) - || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (op)))) + || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (op))) + && (!FLOAT_TYPE_P (TREE_TYPE (op)) + || !DECIMAL_FLOAT_MODE_P (element_mode (op)))) { tree rhs1 = gimple_assign_rhs1 (def_stmt); tree cst = build_minus_one_cst (TREE_TYPE (op)); diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc index 66b4fc21f5b..d4d0aba880c 100644 --- a/gcc/tree-ssa-sccvn.cc +++ b/gcc/tree-ssa-sccvn.cc @@ -5140,12 +5140,11 @@ visit_reference_op_call (tree lhs, gcall *stmt) { accesses.quick_grow (accesses.length () + 1); ao_ref *r = &accesses.last (); - tree arg = access_node.get_call_arg (stmt); - if (!POINTER_TYPE_P (TREE_TYPE (arg)) - || !access_node.get_ao_ref (stmt, r)) + if (!access_node.get_ao_ref (stmt, r)) { /* Initialize a ref based on the argument and unknown offset if possible. */ + tree arg = access_node.get_call_arg (stmt); if (arg && TREE_CODE (arg) == SSA_NAME) arg = SSA_VAL (arg); if (arg diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc index d318f883e70..581bdcf5652 100644 --- a/gcc/tree-ssa-structalias.cc +++ b/gcc/tree-ssa-structalias.cc @@ -6995,10 +6995,12 @@ pt_solution_singleton_or_null_p (struct pt_solution *pt, unsigned *uid) return true; } -/* Return true if the points-to solution *PT includes global memory. */ +/* Return true if the points-to solution *PT includes global memory. + If ESCAPED_LOCAL_P is true then escaped local variables are also + considered global. */ bool -pt_solution_includes_global (struct pt_solution *pt) +pt_solution_includes_global (struct pt_solution *pt, bool escaped_local_p) { if (pt->anything || pt->nonlocal @@ -7009,12 +7011,17 @@ pt_solution_includes_global (struct pt_solution *pt) || pt->vars_contains_escaped_heap) return true; + if (escaped_local_p && pt->vars_contains_escaped) + return true; + /* 'escaped' is also a placeholder so we have to look into it. */ if (pt->escaped) - return pt_solution_includes_global (&cfun->gimple_df->escaped); + return pt_solution_includes_global (&cfun->gimple_df->escaped, + escaped_local_p); if (pt->ipa_escaped) - return pt_solution_includes_global (&ipa_escaped_pt); + return pt_solution_includes_global (&ipa_escaped_pt, + escaped_local_p); return false; } diff --git a/gcc/tree-vect-generic.cc b/gcc/tree-vect-generic.cc index 12a553ec8be..8b7227e8b58 100644 --- a/gcc/tree-vect-generic.cc +++ b/gcc/tree-vect-generic.cc @@ -317,8 +317,11 @@ expand_vector_piecewise (gimple_stmt_iterator *gsi, elem_op_func f, int i; location_t loc = gimple_location (gsi_stmt (*gsi)); - if (nunits == 1) - /* Do not diagnose decomposing single element vectors. */ + if (nunits == 1 + || warning_suppressed_p (gsi_stmt (*gsi), + OPT_Wvector_operation_performance)) + /* Do not diagnose decomposing single element vectors or when + decomposing vectorizer produced operations. */ ; else if (ret_type || !parallel_p) warning_at (loc, OPT_Wvector_operation_performance, @@ -379,14 +382,16 @@ expand_vector_parallel (gimple_stmt_iterator *gsi, elem_op_func f, tree type, else { /* Use a single scalar operation with a mode no wider than word_mode. */ + if (!warning_suppressed_p (gsi_stmt (*gsi), + OPT_Wvector_operation_performance)) + warning_at (loc, OPT_Wvector_operation_performance, + "vector operation will be expanded with a " + "single scalar operation"); scalar_int_mode mode = int_mode_for_size (tree_to_uhwi (TYPE_SIZE (type)), 0).require (); compute_type = lang_hooks.types.type_for_mode (mode, 1); result = f (gsi, compute_type, a, b, bitsize_zero_node, TYPE_SIZE (compute_type), code, type); - warning_at (loc, OPT_Wvector_operation_performance, - "vector operation will be expanded with a " - "single scalar operation"); } return result; @@ -487,8 +492,10 @@ expand_vector_comparison (gimple_stmt_iterator *gsi, tree type, tree op0, if (TYPE_PRECISION (ret_inner_type) != 1) ret_inner_type = build_nonstandard_integer_type (1, 1); - warning_at (loc, OPT_Wvector_operation_performance, - "vector operation will be expanded piecewise"); + if (!warning_suppressed_p (gsi_stmt (*gsi), + OPT_Wvector_operation_performance)) + warning_at (loc, OPT_Wvector_operation_performance, + "vector operation will be expanded piecewise"); for (i = 0; i < nunits; i++, index = int_const_binop (PLUS_EXPR, index, part_width)) { @@ -1098,8 +1105,9 @@ expand_vector_condition (gimple_stmt_iterator *gsi, bitmap dce_ssa_names) /* TODO: try and find a smaller vector type. */ - warning_at (loc, OPT_Wvector_operation_performance, - "vector condition will be expanded piecewise"); + if (!warning_suppressed_p (stmt, OPT_Wvector_operation_performance)) + warning_at (loc, OPT_Wvector_operation_performance, + "vector condition will be expanded piecewise"); if (!a_is_comparison && VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (a)) @@ -1591,9 +1599,10 @@ lower_vec_perm (gimple_stmt_iterator *gsi) } else if (can_vec_perm_var_p (TYPE_MODE (vect_type))) return; - - warning_at (loc, OPT_Wvector_operation_performance, - "vector shuffling operation will be expanded piecewise"); + + if (!warning_suppressed_p (stmt, OPT_Wvector_operation_performance)) + warning_at (loc, OPT_Wvector_operation_performance, + "vector shuffling operation will be expanded piecewise"); vec_alloc (v, elements); bool constant_p = true; @@ -2029,8 +2038,12 @@ expand_vector_conversion (gimple_stmt_iterator *gsi) location_t loc = gimple_location (gsi_stmt (*gsi)); if (compute_type != arg_type) - warning_at (loc, OPT_Wvector_operation_performance, - "vector operation will be expanded piecewise"); + { + if (!warning_suppressed_p (gsi_stmt (*gsi), + OPT_Wvector_operation_performance)) + warning_at (loc, OPT_Wvector_operation_performance, + "vector operation will be expanded piecewise"); + } else { nunits = 1; diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc index a7bbc916bbc..e4381eb7079 100644 --- a/gcc/tree-vect-loop-manip.cc +++ b/gcc/tree-vect-loop-manip.cc @@ -3445,13 +3445,34 @@ vect_loop_versioning (loop_vec_info loop_vinfo, cond_expr = expr; } + tree cost_name = NULL_TREE; + profile_probability prob2 = profile_probability::uninitialized (); + if (cond_expr + && !integer_truep (cond_expr) + && (version_niter + || version_align + || version_alias + || version_simd_if_cond)) + { + cost_name = cond_expr = force_gimple_operand_1 (unshare_expr (cond_expr), + &cond_expr_stmt_list, + is_gimple_val, NULL_TREE); + /* Split prob () into two so that the overall probability of passing + both the cost-model and versioning checks is the orig prob. */ + prob2 = prob.split (prob); + } + if (version_niter) vect_create_cond_for_niters_checks (loop_vinfo, &cond_expr); if (cond_expr) - cond_expr = force_gimple_operand_1 (unshare_expr (cond_expr), - &cond_expr_stmt_list, - is_gimple_condexpr, NULL_TREE); + { + gimple_seq tem = NULL; + cond_expr = force_gimple_operand_1 (unshare_expr (cond_expr), + &tem, + is_gimple_condexpr, NULL_TREE); + gimple_seq_add_seq (&cond_expr_stmt_list, tem); + } if (version_align) vect_create_cond_for_align_checks (loop_vinfo, &cond_expr, @@ -3524,7 +3545,8 @@ vect_loop_versioning (loop_vec_info loop_vinfo, outermost = superloop_at_depth (loop, 1); /* And avoid applying versioning on non-perfect nests. */ while (loop_to_version != outermost - && single_exit (loop_outer (loop_to_version)) + && (e = single_exit (loop_outer (loop_to_version))) + && !(e->flags & EDGE_COMPLEX) && (!loop_outer (loop_to_version)->inner->next || vect_loop_vectorized_call (loop_to_version)) && (!loop_outer (loop_to_version)->inner->next @@ -3654,6 +3676,39 @@ vect_loop_versioning (loop_vec_info loop_vinfo, update_ssa (TODO_update_ssa); } + /* Split the cost model check off to a separate BB. Costing assumes + this is the only thing we perform when we enter the scalar loop + from a failed cost decision. */ + if (cost_name && TREE_CODE (cost_name) == SSA_NAME) + { + gimple *def = SSA_NAME_DEF_STMT (cost_name); + /* All uses of the cost check are 'true' after the check we + are going to insert. */ + replace_uses_by (cost_name, boolean_true_node); + /* And we're going to build the new single use of it. */ + gcond *cond = gimple_build_cond (NE_EXPR, cost_name, boolean_false_node, + NULL_TREE, NULL_TREE); + edge e = split_block (gimple_bb (def), def); + gimple_stmt_iterator gsi = gsi_for_stmt (def); + gsi_insert_after (&gsi, cond, GSI_NEW_STMT); + edge true_e, false_e; + extract_true_false_edges_from_block (e->dest, &true_e, &false_e); + e->flags &= ~EDGE_FALLTHRU; + e->flags |= EDGE_TRUE_VALUE; + edge e2 = make_edge (e->src, false_e->dest, EDGE_FALSE_VALUE); + e->probability = prob2; + e2->probability = prob2.invert (); + set_immediate_dominator (CDI_DOMINATORS, false_e->dest, e->src); + auto_vec<basic_block, 3> adj; + for (basic_block son = first_dom_son (CDI_DOMINATORS, e->dest); + son; + son = next_dom_son (CDI_DOMINATORS, son)) + if (EDGE_COUNT (son->preds) > 1) + adj.safe_push (son); + for (auto son : adj) + set_immediate_dominator (CDI_DOMINATORS, son, e->src); + } + if (version_niter) { /* The versioned loop could be infinite, we need to clear existing diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index d7bc34636bd..f53a634a390 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -9977,7 +9977,11 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple *loop_vectorized_call) lowest_vf) - 1 : wi::udiv_floor (loop->nb_iterations_upper_bound + bias_for_lowest, lowest_vf) - 1); - if (main_vinfo) + if (main_vinfo + /* Both peeling for alignment and peeling for gaps can end up + with the scalar epilogue running for more than VF-1 iterations. */ + && !main_vinfo->peeling_for_alignment + && !main_vinfo->peeling_for_gaps) { unsigned int bound; poly_uint64 main_iters diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 4ac2b70303c..805dd7e10e2 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -5185,22 +5185,46 @@ vect_bb_slp_scalar_cost (vec_info *vinfo, the scalar cost. */ if (!STMT_VINFO_LIVE_P (stmt_info)) { - FOR_EACH_PHI_OR_STMT_DEF (def_p, orig_stmt, op_iter, SSA_OP_DEF) + auto_vec<gimple *, 8> worklist; + hash_set<gimple *> *worklist_visited = NULL; + worklist.quick_push (orig_stmt); + do { - imm_use_iterator use_iter; - gimple *use_stmt; - FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, DEF_FROM_PTR (def_p)) - if (!is_gimple_debug (use_stmt)) - { - stmt_vec_info use_stmt_info = vinfo->lookup_stmt (use_stmt); - if (!use_stmt_info - || !vectorized_scalar_stmts.contains (use_stmt_info)) + gimple *work_stmt = worklist.pop (); + FOR_EACH_PHI_OR_STMT_DEF (def_p, work_stmt, op_iter, SSA_OP_DEF) + { + imm_use_iterator use_iter; + gimple *use_stmt; + FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, + DEF_FROM_PTR (def_p)) + if (!is_gimple_debug (use_stmt)) { - (*life)[i] = true; - break; + stmt_vec_info use_stmt_info + = vinfo->lookup_stmt (use_stmt); + if (!use_stmt_info + || !vectorized_scalar_stmts.contains (use_stmt_info)) + { + if (use_stmt_info + && STMT_VINFO_IN_PATTERN_P (use_stmt_info)) + { + /* For stmts participating in patterns we have + to check its uses recursively. */ + if (!worklist_visited) + worklist_visited = new hash_set<gimple *> (); + if (!worklist_visited->add (use_stmt)) + worklist.safe_push (use_stmt); + continue; + } + (*life)[i] = true; + goto next_lane; + } } - } + } } + while (!worklist.is_empty ()); +next_lane: + if (worklist_visited) + delete worklist_visited; if ((*life)[i]) continue; } diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index c0107c8c489..c9534ef9b1e 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -6440,6 +6440,8 @@ vectorizable_operation (vec_info *vinfo, new_temp = make_ssa_name (vec_dest, new_stmt); gimple_assign_set_lhs (new_stmt, new_temp); vect_finish_stmt_generation (vinfo, stmt_info, new_stmt, gsi); + if (using_emulated_vectors_p) + suppress_warning (new_stmt, OPT_Wvector_operation_performance); /* Enter the combined value into the vector cond hash so we don't AND it with a loop mask again. */ @@ -10510,7 +10512,7 @@ vectorizable_condition (vec_info *vinfo, bool honor_nans = HONOR_NANS (TREE_TYPE (cond.op0)); tree_code orig_code = cond.code; cond.code = invert_tree_comparison (cond.code, honor_nans); - if (loop_vinfo->scalar_cond_masked_set.contains (cond)) + if (!masked && loop_vinfo->scalar_cond_masked_set.contains (cond)) { masks = &LOOP_VINFO_MASKS (loop_vinfo); cond_code = cond.code; diff --git a/gcc/tree.cc b/gcc/tree.cc index ec200e9a7eb..3c39be4f501 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -6985,6 +6985,15 @@ build_reference_type (tree to_type) (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64) static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2]; +static void +clear_nonstandard_integer_type_cache (void) +{ + for (size_t i = 0 ; i < 2 * MAX_INT_CACHED_PREC + 2 ; i++) + { + nonstandard_integer_type_cache[i] = NULL; + } +} + /* Builds a signed or unsigned integer type of precision PRECISION. Used for C bitfields whose precision does not match that of built-in target types. */ @@ -8406,6 +8415,69 @@ get_callee_fndecl (const_tree call) return NULL_TREE; } +/* Return true when STMTs arguments and return value match those of FNDECL, + a decl of a builtin function. */ + +static bool +tree_builtin_call_types_compatible_p (const_tree call, tree fndecl) +{ + gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN); + + if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL) + if (tree decl = builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl))) + fndecl = decl; + + bool gimple_form = (cfun && (cfun->curr_properties & PROP_gimple)) != 0; + if (gimple_form + ? !useless_type_conversion_p (TREE_TYPE (call), + TREE_TYPE (TREE_TYPE (fndecl))) + : (TYPE_MAIN_VARIANT (TREE_TYPE (call)) + != TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))))) + return false; + + tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); + unsigned nargs = call_expr_nargs (call); + for (unsigned i = 0; i < nargs; ++i, targs = TREE_CHAIN (targs)) + { + /* Variadic args follow. */ + if (!targs) + return true; + tree arg = CALL_EXPR_ARG (call, i); + tree type = TREE_VALUE (targs); + if (gimple_form + ? !useless_type_conversion_p (type, TREE_TYPE (arg)) + : TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (TREE_TYPE (arg))) + { + /* For pointer arguments be more forgiving, e.g. due to + FILE * vs. fileptr_type_node, or say char * vs. const char * + differences etc. */ + if (!gimple_form + && POINTER_TYPE_P (type) + && POINTER_TYPE_P (TREE_TYPE (arg)) + && tree_nop_conversion_p (type, TREE_TYPE (arg))) + continue; + /* char/short integral arguments are promoted to int + by several frontends if targetm.calls.promote_prototypes + is true. Allow such promotion too. */ + if (INTEGRAL_TYPE_P (type) + && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node) + && INTEGRAL_TYPE_P (TREE_TYPE (arg)) + && !TYPE_UNSIGNED (TREE_TYPE (arg)) + && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)) + && (gimple_form + ? useless_type_conversion_p (integer_type_node, + TREE_TYPE (arg)) + : tree_nop_conversion_p (integer_type_node, + TREE_TYPE (arg)))) + continue; + return false; + } + } + if (targs && !VOID_TYPE_P (TREE_VALUE (targs))) + return false; + return true; +} + /* If CALL_EXPR CALL calls a normal built-in function or an internal function, return the associated function code, otherwise return CFN_LAST. */ @@ -8419,7 +8491,9 @@ get_call_combined_fn (const_tree call) return as_combined_fn (CALL_EXPR_IFN (call)); tree fndecl = get_callee_fndecl (call); - if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)) + if (fndecl + && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL) + && tree_builtin_call_types_compatible_p (call, fndecl)) return as_combined_fn (DECL_FUNCTION_CODE (fndecl)); return CFN_LAST; @@ -12906,6 +12980,8 @@ component_ref_size (tree ref, special_array_member *sam /* = NULL */) to struct types with flexible array members. */ if (memsize) { + if (!tree_fits_poly_int64_p (memsize)) + return NULL_TREE; poly_int64 memsz64 = memsize ? tree_to_poly_int64 (memsize) : 0; if (known_lt (baseoff, memsz64)) { @@ -14618,6 +14694,12 @@ get_target_clone_attr_len (tree arglist) return str_len_sum; } +void +tree_cc_finalize (void) +{ + clear_nonstandard_integer_type_cache (); +} + #if CHECKING_P namespace selftest { diff --git a/gcc/tree.h b/gcc/tree.h index cea49a500f2..8844471e9a5 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5401,6 +5401,7 @@ extern bool real_minus_onep (const_tree); extern void init_ttree (void); extern void build_common_tree_nodes (bool); extern void build_common_builtin_nodes (void); +extern void tree_cc_finalize (void); extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int); extern tree build_nonstandard_boolean_type (unsigned HOST_WIDE_INT); extern tree build_range_type (tree, tree, tree); diff --git a/gcc/value-prof.cc b/gcc/value-prof.cc index 9785c7a03ea..c240a186336 100644 --- a/gcc/value-prof.cc +++ b/gcc/value-prof.cc @@ -336,6 +336,10 @@ stream_out_histogram_value (struct output_block *ob, histogram_value hist) /* Note that the IOR counter tracks pointer values and these can have sign bit set. */ ; + else if (hist->type == HIST_TYPE_INDIR_CALL && i == 0) + /* 'all' counter overflow is stored as a negative value. Individual + counters and values are expected to be non-negative. */ + ; else gcc_assert (value >= 0); diff --git a/include/ChangeLog b/include/ChangeLog index e8bfe3982e5..ce988517e89 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,7 @@ +2022-04-06 Thomas Schwinge <thomas@codesourcery.com> + + * cuda/cuda.h: New file. + 2022-03-19 Tiezhu Yang <yangtiezhu@loongson.cn> * floatformat.h (floatformat_ieee_quad_big): Renamed from diff --git a/libgomp/plugin/cuda/cuda.h b/include/cuda/cuda.h index 5c679c1767a..5c813ad2cf8 100644 --- a/libgomp/plugin/cuda/cuda.h +++ b/include/cuda/cuda.h @@ -1,4 +1,4 @@ -/* CUDA API description. +/* CUDA Driver API description. Copyright (C) 2017-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -22,9 +22,8 @@ a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. -This header provides the minimum amount of typedefs, enums and function -declarations to be able to compile plugin-nvptx.c if cuda.h and -libcuda.so.1 are not available. */ +This header provides parts of the CUDA Driver API, without having to rely on +the proprietary CUDA toolkit. */ #ifndef GCC_CUDA_H #define GCC_CUDA_H diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog index 8b2b9f4c191..ce0cb325db3 100644 --- a/libgcc/ChangeLog +++ b/libgcc/ChangeLog @@ -1,3 +1,7 @@ +2022-04-08 Sergei Trofimovich <siarheit@google.com> + + * config/ia64/fde-glibc.c: Make a no-op in inhibit_libc mode. + 2022-03-29 Chenghua Xu <xuchenghua@loongson.cn> Lulu Cheng <chenglulu@loongson.cn> diff --git a/libgcc/config/ia64/fde-glibc.c b/libgcc/config/ia64/fde-glibc.c index 9caac2bca24..bd74847fa85 100644 --- a/libgcc/config/ia64/fde-glibc.c +++ b/libgcc/config/ia64/fde-glibc.c @@ -29,6 +29,7 @@ #define _GNU_SOURCE 1 #endif #include "config.h" +#ifndef inhibit_libc #include <stddef.h> #include <stdlib.h> #include <link.h> @@ -159,3 +160,4 @@ _Unwind_FindTableEntry (void *pc, unw_word *segment_base, unw_word *gp, return data.ret; } +#endif diff --git a/libgo/Makefile.am b/libgo/Makefile.am index e0a1eec52a2..a5d4b6a3525 100644 --- a/libgo/Makefile.am +++ b/libgo/Makefile.am @@ -1305,7 +1305,7 @@ check-tail: check-recursive check-multi if test "$$untested" -ne "0"; then \ echo "# of untested testcases $$untested" >> libgo.sum; \ fi; \ - echo `echo $(GOC) | sed -e 's/ .*//'` `$(GOC) -v 2>&1 | grep " version" | sed -n -e 's/.* \(version.*$$\)/\1/p'` >> libgo.sum; \ + echo `echo $(GOC) | sed -e 's/ .*//'` `$(GOC) -v 2>&1 | grep " version" | sed -n -e 's/.* \(version.*\)$$/\1/p'` >> libgo.sum; \ echo >> libgo.log; \ echo "runtest completed at `date`" >> libgo.log; \ if test "$$fail" -ne "0"; then \ diff --git a/libgo/Makefile.in b/libgo/Makefile.in index 7bef5df90d1..22f48a52938 100644 --- a/libgo/Makefile.in +++ b/libgo/Makefile.in @@ -3189,7 +3189,7 @@ check-tail: check-recursive check-multi if test "$$untested" -ne "0"; then \ echo "# of untested testcases $$untested" >> libgo.sum; \ fi; \ - echo `echo $(GOC) | sed -e 's/ .*//'` `$(GOC) -v 2>&1 | grep " version" | sed -n -e 's/.* \(version.*$$\)/\1/p'` >> libgo.sum; \ + echo `echo $(GOC) | sed -e 's/ .*//'` `$(GOC) -v 2>&1 | grep " version" | sed -n -e 's/.* \(version.*\)$$/\1/p'` >> libgo.sum; \ echo >> libgo.log; \ echo "runtest completed at `date`" >> libgo.log; \ if test "$$fail" -ne "0"; then \ diff --git a/libgo/go/runtime/mpagealloc.go b/libgo/go/runtime/mpagealloc.go index 2725e3b7c7b..5e40da45d17 100644 --- a/libgo/go/runtime/mpagealloc.go +++ b/libgo/go/runtime/mpagealloc.go @@ -87,7 +87,9 @@ const ( // // We alias maxOffAddr just to make it clear that this is the maximum address // for the page allocator's search space. See maxOffAddr for details. -var maxSearchAddr = maxOffAddr +func maxSearchAddr() offAddr { + return maxOffAddr +} // Global chunk index. // @@ -331,13 +333,13 @@ func (p *pageAlloc) init(mheapLock *mutex, sysStat *sysMemStat) { p.sysInit() // Start with the searchAddr in a state indicating there's no free memory. - p.searchAddr = maxSearchAddr + p.searchAddr = maxSearchAddr() // Set the mheapLock. p.mheapLock = mheapLock // Initialize scavenge tracking state. - p.scav.scavLWM = maxSearchAddr + p.scav.scavLWM = maxSearchAddr() } // tryChunkOf returns the bitmap data for the given chunk. @@ -760,7 +762,7 @@ nextLevel: } if l == 0 { // We're at level zero, so that means we've exhausted our search. - return 0, maxSearchAddr + return 0, maxSearchAddr() } // We're not at level zero, and we exhausted the level we were looking in. @@ -854,7 +856,7 @@ func (p *pageAlloc) alloc(npages uintptr) (addr uintptr, scav uintptr) { // exhausted. Otherwise, the heap still might have free // space in it, just not enough contiguous space to // accommodate npages. - p.searchAddr = maxSearchAddr + p.searchAddr = maxSearchAddr() } return 0, 0 } diff --git a/libgo/go/runtime/mpagecache.go b/libgo/go/runtime/mpagecache.go index 7206e2dbdb7..5bad4f789a1 100644 --- a/libgo/go/runtime/mpagecache.go +++ b/libgo/go/runtime/mpagecache.go @@ -143,7 +143,7 @@ func (p *pageAlloc) allocToCache() pageCache { if addr == 0 { // We failed to find adequate free space, so mark the searchAddr as OoM // and return an empty pageCache. - p.searchAddr = maxSearchAddr + p.searchAddr = maxSearchAddr() return pageCache{} } ci := chunkIndex(addr) diff --git a/libgo/go/runtime/signal_gccgo.go b/libgo/go/runtime/signal_gccgo.go index 2eece687e35..82e6996ab7e 100644 --- a/libgo/go/runtime/signal_gccgo.go +++ b/libgo/go/runtime/signal_gccgo.go @@ -106,7 +106,8 @@ func getsig(i uint32) uintptr { if sigaction(i, nil, &sa) < 0 { // On GNU/Linux glibc rejects attempts to call // sigaction with signal 32 (SIGCANCEL) or 33 (SIGSETXID). - if GOOS == "linux" && (i == 32 || i == 33) { + // On musl signal 34 (SIGSYNCCALL) also needs to be treated accordingly. + if GOOS == "linux" && (i == 32 || i == 33 || i == 34) { return _SIG_DFL } throw("sigaction read failure") diff --git a/libgo/match.sh b/libgo/match.sh index 139d0cdbe64..7ed587ff794 100755 --- a/libgo/match.sh +++ b/libgo/match.sh @@ -100,7 +100,7 @@ fi gobuild() { line=$(echo "$1" | sed -e 's|//go:build ||') - line=$(echo "$line" | sed -e 's/go1\.[0-9]\+/1/g' -e 's/goexperiment\./goexperiment/') + line=$(echo "$line" | sed -e 's/go1\.[0-9][0-9]*/1/g' -e 's/goexperiment\./goexperiment/') line=" $line " wrap='[ ()!&|]' for ones in $goarch $goos $cgotag $cmdlinetag gccgo goexperimentfieldtrack; do diff --git a/libgo/mksigtab.sh b/libgo/mksigtab.sh index 11e4ec436bd..bea8739957e 100644 --- a/libgo/mksigtab.sh +++ b/libgo/mksigtab.sh @@ -26,7 +26,6 @@ SIGLIST="" # Handle signals valid on all Unix systems. addsig() { - echo " $1: $2," # Get the signal number and add it to SIGLIST signum=`grep "const $1 = " gen-sysinfo.go | sed -e 's/.* = //'` if echo "$signum" | grep '^_SIG[A-Z0-9_]*$' >/dev/null 2>&1; then @@ -34,7 +33,12 @@ addsig() { # This is needed for some MIPS signals defined as aliases of other signals signum=`grep "const $signum = " gen-sysinfo.go | sed -e 's/.* = //'` fi - SIGLIST=$SIGLIST"_${signum}_" + # Only add signal if the signal number isn't in the list yet. + # For example, musl libc uses signal 29 for both SIGIO and SIGPOLL. + if ! echo "$SIGLIST" | grep "_${signum}_" >/dev/null 2>&1; then + echo " $1: $2," + SIGLIST=$SIGLIST"_${signum}_" + fi } echo ' 0: {0, "SIGNONE: no trap"},' @@ -95,10 +99,12 @@ checksig _SIGLOST ' {_SigNotify, "SIGLOST: resource lost (Sun); server died (G # Special handling of signals 32 and 33 on GNU/Linux systems, # because they are special to glibc. +# Signal 34 is additionally special to Linux systems with musl. if test "${GOOS}" = "linux"; then - SIGLIST=$SIGLIST"_32__33_" + SIGLIST=$SIGLIST"_32__33__34_" echo ' 32: {_SigSetStack + _SigUnblock, "signal 32"}, /* SIGCANCEL; see issue 6997 */' echo ' 33: {_SigSetStack + _SigUnblock, "signal 33"}, /* SIGSETXID; see issues 3871, 9400, 12498 */' + echo ' 34: {_SigSetStack + _SigUnblock, "signal 34"}, /* musl SIGSYNCCALL; see issue 39343 */' fi if test "${GOOS}" = "aix"; then diff --git a/libgo/runtime/go-signal.c b/libgo/runtime/go-signal.c index 9c919e1568a..528d9b6d9fe 100644 --- a/libgo/runtime/go-signal.c +++ b/libgo/runtime/go-signal.c @@ -230,15 +230,14 @@ getSiginfo(siginfo_t *info, void *context __attribute__((unused))) ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[REG_EIP]; #elif defined(__alpha__) && defined(__linux__) ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.sc_pc; +#elif defined(__PPC64__) && defined(__linux__) + ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gp_regs[32]; #elif defined(__PPC__) && defined(__linux__) - // For some reason different libc implementations use - // different names. -#if defined(__PPC64__) || defined(__GLIBC__) - ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.regs->nip; -#else - // Assumed to be ppc32 musl. +# if defined(__GLIBC__) + ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.uc_regs->gregs[32]; +# else ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.gregs[32]; -#endif +# endif #elif defined(__PPC__) && defined(_AIX) ret.sigpc = ((ucontext_t*)(context))->uc_mcontext.jmp_context.iar; #elif defined(__aarch64__) && defined(__linux__) @@ -349,30 +348,37 @@ dumpregs(siginfo_t *info __attribute__((unused)), void *context __attribute__((u runtime_printf("sp %X\n", m->sc_regs[30]); runtime_printf("pc %X\n", m->sc_pc); } -#elif defined(__PPC__) && defined(__LITTLE_ENDIAN__) && defined(__linux__) +#elif defined(__PPC__) && defined(__linux__) { - mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext; int i; -#if defined(__PPC64__) || defined(__GLIBC__) +# if defined(__PPC64__) + mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext; + for (i = 0; i < 32; i++) - runtime_printf("r%d %X\n", i, m->regs->gpr[i]); - runtime_printf("pc %X\n", m->regs->nip); - runtime_printf("msr %X\n", m->regs->msr); - runtime_printf("cr %X\n", m->regs->ccr); - runtime_printf("lr %X\n", m->regs->link); - runtime_printf("ctr %X\n", m->regs->ctr); - runtime_printf("xer %X\n", m->regs->xer); -#else + runtime_printf("r%d %X\n", i, m->gp_regs[i]); + runtime_printf("pc %X\n", m->gp_regs[32]); + runtime_printf("msr %X\n", m->gp_regs[33]); + runtime_printf("cr %X\n", m->gp_regs[38]); + runtime_printf("lr %X\n", m->gp_regs[36]); + runtime_printf("ctr %X\n", m->gp_regs[35]); + runtime_printf("xer %X\n", m->gp_regs[37]); +# else +# if defined(__GLIBC__) + mcontext_t *m = ((ucontext_t*)(context))->uc_mcontext.uc_regs; +# else + mcontext_t *m = &((ucontext_t*)(context))->uc_mcontext; +# endif + for (i = 0; i < 32; i++) - runtime_printf("r%d %X\n", i, m->gregs[i]); - runtime_printf("pc %X\n", m->gregs[32]); - runtime_printf("msr %X\n", m->gregs[33]); - runtime_printf("cr %X\n", m->gregs[38]); - runtime_printf("lr %X\n", m->gregs[36]); - runtime_printf("ctr %X\n", m->gregs[35]); - runtime_printf("xer %X\n", m->gregs[37]); -#endif + runtime_printf("r%d %x\n", i, m->gregs[i]); + runtime_printf("pc %x\n", m->gregs[32]); + runtime_printf("msr %x\n", m->gregs[33]); + runtime_printf("cr %x\n", m->gregs[38]); + runtime_printf("lr %x\n", m->gregs[36]); + runtime_printf("ctr %x\n", m->gregs[35]); + runtime_printf("xer %x\n", m->gregs[37]); +# endif } #elif defined(__PPC__) && defined(_AIX) { diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index f8091c1516d..1b36447f0c4 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,35 @@ +2022-04-26 Jakub Jelinek <jakub@redhat.com> + + PR libgomp/105358 + * work.c (gomp_init_work_share): Don't mask of adjustment for + dynamic long long realignment if struct gomp_work_share has smaller + alignof than long long. + * loop.c (GOMP_loop_start): Don't use inline_ordered_team_ids if + struct gomp_work_share has smaller alignof than long long or if + sizeof (struct gomp_work_share) is smaller than + INLINE_ORDERED_TEAM_IDS_OFF. + * loop_ull.c (GOMP_loop_ull_start): Likewise. + * sections.c (GOMP_sections2_start): Likewise. + +2022-04-25 Jakub Jelinek <jakub@redhat.com> + Thomas Schwinge <thomas@codesourcery.com> + + PR fortran/104717 + * testsuite/libgomp.oacc-fortran/privatized-ref-2.f90: Adjust. + +2022-04-13 Jakub Jelinek <jakub@redhat.com> + + * libgomp.texi: Fix a typo - mutexinouset -> mutexinoutset. + +2022-04-06 Thomas Schwinge <thomas@codesourcery.com> + + * plugin/cuda/cuda.h: Remove file. + * plugin/plugin-nvptx.c [PLUGIN_NVPTX_DYNAMIC]: Include + "cuda/cuda.h" instead of <cuda.h>. + * plugin/configfrag.ac <PLUGIN_NVPTX_DYNAMIC>: Don't set + 'PLUGIN_NVPTX_CPPFLAGS'. + * configure: Regenerate. + 2022-04-05 Chung-Lin Tang <cltang@codesourcery.com> * testsuite/libgomp.fortran/use_device_ptr-4.f90: New testcase. diff --git a/libgomp/configure b/libgomp/configure index bdbe3d142d1..5ef071ea046 100755 --- a/libgomp/configure +++ b/libgomp/configure @@ -15362,7 +15362,6 @@ rm -f core conftest.err conftest.$ac_objext \ && (test "x$CUDA_DRIVER_LIB" = x \ || test "x$CUDA_DRIVER_LIB" = xno); then PLUGIN_NVPTX=1 - PLUGIN_NVPTX_CPPFLAGS='-I$(srcdir)/plugin/cuda' PLUGIN_NVPTX_LIBS='-ldl' PLUGIN_NVPTX_DYNAMIC=1 else diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi index fcabd6e3e10..c10d0cbb6a1 100644 --- a/libgomp/libgomp.texi +++ b/libgomp/libgomp.texi @@ -214,7 +214,7 @@ The OpenMP 4.5 specification is fully supported. and @code{taskloop simd} constructs @tab Y @tab @item @code{taskloop} construct cancelable by @code{cancel} construct @tab Y @tab -@item @code{mutexinouset} @emph{dependence-type} for @code{depend} clause +@item @code{mutexinoutset} @emph{dependence-type} for @code{depend} clause @tab Y @tab @item Predefined memory spaces, memory allocators, allocator traits @tab Y @tab Some are only stubs diff --git a/libgomp/loop.c b/libgomp/loop.c index 682df39a4ed..be85162bb1e 100644 --- a/libgomp/loop.c +++ b/libgomp/loop.c @@ -270,8 +270,11 @@ GOMP_loop_start (long start, long end, long incr, long sched, #define INLINE_ORDERED_TEAM_IDS_OFF \ ((offsetof (struct gomp_work_share, inline_ordered_team_ids) \ + __alignof__ (long long) - 1) & ~(__alignof__ (long long) - 1)) - if (size > (sizeof (struct gomp_work_share) - - INLINE_ORDERED_TEAM_IDS_OFF)) + if (sizeof (struct gomp_work_share) + <= INLINE_ORDERED_TEAM_IDS_OFF + || __alignof__ (struct gomp_work_share) < __alignof__ (long long) + || size > (sizeof (struct gomp_work_share) + - INLINE_ORDERED_TEAM_IDS_OFF)) *mem = (void *) (thr->ts.work_share->ordered_team_ids = gomp_malloc_cleared (size)); diff --git a/libgomp/loop_ull.c b/libgomp/loop_ull.c index 2aaa34e3bca..602737296d4 100644 --- a/libgomp/loop_ull.c +++ b/libgomp/loop_ull.c @@ -269,8 +269,11 @@ GOMP_loop_ull_start (bool up, gomp_ull start, gomp_ull end, #define INLINE_ORDERED_TEAM_IDS_OFF \ ((offsetof (struct gomp_work_share, inline_ordered_team_ids) \ + __alignof__ (long long) - 1) & ~(__alignof__ (long long) - 1)) - if (size > (sizeof (struct gomp_work_share) - - INLINE_ORDERED_TEAM_IDS_OFF)) + if (sizeof (struct gomp_work_share) + <= INLINE_ORDERED_TEAM_IDS_OFF + || __alignof__ (struct gomp_work_share) < __alignof__ (long long) + || size > (sizeof (struct gomp_work_share) + - INLINE_ORDERED_TEAM_IDS_OFF)) *mem = (void *) (thr->ts.work_share->ordered_team_ids = gomp_malloc_cleared (size)); diff --git a/libgomp/plugin/configfrag.ac b/libgomp/plugin/configfrag.ac index 9f9d0a7f08c..09f87f48bc7 100644 --- a/libgomp/plugin/configfrag.ac +++ b/libgomp/plugin/configfrag.ac @@ -197,7 +197,6 @@ if test x"$enable_offload_targets" != x; then && (test "x$CUDA_DRIVER_LIB" = x \ || test "x$CUDA_DRIVER_LIB" = xno); then PLUGIN_NVPTX=1 - PLUGIN_NVPTX_CPPFLAGS='-I$(srcdir)/plugin/cuda' PLUGIN_NVPTX_LIBS='-ldl' PLUGIN_NVPTX_DYNAMIC=1 else diff --git a/libgomp/plugin/plugin-nvptx.c b/libgomp/plugin/plugin-nvptx.c index b4f0a84d77a..b28dfca00fa 100644 --- a/libgomp/plugin/plugin-nvptx.c +++ b/libgomp/plugin/plugin-nvptx.c @@ -41,7 +41,11 @@ #include "oacc-int.h" #include <pthread.h> -#include <cuda.h> +#if PLUGIN_NVPTX_DYNAMIC +# include "cuda/cuda.h" +#else +# include <cuda.h> +#endif #include <stdbool.h> #include <limits.h> #include <string.h> diff --git a/libgomp/sections.c b/libgomp/sections.c index e9d99e434ac..7751d5aac83 100644 --- a/libgomp/sections.c +++ b/libgomp/sections.c @@ -121,8 +121,11 @@ GOMP_sections2_start (unsigned count, uintptr_t *reductions, void **mem) #define INLINE_ORDERED_TEAM_IDS_OFF \ ((offsetof (struct gomp_work_share, inline_ordered_team_ids) \ + __alignof__ (long long) - 1) & ~(__alignof__ (long long) - 1)) - if (size > (sizeof (struct gomp_work_share) - - INLINE_ORDERED_TEAM_IDS_OFF)) + if (sizeof (struct gomp_work_share) + <= INLINE_ORDERED_TEAM_IDS_OFF + || __alignof__ (struct gomp_work_share) < __alignof__ (long long) + || size > (sizeof (struct gomp_work_share) + - INLINE_ORDERED_TEAM_IDS_OFF)) *mem = (void *) (thr->ts.work_share->ordered_team_ids = gomp_malloc_cleared (size)); diff --git a/libgomp/testsuite/libgomp.oacc-fortran/print-1.f90 b/libgomp/testsuite/libgomp.oacc-fortran/print-1.f90 index 7b7f73741fe..42a8538e1fb 100644 --- a/libgomp/testsuite/libgomp.oacc-fortran/print-1.f90 +++ b/libgomp/testsuite/libgomp.oacc-fortran/print-1.f90 @@ -6,11 +6,39 @@ ! Separate file 'print-1-nvptx.f90' for nvptx offloading. ! { dg-skip-if "separate file" { offload_target_nvptx } } +! For GCN offloading compilation, when gang-privatizing 'dt_parm.N' +! (see below), we run into an 'gang-private data-share memory exhausted' +! error: the default '-mgang-private-size' is too small. Per +! 'gcc/fortran/trans-io.cc'/'libgfortran/io/io.h', that one is +! 'struct st_parameter_dt', which indeed is rather big. Instead of +! working out its exact size (which may vary per GCC configuration), +! raise '-mgang-private-size' to an arbitrary high value. +! { dg-additional-options "-foffload-options=amdgcn-amdhsa=-mgang-private-size=13579" { target openacc_radeon_accel_selected } } + +! { dg-additional-options "-fopt-info-note-omp" } +! { dg-additional-options "-foffload=-fopt-info-note-omp" } + +! { dg-additional-options "--param=openacc-privatization=noisy" } +! { dg-additional-options "-foffload=--param=openacc-privatization=noisy" } +! Prune a few: uninteresting, and potentially varying depending on GCC configuration (data types): +! { dg-prune-output {note: variable 'D\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} } */ + +! It's only with Tcl 8.5 (released in 2007) that "the variable 'varName' +! passed to 'incr' may be unset, and in that case, it will be set to [...]", +! so to maintain compatibility with earlier Tcl releases, we manually +! initialize counter variables: +! { dg-line l_dummy[variable c_compute 0] } +! { dg-message dummy {} { target iN-VAl-Id } l_dummy } to avoid +! "WARNING: dg-line var l_dummy defined, but not used". + program main implicit none integer :: var = 42 -!$acc parallel +!$acc parallel ! { dg-line l_compute[incr c_compute] } + ! { dg-note {variable 'dt_parm\.[0-9]+' declared in block is candidate for adjusting OpenACC privatization level} {} { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'dt_parm\.[0-9]+' ought to be adjusted for OpenACC privatization level: 'gang'} {} { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'dt_parm\.[0-9]+' adjusted for OpenACC privatization level: 'gang'} {} { target { ! openacc_host_selected } } l_compute$c_compute } write (0, '("The answer is ", I2)') var !$acc end parallel diff --git a/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90 b/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90 index 1d91e115d9f..b31f4066152 100644 --- a/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90 +++ b/libgomp/testsuite/libgomp.oacc-fortran/privatized-ref-2.f90 @@ -53,6 +53,9 @@ contains integer :: array(nn) !$acc parallel copyout(array) ! { dg-line l_compute[incr c_compute] } + ! { dg-note {variable 'atmp\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'shadow_loopvar\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'offset\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } ! { dg-note {variable 'S\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } array = [(-i, i = 1, nn)] !$acc end parallel @@ -81,6 +84,10 @@ contains integer :: array(:) !$acc parallel copyout(array) ! { dg-line l_compute[incr c_compute] } + ! { dg-note {variable 'atmp\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'parm\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'shadow_loopvar\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } + ! { dg-note {variable 'offset\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } ! { dg-note {variable 'S\.[0-9]+' declared in block isn't candidate for adjusting OpenACC privatization level: not addressable} "" { target *-*-* } l_compute$c_compute } array = [(-2*i, i = 1, size(array))] !$acc end parallel diff --git a/libgomp/work.c b/libgomp/work.c index a88409dc78b..c53625afe2c 100644 --- a/libgomp/work.c +++ b/libgomp/work.c @@ -113,7 +113,9 @@ gomp_init_work_share (struct gomp_work_share *ws, size_t ordered, size_t o = nthreads * sizeof (*ws->ordered_team_ids); o += __alignof__ (long long) - 1; if ((offsetof (struct gomp_work_share, inline_ordered_team_ids) - & (__alignof__ (long long) - 1)) == 0) + & (__alignof__ (long long) - 1)) == 0 + && __alignof__ (struct gomp_work_share) + >= __alignof__ (long long)) o &= ~(__alignof__ (long long) - 1); ordered += o - 1; } diff --git a/libphobos/ChangeLog b/libphobos/ChangeLog index 4b227d6c310..0a9d916ee18 100644 --- a/libphobos/ChangeLog +++ b/libphobos/ChangeLog @@ -1,3 +1,20 @@ +2022-04-26 Iain Buclaw <ibuclaw@gdcproject.org> + + * libdruntime/gcc/emutls.d (emutlsDestroyThread): Clear the per-thread + TLS array, don't call free(). + +2022-04-21 Iain Buclaw <ibuclaw@gdcproject.org> + + * libdruntime/MERGE: Merge upstream druntime 27834edb. + * src/MERGE: Merge upstream phobos ac296f80c. + * src/Makefile.am (PHOBOS_DSOURCES): Add std/int128.d. + * src/Makefile.in: Regenerate. + +2022-04-13 Iain Buclaw <ibuclaw@gdcproject.org> + + * libdruntime/MERGE: Merge upstream druntime 9ba9a6ae. + * src/MERGE: Merge upstream phobos c0cc5e917. + 2022-04-02 Iain Buclaw <ibuclaw@gdcproject.org> * libdruntime/MERGE: Merge upstream druntime c52e28b7. diff --git a/libphobos/libdruntime/MERGE b/libphobos/libdruntime/MERGE index b1da32e43e1..c94634f4770 100644 --- a/libphobos/libdruntime/MERGE +++ b/libphobos/libdruntime/MERGE @@ -1,4 +1,4 @@ -c52e28b723ccfbe845a95e8e7b528e3cc0b9d790 +e361d200b287a68344095f306cf5ea3a63c080e1 The first line of this file holds the git revision number of the last merge done from the dlang/druntime repository. diff --git a/libphobos/libdruntime/core/exception.d b/libphobos/libdruntime/core/exception.d index a6928660773..81aa43b27d0 100644 --- a/libphobos/libdruntime/core/exception.d +++ b/libphobos/libdruntime/core/exception.d @@ -19,29 +19,6 @@ void __switch_errorT()(string file = __FILE__, size_t line = __LINE__) @trusted assert(0, "No appropriate switch clause found"); } -version (D_BetterC) -{ - // When compiling with -betterC we use template functions so if they are - // used the bodies are copied into the user's program so there is no need - // for the D runtime during linking. - - // In the future we might want to convert all functions in this module to - // templates even for ordinary builds instead of providing them as an - // extern(C) library. - - void onOutOfMemoryError()(void* pretend_sideffect = null) @nogc nothrow pure @trusted - { - assert(0, "Memory allocation failed"); - } - alias onOutOfMemoryErrorNoGC = onOutOfMemoryError; - - void onInvalidMemoryOperationError()(void* pretend_sideffect = null) @nogc nothrow pure @trusted - { - assert(0, "Invalid memory operation"); - } -} -else: - /** * Thrown on a range error. */ @@ -218,17 +195,17 @@ private void rangeMsgPut(ref char[] r, scope const(char)[] e) @nogc nothrow pure */ class AssertError : Error { - @safe pure nothrow this( string file, size_t line ) + @safe pure nothrow @nogc this( string file, size_t line ) { this(cast(Throwable)null, file, line); } - @safe pure nothrow this( Throwable next, string file = __FILE__, size_t line = __LINE__ ) + @safe pure nothrow @nogc this( Throwable next, string file = __FILE__, size_t line = __LINE__ ) { this( "Assertion failure", file, line, next); } - @safe pure nothrow this( string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null ) + @safe pure nothrow @nogc this( string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null ) { super( msg, file, line, next ); } @@ -692,26 +669,49 @@ extern (C) void onFinalizeError( TypeInfo info, Throwable e, string file = __FIL throw staticError!FinalizeError(info, e, file, line); } -/** - * A callback for out of memory errors in D. An $(LREF OutOfMemoryError) will be - * thrown. - * - * Throws: - * $(LREF OutOfMemoryError). - */ -extern (C) void onOutOfMemoryError(void* pretend_sideffect = null) @trusted pure nothrow @nogc /* dmd @@@BUG11461@@@ */ +version (D_BetterC) { - // NOTE: Since an out of memory condition exists, no allocation must occur - // while generating this object. - throw staticError!OutOfMemoryError(); -} + // When compiling with -betterC we use template functions so if they are + // used the bodies are copied into the user's program so there is no need + // for the D runtime during linking. -extern (C) void onOutOfMemoryErrorNoGC() @trusted nothrow @nogc -{ - // suppress stacktrace until they are @nogc - throw staticError!OutOfMemoryError(false); + // In the future we might want to convert all functions in this module to + // templates even for ordinary builds instead of providing them as an + // extern(C) library. + + void onOutOfMemoryError()(void* pretend_sideffect = null) @nogc nothrow pure @trusted + { + assert(0, "Memory allocation failed"); + } + alias onOutOfMemoryErrorNoGC = onOutOfMemoryError; + + void onInvalidMemoryOperationError()(void* pretend_sideffect = null) @nogc nothrow pure @trusted + { + assert(0, "Invalid memory operation"); + } } +else +{ + /** + * A callback for out of memory errors in D. An $(LREF OutOfMemoryError) will be + * thrown. + * + * Throws: + * $(LREF OutOfMemoryError). + */ + extern (C) void onOutOfMemoryError(void* pretend_sideffect = null) @trusted pure nothrow @nogc /* dmd @@@BUG11461@@@ */ + { + // NOTE: Since an out of memory condition exists, no allocation must occur + // while generating this object. + throw staticError!OutOfMemoryError(); + } + extern (C) void onOutOfMemoryErrorNoGC() @trusted nothrow @nogc + { + // suppress stacktrace until they are @nogc + throw staticError!OutOfMemoryError(false); + } +} /** * A callback for invalid memory operations in D. An diff --git a/libphobos/libdruntime/core/int128.d b/libphobos/libdruntime/core/int128.d index 2f628c03138..e4326fd54c3 100644 --- a/libphobos/libdruntime/core/int128.d +++ b/libphobos/libdruntime/core/int128.d @@ -18,15 +18,26 @@ alias I = long; alias U = ulong; enum Ubits = uint(U.sizeof * 8); -align(16) struct Cent +version (X86_64) private enum Cent_alignment = 16; +else private enum Cent_alignment = (size_t.sizeof * 2); + +align(Cent_alignment) struct Cent { - U lo; // low 64 bits - U hi; // high 64 bits + version (LittleEndian) + { + U lo; // low 64 bits + U hi; // high 64 bits + } + else + { + U hi; // high 64 bits + U lo; // low 64 bits + } } -enum One = Cent(1); -enum Zero = Cent(); -enum MinusOne = neg(One); +enum Cent One = { lo:1 }; +enum Cent Zero = { lo:0 }; +enum Cent MinusOne = neg(One); /***************************** * Test against 0 @@ -320,7 +331,8 @@ Cent ror(Cent c, uint n) pure Cent and(Cent c1, Cent c2) { - return Cent(c1.lo & c2.lo, c1.hi & c2.hi); + const Cent ret = { lo:c1.lo & c2.lo, hi:c1.hi & c2.hi }; + return ret; } /**************************** @@ -334,7 +346,8 @@ Cent and(Cent c1, Cent c2) pure Cent or(Cent c1, Cent c2) { - return Cent(c1.lo | c2.lo, c1.hi | c2.hi); + const Cent ret = { lo:c1.lo | c2.lo, hi:c1.hi | c2.hi }; + return ret; } /**************************** @@ -348,7 +361,8 @@ Cent or(Cent c1, Cent c2) pure Cent xor(Cent c1, Cent c2) { - return Cent(c1.lo ^ c2.lo, c1.hi ^ c2.hi); + const Cent ret = { lo:c1.lo ^ c2.lo, hi:c1.hi ^ c2.hi }; + return ret; } /**************************** @@ -363,7 +377,8 @@ pure Cent add(Cent c1, Cent c2) { U r = cast(U)(c1.lo + c2.lo); - return Cent(r, cast(U)(c1.hi + c2.hi + (r < c1.lo))); + const Cent ret = { lo:r, hi:cast(U)(c1.hi + c2.hi + (r < c1.lo)) }; + return ret; } /**************************** @@ -419,9 +434,9 @@ Cent mul(Cent c1, Cent c2) const c1h1 = c1.hi >> mulshift; r3 = c1h1 * c2l0 + (r3 & mulmask); - return Cent((r0 & mulmask) + (r1 & mulmask) * (mulmask + 1), - (r2 & mulmask) + (r3 & mulmask) * (mulmask + 1)); - + const Cent ret = { lo:(r0 & mulmask) + (r1 & mulmask) * (mulmask + 1), + hi:(r2 & mulmask) + (r3 & mulmask) * (mulmask + 1) }; + return ret; } @@ -523,8 +538,10 @@ Cent udivmod(Cent c1, Cent c2, out Cent modulus) if (c1.hi == 0 && c2.hi == 0) { // Single precision divide - modulus = Cent(c1.lo % c2.lo); - return Cent(c1.lo / c2.lo); + const Cent rem = { lo:c1.lo % c2.lo }; + modulus = rem; + const Cent ret = { lo:c1.lo / c2.lo }; + return ret; } if (c1.hi == 0) { @@ -539,10 +556,11 @@ Cent udivmod(Cent c1, Cent c2, out Cent modulus) const q1 = (c1.hi < c2.lo) ? 0 : (c1.hi / c2.lo); if (q1) c1.hi = c1.hi % c2.lo; - U rem; - const q0 = udivmod128_64(c1, c2.lo, rem); - modulus = Cent(rem); - return Cent(q0, q1); + Cent rem; + const q0 = udivmod128_64(c1, c2.lo, rem.lo); + modulus = rem; + const Cent ret = { lo:q0, hi:q1 }; + return ret; } // Full cent precision division. @@ -560,10 +578,10 @@ Cent udivmod(Cent c1, Cent c2, out Cent modulus) // Get quotient from divide unsigned operation. U rem_ignored; - const q1 = udivmod128_64(u1, v1, rem_ignored); + const Cent q1 = { lo:udivmod128_64(u1, v1, rem_ignored) }; // Undo normalization and division of c1 by 2. - Cent quotient = shr(shl(Cent(q1), shift), 63); + Cent quotient = shr(shl(q1, shift), 63); // Make quotient correct or too small by 1 if (tst(quotient)) @@ -770,44 +788,44 @@ version (unittest) unittest { - const C0 = Zero; - const C1 = One; - const C2 = Cent(2); - const C3 = Cent(3); - const C5 = Cent(5); - const C10 = Cent(10); - const C20 = Cent(20); - const C30 = Cent(30); - const C100 = Cent(100); - - const Cm1 = neg(One); - const Cm3 = neg(C3); - const Cm10 = neg(C10); - - const C3_1 = Cent(1,3); - const C3_2 = Cent(2,3); - const C4_8 = Cent(8, 4); - const C5_0 = Cent(0, 5); - const C7_1 = Cent(1,7); - const C7_9 = Cent(9,7); - const C9_3 = Cent(3,9); - const C10_0 = Cent(0,10); - const C10_1 = Cent(1,10); - const C10_3 = Cent(3,10); - const C11_3 = Cent(3,11); - const C20_0 = Cent(0,20); - const C90_30 = Cent(30,90); - - const Cm10_0 = inc(com(C10_0)); // Cent(0, -10); - const Cm10_1 = inc(com(C10_1)); // Cent(-1, -11); - const Cm10_3 = inc(com(C10_3)); // Cent(-3, -11); - const Cm20_0 = inc(com(C20_0)); // Cent(0, -20); - - enum Cs_3 = Cent(3, I.min); - - const Cbig_1 = Cent(0xa3ccac1832952398, 0xc3ac542864f652f8); - const Cbig_2 = Cent(0x5267b85f8a42fc20, 0); - const Cbig_3 = Cent(0xf0000000ffffffff, 0); + const Cent C0 = Zero; + const Cent C1 = One; + const Cent C2 = { lo:2 }; + const Cent C3 = { lo:3 }; + const Cent C5 = { lo:5 }; + const Cent C10 = { lo:10 }; + const Cent C20 = { lo:20 }; + const Cent C30 = { lo:30 }; + const Cent C100 = { lo:100 }; + + const Cent Cm1 = neg(One); + const Cent Cm3 = neg(C3); + const Cent Cm10 = neg(C10); + + const Cent C3_1 = { lo:1, hi:3 }; + const Cent C3_2 = { lo:2, hi:3 }; + const Cent C4_8 = { lo:8, hi:4 }; + const Cent C5_0 = { lo:0, hi:5 }; + const Cent C7_1 = { lo:1, hi:7 }; + const Cent C7_9 = { lo:9, hi:7 }; + const Cent C9_3 = { lo:3, hi:9 }; + const Cent C10_0 = { lo:0, hi:10 }; + const Cent C10_1 = { lo:1, hi:10 }; + const Cent C10_3 = { lo:3, hi:10 }; + const Cent C11_3 = { lo:3, hi:11 }; + const Cent C20_0 = { lo:0, hi:20 }; + const Cent C90_30 = { lo:30, hi:90 }; + + const Cent Cm10_0 = inc(com(C10_0)); // Cent(lo=0, hi=-10); + const Cent Cm10_1 = inc(com(C10_1)); // Cent(lo=-1, hi=-11); + const Cent Cm10_3 = inc(com(C10_3)); // Cent(lo=-3, hi=-11); + const Cent Cm20_0 = inc(com(C20_0)); // Cent(lo=0, hi=-20); + + enum Cent Cs_3 = { lo:3, hi:I.min }; + + const Cent Cbig_1 = { lo:0xa3ccac1832952398, hi:0xc3ac542864f652f8 }; + const Cent Cbig_2 = { lo:0x5267b85f8a42fc20, hi:0 }; + const Cent Cbig_3 = { lo:0xf0000000ffffffff, hi:0 }; /************************/ @@ -893,12 +911,20 @@ unittest assert(div(mul(C90_30, C2), C2) == C90_30); assert(div(mul(C90_30, C2), C90_30) == C2); - assert(divmod(Cbig_1, Cbig_2, modulus) == Cent(0x4496aa309d4d4a2f, U.max)); - assert(modulus == Cent(0xd83203d0fdc799b8, U.max)); - assert(udivmod(Cbig_1, Cbig_2, modulus) == Cent(0x5fe0e9bace2bedad, 2)); - assert(modulus == Cent(0x2c923125a68721f8, 0)); - assert(div(Cbig_1, Cbig_3) == Cent(0xbfa6c02b5aff8b86, U.max)); - assert(udiv(Cbig_1, Cbig_3) == Cent(0xd0b7d13b48cb350f, 0)); + const Cent Cb1divb2 = { lo:0x4496aa309d4d4a2f, hi:U.max }; + const Cent Cb1modb2 = { lo:0xd83203d0fdc799b8, hi:U.max }; + assert(divmod(Cbig_1, Cbig_2, modulus) == Cb1divb2); + assert(modulus == Cb1modb2); + + const Cent Cb1udivb2 = { lo:0x5fe0e9bace2bedad, hi:2 }; + const Cent Cb1umodb2 = { lo:0x2c923125a68721f8, hi:0 }; + assert(udivmod(Cbig_1, Cbig_2, modulus) == Cb1udivb2); + assert(modulus == Cb1umodb2); + + const Cent Cb1divb3 = { lo:0xbfa6c02b5aff8b86, hi:U.max }; + const Cent Cb1udivb3 = { lo:0xd0b7d13b48cb350f, hi:0 }; + assert(div(Cbig_1, Cbig_3) == Cb1divb3); + assert(udiv(Cbig_1, Cbig_3) == Cb1udivb3); assert(mul(Cm10, C1) == Cm10); assert(mul(C1, Cm10) == Cm10); diff --git a/libphobos/libdruntime/core/lifetime.d b/libphobos/libdruntime/core/lifetime.d index 3a7c8e02b8a..47fed9dc514 100644 --- a/libphobos/libdruntime/core/lifetime.d +++ b/libphobos/libdruntime/core/lifetime.d @@ -1273,7 +1273,9 @@ void copyEmplace(S, T)(ref S source, ref T target) @system } else static if (__traits(hasCopyConstructor, T)) { - emplace(cast(Unqual!(T)*) &target); // blit T.init + // https://issues.dlang.org/show_bug.cgi?id=22766 + import core.internal.lifetime : emplaceInitializer; + emplaceInitializer(*(cast(Unqual!T*)&target)); static if (__traits(isNested, T)) { // copy context pointer @@ -1373,6 +1375,22 @@ void copyEmplace(S, T)(ref S source, ref T target) @system static assert(!__traits(compiles, copyEmplace(ss, t))); } +// https://issues.dlang.org/show_bug.cgi?id=22766 +@system pure nothrow @nogc unittest +{ + static struct S + { + @disable this(); + this(int) @safe pure nothrow @nogc{} + this(ref const(S) other) @safe pure nothrow @nogc {} + } + + S s1 = S(1); + S s2 = void; + copyEmplace(s1, s2); + assert(s2 == S(1)); +} + version (DigitalMars) version (X86) version (Posix) version = DMD_X86_Posix; // don't violate immutability for reference types diff --git a/libphobos/libdruntime/gcc/emutls.d b/libphobos/libdruntime/gcc/emutls.d index 6d9fb309a30..ee3603206b6 100644 --- a/libphobos/libdruntime/gcc/emutls.d +++ b/libphobos/libdruntime/gcc/emutls.d @@ -223,9 +223,9 @@ void** emutlsAlloc(shared __emutls_object* obj) nothrow @nogc } /* - * When a thread has finished, remove the TLS array from the GC - * scan list emutlsArrays, free all allocated TLS variables and - * finally free the array. + * When a thread has finished, free all allocated TLS variables and empty the + * array. The pointer is not free'd as it is stil referenced by the GC scan + * list emutlsArrays, which gets destroyed when druntime is unloaded. */ extern (C) void emutlsDestroyThread(void* ptr) nothrow @nogc { @@ -237,7 +237,7 @@ extern (C) void emutlsDestroyThread(void* ptr) nothrow @nogc free(entry[-1]); } - free(arr); + arr.length = 0; } /* diff --git a/libphobos/libdruntime/object.d b/libphobos/libdruntime/object.d index a15616c6e0f..e58afa2f985 100644 --- a/libphobos/libdruntime/object.d +++ b/libphobos/libdruntime/object.d @@ -2830,8 +2830,8 @@ extern (C) private struct AA { void* impl; } // size_t _aaLen(in AA aa) pure nothrow @nogc; - private void* _aaGetY(AA* paa, const TypeInfo_AssociativeArray ti, const size_t valsz, const scope void* pkey) pure nothrow; - private void* _aaGetX(AA* paa, const TypeInfo_AssociativeArray ti, const size_t valsz, const scope void* pkey, out bool found) pure nothrow; + private void* _aaGetY(scope AA* paa, const TypeInfo_AssociativeArray ti, const size_t valsz, const scope void* pkey) pure nothrow; + private void* _aaGetX(scope AA* paa, const TypeInfo_AssociativeArray ti, const size_t valsz, const scope void* pkey, out bool found) pure nothrow; // inout(void)* _aaGetRvalueX(inout AA aa, in TypeInfo keyti, in size_t valsz, in void* pkey); inout(void[]) _aaValues(inout AA aa, const size_t keysz, const size_t valsz, const TypeInfo tiValueArray) pure nothrow; inout(void[]) _aaKeys(inout AA aa, const size_t keysz, const TypeInfo tiKeyArray) pure nothrow; diff --git a/libphobos/libdruntime/rt/aaA.d b/libphobos/libdruntime/rt/aaA.d index 0c38622a879..ab93f191634 100644 --- a/libphobos/libdruntime/rt/aaA.d +++ b/libphobos/libdruntime/rt/aaA.d @@ -504,7 +504,7 @@ extern (C) size_t _aaLen(scope const AA aa) pure nothrow @nogc * If key was not in the aa, a mutable pointer to newly inserted value which * is set to all zeros */ -extern (C) void* _aaGetY(AA* paa, const TypeInfo_AssociativeArray ti, +extern (C) void* _aaGetY(scope AA* paa, const TypeInfo_AssociativeArray ti, const size_t valsz, scope const void* pkey) { bool found; @@ -525,7 +525,7 @@ extern (C) void* _aaGetY(AA* paa, const TypeInfo_AssociativeArray ti, * If key was not in the aa, a mutable pointer to newly inserted value which * is set to all zeros */ -extern (C) void* _aaGetX(AA* paa, const TypeInfo_AssociativeArray ti, +extern (C) void* _aaGetX(scope AA* paa, const TypeInfo_AssociativeArray ti, const size_t valsz, scope const void* pkey, out bool found) { // lazily alloc implementation diff --git a/libphobos/src/MERGE b/libphobos/src/MERGE index 7306c1071a1..3218ace50a0 100644 --- a/libphobos/src/MERGE +++ b/libphobos/src/MERGE @@ -1,4 +1,4 @@ -99e9c1b7741e0f4e6f2a8c14883c4828d092701d +ac296f80cda437483b743f953dc69cb1271c82df The first line of this file holds the git revision number of the last merge done from the dlang/phobos repository. diff --git a/libphobos/src/Makefile.am b/libphobos/src/Makefile.am index 75f83974e99..da7a2004ff8 100644 --- a/libphobos/src/Makefile.am +++ b/libphobos/src/Makefile.am @@ -130,7 +130,7 @@ PHOBOS_DSOURCES = etc/c/curl.d etc/c/zlib.d std/algorithm/comparison.d \ std/experimental/typecons.d std/file.d std/format/internal/floats.d \ std/format/internal/read.d std/format/internal/write.d \ std/format/package.d std/format/read.d std/format/spec.d \ - std/format/write.d std/functional.d std/getopt.d \ + std/format/write.d std/functional.d std/getopt.d std/int128.d \ std/internal/attributes.d std/internal/cstring.d \ std/internal/math/biguintcore.d std/internal/math/biguintnoasm.d \ std/internal/math/errorfunction.d std/internal/math/gammafunction.d \ diff --git a/libphobos/src/Makefile.in b/libphobos/src/Makefile.in index f2395e2caf7..6f58fee01ac 100644 --- a/libphobos/src/Makefile.in +++ b/libphobos/src/Makefile.in @@ -228,6 +228,7 @@ am__dirstamp = $(am__leading_dot)dirstamp @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/format/spec.lo \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/format/write.lo \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/functional.lo std/getopt.lo \ +@ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/int128.lo \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/internal/attributes.lo \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/internal/cstring.lo \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/internal/math/biguintcore.lo \ @@ -591,7 +592,7 @@ libgphobos_la_LINK = $(LIBTOOL) --tag=D $(libgphobos_la_LIBTOOLFLAGS) \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/experimental/typecons.d std/file.d std/format/internal/floats.d \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/format/internal/read.d std/format/internal/write.d \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/format/package.d std/format/read.d std/format/spec.d \ -@ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/format/write.d std/functional.d std/getopt.d \ +@ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/format/write.d std/functional.d std/getopt.d std/int128.d \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/internal/attributes.d std/internal/cstring.d \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/internal/math/biguintcore.d std/internal/math/biguintnoasm.d \ @ENABLE_LIBDRUNTIME_ONLY_FALSE@ std/internal/math/errorfunction.d std/internal/math/gammafunction.d \ @@ -846,6 +847,7 @@ std/format/spec.lo: std/format/$(am__dirstamp) std/format/write.lo: std/format/$(am__dirstamp) std/functional.lo: std/$(am__dirstamp) std/getopt.lo: std/$(am__dirstamp) +std/int128.lo: std/$(am__dirstamp) std/internal/$(am__dirstamp): @$(MKDIR_P) std/internal @: > std/internal/$(am__dirstamp) diff --git a/libphobos/src/etc/c/zlib.d b/libphobos/src/etc/c/zlib.d index a1b20fedce9..73c6534d8da 100644 --- a/libphobos/src/etc/c/zlib.d +++ b/libphobos/src/etc/c/zlib.d @@ -2,15 +2,16 @@ /* updated from 1.2.1 to 1.2.3 by Thomas Kuehne */ /* updated from 1.2.3 to 1.2.8 by Dmitry Atamanov */ /* updated from 1.2.8 to 1.2.11 by Iain Buclaw */ +/* updated from 1.2.11 to 1.2.12 by Brian Callahan */ module etc.c.zlib; import core.stdc.config; /* zlib.h -- interface of the 'zlib' general purpose compression library - version 1.2.11, January 15th, 2017 + version 1.2.12, March 11th, 2022 - Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler + Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages @@ -42,8 +43,8 @@ nothrow: extern (C): // Those are extern(D) as they should be mangled -extern(D) immutable string ZLIB_VERSION = "1.2.11"; -extern(D) immutable ZLIB_VERNUM = 0x12b0; +extern(D) immutable string ZLIB_VERSION = "1.2.12"; +extern(D) immutable ZLIB_VERNUM = 0x12c0; /* The 'zlib' compression library provides in-memory compression and @@ -566,8 +567,7 @@ int deflateInit2(z_streamp strm, } /* This is another version of deflateInit with more compression options. The - fields next_in, zalloc, zfree and opaque must be initialized before by the - caller. + fields zalloc, zfree and opaque must be initialized before by the caller. The method parameter is the compression method. It must be Z_DEFLATED in this version of the library. @@ -586,7 +586,7 @@ int deflateInit2(z_streamp strm, with deflateInit2() with this initialization, or at least in that case use 9 with inflateInit2(). - windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + windowBits can also be -8 .. -15 for raw deflate. In this case, -windowBits determines the window size. deflate() will then generate raw deflate data with no zlib header or trailer, and will not compute a check value. @@ -728,11 +728,12 @@ int deflateParams(z_streamp strm, int level, int strategy); used to switch between compression and straight copy of the input data, or to switch to a different kind of input data requiring a different strategy. If the compression approach (which is a function of the level) or the - strategy is changed, and if any input has been consumed in a previous - deflate() call, then the input available so far is compressed with the old - level and strategy using deflate(strm, Z_BLOCK). There are three approaches - for the compression levels 0, 1 .. 3, and 4 .. 9 respectively. The new level - and strategy will take effect at the next call of deflate(). + strategy is changed, and if there have been any deflate() calls since the + state was initialized or reset, then the input available so far is + compressed with the old level and strategy using deflate(strm, Z_BLOCK). + There are three approaches for the compression levels 0, 1 .. 3, and 4 .. 9 + respectively. The new level and strategy will take effect at the next call + of deflate(). If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does not have enough output space to complete, then the parameter change will not @@ -856,7 +857,7 @@ int inflateInit2(z_streamp strm, int windowBits) windowBits can also be zero to request that inflate use the window size in the zlib header of the compressed stream. - windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + windowBits can also be -8 .. -15 for raw inflate. In this case, -windowBits determines the window size. inflate() will then process raw deflate data, not looking for a zlib or gzip header, not generating a check value, and not looking for any check values for comparison at the end of the stream. This @@ -873,9 +874,11 @@ int inflateInit2(z_streamp strm, int windowBits) detection, or add 16 to decode only the gzip format (the zlib format will return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see - below), inflate() will not automatically decode concatenated gzip streams. - inflate() will return Z_STREAM_END at the end of the gzip stream. The state - would need to be reset to continue decoding a subsequent gzip stream. + below), inflate() will *not* automatically decode concatenated gzip members. + inflate() will return Z_STREAM_END at the end of the gzip member. The state + would need to be reset to continue decoding a subsequent gzip member. This + *must* be done if there is more data after a gzip member, in order for the + decompression to be compliant with the gzip standard (RFC 1952). inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_VERSION_ERROR if the zlib library version is incompatible with the @@ -1311,14 +1314,14 @@ alias z_size_t = size_t; gzFile gzopen(const(char)* path, const(char)* mode); /* - Opens a gzip (.gz) file for reading or writing. The mode parameter is as - in fopen ("rb" or "wb") but can also include a compression level ("wb9") or - a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only - compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' - for fixed code compression as in "wb9F". (See the description of - deflateInit2 for more information about the strategy parameter.) 'T' will - request transparent writing or appending with no compression and not using - the gzip format. + Open the gzip (.gz) file at path for reading and decompressing, or + compressing and writing. The mode parameter is as in fopen ("rb" or "wb") + but can also include a compression level ("wb9") or a strategy: 'f' for + filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h", + 'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression + as in "wb9F". (See the description of deflateInit2 for more information + about the strategy parameter.) 'T' will request transparent writing or + appending with no compression and not using the gzip format. "a" can be used instead of "w" to request that the gzip stream that will be written be appended to the file. "+" will result in an error, since @@ -1348,9 +1351,9 @@ gzFile gzopen(const(char)* path, const(char)* mode); gzFile gzdopen(int fd, const(char)* mode); /* - gzdopen associates a gzFile with the file descriptor fd. File descriptors - are obtained from calls like open, dup, creat, pipe or fileno (if the file - has been previously opened with fopen). The mode parameter is as in gzopen. + Associate a gzFile with the file descriptor fd. File descriptors are + obtained from calls like open, dup, creat, pipe or fileno (if the file has + been previously opened with fopen). The mode parameter is as in gzopen. The next call of gzclose on the returned gzFile will also close the file descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor @@ -1371,13 +1374,13 @@ gzFile gzdopen(int fd, const(char)* mode); int gzbuffer(gzFile file, uint size); /* - Set the internal buffer size used by this library's functions. The - default buffer size is 8192 bytes. This function must be called after - gzopen() or gzdopen(), and before any other calls that read or write the - file. The buffer memory allocation is always deferred to the first read or - write. Three times that size in buffer space is allocated. A larger buffer - size of, for example, 64K or 128K bytes will noticeably increase the speed - of decompression (reading). + Set the internal buffer size used by this library's functions for file to + size. The default buffer size is 8192 bytes. This function must be called + after gzopen() or gzdopen(), and before any other calls that read or write + the file. The buffer memory allocation is always deferred to the first read + or write. Three times that size in buffer space is allocated. A larger + buffer size of, for example, 64K or 128K bytes will noticeably increase the + speed of decompression (reading). The new buffer size also affects the maximum length for gzprintf(). @@ -1387,9 +1390,9 @@ int gzbuffer(gzFile file, uint size); int gzsetparams(gzFile file, int level, int strategy); /* - Dynamically update the compression level or strategy. See the description - of deflateInit2 for the meaning of these parameters. Previously provided - data is flushed before the parameter change. + Dynamically update the compression level and strategy for file. See the + description of deflateInit2 for the meaning of these parameters. Previously + provided data is flushed before applying the parameter changes. gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not opened for writing, Z_ERRNO if there is an error writing the flushed data, @@ -1398,7 +1401,7 @@ int gzsetparams(gzFile file, int level, int strategy); int gzread(gzFile file, void* buf, uint len); /* - Reads the given number of uncompressed bytes from the compressed file. If + Read and decompress up to len uncompressed bytes from file into buf. If the input file is not in gzip format, gzread copies the given number of bytes into the buffer directly from the file. @@ -1428,11 +1431,11 @@ int gzread(gzFile file, void* buf, uint len); z_size_t gzfread(void* buf, z_size_t size, z_size_t nitems, gzFile file); /* - Read up to nitems items of size size from file to buf, otherwise operating - as gzread() does. This duplicates the interface of stdio's fread(), with - size_t request and return types. If the library defines size_t, then - z_size_t is identical to size_t. If not, then z_size_t is an unsigned - integer type that can contain a pointer. + Read and decompress up to nitems items of size size from file into buf, + otherwise operating as gzread() does. This duplicates the interface of + stdio's fread(), with size_t request and return types. If the library + defines size_t, then z_size_t is identical to size_t. If not, then z_size_t + is an unsigned integer type that can contain a pointer. gzfread() returns the number of full items read of size size, or zero if the end of the file was reached and a full item could not be read, or if @@ -1453,14 +1456,13 @@ z_size_t gzfread(void* buf, z_size_t size, z_size_t nitems, gzFile file); int gzwrite(gzFile file, void* buf, uint len); /* - Writes the given number of uncompressed bytes into the compressed file. - gzwrite returns the number of uncompressed bytes written or 0 in case of - error. + Compress and write the len uncompressed bytes at buf to file. gzwrite + returns the number of uncompressed bytes written or 0 in case of error. */ z_size_t gzfwrite(void* buf, z_size_t size, z_size_t nitems, gzFile file); /* - gzfwrite() writes nitems items of size size from buf to file, duplicating + Compress and write nitems items of size size from buf to file, duplicating the interface of stdio's fwrite(), with size_t request and return types. If the library defines size_t, then z_size_t is identical to size_t. If not, then z_size_t is an unsigned integer type that can contain a pointer. @@ -1473,22 +1475,22 @@ z_size_t gzfwrite(void* buf, z_size_t size, z_size_t nitems, gzFile file); int gzprintf(gzFile file, const(char)* format, ...); /* - Converts, formats, and writes the arguments to the compressed file under - control of the format string, as in fprintf. gzprintf returns the number of + Convert, format, compress, and write the arguments (...) to file under + control of the string format, as in fprintf. gzprintf returns the number of uncompressed bytes actually written, or a negative zlib error code in case of error. The number of uncompressed bytes written is limited to 8191, or one less than the buffer size given to gzbuffer(). The caller should assure that this limit is not exceeded. If it is exceeded, then gzprintf() will return an error (0) with nothing written. In this case, there may also be a buffer overflow with unpredictable consequences, which is possible only if - zlib was compiled with the insecure functions sprintf() or vsprintf() + zlib was compiled with the insecure functions sprintf() or vsprintf(), because the secure snprintf() or vsnprintf() functions were not available. This can be determined using zlibCompileFlags(). */ int gzputs(gzFile file, const(char)* s); /* - Writes the given null-terminated string to the compressed file, excluding + Compress and write the given null-terminated string s to file, excluding the terminating null character. gzputs returns the number of characters written, or -1 in case of error. @@ -1496,11 +1498,12 @@ int gzputs(gzFile file, const(char)* s); const(char)* gzgets(gzFile file, const(char)* buf, int len); /* - Reads bytes from the compressed file until len-1 characters are read, or a - newline character is read and transferred to buf, or an end-of-file - condition is encountered. If any characters are read or if len == 1, the - string is terminated with a null character. If no characters are read due - to an end-of-file or len < 1, then the buffer is left untouched. + Read and decompress bytes from file into buf, until len-1 characters are + read, or until a newline character is read and transferred to buf, or an + end-of-file condition is encountered. If any characters are read or if len + is one, the string is terminated with a null character. If no characters + are read due to an end-of-file or len is less than one, then the buffer is + left untouched. gzgets returns buf which is a null-terminated string, or it returns NULL for end-of-file or in case of error. If there was an error, the contents at @@ -1509,13 +1512,13 @@ const(char)* gzgets(gzFile file, const(char)* buf, int len); int gzputc(gzFile file, int c); /* - Writes c, converted to an unsigned char, into the compressed file. gzputc + Compress and write c, converted to an unsigned char, into file. gzputc returns the value that was written, or -1 in case of error. */ int gzgetc(gzFile file); /* - Reads one byte from the compressed file. gzgetc returns this byte or -1 + Read and decompress one byte from file. gzgetc returns this byte or -1 in case of end of file or error. This is implemented as a macro for speed. As such, it does not do all of the checking the other functions do. I.e. it does not check to see if file is NULL, nor whether the structure file @@ -1524,8 +1527,8 @@ int gzgetc(gzFile file); int gzungetc(int c, gzFile file); /* - Push one character back onto the stream to be read as the first character - on the next read. At least one character of push-back is allowed. + Push c back onto the stream for file to be read as the first character on + the next read. At least one character of push-back is always allowed. gzungetc() returns the character pushed, or -1 on failure. gzungetc() will fail if c is -1, and may fail if a character has been pushed but not read yet. If gzungetc is used immediately after gzopen or gzdopen, at least the @@ -1536,9 +1539,9 @@ int gzungetc(int c, gzFile file); int gzflush(gzFile file, int flush); /* - Flushes all pending output into the compressed file. The parameter flush - is as in the deflate() function. The return value is the zlib error number - (see function gzerror below). gzflush is only permitted when writing. + Flush all pending output to file. The parameter flush is as in the + deflate() function. The return value is the zlib error number (see function + gzerror below). gzflush is only permitted when writing. If the flush parameter is Z_FINISH, the remaining data is written and the gzip stream is completed in the output. If gzwrite() is called again, a new @@ -1551,8 +1554,8 @@ int gzflush(gzFile file, int flush); z_off_t gzseek(gzFile file, z_off_t offset, int whence); /* - Sets the starting position for the next gzread or gzwrite on the given - compressed file. The offset represents a number of bytes in the + Set the starting position to offset relative to whence for the next gzread + or gzwrite on file. The offset represents a number of bytes in the uncompressed data stream. The whence parameter is defined as in lseek(2); the value SEEK_END is not supported. @@ -1569,39 +1572,39 @@ z_off_t gzseek(gzFile file, z_off_t offset, int whence); int gzrewind(gzFile file); /* - Rewinds the given file. This function is supported only for reading. + Rewind file. This function is supported only for reading. - gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET). */ z_off_t gztell(gzFile file); /* - Returns the starting position for the next gzread or gzwrite on the given - compressed file. This position represents a number of bytes in the - uncompressed data stream, and is zero when starting, even if appending or - reading a gzip stream from the middle of a file using gzdopen(). + Return the starting position for the next gzread or gzwrite on file. + This position represents a number of bytes in the uncompressed data stream, + and is zero when starting, even if appending or reading a gzip stream from + the middle of a file using gzdopen(). gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) */ z_off_t gzoffset(gzFile file); /* - Returns the current offset in the file being read or written. This offset - includes the count of bytes that precede the gzip stream, for example when - appending or when using gzdopen() for reading. When reading, the offset - does not include as yet unused buffered input. This information can be used - for a progress indicator. On error, gzoffset() returns -1. + Return the current compressed (actual) read or write offset of file. This + offset includes the count of bytes that precede the gzip stream, for example + when appending or when using gzdopen() for reading. When reading, the + offset does not include as yet unused buffered input. This information can + be used for a progress indicator. On error, gzoffset() returns -1. */ int gzeof(gzFile file); /* - Returns true (1) if the end-of-file indicator has been set while reading, - false (0) otherwise. Note that the end-of-file indicator is set only if the - read tried to go past the end of the input, but came up short. Therefore, - just like feof(), gzeof() may return false even if there is no more data to - read, in the event that the last read request was for the exact number of - bytes remaining in the input file. This will happen if the input file size - is an exact multiple of the buffer size. + Return true (1) if the end-of-file indicator for file has been set while + reading, false (0) otherwise. Note that the end-of-file indicator is set + only if the read tried to go past the end of the input, but came up short. + Therefore, just like feof(), gzeof() may return false even if there is no + more data to read, in the event that the last read request was for the exact + number of bytes remaining in the input file. This will happen if the input + file size is an exact multiple of the buffer size. If gzeof() returns true, then the read functions will return no more data, unless the end-of-file indicator is reset by gzclearerr() and the input file @@ -1610,7 +1613,7 @@ int gzeof(gzFile file); int gzdirect(gzFile file); /* - Returns true (1) if file is being copied directly while reading, or false + Return true (1) if file is being copied directly while reading, or false (0) if file is a gzip stream being decompressed. If the input file is empty, gzdirect() will return true, since the input @@ -1631,8 +1634,8 @@ int gzdirect(gzFile file); int gzclose(gzFile file); /* - Flushes all pending output if necessary, closes the compressed file and - deallocates the (de)compression state. Note that once file is closed, you + Flush all pending output for file, if necessary, close file and + deallocate the (de)compression state. Note that once file is closed, you cannot call gzerror with file, since its structures have been deallocated. gzclose must not be called more than once on the same file, just as free must not be called more than once on the same allocation. @@ -1656,10 +1659,10 @@ int gzclose_w(gzFile file); const(char)* gzerror(gzFile file, int* errnum); /* - Returns the error message for the last error which occurred on the given - compressed file. errnum is set to zlib error number. If an error occurred - in the file system and not in the compression library, errnum is set to - Z_ERRNO and the application may consult errno to get the exact error code. + Return the error message for the last error which occurred on file. + errnum is set to zlib error number. If an error occurred in the file system + and not in the compression library, errnum is set to Z_ERRNO and the + application may consult errno to get the exact error code. The application must not modify the returned string. Future calls to this function may invalidate the previously returned string. If file is @@ -1672,7 +1675,7 @@ const(char)* gzerror(gzFile file, int* errnum); void gzclearerr(gzFile file); /* - Clears the error and end-of-file flags for file. This is analogous to the + Clear the error and end-of-file flags for file. This is analogous to the clearerr() function in stdio. This is useful for continuing to read a gzip file that is being written concurrently. */ @@ -1688,8 +1691,9 @@ void gzclearerr(gzFile file); uint adler32(uint adler, const(ubyte)* buf, uint len); /* Update a running Adler-32 checksum with the bytes buf[0 .. len-1] and - return the updated checksum. If buf is Z_NULL, this function returns the - required initial value for the checksum. + return the updated checksum. An Adler-32 value is in the range of a 32-bit + unsigned integer. If buf is Z_NULL, this function returns the required + initial value for the checksum. An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed much faster. @@ -1722,9 +1726,10 @@ uint adler32_combine(uint adler1, uint adler2, z_off_t len2); uint crc32(uint crc, const(ubyte)* buf, uint len); /* Update a running CRC-32 with the bytes buf[0 .. len-1] and return the - updated CRC-32. If buf is Z_NULL, this function returns the required - initial value for the crc. Pre- and post-conditioning (one's complement) is - performed within this function so it shouldn't be done by the application. + updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer. + If buf is Z_NULL, this function returns the required initial value for the + crc. Pre- and post-conditioning (one's complement) is performed within this + function so it shouldn't be done by the application. Usage example: @@ -1736,7 +1741,7 @@ uint crc32(uint crc, const(ubyte)* buf, uint len); if (crc != original_crc) error(); */ -uint crc32_z(uint adler, const(ubyte)* buf, z_size_t len); +uint crc32_z(uint crc, const(ubyte)* buf, z_size_t len); /* Same as crc32(), but with a size_t length. */ @@ -1751,6 +1756,18 @@ uint crc32_combine(uint crc1, uint crc2, z_off_t len2); len2. */ +uint crc32_combine_gen(z_off_t len2); +/* + Return the operator corresponding to length len2, to be used with + crc32_combine_op(). +*/ + +uint crc32_combine_op(uint crc1, uint crc2, uint op); +/* + Give the same result as crc32_combine(), using op in place of len2. op is + is generated from len2 by crc32_combine_gen(). This will be faster than + crc32_combine() if the generated op is used more than once. +*/ /* various hacks, don't look :) */ diff --git a/libphobos/src/std/base64.d b/libphobos/src/std/base64.d index 866f7005060..d971dba1c71 100644 --- a/libphobos/src/std/base64.d +++ b/libphobos/src/std/base64.d @@ -63,7 +63,7 @@ import std.range.primitives : empty, front, isInputRange, isOutputRange, import std.traits : isArray; // Make sure module header code examples work correctly. -@safe unittest +pure @safe unittest { ubyte[] data = [0x14, 0xfb, 0x9c, 0x03, 0xd9, 0x7e]; @@ -82,7 +82,7 @@ import std.traits : isArray; alias Base64 = Base64Impl!('+', '/'); /// -@safe unittest +pure @safe unittest { ubyte[] data = [0x83, 0xd7, 0x30, 0x7a, 0x01, 0x3f]; assert(Base64.encode(data) == "g9cwegE/"); @@ -98,7 +98,7 @@ alias Base64 = Base64Impl!('+', '/'); alias Base64URL = Base64Impl!('-', '_'); /// -@safe unittest +pure @safe unittest { ubyte[] data = [0x83, 0xd7, 0x30, 0x7a, 0x01, 0x3f]; assert(Base64URL.encode(data) == "g9cwegE_"); @@ -114,7 +114,7 @@ alias Base64URL = Base64Impl!('-', '_'); alias Base64URLNoPadding = Base64Impl!('-', '_', Base64.NoPadding); /// -@safe unittest +pure @safe unittest { ubyte[] data = [0x83, 0xd7, 0x30, 0x7b, 0xef]; assert(Base64URLNoPadding.encode(data) == "g9cwe-8"); @@ -180,7 +180,7 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=') * Returns: * The length of a Base64 encoding of an array of the given length. */ - @safe + @safe @nogc pure nothrow size_t encodeLength(in size_t sourceLength) { static if (Padding == NoPadding) @@ -218,8 +218,8 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=') * The slice of $(D_PARAM buffer) that contains the encoded string. */ @trusted - pure char[] encode(R1, R2)(in R1 source, return scope R2 buffer) if (isArray!R1 && is(ElementType!R1 : ubyte) && - is(R2 == char[])) + pure char[] encode(R1, R2)(const scope R1 source, return scope R2 buffer) + if (isArray!R1 && is(ElementType!R1 : ubyte) && is(R2 == char[])) in { assert(buffer.length >= encodeLength(source.length), "Insufficient buffer for encoding"); @@ -277,9 +277,9 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=') } /// - @safe unittest + @nogc nothrow @safe unittest { - ubyte[] data = [0x83, 0xd7, 0x30, 0x7a, 0x01, 0x3f]; + ubyte[6] data = [0x83, 0xd7, 0x30, 0x7a, 0x01, 0x3f]; char[32] buffer; // much bigger than necessary // Just to be sure... @@ -287,7 +287,7 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=') assert(buffer.length >= encodedLength); // encode() returns a slice to the provided buffer. - auto encoded = Base64.encode(data, buffer[]); + auto encoded = Base64.encode(data[], buffer[]); assert(encoded is buffer[0 .. encodedLength]); assert(encoded == "g9cwegE/"); } diff --git a/libphobos/src/std/int128.d b/libphobos/src/std/int128.d new file mode 100644 index 00000000000..fc992f82422 --- /dev/null +++ b/libphobos/src/std/int128.d @@ -0,0 +1,374 @@ +// Written in the D programming language +/** + * Implements a signed 128 bit integer type. + * + Author: Walter Bright + Copyright: Copyright (c) 2022, D Language Foundation + License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0) + Source: $(PHOBOSSRC std/int128.d) + */ +module std.int128; + +private import core.int128; + + +/*********************************** + * 128 bit signed integer type. + */ + +public struct Int128 +{ + @safe pure nothrow @nogc: + + Cent data; /// core.int128.Cent + + /**************** + * Construct an `Int128` from a `long` value. + * The upper 64 bits are formed by sign extension. + * Params: + * lo = signed lower 64 bits + */ + this(long lo) + { + data.lo = lo; + data.hi = lo < 0 ? ~0L : 0; + } + + /**************** + * Construct an `Int128` from a `ulong` value. + * The upper 64 bits are set to zero. + * Params: + * lo = unsigned lower 64 bits + */ + this(ulong lo) + { + data.lo = lo; + data.hi = 0; + } + + /**************** + * Construct an `Int128` from a `long` value. + * Params: + * hi = upper 64 bits + * lo = lower 64 bits + */ + this(long hi, long lo) + { + data.hi = hi; + data.lo = lo; + } + + /******************** + * Construct an `Int128` from a `Cent`. + * Params: + * data = Cent data + */ + this(Cent data) + { + this.data = data; + } + + /******************** + * Returns: hash value for Int128 + */ + size_t toHash() const + { + return cast(size_t)((data.lo & 0xFFFF_FFFF) + (data.hi & 0xFFFF_FFFF) + (data.lo >> 32) + (data.hi >> 32)); + } + + /************************ + * Compare for equality + * Params: lo = signed value to compare with + * Returns: true if Int128 equals value + */ + bool opEquals(long lo) const + { + return data.lo == lo && data.hi == (lo >> 63); + } + + /************************ + * Compare for equality + * Params: lo = unsigned value to compare with + * Returns: true if Int128 equals value + */ + bool opEquals(ulong lo) const + { + return data.hi == 0 && data.lo == lo; + } + + /************************ + * Compare for equality + * Params: op2 = value to compare with + * Returns: true if Int128 equals value + */ + bool opEquals(Int128 op2) const + { + return data.hi == op2.data.hi && data.lo == op2.data.lo; + } + + /** Support unary arithmentic operator + + * Params: op = "+" + * Returns: lvalue of result + */ + Int128 opUnary(string op)() const + if (op == "+") + { + return this; + } + + /** Support unary arithmentic operator - ~ + * Params: op = "-", "~" + * Returns: lvalue of result + */ + Int128 opUnary(string op)() const + if (op == "-" || op == "~") + { + static if (op == "-") + return Int128(neg(this.data)); + else static if (op == "~") + return Int128(com(this.data)); + } + + /** Support unary arithmentic operator ++ -- + * Params: op = "++", "--" + * Returns: lvalue of result + */ + Int128 opUnary(string op)() + if (op == "++" || op == "--") + { + static if (op == "++") + this.data = inc(this.data); + else static if (op == "--") + this.data = dec(this.data); + else + static assert(0, op); + return this; + } + + /** Support casting to a bool + * Params: T = bool + * Returns: boolean result + */ + bool opCast(T : bool)() const + { + return tst(this.data); + } + + /** Support binary arithmetic operators + - * / % & | ^ << >> >>> + * Params: + * op = one of the arithmetic binary operators + * op2 = second operand + * Returns: value after the operation is applied + */ + Int128 opBinary(string op)(Int128 op2) const + if (op == "+" || op == "-" || + op == "*" || op == "/" || op == "%" || + op == "&" || op == "|" || op == "^") + { + static if (op == "+") + return Int128(add(this.data, op2.data)); + else static if (op == "-") + return Int128(sub(this.data, op2.data)); + else static if (op == "*") + return Int128(mul(this.data, op2.data)); + else static if (op == "/") + return Int128(div(this.data, op2.data)); + else static if (op == "%") + { + Cent modulus; + divmod(this.data, op2.data, modulus); + return Int128(modulus); + } + else static if (op == "&") + return Int128(and(this.data, op2.data)); + else static if (op == "|") + return Int128(or(this.data, op2.data)); + else static if (op == "^") + return Int128(xor(this.data, op2.data)); + else + static assert(0, "wrong op value"); + } + + /// ditto + Int128 opBinary(string op)(long op2) const + if (op == "+" || op == "-" || + op == "*" || op == "/" || op == "%" || + op == "&" || op == "|" || op == "^") + { + return mixin("this " ~ op ~ " Int128(0, op2)"); + } + + /// ditto + Int128 opBinaryRight(string op)(long op2) const + if (op == "+" || op == "-" || + op == "*" || op == "/" || op == "%" || + op == "&" || op == "|" || op == "^") + { + mixin("return Int128(0, op2) " ~ op ~ " this;"); + } + + /// ditto + Int128 opBinary(string op)(long op2) const + if (op == "<<") + { + return Int128(shl(this.data, cast(uint) op2)); + } + + /// ditto + Int128 opBinary(string op)(long op2) const + if (op == ">>") + { + return Int128(sar(this.data, cast(uint) op2)); + } + + /// ditto + Int128 opBinary(string op)(long op2) const + if (op == ">>>") + { + return Int128(shr(this.data, cast(uint) op2)); + } + + /** arithmetic assignment operators += -= *= /= %= &= |= ^= <<= >>= >>>= + * Params: op = one of +, -, etc. + * op2 = second operand + * Returns: lvalue of updated left operand + */ + ref Int128 opOpAssign(string op)(Int128 op2) + if (op == "+" || op == "-" || + op == "*" || op == "/" || op == "%" || + op == "&" || op == "|" || op == "^" || + op == "<<" || op == ">>" || op == ">>>") + { + mixin("this = this " ~ op ~ " op2;"); + return this; + } + + /// ditto + ref Int128 opOpAssign(string op)(long op2) + if (op == "+" || op == "-" || + op == "*" || op == "/" || op == "%" || + op == "&" || op == "|" || op == "^" || + op == "<<" || op == ">>" || op == ">>>") + { + mixin("this = this " ~ op ~ " op2;"); + return this; + } + + /** support signed arithmentic comparison operators < <= > >= + * Params: op2 = right hand operand + * Returns: -1 for less than, 0 for equals, 1 for greater than + */ + int opCmp(Int128 op2) const + { + return this == op2 ? 0 : gt(this.data, op2.data) * 2 - 1; + } + + /** support signed arithmentic comparison operators < <= > >= + * Params: op2 = right hand operand + * Returns: -1 for less than, 0 for equals, 1 for greater than + */ + int opCmp(long op2) const + { + return opCmp(Int128(0, op2)); + } + + enum min = Int128(long.min, 0); /// minimum value + enum max = Int128(long.max, ulong.max); /// maximum value +} + +/********************************************* Tests ************************************/ + +version (unittest) +{ +import core.stdc.stdio; + +@trusted void print(Int128 c) +{ + printf("%lld, %lld\n", c.data.hi, c.data.lo); +} + +@trusted void printx(Int128 c) +{ + printf("%llx, %llx\n", c.data.hi, c.data.lo); +} +} + +/// Int128 tests +@safe pure nothrow @nogc +unittest +{ + Int128 c = Int128(5, 6); + assert(c == c); + assert(c == +c); + assert(c == - -c); + assert(~c == Int128(~5, ~6)); + ++c; + assert(c == Int128(5, 7)); + assert(--c == Int128(5, 6)); + assert(!!c); + assert(!Int128()); + + assert(c + Int128(10, 20) == Int128(15, 26)); + assert(c - Int128(1, 2) == Int128(4, 4)); + assert(c * Int128(100, 2) == Int128(610, 12)); + assert(c / Int128(3, 2) == Int128(0, 1)); + assert(c % Int128(3, 2) == Int128(2, 4)); + assert((c & Int128(3, 2)) == Int128(1, 2)); + assert((c | Int128(3, 2)) == Int128(7, 6)); + assert((c ^ Int128(3, 2)) == Int128(6, 4)); + + assert(c + 15 == Int128(5, 21)); + assert(c - 15 == Int128(4, -9)); + assert(c * 15 == Int128(75, 90)); + assert(c / 15 == Int128(0, 6148914691236517205)); + assert(c % 15 == Int128(0, 11)); + assert((c & 15) == Int128(0, 6)); + assert((c | 15) == Int128(5, 15)); + assert((c ^ 15) == Int128(5, 9)); + + assert(15 + c == Int128(5, 21)); + assert(15 - c == Int128(-5, 9)); + assert(15 * c == Int128(75, 90)); + assert(15 / c == Int128(0, 0)); + assert(15 % c == Int128(0, 15)); + assert((15 & c) == Int128(0, 6)); + assert((15 | c) == Int128(5, 15)); + assert((15 ^ c) == Int128(5, 9)); + + assert(c << 1 == Int128(10, 12)); + assert(-c >> 1 == Int128(-3, 9223372036854775805)); + assert(-c >>> 1 == Int128(9223372036854775805, 9223372036854775805)); + + assert((c += 1) == Int128(5, 7)); + assert((c -= 1) == Int128(5, 6)); + assert((c += Int128(0, 1)) == Int128(5, 7)); + assert((c -= Int128(0, 1)) == Int128(5, 6)); + assert((c *= 2) == Int128(10, 12)); + assert((c /= 2) == Int128(5, 6)); + assert((c %= 2) == Int128()); + c += Int128(5, 6); + assert((c *= Int128(10, 20)) == Int128(160, 120)); + assert((c /= Int128(10, 20)) == Int128(0, 15)); + c += Int128(72, 0); + assert((c %= Int128(10, 20)) == Int128(1, -125)); + assert((c &= Int128(3, 20)) == Int128(1, 0)); + assert((c |= Int128(8, 2)) == Int128(9, 2)); + assert((c ^= Int128(8, 2)) == Int128(1, 0)); + c |= Int128(10, 5); + assert((c <<= 1) == Int128(11 * 2, 5 * 2)); + assert((c >>>= 1) == Int128(11, 5)); + c = Int128(long.min, long.min); + assert((c >>= 1) == Int128(long.min >> 1, cast(ulong) long.min >> 1)); + + assert(-Int128.min == Int128.min); + assert(Int128.max + 1 == Int128.min); + + c = Int128(5, 6); + assert(c < Int128(6, 5)); + assert(c > 10); + + c = Int128(-1UL); + assert(c == -1UL); + c = Int128(-1L); + assert(c == -1L); +} diff --git a/libphobos/src/std/path.d b/libphobos/src/std/path.d index 20518b86333..de180fcc548 100644 --- a/libphobos/src/std/path.d +++ b/libphobos/src/std/path.d @@ -1519,7 +1519,7 @@ if (isSomeChar!C) import std.range; // ir() wraps an array in a plain (i.e. non-forward) input range, so that // we can test both code paths - InputRange!(C[]) ir(C)(C[][] p...) { return inputRangeObject(p); } + InputRange!(C[]) ir(C)(C[][] p...) { return inputRangeObject(p.dup); } version (Posix) { assert(buildPath("foo") == "foo"); diff --git a/libphobos/src/std/regex/internal/parser.d b/libphobos/src/std/regex/internal/parser.d index 41ca6872a7a..448bb99a9a1 100644 --- a/libphobos/src/std/regex/internal/parser.d +++ b/libphobos/src/std/regex/internal/parser.d @@ -841,7 +841,7 @@ if (isForwardRange!R && is(ElementType!R : dchar)) switch (front) { case '*', '?', '+', '|', '{', '}': - error("'*', '+', '?', '{', '}' not allowed in atom"); + return error("'*', '+', '?', '{', '}' not allowed in atom"); case '.': if (re_flags & RegexOption.singleline) g.put(Bytecode(IR.Any, 0)); diff --git a/libphobos/src/std/traits.d b/libphobos/src/std/traits.d index 9ca676d312a..18400e3e859 100644 --- a/libphobos/src/std/traits.d +++ b/libphobos/src/std/traits.d @@ -1422,6 +1422,11 @@ if (isCallable!func) enum val = "val" ~ (name == "val" ? "_" : ""); enum ptr = "ptr" ~ (name == "ptr" ? "_" : ""); mixin(" + enum hasDefaultArg = (PT[i .. i+1] " ~ args ~ ") { return true; }; + "); + static if (is(typeof(hasDefaultArg()))) + { + mixin(" // workaround scope escape check, see // https://issues.dlang.org/show_bug.cgi?id=16582 // should use return scope once available @@ -1432,10 +1437,9 @@ if (isCallable!func) auto " ~ val ~ " = " ~ args ~ "[0]; auto " ~ ptr ~ " = &" ~ val ~ "; return *" ~ ptr ~ "; - }; - "); - static if (is(typeof(get()))) + };"); enum Get = get(); + } else alias Get = void; // If default arg doesn't exist, returns void instead. @@ -1483,6 +1487,17 @@ if (isCallable!func) static foreach (V; Voids) static assert(is(V == void)); } +// https://issues.dlang.org/show_bug.cgi?id=20182 +@safe pure nothrow @nogc unittest +{ + struct S + { + this(ref S) {} + } + + static assert(__traits(compiles, ParameterDefaults!(S.__ctor))); +} + /** * Alternate name for $(LREF ParameterDefaults), kept for legacy compatibility. */ diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 59c784378d9..461cc8a7086 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,338 @@ +2022-04-27 Jakub Jelinek <jakub@redhat.com> + + * config/abi/post/x86_64-linux-gnu/baseline_symbols.txt: Update. + * config/abi/post/x86_64-linux-gnu/32/baseline_symbols.txt: Update. + * config/abi/post/i486-linux-gnu/baseline_symbols.txt: Update. + * config/abi/post/aarch64-linux-gnu/baseline_symbols.txt: Update. + * config/abi/post/s390x-linux-gnu/baseline_symbols.txt: Update. + * config/abi/post/powerpc-linux-gnu/baseline_symbols.txt: Update. + * config/abi/post/powerpc64-linux-gnu/baseline_symbols.txt: Update. + * config/abi/post/powerpc64-linux-gnu/32/baseline_symbols.txt: Update. + +2022-04-27 Jonathan Wakely <jwakely@redhat.com> + + * python/libstdcxx/v6/printers.py (SharedPointerPrinter): Add + support for atomic<shared_ptr<T>> and atomic<weak_ptr<T>>. + (StdAtomicPrinter): New printer. + (build_libstdcxx_dictionary): Register new printer. + * testsuite/libstdc++-prettyprinters/cxx11.cc: Test std::atomic. + * testsuite/libstdc++-prettyprinters/cxx20.cc: Test atomic smart + pointers. + +2022-04-26 Jonathan Wakely <jwakely@redhat.com> + + * include/bits/shared_ptr_atomic.h (atomic<shared_ptr>): Add + constructor for constant initialization from nullptr_t. + * testsuite/20_util/shared_ptr/atomic/atomic_shared_ptr.cc: + Check for new constructor. + +2022-04-26 Jonathan Wakely <jwakely@redhat.com> + + * include/bits/fs_path.h (hash<filesystem::path>): Define. + * testsuite/27_io/filesystem/path/nonmember/hash_value.cc: + Check std::hash specialization. + +2022-04-25 Jonathan Wakely <jwakely@redhat.com> + + * include/bits/ptr_traits.h (__cpp_lib_constexpr_memory): Define + conditionally. + * include/bits/unique_ptr.h (__cpp_lib_constexpr_memory): + Define for C++23. + (default_delete, default_delete<T[]>, __uniq_ptr_impl) + (unique_ptr, unique_ptr<T[], D>): Add constexpr to all member + functions. + * include/std/version (__cpp_lib_constexpr_memory): Define new + value for C++23. + * testsuite/20_util/unique_ptr/assign/constexpr.cc: New test. + * testsuite/20_util/unique_ptr/comparison/constexpr.cc: New test. + * testsuite/20_util/unique_ptr/cons/constexpr_c++20.cc: New test. + * testsuite/20_util/unique_ptr/creation/constexpr.cc: New test. + * testsuite/20_util/unique_ptr/modifiers/constexpr.cc: New test. + * testsuite/20_util/unique_ptr/specialized_algorithms/constexpr.cc: + New test. + +2022-04-25 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105375 + * include/std/future (packaged_task): Add deduction guides. + * testsuite/30_threads/packaged_task/cons/deduction.cc: New test. + +2022-04-25 Philipp Fent <fent@in.tum.de> + + * python/libstdcxx/v6/printers.py (StdSpanPrinter._iterator): + Rename as iterator. + (StdInitializerListPrinter): Define new printer. + (build_libstdcxx_dictionary): Register new printer. + * testsuite/libstdc++-prettyprinters/cxx11.cc: Check printer for + initializer_list. + +2022-04-22 Thomas W Rodgers <trodgers@redhat.com> + + PR libstdc++/102994 + * include/bits/atomic_base.h (atomic_flag::notify_one, + notify_all): Remove const qualification. + (__atomic_base::notify_one, notify_all): Likewise. + * include/std/atomic (atomic<bool>::notify_one, notify_all): + Likewise. + (atomic::notify_one, notify_all): Likewise. + (atomic<T*>::notify_one, notify_all): Likewise. + (atomic_notify_one, atomic_notify_all): Likewise. + * testsuite/29_atomics/atomic/wait_notify/102994.cc: Adjust test + to account for change in notify_one/notify_all signature. + +2022-04-21 Patrick Palka <ppalka@redhat.com> + + * include/std/charconv (__from_chars_alnum_to_val_table): + Simplify initialization of __lower/__upper_letters. + (__from_chars_alnum_to_val): Default the template parameter to + false. + * src/c++17/floating_from_chars.cc (starts_with_ci): Don't + assume the uppercase and lowercase letters are contiguous. + (__floating_from_chars_hex): Likewise. + +2022-04-21 Patrick Palka <ppalka@redhat.com> + + PR c++/105297 + PR c++/105322 + * include/std/charconv (__from_chars_alnum_to_val): Make + initializer for __table dependent in an artificial way. + +2022-04-21 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105324 + * src/c++17/floating_from_chars.cc (buffer_resource::do_allocate): + Remove assertion. + * testsuite/20_util/from_chars/pr105324.cc: New test. + +2022-04-20 Jonathan Wakely <jwakely@redhat.com> + + * testsuite/21_strings/basic_string_view/operations/copy/char/constexpr.cc: + Check correct feature test macro. + +2022-04-20 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/93602 + * doc/xml/manual/prerequisites.xml: Document libiconv + workarounds. + * doc/html/manual/setup.html: Regenerate. + * src/Makefile.am (CXXLINK): Add $(LTLIBICONV). + * src/Makefile.in: Regenerate. + +2022-04-19 Patrick Palka <ppalka@redhat.com> + + * src/c++17/floating_to_chars.cc (_GLIBCXX_ASSERTIONS): Don't + define. + (__floating_to_chars_shortest): Add __builtin_unreachable calls to + squelch false-positive -Wmaybe-uninitialized and -Wreturn-type + warnings. + (__floating_to_chars_precision): Likewise. + +2022-04-19 Philipp Fent <fent@in.tum.de> + + * python/libstdcxx/v6/printers.py (StdSpanPrinter): Define. + * testsuite/libstdc++-prettyprinters/cxx20.cc: Test it. + +2022-04-19 Jonathan Wakely <jwakely@redhat.com> + + * acinclude.m4 (GLIBCXX_ENABLE_BACKTRACE): Fix shell operators. + * configure: Regenerate. + +2022-04-18 Patrick Palka <ppalka@redhat.com> + + * include/std/charconv (__from_chars_pow2_base): Manually + unroll the first iteration of the main loop and simplify + accordingly. + +2022-04-15 Patrick Palka <ppalka@redhat.com> + + PR libstdc++/104858 + * include/bits/ranges_algo.h (__minmax_fn): Avoid dereferencing + __first twice at the start. + * testsuite/25_algorithms/minmax/constrained.cc (test06): New test. + +2022-04-15 Patrick Palka <ppalka@redhat.com> + + * include/std/charconv (__from_chars_alnum_to_val_table): Define. + (__from_chars_alnum_to_val): Define. + (__from_chars_binary): Rename to ... + (__from_chars_pow2_base): ... this. Generalize to handle any + power-of-two base using __from_chars_alnum_to_val. + (__from_chars_digit): Optimize digit recognition to a single + test instead of two tests. Use [[__unlikely___]] attribute. + (__from_chars_alpha_to_num): Remove. + (__from_chars_alnum): Use __from_chars_alnum_to_val. Use a + nested loop for the overflow case. Maintain a lower bound + on the number of available bits in the result and use it to + omit the overflow check. + (from_chars): Adjust appropriately. + * src/c++17/floating_from_chars.cc (ascii_to_hexit): Remove. + (__floating_from_chars_hex): Use __from_chars_alnum_to_val + to recognize a hex digit instead. + +2022-04-14 Palmer Dabbelt <palmer@rivosinc.com> + + * acinclude.m4 (GLIBCXX_ENABLE_LOCK_POLICY): Force auto to mutex + for RISC-V. + * configure: Regenerate. + +2022-04-14 Jonathan Wakely <jwakely@redhat.com> + + * doc/xml/manual/intro.xml: Fix comment. + +2022-04-14 Jonathan Wakely <jwakely@redhat.com> + + * include/precompiled/stdc++.h: Include <stacktrace> and + <stdatomic.h> for C++23. + +2022-04-14 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105269 + * include/bits/stl_vector.h (__cpp_lib_constexpr_vector): + Define. + * include/c_compatibility/stdatomic.h (__cpp_lib_stdatomic_h): + Define. + * include/std/optional (__cpp_lib_optional): Define new value + for C++23. + (__cpp_lib_monadic_optional): Remove. + * include/std/version (__cpp_lib_constexpr_vector): Define. + (__cpp_lib_stdatomic_h): Define. + (__cpp_lib_optional): Define new value for C++23. + (__cpp_lib_monadic_optional): Remove. + * testsuite/20_util/optional/monadic/and_then.cc: Adjust. + * testsuite/20_util/optional/requirements.cc: Adjust for C++23. + * testsuite/20_util/optional/version.cc: Likewise. + * testsuite/23_containers/vector/cons/constexpr.cc: Check + feature test macro. + * testsuite/29_atomics/headers/stdatomic.h/c_compat.cc: + Likewise. + * testsuite/20_util/optional/monadic/version.cc: Removed. + * testsuite/23_containers/vector/requirements/version.cc: New test. + * testsuite/29_atomics/headers/stdatomic.h/version.cc: New test. + +2022-04-12 Jonathan Wakely <jwakely@redhat.com> + + * acinclude.m4 (GLIBCXX_ENABLE_BACKTRACE): Check for mmap. + * config.h.in: Regenerate. + * configure: Regenerate. + +2022-04-12 Jonathan Wakely <jwakely@redhat.com> + + * include/std/stacktrace (basic_stacktrace::current): Reallocate + a smaller container if the unused capacity is larger than the + used size. + +2022-04-12 Jonathan Wakely <jwakely@redhat.com> + + * include/std/stacktrace (basic_stacktrace): Use _Impl::_M_clone + or _Impl::_M_assign to initialize elements in allocated storage. + (basic_stacktrace::_M_clear()): Use _Impl::_M_resize instead of + _Impl::_M_destroy. + (basic_stacktrace::_Impl::_M_destroy()): Replace with ... + (basic_stacktrace::_Impl::_M_resize(size_type, allocator&)): New + function. + (basic_stacktrace::_Impl::_M_push_back): Use _M_xclone. Construct + new element using allocator. + (basic_stacktrace::_Impl::_M_clone): New function. + (basic_stacktrace::_Impl::_M_xclone): New function. + (basic_stacktrace::_Impl::_M_assign): New function. + +2022-04-12 Jonathan Wakely <jwakely@redhat.com> + + * include/std/stacktrace (basic_stacktrace::_Impl::_M_allocate): + Use nothrow new instead of try block for std::allocator. + (basic_stacktrace::_Impl::_M_deallocate): Use delete for + std::allocator. + +2022-04-12 Jonathan Wakely <jwakely@redhat.com> + + * include/std/stacktrace (basic_stacktrace::current): Replace + calls to _M_reserve and _S_curr_cb with call to _M_prepare. + Check return value of backtrace_simple when max depth given. + (basic_stacktrace::_M_reserve): Remove. + (basic_stacktrace::_S_curr_cb): Remove. + (basic_stacktrace::_M_prepare(size_type)): New function to + reserve initial capacity and return callback. + (basic_stacktrace::_Impl::_M_allocate): Remove check for 0 < n + and remove redundant zeroing of _M_frames and _M_capacity. + (basic_stacktrace::_Impl::_M_push_back): Add [[unlikely]] + attribute. Assign _Impl instead of swapping. + * testsuite/19_diagnostics/stacktrace/current.cc: New test. + +2022-04-11 Jonathan Wakely <jwakely@redhat.com> + + * include/std/stacktrace (basic_stacktrace::_Impl::_M_allocate): + Change [[unlikely]] attribute to [[likely]]. + +2022-04-11 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105031 + * include/std/stacktrace (basic_stacktrace::basic_stacktrace): + Fix allocator usage in constructors. + (basic_stacktrace::operator=(const basic_stacktrace&)): Do not + try to reallocate using const allocator. + (basic_stacktrace::operator=(basic_stacktrace&&)): Fix + if-constexpr with non-constant condition. Do not allocate new + storage if allocator propagates. Do not set _M_size if + allocation fails. + (basic_stacktrace::swap(basic_stacktrace&)): Fix typo. Add + assertion that non-propagating allocators are equal. + * testsuite/19_diagnostics/stacktrace/stacktrace.cc: New test. + +2022-04-11 Jonathan Wakely <jwakely@redhat.com> + + * include/std/stacktrace (basic_stacktrace::current): Duplicate + implementation into each overload. Add noinline attribute and + skip current frame. + (basic_stacktrace::max_size()): Call _Impl::_S_max_size. + (basic_stacktrace::_S_curr_cb()): New function defining lambda. + (basic_stacktrace::_Impl::_S_max_size): New function defining + maximum size in terms of allocator and size_type. + (basic_stacktrace::_Impl::_M_allocate): Check against + max_size(). + * testsuite/19_diagnostics/stacktrace/entry.cc: Call function + for non-constexpr checks. Check line number is correct. + +2022-04-11 Jonathan Wakely <jwakely@redhat.com> + + * testsuite/20_util/stacktrace/entry.cc: Moved to... + * testsuite/19_diagnostics/stacktrace/entry.cc: ...here. + * testsuite/20_util/stacktrace/synopsis.cc: Moved to... + * testsuite/19_diagnostics/stacktrace/synopsis.cc: ...here. + * testsuite/20_util/stacktrace/version.cc: Moved to... + * testsuite/19_diagnostics/stacktrace/version.cc: ...here. + +2022-04-11 Jonathan Wakely <jwakely@redhat.com> + + * include/experimental/bits/fs_path.h (path): Define special + members after path::_Cmpt is complete. + +2022-04-08 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105153 + * include/std/expected + (expected<void,E>::expected(expected<U,G>&&)): Fix constraints. + * testsuite/20_util/expected/cons.cc: Check constructor. + +2022-04-08 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105154 + * include/std/expected (expected<void, E>::swap): Set + _M_has_value to false for objects that previously had a value. + * testsuite/20_util/expected/swap.cc: Fix test to check void + specialization. + +2022-04-08 Jonathan Wakely <jwakely@redhat.com> + + PR libstdc++/105146 + * include/std/expected (bad_expected_access): Move constructor + parameter. + * testsuite/20_util/expected/bad.cc: New test. + +2022-04-07 Hans-Peter Nilsson <hp@axis.com> + + * testsuite/20_util/expected/requirements.cc: Correct minimal-size + test. + 2022-04-02 Jakub Jelinek <jakub@redhat.com> PR libstdc++/105128 diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4 index f53461c85a5..138bd58d86c 100644 --- a/libstdc++-v3/acinclude.m4 +++ b/libstdc++-v3/acinclude.m4 @@ -3612,6 +3612,9 @@ AC_DEFUN([GLIBCXX_ENABLE_LOCK_POLICY], [ dnl Why don't we check 8-byte CAS for sparc64, where _Atomic_word is long?! dnl New targets should only check for CAS for the _Atomic_word type. AC_TRY_COMPILE([ + #if defined __riscv + # error "Defaulting to mutex-based locks for ABI compatibility" + #endif #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 # error "No 2-byte compare-and-swap" #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 @@ -5003,18 +5006,41 @@ elf64) elfsize=64 ;; esac BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DBACKTRACE_ELF_SIZE=$elfsize" - ALLOC_FILE=alloc.lo - AC_SUBST(ALLOC_FILE) - VIEW_FILE=read.lo - AC_SUBST(VIEW_FILE) - AC_MSG_CHECKING([whether to build libbacktrace support]) - if test "$enable_libstdcxx_backtrace" == "auto"; then + if test "$enable_libstdcxx_backtrace" = "auto"; then enable_libstdcxx_backtrace=no fi - if test "$enable_libstdcxx_backtrace" == "yes"; then + if test "$enable_libstdcxx_backtrace" = "yes"; then BACKTRACE_SUPPORTED=1 - BACKTRACE_USES_MALLOC=1 + + AC_CHECK_HEADERS(sys/mman.h) + case "${host}" in + *-*-msdosdjgpp) # DJGPP has sys/man.h, but no mmap + have_mmap=no ;; + *-*-*) + have_mmap="$ac_cv_header_sys_mman_h" ;; + esac + + if test "$have_mmap" = "no"; then + VIEW_FILE=read.lo + ALLOC_FILE=alloc.lo + else + VIEW_FILE=mmapio.lo + AC_PREPROC_IFELSE([AC_LANG_SOURCE([ + #include <sys/mman.h> + #if !defined(MAP_ANONYMOUS) && !defined(MAP_ANON) + #error no MAP_ANONYMOUS + #endif + ])], [ALLOC_FILE=mmap.lo], [ALLOC_FILE=alloc.lo]) + fi + AC_SUBST(VIEW_FILE) + AC_SUBST(ALLOC_FILE) + + BACKTRACE_USES_MALLOC=0 + if test "$ALLOC_FILE" = "alloc.lo"; then + BACKTRACE_USES_MALLOC=1 + fi + if test "$ac_has_gthreads" = "yes"; then BACKTRACE_SUPPORTS_THREADS=1 else @@ -5031,7 +5057,7 @@ BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DBACKTRACE_ELF_SIZE=$elfsize" BACKTRACE_SUPPORTS_THREADS=0 fi AC_MSG_RESULT($enable_libstdcxx_backtrace) - GLIBCXX_CONDITIONAL(ENABLE_BACKTRACE, [test "$enable_libstdcxx_backtrace" != no]) + GLIBCXX_CONDITIONAL(ENABLE_BACKTRACE, [test "$enable_libstdcxx_backtrace" = yes]) ]) # Macros from the top-level gcc directory. diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in index f6212de9268..f30a8c51c45 100644 --- a/libstdc++-v3/config.h.in +++ b/libstdc++-v3/config.h.in @@ -420,6 +420,9 @@ /* Define to 1 if you have the <sys/machine.h> header file. */ #undef HAVE_SYS_MACHINE_H +/* Define to 1 if you have the <sys/mman.h> header file. */ +#undef HAVE_SYS_MMAN_H + /* Define to 1 if you have the <sys/param.h> header file. */ #undef HAVE_SYS_PARAM_H diff --git a/libstdc++-v3/config/abi/post/aarch64-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/aarch64-linux-gnu/baseline_symbols.txt index 898c8e1e895..c8ccecb120c 100644 --- a/libstdc++-v3/config/abi/post/aarch64-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/aarch64-linux-gnu/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -954,6 +956,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -973,6 +976,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1225,6 +1229,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1244,6 +1249,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2818,6 +2824,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Em@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -2928,7 +2935,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4153,6 +4161,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4522,6 +4531,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/i486-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/i486-linux-gnu/baseline_symbols.txt index 259cfdbaaa4..facc208bf27 100644 --- a/libstdc++-v3/config/abi/post/i486-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/i486-linux-gnu/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -954,6 +956,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -973,6 +976,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1225,6 +1229,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1244,6 +1249,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2818,6 +2824,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Ej@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -2928,7 +2935,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4153,6 +4161,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4523,6 +4532,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/powerpc-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/powerpc-linux-gnu/baseline_symbols.txt index 92cf176d63b..0209003243a 100644 --- a/libstdc++-v3/config/abi/post/powerpc-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/powerpc-linux-gnu/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -1096,6 +1098,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1115,6 +1118,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1367,6 +1371,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1386,6 +1391,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2968,6 +2974,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Ej@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -3118,7 +3125,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4345,6 +4353,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4760,6 +4769,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/powerpc64-linux-gnu/32/baseline_symbols.txt b/libstdc++-v3/config/abi/post/powerpc64-linux-gnu/32/baseline_symbols.txt index 92cf176d63b..0209003243a 100644 --- a/libstdc++-v3/config/abi/post/powerpc64-linux-gnu/32/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/powerpc64-linux-gnu/32/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -1096,6 +1098,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1115,6 +1118,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1367,6 +1371,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1386,6 +1391,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2968,6 +2974,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Ej@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -3118,7 +3125,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4345,6 +4353,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4760,6 +4769,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/powerpc64-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/powerpc64-linux-gnu/baseline_symbols.txt index 941c96eb3ff..773ee739ef7 100644 --- a/libstdc++-v3/config/abi/post/powerpc64-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/powerpc64-linux-gnu/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -1226,6 +1228,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1245,6 +1248,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1497,6 +1501,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1516,6 +1521,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -3106,6 +3112,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Em@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -3121,6 +3128,7 @@ FUNC:_ZNSt16invalid_argumentD2Ev@@GLIBCXX_3.4.15 FUNC:_ZNSt16nested_exceptionD0Ev@@CXXABI_1.3.5 FUNC:_ZNSt16nested_exceptionD1Ev@@CXXABI_1.3.5 FUNC:_ZNSt16nested_exceptionD2Ev@@CXXABI_1.3.5 +FUNC:_ZNSt17__gnu_cxx_ieee12816__convert_from_vERKP15__locale_structPciPKcz@@GLIBCXX_IEEE128_3.4.30 FUNC:_ZNSt17__gnu_cxx_ieee1287num_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEEC1Em@@GLIBCXX_IEEE128_3.4.29 FUNC:_ZNSt17__gnu_cxx_ieee1287num_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEEC2Em@@GLIBCXX_IEEE128_3.4.29 FUNC:_ZNSt17__gnu_cxx_ieee1287num_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEED0Ev@@GLIBCXX_IEEE128_3.4.29 @@ -3276,7 +3284,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4505,6 +4514,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4944,6 +4954,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 OBJECT:0:GLIBCXX_3.4.4 OBJECT:0:GLIBCXX_3.4.5 OBJECT:0:GLIBCXX_3.4.6 @@ -4951,6 +4962,7 @@ OBJECT:0:GLIBCXX_3.4.7 OBJECT:0:GLIBCXX_3.4.8 OBJECT:0:GLIBCXX_3.4.9 OBJECT:0:GLIBCXX_IEEE128_3.4.29 +OBJECT:0:GLIBCXX_IEEE128_3.4.30 OBJECT:0:GLIBCXX_LDBL_3.4 OBJECT:0:GLIBCXX_LDBL_3.4.10 OBJECT:0:GLIBCXX_LDBL_3.4.21 diff --git a/libstdc++-v3/config/abi/post/s390x-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/s390x-linux-gnu/baseline_symbols.txt index ba9f8bcb907..76243252739 100644 --- a/libstdc++-v3/config/abi/post/s390x-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/s390x-linux-gnu/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -1096,6 +1098,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1115,6 +1118,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1367,6 +1371,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1386,6 +1391,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2968,6 +2974,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Em@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -3118,7 +3125,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4345,6 +4353,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4760,6 +4769,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/x86_64-linux-gnu/32/baseline_symbols.txt b/libstdc++-v3/config/abi/post/x86_64-linux-gnu/32/baseline_symbols.txt index 259cfdbaaa4..facc208bf27 100644 --- a/libstdc++-v3/config/abi/post/x86_64-linux-gnu/32/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/x86_64-linux-gnu/32/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -954,6 +956,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -973,6 +976,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1225,6 +1229,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1244,6 +1249,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwjRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2818,6 +2824,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Ej@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -2928,7 +2935,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4153,6 +4161,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEEiPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4523,6 +4532,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/x86_64-linux-gnu/baseline_symbols.txt b/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt index 4cb3ae95dff..859a110e710 100644 --- a/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt +++ b/libstdc++-v3/config/abi/post/x86_64-linux-gnu/baseline_symbols.txt @@ -475,6 +475,7 @@ FUNC:_ZNKSt10moneypunctIwLb1EE8groupingEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream5rdbufEv@@GLIBCXX_3.4 FUNC:_ZNKSt10ostrstream6pcountEv@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIcE15_M_am_pm_formatEPPKc@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIcE15_M_date_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE15_M_time_formatsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE19_M_days_abbreviatedEPPKc@@GLIBCXX_3.4 @@ -485,6 +486,7 @@ FUNC:_ZNKSt11__timepunctIcE7_M_daysEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE8_M_am_pmEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIcE9_M_monthsEPPKc@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt11__timepunctIwE15_M_am_pm_formatEPPKw@@GLIBCXX_3.4.30 FUNC:_ZNKSt11__timepunctIwE15_M_date_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE15_M_time_formatsEPPKw@@GLIBCXX_3.4 FUNC:_ZNKSt11__timepunctIwE19_M_days_abbreviatedEPPKw@@GLIBCXX_3.4 @@ -954,6 +956,7 @@ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_ FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES4_S4_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -973,6 +976,7 @@ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_ FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4.21 +FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES4_S4_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSD_@@GLIBCXX_3.4.21 FUNC:_ZNKSt7__cxx118time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES4_S4_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.21 @@ -1225,6 +1229,7 @@ FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE14do_get_week FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE15_M_extract_nameES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKc@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE24_M_extract_wday_or_monthES3_S3_RiPPKcmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKcSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -1244,6 +1249,7 @@ FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE14do_get_week FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE15_M_extract_nameES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE16do_get_monthnameES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tm@@GLIBCXX_3.4 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKw@@GLIBCXX_3.4 +FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE21_M_extract_via_formatES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwRSt16__time_get_state@@GLIBCXX_3.4.30 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE24_M_extract_wday_or_monthES3_S3_RiPPKwmRSt8ios_baseRSt12_Ios_Iostate@@GLIBCXX_3.4.14 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmPKwSC_@@GLIBCXX_3.4.21 FUNC:_ZNKSt8time_getIwSt19istreambuf_iteratorIwSt11char_traitsIwEEE3getES3_S3_RSt8ios_baseRSt12_Ios_IostateP2tmcc@@GLIBCXX_3.4.26 @@ -2818,6 +2824,7 @@ FUNC:_ZNSt16__numpunct_cacheIwEC2Em@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED0Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED1Ev@@GLIBCXX_3.4 FUNC:_ZNSt16__numpunct_cacheIwED2Ev@@GLIBCXX_3.4 +FUNC:_ZNSt16__time_get_state17_M_finalize_stateEP2tm@@GLIBCXX_3.4.30 FUNC:_ZNSt16bad_array_lengthD0Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD1Ev@@CXXABI_1.3.8 FUNC:_ZNSt16bad_array_lengthD2Ev@@CXXABI_1.3.8 @@ -2928,7 +2935,8 @@ FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEED2Ev@@GLIBCXX_3.4 FUNC:_ZNSt18basic_stringstreamIwSt11char_traitsIwESaIwEEaSEOS3_@@GLIBCXX_3.4.21 FUNC:_ZNSt18condition_variable10notify_allEv@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variable10notify_oneEv@@GLIBCXX_3.4.11 -FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.11 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@@GLIBCXX_3.4.30 +FUNC:_ZNSt18condition_variable4waitERSt11unique_lockISt5mutexE@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC1Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableC2Ev@@GLIBCXX_3.4.11 FUNC:_ZNSt18condition_variableD1Ev@@GLIBCXX_3.4.11 @@ -4153,6 +4161,7 @@ FUNC:_ZSt20__throw_system_errori@@GLIBCXX_3.4.11 FUNC:_ZSt21_Rb_tree_rotate_rightPSt18_Rb_tree_node_baseRS0_@@GLIBCXX_3.4 FUNC:_ZSt21__copy_streambufs_eofIcSt11char_traitsIcEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 FUNC:_ZSt21__copy_streambufs_eofIwSt11char_traitsIwEElPSt15basic_streambufIT_T0_ES6_Rb@@GLIBCXX_3.4.9 +FUNC:_ZSt21__glibcxx_assert_failPKciS0_S0_@@GLIBCXX_3.4.30 FUNC:_ZSt21__throw_bad_exceptionv@@GLIBCXX_3.4 FUNC:_ZSt21__throw_runtime_errorPKc@@GLIBCXX_3.4 FUNC:_ZSt22__throw_overflow_errorPKc@@GLIBCXX_3.4 @@ -4523,6 +4532,7 @@ OBJECT:0:GLIBCXX_3.4.27 OBJECT:0:GLIBCXX_3.4.28 OBJECT:0:GLIBCXX_3.4.29 OBJECT:0:GLIBCXX_3.4.3 +OBJECT:0:GLIBCXX_3.4.30 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/pre/gnu-versioned-namespace.ver b/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver index e9520a6421e..b37199ece72 100644 --- a/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver +++ b/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver @@ -28,7 +28,6 @@ GLIBCXX_8.0 { { std::*; std::__8::*; - std::random_device::* }; # operator new(size_t) diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure index ef80912d0b9..9b94fd71e42 100755 --- a/libstdc++-v3/configure +++ b/libstdc++-v3/configure @@ -681,8 +681,8 @@ BACKTRACE_SUPPORTS_THREADS BACKTRACE_USES_MALLOC BACKTRACE_SUPPORTED BACKTRACE_CPPFLAGS -VIEW_FILE ALLOC_FILE +VIEW_FILE FORMAT_FILE ENABLE_FILESYSTEM_TS_FALSE ENABLE_FILESYSTEM_TS_TRUE @@ -16190,9 +16190,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu ac_save_CXXFLAGS="$CXXFLAGS" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext + cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ + #if defined __riscv + # error "Defaulting to mutex-based locks for ABI compatibility" + #endif #if ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 # error "No 2-byte compare-and-swap" #elif ! defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 @@ -16240,7 +16243,7 @@ $as_echo "mutex" >&6; } # unnecessary for this test. cat > conftest.$ac_ext << EOF -#line 16243 "configure" +#line 16246 "configure" int main() { _Decimal32 d1; @@ -16282,7 +16285,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu # unnecessary for this test. cat > conftest.$ac_ext << EOF -#line 16285 "configure" +#line 16288 "configure" template<typename T1, typename T2> struct same { typedef T2 type; }; @@ -77463,19 +77466,62 @@ elf64) elfsize=64 ;; esac BACKTRACE_CPPFLAGS="$BACKTRACE_CPPFLAGS -DBACKTRACE_ELF_SIZE=$elfsize" - ALLOC_FILE=alloc.lo - - VIEW_FILE=read.lo - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build libbacktrace support" >&5 $as_echo_n "checking whether to build libbacktrace support... " >&6; } - if test "$enable_libstdcxx_backtrace" == "auto"; then + if test "$enable_libstdcxx_backtrace" = "auto"; then enable_libstdcxx_backtrace=no fi - if test "$enable_libstdcxx_backtrace" == "yes"; then + if test "$enable_libstdcxx_backtrace" = "yes"; then BACKTRACE_SUPPORTED=1 - BACKTRACE_USES_MALLOC=1 + + for ac_header in sys/mman.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "sys/mman.h" "ac_cv_header_sys_mman_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_mman_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_SYS_MMAN_H 1 +_ACEOF + +fi + +done + + case "${host}" in + *-*-msdosdjgpp) # DJGPP has sys/man.h, but no mmap + have_mmap=no ;; + *-*-*) + have_mmap="$ac_cv_header_sys_mman_h" ;; + esac + + if test "$have_mmap" = "no"; then + VIEW_FILE=read.lo + ALLOC_FILE=alloc.lo + else + VIEW_FILE=mmapio.lo + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + #include <sys/mman.h> + #if !defined(MAP_ANONYMOUS) && !defined(MAP_ANON) + #error no MAP_ANONYMOUS + #endif + +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + ALLOC_FILE=mmap.lo +else + ALLOC_FILE=alloc.lo +fi +rm -f conftest.err conftest.i conftest.$ac_ext + fi + + + + BACKTRACE_USES_MALLOC=0 + if test "$ALLOC_FILE" = "alloc.lo"; then + BACKTRACE_USES_MALLOC=1 + fi + if test "$ac_has_gthreads" = "yes"; then BACKTRACE_SUPPORTS_THREADS=1 else @@ -78517,7 +78563,7 @@ else fi - if test "$enable_libstdcxx_backtrace" != no; then + if test "$enable_libstdcxx_backtrace" = yes; then ENABLE_BACKTRACE_TRUE= ENABLE_BACKTRACE_FALSE='#' else diff --git a/libstdc++-v3/doc/html/manual/setup.html b/libstdc++-v3/doc/html/manual/setup.html index 636a4401602..069354b8ce0 100644 --- a/libstdc++-v3/doc/html/manual/setup.html +++ b/libstdc++-v3/doc/html/manual/setup.html @@ -42,6 +42,39 @@ </p><p> Finally, a few system-specific requirements: </p><div class="variablelist"><dl class="variablelist"><dt><span class="term">linux</span></dt><dd><p> + The 'gnu' locale model makes use of <code class="function">iconv</code> + for character set conversions. The relevant functions are provided + by Glibc and so are always available, however they can also be + provided by the separate GNU libiconv library. If GNU libiconv is + found when GCC is built (e.g., because its headers are installed + in <code class="filename">/usr/local/include</code>) + then the <code class="filename">libstdc++.so.6</code> library will have a + run-time dependency on <code class="filename">libiconv.so.2</code>. + If you do not want that run-time dependency then you should do + one of the following: + </p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p> + Uninstall the libiconv headers before building GCC. + Glibc already provides <code class="function">iconv</code> so you should + not need libiconv anyway. + </p></li><li class="listitem"><p> + <a class="link" href="../"> + Download</a> the libiconv sources and extract them into the + top level of the GCC source tree, e.g., + </p><pre class="programlisting"> +wget https://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.16.tar.gz +tar xf libiconv-1.16.tar.gz +ln -s libiconv-1.16 libiconv +</pre><p> + This will build libiconv as part of building GCC and link to + it statically, so there is no <code class="filename">libiconv.so.2</code> + dependency. + </p></li><li class="listitem"><p> + Configure GCC with <code class="option">--with-libiconv-type=static</code>. + This requires the static <code class="filename">libiconv.a</code> library, + which is not installed by default. You might need to reinstall + libiconv using the <code class="option">--enable-static</code> configure + option to get the static library. + </p></li></ul></div><p> If GCC 3.1.0 or later on is being used on GNU/Linux, an attempt will be made to use "C" library functionality necessary for C++ named locale support. For GCC 4.6.0 and later, this diff --git a/libstdc++-v3/doc/xml/manual/intro.xml b/libstdc++-v3/doc/xml/manual/intro.xml index 86ed6964b6a..548b632b6e4 100644 --- a/libstdc++-v3/doc/xml/manual/intro.xml +++ b/libstdc++-v3/doc/xml/manual/intro.xml @@ -55,7 +55,7 @@ <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="xml" href="status_cxxtr24733.xml"> </xi:include> - <!-- Section 01.7 : Status C++ IS 24733 --> + <!-- Section 01.7 : Status C++ IS 29124 --> <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="xml" href="status_cxxis29124.xml"> </xi:include> </section> diff --git a/libstdc++-v3/doc/xml/manual/prerequisites.xml b/libstdc++-v3/doc/xml/manual/prerequisites.xml index 22e90a7e79d..8799487c821 100644 --- a/libstdc++-v3/doc/xml/manual/prerequisites.xml +++ b/libstdc++-v3/doc/xml/manual/prerequisites.xml @@ -50,6 +50,56 @@ <listitem> <para> + The 'gnu' locale model makes use of <function>iconv</function> + for character set conversions. The relevant functions are provided + by Glibc and so are always available, however they can also be + provided by the separate GNU libiconv library. If GNU libiconv is + found when GCC is built (e.g., because its headers are installed + in <filename class="directory">/usr/local/include</filename>) + then the <filename>libstdc++.so.6</filename> library will have a + run-time dependency on <filename>libiconv.so.2</filename>. + If you do not want that run-time dependency then you should do + one of the following: + </para> + <itemizedlist> + <listitem> + <para> + Uninstall the libiconv headers before building GCC. + Glibc already provides <function>iconv</function> so you should + not need libiconv anyway. + </para> + </listitem> + <listitem> + <para> + <link linkend="https://www.gnu.org/software/libiconv/#downloading"> + Download</link> the libiconv sources and extract them into the + top level of the GCC source tree, e.g., + </para> +<programlisting> +wget https://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.16.tar.gz +tar xf libiconv-1.16.tar.gz +ln -s libiconv-1.16 libiconv +</programlisting> + <para> + This will build libiconv as part of building GCC and link to + it statically, so there is no <filename>libiconv.so.2</filename> + dependency. + </para> + </listitem> + <listitem> + <para> + Configure GCC with <option>--with-libiconv-type=static</option>. + This requires the static <filename>libiconv.a</filename> library, + which is not installed by default. You might need to reinstall + libiconv using the <option>--enable-static</option> configure + option to get the static library. + </para> + </listitem> + </itemizedlist> + </listitem> + + <listitem> + <para> If GCC 3.1.0 or later on is being used on GNU/Linux, an attempt will be made to use "C" library functionality necessary for C++ named locale support. For GCC 4.6.0 and later, this diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h index 2cad8486c69..5cf217dbf28 100644 --- a/libstdc++-v3/include/bits/atomic_base.h +++ b/libstdc++-v3/include/bits/atomic_base.h @@ -252,13 +252,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload _GLIBCXX_ALWAYS_INLINE void - notify_one() const noexcept + notify_one() noexcept { std::__atomic_notify_address(&_M_i, false); } // TODO add const volatile overload _GLIBCXX_ALWAYS_INLINE void - notify_all() const noexcept + notify_all() noexcept { std::__atomic_notify_address(&_M_i, true); } // TODO add const volatile overload @@ -600,13 +600,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload _GLIBCXX_ALWAYS_INLINE void - notify_one() const noexcept + notify_one() noexcept { std::__atomic_notify_address(&_M_i, false); } // TODO add const volatile overload _GLIBCXX_ALWAYS_INLINE void - notify_all() const noexcept + notify_all() noexcept { std::__atomic_notify_address(&_M_i, true); } // TODO add const volatile overload diff --git a/libstdc++-v3/include/bits/fs_path.h b/libstdc++-v3/include/bits/fs_path.h index 9e06fa679d8..d6202fd275a 100644 --- a/libstdc++-v3/include/bits/fs_path.h +++ b/libstdc++-v3/include/bits/fs_path.h @@ -1416,6 +1416,16 @@ extern template class __shared_ptr<const filesystem::filesystem_error::_Impl>; /// @endcond +// _GLIBCXX_RESOLVE_LIB_DEFECTS +// 3657. std::hash<std::filesystem::path> is not enabled +template<> + struct hash<filesystem::path> + { + size_t + operator()(const filesystem::path& __p) const noexcept + { return filesystem::hash_value(__p); } + }; + _GLIBCXX_END_NAMESPACE_VERSION } // namespace std diff --git a/libstdc++-v3/include/bits/ptr_traits.h b/libstdc++-v3/include/bits/ptr_traits.h index c85e6d44ded..047efa5cf28 100644 --- a/libstdc++-v3/include/bits/ptr_traits.h +++ b/libstdc++-v3/include/bits/ptr_traits.h @@ -36,7 +36,10 @@ #if __cplusplus > 201703L #include <concepts> -#define __cpp_lib_constexpr_memory 201811L +# ifndef __cpp_lib_constexpr_memory +// Defined to a newer value in bits/unique_ptr.h for C++23 +# define __cpp_lib_constexpr_memory 201811L +# endif namespace __gnu_debug { struct _Safe_iterator_base; } #endif diff --git a/libstdc++-v3/include/bits/ranges_algo.h b/libstdc++-v3/include/bits/ranges_algo.h index 62dc605080a..3d30fb1428c 100644 --- a/libstdc++-v3/include/bits/ranges_algo.h +++ b/libstdc++-v3/include/bits/ranges_algo.h @@ -3084,7 +3084,7 @@ namespace ranges auto __last = ranges::end(__r); __glibcxx_assert(__first != __last); auto __comp_proj = __detail::__make_comp_proj(__comp, __proj); - minmax_result<range_value_t<_Range>> __result = {*__first, *__first}; + minmax_result<range_value_t<_Range>> __result = {*__first, __result.min}; if (++__first == __last) return __result; else diff --git a/libstdc++-v3/include/bits/shared_ptr_atomic.h b/libstdc++-v3/include/bits/shared_ptr_atomic.h index 9e4df7da7f8..ff86432f0b4 100644 --- a/libstdc++-v3/include/bits/shared_ptr_atomic.h +++ b/libstdc++-v3/include/bits/shared_ptr_atomic.h @@ -573,6 +573,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr atomic() noexcept = default; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 3661. constinit atomic<shared_ptr<T>> a(nullptr); should work + constexpr atomic(nullptr_t) noexcept : atomic() { } + atomic(shared_ptr<_Tp> __r) noexcept : _M_impl(std::move(__r)) { } diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index 8e2fcc6f49b..b4ff3989a5d 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -62,8 +62,9 @@ #if __cplusplus >= 201103L #include <initializer_list> #endif -#if __cplusplus > 201703L +#if __cplusplus >= 202002L # include <compare> +#define __cpp_lib_constexpr_vector 201907L #endif #include <debug/assertions.h> diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h index 8f4430f61f5..ad60fada59b 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -41,6 +41,14 @@ # include <ostream> #endif +#if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc +# if __cpp_lib_constexpr_memory < 202202L +// Defined with older value in bits/ptr_traits.h for C++20 +# undef __cpp_lib_constexpr_memory +# define __cpp_lib_constexpr_memory 202202L +# endif +#endif + namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION @@ -72,9 +80,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION */ template<typename _Up, typename = _Require<is_convertible<_Up*, _Tp*>>> + _GLIBCXX23_CONSTEXPR default_delete(const default_delete<_Up>&) noexcept { } /// Calls `delete __ptr` + _GLIBCXX23_CONSTEXPR void operator()(_Tp* __ptr) const { @@ -108,10 +118,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION */ template<typename _Up, typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>> + _GLIBCXX23_CONSTEXPR default_delete(const default_delete<_Up[]>&) noexcept { } /// Calls `delete[] __ptr` template<typename _Up> + _GLIBCXX23_CONSTEXPR typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type operator()(_Up* __ptr) const { @@ -152,16 +164,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION " or an lvalue reference type" ); __uniq_ptr_impl() = default; + _GLIBCXX23_CONSTEXPR __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } template<typename _Del> - __uniq_ptr_impl(pointer __p, _Del&& __d) + _GLIBCXX23_CONSTEXPR + __uniq_ptr_impl(pointer __p, _Del&& __d) : _M_t(__p, std::forward<_Del>(__d)) { } + _GLIBCXX23_CONSTEXPR __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept : _M_t(std::move(__u._M_t)) { __u._M_ptr() = nullptr; } + _GLIBCXX23_CONSTEXPR __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept { reset(__u.release()); @@ -169,11 +185,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *this; } + _GLIBCXX23_CONSTEXPR pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } + _GLIBCXX23_CONSTEXPR pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } + _GLIBCXX23_CONSTEXPR _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } + _GLIBCXX23_CONSTEXPR const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } + _GLIBCXX23_CONSTEXPR void reset(pointer __p) noexcept { const pointer __old_p = _M_ptr(); @@ -182,6 +203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_deleter()(__old_p); } + _GLIBCXX23_CONSTEXPR pointer release() noexcept { pointer __p = _M_ptr(); @@ -189,6 +211,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __p; } + _GLIBCXX23_CONSTEXPR void swap(__uniq_ptr_impl& __rhs) noexcept { @@ -281,6 +304,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * The deleter will be value-initialized. */ template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>> + _GLIBCXX23_CONSTEXPR explicit unique_ptr(pointer __p) noexcept : _M_t(__p) @@ -295,6 +319,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION */ template<typename _Del = deleter_type, typename = _Require<is_copy_constructible<_Del>>> + _GLIBCXX23_CONSTEXPR unique_ptr(pointer __p, const deleter_type& __d) noexcept : _M_t(__p, __d) { } @@ -307,6 +332,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION */ template<typename _Del = deleter_type, typename = _Require<is_move_constructible<_Del>>> + _GLIBCXX23_CONSTEXPR unique_ptr(pointer __p, __enable_if_t<!is_lvalue_reference<_Del>::value, _Del&&> __d) noexcept @@ -315,6 +341,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Del = deleter_type, typename _DelUnref = typename remove_reference<_Del>::type> + _GLIBCXX23_CONSTEXPR unique_ptr(pointer, __enable_if_t<is_lvalue_reference<_Del>::value, _DelUnref&&>) = delete; @@ -341,6 +368,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __conditional_t<is_reference<_Dp>::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>>> + _GLIBCXX23_CONSTEXPR unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } @@ -356,6 +384,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif /// Destructor, invokes the deleter if the stored pointer is not null. +#if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc + constexpr +#endif ~unique_ptr() noexcept { static_assert(__is_invocable<deleter_type&, pointer>::value, @@ -382,6 +413,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Invokes the deleter if this object owns a pointer. */ template<typename _Up, typename _Ep> + _GLIBCXX23_CONSTEXPR typename enable_if< __and_< __safe_conversion_up<_Up, _Ep>, is_assignable<deleter_type&, _Ep&&> @@ -395,6 +427,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } /// Reset the %unique_ptr to empty, invoking the deleter if necessary. + _GLIBCXX23_CONSTEXPR unique_ptr& operator=(nullptr_t) noexcept { @@ -405,6 +438,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Observers. /// Dereference the stored pointer. + _GLIBCXX23_CONSTEXPR typename add_lvalue_reference<element_type>::type operator*() const noexcept(noexcept(*std::declval<pointer>())) { @@ -413,6 +447,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } /// Return the stored pointer. + _GLIBCXX23_CONSTEXPR pointer operator->() const noexcept { @@ -421,27 +456,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } /// Return the stored pointer. + _GLIBCXX23_CONSTEXPR pointer get() const noexcept { return _M_t._M_ptr(); } /// Return a reference to the stored deleter. + _GLIBCXX23_CONSTEXPR deleter_type& get_deleter() noexcept { return _M_t._M_deleter(); } /// Return a reference to the stored deleter. + _GLIBCXX23_CONSTEXPR const deleter_type& get_deleter() const noexcept { return _M_t._M_deleter(); } /// Return @c true if the stored pointer is not null. + _GLIBCXX23_CONSTEXPR explicit operator bool() const noexcept { return get() == pointer() ? false : true; } // Modifiers. /// Release ownership of any stored pointer. + _GLIBCXX23_CONSTEXPR pointer release() noexcept { return _M_t.release(); } @@ -452,6 +492,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * * The deleter will be invoked if a pointer is already owned. */ + _GLIBCXX23_CONSTEXPR void reset(pointer __p = pointer()) noexcept { @@ -461,6 +502,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } /// Exchange the pointer and deleter with another object. + _GLIBCXX23_CONSTEXPR void swap(unique_ptr& __u) noexcept { @@ -551,6 +593,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename = _DeleterConstraint<_Vp>, typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type> + _GLIBCXX23_CONSTEXPR explicit unique_ptr(_Up __p) noexcept : _M_t(__p) @@ -567,8 +610,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Up, typename _Del = deleter_type, typename = _Require<__safe_conversion_raw<_Up>, is_copy_constructible<_Del>>> - unique_ptr(_Up __p, const deleter_type& __d) noexcept - : _M_t(__p, __d) { } + _GLIBCXX23_CONSTEXPR + unique_ptr(_Up __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } /** Takes ownership of a pointer. * @@ -581,6 +625,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Up, typename _Del = deleter_type, typename = _Require<__safe_conversion_raw<_Up>, is_move_constructible<_Del>>> + _GLIBCXX23_CONSTEXPR unique_ptr(_Up __p, __enable_if_t<!is_lvalue_reference<_Del>::value, _Del&&> __d) noexcept @@ -608,11 +653,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __conditional_t<is_reference<_Dp>::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>>> + _GLIBCXX23_CONSTEXPR unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } /// Destructor, invokes the deleter if the stored pointer is not null. +#if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc + constexpr +#endif ~unique_ptr() { auto& __ptr = _M_t._M_ptr(); @@ -638,6 +687,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Invokes the deleter if this object owns a pointer. */ template<typename _Up, typename _Ep> + _GLIBCXX23_CONSTEXPR typename enable_if<__and_<__safe_conversion_up<_Up, _Ep>, is_assignable<deleter_type&, _Ep&&> @@ -651,6 +701,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } /// Reset the %unique_ptr to empty, invoking the deleter if necessary. + _GLIBCXX23_CONSTEXPR unique_ptr& operator=(nullptr_t) noexcept { @@ -661,6 +712,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Observers. /// Access an element of owned array. + _GLIBCXX23_CONSTEXPR typename std::add_lvalue_reference<element_type>::type operator[](size_t __i) const { @@ -669,27 +721,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } /// Return the stored pointer. + _GLIBCXX23_CONSTEXPR pointer get() const noexcept { return _M_t._M_ptr(); } /// Return a reference to the stored deleter. + _GLIBCXX23_CONSTEXPR deleter_type& get_deleter() noexcept { return _M_t._M_deleter(); } /// Return a reference to the stored deleter. + _GLIBCXX23_CONSTEXPR const deleter_type& get_deleter() const noexcept { return _M_t._M_deleter(); } /// Return @c true if the stored pointer is not null. + _GLIBCXX23_CONSTEXPR explicit operator bool() const noexcept { return get() == pointer() ? false : true; } // Modifiers. /// Release ownership of any stored pointer. + _GLIBCXX23_CONSTEXPR pointer release() noexcept { return _M_t.release(); } @@ -712,14 +769,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > >> + _GLIBCXX23_CONSTEXPR void reset(_Up __p) noexcept { _M_t.reset(std::move(__p)); } + _GLIBCXX23_CONSTEXPR void reset(nullptr_t = nullptr) noexcept { reset(pointer()); } /// Exchange the pointer and deleter with another object. + _GLIBCXX23_CONSTEXPR void swap(unique_ptr& __u) noexcept { @@ -740,6 +800,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 // Constrained free swap overload, see p0185r1 + _GLIBCXX23_CONSTEXPR typename enable_if<__is_swappable<_Dp>::value>::type #else void @@ -758,41 +819,47 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Equality operator for unique_ptr objects, compares the owned pointers template<typename _Tp, typename _Dp, typename _Up, typename _Ep> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator==(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return __x.get() == __y.get(); } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept { return !__x; } #ifndef __cpp_lib_three_way_comparison /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD + inline bool operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept { return !__x; } /// Inequality operator for unique_ptr objects, compares the owned pointers template<typename _Tp, typename _Dp, typename _Up, typename _Ep> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD + inline bool operator!=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return __x.get() != __y.get(); } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD + inline bool operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept { return (bool)__x; } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD + inline bool operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept { return (bool)__x; } #endif // three way comparison @@ -800,7 +867,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Relational operator for unique_ptr objects, compares the owned pointers template<typename _Tp, typename _Dp, typename _Up, typename _Ep> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator<(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { @@ -812,7 +880,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(), @@ -821,7 +890,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr, @@ -831,34 +901,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Relational operator for unique_ptr objects, compares the owned pointers template<typename _Tp, typename _Dp, typename _Up, typename _Ep> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator<=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return !(__y < __x); } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return !(nullptr < __x); } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return !(__x < nullptr); } /// Relational operator for unique_ptr objects, compares the owned pointers template<typename _Tp, typename _Dp, typename _Up, typename _Ep> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator>(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return (__y < __x); } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr, @@ -867,7 +942,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(), @@ -877,14 +953,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Relational operator for unique_ptr objects, compares the owned pointers template<typename _Tp, typename _Dp, typename _Up, typename _Ep> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator>=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return !(__x < __y); } /// unique_ptr comparison with nullptr template<typename _Tp, typename _Dp> - _GLIBCXX_NODISCARD inline bool + _GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR + inline bool operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return !(__x < nullptr); } @@ -898,6 +976,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp, typename _Dp, typename _Up, typename _Ep> requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer, typename unique_ptr<_Up, _Ep>::pointer> + _GLIBCXX23_CONSTEXPR inline compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer, typename unique_ptr<_Up, _Ep>::pointer> @@ -907,6 +986,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp, typename _Dp> requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer> + _GLIBCXX23_CONSTEXPR inline compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer> operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) @@ -979,6 +1059,7 @@ namespace __detail * @relates unique_ptr */ template<typename _Tp, typename... _Args> + _GLIBCXX23_CONSTEXPR inline __detail::__unique_ptr_t<_Tp> make_unique(_Args&&... __args) { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } @@ -993,6 +1074,7 @@ namespace __detail * The array elements are value-initialized. */ template<typename _Tp> + _GLIBCXX23_CONSTEXPR inline __detail::__unique_ptr_array_t<_Tp> make_unique(size_t __num) { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } @@ -1014,6 +1096,7 @@ namespace __detail * @relates unique_ptr */ template<typename _Tp> + _GLIBCXX23_CONSTEXPR inline __detail::__unique_ptr_t<_Tp> make_unique_for_overwrite() { return unique_ptr<_Tp>(new _Tp); } @@ -1026,6 +1109,7 @@ namespace __detail * @relates unique_ptr */ template<typename _Tp> + _GLIBCXX23_CONSTEXPR inline __detail::__unique_ptr_array_t<_Tp> make_unique_for_overwrite(size_t __num) { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]); } diff --git a/libstdc++-v3/include/c_compatibility/stdatomic.h b/libstdc++-v3/include/c_compatibility/stdatomic.h index c97cbac984e..a51a84c2054 100644 --- a/libstdc++-v3/include/c_compatibility/stdatomic.h +++ b/libstdc++-v3/include/c_compatibility/stdatomic.h @@ -32,6 +32,8 @@ #if __cplusplus > 202002L #include <atomic> +#define __cpp_lib_stdatomic_h 202011L + #define _Atomic(_Tp) std::atomic<_Tp> using std::memory_order; diff --git a/libstdc++-v3/include/experimental/bits/fs_path.h b/libstdc++-v3/include/experimental/bits/fs_path.h index 803df424664..b0825ba76e8 100644 --- a/libstdc++-v3/include/experimental/bits/fs_path.h +++ b/libstdc++-v3/include/experimental/bits/fs_path.h @@ -212,21 +212,11 @@ namespace __detail // constructors and destructor - path() noexcept { } + path() noexcept; + path(const path& __p); + path(path&& __p) noexcept; - path(const path& __p) = default; - - path(path&& __p) noexcept - : _M_pathname(std::move(__p._M_pathname)), _M_type(__p._M_type) - { - if (_M_type == _Type::_Multi) - _M_split_cmpts(); - __p.clear(); - } - - path(string_type&& __source) - : _M_pathname(std::move(__source)) - { _M_split_cmpts(); } + path(string_type&& __source); template<typename _Source, typename _Require = __detail::_Path<_Source>> @@ -256,11 +246,11 @@ namespace __detail : _M_pathname(_S_convert_loc(__first, __last, __loc)) { _M_split_cmpts(); } - ~path() = default; + ~path(); // assignments - path& operator=(const path& __p) = default; + path& operator=(const path& __p); path& operator=(path&& __p) noexcept; path& operator=(string_type&& __source); path& assign(string_type&& __source); @@ -449,11 +439,7 @@ namespace __detail _Multi, _Root_name, _Root_dir, _Filename }; - path(string_type __str, _Type __type) : _M_pathname(__str), _M_type(__type) - { - __glibcxx_assert(!empty()); - __glibcxx_assert(_M_type != _Type::_Multi); - } + path(string_type __str, _Type __type); enum class _Split { _Stem, _Extension }; @@ -908,6 +894,37 @@ namespace __detail bool _M_at_end; // only used when type != _Multi }; + inline + path::path() noexcept = default; + + inline + path::path(const path&) = default; + + inline + path::path(path&& __p) noexcept + : _M_pathname(std::move(__p._M_pathname)), + _M_cmpts(__p._M_cmpts), + _M_type(__p._M_type) + { __p.clear(); } + + inline + path::path(string_type&& __source) + : _M_pathname(std::move(__source)) + { _M_split_cmpts(); } + + inline + path::path(string_type __str, _Type __type) + : _M_pathname(__str), _M_type(__type) + { + __glibcxx_assert(!empty()); + __glibcxx_assert(_M_type != _Type::_Multi); + } + + inline + path::~path() = default; + + inline path& + path::operator=(const path& __p) = default; inline path& path::operator=(path&& __p) noexcept diff --git a/libstdc++-v3/include/precompiled/stdc++.h b/libstdc++-v3/include/precompiled/stdc++.h index 6d6d2ad7c4c..5ee1244dc22 100644 --- a/libstdc++-v3/include/precompiled/stdc++.h +++ b/libstdc++-v3/include/precompiled/stdc++.h @@ -155,4 +155,8 @@ #if __cplusplus > 202002L #include <expected> #include <spanstream> +#if __has_include(<stacktrace>) +# include <stacktrace> +#endif +#include <stdatomic.h> #endif diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index bc57659b6e7..d819b6bf41e 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -172,11 +172,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload void - notify_one() const noexcept + notify_one() noexcept { _M_base.notify_one(); } void - notify_all() const noexcept + notify_all() noexcept { _M_base.notify_all(); } #endif // __cpp_lib_atomic_wait }; @@ -399,11 +399,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload void - notify_one() const noexcept + notify_one() noexcept { std::__atomic_notify_address(&_M_i, false); } void - notify_all() const noexcept + notify_all() noexcept { std::__atomic_notify_address(&_M_i, true); } #endif // __cpp_lib_atomic_wait @@ -654,11 +654,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // TODO add const volatile overload void - notify_one() const noexcept + notify_one() noexcept { _M_b.notify_one(); } void - notify_all() const noexcept + notify_all() noexcept { _M_b.notify_all(); } #endif // __cpp_lib_atomic_wait @@ -1434,12 +1434,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp> inline void - atomic_notify_one(const atomic<_Tp>* __a) noexcept + atomic_notify_one(atomic<_Tp>* __a) noexcept { __a->notify_one(); } template<typename _Tp> inline void - atomic_notify_all(const atomic<_Tp>* __a) noexcept + atomic_notify_all(atomic<_Tp>* __a) noexcept { __a->notify_all(); } #endif // __cpp_lib_atomic_wait diff --git a/libstdc++-v3/include/std/charconv b/libstdc++-v3/include/std/charconv index 2ce9c7d4cb9..218813e4797 100644 --- a/libstdc++-v3/include/std/charconv +++ b/libstdc++-v3/include/std/charconv @@ -407,176 +407,132 @@ namespace __detail return true; } - /// std::from_chars implementation for integers in base 2. - template<typename _Tp> + // Construct and return a lookup table that maps 0-9, A-Z and a-z to their + // corresponding base-36 value and maps all other characters to 127. + constexpr auto + __from_chars_alnum_to_val_table() + { + constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz"; + constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + struct { unsigned char __data[1u << __CHAR_BIT__] = {}; } __table; + for (auto& __entry : __table.__data) + __entry = 127; + for (int __i = 0; __i < 10; ++__i) + __table.__data['0' + __i] = __i; + for (int __i = 0; __i < 26; ++__i) + { + __table.__data[__lower_letters[__i]] = 10 + __i; + __table.__data[__upper_letters[__i]] = 10 + __i; + } + return __table; + } + + // If _DecOnly is true: if the character is a decimal digit, then + // return its corresponding base-10 value, otherwise return a value >= 127. + // If _DecOnly is false: if the character is an alphanumeric digit, then + // return its corresponding base-36 value, otherwise return a value >= 127. + template<bool _DecOnly = false> + unsigned char + __from_chars_alnum_to_val(unsigned char __c) + { + if _GLIBCXX17_CONSTEXPR (_DecOnly) + return __c - '0'; + else + { + // This initializer is deliberately made dependent in order to work + // around modules bug PR105322. + static constexpr auto __table = (_DecOnly, __from_chars_alnum_to_val_table()); + return __table.__data[__c]; + } + } + + /// std::from_chars implementation for integers in a power-of-two base. + /// If _DecOnly is true, then we may assume __base is at most 8. + template<bool _DecOnly, typename _Tp> bool - __from_chars_binary(const char*& __first, const char* __last, _Tp& __val) + __from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val, + int __base) { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); + // __glibcxx_assert((__base & (__base - 1)) == 0); + // __glibcxx_assert(_DecOnly ? __base <= 8 : __base <= 32); + const int __log2_base = __countr_zero(__base); + const ptrdiff_t __len = __last - __first; ptrdiff_t __i = 0; while (__i < __len && __first[__i] == '0') ++__i; const ptrdiff_t __leading_zeroes = __i; + if (__i >= __len) [[__unlikely__]] + { + __first += __i; + return true; + } - while (__i < __len) + // Remember the leading significant digit value if necessary. + unsigned char __leading_c = 0; + if (__base != 2) { - const unsigned char __c = (unsigned)__first[__i] - '0'; - if (__c < 2) - __val = (__val << 1) | __c; - else + __leading_c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]); + // __glibcxx_assert(__leading_c != 0); + if (__leading_c >= __base) [[__unlikely__]] + { + __first += __i; + return true; + } + __val = __leading_c; + ++__i; + } + + for (; __i < __len; ++__i) + { + const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]); + if (__c >= __base) break; - __i++; + __val = (__val << __log2_base) | __c; } __first += __i; - return (__i - __leading_zeroes) <= __gnu_cxx::__int_traits<_Tp>::__digits; + auto __significant_bits = (__i - __leading_zeroes) * __log2_base; + if (__base != 2) + // Compensate for a leading significant digit that didn't use all + // of its available bits. + __significant_bits -= __log2_base - __bit_width(__leading_c); + // __glibcxx_assert(__significant_bits >= 0); + return __significant_bits <= __gnu_cxx::__int_traits<_Tp>::__digits; } - /// std::from_chars implementation for integers in bases 3 to 10. - template<typename _Tp> + /// std::from_chars implementation for integers in any base. + /// If _DecOnly is true, then we may assume __base is at most 10. + template<bool _DecOnly, typename _Tp> bool - __from_chars_digit(const char*& __first, const char* __last, _Tp& __val, + __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, int __base) { - static_assert(is_integral<_Tp>::value, "implementation bug"); - static_assert(is_unsigned<_Tp>::value, "implementation bug"); + // __glibcxx_assert(!_DecOnly || __base <= 10); - auto __matches = [__base](char __c) { - return '0' <= __c && __c <= ('0' + (__base - 1)); - }; - - while (__first != __last) + const int __bits_per_digit = __bit_width(__base); + int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits; + for (; __first != __last; ++__first) { - const char __c = *__first; - if (__matches(__c)) - { - if (!__raise_and_add(__val, __base, __c - '0')) - { - while (++__first != __last && __matches(*__first)) - ; - return false; - } - __first++; - } - else + const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first); + if (__c >= __base) return true; - } - return true; - } - - constexpr char - __from_chars_alpha_to_num(char __c) - { - switch (__c) - { - case 'a': - case 'A': - return 10; - case 'b': - case 'B': - return 11; - case 'c': - case 'C': - return 12; - case 'd': - case 'D': - return 13; - case 'e': - case 'E': - return 14; - case 'f': - case 'F': - return 15; - case 'g': - case 'G': - return 16; - case 'h': - case 'H': - return 17; - case 'i': - case 'I': - return 18; - case 'j': - case 'J': - return 19; - case 'k': - case 'K': - return 20; - case 'l': - case 'L': - return 21; - case 'm': - case 'M': - return 22; - case 'n': - case 'N': - return 23; - case 'o': - case 'O': - return 24; - case 'p': - case 'P': - return 25; - case 'q': - case 'Q': - return 26; - case 'r': - case 'R': - return 27; - case 's': - case 'S': - return 28; - case 't': - case 'T': - return 29; - case 'u': - case 'U': - return 30; - case 'v': - case 'V': - return 31; - case 'w': - case 'W': - return 32; - case 'x': - case 'X': - return 33; - case 'y': - case 'Y': - return 34; - case 'z': - case 'Z': - return 35; - } - return 127; - } - /// std::from_chars implementation for integers in bases 11 to 36. - template<typename _Tp> - bool - __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, - int __base) - { - bool __valid = true; - while (__first != __last) - { - char __c = *__first; - if ('0' <= __c && __c <= '9') // isdigit - __c -= '0'; - else + __unused_bits_lower_bound -= __bits_per_digit; + if (__unused_bits_lower_bound >= 0) [[__likely__]] + // We're definitely not going to overflow. + __val = __val * __base + __c; + else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]] { - __c = __from_chars_alpha_to_num(__c); - if (__c >= __base) - break; + while (++__first != __last + && __from_chars_alnum_to_val<_DecOnly>(*__first) < __base) + ; + return false; } - - if (__builtin_expect(__valid, 1)) - __valid = __raise_and_add(__val, __base, __c); - __first++; } - return __valid; + return true; } template<typename _Tp> @@ -611,12 +567,17 @@ namespace __detail const auto __start = __first; bool __valid; - if (__base == 2) - __valid = __detail::__from_chars_binary(__first, __last, __val); + if ((__base & (__base - 1)) == 0) + { + if (__base <= 8) + __valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base); + else + __valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base); + } else if (__base <= 10) - __valid = __detail::__from_chars_digit(__first, __last, __val, __base); + __valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base); else - __valid = __detail::__from_chars_alnum(__first, __last, __val, __base); + __valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base); if (__builtin_expect(__first == __start, 0)) __res.ec = errc::invalid_argument; diff --git a/libstdc++-v3/include/std/expected b/libstdc++-v3/include/std/expected index 39d07cda4a9..3446d6dbaed 100644 --- a/libstdc++-v3/include/std/expected +++ b/libstdc++-v3/include/std/expected @@ -95,7 +95,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION class bad_expected_access : public bad_expected_access<void> { public: explicit - bad_expected_access(_Er __e) : _M_val(__e) { } + bad_expected_access(_Er __e) : _M_val(std::move(__e)) { } // XXX const char* what() const noexcept override; @@ -966,8 +966,8 @@ namespace __expected } template<typename _Up, typename _Gr> - requires is_void_v<_Tp> - && is_constructible_v<_Er, const _Gr&> + requires is_void_v<_Up> + && is_constructible_v<_Er, _Gr> && (!__cons_from_expected<_Up, _Gr>) constexpr explicit(!is_convertible_v<_Gr, _Er>) expected(expected<_Up, _Gr>&& __x) @@ -1104,6 +1104,7 @@ namespace __expected std::construct_at(__builtin_addressof(_M_unex), std::move(__x._M_unex)); // might throw std::destroy_at(__builtin_addressof(__x._M_unex)); + _M_has_value = false; __x._M_has_value = true; } } @@ -1115,6 +1116,7 @@ namespace __expected std::move(_M_unex)); // might throw std::destroy_at(__builtin_addressof(_M_unex)); _M_has_value = true; + __x._M_has_value = false; } else { diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index cba40dc0883..a9268cade91 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -1622,6 +1622,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } }; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 3117. Missing packaged_task deduction guides +#if __cpp_deduction_guides >= 201606 + template<typename _Res, typename... _ArgTypes> + packaged_task(_Res(*)(_ArgTypes...)) -> packaged_task<_Res(_ArgTypes...)>; + + template<typename _Fun, typename _Signature = typename + __function_guide_helper<decltype(&_Fun::operator())>::type> + packaged_task(_Fun) -> packaged_task<_Signature>; +#endif + /// swap template<typename _Res, typename... _ArgTypes> inline void diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional index d6aece45fbf..791ef6f1994 100644 --- a/libstdc++-v3/include/std/optional +++ b/libstdc++-v3/include/std/optional @@ -60,10 +60,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * @{ */ -#if __cplusplus == 201703L -# define __cpp_lib_optional 201606L -#else +#if __cplusplus > 202002L && __cpp_lib_concepts +# define __cpp_lib_optional 202110L +#elif __cplusplus >= 202002L # define __cpp_lib_optional 202106L +#else +# define __cpp_lib_optional 201606L #endif template<typename _Tp> @@ -1043,9 +1045,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return static_cast<_Tp>(std::forward<_Up>(__u)); } -#if __cplusplus > 202002L && __cpp_lib_concepts -#define __cpp_lib_monadic_optional 202110L - +#if __cpp_lib_optional >= 202110L // [optional.monadic] template<typename _Fn> diff --git a/libstdc++-v3/include/std/stacktrace b/libstdc++-v3/include/std/stacktrace index 623f44bdca4..98ce9231150 100644 --- a/libstdc++-v3/include/std/stacktrace +++ b/libstdc++-v3/include/std/stacktrace @@ -30,12 +30,14 @@ #if __cplusplus > 202002L && _GLIBCXX_HAVE_STACKTRACE #include <compare> +#include <new> #include <string> #include <sstream> #include <bits/stl_algobase.h> #include <bits/stl_algo.h> #include <bits/stl_iterator.h> #include <bits/stl_uninitialized.h> +#include <ext/numeric_traits.h> #include <cxxabi.h> struct __glibcxx_backtrace_state; @@ -232,43 +234,75 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // [stacktrace.basic.ctor], creation and assignment + [[__gnu__::__noinline__]] static basic_stacktrace current(const allocator_type& __alloc = allocator_type()) noexcept { - return current(0, size_type(-1), __alloc); + basic_stacktrace __ret(__alloc); + if (auto __cb = __ret._M_prepare()) [[likely]] + { + auto __state = stacktrace_entry::_S_init(); + if (__glibcxx_backtrace_simple(__state, 1, __cb, nullptr, + std::__addressof(__ret))) + __ret._M_clear(); + } + return __ret; } + [[__gnu__::__noinline__]] static basic_stacktrace current(size_type __skip, const allocator_type& __alloc = allocator_type()) noexcept { - return current(__skip, size_type(-1), __alloc); + basic_stacktrace __ret(__alloc); + if (__skip >= __INT_MAX__) [[unlikely]] + return __ret; + if (auto __cb = __ret._M_prepare()) [[likely]] + { + auto __state = stacktrace_entry::_S_init(); + if (__glibcxx_backtrace_simple(__state, __skip + 1, __cb, nullptr, + std::__addressof(__ret))) + __ret._M_clear(); + } + + return __ret; } + [[__gnu__::__noinline__]] static basic_stacktrace current(size_type __skip, size_type __max_depth, const allocator_type& __alloc = allocator_type()) noexcept { __glibcxx_assert(__skip <= (size_type(-1) - __max_depth)); - auto __state = stacktrace_entry::_S_init(); basic_stacktrace __ret(__alloc); - if (!__ret._M_reserve(std::min<int>(__max_depth, 64))) + if (__max_depth == 0) [[unlikely]] return __ret; - - auto __cb = [](void* __data, uintptr_t __pc) { - auto& __s = *static_cast<basic_stacktrace*>(__data); - stacktrace_entry __f; - __f._M_pc = __pc; - if (__s._M_push_back(__f)) - return 0; - return 1; - }; - - if (__glibcxx_backtrace_simple(__state, __skip, +__cb, nullptr, - std::__addressof(__ret))) + if (__skip >= __INT_MAX__) [[unlikely]] + return __ret; + if (auto __cb = __ret._M_prepare(__max_depth)) [[likely]] { - __ret._M_clear(); + auto __state = stacktrace_entry::_S_init(); + int __err = __glibcxx_backtrace_simple(__state, __skip + 1, __cb, + nullptr, + std::__addressof(__ret)); + if (__err < 0) + __ret._M_clear(); + else if (__ret.size() > __max_depth) + { + __ret._M_impl._M_resize(__max_depth, __ret._M_alloc); + + if (__ret._M_impl._M_capacity / 2 >= __max_depth) + { + // shrink to fit + _Impl __tmp = __ret._M_impl._M_clone(__ret._M_alloc); + if (__tmp._M_capacity) + { + __ret._M_clear(); + __ret._M_impl = __tmp; + } + } + } } return __ret; } @@ -283,7 +317,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } basic_stacktrace(const basic_stacktrace& __other) noexcept - : basic_stacktrace(__other, __other._M_alloc) + : basic_stacktrace(__other, + _AllocTraits::select_on_container_copy_construction(__other._M_alloc)) { } basic_stacktrace(basic_stacktrace&& __other) noexcept @@ -296,11 +331,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : _M_alloc(__alloc) { if (const auto __s = __other._M_impl._M_size) - if (auto __f = _M_impl._M_allocate(_M_alloc, __s)) - { - std::uninitialized_copy_n(__other.begin(), __s, __f); - _M_impl._M_size = __s; - } + _M_impl = __other._M_impl._M_clone(_M_alloc); } basic_stacktrace(basic_stacktrace&& __other, @@ -308,13 +339,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : _M_alloc(__alloc) { if constexpr (_Allocator::is_always_equal::value) - { - _M_impl = std::__exchange(__other._M_impl, {}); - } + _M_impl = std::__exchange(__other._M_impl, {}); else if (_M_alloc == __other._M_alloc) - { - _M_impl = std::__exchange(__other._M_impl, {}); - } + _M_impl = std::__exchange(__other._M_impl, {}); + else if (const auto __s = __other._M_impl._M_size) + _M_impl = __other._M_impl._M_clone(_M_alloc); } basic_stacktrace& @@ -343,25 +372,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Need to allocate new storage. _M_clear(); - // Use the allocator we will have after this function returns. - auto& __alloc = __pocca ? __other._M_alloc : _M_alloc; - if (auto __f = _M_impl._M_allocate(__alloc, __s)) - { - std::uninitialized_copy_n(__other.begin(), __s, __f); - _M_impl._M_size = __s; - } + if constexpr (__pocca) + _M_alloc = __other._M_alloc; + + _M_impl = __other._M_impl._M_clone(_M_alloc); } else { - // Current storage is large enough and can be freed by whichever - // allocator we will have after this function returns. - auto __to = std::copy_n(__other.begin(), __s, begin()); - std::destroy(__to, end()); - _M_impl._M_size = __s; - } + // Current storage is large enough. + _M_impl._M_resize(0, _M_alloc); + _M_impl._M_assign(__other._M_impl, _M_alloc); - if constexpr (__pocca) - _M_alloc = __other._M_alloc; + if constexpr (__pocca) + _M_alloc = __other._M_alloc; + } return *this; } @@ -379,31 +403,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::swap(_M_impl, __other._M_impl); else if (_M_alloc == __other._M_alloc) std::swap(_M_impl, __other._M_impl); - else + else if constexpr (__pocma) { - const auto __s = __other.size(); + // Free current storage and take ownership of __other's storage. + _M_clear(); + _M_impl = std::__exchange(__other._M_impl, {}); + } + else // Allocators are unequal and don't propagate. + { + const size_type __s = __other.size(); - if constexpr (__pocma || _M_impl._M_capacity < __s) + if (_M_impl._M_capacity < __s) { // Need to allocate new storage. _M_clear(); - - // Use the allocator we will have after this function returns. - auto& __alloc = __pocma ? __other._M_alloc : _M_alloc; - if (auto __f = _M_impl._M_allocate(__alloc, __s)) - std::uninitialized_copy_n(__other.begin(), __s, __f); + _M_impl = __other._M_impl._M_clone(_M_alloc); } else { // Current storage is large enough. - auto __first = __other.begin(); - auto __mid = __first + std::min(__s, _M_impl._M_size); - auto __last = __other.end(); - auto __to = std::copy(__first, __mid, begin()); - __to = std::uninitialized_copy(__mid, __last, __to); - std::destroy(__to, end()); + _M_impl._M_resize(0, _M_alloc); + _M_impl._M_assign(__other._M_impl, _M_alloc); } - _M_impl._M_size = __s; } if constexpr (__pocma) @@ -443,7 +464,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION [[nodiscard]] bool empty() const noexcept { return size() == 0; } size_type size() const noexcept { return _M_impl._M_size; } - size_type max_size() const noexcept { return size_type(-1); } + + size_type + max_size() const noexcept + { return _Impl::_S_max_size(_M_impl._M_alloc); } const_reference operator[](size_type __n) const noexcept @@ -482,19 +506,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void swap(basic_stacktrace& __other) noexcept { - std::swap(_M_impl. __other._M_impl); + std::swap(_M_impl, __other._M_impl); if constexpr (_AllocTraits::propagate_on_container_swap::value) std::swap(_M_alloc, __other._M_alloc); + else if constexpr (!_AllocTraits::is_always_equal::value) + { + __glibcxx_assert(_M_alloc == __other._M_alloc); + } } private: bool - _M_reserve(size_type __n) noexcept - { - return _M_impl._M_allocate(_M_alloc, __n) != nullptr; - } - - bool _M_push_back(const value_type& __x) noexcept { return _M_impl._M_push_back(_M_alloc, __x); @@ -503,10 +525,43 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void _M_clear() noexcept { - _M_impl._M_destroy(); + _M_impl._M_resize(0, _M_alloc); _M_impl._M_deallocate(_M_alloc); } + // Precondition: __max_depth != 0 + auto + _M_prepare(size_type __max_depth = -1) noexcept + -> int (*) (void*, uintptr_t) + { + auto __cb = +[](void* __data, uintptr_t __pc) { + auto& __s = *static_cast<basic_stacktrace*>(__data); + stacktrace_entry __f; + __f._M_pc = __pc; + if (__s._M_push_back(__f)) [[likely]] + return 0; // continue tracing + return -1; // stop tracing due to error + }; + + if (__max_depth > 128) + __max_depth = 64; // soft limit, _M_push_back will reallocate + else + __cb = [](void* __data, uintptr_t __pc) { + auto& __s = *static_cast<basic_stacktrace*>(__data); + stacktrace_entry __f; + __f._M_pc = __pc; + if (__s.size() == __s._M_impl._M_capacity) [[unlikely]] + return 1; // stop tracing due to reaching max depth + if (__s._M_push_back(__f)) [[likely]] + return 0; // continue tracing + return -1; // stop tracing due to error + }; + + if (_M_impl._M_allocate(_M_alloc, __max_depth)) [[likely]] + return __cb; + return nullptr; + } + struct _Impl { using pointer = typename _AllocTraits::pointer; @@ -515,21 +570,51 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION size_type _M_size = 0; size_type _M_capacity = 0; - // Precondition: _M_frames == nullptr + static size_type + _S_max_size(const allocator_type& __alloc) noexcept + { + const size_t __size_max = __gnu_cxx::__int_traits<size_type>::__max; + const size_t __alloc_max = _AllocTraits::max_size(__alloc); + return std::min(__size_max, __alloc_max); + } + +#if __has_builtin(__builtin_operator_new) >= 201802L +# define _GLIBCXX_OPERATOR_NEW __builtin_operator_new +# define _GLIBCXX_OPERATOR_DELETE __builtin_operator_delete +#else +# define _GLIBCXX_OPERATOR_NEW ::operator new +# define _GLIBCXX_OPERATOR_DELETE ::operator delete +#endif + + // Precondition: _M_frames == nullptr && __n != 0 pointer _M_allocate(allocator_type& __alloc, size_type __n) noexcept { - __try + if (__n <= _S_max_size(__alloc)) [[likely]] { - _M_frames = __n ? __alloc.allocate(__n) : nullptr; + if constexpr (is_same_v<allocator_type, allocator<value_type>>) + { + __n *= sizeof(value_type); + void* const __p = _GLIBCXX_OPERATOR_NEW (__n, nothrow_t{}); + if (__p == nullptr) [[unlikely]] + return nullptr; + _M_frames = static_cast<pointer>(__p); + } + else + { + __try + { + _M_frames = __alloc.allocate(__n); + } + __catch (const std::bad_alloc&) + { + return nullptr; + } + } _M_capacity = __n; + return _M_frames; } - __catch (...) - { - _M_frames = nullptr; - _M_capacity = 0; - } - return _M_frames; + return nullptr; } void @@ -537,38 +622,72 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (_M_capacity) { - __alloc.deallocate(_M_frames, _M_capacity); + if constexpr (is_same_v<allocator_type, allocator<value_type>>) + _GLIBCXX_OPERATOR_DELETE (static_cast<void*>(_M_frames), + _M_capacity * sizeof(value_type)); + else + __alloc.deallocate(_M_frames, _M_capacity); _M_frames = nullptr; _M_capacity = 0; } } +#undef _GLIBCXX_OPERATOR_DELETE +#undef _GLIBCXX_OPERATOR_NEW + + // Precondition: __n <= _M_size void - _M_destroy() noexcept + _M_resize(size_type __n, allocator_type& __alloc) noexcept { - std::destroy_n(_M_frames, _M_size); - _M_size = 0; + for (size_type __i = __n; __i < _M_size; ++__i) + _AllocTraits::destroy(__alloc, &_M_frames[__i]); + _M_size = __n; } bool _M_push_back(allocator_type& __alloc, const stacktrace_entry& __f) noexcept { - if (_M_size == _M_capacity) + if (_M_size == _M_capacity) [[unlikely]] { - _Impl __tmp; - if (auto __f = __tmp._M_allocate(__alloc, _M_capacity * 2)) - std::uninitialized_copy_n(_M_frames, _M_size, __f); - else + _Impl __tmp = _M_xclone(_M_capacity ? _M_capacity : 8, __alloc); + if (!__tmp._M_capacity) [[unlikely]] return false; + _M_resize(0, __alloc); _M_deallocate(__alloc); - std::swap(*this, __tmp); + *this = __tmp; } stacktrace_entry* __addr = std::to_address(_M_frames + _M_size++); - std::construct_at(__addr, __f); + _AllocTraits::construct(__alloc, __addr, __f); return true; } + // Precondition: _M_size != 0 + _Impl + _M_clone(allocator_type& __alloc) const noexcept + { + return _M_xclone(_M_size, __alloc); + } + + // Precondition: _M_size != 0 || __extra != 0 + _Impl + _M_xclone(size_type __extra, allocator_type& __alloc) const noexcept + { + _Impl __i; + if (__i._M_allocate(__alloc, _M_size + __extra)) [[likely]] + __i._M_assign(*this, __alloc); + return __i; + } + + // Precondition: _M_capacity >= __other._M_size + void + _M_assign(const _Impl& __other, allocator_type& __alloc) noexcept + { + std::__uninitialized_copy_a(__other._M_frames, + __other._M_frames + __other._M_size, + _M_frames, __alloc); + _M_size = __other._M_size; + } }; [[no_unique_address]] allocator_type _M_alloc{}; diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index 51f2110b68e..22280e1a349 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -257,6 +257,7 @@ #define __cpp_lib_constexpr_string_view 201811L #define __cpp_lib_constexpr_tuple 201811L #define __cpp_lib_constexpr_utility 201811L +#define __cpp_lib_constexpr_vector 201907L #define __cpp_lib_erase_if 202002L #define __cpp_lib_generic_unordered_lookup 201811L #define __cpp_lib_interpolate 201902L @@ -306,13 +307,18 @@ #if _GLIBCXX_HOSTED #define __cpp_lib_adaptor_iterator_pair_constructor 202106L +#if __cpp_constexpr_dynamic_alloc +# undef __cpp_lib_constexpr_memory +# define __cpp_lib_constexpr_memory 202202L +#endif #if __cpp_concepts >= 202002L # define __cpp_lib_expected 202202L #endif #define __cpp_lib_invoke_r 202106L #define __cpp_lib_ios_noreplace 202200L #if __cpp_lib_concepts -# define __cpp_lib_monadic_optional 202110L +# undef __cpp_lib_optional +# define __cpp_lib_optional 202110L #endif #define __cpp_lib_move_only_function 202110L #if __cpp_lib_span @@ -321,6 +327,7 @@ #if _GLIBCXX_HAVE_STACKTRACE # define __cpp_lib_stacktrace 202011L #endif +#define __cpp_lib_stdatomic_h 202011L #define __cpp_lib_string_contains 202011L #if _GLIBCXX_USE_CXX11_ABI // Only supported with cxx11-abi # define __cpp_lib_string_resize_and_overwrite 202110L diff --git a/libstdc++-v3/python/libstdcxx/v6/printers.py b/libstdc++-v3/python/libstdcxx/v6/printers.py index f7a7f9961a7..0bd793c0897 100644 --- a/libstdc++-v3/python/libstdcxx/v6/printers.py +++ b/libstdc++-v3/python/libstdcxx/v6/printers.py @@ -218,7 +218,7 @@ class SmartPtrIterator(Iterator): return ('get()', val) class SharedPointerPrinter: - "Print a shared_ptr or weak_ptr" + "Print a shared_ptr, weak_ptr, atomic<shared_ptr>, or atomic<weak_ptr>" def __init__ (self, typename, val): self.typename = strip_versioned_namespace(typename) @@ -228,9 +228,21 @@ class SharedPointerPrinter: def children (self): return SmartPtrIterator(self.pointer) + # Return the _Sp_counted_base<>* that holds the refcounts. + def _get_refcounts (self): + if self.typename == 'std::atomic': + # A tagged pointer is stored as uintptr_t. + ptr_val = self.val['_M_refcount']['_M_val']['_M_i'] + ptr_val = ptr_val - (ptr_val % 2) # clear lock bit + ptr_type = find_type(self.val['_M_refcount'].type, 'pointer') + return ptr_val.cast(ptr_type) + return self.val['_M_refcount']['_M_pi'] + def to_string (self): state = 'empty' - refcounts = self.val['_M_refcount']['_M_pi'] + refcounts = self._get_refcounts() + targ = self.val.type.template_argument(0) + if refcounts != 0: usecount = refcounts['_M_use_count'] weakcount = refcounts['_M_weak_count'] @@ -238,7 +250,7 @@ class SharedPointerPrinter: state = 'expired, weak count %d' % weakcount else: state = 'use count %d, weak count %d' % (usecount, weakcount - 1) - return '%s<%s> (%s)' % (self.typename, str(self.val.type.template_argument(0)), state) + return '%s<%s> (%s)' % (self.typename, str(targ), state) def _tuple_impl_get(val): "Return the tuple element stored in a _Tuple_impl<N, T> base class." @@ -1654,6 +1666,94 @@ class StdRegexStatePrinter: s = "{}, {}={}".format(s, v, self.val['_M_' + v]) return "{%s}" % (s) +class StdSpanPrinter: + "Print a std::span" + + class iterator(Iterator): + def __init__(self, begin, size): + self.count = 0 + self.begin = begin + self.size = size + + def __iter__ (self): + return self + + def __next__ (self): + if self.count == self.size: + raise StopIteration + + count = self.count + self.count = self.count + 1 + return '[%d]' % count, (self.begin + count).dereference() + + def __init__(self, typename, val): + self.typename = typename + self.val = val + if val.type.template_argument(1) == gdb.parse_and_eval('static_cast<std::size_t>(-1)'): + self.size = val['_M_extent']['_M_extent_value'] + else: + self.size = val.type.template_argument(1) + + def to_string(self): + return '%s of length %d' % (self.typename, self.size) + + def children(self): + return self.iterator(self.val['_M_ptr'], self.size) + + def display_hint(self): + return 'array' + +class StdInitializerListPrinter: + "Print a std::initializer_list" + + def __init__(self, typename, val): + self.typename = typename + self.val = val + self.size = val['_M_len'] + + def to_string(self): + return '%s of length %d' % (self.typename, self.size) + + def children(self): + return StdSpanPrinter.iterator(self.val['_M_array'], self.size) + + def display_hint(self): + return 'array' + +class StdAtomicPrinter: + "Print a std:atomic" + + def __init__(self, typename, val): + self.typename = typename + self.val = val + self.shptr_printer = None + self.value_type = self.val.type.template_argument(0) + if self.value_type.tag is not None: + typ = strip_versioned_namespace(self.value_type.tag) + if typ.startswith('std::shared_ptr<') or typ.startswith('std::weak_ptr<'): + impl = val['_M_impl'] + self.shptr_printer = SharedPointerPrinter(typename, impl) + self.children = self._shptr_children + + def _shptr_children(self): + return SmartPtrIterator(self.shptr_printer.pointer) + + def to_string(self): + if self.shptr_printer is not None: + return self.shptr_printer.to_string() + + if self.value_type.code == gdb.TYPE_CODE_INT: + val = self.val['_M_i'] + elif self.value_type.code == gdb.TYPE_CODE_FLT: + val = self.val['_M_fp'] + elif self.value_type.code == gdb.TYPE_CODE_PTR: + val = self.val['_M_b']['_M_p'] + elif self.value_type.code == gdb.TYPE_CODE_BOOL: + val = self.val['_M_base']['_M_i'] + else: + val = self.val['_M_i'] + return '%s<%s> = { %s }' % (self.typename, str(self.value_type), val) + # A "regular expression" printer which conforms to the # "SubPrettyPrinter" protocol from gdb.printing. class RxPrinter(object): @@ -2119,6 +2219,10 @@ def build_libstdcxx_dictionary (): libstdcxx_printer.add_version('std::tr1::', 'unordered_multiset', Tr1UnorderedSetPrinter) + libstdcxx_printer.add_version('std::', 'initializer_list', + StdInitializerListPrinter) + libstdcxx_printer.add_version('std::', 'atomic', StdAtomicPrinter) + # std::regex components libstdcxx_printer.add_version('std::__detail::', '_State', StdRegexStatePrinter) @@ -2170,6 +2274,7 @@ def build_libstdcxx_dictionary (): libstdcxx_printer.add_version('std::', 'partial_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'weak_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'strong_ordering', StdCmpCatPrinter) + libstdcxx_printer.add_version('std::', 'span', StdSpanPrinter) # Extensions. libstdcxx_printer.add_version('__gnu_cxx::', 'slist', StdSlistPrinter) diff --git a/libstdc++-v3/src/Makefile.am b/libstdc++-v3/src/Makefile.am index 18f57632c3d..9c3f4aca655 100644 --- a/libstdc++-v3/src/Makefile.am +++ b/libstdc++-v3/src/Makefile.am @@ -278,7 +278,9 @@ CXXLINK = \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CXX) \ $(VTV_CXXLINKFLAGS) \ - $(OPT_LDFLAGS) $(SECTION_LDFLAGS) $(AM_CXXFLAGS) $(LTLDFLAGS) -o $@ + $(OPT_LDFLAGS) $(SECTION_LDFLAGS) $(AM_CXXFLAGS) \ + $(LTLDFLAGS) $(LTLIBICONV) \ + -o $@ # Symbol versioning for shared libraries. if ENABLE_SYMVERS diff --git a/libstdc++-v3/src/Makefile.in b/libstdc++-v3/src/Makefile.in index eeafb892386..4a06f6cfec1 100644 --- a/libstdc++-v3/src/Makefile.in +++ b/libstdc++-v3/src/Makefile.in @@ -643,7 +643,9 @@ CXXLINK = \ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CXX) \ $(VTV_CXXLINKFLAGS) \ - $(OPT_LDFLAGS) $(SECTION_LDFLAGS) $(AM_CXXFLAGS) $(LTLDFLAGS) -o $@ + $(OPT_LDFLAGS) $(SECTION_LDFLAGS) $(AM_CXXFLAGS) \ + $(LTLDFLAGS) $(LTLIBICONV) \ + -o $@ @ENABLE_SYMVERS_TRUE@CLEANFILES = libstdc++-symbols.ver $(version_dep) @ENABLE_SYMVERS_DARWIN_TRUE@@ENABLE_SYMVERS_TRUE@version_arg = -Wl,-exported_symbols_list,libstdc++-symbols.explist diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc b/libstdc++-v3/src/c++17/floating_from_chars.cc index 4aa2483bc28..13de1e346ab 100644 --- a/libstdc++-v3/src/c++17/floating_from_chars.cc +++ b/libstdc++-v3/src/c++17/floating_from_chars.cc @@ -30,6 +30,7 @@ // Prefer to use std::pmr::string if possible, which requires the cxx11 ABI. #define _GLIBCXX_USE_CXX11_ABI 1 +#include <array> #include <charconv> #include <bit> #include <string> @@ -101,7 +102,6 @@ namespace return m_buf + std::__exchange(m_bytes, m_bytes + bytes); __glibcxx_assert(m_ptr == nullptr); - __glibcxx_assert(alignment != 1); m_ptr = operator new(bytes); m_bytes = bytes; @@ -451,30 +451,34 @@ namespace #endif // USE_STRTOD_FOR_FROM_CHARS #if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 - // If the given ASCII character represents a hexit, return that hexit. - // Otherwise return -1. - int - ascii_to_hexit(char ch) - { - if (ch >= '0' && ch <= '9') - return ch - '0'; - if (ch >= 'a' && ch <= 'f') - return ch - 'a' + 10; - if (ch >= 'A' && ch <= 'F') - return ch - 'A' + 10; - return -1; - } - // Return true iff [FIRST,LAST) begins with PREFIX, ignoring case. + // PREFIX is assumed to not contain any uppercase letters. bool starts_with_ci(const char* first, const char* last, string_view prefix) { __glibcxx_requires_valid_range(first, last); - for (char ch : prefix) + // A lookup table that maps uppercase letters to lowercase and + // is otherwise the identity mapping. + static constexpr auto upper_to_lower_table = [] { + constexpr unsigned char lower_letters[27] = "abcdefghijklmnopqrstuvwxyz"; + constexpr unsigned char upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + std::array<unsigned char, (1u << __CHAR_BIT__)> table = {}; + for (unsigned i = 0; i < table.size(); ++i) + table[i] = i; + for (unsigned i = 0; i < 26; ++i) + table[upper_letters[i]] = lower_letters[i]; + return table; + }(); + + if (last - first < static_cast<ptrdiff_t>(prefix.length())) + return false; + + for (const unsigned char pch : prefix) { - __glibcxx_assert(ch >= 'a' && ch <= 'z'); - if (first == last || (*first != ch && *first != ch - 32)) + // __glibcxx_assert(pch == upper_to_lower_table[pch]); + const unsigned char ch = *first; + if (ch != pch && upper_to_lower_table[ch] != pch) return false; ++first; } @@ -550,10 +554,8 @@ namespace ++first; break; } - else if ((ch >= '0' && ch <= '9') - || (ch >= 'a' && ch <= 'z') - || (ch >= 'A' && ch <= 'Z') - || ch == '_') + else if (ch == '_' + || __detail::__from_chars_alnum_to_val(ch) < 127) continue; else { @@ -614,8 +616,8 @@ namespace continue; } - int hexit = ascii_to_hexit(ch); - if (hexit == -1) + int hexit = __detail::__from_chars_alnum_to_val(ch); + if (hexit >= 16) break; seen_hexit = true; diff --git a/libstdc++-v3/src/c++17/floating_to_chars.cc b/libstdc++-v3/src/c++17/floating_to_chars.cc index 66bd457cbe2..4599d68a39c 100644 --- a/libstdc++-v3/src/c++17/floating_to_chars.cc +++ b/libstdc++-v3/src/c++17/floating_to_chars.cc @@ -22,9 +22,6 @@ // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. -// Activate __glibcxx_assert within this file to shake out any bugs. -#define _GLIBCXX_ASSERTIONS 1 - #include <charconv> #include <bit> @@ -1114,6 +1111,7 @@ template<typename T> } __glibcxx_assert(false); + __builtin_unreachable(); } template<typename T> @@ -1202,6 +1200,8 @@ template<typename T> effective_precision = min(precision, max_eff_scientific_precision); output_specifier = "%.*Lg"; } + else + __builtin_unreachable(); const int excess_precision = (fmt != chars_format::general ? precision - effective_precision : 0); @@ -1234,6 +1234,8 @@ template<typename T> output_length_upper_bound = sign + strlen("0"); output_length_upper_bound += sizeof(radix) + effective_precision; } + else + __builtin_unreachable(); // Do the sprintf into the local buffer. char buffer[output_length_upper_bound+1]; @@ -1570,6 +1572,7 @@ template<typename T> } __glibcxx_assert(false); + __builtin_unreachable(); } // Define the overloads for float. diff --git a/libstdc++-v3/src/c++17/fs_ops.cc b/libstdc++-v3/src/c++17/fs_ops.cc index 4552a730bf2..435368fa5c5 100644 --- a/libstdc++-v3/src/c++17/fs_ops.cc +++ b/libstdc++-v3/src/c++17/fs_ops.cc @@ -408,8 +408,12 @@ fs::copy(const path& from, const path& to, copy_options options, // set an unused bit in options to disable further recursion if (!is_set(options, copy_options::recursive)) options |= static_cast<copy_options>(4096); - for (const directory_entry& x : directory_iterator(from)) - copy(x.path(), to/x.path().filename(), options, ec); + for (const directory_entry& x : directory_iterator(from, ec)) + { + copy(x.path(), to/x.path().filename(), options, ec); + if (ec) + return; + } } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2683. filesystem::copy() says "no effects" diff --git a/libstdc++-v3/src/filesystem/ops.cc b/libstdc++-v3/src/filesystem/ops.cc index e2a2cefdf49..98ddff5a66e 100644 --- a/libstdc++-v3/src/filesystem/ops.cc +++ b/libstdc++-v3/src/filesystem/ops.cc @@ -350,8 +350,12 @@ fs::copy(const path& from, const path& to, copy_options options, // set an unused bit in options to disable further recursion if (!is_set(options, copy_options::recursive)) options |= static_cast<copy_options>(4096); - for (const directory_entry& x : directory_iterator(from)) - copy(x.path(), to/x.path().filename(), options, ec); + for (const directory_entry& x : directory_iterator(from, ec)) + { + copy(x.path(), to/x.path().filename(), options, ec); + if (ec) + return; + } } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2683. filesystem::copy() says "no effects" diff --git a/libstdc++-v3/testsuite/19_diagnostics/stacktrace/current.cc b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/current.cc new file mode 100644 index 00000000000..184e23b460e --- /dev/null +++ b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/current.cc @@ -0,0 +1,86 @@ +// { dg-options "-std=gnu++23 -lstdc++_libbacktrace" } +// { dg-do run { target c++23 } } +// { dg-require-effective-target stacktrace } + +#include <stacktrace> +#include <memory> +#include <new> +#include "testsuite_hooks.h" + +template<typename T> +struct Allocator +{ + using value_type = T; + using propagate_on_container_move_assignment = std::true_type; + + explicit + Allocator(unsigned max = -1u) : max_size(max) { } + + template<typename U> + Allocator(const Allocator<U>& a) : max_size(a.max_size) { } + + T* + allocate(std::size_t n) + { + if (n > max_size) + throw std::bad_alloc(); + + return std::allocator<T>().allocate(n); + } + + void + deallocate(T* p, std::size_t n) noexcept + { + std::allocator<T>().deallocate(p, n); + } + + bool operator==(const Allocator&) const = default; + +private: + unsigned max_size; +}; + +[[gnu::optimize("O0")]] +void +test_max_depth() +{ + using Stacktrace = std::basic_stacktrace<Allocator<std::stacktrace_entry>>; + using Alloc = typename Stacktrace::allocator_type; + + [] { [] { [] { [] { [] { [] { [] { [] { + auto t = Stacktrace::current(); + VERIFY( ! t.empty() ); + const auto n = t.size(); // total number of frames + t = Stacktrace::current(8); + VERIFY( t.size() == (n - 8) ); + t = Stacktrace::current(n); + VERIFY( t.empty() ); + t = Stacktrace::current(n - 2); + VERIFY( t.size() == 2 ); + t = Stacktrace::current(2, 6); + VERIFY( t.size() == 6 ); + t = Stacktrace::current(n - 2, 6); + VERIFY( t.size() == 2 ); + + t = Stacktrace::current(Alloc(3)); + // Full stacktrace is larger than 3 frames, so allocation fails: + VERIFY( t.empty() ); + t = Stacktrace::current(3, Alloc(2)); + // Stacktrace still too large after skipping 3 frames, so allocation fails: + VERIFY( t.empty() ); + t = Stacktrace::current(0, 3, Alloc(3)); + // Capacity for exactly 3 frames is allocated: + VERIFY( t.size() == 3 ); + t = Stacktrace::current(2, 4, Alloc(4)); + // Capacity for exactly 4 frames is allocated: + VERIFY( t.size() == 4 ); + t = Stacktrace::current(0, 4, Alloc(3)); + // Capacity for exactly 4 frames is requested, but allocation fails: + VERIFY( t.empty() ); + }(); }(); }(); }(); }(); }(); }(); }(); +} + +int main() +{ + test_max_depth(); +} diff --git a/libstdc++-v3/testsuite/20_util/stacktrace/entry.cc b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/entry.cc index 0bbcabd8fae..a222c425b20 100644 --- a/libstdc++-v3/testsuite/20_util/stacktrace/entry.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/entry.cc @@ -36,7 +36,8 @@ test_members() VERIFY( e1 != e2 ); VERIFY( e1.description() == e2.description() ); VERIFY( e1.source_file() == e2.source_file() ); - VERIFY( e1.source_line() != e2.source_line() ); + VERIFY( e1.source_line() == (__LINE__ - 5) ); + VERIFY( e2.source_line() == (__LINE__ - 5) ); std::stacktrace_entry e3 = []{ return std::stacktrace::current().at(0); @@ -44,10 +45,10 @@ test_members() VERIFY( e1 != e3 ); VERIFY( e1.description() != e3.description() ); VERIFY( e1.source_file() == e3.source_file() ); - VERIFY( e1.source_line() != e3.source_line() ); + VERIFY( e3.source_line() == (__LINE__ - 5) ); } int main() { - test_constexpr(); + test_members(); } diff --git a/libstdc++-v3/testsuite/19_diagnostics/stacktrace/stacktrace.cc b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/stacktrace.cc new file mode 100644 index 00000000000..8dfdf4739be --- /dev/null +++ b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/stacktrace.cc @@ -0,0 +1,215 @@ +// { dg-options "-std=gnu++23 -lstdc++_libbacktrace" } +// { dg-do run { target c++23 } } +// { dg-require-effective-target stacktrace } + +#include <stacktrace> +#include "testsuite_allocator.h" + +static_assert( std::is_nothrow_default_constructible_v<std::stacktrace> ); +static_assert( std::is_copy_constructible_v<std::stacktrace> ); +static_assert( std::is_nothrow_move_constructible_v<std::stacktrace> ); +static_assert( std::is_copy_assignable_v<std::stacktrace> ); +static_assert( std::is_nothrow_move_assignable_v<std::stacktrace> ); +static_assert( std::is_nothrow_swappable_v<std::stacktrace> ); + +void +test_cons() +{ + { + using Stacktrace = std::stacktrace; + using Alloc = Stacktrace::allocator_type; + + Stacktrace s0; + VERIFY( s0.empty() ); + VERIFY( s0.size() == 0 ); + VERIFY( s0.begin() == s0.end() ); + + Stacktrace s1(Alloc{}); + VERIFY( s1.empty() ); + VERIFY( s1.size() == 0 ); + VERIFY( s1.begin() == s1.end() ); + + VERIFY( s0 == s1 ); + + Stacktrace s2(s0); + VERIFY( s2 == s0 ); + + const Stacktrace curr = Stacktrace::current(); + + Stacktrace s3(curr); + VERIFY( ! s3.empty() ); + VERIFY( s3.size() != 0 ); + VERIFY( s3.begin() != s3.end() ); + VERIFY( s3 != s0 ); + + Stacktrace s4(s3); + VERIFY( ! s4.empty() ); + VERIFY( s4.size() != 0 ); + VERIFY( s4.begin() != s4.end() ); + VERIFY( s4 == s3 ); + VERIFY( s4 != s0 ); + + Stacktrace s5(std::move(s3)); + VERIFY( ! s5.empty() ); + VERIFY( s5.size() != 0 ); + VERIFY( s5.begin() != s5.end() ); + VERIFY( s5 == s4 ); + VERIFY( s5 != s0 ); + VERIFY( s3 == s0 ); + + Stacktrace s6(s4, Alloc{}); + VERIFY( s6 == s4 ); + + Stacktrace s7(std::move(s6), Alloc{}); + VERIFY( s7 == s4 ); + } + + { + using Alloc = __gnu_test::uneq_allocator<std::stacktrace_entry>; + using Stacktrace = std::basic_stacktrace<Alloc>; + + Stacktrace s0; + VERIFY( s0.empty() ); + VERIFY( s0.size() == 0 ); + VERIFY( s0.begin() == s0.end() ); + + Stacktrace s1(Alloc{}); + VERIFY( s1.empty() ); + VERIFY( s1.size() == 0 ); + VERIFY( s1.begin() == s1.end() ); + + VERIFY( s0 == s1 ); + + Stacktrace s2(s0); + VERIFY( s2 == s0 ); + + const Stacktrace curr = Stacktrace::current(); + + Stacktrace s3(curr); + VERIFY( ! s3.empty() ); + VERIFY( s3.size() != 0 ); + VERIFY( s3.begin() != s3.end() ); + VERIFY( s3 != s0 ); + + Stacktrace s4(s3); + VERIFY( ! s4.empty() ); + VERIFY( s4.size() != 0 ); + VERIFY( s4.begin() != s4.end() ); + VERIFY( s4 == s3 ); + VERIFY( s4 != s0 ); + + Stacktrace s5(std::move(s3)); + VERIFY( ! s5.empty() ); + VERIFY( s5.size() != 0 ); + VERIFY( s5.begin() != s5.end() ); + VERIFY( s5 == s4 ); + VERIFY( s5 != s0 ); + VERIFY( s3 == s0 ); + + // TODO test allocator-extended copy/move + + // TODO test allocator propagation + } +} + + +void +test_assign() +{ + { + using Stacktrace = std::stacktrace; + + Stacktrace s0; + s0 = s0; + VERIFY( s0.empty() ); + s0 = std::move(s0); + VERIFY( s0.empty() ); + + Stacktrace s1 = Stacktrace::current(); + VERIFY( s1 != s0 ); + s0 = s1; + VERIFY( s0 == s1 ); + VERIFY( s0.at(0).source_line() == (__LINE__ - 4) ); + + s1 = Stacktrace::current(); + VERIFY( s1 != s0 ); + Stacktrace s2 = s0; + Stacktrace s3 = s1; + s0 = std::move(s1); + VERIFY( s0 == s3 ); + VERIFY( s1 == s2 ); // ISO C++: valid but unspecified; GCC: swapped. + } + + { + using Alloc = __gnu_test::uneq_allocator<std::stacktrace_entry>; + using Stacktrace = std::basic_stacktrace<Alloc>; + + Stacktrace s0; + s0 = s0; + VERIFY( s0.empty() ); + s0 = std::move(s0); + VERIFY( s0.empty() ); + + Stacktrace s1 = Stacktrace::current(); + VERIFY( s1 != s0 ); + s0 = s1; + VERIFY( s0 == s1 ); + + s1 = Stacktrace::current(Alloc(__LINE__)); + VERIFY( s1 != s0 ); + s0 = std::move(s1); + VERIFY( s0.at(0).source_line() == s0.get_allocator().get_personality() ); + VERIFY( s1.empty() ); // ISO C++: valid but unspecified; GCC: empty. + + Stacktrace s2 = Stacktrace::current(s0.get_allocator()); + Stacktrace s3 = s2; + s2 = std::move(s0); + VERIFY( s2.at(0).source_line() == s2.get_allocator().get_personality() ); + VERIFY( s0 == s3 ); // ISO C++: valid but unspecified, GCC: swapped. + } +} + +void +test_swap() +{ + { + using Stacktrace = std::stacktrace; + + Stacktrace s0; + Stacktrace s1 = Stacktrace::current(); + swap(s0, s1); + VERIFY( s1.empty() ); + VERIFY( ! s0.empty() ); + } + + { + using Alloc = __gnu_test::uneq_allocator<std::stacktrace_entry>; + using Stacktrace = std::basic_stacktrace<Alloc>; + + Stacktrace s0; + Stacktrace s1 = Stacktrace::current(); + swap(s0, s1); + VERIFY( s1.empty() ); + VERIFY( ! s0.empty() ); + + // TODO test allocator propagation + } +} + +void +test_pr105031() +{ + // PR libstdc++/105031 + // wrong constexpr if statement in operator=(basic_stacktrace&&) + using Alloc = __gnu_test::uneq_allocator<std::stacktrace_entry>; + std::basic_stacktrace<Alloc> s; + s = auto(s); +} + +int main() +{ + test_cons(); + test_assign(); + test_swap(); + test_pr105031(); +} diff --git a/libstdc++-v3/testsuite/20_util/stacktrace/synopsis.cc b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/synopsis.cc index 72582fa53c6..72582fa53c6 100644 --- a/libstdc++-v3/testsuite/20_util/stacktrace/synopsis.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/synopsis.cc diff --git a/libstdc++-v3/testsuite/20_util/stacktrace/version.cc b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/version.cc index ed466be5a36..ed466be5a36 100644 --- a/libstdc++-v3/testsuite/20_util/stacktrace/version.cc +++ b/libstdc++-v3/testsuite/19_diagnostics/stacktrace/version.cc diff --git a/libstdc++-v3/testsuite/20_util/expected/bad.cc b/libstdc++-v3/testsuite/20_util/expected/bad.cc new file mode 100644 index 00000000000..17bc6d69e88 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/expected/bad.cc @@ -0,0 +1,15 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile } + +#include <expected> + +struct E { + E() = default; + E(E&&) = default; +}; + +void +test_pr105146() +{ + std::bad_expected_access(E{}); +} diff --git a/libstdc++-v3/testsuite/20_util/expected/cons.cc b/libstdc++-v3/testsuite/20_util/expected/cons.cc index 1fe5b7bf4d1..6946858198c 100644 --- a/libstdc++-v3/testsuite/20_util/expected/cons.cc +++ b/libstdc++-v3/testsuite/20_util/expected/cons.cc @@ -162,6 +162,22 @@ test_copy() return true; } +constexpr bool +test_pr105153() +{ + struct E { + E(int&&) = delete; + E(const int&); + }; + + std::expected<void, E> e(std::expected<void, int>{}); + + static_assert( ! std::is_constructible_v<std::expected<void, int>, + std::expected<int, int>> ); + + return true; +} + int main() { test_default(); @@ -172,4 +188,6 @@ int main() static_assert( test_err() ); test_copy(); static_assert( test_copy() ); + test_pr105153(); + static_assert( test_pr105153() ); } diff --git a/libstdc++-v3/testsuite/20_util/expected/requirements.cc b/libstdc++-v3/testsuite/20_util/expected/requirements.cc index 485aa338679..aae7059ef71 100644 --- a/libstdc++-v3/testsuite/20_util/expected/requirements.cc +++ b/libstdc++-v3/testsuite/20_util/expected/requirements.cc @@ -124,6 +124,6 @@ static_assert( move_assignable< void, G > ); // QoI properties static_assert( sizeof(std::expected<char, unsigned char>) == 2 ); static_assert( sizeof(std::expected<void, char>) == 2 ); -static_assert( sizeof(std::expected<void*, char>) == 2 * __alignof(void*) ); +static_assert( sizeof(std::expected<void*, char>) == sizeof(void*) + __alignof(void*) ); static_assert( alignof(std::expected<void, char>) == 1 ); static_assert( alignof(std::expected<void*, char>) == alignof(void*) ); diff --git a/libstdc++-v3/testsuite/20_util/expected/swap.cc b/libstdc++-v3/testsuite/20_util/expected/swap.cc index 1b3b8c5f4e8..745db65fc6c 100644 --- a/libstdc++-v3/testsuite/20_util/expected/swap.cc +++ b/libstdc++-v3/testsuite/20_util/expected/swap.cc @@ -27,19 +27,19 @@ test_swap() VERIFY( e3.error() == 4 ); VERIFY( e4.error() == 3 ); - std::expected<int, int> v1(1), v2(2); - std::expected<int, int> v3(std::unexpect, 3), v4(std::unexpect, 4); + std::expected<void, int> v1, v2; + std::expected<void, int> v3(std::unexpect, 3), v4(std::unexpect, 4); swap(v1, v2); - VERIFY( v1.value() == 2 ); - VERIFY( v2.value() == 1 ); + VERIFY( v1.has_value() ); + VERIFY( v2.has_value() ); swap(v1, v3); VERIFY( ! v1.has_value() ); VERIFY( v1.error() == 3 ); - VERIFY( v3.value() == 2 ); + VERIFY( v3.has_value() ); swap(v1, v3); VERIFY( ! v3.has_value() ); - VERIFY( v1.value() == 2 ); + VERIFY( v1.has_value() ); VERIFY( v3.error() == 3 ); swap(v3, v4); VERIFY( ! v3.has_value() ); diff --git a/libstdc++-v3/testsuite/20_util/from_chars/pr105324.cc b/libstdc++-v3/testsuite/20_util/from_chars/pr105324.cc new file mode 100644 index 00000000000..cecb17e41cc --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/from_chars/pr105324.cc @@ -0,0 +1,14 @@ +// { dg-do run { target c++17 } } + +#include <charconv> +#include <string> + +int main() +{ + // PR libstdc++/105324 + // std::from_chars() assertion at floating_from_chars.cc:78 + std::string s(512, '1'); + s[1] = '.'; + long double d; + std::from_chars(s.data(), s.data() + s.size(), d); +} diff --git a/libstdc++-v3/testsuite/20_util/optional/monadic/and_then.cc b/libstdc++-v3/testsuite/20_util/optional/monadic/and_then.cc index 7cbec330ea0..c7e54efafee 100644 --- a/libstdc++-v3/testsuite/20_util/optional/monadic/and_then.cc +++ b/libstdc++-v3/testsuite/20_util/optional/monadic/and_then.cc @@ -3,9 +3,7 @@ #include <optional> -#ifndef __cpp_lib_monadic_optional -# error "Feature test macro for monadic optional is missing in <optional>" -#elif __cpp_lib_monadic_optional < 202110L +#if __cpp_lib_optional < 202110L # error "Feature test macro for monadic optional has wrong value in <optional>" #endif diff --git a/libstdc++-v3/testsuite/20_util/optional/monadic/version.cc b/libstdc++-v3/testsuite/20_util/optional/monadic/version.cc deleted file mode 100644 index 90b2a90a5df..00000000000 --- a/libstdc++-v3/testsuite/20_util/optional/monadic/version.cc +++ /dev/null @@ -1,10 +0,0 @@ -// { dg-options "-std=gnu++23" } -// { dg-do preprocess { target c++23 } } - -#include <version> - -#ifndef __cpp_lib_monadic_optional -# error "Feature test macro for monadic optional is missing in <version>" -#elif __cpp_lib_monadic_optional < 202110L -# error "Feature test macro for monadic optional has wrong value in <version>" -#endif diff --git a/libstdc++-v3/testsuite/20_util/optional/requirements.cc b/libstdc++-v3/testsuite/20_util/optional/requirements.cc index d6a81529c74..a56680a6fb1 100644 --- a/libstdc++-v3/testsuite/20_util/optional/requirements.cc +++ b/libstdc++-v3/testsuite/20_util/optional/requirements.cc @@ -23,8 +23,10 @@ # error "Feature test macro for optional is missing in <optional>" #elif __cpp_lib_optional < 201606L # error "Feature test macro for optional has wrong value in <optional>" -#elif __cplusplus >= 202002L && __cpp_lib_optional < 202106L +#elif __cplusplus == 202002L && __cpp_lib_optional != 202106L # error "Feature test macro for optional has wrong value for C++20 in <optional>" +#elif __cplusplus > 202002L && __cpp_lib_optional != 202110L +# error "Feature test macro for optional has wrong value for C++23 in <version>" #endif #include <testsuite_hooks.h> diff --git a/libstdc++-v3/testsuite/20_util/optional/version.cc b/libstdc++-v3/testsuite/20_util/optional/version.cc index c18ecb8d48d..2fd52f7c194 100644 --- a/libstdc++-v3/testsuite/20_util/optional/version.cc +++ b/libstdc++-v3/testsuite/20_util/optional/version.cc @@ -6,6 +6,8 @@ # error "Feature test macro for optional is missing in <version>" #elif __cplusplus == 201703L && __cpp_lib_optional != 201606L # error "Feature test macro for optional has wrong value for C++17 in <version>" -#elif __cplusplus >= 202002L && __cpp_lib_optional < 202106L +#elif __cplusplus == 202002L && __cpp_lib_optional != 202106L # error "Feature test macro for optional has wrong value for C++20 in <version>" +#elif __cplusplus > 202002L && __cpp_lib_optional != 202110L +# error "Feature test macro for optional has wrong value for C++23 in <version>" #endif diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/atomic_shared_ptr.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/atomic_shared_ptr.cc index 1f97224bf6a..a1902745a3e 100644 --- a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/atomic_shared_ptr.cc +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/atomic_shared_ptr.cc @@ -18,6 +18,8 @@ // Check constexpr constructor. constinit std::atomic<std::shared_ptr<int>> a; +// LWG 3661. constinit atomic<shared_ptr<T>> a(nullptr); should work +constinit std::atomic<std::shared_ptr<int>> a2 = nullptr; void test_is_lock_free() diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/assign/constexpr.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/assign/constexpr.cc new file mode 100644 index 00000000000..fb4acbda2d5 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/assign/constexpr.cc @@ -0,0 +1,48 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include <memory> +#include <testsuite_hooks.h> + +constexpr bool +test_move() +{ + std::unique_ptr<int> p1(new int(2)); + std::unique_ptr<int> p2; + p2 = std::move(p1); + VERIFY( *p2 == 2 ); + std::unique_ptr<int[]> a1(new int[]{0, 1, 2}); + std::unique_ptr<int[]> a2; + a2 = std::move(a1); + VERIFY( a2[2] == 2 ); + + return true; +} +static_assert( test_move() ); + +constexpr bool +test_convert() +{ + std::unique_ptr<int> p1(new int(2)); + std::unique_ptr<const int> p2; + p2 = std::move(p1); + VERIFY( *p2 == 2 ); + std::unique_ptr<int[]> a1(new int[]{0, 1, 2}); + std::unique_ptr<const int[]> a2; + a2 = std::move(a1); + VERIFY( a2[2] == 2 ); + + return true; +} +static_assert( test_convert() ); + +constexpr bool +test_null() +{ + std::unique_ptr<int> p(new int(2)); + p = nullptr; + VERIFY( !p ); + p = nullptr; + return true; +} +static_assert( test_null() ); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/comparison/constexpr.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/comparison/constexpr.cc new file mode 100644 index 00000000000..83e4f0826a8 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/comparison/constexpr.cc @@ -0,0 +1,73 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include <memory> +#include <testsuite_hooks.h> + +constexpr bool +test_eq() +{ + std::unique_ptr<int> p1, p2; + VERIFY( p1 == p2 ); + p1.reset(new int(1)); + VERIFY( p1 == p1 ); + VERIFY( p1 != p2 ); + struct null_deleter { constexpr void operator()(const void*) const { } }; + std::unique_ptr<const int[], null_deleter> p3(p1.get()); + VERIFY( p3 == p3 ); + VERIFY( p1 == p3 ); + VERIFY( p3 != p2 ); + + return true; +} +static_assert( test_eq() ); + +constexpr bool +test_rel() +{ + std::unique_ptr<int> p1, p2; + VERIFY( !(p1 < p2) ); + VERIFY( !(p1 > p2) ); + VERIFY( p1 <= p2 ); + VERIFY( p1 >= p2 ); + p1.reset(new int(1)); + VERIFY( p1 <= p1 ); + VERIFY( p1 >= p1 ); + VERIFY( p1 > p2 ); + VERIFY( p2 < p1 ); + VERIFY( p2 <= p1 ); + VERIFY( p1 >= p2 ); + struct null_deleter { constexpr void operator()(const void*) const { } }; + std::unique_ptr<const int[], null_deleter> p3(p1.get()); + VERIFY( p3 <= p3 ); + VERIFY( p3 >= p3 ); + VERIFY( p1 <= p3 ); + VERIFY( p3 > p2 ); + VERIFY( p3 >= p2 ); + VERIFY( p2 < p3 ); + VERIFY( p2 <= p3 ); + + return true; +} +static_assert( test_rel() ); + +constexpr bool +test_3way() +{ + std::unique_ptr<int> p1, p2; + VERIFY( (p1 <=> p1) == 0 ); + VERIFY( (p1 <=> p2) == 0 ); + p1.reset(new int(1)); + VERIFY( (p1 <=> p1) == 0 ); + VERIFY( (p1 <=> p2) > 0 ); + VERIFY( (p2 <=> p1) < 0 ); + struct null_deleter { constexpr void operator()(const void*) const { } }; + std::unique_ptr<const int[], null_deleter> p3(p1.get()); + VERIFY( (p3 <=> p3) == 0 ); + VERIFY( (p1 <=> p3) == 0 ); + VERIFY( (p3 <=> p2) > 0 ); + VERIFY( (p2 <=> p3) < 0 ); + + return true; +} +static_assert( test_3way() ); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr_c++20.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr_c++20.cc new file mode 100644 index 00000000000..243d80aaba5 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr_c++20.cc @@ -0,0 +1,85 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include <memory> + +#ifndef __cpp_lib_constexpr_memory +# error "Feature test macro for constexpr unique_ptr is missing in <memory>" +#elif __cpp_lib_constexpr_memory < 202202L +# error "Feature test macro for constexpr unique_ptr has wrong value in <memory>" +#endif + +#include <testsuite_hooks.h> + +constexpr bool +test_default() +{ + std::unique_ptr<int> p; + std::unique_ptr<int> np(nullptr); + VERIFY( p == np ); + + std::unique_ptr<int[]> a; + std::unique_ptr<int[]> na(nullptr); + VERIFY( a == na ); + + return true; +} +static_assert( test_default() ); + +constexpr bool +test_ptr() +{ + std::unique_ptr<int> p(new int(2)); + VERIFY( *p == 2 ); + std::unique_ptr<int[]> a(new int[]{0, 1, 2}); + VERIFY( a[2] == 2 ); + + return true; +} +static_assert( test_ptr() ); + +constexpr bool +test_del() +{ + const std::default_delete<int> pd; + std::unique_ptr<int> p1(new int(1), pd); + VERIFY( *p1 == 1 ); + std::unique_ptr<int> p2(new int(2), std::default_delete<int>{}); + VERIFY( *p2 == 2 ); + const std::default_delete<int[]> ad; + std::unique_ptr<int[]> a1(new int[]{3, 4}, ad); + VERIFY( a1[0] == 3 ); + std::unique_ptr<int[]> a2(new int[]{5, 6}, std::default_delete<int[]>{}); + VERIFY( a2[1] == 6 ); + + return true; +} +static_assert( test_del() ); + +constexpr bool +test_move() +{ + std::unique_ptr<int> p1(new int(2)); + std::unique_ptr<int> p2 = std::move(p1); + VERIFY( *p2 == 2 ); + std::unique_ptr<int[]> a1(new int[]{0, 1, 2}); + std::unique_ptr<int[]> a2 = std::move(a1); + VERIFY( a2[2] == 2 ); + + return true; +} +static_assert( test_move() ); + +constexpr bool +test_convert() +{ + std::unique_ptr<int> p1(new int(2)); + std::unique_ptr<const int> p2 = std::move(p1); + VERIFY( *p2 == 2 ); + std::unique_ptr<int[]> a1(new int[]{0, 1, 2}); + std::unique_ptr<const int[]> a2 = std::move(a1); + VERIFY( a2[2] == 2 ); + + return true; +} +static_assert( test_convert() ); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/creation/constexpr.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/creation/constexpr.cc new file mode 100644 index 00000000000..90d11198578 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/creation/constexpr.cc @@ -0,0 +1,34 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include <memory> +#include <testsuite_hooks.h> + +constexpr bool +test_creation_single() +{ + std::unique_ptr<int> p = std::make_unique<int>(1); + VERIFY( *p == 1 ); + p = std::make_unique_for_overwrite<int>(); + *p = 2; + VERIFY( *p == 2 ); + + return true; +} +static_assert( test_creation_single() ); + +constexpr bool +test_creation_array() +{ + std::unique_ptr<int[]> a = std::make_unique<int[]>(2); + VERIFY( a[0] == 0 ); + VERIFY( a[1] == 0 ); + a = std::make_unique_for_overwrite<int[]>(2); + a[0] = 1; + a[1] = 2; + VERIFY( a[0] == 1 ); + VERIFY( a[1] == 2 ); + + return true; +} +static_assert( test_creation_array() ); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/constexpr.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/constexpr.cc new file mode 100644 index 00000000000..81908fdc081 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/constexpr.cc @@ -0,0 +1,68 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include <memory> +#include <testsuite_hooks.h> + +constexpr bool +test_release() +{ + std::unique_ptr<int> p1; + int* r = p1.release(); + VERIFY( !r ); + VERIFY( !p1 ); + + std::unique_ptr<int> p2(new int(2)); + r = p2.release(); + VERIFY( r ); + VERIFY( !p2 ); + delete r; + + std::unique_ptr<int[]> a1; + r = a1.release(); + VERIFY( !r ); + VERIFY( !a1 ); + + std::unique_ptr<int[]> a2(new int[2]{}); + r = a2.release(); + VERIFY( r ); + VERIFY( !a2 ); + delete[] r; + + return true; +} +static_assert( test_release() ); + +constexpr bool +test_reset() +{ + std::unique_ptr<int> p1; + p1.reset(); + VERIFY( !p1 ); + p1.reset(nullptr); + VERIFY( !p1 ); + p1.reset(new int(2)); + VERIFY( *p1 == 2 ); + p1.reset(new int(3)); + VERIFY( *p1 == 3 ); + p1.reset(nullptr); + VERIFY( !p1 ); + + std::unique_ptr<int[]> a1; + a1.reset(); + VERIFY( !a1 ); + a1.reset(nullptr); + VERIFY( !a1 ); + a1.reset(new int[]{2,3}); + VERIFY( a1[0] == 2 ); + a1.reset(new int[]{4,5,6}); + VERIFY( a1[1] == 5 ); + a1.reset(nullptr); + VERIFY( !a1 ); + + std::unique_ptr<const int[]> a2; + a2.reset(new int[2]{}); + + return true; +} +static_assert( test_reset() ); diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/constexpr.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/constexpr.cc new file mode 100644 index 00000000000..91a0165d212 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/constexpr.cc @@ -0,0 +1,46 @@ +// { dg-options "-std=gnu++23" } +// { dg-do compile { target c++23 } } + +#include <memory> +#include <testsuite_hooks.h> + +constexpr bool +test_swap_single() +{ + std::unique_ptr<int> p1; + swap(p1, p1); + VERIFY( !p1 ); + std::unique_ptr<int> p2; + swap(p1, p2); + VERIFY( !p1 && !p2 ); + std::unique_ptr<int> p3(new int(3)); + swap(p3, p3); + VERIFY( *p3 == 3 ); + swap(p1, p3); + VERIFY( *p1 == 3 ); + std::unique_ptr<int> p4(new int(4)); + swap(p4, p1); + VERIFY( *p4 == 3 ); + VERIFY( *p1 == 4 ); + + return true; +} +static_assert( test_swap_single() ); + +constexpr bool +test_swap_array() +{ + std::unique_ptr<int[]> a1; + std::unique_ptr<int[]> a2; + swap(a1, a2); + VERIFY( !a1 && !a2 ); + std::unique_ptr<int[]> a3(new int[]{3}); + swap(a1, a3); + VERIFY( a1[0] == 3 ); + std::unique_ptr<int[]> a4(new int[]{4, 5}); + swap(a1, a4); + VERIFY( a1[1] == 5 ); + + return true; +} +static_assert( test_swap_array() ); diff --git a/libstdc++-v3/testsuite/21_strings/basic_string_view/operations/copy/char/constexpr.cc b/libstdc++-v3/testsuite/21_strings/basic_string_view/operations/copy/char/constexpr.cc index 28f8ae845c2..2705098fb76 100644 --- a/libstdc++-v3/testsuite/21_strings/basic_string_view/operations/copy/char/constexpr.cc +++ b/libstdc++-v3/testsuite/21_strings/basic_string_view/operations/copy/char/constexpr.cc @@ -22,7 +22,7 @@ #ifndef __cpp_lib_constexpr_string_view # error "Feature test macro for constexpr copy is missing in <string_view>" -#elif __cpp_lib_constexpr_iterator < 201811L +#elif __cpp_lib_constexpr_string_view < 201811L # error "Feature test macro for constexpr copy has wrong value in <string_view>" #endif diff --git a/libstdc++-v3/testsuite/23_containers/vector/cons/constexpr.cc b/libstdc++-v3/testsuite/23_containers/vector/cons/constexpr.cc index f5d2f08faf2..e6324ad4a0a 100644 --- a/libstdc++-v3/testsuite/23_containers/vector/cons/constexpr.cc +++ b/libstdc++-v3/testsuite/23_containers/vector/cons/constexpr.cc @@ -3,6 +3,13 @@ // { dg-xfail-if "not supported" { debug_mode } } #include <vector> + +#ifndef __cpp_lib_constexpr_vector +# error "Feature test macro for constexpr vector is missing in <vector>" +#elif __cpp_lib_constexpr_vector != 201907L +# error "Feature test macro for constexpr vector has wrong value in <vector>" +#endif + #include <testsuite_hooks.h> #include <testsuite_iterators.h> diff --git a/libstdc++-v3/testsuite/23_containers/vector/requirements/version.cc b/libstdc++-v3/testsuite/23_containers/vector/requirements/version.cc new file mode 100644 index 00000000000..c85e060f048 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/vector/requirements/version.cc @@ -0,0 +1,10 @@ +// { dg-options "-std=gnu++20" } +// { dg-do preprocess { target c++20 } } + +#include <version> + +#ifndef __cpp_lib_constexpr_vector +# error "Feature test macro for constexpr vector is missing in <version>" +#elif __cpp_lib_constexpr_vector != 201907L +# error "Feature test macro for constexpr vector has wrong value in <version>" +#endif diff --git a/libstdc++-v3/testsuite/25_algorithms/minmax/constrained.cc b/libstdc++-v3/testsuite/25_algorithms/minmax/constrained.cc index 90882afb6d0..59864043a0a 100644 --- a/libstdc++-v3/testsuite/25_algorithms/minmax/constrained.cc +++ b/libstdc++-v3/testsuite/25_algorithms/minmax/constrained.cc @@ -20,6 +20,7 @@ #include <algorithm> #include <string> +#include <utility> #include <vector> #include <testsuite_hooks.h> #include <testsuite_iterators.h> @@ -129,6 +130,34 @@ test05() VERIFY( result.min == "a"s && result.max == "c"s ); } +struct A { + A() = delete; + A(int i) : i(i) { } + A(const A&) = default; + A(A&& other) : A(std::as_const(other)) { ++move_count; } + A& operator=(const A&) = default; + A& operator=(A&& other) { + ++move_count; + return *this = std::as_const(other); + }; + friend auto operator<=>(const A&, const A&) = default; + static inline int move_count = 0; + int i; +}; + +void +test06() +{ + // PR libstdc++/104858 + // Verify ranges::minmax doesn't dereference the iterator for the first + // element in the range twice. + A a(42); + ranges::subrange r = {std::move_iterator(&a), std::move_sentinel(&a + 1)}; + auto result = ranges::minmax(r); + VERIFY( A::move_count == 1 ); + VERIFY( result.min.i == 42 && result.max.i == 42 ); +} + int main() { @@ -137,4 +166,5 @@ main() test03(); test04(); test05(); + test06(); } diff --git a/libstdc++-v3/testsuite/27_io/filesystem/operations/copy.cc b/libstdc++-v3/testsuite/27_io/filesystem/operations/copy.cc index b85628cdf30..b936e04493b 100644 --- a/libstdc++-v3/testsuite/27_io/filesystem/operations/copy.cc +++ b/libstdc++-v3/testsuite/27_io/filesystem/operations/copy.cc @@ -193,6 +193,34 @@ test05() VERIFY( !ec ); // Previous value should be cleared (LWG 2683) } +void +test_pr99290() +{ + auto dir = __gnu_test::nonexistent_path(); + auto source = dir/"source"; + auto dest = dir/"dest"; + create_directories(source/"emptydir"); + create_directories(dest/"emptydir"); + std::ofstream{source/"file"} << 'a'; + std::ofstream{dest/"file"} << 'b'; + // PR libstdc++/99290 + // std::filesystem::copy does not always report errors for recursion + std::error_code ec; + copy(source, dest, ec); + VERIFY( ec == std::errc::file_exists ); + +#if __cpp_exceptions + try { + copy(source, dest); + VERIFY( false ); + } catch (const fs::filesystem_error& e) { + VERIFY( e.code() == std::errc::file_exists ); + } +#endif + + remove_all(dir); +} + int main() { @@ -201,4 +229,5 @@ main() test03(); test04(); test05(); + test_pr99290(); } diff --git a/libstdc++-v3/testsuite/27_io/filesystem/path/nonmember/hash_value.cc b/libstdc++-v3/testsuite/27_io/filesystem/path/nonmember/hash_value.cc index 6bc6296b5a8..0dcea6efc64 100644 --- a/libstdc++-v3/testsuite/27_io/filesystem/path/nonmember/hash_value.cc +++ b/libstdc++-v3/testsuite/27_io/filesystem/path/nonmember/hash_value.cc @@ -42,9 +42,19 @@ test02() } } +void +test03() +{ + std::hash<path> h; + // LWG 3657. std::hash<std::filesystem::path> is not enabled + for (const path p : __gnu_test::test_paths) + VERIFY( h(p) == hash_value(p) ); +} + int main() { test01(); test02(); + test03(); } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/wait_notify/102994.cc b/libstdc++-v3/testsuite/29_atomics/atomic/wait_notify/102994.cc index 9d92ff954f1..f572ce7ef11 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic/wait_notify/102994.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic/wait_notify/102994.cc @@ -5,13 +5,13 @@ #include <atomic> void -test1(const std::atomic<char*>& a, char* p) +test1(std::atomic<char*>& a, char* p) { a.wait(p); } void -test2(const std::atomic<int>* a, int v) +test2(std::atomic<int>* a, int v) { std::atomic_wait(a, v); std::atomic_notify_one(a); diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc index 6dd4f5b00ca..edf19960cbb 100644 --- a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc +++ b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/c_compat.cc @@ -3,6 +3,12 @@ #include <stdatomic.h> +#ifndef __cpp_lib_stdatomic_h +# error "Feature test macro for stdatomic.h is missing in <stdatomic.h>" +#elif __cpp_lib_stdatomic_h != 202011L +# error "Feature test macro for stdatomic.h has wrong value in <stdatomic.h>" +#endif + #ifndef ATOMIC_BOOL_LOCK_FREE #error ATOMIC_BOOL_LOCK_FREE is not defined in <stdatomic.h> #endif diff --git a/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/version.cc b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/version.cc new file mode 100644 index 00000000000..dbaf6bc59d3 --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/headers/stdatomic.h/version.cc @@ -0,0 +1,10 @@ +// { dg-options "-std=gnu++23" } +// { dg-do preprocess { target c++23 } } + +#include <version> + +#ifndef __cpp_lib_stdatomic_h +# error "Feature test macro for stdatomic.h is missing in <version>" +#elif __cpp_lib_stdatomic_h != 202011L +# error "Feature test macro for stdatomic.h has wrong value in <version>" +#endif diff --git a/libstdc++-v3/testsuite/30_threads/packaged_task/cons/deduction.cc b/libstdc++-v3/testsuite/30_threads/packaged_task/cons/deduction.cc new file mode 100644 index 00000000000..0eb69763ab9 --- /dev/null +++ b/libstdc++-v3/testsuite/30_threads/packaged_task/cons/deduction.cc @@ -0,0 +1,85 @@ +// // Copyright (C) 2017-2022 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +// { dg-do compile { target c++17 } } + +#include <future> + +template<typename T, typename U> struct require_same; +template<typename T> struct require_same<T, T> { using type = void; }; + +template<typename T, typename U> + typename require_same<T, U>::type + check_type(U&) { } + +void f0v(); +void f0vn() noexcept; +int f0i(); +int f0in() noexcept; +long f1l(int&); +long f1ln(double*) noexcept; + +void +test01() +{ + std::packaged_task task1{f0v}; + check_type<std::packaged_task<void()>>(task1); + + std::packaged_task task2{f0vn}; + check_type<std::packaged_task<void()>>(task2); + + std::packaged_task task3{f0i}; + check_type<std::packaged_task<int()>>(task3); + + std::packaged_task task4{f0in}; + check_type<std::packaged_task<int()>>(task4); + + std::packaged_task task5{f1l}; + check_type<std::packaged_task<long(int&)>>(task5); + + std::packaged_task task6{f1ln}; + check_type<std::packaged_task<long(double*)>>(task6); + + std::packaged_task task5a{std::move(task5)}; + check_type<std::packaged_task<long(int&)>>(task5a); + + std::packaged_task task6a{std::move(task6)}; + check_type<std::packaged_task<long(double*)>>(task6a); +} + +struct X { + int operator()(const short&, void*); +}; + +struct Y { + void operator()(int) const & noexcept; +}; + +void +test02() +{ + X x; + std::packaged_task task1{x}; + check_type<std::packaged_task<int(const short&, void*)>>(task1); + + Y y; + std::packaged_task task2{y}; + check_type<std::packaged_task<void(int)>>(task2); + + std::packaged_task task3{[&x](float) -> X& { return x; }}; + check_type<std::packaged_task<X&(float)>>(task3); +} diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc index 319632a5a76..5cd6b483c26 100644 --- a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc +++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc @@ -190,6 +190,34 @@ test05() VERIFY( !ec ); // Previous value should be cleared (LWG 2683) } +void +test_pr99290() +{ + auto dir = __gnu_test::nonexistent_path(); + auto source = dir/"source"; + auto dest = dir/"dest"; + create_directories(source/"emptydir"); + create_directories(dest/"emptydir"); + std::ofstream{source/"file"} << 'a'; + std::ofstream{dest/"file"} << 'b'; + // PR libstdc++/99290 + // std::filesystem::copy does not always report errors for recursion + std::error_code ec; + copy(source, dest, ec); + VERIFY( ec == std::errc::file_exists ); + +#if __cpp_exceptions + try { + copy(source, dest); + VERIFY( false ); + } catch (const fs::filesystem_error& e) { + VERIFY( e.code() == std::errc::file_exists ); + } +#endif + + remove_all(dir); +} + int main() { @@ -198,4 +226,5 @@ main() test03(); test04(); test05(); + test_pr99290(); } diff --git a/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx11.cc b/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx11.cc index 4262ca88bc3..f97640a0189 100644 --- a/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx11.cc +++ b/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx11.cc @@ -25,6 +25,8 @@ #include <memory> #include <iostream> #include <future> +#include <initializer_list> +#include <atomic> #include "../util/testsuite_allocator.h" // NullablePointer typedef std::tuple<int, int> ExTuple; @@ -191,6 +193,20 @@ main() std::error_code ecfut0 = std::make_error_code(std::future_errc{}); // { dg-final { note-test ecfut0 {std::error_code = {"future": 0}} } } + std::initializer_list<int> emptyIl = {}; + // { dg-final { note-test emptyIl {std::initializer_list of length 0} } } + std::initializer_list<int> il = {3, 4}; + // { dg-final { note-test il {std::initializer_list of length 2 = {3, 4}} } } + + std::atomic<int> ai{100}; + // { dg-final { note-test ai {std::atomic<int> = { 100 }} } } + long l{}; + std::atomic<long*> ap{&l}; + // { dg-final { regexp-test ap {std::atomic.long \*. = { 0x.* }} } } + struct Value { int i, j; }; + std::atomic<Value> av{{8, 9}}; + // { dg-final { note-test av {std::atomic<Value> = { {i = 8, j = 9} }} } } + placeholder(""); // Mark SPOT use(efl); use(fl); diff --git a/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx20.cc b/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx20.cc index b0de25c27ec..f027d0eae38 100644 --- a/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx20.cc +++ b/libstdc++-v3/testsuite/libstdc++-prettyprinters/cxx20.cc @@ -18,8 +18,11 @@ // with this library; see the file COPYING3. If not see // <http://www.gnu.org/licenses/>. +#include <array> #include <compare> #include <iostream> +#include <memory> +#include <span> struct X { @@ -54,6 +57,23 @@ main() auto c10 = 0.0 <=> __builtin_nan(""); // { dg-final { note-test c10 "std::partial_ordering::unordered" } } + auto il = {1, 2}; + auto s1 = std::span(il); + static_assert(s1.extent == std::size_t(-1)); +// { dg-final { note-test s1 {std::span of length 2 = {1, 2}} } } + auto a = std::array{3, 4}; + auto s2 = std::span(a); + static_assert(s2.extent == std::size_t(2)); +// { dg-final { note-test s2 {std::span of length 2 = {3, 4}} } } + + std::atomic<std::shared_ptr<int>> spe; +// { dg-final { note-test spe {std::atomic<std::shared_ptr<int>> (empty) = {get() = 0x0}} } } + std::atomic<std::shared_ptr<int>> sp1 = std::make_shared<int>(1); + std::atomic<std::shared_ptr<int>> sp2 = sp1.load(); + std::atomic<std::weak_ptr<int>> wp{sp2.load()}; +// { dg-final { regexp-test sp1 {std::atomic.std::shared_ptr.int.. \(use count 2, weak count 1\) = {get\(\) = 0x.*}} } } +// { dg-final { regexp-test wp {std::atomic.std::weak_ptr.int.. \(use count 2, weak count 1\) = {get\(\) = 0x.*}} } } + std::cout << "\n"; return 0; // Mark SPOT } |
