]> git.ipfire.org Git - thirdparty/gcc.git/log
thirdparty/gcc.git
2 months agoFortran: Add new test case
Jerry DeLisle [Sat, 17 Jan 2026 18:02:26 +0000 (10:02 -0800)] 
Fortran: Add new test case

PR fortran/94377

gcc/testsuite/ChangeLog:

* gfortran.dg/pr94377.f90: New test, failed on gcc-15

2 months agoFortran: Documentation update on -fdefault-real-8 and family
Jerry DeLisle [Sat, 17 Jan 2026 17:23:53 +0000 (09:23 -0800)] 
Fortran: Documentation update on -fdefault-real-8 and family

PR fortran/122957

gcc/fortran/ChangeLog:

* invoke.texi: Add note that these features are incompatible
with user defined derived type I/O. (DTIO)

2 months agoFortran: Fix accepts invalid implicit none (external)
Steven G. Kargl [Sat, 17 Jan 2026 02:09:56 +0000 (18:09 -0800)] 
Fortran: Fix accepts invalid implicit none (external)

This patch yields an error for the test case which was
previously being accepted even though implicit none (external)
was being specified.

PR fortran/109512

gcc/fortran/ChangeLog:

* resolve.cc (resolve_function): Check if an external
attribute is required on a call to an external procedure.
(resolve_call): Likewise.

gcc/testsuite/ChangeLog:

* gfortran.dg/pr109512.f90: New test.

2 months agotree: Handle ::operator {new,delete} function templates as uncertain matches [PR123513]
Jakub Jelinek [Sat, 17 Jan 2026 13:37:30 +0000 (14:37 +0100)] 
tree: Handle ::operator {new,delete} function templates as uncertain matches [PR123513]

We have for some reason two different ways to check for matching
::operator new vs. ::operator delete kind.  One is a dumb one in
tree.cc (valid_new_delete_pair_p) and another one is in
gimple-ssa-warn-access.cc (new_delete_mismatch_p).
The former is used both in the latter and in optimizations,
the latter only for warnings.
The former just handles the easy cases, global operator new and
the latter can handle everything as it uses the demangler.
The former has essentially a tri-state return even when it has just bool
return type, it has another bool * optional argument, so can return
true for this is definitely ok, false with false with this might be
not matching and false with true for this definitely doesn't match.
false with false is returned e.g. for the class scope operator new/delete,
where we definitely need the demangler to figure stuff out.
false with true is returned for mismatches which are guaranteed, e.g.
when one mangled name starts with _Znw and the other with _Zda,
one is ::operator new and the other is ::operator delete[].
valid_new_delete_pair_p expects that after the _Znw/_Zna/_Zdl/_Zda
prefix (or two _ at the start instead of one) it sees [jmy] for
the size_t argument resp. Pv for void* for delete, for delete
then optionally the same [jmy] for sized deallocation and
optionally RKSt9nothrow_t after it for nothrow versions or
also something with St11align_val_t.  If it has some extra arguments
after it, it also returns false/false.

The following testcase shows another case where I'm afraid we need
to return the maybe mismatch - when the global operators are function
templates.
_ZnwILm1024EEPvmR13BumpAllocatorIXT_EE
_ZdlILm1024EEvPvR13BumpAllocatorIXT_EE
where the Ilm1024EE here mean <1024ul> and Pv after it means function
return type void *.  As valid_new_delete_pair_p needs to find the m
after it, it would need to know everything about what can appear
in between I and E for the template arguments (which is a lot) and
also be able to skip over mangling of arbitrary function return types
(though perhaps it could hardcode those Pv vs. v cases for those).

So, the following patch just returns false/false instead of false/true
if known _Z{nw,na,dl,da} is followed by I, i.e. if it is a function
template.  For optimizations it makes no difference, those care just
about the return value and not on *pcertain, and for the warning it
means it will use the demangler which will figure stuff hopefully right.

2026-01-17  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/123513
* tree.cc (valid_new_delete_pair_p): If new_name[3] or delete_name[3]
is 'I', return false with *pcertain set to false rather than true.

* g++.dg/warn/Wmismatched-new-delete-10.C: New test.

2 months agoc++/modules: Fix local type handling when not streaming function definitions [PR123627]
Nathaniel Shead [Fri, 16 Jan 2026 23:41:58 +0000 (10:41 +1100)] 
c++/modules: Fix local type handling when not streaming function definitions [PR123627]

r14-9948-g716af95fd45487 added support for merging local types of
functions.  This however causes the linked PR to crash, because when
restreaming the local type from a partition for the primary module
interface's CMI, we no longer have the DECL_INITIAL for a function.

This patch fixes the issue by reusing the MK_keyed merge kind, as used
for lambda types.  This is required so that if a module partition
imports both the primary module interface and a different module
partition that both provide the same local type it can properly dedup
the declarations.

We only need to do this if !has_definition; in cases where a definition
is available we keep using the MK_local_type behaviour as that avoids
the need to maintain a separately allocated chain of keyed decls.

An additional change is to further the modifications made in r16-4671
and always attempt to key to the top-most decl, including going through
possibly many nested class and function definitions.  This avoids any
similar issues to that bug where we read a keyed decl before we see the
decl it's keyed to now that we support keying to functions as well.

PR c++/123627

gcc/cp/ChangeLog:

* class.cc (finish_struct): Maybe key function-local types.
* module.cc (trees_out::get_merge_kind): Choose whether to use
MK_local_type or MK_keyed for a local type based on if the
immediate context's definition will be streamed.
(trees_in::key_mergeable): Allow key decls on FUNCTION_DECL.
(adjust_key_scope): New function.
(maybe_key_decl): Handle key decls on FUNCTION_DECL; check that
we only key a given decl to a context at most once.
(get_keyed_decl_scope): Support non-lambda decls.

gcc/testsuite/ChangeLog:

* g++.dg/modules/block-decl-4_a.C: New test.
* g++.dg/modules/block-decl-4_b.C: New test.
* g++.dg/modules/block-decl-4_c.C: New test.

Signed-off-by: Nathaniel Shead <nathanieloshead@gmail.com>
Reviewed-by: Jason Merrill <jason@redhat.com>
2 months agoa68: handle TImode in a68_type_for_{mode,size}
Mohammad-Reza Nabipoor [Sat, 17 Jan 2026 02:36:47 +0000 (03:36 +0100)] 
a68: handle TImode in a68_type_for_{mode,size}

Signed-off-by: Mohammad-Reza Nabipoor <mnabipoor@gnu.org>
gcc/algol68/ChangeLog

PR algol68/123007
* a68-lang.cc (a68_type_for_mode): Handle TImode.
(a68_type_for_size): Handle unsigned_intTI_type_node.

2 months agocobol: Support National characters and Unicode runtime encoding.
Robert Dubner [Fri, 16 Jan 2026 20:42:50 +0000 (15:42 -0500)] 
cobol: Support National characters and Unicode runtime encoding.

The last few months have seen an evolution in the COBOL compiler.  Up
until now it could use either CP1252/ASCII or CP1140/EBCDIC to represent
alphanumeric variables and numeric types that are stored as character
strings.  With these changes, those types can be represented in many
other single-byte encodings, as well as UTF16 and UTF32 encodings.

These changes required extensive changes.

1) The initial parsing has to handle the extended capabilities.

2) Each run-time variable designates its character set.

3) The run-time code has to be able to handle wide characters.

Since the development took place over a period of time, other changes
crept in. In particular, there is an expansion of bindings making
certain POSIX functions available to the COBOL programmer.

There has also been an expansion of gcobol's use of the GCC diagnostic
framework.

Co-Authored-By: Robert Dubner <rdubner@symas.com>
Co-Authored-By: James K. Lowden <jklowden@cobolworx.com>
gcc/cobol/ChangeLog:

* cbldiag.h (struct cbl_loc_t): Diagnostics.
(enum cbl_diag_id_t): Diagnostics.
* cdf.y: Includes.
* cobol1.cc (cobol_warning_suppress): Diagnostics.
(cobol_langhook_handle_option): Implement -fexec-charset.  Expand
the use of diagnostics.
* gcobc: Expand options and warnings.
* gcobol.1: Documentation.
* genapi.cc (level_88_helper): Charsets.
(get_level_88_domain): Charsets.
(get_class_condition_string): Charsets.
(function_pointer_from_name): Charsets.
(initialize_variable_internal):  Charsets.
(parser_initialize): Charsets.
(get_binary_value_from_float): Charsets.
(get_bytes_needed): Charsets.
(cobol_compare): Charsets.
(move_tree): Eliminate function.
(move_tree_to_field): Eliminate function.
(get_string_from): Eliminate function.
(parser_init_list): Charsets.
(psa_FldLiteralN): Charsets.
(parser_accept_date_yymmdd): Charsets.
(parser_accept_date_yyyymmdd): Charsets.
(parser_accept_date_yyddd): Charsets.
(parser_accept_date_yyyyddd): Charsets.
(parser_accept_date_dow): Charsets.
(parser_accept_date_hhmmssff): Charsets.
(parser_alphabet): Charsets.
(parser_alphabet_use): Charsets.
(parser_display_internal): Charsets.
(get_literalN_value): Charsets.
(tree_type_from_field_type): Charsets.
(program_end_stuff): Charsets.
(walk_initialization): Charsets.
(parser_xml_parse): Charsets.
(initialize_the_data): Charsets.
(establish_using): Charsets.
(parser_setop): Charsets.
(parser_set_conditional88): Charsets.
(parser_file_add): Charsets.
(get_the_filename): Eliminate function.
(parser_file_open): Charsets.
(parser_file_delete_file): Charsets.
(parser_file_start): Charsets.
(parser_module_name): Charsets.
(parser_intrinsic_find_string): New function.
(parser_intrinsic_numval_c): Charsets.
(parser_intrinsic_convert): New function.
(parser_intrinsic_call_1): Charsets.
(create_and_call): Charsets.
(mh_identical): Charsets.
(mh_source_is_literalN): Charsets.
(float_type_of): Charsets.
(mh_dest_is_float): Charsets.
(mh_numeric_display): Charsets.
(mh_little_endian): Charsets.
(mh_source_is_group): Charsets.
(mh_source_is_literalA): Charsets.
(move_helper): Charsets.
(binary_initial): Eliminate function.
(digits_from_int128): Eliminate function.
(digits_from_float128): Eliminate function.
(initial_from_initial):  Eliminate function.
(convert_data_initial): New function.
(actually_create_the_static_field): Charsets.
(psa_new_var_decl): Charsets.
(psa_FldLiteralA): Charsets.
(parser_local_add): Charsets.
(parser_symbol_add): Charsets.
* genapi.h (parser_intrinsic_convert): New function.
(parser_intrinsic_find_string): New function.
* genmath.cc (arithmetic_operation): Charsets.
(largest_binary_term): Charsets.
(fast_add): Charsets.
(fast_subtract): Charsets.
(fast_multiply): Charsets.
(fast_divide): Charsets.
(parser_subtract): Fix subtract float from float.
* genutil.cc (get_any_capacity): Charsets.
(get_and_check_refstart_and_reflen): Charsets.
(get_data_offset): Charsets.
(get_binary_value): Charsets.
(tree_type_from_field): Charsets.
(copy_little_endian_into_place): Charsets.
(get_literal_string): Charsets.
(refer_is_clean): Charsets.
(refer_fill_depends): Charsets.
(refer_size_source): Comment.
* lang-specs.h: Charsets.
* lang.opt: Charsets.
* lexio.cc (parse_copy_directive): Diagnostics.
* messages.cc (cbl_diagnostic_kind): Diagnostics.
(cobol_warning_suppress): Diagnostics.
* parse.y: Many changes for charsets and diagnostics.
* parse_ante.h (MAXLENGTH_FORMATTED_DATE): Charsets.
(MAXLENGTH_FORMATTED_TIME): Charsets.
(MAXLENGTH_CALENDAR_DATE): Charsets.
(MAXLENGTH_FORMATTED_DATETIME): Charsets.
(consistent_encoding_check): Charsets.
(enum data_clause_t): Charsets.
(new_alphanumeric): Charsets.
(name_of): Charsets.
(class eval_subject_t): Charsets.
(struct domain_t): Charsets.
(struct file_list_t): Charsets.
(current_encoding): Charsets.
(new_tempnumeric): Charsets.
(is_integer_literal): Charsets.
(new_literal): Charsets.
(new_constant): Charsets.
(conditional_set): Charsets.
(field_find): Charsets.
(valid_redefine): Charsets.
(field_value_all): Charsets.
(parent_has_picture): Charsets.
(parent_has_value): Charsets.
(blank_pad_initial): Charsets.
(blankit): Charsets.
(cbl_field_t::blank_initial): Charsets.
(value_encoding_check): Charsets.
(cbl_field_t::set_initial): Charsets.
(field_alloc): Charsets.
(parser_move_carefully): Charsets.
(data_division_ready): Charsets.
(anybody_redefines): Charsets.
(procedure_division_ready): Charsets.
(file_section_parent_set): Charsets.
(field_binary_usage): Charsets.
(goodnight_gracie): Formatting.
* scan.l: Charsets.
* scan_ante.h (numstr_of): Charsets.
(typed_name): Charsets.
* show_parse.h: Charsets.
* structs.cc (create_cblc_file_t): Charsets.
* symbols.cc (symbol_table_extend): Charsets.
(WARNING_FIELD): Diagnostics.
(constq): Charsets.
(elementize): Charsets.
(field_size): Charsets.
(cbl_field_t::set_attr): Eliminate run-time component.
(cbl_field_t::clear_attr): Eliminate run-time component.
(field_memsize): Charsets.
(cbl_encoding_str): Charsets.
(symbols_dump): Charsets.
(is_variable_length): Formatting.
(field_str): Charsets.
(extend_66_capacity): Charsets.
(operator<<): Charsets.
(symbols_update): Charsets.
(symbol_field_parent_set): Charsets.
(symbol_table_init): Charsets.
(numeric_group_attrs): Charsets.
(symbol_field_add): Charsets.
(symbol_field_alias): Charsets.
(fd_record_size_cmp): Charsets.
(symbol_file_record_sizes): Charsets.
(cbl_alphabet_t::reencode): Charsets.
(symbol_temporary_location): Charsets.
(new_literal_2): Charsets.
(new_alphanumeric): Charsets.
(standard_internal): Charsets.
(cbl_field_t::codeset_t::stride): Charsets.
(cobol_alpha_encoding): Charsets.
(cobol_national_encoding): Charsets.
(new_temporary): Charsets.
(new_literal_float): Charsets.
(cbl_field_t::is_ascii): Charsets.
(cbl_field_t::internalize): Eliminate function.
(cbl_field_t::source_code_check): Charsets.
(iconv_cd): Charsets.
(cbl_field_t::encode): New function for charsets.
(cbl_field_t::set_capacity): Charsets.
(cbl_field_t::add_capacity): Charsets.
(cbl_field_t::char_capacity): Charsets.
(symbol_label_section_exists): Charsets.
(size): Charsets.
(validate_numeric_edited): Charsets.
* symbols.h (cobol_alpha_encoding): Charsets.
(cobol_national_encoding): Charsets.
(consistent_encoding_check): Charsets.
(class cbl_domain_elem_t): Charsets.
(struct cbl_domain_t): Charsets.
(struct cbl_field_data_t): Charsets.
(class cbl_field_data_t): Charsets.
(struct cbl_subtable_t): Charsets.
(struct cbl_field_t): Charsets.
(new_literal_float): Charsets.
(new_temporary): Charsets.
(new_literal_2): Charsets.
(symbol_temporary_location): Charsets.
(class temporaries_t): Charsets.
(struct symbol_elem_t): Charsets.
(symbol_elem_of): Charsets.
(symbol_unique_index): Charsets.
(cbl_field_type_name): Charsets.
(validate_numeric_edited): Charsets.
* token_names.h: Charsets.
* util.cc (cdf_literalize): Charsets.
(cbl_field_type_name): Charsets.
(determine_intermediate_type): Charsets.
(is_alpha_edited): Charsets.
(cbl_field_data_t::is_alpha_edited): Charsets.
(symbol_field_type_update): Charsets.
(redefine_field): Charsets.
(FIXED_WIDE_INT): Charsets.
(dirty_to_binary): Charsets.
(digits_from_int128): Charsets.
(binary_initial): Charsets.
(cbl_field_t::encode_numeric): Charsets.
(FOR_JIM): Temporary conditional demonstration code.
(parse_error_inc): Diagnostics.
(parse_error_count): Diagnostics.
(cbl_field_t::report_invalid_initial_value): Diagnostics.
(valid_move): Diagnostics.
(type_capacity): Charsets.
(symbol_unique_index): New function.
(cbl_unimplementedw): Formatting.

libgcobol/ChangeLog:

* charmaps.cc (__gg__encoding_iconv_name): Charsets.
(__gg__encoding_iconv_valid): Charsets.
(__gg__encoding_iconv_type): Charsets.
(encoding_descr): Charsets.
(__gg__encoding_iconv_descr): Charsets.
(__gg__iconverter): Charsets.
(__gg__miconverter): Charsets.
* charmaps.h (NOT_A_CHARACTER): Charsets.
(ascii_nul): Charsets.
(ascii_bang): Charsets.
(__gg__encoding_iconv_type): Charsets.
(__gg__iconverter): Charsets.
(__gg__miconverter): Charsets.
(DEFAULT_32_ENCODING): Charsets.
(class charmap_t): Charsets.
(__gg__get_charmap): Charsets.
* common-defs.h (enum cbl_field_attr_t):
(enum cbl_figconst_t): Formatting.
(LOW_VALUE_E): Handle enum arithmetic.
(ZERO_VALUE_E): Handle enum arithmetic.
(SPACE_VALUE_E): Handle enum arithmetic.
(QUOTE_VALUE_E): Handle enum arithmetic.
(HIGH_VALUE_E): Handle enum arithmetic.
(enum convert_type_t): Enum for new FUNCTION CONVERT.
(struct cbl_declarative_t): Formatting.
* encodings.h (struct encodings_t): Charsets.
* gcobolio.h: Charsets.
* gfileio.cc (get_filename): Rename to establish filename.
(establish_filename): Renamed from get_filename.
(relative_file_delete):  Charsets.
(__io__file_remove): Moved.
(trim_in_place): Charsets.
(relative_file_start): Charsets.
(relative_file_rewrite): Charsets.
(relative_file_write): Charsets.
(sequential_file_write): Charsets.
(line_sequential_file_read): Charsets.
(sequential_file_read): Charsets.
(relative_file_read): Charsets.
(__gg__file_reopen): Charsets.
(__io__file_open): Charsets.
(__io__file_close): Charsets.
(gcobol_fileops): Charsets.
(__gg__file_open): Charsets.
(__gg__file_remove): Charsets.
* gfileio.h (__gg__file_open): Charsets.
* gmath.cc (__gg__subtractf1_float_phase2): Comment.
(__gg__subtractf2_float_phase1): Comment.
(__gg__multiplyf1_phase2): Comment.
* intrinsic.cc (is_zulu_format): Charsets.
(string_to_dest): Charsets.
(get_all_time): Charsets.
(ftime_replace): Charsets.
(__gg__char): Charsets.
(__gg__current_date): Charsets.
(__gg__formatted_current_date): Charsets.
(__gg__formatted_date): Charsets.
(__gg__formatted_datetime): Charsets.
(__gg__formatted_time): Charsets.
(change_case): Charsets.
(__gg__upper_case): Charsets.
(numval): Charsets.
(numval_c): Charsets.
(__gg__trim): Charsets.
(__gg__reverse): Charsets.
(fill_cobol_tm): Charsets.
(__gg__seconds_from_formatted_time): Charsets.
(__gg__hex_of): Charsets.
(__gg__numval_f): Charsets.
(__gg__test_numval_f): Charsets.
(__gg__locale_date): Charsets.
(__gg__locale_time): Charsets.
(__gg__locale_time_from_seconds): Charsets.
* libgcobol.cc (NO_RDIGITS): Alias for (0).
(__gg__move): Forward reference.
(struct program_state): Charsets.
(cstrncmp): Charsets.
(__gg__init_program_state): Charsets.
(edited_to_binary): Charsets.
(var_is_refmod): Comment.
(__gg__power_of_ten): Reworked data initialization.
(__gg__scale_by_power_of_ten_1): Likewise.
(__gg__scale_by_power_of_ten_2): Likewise.
(value_is_too_big): Likewise.
(binary_to_big_endian): Likewise.
(binary_to_little_endian): Likewise.
(int128_to_int128_rounded): Likewise.
(get_binary_value_local): Likewise.
(get_init_value): Likewise.
(f128_to_i128_rounded): Likewise.
(__gg__initialization_values): Likewise.
(int128_to_field): Likewise.
(__gg__get_date_yymmdd): Charsets.
(__gg__field_from_string): Charsets.
(field_from_ascii): Charsets.
(__gg__get_date_yyyymmdd): Charsets.
(__gg__get_date_yyddd): Charsets.
(__gg__get_yyyyddd): Charsets.
(__gg__get_date_dow): Charsets.
(__gg__get_date_hhmmssff): Charsets.
(collation_position): Charsets.
(uber_compare): Charsets.
(__gg__dirty_to_binary): Charsets.
(__gg__dirty_to_float): Charsets.
(format_for_display_internal): Charsets.
(compare_88): Charsets.
(get_float128): Reworked.
(compare_field_class): Charsets.
(interconvert): Charsets.
(compare_strings): Charsets.
(__gg__compare_2): Charsets.
(compare_two_records): Charsets.
(__gg__sort_table): Charsets.
(init_var_both): Charsets.
(__gg__initialize_variable_clean): Charsets.
(alpha_to_alpha_move_from_location): Charsets.
(__gg__memdup): New function.
(alpha_to_alpha_move): Charsets.
(__gg__sort_workfile): Charsets.
(__gg__merge_files): Charsets.
(funky_find_wide): Charsets.
(funky_find_wide_backward): Charsets.
(normalize_id): Charsets.
(match_lengths): Charsets.
(the_alpha_and_omega): Charsets.
(the_alpha_and_omega_backward): Charsets.
(inspect_backward_format_1): Charsets.
(__gg__inspect_format_1): Charsets.
(inspect_backward_format_2): Charsets.
(__gg__inspect_format_2): Charsets.
(normalize_for_inspect_format_4): Charsets.
(__gg__inspect_format_4): Charsets.
(move_string): Charsets.
(brute_force_trim): Charsets.
(__gg__string): Charsets.
(display_both): Charsets.
(__gg__display_string): Charsets.
(__gg__bitwise_op): Charsets.
(is_numeric_display_numeric): Charsets.
(is_alpha_a_number): Charsets.
(classify_numeric_type): Charsets.
(classify_alphabetic_type): Charsets.
(__gg__classify): Charsets.
(__gg__convert_encoding): Charsets.
(accept_envar): Charsets.
(__gg__accept_envar): Charsets.
(__gg__get_argc): Charsets.
(__gg__get_argv): Charsets.
(__gg__get_command_line): Charsets.
(__gg__parser_set_conditional): Charsets.
(__gg__literaln_alpha_compare): Charsets.
(string_in): Charsets.
(__gg__unstring): Charsets.
(__gg__integer_from_float128): Charsets.
(__gg__adjust_dest_size): Charsets.
(__gg__just_mangle_name): Charsets.
(__gg__function_handle_from_name): Charsets.
(get_the_byte): Charsets.
(__gg__refer_from_string): Charsets.
(__gg__refer_from_psz): Charsets.
(__gg__find_string): Charsets.
(convert_for_convert): Charsets.
(__gg__convert): Charsets.
* libgcobol.h (__gg__compare_2): Charsets.
(__gg__field_from_string): Charsets.
(__gg__memdup): Charsets.
* posix/bin/Makefile: Posix bindings.
* posix/bin/scrape.awk: Posix bindings.
* posix/bin/udf-gen: Posix bindings.
* posix/udf/posix-lseek.cbl: Posix bindings.
* posix/udf/posix-unlink.cbl: Posix bindings.
* stringbin.cc (__gg__binary_to_string_encoded): Charsets.
(__gg__numeric_display_to_binary): Charsets.
* stringbin.h (__gg__binary_to_string_encoded): Charsets.
* valconv.cc (__gg__string_to_numeric_edited): Charsets.
* posix/cpy/psx-lseek.cpy: New file.
* posix/shim/lseek.cc: New file.

