[Bug fortran/60110] internal compiler error

["kargl at gcc dot gnu.org" <gcc-bugzilla at gcc dot gnu dot org>]

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

kargl at gcc dot gnu.org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |kargl at gcc dot gnu.org

--- Comment #2 from kargl at gcc dot gnu.org ---
(In reply to Walt Brainerd from comment #0)
> Created attachment 32079 [details]
> source file gfortran_bug.f90
> 
> Sorry, I am not sure where to begin to cut this down.
> I hope you can figure it out from the error msg.
> 
> This also fails the same way on the TDM build.
> 
> $ gfortran -c gfortran_bug.f90
> gfortran_bug.f90: In function 'r701t735_array':
> gfortran_bug.f90:2282:0: internal compiler error: in gfc_get_symbol_decl, at

The line number 2282 points to a problem with the character type.  Here's 
a reduced test case from your code:


module check_sem

  implicit  none

  type check_logical
    logical  ok
  end type

  interface  operator( .and. )
    module procedure  logical_and_check_logical
  end interface

  interface  operator( .not. )
    module procedure  not_check_logical
  end interface

  interface  assignment( = )
    module procedure  check_logical_to_logical, logical_to_check_logical
  end interface

  interface  check
  module procedure check_character1_rank1
  end interface

  contains

    subroutine check_logical_to_logical( l, r )
      logical, intent(out) :: l
      type( check_logical ), intent(in) :: r
      l = r % ok
    end subroutine check_logical_to_logical

    subroutine  logical_to_check_logical( l, r )
      type( check_logical ), intent(out) :: l
      logical, intent(in) :: r
      l % ok = r
    end subroutine logical_to_check_logical

    logical function  logical_and_check_logical( l, r )
      logical, intent(in) :: l
      type( check_logical ), intent(in) :: r
      logical_and_check_logical = l .and. r % ok
    end function logical_and_check_logical

    logical function  not_check_logical( r )
      type( check_logical ), intent(in) :: r
      not_check_logical = .not. r % ok
    end function not_check_logical

   function check_character1_rank1 (expected, computed, location)
      character(*), intent(in), optional :: location
      character(*,1), dimension(:), intent(in) ::  expected, computed
      type (check_logical) :: check_character1_rank1
      intrinsic all, present
      check_character1_rank1 = all(computed == expected)
   end function check_character1_rank1

end module check_sem

module  overloads

  interface  operator( ** )
    function  character_power_sc(l, r)
      character(*), intent(in) :: l, r
      intrinsic  len
      character(len(l)) :: character_power_sc
    end function  character_power_sc

    function  character_power_array(l, r)
      character(*), intent(in), dimension(3) :: l, r
      intrinsic  len
      character(len(l)), dimension(3) :: character_power_array
    end function  character_power_array
  end interface

end module overloads

program foo

  use check_sem
  use overloads

  implicit none
  logical  :: ok = .true.

  character, parameter, dimension(3) :: ch_c = (/ 'a', 'b', 'c' /)
  character  chv(3), cho1(3), cho2(3)

  cho1 = (ch_c)
  chv = cho1 ** ch_c
  ok = ok .and. check(chv, &
              (/ cho1(1)**ch_c(1), cho1(2)**ch_c(2), cho1(3)**ch_c(3) /), &
                      'mult-operand-16')

end program foo