middle-end/97579 - lower VECTOR_BOOLEAN_TYPE_P VEC_COND_EXPRs

This makes sure to lower VECTOR_BOOLEAN_TYPE_P typed non-vector
mode VEC_COND_EXPRs so we don't try to use vcond to expand those.
That's required for x86 and gcn integer mode boolean vectors.

2020-11-25  Richard Biener  <rguenther@suse.de>

PR middle-end/97579
* gimple-isel.cc (gimple_expand_vec_cond_expr): Lower
VECTOR_BOOLEAN_TYPE_P, non-vector mode VEC_COND_EXPRs.

* gcc.dg/pr97579.c: New testcase.

Fix atomic_capture-1.f90 testcase

The testcase had invalid assumptions about which loop iterations would run
first and last.

libgomp/ChangeLog

* testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 (main): Adjust
expected results.

[Ada] Further optimization with uninitialized aggregates

gcc/ada/

* freeze.adb (Is_Uninitialized_Aggregate): Move...
* exp_util.adb (Is_Uninitialized_Aggregate): ... here.
(Expand_Subtype_From_Expr): If the expression is an
uninitialized aggregate, capture subtype for declared object and
remove expression to suppress further superfluous expansion.

[Ada] Spurious error on instance with predicated actual

gcc/ada/

* sem_eval.adb (Subtypes_Statically_Compatible): Scalar types
with compatible static bounds are statically compatible if
predicates are compatible, even if they are not static subtypes.
Same for private types without discriminants.

[Ada] Fix couple of minor issues with local exception propagation

gcc/ada/

* exp_ch11.adb (Expand_N_Raise_Statement): Use Is_Entity_Name
consistently in tests on the name of the statement.
* exp_prag.adb (Expand_Pragma_Check): In the local propagation
case, wrap the raise statement in a block statement.

[Ada] Remove shadowing by a nested subprogram parameter

gcc/ada/

* exp_ch8.adb (Expand_N_Exception_Renaming_Declaration): Move
"Nam" constant after the body of a nested subprogram; change "T"
from variable to constant.

[Ada] Merge duplicated processing for gnatmake -u and -U switches

gcc/ada/

* make.adb (Scan_Make_Arg): Merge ELSIF branches for -u and -U.

[Ada] Document attribute Has_Tagged_Values in GNAT RM

gcc/ada/

* doc/gnat_rm/implementation_defined_attributes.rst
(Has_Tagged_Values): Document based on the existing description
of Has_Access_Type and the comment for Has_Tagged_Component,
which is where frontend evaluates this attribute.
* gnat_rm.texi: Regenerate.
* sem_attr.adb (Analyze_Attribute): Merge processing of
Has_Access_Type and Has_Tagged_Component attributes.
* sem_util.adb (Has_Access_Type): Fix casing in comment.
* sem_util.ads (Has_Tagged_Component): Remove wrong (or
outdated) comment about the use of this routine to implement the
equality operator.

[Ada] Minor whitespace fix in expansion of attribute Size

gcc/ada/

* exp_attr.adb (Expand_Size_Attribute): Remove whitespace;
simplify with a membership test, which are now allowed in the
frontend code.

[Ada] Use hardcoded names when converting aspects to pragmas

gcc/ada/

* sem_ch13.adb (Analyze_One_Aspect): Fix inconsistent calls to
Make_Aitem_Pragma.

[Ada] Reuse Is_Named_Number where possible

gcc/ada/

* sem_ch13.adb (Check_Expr_Constants): Simplify with
Is_Named_Number.
* sem_prag.adb (Process_Convention): Likewise.

[Ada] Simplify aspect processing with membership tests

gcc/ada/

* sem_ch13.adb (Analyze_One_Aspect): Detect aspect identifiers
with membership tests.
(Check_Aspect_At_End_Of_Declarations): Likewise.
(Freeze_Entity_Checks): Likewise; a local constant is no longer
needed.
(Is_Operational_Item): Similar simplification for attribute
identifiers.
(Is_Type_Related_Rep_Item): Likewise.
(Resolve_Iterable_Operation): Detect names with a membership
test.
(Validate_Independence): Replace repeated Ekind with a
membership test.

[Ada] Fix copy-paste mistake in diagnostics for aspect Effective_Writes

gcc/ada/

* sem_ch13.adb (Analyze_One_Aspect): Replace duplicate of
Effective_Reads.

[Ada] Simplify Ekind tests with wrappers and membership tests

gcc/ada/

* einfo.adb: Use composite wrappers (e.g.
Is_Subprogram_Or_Entry) and membership tests where it appears to
improve clarity.

[Ada] Simplify Is_Standard_xxx_Type routines with membership tests

gcc/ada/

* einfo.adb (Is_Standard_Character_Type,
Is_Standard_String_Type): Simplify.
(Last_Formal): Use procedural variant of Next_Formal.

[Ada] Consistently use explicit Entity_Id type instead of alias

gcc/ada/

* einfo.adb: Replace "E" with Entity_Id in local object
declarations.

[Ada] Don't constant-fold renamed qualified expressions

gcc/ada/

* exp_ch2.adb (Expand_Entity_Reference): A new local predicate
Is_Object_Renaming_Name indicates whether a given expression
occurs (after looking through qualified expressions and type
conversions) as the name of an object renaming declaration. If
Current_Value is available but this new predicate is True, then
ignore the availability of Current_Value.

[Ada] Remove dead and duplicated diagnostics for generic access types

gcc/ada/

* sem_ch12.adb (Instantiate_Type): Remove extra whitespace.
(Validate_Access_Type_Instance): Remove dead (and duplicated)
code.

[Ada] Remove hyphens in two cases of "side-effect" used as a noun

gcc/ada/

