libcody as originally added to GCC fail to build on *-unknown-freebsd11.4
and presumably others:

  c++ -std=c++11 -g -include config.h -I ... -MMD -MP -MF netclient.d -c
    -o netclient.o
  .../libcody/netclient.cc:114:3: error: unknown type sockaddr_in6 addr;
                                                      ^~~~~~~~~~~~

sockaddr_in6 is declared in /usr/include/netinet6/in6.h,
which is included by /usr/include/netinet/in.h.

Indeed, per https://man7.org/linux/man-pages/man7/ipv6.7.html

    #include <sys/socket.h>
    #include <netinet/in.h>

should be included, and our own gcc/ada/gsocket.h also has

    #if !(defined (VMS) || defined (__MINGW32__))
    #include <sys/socket.h>
    #include <sys/un.h>
    #include <netinet/in.h>
    :
    #endif

libcody/ChangeLog:

2020-12-21  Gerald Pfeifer  <gerald@pfeifer.com>

	* netserver.cc: Include <netinet/in.h>.

Add RANLIB.

	libcody/
	* Makefile.in (RANLIB): New var.
	* Makesub.in (libcody.a): Apply RANLIB.
	* configure.ac: Call AC_PROG_RANLIB.
	* configure: Rebuilt.

to_string is not always available, so don't use it.

	libcody/
	* buffer.cc (MessageBuffer::AppendInteger): Workaround
	to_string's non-ubiquity.

We explicitly need to inlude netinet.h, (despite what happened on my test systems)

	libcody/
	* netclient.cc: Add netinet.h.

I had a thinko about variable case, and, coupled with Make's behaviour
of just consing up variables out of nothing, and linux not having an
executable extension, didn't notice.

	PR other/98409
	c++tools/
	* Makefile.in: Fix exeext variable case.

contrib/ChangeLog:

	* gcc-changelog/git_commit.py: Add new error for quoted
	filenames.
	* gcc-changelog/test_email.py: Test it.
	* gcc-changelog/test_patches.txt: Test it.

contrib/ChangeLog:

	* gcc-changelog/test_email.py: New test.
	* gcc-changelog/test_patches.txt: Likewise.

For flexible array members we need to incrementally clear just from
ptr + total_bytes up to new ptr + total_bytes, but memset has been called
with the length from ptr, so was missing - total_bytes.  Additionally,
in this code off is guaranteed to be -1 and thus o 0, so don't bother pretending
we could handle anything else, it would be more complicated than that.

2020-12-21  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/98407
	* fold-const.c (native_encode_initializer): When handling flexible
	array members, fix up computation of length for memset.  Also remove
	" - o" as o is always guaranteed to be 0 in this code path.

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

For simd, we have code to artificially add locally defined variables into
private clauses if they are addressable, so that omplower turns them into
"omp simd array" variables.  As the testcase shows, this is undesirable if
those temporaries only show in the lb, b or incr expressions and nowhere else,
if it is just used there, we really want normal scalar temporaries.

This patch implements that by making sure we don't set for those GOVD_LOCAL-ish
temporaries turned into GOVD_PRIVATE the GOVD_SEEN flag during gimplification
of the lb, b and incr expressions, which means that the private clause isn't
added for those.

2020-12-21  Jakub Jelinek  <jakub@redhat.com>

	PR c++/98383
	* gimplify.c (struct gimplify_omp_ctx): Add in_for_exprs flag.
	(gimple_add_tmp_var): For addressable temporaries appearing in
	simd lb, b or incr expressions, don't add a private clause unless
	it is seen also outside of those expressions in the simd body.
	(omp_notice_variable): Likewise.
	(gimplify_omp_for): Set and reset in_for_exprs around gimplification
	of lb, b or incr expressions.

	* g++.dg/gomp/pr98383.C: New test.

