Now that stmt_vec_info records the choice between vector mask
types and normal nonmask types, we can use that information in
vect_get_vector_types_for_stmt instead of deferring the choice
of vector type till later.

vect_get_mask_type_for_stmt used to check whether the boolean inputs
to an operation:
(a) consistently used mask types or consistently used nonmask types; and
(b) agreed on the number of elements.

(b) shouldn't be a problem when (a) is met.  If the operation
consistently uses mask types, tree-vect-patterns.c will have corrected
any mismatches in mask precision.  (This is because we only use mask
types for a small well-known set of operations and tree-vect-patterns.c
knows how to handle any that could have different mask precisions.)
And if the operation consistently uses normal nonmask types, there's
no reason why booleans should need extra vector compatibility checks
compared to ordinary integers.

So the potential difficulties all seem to come from (a).  Now that
we've chosen the result type ahead of time, we also have to consider
whether the outputs and inputs consistently use mask types.

Taking each vectorizable_* routine in turn:

- vectorizable_call

    vect_get_vector_types_for_stmt only handled booleans specially
    for gassigns, so vect_get_mask_type_for_stmt never had chance to
    handle calls.  I'm not sure we support any calls that operate on
    booleans, but as things stand, a boolean result would always have
    a nonmask type.  Presumably any vector argument would also need to
    use nonmask types, unless it corresponds to internal_fn_mask_index
    (which is already a special case).

    For safety, I've added a check for mask/nonmask combinations here
    even though we didn't check this previously.

- vectorizable_simd_clone_call

    Again, vect_get_mask_type_for_stmt never had chance to handle calls.
    The result of the call will always be a nonmask type and the patch
    for PR 92710 rejects mask arguments.  So all booleans should
    consistently use nonmask types here.

- vectorizable_conversion

    The function already rejects any conversion between booleans in which
    one type isn't a mask type.

- vectorizable_operation

    This function definitely needs a consistency check, e.g. to handle
    & and | in which one operand is loaded from memory and the other is
    a comparison result.  Ideally we'd handle this via pattern stmts
    instead (like we do for the all-mask case), but that's future work.

- vectorizable_assignment

    VECT_SCALAR_BOOLEAN_TYPE_P requires single-bit precision, so the
    current code already rejects problematic cases.

- vectorizable_load

    Loads always produce nonmask types and there are no relevant inputs
    to check against.

- vectorizable_store

    vect_check_store_rhs already rejects mask/nonmask combinations
    via useless_type_conversion_p.

- vectorizable_reduction
- vectorizable_lc_phi

    PHIs always have nonmask types.  After the change above, attempts
    to combine the PHI result with a mask type would be rejected by
    vectorizable_operation.  (Again, it would be better to handle
    this using pattern stmts.)

- vectorizable_induction

    We don't generate inductions for booleans.

- vectorizable_shift

    The function already rejects boolean shifts via type_has_mode_precision_p.

- vectorizable_condition

    The function already rejects mismatches via useless_type_conversion_p.

- vectorizable_comparison

    The function already rejects comparisons between mask and nonmask types.
    The result is always a mask type.

2019-11-29  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	PR tree-optimization/92596
	* tree-vect-stmts.c (vectorizable_call): Punt on hybrid mask/nonmask
	operations.
	(vectorizable_operation): Likewise, instead of relying on
	vect_get_mask_type_for_stmt to do this.
	(vect_get_vector_types_for_stmt): Always return a vector type
	immediately, rather than deferring the choice for boolean results.
	Use a vector mask type instead of a normal vector if
	vect_use_mask_type_p.
	(vect_get_mask_type_for_stmt): Delete.
	* tree-vect-loop.c (vect_determine_vf_for_stmt_1): Remove
	mask_producers argument and special boolean_type_node handling.
	(vect_determine_vf_for_stmt): Remove mask_producers argument and
	update calls to vect_determine_vf_for_stmt_1.  Remove doubled call.
	(vect_determine_vectorization_factor): Update call accordingly.
	* tree-vect-slp.c (vect_build_slp_tree_1): Remove special
	boolean_type_node handling.
	(vect_slp_analyze_node_operations_1): Likewise.