* exp_util.adb (Possible_Side_Effect_In_SPARK): Replace hyphen
with a space in "side-effect" (two instances).

[Ada] Crash on right shift operator for signed integers

gcc/ada/

* doc/gnat_rm/intrinsic_subprograms.rst (Shifts and Rotates):
Document behavior on negative numbers
* gnat_rm.texi: Regenerate.
* sem_eval.adb (Fold_Shift): Set modulus to be based on the RM
size for non-modular integer types.

[Ada] Reinstate utime based code for vx6 in __gnat_copy_attribs

gcc/ada/

* adaint.c (__gnat_copy_attribs): Reinstate code based on utime
for timestamp processing on VxWorks 6.

[Ada] Minimize side-effect removal in GNATprove mode

gcc/ada/

* exp_util.adb (Remove_Side_Effects): Only remove side-effects
in GNATprove mode when this is useful.
* sem_res.adb (Set_Slice_Subtype): Make sure in GNATprove mode
to define the Itype when needed, so that run-time errors can be
analyzed.
* sem_util.adb (Enclosing_Declaration): Correctly take into
account renaming declarations.

[Ada] Adjust support for 128-bit integer types in System.Random_Numbers

gcc/ada/

* libgnat/s-rannum.adb (Random_Discrete): Specifically deal with
the case where the size of the base type is larger than 64 bits.

[Ada] Fix internal compilation error on circular type in SPARK code

gcc/ada/

* sem_ch3.adb (Access_Type_Declaration): Set Etype before
checking for volatility compatibility.

[Ada] Add support for 128-bit integer types to GNAT.Random_Numbers

gcc/ada/

* libgnat/g-rannum.ads (Random): New functions returning 128-bit.
* libgnat/g-rannum.adb (Random): Implement them and alphabetize.
(To_Signed): New unchecked conversion function for 128-bit.

[Ada] Allow debugging finalization-related expanded code

gcc/ada/

* exp_ch7.adb (Build_Finalization_Master, Build_Finalizer,
Build_Object_Declarations, Make_Deep_Array_Body,
Wrap_Transient_Expression): Call Set_Debug_Info_Needed on
temporaries when Debug_Generated_Code is True.

[Ada] Unrecursify Set_Digit/Set_Image_Unsigned procedure

gcc/ada/

* libgnat/s-imagei.adb
(Set_Digits): Rewrite the procedure to remove recursion.
(Image_Integer, Set_Image_Integer): Update assertions and remove
redundant ones.
* libgnat/s-imageu.adb
(Set_Image_Unsigned): Rewrite the procedure to remove recursion.

[Ada] Remove repeated calls to Attribute_Name

gcc/ada/

* exp_util.adb (Attribute_Constrained_Static_Value): Fix body
box.
* sem_attr.adb (Eval_Attribute): Replace repeated calls to
Attribute_Name with a captured value of the Attribute_Id; also,
remove extra parens around Is_Generic_Type.

[Ada] Fix crash on invalid `pragma Profile`

gcc/ada/

* sem_prag.adb (Analyze_Pragma): Emit error on wrong argument
nkind.

[Ada] Reuse Is_Named_Number where possible

gcc/ada/

* sem_attr.adb, sem_prag.adb: Use Is_Named_Number.

[Ada] Fix style and typos in code for expanding attribute references

gcc/ada/

* exp_attr.adb, exp_util.adb: Fix style and typos in comments.

[Ada] Minor refine type of a counter variable

gcc/ada/

* exp_attr.adb (Expand_N_Attribute_Reference): A variable that
is only incremented in the code has now type Nat; conversion is
now unnecessary.

arm: Add test that was missing from old commit [PR91816]

A while back I submitted GCC10 commit:

 44f77a6dea2f312ee1743f3dde465c1b8453ee13

for PR91816.

Turns out I was an idiot and forgot to include the test in the actual git commit.

Tested that the test still passes on a cross arm-none-eabi and also in a
Cortex A-15 bootstrap with no regressions.

gcc/testsuite/ChangeLog:
PR target/91816
* gcc.target/arm/pr91816.c: New test.

libstdc++: Fix silly typos [PR 97936]

libstdc++-v3/ChangeLog:

PR libstdc++/97936
* include/bits/atomic_wait.h (__platform_wait): Check errno,
not just the value of EAGAIN.
(__waiters::__waiters()): Fix name of data member.

libstdc++: Fix handling of futex wake [PR 97936]

The __platform_wait function is supposed to wait until *addr != old.
The futex syscall checks the initial value and returns EAGAIN if *addr
!= old is already true, which should cause __platform_wait to return.
Instead it loops and keeps doing a futex wait, which keeps returning
EAGAIN.

libstdc++-v3/ChangeLog:

PR libstdc++/97936
* include/bits/atomic_wait.h (__platform_wait): Return if futex
sets EAGAIN.
* testsuite/30_threads/latch/3.cc: Re-enable test.
* testsuite/30_threads/semaphore/try_acquire_until.cc: Likewise.

middle-end: Reject flexible array members in __builtin_clear_padding [PR97943]

As mentioned in the PR, we currently ICE on flexible array members in
structs and unions during __builtin_clear_padding processing.

Jason said in the PR he'd prefer an error in these cases over forcefully
handling it as [0] arrays (everything is padding then) or consider the
arrays to have as many whole elements as would fit into the tail padding.

So, this patch implements that.

2020-11-25  Jakub Jelinek  <jakub@redhat.com>

PR middle-end/97943
* gimple-fold.c (clear_padding_union, clear_padding_type): Error on and
ignore flexible array member fields.  Ignore fields with
error_mark_node type.

