Re: [Ping, Fortran, Patch, PR78466, coarray, v1.1] Fix Explicit cobounds of a procedures parameter not respected
Hi all,
just pinging on this patch. The attached patch is rebased to an unmodified
master as of this afternoon (CEST 3 p.m.).
Anyone in for a review?
Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline?
Regards,
Andre
On Wed, 10 Jul 2024 11:17:44 +0200
Andre Vehreschild wrote:
> Hi all,
>
> the attached patch fixes explicit cobounds of procedure parameters not
> respected. The central issue is, that class (array) types store their
> attributes and `as` in the first component of the derived type. This made
> comparison of existing types harder and gfortran confused generated trees for
> different cobounds. The attached patch fixes this.
>
> Note, the patch is based
> on https://gcc.gnu.org/pipermail/fortran/2024-July/060645.html . Without it
> the
> test poly_run_2 fails.
>
> Regtests ok on x86_64-pc-linux-gnu/Fedora 39. Ok for mainline?
>
> This patch also fixes PR fortran/80774.
>
> Regards,
> Andre
> --
> Andre Vehreschild * Email: vehre ad gmx dot de
--
Andre Vehreschild * Email: vehre ad gmx dot de
From 5de2037da1bca3e084838458b60751965020c031 Mon Sep 17 00:00:00 2001
From: Andre Vehreschild
Date: Thu, 31 Dec 2020 10:40:30 +0100
Subject: [PATCH] Fortran: Fix Explicit cobounds of a procedures parameter not
respected [PR78466]
Explicit cobounds of class array procedure parameters were not taken
into account. Furthermore were different cobounds in distinct
procedure parameter lists mixed up, i.e. the last definition was taken
for all. The bounds are now regenerated when tree's and expr's bounds
do not match.
PR fortran/78466
PR fortran/80774
gcc/fortran/ChangeLog:
* array.cc (gfc_compare_array_spec): Take cotype into account.
* class.cc (gfc_build_class_symbol): Coarrays are also arrays.
* gfortran.h (IS_CLASS_COARRAY_OR_ARRAY): New macro to detect
regular and coarray class arrays.
* interface.cc (compare_components): Take codimension into
account.
* resolve.cc (resolve_symbol): Improve error message.
* simplify.cc (simplify_bound_dim): Remove duplicate.
* trans-array.cc (gfc_trans_array_cobounds): Coarrays are also
arrays.
(gfc_trans_array_bounds): Same.
(gfc_trans_dummy_array_bias): Same.
(get_coarray_as): Get the as having a non-zero codim.
(is_explicit_coarray): Detect explicit coarrays.
(gfc_conv_expr_descriptor): Create a new descriptor for explicit
coarrays.
* trans-decl.cc (gfc_build_qualified_array): Coarrays are also
arrays.
(gfc_build_dummy_array_decl): Same.
(gfc_get_symbol_decl): Same.
(gfc_trans_deferred_vars): Same.
* trans-expr.cc (class_scalar_coarray_to_class): Get the
descriptor from the correct location.
(gfc_conv_variable): Pick up the descriptor when needed.
* trans-types.cc (gfc_is_nodesc_array): Coarrays are also
arrays.
(gfc_get_nodesc_array_type): Indentation fix only.
(cobounds_match_decl): Match a tree's bounds to the expr's
bounds and return true, when they match.
(gfc_get_derived_type): Create a new type tree/descriptor, when
the cobounds of the existing declaration and expr to not
match. This happends for class arrays in parameter list, when
there are different cobound declarations.
gcc/testsuite/ChangeLog:
* gfortran.dg/coarray/poly_run_1.f90: Activate old test code.
* gfortran.dg/coarray/poly_run_2.f90: Activate test. It was
stopping before and passing without an error.
---
gcc/fortran/array.cc | 3 +
gcc/fortran/class.cc | 8 +-
gcc/fortran/gfortran.h| 5 ++
gcc/fortran/interface.cc | 7 ++
gcc/fortran/resolve.cc| 3 +-
gcc/fortran/simplify.cc | 2 -
gcc/fortran/trans-array.cc| 53 -
gcc/fortran/trans-decl.cc | 20 ++---
gcc/fortran/trans-expr.cc | 34 ++---
gcc/fortran/trans-types.cc| 74 ---
.../gfortran.dg/coarray/poly_run_1.f90| 33 -
.../gfortran.dg/coarray/poly_run_2.f90| 28 ---
12 files changed, 207 insertions(+), 63 deletions(-)
diff --git a/gcc/fortran/array.cc b/gcc/fortran/array.cc
index e9934f1491b2..79c774d59a0b 100644
--- a/gcc/fortran/array.cc
+++ b/gcc/fortran/array.cc
@@ -1017,6 +1017,9 @@ gfc_compare_array_spec (gfc_array_spec *as1, gfc_array_spec *as2)
if (as1->type != as2->type)
return 0;
+ if (as1->cotype != as2->cotype)
+return 0;
+
if (as1->type == AS_EXPLICIT)
for (i = 0; i < as1->rank + as1->corank; i++)
{
diff --git a/gcc/fortran/class.cc b/gcc/fortran/class.cc
index abe89630be3c..b9dcc0a3d98c 100644
--- a/gcc/fortran/class.cc
+++ b/gcc/fortran/class.cc
@@ -709,8 +709,12 @@ gfc_build_class_symbol (gfc_typespec *ts, symbol_attribute *attr,
work on the declared type. All array type other than deferred shape or
assumed rank are added to the function namespace to ensure that they
are properly distinguished. */
- if (attr->dummy && !a
Re: [Ping, Fortran, Patch, PR82904] Fix [11/12/13/14/15 Regression][Coarray] ICE in make_ssa_name_fn, at tree-ssanames.c:261
Hi all,
pinging for attached patch rebased on master and my patch for 78466.
Anyone in for a review?
Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline?
Regards,
Andre
On Wed, 10 Jul 2024 14:51:53 +0200
Andre Vehreschild wrote:
> Hi all,
>
> the patch attached fixes the use of an uninitialized variable for the string
> length in the declaration of the char[1:_len] type (the _len!). The type for
> save'd deferred length char arrays is now char*, so that there is no need for
> the length in the type declaration anymore. The length is of course still
> provided and needed later on.
>
> I hope this fixes the ICE in the IPA: inline phase, because I never saw it. Is
> that what you had in mind @Richard?
>
> Regtests ok on x86_64-pc-linux-gnu/Fedora 39. Ok for mainline?
>
> Regards,
> Andre
> --
> Andre Vehreschild * Email: vehre ad gmx dot de
--
Andre Vehreschild * Email: vehre ad gmx dot de
From e66e66ed6ac191763b430789f804fabafd9dfc4c Mon Sep 17 00:00:00 2001
From: Andre Vehreschild
Date: Wed, 10 Jul 2024 14:37:37 +0200
Subject: [PATCH] Fortran: Use char* for deferred length character arrays
[PR82904]
Randomly during compiling the pass IPA: inline would ICE. This was
caused by a saved deferred length string. The length variable was not
set, but the variable was used in the array's declaration. Now using a
character pointer to prevent this.
gcc/fortran/ChangeLog:
* trans-types.cc (gfc_sym_type): Use type `char*` for saved
deferred length char arrays.
* trans.cc (get_array_span): Get `.span` also for `char*` typed
arrays, i.e. for those that have INTEGER_TYPE instead of
ARRAY_TYPE.
gcc/testsuite/ChangeLog:
* gfortran.dg/deferred_character_38.f90: New test.
---
gcc/fortran/trans-types.cc| 6 --
gcc/fortran/trans.cc | 4 +++-
.../gfortran.dg/deferred_character_38.f90 | 20 +++
3 files changed, 27 insertions(+), 3 deletions(-)
create mode 100644 gcc/testsuite/gfortran.dg/deferred_character_38.f90
diff --git a/gcc/fortran/trans-types.cc b/gcc/fortran/trans-types.cc
index 6743adfc9bab..59d72136a0de 100644
--- a/gcc/fortran/trans-types.cc
+++ b/gcc/fortran/trans-types.cc
@@ -2334,8 +2334,10 @@ gfc_sym_type (gfc_symbol * sym, bool is_bind_c)
|| ((sym->attr.result || sym->attr.value)
&& sym->ns->proc_name
&& sym->ns->proc_name->attr.is_bind_c)
- || (sym->ts.deferred && (!sym->ts.u.cl
- || !sym->ts.u.cl->backend_decl))
+ || (sym->ts.deferred
+ && (!sym->ts.u.cl
+ || !sym->ts.u.cl->backend_decl
+ || sym->attr.save))
|| (sym->attr.dummy
&& sym->attr.value
&& gfc_length_one_character_type_p (&sym->ts
diff --git a/gcc/fortran/trans.cc b/gcc/fortran/trans.cc
index 1067e032621b..d4c54093cbc3 100644
--- a/gcc/fortran/trans.cc
+++ b/gcc/fortran/trans.cc
@@ -398,7 +398,9 @@ get_array_span (tree type, tree decl)
return gfc_conv_descriptor_span_get (decl);
/* Return the span for deferred character length array references. */
- if (type && TREE_CODE (type) == ARRAY_TYPE && TYPE_STRING_FLAG (type))
+ if (type
+ && (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == INTEGER_TYPE)
+ && TYPE_STRING_FLAG (type))
{
if (TREE_CODE (decl) == PARM_DECL)
decl = build_fold_indirect_ref_loc (input_location, decl);
diff --git a/gcc/testsuite/gfortran.dg/deferred_character_38.f90 b/gcc/testsuite/gfortran.dg/deferred_character_38.f90
new file mode 100644
index ..d5a6c0e50136
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/deferred_character_38.f90
@@ -0,0 +1,20 @@
+! { dg-do run }
+
+! Check for PR fortran/82904
+! Contributed by G.Steinmetz
+
+! This test checks that 'IPA pass: inline' passes.
+! The initial version of the testcase contained coarrays, which does not work
+! yet.
+
+program p
+ save
+ character(:), allocatable :: x
+ character(:), allocatable :: y
+ allocate (character(3) :: y)
+ allocate (x, source='abc')
+ y = x
+
+ if (y /= 'abc') stop 1
+end
+
--
2.45.2
Re: [Ping, Patch, Fortran, PR88624, v1] Fix Rejects allocatable coarray passed as a dummy argument
Hi all,
and another ping...
Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline?
- Andre
On Thu, 11 Jul 2024 15:42:54 +0200
Andre Vehreschild wrote:
> Hi all,
>
> attached patch fixes using of coarrays as dummy arguments. The coarray
> dummy argument was not dereferenced correctly, which is fixed now.
>
> Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline.
>
> Regards,
> Andre
> --
> Andre Vehreschild * Email: vehre ad gcc dot gnu dot org
--
Andre Vehreschild * Email: vehre ad gmx dot de
From 7af72686efe21c14672b909646862a6fd80ca7b4 Mon Sep 17 00:00:00 2001
From: Andre Vehreschild
Date: Thu, 11 Jul 2024 10:07:12 +0200
Subject: [PATCH] [Fortran] Fix Rejects allocatable coarray passed as a dummy
argument [88624]
Coarray parameters of procedures/functions need to be dereffed, because
they are references to the descriptor but the routine expected the
descriptor directly.
PR fortran/88624
gcc/fortran/ChangeLog:
* trans-expr.cc (gfc_conv_procedure_call): Treat
pointers/references (e.g. from parameters) correctly by derefing
them.
gcc/testsuite/ChangeLog:
* gfortran.dg/coarray/dummy_1.f90: Add calling function trough
function.
---
gcc/fortran/trans-expr.cc | 35 +--
gcc/testsuite/gfortran.dg/coarray/dummy_1.f90 | 2 ++
2 files changed, 27 insertions(+), 10 deletions(-)
diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc
index d9eb333abcb1..feb43fdec746 100644
--- a/gcc/fortran/trans-expr.cc
+++ b/gcc/fortran/trans-expr.cc
@@ -7773,16 +7773,26 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym,
&& CLASS_DATA (fsym)->attr.codimension
&& !CLASS_DATA (fsym)->attr.allocatable)))
{
- tree caf_decl, caf_type;
+ tree caf_decl, caf_type, caf_desc = NULL_TREE;
tree offset, tmp2;
caf_decl = gfc_get_tree_for_caf_expr (e);
caf_type = TREE_TYPE (caf_decl);
-
- if (GFC_DESCRIPTOR_TYPE_P (caf_type)
- && (GFC_TYPE_ARRAY_AKIND (caf_type) == GFC_ARRAY_ALLOCATABLE
- || GFC_TYPE_ARRAY_AKIND (caf_type) == GFC_ARRAY_POINTER))
- tmp = gfc_conv_descriptor_token (caf_decl);
+ if (POINTER_TYPE_P (caf_type)
+ && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (caf_type)))
+ caf_desc = TREE_TYPE (caf_type);
+ else if (GFC_DESCRIPTOR_TYPE_P (caf_type))
+ caf_desc = caf_type;
+
+ if (caf_desc
+ && (GFC_TYPE_ARRAY_AKIND (caf_desc) == GFC_ARRAY_ALLOCATABLE
+ || GFC_TYPE_ARRAY_AKIND (caf_desc) == GFC_ARRAY_POINTER))
+ {
+ tmp = POINTER_TYPE_P (TREE_TYPE (caf_decl))
+ ? build_fold_indirect_ref (caf_decl)
+ : caf_decl;
+ tmp = gfc_conv_descriptor_token (tmp);
+ }
else if (DECL_LANG_SPECIFIC (caf_decl)
&& GFC_DECL_TOKEN (caf_decl) != NULL_TREE)
tmp = GFC_DECL_TOKEN (caf_decl);
@@ -7795,8 +7805,8 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym,
vec_safe_push (stringargs, tmp);
- if (GFC_DESCRIPTOR_TYPE_P (caf_type)
- && GFC_TYPE_ARRAY_AKIND (caf_type) == GFC_ARRAY_ALLOCATABLE)
+ if (caf_desc
+ && GFC_TYPE_ARRAY_AKIND (caf_desc) == GFC_ARRAY_ALLOCATABLE)
offset = build_int_cst (gfc_array_index_type, 0);
else if (DECL_LANG_SPECIFIC (caf_decl)
&& GFC_DECL_CAF_OFFSET (caf_decl) != NULL_TREE)
@@ -7806,8 +7816,13 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym,
else
offset = build_int_cst (gfc_array_index_type, 0);
- if (GFC_DESCRIPTOR_TYPE_P (caf_type))
- tmp = gfc_conv_descriptor_data_get (caf_decl);
+ if (caf_desc)
+ {
+ tmp = POINTER_TYPE_P (TREE_TYPE (caf_decl))
+ ? build_fold_indirect_ref (caf_decl)
+ : caf_decl;
+ tmp = gfc_conv_descriptor_data_get (tmp);
+ }
else
{
gcc_assert (POINTER_TYPE_P (caf_type));
diff --git a/gcc/testsuite/gfortran.dg/coarray/dummy_1.f90 b/gcc/testsuite/gfortran.dg/coarray/dummy_1.f90
index 33e95853ad4a..c437b2a10fc4 100644
--- a/gcc/testsuite/gfortran.dg/coarray/dummy_1.f90
+++ b/gcc/testsuite/gfortran.dg/coarray/dummy_1.f90
@@ -66,5 +66,7 @@
if (lcobound(A, dim=1) /= 2) STOP 13
if (ucobound(A, dim=1) /= 3) STOP 14
if (lcobound(A, dim=2) /= 5) STOP 15
+
+call sub4(A) ! Check PR88624 is fixed.
end subroutine sub5
end
--
2.45.2
Re: [Ping, Patch, Fortran, PR84244, v1] Fix ICE in recompute_tree_invariant_for_addr_expr, at tree.c:4535
Hi all,
and the last ping.
Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline?
Regards,
Andre
On Thu, 11 Jul 2024 16:05:09 +0200
Andre Vehreschild wrote:
> Hi all,
>
> the attached patch fixes a segfault in the compiler, where for pointer
> components of a derived type the caf_token in the component was not
> set, when the derived was previously used outside of a coarray.
>
> Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline?
>
> Regards,
> Andre
--
Andre Vehreschild * Email: vehre ad gmx dot de
From ff2d1145fc008f23e835054e6bb668be0430fdd7 Mon Sep 17 00:00:00 2001
From: Andre Vehreschild
Date: Thu, 11 Jul 2024 15:44:56 +0200
Subject: [PATCH] [Fortran] Fix ICE in recompute_tree_invariant_for_addr_expr,
at tree.c:4535 [PR84244]
Declaring an unused function with a derived type having a pointer
component and using that derived type as a coarray, lead the compiler to
ICE because the caf_token for the pointer was not linked into the
component correctly.
PR fortran/84244
gcc/fortran/ChangeLog:
* trans-types.cc (gfc_get_derived_type): When a caf_sub_token is
generated for a component, link it to the component it is
generated for (the previous one).
gcc/testsuite/ChangeLog:
* gfortran.dg/coarray/ptr_comp_5.f08: New test.
---
gcc/fortran/trans-types.cc| 6 +-
.../gfortran.dg/coarray/ptr_comp_5.f08| 19 +++
2 files changed, 24 insertions(+), 1 deletion(-)
create mode 100644 gcc/testsuite/gfortran.dg/coarray/ptr_comp_5.f08
diff --git a/gcc/fortran/trans-types.cc b/gcc/fortran/trans-types.cc
index 59d72136a0de..71415385c8c3 100644
--- a/gcc/fortran/trans-types.cc
+++ b/gcc/fortran/trans-types.cc
@@ -2661,7 +2661,7 @@ gfc_get_derived_type (gfc_symbol * derived, int codimen)
tree *chain = NULL;
bool got_canonical = false;
bool unlimited_entity = false;
- gfc_component *c;
+ gfc_component *c, *last_c = nullptr;
gfc_namespace *ns;
tree tmp;
bool coarray_flag, class_coarray_flag;
@@ -2961,10 +2961,14 @@ gfc_get_derived_type (gfc_symbol * derived, int codimen)
types. */
if (class_coarray_flag || !c->backend_decl)
c->backend_decl = field;
+ if (c->attr.caf_token && last_c)
+ last_c->caf_token = field;
if (c->attr.pointer && (c->attr.dimension || c->attr.codimension)
&& !(c->ts.type == BT_DERIVED && strcmp (c->name, "_data") == 0))
GFC_DECL_PTR_ARRAY_P (c->backend_decl) = 1;
+
+ last_c = c;
}
/* Now lay out the derived type, including the fields. */
diff --git a/gcc/testsuite/gfortran.dg/coarray/ptr_comp_5.f08 b/gcc/testsuite/gfortran.dg/coarray/ptr_comp_5.f08
new file mode 100644
index ..ed3a8db13fa5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/coarray/ptr_comp_5.f08
@@ -0,0 +1,19 @@
+! { dg-do compile }
+
+! Check PR84244 does not ICE anymore.
+
+program ptr_comp_5
+ integer, target :: dest = 42
+ type t
+integer, pointer :: p
+ end type
+ type(t) :: o[*]
+
+ o%p => dest
+contains
+ ! This unused routine is crucial for the ICE.
+ function f(x)
+type(t), intent(in) ::x
+ end function
+end program
+
--
2.45.2
[Fortran, Patch, coarray, PR84246] Fix for [Coarray] ICE in conv_caf_send, at fortran/trans-intrinsic.c:1950
Hi all,
attached patch fixes an ICE in coarray code, where the coarray expression
already was a pointer, which confused the compiler. Furthermore have I removed
a rewrite to a caf_send late in the trans-phase. This is now done in the
resolve stage to have only a single place for these rewriting actions.
Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline?
Regards,
Andre
--
Andre Vehreschild * Email: vehre ad gmx dot de
From e073b32bd792f7db92334e89e546095c9ad583f8 Mon Sep 17 00:00:00 2001
From: Andre Vehreschild
Date: Wed, 17 Jul 2024 12:30:52 +0200
Subject: [PATCH] Fortran: Fix [Coarray] ICE in conv_caf_send, at
fortran/trans-intrinsic.c:1950 [PR84246]
Fix ICE caused by converted expression already being pointer by checking
for its type. Lift rewrite to caf_send completely into resolve and
prevent more temporary arrays.
PR fortran/84246
gcc/fortran/ChangeLog:
* resolve.cc (caf_possible_reallocate): Detect arrays that may
be reallocated by caf_send.
(resolve_ordinary_assign): More reliably detect assignments
where a rewrite to caf_send is needed.
* trans-expr.cc (gfc_trans_assignment_1): Remove rewrite to
caf_send, because this is done by resolve now.
* trans-intrinsic.cc (conv_caf_send): Prevent unneeded temporary
arrays.
libgfortran/ChangeLog:
* caf/single.c (send_by_ref): Created array's lbound is now 1
and the offset set correctly.
gcc/testsuite/ChangeLog:
* gfortran.dg/coarray_allocate_7.f08: Adapt to array being
allocate by caf_send.
---
gcc/fortran/resolve.cc| 18 +++
gcc/fortran/trans-expr.cc | 23 ---
gcc/fortran/trans-intrinsic.cc| 17 --
.../gfortran.dg/coarray_allocate_7.f08| 4 +---
libgfortran/caf/single.c | 6 ++---
5 files changed, 32 insertions(+), 36 deletions(-)
diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc
index 503029364c14..3bf48f793d80 100644
--- a/gcc/fortran/resolve.cc
+++ b/gcc/fortran/resolve.cc
@@ -11450,6 +11450,23 @@ gfc_resolve_blocks (gfc_code *b, gfc_namespace *ns)
}
}
+bool
+caf_possible_reallocate (gfc_expr *e)
+{
+ symbol_attribute caf_attr;
+ gfc_ref *last_arr_ref = nullptr;
+
+ caf_attr = gfc_caf_attr (e);
+ if (!caf_attr.codimension || !caf_attr.allocatable || !caf_attr.dimension)
+return false;
+
+ /* Only full array refs can indicate a needed reallocation. */
+ for (gfc_ref *ref = e->ref; ref; ref = ref->next)
+if (ref->type == REF_ARRAY && ref->u.ar.dimen)
+ last_arr_ref = ref;
+
+ return last_arr_ref && last_arr_ref->u.ar.type == AR_FULL;
+}
/* Does everything to resolve an ordinary assignment. Returns true
if this is an interface assignment. */
@@ -11694,6 +11711,7 @@ resolve_ordinary_assign (gfc_code *code, gfc_namespace *ns)
bool caf_convert_to_send = flag_coarray == GFC_FCOARRAY_LIB
&& (lhs_coindexed
+ || caf_possible_reallocate (lhs)
|| (code->expr2->expr_type == EXPR_FUNCTION
&& code->expr2->value.function.isym
&& code->expr2->value.function.isym->id == GFC_ISYM_CAF_GET
diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc
index feb43fdec746..d4bfb39a774f 100644
--- a/gcc/fortran/trans-expr.cc
+++ b/gcc/fortran/trans-expr.cc
@@ -12598,29 +12598,6 @@ gfc_trans_assignment_1 (gfc_expr * expr1, gfc_expr * expr2, bool init_flag,
expr1->must_finalize = 0;
}
- else if (flag_coarray == GFC_FCOARRAY_LIB
- && lhs_caf_attr.codimension && rhs_caf_attr.codimension
- && ((lhs_caf_attr.allocatable && lhs_refs_comp)
- || (rhs_caf_attr.allocatable && rhs_refs_comp)))
-{
- /* Only detour to caf_send[get][_by_ref] () when the lhs or rhs is an
- allocatable component, because those need to be accessed via the
- caf-runtime. No need to check for coindexes here, because resolve
- has rewritten those already. */
- gfc_code code;
- gfc_actual_arglist a1, a2;
- /* Clear the structures to prevent accessing garbage. */
- memset (&code, '\0', sizeof (gfc_code));
- memset (&a1, '\0', sizeof (gfc_actual_arglist));
- memset (&a2, '\0', sizeof (gfc_actual_arglist));
- a1.expr = expr1;
- a1.next = &a2;
- a2.expr = expr2;
- a2.next = NULL;
- code.ext.actual = &a1;
- code.resolved_isym = gfc_intrinsic_subroutine_by_id (GFC_ISYM_CAF_SEND);
- tmp = gfc_conv_intrinsic_subroutine (&code);
-}
else if (!is_poly_assign && expr2->must_finalize
&& expr1->ts.type == BT_CLASS
&& expr2->ts.type == BT_CLASS)
diff --git a/gcc/fortran/trans-intrinsic.cc b/gcc/fortran/trans-intrinsic.cc
index 180d0d7a88c6..d58bea30101c 100644
--- a/gcc/fortran/trans-intrinsic.cc
+++ b/gcc/fortran/trans-intrinsic.cc
@@ -1945,11 +1945,14 @@ conv_caf_send (gfc_code *code) {
tree lhs_type = NULL_TREE;
tree vec = null_pointer_node, rhs_vec = null_pointer_node;
symbol_attribute lhs_caf_attr, rhs_caf_attr;
+ bool lhs_is_coindexe
Re: [Ping, Fortran, Patch, PR82904] Fix [11/12/13/14/15 Regression][Coarray] ICE in make_ssa_name_fn, at tree-ssanames.c:261
Hi Andre, It looks good to me. I am happy to see that the principle of the patch has Richi's blessing too. OK for mainline. I leave it for you (and Richi?) to decide whether to backport in time for the 14.2 release. Regards Paul On Wed, 17 Jul 2024 at 14:08, Andre Vehreschild wrote: > Hi all, > > pinging for attached patch rebased on master and my patch for 78466. > > Anyone in for a review? > > Regtests ok on x86_64-pc-linux-gnu / Fedora 39. Ok for mainline? > > Regards, > Andre > > On Wed, 10 Jul 2024 14:51:53 +0200 > Andre Vehreschild wrote: > > > Hi all, > > > > the patch attached fixes the use of an uninitialized variable for the > string > > length in the declaration of the char[1:_len] type (the _len!). The type > for > > save'd deferred length char arrays is now char*, so that there is no > need for > > the length in the type declaration anymore. The length is of course still > > provided and needed later on. > > > > I hope this fixes the ICE in the IPA: inline phase, because I never saw > it. Is > > that what you had in mind @Richard? > > > > Regtests ok on x86_64-pc-linux-gnu/Fedora 39. Ok for mainline? > > > > Regards, > > Andre > > -- > > Andre Vehreschild * Email: vehre ad gmx dot de > > > -- > Andre Vehreschild * Email: vehre ad gmx dot de >
[Patch, fortran] PR108889 -[12/13/14/15 Regression] (Re)Allocate in assignment shows used uninitialized memory warning with -Wall if LHS is unallocated
Hi All,
This patch is simple and well described by the ChangeLogs and the comments.
Regtests OK.
OK for mainline and backporting?
Cheers
Paul
Change.Logs
Description: Binary data
diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h
index ed1213a41cb..c1fb896f587 100644
--- a/gcc/fortran/gfortran.h
+++ b/gcc/fortran/gfortran.h
@@ -1950,6 +1950,10 @@ typedef struct gfc_symbol
/* Set if this should be passed by value, but is not a VALUE argument
according to the Fortran standard. */
unsigned pass_as_value:1;
+ /* Set if an allocatable array variable has been allocated in the current
+ scope. Used in the suppression of uninitialized warnings in reallocation
+ on assignment. */
+ unsigned allocated_in_scope:1;
/* Reference counter, used for memory management.
diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc
index 140d933e45d..aa7b90e483a 100644
--- a/gcc/fortran/trans-array.cc
+++ b/gcc/fortran/trans-array.cc
@@ -6580,6 +6580,8 @@ gfc_array_allocate (gfc_se * se, gfc_expr * expr, tree status, tree errmsg,
else
gfc_add_expr_to_block (&se->pre, set_descriptor);
+ expr->symtree->n.sym->allocated_in_scope = 1;
+
return true;
}
@@ -11060,6 +11062,8 @@ gfc_alloc_allocatable_for_assignment (gfc_loopinfo *loop,
stmtblock_t realloc_block;
stmtblock_t alloc_block;
stmtblock_t fblock;
+ stmtblock_t loop_pre_block;
+ gfc_ref *ref;
gfc_ss *rss;
gfc_ss *lss;
gfc_array_info *linfo;
@@ -11260,6 +11264,52 @@ gfc_alloc_allocatable_for_assignment (gfc_loopinfo *loop,
array1, build_int_cst (TREE_TYPE (array1), 0));
cond_null= gfc_evaluate_now (cond_null, &fblock);
+ /* If the data is null, set the descriptor bounds and offset. This suppresses
+ the maybe used uninitialized warning and forces the use of malloc because
+ the size is zero in all dimensions. Note that this block is only executed
+ if the lhs is unallocated and is only applied once in any namespace.
+ Component references are not subject to the warnings. */
+ for (ref = expr1->ref; ref; ref = ref->next)
+if (ref->type == REF_COMPONENT)
+ break;
+
+ if (!expr1->symtree->n.sym->allocated_in_scope && !ref)
+{
+ gfc_start_block (&loop_pre_block);
+ for (n = 0; n < expr1->rank; n++)
+ {
+ gfc_conv_descriptor_lbound_set (&loop_pre_block, desc,
+ gfc_rank_cst[n],
+ gfc_index_one_node);
+ gfc_conv_descriptor_ubound_set (&loop_pre_block, desc,
+ gfc_rank_cst[n],
+ gfc_index_zero_node);
+ gfc_conv_descriptor_stride_set (&loop_pre_block, desc,
+ gfc_rank_cst[n],
+ gfc_index_zero_node);
+ }
+
+ tmp = gfc_conv_descriptor_offset (desc);
+ gfc_add_modify (&loop_pre_block, tmp, gfc_index_zero_node);
+
+ tmp = fold_build2_loc (input_location, EQ_EXPR,
+ logical_type_node, array1,
+ build_int_cst (TREE_TYPE (array1), 0));
+ tmp = build3_v (COND_EXPR, tmp,
+ gfc_finish_block (&loop_pre_block),
+ build_empty_stmt (input_location));
+ gfc_prepend_expr_to_block (&loop->pre, tmp);
+
+ /* Mark so that rhs "used unallocated" warnings can be issued. Component
+ references do not generate the warnings. */
+ for (ref = expr1->ref; ref; ref = ref->next)
+ if (ref->type == REF_COMPONENT)
+ break;
+
+ if (!ref)
+ expr1->symtree->n.sym->allocated_in_scope = 1;
+}
+
tmp = build3_v (COND_EXPR, cond_null,
build1_v (GOTO_EXPR, jump_label1),
build_empty_stmt (input_location));
diff --git a/gcc/testsuite/gfortran.dg/pr108889.f90 b/gcc/testsuite/gfortran.dg/pr108889.f90
new file mode 100644
index 000..7fd4e3882a4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr108889.f90
@@ -0,0 +1,43 @@
+! { dg-do compile }
+! { dg-options "-Wall -fdump-tree-original" }
+!
+! Contributed by Tobias Burnus
+!
+program main
+ implicit none
+
+ type :: struct
+real, allocatable :: var(:)
+ end type struct
+
+ type(struct) :: single
+ real, allocatable :: ref1(:), ref2(:), ref3(:), ref4(:)
+
+ ref2 = [1,2,3,4,5]! Warnings here
+
+ single%var = ref2 ! No warnings for components
+ ref1 = single%var ! Warnings here
+ ref1 = [1,2,3,4,5]! Should not add to tree dump count
+
+ allocate (ref3(5))
+ ref3 = single%var ! No warnings following allocation
+
+ call set_ref4
+
+ call test (ref1)
+ call test (ref2)
+ call test (ref3)
+ call test (ref4)
+
+contains
+ subroutine test (arg)
+real, allocatable :: arg(:)
+if (size(arg) /= size(single%var)) stop 1
+if (lbound(arg, 1) /= 1) stop 2
+if (any (arg /= single%var)) stop 3
+ end
+ subroutine set_ref4
+ref4 = single%var ! Warnings in contained scope
+ end
+end
+! { df-final { scan-tree-dump-times "ubound = 0" 3 "original" } }
\ No newline at end of file
Re: [Patch, fortran] PR108889 -[12/13/14/15 Regression] (Re)Allocate in assignment shows used uninitialized memory warning with -Wall if LHS is unallocated
Hi Paul, isn't the ref you are computing here: + /* Mark so that rhs "used unallocated" warnings can be issued. Component +references do not generate the warnings. */ + for (ref = expr1->ref; ref; ref = ref->next) + if (ref->type == REF_COMPONENT) + break; not the same you compute before the outer if? I see at least no change to it in between. I haven't tested your patch yet, but will do when I have some grid power for my notebook. I am wondering what happens, when one uses a coarray here. Thanks for the patch. Regards, Andre On Thu, 18 Jul 2024 06:55:14 +0100 Paul Richard Thomas wrote: > Hi All, > > This patch is simple and well described by the ChangeLogs and the > comments. Regtests OK. > > OK for mainline and backporting? > > Cheers > > Paul -- Andre Vehreschild * Email: vehre ad gcc dot gnu dot org
