Improved constant folding for scalar evolution.

This patch adds a small (follow-up) optimization to chrec_apply for
linear chrecs to clean-up the final value expressions sometimes generated
by GCC's scalar evolution pass.  The transformation of A+(X-1)*A into
A*X is usually unsafe with respect to overflow (see PR92712), and so
can't be performed by match.pd (or fold-const).  However, during scalar
evolution's evaluation of recurrences it's known that X-1 can't be negative
(in fact X-1 is unsigned even when A is signed), hence this optimization
can be applied.  Interestingly, this expression does get simplified in
later passes once the range of X-1 is bounded by VRP, but that occurs
long after the decision of whether to perform final value replacement,
which is based on the complexity of this expression.

The motivating test case is the optimization of the loop (from comment

int square(int x) {
  int result = 0;
  for (int i = 0; i < x; ++i)
    result += x;
  return result;
}

which is currently optimized, with final value replacement to:

  final value replacement:
   with expr: (int) ((unsigned int) x_3(D) + 4294967295) * x_3(D) + x_3(D)

but with this patch it first gets simplified further:

  final value replacement:
   with expr: x_3(D) * x_3(D)

2022-05-10  Roger Sayle  <roger@nextmovesoftware.com>

gcc/ChangeLog
* tree-chrec.cc (chrec_apply): Attempt to fold the linear chrec
"{a, +, a} (x-1)" as "a*x", as the number of loop iterations, x-1,
can't be negative.

gcc/testsuite/ChangeLog
* gcc.dg/tree-ssa/pr65855-2.c: New test case.

[Ada] Export Is_Expression_Function predicate for use in gigi

gcc/ada/

* fe.h (Is_Expression_Function): Declare.
* sem_util.ads (Is_Expression_Function): Add warning line.

[Ada] Optimize nonstandard boolean validity checking

Validity checking of enumerations with nonstandard representation
starts by checking the value range, then calling _rep_to_pos to verify
that the value itself is valid. The value range check is thus
redundant and inefficient: the _rep_to_pos call is normally inlined
when optimizing for speed and the range check slows down the fast
path; it is unnecesary and undesirable when optimizing for size, and
just unnecessary when not optimizing. This patch thus drops the range
check for nonstandard boolean types.

gcc/ada/

* exp_attr.adb (Expand_N_Attribute_Reference) <Attribute_Valid>:
Drop redundant range check for nonstandard booleans.

[Ada] Optimize nonstandard boolean conversions

This patch improves the generated code for nonstandard boolean types.

One of the improvements extends the code that avoids converting back
to the nonstandard boolean type an expression computed as standard
boolean, when it will be converted to a(nother) nonstandard boolean
type.

The other improvement involves using the literal representation
constants in an If_Expression instead of dereferencing the T'Val array
when converting to a (nonstandard) boolean type. Avoiding the array
dereference enables the compiler middle-end to propagate the constants
and perform optimizations based on them, to the point of obviating the
improvement above.

Unfortunately, the code generated with this alternate expansion tends
to be slightly larger if it turns out to not enable any further
optimization, though it's most certainly faster, especially on targets
with conditional moves, more so if "store flag" is slow, as on x86.
Still, the array dereference is more straightforward and shorter, so
I've arranged for this alternate expansion to be used only when
optimizing for speed.

gcc/ada/

* exp_util.adb (Adjust_Result_Type): Leave result in
Standard.Boolean if it's going to be converted to another
boolean type.
* exp_ch4.adb (Expand_N_Type_Conversion): When optimizing,
convert to nonstandard booleans with an if_expression with
boolean literals.

[Ada] Handle non-standard booleans in if_expression condition

We failed to call Adjust_Condition for the condition expression of an
if_expression, so non-standard booleans were expanded like standard
booleans, disregarding representation clauses. Fixed.

gcc/ada/

* exp_ch4.adb (Expand_N_If_Expression): Call Adjust_Condition to
handle non-standard booleans.

[Ada] Incorrect ineffective use type clause warning

This patch fixes an issue in the compiler whereby a use_type_clause
incorrectly gets flagged as ineffective when the use of it comes after a
generic package instantiation where the installation of private use
clauses are required and one such clause references the same type.

gcc/ada/

* sem_ch8.adb (Use_One_Type): Remove code in charge of setting
Current_Use_Clause when Id is known to be redundant, and modify
the printing of errors associated with redundant use type
clauses so that line number gets included in more cases.

[Ada] Simplify call to overloaded Earlier_In_Extended_Unit

We have two variants of Earlier_In_Extended_Unit that take either
Node_Id or Source_Ptr values. The caller can simply use another variant
and not explicitly convert parameters.

Code cleanup; semantics is unaffected.

gcc/ada/

* sem_warn.adb (Check_Unset_Reference): Use variant of
Earlier_In_Extended_Unit that calls Sloc internally.

[Ada] Remove repeated conversions between Source_Ptr and Int

Both Source_Ptr and Int are integer types (and even happen to have equal
ranges). Their values can be calculated without converting
back-and-forth, e.g.:

  Int (Loc1) - Int (Loc2)

can be written simply as:

  Int (Loc1 - Loc2)

Code cleanup related to handling of references to unset objects.
Offending occurrences found with various invocations of grep.

gcc/ada/

* par-ch10.adb, scng.adb, sem_res.adb, sinfo-utils.adb,
treepr.adb: Simplify calculations with Source_Ptr and Loc
values.

[Ada] Fix style in resolution of expression with actions

gcc/ada/

* sem_res.adb (Resolve_Expression_With_Actions): Fix style in
nested routines.

[Ada] Reuse Is_Rewrite_Substitution where possible

Replace comparisons of Original_Node with semantically equivalent but
high-level calls to Is_Rewrite_Substitution. Offending occurrences found
with:

  $ grep -n "Original_Node (\([A-Za-z_]\+\)) /\?= \1" *.adb

Code cleanup only; semantics is unaffected.

gcc/ada/

* atree.adb, exp_ch6.adb, exp_ch9.adb, ghost.adb, sem_ch3.adb,
sem_ch4.adb, sem_res.adb, sem_util.adb: Use
Is_Rewrite_Substitution where possible.

[Ada] Cleanup detection of No_Elist with No and Present

Replace equality and inequality operators with calls to No and Present.
Offending occurrences found with:

$ grep -n " /\?= No_Elist" *.adb

Code cleanup only; semantics is unaffected.

gcc/ada/

* exp_ch11.adb, exp_ch5.adb, exp_prag.adb, gnat_cuda.adb,
sem_ch12.adb, sem_ch3.adb, sem_ch6.adb, sem_util.adb,
treepr.adb: Replace /= and = operators with No and Present,
respectively.

[Ada] Prevent search for references in postconditions from going too far

Add a standard prevention against climbing the entire compilation unit.
Cleanup only; behaviour of the compiler is unaffected.

gcc/ada/

* sem_warn.adb (Within_Postcondition): Guard against search
going too far.

[Ada] Remove tiny and incomplete optimization for unset references

Code cleanup; behaviour is unaffected.

gcc/ada/

* sem_warn.adb (Check_Unset_Reference): The early test was only
saving time of calls to Original_Node, Comes_From_Source and
Nkind, which are all quick and cheap.

[Ada] Cleanup unnecessary declare block in Check_Unreachable_Code

Cleanup related to static detection of references to uninitialized
variables. Semantics is unaffected.

gcc/ada/

* sem_ch5.adb (Check_Unreachable_Code): Remove inner declare
block; refill code and comments.

[Ada] Refine iteration from entities to formals

When matching formal parameters from spec and body it is cleaner and
more efficient to iterate with First_Formal/Next_Formal and not with
First_Entity/Next_Entity. The previous iteration could unintentionally
pick entities from within the subprogram body, e.g. objects declared
within the subprogram.

gcc/ada/

* sem_ch6.adb (Analyze_Subprogram_Body_Helper): Replace
First_Entity/Next_Entity with First_Formal/Next_Formal; rename
E1/E2 to F1/F2.

[Ada] Check declare and qualified expressions for unset references

Detection of references to unset (uninitialized) objects requires calls
to Check_Unset_Reference on every subexpression of a composite statement
and expression. For declare and qualified expressions this was done only
when they occurred within another composite statement/expression.

gcc/ada/

* sem_res.adb (Resolve_Declare_Expression): Check expression for
references to unset objects.
(Resolve_Qualified_Expression): Likewise.
* sem_warn.adb (Check_Unset_Reference): Remove handling of
declare and qualified expressions; clarify comment for type
conversions.

[Ada] Check if- and case-expressions for unset references

Detection of references to unset (uninitialized) objects requires calls
to Check_Unset_Reference on every subexpression of a composite statement
and expression. This was missing for if-expressions and incomplete for
case-expressions.

gcc/ada/

* sem_res.adb (Resolve_Case_Expression): Check alternative
expressions for references to unset objects.
(Resolve_If_Expression): Check condition, then and else
expressions for references to unset objects.

[Ada] Fix a couple of typos

gcc/ada/

* doc/gnat_rm/implementation_defined_attributes.rst,
doc/gnat_ugn/the_gnat_compilation_model.rst: Fix typos.
* gnat_rm.texi, gnat_ugn.texi: Regenerate.

[Ada] Fix typo in comment for Is_Predicate_Static

gcc/ada/

* sem_ch13.adb (Is_Predicate_Static): Fix typo in comment.

[Ada] Fix indentation to follow uniform style across runtime units

gcc/ada/

* libgnat/s-valuei.adb: Fix indentation.
* libgnat/s-valuei.ads: Same.

[Ada] Accept Structural in aspect Subprogram_Variant and pragma Loop_Variant

Add a new form of variants to ensure termination of loops or recursive
subprograms. Structural variants correspond to objects which designate a
part of the data-structure they used to designate in the previous loop
iteration or recursive call. They only imply termination if the
data-structure is acyclic, which is the case in SPARK but not in Ada in
general. The fact that these variants are correct is only verified
formally by the proof tool and not by the compiler or dynamically at
execution like other forms of variants.

gcc/ada/

* snames.ads-tmpl: Add "Structural" as a name.
* sem_prag.adb: (Analyze_Pragma): Accept modifier "Structural"
in pragmas Loop_Variant and Subprogram_Variant. Check that items
associated to Structural occur alone in the pragma associations.
(Analyze_Subprogram_Variant_In_Decl_Part): Idem.
* exp_prag.adb (Expand_Pragma_Loop_Variant): Discard structural
variants.
(Expand_Pragma_Subprogram_Variant): Idem.

gcc/testsuite/

* gnat.dg/loopvar.adb: Update expected error message.

[Ada] Proof of System.Val_Int at gold level

gcc/ada/

* libgnat/s-valint.ads: Add SPARK_Mode and pragma to ignore
assertions in instance and add additional ghost parameters to
the instance of Value_I.
* libgnat/s-vallli.ads: Idem.
* libgnat/s-valllli.ads: Idem.
* libgnat/s-valuei.ads, libgnat/s-valuei.adb: New generic
parameters for ghost functions from System.Valueu. Add
functional contracts.

[Ada] Fix hiding of user-defined operator that is not a homograph

This adds a missing test for the presence of a homograph when applying
the RM 8.4(10) clause about the visibility of operators, and removes
resolution code made obsolete by the change.  There is also a fixlet
for a previously undetected ambiguity in the runtime.

gcc/ada/

* sem_res.adb (Resolve_Eqyality_Op): Remove obsolete code.
(Resolve_Op_Not): Likewise.
* sem_type.adb (Disambiguate): Add missing test for RM 8.4(10).
* libgnat/s-dwalin.adb (Enable_Cache): Fix ambiguity.
(Symbolic_Address): Likewise.

gcc/testsuite/

* gnat.dg/equal7.adb: Add expected error messages (code is now
illegal).

[Ada] Fix oversight for case expression in Eval_Integer_Literal

The intent of the entry test is to treat conditional expressions, that is
to say if-expression and case-expression, alike and to require that a second
condition be true for them.  But an N_Case_Expression_Alternative is not an
N_Subexpr so this second condition was short-circuited for this node.

gcc/ada/

* sem_eval.adb (Eval_Integer_Literal): Fix oversight in entry test.

[Ada] Avoid repeated conversions from Int to Char_Code

When expanding aggregates like "(others => 'x')" into strings we
repeated conversion from Int to Char_Code for every character.  Now we
convert once and use the Char_Code directly.

Cleanup related to handling characters in GNATprove counterexamples;
semantics is unaffected.

gcc/ada/

* exp_aggr.adb (Expand_N_Aggregate): Replace UI_To_Int with
UI_To_CC; replace magic literals with high-level routines that
recognise wide and wide wide characters; reorder if-then-elsif
condition, because we don't have a routine to detect wide wide
characters.

[Ada] Reject numeric literals with too big exponents

While the compiler can compute numeric literal with arbitrary large
exponents, this may take ages and is most likely a typo. Better emit an
error when we certainly expect it to take long. The chosen threshold
takes about 100s to compute.

gcc/ada/

* scng.adb (Nlit): Error on big UI_Scale.

[Ada] Replace variables with constants in expanded code for task names

Using constants instead of variables is cleaner both in human-written
and auto-generated code.

Cleanup related to handling of character values in SPARK
counterexamples, which just like the code for names of tasks create
N_Character_Literal nodes.

gcc/ada/

* exp_util.adb (Build_Task_Array_Image): Declare expanded
objects as constants.
(Build_Task_Image_Prefix): Likewise.
(Build_Task_Record_Image): Likewise.

[Ada] Fix incorrect range computation

When the type range [Lo, Hi] and the computed expression range [Lor,
Hir] are disjoint, the range-constraining logic breaks and returns an
incorrect range. For example, when Lo<Hi<Lor<Hir, it currently returns
[Lor, Hi]. Instead, return the computed range.

The current constraining logic would require returning the base type's
bounds. However, this would miss an opportunity to warn about out of
range values for some cases (e.g. when type's upper bound is equal to
base type upper bound).

The alternative of always returning the computed values, even when
ranges are intersecting, has unwanted effects (mainly useless
constraint checks are inserted) in the Enable_Overflow_Check and
Apply_Scalar_Range_Check as these bounds have a special interpretation.

gcc/ada/

* checks.adb (Determine_Range): Fix range refining.

[Ada] Failure compiling "for ... of" loop over a slice

In some cases involving a "for ... of" loop (not to be confused with the
more common "for ... in" loop) iterating over a slice, compilation would
fail with an internal compiler error.

gcc/ada/

* sem_util.adb (Get_Actual_Subtype): If a new subtype is built,
do not freeze it if Expander_Active is False. The idea here is
to avoid generating an unwanted Freeze_Node for a subtype that
has been conjured up solely for purposes of preanalysis.

[Ada] Fix comment about building names in task arrays

Cleanup related to handling of character values in SPARK
counterexamples, which just like the code for names in task arrays
create N_Character_Literal nodes.

gcc/ada/

* exp_util.adb (Build_Task_Array_Image): Fix style in the
structure of generated code; add Pref'Length as the component of
the Sum initialization expression.

[Ada] Simplify conversion from Character to Char_Code

Replace "Char_Code (Character'Pos (...))" with "Get_Char_Code (...)".
The Get_Char_Code routine is inlined, so there is no performance penalty
when it is called with static actual parameters.

The N_Character_Literal has field Char_Literal_Value of type Unat, but
we should really only store there values from Char_Code type (e.g. there
are no characters with negative ASCII codes). It seems cleaner to use
UI_From_CC and not a more general UI_From_Int when setting the character
literal values.

Cleanup related to handling of character values in SPARK
counterexamples, which just like the code for names in task arrays
create N_Character_Literal nodes.

gcc/ada/

* exp_prag.adb (Expand_Pragma_Import_Or_Interface): Use
Get_Char_Code.
* exp_util.adb (Build_Task_Array_Image): Simplify conversion to
Char_Code.
(Build_Task_Image_Prefix): Likewise.
(Build_Task_Record_Image): Likewise.
* cstand.adb (Create_Standard): Use UI_From_Int instead of
UI_From_CC.
* exp_ch11.adb (Expand_N_Exception_Declaration): Likewise.
* sem_res.adb (Patch_Up_Value): Likewise.
* stringt.adb (Write_String_Table_Entry): Use Get_Char_Code.

Fix internal error with vectorization on SPARC

This is a regression present since the 10.x series, but the underlying issue
has been there since the TARGET_VEC_PERM_CONST hook was implemented, in the
form of an ICE when expanding a constant VEC_PERM_EXPR in V4QI, while the
back-end only supports V8QI constant VEC_PERM_EXPRs.

gcc/
PR target/105292
* config/sparc/sparc.cc (sparc_vectorize_vec_perm_const): Return
true only for 8-byte vector modes.

gcc/testsuite/
* gcc.target/sparc/20220510-1.c: New test.

middle-end/70090: Dynamic sizes for -fsanitize=object-size

Use __builtin_dynamic_object_size to get object sizes for ubsan.

gcc/ChangeLog:

PR middle-end/70090
* ubsan.cc (ubsan_expand_objsize_ifn): Allow non-constant SIZE.
(instrument_object_size): Get dynamic object size expression.

gcc/testsuite/ChangeLog:

PR middle-end/70090
* gcc.dg/ubsan/object-size-dyn.c: New test.

Signed-off-by: Siddhesh Poyarekar <siddhesh@gotplt.org>

c++: fix arm-eabi crash building libstdc++ [PR105529]

My recent change to cxx_eval_store_expression asserts that the target and
value can only end up having different types in the case of an empty base;
this was crashing arm-eabi compilers because in that ABI [cd]tors
return *this, and weren't converting it to void* first.

This also shares the 'return this' code between the three places it occurs.

Thanks to Marek for the tests.

PR c++/105529

gcc/cp/ChangeLog:

* decl.cc (maybe_return_this): Replace...
(finish_constructor_body, finish_destructor_body): ...these.
(finish_function_body): Call it.
* optimize.cc (build_delete_destructor_body): Call it.
* cp-tree.h (maybe_return_this): Declare.

gcc/testsuite/ChangeLog:

* g++.dg/cpp2a/constexpr-dtor13.C: New test.
* g++.dg/cpp2a/constexpr-dtor14.C: New test.

rs6000: avoid peeking eof after __vector

There is a rare corner case: where vector is followed only by one
valid identifer and the ";" which is near the end of the file.

Like the case in PR101168:
using vdbl =  __vector double;
#define BREAK 1

For this case, "vector double" is followed by CPP_SEMICOLON and then
EOF.  There is no more tokens need to check for this case.

PR preprocessor/101168

gcc/ChangeLog:

* config/rs6000/rs6000-c.cc (rs6000_macro_to_expand):
Avoid empty identifier.

gcc/testsuite/ChangeLog:

* g++.target/powerpc/pr101168.C: New test.

Daily bump.

Update gcc.po files

* be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po,
ja.po, nl.po, ru.po, sr.po, sv.po, tr.po, uk.po, vi.po, zh_CN.po,
zh_TW.po: Update.

c++: Implement P2324R2, labels at the end of compound-stmts [PR103539]

This patch implements C++23 <https://wg21.link/p2324r2>, which allows
labels at the end of a compound statement.   Its C FE counterpart was
already implemented in r11-4813.

In cp_parser_statement I rely on in_compound to determine whether we're
in a compound-statement, so that the patch doesn't accidentally allow

  void fn(int c) {
    if (c)
  label:
  }

Strangely, in_compound was reset after seeing a label (this is tested in
c-c++-common/gomp/pr63326.c), so I've made a modifiable copy specific
for OpenMP #pragma purposes.

PR c++/103539

gcc/cp/ChangeLog:

* parser.cc (cp_parser_statement): Constify the in_compound parameter.
Create a modifiable copy.  Allow labels at the end of compound
statements.

gcc/testsuite/ChangeLog:

* g++.dg/cpp23/label1.C: New test.
* g++.dg/cpp23/label2.C: New test.

Fortran: check for non-optional spaces between adjacent keywords

In free format, spaces between adjacent keywords are not optional except
when a combination is explicitly listed (e.g. F2018: table 6.2).  The
following combinations thus require separating blanks: CHANGE TEAM,
ERROR STOP, EVENT POST, EVENT WAIT, FAIL IMAGE, FORM TEAM, SELECT RANK,
SYNC ALL, SYNC IMAGES, SYNC MEMORY, SYNC TEAM, TYPE IS.

gcc/fortran/ChangeLog:

PR fortran/105501
* match.cc (gfc_match_if): Adjust patterns used for matching.
(gfc_match_select_rank): Likewise.
* parse.cc (decode_statement): Likewise.

gcc/testsuite/ChangeLog:

PR fortran/105501
* gfortran.dg/pr105501.f90: New test.

testsuite: Silence analyzer/pr51628-30.c for default_packed

On default_packed targets like PRU, a warning in the file included from
analyzer/pr51628-30.c is reported as spurious one, even though it has been
annotated there:

  Excess errors:
  gcc/gcc/testsuite/gcc.dg/analyzer/torture/../../../c-c++-common/pr51628-30.c:7:19: warning: 'packed' attribute ignored for field of type 'struct B' [-Wattributes]

Mark that gcc.dg/analyzer/torture/pr51628-30.c generates excess warnings
for default_packed targets.  This is safe because the original test case
covered an ICE, not a diagnostic error.

gcc/testsuite/ChangeLog:

* gcc.dg/analyzer/torture/pr51628-30.c: Test can spill excess
errors for default_packed targets.

Signed-off-by: Dimitar Dimitrov <dimitar@dinux.eu>

testsuite: Remove superfluous semicolon [PR105256]

2022-05-09  Jakub Jelinek  <jakub@redhat.com>

PR c++/105256
* g++.dg/cpp0x/pr105256.C: Remove superfluous semicolon.

i386: Adjust -fzero-call-used-regs to always use XOR [PR101891]

Currently on i386, -fzero-call-used-regs uses a pattern of:

XOR regA,regA
MOV regA,regB
MOV regA,regC
...
RET

However, this introduces both a register ordering dependency (e.g. the CPU
cannot clear regB without clearing regA first), and while greatly reduces
available ROP gadgets, it does technically leave a set of "MOV" ROP gadgets
at the end of functions (e.g. "MOV regA,regC; RET").

This patch will switch to always use XOR on i386:

XOR regA,regA
XOR regB,regB
XOR regC,regC
...
RET

gcc/ChangeLog:

PR target/101891
* config/i386/i386.cc (zero_call_used_regno_mode): use V2SImode
as a generic MMX mode instead of V4HImode.
(zero_all_mm_registers): Use SET to zero instead of MOV for
zeroing scratch registers.
(ix86_zero_call_used_regs): Likewise.

gcc/testsuite/ChangeLog:

* gcc.target/i386/zero-scratch-regs-1.c: Add -fno-stack-protector
-fno-PIC.
* gcc.target/i386/zero-scratch-regs-10.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-13.c: Add -msse.
* gcc.target/i386/zero-scratch-regs-14.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-15.c: Add -fno-stack-protector
-fno-PIC.
* gcc.target/i386/zero-scratch-regs-16.c: Likewise.
* gcc.target/i386/zero-scratch-regs-17.c: Likewise.
* gcc.target/i386/zero-scratch-regs-18.c: Add -fno-stack-protector
-fno-PIC, adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-19.c: Add -fno-stack-protector
-fno-PIC.
* gcc.target/i386/zero-scratch-regs-2.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-20.c: Add -msse.
* gcc.target/i386/zero-scratch-regs-21.c: Add -fno-stack-protector
-fno-PIC, Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-22.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-23.c: Likewise.
* gcc.target/i386/zero-scratch-regs-26.c: Likewise.
* gcc.target/i386/zero-scratch-regs-27.c: Likewise.
* gcc.target/i386/zero-scratch-regs-28.c: Likewise.
* gcc.target/i386/zero-scratch-regs-3.c: Add -fno-stack-protector.
* gcc.target/i386/zero-scratch-regs-31.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-4.c: Add -fno-stack-protector
-fno-PIC.
* gcc.target/i386/zero-scratch-regs-5.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-6.c: Add -fno-stack-protector.
* gcc.target/i386/zero-scratch-regs-7.c: Likewise.
* gcc.target/i386/zero-scratch-regs-8.c: Adjust mov to xor.
* gcc.target/i386/zero-scratch-regs-9.c: Add -fno-stack-protector.

MAINTAINERS: Update my email address

I have to change the domain name for "some unpleasant personal issue".

ChangeLog:

* MAINTAINERS: Update my email address.

c++: constexpr init of union sub-aggr w/ base [PR105491]

Here ever since r10-7313-gb599bf9d6d1e18, reduced_constant_expression_p
in C++11/14 is rejecting the marked sub-aggregate initializer (of type S)

  W w = {.D.2445={.s={.D.2387={.m=0}, .b=0}}};
                     ^
ultimately because said initializer has CONSTRUCTOR_NO_CLEARING set,
hence the function must verify that all fields of S are initialized.
And before C++17 it doesn't expect to see base class fields (since
next_initializable_field skips over them), so the presence thereof
causes r_c_e_p to return false.

