Instantiations of templated conversion operators failed to demangle
for cases such as 'operator X<int>', but worked for 'operator X<int>
&', due to thinking the template instantiation of X was the
instantiation of the conversion operator itself.

	libiberty/
	* cp-demangle.c (d_print_conversion): Remove incorrect
	template instantiation handling.
	* testsuite/demangle-expected: Add testcases.

gcc/testsuite/
	* gfortran.dg/data_array_7.f90: New test.

gcc/fortran/ChangeLog:

	PR fortran/86277
	* trans-array.cc (gfc_trans_allocate_array_storage): When passing a
	zero-sized array with fixed (= non-dynamic) size, allocate temporary
	by the caller, not by the callee.

gcc/testsuite/ChangeLog:

	PR fortran/86277
	* gfortran.dg/zero_sized_14.f90: New test.
	* gfortran.dg/zero_sized_15.f90: New test.

Co-authored-by: Mikael Morin <mikael@gcc.gnu.org>

I happened to be digging into the specs to understand a build
failure and spotted mflib and mfwrap.  Those were used by the
mudflap system which we ripped out years ago and we just missed
these.

I verified x86 still bootstraps after removing these bits.

Pushed to the trunk as obvious,
gcc/
	* gcc.cc (LINK_COMMAND_SPEC): Remove mudflap spec handling.

Spurred by Akari Takahashi's patch to config/sh/divtab.cc, this removes
divtab.cc completely.

divtab.cc was used to calculate a division table for the sh5 media
processor.  GCC dropped support for that (unmanufactured) chip back
in 2016 and this file simply got missed AFAICT.

gcc/
	* config/sh/divtab.cc: Remove.

I've noticed that standard_sse_constant_opcode emits some spurious
whitespace around tab, that isn't something which is done for
any other instruction and looks wrong.

2023-06-13  Jakub Jelinek  <jakub@redhat.com>

	* config/i386/i386.cc (standard_sse_constant_opcode): Remove
	superfluous spaces around \t for vpcmpeqd.

This middle-end patch avoids some redundant RTL for vector initialization
during RTL expansion.  For the simple test case:

typedef __int128 v1ti __attribute__ ((__vector_size__ (16)));
__int128 key;

v1ti foo() {
    return (v1ti){key};
}

the middle-end currently expands:

(set (reg:V1TI 85) (const_vector:V1TI [ (const_int 0) ]))

(set (reg:V1TI 85) (mem/c:V1TI (symbol_ref:DI ("key"))))

where we create a dead instruction that initializes the vector to zero,
immediately followed by a set of the entire vector.  This patch skips
this zeroing instruction when the vector has only a single element.
It also updates the code to indicate when we've cleared the vector,
so that we don't need to initialize zero elements.

2023-06-13  Roger Sayle  <roger@nextmovesoftware.com>

gcc/ChangeLog
	* expr.cc (store_constructor) <case VECTOR_TYPE>: Don't bother
	clearing vectors with only a single element.  Set CLEARED if the
	vector was initialized to zero.

Hi,

This patch remove the duplicate `#include "riscv-vector-switch.def"` statement
and add #undef for ENTRY and TUPLE_ENTRY macros later.

Best,
Lehua

gcc/ChangeLog:

	* config/riscv/riscv-v.cc (struct mode_vtype_group): Remove duplicate
	#include.
	(ENTRY): Undef.
	(TUPLE_ENTRY): Undef.

gcc/ChangeLog:

	* config/riscv/riscv-v.cc (rvv_builder::single_step_npatterns_p): Add comment.
	(shuffle_generic_patterns): Ditto.
	(expand_vec_perm_const_1): Ditto.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/rvv/autovec/partial/slp-10.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp-11.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp-13.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp-14.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp-15.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp_run-10.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp_run-11.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp_run-13.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp_run-14.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp_run-15.c: New test.

Sorry for producing bugs in the previous VLA SLP patch.

