gcc/analyzer/ChangeLog:
	PR analyzer/111289
	* varargs.cc (representable_in_integral_type_p): New.
	(va_arg_compatible_types_p): Add "arg_sval" param.  Handle integer
	types.
	(kf_va_arg::impl_call_pre): Pass arg_sval to
	va_arg_compatible_types_p.

gcc/testsuite/ChangeLog:
	PR analyzer/111289
	* c-c++-common/analyzer/stdarg-pr111289-int.c: New test.
	* c-c++-common/analyzer/stdarg-pr111289-ptr.c: New test.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>

gcc/testsuite/ChangeLog:
	PR analyzer/110520
	* c-c++-common/analyzer/null-deref-pr110520.c: New test.

Signed-off-by: David Malcolm <dmalcolm@redhat.com>

After r14-6419-g4eaaf7f5a378e8, maybe_undo_optimize_bit_field_compare would ICE on
vector CST but this function really should be checking if we had integer types so
reject non-integral types early on (like it was doing for non-char type before r14-6419-g4eaaf7f5a378e8).

Committed as obvious after build and tested for aarch64-linux-gnu with no regressions.

	PR analyzer/113983

gcc/analyzer/ChangeLog:

	* region-model-manager.cc (maybe_undo_optimize_bit_field_compare): Reject
	non integral types.

gcc/testsuite/ChangeLog:

	* gcc.dg/analyzer/torture/vector-extract-1.c: New test.

Signed-off-by: Andrew Pinski <quic_apinski@quicinc.com>

Darwin's linker warns when we make a direct branch to code that is
in a weak definition (citing that if a different implementation of
the weak function is chosen by the dynamic linker this would be an
error).

As the analysis in the PR shows, this can happen when we have hot/
cold partitioning and there is an error path that is primarily cold
but makes use of epilogue code in the hot section.  In this simple
case, we can easily deduce that the code is in fact safe; however
that is not something we can realistically implement in the linker.

Since the user-replaceable allocators are implemented using weak
definitions, this is a warning that is frequently flagged up in both
the testsuite and end-user code.

The chosen solution here is to suppress the hot/cold partitioning for
these cases (it is unlikely to impact performance much c.f. the
actual allocation).

	PR target/112397

libstdc++-v3/ChangeLog:

	* configure: Regenerate.
	* configure.ac: Detect if we are building for Darwin.
	* libsupc++/Makefile.am: If we are building for Darwin, then
	suppress hot/cold partitioning for the array allocators.
	* libsupc++/Makefile.in: Regenerated.

Signed-off-by: Iain Sandoe <iain@sandoe.co.uk>
Co-authored-by: Jonathan Wakely <jwakely@redhat.com>

r14-5310-g879cf9ff45d940 introduced some new handling for spawning sub
processes.  The return value from the generic exec_child is examined
and needs to be < 0 to signal an error. However, the unix flavour of
this routine is returning the PID value set from the posix_spawn{p}.

This latter value is undefined per the manual pages for both Darwin
and Linux, and it seems Darwin, at least, sets the value to some
usually positive number (presumably the PID that would have been used
if the fork had succeeded).

The fix proposed here is to set the pid = -1 in the relevant error
paths.

	PR other/113957

libiberty/ChangeLog:

	* pex-unix.c (pex_unix_exec_child): Set pid = -1 in the error
	paths, since that is used to signal an erroneous outcome for
	the routine.

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

Currently, these are registered as unsigned_intDI_type_node which is not
necessarily the same type definition as uint64_t.  On platforms where these
differ that causes fails in consuming the arm_acle.h header.

gcc/ChangeLog:

	* config/aarch64/aarch64-builtins.cc (aarch64_init_rng_builtins):
	Register these builtins with a pointer to uint64_t rather than unsigned
	DI mode.

	* es.po: Update.

gcc/po/
	* be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po,
	ja.po, nl.po, ru.po, sr.po, sv.po, tr.po, uk.po, vi.po, zh_CN.po,
	zh_TW.po: Update.

libcpp/po/
	* be.po, ca.po, da.po, de.po, el.po, eo.po, es.po, fi.po, fr.po,
	id.po, ja.po, ka.po, nl.po, pt_BR.po, ro.po, ru.po, sr.po, sv.po,
	tr.po, uk.po, vi.po, zh_CN.po, zh_TW.po: Update.

GCN: Conditionalize 'define_expand "reduc_<fexpander>_scal_<mode>"' on '!TARGET_RDNA2_PLUS' [PR113615]

On top of commit c7ec7bd1
"amdgcn: add -march=gfx1030 EXPERIMENTAL" conditionalizing
'define_expand "reduc_<reduc_op>_scal_<mode>"' on
'!TARGET_RDNA2' (later: '!TARGET_RDNA2_PLUS'), we then did similar in
commit 7cc2262e
"gcn/gcn-valu.md: Disable fold_left_plus for TARGET_RDNA2_PLUS [PR113615]"
to conditionalize 'define_expand "fold_left_plus_<mode>"' on
'!TARGET_RDNA2_PLUS', but I found we also need to conditionalize the related
'define_expand "reduc_<fexpander>_scal_<mode>"' on '!TARGET_RDNA2_PLUS', to
avoid ICEs like:

    [...]/gcc.dg/vect/pr108608.c: In function 'foo':
    [...]/gcc.dg/vect/pr108608.c:9:1: error: unrecognizable insn:
    (insn 34 33 35 2 (set (reg:V64DF 723)
            (unspec:V64DF [
                    (reg:V64DF 690 [ vect_m_11.20 ])
                    (const_int 1 [0x1])
                ] UNSPEC_MOV_DPP_SHR)) -1
         (nil))
    during RTL pass: vregs

