openmp: Ensure copy ctor for composite distribute parallel for class iterators is instantiated [PR95197]

During gimplification omp_finish_clause langhook is called in several places
to add the language specific info to the clause like what default/copy ctors,
dtors and assignment operators should be used.

Unfortunately, if it refers to some not yet instantiated method, during
gimplification it is too late and the methods will not be instantiated
anymore.  For other cases, the genericizer has code to detect those and
instantiate whatever is needed, this change adds the same for
distribute parallel for class iterators where we under the hood need
a copy constructor for the iterator to implement it.

2020-05-26  Jakub Jelinek  <jakub@redhat.com>

	PR c++/95197
	* gimplify.c (find_combined_omp_for): Move to omp-general.c.
	* omp-general.h (find_combined_omp_for): Declare.
	* omp-general.c: Include tree-iterator.h.
	(find_combined_omp_for): New function, moved from gimplify.c.

	* cp-gimplify.c: Include omp-general.h.
	(cp_genericize_r) <case OMP_DISTRIBUTE>: For class iteration
	variables in composite distribute parallel for, instantiate copy
	ctor of their types.

(cherry picked from commit f1f862aec2c3b93dbd6adfc35b0e1b6034e59c21)

For normal stmts, preparation statements are inserted before the stmt, so if we need multiple,
they are in the correct order, but for PHIs we emit them after labels in the entry successor
bb, and we used to emit them in the reverse order that way.

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

	PR middle-end/95108
	* omp-simd-clone.c (struct modify_stmt_info): Add after_stmt member.
	(ipa_simd_modify_stmt_ops): For PHIs, only add before first stmt in
	entry block if info->after_stmt is NULL, otherwise add after that stmt
	and update it after adding each stmt.
	(ipa_simd_modify_function_body): Initialize info.after_stmt.

	* gcc.dg/gomp/pr95108.c: New test.

(cherry picked from commit d0fb9ffc1b8f3b86bbdf0e915cec2136141b329b)

The following testcase fails with -fcompare-debug, the bug used to be latent
since introduction of -fcompare-debug.
The loop at the start of purge_dead_edges behaves differently between -g0
and -g - if the last insn is a DEBUG_INSN, then it skips not just
DEBUG_INSNs but also NOTEs until it finds some other real insn (or bb head),
while with -g0 it will not skip any NOTEs, so if we have
real_insn
note
debug_insn // not present with -g0
then with -g it might remove useless REG_EH_REGION from real_insn, while
with -g0 it will not.

Yet another option would be not skipping NOTE_P in the loop; I couldn't find
in history rationale for why it is done.

2020-05-13  Jakub Jelinek  <jakub@redhat.com>

	PR debug/95080
	* cfgrtl.c (purge_dead_edges): Skip over debug and note insns even
	if the last insn is a note.

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

(cherry picked from commit 18edc195442291525e04f0fa4d5ef972155117da)

gcc/testsuite/ChangeLog:

	PR testsuite/95575
	* lib/gdc-utils.exp (gdc-do-test): Re-add $subdir link and inclusion
	in filename.

(cherry picked from commit 4a557dc45650bbe500276680674afa18d291fdcc)

build_new_method_call is supposed to be able to handle a null
arguments list pointer (when the method has no parms).  There
were a couple of places where uses of the argument list pointer
were not defended against NULL.

gcc/cp/ChangeLog:

	PR c++/95440
	* call.c (add_candidates): Use vec_safe_length() for
	testing the arguments list.
	(build_new_method_call_1): Use vec_safe_is_empty() when
	checking for an empty args list.

gcc/testsuite/ChangeLog:

	PR c++/95440
	* g++.dg/coroutines/pr95440.C: New test.

(cherry picked from commit a9eec9625ea7165292958be04899b057804192fb)

This fixes two issues in our handling of constrained class template
friend declarations.

The first issue is that we fail to set the constraints on the injected
class template declaration during tsubst_friend_class.