Consider this following permutation:
_85 = VEC_PERM_EXPR <{ 99, 17, ... }, { 11, 80, ... }, { 0, POLY_INT_CST [4, 4], 1, POLY_INT_CST [5, 4], 2, POLY_INT_CST [6, 4], ... }>;

The correct result should be:
_85 = { 99, 11, 17, 80, ... }

However, I did wrong in the previous patch.

Code sequence before this patch:

set mask = { 0, 1, 0, 1, ... }
set v0 = { 99, 17, 99, 17, ... }
set v1 = { 11, 80, 11, 80, ... }
set index = viota (mask) = { 0, 0, 1, 1, 2, 2, ... }
set result = vrgather_mu (v0, v1, index, mask) = { 99, 11, 99, 80 }
The result is incorrect.

After this patch:

set mask = { 0, 1, 0, 1, ... }
set index = viota (mask) = { 0, 0, 1, 1, 2, 2, ... }
set v0 = vrgather ({ 99, 17, 99, 17, ... }, index) = { 99, 99, 17, 17, ... }
set v1 = { 11, 80, 11, 80, ... }
set result = vrgather_mu (v0, v1, index, mask) = { 99, 11, 17, 80 }
The result is what we expected.

This issue was discovered in the test I appended in this patch with --param=riscv-autovec-lmul=2.

gcc/ChangeLog:

	* config/riscv/riscv-v.cc (emit_vlmax_decompress_insn): Fix bug.
	(shuffle_decompress_patterns): Ditto.

gcc/testsuite/ChangeLog:

	* gcc.target/riscv/rvv/autovec/partial/slp-12.c: New test.
	* gcc.target/riscv/rvv/autovec/partial/slp_run-12.c: New test.

	* tree-ssa-loop-ch.cc (ch_base::copy_headers): Free loop BBs.

If the type of a temporary has mutable members, we can't set TREE_READONLY
on the VAR_DECL; this is parallel to the check in
cp_apply_type_quals_to_decl.

gcc/cp/ChangeLog:

	* tree.cc (build_target_expr): Check TYPE_HAS_MUTABLE_P.

gcc/testsuite/ChangeLog:

	* g++.dg/tree-ssa/initlist-opt6.C: New test.

This patch adds support to check function's argument or return is vector type
and throw warning if yes.

There're two exceptions,
  - The vector_size attribute.
  - The intrinsic functions.

Some cases that need to add -Wno-psabi to ignore the warning.

gcc/ChangeLog:

	* config/riscv/riscv-protos.h (riscv_init_cumulative_args): Set
	warning flag if func is not builtin
	* config/riscv/riscv.cc
	(riscv_scalable_vector_type_p): Determine whether the type is scalable vector.
	(riscv_arg_has_vector): Determine whether the arg is vector type.
	(riscv_pass_in_vector_p): Check the vector type param is passed by value.
	(riscv_init_cumulative_args): The same as header.
	(riscv_get_arg_info): Add the checking.
	(riscv_function_value): Check the func return and set warning flag
	* config/riscv/riscv.h (INIT_CUMULATIVE_ARGS): Add a flag to
	determine whether warning psabi or not.