Similar for 'gcc.dg/vect/vect-fmax-2.c', 'gcc.dg/vect/vect-fmin-2.c', and
'UNSPEC_SMAX_DPP_SHR' for 'gcc.dg/vect/vect-fmax-1.c', and
'UNSPEC_SMIN_DPP_SHR' for 'gcc.dg/vect/vect-fmin-1.c', when running 'vect.exp'
for 'check-gcc-c'.

	PR target/113615
	gcc/
	* config/gcn/gcn-valu.md (define_expand "reduc_<fexpander>_scal_<mode>"):
	Conditionalize on '!TARGET_RDNA2_PLUS'.
	* config/gcn/gcn.cc (gcn_expand_dpp_shr_insn)
	(gcn_expand_reduc_scalar):
	'gcc_checking_assert (!TARGET_RDNA2_PLUS);'.

Also, add some safeguards for the future.

Fix-up for commit 52a2c659
"GCN: Add pre-initial support for gfx1100".

	gcc/
	* config/gcn/gcn.h (TARGET_CPU_CPP_BUILTINS): Restore lost
	'__gfx90a__' target CPU definition.  Add some safeguards for the future.

When partially substituting a requires-expr, we don't want to perform
any additional checks beyond the substitution itself so as to minimize
checking requirements out of order.  So don't check the return-type-req
of a compound-requirement during partial substitution.  And don't check
the noexcept condition either since we can't do that on templated trees.

	PR c++/113966

gcc/cp/ChangeLog:

	* constraint.cc (tsubst_compound_requirement): Don't check
	the noexcept condition or the return-type-requirement when
	partially substituting.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp2a/concepts-friend17.C: New test.

Reviewed-by: Jason Merrill <jason@redhat.com>

Replaced uses of __seg_gs with the MACRO SEG defined in the testcase to pick
(if any) the right __seg_{gs,fs} keyword based on target.

gcc/testsuite/ChangeLog:

	* gcc.dg/bitint-86.c (__seg_gs): Replace with SEG MACRO.

The following tries to address the PHI insertion compile-time hog in
RTL fwprop observed with the PR54052 testcase where the loop computing
the "unfiltered" set of variables possibly needing PHI nodes for each
block exhibits quadratic compile-time and memory-use.

It does so by pruning the local DEFs with LR_OUT of the block, removing
regs that can never be LR_IN (defined by this block) in the dominance
frontier.

	PR rtl-optimization/54052
	* rtl-ssa/blocks.cc (function_info::place_phis): Filter
	local defs by LR_OUT.

This patch fixes a bug exposed when a constant string is declared in a
definition module and imported by a program module.  The bug fix
was to defer the string assignment and concatenation until quadruples
were generated.  The conststring symbol has a known field which
must be checked prior to retrieving the string contents.

