Issue 161109.1: No way to describe Fortran derived types with deferred length components

Jakub Jelinek

## Original Issue Description

When the producer implements Fortran derived type components with deferred length, e.g.

    type t
      integer :: j
      character(len=:), allocatable :: f
      integer :: i
    end type

like in C:

    struct t
    {
      int j;
      void *f;
      int i;
      int _f_length; // The string length *f points to.
    };

the current DWARF doesn't really allow to express this, at least not in the type
DIEs and their children (basically, for each variable of such type one would have
to create a new distinct set of type DIEs where the `DW_AT_string_length` attribute
would use a particular location expression specific to the particular variable.

The problem is that the string length is not stored in the CHARACTER(len=:)
objects themselves, but is shared by all the elements of the array.  The
`DW_AT_string_length` must appear on the `DW_TAG_string_type` DIE, so
`DW_OP_push_object_address` on it pushes the address of a particular array
element.  Where one can evaluate the string length is the `DW_TAG_array_type`,
where one could `DW_OP_push_object_address`, and is used for `DW_AT_data_location`
etc.  We could e.g. allow `DW_AT_string_length` on `DW_AT_array_type` and have some
form of `DW_AT_string_length` or some new attribute on `DW_TAG_string_type` say that
`DW_AT_string_length` location isn't provided here, but on the parent (or grand
parent etc.) `DW_TAG_array_type`.  Or have some `DW_OP_*` that would push address
of the containing array object instead of the current object's address.

## Analysis

### The GCC Fortran Compiler

For a deferred-length string in GCC Fortran, the length of that
string is stored *outside* the string object itself.

For a standalone string variable with deferred length, the GCC
Fortran compiler generates a separate (artificial) variable to
hold the length:

    character (:), allocatable :: s

    V1: DW_TAG_variable
           DW_AT_name: s
           DW_AT_type: [ref to ptr to string type (T1)]
           DW_AT_location: [DW_OP_fbreg(-8)]
    V2: DW_TAG_variable
           DW_AT_name: .s
           DW_AT_type: [ref to int type]
           DW_AT_artificial: 1
           DW_AT_location: [DW_OP_fbreg(-16)]

    T1: DW_TAG_pointer_type
           DW_AT_byte_size: 8
           DW_AT_type: [ref to string type (T2)]
    T2: DW_TAG_string_type
           DW_AT_string_length: [ref to V2]

There are two problems with this DWARF output:

- The variable `s` is not truly a pointer. It should be a string type
  with a data location attribute, rather than a pointer to a string type.

- The string type (T2 in the example above) has a reference to
  the artificial `.s` length variable, so that each such string
  variable would require a separate type in order for each to
  refer to its associated length variable.

The DWARF for this case should instead use a string type
rather than a pointer type for T1:

    T1: DW_TAG_string_type
           DW_AT_data_location: [DW_OP_push_object_location; DW_OP_deref]
           DW_AT_string_length: [ref to V2]

The pointer is essentially an object descriptor for the string,
whose only field is a pointer to the allocated string.

This solves the first problem but not the second. In order for
two string variables `s1` and `s2` to share a type, we’d need to
allow the string length attribute to be placed in each variable DIE
instead of in the type DIE.

If a string is a member of a derived type, its length is
stored in a separate (compiler-generated) field in the type.

    type dstring
      character (len=:), allocatable :: s
    end type

    T1: DW_TAG_pointer_type
            DW_AT_byte_size: 8
            DW_AT_type: [ref to T2]
    T2: DW_TAG_string_type
            DW_AT_byte_size: 0
    T3: DW_TAG_structure_type
            DW_AT_name: dstring
            DW_AT_byte_size: 16
          DW_TAG_member
              DW_AT_name: s
              DW_AT_type: [ref to T1]
              DW_AT_data_member_location: 0
          DW_TAG_member
              DW_AT_name: _s_length
              DW_AT_type: [ref to int type]
              DW_AT_data_member_location: 8

There are three problems with the DWARF output for this example:

- As above, the member `s` should be a string type, not a pointer type.

- There is nothing in the DWARF that identifies the `_s_length` member
  as the string length for `s`.

- The `_s_length` member should be flagged with `DW_AT_artificial`.