The reason r10-7313-gb599bf9d6d1e18 causes this is because in that
commit we began using CONSTRUCTOR_NO_CLEARING to precisely track whether
we're in middle of activating a union member.  This ends up affecting
clear_no_implicit_zero, which recurses into sub-aggregate initializers
only if the outer initializer has CONSTRUCTOR_NO_CLEARING set.  After
that commit, the outer union initializer above no longer has the flag
set at this point and so clear_no_implicit_zero no longer recurses into
the marked inner initializer.

But arguably r_c_e_p should be able to accept the marked initializer
regardless of whether CONSTRUCTOR_NO_CLEARING is set.  The primary bug
therefore seems to be that r_c_e_p relies on next_initializable_field
which skips over base class fields in C++11/14.  To fix this, this patch
introduces a new helper function next_subobject_field which is like
next_initializable_field except that it never skips base class fields,
and makes r_c_e_p use it.  This patch then renames next_initializable_field
to next_aggregate_field (and makes it skip over vptr fields again).

PR c++/105491

gcc/cp/ChangeLog:

* call.cc (field_in_pset): Adjust after next_initializable_field
renaming.
(build_aggr_conv): Likewise.
(convert_like_internal): Likewise.
(type_has_extended_temps): Likewise.
* class.cc (default_init_uninitialized_part): Likewise.
(finish_struct): Likewise.
* constexpr.cc (cx_check_missing_mem_inits): Likewise.
(reduced_constant_expression_p): Use next_subobject_field
instead.
* cp-gimplify.cc (get_source_location_impl_type): Adjust after
next_initializable_field renaming.
(fold_builtin_source_location): Likewise.
* cp-tree.h (next_initializable_field): Rename to ...
(next_aggregate_field): ... this.
(next_subobject_field): Declare.
* decl.cc (next_aggregate_field): Renamed from ...
(next_initializable_field): ... this.  Skip over vptr fields
again.
(next_subobject_field): Define.
(reshape_init_class): Adjust after next_initializable_field
renaming.
* init.cc (build_value_init_noctor): Likewise.
(emit_mem_initializers): Likewise.
* lambda.cc (build_capture_proxy): Likewise.
* method.cc (build_comparison_op): Likewise.
* pt.cc (maybe_aggr_guide): Likewise.
* tree.cc (structural_type_p): Likewise.
* typeck2.cc (split_nonconstant_init_1): Likewise.
(digest_init_r): Likewise.