* c-c++-common/builtin-clear-padding-2.c: New test.
* c-c++-common/builtin-clear-padding-3.c: New test.
* g++.dg/ext/builtin-clear-padding-1.C: New test.
* gcc.dg/builtin-clear-padding-2.c: New test.

Daily bump.

changelog: fix parsing of a revert commit

contrib/ChangeLog:

* gcc-changelog/git_commit.py: Use revert_regex instead
of string prefix.  Convert sets to literals.

libstdc++: Disable failing tests [PR 97936]

These tests are unstable and causing failures due to timeouts. Disable
them until the cause can be found, so that testing doesn't have to wait
for them to timeout.

libstdc++-v3/ChangeLog:

PR libstdc++/97936
PR libstdc++/97944
* testsuite/29_atomics/atomic_integral/wait_notify.cc: Disable.
Do not require pthreads, but add -pthread when appropriate.
* testsuite/30_threads/jthread/95989.cc: Likewise.
* testsuite/30_threads/latch/3.cc: Likewise.
* testsuite/30_threads/semaphore/try_acquire_until.cc: Likewise.

PR c/97955 - ICE in build_array_type_1 on invalid redeclaration of function with VLA parameter

gcc/c-family/ChangeLog:

* c-warn.c (warn_parm_array_mismatch): Avoid invalid redeclarations.

gcc/testsuite/ChangeLog:

* gcc.dg/pr97955.c: New test.

Add a note.

gcc/testsuite/ChangeLog:
* gcc.dg/Wstringop-overflow-47.c: Add a note.

c++: ICE with int{} in template. [PR97899]

split_nonconstant_init_1 was confused by a CONSTRUCTOR with non-aggregate
type, which (with COMPOUND_LITERAL_P set) we use in a template to represent
a braced functional cast.  It seems to me that there's no good reason to do
split_nonconstant_init at all in a template.

gcc/cp/ChangeLog:

PR c++/97899
* typeck2.c (store_init_value): Don't split_nonconstant_init in a
template.

gcc/testsuite/ChangeLog:

PR c++/97899
* g++.dg/cpp0x/initlist-template3.C: New test.

Revert: "Fix -ffast-math flags handling inconsistencies"

This reverts commit c4fa3728ab4f78984a549894e0e8c4d6a253e540,
which caused a regression in the default for flag_excess_precision.

2020-11-24  Ulrich Weigand  <uweigand@de.ibm.com>

gcc/
PR tree-optimization/97970
* doc/invoke.texi (-ffast-math): Revert last change.
* opts.c: Revert last change.

Adjust regex pattern to expect an additional attribute and function return type

gcc/testsuite/ChangeLog:

* gfortran.dg/gomp/declare-target-4.f90: Adjust pattern to expect
an additional attribute and function return type.

[PR97933] LRA: find correctly last empty dest block.

gcc/

2020-11-24  Vladimir Makarov  <vmakarov@redhat.com>

PR bootstrap/97933
* lra.c (lra_process_new_insns): Stop on the first real insn after
head of e->dest.

arm: correctly handle negating INT_MIN in arm_split_atomic_op [PR97534]

arm_split_atomic_op handles subtracting a constant by converting it
into addition of the negated constant.  But if the type of the operand
is int and the constant is -1 we currently end up generating invalid
RTL which can lead to an abort later on.

The problem is that in a HOST_WIDE_INT, INT_MIN is represented as
0xffffffff80000000 and the negation of this is 0x0000000080000000, but
that's not a valid constant for use in SImode operations.

The fix is straight-forward which is to use gen_int_mode rather than
simply GEN_INT.  This knows how to correctly sign-extend the negated
constant when this is needed.

gcc/
PR target/97534
* config/arm/arm.c (arm_split_atomic_op): Use gen_int_mode when
negating a const_int.
gcc/testsuite
* gcc.dg/pr97534.c: New test.

preprocessor: Add deferred macros

Deferred macros are needed for C++ modules.  Header units may export
macro definitions and undefinitions.  These are resolved lazily at the
point of (potential) use.  (The language specifies that, it's not just
a useful optimization.)  Thus, identifier nodes grow a 'deferred'
field, which fortunately doesn't expand the structure on 64-bit
systems as there was padding there.  This is non-zero on NT_MACRO
nodes, if the macro is deferred.  When such an identifier is lexed, it
is resolved via a callback that I added recently.  That will either
provide the macro definition, or discover it there was an overriding
undef.  Either way the identifier is no longer a deferred macro.
Notice it is now possible for NT_MACRO nodes to have a NULL macro
expansion.

libcpp/
* include/cpplib.h (struct cpp_hashnode): Add deferred field.
(cpp_set_deferred_macro): Define.
(cpp_get_deferred_macro): Declare.
(cpp_macro_definition): Reformat, add overload.
(cpp_macro_definition_location): Deal with deferred macro.
(cpp_alloc_token_string, cpp_compare_macro): Declare.
* internal.h (_cpp_notify_macro_use): Return bool
(_cpp_maybe_notify_macro_use): Likewise.
* directives.c (do_undef): Check macro is not undef before
warning.
(do_ifdef, do_ifndef): Deal with deferred macro.
* expr.c (parse_defined): Likewise.
* lex.c (cpp_allocate_token_string): Break out of ...
(create_literal): ... here.  Call it.
(cpp_maybe_module_directive): Deal with deferred macro.
* macro.c (cpp_get_token_1): Deal with deferred macro.
(warn_of_redefinition): Deal with deferred macro.
(compare_macros): Rename to ...
(cpp_compare_macro): ... here.  Make extern.
(cpp_get_deferred_macro): New.
(_cpp_notify_macro_use): Deal with deferred macro, return bool
indicating definedness.
(cpp_macro_definition): Deal with deferred macro.