gcc/testsuite/ChangeLog:

* cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob:
Change diagnostics message.
* cobol.dg/group2/Multi-target_MOVE_with_subscript_re-evaluation.cob:
Change diagnostics message.
* cobol.dg/group2/floating-point_SUBTRACT_FORMAT_2.out:
Change diagnostics message.
* cobol.dg/group2/floating-point_literals.out:
Change diagnostics message.

2 months agoDaily bump.
GCC Administrator [Sat, 17 Jan 2026 00:16:34 +0000 (00:16 +0000)] 
Daily bump.

2 months agoc++/reflection: amend comment
Marek Polacek [Fri, 16 Jan 2026 22:30:05 +0000 (17:30 -0500)] 
c++/reflection: amend comment

Clarify that the current code seems fine.

gcc/cp/ChangeLog:

* reflect.cc (eval_variable_of): Update comment.

2 months ago[AutoFDO] Walk function body to to find existing max copyids per location
Kugan Vivekanandarajah [Fri, 16 Jan 2026 20:59:57 +0000 (07:59 +1100)] 
[AutoFDO] Walk function body to to find existing max copyids per location

This patch addresses the review comment and walks the function body to
find existing max copyids per location in init_copyid_allocator.

gcc/ChangeLog:

2026-01-15  Kugan Vivekanandarajah  <kvivekananda@nvidia.com>

* hierarchical_discriminator.cc (init_copyid_allocator): Walks the function
body to find existing max copyids per location.
(record_existing_copyid): New.

gcc/testsuite/ChangeLog:

2026-01-15  Kugan Vivekanandarajah  <kvivekananda@nvidia.com>

* gcc.dg/hierarchical-discriminator-loop-version.c: Simplify.
* gcc.dg/hierarchical-discriminator-unroll.c: Likewise
* gcc.dg/hierarchical-discriminator-vect-version.c: Likewise.

Signed-off-by: Kugan Vivekanandarajah <kvivekananda@nvidia.com>
2 months agoaarch64: Accept hyphenated extensions in --with-arch [PR123460]
Alice Carlotti [Wed, 7 Jan 2026 18:55:46 +0000 (18:55 +0000)] 
aarch64: Accept hyphenated extensions in --with-arch [PR123460]

Add "-" to the list of valid characters in an extension name that is
used when removing the first extension from an extension string.

gcc/ChangeLog:

PR target/123460
* config.gcc: Accept hyphens in aarch64 --with-arch extensions.

2 months agogccrs: Fix empty struct constructors causing ICE during type checking
Yap Zhi Heng [Sun, 28 Dec 2025 13:03:13 +0000 (21:03 +0800)] 
gccrs: Fix empty struct constructors causing ICE during type checking

gcc/rust/ChangeLog:

* typecheck/rust-hir-type-check-expr.cc (visit(StructExprStruct)): Update to properly
unwrap enum variants for type checking.
* typecheck/rust-tyty.cc (VariantDef::get_fields) : Remove NUM assert.
* backend/rust-compile-expr.cc: Update to properly unwrap enum variants for type
resolution checking.

Signed-off-by: Yap Zhi Heng <yapzhhg@gmail.com>
2 months agogccrs: Adds and fixes tests for outer attributes in expression
lenny.chiadmi-delage [Tue, 6 Jan 2026 14:57:47 +0000 (14:57 +0000)] 
gccrs: Adds and fixes tests for outer attributes in expression

Adds test of issue 3904 and fix test of the issue 3874 to follows rust
1.49 behavior.

Fixes GCC-Rust/gccrs#3904

gcc/testsuite/ChangeLog:

* rust/compile/issue-3874.rs: Fixes test.
* rust/compile/issue-3904.rs: New test.

Signed-off-by: lenny.chiadmi-delage <lenny.chiadmi-delage@epita.fr>
2 months agogccrs: handle outer attributes in expression parsing
lenny.chiadmi-delage [Tue, 6 Jan 2026 14:51:14 +0000 (14:51 +0000)] 
gccrs: handle outer attributes in expression parsing

Fix parsing of outer attributes in expressions.

Fixes Rust-GCC/gccrs#3904

gcc/rust/ChangeLog:

* parse/rust-parse-impl-expr.hxx(Parser::null_denotation): Add
HASH case to handle outer attributes in expressions.

Signed-off-by: lenny.chiadmi-delage <lenny.chiadmi-delage@epita.fr>
2 months agogccrs: add unused label lint
Lucas Ly Ba [Wed, 7 Jan 2026 11:46:50 +0000 (11:46 +0000)] 
gccrs: add unused label lint

gcc/rust/ChangeLog:

* checks/lints/unused/rust-unused-checker.cc (UnusedChecker::visit_loop_label):
Add warning for unused label in LoopLabel expr.
* checks/lints/unused/rust-unused-checker.h: Likewise.
* checks/lints/unused/rust-unused-collector.cc (UnusedCollector::visit):
Check in BreakExpr and ContinueExpr if a label is used.
* checks/lints/unused/rust-unused-collector.h: Likewise.
* checks/lints/unused/rust-unused-context.cc (UnusedContext::add_label):
Method helper.
(UnusedContext::is_label_used): Likewise
* checks/lints/unused/rust-unused-context.h: Likewise.

gcc/testsuite/ChangeLog:

* rust/compile/unused-label_0.rs: New test.

Signed-off-by: Lucas Ly Ba <lucas.ly-ba@outlook.com>
2 months agogccrs: util/attributes: error on malformed #[no_mangle] input
Jayant Chauhan [Tue, 6 Jan 2026 18:12:58 +0000 (23:42 +0530)] 
gccrs: util/attributes: error on malformed #[no_mangle] input

Emit a diagnostic when #[no_mangle] is used with arguments,
matching rustc behavior. The no_mangle attribute is a word
attribute and should not accept any input values.

Fixes Rust-GCC#4230

gcc/rust/ChangeLog:

* util/rust-attributes.cc (AttributeChecker::visit): Emit diagnostic.

gcc/testsuite/ChangeLog:

* rust/compile/no_mangle-malformed.rs: New test.

Signed-off-by: Jayant Chauhan <0001jayant@gmail.com>
2 months agogccrs: util/attributes: error on malformed #[target_feature] input
Jayant Chauhan [Tue, 6 Jan 2026 16:25:02 +0000 (21:55 +0530)] 
gccrs: util/attributes: error on malformed #[target_feature] input

Emit a diagnostic when #[target_feature] is used without arguments,
matching rustc behavior. This prevents silent acceptance of empty
attributes and provides a helpful diagnostic that shows the expected form.

Fixes Rust-GCC#4233

gcc/rust/ChangeLog:

* util/rust-attributes.cc (AttributeChecker::visit): Emit diagnostic.

gcc/testsuite/ChangeLog:

* rust/compile/target_feature-malformed-4233.rs: New test.

Signed-off-by: Jayant Chauhan <0001jayant@gmail.com>
2 months agogccrs: add redudant semicolon lint
Lucas Ly Ba [Tue, 6 Jan 2026 11:21:13 +0000 (11:21 +0000)] 
gccrs: add redudant semicolon lint

gcc/rust/ChangeLog:

* checks/lints/unused/rust-unused-checker.cc (UnusedChecker::visit):
Emit warning in empty statement visitor.
* checks/lints/unused/rust-unused-checker.h:
Likewise.

gcc/testsuite/ChangeLog:

* rust/compile/redundant-semicolons_0.rs: New test.

Signed-off-by: Lucas Ly Ba <lucas.ly-ba@outlook.com>
2 months agogccrs: util/attributes: error on malformed #[link_name] input
Jayant Chauhan [Sat, 3 Jan 2026 23:36:53 +0000 (05:06 +0530)] 
gccrs: util/attributes: error on malformed #[link_name] input

Emit a diagnostic when #[link_name] is used without arguments,
matching rustc behavior. This prevents silent acceptance of empty
attributes and provides a helpful diagnostic that shows the expected form.

Fixes Rust-GCC#4228

gcc/rust/ChangeLog:

* util/rust-attributes.cc: Emit diagnostic.

gcc/testsuite/ChangeLog:

* rust/compile/link_name-malformed.rs: New test.

Signed-off-by: Jayant Chauhan <0001jayant@gmail.com>
2 months agogccrs: nr: Ignore errors when doing prelude resolution
Arthur Cohen [Wed, 1 Oct 2025 10:10:58 +0000 (12:10 +0200)] 
gccrs: nr: Ignore errors when doing prelude resolution

We only want to emit the ones from regular name resolution as otherwise
they will be doubled for the user for no good reason.

gcc/rust/ChangeLog:

* resolve/rust-name-resolution-context.h:

Co-authored-by: Owen Avery <powerboat9.gamer@gmail.com>
2 months agogccrs: nr: Do prelude resolution for Identifiers
Arthur Cohen [Fri, 12 Sep 2025 14:11:15 +0000 (16:11 +0200)] 
gccrs: nr: Do prelude resolution for Identifiers

gcc/rust/ChangeLog:

* resolve/rust-forever-stack.h: New function.
* resolve/rust-forever-stack.hxx: Implement it.
* resolve/rust-late-name-resolver-2.0.cc (Late::visit): Call it if the prelude exists
and we have an unresolved Identifier Call it if the prelude exists and we have
an unresolved Identifier.

2 months agogccrs: forever-stack: Add extra path resolution from a known NodeId.
Arthur Cohen [Wed, 10 Sep 2025 07:39:18 +0000 (09:39 +0200)] 
gccrs: forever-stack: Add extra path resolution from a known NodeId.

gcc/rust/ChangeLog:

* resolve/rust-forever-stack.h: Add new resolve_path function.
* resolve/rust-forever-stack.hxx: Implement it.

2 months agogccrs: nr: Add prelude field to NRCtx, and fill it upon encountering a prelude.
Arthur Cohen [Wed, 10 Sep 2025 07:07:55 +0000 (09:07 +0200)] 
gccrs: nr: Add prelude field to NRCtx, and fill it upon encountering a prelude.

gcc/rust/ChangeLog:

* resolve/rust-early-name-resolver-2.0.cc (Early::finalize_glob_import): Save prelude
if we find one.
* resolve/rust-name-resolution-context.h: Add field.
* resolve/rust-toplevel-name-resolver-2.0.cc (has_prelude_import): New function.
(TopLevel::visit): Create a prelude glob import if necessary.
* resolve/rust-toplevel-name-resolver-2.0.h: Allow glob imports to be prelude imports.

2 months agogccrs: forever-stack: Display depth in debug string
Arthur Cohen [Wed, 31 Dec 2025 15:29:23 +0000 (16:29 +0100)] 
gccrs: forever-stack: Display depth in debug string

gcc/rust/ChangeLog:

* resolve/rust-forever-stack.h: Add depth parameter to function.
* resolve/rust-forever-stack.hxx: Likewise and use it.

2 months agogccrs: Explicitely specify templates for GCC5
Pierre-Emmanuel Patry [Mon, 5 Jan 2026 16:03:27 +0000 (17:03 +0100)] 
gccrs: Explicitely specify templates for GCC5

GCC5 does not infer correctly the type to use within the template.

gcc/rust/ChangeLog:

* parse/rust-parse-impl-expr.hxx: Use explicit template.
* parse/rust-parse-impl-path.hxx: Likewise.
* parse/rust-parse-impl-ttree.hxx: Likewise.
* parse/rust-parse-impl.hxx: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
2 months agogccrs: Use error wrapper when required instead of nullptr
Pierre-Emmanuel Patry [Fri, 26 Dec 2025 03:38:52 +0000 (04:38 +0100)] 
gccrs: Use error wrapper when required instead of nullptr

gcc/rust/ChangeLog:

* ast/rust-ast-collector.cc (TokenCollector::visit): Update function
name.
* ast/rust-ast-pointer-visitor.cc (PointerVisitor::visit): Likewise.
* ast/rust-ast-visitor.cc (DefaultASTVisitor::visit): Likewise.
* ast/rust-ast.cc (BreakExpr::as_string): Use getter function.
(AttributeParser::parse_path_meta_item): Convert to expected type.
(ReturnExpr::as_string): Change access to returned expr.
* ast/rust-desugar-for-loops.cc (DesugarForLoops::DesugarCtx::make_break_arm):
Likewise.
* ast/rust-expr.h (class BreakExpr): Make expr in break optional.
(class ReturnExpr): Make returned expr explicitely optional. Change the
getters and introduce a  const getter.
* expand/rust-cfg-strip.cc (CfgStrip::visit): Convert to expected type.
* expand/rust-macro-builtins-asm.cc (parse_reg_operand_in): Update
constructor call to new expected types.
(parse_reg_operand_out): Likewise.
(parse_reg_operand_inout): Likewise.
(parse_llvm_operands): Likewise.
* expand/rust-macro-builtins-format-args.cc (format_args_parse_expr):
Likewise.
(format_args_parse_arguments): Likewise.
* expand/rust-macro-builtins-helpers.cc (try_expand_many_expr): Update
value for tl::expected.
* expand/rust-macro-builtins-include.cc (MacroBuiltin::include_handler):
Likewise.
* expand/rust-macro-expand.cc (transcribe_expression): Update
constructor call with expected value.
* hir/rust-ast-lower-expr.cc (ASTLoweringExpr::visit): Likewise.
* parse/rust-parse-error.h (enum class): Add new error types for Expr
and StructExprField.
* parse/rust-parse-impl-expr.hxx: Explicitely handle return expr
parsing failure. Update to fit new expected types.
* parse/rust-parse-impl.hxx: Likewise.
* resolve/rust-late-name-resolver-2.0.cc (Late::visit): Adapt to
tl::expected.
* ast/rust-desugar-while-let.cc (DesugarWhileLet::DesugarCtx::make_break_arm):
Use optional for break expressions when missing instead of nullptr.
* parse/rust-parse.h: Change function return type with expected. Remove
error state from ExprOrStmt.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
2 months agogccrs: Remove redundant error types
Pierre-Emmanuel Patry [Fri, 12 Dec 2025 12:17:22 +0000 (13:17 +0100)] 
gccrs: Remove redundant error types

Some error types in the parser had the exact same meaning and could be
grouped under one same type.

gcc/rust/ChangeLog:

* ast/rust-ast.cc (AttributeParser::parse_meta_item_lit): Use
tl::expected
* expand/rust-macro-builtins-helpers.cc (parse_single_string_literal):
Likewise.
* expand/rust-macro-expand.cc (MacroExpander::match_fragment):
Likewise.
* parse/rust-cfg-parser.cc (parse_cfg_option): Likewise.
* parse/rust-parse-error.h (struct SimplePath): Remove error type.
(struct DelimTokenTree): Likewise.
(struct Token): Likewise.
(struct TokenTree): Likewise.
(class LifetimeParam): Move from here ...
(struct LifetimeParam): ... to here. Add ctor.
(class Lifetime): Add error type.
(enum class): Remove AnonConst.
(struct BlockExpr): Change BlockExpr to generic node error.
* parse/rust-parse-impl-expr.hxx: Use tl::expected for errors.
* parse/rust-parse-impl-path.hxx: Likewise.
* parse/rust-parse-impl-ttree.hxx: Likewise.
* parse/rust-parse-impl.hxx: Likewise.
* parse/rust-parse.h: Update function return types with tl::expected
to propagate errors.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
2 months agogccrs: Use tl::expected for parse_block_expr results
Pierre-Emmanuel Patry [Wed, 10 Dec 2025 14:24:58 +0000 (15:24 +0100)] 
gccrs: Use tl::expected for parse_block_expr results

gcc/rust/ChangeLog:

* parse/rust-parse-error.h (struct BlockExpr): Add BlockExpr error type
* parse/rust-parse-impl-expr.hxx: Update return types.
* parse/rust-parse-impl.hxx: Likewise.
* parse/rust-parse.h: Update function prototypes.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
2 months agogccrs: Use error collector in the parser
Pierre-Emmanuel Patry [Wed, 10 Dec 2025 12:59:13 +0000 (13:59 +0100)] 
gccrs: Use error collector in the parser

Errors in the parser needs to be collected instead of emitted directly.

gcc/rust/ChangeLog:

* parse/rust-parse-impl.hxx: Collect errors instead of emitting them.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
2 months agogccrs: Move old parser error classes to error header
Pierre-Emmanuel Patry [Wed, 10 Dec 2025 12:38:24 +0000 (13:38 +0100)] 
gccrs: Move old parser error classes to error header

A parser error header with Parse::Error namespace has recently been
introduced. Move some old parser error classes to this namespace.

gcc/rust/ChangeLog:

* parse/rust-parse.h (class ParseLifetimeParamError): Move error from
here ...
(class ParseLifetimeError): Likewise.
(enum class): Likewise.
* parse/rust-parse-error.h (class LifetimeParam): ... to here.
here.
(class Lifetime): Likewise.
(enum class): Likewise.
(struct LoopLabel): Likewise and make it a full struct with ctors.
(struct Self): Likewise.
* parse/rust-parse-impl-expr.hxx: Make error point to new namespace.
* parse/rust-parse-impl.hxx: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
2 months agogccrs: Fix rogue macro error during lowering on expansion failure
Harishankar [Thu, 1 Jan 2026 05:17:23 +0000 (10:47 +0530)] 
gccrs: Fix rogue macro error during lowering on expansion failure

When a macro expansion fails (e.g. due to a parsing error like invalid
syntax in the macro body), the expander previously returned an error
fragment but did not update the AST. This left the original macro
invocation in place, which subsequently caused an ICE (rogue macro
detected) during the lowering phase.

This patch updates `expand_invoc` to replace the macro invocation with
an empty fragment if expansion fails, ensuring the compiler can proceed
(or exit gracefully) without crashing.

Fixes Rust-GCC/gccrs#4213

gcc/rust/ChangeLog:

* expand/rust-macro-expand.cc (MacroExpander::expand_invoc): Handle
error fragments by replacing them with empty fragments.

gcc/testsuite/ChangeLog:

* rust/compile/issue-4213.rs: New test.

Signed-off-by: Harishankar <harishankarpp7@gmail.com>
2 months agogccrs: remove match arm pattern vector to single pattern
Lucas Ly Ba [Thu, 20 Nov 2025 14:01:08 +0000 (14:01 +0000)] 
gccrs: remove match arm pattern vector to single pattern

This patch refactors all uses of vector patterns since a vector of
patterns would be considered as an alt pattern, a vector is considered
useless.

gcc/rust/ChangeLog:

* ast/rust-ast-builder.cc (Builder::match_arm): Moves the vector of patterns
to a single pattern.
* ast/rust-ast-collector.cc (TokenCollector::visit):Likewise.
* ast/rust-ast-pointer-visitor.cc (PointerVisitor::visit):Likewise.
* ast/rust-ast-visitor.cc (DefaultASTVisitor::visit):Likewise.
* ast/rust-ast.cc (IfLetExpr::as_string):Likewise.
(WhileLetLoopExpr::as_string):Likewise.
(MatchArm::as_string):Likewise.
* ast/rust-desugar-question-mark.cc (make_match_arm):Likewise.
* ast/rust-desugar-while-let.cc (DesugarWhileLet::desugar):Likewise.
* ast/rust-expr.h (class WhileLetLoopExpr):Likewise.
(class IfLetExpr):Likewise.
* backend/rust-compile-expr.cc (CompileExpr::visit):Likewise.
* checks/errors/rust-hir-pattern-analysis.cc (lower_arm):Likewise.
* expand/rust-cfg-strip.cc (CfgStrip::visit):Likewise.
* hir/rust-ast-lower.cc (ASTLoweringIfLetBlock::desugar_iflet):Likewise.
(ASTLoweringExprWithBlock::visit):Likewise.
* hir/rust-hir-dump.cc (Dump::do_matcharm):Likewise.
(Dump::visit):Likewise.
* hir/tree/rust-hir-expr.cc (OperatorExpr::operator=):Likewise.
(ArithmeticOrLogicalExpr::operator=):Likewise.
(ComparisonExpr::operator=):Likewise.
(LazyBooleanExpr::operator=):Likewise.
(TypeCastExpr::operator=):Likewise.
(AssignmentExpr::operator=):Likewise.
(CompoundAssignmentExpr::operator=):Likewise.
(GroupedExpr::operator=):Likewise.
(ArrayExpr::operator=):Likewise.
(ArrayIndexExpr::operator=):Likewise.
(CallExpr::operator=):Likewise.
(MethodCallExpr::operator=):Likewise.
(FieldAccessExpr::operator=):Likewise.
(BlockExpr::operator=):Likewise.
(BreakExpr::operator=):Likewise.
(ReturnExpr::operator=):Likewise.
(UnsafeBlockExpr::operator=):Likewise.
(BaseLoopExpr::operator=):Likewise.
(WhileLetLoopExpr::WhileLetLoopExpr):Likewise.
(WhileLetLoopExpr::operator=):Likewise.
(MatchArm::MatchArm):Likewise.
(MatchArm::operator=):Likewise.
(MatchExpr::operator=):Likewise.
* hir/tree/rust-hir-expr.h (class WhileLetLoopExpr):Likewise.
* hir/tree/rust-hir-visitor.cc (DefaultHIRVisitor::walk):Likewise.
(DefaultHIRVisitor::visit_match_arm):Likewise.
* hir/tree/rust-hir.cc (WhileLetLoopExpr::as_string):Likewise.
(MatchArm::as_string):Likewise.
* parse/rust-parse-impl-expr.hxx: Likewise.
* parse/rust-parse-impl.hxx: Likewise.
* parse/rust-parse.h:Likewise.
* resolve/rust-default-resolver.cc (DefaultResolver::visit_if_let_patterns):Likewise.
* resolve/rust-late-name-resolver-2.0.cc (Late::visit):Likewise.
* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit):Likewise.

Signed-off-by: Lucas Ly Ba <lucas.ly-ba@outlook.com>
2 months agogccrs: nr: Add better error to unresolved attribute macro
Arthur Cohen [Tue, 16 Sep 2025 08:47:05 +0000 (10:47 +0200)] 
gccrs: nr: Add better error to unresolved attribute macro

gcc/rust/ChangeLog:

* resolve/rust-early-name-resolver-2.0.cc (Early::visit_attributes): Mention the name
of the attribute macro that hasn't been found.

2 months agoanalyzer: fix check against --param=analyzer-bb-explosion-factor=0
David Malcolm [Fri, 16 Jan 2026 15:54:32 +0000 (10:54 -0500)] 
analyzer: fix check against --param=analyzer-bb-explosion-factor=0

analyzer.texi documents --param=analyzer-bb-explosion-factor=0 as a way
to make the analysis bail out early, but I broke this in
r16-6063-g0b786d961d4426.

Fix thusly.

gcc/analyzer/ChangeLog:
* engine.cc (exploded_graph::process_worklist): Remove guard on
limit being non-zero when checking for -Wanalyzer-too-complex
on overall number of exploded nodes.  Allow for the origin enode.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>
2 months agoanalyzer: add timevar values for supergraph manipulation [PR123145]
David Malcolm [Fri, 16 Jan 2026 15:54:31 +0000 (10:54 -0500)] 
analyzer: add timevar values for supergraph manipulation [PR123145]

Whilst tracking down the slowdown of PR analyzer/123145, I noticed that
the various supergraph manipulations introduced in
r16-6063-g0b786d961d4426 can take non-trivial amounts of time on
complicated TUs.  Add timevars to track each of them.

gcc/analyzer/ChangeLog:
PR analyzer/123145
* supergraph-fixup-locations.cc: Include "timevar.h".
(supergraph::fixup_locations): Track time spent as
TV_ANALYZER_SUPERGRAPH_FIXUP_LOCATIONS.
* supergraph-simplify.cc: Include "timevar.h".
(supergraph::simplify): Track time spent as
TV_ANALYZER_SUPERGRAPH_SIMPLIFY.
* supergraph-sorting.cc: Include "timevar.h".
(supergraph::sort_nodes): Track time spent as
TV_ANALYZER_SUPERGRAPH_SORTING.
* supergraph.cc (supergraph::supergraph): Track time spent as
TV_ANALYZER_SUPERGRAPH_CREATION rather than
TV_ANALYZER_SUPERGRAPH.

gcc/ChangeLog:
PR analyzer/123145
* timevar.def (TV_ANALYZER_SUPERGRAPH): Rename to...
(TV_ANALYZER_SUPERGRAPH_CREATION): ...this.
(TV_ANALYZER_SUPERGRAPH_FIXUP_LOCATIONS): New.
(TV_ANALYZER_SUPERGRAPH_SIMPLIFY): New.
(TV_ANALYZER_SUPERGRAPH_SORTING): New.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>
2 months agoanalyzer: eliminate unused field eh_dispatch_edge_op::m_dst_snode [PR123540]
David Malcolm [Fri, 16 Jan 2026 15:54:31 +0000 (10:54 -0500)] 
analyzer: eliminate unused field eh_dispatch_edge_op::m_dst_snode [PR123540]

gcc/analyzer/ChangeLog:
PR analyzer/123540
* ops.cc (eh_dispatch_edge_op::make): Drop dst_snode param to
ctor.
(eh_dispatch_edge_op::eh_dispatch_edge_op): Likewise, dropping
field eh_dispatch_edge_op::m_dst_snode.
(eh_dispatch_try_edge_op::eh_dispatch_try_edge_op): Likewise.
(eh_dispatch_allowed_edge_op::eh_dispatch_allowed_edge_op):
Likewise.
* ops.h (eh_dispatch_edge_op::eh_dispatch_edge_op): Likewise.
(eh_dispatch_edge_op::m_dst_snode): Drop unused field.
(eh_dispatch_try_edge_op::eh_dispatch_try_edge_op): Drop unused
dst_snode param.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>
2 months ago[PR123092, LRA]: Reprocess insn after equivalence substitution
Vladimir N. Makarov [Fri, 16 Jan 2026 15:09:52 +0000 (10:09 -0500)] 
[PR123092, LRA]: Reprocess insn after equivalence substitution

LRA in the test case substituted equivalence in an insn but did not
process the insn on satisfying constraints after that.  It resulted in
error "insn does not satisfy its constraints"

gcc/ChangeLog:

PR target/123092
* lra-constraints.cc (lra_constraints): Push insn on processing
stack after equivalence substitution.

gcc/testsuite/ChangeLog:

PR target/123092
* gcc.target/riscv/pr123092.c: New.

2 months agoc++/reflection: enable more testing
Marek Polacek [Thu, 15 Jan 2026 19:57:13 +0000 (14:57 -0500)] 
c++/reflection: enable more testing

These TODOs already work fine so let's enable more testing.

gcc/testsuite/ChangeLog:

* g++.dg/reflect/member15.C: Enable commented-out test.
* g++.dg/reflect/splice5.C: Likewise.  Add XFAIL.

Reviewed-by: Jason Merrill <jason@redhat.com>
2 months agoProvide gt_pch_get_address etc. on FreeBSD [PR110746]
Rainer Orth [Fri, 16 Jan 2026 12:12:03 +0000 (13:12 +0100)] 
Provide gt_pch_get_address etc. on FreeBSD [PR110746]

On FreeBSD/amd64, more than 700 tests FAIL like

FAIL: gcc.dg/pch/common-1.c  -O0 -g -I. -Dwith_PCH (test for excess errors)
Excess errors:
gcc/testsuite/gcc.dg/pch/common-1.c:1: sorry, unimplemented: PCH allocation failure

This can easily be fixed by implementing the
host_hooks.gt_pch_get_address hook.  The code is shamelessly stolen from
the openbsd implementation, only changing the names and omitting the
hppa and i386 code.  The former isn't supported by FreeBSD at all AFAIK,
while the latter has just been removed in FreeBSD 15.0.

Bootstrapped without regressions on x86_64-unknown-freebsd14.3: all PCH
failures are gone.

2026-01-15  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gcc:
PR pch/110746
* config/host-freebsd.cc: New file.
* config.host <*-*-freebsd*>: Use it.
* config/x-freebsd: New file.

2 months agoipa-cp: Fix devirt bonus for targets that cannot be inlined
Martin Jambor [Fri, 16 Jan 2026 11:04:23 +0000 (12:04 +0100)] 
ipa-cp: Fix devirt bonus for targets that cannot be inlined

PR 123412 has been filed because since commit
r16-3990-gad3fb999a1b568 (Jan Hubicka: Improve ipa-cp devirtualization
costing), there is accidentally zero devirtualization bonus for
functions which cannot be inlined.  This has resulted in
g++.dg/ipa/devirt-2.C failing since it has been pushed because the
required function is not cloned even with --param max-devirt-targets=1.

The intention was that we do get at least some small benefit boost and
so this patch adds an addition of the indirect edge frequency once
before the early continue statements.

gcc/ChangeLog:

2026-01-14  Martin Jambor  <mjambor@suse.cz>

PR ipa/123412
* ipa-cp.cc (devirtualization_time_bonus): Do add the indirect
edge frequency at least once even for targets which cannot be
inlined.

2 months agoc, c++: Fix vector enum division handling [PR123437]
Jakub Jelinek [Fri, 16 Jan 2026 10:03:18 +0000 (11:03 +0100)] 
c, c++: Fix vector enum division handling [PR123437]

To my surprise we accept generic vectors with enumeral element
types (unlike e.g. _Complex) and we don't actually try to
perform "integral" promotions for those either (which for scalars
promotes ENUMERAL_TYPE operands to their underlying type or
promoted underlying type).  I'm afraid it is inappropriate
to change the promotions at this point in stage4, that would
be a significant user visible change (though sure for a feature
that hopefully nobody actually uses).  Anyway, in GCC 16
development some assertions that RDIV_EXPR is only used for floating
(scalar/vector/complex) operands were added and those now trigger
on trying to divide vectors where both operands are enum vectors.
THis is due to the FEs using RDIV_EXPR instead of TRUNC_DIV_EXPR
when the operands (after promotions) don't have INTEGER_TYPE (or for C
BITINT_TYPE) operands.

This patch just adds vector enum to that.

2026-01-16  Jakub Jelinek  <jakub@redhat.com>
    Peter Damianov  <peter0x44@disroot.org>

PR c/123437
* c-typeck.cc (build_binary_op): Don't use RDIV_EXPR
resultcode if both types are integral, _BitInt or
newly VECTOR_TYPE of ENUMERAL_TYPE.

* typeck.cc (cp_build_binary_op): Don't use RDIV_EXPR
resultcode if both types are integral, _BitInt or
newly VECTOR_TYPE of ENUMERAL_TYPE.

* c-c++-common/pr123437.c: New test.

2 months agoi386: Fix up movhf_mask constraints [PR123607]
Jakub Jelinek [Fri, 16 Jan 2026 07:22:32 +0000 (08:22 +0100)] 
i386: Fix up movhf_mask constraints [PR123607]

As documented in the manuals and enforced by gas,
VMOVSH two operand loads and three operands moves accept both
masking and masking/zeroing, but VMOVSH two operand store accepts
only masking:
EVEX.LLIG.F3.MAP5.W0 10 /r VMOVSH xmm1{k1}{z}, m16
EVEX.LLIG.F3.MAP5.W0 11 /r VMOVSH m16{k1}, xmm1
EVEX.LLIG.F3.MAP5.W0 10 /r VMOVSH xmm1{k1}{z}, xmm2, xmm3
EVEX.LLIG.F3.MAP5.W0 11 /r VMOVSH xmm1{k1}{z}, xmm2, xmm3
But the constraints in movhf_mask define_insn were allowing 0C
for all the alternatives.  The following patch enforces just 0
(i.e. just non-zeroing masking) for the second alternative (i.e.
the store).

2026-01-16  Jakub Jelinek  <jakub@redhat.com>

PR target/123607
* config/i386/i386.md (movhf_mask): Change constraint on
match_operand 2's second alternative from 0C to 0.

* g++.target/i386/avx512fp16-pr123607.C: New test.

2 months agoLoongArch: Fix bug123521.
Lulu Cheng [Mon, 12 Jan 2026 09:23:41 +0000 (17:23 +0800)] 
LoongArch: Fix bug123521.

In the vector initialization process, optimization can be performed
if it can be determined that all elements are the same, or if the
upper or lower halves are identical.  However, during this
optimization, when the identical element is an immediate value
larger than 10 bits, an internal compiler error (ICE) occurs.
The reason is that in such cases, the function
`simplify_gen_subreg (imode, reg_tmp, GET_MODE (reg_tmp), 0)` is
called, where `imode` is `E_DImode`.  The mode of `reg_tmp` in
`GET_MODE (reg_tmp)` is taken from the immediate value's mode,
which is `E_VOIDmode`.  This results in a move from `E_VOIDmode`
to `E_DImode`, an operation not supported by LoongArch.

PR target/123521

gcc/ChangeLog:

* config/loongarch/loongarch.cc
(loongarch_expand_vector_init_same): Fixed a bug in the
vector initialization section..

gcc/testsuite/ChangeLog:

* gcc.target/loongarch/vector/lasx/pr123521.c: New test.

Suggested-by: Xi Ruoyao <xry111@xry111.site>
2 months agoMIPS: Add R5900 to ISA_HAS_FMIN_FMAX.
David Guillen Fandos [Wed, 14 Jan 2026 23:45:37 +0000 (00:45 +0100)] 
MIPS: Add R5900 to ISA_HAS_FMIN_FMAX.

The R5900 doesn't have proper IEEE754 handling: for all its FP
instructions, like "c.eq.s" or "add.s".

Since most of the other instructions are also broken,
so we can just define this, and the users should know about
what they are doing.

gcc/ChangeLog:

* config/mips/mips.h (ISA_HAS_FMIN_FMAX): Add R5900;
note that, R5900 is not IEEE754 fully compatiable.

Signed-off-by: David Guillen Fandos <david@davidgf.net>
2 months agoDaily bump.
GCC Administrator [Fri, 16 Jan 2026 00:16:30 +0000 (00:16 +0000)] 
Daily bump.

2 months agotestsuite: Require target x86_64 and aarch64 for gcc.dg/pr123109.c
Pengxuan Zheng [Thu, 15 Jan 2026 19:53:21 +0000 (11:53 -0800)] 
testsuite: Require target x86_64 and aarch64 for gcc.dg/pr123109.c

This fixes failures on i686 and arm.

gcc/testsuite/ChangeLog:

* gcc.dg/pr123109.c: Require target x86_64 and aarch64.

Signed-off-by: Pengxuan Zheng <pengxuan.zheng@oss.qualcomm.com>
2 months agoFix RISC-V test after recent vectorizer changes
Jeff Law [Thu, 15 Jan 2026 19:49:55 +0000 (12:49 -0700)] 
Fix RISC-V test after recent vectorizer changes

Richi's patch to fix costing of permuted contiguous loads changed the code
generation for pr122445.c in the testsuite.  After reviewing the code, it looks
clearly better to me -- essentially covering 2X as many elements per vector op
with fewer total vector ops in the end (without resulting to LMUL > 1).

I've verified this fixes the overnight regressions seen on riscv{32,64}-elf.
The bootstrap and regression tests are in flight, but won't finish for many
more hours.

gcc/testsuite
* gcc.target/riscv/rvv/autovec/pr122445.c: Adjust expected output.

2 months agoc-family: Regenerate c.opt.urls
Jakub Jelinek [Thu, 15 Jan 2026 16:12:07 +0000 (17:12 +0100)] 
c-family: Regenerate c.opt.urls

We forgot to regenerate c.opt.urls after the addition of -freflection
to c.opt.

2026-01-15  Jakub Jelinek  <jakub@redhat.com>

* c.opt.urls: Regenerate.

2 months agolibstdc++: Fix __cpp_impl_reflection comparisons
Jakub Jelinek [Thu, 15 Jan 2026 15:34:14 +0000 (16:34 +0100)] 
libstdc++: Fix __cpp_impl_reflection comparisons

Last night when applying Marek's patchset for testing I've noticed I forgot
to change these 5 spots when changing the -freflection -std=c++26 predefined
value from 202500 which meant we implement some reflection, but not the
whole paper, to 202506 which is the https://eel.is/c++draft/tab:cpp.predefined.ft
value for it.

2026-01-15  Jakub Jelinek  <jakub@redhat.com>

* include/std/type_traits (std::is_reflection, std::is_fundamental,
std::is_reflection_v, std::is_consteval_only): Compare
__cpp_impl_reflection >= 202506L instead of 202500L.
* testsuite/20_util/variable_templates_for_traits.cc: Likewise.

2 months agoc++: C++26 Reflection [PR120775]
Marek Polacek [Wed, 14 Jan 2026 16:37:39 +0000 (11:37 -0500)] 
c++: C++26 Reflection [PR120775]

This patch implements C++26 Reflection as specified by P2996R13, which allows
users to perform magic.  This patch also implements related papers:
Annotations for Reflection (P3394R4),
Splicing a base class subobject (P3293R3),
define_static_{string,object,array} (P3491R3),
Function Parameter Reflection (P3096R12).
(I already implemented consteval blocks back in July.)
(We do not yet implement P3795.)

We also implemented some CWG issues that had been approved in Kona;
e.g., CWG 3101, 3109, 3111, 3115, 3117.

All metafunctions are implemented in this patch.

The feature needs to be enabled by -std=c++26 -freflection.

Some stats: the v1 patch was over 51,200 LOC which were written in ~335
commits.  It came with over 400 tests with 11,722 static_asserts.  We still
had about 50 TODOs and FIXMEs in the code.
v2 consists of about 56,000 LOC which were created in 440 commits.  We
now have 446 tests with 40 TODOs remaining.
v3 brought another 77 commits, mostly clean-ups and various bug fixes.