gcc/testsuite/ChangeLog:

* g++.dg/cpp0x/constexpr-union7.C: New test.
* g++.dg/cpp0x/constexpr-union7a.C: New test.
* g++.dg/cpp2a/constinit17.C: New test.

Implement permutation with pslldq + psrldq + por when pshufb is not available.

pand/pandn may be used to clear upper/lower bits of the operands, in
that case there will be 4-5 instructions for permutation, and it's
still better than scalar codes.

gcc/ChangeLog:

PR target/105354
* config/i386/i386-expand.cc
(expand_vec_perm_pslldq_psrldq_por): New function.
(ix86_expand_vec_perm_const_1): Try
expand_vec_perm_pslldq_psrldq_por for both 3-instruction and
4/5-instruction sequence.

gcc/testsuite/ChangeLog:

* gcc.target/i386/pr105354-1.c: New test.
* gcc.target/i386/pr105354-2.c: New test.

[c++][NFC] Rename Attached to Keyed

With modules, certain decls are 'scoped' with another decl.  I chose
the name 'attached', but that has become something specific in the
modules context, so is no longer a good name.  The alternative name I
considered was 'keyed', but we already had the concept of a key
virtual function (from the ABI), which is why I went with 'attached'.
However, I think 'keyed' is the less worse name.  I think there's less
chance of confusion.

