[Bug fortran/26393] New: "CONTAIN"-ed + assumed character length + "WRITE" -> ICE at trans-decl.c:849?

[P dot Schaffnit at access dot rwth-aachen dot de]

Hi!

I have some severly twisted code (..): a "CONTAIN"-ed routine with assumed
character length arguments writing out a string (...) which causes an ICE. The
bad news, is that a "barebones" similar thing compiles (and runs) fine, so I
had to reduce it by trial and error, 8-( ... Whatever, don't look for much
sense here, but I believe that to be still valid (and lf95 would seem to
agree!).

Philippe

PS: what I get (and how I do it):
gfortran -c -g -pedantic-errors -Wall Sources.f90
Sources.f90: In function 'outdiffkoeff':
Sources.f90:85: internal compiler error: in gfc_get_symbol_decl, at
fortran/trans-decl.c:849
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://gcc.gnu.org/bugs.html> for instructions.

PPS: the "sources":
!
      MODULE MODULE_DIMENSION
!
      INTEGER, PARAMETER :: Sng = 4
      INTEGER, PARAMETER :: Dbl = 8
      INTEGER, PARAMETER :: Dft = Sng
!
      INTEGER, PARAMETER :: Length_File_Name = 1000
!
      END MODULE MODULE_DIMENSION
!
!
      MODULE MODULE_CONC
!
      USE MODULE_DIMENSION, ONLY: Length_File_Name, Dft, Sng, Dbl
!
      INTEGER, PARAMETER :: Weight = 1, Atom = 2
      INTEGER, PARAMETER :: Atom_to_Weight = 1, Weight_to_Atom = 2
!
      INTEGER, SAVE                               :: anzKomponenten = 0
      INTEGER, SAVE                               :: concTyp
      INTEGER, SAVE, ALLOCATABLE, DIMENSION(:,:,:):: diffZeiger
!
      REAL ( KIND = Dft ), SAVE, ALLOCATABLE  :: diffKoefKonst(:)
      REAL ( KIND = Dft ), SAVE, ALLOCATABLE  :: diffKoefAkt(:)
!
      END MODULE MODULE_CONC
!
!
      MODULE MODULE_THERMOCALC
!
      USE MODULE_DIMENSION, ONLY: Dft, Sng, Dbl
!
      CHARACTER ( LEN = 2 ), SAVE, ALLOCATABLE  ::   kompNameTQ(:)
      CHARACTER ( LEN = 12 ), SAVE, ALLOCATABLE ::   phaseNameTQ(:)
!
      LOGICAL, SAVE, ALLOCATABLE ::   usePhaseTQ(:)
      LOGICAL, SAVE, ALLOCATABLE ::   diff_Coeff_Inter(:,:)
!
      INTEGER, SAVE, ALLOCATABLE ::   cNr(:)
      INTEGER, SAVE, ALLOCATABLE ::   pNr(:)
!
      REAL ( KIND = Dft ), SAVE, ALLOCATABLE ::                        &
     &                                         diff_Coeff_Cond_Conc(:,:)
      REAL ( KIND = Dft ), SAVE, ALLOCATABLE ::                        &
     &                                         diff_Coeff_Cond_Temp(:)
!
      INTERFACE
          FUNCTION solveCConvert ( Flag_Conversion, Composition )
              USE MODULE_CONC, ONLY: anzKomponenten
              USE MODULE_DIMENSION, ONLY: Dft
              IMPLICIT NONE
              INTEGER, INTENT ( IN )         ::   Flag_Conversion
              REAL ( KIND = Dft ),                                     &
     &                        INTENT ( IN )  ::   Composition          &
     &                                            ( 1 : anzKomponenten )
              REAL ( KIND = Dft )            ::   solveCConvert        &
     &                                            ( 1 : anzKomponenten )
          END FUNCTION solveCConvert
      END INTERFACE
!
      END MODULE MODULE_THERMOCALC
!
!
      SUBROUTINE outDiffKoeff ( phase )
!
      USE MODULE_CONC
      USE MODULE_DIMENSION
      USE MODULE_THERMOCALC
!
      IMPLICIT   NONE
!
      LOGICAL, PARAMETER  ::   thermocalc = .TRUE.
!
      INTEGER                           ::   IO_Stat
      INTEGER                           ::   phase, k
!
      REAL ( KIND = Dft ), PARAMETER    ::   R = 8.31441
      REAL ( KIND = Dft )               ::   buffer_conc               &
     &                                            ( 1 : anzKomponenten )
!
      CHARACTER ( LEN = 250 )           ::   String
!
      WRITE ( String, FMT = * ) diff_Coeff_Cond_Temp(phase)
      CALL CTN_Write_String ( TRIM(String), "(A)" )
          IF ( ( ( thermocalc ) .AND. ( concTyp .EQ. Weight ) ) ) THEN
            buffer_conc = solveCConvert ( Atom_to_Weight, &
     &                diff_Coeff_Cond_Conc(phase,:) ) * 1E2
          ELSE
            buffer_conc = diff_Coeff_Cond_Conc(phase,:) * 1E2
          ENDIF
          DO k = 1, anzKomponenten
              WRITE ( UNIT = String, FMT = "(ES12.4)" ) buffer_conc(k)
              CALL CTN_Write_String ( TRIM(String), "(A)" )
          ENDDO
!
      CONTAINS
!
        SUBROUTINE CTN_Write_String ( String, Fmt )
!
          CHARACTER ( LEN = * ), INTENT ( IN )    ::   String, Fmt
!
          WRITE ( UNIT = 12, FMT = TRIM(Fmt), IOSTAT = IO_Stat )       &
     &                                                      TRIM(String)
          IF ( IO_Stat .NE. 0 ) THEN
            CALL toolStop
          ENDIF
!
        END SUBROUTINE CTN_Write_String
!
      END SUBROUTINE outDiffKoeff
!

PPPS: I'm using 4.2.0 20060221 (experimental)


-- 
           Summary: "CONTAIN"-ed + assumed character length + "WRITE" -> ICE
                    at trans-decl.c:849?
           Product: gcc
           Version: 4.2.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: fortran
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: P dot Schaffnit at access dot rwth-aachen dot de


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=26393