[PR122215, IRA]: Fix undefined behaviour of improve_allocation

Register filters are used in one loop of improve_allocation to ignore some
hard regs for cost calculation but it is missed in the subsequent loop
using the costs.  This results in usage of random (undefined) register costs
and in sporadic code generation for riscv32 which uses the filters.

gcc/ChangeLog:

PR rtl-optimization/122215
* ira-color.cc (improve_allocation): Use register filter for all
loop on hard regs.

gcc/testsuite/ChangeLog:

PR rtl-optimization/122215
* gcc.target/riscv/pr122215.c: New.
* lib/target-supports.exp (check_effective_target_valgrind): New.

Fortran: associate to a contiguous pointer or target [PR122977]

PR fortran/122977

gcc/fortran/ChangeLog:

* expr.cc (gfc_is_simply_contiguous): For an associate variable
check whether the associate target is contiguous.
* resolve.cc (resolve_symbol): Skip array type check for an
associate variable when the target has the contiguous attribute.

gcc/testsuite/ChangeLog:

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

libstdc++: Implement rest of P2655R3 common_reference of reference_wrapper

PR libstdc++/120446

libstdc++-v3/ChangeLog:

* include/bits/refwrap.h (__detail::__is_ref_wrapper):
Define as per P2655R3 for C++20.
(__detail::__ref_wrap_common_reference_exists_with): Likewise.
(basic_common_reference): Define partial specializations using
the above as per P2655R3 for C++20.
* include/bits/version.def (common_reference_wrapper): New.
* include/bits/version.h: Regenerate.
* include/std/functional (__glibcxx_want_common_reference_wrapper):
Define.
* testsuite/20_util/reference_wrapper/p2655r3.cc: New test.

Co-authored-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++: Implement P2655R3 changes to common_reference bullet 1

We implement this paper as a DR against C++20 (as do MSVC and libc++).

PR libstdc++/120446

libstdc++-v3/ChangeLog:

* include/bits/version.def (common_reference): New.
* include/bits/version.h: Regenerate.
* include/std/type_traits (__glibcxx_want_common_reference):
Define.
(__common_reference_impl<T1, T2, 1>): Add pointer convertibility
constraints as per P2655R3.
* testsuite/20_util/common_reference/p2655r3.cc: New test.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++: Consolidate bullet 1 __common_reference_impl partial specs

... and in passing use requires-clauses instead of void_t based SFINAE.
This is a non-functional change that'll simplify implementing the
P2655R3 change to common_reference.

PR c++/120446

libstdc++-v3/ChangeLog:

* include/std/type_traits (__common_reference_impl): Rewrite
partial specializations to use requires-clause instead of
an additional void_t template parameter.  Consolidate the
partial specializations corresponding to bullet 1.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++/testsuite: Fix malformed dg-error directive

libstdc++-v3/ChangeLog:

* testsuite/20_util/function_objects/bind_front/111327.cc:
Add missing space before } ending a dg-error directive.

libstdc++: Use deducing this in range adaptors even in C++20 [PR111550]

Use deducing this to implement perfect forwarding even in C++20 mode
by using the _GLIBCXX_EXPLICIT_THIS_PARAMETER internal FTM instead of
the standard __cpp_explicit_this_parameter.  This fixes the original
testcase from this PR even in C++20 mode.

PR libstdc++/111550

libstdc++-v3/ChangeLog:

* include/std/ranges (views::__adaptor::_Partial::operator())
[_GLIBCXX_EXPLICIT_THIS_PARAMETER]: Also use deducing this
in C++20 mode when possible.
(views::__adaptor::_Pipe::Operator())
[_GLIBCXX_EXPLICIT_THIS_PARAMETER]: Likewise.
* testsuite/std/ranges/adaptors/take.cc (test07): New test.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++: Use deducing this in std::bind_front even in C++20 [PR111327]

PR libstdc++/111327

libstdc++-v3/ChangeLog:

* include/bits/binders.h (_Binder::operator())
[_GLIBCXX_EXPLICIT_THIS_PARAMETER]: Also use deducing this in
C++20 mode when possible.
* testsuite/20_util/function_objects/bind_front/111327.cc:
Expect error inside header even in C++20 mode.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++: Use deducing this in std::not_fn when available [PR111327]

Implement the perfect forwarding required by std::not_fn using deducing
this when available, instead of needing 8 operator() overloads.  This
also fixes Jiang An's test from this PR which would be messy to fix in
the old implementation.

PR libstdc++/111327

libstdc++-v3/ChangeLog:

* include/std/functional (_Not_fn::operator())
[_GLIBCXX_EXPLICIT_THIS_PARAMETER]: Define as a single
overload using deducing this.
* testsuite/20_util/function_objects/not_fn/111327.cc: Extend test.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++: Introduce _GLIBCXX_EXPLICIT_THIS_PARAMETER internal FTM

This FTM is like __cpp_explicit_this_parameter but is also defined
in earlier C++ modes if deducing this is supported as an extension
by the compiler.  Currently only GCC supports this, Clang doesn't.

libstdc++-v3/ChangeLog:

* include/bits/c++config (_GLIBCXX_EXPLICIT_THIS_PARAMETER):
New.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>

arm: avoid invalid shift in arm_canonicalize_comparison [PR122999]

There was UB in arm_canonicalize_comparison if it is called with
both operands of type VOIDmode.  Avoid this by first handling
floating-point types, then returning if we are left with anything
other than an integer mode.  For belt-and-braces also check that
the mode does not require a mask larger than HOST_WIDE_INT.

gcc/ChangeLog:

PR target/122999
* config/arm/arm.cc (arm_canonicalize_comparison): Defer
initializing maxval until we know we are dealing with an
integer mode.

gomp/dyn_groupprivate-1.f90: Fix scan-tree-dump-times regex

gcc/testsuite/ChangeLog:

* gfortran.dg/gomp/dyn_groupprivate-1.f90: Fix
scan-tree-dump-times regexp to avoid hard-coded 'D.4680'.

Fix vect_need_peeling_or_partial_vectors_p wrt peeling for gaps

The code assuming that peeling for gaps can be elided by means of
knowing niters and prologue peeling is wrong.  Peeling for gaps
means we need an epilog.

* tree-vect-loop.cc (vect_need_peeling_or_partial_vectors_p):
When peeling for gaps we always need an epilog.

tree-optimization/120939 - remove uninitialized use of LOOP_VINFO_COST_MODEL_THRESHOLD

The following removes an optimization that wrongly triggers right now
because it accesses LOOP_VINFO_COST_MODEL_THRESHOLD which might not be
computed yet and uses guessed likely max stmt executions.

It also refactors the code to make the default conservative.

PR tree-optimization/120939
* tree-vect-loop.cc (vect_need_peeling_or_partial_vectors_p):
Remove eliding an epilogue based on not computed
LOOP_VINFO_COST_MODEL_THRESHOLD and estimated max stmt executions.

* gcc.dg/torture/pr113026-1.c: Skip when -ftracer.

Make gcc.dg/vect/vect-pr123002.c trigger on unfixed trunk

The following avoids VRP to access the constant initializer.

PR tree-optimization/123002
* gcc.dg/vect/vect-pr123002.c: Make global data non-const
and non-static.

ada: Unsigned_Base_Range aspect (part 6)

Revert patch for Is_Modular_Integer_Type and Is_Signed_Integer_Type;
add new synthesized predicates Has_Modular_Operations and
Has_Overflow_Operations, and adjust the frontend sources
to rely on them.

gcc/ada/ChangeLog:

* einfo.ads (Has_Unsigned_Base_Range_Aspect): Update documentation.
(Has_Modular_Operations): New synthesized predicate.
(Has_Overflow_Operations): New synthesized predicate.
* einfo-utils.ads (Has_Modular_Operations): New function.
(Has_Overflow_Operations): New function.
* einfo-utils.adb (Is_Modular_Integer_Type): Undo previous patch.
(Is_Signed_Integer_Type): Undo previous patch.
(Has_Modular_Operations): New function.
(Has_Overflow_Operations): New function.
* checks.adb (Determine_Range): Replace selected occurrences of calls to
Is_Modular_Integer_Type by calls to Has_Modular_Operations, and calls to
Is_Signed_Integer_Type by calls to Has Overflow_Operations.
(Enable_Range_Check): Ditto.
(Insert_Valid_Check): Ditto.
* exp_aggr.adb (Others_Check): Ditto.
* exp_attr.adb (Expand_N_Attribute_Reference [Attribute_Pred,
Attribute_Succ]): Ditto.
* exp_ch4.adb (Expand_Compare_Minimize_Eliminate_Overflow): Ditto.
(Size_In_Storage_Elements): Ditto.
(Expand_N_Op_Abs): Ditto.
(Expand_N_Op_Expon): Ditto.
(Expand_N_Op_Minus): Ditto.
(Expand_N_Op_Multiply): Ditto.
(Expand_N_Op_Subtract): Ditto.
* freeze.adb (Freeze_Entity): Ditto.
* sem_aggr.adb (Report_Null_Array_Constraint_Error): Ditto plus
report specific error for index with unsigned_base_range aspect.
* sem_attr.adb (Check_Modular_Integer_Type): Ditto.
(Analyze_Attribute [Attribute_Pred, Attribute_Succ, Attribute_
Range_Length, Attribute_Small, Attribute_Reduce]): Ditto.
* sem_ch12.adb (Instantiate_Type): Ditto.
(Validate_Formal_Type_Default): Ditto.
* sem_ch13.adb (Valid_Empty): Ditto.
* sem_ch2.adb (Analyze_Integer_Literal): Ditto.
* sem_ch3.adb (Unsigned_Base_Range_Type_Declaration): Set attribute
Has_Unsigned_Base_Range_Aspect on the implicit base, and set Etype
of its first subtype E_Modular_Integer_Subtype.
* sem_ch4.adb (Analyze_Call): Ditto.
* sem_eval.adb (Check_Non_Static_Context_For_Overflow): Ditto.
(Eval_Arithmetic_Op): Ditto.
(Eval_Integer_Literal): Ditto.
(Eval_Logical_Op): Ditto.
(Eval_Op_Expon): Ditto.
(Eval_Op_Not): Ditto.
(Eval_Unary_Op): Ditto.
(Fold_Shift): Ditto.
(Test_Expression_Is_Foldable): Ditto.
* sem_intr.adb (Check_Shift): Ditto.
* sem_prag.adb (Analyze_Pragma [Pragma_Unsigned_Base_Range]): Add
assertion.
* sem_res.adb (Resolve_Logical_Op): Ditto.
(Resolve_Unary_Op): Ditto.
(Set_String_Literal_Subtype): Ditto.
* sem_type.adb (Covers): Ditto.
(Specific_Type): Ditto.
(Valid_Boolean_Arg): Ditto.
* sem_util.adb (Wrong_Type): Ditto
* style.adb (Check_Boolean_Operator): Ditto.

ada: Improve readability of table in reference manual

This patch changes a table in the reference manual so that the Ada code
inside is properly highlighted and uses the usual casing conventions.

gcc/ada/ChangeLog:

* doc/gnat_rm/representation_clauses_and_pragmas.rst: Improve table.
* gnat_rm.texi: Regenerate.
* gnat_ugn.texi: Regenerate.

ada: Fix false positive error for classwide containers

Get_Cursor_Type fails if a classwide container type
is passed to it as it cannot correctly identify the
cursor type since it is expecting the iteration functions
to have a container argument with a classwide container type.

gcc/ada/ChangeLog:

* sem_util.adb (Get_Cursor_Type): use the
specific type for classwide container checks.

ada: Fix problematic aggregate with box notation

It runs afoul of the pragma Initialize_Scalars + -gnatVa combination.

gcc/ada/ChangeLog:

* sem_ch12.adb (Remove_Parent): Only set the Is_Transient component
of the local scope stack entry.

ada: Adjust documentation on floating-point overflow handling

The description of the floating-point overflow behavior is already
documented in other sections: remove the duplication.
This removal also removes confusing/wrong informations

gcc/ada/ChangeLog:

* doc/gnat_ugn/building_executable_programs_with_gnat.rst
(-gnato??): Remove redundant/confusing doc on floating-point
overflow.
* gnat_ugn.texi: Regenerate.

ada: Ensure that file is not locked on windows when opened RO

gcc/ada/ChangeLog:

* adaint.c: use the _tsopen macro when opening RO file

ada: Fix reducer selection when resolving 'Reduce attribute

This patch ensures that, during the 'Reduce attribute resolution phase, the
selected reducer subprogram exists, is not ambiguous, and has the proper reducer
profile. Before we could have selected a wrong interpretation.

gcc/ada/ChangeLog:

* sem_attr.adb
(Analyze_Attribute): Set the type of the attribute expression only when
not ambiguous (it will later be resolved correctly). Emit an error in
case the type is limited.
(Resolve_Attribute): Emit an error if the reducer has no entity.
(Get_Value_Subtype): Try to resolve the Value_Subtype of the aggregate
expression, and if it succeeds, set the candidate reducer subprogram.
(Is_Reducer_Subprogram): Check whether the selected candidate has a
proper reducer profile.
(Make_Array_Type): Return simple array type to resolve the array
aggregate against it.
(Resolve_Attribute): Reimplement the resolution of Reduce attribute,
including its prefix.
* sem_res.adb (Resolve_Declare_Expression): Save and restore variables
that may be hidden by the local declaration. Only setting the new
entities is problematic when dealing with copied trees where the ref is
lost (eg. when resolving array aggregates).
* exp_attr.adb (Expand_N_Attribute_Reference): Remove tricks to resolve
the reducer in case of faulty resolution as not needed anymore.

gcc/testsuite/ChangeLog:

* gnat.dg/reduce1.adb: Adjust expected error message.

Move even/odd validity check from supportable_widening_operation to caller

The following moves the incomplete validity check to use
WIDEN_MULT_{EVEN,ODD} to the caller of supportable_widening_operation
where we have access to more (but not enough) information.  I have
made the test conservative enough I hope.  For the testcase what was
broken is that it uses a SLP reduction where lane-swizzling isn't
valid.

PR tree-optimization/123002
* tree-vectorizer.h (supportable_widening_operation): Remove
vinfo and stmt_info parameters, add flag to indicate whether
the context would allow OP_{EVEN,ODD}.
* tree-vect-patterns.cc (vect_recog_abd_pattern): Adjust
and pass false.
(vect_recog_widen_op_pattern): Likewise.
(vect_recog_widen_abd_pattern): Likewise.
* tree-vect-stmts.cc (vectorizable_conversion): Move
even/odd validity check here, from supportable_widening_operation.
Adjust it to be conservative.
(supportable_widening_operation): Get flag whether even/odd
is OK to use and remove then unused parameters and code.

* gcc.dg/vect/vect-pr123002.c: New testcase.

Add clique/base parsing and dumping to the GIMPLE FE

The following adds clique/base on __MEM to the GIMPLE parser and
to -gimple dumping.

gcc/c/
* gimple-parser.cc (c_parser_gimple_postfix_expression):
Parse optional clique : base specifier on __MEM.

gcc/
* tree-pretty-print.cc (dump_mem_ref): Dump clique : base
specifier for MEM_REF and TARGET_MEM_REF when dumping
GIMPLE format.

gcc/testsuite/
* gcc.dg/gimplefe-58.c: New testcase.

Ada, Darwin: Implement OSLock for Darwin [PR115305].

The generic Posix code does not match the layout of the pthread entities
in the Darwin _pthread_types.h.  So, let's make a Darwin-specific version
and use it.

PR ada/115305

gcc/ada/ChangeLog:

* Makefile.rtl: Use s-oslock__darwin instead of the Posix version.
* libgnat/s-oslock__darwin.ads: New file.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>

OpenMP: C/C++ parser support for dyn_groupprivate

Follow-up to the Fortran patch r16-5633-g26d41e245dbba3, which (besides
other changes) added parser support for the 'dyn_groupprivate' clause to
the target directive.
This commit adds now the parser support to C/C++ and moves the
not-yet-implemented 'sorry' to the early middle end.

gcc/c-family/ChangeLog:

* c-omp.cc (c_omp_split_clauses): Handle
OMP_CLAUSE_DYN_GROUPPRIVATE, sort target clauses
alphabetically.
* c-pragma.h (enum pragma_omp_clause): Add
PRAGMA_OMP_CLAUSE_DYN_GROUPPRIVATE.

gcc/c/ChangeLog:

* c-parser.cc (c_parser_omp_clause_dyn_groupprivate): New.
(OMP_TARGET_CLAUSE_MASK): Add PRAGMA_OMP_CLAUSE_DYN_GROUPPRIVATE;
sort clauses alphabetically.
(c_parser_omp_clause_name, c_parser_omp_all_clauses):
Handle 'dyn_groupprivate' clause.
* c-typeck.cc (c_finish_omp_clauses): Likewise.

gcc/cp/ChangeLog:

* pt.cc (tsubst_omp_clauses): Handle OMP_CLAUSE_DYN_GROUPPRIVATE.
* semantics.cc (finish_omp_clauses): Likewise.
* parser.cc (cp_parser_omp_clause_dyn_groupprivate): New.
(cp_parser_omp_clause_name, cp_parser_omp_all_clauses):
Handle 'dyn_groupprivate' clause.
(OMP_TARGET_CLAUSE_MASK): Add PRAGMA_OMP_CLAUSE_DYN_GROUPPRIVATE;
sort clauses alphabetically.

gcc/fortran/ChangeLog:

* openmp.cc (resolve_omp_clauses): Permit zero with
DYN_GROUPPRIVATE clause.
* trans-openmp.cc (fallback): Generate TREE code
for DYN_GROUPPRIVATE and remove 'sorry'.

gcc/ChangeLog:

* gimplify.cc (gimplify_scan_omp_clauses): Handle
OMP_CLAUSE_DYN_GROUPPRIVATE by printing 'sorry, unimplemented'.
* tree-core.h (enum omp_clause_code): Add OMP_CLAUSE_DYN_GROUPPRIVATE.
(enum omp_clause_fallback_kind): New.
(struct tree_omp_clause): Add fallback_kind union member.
* tree-nested.cc (convert_nonlocal_omp_clauses,
convert_local_omp_clauses): Handle OMP_CLAUSE_DYN_GROUPPRIVATE.
* tree.cc (omp_clause_num_ops, omp_clause_code_name): Add
OMP_CLAUSE_DYN_GROUPPRIVATE.
* tree-pretty-print.cc (dump_omp_clause): Handle
OMP_CLAUSE_DYN_GROUPPRIVATE.
* tree.h (OMP_CLAUSE_DYN_GROUPPRIVATE_EXPR,
OMP_CLAUSE_DYN_GROUPPRIVATE_KIND): New #define.

gcc/testsuite/ChangeLog:

* gfortran.dg/gomp/dyn_groupprivate-1.f90: Add scan-dump test.
* gfortran.dg/gomp/dyn_groupprivate-2.f90: Extend and update.
* c-c++-common/gomp/dyn_groupprivate-1.c: New test.
* c-c++-common/gomp/dyn_groupprivate-2.c: New test.

Make gcc.dg/vect/vect-simd-clone-24.c more robust

When -march=cascadelake is added we get 256bit vectorization by
default but there's no OMP SIMD ABI for this case with inbranch.
So add -mprefer-vector-width=512 to the testcase.

PR tree-optimization/122776
* gcc.dg/vect/vect-simd-clone-24.c: Add -mprefer-vector-width=512.

x86/aarch64: Fix compile time hog with ccmp [PR99782]

With ccmp, right now with TER, we hit an O(n^2) explosion in
compile time. This can be stopped by returning NULL early in
ix86_gen_ccmp_next before we expand the operands which will expand seperately
at that point.

A similar change aarch64's aarch64_gen_ccmp_next is done.

Changes since v1:
 * v2: Change how cmp_mode is assigned in ix86_gen_ccmp_next.
       Reworded commit message about aarch64.

Bootstrapped and tested on x86_64-linux-gnu and aarch64-linux-gnu.

PR middle-end/99782
gcc/ChangeLog:

* config/i386/i386-expand.cc (ix86_gen_ccmp_next): Move the check
for mode earlier before expand_operands.
* config/aarch64/aarch64.cc (aarch64_gen_ccmp_next): Likewise.

gcc/testsuite/ChangeLog:

* gcc.dg/torture/pr99782-1.c: New test.

Signed-off-by: Andrew Pinski <andrew.pinski@oss.qualcomm.com>

match.pd: x&c ?(x op c):(x|c) -> x^c [PR122615, PR122616]

Add a single pattern to reduce these patterns to "x ^ c":

x & c ? (x - c) | (x | c)
x & c ? (x & ~c) | (x | c)

As long as "c" has a single bit set.

        PR tree-optimization/122615
        PR tree-optimization/122616

gcc/ChangeLog:

* match.pd (`x & c ? (x - c) | (x | c)`): New pattern.
(`x & c ? (x & ~c) | (x | c)`): Likewise.

gcc/testsuite/ChangeLog:

* gcc.dg/torture/pr122615.c: New test.
* gcc.dg/torture/pr122616.c: Likewise.

Co-authored-by: Jeff Law <jlaw@ventanamicro.com>
Signed-off-by: Daniel Barboza <dbarboza@ventanamicro.com>

RISC-V: Add test for vec_duplicate + vmsltu.vv combine with GR2VR cost 0, 1 and 15

Add asm dump check and run test for vec_duplicate + vmsltu.vv
combine to vmsltu.vx, with the GR2VR cost is 0, 2 and 15.

gcc/testsuite/ChangeLog:

* gcc.target/riscv/rvv/autovec/vx_vf/vx-1-u16.c: Add asm check
for vmsltu.vx.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-1-u32.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-1-u64.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-1-u8.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-2-u16.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-2-u32.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-2-u64.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-2-u8.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-3-u16.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-3-u32.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-3-u64.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx-3-u8.c: Ditto.
* gcc.target/riscv/rvv/autovec/vx_vf/vx_binary.h: Add test
helper macros.
* gcc.target/riscv/rvv/autovec/vx_vf/vx_binary_data.h: Add test
data for run test.
* gcc.target/riscv/rvv/autovec/vx_vf/vx_vmsltu-run-1-u16.c: New test.
* gcc.target/riscv/rvv/autovec/vx_vf/vx_vmsltu-run-1-u32.c: New test.
* gcc.target/riscv/rvv/autovec/vx_vf/vx_vmsltu-run-1-u64.c: New test.
* gcc.target/riscv/rvv/autovec/vx_vf/vx_vmsltu-run-1-u8.c: New test.

Signed-off-by: Pan Li <pan2.li@intel.com>

RISC-V: Combine vec_duplicate + vmsltu.vv to vmsltu.vx on GR2VR cost

This patch would like to combine the vec_duplicate + vmsltu.wv to the
vmsltu.vx.  From example as below code.  The related pattern will depend
on the cost of vec_duplicate from GR2VR.  Then the late-combine will
take action if the cost of GR2VR is zero, and reject the combination
if the GR2VR cost is greater than zero.

Assume we have asm code like below, GR2VR cost is 0.

Before this patch:
  11       beq a3,zero,.L8
  12       vsetvli a5,zero,e32,m1,ta,ma
  13       vmv.v.x v2,a2
  ...
  16   .L3:
  17       vsetvli a5,a3,e32,m1,ta,ma
  ...
  22       vmsltu.wv v1,v2,v3
  ...
  25       bne a3,zero,.L3

After this patch:
  11       beq a3,zero,.L8
  ...
  14    .L3:
  15       vsetvli a5,a3,e32,m1,ta,ma
  ...
  20       vmsltu.wx v1,a2,v3
  ...
  23       bne a3,zero,.L3

gcc/ChangeLog:

* config/riscv/autovec-opt.md (*pred_cmp_swapped<mode>_scalar):
Add new pattern to match vec_dup > vec for vmsltu.
* config/riscv/predicates.md (comparison_swappable_operator):
Add new iterator for above pattern
* config/riscv/riscv-protos.h (expand_vx_cmp_vec_dup_vec): Add
new func to emit vmsltu.vx.
* config/riscv/riscv-v.cc (get_swapped_cmp_rtx_code): Add new
func to convert cmp code to swapped, like gtu to ltu.
(expand_vx_cmp_vec_dup_vec): Add new func decl.

Signed-off-by: Pan Li <pan2.li@intel.com>

Daily bump.

libstdc++: Fix std::erase_if behavior for std::__debug::deque

std::erase and std::erase_if are broken for users directly referencing
__gnu_debug::deque in their code that is to say without activating the
_GLIBCXX_DEBUG mode. The iterators potentially invalidated by the erase
operations are not detected by the __gnu_debug::deque container and so
won't be reported as invalidated.

We need explicit std::erase and std::erase_if implementations for
std::__debug::deque which will work also when _GLIBCXX_DEBUG mode is
activated.

libstdc++-v3/ChangeLog:

* include/debug/deque
(std::erase_if<>(std::__debug::deque<>&, _Pred)): New.
(std::erase<>(std::__debug::deque<>&, const _Up&)): New.
* include/std/deque (std::erase_if(std::deque<>&, _Pred)): Remove
_GLIBCXX_DEBUG code.
* testsuite/23_containers/deque/debug/erase.cc: New test case.
* testsuite/23_containers/deque/debug/invalidation/erase.cc: New test case.

aarch64: Fix crc{,_rev}<SWI124:mode>si4 expanders [PR122991]

The newly added gcc.dg/pr122991.c test fails also on aarch64.
The problem is the same as on x86 which has been fixed in r16-5882,
while the last operand is guaranteed to be a CONST_INT of the right
mode initially, maybe_legitimize_operands can change that if some earlier
operand has the same value and e.g. register_operand predicate has been
used, that operand is forced into a pseudo and maybe_legitimize_operands
then checks if that satisfies the predicate of the other operand.
As on x86 and aarch64 it didn't have any predicate, it happily used
a pseudo in those cases instead of the expected CONST_INT.