gcc/testsuite/
	PR tree-optimization/92596
	* gcc.dg/vect/bb-slp-pr92596.c: New test.
	* gcc.dg/vect/bb-slp-43.c: Likewise.

From-SVN: r278851

search_type_for_mask uses a worklist to search a chain of boolean
operations for a natural vector mask type.  This patch instead does
that in vect_determine_stmt_precisions, where we also look for
overpromoted integer operations.  We then only need to compute
the precision once and can cache it in the stmt_vec_info.

The new function vect_determine_mask_precision is supposed
to handle exactly the same cases as search_type_for_mask_1,
and in the same way.  There's a lot we could improve here,
but that's not stage 3 material.

I wondered about sharing mask_precision with other fields like
operation_precision, but in the end that seemed too dangerous.
We have patterns to convert between boolean and non-boolean
operations and it would be very easy to get mixed up about
which case the fields are describing.

2019-11-29  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (stmt_vec_info::mask_precision): New field.
	(vect_use_mask_type_p): New function.
	* tree-vect-patterns.c (vect_init_pattern_stmt): Copy the
	mask precision to the pattern statement.
	(append_pattern_def_seq): Add a scalar_type_for_mask parameter
	and use it to initialize the new stmt's mask precision.
	(search_type_for_mask_1): Delete.
	(search_type_for_mask): Replace with...
	(integer_type_for_mask): ...this new function.  Use the information
	cached in the stmt_vec_info.
	(vect_recog_bool_pattern): Update accordingly.
	(build_mask_conversion): Pass the scalar type associated with the
	mask type to append_pattern_def_seq.
	(vect_recog_mask_conversion_pattern): Likewise.  Call
	integer_type_for_mask instead of search_type_for_mask.
	(vect_convert_mask_for_vectype): Call integer_type_for_mask instead
	of search_type_for_mask.
	(possible_vector_mask_operation_p): New function.
	(vect_determine_mask_precision): Likewise.
	(vect_determine_stmt_precisions): Call it.

From-SVN: r278850

This patch makes vect_get_mask_type_for_stmt and
get_mask_type_for_scalar_type take a group size instead of
the SLP node, so that later patches can call it before an
SLP node has been built.

2019-11-29  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vectorizer.h (get_mask_type_for_scalar_type): Replace
	the slp_tree parameter with a group size parameter.
	(vect_get_mask_type_for_stmt): Likewise.
	* tree-vect-stmts.c (get_mask_type_for_scalar_type): Likewise.
	(vect_get_mask_type_for_stmt): Likewise.
	* tree-vect-slp.c (vect_slp_analyze_node_operations_1): Update
	call accordingly.

From-SVN: r278849

vectorizable_operation returned false for codes that are handled by
vectorizable_shift, but only after it had already done a lot of work.
Checking earlier should be more efficient and avoid polluting the logs
with duplicate info.

Also, there was no such early-out for comparisons or COND_EXPRs.
Fixing that avoids a false scan-tree-dump hit with a later patch.

2019-11-29  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* tree-vect-stmts.c (vectorizable_operation): Punt early
	on codes that are handled elsewhere.

From-SVN: r278848