The second issue is that the template parameter levels within the parsed
constraints of a class template friend declaration are shifted if the
enclosing class is a template, and this shift leads to spurious
constraint mismatch errors in associate_classtype_constraints if the
friend declaration refers to an already declared class template.

gcc/cp/ChangeLog:

	PR c++/93467
	* constraint.cc (associate_classtype_constraints): If there is a
	discrepancy between the current template depth and the template
	depth of the original declaration, then adjust the template
	parameter depth within the current constraints appropriately.
	* pt.c (tsubst_friend_class): Substitute into and set the
	constraints on the injected declaration.

gcc/testsuite/ChangeLog:

	PR c++/93467
	* g++.dg/cpp2a/concepts-friend6.C: New test.
	* g++.dg/cpp2a/concepts-friend7.C: New test.

(cherry picked from commit 11c7261128ad3ee136508703b20e45cbe04f8dd0)

This lets the test pass on AIX.

Not updating to master because we get slightly different error messages,
so that is a more complex change.

Adjust to handle rvalue refs the same way as clang, and to correct
the handling of moves when a copy CTOR is present.  This is one area
where we could make things easier for the end-user (as was implemented
before this change), however there needs to be agreement about when the
full statement containing a coroutine call ends (i.e. when the ramp
terminates or when the coroutine terminates).

gcc/cp/ChangeLog:

	PR c++/95350
	* coroutines.cc (struct param_info): Remove rv_ref field.
	(build_actor_fn): Remove specifial rvalue ref handling.
	(morph_fn_to_coro): Likewise.

gcc/testsuite/ChangeLog:

	PR c++/95350
	* g++.dg/coroutines/torture/func-params-08.C: Adjust test to
	reflect that all rvalue refs are dangling.
	* g++.dg/coroutines/torture/func-params-09-awaitable-parms.C:
	Likewise.
	* g++.dg/coroutines/pr95350.C: New test.

(cherry picked from commit 88f48e2967ead9be262483618238efa9c7c842ec)

gcc/ChangeLog:

	PR sanitizer/95634
	* asan.c (asan_emit_stack_protection): Fix emission for ilp32
	by using Pmode instead of ptr_mode.

Co-Authored-By: Jakub Jelinek <jakub@redhat.com>
(cherry picked from commit 8cff672cb9a132d3d3158c2edfc9a64b55292b80)

gcc/ChangeLog:

2020-05-19  Martin Liska  <mliska@suse.cz>

	PR sanitizer/94910
	* asan.c (asan_emit_stack_protection): Emit
	also **SavedFlagPtr(FakeStack, class_id) = 0 in order to release
	a stack frame.

(cherry picked from commit 8b6731e674c76cb48a417f2eef74ced92a17f469)

Another indication that perhaps this warning is emitted too early.  We
crash because same_type_p gets a null type: we have an enumerator
without a fixed underlying type and finish_enum_value_list hasn't yet
run.  So check if the type is null before calling same_type_p.

	PR c++/95560
	* name-lookup.c (check_local_shadow): Check if types are
	non-null before calling same_type_p.

	* g++.dg/warn/Wshadow-local-3.C: New test.

I forgot to set DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P when merging two
function declarations and as a sad consequence, we never tsubsted
the dependent explicit-specifier in tsubst_function_decl, leading to
disregarding the explicit-specifier altogether, and wrongly accepting
this test.

	PR c++/95066
	* decl.c (duplicate_decls): Set DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P.

	* g++.dg/cpp2a/explicit16.C: New test.

An ICE arises here because we call cp_get_callee_fndecl_nofold in a
template, and we've got a CALL_EXPR whose CALL_EXPR_FN is a BASELINK.
This tickles the INDIRECT_TYPE_P assert in cp_get_fndecl_from_callee.