gcc/m2/ChangeLog:

	PR modula2/113889
	* gm2-compiler/M2ALU.mod (StringFitsArray): Add tokeno parameter
	to GetStringLength.
	(InitialiseArrayOfCharWithString): Add tokeno parameter to
	GetStringLength.
	(CheckGetCharFromString): Add tokeno parameter to GetStringLength.
	* gm2-compiler/M2Const.mod (constResolveViaMeta): Replace
	PutConstString with PutConstStringKnown.
	* gm2-compiler/M2GCCDeclare.mod (DeclareCharConstant): Add tokenno
	parameter and add assert.  Use tokenno to generate location.
	(DeclareStringConstant): Add tokenno and add asserts.
	Add tokenno parameter to calls to GetStringLength.
	(PromoteToString): Add assert and add tokenno parameter to
	GetStringLength.
	(PromoteToCString): Add assert and add tokenno parameter to
	GetStringLength.
	(DeclareConstString): New procedure function.
	(TryDeclareConst): Remove size local variable.
	Check IsConstStringKnown.
	Call DeclareConstString.
	(PrintString): New procedure.
	(PrintVerboseFromList): Call PrintString.
	(CheckResolveSubrange): Check IsConstStringKnown before creating
	subrange for char or issuing an error.
	* gm2-compiler/M2GenGCC.mod (ResolveConstantExpressions): Add
	StringLengthOp, StringConvertM2nulOp, StringConvertCnulOp case
	clauses.
	(FindSize): Add assert IsConstStringKnown.
	(StringToChar): New variable tokenno.
	Add tokenno parameter to GetStringLength.
	(FoldStringLength): New procedure.
	(FoldStringConvertM2nul): New procedure.
	(FoldStringConvertCnul): New procedure.
	(CodeAddr): Add tokenno parameter.
	Replace CurrentQuadToken with tokenno.
	Add tokenno parameter to GetStringLength.
	(PrepareCopyString): Rewrite.
	(IsConstStrKnown): New procedure function.
	(FoldAdd): Detect conststring op2 and op3 which are known and
	concat.  Place result into op1.
	(FoldStandardFunction): Pass tokenno as a parameter to
	GetStringLength.
	(CodeXIndr): Rewrite comment.
	Rename op1 to left, op3 to right.
	Pass rightpos to GetStringLength.
	* gm2-compiler/M2Quads.def (QuadrupleOp): Add
	StringConvertCnulOp, StringConvertM2nulOp and StringLengthOp.
	* gm2-compiler/M2Quads.mod (import): Remove MakeConstLitString.
	Add CopyConstString and PutConstStringKnown.
	(IsInitialisingConst): Add StringConvertCnulOp,
	StringConvertM2nulOp and StringLengthOp.
	(callRequestDependant): Replace MakeConstLitString with
	MakeConstString.
	(DeferMakeConstStringCnul): New procedure function.
	(DeferMakeConstStringM2nul): New procedure function.
	(CheckParameter): Add early return if the string const is unknown.
	(DescribeType): Add token parameter to GetStringLength.
	Check for IsConstStringKnown.
	(ManipulateParameters): Use DeferMakeConstStringCnul and
	DeferMakeConstStringM2nul.
	(MakeLengthConst): Remove and replace with...
	(DeferMakeLengthConst): ... this.
	(doBuildBinaryOp): Create ConstString and set it to contents
	unknown.
	Check IsConstStringKnown before generating error message.
	(WriteQuad): Add StringConvertCnulOp, StringConvertM2nulOp and
	StringLengthOp.
	(WriteOperator): Add StringConvertCnulOp, StringConvertM2nulOp and
	StringLengthOp.
	* gm2-compiler/M2SymInit.mod (CheckReadBeforeInitQuad): Add
	StringConvertCnulOp, StringConvertM2nulOp and StringLengthOp.
	* gm2-compiler/NameKey.mod (LengthKey): Allow NulName to return 0.
	* gm2-compiler/P2SymBuild.mod (BuildString): Replace
	MakeConstLitString with MakeConstString.
	(DetermineType): Replace PutConstString with PutConstStringKnown.
	* gm2-compiler/SymbolTable.def (MakeConstVar): Tidy up comment.
	(MakeConstLitString): Remove.
	(MakeConstString): New procedure function.
	(MakeConstStringCnul): New procedure function.
	(MakeConstStringM2nul): New procedure function.
	(PutConstStringKnown): New procedure.
	(CopyConstString): New procedure.
	(IsConstStringKnown): New procedure function.
	(IsConstStringM2): New procedure function.
	(IsConstStringC): New procedure function.
	(IsConstStringM2nul): New procedure function.
	(IsConstStringCnul): New procedure function.
	(GetStringLength): Add token parameter.
	(PutConstString): Remove.
	(GetConstStringM2): Remove.
	(GetConstStringC): Remove.
	(GetConstStringM2nul): Remove.
	(GetConstStringCnul): Remove.
	(MakeConstStringC): Remove.
	* gm2-compiler/SymbolTable.mod (SymConstString): Remove
	M2Variant, NulM2Variant, CVariant, NulCVariant.
	Add Known.
	(CheckAnonymous): Replace $$ with __anon.
	(IsNameAnonymous): Replace $$ with __anon.
	(MakeConstVar): Detect whether the name is nul and treat as
	a temporary constant.
	(MakeConstLitString): Remove.
	(BackFillString): Remove.
	(InitConstString): Rewrite.
	(GetConstStringM2): Remove.
	(GetConstStringC): Remove.
	(GetConstStringContent): New procedure function.
	(GetConstStringM2nul): Remove.
	(GetConstStringCnul): Remove.
	(MakeConstStringCnul): Rewrite.
	(MakeConstStringM2nul): Rewrite.
	(MakeConstStringC): Remove.
	(MakeConstString): Rewrite.
	(PutConstStringKnown): New procedure.
	(CopyConstString): New procedure.
	(PutConstString): Remove.
	(IsConstStringKnown): New procedure function.
	(IsConstStringM2): New procedure function.
	(IsConstStringC): Rewrite.
	(IsConstStringM2nul): Rewrite.
	(IsConstStringCnul): Rewrite.
	(GetConstStringKind): New procedure function.
	(GetString): Check Known.
	(GetStringLength): Add token parameter and check Known.

gcc/testsuite/ChangeLog:

	PR modula2/113889
	* gm2/pim/run/pass/pim-run-pass.exp: Add filter for
	constdef.mod.
	* gm2/extensions/run/pass/callingc2.mod: New test.
	* gm2/extensions/run/pass/callingc3.mod: New test.
	* gm2/extensions/run/pass/callingc4.mod: New test.
	* gm2/extensions/run/pass/callingc5.mod: New test.
	* gm2/extensions/run/pass/callingc6.mod: New test.
	* gm2/extensions/run/pass/callingc7.mod: New test.
	* gm2/extensions/run/pass/callingc8.mod: New test.
	* gm2/extensions/run/pass/fixedarray.mod: New test.
	* gm2/extensions/run/pass/fixedarray2.mod: New test.
	* gm2/pim/run/pass/constdef.def: New test.
	* gm2/pim/run/pass/constdef.mod: New test.
	* gm2/pim/run/pass/testimportconst.mod: New test.

