This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [Patch, fortran] PR 64757 - [5 Regression] ICE in fold_convert_loc, at fold-const.c:2353

Dear Paul, dear all,

Paul Richard Thomas wrote:

Please find attached a reworked version of the patch for this PR. [...]
In this version, the treatment of scalar and array components is cleanly
separated.

Bootstrapped and regtested on FC21/x86_64. OK for trunk?


Looks good to me. Thanks for the patch.

 * * *
However, as follow up, one should check also the initialization of a (polymorphic) pointer component. Quoting the standard:
"For a pointer component, the corresponding component-data-source shall be an allowable data-target or proctarget for such a pointer in a pointer assignment statement (7.2.2). If the component data source is a pointer, the association of the component is that of the pointer; otherwise, the component is pointer associated with the component data source." 

Thus, one should check CLASS => CLASS and CLASS <-> TYPE.

 * * *

And, finally, I wonder whether we need to take care of:

type m
end type m
type t
  CLASS(m), allocatable :: caf[:]
end type t
type(t), save :: x = t(m())
end
We probably do. I think that's valid as it is (kind of) statically allocated. That means we need to call for -fcoarray=lib the _gfortran_caf_register function for x%caf as constructor (in the C sense) - such that the address is registered at program start up. The (pointer) assignment of that address to x%caf can be done later, e.g. when the procedure (or __MAIN) is actually entered. 

Tobias


2015-02-04  Paul Thomas  <pault@gcc.gnu.org>

     PR fortran/640757
     * resolve.c (resolve_structure_cons): Obtain the rank of class
     components.
     * trans-expr.c (gfc_trans_alloc_subarray_assign): Do the
     assignment to allocatable class array components.
     (alloc_scalar_allocatable_for_subcomponent_assignment): If comp
     is a class component, allocate to the _data field.
     (gfc_trans_subcomponent_assign): If a class component with a
     derived type expression set the _vptr field and for array
     components, call gfc_trans_alloc_subarray_assign. For scalars,
     the assignment is performed here.

2015-02-04  Paul Thomas  <pault@gcc.gnu.org>

     PR fortran/640757
     * gfortran.dg/type_to_class_2.f90: New test
     * gfortran.dg/type_to_class_3.f90: New test

On 3 February 2015 at 22:36, Paul Richard Thomas
<paul.richard.thomas@gmail.com> wrote:

Dear Dominique,

I have fixed all the problems except the last one. For that case, the
other brand gives
type_to_class_30.f90(19): error #7822: Variables containing ultimate
allocatable array components are forbidden from appearing directly in
input/output lists.
print *, TestReference([Test(99), Test(199)])
---------^
compilation aborted for type_to_class_30.f90 (code 1)

which seems to me to be correct. I'll see what I can do to fix it.

Thanks for the help

Paul

On 2 February 2015 at 17:53, Dominique Dhumieres <dominiq@lps.ens.fr> wrote:

Dear Paul,

I have tested your patch at https://gcc.gnu.org/ml/fortran/2015-01/txtwnaoa1115V.txt
(the latest version) and I found that the test type_to_class_3.f03 is miscompiled
(FAIL) with -flto -O0 -m64 (this does not happens with -flto -O0 -m32 or with -Ox and
x!=0).

In addition, while the reduced test

   type :: Test
     integer :: i
   end type

   type :: TestReference
      class(Test), allocatable :: test(:)
   end type

   type(TestReference) :: testList
   type(test), allocatable :: x(:)

  allocate (testList%test(2), source = [Test(99), Test(199)]) ! Works, of course
  print *, size(testList%test)
  x = testList%test
  print *, x
end

gives what I expect, i.e.,

            2
           99         199

   type :: Test
     integer :: i
   end type

   type :: TestReference
      class(Test), allocatable :: test(:)
   end type

   type(TestReference) :: testList
   type(test), allocatable :: x(:)

   testList = TestReference([Test(99), Test(199)])  ! Gave: The rank of the element in the
                                                    ! structure constructor at (1) does not
                                                    ! match that of the component (1/0)
   print *, size(testList%test)
   x = testList%test
   print *, x
end

gives

            1
           99

Last problem I see,

print *, TestReference([Test(99), Test(199)])

gives the following ICE

f951: internal compiler error: Bad IO basetype (7)

type_to_class_3_red_2.f03:12:0:

    print *, TestReference([Test(99), Test(199)])


Cheers,

Dominique



--
Outside of a dog, a book is a man's best friend. Inside of a dog it's
too dark to read.

Groucho Marx
Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]