gcc/testsuite/ChangeLog:

	* g++.target/riscv/rvv/base/pr109244.C: Add the -Wno-psabi.
	* g++.target/riscv/rvv/base/pr109535.C: Same
	* gcc.target/riscv/rvv/base/binop_vx_constraint-120.c: Same
	* gcc.target/riscv/rvv/base/integer_compare_insn_shortcut.c: Same
	* gcc.target/riscv/rvv/base/mask_insn_shortcut.c: Same
	* gcc.target/riscv/rvv/base/misc_vreinterpret_vbool_vint.c: Same
	* gcc.target/riscv/rvv/base/pr110109-2.c: Same
	* gcc.target/riscv/rvv/base/scalar_move-9.c: Same
	* gcc.target/riscv/rvv/base/spill-10.c: Same
	* gcc.target/riscv/rvv/base/spill-11.c: Same
	* gcc.target/riscv/rvv/base/spill-9.c: Same
	* gcc.target/riscv/rvv/base/vlmul_ext-1.c: Same
	* gcc.target/riscv/rvv/base/zero_base_load_store_optimization.c: Same
	* gcc.target/riscv/rvv/base/zvfh-intrinsic.c: Same
	* gcc.target/riscv/rvv/base/zvfh-over-zvfhmin.c: Same
	* gcc.target/riscv/rvv/base/zvfhmin-intrinsic.c: Same
	* gcc.target/riscv/rvv/vsetvl/vsetvl-1.c: Same
	* gcc.target/riscv/vector-abi-1.c: New test.
	* gcc.target/riscv/vector-abi-2.c: New test.
	* gcc.target/riscv/vector-abi-3.c: New test.
	* gcc.target/riscv/vector-abi-4.c: New test.
	* gcc.target/riscv/vector-abi-5.c: New test.
	* gcc.target/riscv/vector-abi-6.c: New test.

Signed-off-by: Yanzhang Wang <yanzhang.wang@intel.com>
Co-authored-by: Kito Cheng <kito.cheng@sifive.com>

Add a testcase for 'omp requires unified_address' that is currently supported
by all devices but was not tested for.

libgomp/

	PR libgomp/109837
	* testsuite/libgomp.c-c++-common/requires-unified-addr-1.c: New test.
	* testsuite/libgomp.fortran/requires-unified-addr-1.f90: New test.

After discussing the -mtp= option with Arm's LLVM developers we'd like to extend
the functionality of the option somewhat.
There are actually 3 system registers that can be accessed for the thread pointer
in aarch32: tpidrurw, tpidruro, tpidrprw.  They are all read through the CP15 co-processor
mechanism. The current -mtp=cp15 option reads the tpidruro register.
This patch extends -mtp to allow for the above three explicit tpidr names and
keeps -mtp=cp15 as an alias of -mtp=tpidruro for backwards compatibility.

Bootstrapped and tested on arm-none-linux-gnueabihf.

gcc/ChangeLog:

	* config/arm/arm-opts.h (enum arm_tp_type): Remove TP_CP15.
	Add TP_TPIDRURW, TP_TPIDRURO, TP_TPIDRPRW values.
	* config/arm/arm-protos.h (arm_output_load_tpidr): Declare prototype.
	* config/arm/arm.cc (arm_option_reconfigure_globals): Replace TP_CP15
	with TP_TPIDRURO.
	(arm_output_load_tpidr): Define.
	* config/arm/arm.h (TARGET_HARD_TP): Define in terms of TARGET_SOFT_TP.
	* config/arm/arm.md (load_tp_hard): Call arm_output_load_tpidr to output
	assembly.
	(reload_tp_hard): Likewise.
	* config/arm/arm.opt (tpidrurw, tpidruro, tpidrprw): New values for
	arm_tp_type.
	* doc/invoke.texi (Arm Options, mtp): Document new values.

gcc/testsuite/ChangeLog:

	* gcc.target/arm/mtp.c: New test.
	* gcc.target/arm/mtp_1.c: New test.
	* gcc.target/arm/mtp_2.c: New test.
	* gcc.target/arm/mtp_3.c: New test.
	* gcc.target/arm/mtp_4.c: New test.

After discussing the -mtp= option with Arm's LLVM developers we'd like to extend
the functionality of the option somewhat.
First of all, there is another TPIDR register that can be used to read the thread pointer:
TPIDRRO_EL0 (which can also be accessed by AArch32 under another name) so it makes sense
to add -mtp=tpidrr0_el0. This makes the existing arguments el0, el1, el2, el3 somewhat
inconsistent in their naming so this patch introduces the more "full" names
tpidr_el0, tpidr_el1, tpidr_el2, tpidr_el3 and makes the above short names alias of these new ones.
Long story short, we preserve backwards compatibility and add a new TPIDR register to access through
-mtp that wasn't available previously.
There is more relevant discussion of the options at https://reviews.llvm.org/D152433 if you're interested.