Signed-off-by: Gaius Mulley <gaiusmod2@gmail.com>

Some of these are part of the upstream DMD `gdc.test' testsuite, but
they had been omitted because they get mangled by the lib/gdc-utils.exp
helpers when parsing and staging the tests. Translate them over to the
gdc.dg testsuite instead.

gcc/testsuite/ChangeLog:

	* gdc.dg/bom_UTF16BE.d: New test.
	* gdc.dg/bom_UTF16LE.d: New test.
	* gdc.dg/bom_UTF32BE.d: New test.
	* gdc.dg/bom_UTF32LE.d: New test.
	* gdc.dg/bom_UTF8.d: New test.
	* gdc.dg/bom_characters.d: New test.
	* gdc.dg/bom_error_UTF8.d: New test.
	* gdc.dg/bom_infer_UTF16BE.d: New test.
	* gdc.dg/bom_infer_UTF16LE.d: New test.
	* gdc.dg/bom_infer_UTF32BE.d: New test.
	* gdc.dg/bom_infer_UTF32LE.d: New test.
	* gdc.dg/bom_infer_UTF8.d: New test.

The following testcase ICEs, because BIT_FIELD_REF's position is not
multiple of the vector element's bit size and the code uses exact_div
to divide those 2 values.

For BIT_INSERT_EXPR, the tree-cfg.cc verification verifies the position
is a multiple of the inserted bit size when inserting into vectors,
but for BIT_FIELD_REF the position can be arbitrary if within the range.

The following patch fixes that.

2024-02-19  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/113967
	* match.pd (bit_insert @0 (BIT_FIELD_REF @1 ..) ..): Require
	in condition that @rpos is multiple of vector element size.

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

Update in v2: Add dump information.

This patch fixes the following ineffective vsetvl insertion:

void f (int32_t * restrict in, int32_t * restrict out, size_t n, size_t cond, size_t cond2)
{
  for (size_t i = 0; i < n; i++)
    {
      if (i == cond) {
        vint8mf8_t v = *(vint8mf8_t*)(in + i + 100);
        *(vint8mf8_t*)(out + i + 100) = v;
      } else if (i == cond2) {
        vfloat32mf2_t v = *(vfloat32mf2_t*)(in + i + 200);
        *(vfloat32mf2_t*)(out + i + 200) = v;
      } else if (i == (cond2 - 1)) {
        vuint16mf2_t v = *(vuint16mf2_t*)(in + i + 300);
        *(vuint16mf2_t*)(out + i + 300) = v;
      } else {
        vint8mf4_t v = *(vint8mf4_t*)(in + i + 400);
        *(vint8mf4_t*)(out + i + 400) = v;
      }
    }
}

Before this patch:

f:
.LFB0:
        .cfi_startproc
        beq     a2,zero,.L12
        addi    a7,a0,400
        addi    a6,a1,400
        addi    a0,a0,1600
        addi    a1,a1,1600
        li      a5,0
        addi    t6,a4,-1
        vsetvli t3,zero,e8,mf8,ta,ma     ---> ineffective uplift
.L7:
        beq     a3,a5,.L15
        beq     a4,a5,.L16
        beq     t6,a5,.L17
        vsetvli t1,zero,e8,mf4,ta,ma
        vle8.v  v1,0(a0)
        vse8.v  v1,0(a1)
        vsetvli t3,zero,e8,mf8,ta,ma
.L4:
        addi    a5,a5,1
        addi    a7,a7,4
        addi    a6,a6,4
        addi    a0,a0,4
        addi    a1,a1,4
        bne     a2,a5,.L7
.L12:
        ret
.L15:
        vle8.v  v1,0(a7)
        vse8.v  v1,0(a6)
        j       .L4
.L17:
        vsetvli t1,zero,e8,mf4,ta,ma
        addi    t5,a0,-400
        addi    t4,a1,-400
        vle16.v v1,0(t5)
        vse16.v v1,0(t4)
        vsetvli t3,zero,e8,mf8,ta,ma
        j       .L4
.L16:
        addi    t5,a0,-800
        addi    t4,a1,-800
        vle32.v v1,0(t5)
        vse32.v v1,0(t4)
        j       .L4

It's obvious that we are hoisting the e8mf8 vsetvl to the top. It's ineffective since e8mf8 comes from
low probability block which is if (i == cond).

For this case, we disable such fusion.

After this patch:

f:
	beq	a2,zero,.L12
	addi	a7,a0,400
	addi	a6,a1,400
	addi	a0,a0,1600
	addi	a1,a1,1600
	li	a5,0
	addi	t6,a4,-1
.L7:
	beq	a3,a5,.L15
	beq	a4,a5,.L16
	beq	t6,a5,.L17
	vsetvli	t1,zero,e8,mf4,ta,ma
	vle8.v	v1,0(a0)
	vse8.v	v1,0(a1)
.L4:
	addi	a5,a5,1
	addi	a7,a7,4
	addi	a6,a6,4
	addi	a0,a0,4
	addi	a1,a1,4
	bne	a2,a5,.L7
.L12:
	ret
.L15:
	vsetvli	t3,zero,e8,mf8,ta,ma
	vle8.v	v1,0(a7)
	vse8.v	v1,0(a6)
	j	.L4
.L17:
	addi	t5,a0,-400
	addi	t4,a1,-400
	vsetvli	t1,zero,e8,mf4,ta,ma
	vle16.v	v1,0(t5)
	vse16.v	v1,0(t4)
	j	.L4
.L16:
	addi	t5,a0,-800
	addi	t4,a1,-800
	vsetvli	t3,zero,e32,mf2,ta,ma
	vle32.v	v1,0(t5)
	vse32.v	v1,0(t4)
	j	.L4

Tested on both RV32/RV64 no regression. Ok for trunk ?

	PR target/113696

gcc/ChangeLog:

	* config/riscv/riscv-vsetvl.cc (pre_vsetvl::earliest_fuse_vsetvl_info):
	Suppress vsetvl fusion.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/rvv/vsetvl/pr113696.c: New test.

Since push2/pop2 requires 16-byte stack alignment, don't generate them
if the incoming stack isn't 16-byte aligned.

gcc/

	PR target/113912
	* config/i386/i386.cc (ix86_can_use_push2pop2): New.
	(ix86_pro_and_epilogue_can_use_push2pop2): Use it.
	(ix86_emit_save_regs): Don't generate push2 if
	ix86_can_use_push2pop2 return false.
	(ix86_expand_epilogue): Don't generate pop2 if
	ix86_can_use_push2pop2 return false.

gcc/testsuite/

	PR target/113912
	* gcc.target/i386/apx-push2pop2-2.c: New test.

gcc/
	* doc/invoke.texi (AVR Options) <-mmcu>: Remove "Atmel".
	Note on complete device support.

gcc/
	* doc/extend.texi (AVR Function Attributes): Fuse description
	of "signal" and "interrupt" attribute.  Link pseudo instruction.

When not optimized for speed, the test for PR112344 takes several
seconds to execute on native x86_64, and 15 minutes on PRU target
simulator.  Thus mark those variants as expensive.  The -O2 variant
which originally triggered the PR is not expensive, hence it is
still run by default.

	PR middle-end/112344

gcc/testsuite/ChangeLog:

	* gcc.dg/torture/pr112344.c: Run non-optimized variants only
	if expensive tests are allowed.

Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>

gcc/ChangeLog:

	* config/loongarch/larchintrin.h (__movgr2fcsr): Remove redundant
	symbol type conversions.
	(__cacop_d): Likewise.
	(__cpucfg): Likewise.
	(__asrtle_d): Likewise.
	(__asrtgt_d): Likewise.
	(__lddir_d): Likewise.
	(__ldpte_d): Likewise.
	(__crc_w_b_w): Likewise.
	(__crc_w_h_w): Likewise.
	(__crc_w_w_w): Likewise.
	(__crc_w_d_w): Likewise.
	(__crcc_w_b_w): Likewise.
	(__crcc_w_h_w): Likewise.
	(__crcc_w_w_w): Likewise.
	(__crcc_w_d_w): Likewise.
	(__csrrd_w): Likewise.
	(__csrwr_w): Likewise.
	(__csrxchg_w): Likewise.
	(__csrrd_d): Likewise.
	(__csrwr_d): Likewise.
	(__csrxchg_d): Likewise.
	(__iocsrrd_b): Likewise.
	(__iocsrrd_h): Likewise.
	(__iocsrrd_w): Likewise.
	(__iocsrrd_d): Likewise.
	(__iocsrwr_b): Likewise.
	(__iocsrwr_h): Likewise.
	(__iocsrwr_w): Likewise.
	(__iocsrwr_d): Likewise.
	(__frecipe_s): Likewise.
	(__frecipe_d): Likewise.
	(__frsqrte_s): Likewise.
	(__frsqrte_d): Likewise.

gcc/ChangeLog:

	* config/loongarch/larchintrin.h (__iocsrrd_h): Modify the
	function return value type to unsigned short.

D front-end changes:

	- Import dmd v2.107.1-rc.1.

D runtime changes:

	- Import druntime v2.107.1-rc.1.

Phobos changes:

	- Import phobos v2.107.1-rc.1.

gcc/d/ChangeLog:

	* dmd/MERGE: Merge upstream dmd 9471b25db9.
	* dmd/VERSION: Bump version to v2.107.1-rc.1.
	* Make-lang.in (D_FRONTEND_OBJS): Add d/cxxfrontend.o.
	* d-attribs.cc (build_attributes): Update for new front-end interface.
	* d-builtins.cc (build_frontend_type): Likewise.
	(strip_type_modifiers): Likewise.
	(covariant_with_builtin_type_p): Likewise.
	* d-codegen.cc (declaration_type): Likewise.
	(parameter_type): Likewise.
	(build_array_struct_comparison): Likewise.
	(void_okay_p): Likewise.
	* d-convert.cc (convert_expr): Likewise.
	(check_valist_conversion): Likewise.
	* d-lang.cc (d_generate_ddoc_file): Likewise.
	(d_parse_file): Likewise.
	* d-target.cc (TargetCPP::toMangle): Likewise.
	(TargetCPP::typeInfoMangle): Likewise.
	(TargetCPP::thunkMangle): Likewise.
	(TargetCPP::parameterType): Likewise.
	* decl.cc (d_mangle_decl): Likewise.
	(DeclVisitor::visit): Likewise.
	(DeclVisitor::visit (CAsmDeclaration *)): New method.
	(get_symbol_decl): Update for new front-end interface.
	(layout_class_initializer): Likewise.
	* expr.cc (ExprVisitor::visit): Likewise.
	* intrinsics.cc (maybe_set_intrinsic): Likewise.
	(expand_intrinsic_rotate): Likewise.
	* modules.cc (layout_moduleinfo_fields): Likewise.
	(layout_moduleinfo): Likewise.
	* runtime.cc (get_libcall_type): Likewise.
	* typeinfo.cc (make_frontend_typeinfo): Likewise.
	(TypeInfoVisitor::visit): Likewise.
	(create_typeinfo): Likewise.
	* types.cc (same_type_p): Likewise.
	(build_ctype): Likewise.

libphobos/ChangeLog:

	* libdruntime/MERGE: Merge upstream druntime 9471b25db9.
	* src/MERGE: Merge upstream phobos 547886846.

	PR libfortran/105473

libgfortran/ChangeLog:

	* io/list_read.c (eat_separator): Reject comma as a
	seprator when it is being used as a decimal point.
	(parse_real): Reject a '.' when is should be a comma.
	(read_real): Likewise.
	* io/read.c (read_f): Add more checks for ',' and '.'
	conditions.

gcc/testsuite/ChangeLog:

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

The r14-870 changes broke xtb package tests (reduced testcase is the first
one below) and caused ICEs on a test derived from that (the second one).
For the
  x = T(u = trim (us(1)))
statement, before that change gfortran used to emit weird code with
2 trim calls:
      _gfortran_string_trim (&len.2, (void * *) &pstr.1, 20, &us[0]);
      if (len.2 > 0)
        {
          __builtin_free ((void *) pstr.1);
        }
      D.4275 = len.2;
      t.0.u = (character(kind=1)[1:0] *) __builtin_malloc (MAX_EXPR <(sizetype) D.4275, 1>);
      t.0._u_length = D.4275;
      _gfortran_string_trim (&len.4, (void * *) &pstr.3, 20, &us[0]);
      (void) __builtin_memcpy ((void *) t.0.u, (void *) pstr.3, (unsigned long) NON_LVALUE_EXPR <len.4>);
      if (len.4 > 0)
        {
          __builtin_free ((void *) pstr.3);
        }
That worked at runtime, though it is wasteful.
That commit changed it to:
      slen.3 = len.2;
      t.0.u = (character(kind=1)[1:0] *) __builtin_malloc (MAX_EXPR <(sizetype) slen.3, 1>);
      t.0._u_length = slen.3;
      _gfortran_string_trim (&len.2, (void * *) &pstr.1, 20, &us[0]);
      (void) __builtin_memcpy ((void *) t.0.u, (void *) pstr.1, (unsigned long) NON_LVALUE_EXPR <len.2>);
      if (len.2 > 0)
        {
          __builtin_free ((void *) pstr.1);
        }
which results in -Wuninitialized warning later on and if one is unlucky and
the uninitialized len.2 variable is smaller than the trimmed length, it
results in heap overflow and often crashes later on.
The bug above is clear, len.2 is only initialized in the
_gfortran_string_trim (&len.2, (void * *) &pstr.1, 20, &us[0]);
call, but used before that.  Now, the
      slen.3 = len.2;
      t.0.u = (character(kind=1)[1:0] *) __builtin_malloc (MAX_EXPR <(sizetype) slen.3, 1>);
      t.0._u_length = slen.3;
statements come from the alloc_scalar_allocatable_subcomponent call,
while
      _gfortran_string_trim (&len.2, (void * *) &pstr.1, 20, &us[0]);
from the gfc_conv_expr (&se, expr); call which is done before the
alloc_scalar_allocatable_subcomponent call, but is only appended later on
with gfc_add_block_to_block (&block, &se.pre);
Now, obviously the alloc_scalar_allocatable_subcomponent emitted statements
can depend on the se.pre sequence statements which can compute variables
used by alloc_scalar_allocatable_subcomponent like the length.
On the other side, I think the se.pre sequence really shouldn't depend
on the changes done by alloc_scalar_allocatable_subcomponent, that is
initializing the FIELD_DECLs of the destination allocatable subcomponent
only, the gfc_conv_expr statements are already created, so all they could
in theory depend above is on t.0.u or t.0._u_length, but I believe if the
rhs dependened on the lhs content (which is allocated by those statements
but really uninitialized), it would need to be discovered by the dependency
analysis and forced into a temporary.
So, in order to fix the first testcase, the second hunk of the patch just
emits the se.pre block before the alloc_scalar_allocatable_subcomponent
changes rather than after it.

The second problem is an ICE on the second testcase.  expr in the caller
(expr2 inside of alloc_scalar_allocatable_subcomponent) has
expr2->ts.u.cl->backend_decl already set, INTEGER_CST 20, but
alloc_scalar_allocatable_subcomponent overwrites it to a new VAR_DECL
which it assigns a value to before the malloc.  That can work if the only
places the expr2->ts is ever used are in the same local block or its
subblocks (and only if it is dominated by the code emitted by
alloc_scalar_allocatable_subcomponent, so e.g. not if that call is inside
of a conditional code and use later unconditional), but doesn't work
if expr2->ts is used before that block or after it.  So, the exact ICE is
because of:
  slen.1 = 20;
    static character(kind=1) us[1][1:20] = {"foo                 "};
  x.u = 0B;
  x._u_length = 0;
  {
    struct t t.0;
    struct t D.4308;

    {
      integer(kind=8) slen.1;

      slen.1 = 20;
      t.0.u = (character(kind=1)[1:0] *) __builtin_malloc (MAX_EXPR <(sizetype) slen.1, 1>);
      t.0._u_length = slen.1;
      (void) __builtin_memcpy ((void *) t.0.u, (void *) &us[0], 20);
    }
where the first slen.1 = 20; is emitted because it sees us has a VAR_DECL
ts.u.cl->backend_decl and so it wants to initialize it to the actual length.
This is invalid GENERIC, because the slen.1 variable is only declared inside
of a {} later on and so uses outside of it are wrong.  Similarly wrong would
be if it is used later on.  E.g. in the same testcase if it has
  type(T) :: x, y
  x = T(u = us(1))
  y%u = us(1)
then there is
    {
      integer(kind=8) slen.1;

      slen.1 = 20;
      t.0.u = (character(kind=1)[1:0] *) __builtin_malloc (MAX_EXPR <(sizetype) slen.1, 1>);
      t.0._u_length = slen.1;
      (void) __builtin_memcpy ((void *) t.0.u, (void *) &us[0], 20);
    }
...
    if (y.u != 0B) goto L.1;
    y.u = (character(kind=1)[1:0] *) __builtin_malloc (MAX_EXPR <(sizetype) slen.1, 1>);
i.e. another use of slen.1, this time after slen.1 got out of scope.

I really don't understand why the code modifies
expr2->ts.u.cl->backend_decl, expr2 isn't used there anywhere except for
expr2->ts.u.cl->backend_decl expressions, so hacks like save the previous
value, overwrite it temporarily over some call that will use expr2 and
restore afterwards aren't needed - there are no such calls, so the
following patch fixes it just by not messing up with
expr2->ts.u.cl->backend_decl, only set it to size variable and overwrite
that with a temporary if needed.

2024-02-17  Jakub Jelinek  <jakub@redhat.com>

	PR fortran/113503
	* trans-expr.cc (alloc_scalar_allocatable_subcomponent): Don't
	overwrite expr2->ts.u.cl->backend_decl, instead set size to
	expr2->ts.u.cl->backend_decl first and use size instead of
	expr2->ts.u.cl->backend_decl.
	(gfc_trans_subcomponent_assign): Emit se.pre into block
	before calling alloc_scalar_allocatable_subcomponent instead of
	after it.

	* gfortran.dg/pr113503_1.f90: New test.
	* gfortran.dg/pr113503_2.f90: New test.

	PR libfortran/107068

libgfortran/ChangeLog:

	* io/list_read.c (read_logical): When looking for a possible
	variable name, check for left paren, indicating a possible
	array reference.

gcc/testsuite/ChangeLog:

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

Here we find ourselves in maybe_check_overriding_exception_spec in
a template context where we can't instantiate a dependent noexcept.
That's OK, but we have to defer the checking otherwise we give wrong
errors.

	PR c++/113158

gcc/cp/ChangeLog:

	* search.cc (maybe_check_overriding_exception_spec): Defer checking
	when a noexcept couldn't be instantiated & evaluated to false/true.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/noexcept83.C: New test.

std::__niter_base is used in _GLIBCXX_DEBUG mode to remove _Safe_iterator<>
wrapper on random access iterators. But doing so it should also preserve original
behavior to remove __normal_iterator wrapper.

libstdc++-v3/ChangeLog:

	* include/bits/stl_algobase.h (std::__niter_base): Redefine the overload
	definitions for __gnu_debug::_Safe_iterator.
	* include/debug/safe_iterator.tcc (std::__niter_base): Adapt declarations.

	PR fortran/113911

gcc/fortran/ChangeLog:

	* trans-array.cc (gfc_trans_deferred_array): Do not clobber
	deferred length for a character variable passed as dummy argument.

gcc/testsuite/ChangeLog:

	* gfortran.dg/allocatable_length_2.f90: New test.
	* gfortran.dg/bind_c_optional-2.f90: Enable deferred-length test.

Given the recent discussions on IRC started with Andrew P. mentioning that
an asm goto outputs test should have { target lra } and the lra effective
target in GCC 11/12 only returning 0 for PA and in 13/14 for PA/AVR, while
we clearly have 14 other targets which don't support LRA and a couple of
further ones which have an -mlra/-mno-lra switch (whatever default they
have), seems to me the effective target is quite broken.

The following patch rewrites it, such that it has a fast path for heavily
used targets which are for years known to use only LRA (just an
optimization) plus determines whether it is a LRA target or reload target
by scanning the -fdump-rtl-reload-details dump on an empty function,
LRA has quite a few always emitted messages in that case while reload has
none of those.

Tested on x86_64-linux and cross to s390x-linux, for the latter with both
make check-gcc RUNTESTFLAGS='--target_board=unix/-mno-lra dg.exp=pr107385.c'
where the test is now UNSUPPORTED and
make check-gcc RUNTESTFLAGS='--target_board=unix/-mlra dg.exp=pr107385.c'
where it fails because I don't have libc around.

There is one special case, NVPTX, which is a TARGET_NO_REGISTER_ALLOCATION
target.  I think claiming for it that it is a lra target is strange (even
though it effectively returns true for targetm.lra_p ()), unsure if it
supports asm goto with outputs or not, if it does and we want to test it,
perhaps we should introduce asm_goto_outputs effective target and use
lra || nvptx-*-* for that?

2024-02-17  Jakub Jelinek  <jakub@redhat.com>

	* lib/target-supports.exp (check_effective_target_lra): Rewrite
	to list some heavily used always LRA targets and otherwise check the
	-fdump-rtl-reload-details dump for messages specific to LRA.

Fix a typo in __gthr_win32_abs_to_rel_time that caused it to return a
relative time in seconds instead of milliseconds. As a consequence,
__gthr_win32_cond_timedwait called SleepConditionVariableCS with a
1000x shorter timeout; this caused ~1000x more spurious wakeups in
CV timed waits such as std::condition_variable::wait_for or wait_until,
resulting generally in much higher CPU usage.

This can be demonstrated by this sample program:

```