For an array of strings, the elements all share the same length
field, which is stored in the type containing the array.
The GCC Fortran compiler generates the following DWARF:

    type dstring
      character (len=:), allocatable :: s (:)
    end type

    type (dstring) :: d

    V3: DW_TAG_variable
           DW_AT_name: d
           DW_AT_type: [ref to T4]
           DW_AT_location: [DW_OP_addr(d)]

    T4: DW_TAG_structure_type
            DW_AT_name: dstring
            DW_AT_byte_size: 72
          DW_TAG_member
              DW_AT_name: s
              DW_AT_type: [ref to T5]
              DW_AT_data_member_location: 0
          DW_TAG_member
              DW_AT_name: _s_length
              DW_AT_type: [ref to int type]
              DW_AT_data_member_location: 64
    T5: DW_TAG_structure_type
            DW_AT_declaration: 1

There are two problems with the DWARF output for this example:

- The `_s_length` field should be marked artificial.

- The type of the `s` field (T5) is a structure type that is left undefined.
  It should instead be an array type whose elements are strings.

The type T5 would need to look something like the following:

    T5: DW_TAG_array_type
            DW_AT_data_location: [DW_OP_push_object_location; DW_OP_deref]
            DW_AT_allocated: [DW_OP_push_object_location; DW_OP_deref; DW_OP_lit0; DW_OP_ne]
            DW_AT_type: [ref to T6]
          DW_TAG_subrange_type
              DW_AT_type: [ref to int type]
              DW_AT_lower_bound: [DW_OP_push_object_location; DW_OP_plus_uconst: 24; DW_OP_deref]
              DW_AT_count: [DW_OP_push_object_location; DW_OP_plus_uconst: 32; DW_OP_deref]

    T6: DW_TAG_string_type
            DW_AT_string_length: ???

But we still have a problem where the string type DIE cannot describe
the location of the string length field, because `DW_OP_push_object_location`
will push the location of the string object rather than of the array object.

### Other Fortran Compilers

The LLVM and Intel Fortran compilers both choose to represent a
deferred-length allocatable string, whether a standalone variable or a
member of a derived type, as a descriptor with two fields — a data pointer
and a string length. The string type would look something like the
following:

    T7: DW_TAG_string_type
            DW_AT_data_location: [DW_OP_push_object_location, DW_OP_deref]
            DW_AT_string_length: [DW_OP_push_object_location, DW_OP_plus_uconst 0x8]

With this representation, the type DIE can be shared by all variables
of this type.

For an array of strings, however, a single length field is shared by
all strings of the array, as in the GCC case. The DWARF output from these
compilers is something like the following:

    T8: DW_TAG_array_type
            DW_AT_data_location: [DW_OP_push_object_location; DW_OP_deref]
            DW_AT_allocated: [DW_OP_push_object_location; DW_OP_deref; DW_OP_lit0; DW_OP_ne]
            DW_AT_type: [ref to T9]
          DW_TAG_subrange_type
              DW_AT_type: [ref to int type]
              DW_AT_lower_bound: [DW_OP_push_object_location; DW_OP_plus_uconst: 24; DW_OP_deref]
              DW_AT_count: [DW_OP_push_object_location; DW_OP_plus_uconst: 32; DW_OP_deref]
              DW_AT_byte_stride: [DW_OP_push_object_location; DW_OP_plus_uconst: 40; DW_OP_deref]

    T9: DW_TAG_string_type
            DW_AT_string_length: [DW_OP_push_object_location; DW_OP_plus_uconst: 8]

As described above, the string length attribute for the string
type T9 is not correct. It wants to push the address of the
containing array object, where the common string length can be
found at offset 8, but will instead push the address of the
string object.

Compare with type T7 in the example above, where the
`DW_OP_push_object_location` *is* intended to push the location
of the string object. To handle this latter case correctly,
debuggers are forced to use a heuristic to decide which object’s
location should be pushed.

## Solutions

### String Scalars

For the GCC model, where the string length is stored as a separate variable
or field, we should allow the `DW_AT_string_length` attribute to appear
on variable or data member DIEs when the string length is not part of the
string object. Furthermore, to make it clear that the string length is
deferred to the variable or data member DIE, the type DIE should have
a `DW_AT_string_length` attribute using the *flag* form class.

