libstdc++-v3/ChangeLog:

	* configure.ac: Stop generating gstdint.h.
	* src/c++11/compatibility-atomic-c++0x.cc: Stop using gstdint.h.
	* Makefile.in: Regenerate.
	* aclocal.m4: Regenerate.
	* config.h.in: Regenerate.
	* configure: Regenerate.
	* doc/Makefile.in: Regenerate.
	* include/Makefile.in: Regenerate.
	* libsupc++/Makefile.in: Regenerate.
	* po/Makefile.in: Regenerate.
	* python/Makefile.in: Regenerate.
	* src/Makefile.in: Regenerate.
	* src/c++11/Makefile.in: Regenerate.
	* src/c++17/Makefile.in: Regenerate.
	* src/c++20/Makefile.in: Regenerate.
	* src/c++98/Makefile.in: Regenerate.
	* src/filesystem/Makefile.in: Regenerate.
	* src/libbacktrace/Makefile.in: Regenerate.
	* testsuite/Makefile.in: Regenerate.

I got this testcase:

  auto f() -> std::optional<std::string>;
  for (char c : f().value()) { }

which has a dangling reference: std::optional<T>::value returns
a reference to the contained value, but here it's the f() temporary.
We warn, which is great, but only with -Wsystem-headers, because
the function comes from a system header and warning_enabled_at used
in do_warn_dangling_reference checks diagnostic_report_warnings_p,
which in this case returned false so we didn't warn.

Fixed as below.  I could also override dc_warn_system_headers so that
the warning is enabled in system headers always.  With that, I found one
issue in libstdc++:

libstdc++-v3/include/bits/fs_path.h:1265:15: warning: possibly dangling reference to a temporary [-Wdangling-reference]
 1265 |         auto& __last = *--end();
      |               ^~~~~~

which looks like a true positive as well.

gcc/cp/ChangeLog:

	* call.cc (maybe_warn_dangling_reference): Enable the warning in
	system headers if the decl isn't in a system header.

gcc/testsuite/ChangeLog:

	* g++.dg/warn/Wdangling-reference4.C: New test.

Comparing attributes between declarations of a friend function has been
complicated by pushdecl happening before decl_attributes.  I assumed there
was some complicated reason we weren't calling decl_attributes here, but it
doesn't break anything.

gcc/cp/ChangeLog:

	* decl.cc (grokdeclarator): Call decl_attributes before do_friend.

C2x allows function prototypes to be given as (...), a prototype
meaning a variable-argument function with no named arguments.  To
allow such functions to access their arguments, requirements for
va_start calls are relaxed so it ignores all but its first argument
(i.e. subsequent arguments, if any, can be arbitrary pp-token
sequences).

Implement this feature accordingly.  The va_start relaxation in
<stdarg.h> is itself easy: __builtin_va_start already supports a
second argument of 0 instead of a parameter name, and calls get
converted internally to the form using 0 for that argument, so
<stdarg.h> just needs changing to use a variadic macro that passes 0
as the second argument of __builtin_va_start.  (This is done only in
C2x mode, on the expectation that users of older standard would expect
unsupported uses of va_start to be diagnosed.)

For the (...) functions, it's necessary to distinguish these from
unprototyped functions, whereas previously C++ (...) functions and
unprototyped functions both used NULL TYPE_ARG_TYPES.  A flag is added
to tree_type_common to mark the (...) functions; as discussed on gcc@,
doing things this way is likely to be safer for unchanged code in GCC
than adding a different form of representation in TYPE_ARG_TYPES, or
adding a flag that instead signals that the function is unprototyped.

There was previously an option
-fallow-parameterless-variadic-functions to enable support for (...)
prototypes.  The support was incomplete - it treated the functions as
unprototyped, and only parsed some declarations, not e.g.
"int g (int (...));".  This option is changed into a no-op ignored
option; (...) is always accepted syntactically, with a pedwarn_c11
call to given required diagnostics when appropriate.  The peculiarity
of a parameter list with __attribute__ followed by '...' being
accepted with that option is removed.

Interfaces in tree.cc that create function types are adjusted to set
this flag as appropriate.  It is of course possible that some existing
users of the functions to create variable-argument functions actually
wanted unprototyped functions in the no-named-argument case, rather
than functions with a (...) prototype; some such cases in c-common.cc
(for built-in functions and implicit function declarations) turn out
to need updating for that reason.

I didn't do anything to change how the C++ front end creates (...)
function types.  It's very likely there are unchanged places in the
compiler that in fact turn out to need changes to work properly with
(...) function prototypes.

Target setup_incoming_varargs hooks, where they used the information
passed about the last named argument, needed updating to avoid using
that information in the (...) case.  Note that apart from the x86
changes, I haven't done any testing of those target changes beyond
building cc1 to check for syntax errors.  It's possible further
target-specific fixes will be needed; target maintainers should watch
out for failures of c2x-stdarg-4.c or c2x-stdarg-split-1a.c, the
execution tests, which would indicate that this feature is not working
correctly.  Those tests also verify the case where there are named
arguments but the last named argument has a declaration that results
in undefined behavior in previous C standard versions, such as a type
changed by the default argument promotions.

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

