Fix declare copyout in libgomp.oacc-c++/declare-pr94120.C

Testing on the host does not make sense for 'declare copyout' for
a same-scope stack-allocated variable. Once the copyout is done,
the variable is gone. Hence, test the variable on the device. This
can be revisit after the OpenACC semantic has been fixed; but with
that fix, the test PASSes again with devices.

        PR middle-end/94120
        * testsuite/libgomp.oacc-c++/declare-pr94120.C: Fix 'declare copy(out)'
        test case.

Daily bump.

libstdc++: Define operator<=> for std::stack and std::queue

Some more C++20 changes from P1614R2, "The Mothership has Landed".

* include/bits/stl_queue.h (queue): Define operator<=> for C++20.
* include/bits/stl_stack.h (stack): Likewise.
* testsuite/23_containers/queue/cmp_c++20.cc: New test.
* testsuite/23_containers/stack/cmp_c++20.cc: New test.

libstdc++: Remove operator!= overloads for unordered containers

Some more C++20 changes from P1614R2, "The Mothership has Landed".

* include/bits/unordered_map.h (unordered_map, unordered_multimap):
Remove redundant operator!= for C++20.
* include/bits/unordered_set.h (unordered_set, unordered_multiset):
Likewise.
* include/debug/unordered_map (unordered_map, unordered_multimap):
Likewise.
* include/debug/unordered_set (unordered_set, unordered_multiset):
Likewise.

libstdc++: Fix redundant assignment (PR 94629)

This appears to be a copy&paste error, which cppcheck diagnoses.

PR other/94629
* include/debug/formatter.h (_Error_formatter::_Parameter): Fix
redundant assignment in constructor.

rs6000: Skip DWARF5 and -fcompare-debug testcases on AIX.

AIX does not support DWARF5 sections.
-fcompare-debug causes gratuitous testcase failures on AIX.

2020-04-19  David Edelsohn  <dje.gcc@gmail.com>

        * g++.dg/debug/dwarf2/pr85550.C: Skip AIX.
        * g++.dg/debug/pr94272.C: Skip AIX.
        * g++.dg/debug/pr94281.C: Skip AIX.
        * g++.dg/debug/pr94323.C: Skip AIX.

libphobos: Merge upstream phobos bf0d0a37c

std.array.Appender and RefAppender: use .opSlice() instead of data()

Previously, Appender.data() was used to extract a slice of the Appender's array.
Now use the [] slice operator instead.  The same goes for RefAppender.

Fixes: PR d/94455
Reviewed-on: https://github.com/dlang/phobos/pull/7450

libphobos: Merge upstream phobos 99003a75a

Fixes hasLength unittest to pass on X32.

References: PR d/94609

Reviewed-on: https://github.com/dlang/phobos/pull/7448

d/dmd: Merge upstream dmd ba99ee345

Initializes the VectorArrayExp::size field with the correct value.

Fixes: PR d/94652
Reviewed-on: https://github.com/dlang/dmd/pull/11046

d/dmd: Merge upstream dmd 09be6ee14

Initializes ncost before use, which was caught by valgrind.

Fixes: PR d/94653
Reviewed-on: https://github.com/dlang/dmd/pull/11045

i386: Remove unneeded assignments when triggering SSE exceptions

According to "Intel 64 and IA32 Arch SDM, Vol. 3:

"Because SIMD floating-point exceptions are precise and occur immediately,
the situation does not arise where an x87 FPU instruction, a WAIT/FWAIT
instruction, or another SSE/SSE2/SSE3 instruction will catch a pending
unmasked SIMD floating-point exception."

Remove unneeded assignments to volatile memory.

libgcc/ChangeLog:

* config/i386/sfp-exceptions.c (__sfp_handle_exceptions) [__SSE_MATH__]:
Remove unneeded assignments to volatile memory.

libatomic/ChangeLog:

* config/x86/fenv.c (__atomic_feraiseexcept) [__SSE_MATH__]:
Remove unneeded assignments to volatile memory.

libgfortran/ChangeLog:

* config/fpu-387.h (local_feraiseexcept) [__SSE_MATH__]:
Remove unneeded assignments to volatile memory.

coroutines, testsuite: Require C++17 for two tests.

While the coroutines implementation, and most of the coroutines
tests, will operate with C++14 or newer, these tests require
facilities introduced in C++17.  Add the target requirement.

gcc/testsuite/

2020-04-19  Iain Sandoe  <iain@sandoe.co.uk>

* g++.dg/coroutines/torture/co-await-17-capture-comp-ref.C: Require
C++17.
* g++.dg/coroutines/torture/co-ret-15-default-return_void.C: Likewise.

PR 94347 - fix previous ChangeLog entry.

PR 94347 - add a test case for something a PR has fixed itself.

2020-04-19  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/94347
* gfortran.dg/char_pointer_init_1.f90: New test.

Commit test case for PR 57129.

2020-04-19  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/57129
* gfortran.dg/subroutine_as_type.f90: New test.

Fix PR fortran/93500, ICE on invalid.

Returning &gfc_bad_expr when simplifying bounds after a divisin by zero
happened results in the division by zero error actually reaching the user.

2020-04-19  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/93500
* resolve.c (resolve_operator): If both operands are
NULL, return false.
* simplify.c (simplify_bound): If a division by zero
was seen during bound simplification, free the
corresponcing expression and return &gfc_bad_expr.

2020-04-19  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/93500
* arith_divide_3.f90: New test.

c, objc: Fix up c_parser_objc_selector_arg after CPP_SCOPE changes [PR94637]

Similarly to inline asm, :: (or any other number of consecutive colons) can
appear in ObjC @selector argument and with the introduction of CPP_SCOPE
into the C FE, we need to trat CPP_SCOPE as two CPP_COLON tokens.
The C++ FE does that already that way.

2020-04-19  Jakub Jelinek  <jakub@redhat.com>

PR objc/94637
* c-parser.c (c_parser_objc_selector_arg): Handle CPP_SCOPE like
two CPP_COLON tokens.

* objc.dg/pr94637.m: New test.

d: Fix FAIL in gdc.dg/runnable.d on X32 targets (PR94609)

Patch fixes test failure seen on X32 where a nested struct was passed in
registers, rather than via invisible reference.  Now, all non-POD
structs are passed by invisible reference, not just those with a
user-defined copy constructor/destructor.

gcc/d/ChangeLog:

PR d/94609
* d-codegen.cc (argument_reference_p): Don't check TREE_ADDRESSABLE.
(type_passed_as): Build reference type if TREE_ADDRESSABLE.
* d-convert.cc (convert_for_argument): Build explicit TARGET_EXPR if
needed for arguments passed by invisible reference.
* types.cc (TypeVisitor::visit (TypeStruct *)): Mark all structs that
are not POD as TREE_ADDRESSABLE.

Daily bump.

Add missing changelog entries for r10-7790

libphobos: Add --with-libphobos-druntime-only option.

The intended purpose of the option is both for targets that don't
support phobos yet, and for gdc itself to support bootstrapping itself
as a self-hosted D compiler.

The libphobos testsuite has been updated to only add libphobos to the
search paths if it's being built.  A new D2 testsuite directive
RUNNABLE_PHOBOS_TEST has also been patched in to disable some runnable
tests that have phobos dependencies, of which is a temporary measure
until upstream DMD fixes or removes these tests entirely.

gcc/testsuite/ChangeLog:

* lib/gdc-utils.exp (gdc-convert-test): Add dg-skip-if for tests that
depending on the phobos standard library.

libphobos/ChangeLog:

* configure: Regenerate.
* configure.ac: Add --with-libphobos-druntime-only option and the
conditional ENABLE_LIBDRUNTIME_ONLY.
* configure.tgt: Define LIBDRUNTIME_ONLY.
* src/Makefile.am: Add phobos sources if not ENABLE_LIBDRUNTIME_ONLY.
* src/Makefile.in: Regenerate.
* testsuite/testsuite_flags.in: Add phobos path if compiling phobos.

Don't let DEBUG_INSNSs change register renaming decisions

PR debug/94439
* regrename.c (check_new_reg_p): Ignore DEBUG_INSNs when walking
the chain.

PR debug/94439
* gcc.dg/torture/pr94439.c: New test.

testsuite: Disable gdc standard runtime tests if phobos is not built.

The current check_effective_target_d_runtime procedure returns false if
the target is built without any core runtime library for D being
available (--disable-libphobos).  This additional procedure is for
targets where the core runtime library exists, but without the higher
level standard library.