With this simple change, a Fortran deferred-length allocatable string
can be represented as follows:

    character (:), allocatable :: s1, s2

    V1: DW_TAG_variable
           DW_AT_name: s1
           DW_AT_type: [ref to T1]
           DW_AT_location: [...]
           DW_AT_string_length: [ref to V3]
    V2: DW_TAG_variable
           DW_AT_name: s2
           DW_AT_type: [ref to T1]
           DW_AT_location: [...]
           DW_AT_string_length: [ref to V4]
    V3: DW_TAG_variable
           DW_AT_name: .s1
           DW_AT_type: [ref to int type]
           DW_AT_artificial: 1
           DW_AT_location: [...]
    V4: DW_TAG_variable
           DW_AT_name: .s2
           DW_AT_type: [ref to int type]
           DW_AT_artificial: 1
           DW_AT_location: [...]

    T1: DW_TAG_string_type
           DW_AT_data_location: [DW_OP_push_object_location; DW_OP_deref]
           DW_AT_string_length: [flag_present]

Multiple strings can now share the single type DIE at T1.

For string members of a derived type, the string length attribute can
be attached to the data member DIE, referring to the artificial data member
where the string length is stored:

    type dstring
      character (len=:), allocatable :: s1, s2
    end type

    T1: DW_TAG_string_type
           DW_AT_data_location: [DW_OP_push_object_location; DW_OP_deref]
           DW_AT_string_length: [flag_present]

    T2: DW_TAG_structure_type
            DW_AT_name: dstring
            DW_AT_byte_size: 32
    M1:   DW_TAG_member
              DW_AT_name: s1
              DW_AT_type: [ref to T1]
              DW_AT_data_member_location: 0
              DW_AT_string_length: [ref to M3]
    M2:   DW_TAG_member
              DW_AT_name: s2
              DW_AT_type: [ref to T1]
              DW_AT_data_member_location: 8
              DW_AT_string_length: [ref to M4]
    M3:   DW_TAG_member
              DW_AT_name: _s1_length
              DW_AT_artificial: 1
              DW_AT_type: [ref to int type]
              DW_AT_data_member_location: 16
    M4:   DW_TAG_member
              DW_AT_name: _s2_length
              DW_AT_artificial: 1
              DW_AT_type: [ref to int type]
              DW_AT_data_member_location: 24

For the LLVM and Intel compiler model, where the string length is
stored as a second field in the object descriptor, the existing
DWARF (as shown at T7 in the example in the previous section) is
sufficient and no changes are necessary.

### String Arrays

A deferred-length allocatable array of strings is represented in DWARF
as an array type whose elements are string types, but the string elements
of the array all share the same length, which is stored in the array
descriptor. The individual strings are stored in a contiguous block
of characters whose location is given by the array type’s
`DW_AT_data_location` attribute. The string type needs to inherit
the string length attribute from the containing array object,
so we propose to place the `DW_AT_string_length` attribute on the
`DW_TAG_array_type` DIE, and let the string type for the array elements
use the flag form to indicate that the attribute is provided elsewhere.

    character (len=:), allocatable :: s (:)

    T3: DW_TAG_array_type
            DW_AT_data_location: [DW_OP_push_object_location; DW_OP_deref]
            DW_AT_allocated: [DW_OP_push_object_location; DW_OP_deref; DW_OP_lit0; DW_OP_ne]
            DW_AT_type: [ref to T4]
            DW_AT_string_length: [DW_OP_push_object_location; DW_OP_plus_uconst: 8]
          DW_TAG_subrange_type
              DW_AT_type: [ref to int type]
              DW_AT_lower_bound: [DW_OP_push_object_location; DW_OP_plus_uconst: 24; DW_OP_deref]
              DW_AT_count: [DW_OP_push_object_location; DW_OP_plus_uconst: 32; DW_OP_deref]
              DW_AT_byte_stride: [DW_OP_push_object_location; DW_OP_plus_uconst: 40; DW_OP_deref]

    T4: DW_TAG_string_type
            DW_AT_string_length: [flag_present]

### Alternative Approach for String Arrays

Author:	Jakub Jelinek
Champion:	Cary Coutant
Date submitted:	2016-11-09
Date revised:	2026-10-12
Date closed:	2026-10-26
Type:	Enhancement
Status:	Accepted
DWARF version:	6