Bootstrapped and tested on aarch64-none-linux-gnu.

gcc/ChangeLog:

	PR target/108779
	* config/aarch64/aarch64-opts.h (enum aarch64_tp_reg): Add
	AARCH64_TPIDRRO_EL0 value.
	* config/aarch64/aarch64.cc (aarch64_output_load_tp): Define.
	* config/aarch64/aarch64.opt (tpidr_el0, tpidr_el1, tpidr_el2,
	tpidr_el3, tpidrro_el3): New accepted values to -mtp=.
	* doc/invoke.texi (AArch64 Options): Document new -mtp= options.

gcc/testsuite/ChangeLog:

	PR target/108779
	* gcc.target/aarch64/mtp_5.c: New test.
	* gcc.target/aarch64/mtp_6.c: New test.
	* gcc.target/aarch64/mtp_7.c: New test.
	* gcc.target/aarch64/mtp_8.c: New test.
	* gcc.target/aarch64/mtp_9.c: New test.

C++ requires inline functions to be declared inline and defined in
every translation unit that uses them.  frange_nextafter is used in
gimple-range-op.cc but it's only defined as inline in
range-op-float.cc.  Drop the extraneous inline specifier.

Other non-static inline functions in range-op-float.cc are not
referenced elsewhere, so I'm making them static.


for  gcc/ChangeLog

	* range-op-float.cc (frange_nextafter): Drop inline.
	(frelop_early_resolve): Add static.
	(frange_float): Likewise.

The following fixes native interpretation of a buffer as boolean
vector with bit-precision elements such as AVX512 vectors.  The
check whether the buffer covers the whole vector was broken for
bit-precision elements and the following instead implements it
based on the vector type size.

	PR middle-end/110232
	* fold-const.cc (native_interpret_vector): Use TYPE_SIZE_UNIT
	to check whether the buffer covers the whole vector.

	* gcc.target/i386/pr110232.c: New testcase.

Alias analysis was treating .MASK_LOAD as storing a full vector
which means we disambiguate against decls of smaller than vector size.
This complements the previous patch handling .MASK_STORE and fixes
runtime execution FAILs of gfortran.dg/matmul_3.f90 and
gfortran.dg/inline_sum_2.f90 when using AVX512 with full masked loop
vectorization on Zen4.

	* tree-ssa-alias.cc (ref_maybe_used_by_call_p_1): For
	.MASK_LOAD and friends set the size of the access to unknown.

Update powerpc tests with extra zero_extend removal with default ree pass.

2023-06-13  Ajit Kumar Agarwal  <aagarwa1@linux.ibm.com>

gcc/testsuite/ChangeLog:

	PR testsuite/109880
	* gcc.target/powerpc/fold-vec-extract-int.p8.c: Update test.

This patch is to make newly added test cases pr109932-{1,2}.c
check int128 effective target to avoid unsupported type error
on 32-bit.  I did hit this failure during testing and fixed
it, but made a stupid mistake not updating the local formatted
patch which was actually out of date.

	PR testsuite/110230
	PR target/109932

gcc/testsuite/ChangeLog:

	* gcc.target/powerpc/pr109932-1.c: Adjust with int128 effective target.
	* gcc.target/powerpc/pr109932-2.c: Ditto.

This patch is an alternative solution for a recent fix in analysis of
iterated component association.

To recap, if the iterated expression is an aggregate, we want to
propagate the component type downward with a call to Resolve_Aggr_Expr;
otherwise we want this expression to be only preanalysed (since the
association might need to be repeatedly evaluated), but also we need to
apply predicate and range checks to the expression itself (these are
required for GNATprove).

