Jan Hubicka [Fri, 30 Oct 2020 13:30:43 +0000 (14:30 +0100)]
Fix thunk info WRT PCH
PR pch/97593
* cgraph.c (cgraph_node::create_thunk): Register thunk as early during
parsing.
* cgraphunit.c (analyze_functions): Call
thunk_info::process_early_thunks.
* symtab-thunks.cc (struct unprocessed_thunk): New struct.
(thunks): New static variable.
(thunk_info::register_early): New member function.
(thunk_info::process_early_thunks): New member function.
* symtab-thunks.h (thunk_info::register_early): Declare.
(thunk_info::process_early_thunks): Declare.
Richard Biener [Fri, 30 Oct 2020 12:32:32 +0000 (13:32 +0100)]
tree-optimization/97623 - avoid excessive insert iteration for hoisting
This avoids requiring insert iteration for back-to-back hoisting
opportunities as seen in the added testcase. For the PR at hand
this halves the number of insert iterations retaining only
the hard to avoid PRE / hoist insert back-to-backs.
2020-10-30 Richard Biener <rguenther@suse.de>
PR tree-optimization/97623
* tree-ssa-pre.c (insert): First do hoist insertion in
a backward walk.
Richard Biener [Fri, 30 Oct 2020 10:26:18 +0000 (11:26 +0100)]
tree-optimization/97626 - handle SCCs properly in SLP stmt analysis
This makes sure to roll-back the whole SCC when we fail stmt
analysis, otherwise the optimistic visited treatment breaks down
with different entries. Rollback is easy when tracking additions
to visited in a vector which also makes the whole thing cheaper
than the two hash-sets used before.
2020-10-30 Richard Biener <rguenther@suse.de>
PR tree-optimization/97626
* tree-vect-slp.c (vect_slp_analyze_node_operations):
Exchange the lvisited hash-set for a vector, roll back
recursive adds to visited when analysis failed.
(vect_slp_analyze_operations): Likewise.
Martin Liska [Fri, 30 Oct 2020 10:23:11 +0000 (11:23 +0100)]
gcc-changelog: Handle situations like '* tree-vect-slp.c (): '
contrib/ChangeLog:
* gcc-changelog/git_commit.py: Handle empty groups in
file description.
* gcc-changelog/test_email.py: New test.
* gcc-changelog/test_patches.txt: Likewise.
Alex Coplan [Fri, 30 Oct 2020 09:21:31 +0000 (09:21 +0000)]
aarch64: Fix PR96998 and restore code quality in combine
This change fixes a bug in the AArch64 backend. Currently, we accept an
odd sign_extract representation of addresses, but don't accept that same
odd form of address as an LEA.
This is the cause of PR96998. In the testcase given in the PR, combine
produces:
The aarch64 changes here remove the support for this sign_extract
representation of addresses, fixing PR96998. Now this by itself would
regress code quality, so this change is paired with an improvement to
combine which prevents an extract rtx from being emitted in this case:
we now write the rtx above as a shift of an extend, which allows the
combination to go ahead.
Prior to this, combine.c:make_extraction() identified where we can emit
an ashift of an extend in place of an extraction, but failed to make the
corresponding canonicalization/simplification when presented with a mult
by a power of two. Such a representation is canonical when representing
a left-shifted address inside a mem.
This change remedies this situation. For rtxes such as:
where the bottom 32 + n bits are valid (the higher-order bits are
undefined) and make_extraction() is being asked to sign_extract the
lower (valid) bits, after the patch, we rewrite this as:
Olivier Hainque [Wed, 28 Oct 2020 18:04:32 +0000 (18:04 +0000)]
Predefine __ppc and __ppc__ for VxWorks 7
Unfortunately, some VxWorks 7r2 system headers rely on a
couple more variations of the predefined macros expected
to characterize a "powerpc" target that we discussed recently.
setjmp.h, for example, relies on __ppc and the absence of
a definition results in "gcc" dejagnu test failures from all
the tests #including that header, which stumble on:
#error "_JBLEN not set!"
The other case is __ppc__ expected by yvals.h, key to libstdc++.
This change adjusts the VxWorks 7 section of our configuration
to honor those expectations.
2020-10-29 Olivier Hainque <hainque@adacore.com>
gcc/
* config/rs6000/vxworks.h (TARGET_OS_CPP_BUILTINS): Also
builtin_define __ppc and __ppc__ for VxWorks 7.
Olivier Hainque [Wed, 26 Feb 2020 13:47:43 +0000 (13:47 +0000)]
Introduce support for vxworks7r2 on x86 and x86_64
This change extends the VxWorks support on intel CPUs to
VxWorks7r2 for x86_64 as well as x86, with a "mcmodel=large"
additional multilib for the 64bit configuration.
The support for fPIC is not functional yet for this model,
so we just don't add the corresponding multilib.
We extend the range of CPU families handled by TARGET_OS_CPP_BUILTINS,
accounting for the fact that archs older than PENTIUM4 are
not supported (any more) by VxWorks 7.
As we did for powerpc, we leverage VX_CPU_PREFIX to emit different
forms of definitions for different families of VxWorks as the system
headers's expectations has evolved between Vx 5, 6 and 7.
2020-10-27 Olivier Hainque <hainque@adacore.com>
gcc/
* config.gcc: Adjust the ix86/x86_64-wrs-vxworks filters
to apply to VxWorks 7 as well.
* config/i386/t-vxworks (MULTILIB_OPTIONS, MULTILIB_DIRNAMES):
Remove the fPIC multilib and add one for the large code model
on x86_64.
* config/i386/vxworks.h: Separate sections for TARGET_VXWORKS7,
other variants and common bits.
(TARGET_OS_CPP_BUILTINS): Augment to support a range of CPU
families. Leverage VX_CPU_PREFIX.
(CC1_SPEC): Add definition.
(STACK_CHECK_PROTECT): Use conditional expression instead of
heavier to read conditioned macro definitions.
libgcc/
* config.host: Adjust the ix86/x86_64-wrs-vxworks filters
to apply to VxWorks 7 as well.
Co-authored-by: Douglas Rupp <rupp@adacore.com> Co-authored-by: Pat Bernardi <bernardi@adacore.com>
Jakub Jelinek [Fri, 30 Oct 2020 08:18:36 +0000 (09:18 +0100)]
openmp: Fix handling of allocate clause on taskloop
This patch fixes gimplification of allocate clause on taskloop - puts
allocate on inner taskloop only if there is allocate clause, because otherwise
the data sharing clauses are only on the task construct in the construct sandwich.
2020-10-30 Jakub Jelinek <jakub@redhat.com>
* gimplify.c (gimplify_scan_omp_clauses): Force
OMP_CLAUSE_ALLOCATE_ALLOCATOR into a temporary if it is non-NULL and
non-constant.
(gimplify_omp_for): Only put allocate on inner taskloop if lastprivate
for the same variable is going to be put there, and in that case
if the OMP_CLAUSE_ALLOCATE_ALLOCATOR is non-NULL non-constant, make
the allocator firstprivate on task.
Jakub Jelinek [Fri, 30 Oct 2020 08:16:45 +0000 (09:16 +0100)]
openmp: Handle non-static data members in allocate clause and other C++ allocate fixes
This allows specification of non-static data members in allocate clause like it
can be specified in other privatization clauses and adds a new testcase that covers
also handling of that clause in templates.
2020-10-30 Jakub Jelinek <jakub@redhat.com>
* semantics.c (finish_omp_clauses) <case OMP_CLAUSE_ALLOCATE>: Handle
non-static members in methods.
* pt.c (tsubst_omp_clauses): Handle OMP_CLAUSE_ALLOCATE.
* c-c++-common/gomp/allocate-1.c (qux): Add another test.
* g++.dg/gomp/allocate-1.C: New test.
Michael Meissner [Fri, 30 Oct 2020 02:15:10 +0000 (22:15 -0400)]
PowerPC: Adjust float128/ibm128 warnings.
This patch ccombines two patches:
1) If GLIBC is 2.32 or newer, and the language is C or C++, allow the user to
change the long double type without having to use -Wno-psabi.
2) Adjust the warnings for intermixing __float128 and __ibm128 to accomidate
the future change to allow long double to use the IEEE 128-bit format.
gcc/
2020-10-29 Michael Meissner <meissner@linux.ibm.com>
* config/rs6000/rs6000.c (rs6000_option_override_internal): Allow
long double type to be changed for C/C++ if glibc 2.32 or newer.
(rs6000_invalid_binary_op): Update error messages about mixing IBM
long double and IEEE 128-bit.
gcc/testsuite/
2020-10-27 Michael Meissner <meissner@linux.ibm.com>
* gcc.target/powerpc/float128-mix-2.c: New test.
* gcc.target/powerpc/float128-mix-3.c: New test.
* gcc.target/powerpc/float128-mix.c: Update failure messages.
David Edelsohn [Thu, 29 Oct 2020 20:46:53 +0000 (16:46 -0400)]
libstdc++: AIX xfail for_overwrite.cc testcase
The 20_util/unique_ptr/creation/for_overwrite.cc testcase relies on
operator new, which requires special features on AIX. This patch
disables the testcase.
libstdc++-v3/ChangeLog:
* testsuite/20_util/unique_ptr/creation/for_overwrite.cc: XFAIL on AIX.
Jonathan Wakely [Thu, 29 Oct 2020 22:47:22 +0000 (22:47 +0000)]
libstdc++: Avoid narrowing conversion in subrange constructor
libstdc++-v3/ChangeLog:
* include/bits/ranges_util.h (subrange::subrange(R&&)): Use
direct-initialization instead of list-initialization, so a
potential narrowing conversion from ranges::size(r) to the
stored size isn't ill-formed.
Jonathan Wakely [Thu, 29 Oct 2020 22:47:22 +0000 (22:47 +0000)]
libstdc++: Fix some warnings in headers
These are usually suppressed in system headers, but should be fixed
anyway.
libstdc++-v3/ChangeLog:
* include/bits/parse_numbers.h (_Select_int_base): Avoid
narrowing conversion in constant expression.
* include/experimental/buffer (buffer_copy): Avoid narrowing
conversion.
* include/experimental/internet (hash<>::operator()): Do not
use deprecated 'argument_type' member.
* include/std/variant (variant::emplace): Use cast instead
of implicit conversion from size_t to narrower unsigned type.
Jonathan Wakely [Thu, 29 Oct 2020 22:47:21 +0000 (22:47 +0000)]
libstdc++: Avoid warnings in tests
This fixes some warnings emitted when testing with warning flags added.
Some of these are only necessary when testing with -Wsystem-headers, but
either way it cleans up the tests to be less noisy under non-default
flags.
Marek Polacek [Mon, 26 Oct 2020 21:35:56 +0000 (17:35 -0400)]
c++: Implement CWG 625: Use of auto as template-arg [PR97479]
This patch implements CWG 625 which prohibits using auto in a template
argument. A few tests used this construction. Since this usage was
allowed by the Concepts TS, we only give an error in C++20.
gcc/cp/ChangeLog:
DR 625
PR c++/97479
* parser.c (cp_parser_type_id_1): Reject using auto as
a template-argument in C++20.
Marek Polacek [Fri, 16 Oct 2020 15:00:12 +0000 (11:00 -0400)]
c++: Deducing type from initializer_list<auto> [PR93107]
In this testcase we weren't able to deduce b's type:
template<typename T> void Task() { }
auto b = { &Task<int> };
because resolve_nondeduced_context doesn't iterate on the {}'s elements.
So make sure to look into {} too. We don't need to handle nested {}
here.
We could either tweak resolve_nondeduced_context to handle CONSTRUCTORs
or add a _ctor version, but then resolve_nondeduced_context_or_error
would need some changes too -- it'd have to check the result of a call
to r_n_c for each element.
gcc/cp/ChangeLog:
PR c++/93107
* pt.c (do_auto_deduction): Call resolve_nondeduced_context for
the elements of a { } list.
gcc/testsuite/ChangeLog:
PR c++/93107
* g++.dg/cpp0x/initlist-deduce3.C: New test.
Patrick Palka [Thu, 29 Oct 2020 18:03:03 +0000 (14:03 -0400)]
c++: Simplify constraint normalization routines
Many of the high-level constraint normalization routines allow the
caller to supply the initial template arguments for normalization, but
in practice all of the callers supply something equivalent to the
identity mapping(*).
This patch hard-codes this prevalent choice of initial template
arguments by making get_normalized_constraints always pass NULL_TREE as
the args to normalize_expression. This admits some simplifications in
the high-level routines, such as removing their 'args' parameter and
consolidating the two versions of normalize_constraint_expression.
(*): In particular, a set of generic template arguments or NULL_TREE.
In the case of the two-parm version of normalize_constraint_expression,
we were suspiciously using the template arguments of a concept-id when
normalizing the concept-id as a constraint-expression.
gcc/cp/ChangeLog:
* constraint.cc (get_normalized_constraints): Remove 'args'
parameter. Pass NULL_TREE as the initial template arguments to
normalize_expression.
(get_normalized_constraints_from_info): Remove 'args' parameter
and adjust the call to get_normalized_constraints.
(get_normalized_constraints_from_decl): Remove 'args' local
variable and adjust call to get_normalized_constraints_from_info.
(normalize_concept_definition): Remove 'args' local variable
and adjust call to get_normalized_constraints.
(normalize_constraint_expression): Remove the two-parameter
overload. Remove 'args' parameter from the three-parameter
overload and update function comment accordingly. Remove
default argument from 'diag' parameter. Adjust call to
get_normalized_constraints.
(finish_nested_requirement): Adjust call to
normalize_constraint_expression.
(strictly_subsumes): Remove 'args' parameter. Adjust call to
get_normalized_constraints_from_info.
(weakly_subsumes): Likewise.
* cp-tree.h (strictly_subsumes): Remove 'args' parameter.
(weakly_subsumes): Likewise.
* pt.c (process_partial_specialization): Adjust call to
strictly_subsumes.
(is_compatible_template_arg): Adjust call to weakly_subsumes.
Patrick Palka [Thu, 29 Oct 2020 18:02:59 +0000 (14:02 -0400)]
c++: Tolerate empty initial args during normalization [PR97412]
When normalizing the constraint-expression of a nested-requirement, we
pass NULL_TREE as the initial template arguments for normalization, but
tsubst_argument_pack is not prepared to handle a NULL_TREE args vector.
This causes us to ICE when normalizing a variadic concept as part of a
nested-requirement.
This patch fixes the ICE by guarding the call to tsubst_template_args in
normalize_concept_check appropriately. This will also enable us to
simplify many of the normalization routines to just pass NULL_TREE
(instead of a set of generic template arguments) as the initial template
arguments.
gcc/cp/ChangeLog:
PR c++/97412
* constraint.cc (normalize_concept_check): Don't call
tsubst_template_args when 'args' is NULL.
gcc/testsuite/ChangeLog:
PR c++/97412
* g++.dg/cpp2a/concepts-variadic2.C: New test.
Jason Merrill [Wed, 28 Oct 2020 21:30:05 +0000 (17:30 -0400)]
c++: Fix constexpr cleanup error handling.
In this testcase, the primary evaluation successfully produces 'true', and
then running one of the cleanups hits a double delete, making the whole
thing not a valid constant expression. So we were returning 'true' wrapped
in a NOP_EXPR to indicate its non-constancy, but evaluating that again is a
perfectly acceptable constant expression, so we weren't getting the verbose
diagnostic we were looking for.
So if non_constant_p gets set other than for overflow, go back to the
original expression.
With this change, we should never hit the manifestly_const_eval test, and
the is-constant-evaluated1.C test passes without it.
gcc/cp/ChangeLog:
PR c++/97388
* constexpr.c (cxx_eval_outermost_constant_expr): Revert to
original expression if evaluation sets non_constant_p.
gcc/testsuite/ChangeLog:
PR c++/97388
* g++.dg/cpp2a/constexpr-dtor8.C: New test.
Jakub Jelinek [Tue, 20 Oct 2020 07:33:20 +0000 (09:33 +0200)]
c++: Fix constexpr dtors vs invisible ref [PR97388]
For arguments passed by invisible reference, in the IL until genericization
we have the source types on the callee side and while on the caller side
we already pass references to the actual argument slot in the caller, we
undo that in cxx_bind_parameters_in_call's
if (TREE_ADDRESSABLE (type))
/* Undo convert_for_arg_passing work here. */
x = convert_from_reference (x);
This works fine most of the time, except when the type also has constexpr
destructor; in that case the destructor is invoked in the caller and thus
the unsharing we do to make sure that the callee doesn't modify caller's
values is in that case undesirable, it prevents the changes done in the
callee propagating to the caller which should see them for the constexpr
dtor evaluation.
The following patch fixes that. While it could be perhaps done for all
TREE_ADDRESSABLE types, I don't see the need to change the behavior
if there is no constexpr non-trivial dtor.
Jason: And we need to avoid memoizing the call, because a later equivalent
call also needs to modify its argument. And we don't need to unshare
constructors when we aren't memoizing the call, because we already unshared
them when evaluating the TARGET_EXPR representing the copy-initialization of
the argument.
2020-10-20 Jakub Jelinek <jakub@redhat.com>
Jason Merrill <jason@redhat.com>
PR c++/97388
* constexpr.c (cxx_bind_parameters_in_call): Set non_constant_args
if the parameter type has a non-trivial destructor.
(cxx_eval_call_expression): Only unshare arguments if we're
memoizing this evaluation.
* g++.dg/cpp2a/constexpr-dtor5.C: New test.
* g++.dg/cpp2a/constexpr-dtor6.C: New test.
* g++.dg/cpp2a/constexpr-dtor7.C: New test.
Jan Hubicka [Thu, 29 Oct 2020 15:44:48 +0000 (16:44 +0100)]
Avoid typeless storage in wide-int
* wide-int.h (trailing_wide_ints <N>): Turn len to array of structures
so it does not imply typeless storage.
(trailing_wide_ints <N>::operator): update
(trailing_wide_ints <N>::operator []): Update.
Jakub Jelinek [Thu, 29 Oct 2020 15:27:01 +0000 (16:27 +0100)]
c++: Diagnose constexpr delete [] new int; and delete new int[N]; [PR95808]
This patch diagnoses delete [] new int; and delete new int[1]; in constexpr
contexts by remembering
IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (fun)) & OVL_OP_FLAG_VEC
from the operator new and checking it at operator delete time.
2020-10-29 Jakub Jelinek <jakub@redhat.com>
PR c++/95808
* cp-tree.h (enum cp_tree_index): Add CPTI_HEAP_VEC_UNINIT_IDENTIFIER
and CPTI_HEAP_VEC_IDENTIFIER.
(heap_vec_uninit_identifier, heap_vec_identifier): Define.
* decl.c (initialize_predefined_identifiers): Initialize those
identifiers.
* constexpr.c (cxx_eval_call_expression): Reject array allocations
deallocated with non-array deallocation or non-array allocations
deallocated with array deallocation.
(non_const_var_error): Handle heap_vec_uninit_identifier and
heap_vec_identifier too.
(cxx_eval_constant_expression): Handle also heap_vec_uninit_identifier
and in that case during initialization replace it with
heap_vec_identifier.
(find_heap_var_refs): Handle heap_vec_uninit_identifier and
heap_vec_identifier too.
Joseph Myers [Thu, 29 Oct 2020 15:05:33 +0000 (15:05 +0000)]
stdbool.h: Update true and false expansions for C2x
C2x has changed the expansions of the true and false macros in
<stdbool.h> so that they have type _Bool (including in #if conditions,
i.e. an unsigned type in that context). Use the new expansions in
GCC's <stdbool.h> for C2x.
See bug 82272 for related discussion (but this patch does *not*
implement the warning discussed there).
Note that it's possible there may be a further change to make bool,
true and false keywords (there was support in principle for that at
the April WG14 meeting). But currently these expansions of type _Bool
are what C2x requires and there isn't actually a paper before WG14 at
present that would introduce the new keywords.
Bootstrapped with no regressions on x86_64-pc-linux-gnu.
gcc/
2020-10-29 Joseph Myers <joseph@codesourcery.com>
* ginclude/stdbool.h [__STDC_VERSION__ > 201710L] (true, false):
Define with type _Bool.
gcc/testsuite/
2020-10-29 Joseph Myers <joseph@codesourcery.com>
* gcc.dg/c11-bool-1.c, gcc.dg/c2x-bool-1.c, gcc.dg/c99-bool-4.c:
New tests.
Jonathan Wakely [Thu, 29 Oct 2020 14:47:18 +0000 (14:47 +0000)]
libstdc++: Improve tests for constexpr algorithms
These tests just return true without checking that the results of the
algorithms. Although it should be safe to assume that the algorithms
behave the same at compile-time as at run-time, we can use these tests
to verify it.
This replaces each 'return true' statement with a condition that depends
on the basic functionality of the algorithm, such as returning an
iterator to the right position.
Jonathan Wakely [Thu, 29 Oct 2020 14:47:18 +0000 (14:47 +0000)]
libstdc++: Allow Lemire's algorithm to be used in more cases
This extends the fast path to also work when the URBG's range of
possible values is not the entire range of its result_type. Previously,
the slow path would be used for engines with a uint_fast32_t result type
if that type is actually a typedef for uint64_t rather than uint32_t.
After this change, the generator's result_type is not important, only
the range of possible value that generator can produce. If the
generator's range is exactly UINT64_MAX then the calculation will be
done using 128-bit and 64-bit integers, and if the range is UINT32_MAX
it will be done using 64-bit and 32-bit integers.
In practice, this benefits most of the engines and engine adaptors
defined in [rand.predef] on x86_64-linux and other 64-bit targets. This
is because std::minstd_rand0 and std::mt19937 and others use
uint_fast32_t, which is a typedef for uint64_t.
The code now makes use of the recently-clarified requirement that the
generator's min() and max() functions are usable in constant
expressions (see LWG 2154).
libstdc++-v3/ChangeLog:
* include/bits/uniform_int_dist.h (_Power_of_two): Add
constexpr.
(uniform_int_distribution::_S_nd): Add static_assert to ensure
the wider type is twice as wide as the result type.
(uniform_int_distribution::__generate_impl): Add static_assert
and declare variables as constexpr where appropriate.
(uniform_int_distribution:operator()): Likewise. Only consider
the uniform random bit generator's range of possible results
when deciding whether _S_nd can be used, not the __uctype type.
Jonathan Wakely [Thu, 29 Oct 2020 14:47:17 +0000 (14:47 +0000)]
libstdc++: Do not use volatile for __gnu_cxx::rope reference counting
The rope extension uses a volatile variable for its reference count.
This is not only unnecessary for correctness (volatile provides neither
atomicity nor memory visibility, and the variable is only modified while
a lock is held) but it now causes deprecated warnings with
-Wsystem-headers due to the use of ++ and -- operators.
It would be possible to use __gnu_cxx::__exchange_and_add in _M_incr and
_M_decr when __atomic_is_lock_free(sizeof(_RC_t), &_M_ref_count) is
true, rather than locking a mutex. That would probably be a significant
improvement for multi-threaded and single-threaded code (because
__exchange_and_add will use non-atomic ops when possible, and even in MT
code it should be faster than the mutex lock/unlock pair). However,
mixing objects compiled with the old and new code would result in
inconsistent synchronization being used for the reference count.
Jonathan Wakely [Thu, 29 Oct 2020 14:47:17 +0000 (14:47 +0000)]
libstdc++: Make std::function work better with -fno-rtti
This change allows std::function::target<F>() to work even without RTTI,
using the same approach as std::any. Because we know what the manager
function would be for a given type, we can check if the stored pointer
has the expected address. If it does, we don't need to use RTTI. If it
isn't equal, we still need to do the RTTI check (when RTTI is enabled)
to handle the case where the same function has different addresses in
different shared objects.
This also changes the implementation of the manager function to return a
null pointer result when asked for the type_info of the target object.
This not only avoids a warning with -Wswitch -Wsystem-headers, but also
avoids prevents std::function::target_type() from dereferencing an
uninitialized pointer when the linker keeps an instantiation of the
manager function that was compiled without RTTI.
Finally, this fixes a bug in the non-const overload of function::target
where calling it with a function type F was ill-formed, due to
attempting to use const_cast<F*>(ptr). The standard only allows
const_cast<T*> when T is an object type. The solution is to use
*const_cast<F**>(&ptr) instead, because F* is an object type even if F
isn't. I've also used _GLIBCXX17_CONSTEXPR in function::target so that
it doesn't bother instantiating anything for types that can never be a
valid target.
libstdc++-v3/ChangeLog:
* include/bits/std_function.h (_Function_handler<void, void>):
Define explicit specialization used for invalid target types.
(_Base_manager::_M_manager) [!__cpp_rtti]: Return null.
(function::target_type()): Check for null pointer.
(function::target()): Define unconditionall. Fix bug with
const_cast of function pointer type.
(function::target() const): Define unconditionally, but
only use RTTI if enabled.
* testsuite/20_util/function/target_no_rtti.cc: New test.
Aldy Hernandez [Thu, 22 Oct 2020 06:39:04 +0000 (08:39 +0200)]
Selectively trap if ranger and vr-values disagree on range builtins.
The UBSAN builtins degrade into PLUS/MINUS/MULT and call
extract_range_from_binary_expr, which as the PR shows, can special
case some symbolics which the ranger doesn't currently handle.
Looking at vr_values::extract_range_builtin(), I see that every single
place where we ask for a range, we bail on non-integers (symbolics,
etc). That is, with the exception of the UBSAN builtins.
Since this seems to be particular to UBSAN, we could still go with the
original plan of removing the duplicity in ranger vs vr-values, but
leave in the UBSAN builtin handling. This isn't ideal, as we'd like
to remove all the common code, but I'd be willing to put up with UBSAN
duplication for the time being.
This patch disables the assert on the UBSAN builtins, while still
trapping if any other differences are found between the vr_values and
the ranger versions of builtin range handling.
As a follow-up, once Fedora can test this approach, I'll remove all
the builtin code from extract_range_builtin, with the exception of the
UBSAN stuff (renaming it to extract_range_ubsan_builtin).
Since the builtin code has proven fickle across architectures, I've
tested this with {-m32,-m64,-fsanitize=signed-integer-overflow} on
x86, ppc64le, and aarch64. I think this should be enough. If it
isn't, we can revert the patch, and leave the duplicate code until
the next release cycle when hopefully vr_values, evrp, and friends
will all be overhauled.
gcc/ChangeLog:
PR tree-optimization/97505
* vr-values.c (vr_values::extract_range_basic): Enable
trap again for everything except UBSAN builtins.
Nathan Sidwell [Thu, 29 Oct 2020 11:56:27 +0000 (04:56 -0700)]
c++: Stop (most) function-scope entities having a template header
Currently push_template_decl (mostly) decides whether to add a
template header to an entity by seeing if it has DECL_LANG_SPECIFIC.
That might have been a useful predicate at one time, but basing
semantic implications on how we've decided to represent decls is bound
to be brittle. And indeed it is, as more decls grow a use for
lang-specific. In particular I discovered that function-scope
VAR_DECLs couild grow lang-specific, and thereby get a template
header. There's no need for that, and it breaks an invariant modules
was expected.
This patch changes that, and bases the descision on the properties of
the decl. In particular the only function-scope decl that gets a
template header is an implicit-typedef.
I also cleaned up the behaviour of it building a template-info only to
ignore it.
gcc/cp/
* pt.c (push_template_decl): Do not give function-scope entities
other than implicit typedefs a template header. Do not readd
template info to a redeclared template.
The problem is that the code only considers the permutation for
the first scalar iteration, rather than for all VF iterations.
This patch tries to fix that by making vect_transform_slp_perm_load
calculate the value instead.
gcc/
* tree-vectorizer.h (vect_transform_slp_perm_load): Take an
optional extra parameter.
* tree-vect-slp.c (vect_transform_slp_perm_load): Calculate
the number of loads as well as the number of permutes, taking
the counting loop from...
* tree-vect-stmts.c (vect_model_load_cost): ...here. Use the
value computed by vect_transform_slp_perm_load for ncopies.
Richard Biener [Thu, 29 Oct 2020 11:21:41 +0000 (12:21 +0100)]
Consistently pass the vector type for scalar SLP cost compute
This avoids randomly (based on whether the stmt is
SLP_TREE_REPRESENTATIVE and not a pattern stmt) passing a vector
type or NULL to the add_stmt_cost hook for scalar code cost
compute. For example the x86 backend uses only the vector type to
decide on the scalar computation mode which makes costing off.
So the following explicitely passes the vector type and uses
SLP_TREE_VECTYPE for this purpose.
2020-10-29 Richard Biener <rguenther@suse.de>
* tree-vect-slp.c (vect_bb_slp_scalar_cost): Pass
SLP_TREE_VECTYPE to record_stmt_cost.
Olivier Hainque [Wed, 28 Oct 2020 11:24:56 +0000 (11:24 +0000)]
Fix the logic conditioning VX_ENTER/LEAVE_TLS_DTOR
Fix a basic #if/#ifdef confusion which leads to improper
choices in some configurations.
2020-10-28 Olivier Hainque <hainque@adacore.com>
libgcc/
* config/gthr-vxworks-tls.c: Fix preprocessor logic
controlling the definition of VX_ENTER_TLS_DTOR and
VX_LEAVE_TLS_DTOR based on a version major check.
Olivier Hainque [Wed, 28 Oct 2020 11:16:57 +0000 (11:16 +0000)]
Fix conditional inclusion guard in gthr-vxworks-thread.c
This fixes the name of the macro used to condition the
inclusion of an actual implementation of some of the gthread
support services for VxWorks, to agree with the side
defining that macro based on tests against the targetted
VxWorks version major.
2020-10-28 Olivier Hainque <hainque@adacore.com>
libgcc/
* config/gthr-vxworks-thread.c: Fix name of macro used
to condition the inclusion of an actual implementation.
Alexandre Oliva [Thu, 29 Oct 2020 09:30:50 +0000 (06:30 -0300)]
CSE conversions within sincos
On platforms in which Aux_[Real_Type] involves non-NOP conversions
(e.g., between single- and double-precision, or between short float
and float), the conversions before the calls are CSEd too late for
sincos to combine calls.
This patch enables the sincos pass to CSE type casts used as arguments
to eligible calls before looking for other calls using the same
operand.
for gcc/ChangeLog
* tree-ssa-math-opts.c (sincos_stats): Add conv_removed.
(execute_cse_conv_1): New.
(execute_cse_sincos_1): Call it. Fix return within
FOR_EACH_IMM_USE_STMT.
(pass_cse_sincos::execute): Report conv_inserted.
The paper P0346R1 renamed uniform random number generators to
uniform random bit generators, to describe their purpose more
accurately. This makes that same change in one of the relevant
files (but not the others).
libstdc++-v3/ChangeLog:
* include/bits/uniform_int_dist.h (uniform_int_distribution):
Rename _UniformRandomNumberGenerator template parameters to
_UniformRandomBitGenerator, as per P0346R1.
Richard Biener [Thu, 29 Oct 2020 07:48:15 +0000 (08:48 +0100)]
More BB vectorization tweaks
This tweaks the op build from splats to allow loads marked as not
vectorizable. It also amends some dump prints with the address of
the SLP node or the instance to better be able to debug things.
2020-10-29 Richard Biener <rguenther@suse.de>
* tree-vect-slp.c (vect_build_slp_tree_2): Allow splatting
not vectorizable loads.
(vect_build_slp_instance): Amend dumping with address.
(vect_slp_convert_to_external): Likewise.
Nikhil Benesch [Mon, 26 Oct 2020 18:42:08 +0000 (18:42 +0000)]
libgo: handle linking to NetBSD's versioned symbols
On NetBSD, for backwards compatibility, various libc symbols are
renamed to a symbol with a version suffix. For example, this is the
(abbreviated) definition of sigaction:
int sigaction(...) __asm__ ("__sigaction14")
This poses a challenge for libgo, which attempts to link sigaction by
way of an "//extern" comment:
//extern sigaction
func sigaction(...)
This results in a reference to the deprecated compatibility symbol
"sigaction", rather than the desired "__sigaction14" symbol.
This patch introduces a new "//extern-sysinfo" comment to handle this
situation. The new mklinknames.awk script scans a package for these
comments and outputs a "//go:linkname" directive that links the wrapper
to the correct versioned symbol, as determined by parsing the __asm__
annotation on the function's declaration in gen-sysinfo.go.
For now, only the following packages are scanned by mklinknames.awk:
gcc/analyzer/ChangeLog:
* analyzer.h (class state_machine): New forward decl.
(class logger): Likewise.
(class visitor): Likewise.
* complexity.cc: New file, taken from svalue.cc.
* complexity.h: New file, taken from region-model.h.
* region-model.h: Include "analyzer/svalue.h" and
"analyzer/region.h". Move struct complexity to complexity.h.
Move svalue, its subclasses and supporting decls to svalue.h.
Move region, its subclasses and supporting decls to region.h.
* region.cc: Include "analyzer/region.h".
(symbolic_region::symbolic_region): Move here from region-model.h.
* region.h: New file, based on material from region-model.h.
* svalue.cc: Include "analyzer/svalue.h".
(complexity::complexity): Move to complexity.cc.
(complexity::from_pair): Likewise.
* svalue.h: New file, based on material from region-model.h.
David Malcolm [Thu, 29 Oct 2020 00:07:35 +0000 (20:07 -0400)]
analyzer: fix more pointer-printing in logs
gcc/analyzer/ChangeLog:
* program-state.cc (sm_state_map::print): Guard the printing of
the origin pointer with !flag_dump_noaddr.
* region.cc (string_region::dump_to_pp): Likewise for
m_string_cst.
Alan Modra [Wed, 28 Oct 2020 08:33:04 +0000 (19:03 +1030)]
[RS6000] Don't be too clever with dg-do run and dg-do compile
Otherwise some versions of dejagnu go ahead and run the vsx tests
below when they should not. To best cope with older dejagnu, put
"run" before "compile", the idea being that if the second dg-do always
wins then that won't cause fails.
The altivec tests also need -save-temps for the scan-assembler test to
occur when vms_hw.
* gcc.target/powerpc/vsx-load-element-extend-char.c: Put "dg-do run"
before "dg-do compile", and make them mutually exclusive.
* gcc.target/powerpc/vsx-load-element-extend-int.c: Likewise.
* gcc.target/powerpc/vsx-load-element-extend-longlong.c: Likewise.
* gcc.target/powerpc/vsx-load-element-extend-short.c: Likewise.
* gcc.target/powerpc/vsx-store-element-truncate-char.c: Likewise.
* gcc.target/powerpc/vsx-store-element-truncate-int.c: Likewise.
* gcc.target/powerpc/vsx-store-element-truncate-longlong.c: Likewise.
* gcc.target/powerpc/vsx-store-element-truncate-short.c: Likewise.
* gcc.target/powerpc/altivec-consts.c: Likewise, add -save-temps.
* gcc.target/powerpc/le-altivec-consts.c: Likewise.
Alan Modra [Wed, 28 Oct 2020 05:27:57 +0000 (15:57 +1030)]
[RS6000] float128-type-2.c unsupported
I noticed this test is unsupported on power10 when looking through
test logs. There seems no reason why that should be the case, ie.
the target test was meant to be powerpc64*-*-linux*. And that
simplifies down further.
Alan Modra [Tue, 27 Oct 2020 23:37:44 +0000 (10:07 +1030)]
Re: testsuite: Enable and adjust powerpc fold-vec-extract/insert testcases
git commit badeac77f552 changed expected number of addi instructions,
causing these fails on powerpc-linux.
gcc.target/powerpc/fold-vec-insert-int-p9.c: \\maddi\\M found 12 times
FAIL: gcc.target/powerpc/fold-vec-insert-int-p9.c scan-assembler-times \\maddi\\M 8
gcc.target/powerpc/fold-vec-extract-char.p9.c: addi found 6 times
FAIL: gcc.target/powerpc/fold-vec-extract-char.p9.c scan-assembler-times addi 3
gcc.target/powerpc/fold-vec-extract-int.p9.c: \\maddi\\M found 6 times
FAIL: gcc.target/powerpc/fold-vec-extract-int.p9.c scan-assembler-times \\maddi\\M 3
gcc.target/powerpc/fold-vec-extract-longlong.p7.c: \\maddi\\M found 6 times
FAIL: gcc.target/powerpc/fold-vec-extract-longlong.p7.c scan-assembler-times \\maddi\\M 4
gcc.target/powerpc/fold-vec-extract-longlong.p8.c: \\maddi\\M found 6 times
FAIL: gcc.target/powerpc/fold-vec-extract-longlong.p8.c scan-assembler-times \\maddi\\M 4
changed by badeac77f552
I'm not at all sure why we are counting addi. On linux I see
eight in fold-vec-insert-int-p9.c tearing down the stack frame in
function epilogues, and four in
addi 9,1,16
lvewx 0,0,9
For aix you have the above four but with a -16 offset. There are no
stack frames, and you have four addressing stack red-zone as
addi 9,1,-64
fold-vec-extract-char.p9.c on linux just has epilogue addi, aix has
red-zone addressing. The same for fold-vec-extract-int.p9.c,
fold-vec-extract-longlong.p7.c and fold-vec-extract-longlong.p8.c.
It seems silly to count addi in a function epilogue, and fragile to
count them in code. So remove the ilp32 addi checks.
Marek Polacek [Wed, 28 Oct 2020 18:45:27 +0000 (14:45 -0400)]
c++: Improve the MVP -Wparentheses diagnostic.
I noticed that declarator->parenthesized is, for this warning, only set
to the opening paren. But we can easily make it a range and generate
a nicer diagnostic. Moreover, we can then offer a fix-it hint.
TL;DR: This patch changes
mvp3.C:8:7: warning: unnecessary parentheses in declaration of ‘i’ [-Wparentheses]
8 | int (i);
| ^
to
mvp3.C:8:7: warning: unnecessary parentheses in declaration of ‘i’ [-Wparentheses]
8 | int (i);
| ^~~
mvp3.C:8:7: note: remove parentheses
8 | int (i);
| ^~~
| - -
Tested by using -fdiagnostics-generate-patch and verifying that the
generated patch DTRT.
gcc/cp/ChangeLog:
* decl.c (grokdeclarator): Offer a fix-it hint for the "unnecessary
parentheses in declaration" warning.
* parser.c (cp_parser_direct_declarator): When setting
declarator->parenthesized, use a location range.
Marek Polacek [Tue, 27 Oct 2020 15:16:50 +0000 (11:16 -0400)]
c++: Deprecate arithmetic convs on different enums [PR97573]
I noticed that C++20 P1120R0 deprecated certain arithmetic conversions
as outlined in [depr.arith.conv.enum], but we don't warn about them. In
particular, "If one operand is of enumeration type and the other operand
is of a different enumeration type or a floating-point type, this
behavior is deprecated." These will likely become ill-formed in C++23,
so we should warn by default in C++20. To this effect, this patch adds
two new warnings (like clang++): -Wdeprecated-enum-enum-conversion and
-Wdeprecated-enum-float-conversion. They are enabled by default in
C++20. In older dialects, to enable these warnings you can now use
-Wenum-conversion which I made available in C++ too. Note that unlike
C, in C++ it is not enabled by -Wextra, because that breaks bootstrap.
We already warn about comparisons of two different enumeration types via
-Wenum-compare, the rest is handled in this patch: we're performing the
usual arithmetic conversions in these contexts:
- an arithmetic operation,
- a bitwise operation,
- a comparison,
- a conditional operator,
- a compound assign operator.
Using the spaceship operator as enum <=> real_type is ill-formed but we
don't reject it yet. We should also address [depr.array.comp] too, but
it's not handled in this patch.
gcc/c-family/ChangeLog:
PR c++/97573
* c-opts.c (c_common_post_options): In C++20, turn on
-Wdeprecated-enum-enum-conversion and
-Wdeprecated-enum-float-conversion.
* c.opt (Wdeprecated-enum-enum-conversion,
Wdeprecated-enum-float-conversion): New options.
(Wenum-conversion): Allow for C++ too.
gcc/cp/ChangeLog:
PR c++/97573
* call.c (build_conditional_expr_1): Warn about the deprecated
enum/real type conversion in C++20. Also warn about a non-enumerated
and enumerated type in ?: when -Wenum-conversion is on.
* typeck.c (do_warn_enum_conversions): New function.
(cp_build_binary_op): Call it.
gcc/ChangeLog:
PR c++/97573
* doc/invoke.texi: Document -Wdeprecated-enum-enum-conversion
and -Wdeprecated-enum-float-conversion. -Wenum-conversion is
no longer C/ObjC only.
gcc/testsuite/ChangeLog:
PR c++/97573
* g++.dg/cpp0x/linkage2.C: Add dg-warning.
* g++.dg/parse/attr3.C: Likewise.
* g++.dg/cpp2a/enum-conv1.C: New test.
* g++.dg/cpp2a/enum-conv2.C: New test.
* g++.dg/cpp2a/enum-conv3.C: New test.
Marek Polacek [Sat, 24 Oct 2020 19:26:27 +0000 (15:26 -0400)]
c++: Prevent warnings for value-dependent exprs [PR96742]
Here, in r11-155, I changed the call to uses_template_parms to
type_dependent_expression_p_push to avoid a crash in C++98 in
value_dependent_expression_p on a non-constant expression. But that
prompted a host of complaints that we now warn for value-dependent
expressions in templates. Those warnings are technically valid, but
people still don't want them because they're awkward to avoid. This
patch uses value_dependent_expression_p or type_dependent_expression_p.
But make sure that we don't ICE in value_dependent_expression_p by
checking potential_constant_expression first.
gcc/cp/ChangeLog:
PR c++/96675
PR c++/96742
* pt.c (tsubst_copy_and_build): Call value_dependent_expression_p or
type_dependent_expression_p instead of type_dependent_expression_p_push.
But only call value_dependent_expression_p for expressions that are
potential_constant_expression.
gcc/testsuite/ChangeLog:
PR c++/96675
PR c++/96742
* g++.dg/warn/Wdiv-by-zero-3.C: Turn dg-warning into dg-bogus.
* g++.dg/warn/Wtautological-compare3.C: New test.
* g++.dg/warn/Wtype-limits5.C: New test.
* g++.old-deja/g++.pt/crash10.C: Remove dg-warning.
Marek Polacek [Mon, 19 Oct 2020 22:13:42 +0000 (18:13 -0400)]
c++: Member template function lookup failure [PR94799]
My earlier patch for this PR, r11-86, broke pybind11. That patch
changed cp_parser_class_name to also consider the object expression
scope (parser->context->object_type) to fix parsing of
p->template A<T>::foo(); // consider p's scope too
Here we reject
b.operator typename B<T>::type();
because 'typename_p' in cp_parser_class_name uses 'scope', which means
that 'typename_p' will be true for the example above. Then we create
a TYPENAME_TYPE via make_typename_type, which fails when tsubsting it;
the code basically created 'typename B::B' and then we complain that there
is no member named 'B' in 'A<int>'. So, when deciding if we should
create a TYPENAME_TYPE, don't consider the object_type scope, like we
did pre-r11-86.
gcc/cp/ChangeLog:
PR c++/94799
* parser.c (cp_parser_class_name): Use parser->scope when
setting typename_p.
gcc/testsuite/ChangeLog:
PR c++/94799
* g++.dg/template/lookup16.C: New test.
where the VQ coefficient is unsigned but is effectively acting
as a negative number. We wrongly give the POLY_INT_CST the range:
[9, INT_MAX]
and things go downhill from there: later iterations of the unrolled
epilogue are wrongly removed as dead.
I guess this is the final nail in the coffin for doing VRP on
POLY_INT_CSTs. For other similarly exotic testcases we could have
overflow for any coefficient, not just those that could be treated
as contextually negative.
Testing TYPE_OVERFLOW_UNDEFINED doesn't seem like an option because we
couldn't handle warn_strict_overflow properly. At this stage we're
just recording a range that might or might not lead to strict-overflow
assumptions later.
It still feels like we should be able to do something here, but for
now removing the code seems safest. It's also telling that there
are no testsuite failures on SVE from doing this.
Joseph Myers [Wed, 28 Oct 2020 18:57:02 +0000 (18:57 +0000)]
c: Allow omitted parameter names for C2x
C2x allows parameter names to be omitted in function definitions, as
in C++; add support for this feature. As with other features that
only result in previously rejected code being accepted, this feature
is now accepted as an extension for previous standard versions, with a
pedwarn-if-pedantic that is disabled by -Wno-c11-c2x-compat. The
logic for avoiding unused-parameter warnings for unnamed parameters is
in code shared between C and C++, so no changes are needed there.
Bootstrapped with no regressions for x86_64-pc-linux-gnu.
gcc/c/
2020-10-28 Joseph Myers <joseph@codesourcery.com>
* c-decl.c (store_parm_decls_newstyle): Use pedwarn_c11 not
error_at for omitted parameter name.
gcc/testsuite/
2020-10-28 Joseph Myers <joseph@codesourcery.com>
* gcc.dg/c11-parm-omit-1.c, gcc.dg/c11-parm-omit-2.c,
gcc.dg/c11-parm-omit-3.c, gcc.dg/c11-parm-omit-4.c,
gcc.dg/c2x-parm-omit-1.c, gcc.dg/c2x-parm-omit-2.c,
gcc.dg/c2x-parm-omit-3.c, gcc.dg/c2x-parm-omit-4.c: New tests.
* gcc.dg/noncompile/pr79758.c: Do not expect error for omitted
parameter name.
Nathan Sidwell [Wed, 28 Oct 2020 18:42:11 +0000 (11:42 -0700)]
c++: Make OMP UDR DECL_LOCAL_DECL_P earlier
I discovered that we were pushing an OMP UDR in a template before
setting DECL_LOCAL_DECL. This caused the template machinery to give
it some template info. It doesn't need that, and this changes the
parser to set it earlier. We have to adjust instantiate_body to not
try and access such a function's non-existant template_info. The
access checks that we're no longer doing are the same as those we did
on the containing function anyway. So nothing is lost.
gcc/cp/
* parser.c (cp_parser_omp_declare_reduction): Set
DECL_LOCAL_DECL_P before push_template_decl.
* pt.c (instantiate_body): Nested fns do not have template_info.
Patrick Palka [Wed, 28 Oct 2020 16:28:08 +0000 (12:28 -0400)]
libstdc++: Fix arithmetic bug in year_month_weekday conversion [PR96713]
The conversion function year_month_weekday::operator sys_days computes
the offset in days from the first weekday of the month with:
days{(index()-1)*7}
^~~~~~~~~~~~~ type 'unsigned'
We want the above to yield -7d when index() is 0u, but our 'days' alias
is based on long instead of int, so the conversion from unsigned to the
underlying type of 'days' instead yields a large positive value.
This patch fixes this by casting the result of index() to int so that
the initializer is sign-extended in the conversion to long.
The added testcase also verifies we do the right thing when index() == 5.
libstdc++-v3/ChangeLog:
PR libstdc++/96713
* include/std/chrono (year_month_weekday::operator sys_days):
Cast the result of index() to int so that the initializer for
days{} is sign-extended when it's converted to the underlying
type.
* testsuite/std/time/year_month_weekday/3.cc: New test.
Patrick Palka [Wed, 28 Oct 2020 15:47:26 +0000 (11:47 -0400)]
c++: Check constraints before instantiation from mark_used [PR95132]
This makes mark_used check constraints of a function _before_ calling
maybe_instantiate_decl, so that we don't try instantiating a function
(as part of return type deduction) with unsatisfied constraints.
gcc/cp/ChangeLog:
PR c++/95132
* decl2.c (mark_used): Move up the constraints_satisfied_p check
so that we check constraints before calling maybe_instantiate_decl.
gcc/testsuite/ChangeLog:
PR c++/95132
* g++.dg/cpp2a/concepts-fn7.C: New test.
Richard Biener [Wed, 28 Oct 2020 14:07:02 +0000 (15:07 +0100)]
Ignore ignored operands in vect_get_and_check_slp_defs
This passes down skip_args to vect_get_and_check_slp_defs to skip
ignored ops there, too and not fail SLP discovery. This fixes
gcc.target/aarch64/sve/reduc_strict_5.c
2020-10-28 Richard Biener <rguenther@suse.de>
* tree-vect-slp.c (vect_get_and_check_slp_defs): For skipped
args just push NULLs and vect_uninitialized_def.
(vect_build_slp_tree_2): Allocate skip_args for all ops
and pass it down to vect_get_and_check_slp_defs.
David Edelsohn [Wed, 28 Oct 2020 14:26:45 +0000 (10:26 -0400)]
testsuite: Correct requirements for byte-in-* testcases.
commit 25ffd3d34e means we no longer define an overloaded
__builtin_byte_in_set for -m32, so the more informative
"__builtin_byte_in_set is not supported in this compiler
configuration" is not reported.
This patch changes byte-in-set-2.c to expect an implicit declaration
warning. It also removes unnecessary target requirement for all
byte-in-*.c tests and no longer skips AIX.
gcc/testsuite/ChangeLog:
2020-10-28 David Edelsohn <dje.gcc@gmail.com>
Alan Modra <amodra@gmail.com>
Jonathan Wakely [Wed, 28 Oct 2020 13:19:21 +0000 (13:19 +0000)]
libstdc++: Override BUFSIZ for Windows targets [PR 94268]
This replaces uses of BUFSIZ with a new _GLIBCXX_BUFSIZ macro that can
be overridden in target-specific config headers.
That allows the mingw and mingw-w64 targets to override it, because
BUFSIZ is apparently defined to 512, resulting in poor performance. The
MSVCRT stdio apparently uses 4096, so we use that too.
Richard Biener [Wed, 28 Oct 2020 11:56:16 +0000 (12:56 +0100)]
Change the way we split stores in BB vectorization
The following fixes missed optimizations due to the strange way we
split stores in BB vectorization. The solution is to split at
the failure boundary and not re-align that to the initial piece
chosen vector size. Also re-analyze any larger matching rest.
2020-10-28 Richard Biener <rguenther@suse.de>
* tree-vect-slp.c (vect_build_slp_instance): Split the store
group at the failure boundary and also re-analyze a large enough
matching rest.
Jonathan Wakely [Wed, 28 Oct 2020 12:35:44 +0000 (12:35 +0000)]
libstdc++: Fix name clash with _Cosh in QNX headers [PR 95592]
This replaces unqualified names like _Cosh with struct std::_Cosh to
ensure there is no ambiguity with other entities with the same name.
libstdc++-v3/ChangeLog:
PR libstdc++/95592
* include/bits/valarray_after.h (_DEFINE_EXPR_UNARY_OPERATOR)
(_DEFINE_EXPR_BINARY_OPERATOR, _DEFINE_EXPR_BINARY_FUNCTION):
Use elaborated-type-specifier and qualified-id to avoid
ambiguities with QNX system headers.
* testsuite/26_numerics/valarray/95592.cc: New test.
Jonathan Wakely [Wed, 28 Oct 2020 12:07:40 +0000 (12:07 +0000)]
libstdc++: Make std::span layout-compatible with struct iovec [PR 95609]
This change reorders the data members of std::span so that span<byte> is
layout-compatible with common implementations of struct iovec. This will
allow span<byte> to be used directly in places that use a struct iovec
to do scatter-gather I/O.
It's important to note that POSIX doesn't specify the order of members
in iovec. Also the equivalent type on Windows has members in the other
order, and uses type ULONG (which is always 32-bit whereas size_t is
64-bit for Win64). So this change will only help for certain targets and
an indirection between std::span and I/O system calls will still be
needed for the general case.
libstdc++-v3/ChangeLog:
PR libstdc++/95609
* include/std/span (span): Reorder data members to match common
implementations of struct iovec.
* testsuite/23_containers/span/layout_compat.cc: New test.
2020-10-19 Andrea Corallo <andrea.corallo@arm.com>
* config/aarch64/arm_neon.h (__ST2_LANE_FUNC, __ST3_LANE_FUNC)
(__ST4_LANE_FUNC): Rename the macro generating the 'q' variants
into __ST2Q_LANE_FUNC, __ST2Q_LANE_FUNC, __ST2Q_LANE_FUNC so they
all can be undefed at the and of the file.
(vst2_lane_bf16, vst2q_lane_bf16, vst3_lane_bf16, vst3q_lane_bf16)
(vst4_lane_bf16, vst4q_lane_bf16): Add new intrinsics.
gcc/testsuite/ChangeLog
2020-10-19 Andrea Corallo <andrea.corallo@arm.com>
* gcc.target/aarch64/advsimd-intrinsics/arm-neon-ref.h
(hbfloat16_t): Define type.
(CHECK_FP): Make it working for bfloat types.
* gcc.target/aarch64/advsimd-intrinsics/bf16_vstN_lane_1.c: New file.
* gcc.target/aarch64/advsimd-intrinsics/bf16_vstN_lane_2.c: Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vst2_lane_bf16_indices_1.c:
Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vst2q_lane_bf16_indices_1.c:
Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vst3_lane_bf16_indices_1.c:
Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vst3q_lane_bf16_indices_1.c:
Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vst4_lane_bf16_indices_1.c:
Likewise.
* gcc.target/aarch64/advsimd-intrinsics/vst4q_lane_bf16_indices_1.c:
Likewise.
2020-10-15 Andrea Corallo <andrea.corallo@arm.com>
* config/aarch64/arm_neon.h (__LD2_LANE_FUNC, __LD3_LANE_FUNC)
(__LD4_LANE_FUNC): Rename the macro generating the 'q' variants
into __LD2Q_LANE_FUNC, __LD2Q_LANE_FUNC, __LD2Q_LANE_FUNC so they
all can be undefed at the and of the file.
(vld2_lane_bf16, vld2q_lane_bf16, vld3_lane_bf16, vld3q_lane_bf16)
(vld4_lane_bf16, vld4q_lane_bf16): Add new intrinsics.
gcc/testsuite/ChangeLog
2020-10-15 Andrea Corallo <andrea.corallo@arm.com>