DWARF Standard


HOME
SPECIFICATIONS
FAQ
ISSUES



131106.1 Ron Brender Replace DW_TAG_descriptor_type (130318.1) with DW_TAG_dynamic_type Enhancement Accepted Ron Brender


Section 5.15, pg 
This is a proposal to reconsider 130318.1, which was approved in 
July (pending an examples section to be supplied). In particular, 
the proposal is to replace 130318.1 in toto with a new formulation 
as described below.

Background

130318.1 is an outgrowth of the older 121112.1, which proposed a
fairly general DW_TAG_refine_type entry that could be used to
add various properties to a type, notably make it into a co-array
or add the dynamic properties represented by the DW_AT_allocated
and DW_AT_associated attributes. The committee opted for a more
specific and specialized construct for co-arrays (and similarly
assumed rank arrays), leaving the dynamic type related-attributes
to be addressed.

The dynamic type attributes DW_AT_allocated and DW_AT_associated
were added to DWARF in Version 3 to address FORTRAN needs. There
is no additional semantic functionality that needs to be expressed--
the DW_AT_data_location attribute can be used in combination with
DW_AT_allocated and/or DW_AT_associated to effectively describe a 
variety of needs in Fortran, Ada, and other languages (see Appendix 
D.2).

The case was made, however, that Fortran's syntax for adding the
dynamic properties to an existing type can lead to excessive
replication of DWARF description if these attributes must be added
to new types that are otherwise the same as earlier.

Unfortunately the matters of type description and run-time 
type representation (a potential descriptor) became more entangled 
that seems necessary or desirable. The resulting proposal and 
justification for the DW_TAG_descriptor_type reflects that.

In addition, the 1130318.1 proposal contains this sweeping statement

    "Any other attributes and/or children debugging information 
	entries on the descriptor type entry would behave identically
	as if the attribute and/or children DIEs [sic] are attached
	to the referencing type entry."
	
As formulated, this doesn't work if the referenced type has a
DW_AT_name attribute. In the example of that proposal this results
in multiple descriptor type declarations, all with the name "dt"
(like the referenced type). And it is unclear whether a descriptor
type can have a name in its own right, although apparently not.

More generally, not addressed is the effect of a DW_AT_allocated
or DW_AT_associated attribute on the descriptor type if there is
a corresponding attribute on the referenced type.

Following is a new formulation that seeks to provide the intended
functionality in a way that directly addresses the DWARF replication
motivation without mixing in descriptor concepts.

Proposal

1) In Table 2.1: Tag names add

        DW_TAG_dynamic_type
        
2) Renumber the existing 5.15, "Dynamic Type Properties" to 5.15.1
making it part of the following new 5.15:

    "5.15 Dynamic Type Entries and Properties
	Some languages such as Fortran 90, provide types whose values
	may be dynamically allocated or associated with a variable
	under explicit program control. However, unlike the related
	pointer type in C or C++, the indirection involved in accessing
	the value of the variable is generally implicit, that is, not
	indicated as part of program source.
	
	A dynamic type entry is used to declare a dynamic type that is 
	"just like" another non-dynamic type without needing to
	replicate the full description of that other type.

	A dynamic type is represented by a debugging information entry
	with the tag DW_TAG_dynamic_type. If a name has been given to the
	dynamic type, then the dynamic type has a DW_AT_name attribute 
	whose value is a null-terminated string containing the dynamic
	type name as it appears in the source.
	
	A dynamic type entry has a DW_AT_type attribute whose value is a
	reference to the type of the entities that are dynamically allocated.
	
	A dynamic type entry also has a DW_AT_data_location, and may also
	have DW_AT_allocated and/or DW_AT_associated attributes as 
	described following (Section 5.15.1). The type referenced by the
    DW_AT_type attribute must not have any of these attributes.
	
3) The current 5.15, "Dynamic Type Properties", is renumbered to 5.15.1.
At the beginning of 5.15.1 insert:

    The DW_AT_data_location, DW_AT_allocated and DW_AT_associated 
	attributes described in this section can be used for any type, not
	just dynamic types.
	
4) The current 5.15.1, "Data Location" is renumbered to 5.15.1.1, and
5.15.2, "Allocation and Association Status" is renumbered to
5.15.1.2.

5) The recently introduced 5.15.3, "Array Rank" (mis-numbered as 
5.15.4 in the October 27, 2013 draft because of an earlier header 
level error) is renumbered to 5.15.1.3. 

6) Add DW_TAG_dynamic_type to Table 7-1 (encoding TBD).

7) Add to Table A.1: List of attributes allowed on DW_TAG_descriptor_type

        DW_TAG_dynamic_type
            DECL
            DW_AT_abstract_origin
            DW_AT_allocated
            DW_AT_associated
            DW_AT_data_location
            DW_AT_description
            DW_AT_name
            DW_AT_type
            DW_AT_sibling


8) Add the following example at the end of Appendix D.2.1, "Fortran
Array Example":
	
	Consider the Fortran 90 example of dynamic properties in Figure 
	D.<1>. This can be represented in DWARF as illustrated in Figure
	D.<2>. Note that unnamed dynamic types are used to avoid replicating
	the full description of the underlying type dt that is shared by
	several variables.
	
	----------------------------------------------------------------
	  program sample
     
      type :: dt (l)
        integer, len :: l
        integer :: arr(l)
      end type

      integer :: n = 4
      contains

      subroutine s()
        type (dt(n))               :: t1
        type (dt(n)), pointer      :: t2
        type (dt(n)), allocatable  :: t3, t4
      end subroutine
     
      end sample
    -----------------------------------------------------------------
	            Figure D.<1>: Fortran dynamic types: source
	
	-----------------------------------------------------------------
	11$:    DW_TAG_structure_type
            DW_AT_name("dt")
                DW_TAG_member
                    ...
			    ...

    13$:    DW_TAG_dynamic_type             ! plain version
                DW_AT_data_location (dwarf expression to locate raw data)
                DW_AT_type (11$)

    14$:    DW_TAG_dynamic_type             ! 'pointer' version
                DW_AT_data_location (dwarf expression to locate raw data)
                DW_AT_associated (dwarf expression to test if associated)
                DW_AT_type (11$)

    15$:    DW_TAG_dynamic_type             ! 'allocatable' version
                DW_AT_data_location (dwarf expression to locate raw data)
                DW_AT_allocated (dwarf expression to test is allocated)
                DW_AT_type (11$)

    16$:    DW_TAG_variable
                DW_AT_name ("t1")
                DW_AT_type (13$)
                DW_AT_location (dwarf expression to locate descriptor)
    17$:    DW_TAG_variable
                DW_AT_name ("t2")
                DW_AT_type (14$)
                DW_AT_location (dwarf expression to locate descriptor)
    18$:    DW_TAG_variable
                DW_AT_name ("t3")
                DW_AT_type (15$)
                DW_AT_location (dwarf expression to locate descriptor)
    19$:    DW_TAG_variable
                DW_AT_name ("t4")
                DW_AT_type (15$)
                DW_AT_location (dwarf expression to locate descriptor)
	-----------------------------------------------------------------
		 Figure D.<2>: Fortran dynamic types: DWARF description


---
Accepted: 11/20/2013.




All logos and trademarks in this site are property of their respective owner.
The comments are property of their posters, all the rest © 2007-2017 by DWARF Standards Committee.