Fixed by turning the assert into a condition and returning NULL_TREE
in that case.

	PR c++/94937
	* cvt.c (cp_get_fndecl_from_callee): Return NULL_TREE if the function
	type is not INDIRECT_TYPE_P.
	* decl.c (omp_declare_variant_finalize_one): Call
	cp_get_callee_fndecl_nofold instead of looking for the function decl
	manually.

	* g++.dg/cpp1z/constexpr-if34.C: New test.
	* g++.dg/cpp2a/is-constant-evaluated10.C: New test.

Since r267272, which added location wrappers, cp_fold loses
TREE_NO_WARNING on a MODIFY_EXPR that finish_parenthesized_expr set, and
that results in a bogus -Wparentheses warning.

I.e., previously we had "b = 1" but now we have "VIEW_CONVERT_EXPR<bool>(b) = 1"
and cp_fold_maybe_rvalue folds away the location wrapper and so we do
2718             x = fold_build2_loc (loc, code, TREE_TYPE (x), op0, op1);
in cp_fold and the flag is lost.

	PR c++/95344
	* cp-gimplify.c (cp_fold) <case MODIFY_EXPR>: Don't set
	TREE_THIS_VOLATILE here.
	(cp_fold): Set it here along with TREE_NO_WARNING.

	* c-c++-common/Wparentheses-2.c: New test.

Since r10-6527 fold_for_warn calls maybe_constant_value, which means it
can fold more than it previously could.  In this testcase it means that
cp_build_binary_op/RSHIFT_EXPR set short_shift because now we were able
to fold op1 to an INTEGER_CST.  But then when actually performing the
shortening we crashed because cp_fold_rvalue wasn't able to fold as much
as f_f_w and so tree_int_cst_sgn crashed on a NOP_EXPR.  Therefore the
calls should probably match.

	PR c++/94955
	* typeck.c (cp_build_binary_op): Use fold_for_warn instead of
	cp_fold_rvalue.

	* g++.dg/cpp0x/constexpr-shift2.C: New test.

Until 92104 is fixed, let's sorry rather than crash.

	PR c++/90915
	* parser.c (cp_parser_has_attribute_expression): Sorry on a
	type-dependent argument.

	* g++.dg/ext/builtin-has-attribute.C: New test.

When reporting a duplicate access specification of an operator, refer to
the proper symbol.

2020-06-11  Harald Anlauf <anlauf@gmx.de>

gcc/fortran/
	PR fortran/95611
	* decl.c (access_attr_decl): Use correct symbol in error message.

Co-Authored-By: Steven G. Kargl  <kargl@gcc.gnu.org>
(cherry picked from commit 393ccb72566dc004b9ab5c3b8fb6fdca6c095812)

Part of the PR notes that there are UBSAN fails for the coroutines
test suite.  These are primarily related to the use of the same DTOR
tree in the two edges from the await block.  Fixed by building a new
tree for each.

gcc/cp/ChangeLog:

	PR c++/95137
	* coroutines.cc (expand_one_await_expression): Build separate
	DTOR trees for the awaitable object on the destroy and resume
	paths.

(cherry picked from commit 006f28aefeb3be575239beddc7febe56dff463a2)

Add cast to fix bootstrap error with -Werror=sign-compare.

gcc/fortran/
	PR fortran/95091
	* class.c (gfc_hash_value): Add cast.

(cherry picked from commit 5aaccde3db39fac7e7f6677ceccc1eadd9c6a424)

With submodules, name mangling results in long internal symbols.  This
requires adjustment of the sizes of temporaries to avoid buffer overflows.

2020-06-07  Harald Anlauf  <anlauf@gmx.de>

gcc/fortran/
	PR fortran/95091
	* class.c (get_unique_type_string, gfc_hash_value): Enlarge
	buffers, and check whether the strings returned by
	get_unique_type_string() fit.

(cherry picked from commit b342cfd648e6658363c7c8fef83af8f59dba1795)

