From patchwork Mon May 30 12:34:26 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tobias Burnus X-Patchwork-Id: 97911 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id E69C6B6F72 for ; Mon, 30 May 2011 22:34:50 +1000 (EST) Received: (qmail 8911 invoked by alias); 30 May 2011 12:34:46 -0000 Received: (qmail 8619 invoked by uid 22791); 30 May 2011 12:34:44 -0000 X-SWARE-Spam-Status: No, hits=1.0 required=5.0 tests=AWL, BAYES_00, KAM_STOCKTIP, RCVD_IN_DNSWL_NONE, TW_TM X-Spam-Check-By: sourceware.org Received: from mx02.qsc.de (HELO mx02.qsc.de) (213.148.130.14) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 30 May 2011 12:34:28 +0000 Received: from [192.168.178.22] (port-92-204-18-93.dynamic.qsc.de [92.204.18.93]) by mx02.qsc.de (Postfix) with ESMTP id 162B11E356; Mon, 30 May 2011 14:34:27 +0200 (CEST) Message-ID: <4DE38ED2.8010405@net-b.de> Date: Mon, 30 May 2011 14:34:26 +0200 From: Tobias Burnus User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.14) Gecko/20110221 SUSE/3.1.8 Thunderbird/3.1.8 MIME-Version: 1.0 To: gcc patches , gfortran Subject: [Patch, Fortran] Support static coarrays with "automatic" cobounds Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org gfortran currently rejects: subroutine foo(n) integer, SAVE :: foo(500)[n, *] claiming that as SAVE does not work with automatic arrays. The latter is correct. ("C513 An automatic object shall not have the SAVE attribute.") However, I would argue that "foo" is not an automatic object and thus the code is valid: "An automatic data object is a nondummy data object with a type parameter or array bound that depends on the value of a specification-expr that is not a constant expression.". -- Note the "bound" not "cobound". Cf. "1.3.27 cobound: bound (limit) of a codimension" vs. "1.3.17 bound / array bound: limit of a dimension of an array". (Obviously, the bounds need to be constant for a static array, but the cobounds are only "virtual": They just exist to calculate the image from the coarray index - and vice versa ("image_index()").) The test program (cf. patch) also compiles with crayftn, but it is rejected by both g95 and ifort 12.0. I think that's a bug in g95 and ifort, but if possible: please cross check the standard to ensure that I did not misread it. Build and regtested on x86-64-linux. OK for the trunk? Tobias 2011-05-30 Tobias Burnus PR fortran/18918 * resolve.c (resolve_fl_variable): Handle static coarrays with non-constant cobounds. (resolve_symbol): Handle SAVE statement without arguments for coarrays. * trans-array.c (gfc_trans_array_cobounds): New function. (gfc_trans_array_bounds): Place code by call to it. * trans-array.h (gfc_trans_array_cobounds): New prototype. * trans-decl.c (gfc_get_symbol_decl, gfc_trans_deferred_vars): Handle static coarrays with nonconstant cobounds. 2011-05-30 Tobias Burnus PR fortran/18918 * gfortran.dg/coarray/save_1.f90: New. * gfortran.dg/coarray_4.f90: Update dg-error. diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c index 4b18529..6ca98f2 100644 --- a/gcc/fortran/resolve.c +++ b/gcc/fortran/resolve.c @@ -10118,7 +10118,14 @@ resolve_fl_variable (gfc_symbol *sym, int mp_flag) /* Also, they must not have the SAVE attribute. SAVE_IMPLICIT is checked below. */ - if (sym->attr.save == SAVE_EXPLICIT) + if (sym->as && sym->attr.codimension) + { + int corank = sym->as->corank; + sym->as->corank = 0; + no_init_flag = automatic_flag = is_non_constant_shape_array (sym); + sym->as->corank = corank; + } + if (automatic_flag && sym->attr.save == SAVE_EXPLICIT) { gfc_error (auto_save_msg, sym->name, &sym->declared_at); return FAILURE; @@ -12337,6 +12344,7 @@ resolve_symbol (gfc_symbol *sym) if (((sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.coarray_comp) || sym->attr.codimension) && !(sym->attr.allocatable || sym->attr.dummy || sym->attr.save + || sym->ns->save_all || sym->ns->proc_name->attr.flavor == FL_MODULE || sym->ns->proc_name->attr.is_main_program || sym->attr.function || sym->attr.result || sym->attr.use_assoc)) diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c index d83a7a9..0c6c638 100644 --- a/gcc/fortran/trans-array.c +++ b/gcc/fortran/trans-array.c @@ -4648,6 +4648,43 @@ gfc_conv_array_initializer (tree type, gfc_expr * expr) } +/* Generate code to evaluate non-constant coarray cobounds. */ + +void +gfc_trans_array_cobounds (tree type, stmtblock_t * pblock, + const gfc_symbol *sym) +{ + int dim; + tree ubound; + tree lbound; + gfc_se se; + gfc_array_spec *as; + + as = sym->as; + + for (dim = as->rank; dim < as->rank + as->corank; dim++) + { + /* Evaluate non-constant array bound expressions. */ + lbound = GFC_TYPE_ARRAY_LBOUND (type, dim); + if (as->lower[dim] && !INTEGER_CST_P (lbound)) + { + gfc_init_se (&se, NULL); + gfc_conv_expr_type (&se, as->lower[dim], gfc_array_index_type); + gfc_add_block_to_block (pblock, &se.pre); + gfc_add_modify (pblock, lbound, se.expr); + } + ubound = GFC_TYPE_ARRAY_UBOUND (type, dim); + if (as->upper[dim] && !INTEGER_CST_P (ubound)) + { + gfc_init_se (&se, NULL); + gfc_conv_expr_type (&se, as->upper[dim], gfc_array_index_type); + gfc_add_block_to_block (pblock, &se.pre); + gfc_add_modify (pblock, ubound, se.expr); + } + } +} + + /* Generate code to evaluate non-constant array bounds. Sets *poffset and returns the size (in elements) of the array. */ @@ -4728,26 +4765,8 @@ gfc_trans_array_bounds (tree type, gfc_symbol * sym, tree * poffset, size = stride; } - for (dim = as->rank; dim < as->rank + as->corank; dim++) - { - /* Evaluate non-constant array bound expressions. */ - lbound = GFC_TYPE_ARRAY_LBOUND (type, dim); - if (as->lower[dim] && !INTEGER_CST_P (lbound)) - { - gfc_init_se (&se, NULL); - gfc_conv_expr_type (&se, as->lower[dim], gfc_array_index_type); - gfc_add_block_to_block (pblock, &se.pre); - gfc_add_modify (pblock, lbound, se.expr); - } - ubound = GFC_TYPE_ARRAY_UBOUND (type, dim); - if (as->upper[dim] && !INTEGER_CST_P (ubound)) - { - gfc_init_se (&se, NULL); - gfc_conv_expr_type (&se, as->upper[dim], gfc_array_index_type); - gfc_add_block_to_block (pblock, &se.pre); - gfc_add_modify (pblock, ubound, se.expr); - } - } + + gfc_trans_array_cobounds (type, pblock, sym); gfc_trans_vla_type_sizes (sym, pblock); *poffset = offset; diff --git a/gcc/fortran/trans-array.h b/gcc/fortran/trans-array.h index fef56ae..f29162e 100644 --- a/gcc/fortran/trans-array.h +++ b/gcc/fortran/trans-array.h @@ -132,6 +132,9 @@ tree gfc_conv_array_stride (tree, int); tree gfc_conv_array_lbound (tree, int); tree gfc_conv_array_ubound (tree, int); +/* Set cobounds of an array. */ +void gfc_trans_array_cobounds (tree, stmtblock_t *, const gfc_symbol *); + /* Build expressions for accessing components of an array descriptor. */ tree gfc_conv_descriptor_data_get (tree); tree gfc_conv_descriptor_data_addr (tree); diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c index 299f224..27eca79 100644 --- a/gcc/fortran/trans-decl.c +++ b/gcc/fortran/trans-decl.c @@ -1349,7 +1349,7 @@ gfc_get_symbol_decl (gfc_symbol * sym) } /* Remember this variable for allocation/cleanup. */ - if (sym->attr.dimension || sym->attr.allocatable + if (sym->attr.dimension || sym->attr.allocatable || sym->attr.codimension || (sym->ts.type == BT_CLASS && (CLASS_DATA (sym)->attr.dimension || CLASS_DATA (sym)->attr.allocatable)) @@ -3485,6 +3485,15 @@ gfc_trans_deferred_vars (gfc_symbol * proc_sym, gfc_wrapped_block * block) gfc_trans_deferred_array (sym, block); } } + else if (sym->attr.codimension && TREE_STATIC (sym->backend_decl)) + { + gfc_init_block (&tmpblock); + gfc_trans_array_cobounds (TREE_TYPE (sym->backend_decl), + &tmpblock, sym); + gfc_add_init_cleanup (block, gfc_finish_block (&tmpblock), + NULL_TREE); + continue; + } else if (gfc_option.coarray != GFC_FCOARRAY_LIB) { gfc_save_backend_locus (&loc); diff --git a/gcc/testsuite/gfortran.dg/coarray_4.f90 b/gcc/testsuite/gfortran.dg/coarray_4.f90 index 5607ec9..be2bc4e 100644 --- a/gcc/testsuite/gfortran.dg/coarray_4.f90 +++ b/gcc/testsuite/gfortran.dg/coarray_4.f90 @@ -18,7 +18,8 @@ subroutine valid(n, c, f) save :: k integer :: ii = 7 block - integer, save :: kk[ii, *] ! { dg-error "cannot have the SAVE attribute" } + integer :: j = 5 + integer, save :: kk[j, *] ! { dg-error "Variable .j. cannot appear in the expression" } end block end subroutine valid @@ -43,10 +44,10 @@ subroutine invalid(n) complex, save :: hh(n)[*] ! { dg-error "cannot have the SAVE attribute" } integer :: j = 6 - integer, save :: hf1[j,*] ! { dg-error "cannot appear in the expression|cannot have the SAVE attribute" } - integer, save :: hf2[n,*] ! { dg-error "cannot have the SAVE attribute" } + integer, save :: hf1[j,*] ! { dg-error "cannot appear in the expression" } + integer, save :: hf2[n,*] ! OK integer, save :: hf3(4)[j,*] ! { dg-error "cannot appear in the expression|cannot have the SAVE attribute" } - integer, save :: hf4(5)[n,*] ! { dg-error "cannot have the SAVE attribute" } + integer, save :: hf4(5)[n,*] ! OK integer, allocatable :: a2[*] ! { dg-error "must have deferred shape" } integer, allocatable :: a3(:)[*] ! { dg-error "must have deferred shape" }