The following patch fixes that.

2025-12-04  Jakub Jelinek  <jakub@redhat.com>

PR target/122991
* config/aarch64/aarch64.md (crc_rev<ALLI:mode><ALLX:mode>4,
crc<ALLI:mode><ALLX:mode>4): Use const_int_operand predicate for
the last operand.

amdgcn, libgomp: improve generic device errors

Switching to use "generic" ISA variants has changed the error modes a bit.

This patch changes the runtime so that it doesn't say to use the
device-specific -march option when the real problem is not the ISA (it'll be a
mismatched xnack setting, probably).

Additionally, the testsuite effective target check needs to see if the xnack
mode is accepted by the runtime, as well as the compiler.

libgomp/ChangeLog:

* plugin/plugin-gcn.c (generic_isa_code): New function.
(isa_matches_agent): Use generic ISA details to help select an error
message on ISA mismatch.
* testsuite/lib/libgomp.exp
(check_effective_target_offload_target_amdgcn_with_xnack): Use a
runtime check.

libstdc++: Fix debug mode for unordered containers.

The r16-5845-g8a2e6590cc4a2f changed the _Safe_container copy-assignment
to delegate to assignment of the _Base. However, _Safe_unordered_container_base
was not updated, and due the presence of move constructor, it's assignments are
deleted, causing hard error for assignment of any unordered container.

libstdc++-v3/ChangeLog:

* include/debug/safe_unordered_base.h
(_Safe_unordered_container_base::operator=): Define as
defaulted, inherit behavior of _Safe_sequence_base.

Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

Select both inbranch and notinbranch clone during SIMD call analysis

The following recors both a possibly notinbranch and an inbranch
SIMD clone during analysis so that we can properly handle the
late decision on loop masking.  Recording of linear-clause data
from analysis is extended to cover linear-clause arguments from
both clones.

This also fixes AVX512 masked loop code generation in line with
the previous fixes.

PR tree-optimization/122776
* tree-vectorizer.h (vect_simd_clone_data::clone,
vect_simd_clone_data::clone_inbranch): New fields for
the two selected clones.
* tree-vect-stmts.cc (vectorizable_simd_clone_call): Record
both a possibly notinbranch and a inbranch clone.  Delay
the choice between both to code generation based on
LOOP_VINFO_FULLY_MASKED_P.

* gcc.dg/vect/vect-simd-clone-24.c: New testcase.
* gcc.dg/gomp/pr110485.c: Adjust.

vrp: Infer ranges from constant aggregates with initializers (v4)

This patch adds the ability to infer ranges from loads from global
constant static aggregates which have static initializers.  Even when
the load has one or more ARRAY_REFs with an unknown index and thus we
do not know the particular constant that is being loaded, we can
traverse the correponding elements of the initializer and see if we
know in what range(s) the loaed value must fall - or for pointers we
can sometimes infer that the value cannot be NULL.

I thought this was similar to fold_using_range::range_of_address and
so I decided to put my implementation alongside of it.

The differences from v3 posted in
https://inbox.sourceware.org/gcc-patches/ri6a50xjv39.fsf@virgil.suse.cz/
are:

  - The walking budget is not passed around recursively and
    decremented but is estimated from the size of the constant
    variable, which must not be bigger than param_vrp_cstload_limit
    times the size of the loaded type.

  - range_from_readonly_load uses a test for INTEGER_CST tree code to
    verify a tree is an integer constant and leaves all pointer checks
    to tree_single_nonzero_warnv_p.

  - In the testcases, all comparisons with number 666 were replaced
    with tighter bounds.

The one important change compared to v2 posted in
https://inbox.sourceware.org/gcc-patches/ri6fratkchf.fsf@virgil.suse.cz/T/#u
is:

- To get at the static constructor, the patch now uses
  ctor_for_folding instead of directly looking into DECL_INITIAL.  In
  LTO this loads the constructor on demand if necessary, and is also
  capable of looking through symbol aliases, which is necessary for
  example when the variable in question has been merged with another
  one by IPA-ICF.

The changes compared to v1 posted in
https://inbox.sourceware.org/gcc-patches/d1bb0175-0dee-481d-8078-12e74da58787@redhat.com/T/#m974fa6138bb074a239fb2a300e1d60bc087913ad
are:

- The limiting parameter limits the number of constructor leaf
  "elements" that we traverse.

- I have incorporated (hopefully) all suggestions from Richi, mainly
  assuming value zero if we do not encounter a corresponding part of a
  static initializer and using get_array_ctor_element_at_index to get
  at an element of an array with known constant index.  I tried to
  emulate how it is used in fold_array_ctor_reference, I hope I got it
  right.

- I have changed to code to only work for pranges and iranges for now.
  I will file a bug about extending it for frange and attach a patch
  to the code I'm now adding to handle frange.  But as I mentioned in
  an earlier email, something else will need to change too to get it
  working as expected.

- I have changed range_from_readonly_load to simply work true or false
  for pointers - where true means we can infer that it does not
  contain NULL and false means we cannot do anything.  For integers, I
  have changed it to instantiate int_range<1> rather than value_range
  to add another constant.

- I have introduced range_from_missing_constructor_part to handle the
  cases of missing bits in a constructor.

- I have put the (now simplified) functionality of
  add_loaded_invariant_to_range at the beginning of
  range_from_readonly_load.  That function remains recursive and walks
  the memory reference expression "backwards" for reasons explained in
  the previous email thread.

- The case where we need to iterate over all elements of an array was
  optimized for pointers, we first check if all elements are present and
  do not iterate if not.  For integers, we still need to iterate, of
  course.

- I have added testcases to cover situations with two-dimensional
  arrays.  Both when both indices are unknown and when only the second
  one is (in the C-sense).

gcc/ChangeLog:

2025-11-28  Martin Jambor  <mjambor@suse.cz>

* gimple-range-fold.h (class fold_using_range): New member
function range_from_readonly_var.
* gimple-range-fold.cc (fold_using_range::fold_stmt): Call
range_from_readonly_var on assignments.
(range_from_missing_constructor_part): New function.
(range_from_readonly_load): Likewise.
(fold_using_range::range_from_readonly_var): Likewise.
* params.opt (param_vrp_cstload_limit): New.
* doc/invoke.texi (vrp-cstload-limit): Likewise.

gcc/testsuite/ChangeLog:

2025-11-28  Martin Jambor  <mjambor@suse.cz>

* gcc.dg/tree-ssa/vrp-from-cst-agg-1.c: New test.
* gcc.dg/tree-ssa/vrp-from-cst-agg-2.c: Likewise.
* gcc.dg/tree-ssa/vrp-from-cst-agg-3.c: Likewise.
* gcc.dg/tree-ssa/vrp-from-cst-agg-4.c: Likewise.
* gcc.dg/tree-ssa/vrp-from-cst-agg-5.c: Likewise.
* gcc.dg/tree-ssa/vrp-from-cst-agg-6.c: Likewise.
* gcc.dg/tree-ssa/vrp-from-cst-agg-7.c: Likewise.
* gcc.dg/ipa/vrp-from-cst-agg-1.c: Likewise.

libstdc++: Convertibility of rank == 0 layouts, LWG4272.

LWG4272 proposes to add a condition for convertibility from
layout_stride::mapping to other mappings. New conversion requires
both that rank == 0 and that the extent types are convertible.

LWG4272 also proposes to add the same condition for conversion of
padded layouts, i.e. in addition to the condition on the padding
value, the extent types must be convertible.

libstdc++-v3/ChangeLog:

* include/std/mdspan (layout_left): Apply LWG4272.
(layout_right, layout_left_padded, layout_right_padded): Ditto.
* testsuite/23_containers/mdspan/layouts/ctors.cc: Add
test to check ctor uniformity at rank == 0. Update test
for new behavior.
* testsuite/23_containers/mdspan/layouts/padded.cc: Update test
for new behavior.

Co-authored-by: Tomasz Kamiński <tkaminsk@redhat.com>
Signed-off-by: Luc Grosheintz <luc.grosheintz@gmail.com>
Signed-off-by: Tomasz Kamiński <tkaminsk@redhat.com>

i386: Fix gcc.dg/asm-hard-reg-9.c

The testcase introduced in r16-5879-g55cc4377a31 was ment for 64-bit
only because it is referencing register r8.  Fixed by restricting it to
lp64.

gcc/testsuite/ChangeLog:

* gcc.dg/asm-hard-reg-9.c: Restrict to lp64 x86_64.

amdgcn, libgomp: use xfail for gfx908 requires tests

Use a different way to remove the "FAIL" cases for gfx908.  It really isn't
working with fall-back, as intended, so XFAIL is appropriate.

libgomp/ChangeLog:

* testsuite/libgomp.c-c++-common/requires-4.c: Change dg-excess-errors
to dg-xfail-if.
* testsuite/libgomp.c-c++-common/requires-4a.c: Likewise.
* testsuite/libgomp.c-c++-common/requires-5.c: Likewise.

libstdc++: Fix node-base containers copy and move constructor in debug mode.

The fixes regression from r16-5845-g8a2e6590cc4a2f that added an move
assignment operator to the _Safe_node_sequence, and made the class both
non move and copy constructible (copy is deleted, move is not declared).
In consequence debug version of node containers, that define they copy
and move as defaulted, and inherit from above, have deleted copy and moves.

libstdc++-v3/ChangeLog:

* include/debug/safe_sequence.h
(_Safe_node_sequence::_Safe_node_sequence): Define as defaulted.

i386: Fix crc_rev<SWI124:mode>si4 expander [PR122991]

The following testcase ICEs on x86_64, because the crc_rev_optab expander
assumes the last operand will be a CONST_INT.  That assumption comes from
it being created with
  rtx polynomial;
  if (TREE_CODE (rhs3) != INTEGER_CST)
    {
      error ("third argument to %<crc%> builtins must be a constant");
      polynomial = const0_rtx;
    }
  else
    polynomial = convert_to_mode (TYPE_MODE (result_type), expand_normal (rhs3), 0);
and so it doesn't bother adding a predicate for it.
Except that maybe_legitimize_operands which expand_insn calls has:
         This avoids duplicate rtl and ensures that tied operands
         remain tied.

         This search is linear, but NOPS is bounded at compile time
         to a small number (current a single digit).  */
      unsigned int j = 0;
      for (; j < i; ++j)
        if (can_reuse_operands_p (icode, opno + j, opno + i, &ops[j], &ops[i])
            && rtx_equal_p (orig_values[j], orig_values[i])
            && ops[j].value
            && insn_operand_matches (icode, opno + i, ops[j].value))
          {
            ops[i].value = copy_rtx (ops[j].value);
            break;
          }
in it, so if one of the earlier operands has equal original value to the
polynomial argument, but has a predicate like register_operand or
nonimmediate_operand, the earlier iteration forced that value into a pseudo
and when the last operand doesn't have a predicate, this happily reuses that
pseudo as the last operand.  And then it either with RTL checking fails on
INTVAL use on that operand, or without rtl checking ICEs during expansion of
the insn e.g. using table lookup.

The following patch fixes it by using const_int_operand predicate for it.
That is what loongarch and riscv backends use for it too.  Aarch64 doesn't
and I'll send a fix for that once tested on aarch64-linux.

2025-12-04  Jakub Jelinek  <jakub@redhat.com>

PR target/122991
* config/i386/i386.md (crc_rev<SWI124:mode>si4): Use const_int_operand
predicate for the last input argument.

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

testsuite: Add tls runtime directives to decomp18.C [PR122983]

I haven't added the needed dg- directives to decomp18.C test
which uses thread_local and is a dg-do run test.

This adds those.

2025-12-03  Jakub Jelinek  <jakub@redhat.com>

PR target/122983
* g++.dg/cpp26/decomp18.C: Add dg-add-options tls and
dg-require-effective-target tls_runtime directives.

contrib: Fix typo in function name in check_GNU_style_lib.py

contrib/ChangeLog:

* check_GNU_style_lib.py (TrailinigOperatorCheck): Rename to
TrailingOperatorCheck.

lra: Honor exclude start regs while reusing reloads

This fixes

asm-hard-reg-3.c:10:1: error: unrecognizable insn:
   10 | }
      | ^
(insn 9 18 14 2 (parallel [
            (set (reg:DI 0 ax [orig:99 x ] [99])
                (asm_operands:DI ("") ("=r") 0 [
                        (reg:SI 0 ax [100])
                        (reg:DI 1 dx [105]) repeated x2
                    ]
                     [
                        (asm_input:SI ("0") asm-hard-reg-3.c:8)
                        (asm_input:DI ("r") asm-hard-reg-3.c:8)
                        (asm_input:DI ("{r8}") asm-hard-reg-3.c:8)
                    ]
                     [] asm-hard-reg-3.c:8))
            (clobber (reg:CC 17 flags))
        ]) "asm-hard-reg-3.c":8:3 -1
     (nil))