aarch64: Fix aapcs64 testsuite failures

Various aapcs64 tests were failing at -O1 and above because
the assignments to testfunc_ptr were being deleted as dead.
That in turn happened because FUNC_VAL_CHECK hid the tail call
to myfunc using an LR asm trick:

    asm volatile ("mov %0, x30" : "=r" (saved_return_address));
    asm volatile ("mov x30, %0" : : "r" ((unsigned long long) myfunc));

and so the compiler couldn't see any calls that might read
testfunc_ptr.

That in itself could be fixed by adding a memory clobber to the
second asm above, forcing the compiler to keep both the testfunc_ptr
and the saved_return_address assignments.  But since this is an ABI
test, it seems better to make sure that we don't do any IPA at all.
The fact that doing IPA caused a problem was kind-of helpful and
so it might be better to avoid making the test “work” in the
presence of IPA.

The patch therefore just replaced “noinline” with “noipa”.

gcc/testsuite/
* gcc.target/aarch64/aapcs64/abitest.h (FUNC_VAL_CHECK): Use
noipa rather than noinline.
* gcc.target/aarch64/aapcs64/abitest-2.h (FUNC_VAL_CHECK): Likewise.

libstdc++: Run all tests in file

libstdc++-v3/ChangeLog:

* testsuite/30_threads/jthread/95989.cc: Run all three test
functions, not just the first one twice.

libstdc++: Throw instead of segfaulting in std::thread constructor [PR 67791]

This turns a mysterious segfault into an exception with a more useful
message. If the exception isn't caught, the user sees this instead of
just a segfault:

terminate called after throwing an instance of 'std::system_error'
  what():  Enable multithreading to use std::thread: Operation not permitted
Aborted (core dumped)

libstdc++-v3/ChangeLog:

PR libstdc++/67791
* src/c++11/thread.cc (thread::_M_start_thread(_State_ptr, void (*)())):
Check that gthreads is available before calling __gthread_create.

libstdc++: Use __libc_single_threaded for locale initialization

Most initialization of locales and facets happens before main() during
startup, when the program is likely to only have one thread. By using
the new __gnu_cxx::__is_single_threaded() function instead of checking
__gthread_active_p() we can avoid using pthread_once or atomics for the
common case.

That said, I'm not sure why we don't just use a local static variable
instead, as __cxa_guard_acquire() already optimizes for the
single-threaded case:

  static const bool init = (_S_initialize_once(), true);

I'll revisit that for GCC 12.

libstdc++-v3/ChangeLog:

* src/c++98/locale.cc (locale::facet::_S_get_c_locale())
(locale::id::_M_id() const): Use __is_single_threaded.
* src/c++98/locale_init.cc (locale::_S_initialize()):
Likewise.

Tweak plugin-gcn.c defines

Ensure the code will continue to compile when elf.h gets these definitions.

libgomp/ChangeLog:

* plugin/plugin-gcn.c: Don't redefine relocations if elf.h has them.
(reserved): Delete unused define.

IBM Z: Restrict vec_cmp<m><n> on z13