gcc/ChangeLog:

* doc/sourcebuild.texi (Effective-Target Keywords, Environment
attributes): Document d_runtime_has_std_library.

gcc/testsuite/ChangeLog:

* gdc.dg/link.d: Use d_runtime_has_std_library effective target.
* gdc.dg/runnable.d: Move phobos tests to...
* gdc.dg/runnable2.d: ...here.  New test.
* lib/target-supports.exp
(check_effective_target_d_runtime_has_std_library): New.

libphobos/ChangeLog:

* testsuite/libphobos.phobos/phobos.exp: Skip if effective target is
not d_runtime_has_std_library.
* testsuite/libphobos.phobos_shared/phobos_shared.exp: Likewise.

c++: spec_hasher::equal and PARM_DECLs [PR94632]

In the testcase below, during specialization of c<int>::d, we build two
identical specializations of the parameter type b<decltype(e)::k> -- one when
substituting into c<int>::d's TYPE_ARG_TYPES and another when substituting into
c<int>::d's DECL_ARGUMENTS.

We don't reuse the first specialization the second time around as a consequence
of the fix for PR c++/56247 which made PARM_DECLs always compare different from
one another during spec_hasher::equal.  As a result, when looking up existing
specializations of 'b', spec_hasher::equal considers the template argument
decltype(e')::k to be different from decltype(e'')::k, where e' and e'' are the
result of two calls to tsubst_copy on the PARM_DECL e.

Since the two specializations are considered different due to the mentioned fix,
their TYPE_CANONICAL points to themselves even though they are otherwise
identical types, and this triggers an ICE in maybe_rebuild_function_decl_type
when comparing the TYPE_ARG_TYPES of c<int>::d to its DECL_ARGUMENTS.

This patch fixes this issue at the spec_hasher::equal level by ignoring the
'comparing_specializations' flag in cp_tree_equal whenever the DECL_CONTEXTs of
the two parameters are identical.  This seems to be a sufficient condition to be
able to correctly compare PARM_DECLs structurally.  (This also subsumes the
CONSTRAINT_VAR_P check since constraint variables all have empty, and therefore
identical, DECL_CONTEXTs.)

gcc/cp/ChangeLog:

PR c++/94632
* tree.c (cp_tree_equal) <case PARM_DECL>: Ignore
comparing_specializations if the parameters' contexts are identical.

gcc/testsuite/ChangeLog:

PR c++/94632
* g++.dg/template/canon-type-14.C: New test.

c++: Abbreviated function template return type [PR92187]

When updating an auto return type of an abbreviated function template in
splice_late_return_type, we should also propagate PLACEHOLDER_TYPE_CONSTRAINTS
(and cv-qualifiers) of the original auto node.

gcc/cp/ChangeLog:

PR c++/92187
* pt.c (splice_late_return_type): Propagate cv-qualifiers and
PLACEHOLDER_TYPE_CONSTRAINTS from the original auto node to the new one.

gcc/testsuite/ChangeLog:

PR c++/92187
* g++.dg/concepts/abbrev5.C: New test.
* g++.dg/concepts/abbrev6.C: New test.

Daily bump.

libstdc++: Add comparison operators to <chrono> types

Some more C++20 changes from P1614R2, "The Mothership has Landed".

* include/std/chrono (duration, time_point): Define operator<=> and
remove redundant operator!= for C++20.
* testsuite/20_util/duration/comparison_operators/three_way.cc: New
test.
* testsuite/20_util/time_point/comparison_operators/three_way.cc: New
test.

libstdc++: Fix testsuite utility's use of allocators

In C++20 the rebind and const_reference members of std::allocator are
gone, so this testsuite utility stopped working, causing
ext/pb_ds/regression/priority_queue_rand_debug.cc to FAIL.

* testsuite/util/native_type/native_priority_queue.hpp: Use
allocator_traits to rebind allocator.

libstdc++: Add comparison operators to sequence containers

Some more C++20 changes from P1614R2, "The Mothership has Landed".

This implements <=> for sequence containers (and the __normal_iterator
and _Pointer_adapter class templates).

* include/bits/forward_list.h (forward_list): Define operator<=> and
remove redundant comparison operators for C++20.
* include/bits/stl_bvector.h (vector<bool, Alloc>): Likewise.
* include/bits/stl_deque.h (deque): Likewise.
* include/bits/stl_iterator.h (__normal_iterator): Likewise.
* include/bits/stl_list.h (list): Likewise.
* include/bits/stl_vector.h (vector): Likewise.
* include/debug/deque (__gnu_debug::deque): Likewise.
* include/debug/forward_list (__gnu_debug::forward_list): Likewise.
* include/debug/list (__gnu_debug::list): Likewise.
* include/debug/safe_iterator.h (__gnu_debug::_Safe_iterator):
Likewise.
* include/debug/vector (__gnu_debug::vector): Likewise.
* include/ext/pointer.h (__gnu_cxx::_Pointer_adapter): Define
operator<=> for C++20.
* testsuite/23_containers/deque/operators/cmp_c++20.cc: New test.
* testsuite/23_containers/forward_list/cmp_c++20.cc: New test.
* testsuite/23_containers/list/cmp_c++20.cc: New test.
* testsuite/23_containers/vector/bool/cmp_c++20.cc: New test.
* testsuite/23_containers/vector/cmp_c++20.cc: New test.

[committed] [PR rtl-optimization/90275] Another 90275 related cse.c fix

This time instead of having a NOP copy insn that we can completely ignore and
ultimately remove, we have a NOP set within a multi-set PARALLEL.  It triggers,
the same failure when the source of such a set is a hard register for the same
reasons as we've already noted in the BZ and patches-to-date.

For prior cases we've been able to mark the insn as a nop set and ignore it for
the rest of cse_insn, ultimately removing it.  That's not really an option here
as there are other sets that we have to preserve.

We might be able to fix this instance by splitting the multi-set insn, but I'm
not keen to introduce splitting into cse.  Furthermore, the target may not be
able to split the insn.  So I considered this is non-starter.

What I finally settled on was to use the existing do_not_record machinery to
ignore the nop set within the parallel (and only that set within the parallel).

One might argue that we should always ignore a REG_UNUSED set.  But I rejected
that idea -- we could have cse-able divmod insns where the first had a
REG_UNUSED note for a destination, but the second did not.

One might also argue that we could have a nop set without a REG_UNUSED in a
multi-set parallel and thus we could trigger yet another insert_regs ICE at
some point.  I tend to think this is a possibility.  If we see this happen,
we'll have to revisit.

PR rtl-optimization/90275
* cse.c (cse_insn): Avoid recording nop sets in multi-set parallels
when the destination has a REG_UNUSED note.

c++: Non-type-dependent variadic lambda init-capture [PR94483]

In this PR, we're ICEing on a use of an 'int... a' template parameter pack as
part of the variadic lambda init-capture [...z=a].

The unexpected thing about this variadic init-capture is that it is not
type-dependent, and so the call to do_auto_deduction from
lambda_capture_field_type actually resolves its type to 'int' instead of exiting
early like it does for a type-dependent variadic initializer.  This later
confuses add_capture which, according to one of its comments, assumes that
'type' is always 'auto' for a variadic init-capture.

The simplest fix (and the approach that this patch takes) seems to be to avoid
doing auto deduction in lambda_capture_field_type when the initializer uses
parameter packs, so that we always return 'auto' even in the non-type-dependent
case.

gcc/cp/ChangeLog:

PR c++/94483
* lambda.c (lambda_capture_field_type): Avoid doing auto deduction if
the explicit initializer has parameter packs.

gcc/testsuite/ChangeLog:

PR c++/94483
* g++.dg/cpp2a/lambda-pack-init5.C: New test.

c++: Hard error with tentative parse of declaration [PR88754]

In the testcase for this PR, we try to parse the statement

  A(value<0>());

first tentatively as a declaration (with a parenthesized declarator), and during
this tentative parse we end up issuing a hard error from
cp_parser_check_template_parameters about its invalidness as a declaration.

Rather than issuing a hard error, it seems we should instead simulate an error
since we're parsing tentatively.  This would then allow cp_parser_statement to
recover and successfully parse the statement as an expression-statement instead.

gcc/cp/ChangeLog:

PR c++/88754
* parser.c (cp_parser_check_template_parameters): Before issuing a hard
error, first try simulating an error instead.

gcc/testsuite/ChangeLog:

PR c++/88754
* g++.dg/parse/ambig10.C: New test.

Fix ICE on invalid, PR94090.

The attached patch fixes an ICE on invalid: When the return type of
a function was misdeclared with a wrong rank, we issued a warning,
but not an error (unless with -pedantic); later on, an ICE ensued.

Nothing good can come from wrongly declaring a function type
(considering the ABI), so I changed that into a hard error.

2020-04-17  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/94090
* gfortran.dg (gfc_compare_interfaces): Add
optional argument bad_result_characteristics.
* interface.c (gfc_check_result_characteristics): Fix
whitespace.
(gfc_compare_interfaces): Handle new argument; return
true if function return values are wrong.
* resolve.c (resolve_global_procedure): Hard error if
the return value of a function is wrong.

2020-04-17  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/94090
* gfortran.dg/interface_46.f90: New test.

[OpenMP] Fix 'omp exit data' for Fortran arrays (PR 94635)

PR middle-end/94635
* gimplify.c (gimplify_scan_omp_clauses): Turn MAP_TO_PSET to
MAP_DELETE.

PR middle-end/94635
* testsuite/libgomp.fortran/target-enter-data-2.F90: New.

libstdc++: Add comparison operators for string and regex types

Some more C++20 changes from P1614R2, "The Mothership has Landed".

This adds three-way comparison support to std::char_traits,
std::basic_string, std::basic_string_view, and std::sub_match.

* include/bits/basic_string.h (basic_string): Define operator<=> and
remove redundant comparison operators for C++20.
* include/bits/char_traits.h (__gnu_cxx::char_traits, char_traits):
Add comparison_category members.
(__detail::__char_traits_cmp_cat): New helper to get comparison
category from char traits class.
* include/bits/regex.h (regex_traits::_RegexMask::operator!=): Do not
define for C++20.
(sub_match): Define operator<=> and remove redundant comparison
operators for C++20.
(match_results): Remove redundant operator!= for C++20.
* include/std/string_view (basic_string_view): Define operator<=> and
remove redundant comparison operators for C++20.
* testsuite/21_strings/basic_string/operators/char/cmp_c++20.cc: New
test.
* testsuite/21_strings/basic_string/operators/wchar_t/cmp_c++20.cc:
New test.
* testsuite/21_strings/basic_string_view/operations/copy/char/
constexpr.cc: Initialize variable.
* testsuite/21_strings/basic_string_view/operations/copy/wchar_t/
constexpr.cc: Likewise.
* testsuite/21_strings/basic_string_view/operators/char/2.cc: Add
dg-do directive and remove comments showing incorrect signatures.
* testsuite/21_strings/basic_string_view/operators/wchar_t/2.cc:
Likewise.
* testsuite/21_strings/basic_string_view/operators/char/cmp_c++20.cc:
New test.
* testsuite/21_strings/basic_string_view/operators/wchar_t/cmp_c++20.cc:
New test.
* testsuite/28_regex/sub_match/compare_c++20.cc: New test.

aarch64: Tweak SVE load/store costs

We were seeing performance regressions on 256-bit SVE with code like:

  for (int i = 0; i < count; ++i)
  #pragma GCC unroll 128
    for (int j = 0; j < 128; ++j)
      *dst++ = 1;

(derived from lmbench).

For 128-bit SVE, it's clearly better to use Advanced SIMD STPs here,
since they can store 256 bits at a time.  We already do this for
-msve-vector-bits=128 because in that case Advanced SIMD comes first
in autovectorize_vector_modes.

If we handled full-loop predication well for this kind of loop,
the choice between Advanced SIMD and 256-bit SVE would be mostly
a wash, since both of them could store 256 bits at a time.  However,
SVE would still have the extra prologue overhead of setting up the
predicate, so Advanced SIMD would still be the natural choice.

As things stand though, we don't handle full-loop predication well
for this kind of loop, so the 256-bit SVE code is significantly worse.
Something to fix for GCC 11 (hopefully).  However, even though we
account for the overhead of predication in the cost model, the SVE
version (wrongly) appeared to need half the number of stores.
That was enough to drown out the predication overhead and meant
that we'd pick the SVE code over the Advanced SIMD code.

512-bit SVE has a clear advantage over Advanced SIMD, so we should
continue using SVE there.

This patch tries to account for this in the cost model.  It's a bit
of a compromise; see the comment in the patch for more details.

2020-04-17  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
* config/aarch64/aarch64.c (aarch64_advsimd_ldp_stp_p): New function.
(aarch64_sve_adjust_stmt_cost): Add a vectype parameter.  Double the
cost of load and store insns if one loop iteration has enough scalar
elements to use an Advanced SIMD LDP or STP.
(aarch64_add_stmt_cost): Update call accordingly.

gcc/testsuite/
* gcc.target/aarch64/sve/cost_model_2.c: New test.
* gcc.target/aarch64/sve/cost_model_3.c: Likewise.
* gcc.target/aarch64/sve/cost_model_4.c: Likewise.
* gcc.target/aarch64/sve/cost_model_5.c: Likewise.
* gcc.target/aarch64/sve/cost_model_6.c: Likewise.
* gcc.target/aarch64/sve/cost_model_7.c: Likewise.

c, c++: Fix two redundantAssignment warnings [PR94629]

This change fixes two obvious redundant assignments reported by cppcheck:
trunk.git/gcc/c/c-parser.c:16969:2: style: Variable 'data.clauses' is reassigned a value before the old one has been used. [redundantAssignment]
trunk.git/gcc/cp/call.c:5116:9: style: Variable 'arg2' is reassigned a value before the old one has been used. [redundantAssignment]

2020-04-17  Jakub Jelinek  <jakub@redhat.com>

PR other/94629
* c-parser.c (c_parser_oacc_routine): Remove redundant assignment
to data.clauses.

* call.c (build_conditional_expr_1): Remove redundant assignment to
arg2.

i386: Fix up *testqi_ext_3 define_insn_and_split [PR94567]

As the testcase shows, there are unfortunately more problematic cases
in *testqi_ext_3 if the mode is not CCZmode, because the sign flag might
not behave the same between the insn with zero_extract and what we split it
into.

The previous fix to the insn condition was because *testdi_1 for mask with
upper 32-bits clear and bit 31 set is implemented using SImode test and thus
SF is set depending on that bit 31 rather than on always cleared.

But we can have other cases.  On the zero_extract (which has <MODE>mode),
we can have either the pos + len == precision of <MODE>mode, or
pos + len < precision of <MODE>mode cases.  The former one copies the most
significant bit into SF, the latter will have SF always cleared.

For the former case, either it is a zero_extract from a larger mode, but
then when we perform test in that larger mode, SF will be always clear and
thus mismatch from the zero_extract case (so we need to enforce CCZmode),
or it will be a zero_extract from same mode with pos 0 and len equal to
mode precision, such zero_extracts should have been really simplified
into their first operand.

For the latter case, when SF is always clear on the define_insn with
zero_extract, we need to split into something that doesn't sometimes set
SF, i.e. it has to be a test with mask that doesn't have the most
significant bit set.  In some cases it can be achieved through using test
in a wider mode (e.g. in the testcase, there is
(zero_extract:SI (reg:HI) (const_int 13) (const_int 3))
which will always set SF to 0, but we split it into
(and:HI (reg:HI) (const_int -8))
which will copy the MSB of (reg:HI) into SF, but we can do:
(and:SI (subreg:SI (reg:HI) 0) (const_int 0xfff8))
which will keep SF always cleared), but there are various cases where we
can't (when already using DImode, or when SImode and we'd turned it into
the problematic *testdi_1 implemented using SImode test, or when
the val operand is a MEM (we don't want to read from memory more than
the user originally wanted), paradoxical subreg of MEM could be problematic
too if we through the narrowing end up with a MEM).