during RTL pass: reload

During get_reload_reg() a reload register may be reused and so far
exclude start hard registers were not taken into account.  For the test
case this means operands 2 and 3 use the same reload register which gets
dx assigned, although, the constraint of operand 3 refers to register
r8.  That in turn renders the insn unsatisfiable.

A conservative approach would be to simply not reuse any reload register
whenever the set of exclude start hard regs is non-empty.  However, this
would lead to some missed optimizations like in this example where
operands 2 and 3 would land in different registers.  Therefore, if both
share a start hard register, still reuse the reload and refine the
exclude start hard regs set.

I only have a test case for inputs.  However, I expect an analogue
problem for outputs which is why I adapted that case, too.

gcc/ChangeLog:

* lra-constraints.cc (get_reload_reg): Honor exclude start regs
while reusing reloads.

gcc/testsuite/ChangeLog:

* gcc.dg/asm-hard-reg-9.c: New test.

Revert "[PATCH] [AutoFDO] Fix 'inlined' set in inline_functions_by_afdo"

This reverts commit 62736c5a062f8e698c8d8ac2d1b12adf0abb88fb.

Daily bump.

[PR85072, LRA]: Set a limit for considering other reload pseudo preferences

Compilation of test in PR85072 takes a lot of time and memory, e.g. 17
minutes and 23 GB memory on AMD 9900X.  The function in question has one million
program points and one million pseudos. The culprits are
live_reload_and_inheritance_pseudos bitmaps which are used to consider
other reload pseudo preferences when assigning a register to a given
pseudo.  The patch introduces a constraint regarding when those
preferences are considered.  The patch decreases compilation time to
about 10 minutes and memory consumption to about 2GB.

gcc/ChangeLog:

PR rtl-optimization/85072
* lra-assigns.cc (init_live_reload_and_inheritance_pseudos):
Improve calculation of live_reload_and_inheritance_pseudos and set
a constraint to do this.
* params.opt
(lra-max-pseudos-points-log2-considered-for-preferences): New.
* doc/invoke.texi
(lra-max-pseudos-points-log2-considered-for-preferences): Document
it.

libstdc++: Fix pretty printer lookup for class templates [PR122812]

Under some circumstances the type.name of a pair<> type starts with
"struct". This confuses GDB when we use gdb.lookup_type for the name of
template specialization using "struct pair<...>" in its template
argument list.

Using type.tag avoids this problem.

libstdc++-v3/ChangeLog:

PR libstdc++/122812
* python/libstdcxx/v6/printers.py (lookup_templ_spec): Use
gdb.Type.tag if present.

Fix miscompilation of gnatbind with profiled bootstrap

Boolean types may have precision > 1 so using !undefined_p && !varying_p is
not sufficient for them.

gcc/
PR tree-optimization/122934
* tree-ssa-loop-niter.cc (simplify_using_initial_conditions): Use
singleton_p predicate even with boolean ranges.

libgomp: Fix offload_target with additional sources

The offload_target_* effective target checks called libgomp_target_compile in a
way that altered global state if additional sources were configured.

This patch ignores additional sources if the compile check uses no sources (a
compiler probe, only), thus fixing the problem.

libgomp/ChangeLog:

* testsuite/lib/libgomp.exp (libgomp_target_compile): Don't use
additional sources if there are no primary sources.

testsuite: Escape \r in dg-regexp test names

When the regular expression matched in a test using dg-regexp contains
a newline (written in the source as \n inside ""), there is logic in
the testsuite to escape this so the test name after PASS: or FAIL: in
the testsuite output has \n instead of that newline.

When it contains a carriage return (from \r in the source), however,
there is no such escaping, and the test names in the .sum and .log
files thus contain a literal CR character in the middle of a test
name.  The process of combining test results from parallel-run parts
of each testsuite then turns that CR into end-of-line, losing the rest
of the test name (whereas if you use runtest directly, e.g. via
contrib/test_installed, the full test name remains in the .sum file
because there is no such postprocessing).  I suspect the handling of
newlines by Python (used for one of the scripts involved in combining
results) is responsible for test names getting truncated like this.
To avoid this truncation, escape CR like newlines are escaped.

Bootstrapped with no regressions for x86_64-pc-linux-gnu.

* lib/gcc-defs.exp (handle-dg-regexps): Also escape \r in output.

libstdc++: implement P3044R2 - sub-string_view from string (string part)

libstdc++-v3/ChangeLog:

* include/bits/basic_string.h: Add subview.
* include/bits/cow_string.h: Add subview.
* include/std/string: Add FTM.
* testsuite/21_strings/basic_string/operations/subview/char.cc: New test.
* testsuite/21_strings/basic_string/operations/subview/wchar_t.cc: New test.

libstdc++: implement P3044R2 - sub-string_view from string (string_view part)

libstdc++-v3/ChangeLog:

* include/bits/version.def: Add string_subview FTM.
* include/bits/version.h: Regenerate.
* include/std/string_view: Add subview.
* testsuite/21_strings/basic_string_view/operations/subview/char.cc: New test.
* testsuite/21_strings/basic_string_view/operations/subview/wchar_t.cc: New test.

switchconv: Fix up inbound checks for switch types wider than sizetype [PR122943]

In r14-8302 I've changed switchconv to narrow the CONSTRUCTOR indexes and
the runtime SSA_NAME indexing into the arrays to at most sizetype for
types wider than that (__int128, large _BitInt, for -m32 long long too).
The switchconv partitioning ensures that one partition isn't larger than
that and having CONSTRUCTOR with _BitInt(1024) indexes was causing all kinds
of problems.

Unfortunately, as the following testcase shows, while doing that is
desirable, the later gen_inbound_check call uses the lhs of m_arr_ref_first
statement to determine the type and value that should be compared for the
inbound check (against the highest possible bound cast to the lhs type).
So the PR113491 r14-8302 change broke those inbound checks, instead of
being done in unsigned type corresponding to the precision of the switch
expression they are now sometimes done using sizetype.  That is of course
wrong.

So the following patch fixes it by doing the tidx computation in steps,
one is the utype subtraction, which has m_arr_ref_first as the last
instruction, and then if needed there is a cast to sizetype if utype is
wider than that.  When gen_inbound_check is called, it adds the inbound
check after the m_arr_ref_first instruction and the additional cast is
then inside of the guarded block.

So e.g. in bar for -m32 this patch changes:
 unsigned char bar (long long int val)
 {
   unsigned char result;
-  sizetype _7;
+  sizetype _6;
+  long long unsigned int _7;

   <bb 2> :
-  _7 = (sizetype) val_3(D);
+  _7 = (long long unsigned int) val_3(D);
   if (_7 <= 2)
     goto <bb 4>; [INV]
   else
     goto <bb 3>; [INV]

   <bb 3> :
 <L7>:
-  result_5 = 1;
+  result_4 = 1;
   goto <bb 5>; [100.00%]

   <bb 4> :
 <L8>:
-  result_6 = CSWTCH.2[_7];
+  _6 = (sizetype) _7;
+  result_5 = CSWTCH.2[_6];

   <bb 5> :
-  # result_1 = PHI <result_6(4), result_5(3)>
+  # result_1 = PHI <result_5(4), result_4(3)>
 <L9>:
 <L6>:
   return result_1;

 }

2025-12-03  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/122943
* tree-switch-conversion.cc (switch_conversion::build_arrays):
Always gimplify subtraction in utype without cast to tidxtype
and set m_arr_ref_first to the last stmt of that.  Remove unneeded
update_stmt call.  If tidxtype is not utype, append after that stmt
cast to tidxtype and set tidx to the lhs of that cast.

* gcc.c-torture/execute/pr122943.c: New test.

Return true when a value_relation is added.

relation_oracle::record does not indicate whether a relation was added.
Add a boolean return and only update timestamps when a relation is actually
added.

PR tree-optimization/122898
gcc/
* gimple-range-fold.cc (fur_source::register_relation): Return a bool;
(fur_depend::register_relation): Ditto.
(fur_relation::register_relation): Ditto.
* gimple-range-fold.h (fur_source::register_relation): Adjust prototype.
(fur_depend::register_relation): Ditto.
* gimple-range-path.cc (jt_fur_source::register_relation): Return bool.
* value-relation.cc (equiv_oracle::add_partial_equiv): Return a bool.
(equiv_oracle::record): Return a bool.
(relation_oracle::record): Return a bool.
(dom_oracle::record): Return a bool.
(dom_oracle::set_one_relation): Remove some debug output.
(path_oracle::equiv_set): Return a bool.
(path_oracle::register_equiv): Return a bool.
(path_oracle::record): Return a bool.
* value-relation.h (relation_oracle::record): Adjust prototype.
(equiv_oracle::add_partial_equiv): Ditto
(equiv_oracle::record): Ditto.
(dom_oracle::record): Ditto.
(path_oracle::equiv_set): Ditto.
(path_oracle::register_equiv): Ditto.
(path_oracle::record): Ditto.

gcc/testsuite
* gcc.dg/pr122898.c: New.

a68: set LVERSION for Algol 68 and fix guard [PR algol68/122964]

This commits sets LVERSION for Algol 68 to 1978, which is the year of
the publication of the Revised Report that defines the revised
language.

It also fixes the guard so LANGUAGE, LNAME and LVERSION is only
emitted when generating DWARF5 or later.

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

PR algol68/122964
* dwarf2out.cc (gen_compile_unit_die): Set LVERSION to 1978 for
Algol 68 and add dwarf_version >= 5 to guard.

vect: fix ICE when duplicate dummy IV PHIs are still in CFG [PR122969]

All the no-options result in duplicate PHI nodes that use the same values just
have different RHS

>>> p debug (loop->header)

    <bb 21> [local count: 958878292]:
    # a.2_29 = PHI <0(18), _34(25)>
    # a_lsm.8_31 = PHI <0(18), _34(25)>
    _34 = a.2_29 + -1;
    if (_34 != 1)
      goto <bb 25>; [94.50%]
    else
      goto <bb 32>; [5.50%]

    $11 = void

>>> p debug (update_bb)

    <bb 33> [local count: 958878292]:
    # a.2_6 = PHI <a_lsm.8_36(32), _41(34)>
    # a_lsm.8_18 = PHI <a_lsm.8_36(32), _41(34)>
    _41 = a.2_6 + -1;
    if (_41 != 1)
      goto <bb 34>; [94.50%]
    else
      goto <bb 26>; [5.50%]

    $12 = void

So one of the PHIs is completely useless. But that makes the update loop visit
the PHI twice, but the first time we already updated them so we end up with a
non-SSA_NAME there.

In the old code we'd just re-update the PHI with the same statement. So I've put
back that code as fallback.  I'm almost 100% sure you can't get here with any
divergent PHI as an inviant has to be a variable before we rewrite it.  But as
I'm not 100% sure I've put the update fallback instead of skipping the update.

gcc/ChangeLog:

PR tree-optimization/122969
* tree-vect-loop-manip.cc (vect_update_ivs_after_vectorizer): handle
non-ssa name IV var args.

gcc/testsuite/ChangeLog:

PR tree-optimization/122969
* gcc.dg/vect/pr122969.c: New test.

Ada: Remove an old Makefile kludge

gcc/ada/
PR ada/122960
* gcc-interface/Makefile.in (powerpc64-suse-linux): Remove kludge.

i386: Generate 3-byte NOP for -mnop-mcount -m16

When generating 16-bit code via -m16, the NOP mcount code generation
emits a 5-byte NOP. However, that is neither a valid i8086 instruction
(long NOPs are PentiumPro+), nor would it get decoded as a 5-byte
instruction. It's a 4-byte 'nopw 0(%si)' followed by a zero byte. The
latter causes the following instruction to get misinterpreted as some
form of ADD.

Fix this by emiting a 3-byte no-op 'lea 0(%si)' instead which makes it
compatible with systems lacking long NOP support.

Add a test for this and change the existing one accordingly.

gcc/ChangeLog:

* config/i386/i386.cc (x86_print_call_or_nop): Fix 16-bit NOP
generation.

gcc/testsuite/ChangeLog:

* gcc.target/i386/nop-mcount-m16.c: New test.
* gcc.target/i386/nop-mcount.c: Adapt to test for 5-byte NOP.

Signed-off-by: Mathias Krause <minipli@grsecurity.net>

c++: fix typo

Thanks to Marek for pointing out my misspelling.

gcc/cp/ChangeLog:

* pt.cc (dependent_implict_conv_p): Rename to...
(dependent_implicit_conv_p): ...this.

gccrs: reindent rust-lex.cc

Reindent according to latest clang-format settings.

No functional change.

gcc/rust/ChangeLog:

* lex/rust-lex.cc (rust_input_source_test): Reindent.

Signed-off-by: Marc Poulhiès <dkm@kataplop.net>

gccrs: Add missing test for lang item feature gate

We recently modified all tests with lang items to add the lang feature
gate switch but we did not introduce any test to check that a proper
error message is printed when this switch is not used.