ranges::copy and a number of other ranges algorithms have unwrapping
optimizations for iterators of type __normal_iterator, move_iterator and
reverse_iterator.  But in the checks that guard these optimizations we
currently only test that the iterator of the iterator/sentinel pair has
the appropriate type before proceeding with the corresponding
optimization, and do not also test the sentinel type.

This breaks the testcase in this PR because this testcase constructs via
range adaptors a range whose begin() is a __normal_iterator and whose
end() is a custom sentinel type, and then performs ranges::copy on it.
From there we bogusly perform the __normal_iterator unwrapping
optimization on this iterator/sentinel pair, which immediately leads to
a constraint failure since the custom sentinel type does not model
sentinel_for<int*>.

This patch fixes this issue by refining each of the problematic checks
to also test that the iterator and sentinel types are the same before
applying the corresponding unwrapping optimization.  Along the way, some
code simplifications are made.

libstdc++-v3/ChangeLog:

	PR libstdc++/95578
	* include/bits/ranges_algo.h (__lexicographical_compare_fn):
	Also check that the iterator and sentinel have the same type before
	applying the unwrapping optimization for __normal_iterator.
	Split the check into two, one for the first iterator/sentinel
	pair and another for second iterator/sentinel pair.  Remove uses
	of __niter_base, and remove uses of std::move on a
	__normal_iterator.
	* include/bits/ranges_algobase.h (__equal_fn): Likewise.
	(__copy_or_move): Likewise.  Perform similar adjustments for
	the reverse_iterator and move_iterator optimizations.  Inline
	the checks into the if-constexprs, and use using-declarations to
	make them less visually noisy.  Remove uses of __niter_wrap.
	(__copy_or_move_backward): Likewise.
	* testsuite/25_algorithms/copy/95578.cc: New test.
	* testsuite/25_algorithms/copy_backward/95578.cc: New test.
	* testsuite/25_algorithms/equal/95578.cc: New test.
	* testsuite/25_algorithms/lexicographical_compare/95578.cc: New test.
	* testsuite/25_algorithms/move/95578.cc: New test.
	* testsuite/25_algorithms/move_backward/95578.cc: New test.

(cherry picked from commit a73051a0ea9ce8281e748a74dd924a6eb8fb3723)

Confusingly, "get_return_object ()" can do two things:
- Firstly it can provide the return object for the ramp function (as
  the name suggests).
- Secondly if the type of the ramp function is different from that
  of the get_return_object call, this is used as a single parameter
  to a CTOR for the ramp's return type.

In the first case we can rely on finish_return_stmt () to do the
necessary processing for copy elision.
In the second case, we should have passed a prvalue to the CTOR as
per the standard comment, but I had omitted the rvalue () call.  Fixed
thus.

gcc/cp/ChangeLog:

	PR c++/95346
	* coroutines.cc (morph_fn_to_coro): Ensure that the get-
	return-object is constructed correctly; When it is not the
	final return value, pass it to the CTOR of the return type
	as an rvalue, per the standard comment.

gcc/testsuite/ChangeLog:

	PR c++/95346
	* g++.dg/coroutines/pr95346.C: New test.

(cherry picked from commit 4f2d05ef0142d269964e165c14c6f7fe4bdfd5a3)

Here we ICE because a DEFERRED_PARSE expression leaked to tsubst_copy.
We create these expressions for deferred noexcept-specifiers in
cp_parser_save_noexcept; they are supposed to be re-parsed in
cp_parser_late_noexcept_specifier.  In this case we never got around
to re-parsing it because the noexcept-specifier was attached to a
pointer to a function, not to a function declaration.  But we should
not have delayed the parsing here in the first place; we already
avoid delaying the parsing for alias-decls, typedefs, and friend
function declarations.  (Clang++ also doesn't delay the parsing
for pointers to function.)

gcc/cp/ChangeLog:

	PR c++/95562
	* parser.c (cp_parser_direct_declarator): Clear
	CP_PARSER_FLAGS_DELAY_NOEXCEPT if the declarator kind is not
	cdk_id.