So, the patch attempts to require CCZmode (and not CCNOmode) if it can't
really ensure the SF will have same meaning between the define_insn and what
we split it into, and if we decide we allow CCNOmode, it needs to avoid
performing narrowing and/or widen if pos + len would indicate we'd have MSB
set in the mask.

2020-04-17  Jakub Jelinek  <jakub@redhat.com>
    Jeff Law  <law@redhat.com>

PR target/94567
* config/i386/i386.md (*testqi_ext_3): Use CCZmode rather than
CCNOmode in ix86_match_ccmode if len is equal to <MODE>mode precision,
or pos + len >= 32, or pos + len is equal to operands[2] precision
and operands[2] is not a register operand.  During splitting perform
SImode AND if operands[0] doesn't have CCZmode and pos + len is
equal to mode precision.

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

Co-Authored-By: Jeff Law <law@redhat.com>

Avoid testcase warning on arm ABI [pr94608]

PR c++/94608
* g++.dg/lto/pr83720_0.C: Add fn def to avoid warning on arm ABI.

Initialize file_data->lto_section_header before lto_mode_identity_table call.

PR lto/94612
* lto-common.c: Initialize file_data->lto_section_header
before lto_mode_identity_table call.  It is needed because
it decompresses a LTO section.

fix PVS studio reported bugs