int main() {
    std::condition_variable cv;
    std::mutex mx;
    bool pass = false;

    auto thread_fn = [&](bool timed) {
        int wakeups = 0;
        using sc = std::chrono::system_clock;
        auto before = sc::now();
        std::unique_lock<std::mutex> ml(mx);
        if (timed) {
            cv.wait_for(ml, std::chrono::seconds(2), [&]{
                ++wakeups;
                return pass;
            });
        } else {
            cv.wait(ml, [&]{
                ++wakeups;
                return pass;
            });
        }
        printf("pass: %d; wakeups: %d; elapsed: %d ms\n", pass, wakeups,
                int((sc::now() - before) / std::chrono::milliseconds(1)));
        pass = false;
    };

    {
        // timed wait, let expire
        std::thread t(thread_fn, true);
        t.join();
    }

    {
        // timed wait, wake up explicitly after 1 second
        std::thread t(thread_fn, true);
        std::this_thread::sleep_for(std::chrono::seconds(1));
        {
            std::unique_lock<std::mutex> ml(mx);
            pass = true;
        }
        cv.notify_all();
        t.join();
    }

    {
        // non-timed wait, wake up explicitly after 1 second
        std::thread t(thread_fn, false);
        std::this_thread::sleep_for(std::chrono::seconds(1));
        {
            std::unique_lock<std::mutex> ml(mx);
            pass = true;
        }
        cv.notify_all();
        t.join();
    }
    return 0;
}
```

On builds based on non-affected threading models (e.g. POSIX on Linux,
or winpthreads or MCF on Win32) the output is something like
```
pass: 0; wakeups: 2; elapsed: 2000 ms
pass: 1; wakeups: 2; elapsed: 991 ms
pass: 1; wakeups: 2; elapsed: 996 ms
```

while with the Win32 threading model we get
```
pass: 0; wakeups: 1418; elapsed: 2000 ms
pass: 1; wakeups: 479; elapsed: 988 ms
pass: 1; wakeups: 2; elapsed: 992 ms
```
(notice the huge number of wakeups in the timed wait cases only).

This commit fixes the conversion, adjusting the final division by
NSEC100_PER_SEC to use NSEC100_PER_MSEC instead (already defined in the
file and not used in any other place, so probably just a typo).

libgcc/ChangeLog:

	PR libgcc/113850
	* config/i386/gthr-win32-cond.c (__gthr_win32_abs_to_rel_time):
	fix absolute timespec to relative milliseconds count
	conversion (it incorrectly returned seconds instead of
	milliseconds); this avoids spurious wakeups in
	__gthr_win32_cond_timedwait

As noticed by Marek Polacek in https://gcc.gnu.org/pipermail/gcc-patches/2024-February/645836.html

,
this testcase was not failing before without -Wstrict-aliasing so let's add that option.

Committed as obvious after testing to make sure the test is now testing with `-Wstrict-aliasing` and `-flto`.

gcc/testsuite/ChangeLog:

	* g++.dg/torture/vector-struct-1.C: Add -Wstrict-aliasing.

Signed-off-by: Andrew Pinski <quic_apinski@quicinc.com>

gcc/po/
	* gcc.pot: Regenerate.

libcpp/po/
	* cpplib.pot: Regenerate.

I noticed we don't implement the "unless the overriding function is
defined as deleted" wording added to [except.spec] via CWG 1351.

	DR 1351

gcc/cp/ChangeLog:

	* search.cc (maybe_check_overriding_exception_spec): Don't error about
	a looser exception specification if the overrider is deleted.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/noexcept82.C: New test.

	PR libstdc++/87744
	PR libstdc++/113961

libstdc++-v3/ChangeLog:

	* testsuite/26_numerics/random/pr60037-neg.cc: Adjust dg-error
	line number.