gcc/cp/
* cp-tree.h (DECL_MODULE_KEYED_DECLS_P): Renamed from
DECL_MODULE_ATTACHMENTS_P.
(struct lane_decl_base): Rename module_attached_p to
module_keyed_decls_p.
(maybe_key_decl): Renamed from maybe_attach_decl.
* lambda.cc (record_lambda_scope): Adjust.
* lex.cc (cxx_dup_lang_specific_decl): Adjust.
* module.cc (keyed_map_t, keyed_table): Renamed from attached_map_t,
attached_table.
(enum merge_kind): Rename MK_attached to MK_keyed.
(trees_out::lang_decl_bools): Adjust.
(trees_in::lang_decl_bools): Adjust.
(trees_in::decl_value): Adjust.
(trees_out::get_merge_kind): Adjust.
(trees_out::key_mergeable): Adjust.
(trees_in::key_mergeable): Adjust.
(maybe_key_decl): Rename from maybe_attach_decl.
(direct_import): Adjust.
(fini_modules): Adjust.

MAINTAINERS: Update my email address.

Update my email address in the MAINTAINERS file.

ChangeLog:
2022-05-06  Clément Chigot  <chigot@adacore.com>

* MAINTAINERS: Update my email address.

Simplify STATIC_ASSERT macro.

For C++, use always __static_assert and for C, use the negative array
index.

gcc/ChangeLog:

* basic-block.h (STATIC_ASSERT): Use normal STATIC_ASSERT.
* system.h (STATIC_ASSERT): Define as static_assert for C++
and fallback to array index in C.

Remove non-ANSI C path in ansidecl.h.

include/ChangeLog:

* ansidecl.h (PTR): Remove Not ANCI C part.

tree-optimization/105517 - avoid offset truncation during VN

When value-numbering an address expression like
&p_74(D)->a1x[4294967295].a1; we are accumulating the byte offset
in an 64bit integer.  When later exploiting the duality between
that and a POINTER_PLUS_EXPR we should avoid truncating that
offset to fit in the target specific sizetype.  While such
overflows are generally undefined behavior, exploiting this
may leads to spurious missing diagnostics.

2022-05-09  Richard Biener  <rguenther@suse.de>

PR tree-optimization/105517
* tree-ssa-sccvn.cc (vn_reference_lookup): Make sure the accumulated
offset can be represented in the POINTER_PLUS_EXPR IL.
(vn_reference_insert): Likewise.
* poly-int.h (sext_hwi): Add poly version of sext_hwi.

Remove GIMPLE restriction of ! using match.pd patterns

This removes #if GIMPLE guards around patterns using ! which is
now also provided in the GENERIC implementation.

2022-05-09  Richard Biener  <rguenther@suse.de>

* match.pd: Remove #if GIMPLE guards around ! using patterns.

Optimize vec_setv8{hi,hf}_0 + pmovzxbq to pmovzxbq.

gcc/ChangeLog:

PR target/105072
* config/i386/sse.md (*sse4_1_<code>v2qiv2di2<mask_name>_1):
New define_insn.
(*sse4_1_zero_extendv2qiv2di2_2): New pre_reload
define_insn_and_split.

gcc/testsuite/ChangeLog:

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

[Ada] Suggest use of First_Valid/Last_Valid on type with static predicate

Attributes First_Valid/Last_Valid can be used on types with static
predicate, instead of First/Last/Range. Include that suggestion in
the corresponding error message.

gcc/ada/

* sem_util.adb (Bad_Predicated_Subtype_Use): Add continuation
message.

[Ada] Raise Constraint_Error when converting negative values to Char_Code

GNATprove relies on the comment for Get_Enum_Lit_From_Pos, which
promises to raise Constraint_Error when its Pos parameter is not among
the representation values for enumeration literal. However, this promise
was only respected in builds with range checks enabled.

The root problem was that a similar comment for conversion from Uint to
Char_Code was likewise only respected in builds with range checks
enabled.

Now both routines respect promises in their comments. The behaviour of
GNAT itself is not affected. The fix is needed to filter garbage
counterexamples generated by provers for characters objects in SPARK.