2020-04-17  Richard Biener  <rguenther@suse.de>

PR other/94629
* cgraphclones.c (cgraph_node::create_clone): Remove duplicate
initialization.
* dwarf2out.c (dw_val_equal_p): Fix pasto in
dw_val_class_vms_delta comparison.
* optabs.c (expand_binop_directly): Fix pasto in commutation
check.
* tree-ssa-sccvn.c (vn_reference_lookup_pieces): Fix pasto in
initialization.

Fix -fcompare-debug issue in delete_insn_and_edges [PR94618]

delete_insn_and_edges calls purge_dead_edges whenever deleting the last insn
in a bb, whatever it is.  If it called it only for mandatory last insns
in the basic block (that may not be followed by DEBUG_INSNs, dunno if that
is control_flow_insn_p or something more complex), that wouldn't be a
problem, but as it calls it on any last insn and can actually do something
in the bb, if such an insn is followed by one more more DEBUG_INSNs and
nothing else in the same bb, we don't call purge_dead_edges with -g and do
call it with -g0.

On the testcase, there are two reg-to-reg moves with REG_EH_REGION notes
(previously memory accesses but simplified and yet not optimized), and the
second is followed by DEBUG_INSNs; the second move is delete_insn_and_edges
and after removing it, for -g0 purge_dead_edges removes the REG_EH_REGION
from the now last insn in the bb (the first reg-to-reg move), while
for -g it isn't called and things diverge from that quickly on.

Fixed by calling purdge_dead_edges even if we remove the last real insn
followed only by DEBUG_INSNs in the same bb.

2020-04-17  Jakub Jelinek  <jakub@redhat.com>

PR rtl-optimization/94618
* cfgrtl.c (delete_insn_and_edges): Set purge not just when
insn is the BB_END of its block, but also when it is only followed
by DEBUG_INSNs in its block.

* g++.dg/opt/pr94618.C: New test.

inliner: Don't ICE on NULL TYPE_DOMAIN [PR94621]

When I've added the VLA tweak for OpenMP to avoid error_mark_nodes in the IL in
type, I forgot that TYPE_DOMAIN could be NULL.  Furthermore, as an optimization,
this patch checks the hopefully cheapest condition that is very likely false
most of the time (enabled only during OpenMP handling) first.

2020-04-17  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/94621
* tree-inline.c (remap_type_1): Don't dereference NULL TYPE_DOMAIN.
Move id->adjust_array_error_bounds check first in the condition.

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

Do not use HAVE_DOS_BASED_FILE_SYSTEM for Cygwin.

PR gcov-profile/94570
* ltmain.sh: Do not define HAVE_DOS_BASED_FILE_SYSTEM
for CYGWIN.

PR gcov-profile/94570
* coverage.c (coverage_init): Use separator properly.

PR gcov-profile/94570
* filenames.h (defined): Do not define HAVE_DOS_BASED_FILE_SYSTEM
for CYGWIN.

Co-Authored-By: Jonathan Yong <10walls@gmail.com>

testsuite: Fix up test language requirements [PR94314]

With c++11 one gets:
Excess errors:
.../testsuite/g++.dg/pr94314-4.C:19:28: error: too many arguments to function 'void operator delete(void*)'
because C++ sized deallocation is a C++14 feature.

2020-04-17  Jakub Jelinek  <jakub@redhat.com>

PR c++/94314
* g++.dg/pr94314-4.C: Require c++14 rather than c++11.

Do not modify tab options in vimrc for .py files.

* vimrc: We do not want to modify tab options
for Python files.

rs6000: Fix ICE in decompose_normal_address. [PR93974]

Fix an ICE in decompose_normal_address(), which cannot handle Altivec AND:
addresses, by disallowing them via implementing the target hook
rs6000_cannot_substitute_mem_equiv_p.

gcc/
PR rtl-optimization/93974
* config/rs6000/rs6000.c (TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P): Define.
(rs6000_cannot_substitute_mem_equiv_p): New function.

gcc/testsuite/
PR rtl-optimization/93974
* g++.dg/pr93974.C: New test.

Daily bump.

coroutines: Back out mandate for tail-calls at O < 2 [PR94359]

For symmetric transfers to work with C++20 coroutines, it is
currently necessary to tail call the callee coroutine from resume
method of the caller coroutine.  However there are several targets
which don't support an indirect tail call to an arbitrary callee.

Unfortunately, the target 'function_ok_for_sibcall' is not usable
from the front end in all cases.  While it is possible to add a new
hook to cover this circumstance, it is too late in the release
cycle to be sure of getting the setting correct for all targets.

So, this patch backs out the use of function_ok_for_sibcall () and
the mandate of CALL_EXPR_MUST_TAIL_CALL from the symmetric
transfer.

Targets that can make indirect tail calls to arbitrary callees will
still be able to make use of the symmetric transfer (without risking
overrunning the stack) for optimization levels >= 2.

The draft standard does not mandate unlimited symmetric transfers,
so removing this is a QOI issue (albeit an important one) rather
than a correctness one.

The test is moved and adjusted so that it can be opted into by any
target that supports the necessary tailcall.

gcc/cp/ChangeLog:

2020-04-16  Iain Sandoe  <iain@sandoe.co.uk>

PR c++/94359
* coroutines.cc (build_actor_fn): Back out use of
targetm.function_ok_for_sibcall.  Do not mark the resume
call as CALL_EXPR_MUST_TAIL_CALL.

gcc/testsuite/ChangeLog:

2020-04-16  Iain Sandoe  <iain@sandoe.co.uk>

PR c++/94359
* g++.dg/coroutines/torture/symmetric-transfer-00-basic.C: Move..
* g++.dg/coroutines/symmetric-transfer-00-basic.C: ..here and
adjust to run at O2 for targets supporting the necessary tail
call.

testsuite: Update pr94426-2 test to handle more targets [PR94426]

The function (_Z4InitIN3VARIZ1qvEUlvE_EUlvE_EEbT_) that initializes
VAR has changed siganture.  It was was weak / comdat [Linux] or
weak / global [Darwin] and now is text section local.

So: test that the symbol exists, is spelled the way intended by the
ABI mangling and is not weak (or global on Darwin).

gcc/testsuite/ChangeLog:

2020-04-16  Iain Sandoe  <iain@sandoe.co.uk>

PR c++/94426
* g++.dg/cpp0x/lambda/pr94426-2.C: Adjust scan-asms to test
for the change on more platforms.

ipa: Make call redirection detect already adjusted calls (PR 93621)

PR 93621 testcase makes redirect_call_stmt_to_callee wrongly assume
that a call statement needs redirecting but then rightly fails an
assert ensuring the call statement parameters have not already been
adjusted because they were already created adjusted as part of thunk
expansion.

The test fails because the decl in the call call statement is
different than the decl of the callee, because the latter was created
in save_inline_function_body.  This patch adds a way to link these two
and detect the situation in redirect_call_stmt_to_callee.

2020-04-16  Martin Jambor  <mjambor@suse.cz>

PR ipa/93621
* ipa-inline.h (ipa_saved_clone_sources): Declare.
* ipa-inline-transform.c (ipa_saved_clone_sources): New variable.
(save_inline_function_body): Link the new body holder with the
previous one.
* cgraph.c: Include ipa-inline.h.
(cgraph_edge::redirect_call_stmt_to_callee): Try to find the decl from
the statement in ipa_saved_clone_sources.
* cgraphunit.c: Include ipa-inline.h.
(expand_all_functions): Free ipa_saved_clone_sources.

testsuite/
* g++.dg/ipa/pr93621.C: New test.

aarch64: Fix mismatched SVE predicate modes [PR94606]

For this testcase we ended up generating the invalid rtl:

(insn 10 9 11 2 (set (reg:VNx16BI 105)
        (and:VNx16BI (xor:VNx16BI (reg:VNx8BI 103)
                (reg:VNx16BI 104))
            (reg:VNx16BI 104))) "/tmp/bar.c":9:12 -1
     (nil))

Fixed by taking the VNx16BI lowpart.  It's safe to do that here because
the gp (r104) masks out the extra odd-indexed bits.

2020-04-16  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
PR target/94606
* config/aarch64/aarch64.c (aarch64_expand_sve_const_pred_eor): Take
the VNx16BI lowpart of the recursively-generated constant.

gcc/testsuite/
PR target/94606
* gcc.dg/vect/pr94606.c: New test.

List valid pairs for new and delete operators.

PR c++/94314
* cgraphclones.c (set_new_clone_decl_and_node_flags): Drop
DECL_IS_REPLACEABLE_OPERATOR during cloning.
* tree-ssa-dce.c (valid_new_delete_pair_p): New function.
(propagate_necessity): Check operator names.

PR c++/94314
* g++.dg/pr94314.C: Do not use dg-additional-options
and remove not needed stdio.h include.
* g++.dg/pr94314-2.C: Likewise.
* g++.dg/pr94314-3.C: Likewise.
* g++.dg/pr94314-4.C: New test.

Co-Authored-By: Jakub Jelinek <jakub@redhat.com>

c++: Error recovery with erroneous DECL_INITIAL [PR94475]

Here we're ICE'ing in do_narrow during error-recovery, because ocp_convert
returns error_mark_node after it attempts to reduce a const decl to its
erroneous DECL_INITIAL via scalar_constant_value, and we later pass this
error_mark_node to fold_build2 which isn't prepared to handle error_mark_nodes.

We could fix this ICE in do_narrow by checking if ocp_convert returns
error_mark_node, but for the sake of consistency and for better error recovery
it seems it'd be preferable if ocp_convert didn't care that a const decl's
initializer is erroneous and would instead proceed as if the decl was not const,
which is the approach that this patch takes.

gcc/cp/ChangeLog:

PR c++/94475
* cvt.c (ocp_convert): If the result of scalar_constant_value is
erroneous, ignore it and use the original expression.

gcc/testsuite/ChangeLog:

PR c++/94475
* g++.dg/conversion/err-recover2.C: New test.
* g++.dg/diagnostic/pr84138.C: Remove now-bogus warning.
* g++.dg/warn/Wsign-compare-8.C: Remove now-bogus warning.

Make it possible to have different instrumented and feedback builds without copying gcda files around [pr93401]

Hi,
in GCC 8 we changed -fprofile-generate=<path> to use mangled absolute paths in
the <path> directory. This was necessary to avoid clashes of files when gcc is
executed from different directories to build different sources of same
filename.

However this made it difficult to build projects on setups where instrumented
build is done in one directory, feedback build in different and possibly
training happens in yet another directory structure.  This happens i.e. for
Firefox builds for month or two.

This patch adds -fprofile-prefix-path that can be used to inform gcc where the
root of build directory is and strip it form the gcda filenames.
This is similar to exisitng debug-prefix-map but without the map feature since
it seems useless for profile data.

We spent quite some time with Maritn Liska discussing options and found no
better solution.  I was looking how this work on LLVM and they produce single
profdata file which is then transformed into kind of simple database by
llvmprofdata tool.  This database keys functions by filename and symbol name.
If you arrane two files with same name define static variable with same symbol
name this gets messedup and result in wrong info. So I think this is not very
good solution and preffer the extra option.

Bootstrapped/regtested x86_64-linux. I plan to commit it later today if there
are no complains.

I suppose our manual could have some central section on profile feedback
explaining the whole setup at one place.

Honza

PR gcov-profile/93401
* common.opt (profile-prefix-path): New option.
* coverae.c: Include diagnostics.h.
(coverage_init): Strip profile prefix path.
* doc/invoke.texi (-fprofile-prefix-path): Document.

early-remat: Handle sets of multiple candidate regs [PR94605]

early-remat.c:process_block wasn't handling insns that set multiple
candidate registers, which led to an assertion failure at the end
of the main loop.

Instructions that set two pseudos aren't rematerialisation candidates in
themselves, but we still need to track them if another instruction that
sets the same register is a rematerialisation candidate.

2020-04-16  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
PR rtl-optimization/94605
* early-remat.c (early_remat::process_block): Handle insns that
set multiple candidate registers.

gcc/testsuite/
PR rtl-optimization/94605
* gcc.target/aarch64/sve/pr94605.c: New test.

cleanup graphite results

