gcc/ada/
* sem_res.adb (Resolve_Declare_Expression): Retrieve the created
block entity that is the scope of the local declarations, from
either a local object declaration or an object renaming
declaration. The block entity does not have an explicit
declaration, but appears as the scope of all locally declared
objects.
gcc/ada/
* sem_ch3.adb (Analyze_Object_Declaration): Limit scope of a
local object by hiding it from local subprograms; simplify
nested if-then-if-then condition for an Ada 83 restriction.
(Array_Type_Declaration): Confirm with assertion when the else
branch is executed.
(Find_Type_Of_Object): Simplify membership test with a subtype
range.
gcc/ada/
* sem_prag.adb (Analyze_Global_In_Decl_Part): Update check to
reject volatile object for reading.
* sem_res.adb (Resolve_Actuals, Resolve_Entity_Name): Update
check to reject volatile object for reading.
* sem_util.adb, sem_util.ads
(Check_Nonvolatile_Function_Profile,
Has_Effectively_Volatile_Profile): Detect use of volatile object
for reading.
(Has_Enabled_Property): Accept constants as well.
(Is_Effectively_Volatile_For_Reading): New function based on
existing Is_Effectively_Volatile.
(Is_Effectively_Volatile_Object_For_Reading): Adapted from the
existing Is_Effectively_Volatile_Object, using a shared
implementation in Is_Effectively_Volatile_Object_Shared.
gcc/ada/
* exp_ch7.adb (Check_Unnesting_In_Decls_Or_Stmts): In the case
of an if-statement, call Unnest_If_Statement to determine
whether there are nested subprograms in any of the statement
lists of the "if" parts that require a wrapping procedure to
handle possible up-level refeferences.
(Unnest_Block): Call Check_Unnesting_In_Handlers to do unnesting
of subprograms in exception handlers of the block statement.
(Unnest_If_Statement): New procedure to traverse the parts of an
if-statement and create wrapper procedures as needed to
encapsulate nested subprograms that may make up-level
references.
(Check_Stmts_For_Subp_Unnesting): New support procedure in
Unnest_If_Statement to traverse a statement list looking for
top-level subprogram bodies that require wrapping inside a
procedure (via Unnest_Statement_List) as well as possibly having
other statements (block, loop, if) that may themselves require
an unnesting transformation (via
Check_Unnesting_In_Decls_Or_Stmts).
(Unnest_Statement_List): New support procedure to traverse the
statements of a statement list that contains subprogram bodies
at the top level and replace the statement list with a wrapper
procedure body encapsulating the statements and a call to the
procedure.
gcc/ada/
* doc/gnat_rm/standard_and_implementation_defined_restrictions.rst
(No_Local_Timing_Events): Package Timing_Events is a child of
Ada.Real_Time, not of Ada.
* gnat_rm.texi: Regenerate.
This enables SLP store group splitting also for loop vectorization.
For the existing testcase gcc.dg/vect/vect-complex-5.c this then
generates much better code, likewise for the PR97428 testcase.
Both of those have a splitting opportunity splitting the group
into two equal (vector-sized) halves, still the patch enables
quite arbitrary splitting since generally the interleaving scheme
results in quite awkward code for even small groups. If any
problems surface with this it's easy to restrict the splitting
to known-good cases.
2020-10-15 Richard Biener <rguenther@suse.de>
PR tree-optimization/97428
* tree-vect-slp.c (vect_analyze_slp_instance): Split store
groups also for loop vectorization.
* gcc.dg/vect/vect-complex-5.c: Expect to SLP.
* gcc.dg/vect/pr97428.c: Likewise.
When hashing a function type the parameter names are ignored.
Therefore, we should not write them into the export data.
Otherwise, minor changes in the order in which we process the
types can cause the export data to change uselessly, leading to
unnecessary rebuilds.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/262818
Make the types of the addr and data arguments in the __go_ptrace shim
match the types declared in Go and the types declared by the C ptrace
function, i.e., void*. This avoids a warning about an implicit
int-to-pointer cast on some platforms.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/262340
This patch fixes some bugs in the powerpc testsuite for runnable tests
whose expected values were endian dependent.
gcc/testsuite/ChangeLog:
2020-10-15 David Edelsohn <dje.gcc@gmail.com>
* gcc.target/powerpc/builtins-1-p9-runnable.c: Adjust for big endian.
* gcc.target/powerpc/builtins-7-p9-runnable.c: Same.
It looks like I did a s/a/__a/ substition in one of these headers, and
then copied it to the other one.
libstdc++-v3/ChangeLog:
* include/std/concepts: Fix typos in copyright notice.
* include/std/ranges: Likewise.
Trying to diagnose the problem with an implicit copy function breaks if the
function isn't actually a copy function.
gcc/cp/ChangeLog:
PR c++/95844
* decl.c (copy_fn_p): Return false for a function that is neither a
constructor nor an assignment operator.
(move_signature_fn_p): Likewise.
gcc/testsuite/ChangeLog:
PR c++/95844
* g++.dg/cpp2a/spaceship-eq10.C: New test.
This PR points out that when printing the parameter mapping for a
pointer-to-member-function, the output was truncated:
[with T = void (X::*]
Fixed by printing the abstract declarator for pointers-to-members in
cxx_pretty_printer::type_id. So now we print:
[with T = void (X::*)()]
But when I tried a pointer-to-data-member, I got
[with T = ‘offset_type’ not supported by simple_type_specifier)‘offset_type’ not supported by direct_abstract_declarator]
so had to fix that too so that we now print:
[with T = int X::*]
or
[with T = int (X::*)[5]]
when the type is an array type. Which is what PR85901 was about.
gcc/cp/ChangeLog:
PR c++/97406
PR c++/85901
* cxx-pretty-print.c (pp_cxx_type_specifier_seq): Handle OFFSET_TYPE.
(cxx_pretty_printer::abstract_declarator): Fix the printing of ')'.
(cxx_pretty_printer::direct_abstract_declarator): Handle OFFSET_TYPE.
(cxx_pretty_printer::type_id): Likewise. Print the abstract declarator
for pointers-to-members.
gcc/testsuite/ChangeLog:
PR c++/97406
PR c++/85901
* g++.dg/diagnostic/ptrtomem1.C: New test.
* g++.dg/diagnostic/ptrtomem2.C: New test.
Nvptx currently doesn't support atomics if it involves a stack address.
PR97444 is open about.
Xfail corresponding execution fails in gcc.dg/atomic. Tested on nvptx.
gcc/testsuite/ChangeLog:
2020-10-15 Tom de Vries <tdevries@suse.de>
* gcc.dg/atomic/c11-atomic-exec-6.c: Xfail execution for nvptx.
* gcc.dg/atomic/c11-atomic-exec-7.c: Same.
* gcc.dg/atomic/stdatomic-op-5.c: Same.
The nvptx port has an -m32 option, but it's not clear whether this
was ever build/tested/used.
Don't expose to user anymore. Tested on nvptx.
gcc/ChangeLog:
2020-10-15 Tom de Vries <tdevries@suse.de>
PR target/97436
* config/nvptx/nvptx.opt (m32): Comment out.
* doc/invoke.texi (NVPTX options): Remove -m32.
gcc/testsuite/ChangeLog:
2020-10-15 Tom de Vries <tdevries@suse.de>
PR target/97436
* gcc.target/nvptx/atomic_fetch-3.c: Remove.
This fixes the missing constant offset from TARGET_MEM_REF dumping.
2020-10-15 Richard Biener <rguenther@suse.de>
* tree-pretty-print.c (dump_mem_ref): Print constant offset
also for TARGET_MEM_REF.
This fixes the case where the insertion iterator for the live stmt
is the end of a BB by adjusting the dominance query to the definition
of the def we're substituting.
2020-10-15 Richard Biener <rguenther@suse.de>
* tree-vect-loop.c (vectorizable_live_operation): Adjust
dominance query.
* gcc.dg/vect/bb-slp-52.c: New testcase.
gcc/ada/
* sem_ch10.adb (Install_With_Clause): Fix implementation of Ada
2005 AI-262 by taking into account generic packages. Minor
reformatting.
* libgnat/a-cbhase.ads, libgnat/a-cbhase.adb: Remove use clause
on runtime unit spec.
gcc/ada/
* sem_prag.adb (Analyze_Pragma): Adding semantic support of
Standard to Default_Storage_Pool.
* freeze.adb (Freeze_Entity): If pragma Default_Storage_Pool
applies and it is set to Standard then use the global pool as
the associated storage pool of the access type.
gcc/ada/
* checks.adb (Apply_Predicate_Check): Generate "infinite
recursion" warning message even if run-time predicate checking
is disabled.
* exp_ch6.adb (Expand_Simple_Function_Return): In testing
whether the returned expression is a function call, look for the
case where the call has been transformed into a dereference of
an access value that designates the result of a function call.
* sem_ch3.adb (Analyze_Object_Declaration): Legality checking
for a static expression is unaffected by assertion policy (and,
in particular, enabling/disabling of subtype predicates. To get
the right legality checking, we need to call
Check_Expression_Against_Static_Predicate for a static
expression even if predicate checking is disabled for the given
predicate-bearing subtype. On the other hand, we don't want to
call Make_Predicate_Check unless predicate checking is enabled.
* sem_ch7.adb (Uninstall_Declarations.Preserve_Full_Attributes):
Preserve the Predicates_Ignored attribute.
* sem_eval.adb (Check_Expression_Against_Static_Predicate):
Previously callers ensured that this procedure was only called
if predicate checking was enabled; that is no longer the case,
so predicates-disabled case must be handled.
* sem_prag.adb (Analyze_Pragma): Fix bug in setting
Predicates_Ignored attribute in Predicate pragma case.
gcc/ada/
* freeze.adb (Freeze_Fixed_Point_Type): Do not scale the bounds
of a declared subtype using the 'Small of the type; this is
done during resolution of the bound itself, unlike what is done
for the bounds of the base type, which are used to determine its
required size. Previous code performed this scaling twice,
leading to meaningless values for such a subtype.
gcc/ada/
* sem_ch3.adb (Process_Subtype): Combine guards for
Null_Exclusion_Present in May_Have_Null_Exclusion; use this
combined guard when checking AI-231.
gcc/ada/
* sem_prag.adb (Is_Acceptable_Dim3): Use Is_RTE to not pull CUDA
package unless necessary; rename local Tmp variable; iterate
with procedural Next.
gcc/ada/
* sem_ch3.adb (Array_Type_Declaration): Refine type of a local
variable.
(Make_Index): Simplify to avoid assignment with a type entity
and then backtracking by reassigning to Empty; remove excessive
whitespace.
* sem_ch9.adb (Analyze_Entry_Body): Remove extra parens.
gcc/ada/
* sem_ch13.adb (Add_Predicates): Prevent analyzing twice the
same pragma in case an inner package references the type with a
predicate (as opposed to defining the type).