gcc/ada/

* uintp.adb (UI_To_CC): Guard against illegal inputs; reuse
UI_To_Int.

[Ada] Simplify conversions from Uint to Char_Code

Replace "Char_Code (UI_To_Int (...))" with "UI_To_CC (...).

Cleanup related to handling characters in GNATprove counterexamples;
semantics is unaffected.

gcc/ada/

* par-prag.adb (Prag): Simplify conversion of character codes.
* sem_case.adb (Choice_Image): Likewise.
(Lit_Of): Likewise.

[Ada] Fix invalid memory access on finalization of class-wide type

This patch corrects issues in the compiler whereby finalization of a
heap- allocated class-wide type may cause an invalid memory read at
runtime when the type in question contains a component whose type has a
large alignment.

gcc/ada/

* exp_attr.adb (Expand_N_Attribute_Reference) <Attribute_Tag>:
Deal specifically wth class-wide equivalent types without a
parent.
* exp_util.adb (Build_Allocate_Deallocate_Proc): Extract
allocator node for calculation of alignment actual and modify
alignment for allocators of class-wide types with associated
expressions.
(Make_CW_Equivalent_Type): Handle interface types differently
when generating the equivalent record.
* sem_aux.adb (First_Tag_Component): Accept class-wide
equivalent types too.

[Ada] Fully qualify name in JSON representation info

The current termination condition of the recursion is wrong.  When in
JSON mode, names should be fully qualified. This requires to stop not at
the first encountered compilation unit but to recurse up to Standard.

gcc/ada/

* repinfo.adb (List_Name): Rework termination condition.

[Ada] Remove extra space around binary operators

Style cleanups. Violation initially spotted while reading the code for
UI_Expon; other occurrences found with grep (and examined manually,
because sometimes the extra space is needed for a code layout).

gcc/ada/

* bindgen.adb, errout.adb, exp_unst.adb, gnatchop.adb,
libgnat/a-ngcefu.adb, libgnat/a-strunb.adb,
libgnat/a-stwiun.adb, libgnat/a-stzunb.adb,
libgnat/a-wtedit.adb, libgnat/g-debpoo.adb, osint.adb,
sigtramp-vxworks.c, uintp.adb: Remove extra whitespace around +,
-, *, / and **.

[Ada] Remove CodePeer annotations for pragma Loop_Variant

Pragma Loop_Variant is now expanded into a null statement in CodePeer
mode. Remove annotation related to false positives in runtime units.

gcc/ada/

* libgnat/s-expmod.adb: Remove CodePeer annotation for pragma
Loop_Variant.

[Ada] Prevent inlining-for-proof for calls inside ELSIF condition

In GNATprove we don't want inlining-for-proof to expand subprogram
bodies into actions attached to nodes. These actions are attached either
to expressions or to statements.

For expressions, we prevented inlining by Is_Potentially_Unevaluated.
For statements, we prevented inlining by In_While_Loop_Condition, but
forgot about actions attached to ELSIF condition.

There are no other expression or statements nodes where actions could be
attached, so this fix is exhaustive.

gcc/ada/

* sem_util.ads (In_Statement_Condition_With_Actions): Renamed
from In_While_Loop_Condition; move to fit the alphabetic order.
* sem_util.adb (In_Statement_Condition_With_Actions): Detect
Elsif condition; stop search on other statements; prevent search
from going too far; move to fit the alphabetic order.
* sem_res.adb (Resolve_Call): Adapt caller.

[Ada] Remove redundant guards for empty list

Routine Has_Excluded_Declaration iterates over declarations with
First/Present/Next, which is safe when declarations are No_List.

Cleanup related to excessive inlining-for-proof by GNATprove.

gcc/ada/

* inline.adb (Build_Body_To_Inline): Remove redundant guards.
* sem_ch6.adb (Analyze_Subprogram_Body_Helper): Likewise.

[Ada] Fix missing error on actual for In/Out parameter

The compiler was failing to give an error on the result of a call to the
Input attribute passed as actual for an In/Out parameter.

gcc/ada/

* sem_util.adb (Is_OK_Variable_For_Out_Formal): Remove test on
Comes_From_Source in the condition dealing with the expression
of an N_Unchecked_Type_Conversion node.

[Ada] Fix indentation of "Start of processing for ..." labels

The "Start of processing for ..." labels should be aligned with the
BEGIN that follows. Violations found with:

$ grep -Pzo "( *)   \-\-  Start of processing for \w+\n\n\1begin" *.adb

and corrected manually, because some of them had to be entirely removed.

Also, remove trailing semicolons found while guessing the grep pattern.

gcc/ada/

* exp_aggr.adb, exp_ch3.adb, exp_util.adb, freeze.adb,
gnatfind.adb, gnatlink.adb, gnatxref.adb, gprep.adb,
libgnat/a-cfhama.adb, libgnat/g-alleve.adb, sem_ch12.adb,
sem_ch13.adb, xr_tabls.adb: Fix style labels.

[Ada] Improve error messages to include full package name

This patch improves error messages in the compiler so that missing
'with' error messages show the complete package name instead of a
limited number of selectors.

gcc/ada/

* err_vars.ads: Add new error message names and nodes.
* erroutc.adb (Set_Msg_Insertion_Name,
Set_Msg_Insertion_Name_Literal): Likewise.
* errout.adb (Set_Msg_Insertion_Node): Likewise.
* errout.ads: Likewise.
* exp_disp.adb (Check_Premature_Freezing): Modify setting of
Error_Msg_Node_2 to occur directly before Error_Msg call where
applicable.
* sem_ch8.adb (Error_Missing_With_Of_Known_Unit): Added to
handle the printing of full package names of known units.
(Undefined, Find_Expanded_Name): Replace error printing with
call to Error_Missing_With_Of_Known_Unit.

[Ada] Set Error_Msg_Warn before use of << insertion

Calls to Error_Msg procedures with a message using the < or <<
insertions need to set appropriately Error_Msg_Warn. This was not done
in one call, which would lead to spurious errors when changing the
implementation of a runtime unit. This fixes it so that changes can be
applied.

gcc/ada/

* exp_ch4.adb (Expand_Allocator_Expression): Set Error_Msg_Warn
correctly.

[Ada] Properly handle unprefixed references to components

In some cases, the compiler would incorrectly reject unprefixed uses of
component names in an aspect specification for the composite type.
Correct this error.

gcc/ada/

* sem_ch13.adb (Replace_Type_Ref): In the case of an identifier
that names a component of the type, simplify the test to decide
whether to build a prefix for it (the prefix denotes the current
instance of the enclosing type): if the identifier doesn't
already have a prefix, then give it one. This isn't quite right
in the corner case of a quantified expression or some other such
expression that declares an object with the same name as a
component, but it is still an improvement.

[Ada] Fix package installation for private array type of private element

The problem comes from the construction of Stream operations, which
happens at the point a tagged type is frozen. Streams need to see the
full view of types, so that for example the Read attribute for an array
can be expanded into a loop over the Read attribute for the component
type.  Now if during that expansion we have a private type we may need
to retrieve the full view of the type to find its structure. And the
corresponding tree must be compiled in the context of the package that
defines the type, which might not be the current package.  The problem
arises when both array and component types are private, then the
described mechanism is invoked twice.

gcc/ada/

* exp_attr.adb (Compile_Stream_Body_In_Scope): Do not install
package if array type and element type come from the same
package, and the original array type is private.

[Ada] Fix internal error on declaration of derived discriminated record type

When the parent type has a variant part and the derived type is also
discriminated but statically selects a variant, the initialization
routine of the derived type may attempt to access components of other
variants that are no longer present.

gcc/ada/

* exp_ch4.adb (Handle_Changed_Representation): Simplify and fix
thinko in the loop building the constraints for discriminants.
* exp_ch5.adb (Make_Component_List_Assign): Try also to extract
discriminant values for a derived type.

[Ada] Fix visibility inside declare_expression

The first implementation just created a scope for the analysis of the
declarations and the expression, so that visibility would just work as
it does for all other constructs. However this led to an annoying bug
when one of the declarations or the expression itself creates a
transient scope: there may be a confusion on scope exit between those
two scopes. As a result visibility is handled by explicit traversal of
the expression and replacement of occurrences of the local variables,
see Replace_Local_Ref in Resolve_Declare_Expression (sem_res.adb). The
current code does not take into account that there may be references to
a local object in a subsequent declaration (not just in the expression).