It turns out that Resolve_Aggr_Expr already knows how to deal with a
nested aggregate and also works for GNATprove, where it both preanalyzes
the expression and applies necessary checks.

In other words, expression of the iterated component association is now
resolved just like expression of an ordinary array aggregate.

gcc/ada/

	* sem_aggr.adb (Resolve_Iterated_Component_Association): Simply resolve
	the expression.

If a quantified expression says "for all ... of F(...)"
where F(...) is a function call that returns on the secondary
stack, we need to clean up the secondary stack. This patch
adds the required ss_mark/ss_release in that case.

gcc/ada/

	* exp_ch4.adb
	(Expand_N_Quantified_Expression): Detect the secondary-stack
	case, and find the innermost scope where we should mark/release,
	and Set_Uses_Sec_Stack on that. Skip intermediate blocks and loops
	that are part of expansion.

As iterated_component_association is an array_component_association
(because of a grammar rule Ada 2022 RM 4.3.3(5/5)), its expression is
repeatedly evaluated (because of Ada 2022 RM 6.1.1(22.14/5)).

With this patch we will now get errors for both conjuncts in this code,
which have semantically equivalent array aggregates that use an ordinary
component association and iterated component association.

  procedure Iter (S : String)
    with Post => String'(for J in 1 .. 3 => S (S'First)'Old) =
                 String'(         1 .. 3 => S (S'First)'Old);

gcc/ada/

	* sem_util.adb (Is_Repeatedly_Evaluated): Recognize iterated component
	association as repeatedly evaluated.

Routine Is_Potentially_Unevaluated was written for Ada 2012, but now we
use it for Ada 2022 as well, so it must recognize iterated component
associations (which were added by Ada 2022) as an array component
association.

gcc/ada/

	* sem_util.adb (Is_Potentially_Unevaluated): Recognize iterated
	component association as potentially unevaluated.

Instead of explicitly disabling inlining in quantified expressions,
(which happen to be only preanalysed) and then disabling inlining in
potentially unevaluated contexts that are fully analysed (which happen
to include quantified expressions), we now simply disable inlining in
all potentially unevaluated contexts, regardless of the full analysis
mode.

This also disables inlining in iterated component associations, which
can be both preanalysed or fully analysed depending on their expression,
but nevertheless are potentially unevaluated.

gcc/ada/

	* sem_res.adb (Resolve_Call): Replace early call to
	In_Quantified_Expression with a call to Is_Potentially_Unevaluated that
	was only done when Full_Analysis is true.

This patch allows subprograms to be annotated with aspect
Always_Terminates that requires a boolean expression. When this
expression evaluates to True, the subprogram is required to terminate or
raise an exception, but not loop infinitely.

This aspect is only meant to be used by GNATprove and it has no
meaningful run-time semantics: either the annotated subprogram
terminates and then the aspect expression doesn't matter, or the
subprogram loops infinitely and there is nothing we can do. (We could
also evaluate the aspect expression just to detect run-time errors in
the expression itself, but this can be implemented later, after a
backend support for the aspect is added to GNATprove.)

Implementation of this aspect is heavily based on the implementation of
Subprogram_Variant, which in turn is heavily based on the implementation
of Contract_Cases. Since the new aspect is not yet expanded, there is no
corresponding assertion kind that would control the expansion.