vect_recog_bool_pattern assumed that a comparison between two booleans
should always become a comparison of vector mask types (implemented as an
XOR_EXPR).  But if the booleans in question are generated as data values
(e.g. because they're loaded directly from memory), we should treat them
like ordinary integers instead, just as we do for boolean logic ops whose
operands are loaded from memory.  vect_get_mask_type_for_stmt already
handled this case:

      /* We may compare boolean value loaded as vector of integers.
	 Fix mask_type in such case.  */
      if (mask_type
	  && !VECTOR_BOOLEAN_TYPE_P (mask_type)
	  && gimple_code (stmt) == GIMPLE_ASSIGN
	  && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
	mask_type = truth_type_for (mask_type);

and not handling it here complicated later patches.

The initial list of targets for vect_bool_cmp is deliberately conservative.

2019-11-29  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	* doc/sourcebuild.texi (vect_bool_cmp): Document.
	* tree-vect-patterns.c (search_type_for_mask_1): If neither
	operand to a boolean comparison is a natural vector mask,
	handle both operands like normal integers instead.

gcc/testsuite/
	* gcc.dg/vect/vect-bool-cmp-2.c: New test.
	* lib/target-supports.exp (check_effective_target_vect_bool_cmp): New
	effective target procedure.

From-SVN: r278847

This fixes two related problems.

The iterators for node-based containers use nested typedefs such as
std::list<T>::iterator::_Node to denote their node types. As reported in
https://bugzilla.redhat.com/show_bug.cgi?id=1053438 those typedefs are
not always present in the debug info. That means the pretty printers
cannot find them using gdb.lookup_type (via the find_type helper).
Instead of looking up the nested typedefs this patch makes the printers
look up the actual class templates directly.

A related problem (and the original topic of PR 91997) is that GDB fails
to find types via gdb.lookup_type when printing a backtrace from a
non-C++ functiion: https://sourceware.org/bugzilla/show_bug.cgi?id=25234
That is also solved by not looking up the nested typedef.

	PR libstdc++/91997
	* python/libstdcxx/v6/printers.py (find_type): Fail more gracefully
	if we run out of base classes to look at.
	(llokup_templ_spec, lookup_node_type): New utilities to find node
	types for node-based containers.
	(StdListPrinter.children, NodeIteratorPrinter.__init__)
	(NodeIteratorPrinter.to_string, StdSlistPrinter.children)
	(StdSlistIteratorPrinter.to_string, StdRbtreeIteratorPrinter.__init__)
	(StdMapPrinter.children, StdSetPrinter.children)
	(StdForwardListPrinter.children): Use lookup_node_type instead of
	find_type.
	(StdListIteratorPrinter.__init__, StdFwdListIteratorPrinter.__init__):
	Pass name of node type to NodeIteratorPrinter constructor.
	(Tr1HashtableIterator.__init__): Rename argument.
	(StdHashtableIterator.__init__): Likewise. Use lookup_templ_spec
	instead of find_type.
	* testsuite/libstdc++-prettyprinters/59161.cc: Remove workaround for
	_Node typedef not being present in debuginfo.
	* testsuite/libstdc++-prettyprinters/91997.cc: New test.

From-SVN: r278846

        * testsuite/libgomp.oacc-fortran/declare-5.f90: Extend by
        adding a common-block test case.

From-SVN: r278845

2019-11-29  Richard Biener  <rguenther@suse.de>

	* tree-ssa-sccvn.c (vn_walk_cb_data::push_partial_def): Bail
	out early for too large objects.

From-SVN: r278844

        * fortran.dg/goacc/common-block-3.f90: Check that unused common-block
        variables do not get mapped.

Reviewed-by: Thomas Schwinge <thomas@codesourcery.com>

From-SVN: r278843

2019-11-29  Martin Jambor  <mjambor@suse.cz>

	PR ipa/92476
        * g++.dg/lto/pr92476_[01].C: New test.

From-SVN: r278842

2019-11-29  Martin Jambor  <mjambor@suse.cz>

	PR ipa/92476
	* ipa-cp.c (set_single_call_flag): Set node_calling_single_call in
	the summary only if the summary exists.
	(find_more_scalar_values_for_callers_subset): Check node_dead in
	the summary only if the summary exists.
	(ipcp_store_bits_results): Ignore nodes without lattices.
	(ipcp_store_vr_results): Likewise.
	* cgraphclones.c: Include ipa-fnsummary.h and ipa-prop.h and the
	header files required by them.
	(cgraph_node::expand_all_artificial_thunks): Analyze expanded thunks.

From-SVN: r278841

In this PR we assigned a vector mask type to the result of a comparison
and then tried to pass that mask type to a simd clone, which expected
a normal (non-mask) type instead.

This patch simply punts on call arguments that have a mask type.
A better fix would be to pattern-match the comparison to a COND_EXPR,
like we would if the comparison was stored to memory, but doing that
isn't gcc 9 or 10 material.

Note that this doesn't affect x86_64-linux-gnu because the ABI promotes
bool arguments to ints.

2019-11-29  Richard Sandiford  <richard.sandiford@arm.com>

gcc/
	PR tree-optimization/92710
	* tree-vect-stmts.c (vectorizable_simd_clone_call): Reject
	vector mask arguments.

gcc/testsuite/
	PR tree-optimization/92710
	* gcc.dg/vect/pr92710.c: New test.

From-SVN: r278839

From-SVN: r278837

        PR ipa/84963
        * gfortran.dg/goacc/pr84963.f90: Use dg-additional-options not
        dg-options as otherwise -fopenacc is not used.

From-SVN: r278836

	* profile-count.c (profile_count::to_cgraph_frequency,
	profile_count::to_sreal_scale): Check for compaibility of counts.
	* profile-count.h (compatible_p): Make public; add checking for
	global0 versus global types.
	* cgraph.c (cgraph_node::verify_node): Verify count compatibility.

From-SVN: r278835

Without epiloque no mask it would only try HI modes, but thanks to the
epiloques nomask It tries QI mode as well which succeeds.  The xfail
then generates an xpass since the condition on it checks for HI to SI
and not QI.

So I disabled the epiloque mask since it seems to violate the conditions
the test actually wanted to test for.

gcc/testsuite/ChangeLog:

	* gcc.dg/vect/slp-reduc-3.c: Turn off epilogue-nomask.

From-SVN: r278834

re PR tree-optimization/92715 (error: position plus size exceeds size of referenced object in  ‘bit_field_ref’)

2019-11-29  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/92715
	* tree-ssa-forwprop.c (simplify_vector_constructor): Bail
	out for uniform vectors and source vectors with less elements
	than the destination.

	* gcc.dg/torture/pr92715.c: New testcase.

From-SVN: r278833

	PR c++/60228
	* parser.c (cp_parser_omp_declare_reduction_exprs): If
	processing_template_decl, wrap the combiner or initializer
	into EXPR_STMT.
	* decl.c (start_preparsed_function): Don't start a lambda scope
	for DECL_OMP_DECLARE_REDUCTION_P functions.
	(finish_function): Don't finish a lambda scope for
	DECL_OMP_DECLARE_REDUCTION_P functions, nor cp_fold_function
	them nor cp_genericize them.
	* mangle.c (decl_mangling_context): Look through
	DECL_OMP_DECLARE_REDUCTION_P functions.
	* semantics.c (expand_or_defer_fn_1): For DECL_OMP_DECLARE_REDUCTION_P
	functions, use tentative linkage, don't keep their bodies with
	-fkeep-inline-functions and return false at the end.

	* g++.dg/gomp/openmp-simd-2.C: Don't expect bodies for
	DECL_OMP_DECLARE_REDUCTION_P functions.

	* testsuite/libgomp.c++/udr-20.C: New test.
	* testsuite/libgomp.c++/udr-21.C: New test.

From-SVN: r278832

	PR c++/60228
	* parser.c (cp_parser_omp_declare_reduction_exprs): If
	processing_template_decl, wrap the combiner or initializer
	into EXPR_STMT.
	* decl.c (start_preparsed_function): Don't start a lambda scope
	for DECL_OMP_DECLARE_REDUCTION_P functions.
	(finish_function): Don't finish a lambda scope for
	DECL_OMP_DECLARE_REDUCTION_P functions, nor cp_fold_function
	them nor cp_genericize them.
	* mangle.c (decl_mangling_context): Look through
	DECL_OMP_DECLARE_REDUCTION_P functions.
	* semantics.c (expand_or_defer_fn_1): For DECL_OMP_DECLARE_REDUCTION_P
	functions, use tentative linkage, don't keep their bodies with
	-fkeep-inline-functions and return false at the end.

	* g++.dg/gomp/openmp-simd-2.C: Don't expect bodies for
	DECL_OMP_DECLARE_REDUCTION_P functions.

	* testsuite/libgomp.c++/udr-20.C: New test.
	* testsuite/libgomp.c++/udr-21.C: New test.

From-SVN: r278831

2019-11-29  Martin Liska  <mliska@suse.cz>

	PR lto/91574
	* ipa-devirt.c (types_same_for_odr): Check for existence
	of TYPE_NAMEs first.
2019-11-29  Martin Liska  <mliska@suse.cz>

	PR lto/91574
	* g++.dg/lto/pr91574_0.C: New test.

From-SVN: r278829

2019-11-29  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/92704
	* tree-if-conv.c (combine_blocks): Deal with virtual PHIs
	in loops performing only loads.

	* gcc.dg/torture/pr92704.c: New testcase.

From-SVN: r278828

When adding the initial support for C2x attributes, I deferred the
unbounded lookahead support required to support such attributes in
Objective-C (except for the changes to string literal handling, which
were the riskier piece of preparation for such lookahead support).
This patch adds that remaining ObjC support.

For C, the parser continues to work exactly as it did before.  For
ObjC, however, when checking for whether '[[' starts attributes, it
lexes however many tokens are needed to check for a matching ']]', but
in a raw mode that omits all the context-sensitive processing that
c_lex_with_flags normally does, so that that processing can be done
later when the right context-sensitive flags are set.  Those tokens
are saved in a separate raw_tokens vector in the parser, and normal
c_lex_one_token calls will get tokens from there and perform the
remaining processing on them, if any tokens are found there, so all
parsing not using the new interfaces gets the same tokens as it did
before.  (For C, this raw lexing never occurs and the vector of raw
tokens is always NULL.)

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

gcc/c:
	* c-parser.c (struct c_parser): Add members raw_tokens and
	raw_tokens_used.
	(c_lex_one_token): Add argument raw.  Handle lexing raw tokens and
	using previously-lexed raw tokens.
	(c_parser_peek_nth_token_raw)
	(c_parser_check_balanced_raw_token_sequence): New functions.
	(c_parser_nth_token_starts_std_attributes): Use
	c_parser_check_balanced_raw_token_sequence for Objective-C.

gcc/testsuite:
	* objc.dg/attributes/gnu2x-attr-syntax-1.m: New test.

From-SVN: r278827

	gcc/
	* builtin-types.def (BT_DFLOAT32_PTR, BT_DFLOAT64_PTR,
	BT_DFLOAT128_PTR) Remove.
	* tree-core.h (TI_DFLOAT32_PTR_TYPE, TI_DFLOAT64_PTR_TYPE,
	TI_DFLOAT128_PTR_TYPE): Remove.
	* tree.c (build_common_type_nodes): Remove dfloat32_ptr_type_node,
	dfloat64_ptr_type_node and dfloat128_ptr_type_node initialisation.
	* tree.h (dfloat32_ptr_type_node, dfloat64_ptr_type_node,
	dfloat128_ptr_type_node): Remove macros.

	gcc/jit/
	* jit-builtins.c (BT_DFLOAT32_PTR, BT_DFLOAT64_PTR, BT_DFLOAT128_PTR):
	Remove commented-out cases.

Reviewed-by: Joseph Myers <joseph@codesourcery.com>

From-SVN: r278826

From-SVN: r278825

	* config/rs6000/rs6000.md (*movsi_internal1): Fix formatting.  Improve
	formatting.
	(*movdi_internal64): Ditto.

From-SVN: r278822

We run fwprop before combine, very early even in the case of fwprop1;
and fwprop1 will change memory addressing to what it considers cheaper.
After the "common" change, it now changes the indexed store instruction
in the testcase to be to a constant address.  But that is not an
improvement at all: the byte reverse instructions only exist in the
indexed form, so they will not match anymore.

This patch changes the patterns for the byte reverse instructions to
allow plain memory_operand, letting reload fix this up.


	PR target/92602
	* config/rs6000/rs6000.md (bswap<mode>2_load for HSI): Change the
	indexed_or_indirect_operand to be memory_operand.
	(bswap<mode>2_store for HSI): Ditto.
	(bswapdi2_load): Ditto.
	(bswapdi2_store): Ditto.

From-SVN: r278821

2019-11-28  Martin Liska  <mliska@suse.cz>

	PR debug/46558
	* dbgcnt.c (dbg_cnt_list_all_counters): Mark table
	headers for translation.

From-SVN: r278820

2019-11-28  Martin Liska  <mliska@suse.cz>

	PR lto/92609
	* ipa-devirt.c (warn_types_mismatch): Use TYPE_MAIN_VARIANT
	consistently.
2019-11-28  Martin Liska  <mliska@suse.cz>

	PR lto/92609
	* g++.dg/lto/pr92609_0.C: New test.
	* g++.dg/lto/pr92609_1.C: New test.

From-SVN: r278819

The switch to default of no-common means that we no longer
indirect the accesses to 'xxx' in this test.  Adjust the scan-
assembler tests to reflect this.

gcc/testsuite/ChangeLog:

2019-11-28  Iain Sandoe  <iain@sandoe.co.uk>

	* gcc.target/i386/pr32219-2.c: Adjust scan-assembler entries
	for revised common default.

From-SVN: r278818

re PR libfortran/90374 (Fortran 2018: Support d0.d, e0.d, es0.d, en0.d, g0.d and ew.d e0 edit descriptors for output)

	PR fortran/90374
	* io.c (check_format): Allow zero width expoenent with e0.

	* io/format.c (parse_format_list): Relax format checking to allow
	e0 exponent specifier.

	* gfortran.dg/fmt_zero_width.f90: Update test.

From-SVN: r278817

	* ipa-inline.c (want_early_inline_function_p): Remove leftover optimize
	checks.

From-SVN: r278816

profile-count.c (profile_count::combine_with_ipa_count): Return uninitialized count if called on ininitialized count.

	* profile-count.c (profile_count::combine_with_ipa_count): Return
	uninitialized count if called on ininitialized count.

From-SVN: r278815

	* ipa-inline-transform.c (inline_transform): Scale profile before
	redirecting.

From-SVN: r278814

	* profile-count.h (profile_count::max): Work on profiles of different
	type.
	(profile_count::apply_scale): Be sure that ret is not local or global0
	type if num is global.

From-SVN: r278813

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

	PR ipa/92697
	* cgraph.c (cgraph_node_cannot_be_local_p_1): Return true for
	ifunc_resolvers.
	* symtab.c (symtab_node::dump_base): Dump ifunc_resolver flag.
	Removed trailig whitespace.

	testsuite/
	* g++.dg/ipa/pr92697.C: New.

From-SVN: r278812

This patch fixes profile updates while cloning.  When new clone is produced
its global profile is subtracted from the original function.  If the original
function profile drops to 0 we want to switch from global profiles to global0
profiles which is implemented by combine_with_ipa_count_within.

However this is done on all edges independnetly and it may happen that we end
up combining global and globa0 profiles in one functions which is not a good
idea.

This implements profile_count::combine_with_ipa_count_within which is able
to take into account that the counter is inside function with a given count.

	* profile-count.h (profile_count::combine_with_ipa_count_within):
	Declare.
	* profile-count.c (profile_count::combine_with_ipa_count_within):
	New.
	* cgraphclones.c (cgraph_edge::clone, cgraph_node::create_clone): Use
	it.

From-SVN: r278811

This patch fixes profile updates while cloning.  When new clone is produced
its global profile is subtracted from the original function.  If the original
function profile drops to 0 we want to switch from global profiles to global0
profiles which is implemented by combine_with_ipa_count_within.

However this is done on all edges independnetly and it may happen that we end
up combining global and globa0 profiles in one functions which is not a good
idea.

This implements profile_count::combine_with_ipa_count_within which is able
to take into account that the counter is inside function with a given count.

	* profile-count.h (profile_count::combine_with_ipa_count_within):
	Declare.
	* profile-count.c (profile_count::combine_with_ipa_count_within):
	New.
	* cgraphclones.c (cgraph_edge::clone, cgraph_node::create_clone): Use
	it.

From-SVN: r278810

	* ipa-utils.c (ipa_merge_profiles): Be sure that all type transtions
	of counters are done same way.

From-SVN: r278809

From-SVN: r278808

re PR tree-optimization/92645 (Hand written vector code is 450 times slower when compiled with GCC compared to Clang)

2019-11-28  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/92645
	* tree-inline.c (remap_gimple_stmt): When the return value
	is not wanted, elide GIMPLE_RETURN.

	* gcc.dg/tree-ssa/inline-12.c: New testcase.

From-SVN: r278807