gcc/ada/

* sem_res.adb (Resolve_Declare_Expression): Traverse the
expression to replace references to local variables that occur
within declarations of the declare_expression; fix typos in
comments.

[Ada] Fix check for looking for user defined literals

Recall that Has_Possible_Literal_Aspects only comes in if a given node
does not have any visible interpretation. If one operand is a literal we
assume that there may be a user-defined literal defined for some type to
be determined during the downward pass of resolution, but that depends
on the existence of some user-defined function or operator that can take
that literal as an actual. If analysis did not find such, the call is
illegal. I think that the following must be added to Operator_Check to
recover the proper error.

Note that this breaks current partial implementation of user-defined
literals.

gcc/ada/

* sem_ch4.adb (Operator_Check): Fix condition.

[Ada] Refine description of SPARK with static Boolean expressions

A number of SPARK pragmas controlled by an optional Boolean expression
require those expressions to be static. This is now clarified in the
GNAT RM.

gcc/ada/

* doc/gnat_rm/implementation_defined_pragmas.rst
(Abstract_State, Async_Readers, Async_Writers,
Constant_After_Elaboration, Effective_Reads, Effective_Writes,
Extensions_Visible, Ghost, No_Caching, Volatile_Function): Only
static Boolean expressions are allowed.
* gnat_rm.texi: Regenerate.

[Ada] Allow Big_Integer in loop and subprogram variants

In SPARK loop and subprogram variants we now allow expressions of any
discrete type and of Ada.Numerics.Big_Numbers.Big_Integers.Big_Integer
type.

gcc/ada/

* exp_prag.adb (Expand_Pragma_Loop_Variant,
Expand_Pragma_Subprogram_Variant): Adapt call via
Process_Variant to Make_Variant_Comparison.
* exp_util.adb (Make_Variant_Comparison): Compare Big_Integer
expressions with a function call and not an operator.
* exp_util.ads (Make_Variant_Comparison): Add type parameter,
which is needed because the Curr_Val and Old_Val expressions
might not be yet decorated.
* rtsfind.ads: (RTU_Id): Add support for Big_Integers and
Big_Integers_Ghost.
(RE_Id): Add support for Big_Integer and its ghost variant.
(RE_Unit_Table): Add mapping from Big_Integer to Big_Integers;
same for the ghost variants.
* rtsfind.adb (Get_Unit_Name): Add support for Big_Numbers.
* sem_prag.adb (Analyze_Pragma): Allow Big_Integer in pragma
Loop_Variant.
(Analyze_Variant): Allow Big_Integer in pragma
Subprogram_Variant.

[Ada] Add utility to preanalyze assert expression without forcing its type

In SPARK loop and subprogram variants we now allow expressions of any
discrete type or of Ada.Numerics.Big_Numbers.Big_Integers.Big_Integer
type. This requires a variant of Preanalyze_Assert_Expression that
doesn't force the expression to be of a particular type, similar to the
existing variant of Analyze_And_Resolve.

gcc/ada/

* sem_ch3.ads, sem_ch3.adb (Preanalyze_Assert_Expression): Add a
variant that doesn't force preanalysis to yield a specific type.

[Ada] Revamp type resolution for comparison and equality operators

The main goal was to make it symmetrical, but this also moves error handling
entirely to the second phase of type resolution.

gcc/ada/

* einfo.ads (Access Kinds): Reorder and beef up.
* sem.adb (Analyze): Call Analyze_Comparison_Equality_Op for all
comparison and equality operators.
* sem_ch4.ads (Analyze_Comparison_Op): Delete.
(Analyze_Equality_Op): Likewise.
(Analyze_Comparison_Equality_Op): Declare.
(Ambiguous_Operands): Likewise.
* sem_ch4.adb (Ambiguous_Operands): Remove declaration.
(Defined_In_Scope): Delete.
(Find_Comparison_Types): Merge into...
(Find_Equality_Types): Merge into...
(Find_Comparison_Equality_Types): ...this.  Make fully symmetrical.
(Analyze_Arithmetic_Op): Minor consistency tweaks.
(Analyze_Comparison_Op): Merge into...
(Analyze_Equality_Op): Merge into...
(Analyze_Comparison_Equality_Op): ...this.  Make fully symmetrical.
(Analyze_Logical_Op): Minor consistency tweaks.
(Analyze_Membership_Op): Make fully symmetrical.
(Analyze_One_Call): Minor comment tweak.
(Analyze_Operator_Call): Call Find_Comparison_Equality_Types.
(Analyze_User_Defined_Binary_Op): Make fully symmetrical.
(Check_Arithmetic_Pair.Specific_Type): Delete.
(Diagnose_Call): Add special handling for "+" operator.
(Operator_Check): Call Analyze_Comparison_Equality_Op.
* sem_ch8.adb (Has_Implicit_Operator): Add Is_Type guard for boolean
operators, use Valid_Comparison_Arg and Valid_Equality_Arg for resp.
comparison and equality operators.
* sem_res.adb (Check_For_Visible_Operator): Call Is_Visible_Operator
(Make_Call_Into_Operator): Use Preserve_Comes_From_Source.
(Resolve_Actuals): Deal specifically with Any_Type actuals for user-
defined comparison and equality operators.
(Resolve_Call): Minor tweaks.
(Resolve_Comparison_Op): Tidy up and give error for ambiguity.
(Resolve_Equality_Op): Likewise, as well as other errors.
(Rewrite_Renamed_Operator): Simplify.
* sem_type.ads (Is_Invisible_Operator): Delete.
(Is_Visible_Operator): Declare.
(Has_Compatible_Type): Remove For_Comparison parameter.
(Specific_Type): Declare.
(Valid_Equality_Arg): Likewise.
* sem_type.adb (Specific_Type): Remove declaration.
(Add_One_Interp): Call Is_Visible_Operator for the visibility test.
(Remove_Conversions): Rename into...
(Remove_Conversions_And_Abstract_Operations): ...this.  Do not apply
numeric-type treatment to Any_Type.  Expand the special handling for
abstract interpretations to second operand.  Remove obsolete code.
(Disambiguate): Adjust to above renaming.  Tweak to hidden case and
call Remove_Conversions_And_Abstract_Operations for operators too.
(Entity_Matches_Spec): Minor tweak.
(Find_Unique_Type): Simplify and deal with user-defined literals.
(Has_Compatible_Type): Remove For_Comparison parameter and adjust.
Call the Is_User_Defined_Literal predicate and remove call to
the Is_Invisible_Operator predicate.
(Is_Invisible_Operator): Delete.
(Is_Visible_Operator): New function.
(Operator_Matches_Spec): Use Valid_Equality_Arg predicate.
(Specific_Type): Tidy up, make fully symmetrical and deal with
private views the same way as Covers.
(Valid_Comparison_Arg): Return true for Any_Composite/Any_String.
(Valid_Equality_Arg): New function.
* sem_util.ads (Is_User_Defined_Literal): Declare.
* sem_util.adb (Is_User_Defined_Literal): New function.

[Ada] Use "aspect" instead of "pragma" in warnings

For warnings related to the Unreferenced, Unmodified, and Unused
aspects, refer to the "aspect", not the "pragma". Note that the aspect
can be set by an aspect_specification or a pragma, so the term "aspect"
is correct even in the pragma case.  However, messages in sem_prag.adb
use Fix_Error, so they refer to "aspect" or "pragma". It's not clear
that we really ought to refer to "pragma", now that those are obsolete,
but de call Fix_Error for uniformity. We do not attempt to make
Fix_Error available outside sem_prag.adb -- too much trouble for
something that perhaps ought to be removed.

gcc/ada/

* lib-xref.adb, sem_util.adb: Change wording of warning messages
to use "aspect".
* sem_prag.adb: Use Fix_Error to change wording of warnings.
* doc/gnat_rm/implementation_defined_pragmas.rst: Minor: fix
cut&paste error.
* gnat_rm.texi: Regenerate.

[Ada] vx21.07: stack-checking on ppc

On VxWorks >= 7.2 and 653, signal processing code is expected to clear
the TCB exception count field when returning control back to user code.
This change arranges to do so.  It is believed that this is only an
issue in Kernel mode, and not RTP because there is no exception count
field in RTP mode and no failures have been observed.