gcc/testsuite/ChangeLog:

	PR c++/95562
	* g++.dg/cpp0x/noexcept60.C: New test.

This corrects a pasto, where I copied the constraint on bare
parameter packs from the co_return to co_yield/await without
properly reviewing it.

gcc/cp/ChangeLog:

	PR c++/95345
	* coroutines.cc (finish_co_await_expr): Revise to allow for
	parameter packs.
	(finish_co_yield_expr): Likewise.

gcc/testsuite/ChangeLog:

	PR c++/95345
	* g++.dg/coroutines/pr95345.C: New test.

(cherry picked from commit cf7eac5805e714c7e71b699329e2c4f4a88addc1)

PR 95113 revealed that when reasoning about which parameters are dead,
IPA-SRA does not perform the same check related to non-call exceptions
as tree DCE.  It most certainly should and so this patch moves the
condition used in tree-ssa-dce.c into a separate predicate (in
tree-eh.c) and uses it from both places.

gcc/ChangeLog:

2020-05-27  Martin Jambor  <mjambor@suse.cz>

	PR ipa/95113
	* tree-ssa-dce.c (mark_stmt_if_obviously_necessary): Move non-call
	exceptions check to...
	* tree-eh.c (stmt_unremovable_because_of_non_call_eh_p): ...this
	new function.
	* tree-eh.h (stmt_unremovable_because_of_non_call_eh_p): Declare it.
	* ipa-sra.c (isra_track_scalar_value_uses): Use it.  New parameter
	fun.

gcc/testsuite/ChangeLog:

2020-05-27  Martin Jambor  <mjambor@suse.cz>

	PR ipa/95113
	* gcc.dg/ipa/pr95113.c: New test.

(cherry picked from commit 1980ffec48c6fa41396bea66366f2e591798e1e1)

This issue has been fixed by PR94090.  Add test case to ensure that
this does not re-occur.

2020-06-08  Mark Eggleston  <markeggleston@gcc.gnu.org>

gcc/testsuite/

	PR fortran/92993
	* gfortran.dg/pr92993.f90: New test.

(cherry picked from commit 5dc3986103d8908c802e940dea8f2def3a6989c2)

Since the co_await expression is mostly opaque to the existing
machinery, we were hiding the details of the await_resume return
value.  If that needs to be wrapped in a target expression, then
emulate this with the whole co_await.  Similarly, if the await
expression we build in response to co_await p.yield_value (e)
is wrapped in a target expression, then we need to transfer that
wrapper to the resultant CO_YIELD_EXPR (which is, itself, just
a proxy for the underlying co_await).

gcc/cp/ChangeLog:

	PR c++/95050
	* coroutines.cc (build_co_await): Wrap the co_await expression
	in a TARGET_EXPR, where needed.
	(finish_co_yield_expr): Likewise.

gcc/testsuite/ChangeLog:

	PR c++/95050
	* g++.dg/coroutines/pr95050.C: New test.

(cherry picked from commit 324276ff9b1aa5128e5cb9f5d43182d1ebab0752)

When we have completely missing key information (e.g. the
coroutine_traits) or a partially transformed function body, we
need to try and balance returning useful information about
failures with the possibility that some part of the diagnostics
machinery or following code will not be able to handle the
state.

The PRs (and revised testcase) point to cases where that processing
has failed.

This revises the process to avoid special handling for the
ramp, and falls back on the same code used for regular function
fails.

There are test-cases (in addition to the ones for the PRs) that now
cover all early exit points [where the transforms are considered
to have failed in a manner that does not allow compilation to
continue].

Diagnosing bad uses of 'return' in coroutines is somewhat
tricky, since the user can use the keyword before we know
that the function is a coroutine (where such returns are not
permitted).  At present, we are just doing a check for any
use of 'return' and erroring on that.  However, we can't then
pass the function body on, since it will contain unlowered
coroutine trees.