This removes { dg-final { scan-tree-dump "tiled" "graphite" } } scans
from graphite tests that pass/fail dependent on the ISL version used.
Note all scans match the actually dumped "not tiled" messages with
ISL 0.12 and not the alternative "tiled by <number>".  With ISL
0.22 neither is printed because the tiling infrastructure doesn't
expect the new schedule layout (though looking at a few cases it
looks superior with more dimensions marked as permutable.

Anyway, the scans have nothing to do with interchange and just
add to testsuite noise.

2020-04-16  Richard Biener  <rguenther@suse.de>

* gcc.dg/graphite/interchange-1.c: Remove scan for tiled.
* gcc.dg/graphite/interchange-10.c: Likewise.
* gcc.dg/graphite/interchange-11.c: Likewise.
* gcc.dg/graphite/interchange-3.c: Likewise.
* gcc.dg/graphite/interchange-4.c: Likewise.
* gcc.dg/graphite/interchange-7.c: Likewise.
* gcc.dg/graphite/interchange-9.c: Likewise.
* gcc.dg/graphite/uns-interchange-9.c: Likewise.
* gfortran.dg/graphite/interchange-3.f90: Likewise.

middle-end/94614 - avoid multiword moves to nothing

This adjusts emit_move_multi_word to handle moves into paradoxical
subregs parts that are not there and adjusts lower-subregs
CLOBBER resolving to deal with those as well.

2020-04-16  Richard Biener  <rguenther@suse.de>

PR middle-end/94614
* expr.c (emit_move_multi_word): Do not generate code when
the destination part is undefined_operand_subword_p.
* lower-subreg.c (resolve_clobber): Look through a paradoxica
subreg.

intl: Unbreak intl build with bison 3 when no regeneration is needed [PR92008]

As Iain reported, my change broke the case when one has bison >= 3,
but make decides there is no reason to regenerate plural.c, unfortunately
that seems to be a scenario I haven't tested.  The problem is that
the pregenerated plural.c has been generated with bison 1.35, but when
config.h says HAVE_BISON3, the code assumes it is the bison3 variant.
What used to work fine is when one has bison >= 3 and plural.c has been
regenerated (e.g. do touch intl/plural.y and it will work), or when
one doesn't have any bison (then nothing is regenerated, but HAVE_BISON3
isn't defined either), or when one has bison < 3 and doesn't need to
regenerate, or when one has bison < 3 and it is regenerated.

The following patch fixes this, by killing the HAVE_BISON3 macro from
config.h, and instead remembering the fact whether plural.c has been created
with bison < 3 or bison >= 3 in a separate new plural-config.h header.
The way this works:
- user doesn't have bison
- user has bison >= 3, but intl/{plural-config.h,plural.c} aren't older than intl/plural.y
- user has bison < 3, but intl/{plural-config.h,plural.c} aren't older than intl/plural.y
pregenerated !USE_BISON3 plural.c and plural-config.h from source
dir is used, nothing in the objdir
- user has bison >= 3 and intl/plural.y is newer
Makefile generates plural.c and USE_BISON3 plural-config.h in the
objdir, which is then used in preference to srcdir copies
- user has bison < 3 and intl/plural.y is newer
Makefile generates plural.c and !USE_BISON3 plural-config.h in the
objdir, which is then used in preference to srcdir copies
I have tested all these cases and make all-yes worked in all the cases.
If one uses the unsupported ./configure where srcdir == objdir, I guess
(though haven't tested) that it should still work, just it would be nice
if such people didn't try to check in the plural{.c,-config.h} they have
regenerated.
What doesn't work, but didn't work before either (just tested gcc-9 branch
too) is when one doesn't have bison and plural.y is newer than plural.c.
Don't do that ;)

2020-04-16  Jakub Jelinek  <jakub@redhat.com>

PR bootstrap/92008
intl/
* configure.ac: Remove HAVE_BISON3 AC_DEFINE.
* Makefile.in (HEADERS): Add plural-config.h.
(.y.c): Also create plural-config.h.
(dcigettext.o loadmsgcat.o plural.o plural-exp.o): Also depend
on plural-config.h.
(plural-config.h): Depend on plural.c.
* plural-exp.h: Include plural-config.h.  Use USE_BISON3 instead
of HAVE_BISON3.
* plural.y: Use USE_BISON3 instead of HAVE_BISON3.
* configure: Regenerated.
* plural.c: Regenerated.
* config.h.in: Regenerated.
* plural-config.h: Generated.
contrib/
* gcc_update: Add intl/plural.y dependency for intl/plural-config.h.

sra: Fix access verification (PR 94598)

get_ref_base_and_extent recognizes ARRAY_REFs with variable index but
into arrays of length one as constant offset accesses.  However,
max_size in such cases is extended to span the whole element.  This
confuses SRA verification when SRA also builds its (total
scalarization) access structures to describe fields under such array -
get_ref_base_and_extent returns different size and max_size for them.

Fixed by not performing the check for total scalarization accesses.
The subsequent check then had to be changed to use size and not
max_size too, which meant it has to be skipped when the access
structure describes a genuine variable array access.

Bootstrapped and tested on x86_64-linux.

2020-04-16  Martin Jambor  <mjambor@suse.cz>

PR tree-optimization/94598
* tree-sra.c (verify_sra_access_forest): Fix verification of total
scalarization accesses under access to one-element arrays.

testsuite/
* gcc.dg/tree-ssa/pr94598.c: New test.

testsuite: Move misplaced gcc.c-torture/pr92372.c test [PR92372]

This test got committed into a spot where nothing actually tests it.
As there is no main, I assume it was meant to be gcc.c-torture/compile/
test and the test PASSes after moving there (both x86_64-linux and
i686-linux).  Though, it passed before the PR92372 fixes too.

2020-04-16  Jakub Jelinek  <jakub@redhat.com>

PR ipa/92372
* gcc.c-torture/pr92372.c: Move ...
* gcc.c-torture/compile/pr92372.c: ... here.

bootstrap: Fix building with GCC 4.2 [PR89494]

GCC 4.2 (but I think not the latest tip of GCC 4.2 branch) has broken value
initialization, see PR33916.  The following patch provides a workaround for
that.  Tested with GCC 4.2 on a reduced testcase I've distilled from the
assign_param_data_one class which has been miscompiled the same.

2020-04-16  Jakub Jelinek  <jakub@redhat.com>

PR bootstrap/89494
* function.c (assign_parm_find_data_types): Add workaround for
BROKEN_VALUE_INITIALIZATION compilers.

intl: Allow building both with old bison and bison >= 3 [PR92008]

bison 3 apparently made a backwards incompatible change, dropped
YYLEX_PARAM/YYPARSE_PARAM support and instead needs %param or %lex-param
and %parse-param.  Furthermore, there is no easy way to conditionalize
on bison version in the *.y files.
While e.g. glibc bumped bison requirement and just has the bison 3
compatible version, Richi said there are still systems with older bison
where we want to build gcc.

So, this patch instead determines during configure bison version, and
depending on that when building plural.c (if building it at all) tweaks
what is passed over to bison if needed.

Tested with both bison 3 and bison 1.35, in each case with reconfiguring
intl and building with make all-yes (as in my setup intl isn't normally
used).

2020-04-16  Jakub Jelinek  <jakub@redhat.com>

PR bootstrap/92008
* configure.ac: Add check for bison >= 3, AC_DEFINE HAVE_BISON3
and AC_SUBST BISON3_YES and BISON3_NO.
* Makefile.in (.y.c): Prefix $(YACC) invocation with @BISON3_NO@,
add @BISON3_YES@ prefixed rule to adjust the *.y source using sed
and adjust output afterwards.
* plural-exp.h (PLURAL_PARSE): If HAVE_BISON3 is defined, use
struct parse_args * type for arg instead of void *.
* plural.y: Add magic /* BISON3 ... */ comments with bison >= 3
directives.
(YYLEX_PARAM, YYPARSE_PARAM): Don't define if HAVE_BISON3 is defined.
(yylex, yyerror): Adjust prototypes and definitions if HAVE_BISON3
is defined.
* plural.c: Regenerated.
* config.h.in: Regenerated.
* configure: Regenerated.

pretty-print SSA names

This adds the SSA name version to the gdb pretty-printing of SSA names.

(gdb) p (tree)$1
$5 = <ssa_name 0x7ffff68435a0 323>

2020-04-16  Richard Biener  <rguenther@suse.de>

* gdbhooks.py (TreePrinter): Print SSA_NAME_VERSION of SSA_NAME
nodes.

libstdc++: Fix -Wunused-parameter warning in test

* testsuite/20_util/unsynchronized_pool_resource/allocate.cc: Remove
name of unused parameter.

c++: Fix pasto in structured binding diagnostics [PR94571]

This snippet has been copied from the non-structured binding declaration
parsing later in the function, and while for non-structured bindings
it can be followed by comma or semicolon, structured bindings may be
only followed by semicolon.

Or, do we want to have a different message for the case when there is
a comma (and keep this corrected one only if there is something else)
that would explain better what is the bug (or add a fix-it hint)?
Marek said in the PR that clang++ reports
error: decomposition declaration must be the only declaration in its group

There is another thing Marek noted (though, something for different spot),
that diagnostic for auto x(1), [e,f] = test2; could also use a clearer
wording like the above (or a fix-it hint), but the question is if we should
assume [ after , as a structured binding or if we should do some tentative
parsing first to figure out if it looks like a structured binding.

2020-04-16  Jakub Jelinek  <jakub@redhat.com>

PR c++/94571
* parser.c (cp_parser_simple_declaration): Fix up a pasto in
diagnostics.

* g++.dg/cpp1z/decomp51.C: New test.

Daily bump.

runtime: use 64 bits of hash seed on arm64

This is the same issue as #33960, but on gofrontend.

Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/220297

libstdc++: Add comparison operators to std::filesystem types

Some more C++20 changes from P1614R2, "The Mothership has Landed".

* include/bits/fs_dir.h (file_status): Define operator== for C++20.
(directory_entry): Define operator<=> and remove redundant comparison
operators for C++20.
* include/bits/fs_fwd.h (space_info): Define operator== for C++20.
* include/bits/fs_path.h (path): Define operator<=> and remove
redundant comparison operators for C++20.
* testsuite/27_io/filesystem/path/compare/compare.cc: Fix comment.
* testsuite/27_io/filesystem/path/compare/lwg2936.cc: Likewise.
* testsuite/27_io/filesystem/path/compare/path.cc: Likewise.
* testsuite/27_io/filesystem/path/compare/strings.cc: Likewise.

Go Gcc_backend class: mark prefetch as novops

PR go/94607
* go-gcc.cc (class Gcc_backend): Define builtin_const,
builtin_noreturn, builtin_novops.
(Gcc_backend::define_builtin): Change const_p and noreturn_p
parameters to a single flags parameter.  Change all callers.
(Gcc_backend::Gcc_backend): Pass novops for prefetch.

libstdc++: Add comparison operators to types from Utilities clause

Some more C++20 changes from P1614R2, "The Mothership has Landed".

This removes all redundant equality and inequality operators in the
Utilities clause, as they can be synthesized from the remaining equality
operators.

It also removes the single redundant operator in the Localization
clause, because it didn't seem worth doing in a separate commit.

* include/bits/allocator.h (operator!=): Do not define for C++20.
* include/bits/locale_classes.h (operator!=): Likewise.
* include/bits/std_function.h (operator==(nullptr_t, const function&))
(operator!=(const function&, nullptr_t))
(operator!=(nullptr_t, const function&)): Likewise.
* include/ext/bitmap_allocator.h (operator!=): Likewise.
* include/ext/debug_allocator.h (operator!=): Likewise.
* include/ext/extptr_allocator.h (operator!=): Likewise.
* include/ext/malloc_allocator.h (operator!=): Likewise.
* include/ext/mt_allocator.h (operator!=): Likewise.
* include/ext/new_allocator.h (operator!=): Likewise.
* include/ext/pool_allocator.h (operator!=): Likewise.
* include/ext/throw_allocator.h (operator!=): Likewise.
* include/std/bitset (bitset::operator!=): Likewise.
* include/std/memory_resource (operator!=): Likewise.
* include/std/scoped_allocator (operator!=): Likewise.

libstdc++: Add spaceship operator to std::type_index

Another C++20 change from P1614R2, "The Mothership has Landed".

* include/std/typeindex (operator<=>): Define for C++20.
* testsuite/20_util/typeindex/comparison_operators_c++20.cc: New test.

Simplify recently introduced check to simplify_bound.

gcc/fortran/ChangeLog:

2020-04-15  Fritz Reese  <foreese@gcc.gnu.org>
Linus Koenig <link@sig-st.de>

PR fortran/94192
* simplify.c (simplify_bound): Simplify condition for error check.

i386: Require OPTION_MASK_ISA_SSE2 for __builtin_ia32_movq128 [PR94603]

PR target/94603
* config/i386/i386-builtin.def (__builtin_ia32_movq128):
Require OPTION_MASK_ISA_SSE2.

testsuite/ChangeLog:

PR target/94603
* gcc.target/i386/pr94603.c: New test.

selftest: Work around GCC 4.2 PR33916 bug by optimizing the ctor [PR89494]

GCC 4.2 due to PR33916 miscompiles temp_dump_context ctor, because it doesn't
zero initialize the whole dump_context temporary on which it runs the static
get method and during destruction of the temporary an uninitialized pointer
is deleted.

More recent GCC versions properly zero initialize it and ideally optimize away
the construction/destruction of the temporary, as it isn't used for anything,
but there is no reason to create the temporary, static member functions can
be called without an associated object.

2020-04-15  Gustavo Romero  <gromero@linux.ibm.com>

PR bootstrap/89494
* dumpfile.c (selftest::temp_dump_context::temp_dump_context):
Don't construct a dump_context temporary to call static method.

aarch64: Fix valid_src_p for use of uninitialized value

2020-04-15  Andrea Corallo  <andrea.corallo@arm.com>

* config/aarch64/falkor-tag-collision-avoidance.c
(valid_src_p): Check for aarch64_address_info type before
accessing base field.

Arm: MVE: Add mve vec_duplicate pattern

This patch fixes an ICE we were seeing due to a missing vec_duplicate pattern.

gcc/ChangeLog:
2020-04-15  Andre Vieira  <andre.simoesdiasvieira@arm.com>

* config/arm/mve.md (mve_vec_duplicate<mode>): New pattern.
(V_sz_elem2): Remove unused mode attribute.

gcc/testsuite/ChangeLog:
2020-04-15  Andre Vieira <andre.simoesdiasvieira@arm.com>
            Srinath Parvathaneni <srinath.parvathaneni@arm.com>

* gcc.target/arm/mve/intrinsics/mve_vec_duplicate.c: New test.

[Arm] Disallow arm_movdi when targetting MVE

Without disabling this, the pattern can try and move DImode values
between floating point registers and general registers.
The constraints on this pattern can't handle that, and reload goes into
an infinite loop.

This was the cause of a testsuite failure in cde_v_1_mve.c, which is now
gone.

A DImode move for MVE now uses the `movdi_vfp` pattern, which is the same
pattern used for such a move when MVE is not available but the target has
TARGET_HARD_FLOAT.

Testing done:
    Bootstrapped and regtested on arm-none-linux-gnueabihf
    regtested on arm-none-eabi

gcc/ChangeLog:

2020-04-15  Matthew Malcomson  <matthew.malcomson@arm.com>

* config/arm/arm.md (arm_movdi): Disallow for MVE.

aarch64: Fix bootstrap with old binutils [PR93053]

As reported in the PR, GCC 10 (and also 9.3.1 but not 9.3.0) fails to build
when using older binutils which lack LSE support, because those instructions
are used in libgcc.
Thanks to Kyrylo's hint, the following patches (hopefully) allow it to build
even with older binutils by using .inst directive if LSE support isn't
available in the assembler.

2020-04-15  Jakub Jelinek  <jakub@redhat.com>

PR target/93053
* configure.ac (LIBGCC_CHECK_AS_LSE): Add HAVE_AS_LSE checking.
* config/aarch64/lse.S: Include auto-target.h, if HAVE_AS_LSE
is not defined, use just .arch armv8-a.
(B, M, N, OPN): Define.
(COMMENT): New .macro.
(CAS, CASP, SWP, LDOP): Use .inst directive if HAVE_AS_LSE is not
defined.  Otherwise, move the operands right after the glue? and
comment out operands where the macros are used.
* configure: Regenerated.
* config.in: Regenerated.

openmp: Reject requires directives not at file or namespace scope [PR94593]

This change started with a bugreport about a typo in one requires testcase
(diagnosed with -Wunknown-pragmas only), but following discussion lead to
noting that we do not diagnose restriction that requires directives in
C/C++ may only appear at file or namespace scope; and several our tests
violated that.

2020-04-15  Jakub Jelinek  <jakub@redhat.com>

PR c/94593
* c-parser.c (c_parser_pragma) <case PRAGMA_OMP_REQUIRES>: Reject
requires directive when not at file scope.

* parser.c (cp_parser_pragma) <case PRAGMA_OMP_REQUIRES>: Reject
requires directive when not at file or namespace scope.

* c-c++-common/gomp/requires-1.c: Fix a typo, requries -> requires.
Move directives to file scope.
(i): Remove.
* c-c++-common/gomp/requires-2.c: Move directives to file scope.
(i, foo): Remove.
* c-c++-common/gomp/requires-4.c: Move directives to file scope.
* c-c++-common/gomp/atomic-19.c: Move requires directive to file scope.
* c-c++-common/gomp/atomic-20.c: Likewise.
* c-c++-common/gomp/atomic-21.c: Likewise.
* c-c++-common/gomp/atomic-22.c: Likewise.
* gcc.dg/gomp/requires-1.c: New test.
* g++.dg/gomp/requires-1.C: New test.
* g++.dg/gomp/requires-2.C: New test.
* g++.dg/gomp/atomic-18.C: Move requires directive to file scope.

middle-end/94539 - void * aliases every other pointer

This makes same_type_for_tbaa_p conservative in the same way
get_alias_set is about void * which we allow to alias all other
pointers.

2020-04-15  Richard Biener  <rguenther@suse.de>

PR middle-end/94539
* tree-ssa-alias.c (same_type_for_tbaa): Defer to
alias_sets_conflict_p for pointers.

* gcc.dg/alias-14.c: Make dg-do run.

Daily bump.

xtensa: fix PR target/94584

Patterns zero_extendhisi2, zero_extendqisi2 and extendhisi2_internal can
load value from memory, but they don't treat volatile memory correctly.
Add %v1 before load instructions to emit 'memw' instruction when
-mserialize-volatile is in effect.

2020-04-14  Max Filippov  <jcmvbkbc@gmail.com>
gcc/
* config/xtensa/xtensa.md (zero_extendhisi2, zero_extendqisi2)
(extendhisi2_internal): Add %v1 before the load instructions.

gcc/testsuite/
* gcc.target/xtensa/pr94584.c: New test.

Update gcc sv.po.

* sv.po: Update.

libstdc++: Fix constraints on std::compare_three_way

My "simplification" of std::compare_three_way's constraints in commit
f214ffb336d582a66149068a2a96b7fcf395b5de was incorrect, because
std::three_way_comparable_with imposes additional restrictions beyond
the <=> expression being valid.

* libsupc++/compare (compare_three_way): Fix constraint so that
BUILTIN-PTR-THREE-WAY does not require three_way_comparable_with.
* testsuite/18_support/comparisons/object/builtin-ptr-three-way.cc:
New test.

libstdc++: Add comparison operators to std::shared_ptr (PR 94562)

This also implements the proposed resolution to LWG issue 3247, so that
the ill-formed <=> expression with nullptr is not used.

PR libstdc++/94562
* include/bits/shared_ptr.h (operator<=>): Define for C++20.
* include/bits/shared_ptr_base.h (operator<=>): Likewise.
* include/bits/unique_ptr.h (operator<=>): Add inline specifier.
* testsuite/20_util/shared_ptr/comparison/cmp_c++20.cc: New test.
* testsuite/20_util/shared_ptr/comparison/less.cc: Do not expect
std::less<A*> to be used when comparing std::shared_ptr<A> objects in
C++20.

coroutines: Fix compile error with symmetric transfers [PR94359]

For symmetric transfers to work with C++20 coroutines, it is
currently necessary to tail call the callee coroutine from resume
method of the caller coroutine. The current codegen marks these
resume calls as "MUST_TAIL_CALL" to indicate that the tail call is
required for correctness.

Unfortunately, several targets have ABI constraints that prevent
an indirect tail-call, which results in the PRs compile error.

The change here tests the target sibcall hook for the resume
expression and only marks it as requiring a tail call if that's
supported.

This doesn't fix the underlying problem; that really a solution is
needed to allow the tail-calls (or equivalent) to take place - but
that will be deferred until next stage 1.

gcc/cp/ChangeLog:

2020-04-14  Iain Sandoe  <iain@sandoe.co.uk>

PR c++/94359
* coroutines.cc (build_actor_fn): Check that the target can
support the resume tailcall before mandating it.

gcc/testsuite/ChangeLog:

2020-04-14  Iain Sandoe  <iain@sandoe.co.uk>

PR c++/94359
* g++.dg/coroutines/torture/symmetric-transfer-00-basic.C:
Expect a run fail for targets without arbitrary indirect
tail-calls.

libstdc++: Fix order of entries in ChangeLog

Fix for PR/94542, do not make TLS refs PC-relative

For rs6000 target, it is not valid to make PC-relative
references to TLS symbols. So addr_to_insn_form() needs
to check if things are TLS before returning PC-rel forms.

2020-04-14  Aaron Sawdey  <acsawdey@linux.ibm.com>

PR target/94542
* config/rs6000/rs6000.c (address_to_insn_form): Do not attempt to
use PC-relative addressing for TLS references.

c++: Add testcase for PR c++/93207

gcc/testsuite/ChangeLog:

PR c++/93207
* g++.dg/concepts/variadic5.C: New test.

c++: "'decltype_type' not supported" in diagnostic [PR85278]

This fixes a garbled concepts diagnostic by moving the handling of DECLTYPE_TYPE
from pp_cxx_type_specifier_seq to cxx_pretty_printer::simple_type_specifier, a
move which also seems to be more consistent with the language grammar.

This patch also fixes pretty printing of rvalue reference types via
cxx_pretty_printer::type_id, which eventually calls pp_c_pointer which currently
doesn't distinguish between lvalue and rvalue references.

gcc/c-family/ChangeLog:

PR c++/85278
* c-pretty-print.c (pp_c_pointer) <case REFERENCE_TYPE>: Print a double
ampersand if it's an rvalue reference type.

gcc/cp/ChangeLog:

PR c++/85278
* cxx-pretty-print.c (cxx_pretty_printer:simple_type_specifier)
<case DECLTYPE_TYPE>: Handle DECLTYPE_TYPE here instead of ...
(pp_cxx_type_specifier_seq) <case DECLTYPE_TYPE>: ... here.
(cxx_pretty_printer::direct_abstract_declarator) <case DECLTYPE_TYPE>:
New no-op case.

gcc/testsuite/ChangeLog:

PR c++/85278
* g++.dg/concepts/diagnostic9.C: New test.

ipa-sra: Fix treatment of internal functions (PR 94434)

IPA-SRA can segfault when processing a call to an internal function
because such calls do not have corresponding call graphs and should be
treated like memory accesses anyway, which what the patch below does.

The patch makes an attempt to differentiate between reads and writes,
although for things passed by value it does not make any difference.
It treats all arguments of functions denoted with internal_store_fn_p
as written to, even though in practice only some are, but for IPA-SRA
purposes, actions needed to be taken when processing a read are also
always performed when analyzing a write, so the code is just slightly
pessimistic.  But not as pessimistic as bailing out on any internal
call immediately.

I have LTO bootstrapped and tested the patch on x86_64-linux and
normally bootstrapped and tested it on aarch64-linux, although one
which is not SVE capable.  I would appreciate testing on such machine
too - as well as a small testcase that would follow all relevant
conventions in gcc.target/aarch64/sve.

2020-04-14  Martin Jambor  <mjambor@suse.cz>

PR ipa/94434
* ipa-sra.c: Include internal-fn.h.
(enum isra_scan_context): Update comment.
(scan_function): Treat calls to internal_functions like loads or stores.

c++: Stray RESULT_DECLs in result of constexpr call [PR94034]

When evaluating the initializer of 'a' in the following example

  struct A {
    A() = default; A(const A&);
    A *p = this;
  };
  constexpr A foo() { return {}; }
  constexpr A a = foo();

the PLACEHOLDER_EXPR for 'this' in the aggregate initializer returned by foo
gets resolved to the RESULT_DECL of foo.  But due to guaranteed RVO, the 'this'
should really be resolved to '&a'.

Fixing this properly by immediately resolving 'this' and PLACEHOLDER_EXPRs to
the ultimate object under construction would in general mean that we would no
longer be able to cache constexpr calls for which RVO possibly applies, because
the result of the call may now depend on the ultimate object under construction.

So as a mostly correct stopgap solution that retains cachability of RVO'd
constexpr calls, this patch fixes this issue by rewriting all occurrences of the
RESULT_DECL in the result of a constexpr function call with the current object
under construction, after the call returns.  This means the 'this' pointer
during construction of the temporary will still point to the temporary object
instead of the ultimate object, but besides that this approach seems
functionally equivalent to the proper approach.

gcc/cp/ChangeLog:

PR c++/94034
* constexpr.c (replace_result_decl_data): New struct.
(replace_result_decl_data_r): New function.
(replace_result_decl): New function.
(cxx_eval_call_expression): Use it.
* tree.c (build_aggr_init_expr): Set the location of the AGGR_INIT_EXPR
to that of its initializer.

gcc/testsuite/ChangeLog:

PR c++/94034
* g++.dg/cpp0x/constexpr-empty15.C: New test.
* g++.dg/cpp1y/constexpr-nsdmi6a.C: New test.
* g++.dg/cpp1y/constexpr-nsdmi6b.C: New test.
* g++.dg/cpp1y/constexpr-nsdmi7a.C: New test.
* g++.dg/cpp1y/constexpr-nsdmi7b.C: New test.

testsuite: Add testcase for already fixed PR [PR94573]

2020-04-14  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/94573
* gcc.dg/store_merging_30.c: New test.

PR tree-optimization/94574 - aarch64: ICE during GIMPLE pass:ccp

In this PR the testcase ICEs because a BIT_INSERT_EXPR whose replaced bits are
not fully inside the container is generated. A size check is added to avoid
this kind of ICE.

gcc/ChangeLog:

PR tree-optimization/94574
* tree-ssa.c (non_rewritable_lvalue_p): Add size check when analyzing
whether a vector-insert is rewritable using a BIT_INSERT_EXPR.

gcc/testsuite/ChangeLog:

PR tree-optimization/94574
* gcc.dg/pr94574.c: New test.

i386: Remove mode size check in ix86_get_ssemov

Even though ix86_hard_regno_mode_ok doesn't allow xmm16-xmm31 nor
ymm16-ymm31 in 128/256 bit modes when AVX512VL is disabled, LRA can
still generate reg to reg moves with xmm16-xmm31 and ymm16-ymm31 in
128/256 bit modes.  Remove mode size check in ix86_get_ssemov.

gcc/

PR target/94561
* config/i386/i386.c (ix86_get_ssemov): Remove mode size check.

gcc/testsuite/

PR target/94561
* gcc.target/i386/pr94561.c: New test.

Add myself as callgraph (IPA) reviewer

2020-04-14  Martin Jambor  <mjambor@suse.cz>

* MAINTAINERS (Reviewers): Add myself as callgraph (IPA) reviewer.

[Fortran] Fix name conflict check for use-assoc (PR 92736)

* module.c (gfc_match_use): Fix name-conflict check for use-associating
the same symbol again in a submodule.

* gfortran.dg/use_rename_10.f90: New.
* gfortran.dg/use_rename_11.f90: New.

Fix PR 94270 by not warning about artifical dummy arguments.

2020-04-14  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/94270
* interface.c (gfc_get_formal_from_actual_arglist): Always
set artificial attribute for symbols.
* trans-decl.c (generate_local_decl): Do not warn if the
symbol is artifical.

2020-04-14  Thomas Koenig  <tkoenig@gcc.gnu.org>

PR fortran/94270
* gfortran.dg/warn_unused_dummy_argument_6.f90: New test.

Add me as callgraph (IPA) reviewer.

ChangeLog:

2020-04-14  Martin Liska  <mliska@suse.cz>

* MAINTAINERS: Add me as callgraph (IPA) reviewer.