gcc/ada/

* init.c [vxworks] (CLEAR_EXCEPTION_COUNT): New macro.
(__gnat_clear_exception_count): Remove.
(__gnat_map_signal): Call CLEAR_EXCEPTION_COUNT().

[Ada] Remove gnattest section from gnat user guide

gcc/ada/

* doc/gnat_ugn/gnat_utility_programs.rst: Remove gnattest
section.

[Ada] Remove repeated analysis of attribute prefixes

At the beginning of Analyze_Attribute routine we analyze the attribute
prefix. There is no need to repeat this analysis in branches for
individual attributes.

Code cleanup related to various Analyze/Resolve routines.

gcc/ada/

* sem_attr.adb (Analyze_Attribute): Remove calls to Analyze for
attributes Identity, Priority, Ref, Restriction_Set, To_Address
and for tasking-related attributes Callable, Terminated and
Storage_Size.

[Ada] Remove redundant call to Set_Etype for attribute Bit_Order

Node created by a call to New_Occurrence_Of (RTE (...), ...) has its
Etype set. There is no need to follow it with a call to Set_Etype.

Cleanup of various Analyze/Resolve routines.

gcc/ada/

* sem_attr.adb (Analyze_Attribute): Don't call Set_Etype for
Bit_Order attribute.

[Ada] Remove doubly-negated tests for empty lists

Replace "not Is_Non_Empty_List (...)" with "Is_Empty_List (...)".

Code cleanup; semantics is unaffected.

gcc/ada/

* exp_ch5.adb (Update_Choice_Index): Simplify condition.
* sem_ch8.adb (Attribute_Renaming): Likewise.

[Ada] Remove unused parameter from __gnat_kill

Remove close parameter from __gnat_kill because it is not used in
implementation.

gcc/ada/

* adaint.c (__gnat_kill): Remove close parameter.
(__gnat_killprocesstree): Do not provide close parameter on call
to __gnat_kill.
* libgnat/g-expect.adb (Kill): Remove Close parameter.
(Close): Do not provide Close parameter on call to Kill.
(Send_Signal): Do not provide Close parameter on call to Kill.
* libgnat/s-os_lib.adb (Kill): Do not provide close parameter on
call to __gnat_kill.

[Ada] Stabilize exit code on close process

Call Kill before close input handler in Close routine.  Otherwise close
input handler can terminate process before Kill and exit code became
unpredictable.

gcc/ada/

* libgnat/g-expect.adb (Close): Call Kill before Close_Input.

Enable match.pd dumping with -fdump-tree-original

I noticed that, while the C/C++ frontends invoke the GENERIC match.pd
simplifications to do early folding, the debug output from
generic-match.cc does not appear in the -fdump-tree-original output,
even with -fdump-tree-original-folding or -fdump-tree-original-all. This
patch fixes that.

For example, before the patch, for the following code:

int a[2];
void bar ();
void f()
{
    if ((unsigned long)(a + 1) == 0)
        bar ();
}

on AArch64 at -O0, -fdump-tree-original-all would give:

;; Function f (null)
;; enabled by -tree-original

{
  if (0)
    {
      bar ();
    }
}

After the patch, we get:

Applying pattern match.pd:3774, generic-match.cc:24535
Matching expression match.pd:146, generic-match.cc:23
Applying pattern match.pd:5638, generic-match.cc:13388

;; Function f (null)
;; enabled by -tree-original

{
  if (0)
    {
      bar ();
    }
}

The reason we don't get the match.pd output as it stands, is that the
original dump is treated specially in c-opts.cc: it gets its own state
which is independent from that used by other dump files in the compiler.
Like most of the compiler, the generated generic-match.cc has code of
the form:

  if (dump_file && (dump_flags & TDF_FOLDING))
    fprintf (dump_file, ...);

But, as it stands, -fdump-tree-original has its own FILE * and flags in
c-opts.cc (original_dump_{file,flags}) and never touches the global
dump_{file,flags} (managed by dumpfile.{h,cc}). This patch adjusts the
code in c-opts.cc to use the main dump infrastructure used by the rest
of the compiler, instead of treating the original dump specially.

We take the opportunity to make a small refactor: the code in
c-gimplify.cc:c_genericize can, with this change, use the global dump
infrastructure to get the original dump file and flags instead of using
the bespoke get_dump_info function implemented in c-opts.cc. With this
change, we remove the only use of get_dump_info, so this can be removed.

Note that we also fix a leak of the original dump file in
c_common_parse_file. I originally thought it might be possible to
achieve this with only one static call to dump_finish () (by simply
moving it earlier in the loop), but unfortunately the dump file is
required to be open while c_parse_final_cleanups runs, as we (e.g.)
perform some template instantiations here for C++, which need to appear
in the original dump file.

We adjust cgraph_node::get_create to avoid introducing noise in the
original dump file: without this, these "Introduced new external node"
lines start appearing in the original dump files, which breaks tests
that do a scan-tree-dump-times on the original dump looking for a
certain function name.

gcc/c-family/ChangeLog:

* c-common.h (get_dump_info): Delete.
* c-gimplify.cc (c_genericize): Get TDI_original dump file info
from the global dump_manager instead of the (now obsolete)
get_dump_info.
* c-opts.cc (original_dump_file): Delete.
(original_dump_flags): Delete.
(c_common_parse_file): Switch to using global dump_manager to
manage the original dump file; fix leak of dump file.
(get_dump_info): Delete.

gcc/ChangeLog:

* cgraph.cc (cgraph_node::get_create): Don't dump if the current
symtab state is PARSING.

Come up with {,UN}LIKELY macros.

gcc/c/ChangeLog:

* c-parser.cc (c_parser_conditional_expression): Use {,UN}LIKELY
macros.
(c_parser_binary_expression): Likewise.

gcc/cp/ChangeLog:

* cp-gimplify.cc (cp_genericize_r): Use {,UN}LIKELY
macros.
* parser.cc (cp_finalize_omp_declare_simd): Likewise.
(cp_finalize_oacc_routine): Likewise.

gcc/ChangeLog:

* system.h (LIKELY): Define.
(UNLIKELY): Likewise.
* domwalk.cc (sort_bbs_postorder): Use {,UN}LIKELY
macros.
* dse.cc (set_position_unneeded): Likewise.
(set_all_positions_unneeded): Likewise.
(any_positions_needed_p): Likewise.
(all_positions_needed_p): Likewise.
* expmed.cc (flip_storage_order): Likewise.
* genmatch.cc (dt_simplify::gen_1): Likewise.
* ggc-common.cc (gt_pch_save): Likewise.
* print-rtl.cc: Likewise.
* rtl-iter.h (T>::array_type::~array_type): Likewise.
(T>::next): Likewise.
* rtl-ssa/internals.inl: Likewise.
* rtl-ssa/member-fns.inl: Likewise.
* rtlanal.cc (T>::add_subrtxes_to_queue): Likewise.
(rtx_properties::try_to_add_dest): Likewise.
* rtlanal.h (growing_rtx_properties::repeat): Likewise.
(vec_rtx_properties_base::~vec_rtx_properties_base): Likewise.
* simplify-rtx.cc (simplify_replace_fn_rtx): Likewise.
* sort.cc (likely): Likewise.
(mergesort): Likewise.
* wide-int.h (wi::eq_p): Likewise.
(wi::ltu_p): Likewise.
(wi::cmpu): Likewise.
(wi::bit_and): Likewise.
(wi::bit_and_not): Likewise.
(wi::bit_or): Likewise.
(wi::bit_or_not): Likewise.
(wi::bit_xor): Likewise.
(wi::add): Likewise.
(wi::sub): Likewise.

RISC-V: Fix wrong expansion for arch-canonicalize

rv64gcv should exapnd into:

rv64imafdcv_zicsr_zifencei_zve32f_zve32x_zve64d_zve64f_zve64x_zvl128b_zvl32b_zvl64b

but we exapnd fd twice for now:

rv64imafdfdcv_zicsr_zifencei_zve32f_zve32x_zve64d_zve64f_zve64x_zvl128b_zvl32b_zvl64b

gcc/ChangeLog:

* config/riscv/arch-canonicalize: Handle g correctly.

Daily bump.

Daily bump.

c, c++: attribute format on a ctor with a vbase [PR101833, PR47634]