This avoids the issue by dropping the entire function body
under that circumstance.

	Backport c7100843831147a034fe37d231c54ac53ceace45 and a1bb808504643e6c3c0df0fdd68a941ed2a64c7f0

gcc/cp/ChangeLog:

	PR c++/94817
	PR c++/94829
	PR c++/95087
	* coroutines.cc (morph_fn_to_coro): Set unformed outline
	functions to error_mark_node.  For early error returns suppress
	warnings about missing ramp return values.  Fix reinstatement
	of the function body on pre-existing initial error.  If we see
	an early fatal error, drop the erroneous function body.
	* decl.c (finish_function): Use the normal error path for fails
	in the ramp function, do not try to compile the helpers if the
	transform fails.

gcc/testsuite/ChangeLog:

	PR c++/94817
	PR c++/94829
	PR c++/95087
	* g++.dg/coroutines/coro-missing-final-suspend.C: New test.
	* g++.dg/coroutines/coro-missing-initial-suspend.C: New test.
	* g++.dg/coroutines/coro-missing-promise-yield.C: Check for
	continuation of compilation.
	* g++.dg/coroutines/coro-missing-promise.C: Likewise.
	* g++.dg/coroutines/coro-missing-ret-value.C: Likewise
	* g++.dg/coroutines/coro-missing-ret-void.C: Likewise
	* g++.dg/coroutines/coro-missing-ueh-3.C: Likewise
	* g++.dg/coroutines/pr94817.C: New test.
	* g++.dg/coroutines/pr94829.C: New test.
	* g++.dg/coroutines/co-return-syntax-08-bad-return.C:
	Adjust the testcase to do the compile (rather than an
	-fsyntax-only parse).
	* g++.dg/coroutines/coro1-ret-int-yield-int.h
	(MISSING_INITIAL_SUSPEND, MISSING_FINAL_SUSPEND): New.

The use of KIND, LEN, RE, and IM inquiry references for applicable intrinsic
types is valid only for suffienctly new Fortran standards.  Add appropriate
checks in the appropriate place.

2020-05-30  Harald Anlauf  <anlauf@gmx.de>

gcc/fortran/
	PR fortran/95373
	* primary.c (is_inquiry_ref): Move validity check of inquiry
	references against selected Fortran standard from here...
	(gfc_match_varspec) ...to here.

gcc/testsuite/
	PR fortran/95373
	* gfortran.dg/pr95373_1.f90: Adjust error messages.
	* gfortran.dg/pr95373_2.f90: Adjust error message.

(cherry picked from commit dd38c765a04d06c775134a135f68b18c3b7c9c78)

The use of KIND, LEN, RE, and IM inquiry references for applicable intrinsic
types is valid only for suffienctly new Fortran standards.  Add appropriate
check.

2020-05-28  Harald Anlauf  <anlauf@gmx.de>

gcc/fortran/
	PR fortran/95373
	* primary.c (is_inquiry_ref): Check validity of inquiry
	references against selected Fortran standard.

gcc/testsuite/
	PR fortran/95373
	* gfortran.dg/pr95373_1.f90: New test.
	* gfortran.dg/pr95373_2.f90: New test.

(cherry picked from commit 5c715e6a2990cfb6c15acc1ee14219523534ec69)

	For long module names, the generated name-mangled symbol was
	truncated, leading to bogus warnings about COMMON block
	mismatches.  Provide sufficiently large temporaries.

gcc/fortran/

2020-05-24  Harald Anlauf  <anlauf@gmx.de>

	PR fortran/95106
	* trans-common.c (gfc_sym_mangled_common_id): Enlarge temporaries
	for name-mangling.

gcc/testsuite/

2020-05-24  Harald Anlauf  <anlauf@gmx.de>

	PR fortran/95106
	* gfortran.dg/equiv_11.f90: New test.