The -fdump-go-spec flag to GCC recently changed to be more fastidious
about handling incomplete types. This caused some breakage in
mk[r]sysinfo.sh on Solaris. This commit adjusts for the new behavior.
Specifically:

  * Types that refer to _in6_addr may be hidden behind a typedef and can
    no longer be filtered out with `grep -v in6_addr`. Instead just
    rewrite the definition of _in6_addr to [16]byte wherever it appears.

  * timestruc_t is now (correctly) emitted as an alias for timespec, so this
    case is handled specially.

  * stdio.h is included in sysinfo.c to avoid emitting an incomplete
    definition of the FILE type.

  * Dummy definitions for _u?pad128_t are now emitted automatically,
    which conflict with the definitions installed by mk[r]sysinfo.sh.
    These definitions were actually dead code, so just remove them.

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

2020-12-20  Max Filippov  <jcmvbkbc@gmail.com>
gcc/
	* config/xtensa/xtensa.md (bswapsi2, bswapdi2): New patterns.

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

libgcc/
	* config/xtensa/lib1funcs.S (__bswapsi2, __bswapdi2): New
	functions.
	* config/xtensa/t-xtensa (LIB1ASMFUNCS): Add _bswapsi2 and
	_bswapdi2.

libstdc++-v3/ChangeLog:

	* include/std/semaphore: Fix indentation.

Fix a typo in an option name in documentation.

2020-12-20  Jakub Jelinek  <jakub@redhat.com>

	PR other/98400
	* doc/invoke.texi (-mbackchain): Fix a typo - -mmo-backchain ->
	-mno-backchain.

It seems we sometimes use DECL_ARTIFICIAL as choosing between
different code paths.  In order not to make -fdebug-aux-vars
do different things, set DECL_ARTIFICIAL on the variables to
avoid these different code paths (and the corresponding
regressions).

gcc/fortran/ChangeLog:

	* trans.c (create_var_debug_raw): Set DECL_ARTIFICIAL
	on variables.

gcc/testsuite/ChangeLog:

	* gfortran.dg/coarray/send_char_array_1.f90: Correct coarray
	indces.