Attribute format takes three arguments: archetype, string-index, and
first-to-check.  The last two specify the position in the function
parameter list.  r63030 clarified that "Since non-static C++ methods have
an implicit this argument, the arguments of such methods should be counted
from two, not one, when giving values for string-index and first-to-check."
Therefore one has to write

  struct D {
    D(const char *, ...) __attribute__((format(printf, 2, 3)));
  };

However -- and this is the problem in this PR -- ctors with virtual
bases also get two additional parameters: the in-charge parameter and
the VTT parameter (added in maybe_retrofit_in_chrg).  In fact we'll end up
with two clones of the ctor: an in-charge and a not-in-charge version (see
build_cdtor_clones).  That means that the argument position the user
specified in the attribute argument will refer to different arguments,
depending on which constructor we're currently dealing with.  This can
cause a range of problems: wrong errors, confusing warnings, or crashes.

This patch corrects that; for C we don't have to do anything, and in C++
we can use num_artificial_parms_for.  It would be wrong to rewrite the
attributes the user supplied, so I've changed POS to be passed by
reference so that we don't have to change all the call sites of
positional_argument and we still get the default_conversion adjustment.

Attribute format_arg is not affected, because it requires that the
function returns "const char *" which will never be the case for cdtors.

PR c++/101833
PR c++/47634

gcc/c-family/ChangeLog:

* c-attribs.cc (positional_argument): Pass POS by reference.  Deal
with FN being either a function declaration or function type.  Use
maybe_adjust_arg_pos_for_attribute.
* c-common.cc (check_function_arguments): Maybe pass FNDECL down to
check_function_format.
* c-common.h (maybe_adjust_arg_pos_for_attribute): Declare.
(positional_argument): Adjust.
* c-format.cc (get_constant): Rename to ...
(validate_constant): ... this.  Take EXPR by reference.  Return bool
instead of tree.
(handle_format_arg_attribute): Don't overwrite FORMAT_NUM_EXPR by the
return value of validate_constant.
(decode_format_attr): Don't overwrite FORMAT_NUM_EXPR and
FIRST_ARG_NUM_EXPR by the return value of validate_constant.
(check_function_format): Adjust a parameter name.
(handle_format_attribute): Maybe pass FNDECL down to decode_format_attr.

gcc/c/ChangeLog:

* c-objc-common.cc (maybe_adjust_arg_pos_for_attribute): New.

gcc/cp/ChangeLog:

* tree.cc (maybe_adjust_arg_pos_for_attribute): New.

gcc/ChangeLog:

* tree-core.h (struct attribute_spec): Update comment for HANDLER.

gcc/testsuite/ChangeLog:

* g++.dg/ext/attr-format-arg1.C: New test.
* g++.dg/ext/attr-format1.C: New test.
* g++.dg/ext/attr-format2.C: New test.
* g++.dg/ext/attr-format3.C: New test.

Daily bump.

compiler: remove Array_index_expression::is_lvalue_

As of CL 77510 it is never true.

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

libstdc++: Simplify std::normal_distribution equality operator

libstdc++-v3/ChangeLog:

* include/bits/random.tcc (operator==): Only check
normal_distribution::_M_saved_available once.
* testsuite/26_numerics/random/normal_distribution/operators/equal.cc:
Check equality after state changes.
* testsuite/26_numerics/random/pr60037-neg.cc: Adjust dg-error
lineno.

libstdc++: Fix deserialization for std::normal_distribution [PR105502]

This fixes a regression in std::normal_distribution deserialization that
caused the object to be left unchanged if the __state_avail value read
from the stream was false.

libstdc++-v3/ChangeLog:

PR libstdc++/105502
* include/bits/random.tcc
(operator>>(basic_istream<C,T>&, normal_distribution<R>&)):
Update state when __state_avail is false.
* testsuite/26_numerics/random/normal_distribution/operators/serialize.cc:
Check that deserialized object equals serialized one.

c++: add color to function decl printing

In reading C++ diagnostics, it's often hard to find the name of the function
in the middle of the template header, return type, parameters, and template
arguments.  So let's colorize it, and maybe the template argument bindings
while we're at it.

I've somewhat arbitrarily chosen bold green for the function name, and
non-bold magenta for the template arguments.

A side-effect of this is that when this happens in a quote (i.e. %qD), the
rest of the quote after the function name is no longer bold.  I think that's
acceptable; returning to the bold would require maintaining a colorize stack
instead of the on/off controls we have now.

gcc/cp/ChangeLog:

* error.cc (decl_to_string): Add show_color parameter.
(subst_to_string): Likewise.
(cp_printer): Pass it.
(type_to_string): Set pp_show_color.
(dump_function_name): Use "fnname" color.
(dump_template_bindings): Use "targs" color.
(struct colorize_guard): New.
(reinit_cxx_pp): Clear pp_show_color.

gcc/ChangeLog:

* diagnostic-color.cc: Add fnname and targs color entries.
* doc/invoke.texi: Document them.

gcc/testsuite/ChangeLog:

* g++.dg/diagnostic/function-color1.C: New test.

vec: fix iterate comment

The comment for this overload, which copies the value out of the vector,
was mostly describing the other overload, which stores a pointer into the
vector.

gcc/ChangeLog:

* vec.h (vec::iterate): Fix comment.

c++: empty base constexpr adjustment [PR105245]

While looking at PR105245 in stage 4, I wanted to reorganize the code a bit,
but it seemed prudent to defer that to stage 1.

PR c++/105245
PR c++/100111

gcc/cp/ChangeLog:

* constexpr.cc (cxx_eval_store_expression): Reorganize empty base
handling.

libstdc++: ppc: conditionalize vsx-only simd intrinsics

libstdc++'s bits/simd.h section for PowerPC, guarded by __ALTIVEC__,
defines various intrinsic vector types that are only available with
__VSX__: 64-bit long double, double, (un)signed long long, and 64-bit
(un)signed long.

experimental/simd/standard_abi_usable{,_2}.cc tests error out
reporting the unmet requirements when the target cpu doesn't enable
VSX.  Make the reported instrinsic types conditional on __VSX__ so
that <experimental/simd> can be used on PowerPC variants that do not
support VSX.

for  libstdc++-v3/ChangeLog

* include/experimental/bits/simd.h [__ALTIVEC__]: Require VSX
for double, long long, and 64-bit long intrinsic types.
[__ALTIVEC__] (__intrinsic_type): Mention 128-bit in
preexisting long double diagnostic, adjust no-VSX double
diagnostic to cover 64-bit long double as well.

compiler: error for duplicate bool map keys

For golang/go#35945
Fixes golang/go#28104

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

rs6000: Ignore fusion option flags for inlining test [PR102059]

The -mpower8-fusion and -mpower10-fusion options do not modify which
instructions we can generate, so ignore them when deciding whether we
can inline callee into caller.

2022-05-06   Michael Meissner  <meissner@linux.ibm.com>

gcc/
PR target/102059
* config/rs6000/rs6000.cc (rs6000_can_inline_p): Ignore -mpower8-fusion
and -mpower10-fusion options for inlining purposes.

gcc/testsuite/
PR target/102059
* gcc.target/powerpc/pr102059-4.c: New test.

aarch64: remove useless GPF_TF_F16 iterator

This iterator is not used anymore and is a leftover from previous
cleanup (r10-5890-gabbe1ed2735517).

2022-04-28  Christophe Lyon  <christophe.lyon@arm.com>

gcc/
* config/aarch64/iterators.md (GPF_TF_F16): Delete.

OpenMP, libgomp: Add new runtime routine omp_target_is_accessible.

gcc/ChangeLog:

* omp-low.cc (omp_runtime_api_call): Added target_is_accessible to
omp_runtime_apis array.

libgomp/ChangeLog:

* libgomp.map: Added omp_target_is_accessible.
* libgomp.texi: Tagged omp_target_is_accessible as supported.
* omp.h.in: Added omp_target_is_accessible.
* omp_lib.f90.in: Added interface for omp_target_is_accessible.
* omp_lib.h.in: Likewise.
* target.c (omp_target_is_accessible): Added implementation of
omp_target_is_accessible.
* testsuite/libgomp.c-c++-common/target-is-accessible-1.c: New test.
* testsuite/libgomp.fortran/target-is-accessible-1.f90: New test.