gcc/
	* config/aarch64/aarch64.cc (aarch64_setup_incoming_varargs):
	Check TYPE_NO_NAMED_ARGS_STDARG_P.
	* config/alpha/alpha.cc (alpha_setup_incoming_varargs): Likewise.
	* config/arc/arc.cc (arc_setup_incoming_varargs): Likewise.
	* config/arm/arm.cc (arm_setup_incoming_varargs): Likewise.
	* config/csky/csky.cc (csky_setup_incoming_varargs): Likewise.
	* config/epiphany/epiphany.cc (epiphany_setup_incoming_varargs):
	Likewise.
	* config/fr30/fr30.cc (fr30_setup_incoming_varargs): Likewise.
	* config/frv/frv.cc (frv_setup_incoming_varargs): Likewise.
	* config/ft32/ft32.cc (ft32_setup_incoming_varargs): Likewise.
	* config/i386/i386.cc (ix86_setup_incoming_varargs): Likewise.
	* config/ia64/ia64.cc (ia64_setup_incoming_varargs): Likewise.
	* config/loongarch/loongarch.cc
	(loongarch_setup_incoming_varargs): Likewise.
	* config/m32r/m32r.cc (m32r_setup_incoming_varargs): Likewise.
	* config/mcore/mcore.cc (mcore_setup_incoming_varargs): Likewise.
	* config/mips/mips.cc (mips_setup_incoming_varargs): Likewise.
	* config/mmix/mmix.cc (mmix_setup_incoming_varargs): Likewise.
	* config/nds32/nds32.cc (nds32_setup_incoming_varargs): Likewise.
	* config/nios2/nios2.cc (nios2_setup_incoming_varargs): Likewise.
	* config/riscv/riscv.cc (riscv_setup_incoming_varargs): Likewise.
	* config/rs6000/rs6000-call.cc (setup_incoming_varargs): Likewise.
	* config/sh/sh.cc (sh_setup_incoming_varargs): Likewise.
	* config/visium/visium.cc (visium_setup_incoming_varargs):
	Likewise.
	* config/vms/vms-c.cc (vms_c_common_override_options): Do not set
	flag_allow_parameterless_variadic_functions.
	* doc/invoke.texi (-fallow-parameterless-variadic-functions): Do
	not document option.
	* function.cc (assign_parms): Call assign_parms_setup_varargs for
	TYPE_NO_NAMED_ARGS_STDARG_P case.
	* ginclude/stdarg.h [__STDC_VERSION__ > 201710L] (va_start): Make
	variadic macro.  Pass second argument of 0 to __builtin_va_start.
	* target.def (setup_incoming_varargs): Update documentation.
	* doc/tm.texi: Regenerate.
	* tree-core.h (struct tree_type_common): Add
	no_named_args_stdarg_p.
	* tree-streamer-in.cc (unpack_ts_type_common_value_fields): Unpack
	TYPE_NO_NAMED_ARGS_STDARG_P.
	* tree-streamer-out.cc (pack_ts_type_common_value_fields): Pack
	TYPE_NO_NAMED_ARGS_STDARG_P.
	* tree.cc (type_cache_hasher::equal): Compare
	TYPE_NO_NAMED_ARGS_STDARG_P.
	(build_function_type): Add argument no_named_args_stdarg_p.
	(build_function_type_list_1, build_function_type_array_1)
	(reconstruct_complex_type): Update calls to build_function_type.
	(stdarg_p, prototype_p): Return true for (...) functions.
	(gimple_canonical_types_compatible_p): Compare
	TYPE_NO_NAMED_ARGS_STDARG_P.
	* tree.h (TYPE_NO_NAMED_ARGS_STDARG_P): New.
	(build_function_type): Update prototype.

gcc/c-family/
	* c-common.cc (def_fn_type): Call build_function_type for
	zero-argument variable-argument function.
	(c_common_nodes_and_builtins): Build default_function_type with
	build_function_type.
	* c.opt (fallow-parameterless-variadic-functions): Mark as ignored
	option.

gcc/c/
	* c-decl.cc (grokdeclarator): Pass
	arg_info->no_named_args_stdarg_p to build_function_type.
	(grokparms): Check arg_info->no_named_args_stdarg_p before
	converting () to (void).
	(build_arg_info): Initialize no_named_args_stdarg_p.
	(get_parm_info): Set no_named_args_stdarg_p.
	(start_function): Pass TYPE_NO_NAMED_ARGS_STDARG_P to
	build_function_type.
	(store_parm_decls): Count (...) functions as prototyped.
	* c-parser.cc (c_parser_direct_declarator): Allow '...' after open
	parenthesis to start parameter list.
	(c_parser_parms_list_declarator): Always allow '...' with no
	arguments, call pedwarn_c11 and set no_named_args_stdarg_p.
	* c-tree.h (struct c_arg_info): Add field no_named_args_stdarg_p.
	* c-typeck.cc (composite_type): Handle
	TYPE_NO_NAMED_ARGS_STDARG_P.
	(function_types_compatible_p): Compare
	TYPE_NO_NAMED_ARGS_STDARG_P.