gcc/ada/

	* aspects.ads (Aspect_Id): Add new aspect.
	(Implementation_Defined_Aspect): New aspect is
	implementation-defined.
	(Aspect_Argument): New aspect has an expression argument.
	(Is_Representation_Aspect): New aspect is not a representation
	aspect.
	(Aspect_Names): Link new aspect identifier with a name.
	(Aspect_Delay): New aspect is never delayed.
	* contracts.adb (Expand_Subprogram_Contract): Mention new aspect
	in comment.
	(Add_Contract_Item): Attach pragma corresponding to the new aspect
	to contract items.
	(Analyze_Entry_Or_Subprogram_Contract): Analyze pragma
	corresponding to the new aspect that appears with subprogram spec.
	(Analyze_Subprogram_Body_Stub_Contract): Expand pragma
	corresponding to the new aspect.
	* contracts.ads
	(Add_Contract_Item, Analyze_Entry_Or_Subprogram_Contract)
	(Analyze_Entry_Or_Subprogram_Body_Contract)
	(Analyze_Subprogram_Body_Stub_Contract): Mention new aspect in
	comment.
	* einfo-utils.adb (Get_Pragma): Return pragma attached to
	contract.
	* einfo-utils.ads (Get_Pragma): Mention new contract in comment.
	* exp_prag.adb (Expand_Pragma_Always_Terminates): Placeholder for
	possibly expanding new aspect.
	* exp_prag.ads (Expand_Pragma_Always_Terminates): Dedicated
	routine for expansion of the new aspect.
	* inline.adb (Remove_Aspects_And_Pragmas): Remove aspect from
	inlined bodies.
	* par-prag.adb (Prag): Postpone checking of the pragma until
	analysis.
	* sem_ch12.adb: Mention new aspect in explanation of handling
	contracts on generic units.
	* sem_ch13.adb (Analyze_Aspect_Specifications): Convert new aspect
	into a corresponding pragma.
	(Check_Aspect_At_Freeze_Point): Don't expect new aspect.
	* sem_prag.adb (Analyze_Always_Terminates_In_Decl_Part): Analyze
	pragma corresponding to the new aspect.
	(Analyze_Pragma): Handle pragma corresponding to the new aspect.
	(Is_Non_Significant_Pragma_Reference): Handle references appearing
	within new aspect.
	* sem_prag.ads (Aspect_Specifying_Pragma): New aspect can be
	emulated with a pragma.
	(Assertion_Expression_Pragma): New aspect has an assertion
	expression.
	(Pragma_Significant_To_Subprograms): New aspect is significant to
	subprograms.
	(Analyze_Always_Terminates_In_Decl_Part): Add spec for routine
	that analyses new aspect.
	(Find_Related_Declaration_Or_Body): Mention new aspect in comment.
	* sem_util.adb (Is_Subprogram_Contract_Annotation): New aspect is
	a subprogram contract annotation.
	* sem_util.ads (Is_Subprogram_Contract_Annotation): Mention new
	aspect in comment.
	* sinfo.ads (Is_Generic_Contract_Pragma): New pragma is a generic
	contract.
	(Contract): Explain attaching new pragma to subprogram contract.
	* snames.ads-tmpl (Name_Always_Terminates): New name for the new
	contract.
	(Pragma_Always_Terminates): New pragma identifier.

Elaboration checks skip abstract subprogram declarations, which have no
body that could be examined. Now these checks also skip abstract
subprograms of a derived type, which have no body either.

gcc/ada/

	* sem_elab.adb (Check_Overriding_Primitive): Prevent Corresponding_Body
	to be called with entity of an abstract subprogram.

It occurs for the case of a function call first parsed as an identifier.

gcc/ada/

	* sem_ch12.adb (Save_References_In_Identifier): In the case where
	the identifier has been turned into a function call by analysis,
	call Set_Global_Type on the entity if it is global.

The call to Resolve_Aggr_Expr may leave references to temporary entities
used to check for the construct legality and meant to be removed.

Using Preanalyze_And_Resolve correctly guarantees that there is no
visible occurrence of such entities.

gcc/ada/

	* sem_aggr.adb (Resolve_Iterated_Component_Association): Call
	Preanalyze_And_Resolve instead of Resolve_Aggr_Expr except for
	aggregate.

Co-authored-by: Ed Schonberg <schonberg@adacore.com>