Commit 5d9ade39b872 ("IBM Z: Fix PR97326: Enable fp compares in
vec_cmp") made it possible to create rtxes that describe signaling
comparisons on z13, which are not supported by the hardware.  Restrict
this by using vcond_comparison_operator predicate.

gcc/ChangeLog:

2020-11-24  Ilya Leoshkevich  <iii@linux.ibm.com>

* config/s390/vector.md: Use vcond_comparison_operator
predicate.

IBM Z: Update autovec-*-quiet-uneq expectations

Commit 229752afe315 ("VEC_COND_EXPR optimizations") has improved code
generation: we no longer need "vx x,x,-1", which turned out to be
superfluous.  Instead, we simply swap 0 and -1 arguments of the
preceding "vsel".

gcc/testsuite/ChangeLog:

2020-11-23  Ilya Leoshkevich  <iii@linux.ibm.com>

* gcc.target/s390/zvector/autovec-double-quiet-uneq.c: Expect
that "vx" is not emitted.
* gcc.target/s390/zvector/autovec-float-quiet-uneq.c: Likewise.

Fix -ffast-math flags handling inconsistencies

This patch implements the following set of changes:

1. If a component flag of -ffast-math (or -funsafe-math-optimizations)
   is explicitly set (or reset) on the command line, this should override
   any implicit change due to -f(no-)fast-math, no matter in which order
   the flags come on the command line.  This change affects all flags.

2. Any component flag modified from its default by -ffast-math should
   be reset to the default by -fno-fast-math.  This was previously
   not done for the following flags:
      -fcx-limited-range
      -fexcess-precision=

3. Once -ffinite-math-only is true, the -f(no-)signaling-nans flag has
   no meaning (if we have no NaNs at all, it does not matter whether
   there is a difference between quiet and signaling NaNs).  Therefore,
   it does not make sense for -ffast-math to imply -fno-signaling-nans.
   (This is also a documentation change.)

4. -ffast-math is documented to imply -fno-rounding-math, however the
   latter setting is the default anyway; therefore it does not make
   sense to try to modify it from its default setting.

5. The __FAST_MATH__ preprocessor macro should be defined if and only
   if all the component flags of -ffast-math are set to the value that
   is documented as the effect of -ffast-math.  The following flags
   were currently *not* so tested:
     -fcx-limited-range
     -fassociative-math
     -freciprocal-math
     -frounding-math
   (Note that we should still *test* for -fno-rounding-math here even
   though it is not set as to 4.  -ffast-math -frounding-math should
   not set the __FAST_MATH__ macro.)
   This is also a documentation change.

2020-11-24  Ulrich Weigand  <uweigand@de.ibm.com>

gcc/

* doc/invoke.texi (-ffast-math): Remove mention of -fno-signaling-nans.
Clarify conditions when __FAST_MATH__ preprocessor macro is defined.

* opts.c (common_handle_option): Pass OPTS_SET to set_fast_math_flags
and set_unsafe_math_optimizations_flags.
(set_fast_math_flags): Add OPTS_SET argument, and use it to avoid
setting flags already explicitly set on the command line.  In the !set
case, also reset x_flag_cx_limited_range and x_flag_excess_precision.
Never reset x_flag_signaling_nans or x_flag_rounding_math.
(set_unsafe_math_optimizations_flags): Add OPTS_SET argument, and use
it to avoid setting flags already explicitly set on the command line.
(fast_math_flags_set_p): Also test x_flag_cx_limited_range,
x_flag_associative_math, x_flag_reciprocal_math, and
x_flag_rounding_math.

[Ada] Fix inconsistent parameter of SPARK_Msg_NE

gcc/ada/

* sem_prag.adb (Analyze_Global_Item): Call SPARK_Msg_NE with the
entity, not with its identifier.

[Ada] Cannot process -S -o with GNAT LLVM

gcc/ada/

* opt.ads (Generate_Asm): New flag.
* osint-c.adb (Set_Output_Object_File_Name): Accept any
extension when generating assembly.
* adabkend.adb (Scan_Compiler_Args): Recognize -S.

[Ada] Reuse Is_Packed_Array where possible

gcc/ada/

* exp_attr.adb, exp_ch4.adb, exp_intr.adb, sem_ch8.adb,
sem_res.adb, sem_type.adb, sem_util.adb: Reuse Is_Packed_Array.

[Ada] Fix minor typos in comments

gcc/ada/

* checks.adb (Apply_Access_Check): Remove unbalanced paren.
* exp_attr.adb (Expand_N_Attribute_Reference): Fix typo in
comment.

[Ada] Compiler crash on assertion pragma in ghost region

gcc/ada/

* sem_prag.adb (Analyze_Pragma): Mark relevant pragmas as ghost
when they are within a ghost region.

[Ada] Reuse In_Same_List where possible

gcc/ada/

* contracts.adb, freeze.adb, sem_ch12.adb, sem_prag.adb: Reuse
In_Same_List.

[Ada] Simplify Is_Loop_Pragma

gcc/ada/

* sem_prag.adb (Is_Loop_Pragma): Avoid repeated calls to
Original_Node; remove unnecessary IF statement.

[Ada] Replace chained if-then-elsif with case stmt for attribute ids

gcc/ada/

* exp_spark.adb (Expand_SPARK_N_Attribute_Reference): Rewrite
with a CASE statement.

[Ada] Cleanup expansion of attribute Constrained

gcc/ada/

* exp_attr.adb (Expand_N_Attribute_Reference): Replace calls to
Sloc with a local constant Loc; remove call to
Analyze_And_Resolve and return, which is exactly what happens
anyway (and other branches in the Constrained declare block
appear to rely on analysis, resolution and returning happening
in all cases).
* sem_util.adb: Remove useless parens.

[Ada] Recognize delta and extension aggregates as objects

gcc/ada/

* sem_util.adb (Is_Object_Reference): Delta and extension
aggregates are objects.

[Ada] Implement No_Unrecognized_{Aspects,Pragmas} restrictions

gcc/ada/

* libgnat/s-rident.ads (System.Rident): Register new restriction
IDs.
* par-ch13.adb (Get_Aspect_Specifications): Add restriction check.
* par-prag.adb (Process_Restrictions_Or_Restriction_Warnings):
Register No_Unrecognized_Aspects restriction.
* sem_prag.adb (Analyze_Pragma): Add restriction check.
* snames.ads-tmpl: Create restriction names.

[Ada] Accept local objects in the prefix of attribute Loop_Entry

gcc/ada/

* sem_attr.adb (Declared_Within): Return True for objects
declared within the attribute Loop_Entry prefix itself.

[Ada] Fix crash in GNATprove on inlined subprogram in default expression

gcc/ada/

* sem_ch3.adb (Process_Discriminants): Correctly set right
context for analyzing default value of discriminant.

[Ada] Wrong resolution of universal_access = operators

gcc/ada/

* sem_type.adb (Add_One_Interp.Is_Universal_Operation): Account
for universal_access = operator.
(Disambiguate): Take into account preference on universal_access
= operator when relevant.
(Disambiguate.Is_User_Defined_Anonymous_Access_Equality): New.

[Ada] Premature finalization on build in place return and case expression

gcc/ada/

* exp_util.adb (Is_Finalizable_Transient): Take into account return
statements containing N_Expression_With_Actions. Also clean up a
condition to make it more readable.
* exp_ch6.adb: Fix typo.

[Ada] Small cleanup in the Ada.Text_IO hierarchy

gcc/ada/

* libgnat/a-wtdeio.adb (TFT): Delete and adjust throughout.
* libgnat/a-wtenau.adb (TFT): Likewise.
* libgnat/a-wtfiio.adb (TFT): Likewise.
* libgnat/a-wtflio.adb (TFT): Likewise.
* libgnat/a-wtinio.adb (TFT): Likewise.
* libgnat/a-wtinio__128.adb (TFT): Likewise.
* libgnat/a-wtmoio.adb (TFT): Likewise.
* libgnat/a-wtmoio__128.adb (TFT): Likewise.
* libgnat/a-ztdeio.adb (TFT): Likewise.
* libgnat/a-ztenau.adb (TFT): Likewise.
* libgnat/a-ztfiio.adb (TFT): Likewise.
* libgnat/a-ztflio.adb (TFT): Likewise.
* libgnat/a-ztinio.adb (TFT): Likewise.
* libgnat/a-ztinio__128.adb (TFT): Likewise.
* libgnat/a-ztmoio.adb (TFT): Likewise.
* libgnat/a-ztmoio__128.adb (TFT): Likewise.

[Ada] AI12-0394 Named Numbers and User-Defined Numeric Literals

gcc/ada/

* sem_ch13.adb (Validate_Literal_Aspect): Add support for named
numbers and in particular overload of the Real_Literal function.
* sem_res.adb (Resolve): Add support for named numbers in
Real_Literal and Integer_Literal resolution.
* einfo.adb, einfo.ads (Related_Expression,
Set_Related_Expression): Allow E_Function.
* uintp.ads (UI_Image_Max): Bump size of buffer to avoid loosing
precision.
* sem_eval.adb: Fix typo in comment.
* libgnat/a-nbnbin.adb, libgnat/a-nbnbin.ads (From_String):
Return a Valid_Big_Integer.
* libgnat/a-nbnbre.adb, libgnat/a-nbnbre.ads (From_String): New
variant taking two strings. Return a Valid_Big_Real.

[Ada] Fix internal error on multiple nested instantiations

gcc/ada/

* sem_ch12.adb (Analyze_Associations) <Explicit_Freeze_Check>: Test
that the instance is in a statement sequence instead of local scope.
(Freeze_Subprogram_Body): Use the special delayed placement with
regard to the parent instance only if its Sloc is strictly greater.
(Install_Body): Likewise.

[Ada] Fix String_Literal aspect spec checking problem for scalars.

gcc/ada/

* sem_ch13.adb (Validate_Literal_Aspect): Call to Base_Type
needed in order to correctly check result type of String_Literal
function when the first named subtype differs from the base
type (e.g.:
type T is range 1 .. 10 with String_Literal => ... ;
).

[Ada] Handle correctly current instance of PO in local subprogram Global

gcc/ada/

* sem_prag.adb (Analyze_Global_Item): Handle specially the
current instance of a PO.
* sem_util.ads (Is_Effectively_Volatile,
Is_Effectively_Volatile_For_Reading): Add parameter
Ignore_Protected.
* sem_util.adb (Is_Effectively_Volatile,
Is_Effectively_Volatile_For_Reading): Add parameter
Ignore_Protected to compute the query results ignoring protected
objects/types.
(Is_Effectively_Volatile_Object,
Is_Effectively_Volatile_Object_For_Reading): Adapt to new
signature.

[Ada] Documentation: update -gnatyk description

gcc/ada/

* doc/gnat_ugn/building_executable_programs_with_gnat.rst:
Update documentation on -gnatyk.
* gnat_ugn.texi: Regenerate.

[Ada] Fix spurious error on child library-level subprogram with aspects

gcc/ada/

* sem_ch10.adb (Analyze_Compilation_Unit): Move aspects from
body to the newly created spec.

[Ada] Wrong finalization in call with if expression

gcc/ada/

* exp_ch6.adb (Add_Cond_Expression_Extra_Actual): Simplify
handling of function calls and remove bug in handling of
transient objects.  Minor reformatting along the way.

[Ada] Implement Big_Integer.From_String fully

gcc/ada/

* libgnat/a-nbnbin.adb (From_String): Implement fully.

[Ada] Fix resolution of subtype_indication in delta aggregates

gcc/ada/

* sem_aggr.adb (Resolve_Delta_Array_Aggregate): If the choice is
a subtype_indication then call
Resolve_Discrete_Subtype_Indication; both for choices
immediately inside array delta aggregates and inside
iterated_component_association within array delta aggregates.

[Ada] Use high-level Present instead of low-level equality test

gcc/ada/

* lib-load.adb, lib-writ.adb, lib.adb, par-load.adb,
rtsfind.adb, sem_ch10.adb: Use Present where possible.

[Ada] Reject Global/Depends contracts on null procedures

gcc/ada/

* sem_prag.adb (Analyze_Depends_Global): Reject Global and
Depends on null procedure.

[Ada] Wrong handling of _ in Big_Reals.From_String

gcc/ada/

* libgnat/a-nbnbre.adb (From_String): Handle properly '_'
characters.

[Ada] Remove SPARK-specific expansion of array aggregates

gcc/ada/

* exp_spark.adb (Expand_SPARK_Array_Aggregate,
Expand_SPARK_N_Aggregate): Remove, no longer needed.
* sem_aggr.adb (Resolve_Iterated_Component_Association): Only
remove references in the analyzed expression when generating
code and the expression needs to be analyzed anew after being
rewritten into a loop.

[Ada] Document characteristics of decimal fixed point types

gcc/ada/

* doc/gnat_rm/implementation_defined_characteristics.rst: Complete
entry of 3.5.9(10).
* gnat_rm.texi: Regenerate.

i386: Add *setcc_hi_1* define_insn_and_split [PR97950]

As the following testcase shows, unlike char, int or long long sized
__builtin_*_overflow{,_p}, for short sized one in most cases the ce1 pass
doesn't optimize the jo/jno or jc/jnc jumps with setting of a pseudo to 0/1
into seto/setc.  The reason is missing *setcc_hi_1* pattern.  The following
patch implements it using mode iterators so that on i486 and pentium?
one can get the zero extension through and instead of movzbw.

2020-11-24  Jakub Jelinek  <jakub@redhat.com>

PR target/97950
* config/i386/i386.md (*setcc_si_1_and): Macroize into...
(*setcc_<mode>_1_and): New define_insn_and_split with SWI24 iterator.
(*setcc_si_1_movzbl): Macroize into...
(*setcc_<mode>_1_movzbl): New define_insn_and_split with SWI24
iterator.

* gcc.target/i386/pr97950.c: New test.

middle-end: Prefer no RMW in __builtin_clear_padding implementation where possible

Currently the __builtin_clear_padding expansion code emits no code for
full words that don't have any padding bits, and most of the time if
the only padding bytes are from the start of the word it attempts to merge
them with previous padding store (via {}) or if the only padding bytes are
from the end of the word, it attempts to merge it with following padding
bytes.  For everything else it was using a RMW, except when it found
an aligned char/short/int covering all the padding bytes and all those
padding bytes were all ones in that store.

The following patch changes it, such that we only use RMW if the padding has
any bytes which have some padding and some non-padding bits (i.e. bitfields
are involved), often it is the same amount of instructions in the end and
avoids being thread-unsafe unless necessary (and avoids having to wait for
the reads to make it into the CPU).  So, if there are no bitfields,
the function will just store some zero bytes, shorts, ints, long longs etc.
where needed.

2020-11-24  Jakub Jelinek  <jakub@redhat.com>

* gimple-fold.c (clear_padding_flush): If a word contains only 0
or 0xff bytes of padding other than all set, all clear, all set
followed by all clear or all clear followed by all set, don't emit
a RMW operation on the whole word or parts of it, but instead
clear the individual bytes of padding.  For paddings of one byte
size, don't use char[1] and {}, but instead just char and 0.

testsuite: Add testcase for already fixed bug [PR97964]

This testcase started failing with r8-2090 and works again starting
with r11-4755.

2020-11-24  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/97964
* gcc.dg/tree-ssa/pr97964.c: New test.

More explicit checking of which OMP constructs we're expecting, part II

In particular, more precisely highlight what applies generally vs. the special
handling for the current 'parloops'-based OpenACC 'kernels' implementation.

gcc/
* omp-expand.c (expand_oacc_for): More explicit checking of which
OMP constructs we're expecting.

[testsuite] Avoid Tcl 8.5-specific behavior

gcc/
* doc/install.texi (Prerequisites) <Tcl>: Add comment.
gcc/testsuite/
* c-c++-common/goacc/kernels-decompose-1.c: Avoid Tcl 8.5-specific
behavior.
* c-c++-common/goacc/kernels-decompose-2.c: Likewise.
* gfortran.dg/goacc/kernels-decompose-1.f95: Likewise.
* gfortran.dg/goacc/kernels-decompose-2.f95: Likewise.
libgomp/
* testsuite/libgomp.oacc-c-c++-common/kernels-decompose-1.c: Avoid
Tcl 8.5-specific behavior.
* testsuite/libgomp.oacc-fortran/pr94358-1.f90: Likewise.

Reported-by: David Edelsohn <dje.gcc@gmail.com>

[testsuite] Emit 'warning' instead of 'error' diagnostics for 'dg-optimized', 'dg-missed'

The diagnostics produced by 'dg-optimized', 'dg-missed' aren't error
diagnostics (fatal, meaning: causes compilation to fail) but rather warning
diagnostics (non-fatal, doesn't cause compilation to fail).  Thus, same as
'dg-message', these should use 'saved-dg-warning' instead of 'saved-dg-error',
which then prints: "(test for *warnings*, line [...]) instead of currently:
"(test for *errors*, line [...])".

This is a small bug-fix for commit ed2d9d3720adef3a260b8a55e17e744352a901fc
"dumpfile.c: use prefixes other than 'note: ' for
MSG_{OPTIMIZED_LOCATIONS|MISSED_OPTIMIZATION}", which added 'dg-optimized',
'dg-missed'.

gcc/testsuite/
* lib/gcc-dg.exp (dg-optimized, dg-missed): Use 'saved-dg-warning'
instead of 'saved-dg-error'.

[testsuite] Enable column location checking for 'dg-optimized', 'dg-missed'

'process-message' would like the 'msgprefix' argument without trailing space.

This is a small bug-fix for commit ed2d9d3720adef3a260b8a55e17e744352a901fc
"dumpfile.c: use prefixes other than 'note: ' for
MSG_{OPTIMIZED_LOCATIONS|MISSED_OPTIMIZATION}", which added 'dg-optimized',
'dg-missed'.

gcc/testsuite/
* lib/gcc-dg.exp (dg-optimized, dg-missed): Fix 'process-message'
call.
* gcc.dg/vect/nodump-vect-opt-info-1.c: Demonstrate.
* gcc.dg/vect/nodump-vect-opt-info-2.c: Likewise.

openmp: Fix C ICE on OpenMP atomics

c_parser_binary_expression was using build2 to create a temporary holder
for binary expression that c_parser_atomic and c_finish_omp_atomic can then
handle.  The latter performs then all the needed checking.

Unfortunately, build2 performs some checking too, e.g. PLUS_EXPR vs.
POINTER_PLUS_EXPR or matching types of the arguments, nothing we can guarantee
at the parsing time.  So we need something like C++ build_min_nt*.  This
patch implements that inline.

2020-11-24  Jakub Jelinek  <jakub@redhat.com>

PR c/97958
* c-parser.c (c_parser_binary_expression): For omp atomic binary
expressions, use make_node instead of build2 to avoid checking build2
performs.

* c-c++-common/gomp/pr97958.c: New test.

middle-end, c++: Treat shifts by negative as undefined [PR96929]

The PR38359 change made the -1 >> x to -1 optimization less useful by
requiring that the x must be non-negative.
Shifts by negative amount are UB, but we for historic reasons had in some
(but not all) places some hack to treat shifts by negative value as the
other direction shifts by the negated amount.

The following patch just removes that special handling, instead we punt on
optimizing those (and ideally path isolation should catch that up and turn
those into __builtin_unreachable, perhaps with __builtin_warning next to
it).  Folding the shifts in some places as if they were rotates and in other
as if they were saturating just leads to inconsistencies.

For C++ constexpr diagnostics and -fpermissive, I've added code to pretend
fold-const.c has not changed, without -fpermissive it will be an error
anyway and I think it is better not to change all the diagnostics.

During x86_64-linux and i686-linux bootstrap/regtest, my statistics
gathering patch noted 185 unique -m32/-m64 x TU x function_name x shift_kind
x fold-const/tree-ssa-ccp cases.  I have investigated the
64 ../../gcc/config/i386/i386.c x86_output_aligned_bss LSHIFT_EXPR wide_int_bitop
64 ../../gcc/config/i386/i386-expand.c emit_memmov LSHIFT_EXPR wide_int_bitop
64 ../../gcc/config/i386/i386-expand.c ix86_expand_carry_flag_compare LSHIFT_EXPR wide_int_bitop
64 ../../gcc/expmed.c expand_divmod LSHIFT_EXPR wide_int_bitop
64 ../../gcc/lra-lives.c process_bb_lives LSHIFT_EXPR wide_int_bitop
64 ../../gcc/rtlanal.c nonzero_bits1 LSHIFT_EXPR wide_int_bitop
64 ../../gcc/varasm.c optimize_constant_pool.isra LSHIFT_EXPR wide_int_bitop
cases and all of them are either during jump threading (dom) or during PRE.
For jump threading, the most common case is 1 << floor_log2 (whatever) where
floor_log2 is return HOST_BITS_PER_WIDE_INT - 1 - clz_hwi (x);
and clz_hwi is if (x == 0) return HOST_BITS_PER_WIDE_INT; return __builtin_clz* (x);
and so has range [-1, 63] and a comparison against == 0 which makes the
threader think it might be nice to jump thread the case leading to 1 << -1.
I think it is better to keep the 1 << -1 s in the IL for this and let path
isolation turn that into __builtin_unreachable () if the user wishes so.

2020-11-24  Jakub Jelinek  <jakub@redhat.com>

PR tree-optimization/96929
* fold-const.c (wide_int_binop) <case LSHIFT_EXPR, case RSHIFT_EXPR>:
Return false on negative second argument rather than trying to handle
it as shift in the other direction.
* tree-ssa-ccp.c (bit_value_binop) <case LSHIFT_EXPR,
case RSHIFT_EXPR>: Punt on negative shift count rather than trying
to handle it as shift in the other direction.
* match.pd (-1 >> x to -1): Remove tree_expr_nonnegative_p check.

* constexpr.c (cxx_eval_binary_expression): For shifts by constant
with MSB set, emulate older wide_int_binop behavior to preserve
diagnostics and -fpermissive behavior.

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

Fix expected output after recent changes

gcc/testsuite
* gcc.dg/tree-ssa/pr23401.c: Update expected output.
* gcc.dg/tree-ssa/pr27810.c: Update expected output.
* gcc.dg/tree-ssa/slsr-8.c: Update expected output.

test: Update some cases for vect_partial_vectors_usage_1

Commit r11-3393 improved the epilogue loop handling of partial
vectors and we won't use partial vectors to vectorize a single
iteration scalar loop any more.

The affected test cases have only one single iteration in their
epilogues, so we shouldn't expect the vectorization with
partial vector there.

Tested with explicit --param=vect-partial-vector-usage=1 and
default enablement.

gcc/testsuite/ChangeLog:

* gcc.dg/vect/slp-perm-1.c: Adjust for partial vectors.
* gcc.dg/vect/slp-perm-5.c: Likewise.
* gcc.dg/vect/slp-perm-6.c: Likewise.
* gcc.dg/vect/slp-perm-7.c: Likewise.

tree-opt: Fix segfault in tree-if-conv.c with -march=armv8.2-a+sve [PR97849]

The issue here is that rpo vn may eliminate target ssa_name referred to in
redundant_ssa_names, and thus ifcvt_local_dce may replace candidate
ssa_name with invalid ssa_name resulting in incorrect IR. The patch simply
does ssa_name replacement before calling do_rpo_vn, which fixes the issue.

gcc/
2020-11-24  Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

PR tree-optimization/97849
* tree-if-conv.c (tree_if_conversion): Move ssa_name
replacement code from ifcvt_local_dce to this function
before calling do_rpo_vn.

gcc/testsuite/
2020-11-24  Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>

PR tree-optimization/97849
* gcc.dg/tree-ssa/pr97849.c: New test.

Dump type attributes in dump_function_to_file.

gcc/ChangeLog:

* tree-cfg.c (dump_function_to_file): Print type attributes
and return type.

gcc/testsuite/ChangeLog:
* gcc.dg/attr-access-5.c: New test.

Daily bump.

c: Allow comparison of pointers to complete and incomplete types for C11 [PR95630]

As noted in bug 95630, C11 removed a restriction in C99 on comparing
pointers to compatible complete and incomplete types (this was one of
the changes in N1439, which was largely a terminological change to
make incomplete types a subset of object types rather than a different
kind of type).  Implement that change by using pedwarn_c99 with
OPT_Wpedantic for this diagnostic.

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

gcc/c/
2020-11-23  Joseph Myers  <joseph@codesourcery.com>

PR c/95630
* c-typeck.c (build_binary_op): Use pedwarn_c99 with OPT_Wpedantic
for comparisons of complete and incomplete pointers.

gcc/testsuite/
2020-11-23  Joseph Myers  <joseph@codesourcery.com>

PR c/95630
* gcc.dg/c11-compare-incomplete-1.c,
gcc.dg/c11-compare-incomplete-2.c,
gcc.dg/c99-compare-incomplete-1.c,
gcc.dg/c99-compare-incomplete-2.c: New tests.