gcc/fortran/
	* trans-types.cc (gfc_get_function_type): Do not use
	build_varargs_function_type_vec for unprototyped function.

gcc/lto/
	* lto-common.cc (compare_tree_sccs_1): Compare
	TYPE_NO_NAMED_ARGS_STDARG_P.

gcc/objc/
	* objc-next-runtime-abi-01.cc (build_next_objc_exception_stuff):
	Use build_function_type to build type of objc_setjmp_decl.

gcc/testsuite/
	* gcc.dg/c11-stdarg-1.c, gcc.dg/c11-stdarg-2.c,
	gcc.dg/c11-stdarg-3.c, gcc.dg/c2x-stdarg-1.c,
	gcc.dg/c2x-stdarg-2.c, gcc.dg/c2x-stdarg-3.c,
	gcc.dg/c2x-stdarg-4.c, gcc.dg/gnu2x-stdarg-1.c,
	gcc.dg/torture/c2x-stdarg-split-1a.c,
	gcc.dg/torture/c2x-stdarg-split-1b.c: New tests.
	* gcc.dg/Wold-style-definition-2.c, gcc.dg/format/sentinel-1.c:
	Update expected diagnostics.
	* gcc.dg/c2x-nullptr-1.c (test5): Cast unused parameter to (void).
	* gcc.dg/diagnostic-token-ranges.c: Use -pedantic.  Expect warning
	in place of error.

The PR points out that we assume the match_results allocator is default
constuctible, which might not be true. We also have a related issue with
unwanted propagation from an object that might have an unequal
allocator.

Ideally we use the same allocator type for _State_info::_M_match_queue
but that would be an ABI change now. We should investigate if that can
be done without breaking anything, which might be possible because the
_Executor object is short-lived and never leaks out of the regex_match,
regex_search, and regex_replace algorithms. If we change the mangled
name for _Executor then there would be no ODR violations when mixing old
and new definitions. This commit does not attempt that.

libstdc++-v3/ChangeLog:

	PR libstdc++/107376
	* include/bits/regex_executor.h (_Executor::_Executor): Use same
	allocator for _M_cur_results and _M_results.
	* include/bits/regex_executor.tcc (_Executor::_M_main_dispatch):
	Prevent possibly incorrect allocator propagating to
	_M_cur_results.
	* testsuite/28_regex/algorithms/regex_match/107376.cc: New test.

The ada failure reported in the PR was being caused by vect_check_gather_scatter
failing to deal with bit offsets that weren't multiples of BITS_PER_UNIT. This
patch makes vect_check_gather_scatter reject memory accesses with such offsets.

gcc/ChangeLog:

	PR tree-optimization/107346
	* tree-vect-data-refs.cc (vect_check_gather_scatter): Reject offsets
	that aren't multiples of BITS_PER_UNIT.

So what happens is that we elide processing of this check with

          /* In addition to kills we can remove defs whose only use
             is another def in defs.  That can only ever be PHIs of which
             we track two for simplicity reasons, the first and last in
             {first,last}_phi_def (we fail for multiple PHIs anyways).
             We can also ignore defs that feed only into
             already visited PHIs.  */
          else if (single_imm_use (vdef, &use_p, &use_stmt)
                   && (use_stmt == first_phi_def
                       || use_stmt == last_phi_def
                       || (gimple_code (use_stmt) == GIMPLE_PHI
                           && bitmap_bit_p (visited,
                                            SSA_NAME_VERSION
                                              (PHI_RESULT (use_stmt))))))

where we have the last PHI being the outer loop virtual PHI and the first
PHI being the loop exit PHI of the outer loop and we've already processed
the single immediate use of the outer loop PHI, the inner loop PHI.  But
we still have to perform the above check!

It's easiest to perform the check when we visit the PHI node instead of
delaying it to the actual processing loop.

	PR tree-optimization/107407
	* tree-ssa-dse.cc (dse_classify_store): Perform backedge
	varying index check when collecting PHI uses rather than
	after optimizing processing of the candidate defs.

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

The following makes sure to not hoist returns-twice calls in LIM
since we have no way to move the abnormal edge associated with it
and we are prone having stray abnormal edges in the IL which will
then cause IL verification failures even when the actual call
does not return twice.

	PR tree-optimization/107447
	* tree-ssa-loop-im.cc (determine_max_movement): Do not
	hoist returns-twice calls.

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

This implements the missed conversion from pointer to integer.

	PR tree-optimization/107435
	* tree-vect-loop.cc (vectorizable_recurr): Convert initial
	value to vector component type.

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