This lets the compiler give a proper error message instead.

gcc/ada/

	* contracts.adb (Contract_Error): New exception.
	(Add_Contract_Item): Raise Contract_Error instead of Program_Error.
	(Add_Generic_Contract_Pragma): Deal with Contract_Error.

The spurious error is given on a call to a parameterless function returning
a private type, present in the body of a generic construct both declared and
instantiated in the presence of the full view of the type, because this full
view is not properly restored for the instantiation.

This is supposed to be handled by the Has_Private_View mechanism, but it is
bypassed here because the call to the parameterless function is first parsed
as a simple identifier before being later analyzed as a function call.

Fixing this first issue uncovered another one, whereby the Has_Private_View
flag was not properly set on an operator returning a private type that ends
up being later resolved as a function call.

Finally a small loophole in Eval_Attribute exposed by the change also needs
to be plugged.

gcc/ada/

	* sem_attr.adb (Eval_Attribute): Add more exceptions to the early
	return for a prefix which is a nonfrozen generic actual type.
	* sem_ch12.adb (Copy_Generic_Node): Also check private views in the
	case of an entity name or operator analyzed as a function call.
	(Set_Global_Type): Make it a child of Save_Global_References.
	(Save_References_In_Operator): In the case where the operator has
	been turned into a function call, call Set_Global_Type on the entity
	if it is global.

The problem, which is also present for an expression function, is that the
function is invoked in the initializing expression of a variable declared
in the same declarative part as the function, which causes the freezing of
its artificial body before the post-condition is analyzed on its spec.

gcc/ada/

	* contracts.adb (Analyze_Entry_Or_Subprogram_Body_Contract): For a
	subprogram body that has no contracts and does not come from source,
	make sure that contracts on its corresponding spec are analyzed, if
	any, before expanding them.

This changes the strategy used to expand controlled actions for array and
record aggregates so as to make it simpler and more robust.

The current strategy is to set the No_Ctrl_Actions flag on the assignments
generated during the expansion of aggregate, as done during the expansion
of initialization procedures, and to generate the adjustments of the LHS
manually in the same list of actions, before sending the entire list for
analysis and expansion.  The problem is that, when the RHS also requires
controlled actions, the No_Ctrl_Actions flag prevents transient scopes
from being created around the assignments, with the end result that the
actions are "naturally" generated between the assignments and adjustments
of the LHS, causing premature finalization of the RHS.  In order to counter
that, the controlled actions of the RHS must also be generated manually
during the expansion of the aggregates, after blocking normal processing
e.g. by means of the No_Side_Effect_Removal flag.  This means that, for
a more complex RHS, this strategy generates a wrong order of controlled
actions by default, until specifically adjusted.

The new strategy is to reuse the standard machinery as much as possible,
disabling only the part that is not needed for the assignments generated
during the expansion of aggregates, namely the finalization of the LHS;
in other words, the adjustment of the LHS is left entirely to the standard
machinery and the creation of transient scopes is no longer blocked, which
gives a correct order of controlled actions by default.  It is implemented
by means of a No_Finalize_Actions flag present on the assignments generated
during the expansion.

It is mostly straightforward, modulo the following hitch: the assignments
are now analyzed and expanded by the common expander, which in the case of
controlled assignments analyzes the final rewriting with all checks off,
which in particular disables elaboration checks for the calls to the Adjust
primitives; now these checks are necessary in the case where an aggregate
is the initialization expression of an object declared before the body of
the Adjust primitive is seen.  Hence the use of an existing trick, namely
Suppress/Unsuppress blocks, around the assignments.