constant_byte_string now uses a convert_to_bytes function, which doesn't
handle bitfields at all (don't punt on them, just puts them into wrong bits
or bytes).  Furthermore, I don't see a reason why that function should exist
at all, it duplicates native_encode_initializer functionality.
Except that native_encode_initializer punted on flexible array members and 2
tests in the testsuite relied on constant_byte_string handling those.
So, this patch throws away convert_to_bytes, uses native_encode_initializer
instead, but teaches it to handle flexible array members (only in the
non-mask mode with off == -1 for now), furthermore, it adds various corner
case checks that the old implementation was missing (like that STRING_CSTs
use int as length and therefore we shouldn't try to build larger than that
strings, or that native_encode*/native_interpret* APIs require sane
host and target bytes (8-bit on both).

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

	PR middle-end/98366
	* fold-const.c (native_encode_initializer): Don't try to
	memset more than total_bytes with off == -1 even if len is large.
	Handle flexible array member initializers if off == -1 and mask is
	NULL.
	* expr.c (convert_to_bytes): Remove.
	(constant_byte_string): Use native_encode_initializer instead of
	convert_to_bytes.  Remove extraneous semicolon.  Punt on various
	corner-cases the APIs don't handle, like sizes > INT_MAX,
	BITS_PER_UNIT != 8, CHAR_BIT != 8.

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

Manifest constants in D are represented as CONST_DECLs, which can be
imported from one module to another.  However, when compiling on strict
dwarf2 targets such as *-*-darwin10, importing CONST_DECLs cannot be
represented in debug as D did not exist as an AT_language until dwarf3,
and the only available fallback being DW_LANG_C.  As CONST_DECLs are
treated as enumerators in C, and not outputted individually in
gen_decl_die, this causes an internal error in force_decl_die to occur.

To handle this, similar to other places in dwarf2out, if a CONST_DECL is
seen in dwarf2out_imported_module_or_decl_1, then we simply return early
if the language is not one of Ada, D, or Fortran.

gcc/ChangeLog:

	PR d/98067
	* dwarf2out.c (dwarf2out_imported_module_or_decl_1): Handle
	  CONST_DECL only if is_fortran, is_ada, or is_dlang.

gcc/testsuite/ChangeLog:

	PR d/98067
	* gdc.dg/debug/debug.exp: New test.
	* gdc.dg/debug/dwarf2/dwarf2.exp: New test.
	* gdc.dg/debug/dwarf2/imports/pr98067.d: New test.
	* gdc.dg/debug/dwarf2/langdw2.d: New test.
	* gdc.dg/debug/dwarf2/langdw3.d: New test.
	* gdc.dg/debug/dwarf2/pr98067.d: New test.
	* gdc.dg/debug/trivial.d: New test.

The code I've added recently in find_bswap_or_nop for VECTOR CONSTRUCTORs
is missing punt on an important case - namely empty CONSTRUCTORs, because in that
case the loop will not initialize *n and the code after the loop will then
use the uninitialized structure.

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

	PR tree-optimization/98378
	* gimple-ssa-store-merging.c (find_bswap_or_nop): Punt if CONSTRUCTOR
	has no elements.

Adjust mksysinfo and mkrsysinfo to strip out floating-point max numbers,
as they can trigger this error.

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

Adjust testcase to not actually check for an undefined warning since we
don't really care about it, or what line it is issued on.

	gcc/testsuite/
	* gcc.dg/pr97750.c: Remove check for warning.

The attached testcase is miscompiled, because we optimize shared clauses
to firstprivate when task body can't modify the variable even when the
task has depend clause.  That is wrong, because firstprivate means the
variable will be copied immediately when the task is created, while with
depend clause some other task might change it later before the dependencies
are satisfied and the task should observe the value only after the change.

2020-12-18  Jakub Jelinek  <jakub@redhat.com>

	* gimplify.c (struct gimplify_omp_ctx): Add has_depend member.
	(gimplify_scan_omp_clauses): Set it to true if OMP_CLAUSE_DEPEND
	appears on OMP_TASK.
	(gimplify_adjust_omp_clauses_1, gimplify_adjust_omp_clauses): Force
	GOVD_WRITTEN on shared variables if task construct has depend clause.

	* testsuite/libgomp.c/task-6.c: New test.

2020-12-18  Kwok Cheung Yeung  <kcy@codesourcery.com>

	gcc/testsuite/
	* g++.dg/gomp/declare-target-3.C: Only check .offload_var_table
	entries if offloading is enabled.

Either we should write test x$darwin_dynamic_lookup = xyes
or we should make sure the variable is always defined to non-empty string.

2020-12-18  Jakub Jelinek  <jakub@redhat.com>

	PR bootstrap/98380
	* configure.ac: Set darwin_dynamic_lookup=no instead to empty
	string.
	* configure: Regenerated.

Problem comes from using the wrong interface to get the index type for a
COND_REDUCTION. For fixed-length SVE we get a V2SI (a 64-bit Advanced
SIMD vector) instead of a VNx2SI (an SVE vector that stores SI elements
in DI containers).

Credits to Richard Sandiford for pointing out the issue's root cause.

Original PR snippet proposed to reproduce issue was only causing ICE for C++
compiler (see pr98177-1 test cases). I've slightly modified original
snippet in order to reproduce issue on both C and C++ compilers. These
are pr98177-2 test cases.

gcc/ChangeLog:

	PR target/98177
	* tree-vect-loop.c (vect_create_epilog_for_reduction): Use
	get_same_sized_vectype to obtain index type.
	(vectorizable_reduction): Likewise.

gcc/testsuite/ChangeLog:

	PR target/98177
	* g++.target/aarch64/sve/pr98177-1.C: New test.
	* g++.target/aarch64/sve/pr98177-2.C: New test.
	* gcc.target/aarch64/sve/pr98177-1.c: New test.
	* gcc.target/aarch64/sve/pr98177-2.c: New test.

The #ifdef RADIXCHAR directive should be moved one line up so that it
also guards the outer if statement, or else when RADIXCHAR is not
defined the outer if statement will end up nonsensically guarding the
declaration of output_length_upper_bound a few lines below it.

libstdc++-v3/ChangeLog:

	PR libstdc++/98377
	* src/c++17/floating_to_chars.cc (__floating_to_chars_precision):
	Fix mistake.

This should fix a build failure on AArch64 ILP32 due to int32_t mapping
to long int instead of int on this platform, which causes type deduction
to fail in the below call to std::max as reported in the PR.

libstdc++-v3/ChangeLog:

	PR libstdc++/98370
	* src/c++17/floating_to_chars.cc (__floating_to_chars_shortest):
	Provide explicit template arguments to the call to std::max.

This should fix a build failure on Windows which lacks <langinfo.h>,
from which we use nl_langinfo() to obtain the radix character of the
current locale.  (We can't use the more portable localeconv() from
<clocale> to obtain the radix character of the current locale here
because it's not thread-safe, unfortunately.)

This change means that on Windows and other such platforms, we'll just
always assume the radix character used by printf is '.' when formatting
a long double through it.

libstdc++-v3/ChangeLog:

	PR libstdc++/98374
	* src/c++17/floating_to_chars.cc: Guard include of <langinfo.h>
	with __has_include.
	(__floating_to_chars_precision) [!defined(RADIXCHAR)]: Don't
	attempt to obtain the radix character of the current locale,
	just assume it's '.'.

We need to test that FE_TONEAREST is defined before we may use it along
with fegetround/fesetround to adjust the floating-point rounding mode.
This fixes a build failure with older versions of newlib.

libstdc++-v3/ChangeLog:

	* src/c++17/floating_from_chars.cc (from_chars_impl)
	[!defined(FE_TONEAREST)]: Don't adjust the rounding mode.
	* src/c++17/floating_to_chars.cc (__floating_to_chars_precision):
	Likewise.

2020-12-18  Kwok Cheung Yeung  <kcy@codesourcery.com>

	gcc/
	* langhooks-def.h (lhd_get_decl_init): New.
	(lhd_finish_decl_inits): New.
	(LANG_HOOKS_GET_DECL_INIT): New.
	(LANG_HOOKS_OMP_FINISH_DECL_INITS): New.
	(LANG_HOOKS_DECLS): Add LANG_HOOKS_GET_DECL_INIT and
	LANG_HOOKS_OMP_FINISH_DECL_INITS.
	* langhooks.c (lhd_omp_get_decl_init): New.
	(lhd_omp_finish_decl_inits): New.
	* langhooks.h (struct lang_hooks_for_decls): Add omp_get_decl_init
	and omp_finish_decl_inits.
	* omp-offload.c (omp_discover_declare_target_var_r): Use
	get_decl_init langhook in place of DECL_INITIAL.  Call
	omp_finish_decl_inits langhook at end of function.

	gcc/cp/
	* cp-lang.c (cxx_get_decl_init): New.
	(cxx_omp_finish_decl_inits): New.
	(LANG_HOOKS_GET_DECL_INIT): New.
	(LANG_HOOKS_OMP_FINISH_DECL_INITS): New.
	* cp-tree.h (dynamic_initializers): New.
	* decl.c (dynamic_initializers): New.
	* decl2.c (c_parse_final_cleanups): Add initializer entries
	from vars to dynamic_initializers.

	gcc/testsuite/
	* g++.dg/gomp/declare-target-3.C: New.

When compiling with -msve-vector-bits=128, aarch64_preferred_simd_mode
would pass the same vector width to aarch64_simd_container_mode for
both SVE and Advanced SIMD, and so Advanced SIMD would always “win”.
This patch instead makes it choose directly between SVE and Advanced
SIMD modes, so that aarch64-autovec-preference==2 and
aarch64-autovec-preference==4 work for this configuration.

(aarch64-autovec-preference shouldn't affect aarch64_simd_container_mode
because that would have an ABI impact for things like GNU vectors.)

gcc/
	* config/aarch64/aarch64.c (aarch64_preferred_simd_mode): Use
	aarch64_full_sve_mode and aarch64_vq_mode directly, instead of
	going via aarch64_simd_container_mode.

Seems when I split the patch I forgot to include these into the rot iterator..
The uncommitted hunks were still in my local tree so didn't notice.

gcc/ChangeLog:

	* config/arm/iterators.md (rot): Add UNSPEC_VCMUL, UNSPEC_VCMUL90,
	UNSPEC_VCMUL180, UNSPEC_VCMUL270.

Windows has unique and special needs for open(2).

	gcc/cp/
	* module.cc (O_CLOEXEC, O_BINARY): Add window's support.
	(elf_in::defrost, module_state::do_import)
	(finish_module_processing): Use O_BINARY.

2020-12-18  Paul Thomas  <pault@gcc.gnu.org>

gcc/fortran
	PR fortran/83118
	PR fortran/96012
	* resolve.c (resolve_ordinary_assign): Generate a vtable if
	necessary for scalar non-polymorphic rhs's to unlimited lhs's.
	* trans-array.c (get_class_info_from_ss): New function.
	(gfc_trans_allocate_array_storage): Defer obtaining class
	element type until all sources of class exprs are tried. Use
	class API rather than TREE_OPERAND. Look for class expressions
	in ss->info by calling get_class_info_from_ss. After, obtain
	the element size for class descriptors. Where the element type
	is unknown, cast the data as character(len=size) to overcome
	unlimited polymorphic problems.
	(gfc_conv_ss_descriptor): Do not fix class variable refs.
	(build_class_array_ref, structure_alloc_comps): Replace code
	replicating the new function gfc_resize_class_size_with_len.
	(gfc_alloc_allocatable_for_assignment): Obtain element size
	for lhs in cases of deferred characters and class enitities.
	Move code for the element size of rhs to start of block. Clean
	up extraction of class parameters throughout this function.
	After the shape check test whether or not the lhs and rhs
	element sizes are the same. Use earlier evaluation of
	'cond_null'. Reallocation of lhs only to happen if size changes
	or element size changes.
	* trans-expr.c (gfc_resize_class_size_with_len): New function.
	(gfc_get_class_from_expr): If a constant expression is
	encountered, return NULL_TREE;
	(trans_scalar_class_assign): New function.
	(gfc_conv_procedure_call): Ensure the vtable is present for
	passing a non-class actual to an unlimited formal.
	(trans_class_vptr_len_assignment): For expressions of type
	BT_CLASS, extract the class expression if necessary. Use a
	statement block outside the loop body. Ensure that 'rhs' is
	of the correct type. Obtain rhs vptr in all circumstances.
	(gfc_trans_scalar_assign): Call trans_scalar_class_assign to
	make maximum use of the vptr copy in place of assignment.
	(trans_class_assignment): Actually do reallocation if needed.
	(gfc_trans_assignment_1): Simplify some of the logic with
	'realloc_flag'. Set 'vptr_copy' for all array assignments to
	unlimited polymorphic lhs.
	* trans.c (gfc_build_array_ref): Call gfc_resize_class_size_
	with_len to correct span for unlimited polymorphic decls.
	* trans.h : Add prototype for gfc_resize_class_size_with_len.

gcc/testsuite/
	PR fortran/83118
	PR fortran/96012
	* gfortran.dg/dependency_60.f90: New test.
	* gfortran.dg/class_allocate_25.f90: New test.
	* gfortran.dg/class_assign_4.f90: New test.
	* gfortran.dg/unlimited_polymorphic_32.f03: New test.

Seems the ggc_remove ppc_nx 3 operand member relies on the hash tables to
contain pointers in the first element, which is not the case for
source_location_table* hash table, which has location_t and unsigned as
first two members and pointer somewhere else.
I've tried to change:
   static void
   pch_nx (T &p, gt_pointer_operator op, void *cookie)
   {
-    op (&p, cookie);
+    extern void gt_pch_nx (T *, gt_pointer_operator, void *);
+    gt_pch_nx (&p, op, cookie);
   }
in hash-traits.h, but that failed miserably.
So, this patch instead overrides the two pch_nx overloads (only the second
one is needed, the former one is identical to the ggc_remove one) but I need
to override both.

2020-12-18  Jakub Jelinek  <jakub@redhat.com>

	PR c++/98343
	* cp-gimplify.c (source_location_table_entry_hash::pch_nx): Override
	static member functions from ggc_remove.

	* g++.dg/pch/pr98343.C: New test.
	* g++.dg/pch/pr98343.Hs: New file.

Update the Go testsuite driver to handle +build lines as is done in
the upstream repo, and update some tests to the upstream repo copy
using +build lines with "gc" and "!gccgo" as appropriate.

	* go.test/go-test.exp (go-set-goos): New procedure.
	(go-gc-match): New procedure.
	(go-gc-tests): Call go-set-goos.  Use go-gc-match to handle +build
	lines.  Look for +build lines beyond first line of file.

The testcases are imported almost verbatim, with the only change being
to the -double_nan and -float_nan testcases.  We expect these values to
be formatted as "-nan" instead of "-nan(ind)".

libstdc++-v3/ChangeLog:

	* testsuite/20_util/to_chars/double.cc: New test, consisting of
	testcases imported from the MSVC STL testsuite.
	* testsuite/20_util/to_chars/float.cc: Likewise.

This implements the floating-point std::to_chars overloads for float,
double and long double.  We use the Ryu library to compute the shortest
round-trippable fixed and scientific forms for float, double and long
double.  We also use Ryu for performing explicit-precision fixed and
scientific formatting for float and double. For explicit-precision
formatting for long double we fall back to using printf.  Hexadecimal
formatting for float, double and long double is implemented from
scratch.

The supported long double binary formats are binary64, binary80 (x86
80-bit extended precision), binary128 and ibm128.

Much of the complexity of the implementation is in computing the exact
output length before handing it off to Ryu (which doesn't do bounds
checking).  In some cases it's hard to compute the output length
beforehand, so in these cases we instead compute an upper bound on the
output length and use a sufficiently-sized intermediate buffer only if
necessary.

Another source of complexity is in the general-with-precision formatting
mode, where we need to do zero-trimming of the string returned by Ryu,
and where we also take care to avoid having to format the number through
Ryu a second time when the general formatting mode resolves to fixed
(which we determine by doing a scientific formatting first and
inspecting the scientific exponent).  We avoid going through Ryu twice
by instead transforming the scientific form to the corresponding fixed
form via in-place string manipulation.

This implementation is non-conforming in a couple of ways:

1. For the shortest hexadecimal formatting, we currently follow the
   Microsoft implementation's decision to be consistent with the
   output of printf's '%a' specifier at the expense of sometimes not
   printing the shortest representation.  For example, the shortest hex
   form for the number 1.08p+0 is 2.1p-1, but we output the former
   instead of the latter, as does printf.

2. The Ryu routine generic_binary_to_decimal that we use for performing
   shortest formatting for large floating point types is implemented
   using the __int128 type, but some targets with a large long double
   type lack __int128 (e.g. i686), so we can't perform shortest
   formatting of long double on such targets through Ryu.  As a
   temporary stopgap this patch makes the long double to_chars overloads
   just dispatch to the double overloads on these targets, which means
   we lose precision in the output.  (We could potentially fix this by
   writing a specialized version of Ryu's generic_binary_to_decimal
   routine that uses uint64_t instead of __int128.)  [Though I wonder if
   there's a better way to work around the lack of __int128 on i686
   specifically?]

3. Our shortest formatting for __ibm128 doesn't guarantee the round-trip
   property if the difference between the high- and low-order exponent
   is large.  This is because we treat __ibm128 as if it has a
   contiguous 105-bit mantissa by merging the mantissas of the high-
   and low-order parts (using code extracted from glibc), so we
   potentially lose precision from the low-order part.  This seems to be
   consistent with how glibc printf formats __ibm128.

libstdc++-v3/ChangeLog:

	* config/abi/pre/gnu.ver: Add new exports.
	* include/std/charconv (to_chars): Declare the floating-point
	overloads for float, double and long double.
	* src/c++17/Makefile.am (sources): Add floating_to_chars.cc.
	* src/c++17/Makefile.in: Regenerate.
	* src/c++17/floating_to_chars.cc: New file.
	(to_chars): Define for float, double and long double.
	* testsuite/20_util/to_chars/long_double.cc: New test.