gcc/testsuite/ChangeLog:

* rust/compile/lang_feature_gate.rs: New test.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

gccrs: Improve feature handling

This fixes a false positive with undefined features, improves the
implementation of Feature::as_name, and configures the testsuite to
check further stages of libcore compilation.

gcc/rust/ChangeLog:

* ast/rust-macro.h (MetaNameValueStr::get_name): New function.
(MetaNameValueStr::get_value): Likewise.
* checks/errors/feature/rust-feature-gate.cc
(FeatureGate::visit): Tweak unknown feature detection.
(FeatureGate::gate): Handle field rename.
(FeatureGate::note_stability_attribute): New function
definition.
* checks/errors/feature/rust-feature-gate.h
(FeatureGate::note_stability_attribute): New function
declaration.
(FeatureGate::Stability): New enum class.
(FeatureGate::valid_features): Rename field to...
(FeatureGate::valid_lang_features): ...here.
(FeatureGate::valid_lib_features): New field.
(FeatureGate::defined_lib_features): Likewise.
* checks/errors/feature/rust-feature.cc (Feature::as_name):
Improve implementation.

gcc/testsuite/ChangeLog:

* rust/core/core.exp: Change -frust-compile-until=astvalidation
to -frust-compile-until=nameresolution.

Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>

gccrs: rust: Add `#![feature(lang_items)]` to tests.

gcc/testsuite/ChangeLog:

* rust/borrowck/reference.rs: Add attributes.
* rust/borrowck/tmp.rs: Likewise.
* rust/compile/additional-trait-bounds1.rs: Likewise.
* rust/compile/additional-trait-bounds2.rs: Likewise.
* rust/compile/additional-trait-bounds2nr2.rs: Likewise.
* rust/compile/auto_traits1.rs: Likewise.
* rust/compile/auto_traits2.rs: Likewise.
* rust/compile/bad-rpit1.rs: Likewise.
* rust/compile/black_box.rs: Likewise.
* rust/compile/bounds1.rs: Likewise.
* rust/compile/box_syntax_feature_gate.rs: Likewise.
* rust/compile/bug-with-default-generic.rs: Likewise.
* rust/compile/canonical_paths1.rs: Likewise.
* rust/compile/cast_generics.rs: Likewise.
* rust/compile/closure_no_type_anno.rs: Likewise.
* rust/compile/cmp1.rs: Likewise.
* rust/compile/complex_qualified_path_in_expr.rs: Likewise.
* rust/compile/const-issue1440.rs: Likewise.
* rust/compile/const_generics_1.rs: Likewise.
* rust/compile/const_generics_10.rs: Likewise.
* rust/compile/const_generics_11.rs: Likewise.
* rust/compile/const_generics_12.rs: Likewise.
* rust/compile/const_generics_13.rs: Likewise.
* rust/compile/const_generics_14.rs: Likewise.
* rust/compile/const_generics_15.rs: Likewise.
* rust/compile/const_generics_16.rs: Likewise.
* rust/compile/const_generics_18.rs: Likewise.
* rust/compile/const_generics_19.rs: Likewise.
* rust/compile/const_generics_3.rs: Likewise.
* rust/compile/const_generics_8.rs: Likewise.
* rust/compile/const_generics_9.rs: Likewise.
* rust/compile/derive-debug1.rs: Likewise.
* rust/compile/derive-default1.rs: Likewise.
* rust/compile/derive-eq-invalid.rs: Likewise.
* rust/compile/derive-hash1.rs: Likewise.
* rust/compile/derive-partialeq1.rs: Likewise.
* rust/compile/derive_clone_enum1.rs: Likewise.
* rust/compile/derive_clone_enum2.rs: Likewise.
* rust/compile/derive_clone_enum3.rs: Likewise.
* rust/compile/derive_macro1.rs: Likewise.
* rust/compile/derive_macro3.rs: Likewise.
* rust/compile/derive_macro4.rs: Likewise.
* rust/compile/derive_macro6.rs: Likewise.
* rust/compile/derive_partial_ord1.rs: Likewise.
* rust/compile/expand_macro_qual_path_in_type.rs: Likewise.
* rust/compile/expected_type_args2.rs: Likewise.
* rust/compile/expected_type_args3.rs: Likewise.
* rust/compile/extern_generics.rs: Likewise.
* rust/compile/for-loop1.rs: Likewise.
* rust/compile/for-loop2.rs: Likewise.
* rust/compile/format_args_basic_expansion.rs: Likewise.
* rust/compile/format_args_concat.rs: Likewise.
* rust/compile/format_args_extra_comma.rs: Likewise.
* rust/compile/generics1.rs: Likewise.
* rust/compile/generics11.rs: Likewise.
* rust/compile/generics12.rs: Likewise.
* rust/compile/generics2.rs: Likewise.
* rust/compile/generics3.rs: Likewise.
* rust/compile/generics4.rs: Likewise.
* rust/compile/generics6.rs: Likewise.
* rust/compile/generics7.rs: Likewise.
* rust/compile/generics8.rs: Likewise.
* rust/compile/if_let_expr.rs: Likewise.
* rust/compile/impl_fnptr.rs: Likewise.
* rust/compile/impl_trait_diag.rs: Likewise.
* rust/compile/impl_trait_generic_arg.rs: Likewise.
* rust/compile/issue-1005.rs: Likewise.
* rust/compile/issue-1019.rs: Likewise.
* rust/compile/issue-1031.rs: Likewise.
* rust/compile/issue-1034.rs: Likewise.
* rust/compile/issue-1128.rs: Likewise.
* rust/compile/issue-1129-2.rs: Likewise.
* rust/compile/issue-1130.rs: Likewise.
* rust/compile/issue-1131.rs: Likewise.
* rust/compile/issue-1165.rs: Likewise.
* rust/compile/issue-1173.rs: Likewise.
* rust/compile/issue-1235.rs: Likewise.
* rust/compile/issue-1237.rs: Likewise.
* rust/compile/issue-1289.rs: Likewise.
* rust/compile/issue-1383.rs: Likewise.
* rust/compile/issue-1447.rs: Likewise.
* rust/compile/issue-1483.rs: Likewise.
* rust/compile/issue-1485.rs: Likewise.
* rust/compile/issue-1487.rs: Likewise.
* rust/compile/issue-1589.rs: Likewise.
* rust/compile/issue-1725-1.rs: Likewise.
* rust/compile/issue-1725-2.rs: Likewise.
* rust/compile/issue-1786.rs: Likewise.
* rust/compile/issue-1893.rs: Likewise.
* rust/compile/issue-1901.rs: Likewise.
* rust/compile/issue-1930.rs: Likewise.
* rust/compile/issue-1981.rs: Likewise.
* rust/compile/issue-2015.rs: Likewise.
* rust/compile/issue-2019-1.rs: Likewise.
* rust/compile/issue-2019-2.rs: Likewise.
* rust/compile/issue-2019-3.rs: Likewise.
* rust/compile/issue-2036.rs: Likewise.
* rust/compile/issue-2037.rs: Likewise.
* rust/compile/issue-2070.rs: Likewise.
* rust/compile/issue-2105.rs: Likewise.
* rust/compile/issue-2106.rs: Likewise.
* rust/compile/issue-2135.rs: Likewise.
* rust/compile/issue-2136-1.rs: Likewise.
* rust/compile/issue-2136-2.rs: Likewise.
* rust/compile/issue-2139.rs: Likewise.
* rust/compile/issue-2142.rs: Likewise.
* rust/compile/issue-2165.rs: Likewise.
* rust/compile/issue-2166.rs: Likewise.
* rust/compile/issue-2190-1.rs: Likewise.
* rust/compile/issue-2190-2.rs: Likewise.
* rust/compile/issue-2195.rs: Likewise.
* rust/compile/issue-2238.rs: Likewise.
* rust/compile/issue-2304.rs: Likewise.
* rust/compile/issue-2323.rs: Likewise.
* rust/compile/issue-2330.rs: Likewise.
* rust/compile/issue-2369.rs: Likewise.
* rust/compile/issue-2375.rs: Likewise.
* rust/compile/issue-2478.rs: Likewise.
* rust/compile/issue-2499.rs: Likewise.
* rust/compile/issue-2723-1.rs: Likewise.
* rust/compile/issue-2723-2.rs: Likewise.
* rust/compile/issue-2725.rs: Likewise.
* rust/compile/issue-2747.rs: Likewise.
* rust/compile/issue-2772-1.rs: Likewise.
* rust/compile/issue-2772-2.rs: Likewise.
* rust/compile/issue-2775.rs: Likewise.
* rust/compile/issue-2782.rs: Likewise.
* rust/compile/issue-2907.rs: Likewise.
* rust/compile/issue-2951.rs: Likewise.
* rust/compile/issue-2953-1.rs: Likewise.
* rust/compile/issue-2953-2.rs: Likewise.
* rust/compile/issue-2954.rs: Likewise.
* rust/compile/issue-2987.rs: Likewise.
* rust/compile/issue-3009.rs: Likewise.
* rust/compile/issue-3022.rs: Likewise.
* rust/compile/issue-3030.rs: Likewise.
* rust/compile/issue-3032-1.rs: Likewise.
* rust/compile/issue-3032-2.rs: Likewise.
* rust/compile/issue-3033.rs: Likewise.
* rust/compile/issue-3035.rs: Likewise.
* rust/compile/issue-3036.rs: Likewise.
* rust/compile/issue-3045-1.rs: Likewise.
* rust/compile/issue-3045-2.rs: Likewise.
* rust/compile/issue-3144.rs: Likewise.
* rust/compile/issue-3242.rs: Likewise.
* rust/compile/issue-3304.rs: Likewise.
* rust/compile/issue-3382.rs: Likewise.
* rust/compile/issue-3402-1.rs: Likewise.
* rust/compile/issue-3402-2.rs: Likewise.
* rust/compile/issue-3403.rs: Likewise.
* rust/compile/issue-3454.rs: Likewise.
* rust/compile/issue-3551.rs: Likewise.
* rust/compile/issue-3554-2.rs: Likewise.
* rust/compile/issue-3599.rs: Likewise.
* rust/compile/issue-3642.rs: Likewise.
* rust/compile/issue-3711.rs: Likewise.
* rust/compile/issue-3836.rs: Likewise.
* rust/compile/issue-3898.rs: Likewise.
* rust/compile/issue-3915.rs: Likewise.
* rust/compile/issue-3916.rs: Likewise.
* rust/compile/issue-3969.rs: Likewise.
* rust/compile/issue-402.rs: Likewise.
* rust/compile/issue-4090-1.rs: Likewise.
* rust/compile/issue-4090-2.rs: Likewise.
* rust/compile/issue-850.rs: Likewise.
* rust/compile/issue-855.rs: Likewise.
* rust/compile/issue-925.rs: Likewise.
* rust/compile/iterators1.rs: Likewise.
* rust/compile/macros/builtin/option_env1.rs: Likewise.
* rust/compile/macros/builtin/option_env2.rs: Likewise.
* rust/compile/macros/builtin/option_env3.rs: Likewise.
* rust/compile/macros/mbe/macro-issue1400.rs: Likewise.
* rust/compile/macros/mbe/macro-issue3708.rs: Likewise.
* rust/compile/macros/mbe/macro-issue3709-2.rs: Likewise.
* rust/compile/macros/mbe/macro20.rs: Likewise.
* rust/compile/macros/mbe/macro23.rs: Likewise.
* rust/compile/macros/mbe/macro40.rs: Likewise.
* rust/compile/macros/mbe/macro49.rs: Likewise.
* rust/compile/macros/mbe/macro54.rs: Likewise.
* rust/compile/multiple_bindings1.rs: Likewise.
* rust/compile/name_resolution2.rs: Likewise.
* rust/compile/name_resolution4.rs: Likewise.
* rust/compile/nested_generic.rs: Likewise.
* rust/compile/parse_associated_type_as_generic_arg.rs: Likewise.
* rust/compile/parse_associated_type_as_generic_arg2.rs: Likewise.
* rust/compile/parse_associated_type_as_generic_arg3.rs: Likewise.
* rust/compile/parse_closure_bind.rs: Likewise.
* rust/compile/parse_complex_generic_application.rs: Likewise.
* rust/compile/parse_complex_generic_application2.rs: Likewise.
* rust/compile/path_as_generic_arg.rs: Likewise.
* rust/compile/privacy4.rs: Likewise.
* rust/compile/privacy6.rs: Likewise.
* rust/compile/silly-order-bug.rs: Likewise.
* rust/compile/sizeof-stray-infer-var-bug.rs: Likewise.
* rust/compile/stmt_with_block_dot.rs: Likewise.
* rust/compile/structural-eq-peq.rs: Likewise.
* rust/compile/torture/associated_types1.rs: Likewise.
* rust/compile/torture/forward_decl_5.rs: Likewise.
* rust/compile/torture/generics1.rs: Likewise.
* rust/compile/torture/generics10.rs: Likewise.
* rust/compile/torture/generics11.rs: Likewise.
* rust/compile/torture/generics12.rs: Likewise.
* rust/compile/torture/generics13.rs: Likewise.
* rust/compile/torture/generics14.rs: Likewise.
* rust/compile/torture/generics15.rs: Likewise.
* rust/compile/torture/generics16.rs: Likewise.
* rust/compile/torture/generics17.rs: Likewise.
* rust/compile/torture/generics18.rs: Likewise.
* rust/compile/torture/generics19.rs: Likewise.
* rust/compile/torture/generics2.rs: Likewise.
* rust/compile/torture/generics20.rs: Likewise.
* rust/compile/torture/generics21.rs: Likewise.
* rust/compile/torture/generics22.rs: Likewise.
* rust/compile/torture/generics23.rs: Likewise.
* rust/compile/torture/generics24.rs: Likewise.
* rust/compile/torture/generics25.rs: Likewise.
* rust/compile/torture/generics26.rs: Likewise.
* rust/compile/torture/generics27.rs: Likewise.
* rust/compile/torture/generics28.rs: Likewise.
* rust/compile/torture/generics29.rs: Likewise.
* rust/compile/torture/generics3.rs: Likewise.
* rust/compile/torture/generics30.rs: Likewise.
* rust/compile/torture/generics31.rs: Likewise.
* rust/compile/torture/generics32.rs: Likewise.
* rust/compile/torture/generics4.rs: Likewise.
* rust/compile/torture/generics5.rs: Likewise.
* rust/compile/torture/generics6.rs: Likewise.
* rust/compile/torture/generics7.rs: Likewise.
* rust/compile/torture/generics8.rs: Likewise.
* rust/compile/torture/generics9.rs: Likewise.
* rust/compile/torture/intrinsics-2.rs: Likewise.
* rust/compile/torture/intrinsics-4.rs: Likewise.
* rust/compile/torture/intrinsics-5.rs: Likewise.
* rust/compile/torture/intrinsics-6.rs: Likewise.
* rust/compile/torture/intrinsics-7.rs: Likewise.
* rust/compile/torture/intrinsics-8.rs: Likewise.
* rust/compile/torture/issue-1024.rs: Likewise.
* rust/compile/torture/issue-1075.rs: Likewise.
* rust/compile/torture/issue-1432.rs: Likewise.
* rust/compile/torture/issue-1555.rs: Likewise.
* rust/compile/torture/issue-368.rs: Likewise.
* rust/compile/torture/issue-808.rs: Likewise.
* rust/compile/torture/issue-862.rs: Likewise.
* rust/compile/torture/issue-893-2.rs: Likewise.
* rust/compile/torture/issue-893.rs: Likewise.
* rust/compile/torture/must_use2.rs: Likewise.
* rust/compile/torture/nested_fn2.rs: Likewise.
* rust/compile/torture/phantom_data.rs: Likewise.
* rust/compile/torture/range-lang-item1.rs: Likewise.
* rust/compile/torture/traits1.rs: Likewise.
* rust/compile/torture/traits10.rs: Likewise.
* rust/compile/torture/traits11.rs: Likewise.
* rust/compile/torture/traits12.rs: Likewise.
* rust/compile/torture/traits13.rs: Likewise.
* rust/compile/torture/traits14.rs: Likewise.
* rust/compile/torture/traits15.rs: Likewise.
* rust/compile/torture/traits16.rs: Likewise.
* rust/compile/torture/traits17.rs: Likewise.
* rust/compile/torture/traits18.rs: Likewise.
* rust/compile/torture/traits19.rs: Likewise.
* rust/compile/torture/traits2.rs: Likewise.
* rust/compile/torture/traits3.rs: Likewise.
* rust/compile/torture/traits4.rs: Likewise.
* rust/compile/torture/traits5.rs: Likewise.
* rust/compile/torture/traits6.rs: Likewise.
* rust/compile/torture/traits7.rs: Likewise.
* rust/compile/torture/traits8.rs: Likewise.
* rust/compile/torture/traits9.rs: Likewise.
* rust/compile/torture/transmute-size-check-1.rs: Likewise.
* rust/compile/torture/transmute1.rs: Likewise.
* rust/compile/torture/uninit-intrinsic-1.rs: Likewise.
* rust/compile/torture/utf8_identifiers.rs: Likewise.
* rust/compile/traits1.rs: Likewise.
* rust/compile/traits10.rs: Likewise.
* rust/compile/traits11.rs: Likewise.
* rust/compile/traits12.rs: Likewise.
* rust/compile/traits2.rs: Likewise.
* rust/compile/traits3.rs: Likewise.
* rust/compile/traits4.rs: Likewise.
* rust/compile/traits5.rs: Likewise.
* rust/compile/traits6.rs: Likewise.
* rust/compile/traits7.rs: Likewise.
* rust/compile/traits8.rs: Likewise.
* rust/compile/traits9.rs: Likewise.
* rust/compile/try-expr1.rs: Likewise.
* rust/compile/try-trait.rs: Likewise.
* rust/compile/try_block1.rs: Likewise.
* rust/compile/type-bindings1.rs: Likewise.
* rust/compile/unconstrained_type_param.rs: Likewise.
* rust/compile/unify-errors1.rs: Likewise.
* rust/compile/unsafe10.rs: Likewise.
* rust/compile/v0-mangle1.rs: Likewise.
* rust/compile/v0-mangle2.rs: Likewise.
* rust/compile/while_let1.rs: Likewise.
* rust/execute/black_box.rs: Likewise.
* rust/execute/torture/atomic_load.rs: Likewise.
* rust/execute/torture/atomic_store.rs: Likewise.
* rust/execute/torture/basic_partial_ord1.rs: Likewise.
* rust/execute/torture/basic_partial_ord2.rs: Likewise.
* rust/execute/torture/builtin_macro_option_env.rs: Likewise.
* rust/execute/torture/closure1.rs: Likewise.
* rust/execute/torture/closure2.rs: Likewise.
* rust/execute/torture/closure3.rs: Likewise.
* rust/execute/torture/closure4.rs: Likewise.
* rust/execute/torture/coercion1.rs: Likewise.
* rust/execute/torture/coercion2.rs: Likewise.
* rust/execute/torture/coercion3.rs: Likewise.
* rust/execute/torture/const-generics-1.rs: Likewise.
* rust/execute/torture/const-generics-2.rs: Likewise.
* rust/execute/torture/const-generics-3.rs: Likewise.
* rust/execute/torture/const-generics-4.rs: Likewise.
* rust/execute/torture/const-generics-5.rs: Likewise.
* rust/execute/torture/const-generics-6.rs: Likewise.
* rust/execute/torture/const-generics-7.rs: Likewise.
* rust/execute/torture/copy_nonoverlapping1.rs: Likewise.
* rust/execute/torture/derive-default1.rs: Likewise.
* rust/execute/torture/derive-partialeq1.rs: Likewise.
* rust/execute/torture/derive-partialeq2.rs: Likewise.
* rust/execute/torture/derive_clone_enum1.rs: Likewise.
* rust/execute/torture/derive_macro1.rs: Likewise.
* rust/execute/torture/derive_macro3.rs: Likewise.
* rust/execute/torture/derive_macro4.rs: Likewise.
* rust/execute/torture/enum_intrinsics1.rs: Likewise.
* rust/execute/torture/enum_intrinsics2.rs: Likewise.
* rust/execute/torture/for-loop1.rs: Likewise.
* rust/execute/torture/for-loop2.rs: Likewise.
* rust/execute/torture/gat1.rs: Likewise.
* rust/execute/torture/impl_desugar-2.rs: Likewise.
* rust/execute/torture/impl_desugar.rs: Likewise.
* rust/execute/torture/impl_rpit1.rs: Likewise.
* rust/execute/torture/impl_rpit2.rs: Likewise.
* rust/execute/torture/impl_rpit3.rs: Likewise.
* rust/execute/torture/impl_trait1.rs: Likewise.
* rust/execute/torture/impl_trait2.rs: Likewise.
* rust/execute/torture/impl_trait3.rs: Likewise.
* rust/execute/torture/impl_trait4.rs: Likewise.
* rust/execute/torture/index1.rs: Likewise.
* rust/execute/torture/issue-1120.rs: Likewise.
* rust/execute/torture/issue-1133.rs: Likewise.
* rust/execute/torture/issue-1198.rs: Likewise.
* rust/execute/torture/issue-1232.rs: Likewise.
* rust/execute/torture/issue-1249.rs: Likewise.
* rust/execute/torture/issue-1436.rs: Likewise.
* rust/execute/torture/issue-1481.rs: Likewise.
* rust/execute/torture/issue-1482.rs: Likewise.
* rust/execute/torture/issue-1496.rs: Likewise.
* rust/execute/torture/issue-1720-2.rs: Likewise.
* rust/execute/torture/issue-1720.rs: Likewise.
* rust/execute/torture/issue-2005.rs: Likewise.
* rust/execute/torture/issue-2052.rs: Likewise.
* rust/execute/torture/issue-2179.rs: Likewise.
* rust/execute/torture/issue-2180.rs: Likewise.
* rust/execute/torture/issue-2236.rs: Likewise.
* rust/execute/torture/issue-2583.rs: Likewise.
* rust/execute/torture/issue-3126.rs: Likewise.
* rust/execute/torture/issue-3381.rs: Likewise.
* rust/execute/torture/issue-3502.rs: Likewise.
* rust/execute/torture/issue-3836.rs: Likewise.
* rust/execute/torture/issue-647.rs: Likewise.
* rust/execute/torture/issue-845.rs: Likewise.
* rust/execute/torture/issue-851.rs: Likewise.
* rust/execute/torture/issue-858.rs: Likewise.
* rust/execute/torture/iter1.rs: Likewise.
* rust/execute/torture/macros23.rs: Likewise.
* rust/execute/torture/macros28.rs: Likewise.
* rust/execute/torture/method2.rs: Likewise.
* rust/execute/torture/method3.rs: Likewise.
* rust/execute/torture/method4.rs: Likewise.
* rust/execute/torture/min_specialization2.rs: Likewise.
* rust/execute/torture/min_specialization3.rs: Likewise.
* rust/execute/torture/operator_overload_1.rs: Likewise.
* rust/execute/torture/operator_overload_10.rs: Likewise.
* rust/execute/torture/operator_overload_11.rs: Likewise.
* rust/execute/torture/operator_overload_12.rs: Likewise.
* rust/execute/torture/operator_overload_2.rs: Likewise.
* rust/execute/torture/operator_overload_3.rs: Likewise.
* rust/execute/torture/operator_overload_4.rs: Likewise.
* rust/execute/torture/operator_overload_5.rs: Likewise.
* rust/execute/torture/operator_overload_6.rs: Likewise.
* rust/execute/torture/operator_overload_7.rs: Likewise.
* rust/execute/torture/operator_overload_8.rs: Likewise.
* rust/execute/torture/operator_overload_9.rs: Likewise.
* rust/execute/torture/partial-eq-1.rs: Likewise.
* rust/execute/torture/partial-eq-2.rs: Likewise.
* rust/execute/torture/partial-eq-3.rs: Likewise.
* rust/execute/torture/partial-eq-4.rs: Likewise.
* rust/execute/torture/partial-ord-1.rs: Likewise.
* rust/execute/torture/partial-ord-2.rs: Likewise.
* rust/execute/torture/partial-ord-3.rs: Likewise.
* rust/execute/torture/partial-ord-4.rs: Likewise.
* rust/execute/torture/partial-ord-5.rs: Likewise.
* rust/execute/torture/partial-ord-6.rs: Likewise.
* rust/execute/torture/prefetch_data.rs: Likewise.
* rust/execute/torture/ref-pattern2.rs: Likewise.
* rust/execute/torture/sip-hasher.rs: Likewise.
* rust/execute/torture/slice-magic.rs: Likewise.
* rust/execute/torture/slice-magic2.rs: Likewise.
* rust/execute/torture/slice1.rs: Likewise.
* rust/execute/torture/str-layout1.rs: Likewise.
* rust/execute/torture/trait1.rs: Likewise.
* rust/execute/torture/trait10.rs: Likewise.
* rust/execute/torture/trait11.rs: Likewise.
* rust/execute/torture/trait12.rs: Likewise.
* rust/execute/torture/trait13.rs: Likewise.
* rust/execute/torture/trait14.rs: Likewise.
* rust/execute/torture/trait15.rs: Likewise.
* rust/execute/torture/trait2.rs: Likewise.
* rust/execute/torture/trait3.rs: Likewise.
* rust/execute/torture/trait4.rs: Likewise.
* rust/execute/torture/trait5.rs: Likewise.
* rust/execute/torture/trait6.rs: Likewise.
* rust/execute/torture/trait7.rs: Likewise.
* rust/execute/torture/trait8.rs: Likewise.
* rust/execute/torture/trait9.rs: Likewise.
* rust/execute/torture/transmute1.rs: Likewise.
* rust/execute/torture/wrapping_op1.rs: Likewise.
* rust/execute/torture/wrapping_op2.rs: Likewise.
* rust/link/generic_function_1.rs: Likewise.
* rust/link/trait_import_1.rs: Likewise.