Previously we've been allowing that comma only in C++ when in attribute
form (which was the reason why it has been allowed), but 5.1 allows that
even in pragma form in C/C++ (with clarifications in 5.2) and 5.2
also in Fortran (which this patch doesn't implement).

Note, for directives which take an argument (== unnamed clause),
comma is not allowed in between the directive name and the argument,
like the directive-1.c testcase shows.

2022-10-28  Jakub Jelinek  <jakub@redhat.com>

gcc/c/
	* c-parser.cc (c_parser_omp_all_clauses): Allow optional
	comma before the first clause.
	(c_parser_omp_allocate, c_parser_omp_atomic, c_parser_omp_depobj,
	c_parser_omp_flush, c_parser_omp_scan_loop_body,
	c_parser_omp_ordered, c_finish_omp_declare_variant,
	c_parser_omp_declare_target, c_parser_omp_declare_reduction,
	c_parser_omp_requires, c_parser_omp_error,
	c_parser_omp_assumption_clauses): Likewise.
gcc/cp/
	* parser.cc (cp_parser_omp_all_clauses): Allow optional comma
	before the first clause even in pragma syntax.
	(cp_parser_omp_allocate, cp_parser_omp_atomic, cp_parser_omp_depobj,
	cp_parser_omp_flush, cp_parser_omp_scan_loop_body,
	cp_parser_omp_ordered, cp_parser_omp_assumption_clauses,
	cp_finish_omp_declare_variant, cp_parser_omp_declare_target,
	cp_parser_omp_declare_reduction_exprs, cp_parser_omp_requires,
	cp_parser_omp_error): Likewise.
gcc/testsuite/
	* c-c++-common/gomp/directive-1.c: New test.
	* c-c++-common/gomp/clauses-6.c: New test.
	* c-c++-common/gomp/declare-variant-2.c (f75a): Declare.
	(f75): Use f75a as variant instead of f1 and don't expect error.
	* g++.dg/gomp/clause-4.C (foo): Don't expect error on comma
	before first clause.
	* gcc.dg/gomp/clause-2.c (foo): Likewise.

The following adjusts the testcase to require no epilogue also
for larger vectors than V4SI.

	* gcc.dg/vect/pr100756.c: Adjust for larger vectors.

This patch prevents compiler-generated artificial variables from being
treated as privatization candidates for OpenACC.

The rationale is that e.g. "gang-private" variables actually must be
shared by each worker and vector spawned within a particular gang, but
that sharing is not necessary for any compiler-generated variable (at
least at present, but no such need is anticipated either).  Variables on
the stack (and machine registers) are already private per-"thread"
(gang, worker and/or vector), and that's fine for artificial variables.

We're restricting this to blocks, as we still need to understand what it
means for a 'DECL_ARTIFICIAL' to appear in a 'private' clause.

Several tests need their scan output patterns adjusted to compensate.

2022-10-14  Julian Brown  <julian@codesourcery.com>

	PR middle-end/90115
gcc/
	* omp-low.cc (oacc_privatization_candidate_p): Artificial vars are not
	privatization candidates.

libgomp/
	* testsuite/libgomp.oacc-fortran/declare-1.f90: Adjust scan output.
	* testsuite/libgomp.oacc-fortran/host_data-5.F90: Likewise.
	* testsuite/libgomp.oacc-fortran/if-1.f90: Likewise.
	* testsuite/libgomp.oacc-fortran/print-1.f90: Likewise.
	* testsuite/libgomp.oacc-fortran/privatized-ref-2.f90: Likewise.

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

... to restore testing lost in recent
commit r13-3225-gbd9a05594d227cde79a67dc715bd9d82e9c464e9
"amdgcn: vector testsuite tweaks" (for example, x86_64-pc-linux-gnu):

    PASS: gcc.dg/vect/bb-slp-cond-1.c (test for excess errors)
    PASS: gcc.dg/vect/bb-slp-cond-1.c -flto -ffat-lto-objects  scan-tree-dump vect "(no need for alias check [^\\n]* when VF is 1|no alias between [^\\n]* when [^\\n]* is outside \\(-16, 16\\))"
    [-PASS: gcc.dg/vect/bb-slp-cond-1.c -flto -ffat-lto-objects  scan-tree-dump-times vect "loop vectorized" 1-]
    PASS: gcc.dg/vect/bb-slp-cond-1.c -flto -ffat-lto-objects (test for excess errors)
    PASS: gcc.dg/vect/bb-slp-cond-1.c -flto -ffat-lto-objects execution test
    PASS: gcc.dg/vect/bb-slp-cond-1.c execution test
    PASS: gcc.dg/vect/bb-slp-cond-1.c scan-tree-dump vect "(no need for alias check [^\\n]* when VF is 1|no alias between [^\\n]* when [^\\n]* is outside \\(-16, 16\\))"
    [-PASS: gcc.dg/vect/bb-slp-cond-1.c scan-tree-dump-times vect "loop vectorized" 1-]

	gcc/testsuite/
	* gcc.dg/vect/bb-slp-cond-1.c: Fix target selector syntax.

	PR sanitizer/107298

gcc/ChangeLog:

	* doc/invoke.texi: Document sanitizers can trigger warnings.

gcc/lto/ChangeLog:

	* lto-dump.cc (dump_list): Remove trailing return.
	(dump_symbol): Likewise.
	(dump_body): Filter name based on mangled name.
	(dump_tool_help): Use GIMPLE wording.
	(lto_main): Update wording.

Refer to 'Makefile.tpl':

    # Rules to wipe a stage and all the following ones, also used for cleanstrap
    [+ IF prev +]distclean-stage[+prev+]:: distclean-stage[+id+] [+ ENDIF prev +]
    .PHONY: distclean-stage[+id+]
    distclean-stage[+id+]::
    	@: $(MAKE); $(stage)
    	@test "`cat stage_last`" != stage[+id+] || rm -f stage_last
    	rm -rf stage[+id+]-* [+
    	  IF compare-target +][+compare-target+] [+ ENDIF compare-target +]

	gcc/
	* doc/makefile.texi (Makefile Targets): Document
	'distclean-stage[N]'.

gcc/ChangeLog:

	* value-range.cc (range_tests_floats): Use HONOR_INFINITIES.

The test cases vect-bitfield-read-* requires vector shift
target support, they need one explicit vect_shift effective
target requirement checking.  Besides, the vectype for struct
in test cases vect-bitfield-read-{2,4} is vector of long long,
we need to check effective target vect_long_long for them.
This patch can help to fix all remaining vect-bitfield-{read,
write}-* test failures on powerpc.

	PR testsuite/107240

gcc/testsuite/ChangeLog:

	* gcc.dg/vect/vect-bitfield-read-1.c: Add effective target checking
	vect_shift.
	* gcc.dg/vect/vect-bitfield-read-3.c: Likewise.
	* gcc.dg/vect/vect-bitfield-read-5.c: Likewise.
	* gcc.dg/vect/vect-bitfield-read-6.c: Likewise.
	* gcc.dg/vect/vect-bitfield-read-7.c: Likewise.
	* gcc.dg/vect/vect-bitfield-read-2.c: Add effective target checking
	vect_shift and replace vect_int with vect_long_long.
	* gcc.dg/vect/vect-bitfield-read-4.c: Likewise.

C2x adds support for enums with a fixed underlying type specified
("enum e : long long;" and similar).  Implement this in the C front
end.  The same representation is used for these types as in C++, with
two macros moved from cp-tree.h to c-common.h.

Such enums can have bool as the underlying type, and various C
front-end code checking for boolean types is adjusted to use a new
C_BOOLEAN_TYPE_P to handle such enums the same way as bool.  (Note
that for C++ we have bug 96496 that enums with underlying type bool
don't work correctly there.)

There are various issues with the wording for such enums in the
current C2x working draft (including but not limited to wording in the
accepted paper that failed to make it into the working draft), which I
intend to raise in NB comments.  I think what I've implemented and
added tests for matches the intent.

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

	PR c/61469

gcc/c-family/
	* c-common.h (ENUM_UNDERLYING_TYPE, ENUM_FIXED_UNDERLYING_TYPE_P):
	New.  Moved from cp/cp-tree.h.
	* c-warn.cc (warnings_for_convert_and_check): Do not consider
	conversions to enum with underlying type bool to overflow.

gcc/c/
	* c-convert.cc (c_convert): Handle enums with underlying boolean
	type like bool.
	* c-decl.cc (shadow_tag_warned): Allow shadowing declarations for
	enums with enum type specifier, but give errors for storage class
	specifiers, qualifiers or alignment specifiers in non-definition
	declarations of such enums.
	(grokdeclarator): Give error for non-definition use of type
	specifier with an enum type specifier.
	(parser_xref_tag): Add argument has_enum_type_specifier.  Pass it
	to lookup_tag and use it to set ENUM_FIXED_UNDERLYING_TYPE_P.
	(xref_tag): Update call to parser_xref_tag.
	(start_enum): Add argument fixed_underlying_type.  Complete enum
	type with a fixed underlying type given in the definition.  Give
	error for defining without a fixed underlying type in the
	definition if one was given in a prior declaration.  Do not mark
	enums with fixed underlying type as packed for -fshort-enums.
	Store the enum type in the_enum.
	(finish_enum): Do not adjust types of values or check their range
	for an enum with a fixed underlying type.  Set underlying type of
	enum and variants.
	(build_enumerator): Check enumeration constants for enum with
	fixed underlying type against that type and convert to that type.
	Increment in the underlying integer type, with handling for bool.
	(c_simulate_enum_decl): Update call to start_enum.
	(declspecs_add_type): Set specs->enum_type_specifier_ref_p.
	* c-objc-common.cc (c_get_alias_set): Use ENUM_UNDERLYING_TYPE
	rather than recomputing an underlying type based on size.
	* c-parser.cc (c_parser_declspecs)
	(c_parser_struct_or_union_specifier, c_parser_typeof_specifier):
	Set has_enum_type_specifier for type specifiers.
	(c_parser_enum_specifier): Handle enum type specifiers.
	(c_parser_struct_or_union_specifier): Update call to
	parser_xref_tag.
	(c_parser_omp_atomic): Check for boolean increment or decrement
	using C_BOOLEAN_TYPE_P.
	* c-tree.h (C_BOOLEAN_TYPE_P): New.
	(struct c_typespec): Add has_enum_type_specifier.
	(struct c_declspecs): Add enum_type_specifier_ref_p.
	(struct c_enum_contents): Add enum_type.
	(start_enum, parser_xref_tag): Update prototypes.
	* c-typeck.cc (composite_type): Allow for enumerated types
	compatible with bool.
	(common_type, comptypes_internal, perform_integral_promotions):
	Use ENUM_UNDERLYING_TYPE.
	(parser_build_binary_op, build_unary_op, convert_for_assignment)
	(c_finish_return, c_start_switch, build_binary_op): Check for
	boolean types using C_BOOLEAN_TYPE_P.

gcc/cp/
	* cp-tree.h (ENUM_FIXED_UNDERLYING_TYPE_P, ENUM_UNDERLYING_TYPE):
	Remove.  Moved to c-common.h.

gcc/testsuite/
	* gcc.dg/c11-enum-4.c, gcc.dg/c11-enum-5.c, gcc.dg/c11-enum-6.c,
	gcc.dg/c2x-enum-6.c, gcc.dg/c2x-enum-7.c, gcc.dg/c2x-enum-8.c,
	gcc.dg/gnu2x-enum-1.c: New tests.

The last argument to the C mmap function is type off_t, not uintptr.
On some 32-bit systems, off_t is larger than uintptr.

Based on patch by Sören Tempel.

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

The setting looks obsolete at this point.

gcc/
	* config/aarch64/aarch64.h (DONT_USE_BUILTIN_SETJMP): Delete.

In i386.md, neg patterns which set MODE_CC register like

(set (reg:CCC FLAGS_REG)
     (ne:CCC (match_operand:SWI48 1 "general_reg_operand") (const_int 0)))

can lead to errors when operand 1 is a constant value.  If FLAGS_REG in

(set (reg:CCC FLAGS_REG)
     (ne:CCC (const_int 2) (const_int 0)))

is set to 1, RTX simplifiers may simplify

(set (reg:SI 93)
     (neg:SI (ltu:SI (reg:CCC 17 flags) (const_int 0 [0]))))

as

(set (reg:SI 93)
     (neg:SI (ltu:SI (const_int 1) (const_int 0 [0]))))

which leads to incorrect results since LTU on MODE_CC register isn't the
same as "unsigned less than" in x86 backend.  To prevent RTL optimizers
from setting MODE_CC register to a constant, use UNSPEC_CC_NE to replace
ne:CCC/ne:CCO when setting FLAGS_REG in neg patterns.

gcc/

	PR target/107172
	* config/i386/i386.md (UNSPEC_CC_NE): New.
	Replace ne:CCC/ne:CCO with UNSPEC_CC_NE in neg patterns.

gcc/testsuite/

	PR target/107172
	* gcc.target/i386/pr107172.c: New test.

This is a simple patch to do some DCE after a successful
match and simplify replacement in PHI-OPT. match and simplify
likes to generate some extra statements which should be cleaned
up.

OK? Bootstrapped and tested on x86_64-linux with no regressions.

Thanks,
Andrew Pinski

gcc/ChangeLog:

	* tree-ssa-phiopt.cc: Include tree-ssa-dce.h
	(replace_phi_edge_with_variable):
	New argument, dce_ssa_names. Call simple_dce_from_worklist.
	(match_simplify_replacement): If we inserted a sequence,
	mark the lhs of the new sequence to be possible dce.
	Always move the statement and mark the lhs (if it is a name)
	as possible to remove.

As mentioned in the PR, apparently my r13-2887 P1467R9 changes
regressed these tests on powerpc64le-linux with IEEE quad by default.

I believe my changes just uncovered a latent bug.
The problem is that push_namespace calls find_namespace_slot,
which does:
  tree *slot = DECL_NAMESPACE_BINDINGS (ns)
    ->find_slot_with_hash (name, name ? IDENTIFIER_HASH_VALUE (name) : 0,
                           create_p ? INSERT : NO_INSERT);
In the <identifier_node 0x7fffe9f55ac0 details> ns case, slot is non-NULL
above with a binding_vector in it.
Then pushdecl is called and this does:
                  slot = find_namespace_slot (ns, name, ns == current_namespace);
where ns == current_namespace (ns is :: and name is details) is true.
So this again calls
          tree *slot = DECL_NAMESPACE_BINDINGS (ns)
            ->find_slot_with_hash (name, name ? IDENTIFIER_HASH_VALUE (name) : 0,
                                   create_p ? INSERT : NO_INSERT);
but this time with create_p and so INSERT.
At this point we reach
          if (insert == INSERT && m_size * 3 <= m_n_elements * 4)
            expand ();
and when we are unlucky and the occupancy of the hash table just reached 3/4,
expand () is called and the hash table is reallocated.  But when that happens,
it means the slot pointer in the pushdecl caller (push_namespace) points to
freed memory and so any accesses to it in make_namespace_finish will be UB.

The following patch fixes it by calling find_namespace_slot again even if it
was non-NULL, just doesn't assert it is *slot == ns in that case (because
it often is not).

2022-10-27  Jakub Jelinek  <jakub@redhat.com>

	PR c++/107379
	* name-lookup.cc (push_namespace): Call find_namespace_slot again
	after pushdecl as the hash table might be expanded during pushdecl.

(Explicitly) Templated lambdas have a different signature to
implicitly templated lambdas -- '[]<template T> (T) {}' is not the
same as '[](auto) {}'.  This should be reflected in the mangling.  The
ABI captures this as
https://github.com/itanium-cxx-abi/cxx-abi/issues/31, and clang has
implemented such additions.

It's relatively straight forwards to write out the non-synthetic
template parms, and note if we need to issue an ABI warning.

	gcc/cp/
	* mangle.cc (write_closure_template_head): New.
	(write_closure_type_name): Call it.
	gcc/testsuite/
	* g++.dg/abi/lambda-ctx1-18.C: Adjust.
	* g++.dg/abi/lambda-ctx1-18vs17.C: Adjust.
	* g++.dg/abi/lambda-tpl1-17.C: New.
	* g++.dg/abi/lambda-tpl1-18.C: New.
	* g++.dg/abi/lambda-tpl1-18vs17.C: New.
	* g++.dg/abi/lambda-tpl1.h: New.

In 9482a5e4 I'd replaced uses
of CONSTEXPR with direct uses of constexpr.  However, it turns
out that we still have CONSTEXPR for a reason: GCC 4.8 doesn't
implement constexpr properly, and for example rejects things like:

  extern const int x;
  constexpr int x = 1;

This patch partially reverts the previous one.  To make things
more complicated, there are still some things that need to be
constexpr rather than CONSTEXPR, since they are used to initialise
scalar constants.  The patch therefore doesn't change anything
in aarch64-feature-deps.h.

gcc/
	* config/aarch64/aarch64-protos.h: Replace constexpr with
	CONSTEXPR.
	* config/aarch64/aarch64-sve-builtins-base.cc: Likewise.
	* config/aarch64/aarch64-sve-builtins-functions.h: Likewise.
	* config/aarch64/aarch64-sve-builtins-shapes.cc: Likewise.
	* config/aarch64/aarch64-sve-builtins-sve2.cc: Likewise.
	* config/aarch64/aarch64-sve-builtins.cc: Likewise.
	* config/aarch64/aarch64.cc: Likewise.
	* config/aarch64/driver-aarch64.cc: Likewise

The problem here is that we're inlining a global range with NANs into
a function that has been tagged with __attribute__((optimize
("-ffinite-math-only"))).  As the global range is copied from
SSA_NAME_RANGE_INFO, its NAN bits are copied, which then cause
frange::verify_range() to fail a sanity check making sure no NANs
creep in when !HONOR_NANS.

I think what we should do is nuke the NAN bits as we're restoring the
global range.  For that matter, if we use the frange constructor,
everything except that NAN sign will be done automatically, including
dropping INFs to the min/max representable range when appropriate.

	PR tree-optimization/107394

gcc/ChangeLog:

	* value-range-storage.cc (frange_storage_slot::get_frange): Use
	frange constructor.

gcc/testsuite/ChangeLog:

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

This clarifies commit 95db7e9a
"options, lto: Optimize streaming of optimization nodes".

No functional change; no change in generated files.

	gcc/
	* optc-save-gen.awk: Clarify 'Init' option property usage for
	streaming optimization.

	PR lto/107418

gcc/lto/ChangeLog:

	* lto-dump.cc (lto_main): Do not load LTO stream for aliases.

The following tests ICE in the gcc_assert (common); in cp_build_binary_op.
I've missed that while for * common is set always, while for +, - and /
it is in some cases not.
If it is not, then
  if (!result_type
      && arithmetic_types_p
      && (shorten || common || short_compare))
condition is false, then the following
  if (may_need_excess_precision
      && (orig_type0 != type0 || orig_type1 != type1)
      && build_type == NULL_TREE)
would fail the assertion there and if there wouldn't be excess precision,
  if (code == SPACESHIP_EXPR)
would be false (for SPACESHIP_EXPR we always have build_type set like for
other comparisons) and then trigger
  if (!result_type)
    {
      if (complain & tf_error)
        {
          binary_op_rich_location richloc (location,
                                           orig_op0, orig_op1, true);
          error_at (&richloc,
                    "invalid operands of types %qT and %qT to binary %qO",
                    TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
        }
      return error_mark_node;
    }
So, if result_type is NULL, we don't really need to compute
semantic_result_type because nothing will use it anyway and can get
fall through into the error/return error_mark_node; case.

2022-10-27  Jakub Jelinek  <jakub@redhat.com>

	PR c++/107382
	PR c++/107383
	* typeck.cc (cp_build_binary_op): Don't compute semantic_result_type
	if result_type is NULL.

	* g++.dg/diagnostic/bad-binary-ops2.C: New test.

In commit 081c9662, the call to resize_reg_info() was moved before
the call to remove_scratches() and the latter one can increase the
number of regs and that would cause an out of bounds usage on the
reg_renumber global array.

Without this patch, the following testcase randomly fails with:
during RTL pass: ira
In file included from /src/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_y.c:13:
/src/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_y.c: In function 'checkgSf13':
/src/gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-y.h:28:1: internal compiler error: Segmentation fault
/src/gcc/testsuite/gcc.dg/compat/struct-by-value-5b_y.c:22:1: note: in expansion of macro 'TEST'

gcc/ChangeLog:

	* ira.cc: Resize array after reg number increased.

Co-Authored-By: Yvan ROUX <yvan.roux@foss.st.com>
Signed-off-by: Torbjörn SVENSSON <torbjorn.svensson@foss.st.com>

Test zhinx/zhinxmin support, same like with zfh/zfhmin testcases
but use gprs and don't use fmv instruction.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/_Float16-zhinx-1.c: New test.
	* gcc.target/riscv/_Float16-zhinx-2.c: New test.
	* gcc.target/riscv/_Float16-zhinx-3.c: New test.
	* gcc.target/riscv/_Float16-zhinxmin-1.c: New test.
	* gcc.target/riscv/_Float16-zhinxmin-2.c: New test.
	* gcc.target/riscv/_Float16-zhinxmin-3.c: New test.

Limit z*inx abi support with 'ilp32','ilp32e','lp64' only.
Use GPR instead FPR when 'zfinx' enable, Only use even registers
in RV32 when 'zdinx' enable.
Enable FLOAT16 when Zhinx/Zhinxmin enabled.

Co-Authored-By: Sinan Lin <sinan@isrc.iscas.ac.cn>

gcc/ChangeLog:

	* config/riscv/constraints.md (TARGET_ZFINX ? GR_REGS): Set GPRS
	use while Zfinx is enable.
	* config/riscv/riscv.cc (riscv_hard_regno_mode_ok): Limit odd
	registers use when Zdinx enable in RV32 cases.
	(riscv_option_override): New target enable MASK_FDIV.
	(riscv_libgcc_floating_mode_supported_p): New error info when
	use incompatible arch&abi.
	(riscv_excess_precision): New target enable FLOAT16.

Support 'TARGET_ZFINX' with float instruction pattern and builtin function.
Reuse 'TARGET_HADR_FLOAT',  'TARGET_DOUBLE_FLOAT' and 'TARGET_ZHINX' patterns.

gcc/ChangeLog:

	* config/riscv/iterators.md (TARGET_ZFINX):New target.
	(TARGET_ZDINX): Ditto.
	(TARGET_ZHINX): Ditto.
	* config/riscv/riscv-builtins.cc (AVAIL): Ditto.
	(riscv_atomic_assign_expand_fenv): Ditto.
	* config/riscv/riscv-c.cc (riscv_cpu_cpp_builtins): Ditto.
	* config/riscv/riscv.md: Ditto.

Minimal support of z*inx extension, include 'zfinx'， 'zdinx' and 'zhinx/zhinxmin'
corresponding to 'f', 'd' and 'zfh/zfhmin', the 'zdinx' will imply 'zfinx'
same as 'd' imply 'f', 'zhinx' will aslo imply 'zfinx', all zfinx extension imply 'zicsr'.

Co-Authored-By: Sinan Lin <sinan@isrc.iscas.ac.cn>

gcc/ChangeLog:

	* common/config/riscv/riscv-common.cc: New extensions.
	* config/riscv/arch-canonicalize: New imply relations.
	* config/riscv/riscv-opts.h (MASK_ZFINX): New mask.
	(MASK_ZDINX): Ditto.
	(MASK_ZHINX): Ditto.
	(MASK_ZHINXMIN): Ditto.
	(TARGET_ZFINX): New target.
	(TARGET_ZDINX): Ditto.
	(TARGET_ZHINX): Ditto.
	(TARGET_ZHINXMIN): Ditto.
	* config/riscv/riscv.opt: New target variable.

gcc/analyzer/ChangeLog:
	* sm-fd.cc (fd_state_machine::on_open): Transition to "unchecked"
	when the mode is symbolic, rather than just on integer constants.
	(fd_state_machine::check_for_open_fd): Don't complain about
	unchecked values in the start state.

gcc/testsuite/ChangeLog:
	* gcc.dg/analyzer/fd-3.c (test_5): Expect "opened here" message
	even when flags are symbolic.
	(test_read_from_symbolic_fd): New.
	(test_write_to_symbolic_fd): New.

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

Add a .dot file to document the file descriptor state machine.

gcc/analyzer/ChangeLog:
	* sm-fd.dot: New file.

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

gcc/fortran/ChangeLog:

	PR fortran/103413
	* symbol.cc (gfc_type_compatible): A boz-literal-constant has no type
	and thus is not considered compatible to any type.

gcc/testsuite/ChangeLog:

	PR fortran/103413
	* gfortran.dg/illegal_boz_arg_4.f90: New test.