gcc/ada/

	* gen_il-fields.ads (Opt_Field_Enum): Add No_Finalize_Actions and
	remove No_Side_Effect_Removal.
	* gen_il-gen-gen_nodes.adb (N_Function_Call): Remove semantic flag
	No_Side_Effect_Removal
	(N_Assignment_Statement): Add semantic flag No_Finalize_Actions.
	* sinfo.ads (No_Ctrl_Actions): Adjust comment.
	(No_Finalize_Actions): New flag on assignment statements.
	(No_Side_Effect_Removal): Delete.
	* exp_aggr.adb (Build_Record_Aggr_Code): Remove obsolete comment and
	Ancestor_Is_Expression variable.  In the case of an extension, do
	not generate a call to Adjust manually, call Set_No_Finalize_Actions
	instead.  Do not set the tags, replace call to Make_Unsuppress_Block
	by Make_Suppress_Block and remove useless assertions.
	In the general case, call Initialize_Component.
	(Initialize_Controlled_Component): Delete.
	(Initialize_Simple_Component): Delete.
	(Initialize_Component): Do the low-level processing, but do not
	generate a call to Adjust manually, call Set_No_Finalize_Actions.
	(Process_Transient_Component): Delete.
	(Process_Transient_Component_Completion): Likewise.
	* exp_ch5.adb (Expand_Assign_Array): Deal with No_Finalize_Actions.
	(Expand_Assign_Array_Loop): Likewise.
	(Expand_N_Assignment_Statement): Likewise.
	(Make_Tag_Ctrl_Assignment): Likewise.
	* exp_util.adb (Remove_Side_Effects): Do not test the
	No_Side_Effect_Removal flag.
	* sem_prag.adb (Process_Suppress_Unsuppress): Give the warning in
	SPARK mode only for pragma Suppress.
	* tbuild.ads (Make_Suppress_Block): New declaration.
	(Make_Unsuppress_Block): Adjust comment.
	* tbuild.adb (Make_Suppress_Block): New procedure.
	(Make_Unsuppress_Block): Unsuppress instead of suppressing.

This code was dealing with build-in-place calls for nonlimited types, but
they no longer exist since Is_Build_In_Place_Result_Type => Is_Limited_View.

gcc/ada/

	* sem_ch5.adb (Analyze_Assignment): Turn Rhs into a constant and
	remove calls to the following subprograms.
	(Transform_BIP_Assignment): Delete.
	(Should_Transform_BIP_Assignment): Likewise.

Remove routine that is no referenced after deconstructing of restriction
SPARK_05.

gcc/ada/

	* sem_util.ads (Is_Inherited_Operation_For_Type): Remove spec.
	* sem_util.adb (Is_Inherited_Operation_For_Type): Remove body.

This avoids repeatedly calling Unqualify on the same node, removes a dead
call to Generate_Finalization_Actions, a redundant setting of Assignment_OK
and reuses a local variable more consistently.  No functional changes.

gcc/ada/

	* exp_aggr.adb (Build_Record_Aggr_Code): Add new variable Ancestor_Q
	to store the result of Unqualify on Ancestor.  Remove the dead call
	to Generate_Finalization_Actions in the case of another aggregate as
	ancestor part.  Remove the redundant setting of Assignment_OK.  Use
	Init_Typ in lieu of Etype (Ancestor) more consistently.

This happens when the ancestor part is itself an aggregate: in this case,
the tag of the extension aggregate is wrongly set to that of the ancestor.

gcc/ada/

	* exp_aggr.adb (Build_Record_Aggr_Code): In the case of an extension
	aggregate of a limited type whose ancestor part is an aggregate, do
	not skip the final code assigning the tag of the extension.

Implement the SPARK RM change that defines attribute Initialized
as being ghost, i.e. only allowed where a ghost entity would be allowed.

gcc/ada/

	* ghost.adb (Check_Ghost_Context): Allow absence of Ghost_Id
	for attribute. Update error message to mention Ghost_Predicate.
	(Is_Ghost_Attribute_Reference): New query.
	* ghost.ads (Is_Ghost_Attribute_Reference): New query.
	* sem_attr.adb (Resolve_Attribute): Check ghost context for ghost
	attributes.