Signed-off-by: Raiki Tamura <tamaron1203@gmail.com>

gccrs: rust: add feature gate for lang_items.

gcc/rust/ChangeLog:

* checks/errors/feature/rust-feature-gate.cc (FeatureGate::visit): Add check for lang_items.
* checks/errors/feature/rust-feature-gate.h: Likewise.

Signed-off-by: Raiki Tamura <tamaron1203@gmail.com>

gccrs: Remove non leaf errors

gcc/rust/ChangeLog:

* parse/rust-parse-impl.h (Parser::parse_function): Return a nullptr on
error instead of a valid function.
(Parser::parse_let_stmt): Remove non leaf error.
(Parser::parse_if_expr): Likewise.
(Parser::parse_loop_expr): Likewise.
(Parser::parse_expr): Return error on null denotation error.

gcc/testsuite/ChangeLog:

* rust/compile/braced_macro_arm.rs: Remove parent errors.
* rust/compile/issue-407-2.rs: Likewise.
* rust/compile/issue-407.rs: Likewise.
* rust/compile/issue-4162.rs: Likewise.
* rust/compile/issue-867.rs: Likewise.
* rust/compile/raw_ref_op_invalid.rs: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

gccrs: Remove non-leaf error message in delimited tt

gcc/rust/ChangeLog:

* parse/rust-parse-impl.h (Parser::parse_delim_token_tree):
Remove error message.
(Parser::parse_token_tree): Split error message.

gcc/testsuite/ChangeLog:

* rust/compile/macros/mbe/macro-issue3608.rs: Remove error.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

gccrs: Initialize uninit boolean

Fixes #122886

gcc/rust/ChangeLog:

* backend/rust-constexpr.cc (eval_binary_expression): Set initial value
equality value to false.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

gccrs: Fix comment typos in rust-macro-expand.h

gcc/rust/ChangeLog:

* expand/rust-macro-expand.h: Fix typos in comment.

gccrs: Remove non-leaf item in crate parsing failure error

gcc/rust/ChangeLog:

* parse/rust-parse-impl.h (Parser::parse_items): Remove item parsing
error.

gcc/testsuite/ChangeLog:

* rust/compile/braced_macro_arm.rs: Remove superfluous error message
matching.
* rust/compile/decl_macro6.rs: Likewise.
* rust/compile/decl_macro7.rs: Likewise.
* rust/compile/extern_type_item_missing_semi.rs: Likewise.
* rust/compile/issue-2187.rs: Likewise.
* rust/compile/issue-407-2.rs: Likewise.
* rust/compile/issue-407.rs: Likewise.
* rust/compile/issue-4162.rs: Likewise.
* rust/compile/issue-867.rs: Likewise.
* rust/compile/macros/mbe/macro-issue1053-2.rs: Likewise.
* rust/compile/macros/mbe/macro-issue1395-2.rs: Likewise.
* rust/compile/macros/mbe/macro-issue3608.rs: Likewise.
* rust/compile/macros/mbe/macro27.rs: Likewise.
* rust/compile/macros/mbe/macro28.rs: Likewise.
* rust/compile/macros/mbe/macro29.rs: Likewise.
* rust/compile/macros/mbe/macro30.rs: Likewise.
* rust/compile/macros/mbe/macro31.rs: Likewise.
* rust/compile/macros/mbe/macro33.rs: Likewise.
* rust/compile/macros/mbe/macro35.rs: Likewise.
* rust/compile/macros/mbe/macro37.rs: Likewise.
* rust/compile/macros/mbe/macro38.rs: Likewise.
* rust/compile/macros/mbe/macro39.rs: Likewise.
* rust/compile/macros/mbe/macro48.rs: Likewise.
* rust/compile/parse_invalid_specialization.rs: Likewise.
* rust/compile/parse_simple_path_fail_1.rs: Likewise.
* rust/compile/parse_simple_path_fail_2.rs: Likewise.
* rust/compile/raw-string-loc.rs: Likewise.
* rust/compile/raw-byte-string-loc.rs: Likewise.
* rust/compile/self_const_ptr.rs: Likewise.
* rust/compile/self_mut_ptr.rs: Likewise.
* rust/compile/static_var1.rs: Likewise.
* rust/compile/self_ptr.rs: Likewise.
* rust/compile/torture/identifier-missing-impl-1.rs: Likewise.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

gccrs: Add derived set to collect derived nodes.

gcc/rust/ChangeLog:

* expand/rust-expand-visitor.cc (builtin_derive_item): Collect derived nodes.
(derive_item): Collect derived nodes.
* util/rust-hir-map.cc (Mappings::add_derived_nodes): Add derived set to collect derived
nodes.
(Mappings::is_derived_node): Add derived set to collect derived nodes.
* util/rust-hir-map.h: Add derived set to collect derived nodes.

Signed-off-by: Ryutaro Okada <1015ryu88@gmail.com>

a68: small C++ improvements [PR algol68/122954]

This patch turns superfluous typedefs into struct forward-references,
and gets rid of a few unused macros.  It also moves some definitions
from the a68-types.h header to a68-parser-scope.

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

PR algol68/122954
* a68-types.h (NO_A68_REF): Delete.
(NO_ARRAY): Likewise.
(NO_BOOK): Likewise.
(NO_BOOL): Likewise.
(NO_BYTE): Likewise.
(NO_CONSTANT): Likewise.
(NO_DEC): Likewise.
(NO_EDLIN): Likewise.
(NO_FILE): Likewise.
(NO_FORMAT): Likewise.
(NO_GPROC): Likewise.
(NO_HANDLE): Likewise.
(NO_INT): Likewise.
(NO_JMP_BUF): Likewise.
(NO_SCOPE): Moved to a68-parser-scope.cc.
(NO_TUPLE): Likewise.
(TUPLE): Likewise.
(NO_GINFO): Converted from macro to contexpr.
(NO_KEYWORD): Likewise.
(NO_NINFO): Likewise.
(NO_PACK): Likewise.
(NO_SOID): Likewise.
(NO_TOKEN): Likewise.
(NO_NOTE): Likewise.
(MODES_T): Turned from typedef to forward declaration.
(NODE_T): Likewise.
(MODE_CACHE_T): Likewise.
(MOID_T): Likewise.
(GINFO_T): Likewise.
(KEYWORD_T): Likewise.
(LINE_T): Likewise.
(NODE_INFO_T): Likewise.
(PACK_T): Likewise.
(SOID_T): Likewise.
(TABLE_T): Likewise.
(TAG_T): Likewise.
(TOKEN_T): Likewise.
(ORIGIN_T): Likewise.
(POSTULATE_T): Likewise.
(OPTIONS_T): Likewise.
(PARSER_T): Likewise.
(MODULE_T): Likewise.
(EXTRACT_T): Likewise.
(MOIF_T): Likewise.
(A68_T): Likewise.
* a68-parser-scope.cc (NO_TUPLE): Moved from a68-types.h
(NO_SCOPE): Likewise.
(TUPLE): Likewise.

a68: remove self-assign in a68_lower_collateral_clause [PR algol68/122966]

This commit removes a spurious self-assignment that was preventing
building with clang.

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

PR algol68/122966
* a68-low-clauses.cc (a68_lower_collateral_clause): Remove
self-assignment.

vect: delay identification of update_e until after skip_epilog [PR122959]

The testcase attached in the PR shows that for some reason
the test openmp_vv.sum when doing OpenMP offloading creates
an intermediate empty block after the skip_epilog split.

This means we should just simply delay setting update_e for
the non-early break case.  For early break we have to do it
early still otherwise the skip_epilog edge would make us find
the wrong edge.

I haven't been able to replicate this on a C testcase and the
attached reduction works fine on AArch64 and x86_64 but have
been able to verify the fixed code with

./gcc/f951 -fopenmp test2.f90 -O3 -o - -march=sm_30 on an

 --target=nvptx-none --enable-as-accelerator-for=x86_64-pc-linux-gnu

configured cc1.

If I manage to create a testcase will push it too.

gcc/ChangeLog:

PR middle-end/122959
* tree-vect-loop-manip.cc (vect_do_peeling): Delay setting update_e.

Fortran: Implement finalization PDTs [PR103371]

2025-12-03  Paul Thomas  <pault@gcc.gnu.org>

gcc/fortran
PR fortran/103371
* decl.cc (gfc_get_pdt_instance): Remove the requirement that
PDT components be of the same type as the enclosing type. Apply
initializers other than the default to PDT components.
* primary.cc (gfc_match_rvalue): Make combination of the two
actual_arglists conditional on 'type_spec_list' having been
seen as well together with applying component names to all the
arguments.
* trans-decl.cc (gfc_init_default_dt): Add 'pdt_ok' to the args
and use it to signal that a PDT can be default initialized.
(gfc_init_default_pdt): New function to check that a pdt is OK
for default intialization before calling gfc_init_default_dt.
(gfc_trans_deferred_vars): Use gfc_init_default_pdt.
* trans.h: Add bool 'pdt_ok' to prototype with defaul value of
false.

gcc/testsuite
PR fortran/103371
* gfortran.dg/pdt_71.f03: New test.

cobol: Fix up help.exp failures