I'd like to thank:
Jakub Jelinek, whose efforts can only be described as heroic and who
never ceases to amaze me even after nearly 15 years of working together,
he implemented many difficult metafunctions, annotations, mangling,
converted our metafunction dispatch to using gperf, and so on and on;
Jonathan Wakely for his libstdc++ patch review and generous & impeccable
advice even at odd hours; Dan Katz for his work on the Reflection papers,
writing Reflection tests for clang++ (many of which I've stolen^Wused),
for his advice, bug reports, and generally cheering me on; Jason Merrill
for his guidance, patch review, and, in fact, encouraging me to take on
this project in the first place; Michael Levine, Valentyn Yukhymenko, and
Alex Yesmanchyk for their nice contributions to Reflection; and Tomasz
Kamiński for providing test cases, finding bugs, and answering my C++
questions.

PR c++/120775
PR c++/123081
PR c++/122634

gcc/ChangeLog:

* attribs.cc (attribute_value_equal): Return false if either attribute
is ATTR_UNIQUE_VALUE_P.
(merge_attributes): Handle lists with ATTR_UNIQUE_VALUE_P values.
* doc/invoke.texi: Document -freflection.
* dwarf2out.cc (is_base_type) <case default>: Check
TREE_CODE >= LAST_AND_UNUSED_TREE_CODE instead of is_cxx_auto.
(gen_type_die_with_usage): For TREE_CODE >= LAST_AND_UNUSED_TREE_CODE
trees use use DW_TAG_unspecified_type.
* tree-core.h (struct tree_base): Update a comment.
* tree.h (ATTR_UNIQUE_VALUE_P): Define.
(BINFO_BASE_ACCESSES): Update the comment.

gcc/c-family/ChangeLog:

* c-attribs.cc (attribute_takes_identifier_p): Return false for C++
annotations.  Handle "old parm name".
* c-cppbuiltin.cc (c_cpp_builtins): Define __cpp_impl_reflection.
* c.opt (freflection): New.

gcc/cp/ChangeLog:

* Make-lang.in: Add cp/reflect.o.  Add a rule for cp/metafns.h.
* config-lang.in: Add reflect.cc.
* constexpr.cc (constexpr_global_ctx): Add consteval_block and
metafns_called members.  Initialize them.
(cxx_constexpr_quiet_p): New.
(cxx_constexpr_manifestly_const_eval): New.
(cxx_constexpr_caller): New.
(cxx_constexpr_consteval_block): New.
(enum value_cat): Move into cp-tree.h.
(cxx_eval_constant_expression): Move the declaration into cp-tree.h.
No longer static.  Handle REFLECT_EXPR.  Handle conversion of
a reflection to the meta::info type.
(cxx_eval_cxa_builtin_fn): Override current_function_decl.
(cxx_eval_builtin_function_call): Handle __builtin_is_string_literal.
(is_std_allocator): Also check __new_allocator.
(is_std_allocator_allocate): No longer static.
(cxa_allocate_and_throw_exception): New.
(cxx_eval_call_expression): Handle metafunctions.  Maybe set
metafns_called.
(reduced_constant_expression_p): Handle REFLECT_EXPR.
(cxx_eval_binary_expression): Use compare_reflections for comparing
reflections.
(find_immediate_fndecl): Don't walk REFLECT_EXPR_P.
(cxx_eval_outermost_constant_expr): Set global_ctx.consteval_block.
Detect consteval-only smuggling.
(potential_constant_expression_1): Return true for REFLECT_EXPR
and SPLICE_EXPR.
* constraint.cc (diagnose_trait_expr): Add CPTK_IS_CONSTEVAL_ONLY case.
* cp-gimplify.cc (immediate_escalating_function_p): No longer static.
(promote_function_to_consteval): Likewise.
(cp_gimplify_expr) <case CALL_EXPR>: Detect any surviving consteval-only
expressions.
<case CP_BUILT_IN_IS_STRING_LITERAL>: Handle.
(wipe_consteval_only_r): New.
(cp_fold_immediate_r): Detect invalid uses of consteval-only types.
Clear consteval-only DECL_EXPRs.
(cp_genericize_r): Wipe consteval-only vars from BIND_EXPR_VARS and
BLOCK_VARS.
* cp-objcp-common.cc (cp_common_init_ts): Mark META_TYPE, SPLICE_SCOPE,
SPLICE_EXPR, and REFLECT_EXPR.
* cp-trait.def (IS_CONSTEVAL_ONLY): New trait.
* cp-tree.def (REFLECT_EXPR, META_TYPE, SPLICE_EXPR, SPLICE_SCOPE): New
trees.
* cp-tree.h (enum cp_tree_index): Add CPTI_ANNOTATION_IDENTIFIER,
CPTI_STD_META, and CPTI_META_INFO_TYPE.
(std_meta_node): Define.
(meta_info_type_node): Define.
(annotation_identifier): Define.
(REFLECTION_TYPE_P): Define.
(REFLECT_EXPR_P): Define.
(REFLECT_EXPR_HANDLE): Define.
(enum reflect_kind): New.
(REFLECT_EXPR_KIND): Define.
(SET_REFLECT_EXPR_KIND): Define.
(SPLICE_EXPR_EXPRESSION_P): Define.
(SET_SPLICE_EXPR_EXPRESSION_P): Define.
(SPLICE_EXPR_MEMBER_ACCESS_P): Define.
(SET_SPLICE_EXPR_MEMBER_ACCESS_P): Define.
(SPLICE_EXPR_ADDRESS_P): Define.
(SET_SPLICE_EXPR_ADDRESS_P): Define.
(SPLICE_SCOPE_EXPR): Define.
(SPLICE_SCOPE_TYPE_P): Define.
(WILDCARD_TYPE_P): Include SPLICE_SCOPE.
(COMPONENT_REF_SPLICE_P): Define.
(SCALAR_TYPE_P): Include REFLECTION_TYPE_P.
(ENUM_BEING_DEFINED_P): Define.
(OLD_PARM_DECL_P): Define.
(MULTIPLE_NAMES_PARM_P): Define.
(cp_preserve_using_decl): Declare.
(DEF_OPERATOR, DEF_ASSN_OPERATOR): Include META.
(struct ovl_op_info_t): Add meta_name member.
(enum cp_built_in_function): Add CP_BUILT_IN_IS_STRING_LITERAL.
(build_stub_type): Declare.
(current_function_decl_without_access_scope): Declare.
(dependent_namespace_p): Declare.
(convert_reflect_constant_arg): Declare.
(finish_base_specifier): Adjust declaration.
(parsing_lambda_declarator): Declare.
(fold_builtin_is_string_literal): Declare.
(annotation_p): Declare.
(finish_class_member_access_expr): Adjust declaration.
(immediate_escalating_function_p): Declare.
(promote_function_to_consteval): Declare.
(is_std_allocator_allocate): Declare.
(cxa_allocate_and_throw_exception): Declare.
(enum value_cat): Define.
(cxx_eval_constant_expression): Declare.
(cxx_constexpr_quiet_p): Declare.
(cxx_constexpr_manifestly_const_eval): Declare.
(cxx_constexpr_caller): Declare.
(cxx_constexpr_consteval_block): Declare.
(init_reflection): Declare.
(metafunction_p): Declare.
(direct_base_parent): Declare.
(process_metafunction): Declare.
(get_reflection): Declare.
(get_null_reflection): Declare.
(splice): Declare.
(check_out_of_consteval_use): Declare.
(consteval_only_p): Declare.
(compare_reflections): Declare.
(valid_splice_type_p): Declare.
(valid_splice_scope_p): Declare.
(check_splice_expr): Declare.
(make_splice_scope): Declare.
(dependent_splice_p): Declare.
(reflection_mangle_prefix): Declare.
(check_consteval_only_fn): Declare.
* cvt.cc (convert_to_void): Call check_out_of_consteval_use.
* cxx-pretty-print.cc (cxx_pretty_printer::unary_expression): New
REFLECT_EXPR case.
(cxx_pretty_printer::expression): Likewise.
(cxx_pretty_printer::simple_type_specifier): New META_TYPE case.
(cxx_pretty_printer::type_id): Likewise.
* decl.cc (duplicate_decls): Merge parameter names for Reflection.
Maybe set OLD_PARM_DECL_P.
(initialize_predefined_identifiers): Add "annotation ".
(cxx_init_decl_processing): Add __builtin_is_string_literal.  Call
init_reflection.
(maybe_commonize_var): Do nothing for consteval_only_p.
(check_initializer): Default-initialize std::meta::info.
(make_rtl_for_nonlocal_decl): For consteval_only_p vars, set
DECL_EXTERNAL and return early.
(cp_finish_decl): Call check_out_of_consteval_use.  Don't go
creating a varpool node for consteval_only_p.
(get_tuple_size): Check the instantiation instead of the type.
(grokfndecl): Call check_consteval_only_fn.
(xref_basetypes): Stitch annotations onto BINFO_BASE_ACCESSES.
(finish_enum_value_list): Clear ENUM_BEING_DEFINED_P.
* decl2.cc (is_late_template_attribute): Handle all annotations as
late.
(cp_check_const_attributes): Don't handle annotations here.
(maybe_make_one_only): Do nothing for consteval_only_p.
(mark_needed): Likewise.
(min_vis_expr_r): Handle reflections.
(prune_vars_needing_no_initialization): Skip consteval_only_p.
(no_linkage_error): Return early for metafunctions.
(c_parse_final_cleanups): Don't write out consteval_only_p vars.  Avoid
complaining about metafunctions.
* error.cc (dump_type): New cases for CONST_DECL, META_TYPE, and
SPLICE_SCOPE.
(dump_type_prefix): New cases for META_TYPE and SPLICE_SCOPE.
(dump_type_suffix): Likewise.
(dump_decl): Dump SPLICE_EXPR.
(dump_expr): Dump REFLECT_EXPR and SPLICE_EXPR.
* init.cc (build_zero_init_1): Build a null reflection value.
(perform_member_init): Call check_out_of_consteval_use.
* lex.cc (DEF_OPERATOR, OPERATOR_TRANSITION): Update defines.
* mangle.cc (write_type): Mangle META_TYPE.
(write_expression): Handle REFLECT_EXPR.
(write_reflection): New.
(write_template_arg_literal): New REFLECT_EXPR case.
(write_template_arg): Handle REFLECT_EXPR.
* method.cc (build_stub_type): No longer static.
* module.cc (trees_out::type_node): Handle META_TYPE.
(trees_in::tree_node): Likewise.
* name-lookup.cc (name_lookup::adl_type): std::meta is an associated
namespace of std::meta::info.
(strip_using_decl): Don't strip when cp_preserve_using_decl.
(handle_namespace_attrs): Handle annotations.
(do_namespace_alias): Handle SPLICE_EXPR.
(lookup_qualified_name): When cp_preserve_using_decl, don't do
OVL_FUNCTION.
(finish_using_directive): Detect annotations on using directive.
* operators.def: Update for META_NAME.
* parser.cc: New cp_preserve_using_decl global.
(enum required_token): Add RT_CLOSE_SPLICE.
(get_required_cpp_ttype): Return CPP_CLOSE_SPLICE for RT_CLOSE_SPLICE.
(cp_parser_next_tokens_start_splice_type_spec_p): New.
(cp_parser_next_tokens_can_start_splice_scope_spec_p): New.
(cp_parser_splice_specifier): New.
(cp_parser_splice_type_specifier): New.
(cp_parser_splice_expression): New.
(cp_parser_splice_scope_specifier): New.
(cp_parser_splice_spec_is_nns_p): New.
(cp_parser_nth_token_starts_splice_without_nns_p): New.
(cp_parser_primary_expression): Handle CPP_OPEN_SPLICE.  Give an
error for ^^ outside reflection.
(cp_parser_unqualified_id): Allow r.~typename [:R:].
(cp_parser_nested_name_specifier_opt): Cope with splice-scope-specifier.
(cp_parser_qualifying_entity): Parse splice-scope-specifier.
(cp_parser_postfix_expression): Deal with [: :] after a typename.
(cp_parser_postfix_dot_deref_expression): Parse & handle splices
in a class member access.  Pass splice_p to
finish_class_member_access_expr.
(cp_parser_reflection_name): New.
(cp_parser_reflect_expression): New.
(cp_parser_unary_expression): Parse reflect-expression.
(cp_parser_declaration): Parse splice-scope-specifier.
(cp_parser_decomposition_declaration): Detect annotations on structured
bindings.
(cp_parser_decltype_expr): Parse splice-expression.
(cp_parser_template_id): New parsed_templ argument.  If it's nonnull,
don't parse the template name.  Turn an assert into a condition.
(cp_parser_type_specifier): Handle typename [: :].
(cp_parser_simple_type_specifier): Parse splice-type-specifier.
(cp_parser_enum_specifier): Set ENUM_BEING_DEFINED_P.
(cp_parser_namespace_alias_definition): Parse splice-specifier.
(cp_parser_using_directive): Likewise.
(cp_parser_type_id_1): New bool * parameter to distinguish between
types and type aliases.  Set it.
(cp_parser_type_id): Adjust the call to cp_parser_type_id_1.
(cp_parser_template_type_arg): Likewise.
(cp_parser_trailing_type_id): Likewise.
(cp_parser_base_specifier): Handle annotations.  Maybe give an error
for splice-scope-specifier.  Parse splice-type-specifier.  Pass
annotations to finish_base_specifier.
(cp_parser_annotation): New.
(cp_parser_std_attribute_list): Detect mixing annotations and attributes
in the same list.
(cp_parser_annotation_list): New.
(cp_parser_std_attribute_spec): Parse annotations.
(cp_parser_skip_balanced_tokens): Also handle CPP_OPEN_SPLICE
and CPP_CLOSE_SPLICE.
(cp_parser_type_requirement): Parse splice-type-specifier.
(cp_parser_lookup_name): Also consider dependent namespaces.  Don't
call check_accessibility_of_qualified_id for USING_DECLs.
(cp_parser_required_error): Handle RT_CLOSE_SPLICE.
* pt.cc (current_function_decl_without_access_scope): New.
(verify_unstripped_args_1): REFLECT_EXPR_P is OK.
(iterative_hash_template_arg): Handle REFLECT_EXPR.
(convert_nontype_argument): Maybe give an error for REFLECTION_TYPE_P.
(for_each_template_parm_r): Handle SPLICE_SCOPE.
(instantiate_class_template): Handle annotations.
(tsubst_pack_index): Make static.
(tsubst_decl): Handle NAMESPACE_DECL.
(tsubst_splice_scope): New.
(tsubst_splice_expr): New.
(tsubst): Don't return early for NAMESPACE_DECL.   New META_TYPE case.
Handle a splice-specifier that expanded into a NAMESPACE_DECL.  Handle
SPLICE_SCOPE, SPLICE_EXPR, and TEMPLATE_ID_EXPR.
(tsubst_scope): Also accept NAMESPACE_DECL.
(tsubst_qualified_id): Check dependent_namespace_p.
(tsubst_lambda_expr): Set LAMBDA_EXPR_CONSTEVAL_BLOCK_P.
(tsubst_expr): Allow dependent_splice_p in an assert.  Check
COMPONENT_REF_SPLICE_P and pass it to finish_class_member_access_expr.
<case NAMESPACE_DECL>: Remove.
New REFLECT_EXPR and SPLICE_EXPR cases.
(unify): Handle META_TYPE.
(instantiate_body): Call check_consteval_only_fn.
(tsubst_enum): Set ENUM_BEING_DEFINED_P.
(dependent_type_p_r): A splice-scope-specifier is dependent.
(dependent_namespace_p): New.
(value_dependent_expression_p): Handle REFLECT_EXPR.  Also handle
[meta.reflection.access.context]/8.
(type_dependent_expression_p): REFLECT_EXPR_P is not type-dependent.
(convert_reflect_constant_arg): New.
* search.cc (check_final_overrider): Adjust for CWG 3117.
* semantics.cc (finish_base_specifier): Handle annotations.
(parsing_lambda_declarator): No longer static.
(finish_id_expression_1): Check dependent_namespace_p.
(fold_builtin_is_string_literal): New.
(trait_expr_value): Handle CPTK_IS_CONSTEVAL_ONLY.
(finish_trait_expr): Likewise.
* tree.cc (handle_annotation_attribute): New.
(builtin_valid_in_constant_expr_p): Return true for
CP_BUILT_IN_IS_STRING_LITERAL.
(cp_tree_equal): Handle comparing REFLECT_EXPRs.
(internal_attributes): Add "annotation ".
(annotation_p): New.
* typeck.cc (finish_class_member_access_expr): New splice_p argument.
Handle dependent splices.  Implement splicing a base class subobject.
Handle class member access using a splice-expression.
(cp_build_binary_op): Handle comparing std::meta::infos.
(check_return_expr): Call check_out_of_consteval_use.
* metafns.gperf: New file.
* metafns.h: New file.
* reflect.cc: New file.

libcc1/ChangeLog:

* libcp1plugin.cc (start_class_def): Update the call to
finish_base_specifier.

libcpp/ChangeLog:

* charset.cc (_cpp_destroy_iconv): Destroy narrow_cset_desc and
utf8_cset_desc.
(cpp_translate_string): New.
(cpp_valid_identifier): New.
* include/cpplib.h: Add OPEN_SPLICE, CLOSE_SPLICE, and REFLECT_OP to
TTYPE_TABLE.
(cpp_translate_string): Declare.
(cpp_valid_identifier): Declare.
* internal.h (struct cpp_reader): Add reverse_narrow_cset_desc and
reverse_utf8_cset_desc fields.
* lex.cc (_cpp_lex_direct): Emit CPP_CLOSE_SPLICE, CPP_REFLECT_OP,
and CPP_OPEN_SPLICE tokens.

libstdc++-v3/ChangeLog:

* include/Makefile.am (std_headers): Add ${std_srcdir}/meta.
* include/Makefile.in: Regenerate.
* include/bits/iterator_concepts.h (std::ranges::__access::__begin): Add
constexpr.
* include/bits/version.def (reflection): New.
* include/bits/version.h: Regenerate.
* include/precompiled/stdc++.h: Include <meta> for C++26.
* include/std/meta: New file.
* include/std/type_traits (std::is_reflection): New trait.
(std::is_fundamental): Include is_reflection for C++26 -freflection.
(std::is_reflection_v): New variable template.
(std::is_consteval_only): New trait.
(std::is_consteval_only_v): New variable template.
* src/c++23/std.cc.in: Add <meta> exports.
* testsuite/20_util/variable_templates_for_traits.cc: Add -freflection as
dg-additional-options for C++26.  Add std::is_reflection_v test in that case.
* testsuite/20_util/is_consteval_only/requirements/explicit_instantiation.cc: New test.
* testsuite/20_util/is_consteval_only/requirements/typedefs.cc: New test.
* testsuite/20_util/is_consteval_only/value.cc: New test.
* testsuite/20_util/is_reflection/requirements/explicit_instantiation.cc: New test.
* testsuite/20_util/is_reflection/requirements/typedefs.cc: New test.
* testsuite/20_util/is_reflection/value.cc: New test.

gcc/testsuite/ChangeLog:

* g++.dg/DRs/dr2581-1.C: Add -freflection.
* g++.dg/DRs/dr2581-2.C: Likewise.
* g++.dg/reflect/access_context1.C: New test.
* g++.dg/reflect/access_context2.C: New test.
* g++.dg/reflect/access_context3.C: New test.
* g++.dg/reflect/adl1.C: New test.
* g++.dg/reflect/alignment_of1.C: New test.
* g++.dg/reflect/alignment_of2.C: New test.
* g++.dg/reflect/annotations1.C: New test.
* g++.dg/reflect/annotations2.C: New test.
* g++.dg/reflect/annotations3.C: New test.
* g++.dg/reflect/annotations4.C: New test.
* g++.dg/reflect/annotations5.C: New test.
* g++.dg/reflect/annotations6.C: New test.
* g++.dg/reflect/annotations7.C: New test.
* g++.dg/reflect/annotations8.C: New test.
* g++.dg/reflect/anon1.C: New test.
* g++.dg/reflect/anon2.C: New test.
* g++.dg/reflect/anon3.C: New test.
* g++.dg/reflect/bases_of1.C: New test.
* g++.dg/reflect/bases_of2.C: New test.
* g++.dg/reflect/bases_of3.C: New test.
* g++.dg/reflect/bit_size_of1.C: New test.
* g++.dg/reflect/bitfield1.C: New test.
* g++.dg/reflect/can_substitute1.C: New test.
* g++.dg/reflect/class1.C: New test.
* g++.dg/reflect/class2.C: New test.
* g++.dg/reflect/common_reference1.C: New test.
* g++.dg/reflect/common_type1.C: New test.
* g++.dg/reflect/compare1.C: New test.
* g++.dg/reflect/compare10.C: New test.
* g++.dg/reflect/compare2.C: New test.
* g++.dg/reflect/compare3.C: New test.
* g++.dg/reflect/compare4.C: New test.
* g++.dg/reflect/compare5.C: New test.
* g++.dg/reflect/compare6.C: New test.
* g++.dg/reflect/compare7.C: New test.
* g++.dg/reflect/compare8.C: New test.
* g++.dg/reflect/compare9.C: New test.
* g++.dg/reflect/compat1.C: New test.
* g++.dg/reflect/complete1.C: New test.
* g++.dg/reflect/constant_of1.C: New test.
* g++.dg/reflect/constant_of2.C: New test.
* g++.dg/reflect/constant_of3.C: New test.
* g++.dg/reflect/constant_of4.C: New test.
* g++.dg/reflect/constant_of5.C: New test.
* g++.dg/reflect/constant_of6.C: New test.
* g++.dg/reflect/constant_of7.C: New test.
* g++.dg/reflect/constant_of8.C: New test.
* g++.dg/reflect/constant_of9.C: New test.
* g++.dg/reflect/crash1.C: New test.
* g++.dg/reflect/crash10.C: New test.
* g++.dg/reflect/crash11.C: New test.
* g++.dg/reflect/crash12.C: New test.
* g++.dg/reflect/crash13.C: New test.
* g++.dg/reflect/crash14.C: New test.
* g++.dg/reflect/crash15.C: New test.
* g++.dg/reflect/crash16.C: New test.
* g++.dg/reflect/crash17.C: New test.
* g++.dg/reflect/crash18.C: New test.
* g++.dg/reflect/crash2.C: New test.
* g++.dg/reflect/crash3.C: New test.
* g++.dg/reflect/crash4.C: New test.
* g++.dg/reflect/crash5.C: New test.
* g++.dg/reflect/crash6.C: New test.
* g++.dg/reflect/crash7.C: New test.
* g++.dg/reflect/crash8.C: New test.
* g++.dg/reflect/crash9.C: New test.
* g++.dg/reflect/data_member_spec1.C: New test.
* g++.dg/reflect/data_member_spec2.C: New test.
* g++.dg/reflect/data_member_spec3.C: New test.
* g++.dg/reflect/data_member_spec4.C: New test.
* g++.dg/reflect/dealias1.C: New test.
* g++.dg/reflect/dealias2.C: New test.
* g++.dg/reflect/dealias3.C: New test.
* g++.dg/reflect/define_aggregate1.C: New test.
* g++.dg/reflect/define_aggregate2.C: New test.
* g++.dg/reflect/define_aggregate3.C: New test.
* g++.dg/reflect/define_aggregate4.C: New test.
* g++.dg/reflect/define_aggregate5.C: New test.
* g++.dg/reflect/define_static_array1.C: New test.
* g++.dg/reflect/define_static_array2.C: New test.
* g++.dg/reflect/define_static_array3.C: New test.
* g++.dg/reflect/define_static_array4.C: New test.
* g++.dg/reflect/define_static_object1.C: New test.
* g++.dg/reflect/define_static_object2.C: New test.
* g++.dg/reflect/define_static_string1.C: New test.
* g++.dg/reflect/dep1.C: New test.
* g++.dg/reflect/dep10.C: New test.
* g++.dg/reflect/dep11.C: New test.
* g++.dg/reflect/dep2.C: New test.
* g++.dg/reflect/dep3.C: New test.
* g++.dg/reflect/dep4.C: New test.
* g++.dg/reflect/dep5.C: New test.
* g++.dg/reflect/dep6.C: New test.
* g++.dg/reflect/dep7.C: New test.
* g++.dg/reflect/dep8.C: New test.
* g++.dg/reflect/dep9.C: New test.
* g++.dg/reflect/diag1.C: New test.
* g++.dg/reflect/diag2.C: New test.
* g++.dg/reflect/diag3.C: New test.
* g++.dg/reflect/diag4.C: New test.
* g++.dg/reflect/display_string_of1.C: New test.
* g++.dg/reflect/eh1.C: New test.
* g++.dg/reflect/eh2.C: New test.
* g++.dg/reflect/eh3.C: New test.
* g++.dg/reflect/eh4.C: New test.
* g++.dg/reflect/eh5.C: New test.
* g++.dg/reflect/eh6.C: New test.
* g++.dg/reflect/eh7.C: New test.
* g++.dg/reflect/eh8.C: New test.
* g++.dg/reflect/eh9.C: New test.
* g++.dg/reflect/enumerators_of1.C: New test.
* g++.dg/reflect/error1.C: New test.
* g++.dg/reflect/error10.C: New test.
* g++.dg/reflect/error2.C: New test.
* g++.dg/reflect/error3.C: New test.
* g++.dg/reflect/error4.C: New test.
* g++.dg/reflect/error5.C: New test.
* g++.dg/reflect/error6.C: New test.
* g++.dg/reflect/error8.C: New test.
* g++.dg/reflect/error9.C: New test.
* g++.dg/reflect/expr1.C: New test.
* g++.dg/reflect/expr10.C: New test.
* g++.dg/reflect/expr11.C: New test.
* g++.dg/reflect/expr12.C: New test.
* g++.dg/reflect/expr13.C: New test.
* g++.dg/reflect/expr14.C: New test.
* g++.dg/reflect/expr2.C: New test.
* g++.dg/reflect/expr3.C: New test.
* g++.dg/reflect/expr4.C: New test.
* g++.dg/reflect/expr5.C: New test.
* g++.dg/reflect/expr6.C: New test.
* g++.dg/reflect/expr7.C: New test.
* g++.dg/reflect/expr8.C: New test.
* g++.dg/reflect/expr9.C: New test.
* g++.dg/reflect/extract1.C: New test.
* g++.dg/reflect/extract2.C: New test.
* g++.dg/reflect/extract3.C: New test.
* g++.dg/reflect/extract4.C: New test.
* g++.dg/reflect/extract5.C: New test.
* g++.dg/reflect/extract6.C: New test.
* g++.dg/reflect/extract7.C: New test.
* g++.dg/reflect/extract8.C: New test.
* g++.dg/reflect/extract9.C: New test.
* g++.dg/reflect/feat1.C: New test.
* g++.dg/reflect/feat2.C: New test.
* g++.dg/reflect/has_c_language_linkage1.C: New test.
* g++.dg/reflect/has_default_argument1.C: New test.
* g++.dg/reflect/has_default_argument2.C: New test.
* g++.dg/reflect/has_default_member_initializer1.C: New test.
* g++.dg/reflect/has_ellipsis_parameter1.C: New test.
* g++.dg/reflect/has_external_linkage1.C: New test.
* g++.dg/reflect/has_external_linkage2.C: New test.
* g++.dg/reflect/has_identifier1.C: New test.
* g++.dg/reflect/has_identifier2.C: New test.
* g++.dg/reflect/has_internal_linkage1.C: New test.
* g++.dg/reflect/has_internal_linkage2.C: New test.
* g++.dg/reflect/has_linkage1.C: New test.
* g++.dg/reflect/has_module_linkage1.C: New test.
* g++.dg/reflect/has_module_linkage2.C: New test.
* g++.dg/reflect/has_parent1.C: New test.
* g++.dg/reflect/has_template_arguments1.C: New test.
* g++.dg/reflect/has_template_arguments2.C: New test.
* g++.dg/reflect/has_template_arguments3.C: New test.
* g++.dg/reflect/has_template_arguments4.C: New test.
* g++.dg/reflect/identifier_of1.C: New test.
* g++.dg/reflect/identifier_of2.C: New test.
* g++.dg/reflect/init1.C: New test.
* g++.dg/reflect/init10.C: New test.
* g++.dg/reflect/init11.C: New test.
* g++.dg/reflect/init12.C: New test.
* g++.dg/reflect/init13.C: New test.
* g++.dg/reflect/init14.C: New test.
* g++.dg/reflect/init15.C: New test.
* g++.dg/reflect/init16.C: New test.
* g++.dg/reflect/init17.C: New test.
* g++.dg/reflect/init2.C: New test.
* g++.dg/reflect/init3.C: New test.
* g++.dg/reflect/init4.C: New test.
* g++.dg/reflect/init5.C: New test.
* g++.dg/reflect/init6.C: New test.
* g++.dg/reflect/init7.C: New test.
* g++.dg/reflect/init8.C: New test.
* g++.dg/reflect/init9.C: New test.
* g++.dg/reflect/is_accessible1.C: New test.
* g++.dg/reflect/is_accessible2.C: New test.
* g++.dg/reflect/is_alias_template1.C: New test.
* g++.dg/reflect/is_assignment1.C: New test.
* g++.dg/reflect/is_bit_field1.C: New test.
* g++.dg/reflect/is_class_member1.C: New test.
* g++.dg/reflect/is_class_template1.C: New test.
* g++.dg/reflect/is_complete_type1.C: New test.
* g++.dg/reflect/is_complete_type2.C: New test.
* g++.dg/reflect/is_concept1.C: New test.
* g++.dg/reflect/is_const1.C: New test.
* g++.dg/reflect/is_consteval_only1.C: New test.
* g++.dg/reflect/is_constructible_type1.C: New test.
* g++.dg/reflect/is_constructible_type2.C: New test.
* g++.dg/reflect/is_constructor_template1.C: New test.
* g++.dg/reflect/is_constuctor1.C: New test.
* g++.dg/reflect/is_conversion_function1.C: New test.
* g++.dg/reflect/is_conversion_function_template1.C: New test.
* g++.dg/reflect/is_copy_assignment1.C: New test.
* g++.dg/reflect/is_copy_constructor1.C: New test.
* g++.dg/reflect/is_data_member_spec1.C: New test.
* g++.dg/reflect/is_default_constructor1.C: New test.
* g++.dg/reflect/is_defaulted1.C: New test.
* g++.dg/reflect/is_defaulted2.C: New test.
* g++.dg/reflect/is_deleted1.C: New test.
* g++.dg/reflect/is_deleted2.C: New test.
* g++.dg/reflect/is_destructor1.C: New test.
* g++.dg/reflect/is_enumerable_type1.C: New test.
* g++.dg/reflect/is_enumerator1.C: New test.
* g++.dg/reflect/is_explicit1.C: New test.
* g++.dg/reflect/is_explicit2.C: New test.
* g++.dg/reflect/is_explicit_object_parameter1.C: New test.
* g++.dg/reflect/is_final1.C: New test.
* g++.dg/reflect/is_function1.C: New test.
* g++.dg/reflect/is_function2.C: New test.
* g++.dg/reflect/is_function3.C: New test.
* g++.dg/reflect/is_function_parameter1.C: New test.
* g++.dg/reflect/is_function_parameter2.C: New test.
* g++.dg/reflect/is_function_template1.C: New test.
* g++.dg/reflect/is_function_template2.C: New test.
* g++.dg/reflect/is_function_type1.C: New test.
* g++.dg/reflect/is_literal_operator1.C: New test.
* g++.dg/reflect/is_literal_operator_template1.C: New test.
* g++.dg/reflect/is_lrvalue_reference_qualified1.C: New test.
* g++.dg/reflect/is_move_assignment1.C: New test.
* g++.dg/reflect/is_move_constructor1.C: New test.
* g++.dg/reflect/is_mutable_member1.C: New test.
* g++.dg/reflect/is_namespace1.C: New test.
* g++.dg/reflect/is_namespace_alias1.C: New test.
* g++.dg/reflect/is_namespace_member1.C: New test.
* g++.dg/reflect/is_noexcept1.C: New test.
* g++.dg/reflect/is_noexcept2.C: New test.
* g++.dg/reflect/is_noexcept3.C: New test.
* g++.dg/reflect/is_noexcept4.C: New test.
* g++.dg/reflect/is_nonstatic_data_member1.C: New test.
* g++.dg/reflect/is_object1.C: New test.
* g++.dg/reflect/is_object2.C: New test.
* g++.dg/reflect/is_operator_function1.C: New test.
* g++.dg/reflect/is_operator_function_template1.C: New test.
* g++.dg/reflect/is_override1.C: New test.
* g++.dg/reflect/is_pure_virtual1.C: New test.
* g++.dg/reflect/is_special_member_function1.C: New test.
* g++.dg/reflect/is_static_member1.C: New test.
* g++.dg/reflect/is_string_literal1.C: New test.
* g++.dg/reflect/is_structured_binding1.C: New test.
* g++.dg/reflect/is_structured_binding2.C: New test.
* g++.dg/reflect/is_template1.C: New test.
* g++.dg/reflect/is_template2.C: New test.
* g++.dg/reflect/is_type1.C: New test.
* g++.dg/reflect/is_type_alias1.C: New test.
* g++.dg/reflect/is_type_alias2.C: New test.
* g++.dg/reflect/is_type_alias3.C: New test.
* g++.dg/reflect/is_user_declared1.C: New test.
* g++.dg/reflect/is_user_declared2.C: New test.
* g++.dg/reflect/is_user_provided1.C: New test.
* g++.dg/reflect/is_user_provided2.C: New test.
* g++.dg/reflect/is_variable1.C: New test.
* g++.dg/reflect/is_variable_template1.C: New test.
* g++.dg/reflect/is_virtual1.C: New test.
* g++.dg/reflect/is_volatile1.C: New test.
* g++.dg/reflect/lex1.C: New test.
* g++.dg/reflect/lex2.C: New test.
* g++.dg/reflect/mangle1.C: New test.
* g++.dg/reflect/member-visibility1.C: New test.
* g++.dg/reflect/member-visibility2.C: New test.
* g++.dg/reflect/member1.C: New test.
* g++.dg/reflect/member10.C: New test.
* g++.dg/reflect/member11.C: New test.
* g++.dg/reflect/member12.C: New test.
* g++.dg/reflect/member13.C: New test.
* g++.dg/reflect/member14.C: New test.
* g++.dg/reflect/member15.C: New test.
* g++.dg/reflect/member16.C: New test.
* g++.dg/reflect/member17.C: New test.
* g++.dg/reflect/member18.C: New test.
* g++.dg/reflect/member19.C: New test.
* g++.dg/reflect/member2.C: New test.
* g++.dg/reflect/member20.C: New test.
* g++.dg/reflect/member3.C: New test.
* g++.dg/reflect/member4.C: New test.
* g++.dg/reflect/member5.C: New test.
* g++.dg/reflect/member6.C: New test.
* g++.dg/reflect/member7.C: New test.
* g++.dg/reflect/member8.C: New test.
* g++.dg/reflect/member9.C: New test.
* g++.dg/reflect/members_of1.C: New test.
* g++.dg/reflect/members_of2.C: New test.
* g++.dg/reflect/members_of3.C: New test.
* g++.dg/reflect/members_of4.C: New test.
* g++.dg/reflect/members_of5.C: New test.
* g++.dg/reflect/members_of6.C: New test.
* g++.dg/reflect/members_of7.C: New test.
* g++.dg/reflect/metafn-ptr1.C: New test.
* g++.dg/reflect/ns1.C: New test.
* g++.dg/reflect/ns2.C: New test.
* g++.dg/reflect/ns3.C: New test.
* g++.dg/reflect/ns4.C: New test.
* g++.dg/reflect/ns5.C: New test.
* g++.dg/reflect/ns6.C: New test.
* g++.dg/reflect/null1.C: New test.
* g++.dg/reflect/null2.C: New test.
* g++.dg/reflect/null3.C: New test.
* g++.dg/reflect/null4.C: New test.
* g++.dg/reflect/null5.C: New test.
* g++.dg/reflect/object_of1.C: New test.
* g++.dg/reflect/object_of2.C: New test.
* g++.dg/reflect/odr1.C: New test.
* g++.dg/reflect/offset_of1.C: New test.
* g++.dg/reflect/operator_of1.C: New test.
* g++.dg/reflect/override1.C: New test.
* g++.dg/reflect/p2996-1.C: New test.
* g++.dg/reflect/p2996-10.C: New test.
* g++.dg/reflect/p2996-11.C: New test.
* g++.dg/reflect/p2996-12.C: New test.
* g++.dg/reflect/p2996-13.C: New test.
* g++.dg/reflect/p2996-14.C: New test.
* g++.dg/reflect/p2996-15.C: New test.
* g++.dg/reflect/p2996-16.C: New test.
* g++.dg/reflect/p2996-17.C: New test.
* g++.dg/reflect/p2996-18.C: New test.
* g++.dg/reflect/p2996-19.C: New test.
* g++.dg/reflect/p2996-2.C: New test.
* g++.dg/reflect/p2996-20.C: New test.
* g++.dg/reflect/p2996-21.C: New test.
* g++.dg/reflect/p2996-3.C: New test.
* g++.dg/reflect/p2996-4.C: New test.
* g++.dg/reflect/p2996-5.C: New test.
* g++.dg/reflect/p2996-6.C: New test.
* g++.dg/reflect/p2996-7.C: New test.
* g++.dg/reflect/p2996-8.C: New test.
* g++.dg/reflect/p2996-9.C: New test.
* g++.dg/reflect/p3394-1.C: New test.
* g++.dg/reflect/p3491-1.C: New test.
* g++.dg/reflect/p3491-2.C: New test.
* g++.dg/reflect/p3491-3.C: New test.
* g++.dg/reflect/pack-index1.C: New test.
* g++.dg/reflect/parameters_of1.C: New test.
* g++.dg/reflect/parameters_of2.C: New test.
* g++.dg/reflect/parameters_of3.C: New test.
* g++.dg/reflect/parameters_of4.C: New test.
* g++.dg/reflect/parameters_of5.C: New test.
* g++.dg/reflect/parameters_of6.C: New test.
* g++.dg/reflect/parent_of1.C: New test.
* g++.dg/reflect/parm1.C: New test.
* g++.dg/reflect/parm2.C: New test.
* g++.dg/reflect/parm3.C: New test.
* g++.dg/reflect/parm4.C: New test.
* g++.dg/reflect/pr122634-1.C: New test.
* g++.dg/reflect/pr122634-2.C: New test.
* g++.dg/reflect/qrn1.C: New test.
* g++.dg/reflect/qrn2.C: New test.
* g++.dg/reflect/range_args.C: New test.
* g++.dg/reflect/reflect_constant1.C: New test.
* g++.dg/reflect/reflect_constant2.C: New test.
* g++.dg/reflect/reflect_constant3.C: New test.
* g++.dg/reflect/reflect_constant4.C: New test.
* g++.dg/reflect/reflect_constant5.C: New test.
* g++.dg/reflect/reflect_constant6.C: New test.
* g++.dg/reflect/reflect_constant7.C: New test.
* g++.dg/reflect/reflect_constant8.C: New test.
* g++.dg/reflect/reflect_constant9.C: New test.
* g++.dg/reflect/reflect_constant_array1.C: New test.
* g++.dg/reflect/reflect_constant_array2.C: New test.
* g++.dg/reflect/reflect_constant_array3.C: New test.
* g++.dg/reflect/reflect_constant_array4.C: New test.
* g++.dg/reflect/reflect_constant_string1.C: New test.
* g++.dg/reflect/reflect_constant_string2.C: New test.
* g++.dg/reflect/reflect_function1.C: New test.
* g++.dg/reflect/reflect_function2.C: New test.
* g++.dg/reflect/reflect_object1.C: New test.
* g++.dg/reflect/reflect_object2.C: New test.
* g++.dg/reflect/reflect_object3.C: New test.
* g++.dg/reflect/reflect_object4.C: New test.
* g++.dg/reflect/return_type_of1.C: New test.
* g++.dg/reflect/return_type_of2.C: New test.
* g++.dg/reflect/serialize1.C: New test.
* g++.dg/reflect/serialize2.C: New test.
* g++.dg/reflect/size_of1.C: New test.
* g++.dg/reflect/source_location_of1.C: New test.
* g++.dg/reflect/source_location_of2.C: New test.
* g++.dg/reflect/splice1.C: New test.
* g++.dg/reflect/splice2.C: New test.
* g++.dg/reflect/splice3.C: New test.
* g++.dg/reflect/splice4.C: New test.
* g++.dg/reflect/splice5.C: New test.
* g++.dg/reflect/splice6.C: New test.
* g++.dg/reflect/splice7.C: New test.
* g++.dg/reflect/splicing-base1.C: New test.
* g++.dg/reflect/splicing-base2.C: New test.
* g++.dg/reflect/splicing-base3.C: New test.
* g++.dg/reflect/splicing-base4.C: New test.
* g++.dg/reflect/storage_duration1.C: New test.
* g++.dg/reflect/storage_duration2.C: New test.
* g++.dg/reflect/storage_duration3.C: New test.
* g++.dg/reflect/subobjects_of1.C: New test.
* g++.dg/reflect/substitute1.C: New test.
* g++.dg/reflect/substitute2.C: New test.
* g++.dg/reflect/symbol_of1.C: New test.
* g++.dg/reflect/symbol_of2.C: New test.
* g++.dg/reflect/template_arguments_of1.C: New test.
* g++.dg/reflect/template_arguments_of2.C: New test.
* g++.dg/reflect/template_arguments_of3.C: New test.
* g++.dg/reflect/template_of1.C: New test.
* g++.dg/reflect/template_of2.C: New test.
* g++.dg/reflect/template_of3.C: New test.
* g++.dg/reflect/tuple1.C: New test.
* g++.dg/reflect/tuple2.C: New test.
* g++.dg/reflect/type1.C: New test.
* g++.dg/reflect/type10.C: New test.
* g++.dg/reflect/type2.C: New test.
* g++.dg/reflect/type3.C: New test.
* g++.dg/reflect/type4.C: New test.
* g++.dg/reflect/type5.C: New test.
* g++.dg/reflect/type6.C: New test.
* g++.dg/reflect/type7.C: New test.
* g++.dg/reflect/type8.C: New test.
* g++.dg/reflect/type9.C: New test.
* g++.dg/reflect/type_of1.C: New test.
* g++.dg/reflect/type_of2.C: New test.
* g++.dg/reflect/type_rels1.C: New test.
* g++.dg/reflect/type_trait1.C: New test.
* g++.dg/reflect/type_trait10.C: New test.
* g++.dg/reflect/type_trait11.C: New test.
* g++.dg/reflect/type_trait12.C: New test.
* g++.dg/reflect/type_trait13.C: New test.
* g++.dg/reflect/type_trait2.C: New test.
* g++.dg/reflect/type_trait3.C: New test.
* g++.dg/reflect/type_trait4.C: New test.
* g++.dg/reflect/type_trait5.C: New test.
* g++.dg/reflect/type_trait6.C: New test.
* g++.dg/reflect/type_trait8.C: New test.
* g++.dg/reflect/type_trait9.C: New test.
* g++.dg/reflect/u8display_string_of1.C: New test.
* g++.dg/reflect/u8identifier_of1.C: New test.
* g++.dg/reflect/u8symbol_of1.C: New test.
* g++.dg/reflect/underlying_type1.C: New test.
* g++.dg/reflect/using1.C: New test.
* g++.dg/reflect/value_or_object1.C: New test.
* g++.dg/reflect/variable_of1.C: New test.
* g++.dg/reflect/variable_of2.C: New test.
* g++.dg/reflect/variable_of3.C: New test.
* g++.dg/reflect/variant1.C: New test.
* g++.dg/reflect/variant2.C: New test.
* g++.dg/reflect/vector1.C: New test.
* g++.dg/reflect/visibility1.C: New test.

Co-authored-by: Jakub Jelinek <jakub@redhat.com>
Signed-off-by: Valentyn Yukhymenko <vyuhimenko@bloomberg.net>
Signed-off-by: Alex Yesmanchyk <ayesmanchyk@bloomberg.net>
Signed-off-by: Michael Levine <mlevine55@bloomberg.net>
Reviewed-by: Jason Merrill <jason@redhat.com>
2 months agoRemove .res specs to fix COFF passthrough [PR123504]
Peter Damianov [Sat, 10 Jan 2026 09:19:54 +0000 (09:19 +0000)] 
Remove .res specs to fix COFF passthrough [PR123504]

Some packages (gnulib) pass COFF object files with .res extension
directly to gcc, expecting them to be passed through to the linker,
instead of windres.  However, the current EXTRA_DEFAULT_COMPILERS spec
intercepts all .res files and runs them through windres, which fails for
COFF files that are not Windows resource files (Microsoft Visual C
binary resource file as identified by libmagic/file).

This patch removes the .res file specs, leaving only the .rc
support specs active. At a later date, this can be reviewed.

The driver could inspect the .res file to see if it's a object file or,
but, it's somewhat questionable if handling .res is even useful.

gcc/ChangeLog:

PR driver/123504
* config/i386/cygming.h (EXTRA_DEFAULT_COMPILERS): Comment out
.res spec to allow COFF files with .res extension to pass
through to the linker.
* config/aarch64/cygming.h (EXTRA_DEFAULT_COMPILERS): Likewise.

Signed-off-by: Jonathan Yong <10walls@gmail.com>
2 months agoira: Implicit uses via hard register constraints
Stefan Schulze Frielinghaus [Thu, 15 Jan 2026 14:14:59 +0000 (15:14 +0100)] 
ira: Implicit uses via hard register constraints

In ira_implicitly_set_insn_hard_regs() all potentially used registers
stemming from single register constraints are recorded.  Since hard
register constraints are pretty similar, do the same for those, too.
This requires to setup the preferred alternatives which is done via
ira_setup_alts() and also implemented for hard register constraints by
this patch.

This fixes an ICE were previously sched1 swapped the order of the
instructions

(insn 10 9 6 2 (parallel [
            (set (reg:DF 118)
                (asm_operands:DF ("") ("={fr2}") 0 [
                        (reg:TF 121 [ a ])
                    ]
                     [
                        (asm_input:TF ("{fr1}") t.i:5)
                    ]
                     [] t.i:5))
            (clobber (reg:SI 98 ca))
        ]) "t.i":5:3 -1
     (expr_list:REG_DEAD (reg:TF 121 [ a ])
        (expr_list:REG_UNUSED (reg:SI 98 ca)
            (nil))))
...
(insn 13 6 14 2 (set (reg:DF 34 2)
        (const_double:DF 0.0 [0x0.0p+0])) "t.i":6:3 606 {*movdf_hardfloat64}
     (nil))

for the attached example.  This led to an ICE because register 34/fr2
was then live while allocating for pseudo 121.

gcc/ChangeLog:

* ira-lives.cc (ira_implicitly_set_insn_hard_regs): Honor hard
register constraints.
* ira.cc (ira_setup_alts): Ditto.

gcc/testsuite/ChangeLog:

* gcc.target/powerpc/asm-hard-reg-1.c: New test.

2 months agoDeal with combinations of hard register constraints
Stefan Schulze Frielinghaus [Thu, 15 Jan 2026 14:14:59 +0000 (15:14 +0100)] 
Deal with combinations of hard register constraints

Currently, multiple hard register constraints in one alternative are not
supported.  Likewise, a combination of hard register constraints and
regular register constraints is not supported.  Note, a combination of
hard register constraints and non-register constraints as e.g. immediate
constraints is supported.  This is inspired by the i386 target where
constraints like aI are used which could be expressed as {ax}I, too.

gcc/ChangeLog:

* doc/extend.texi: Document current limitations of hard register
constraints.
* stmt.cc (parse_output_constraint): Reject multiple hard
register constraints or a combination of hard register
constraints and regular register constraints in one alternative.
(parse_input_constraint): Ditto.

gcc/testsuite/ChangeLog:

* gcc.dg/asm-hard-reg-error-1.c: Remove tests containing
multiple hard register constraints in one alternative.
* gcc.dg/asm-hard-reg-error-6.c: New test.

2 months agoaarch64: Add comment explaining code layout
Alfie Richards [Fri, 9 Jan 2026 16:51:34 +0000 (16:51 +0000)] 
aarch64: Add comment explaining code layout

gcc/ChangeLog:

* config/aarch64/aarch64-simd.md: Add comment.
* config/aarch64/aarch64-sme.md: Likewise.
* config/aarch64/aarch64-sve-builtins-base.def: Likewise.
* config/aarch64/aarch64-sve-builtins-sme.def: Likewise.
* config/aarch64/aarch64-sve-builtins-sve2.def: Likewise.
* config/aarch64/aarch64-sve-builtins.def: Likewise.
* config/aarch64/aarch64-sve.md: Likewise.
* config/aarch64/aarch64-sve2.md: Likewise.
* config/aarch64/aarch64.md: Likewise.

2 months agosparc: Remove TARGET_SUN_TLS
Rainer Orth [Thu, 15 Jan 2026 12:03:59 +0000 (13:03 +0100)] 
sparc: Remove TARGET_SUN_TLS

All remaining uses of TARGET_SUN_TLS refer to either

* a feature missing in Solaris as:

  Lack of support for R_SPARC_TLS_DTPOFF{32,64}: while Solaris ld
  supports those just fine, I know of no Solaris as syntax for them.

* workarounds for bugs in Solaris as in sparc_tls_got,
  sparc_legitimize_tls_address, and the tls_delay_slot attribute

Therefor this patch replaces all uses of TARGET_SUN_TLS with
!HAVE_GNU_AS.

Bootstrapped without regressions on sparc-sun-solaris2.11,
sparcv9-sun-solaris2.11 (as and gas), and sparc64-unknown-linux-gnu.

2026-01-14  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gcc:
* config/sparc/sparc.h (TARGET_SUN_TLS): Remove.
* config/sparc/sol2.h (TARGET_SUN_TLS): Likewise.

* config/sparc/sparc.cc (TARGET_ASM_OUTPUT_DWARF_DTPREL): Guard
with HAVE_GNU_AS.
(sparc_tls_got): Guard with !HAVE_GNU_AS.
(sparc_legitimize_tls_address): Likewise.
* config/sparc/sparc.md ("tls_delay_slot"): Likewise.
("@tie_add<P:mode>"): Likewise.

2 months agocompare-debug: Don't print discriminators for -fdump-final-insns= [PR121045]
Jakub Jelinek [Thu, 15 Jan 2026 11:03:34 +0000 (12:03 +0100)] 
compare-debug: Don't print discriminators for -fdump-final-insns= [PR121045]

Given the discussions in the PR, seems it is intentional that debug
stmts are taken into account when assigning discriminators which is
something that is actually never emitted into generated code, only
into debug info, so for -g0 we might as well not try to compute them
at all.

But discriminators are printed in the dumps, including -fdump-final-insns=
dump which affect -fcompare-debug.

So, the following patch arranges not to print discriminators in that
dump (i.e. when TDF_COMPARE_DEBUG is set in flags).

I think we should also (but it can be handled incrementally) add
some new TDF_* flag and -fdump-{tree,rtl,ipa}-<pass> modifier which
will also disable printing discriminators (similar to nouid/TDF_NOUID)
so that people can use it e.g. in -fcompare-debug -fdump-tree-all-nodiscrim
and don't have to ignore discrim N changes in the dumps.

This patch fixes
-FAIL: c-c++-common/torture/pr116156-1.c   -O1  (test for excess errors)
-FAIL: c-c++-common/torture/pr116156-1.c   -O2  (test for excess errors)
-FAIL: c-c++-common/torture/pr116156-1.c   -O2 -flto -fno-use-linker-plugin -flto-partition=none  (test for excess errors)
-FAIL: c-c++-common/torture/pr116156-1.c   -O3 -fomit-frame-pointer -funroll-loops -fpeel-loops -ftracer -finline-functions  (test for excess errors)
-FAIL: c-c++-common/torture/pr116156-1.c   -O3 -g  (test for excess errors)
-FAIL: c-c++-common/torture/pr116156-1.c   -Os  (test for excess errors)
-FAIL: g++.dg/torture/pr58552.C   -O1  (test for excess errors)
-FAIL: g++.dg/torture/pr58552.C   -O2  (test for excess errors)
-FAIL: g++.dg/torture/pr58552.C   -O2 -flto -fno-use-linker-plugin -flto-partition=none  (test for excess errors)
-FAIL: g++.dg/torture/pr58552.C   -O3 -g  (test for excess errors)
-FAIL: g++.dg/torture/pr58552.C   -Os  (test for excess errors)
so no testcase added for it.

2026-01-15  Jakub Jelinek  <jakub@redhat.com>

PR debug/121045
* tree-pretty-print.h (dump_location): Add new dump_flags_t
argument defaulted to TDF_NONE.
* tree-pretty-print.cc (dump_location): Add flags argument.  Don't
print discriminator if TDF_COMPARE_DEBUG bit is set in flags.
(dump_block_node, dump_generic_node): Pass through flags to
dump_location.
* gimple-pretty-print.cc (dump_gimple_phi, pp_gimple_stmt_1,
dump_implicit_edges): Likewise.
(gimple_dump_bb_as_sarif_properties): Pass dump_flags to
dump_location.
* print-rtl.cc (rtx_writer::print_rtx_operand_code_L): If dump_flags
has TDF_COMPARE_DEBUG bit set, don't print discriminators.

2 months agoUse -m32/-m64 with Solaris/x86 as
Rainer Orth [Thu, 15 Jan 2026 10:13:49 +0000 (11:13 +0100)] 
Use -m32/-m64 with Solaris/x86 as

GCC currently uses -xarch=generic/-xarch=generic64 with Solaris/x86 as
to select either 32 or 64-bit output.  However, -xarch isn't even
documented any longer, but still accepted for compatibility.  Even for
-xchip, only generic is documented, not generic64.

This patch uses -m32/-m64 instead, which is already used in
gcc/configure.ac.

Bootstrapped without regressions on i386-pc-solaris2.11 and
amd64-pc-solaris2.11.

2026-01-14  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gcc:
* config/i386/sol2.h [!HAVE_GNU_AS] (ASM_CPU32_DEFAULT_SPEC): Use -m32.
(ASM_CPU64_DEFAULT_SPEC): Use -m64.

2 months agoipa/122852: Don't delete unreachable callback edges.
Josef Melcr [Mon, 8 Dec 2025 14:35:33 +0000 (15:35 +0100)] 
ipa/122852: Don't delete unreachable callback edges.

Hi,
previously, callback edges of a carrying edge redirected to
__builtin_unreachable  were deleted, as I thought they would
mess with the callgraph, given that they were no longer correct.
In some cases, the edges would be deleted when duplicating
a fn summary, producing a segfault. This patch changes this
behavior.  It redirects the callback edges to __builtin_unreachable and
adds an exception for such cases in the verifier.  Callback edges are
now also required to point to __builtin_unreachable if their carrying
edge is pointing to __builtin_unreachable.

Bootstrapped and regtested on x86_64-linux, no regressions.

OK for master?

Thanks,
Josef

PR ipa/122852

gcc/ChangeLog:

* cgraph.cc (cgraph_node::verify_node): Verify that callback
edges are unreachable when the carrying edge is unreachable.
* ipa-fnsummary.cc (redirect_to_unreachable): Redirect callback
edges to unreachable when redirecting the carrying edge.

libgomp/ChangeLog:

* testsuite/libgomp.c/pr122852.c: New test.

Signed-off-by: Josef Melcr <josef.melcr@suse.com>
2 months agosparc: Remove HAVE_AS_SPARC_UA_PCREL and HAVE_AS_SPARC_UA_PCREL_HIDDEN
Rainer Orth [Thu, 15 Jan 2026 08:50:04 +0000 (09:50 +0100)] 
sparc: Remove HAVE_AS_SPARC_UA_PCREL and HAVE_AS_SPARC_UA_PCREL_HIDDEN

The SPARC backend currently has workarounds for two bugs in old versions
of the assembler and linker.  However, I find both
HAVE_AS_SPARC_UA_PCREL and HAVE_AS_SPARC_UA_PCREL_HIDDEN are always
defined as 1 on both Solaris/SPARC and Linux/sparc64.

I've checked all combinations of the assemblers supported on SPARC: the
Solaris 11.4 FCS as and ld, current Solaris as and ld, gas and gld 2.30
and 2.45.  The tests work on all of those, so the workarounds can be
removed.

Bootstrapped on sparc-sun-solaris2.11 (as and gas) and
sparc64-unknown-linux-gnu.

2026-01-13  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gcc:
* configure.ac (gcc_cv_as_sparc_ua_pcrel): Remove.
(gcc_cv_as_sparc_ua_pcrel_hidden): Likewise.
* configure: Regenerate.
* config.in: Regenerate.

* config/sparc/sparc.h (ASM_PREFERRED_EH_DATA_FORMAT): Remove
!HAVE_AS_SPARC_UA_PCREL, !HAVE_AS_SPARC_UA_PCREL_HIDDEN support.
* config/sparc/sol2.h (ASM_PREFERRED_EH_DATA_FORMAT): Remove.
* config/sparc/sparc.cc (TARGET_ASM_OUTPUT_DWARF_DTPREL): Remove
HAVE_AS_SPARC_UA_PCREL guard.

2 months agosparc: Switch TARGET_SUN_TLS default
Rainer Orth [Thu, 15 Jan 2026 08:45:06 +0000 (09:45 +0100)] 
sparc: Switch TARGET_SUN_TLS default

sparc/sparc.h currently defaults to TARGET_SUN_TLS.  All other SPARC
targets and Solaris with GNU as have to override this, although this is
only needed on Solaris/SPARC with the native assembler.

To simplify the code, this patch switches the default to TARGET_SUN_TLS
set to 0, removing the need for all the overrides.

TARGET_GNU_TLS is only used in two places and can be replaced by
!TARGET_SUN_TLS, too.

Bootstrapped without regressions on sparc-sun-solaris2.11 (as and gas)
and sparc64-unknown-linux-gnu.

2026-01-13  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gcc:
* config/sparc/sparc.h (TARGET_TLS): Define as HAVE_AS_TLS.
Update comment.
(TARGET_SUN_TLS): Define as 0.
(TARGET_GNU_TLS): Remove.
* config/sparc/freebsd.h (TARGET_SUN_TLS): Remove.
(TARGET_GNU_TLS): Remove.
* config/sparc/linux.h: Likewise.
* config/sparc/linux64.h: Likewise.
* config/sparc/sol2.h (TARGET_SUN_TLS): Redefine as 1.
Guard with HAVE_AS_TLS && !HAVE_GNU_AS.
(TARGET_GNU_TLS): Remove.
* config/sparc/sparc.cc (TARGET_ASM_OUTPUT_DWARF_DTPREL): Use
!TARGET_SUN_TLS in guard.
with !TARGET_SUN_TLS only.
* config/sparc/sparc.md ("tls_delay_slot"): Guard with
!TARGET_SUN_TLS.

2 months agoRemove Solaris/SPARC ASM_OUTPUT_ALIGNED_COMMON [PR38118]
Rainer Orth [Thu, 15 Jan 2026 08:13:34 +0000 (09:13 +0100)] 
Remove Solaris/SPARC ASM_OUTPUT_ALIGNED_COMMON [PR38118]

sparc/sol2.h has its own definition of ASM_OUTPUT_ALIGNED_COMMON,
overriding the elfos.h version.  This was introduced back in 2010 as a
workaround for a bug in old versions of the Solaris/SPARC assembler (PR
target/38118).  However, even the Solaris 11.4 FCS as, the oldest one
currently supported, doesn't have this bug any longer.  Besides, the
workaround hasn't been effective anymore since GCC 10 without ill
effect.

Therefore the override definition can simply be removed.

Bootstrapped without regression on sparc-sun-solaris2.11 (as and gas).

2026-01-09  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gcc:
PR target/38118
* config/sparc/sol2.h (ASM_OUTPUT_ALIGNED_COMMON): Remove.

2 months agoFix x86 testsuite fallout from VF == 1 epilogue vectorization change
Richard Biener [Thu, 15 Jan 2026 07:55:34 +0000 (08:55 +0100)] 
Fix x86 testsuite fallout from VF == 1 epilogue vectorization change

The following fixes reported fallout with -march=cascadelake.

* gcc.dg/vect/fast-math-slp-38.c: Avoid epilogue vectorization.

2 months agoFix testsuite fallout of VF == 1 epilogue vectorization change
Richard Biener [Thu, 15 Jan 2026 07:51:36 +0000 (08:51 +0100)] 
Fix testsuite fallout of VF == 1 epilogue vectorization change

The following fixes a testsuite fallout on aarch64.

* gcc.dg/vect/complex/fast-math-complex-add-half-float.c:
Avoid epilogue vectorization.

2 months agotestsuite: Add testcase for already fixed PR [PR120322]
Jakub Jelinek [Thu, 15 Jan 2026 06:46:24 +0000 (07:46 +0100)] 
testsuite: Add testcase for already fixed PR [PR120322]

This testcase started to be miscompiled with r16-170 and got fixed
again with r16-960.

2026-01-15  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/120322
* gcc.dg/torture/pr120322.c: New test.

2 months ago[Autofdo] Add hierarchical discriminator for loop unrolling
Kugan Vivekanandarajah [Thu, 15 Jan 2026 03:40:32 +0000 (14:40 +1100)] 
[Autofdo] Add hierarchical discriminator for loop unrolling

Add hierarchical discriminator support for loop unrolling.
Assigns multiplicity and copyid discriminators to distinguish unrolled
iterations.

gcc/ChangeLog:

* cfgloopmanip.cc (duplicate_loop_body_to_header_edge): Assign
hierarchical discriminators for loop unrolling.
* cfgloopmanip.h (DLTHE_RECORD_HIERARCHICAL_DISCRIMINATOR): New flag.
* tree-ssa-loop-ivcanon.cc (try_unroll_loop_completely): Pass flag
to enable hierarchical discriminator assignment.
(try_peel_loop): Likewise.

gcc/testsuite/ChangeLog:

* gcc.dg/hierarchical-discriminator-unroll.c: New test.

Signed-off-by: Kugan Vivekanandarajah <kvivekananda@nvidia.com>
2 months ago[AutoFDO] Add hierarchical discriminator for loop versioning
Kugan Vivekanandarajah [Thu, 15 Jan 2026 03:39:33 +0000 (14:39 +1100)] 
[AutoFDO] Add hierarchical discriminator for loop versioning

Add hierarchical discriminator support for loop versioning pass.
Assigns copyid discriminators to distinguish different loop versions.

gcc/ChangeLog:

* gimple-loop-versioning.cc (loop_versioning::version_loop): Assign
copyid discriminators to distinguish different loop versions.

gcc/testsuite/ChangeLog:

* gcc.dg/hierarchical-discriminator-loop-version.c: New test.

Signed-off-by: Kugan Vivekanandarajah <kvivekananda@nvidia.com>
2 months ago[AutoFDO] Add hierarchical discriminator for vectorizer
Kugan Vivekanandarajah [Thu, 15 Jan 2026 03:37:50 +0000 (14:37 +1100)] 
[AutoFDO] Add hierarchical discriminator for vectorizer

Add hierarchical discriminator support for vectorized loop versioning.
Assigns copyid discriminators to distinguish vectorized and scalar versions.

gcc/ChangeLog:

* tree-vect-loop-manip.cc (vect_loop_versioning): Assign copyid
discriminators for vectorized and scalar loop versions.
* tree-vect-loop.cc (vect_transform_loop): Assign copyid
discriminators for vectorized and scalar loop versions.

gcc/testsuite/ChangeLog:

* gcc.dg/hierarchical-discriminator-vect-version.c: New test.

Signed-off-by: Kugan Vivekanandarajah <kvivekananda@nvidia.com>
2 months ago[Autofdo] Add hierarchical discriminator support
Kugan Vivekanandarajah [Thu, 15 Jan 2026 03:36:44 +0000 (14:36 +1100)] 
[Autofdo] Add hierarchical discriminator support

This patch introduces the basic infrastructure for hierarchical
discriminators with format [Base:8][Multiplicity:7][CopyID:11][Unused:6].
It adds helper functions to create and extract discriminator components.

gcc/ChangeLog:

* Makefile.in: Add hierarchical_discriminator.o to OBJS.
* hierarchical_discriminator.cc: New file.
* hierarchical_discriminator.h: New file.
* function.h (copyid_alloc): New.
* input.cc (location_with_discriminator_components): New function.
(get_discriminator_components_from_loc): Likewise.
* input.h (DISCR_BASE_BITS): New constant.
(DISCR_MULTIPLICITY_BITS): Likewise.
(DISCR_COPYID_BITS): Likewise.
(DISCR_UNUSED_BITS): Likewise.
(DISCR_BASE_MASK): Likewise.
(DISCR_MULTIPLICITY_MASK): Likewise.
(DISCR_COPYID_MASK): Likewise.
(DISCR_BASE_SHIFT): Likewise.
(DISCR_MULTIPLICITY_SHIFT): Likewise.
(DISCR_COPYID_SHIFT): Likewise.
(DISCR_BASE_MAX): Likewise.
(DISCR_MULTIPLICITY_MAX): Likewise.
(DISCR_COPYID_MAX): Likewise.
(location_with_discriminator_components): New function declaration.
(get_discriminator_components_from_loc): Likewise.

Signed-off-by: Kugan Vivekanandarajah <kvivekananda@nvidia.com>
2 months agoLoongArch: Fix ICE when explicit-relocs is none
DengJianbo [Tue, 13 Jan 2026 07:21:54 +0000 (15:21 +0800)] 
LoongArch: Fix ICE when explicit-relocs is none

When set -mexplicit-relocs=none, the symbol address should be caclulated
by macro instructions, for example la.local. Due to the condition
TARGET_CMODEL_EXTREME in movdi_symbolic_off64, this template can not be
matched in case the cmodel is normal. If the variable has attribute
model("extreme"), gcc will get crashed with error unrecognizable insns.
This patch fix this issue by removing TARGET_CMODEL_EXTREME, since it
already checked in prediction symbolic_off64_or_reg_operand.

gcc/ChangeLog:

* config/loongarch/loongarch.md: Remove condition in template
movdi_symbolic_off64.

gcc/testsuite/ChangeLog:

* gcc.target/loongarch/la64/attr-model-6.c: New test.

2 months agoa68: fix documentation of lseek in manual
Jose E. Marchesi [Wed, 14 Jan 2026 23:58:10 +0000 (00:58 +0100)] 
a68: fix documentation of lseek in manual

The first argument of lseek is a `long long int'.

Signed-off-by: Jose E. Marchesi <jemarch@gnu.org>
gcc/algol68/ChangeLog

* ga68.texi (POSIX files): Fix documentation of lseek.

2 months agoa68: fix documentation of -f[no-]brackets
Jose E. Marchesi [Fri, 9 Jan 2026 23:53:48 +0000 (00:53 +0100)] 
a68: fix documentation of -f[no-]brackets

Signed-off-by: Jose E. Marchesi <jemarch@gnu.org
gcc/algol68/ChangeLog

* ga68.texi (Dialect options): {..} is not a valid variant of
(...).

2 months agoDaily bump.
GCC Administrator [Thu, 15 Jan 2026 00:16:30 +0000 (00:16 +0000)] 
Daily bump.

2 months agoRISC-V: Enable the ZD constraint only when xmipscbop is enabled [PR123092]
Peter Bergner [Wed, 14 Jan 2026 21:12:21 +0000 (15:12 -0600)] 
RISC-V: Enable the ZD constraint only when xmipscbop is enabled [PR123092]

The ZD constraint is specific to the mips prefetch instruction.  It is
currently always enabled, leading to ICEs when xmipscbop is disabled.
Solved by only enabling the ZD constraint whenever xmipscbop is enabled.

2026-01-14  Peter Bergner  <bergner@tenstorrent.com>

gcc/
PR target/123092
* config/riscv/constraints.md (ZD): Disable when xmipscbop is disabled.

Signed-off-by: Peter Bergner <bergner@tenstorrent.com>
2 months agoC: fix issues when supporting counted_by fields in anonymous structure/unions [PR1224...
Qing Zhao [Wed, 14 Jan 2026 17:14:01 +0000 (17:14 +0000)] 
C: fix issues when supporting counted_by fields in anonymous structure/unions [PR122495,PR122496]

Currently, GCC does not fully support the cases when a FAM or pointer field and
its corresponding counted_by field are in different anonymous structure/unions
of a common named structure.

For example:

struct nested_mixed {
  struct {
    union {
      int b;
      float f;
    };
    int n;
  };
  struct {
    PTR_TYPE *pointer __attribute__((__counted_by__(n)));
    FAM_TYPE c[] __attribute__((__counted_by__(b)));
  };
} *nested_mixed_annotated;

In order to support such cases, we always need to locate the first outer
named structure as the root, and then lookup_field inside this named
structure. When building the component_ref for the counted_by field,
we need to build a chain of component_ref starting from the root structure.

When supporting the above in general, we also need to handle the following
several special cases correctly:

A. Support an untagged type as its own top-level type.  */
struct { int a; char b[] __attribute__ ((counted_by (a))); } *x;

B. Support an unnamed field with a named struct/union.  */
struct s { struct { int a; char b[] __attribute__ ((counted_by (a))); } *x; } *y;

C. When -fms-extensions is enabled:

   C.1 Do not support the inward-to-outward counted-by field reference
       since checking the validity of such reference depends on unknown
       situation at the end of the structure definition.

struct bar {
  char *buf __counted_by (n); /* { dg-error "attribute is not a field declaration in the same structure as" } */
};

   C.2 support the outward-to-inward counted-by field reference.

PR C/122495
PR C/122496

gcc/c/ChangeLog:

* c-decl.cc (grokfield): Call verify_counted_by_for_top_anonymous_type
for named field.
(verify_counted_by_attribute): Change the prototype to a recursive
routine.
(verify_counted_by_for_top_anonymous_type): New routine.
(finish_struct): Set C_TYPE_FIELDS_HAS_COUNTED_BY and call the routine
verify_counted_by_attribute only for named structure.
* c-parser.cc (c_parser_declaration_or_fndef): Call
verify_counted_by_for_top_anonymous_type for the decl.
(c_parser_parameter_declaration): Call
verify_counted_by_for_top_anonymous_type for the parameter.
(c_parser_type_name): Call verify_counted_by_for_top_anonymous_type
for the type.
* c-tree.h (C_TYPE_FIELDS_HAS_COUNTED_BY): New flag.
(verify_counted_by_for_top_anonymous_type): New routine.
* c-typeck.cc (build_counted_by_ref): Locate the root named structure,
build a chain of component_ref starting from the root structure.

gcc/testsuite/ChangeLog:

* gcc.dg/counted-by-anonymous-2-char.c: New test.
* gcc.dg/counted-by-anonymous-2-float.c: New test.
* gcc.dg/counted-by-anonymous-2-struct.c: New test.
* gcc.dg/counted-by-anonymous-2-union.c: New test.
* gcc.dg/counted-by-anonymous-2.c: New test.
* gcc.dg/counted-by-anonymous-3.c: New test.
* gcc.dg/counted-by-anonymous.c: New test.
* gcc.dg/ubsan/counted-by-anonymous-bounds-1.c: New test.
* gcc.dg/ubsan/counted-by-anonymous-bounds-2.c: New test.
* gcc.dg/ubsan/counted-by-anonymous-bounds.c: New test.

2 months agoMAINTAINERS: update my email address
Vineet Gupta [Wed, 14 Jan 2026 19:11:18 +0000 (11:11 -0800)] 
MAINTAINERS: update my email address

ChangeLog

* MAINTAINERS: Update to my linux.dev email.

Signed-off-by: Vineet Gupta <vineet.gupta@linux.dev>
2 months agoipa-cp: Always return the right type in ipa_value_from_jfunc (PR123542)
Martin Jambor [Wed, 14 Jan 2026 19:41:57 +0000 (20:41 +0100)] 
ipa-cp: Always return the right type in ipa_value_from_jfunc (PR123542)

PR 123542 is about triggering a checking assert that verifies that we
indeed clone a function for the constant value we started evaluating.
The issue is that we get a double 2 instead of a float 2 which comes
down to function ipa_value_from_jfunc not doing the necessary
conversion when dealing directly with constants (and ancestor jump
functions but that is very unlikley to cause problems).

This patch makes sure the required conversion is performed in all
cases (even for the ancestor JFs) and checks that the result type is
known, because when the function is invoked from ipa-modref.cc or
ipa-fnsummary.cc that may not be the case.

gcc/ChangeLog:

2026-01-14  Martin Jambor  <mjambor@suse.cz>

PR ipa/123542
* ipa-cp.cc (ipa_value_from_jfunc): Always use
ipacp_value_safe_for_type.  Bail out if parm_type is NULL.

gcc/testsuite/ChangeLog:

2026-01-14  Martin Jambor  <mjambor@suse.cz>

PR ipa/123542
* gcc.dg/ipa/pr123542.c: New test.

2 months agotestsuite: Enable cross testing for simulate-thread tests
Joseph Myers [Wed, 14 Jan 2026 17:10:33 +0000 (17:10 +0000)] 
testsuite: Enable cross testing for simulate-thread tests

The simulate-thread tests exit early in cross and remote cases.  Apply
fixes similar to (but affecting separate code) those recently posted
for the guality tests: do not use [transform gdb] since that's a cross
GDB and the tests expect to run GDB on the target, test existence on
the target not the build system, and copy required files to the target
(deleting them later).

Tested for x86_64-pc-linux-gnu to make sure native testing isn't
broken, and with cross to aarch64-linux.

* lib/gcc-dg.exp (gdb-exists): Do not use [transform gdb].  Run
selected GDB with -v on target rather than testing for existence
on build system.
* lib/gcc-simulate-thread.exp (simulate-thread): Do not return
early for non-native and remote.  Download executable and GDB
command file to target before running GDB there, and delete when
closing target.

2 months agotestsuite: Fix issues with cross testing in guality tests
Joseph Myers [Wed, 14 Jan 2026 17:09:40 +0000 (17:09 +0000)] 
testsuite: Fix issues with cross testing in guality tests

The guality tests expect to run (native) GDB on the target.  If this
is available, there is some support for cross testing, but with
various defects and limitations, some of them fixed here.

* GUALITY_GDB_NAME doesn't get passed through to the target for remote
  testing (a general limitation of the DejaGnu interface: it doesn't
  support setting environment variables on the target).  Not fixed
  here.

* Using in-tree GDB is only appropriate when host = target, since
  in-tree GDB runs on the host and the testsuite runs GDB on the
  target.  Fixed here.  (Note that [isnative] isn't used because that
  refers to build = target, and we need host = target here.)

* [transform gdb] is not appropriate because that's a cross-GDB and
  the tests run GDB on the target, so need a native GDB.  Fixed here.

* gdb-test (used by some guality tests) exits early in cross and
  remote cases (whereas the tests running GDB directly from the test
  itself via popen can already do so on the target without needing
  further patches).  Fixed here.  There are various other fixes done
  in gdb-test as well; it needs to transfer files to the target then
  delete them afterwards.

* report_gdb expects to run GDB on the host when the tests run it on
  the target.  Fixed here.

Note: some similar fixes will also be needed for simulate-thread tests
to get them working for cross testing, but I haven't done those yet.

Tested for x86_64-pc-linux-gnu to make sure native testing isn't
broken, and with cross to aarch64-linux.

* lib/gcc-gdb-test.exp (gdb-test): Do not return early for
non-native and remote.  Download executable and GDB command file
to target before running GDB there, and delete when closing
target.
(report_gdb): Use target when testing GDB availability and
version.
* g++.dg/guality/guality.exp: Only use in-tree GDB when host =
target.  Do not use [transform gdb].
* gcc.dg/guality/guality.exp: Likewise.
* gfortran.dg/guality/guality.exp: Likewise.

2 months agoc++: UX improvements for close matches in print_candidates
David Malcolm [Wed, 14 Jan 2026 16:49:12 +0000 (11:49 -0500)] 
c++: UX improvements for close matches in print_candidates

This patch improves the UX for various cases of "no declaration matches"
where print_candidates encounters a close match.

For example, consider the const vs non-const here:

class foo
{
public:
  void test (int i, int j, void *ptr, int k);
};

// Wrong "const"-ness of param 3.
void foo::test (int i, int j, const void *ptr, int k)
{
}

where we emit (with indentation provided by the prior patch):

test.cc:8:6: error: no declaration matches ‘void foo::test(int, int, const void*, int)’
    8 | void foo::test (int i, int j, const void *ptr, int k)
      |      ^~~
  • there is 1 candidate
    • candidate is: ‘void foo::test(int, int, void*, int)’
      test.cc:4:8:
          4 |   void test (int i, int j, void *ptr, int k);
            |        ^~~~
test.cc:1:7: note: ‘class foo’ defined here
    1 | class foo
      |       ^~~

which requires the user to look through the pairs of parameters
and try to find the mismatch by eye.

This patch adds notes identifying that parameter 3 has the mismatch, and
what the mismatch is, using a pair of colors to highlight and contrast
the type mismatch.

test.cc:8:6: error: no declaration matches ‘void foo::test(int, int, const void*, int)’
    8 | void foo::test (int i, int j, const void *ptr, int k)
      |      ^~~
  • there is 1 candidate
    • candidate is: ‘void foo::test(int, int, void*, int)’
      test.cc:4:8:
          4 |   void test (int i, int j, void *ptr, int k);
            |        ^~~~
      • parameter 3 of candidate has type ‘void*’...
        test.cc:4:34:
            4 |   void test (int i, int j, void *ptr, int k);
              |                            ~~~~~~^~~
      • ...which does not match type ‘const void*’
        test.cc:8:43:
            8 | void foo::test (int i, int j, const void *ptr, int k)
              |                               ~~~~~~~~~~~~^~~
test.cc:1:7: note: ‘class foo’ defined here
    1 | class foo
      |       ^~~

This also works for the "this" case, improving the UX for messing up
const vs non-const between decls and defns of member functions; see
bad-fndef-2.C for an example.

For screenshots showing the colorization effect, see slides 9-12 of my
Cauldron talk:
https://gcc.gnu.org/wiki/cauldron2025#What.27s_new_with_diagnostics_in_GCC_16
("Hierarchical diagnostics (not yet in trunk)").

gcc/cp/ChangeLog:
* call.cc (get_fndecl_argument_location): Use DECL_SOURCE_LOCATION
for "this".
* cp-tree.h (class candidate_context): New.
(print_candidates): Add optional candidate_context param.
* decl2.cc: Include "gcc-rich-location.h" and
"tree-pretty-print-markup.h".
(struct fndecl_signature): New.
(class parm_rich_location): New.
(class fndecl_comparison): New.
(class decl_mismatch_context): New.
(check_classfn): For the "no declaration matches" case, pass an
instance of a custom candidate_context subclass to
print_candidates, using fndecl_comparison to report on close
matches.
* pt.cc (print_candidates): Add optional candidate_context param.
Use it if provided to potentially emit per-candidate notes.

gcc/testsuite/ChangeLog:
* g++.dg/diagnostic/bad-fndef-1.C: Add directives to expect
"void *" vs "const void *" notes about parameter 3 of the close
candidate.
* g++.dg/diagnostic/bad-fndef-2.C: New test.
* g++.dg/diagnostic/bad-fndef-3.C: New test.
* g++.dg/diagnostic/bad-fndef-4.C: New test.
* g++.dg/diagnostic/bad-fndef-5.C: New test.
* g++.dg/diagnostic/bad-fndef-6.C: New test.
* g++.dg/diagnostic/bad-fndef-7.C: New test.
* g++.dg/diagnostic/bad-fndef-7b.C: New test.
* g++.dg/diagnostic/bad-fndef-8.C: New test.
* g++.dg/diagnostic/bad-fndef-9.C: New test.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>
2 months agoc++: use nesting and counts in print_candidates
David Malcolm [Wed, 14 Jan 2026 16:43:57 +0000 (11:43 -0500)] 
c++: use nesting and counts in print_candidates

In r15-6116-gd3dd24acd74605 I updated print_z_candidates to print a
count of the number of candidates, and to show the number of each
candidate in the list if there is more than one.

The following patch updates print_candidates to work in a similar
way, showing counts, numbering, and using nesting.

Consider this test case for which we print 2 candidates:

class foo
{
public:
  void test (int i, int j, void *ptr, int k);
  void test (int i, int j, int k);
};

// Wrong "const"-ness of a param, for one of the overloads (param 3).
void foo::test (int i, int j, const void *ptr, int k)
{
}

The output before the patch is:

test.cc:9:6: error: no declaration matches ‘void foo::test(int, int, const void*, int)’
    9 | void foo::test (int i, int j, const void *ptr, int k)
      |      ^~~
test.cc:5:8: note: candidates are: ‘void foo::test(int, int, int)’
    5 |   void test (int i, int j, int k);
      |        ^~~~
test.cc:4:8: note:                 ‘void foo::test(int, int, void*, int)’
    4 |   void test (int i, int j, void *ptr, int k);
      |        ^~~~
test.cc:1:7: note: ‘class foo’ defined here
    1 | class foo
      |       ^~~

With the patch, the output looks like:

test.cc:9:6: error: no declaration matches ‘void foo::test(int, int, const void*, int)’
    9 | void foo::test (int i, int j, const void *ptr, int k)
      |      ^~~
  • there are 2 candidates
    • candidate 1: ‘void foo::test(int, int, int)’
      test.cc:5:8:
          5 |   void test (int i, int j, int k);
            |        ^~~~
    • candidate 2: ‘void foo::test(int, int, void*, int)’
      test.cc:4:8:
          4 |   void test (int i, int j, void *ptr, int k);
            |        ^~~~
test.cc:1:7: note: ‘class foo’ defined here
    1 | class foo
      |       ^~~

which I believe is much more readable.

I dabbled with removing the "there is 1 candidate" line for the case of
a single candidate, but I think I prefer it to be present.

FWIW I've been experimenting with followups that
* show more nested information about the problems (e.g. the "void *"
vs "const void *" mismatch) - having the candidates be nested is a
useful step towards that
* potentially look at the "edit distance" of the type signatures to find
close matches, and perhaps reordering/highlighting them (e.g. in the
above candidate 2 is arguably a closer match than candidate 1, due to
the "const" snafu) - gathering an auto_vec might help with that.

gcc/cp/ChangeLog:
* call.cc (print_z_candidates): Move inform_n call into a new
inform_num_candidates function.
* class.cc (check_methods): Pass location to call to
print_candidates.
(resolve_address_of_overloaded_function): Likewise.
* cp-tree.h (print_candidates): Add location_t param.
(inform_num_candidates): New decl.
* decl.cc (make_typename_type): Pass location to call to
print_candidates.
(reshape_init_class): Likewise.
(lookup_and_check_tag): Likewise.
* decl2.cc (check_classfn): Likewise.
* error.cc (qualified_name_lookup_error): Likewise.
* init.cc (build_new_1): Likewise.
* name-lookup.cc (lookup_using_decl): Likewise.
(set_decl_namespace): Likewise.
(push_namespace): Likewise.
* parser.cc (cp_parser_nested_name_specifier_opt): Likewise.
(cp_parser_lookup_name): Likewise.
* pt.cc  (print_candidates_1): Drop, converting the looping part
into...
(flatten_candidates): ...this new function.
(inform_num_candidates): New function.
(print_candidates): Use flatten_candidates to build an auto_vec
of candidates, and use this to print them here, rather than in
print_candidates_1.  Eliminate the dynamic allocation of spaces
for a prefix in favor of printing "candidate %i" when there is
more than one candidate.  Add "error_loc" param and pass it to
inform_num_candidates to show a heading, and add nesting levels
for it and for the candidate notes.
(determine_specialization): Pass location to calls to
print_candidates.
* search.cc (lookup_member): Likewise.
* semantics.cc (finish_id_expression_1): Likewise.

gcc/testsuite/ChangeLog:
* g++.dg/cpp0x/inline-ns2.C: Make dg-message directives non-empty.
* g++.dg/cpp23/explicit-obj-lambda11.C: Prune the extra note.
* g++.dg/diagnostic/bad-fndef-1.C: New test.
* g++.dg/lookup/decl1.C: Give the dg-message directives different
messages.
* g++.dg/lookup/using17.C: Update expected output.
* g++.dg/parse/non-dependent2.C: Likewise.
* g++.old-deja/g++.other/lineno2.C: Give the dg-message directives
different messages.
* g++.old-deja/g++.pt/t37.C: Likewise.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>
2 months agoc++: Don't ICE on computed goto in potential_constant_expression_1 [PR123551]
Jakub Jelinek [Wed, 14 Jan 2026 16:09:13 +0000 (17:09 +0100)] 
c++: Don't ICE on computed goto in potential_constant_expression_1 [PR123551]

r16-968-g5c6364b09a6 has added if (DECL_ARTIFICIAL (*target)) return true;
stmt for GOTO_EXPRs.  This unfortunately ICEs if *target is not a decl,
which is the case for computed gotos.  For those we should always reject
them, so the following patch additionally checks for LABEL_DECL
before testing DECL_ARTIFICIAL on it.

2026-01-14  Jakub Jelinek  <jakub@redhat.com>

PR c++/123551
* constexpr.cc (potential_constant_expression_1) <case GOTO_EXPR>:
Only test DECL_ARTIFICIAL on LABEL_DECLs.

* g++.dg/ext/goto2.C: New test.

2 months agoAArch64: Use anchors for FP constants [PR 121240]
Wilco Dijkstra [Tue, 13 Jan 2026 16:21:05 +0000 (16:21 +0000)] 
AArch64: Use anchors for FP constants [PR 121240]

Use anchors for FP constants - instead of using mergeable sections which blocks
anchors, load FP constants from the constdata section.  To avoid the anchor
loads being deoptimized later, ensure the cost of a CONST_DOUBLE is larger than
the cost of a MEM that loads it from constdata.  Codesize is slightly smaller,
performance on SPECFP2017 is ~0.30% better.

gcc:
PR target/121240
* config/aarch64/aarch64.md (mov<mode>): Expand FP immediates early.
* config/aarch64/aarch64.cc (aarch64_select_rtx_section): Force
immediates <= 8 bytes to constdata.
(aarch64_rtx_costs): Increase cost of CONST_DOUBLE loaded from memory.

gcc/testsuite:
PR target/121240
* gcc.target/aarch64/dbl_mov_immediate_1.c: Adjust test.
* gcc.target/aarch64/pr63304_1.c: Likewise.

2 months agoAArch64: Improve immediate generation [PR 114528]
Wilco Dijkstra [Mon, 12 Jan 2026 14:19:46 +0000 (14:19 +0000)] 
AArch64: Improve immediate generation [PR 114528]

Improve immediate generation to support 2-instruction MOV+ADD/SUB
of 12-bit shifted immediate. Eg.

long f1 (void)
{
  return 0x123400567000;
}

now generates:

mov     x0, 20014547599360
add     x0, x0, 5664768
ret

gcc:
PR target/114528
* config/aarch64/aarch64.cc (aarch64_check_mov_add_imm12):
New function to check and emit MOV+ADD/SUB immediates.
(aarch64_internal_mov_immediate): Add support for MOV+ADD/SUB
immediates.

gcc/testsuite:
PR target/114528
* gcc.target/aarch64/pr114528.c: New test.

2 months agoexpand: Handle variable-length vector constructors with debug [PR123392]
Tejas Belagod [Tue, 13 Jan 2026 16:58:38 +0000 (16:58 +0000)] 
expand: Handle variable-length vector constructors with debug [PR123392]

Variable-length Vector initializer constructors currently only work in
non-debug mode.  It ICEs when compiled with -g.  This patch fixes it to handle
variable-length vector intialization by limiting the constructor elements to
the lower bound of the variable length poly which is also the maximum number
of elements allowed in the initializer.

PR middle-end/123392
gcc/
* cfgexpand.cc (expand_debug_expr): Handle variable-length initializer
for CONSTRUCTOR.

gcc/testsuite/

* gcc.target/aarch64/sve/acle/general/pr123392.c: New.

2 months agoAdd 'libgomp.c++/target-std__[...]-concurrent-usm.C' test cases for C++ 'std::unorder...
Thomas Schwinge [Fri, 30 May 2025 09:37:46 +0000 (11:37 +0200)] 
Add 'libgomp.c++/target-std__[...]-concurrent-usm.C' test cases for C++ 'std::unordered_map', 'std::unordered_multimap', 'std::unordered_multiset', 'std::unordered_set'

libgomp/
* testsuite/libgomp.c++/target-std__unordered_map-concurrent-usm.C:
New.
* testsuite/libgomp.c++/target-std__unordered_multimap-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__unordered_multiset-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__unordered_set-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__unordered_map-concurrent.C:
Adjust.
* testsuite/libgomp.c++/target-std__unordered_multimap-concurrent.C:
Likewise.
* testsuite/libgomp.c++/target-std__unordered_multiset-concurrent.C:
Likewise.
* testsuite/libgomp.c++/target-std__unordered_set-concurrent.C:
Likewise.

2 months agoAdd 'libgomp.c++/target-std__[...]-concurrent-usm.C' test cases for C++ 'std::flat_ma...
Thomas Schwinge [Fri, 30 May 2025 09:37:46 +0000 (11:37 +0200)] 
Add 'libgomp.c++/target-std__[...]-concurrent-usm.C' test cases for C++ 'std::flat_map', 'std::flat_multimap', 'std::flat_multiset', 'std::flat_set'

libgomp/
* testsuite/libgomp.c++/target-std__flat_map-concurrent-usm.C:
New.
* testsuite/libgomp.c++/target-std__flat_multimap-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__flat_multiset-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__flat_set-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__flat_map-concurrent.C: Adjust.
* testsuite/libgomp.c++/target-std__flat_multimap-concurrent.C:
Likewise.
* testsuite/libgomp.c++/target-std__flat_multiset-concurrent.C:
Likewise.
* testsuite/libgomp.c++/target-std__flat_set-concurrent.C:
Likewise.

2 months agoFix up 'libgomp.c++/target-std__[...]-concurrent-usm.C' dynamic memory allocation
Thomas Schwinge [Fri, 30 May 2025 09:37:46 +0000 (11:37 +0200)] 
Fix up 'libgomp.c++/target-std__[...]-concurrent-usm.C' dynamic memory allocation

OpenMP/USM implies memory accessible from host as well as device, but doesn't
imply that allocation vs. deallocation may be done in the opposite context.
For most of the test cases, (by construction) we're not allocating memory
during device execution, so have nothing to clean up.  (..., but still document
these semantics.)  But for a few, we have to clean up:
'libgomp.c++/target-std__map-concurrent-usm.C',
'libgomp.c++/target-std__multimap-concurrent-usm.C',
'libgomp.c++/target-std__multiset-concurrent-usm.C',
'libgomp.c++/target-std__set-concurrent-usm.C'.

For 'libgomp.c++/target-std__multimap-concurrent-usm.C' (only), this issue
already got addressed in commit 90f2ab4b6e1463d8cb89c70585e19987a58f3de1
"libgomp.c++/target-std__multimap-concurrent.C: Fix USM memory freeing".
However, instead of invoking the 'clear' function (which doesn't generally
guarantee to release dynamically allocated memory; for example, see PR123582
"C++ unordered associative container: dynamic memory management"), we properly
restore the respective object into pristine state.

libgomp/
* testsuite/libgomp.c++/target-std__array-concurrent-usm.C:
'#define OMP_USM'.
* testsuite/libgomp.c++/target-std__forward_list-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__list-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__span-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__map-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__multimap-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__multiset-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__set-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__valarray-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__vector-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__bitset-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__deque-concurrent-usm.C:
Likewise.
* testsuite/libgomp.c++/target-std__array-concurrent.C: Comment.
* testsuite/libgomp.c++/target-std__bitset-concurrent.C: Likewise.
* testsuite/libgomp.c++/target-std__deque-concurrent.C: Likewise.
* testsuite/libgomp.c++/target-std__forward_list-concurrent.C:
Likewise.
* testsuite/libgomp.c++/target-std__list-concurrent.C: Likewise.
* testsuite/libgomp.c++/target-std__span-concurrent.C: Likewise.
* testsuite/libgomp.c++/target-std__valarray-concurrent.C:
Likewise.
* testsuite/libgomp.c++/target-std__vector-concurrent.C: Likewise.
* testsuite/libgomp.c++/target-std__map-concurrent.C [OMP_USM]:
Fix up dynamic memory allocation.
* testsuite/libgomp.c++/target-std__multimap-concurrent.C
[OMP_USM]: Likewise.
* testsuite/libgomp.c++/target-std__multiset-concurrent.C
[OMP_USM]: Likewise.
* testsuite/libgomp.c++/target-std__set-concurrent.C [OMP_USM]:
Likewise.

2 months agolibgomp: Add a few more OpenMP/USM test cases
Thomas Schwinge [Fri, 9 May 2025 13:09:51 +0000 (15:09 +0200)] 
libgomp: Add a few more OpenMP/USM test cases

... where there are clear differences in behavior for OpenMP/USM run-time
configurations.

We shall further clarify all the intended semantics, once the implementation
begins to differentiate OpenMP 'requires unified_shared_memory' vs.
'requires self_maps'.

libgomp/
* testsuite/libgomp.c-c++-common/map-arrayofstruct-2-usm.c: New.
* testsuite/libgomp.c-c++-common/map-arrayofstruct-3-usm.c:
Likewise.
* testsuite/libgomp.c-c++-common/struct-elem-5-usm.c: Likewise.
* testsuite/libgomp.c-c++-common/target-present-1-usm.c: Likewise.
* testsuite/libgomp.c-c++-common/target-present-2-usm.c: Likewise.
* testsuite/libgomp.c-c++-common/target-present-3-usm.c: Likewise.
* testsuite/libgomp.fortran/map-subarray-5-usm.f90: Likewise.
* testsuite/libgomp.fortran/map-subarray-6-usm.f90: Likewise.
* testsuite/libgomp.fortran/map-subarray-7-usm.f90: Likewise.
* testsuite/libgomp.fortran/target-allocatable-1-1-usm.f90:
Likewise.
* testsuite/libgomp.fortran/target-allocatable-1-2-usm.f90:
Likewise.
* testsuite/libgomp.fortran/target-enter-data-2-usm.F90: Likewise.
* testsuite/libgomp.fortran/target-present-1-usm.f90: Likewise.
* testsuite/libgomp.fortran/target-present-2-usm.f90: Likewise.
* testsuite/libgomp.fortran/target-present-3-usm.f90: Likewise.
* testsuite/libgomp.fortran/target-allocatable-1-1.f90: Adjust.
* testsuite/libgomp.fortran/target-allocatable-1-2.f90: Likewise.
* testsuite/libgomp.fortran/target-present-1.f90: Likewise.
* testsuite/libgomp.fortran/target-present-2.f90: Likewise.
* testsuite/libgomp.fortran/target-present-3.f90: Likewise.

2 months agodefaults: Use argument in default EH_RETURN_DATA_REGNO definition [PR123115]
Jakub Jelinek [Wed, 14 Jan 2026 14:56:29 +0000 (15:56 +0100)] 
defaults: Use argument in default EH_RETURN_DATA_REGNO definition [PR123115]

All targets use the EH_RETURN_DATA_REGNO macro argument except for
NVPTX which uses the default.
The problem is that we get then -Wunused-but-set-variable warning
when building df-scan.cc for NVPTX target with GCC 16 (post r16-2258
PR44677) on:
      unsigned int i;
      /* Mark the registers that will contain data for the handler.  */
      for (i = 0; ; ++i)
        {
          unsigned regno = EH_RETURN_DATA_REGNO (i);
          if (regno == INVALID_REGNUM)
            break;
If it were multiple targets suffering from this, I'd think about
adding something to use i in loops like this, but as it is
just the default definition, the following patch fixes it by
using the argument.

2026-01-14  Jakub Jelinek  <jakub@redhat.com>

PR middle-end/123115
* defaults.h (EH_RETURN_DATA_REGNO): Add void (N) to the macro
definition inside of a comma expression before INVALID_REGNUM.

2 months agocombine: Partially revert the r12-4475 changes [PR120250]
Jakub Jelinek [Wed, 14 Jan 2026 14:53:44 +0000 (15:53 +0100)] 
combine: Partially revert the r12-4475 changes [PR120250]

The r12-4475 change added extra code to recog_for_combine to attempt to
force some constants into the constant pool.
Unfortunately, as this (UB at runtime) testcase shows, such changes are
harmful for computed_jump_p jumps.  The computed_jump_p returns false
for loads from constant pool MEMs:
    case MEM:
      return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
                && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
and so if we try to optimize a computed jump that way, it becomes
a non-computed jump which doesn't match any other jump category
(simplejump_p, tablejump_p, condjump_p, returnjump_p, eh_returnjump_p,
asm goto) and doesn't have any label recorded in JUMP_LABEL (because,
it doesn't really jump to any LABEL), so some passes like dwarf2cfi
can get confused about it and ICE.

The following patch just prevents that, by only doing the r12-4475
changes if it is not a jump.

2026-01-14  Jakub Jelinek  <jakub@redhat.com>

PR target/120250
* combine.cc (recog_for_combine): Don't try to put SET_SRC
into a constant pool if SET_DEST is pc_rtx.

* gcc.c-torture/compile/pr120250.c: New test.

2 months agotree-optimization/123190 - fix costing of permuted contiguous loads
Richard Biener [Wed, 14 Jan 2026 11:45:19 +0000 (12:45 +0100)] 
tree-optimization/123190 - fix costing of permuted contiguous loads

The following fixes a regression from the time we split load groups
along SLP boundaries.  When we face a permuted load from an access
that is contiguous across loop iterations we emit code that loads
the whole group and then emit required permutations.  The permutations
might not need all those loads, and if we split the group we would
not have emitted them.  Fortunately when analyzing a permutation
we compute both the number of required permutes and the number of
loads that will survive the followin DCE.  So make sure to use that
when costing.  This allows the previously added testcase for PR123190
to undergo epilog vectorization also at -O2 plus when using non-generic
tuning, such as tuning for Zen4 which ups the cost for XMM loads.

PR tree-optimization/123190
* tree-vectorizer.h (vect_load_store_data): Add n_loads member.
* tree-vect-stmts.cc (get_load_store_type): Record the
number of required loads for permuted loads.
(vectorizable_load): Make use of this when costing loads
for VMAT_CONTIGUOUS[_REVERSE].

* gcc.dg/vect/costmodel/x86_64/costmodel-pr123190-1.c: Do not
require -mtune=generic.
* gcc.dg/vect/costmodel/x86_64/costmodel-pr123190-2.c: Add
variant with -O2 instead of -O3, inner loop not unrolled.

2 months agotree-optimization/123190 - allow VF == 1 epilog vectorization
Richard Biener [Wed, 14 Jan 2026 09:53:05 +0000 (10:53 +0100)] 
tree-optimization/123190 - allow VF == 1 epilog vectorization

The following adjusts the condition where we reject vectorization
because the scalar loop runs only for a single iteration (or two,
in case we need to peel for gaps).  Because this is over-eager
when considering the case of VF == 1 where instead the cost model
should decide wheter it is worthwhile or not.  I'm playing
conservative here and exclude the case of two iterations as I
do not have benchmark evidence.

This helps fixing a regression observed with improved SLP handling,
not exactly for the options used in the PR though, but for a more
common -O3 -march=x86-64-v3 this speeds up 433.milc by 6%.

PR tree-optimization/123190
* tree-vect-loop.cc (vect_analyze_loop_costing): Allow
vectorizing loops with a single scalar iteration iff the
vectorization factor is 1.

* gcc.dg/vect/costmodel/x86_64/costmodel-pr123190-1.c: New testcase.
* gcc.dg/vect/slp-28.c: Avoid epilogue vectorization for
simplicity.

2 months agosimplify-rtx: Fix up SUBREG and LSHIFTRT order canonicalization for AND with constant...
Jakub Jelinek [Wed, 14 Jan 2026 12:21:57 +0000 (13:21 +0100)] 
simplify-rtx: Fix up SUBREG and LSHIFTRT order canonicalization for AND with constant [PR123544]

On Tue, Nov 04, 2025 at 12:59:03PM +0530, Kishan Parmar wrote:
>       PR rtl-optimization/93738
>       * simplify-rtx.cc (simplify_binary_operation_1): Canonicalize
>       SUBREG(LSHIFTRT) into LSHIFTRT(SUBREG) when valid.

This change regressed the following testcase on aarch64-linux.
From what I can see, the PR93738 change has been written with non-paradoxical
SUBREGs in mind but on this testcase on aarch64 we have a paradoxical SUBREG,
in particular simplify_binary_operation_1 is called with AND, SImode,
(subreg:SI (lshiftrt:HI (subreg:HI (reg/v:SI 108 [ x ]) 0)
        (const_int 8 [0x8])) 0)
and op1 (const_int 32767 [0x7fff]) and simplifies that since the PR93738
optimization was added into
(and:SI (lshiftrt:SI (reg/v:SI 108 [ x ])
        (const_int 8 [0x8]))
    (const_int 32767 [0x7fff]))
This looks wrong to me.
Consider (reg/v:SI 108 [ x ]) 0) could have value 0x12345678U.
The original expression takes lowpart 16-bits from that, i.e. 0x5678U,
shifts that right logically by 8 bits, so 0x56U, makes a paradoxical SUBREG
from that, i.e. 0x????0056U and masks that with 0x7fff, i.e. result is 0x56U.
The new expression shifts 0x12345678U logically right by 8 bits, i.e. 0x123456U and
masks it by 0x7fff, result 0x3456U.

Thus, I think we need to limit to non-paradoxical SUBREGs.
On the rlwimi-2.c testcase I see on powerpc64le-linux no differences in
emitted assembly without/with the patch.

2026-01-14  Jakub Jelinek  <jakub@redhat.com>

PR rtl-optimization/123544
* simplify-rtx.cc (simplify_context::simplify_binary_operation_1)
<case AND>: Don't canonicalize (subreg (lshiftrt (x cnt)) low) into
(lshiftrt (subreg x low) cnt) if the SUBREG is paradoxical.

* gcc.dg/pr123544.c: New test.

2 months agolibstdc++: Add comment justifying separate proxy_random_access_iterator_wrapper.
Tomasz Kamiński [Wed, 14 Jan 2026 09:35:59 +0000 (10:35 +0100)] 
libstdc++: Add comment justifying separate proxy_random_access_iterator_wrapper.

It meets Cpp17RandomAccessIterator requirements, but does not satisfy
random_access_iterator concept.

libstdc++-v3/ChangeLog:

* testsuite/util/testsuite_iterators.h: Modify comment.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>
2 months agoEnable time profile function reordering with AutoFDO.
Prathamesh Kulkarni [Wed, 14 Jan 2026 09:41:03 +0000 (09:41 +0000)] 
Enable time profile function reordering with AutoFDO.

The patch enables time profile based reordering with AutoFDO with
-fauto-profile -fprofile-reorder-functions, by mapping timestamps obtained from perf
into node->tp_first_run.

The rationale for doing this is:
(1) GCC already implements time-profile function reordering with PGO, the patch enables
it with AutoFDO.
(2) While time profile ordering is primarly meant for optimizing startup time,
we've also observed good effects on code-locality for large internal workloads.
(3) Possibly useful for function reordering when accurate profile annotation is
hard with AutoFDO -- For eg, if branch samples are missing (due to absence of
LBR like structure).

On AutoFDO tools side, a corresponding patch extends gcov to emit 64-bit perf timestamp that
records first execution of function, which loosely corresponds to PGO's time_profile counter.
The timestamp is stored adjacent to head field in toplevel function info.

On GCC side, this patch makes the following changes:

(1) Changes to auto-profile pass:
The patch adds a new field timestamp to function_instance,
and populates it in read_function_instance.
It maintains a new timestamp_info_map from timestamp -> <name, tp_first_run>,
which maps timestamps sorted in ascending order to (1..N), so lowest ordered
timestamp is mapped to 1 and so on. The rationale for this is that
timestamps are 64-bit integers, and we don't need the full 64-bit range
for ordering by tp_first_run.

During annotation, the timestamp associated with function_instance is looked up
in timestamp_info_map, and corresponding mapped value is assigned
to node->tp_first_run.

Dhruv's sourcefile tracking patch already handles LTO privatized symbols.
The patch adds a workaround for mismatched/empty filenames, which should go away
when the issues with AutoFDO tools dwarf parsing are resolved.

(2) Param to disable profile driven opts.
The patch adds param auto-profile-reorder-only which only enables time-profile reordering with
AutoFDO:
(a) Useful as a debugging aid to isolate regression to either function reordering or profile driven opts.
(b) As a stopgap measure to avoid regressions with AutoFDO profile driven opts.
(c) Possibly useful for architectures which do not support branch sampling.

gcc/ChangeLog:
* auto-profile.cc: (string_table::filenames): New method.
(function_instance::timestamp_): New member.
(function_instance::timestamp): New accessor for timestamp_ member.
(function_instance::set_timestamp): New function.
(function_instance::prop_timestamp): Likewise.
(function_instance::prop_timestamp_1): Likewise.
(function_instance::function_instance): Initialize timestamp_ to 0.
(function_instance::read_function_instance): Adjust prototype by
replacing head_count with toplevel param with default value true, and
stream in head_count and timestamp values from gcov file.
(autofdo::timestamp_info_map): New std::map.
(autofdo_source_profile::get_function_instance_by_decl): New argument
filename with default value NULL.
(autofdo_source_profile::read): Populate timestamp_info_map and
propagate timestamp to inlined instances from toplevel function.
(afdo_annotate_cfg): Assign node->tp_first_run based on
timestamp_info_map and bail out of annotation if
param_auto_profile_reorder_only is enabled.
* params.opt: New param auto-profile-reorder-only.

Signed-off-by: Prathamesh Kulkarni <prathameshk@nvidia.com>
2 months agoMAINTAINERS: update Paolo Carlini email address
Jason Merrill [Wed, 14 Jan 2026 03:24:46 +0000 (11:24 +0800)] 
MAINTAINERS: update Paolo Carlini email address

Paolo is no longer at Oracle.

ChangeLog:

* MAINTAINERS: Update Paolo Carlini email address.

2 months agox86: Disable tight loop alignment for m_CORE_ATOM
Lili Cui [Wed, 14 Jan 2026 01:53:04 +0000 (09:53 +0800)] 
x86: Disable tight loop alignment for m_CORE_ATOM

For the E-core front end, aligning tight loops provides little benefit.

gcc/ChangeLog:

* config/i386/x86-tune.def (X86_TUNE_ALIGN_TIGHT_LOOPS):
disable tight loop alignment for m_CORE_ATOM.

2 months agoClarify function body mismatch
Nathan Sidwell [Thu, 18 Dec 2025 14:11:05 +0000 (09:11 -0500)] 
Clarify function body mismatch

Clearly label the expected and found function bodies.

gcc/testsuite/
* lib/scanasm.exp (check_function_body): Clarify mismatch labelling.

2 months agogcc/tree.h, match.pd: remove 'warn_strict_overflow' ref
Daniel Barboza [Mon, 12 Jan 2026 12:02:26 +0000 (04:02 -0800)] 
gcc/tree.h, match.pd: remove 'warn_strict_overflow' ref

During ML discussions of a match.pd pattern that was introducing a new
instance of 'warn_strict_overflow', Richard mentioned that this use
should be discouraged [1]. After pointing out that this usage was
documented in tree.h he then explained that we should remove the note
from the header [2]. Here's the reasoning:

"Ah, we should remove that note.  -Wstrict-overflow proved useless IMO,
it's way too noisy as it diagnoses when the compiler relies on overflow
not happening, not diagnosing when it possibly happens.  That's not a
very useful diagnostic to have - it does not point to a possible problem
in the code (we could as well diagnose _all_ signed arithmetic
operations for the same argument that we might eventually rely on
overflow not happening)."

Aside from removing the tree.h node we're also removing the 2 references
in match.pd. match.pd patterns tend to be copied around to serve as a
base for new patterns (like I did in [3] adding a
'fold_overflow_warning'), and if we want to discourage the use avoiding
its spread is a good start.

Note that there are a lot of references left, most of them in
gcc/fold-const.cc. Some references are using in nested helpers inside
the file, entangled with code that does other things. Removing all
references from the project is out of scope for this quick patch.

[1] https://gcc.gnu.org/pipermail/gcc-patches/2026-January/705320.html
[2] https://gcc.gnu.org/pipermail/gcc-patches/2026-January/705482.html
[3] https://gcc.gnu.org/pipermail/gcc-patches/2026-January/704992.html

gcc/ChangeLog:

* match.pd: remove 'fold_overflow_warning' references.
* tree.h (TYPE_OVERFLOW_UNDEFINED): remove note telling
that we must use warn_strict_overflow for every optimization
based on TYPE_OVERFLOW_UNDEFINED.

gcc/testsuite/ChangeLog:

* gcc.dg/Wstrict-overflow-1.c: Removed because we no longer
issue a 'fold_overflow_warning' with the
`(le (minus (@0 INTEGER_CST@1)) INTEGER_CST@2)` pattern.

Signed-off-by: Daniel Barboza <daniel.barboza@oss.qualcomm.com>
2 months agoMAINTAINERS: add myself to write after approval
Daniel Barboza [Wed, 14 Jan 2026 00:12:28 +0000 (21:12 -0300)] 
MAINTAINERS: add myself to write after approval

ChangeLog:

* MAINTAINERS: Add myself to write after approval.