I'm seeing a new failure
FAIL: compiler driver --help=warnings option(s): "^ +-.*[^:.]\$" absent from output: "  -Wapply-commit              Warn if APPLY COMMIT is used "
after the last cobol/lang.opt changes.
The
make check-gcc RUNTESTFLAGS=help.exp
test verifies among other things that all the option descriptions
(which aren't omitted) are terminated with dot, so that they are consistent.
Seems most of the COBOL option descriptions violate this.

2025-12-03  Jakub Jelinek  <jakub@redhat.com>

* lang.opt: Make sure all option descriptions are terminated with
a dot.
(preprocess): Capitalize first letter of option description.

Transform std::max(t, float(0)) into vmaxps w/o fast-math.

The pattern is simplied to below since there's const0_operand

(set (reg:V8SF 124)
    (and:V8SF (not:V8SF (lt:V8SF (reg:V8SF 123 [ MEM <const vector(8) float> [(const float *)input_12(D) + ivtmp.30_4 * 1] ])
                (const_vector:V8SF [
                        (const_double:SF 0.0 [0x0.0p+0]) repeated x8
                    ])))
        (reg:V8SF 123 [ MEM <const vector(8) float> [(const float *)input_12(D) + ivtmp.30_4 * 1] ]))

Add new combine pattern to match it.

Also extend related avx512 pattern to accept immediate_operand, so
that the optimization is also available under AVX512.

The codegen is now better than before, however, vpxor is not hoisted
outside of the loop after it's created in split1.

gcc/ChangeLog:

PR target/71921
* config/i386/predicates.md (ieee_maxmin_comparison_operator):
New predicator.
* config/i386/sse.md (*minmax<mode>3_3): New define_insn_and_split.
(*minmax<mode>3_4): Ditto.
(*minmax<mode>3_1): Extend operands[2]/operands[4] to handle
immediate_operand.

gcc/testsuite/ChangeLog:

* g++.target/i386/avx512-pr71921.C: New test.
* g++.target/i386/pr71921.C: New test.

libstdc++: [_GLIBCXX_DEBUG] Implement std::__debug::inplace_vector

Add _GLIBCXX_DEBUG std::inplace_vector implementation.

libstdc++-v3/ChangeLog:

* include/Makefile.am (debug_headers): Add inplace_vector.
* include/Makefile.in: Regenerate.
* include/debug/functions.h (__check_valid_range): Add C++20 constexpr.
* include/debug/helper_functions.h (__valid_range): Likewise.
* include/debug/inplace_vector: New.
* include/debug/safe_base.h (~_Safe_sequence_base()): Add C++11 noexcept.
(_Safe_sequence_base::operator=(const _Safe_sequence_base&)): New.
(_Safe_sequence_base::operator=(_Safe_sequence_base&&)): New.
(_Safe_sequence_base::_M_invalidate_all): Add C++20 constexpr.
* include/debug/safe_container.h
(_Safe_container<>::operator=(const _Safe_container<>&)): Implement using
_Safe_sequence_base same operator.
* include/debug/safe_iterator.h (__valid_range): Add C++20 constexpr.
* include/debug/safe_sequence.h
(_Not_equal_to(const _Type&)): Add C++20 constexpr.
(_Equal_to(const _Type&)): Add C++20 constexpr.
(_After_nth_from(const difference_type&, const _Iterator&)): Add C++20 constexpr.
(_Safe_sequence<>::_M_invalidate_if): Add C++20 constexpr.
(_Safe_node_sequence::operator=(const _Safe_node_sequence&)): New.
(_Safe_node_sequence::operator=(_Safe_node_sequence&&)): New.
(_Safe_node_sequence<>::_M_invalidate_all()): Add C++20 constexpr.
* include/debug/safe_sequence.tcc
(_Safe_sequence<>::_M_invalidate_if): Add C++20 constexpr.
* include/std/inplace_vector [_GLIBCXX_DEBUG](std::inplace_vector<>): Move
implementation into __cxx1998 namespace.
(erase, erase_if): Limit to non-debug inplace_vector<>, cleanup code.
[_GLIBCXX_DEBUG]: Add include <debug/inplace_vector>.
* testsuite/23_containers/inplace_vector/cons/1.cc: Adapt, skip several
is_trivially_xxx checks when in _GLIBCXX_DEBUG mode.
* testsuite/23_containers/inplace_vector/copy.cc: Likewise.
* testsuite/23_containers/inplace_vector/move.cc: Likewise.
* testsuite/23_containers/inplace_vector/debug/assign1_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/assign2_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/assign3_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/assign4_backtrace_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/assign4_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/construct1_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/construct2_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/construct3_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/construct4_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/debug_functions.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/erase.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/insert1_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/insert2_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/insert3_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/insert4_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/insert5_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/insert7_neg.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/1.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/2.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/3.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/4.cc: New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/append_range.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/erase.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/pop_back.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/push_back.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/swap.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/try_append_range.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/try_emplace_back.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/try_push_back.cc:
New test case.
* testsuite/23_containers/inplace_vector/debug/invalidation/unchecked_emplace_back.cc:
New test case.
* testsuite/util/debug/checks.h: Avoid using _GLIBCXX_DEBUG containers in test
implementations.

Daily bump.

hppa: Break out large REG+D addresses from MEM operands

Fixes unrecognizable instruction in binutils build with LRA enabled.

2025-12-02  John David Anglin  <danglin@gcc.gnu.org>

gcc/ChangeLog:

PR target/122874
* config/pa/pa.cc (pa_emit_move_sequence): Break out large
REG+D addresses from MEM operands.  Also, don't allow
unscaled indexed source operands till reload completes.

[PATCH] RISC-V: Make vlsegff similar to vleff [PR122656].

When we expand
  void d() { __riscv_vlseg2e32ff_v_i32mf2x2(&a, &c, b); }
without a destination register we ICE because
use_exact_insn wrongly adds arguments that we don't need and
  gcc_assert (opno == insn_data[icode].n_generator_args);
triggers.

Currently we expand a segmented fault-only-first load via use_exact_insn
because its insn pattern wants a Pmode register as source.  We can't go
the use_contiguous_load route because that one adds a vector-mode memory
operand.

It doesn't need to be like that, though, and this patch makes the
segmented load similar to the regular FoF load in terms of source
operand.  Also the patch only adds additional expansion arguments like
the rounding mode only if the insn needs it and the number of operands is
less than what we need, not unequal.

Regtested on rv64gcv_zvl512b.

Regards
 Robin

PR target/122656

gcc/ChangeLog:

* config/riscv/riscv-vector-builtins-bases.cc: Use
use_contiguous_load for vlsegff.
* config/riscv/riscv-vector-builtins.cc (function_expander::use_exact_insn):
Only add rounding mode operand if insn requires it and number of
arguments is < required.
(function_expander::use_ternop_insn): Ditto.
(function_expander::use_widen_ternop_insn): Ditto.
* config/riscv/vector.md: Use vector-mode source operand.

gcc/testsuite/ChangeLog:

* gcc.target/riscv/rvv/base/pr122656-1.c: New test.
* gcc.target/riscv/rvv/base/pr122656-2.c: New test.`

libsanitizer: Update LOCAL_PATCHES

* LOCAL_PATCHES: Update.

libsanitizer, Darwin: Support macOS13+.

Now we have support for findin dyld in the shared cache, we can enable
libsanitizer on newer systems.

libsanitizer/ChangeLog:

* configure.tgt: Enable for Darwin22+.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>

libsanitizer, Darwin: Updates for building with GCC.

This replaces the Darwin-specific changes previously applied
in b53f7de3e6205f76a794e159a282193e2afaad16 and addresses the
FIXME there.

1. The upstream sources do not, in general, support the range
of Darwin versions covered by GCC.

In order to support versions back to Darwin17, at least we
provide definitions for missing macro values and ensure that
headers are only conditionally included where they apply.

2. GCC does not support the clang __builtin_os_log_format and
therefore must fall back to older reporting methods.

3. Finally, we address a FIXME (for missing Blocks support)
used implement the search for dyld on macOS >= 13 with the
dyld_shared_cache_iterate_text() interface which requires an
(Apple) Block closure as a parameter.

If the compiler supports blocks (__BLOCKS__ is defined) then we
use the upstream implementation.  If not, then we synthesize the
equivalent code-gen manually.

libstdc++: Implement submdspan_extents. [PR110352]

Implement submdspan_extents as described in P3663 and adds it to the std
module.

PR libstdc++/110352

libstdc++-v3/ChangeLog:

* include/std/mdspan (submdspan_extents): New function.
* src/c++23/std.cc.in: Add submdspan_extents.
* testsuite/23_containers/mdspan/int_like.h: Add StructuralInt.
* testsuite/23_containers/mdspan/submdspan/submdspan_extents.cc: New test.
* testsuite/23_containers/mdspan/submdspan/submdspan_extents_neg.cc: New test.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Signed-off-by: Luc Grosheintz <luc.grosheintz@gmail.com>

libstdc++: Implement submdspan_canonicalize_slices. [PR110352]

Implements submdspan_canonicalize_slices as described in P3663 and adds
it to the std module.

There's one deviation from the standard. Doesn't (under all
circumstances) require:

  0 <= begin[k] <= end[k] <= exts.extent(k)

where the k-th slice range is [begin[k], end[k]). Instead, it requires
that the k-th slice ranges is contained in the k-th extent interval. If
the slice range is empty, then that condition is always satisfied, even if

  begin[k] == end[k] > exts.extent(k)

The deviation is that we enforce the above inequality through
preconditions. This is analogous to what the standard requires if
begin[k] is a constant wrapper.

PR libstdc++/110352

libstdc++-v3/ChangeLog:

* include/std/mdspan (submdspan_canonicalize_slices): New
function.
* src/c++23/std.cc.in (submdspan_canonicalize_slices): Add.
* testsuite/23_containers/mdspan/submdspan/submdspan_canonicalize_slices.cc: New test.
* testsuite/23_containers/mdspan/submdspan/submdspan_canonicalize_slices_neg.cc: New test.

Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Signed-off-by: Luc Grosheintz <luc.grosheintz@gmail.com>

RISC-V: Remove unused placeholder_p parameter from add_function

The placeholder_p parameter of function_builder::add_function is always
passed as false.  This was inherited from the AArch64 implementation but
is unnecessary for RISC-V.

gcc/ChangeLog:

* config/riscv/riscv-vector-builtins.cc
(function_builder::add_function): Remove placeholder_p parameter.
(function_builder::add_unique_function): Update call.
(function_builder::add_overloaded_function): Likewise.
* config/riscv/riscv-vector-builtins.h
(function_builder::add_function): Update declaration.

c++: Diagnose taking addresses of hard reg vars in their initializers [PR122860]

DECL_HARD_REGISTER is set only in cp_finish_decl together with
set_user_assembler_name.  If user attempts to take address of
such a var later, cxx_mark_addressable diagnoses it.
But if as in the following testcase the address is taken in its
initializer, we just ICE during expansion.

The following patch fixes it by emitting errors if TREE_ADDRESABLE
at the point we'd otherwise set DECL_HARD_REGISTER on it.

2025-12-02  Jakub Jelinek  <jakub@redhat.com>

PR c++/122860
* decl.cc (make_rtl_for_nonlocal_decl): Diagnose taking address
of a hard register decl in its initializer.
(cp_finish_decl): Likewise.

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

c++: Fix up error recovery for invalid designators [PR122836]

The following testcase ICEs since r12-7741 on the newly added gcc_assert.
We've diagnosed the designator is invalid before, but kept it as is.

The following patch changes it into error_mark_node, so that don't ICE on
it.

2025-12-02  Jakub Jelinek  <jakub@redhat.com>

PR c++/122836
* decl.cc (check_array_designated_initializer): Change ce->index to
error_mark_node after emitting an error for it.

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

c++: alias template parm conv and redecl [PR122171]

Here when substituting BITS into poly_table convert_template_argument adds
an IMPLICIT_CONV_EXPR to represent the conversion to the alias template
parameter.  In r16-4115 I extended that to value-dependent arguments as well
as type-dependent, in case the conversion turns out to be narrowing.
tsubst_expr needs the same change so maybe_update_decl_type doesn't
replace the IMPLICIT_CONV_EXPR with a NOP_EXPR.

The do_auto_deduction change is to avoid a regression in nontype-auto21.C
when the first test is changed from uses_template_parms (as it was in
convert_template_argument) to dependent_type_p; this mattered because we
were failing to resolve the auto return type before deducing the auto
non-type parameter type from helper<token>::c.  Many other places that call
resolve_nondeduced_context similarly then call mark_single_function.

PR c++/122171
PR c++/112632

gcc/cp/ChangeLog:

* pt.cc (dependent_implict_conv_p): Split out...
(convert_template_argument): ...from here.
(tsubst_expr) [IMPLICIT_CONV_EXPR]: Use it.
(do_auto_deduction): Call mark_single_function.

gcc/testsuite/ChangeLog:

* g++.dg/cpp0x/alias-decl-conv1.C: New test.

Reapply all revisions mentioned in LOCAL_PATCHES except for Darwin related stuff.

libsanitizer: Merge from upstream (8723fe5606de6dfb344afacd667c20f55bb2f5e0)

* MERGE: Merge from master.

vect: Use loop len in vectorizable_scan_store.

On riscv we ICE because we use SELECT_VL for a vectorizable_scan_store
that calls vect_get_data_ptr_increment without a loop_lens argument.

This patch just gets the loop_lens and passes them along.

gcc/ChangeLog:

* tree-vect-stmts.cc (vectorizable_scan_store): Pass loop_lens
to vect_get_data_ptr_increment.

c++/modules: Remove incorrect is_import check in using-directives

When I wrote this check in r16-5811 I was thinking of checking if the
using-directive was imported, but this just checks if the target
namespace was imported, which is not what we want.  We don't build deps
to see if the using-directive itself was imported, so just remove the
check.  I haven't been able to come up with a testcase this breaks but
it still seems reasonable to adjust.

gcc/cp/ChangeLog:

* module.cc (module_state::write_using_directives): Correct
condition.

Signed-off-by: Nathaniel Shead <nathanieloshead@gmail.com>

vect: don't hoist conditional loads above their condition [PR122868]

The example in the PR

#include <vector>

std::vector<bool> x, y;
int main() { return x == y; }

now vectorizes but the attributes on std::vector indicate that the vector is
aligned to the natural vector alignment.  In C this is equivalent to the
testcase

int f (int a[12], int b[12], int n)
{
    a = __builtin_assume_aligned (a, 16);
    b = __builtin_assume_aligned (b, 16);
    for (int i = 0; i < n; i++)
      {
        if (b[i] == 0)
          return 0;
        if (a[0] > b[i])
          return 1;
      }
    return 2;
}

Here the load a[0] is loop invariant, and the vectorizer hoists this out of the
loop into the pre-header.  For early break this isn't safe to do as a[0] is
conditionally valid based on the conditions in the block preceding it.  As such
we need some guarantee that the load is valid before we can hoist it or the load
needs to be unconditional (e.g. in the loop header block).

Conceptually alignment peeling can provide this guarantee since making it
through the prologue means the invariant value was loaded at least once and so
we know the address is valid.  At the moment however there's no real defined
order between how GCC inserts conditions in the pre-header, so having tried to
change the order a few times the load always ends up before the prologue.  So
for now I marked it as a missed optimization.

Since we still can hoist invariant loads if in the header, I didn't change
LOOP_VINFO_NO_DATA_DEPENDENCIES since that would be global and instead I
modified the usage site of LOOP_VINFO_NO_DATA_DEPENDENCIES.

gcc/ChangeLog:

PR tree-optimization/122868
* tree-vect-stmts.cc (vectorizable_load): Don't hoist loop invariant
conditional loads unless in header.

gcc/testsuite/ChangeLog:

PR tree-optimization/122868
* gcc.dg/vect/vect-early-break_140-pr122868_1.c: New test.
* gcc.dg/vect/vect-early-break_140-pr122868_2.c: New test.
* gcc.dg/vect/vect-early-break_140-pr122868_3.c: New test.
* gcc.dg/vect/vect-early-break_140-pr122868_4.c: New test.

a68: remove superfluous code detected by cppcheck [PR algol68/122954]

This commits fixes three instances of harmless but redundant code,
detected by cppcheck.

gcc/algol68/ChangeLog

PR algol68/122954
* a68-low-clauses.cc (serial_clause_dsa): Avoid redundant
initialization.
* a68-parser-modes.cc (compute_derived_modes): Likewise.
* a68-low.cc (a68_lower_tree): Remove redundant break.

Manually add ChangeLog entry for r16-5788.

Daily bump.