-Debug information descriptors
------------------------------
-
-In consideration of the complexity and volume of debug information, LLVM
-provides a specification for well formed debug descriptors.
-
-Consumers of LLVM debug information expect the descriptors for program objects
-to start in a canonical format, but the descriptors can include additional
-information appended at the end that is source-language specific. All debugging
-information objects start with a tag to indicate what type of object it is.
-The source-language is allowed to define its own objects, by using unreserved
-tag numbers. We recommend using with tags in the range 0x1000 through 0x2000
-(there is a defined ``enum DW_TAG_user_base = 0x1000``.)
-
-The fields of debug descriptors used internally by LLVM are restricted to only
-the simple data types ``i32``, ``i1``, ``float``, ``double``, ``mdstring`` and
-``mdnode``.
-
-.. code-block:: llvm
-
- !1 = metadata !{
- i32, ;; A tag
- ...
- }
-
-<a name="LLVMDebugVersion">The first field of a descriptor is always an
-``i32`` containing a tag value identifying the content of the descriptor.
-The remaining fields are specific to the descriptor. The values of tags are
-loosely bound to the tag values of DWARF information entries. However, that
-does not restrict the use of the information supplied to DWARF targets.
-
-The details of the various descriptors follow.
-
-Compile unit descriptors
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !0 = metadata !{
- i32, ;; Tag = 17 (DW_TAG_compile_unit)
- metadata, ;; Source directory (including trailing slash) & file pair
- i32, ;; DWARF language identifier (ex. DW_LANG_C89)
- metadata ;; Producer (ex. "4.0.1 LLVM (LLVM research group)")
- i1, ;; True if this is optimized.
- metadata, ;; Flags
- i32 ;; Runtime version
- metadata ;; List of enums types
- metadata ;; List of retained types
- metadata ;; List of subprograms
- metadata ;; List of global variables
- metadata ;; List of imported entities
- metadata ;; Split debug filename
- i32 ;; Debug info emission kind (0 = Line Tables Only, 1 = Full Debug Info)
- }
-
-These descriptors contain a source language ID for the file (we use the DWARF
-3.0 ID numbers, such as ``DW_LANG_C89``, ``DW_LANG_C_plus_plus``,
-``DW_LANG_Cobol74``, etc), a reference to a metadata node containing a pair of
-strings for the source file name and the working directory, as well as an
-identifier string for the compiler that produced it.
-
-Compile unit descriptors provide the root context for objects declared in a
-specific compilation unit. File descriptors are defined using this context.
-These descriptors are collected by a named metadata ``!llvm.dbg.cu``. They
-keep track of subprograms, global variables, type information, and imported
-entities (declarations and namespaces).
-
-.. _format_files:
-
-File descriptors
-^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !0 = metadata !{
- i32, ;; Tag = 41 (DW_TAG_file_type)
- metadata, ;; Source directory (including trailing slash) & file pair
- }
-
-These descriptors contain information for a file. Global variables and top
-level functions would be defined using this context. File descriptors also
-provide context for source line correspondence.
-
-Each input file is encoded as a separate file descriptor in LLVM debugging
-information output.
-
-.. _format_global_variables:
-
-Global variable descriptors
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !1 = metadata !{
- i32, ;; Tag = 52 (DW_TAG_variable)
- i32, ;; Unused field.
- metadata, ;; Reference to context descriptor
- metadata, ;; Name
- metadata, ;; Display name (fully qualified C++ name)
- metadata, ;; MIPS linkage name (for C++)
- metadata, ;; Reference to file where defined
- i32, ;; Line number where defined
- metadata, ;; Reference to type descriptor
- i1, ;; True if the global is local to compile unit (static)
- i1, ;; True if the global is defined in the compile unit (not extern)
- {}*, ;; Reference to the global variable
- metadata, ;; The static member declaration, if any
- }
-
-These descriptors provide debug information about global variables. They
-provide details such as name, type and where the variable is defined. All
-global variables are collected inside the named metadata ``!llvm.dbg.cu``.
-
-.. _format_subprograms:
-
-Subprogram descriptors
-^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32, ;; Tag = 46 (DW_TAG_subprogram)
- metadata, ;; Source directory (including trailing slash) & file pair
- metadata, ;; Reference to context descriptor
- metadata, ;; Name
- metadata, ;; Display name (fully qualified C++ name)
- metadata, ;; MIPS linkage name (for C++)
- i32, ;; Line number where defined
- metadata, ;; Reference to type descriptor
- i1, ;; True if the global is local to compile unit (static)
- i1, ;; True if the global is defined in the compile unit (not extern)
- i32, ;; Virtuality, e.g. dwarf::DW_VIRTUALITY__virtual
- i32, ;; Index into a virtual function
- metadata, ;; indicates which base type contains the vtable pointer for the
- ;; derived class
- i32, ;; Flags - Artificial, Private, Protected, Explicit, Prototyped.
- i1, ;; isOptimized
- {}*, ;; Reference to the LLVM function
- metadata, ;; Lists function template parameters
- metadata, ;; Function declaration descriptor
- metadata, ;; List of function variables
- i32 ;; Line number where the scope of the subprogram begins
- }
-
-These descriptors provide debug information about functions, methods and
-subprograms. They provide details such as name, return types and the source
-location where the subprogram is defined.
-
-Block descriptors
-^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !3 = metadata !{
- i32, ;; Tag = 11 (DW_TAG_lexical_block)
- metadata, ;; Source directory (including trailing slash) & file pair
- metadata, ;; Reference to context descriptor
- i32, ;; Line number
- i32, ;; Column number
- i32, ;; DWARF path discriminator value
- i32 ;; Unique ID to identify blocks from a template function
- }
-
-This descriptor provides debug information about nested blocks within a
-subprogram. The line number and column numbers are used to dinstinguish two
-lexical blocks at same depth.
-
-.. code-block:: llvm
-
- !3 = metadata !{
- i32, ;; Tag = 11 (DW_TAG_lexical_block)
- metadata, ;; Source directory (including trailing slash) & file pair
- metadata ;; Reference to the scope we're annotating with a file change
- }
-
-This descriptor provides a wrapper around a lexical scope to handle file
-changes in the middle of a lexical block.
-
-.. _format_basic_type:
-
-Basic type descriptors
-^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !4 = metadata !{
- i32, ;; Tag = 36 (DW_TAG_base_type)
- metadata, ;; Source directory (including trailing slash) & file pair (may be null)
- metadata, ;; Reference to context
- metadata, ;; Name (may be "" for anonymous types)
- i32, ;; Line number where defined (may be 0)
- i64, ;; Size in bits
- i64, ;; Alignment in bits
- i64, ;; Offset in bits
- i32, ;; Flags
- i32 ;; DWARF type encoding
- }
-
-These descriptors define primitive types used in the code. Example ``int``,
-``bool`` and ``float``. The context provides the scope of the type, which is
-usually the top level. Since basic types are not usually user defined the
-context and line number can be left as NULL and 0. The size, alignment and
-offset are expressed in bits and can be 64 bit values. The alignment is used
-to round the offset when embedded in a :ref:`composite type
-<format_composite_type>` (example to keep float doubles on 64 bit boundaries).
-The offset is the bit offset if embedded in a :ref:`composite type
-<format_composite_type>`.
-
-The type encoding provides the details of the type. The values are typically
-one of the following:
-
-.. code-block:: llvm
-
- DW_ATE_address = 1
- DW_ATE_boolean = 2
- DW_ATE_float = 4
- DW_ATE_signed = 5
- DW_ATE_signed_char = 6
- DW_ATE_unsigned = 7
- DW_ATE_unsigned_char = 8
-
-.. _format_derived_type:
-
-Derived type descriptors
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !5 = metadata !{
- i32, ;; Tag (see below)
- metadata, ;; Source directory (including trailing slash) & file pair (may be null)
- metadata, ;; Reference to context
- metadata, ;; Name (may be "" for anonymous types)
- i32, ;; Line number where defined (may be 0)
- i64, ;; Size in bits
- i64, ;; Alignment in bits
- i64, ;; Offset in bits
- i32, ;; Flags to encode attributes, e.g. private
- metadata, ;; Reference to type derived from
- metadata, ;; (optional) Name of the Objective C property associated with
- ;; Objective-C an ivar, or the type of which this
- ;; pointer-to-member is pointing to members of.
- metadata, ;; (optional) Name of the Objective C property getter selector.
- metadata, ;; (optional) Name of the Objective C property setter selector.
- i32 ;; (optional) Objective C property attributes.
- }
-
-These descriptors are used to define types derived from other types. The value
-of the tag varies depending on the meaning. The following are possible tag
-values:
-
-.. code-block:: llvm
-
- DW_TAG_formal_parameter = 5
- DW_TAG_member = 13
- DW_TAG_pointer_type = 15
- DW_TAG_reference_type = 16
- DW_TAG_typedef = 22
- DW_TAG_ptr_to_member_type = 31
- DW_TAG_const_type = 38
- DW_TAG_volatile_type = 53
- DW_TAG_restrict_type = 55
-
-``DW_TAG_member`` is used to define a member of a :ref:`composite type
-<format_composite_type>` or :ref:`subprogram <format_subprograms>`. The type
-of the member is the :ref:`derived type <format_derived_type>`.
-``DW_TAG_formal_parameter`` is used to define a member which is a formal
-argument of a subprogram.
-
-``DW_TAG_typedef`` is used to provide a name for the derived type.
-
-``DW_TAG_pointer_type``, ``DW_TAG_reference_type``, ``DW_TAG_const_type``,
-``DW_TAG_volatile_type`` and ``DW_TAG_restrict_type`` are used to qualify the
-:ref:`derived type <format_derived_type>`.
-
-:ref:`Derived type <format_derived_type>` location can be determined from the
-context and line number. The size, alignment and offset are expressed in bits
-and can be 64 bit values. The alignment is used to round the offset when
-embedded in a :ref:`composite type <format_composite_type>` (example to keep
-float doubles on 64 bit boundaries.) The offset is the bit offset if embedded
-in a :ref:`composite type <format_composite_type>`.
-
-Note that the ``void *`` type is expressed as a type derived from NULL.
-
-.. _format_composite_type:
-
-Composite type descriptors
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !6 = metadata !{
- i32, ;; Tag (see below)
- metadata, ;; Source directory (including trailing slash) & file pair (may be null)
- metadata, ;; Reference to context
- metadata, ;; Name (may be "" for anonymous types)
- i32, ;; Line number where defined (may be 0)
- i64, ;; Size in bits
- i64, ;; Alignment in bits
- i64, ;; Offset in bits
- i32, ;; Flags
- metadata, ;; Reference to type derived from
- metadata, ;; Reference to array of member descriptors
- i32, ;; Runtime languages
- metadata, ;; Base type containing the vtable pointer for this type
- metadata, ;; Template parameters
- metadata ;; A unique identifier for type uniquing purpose (may be null)
- }
-
-These descriptors are used to define types that are composed of 0 or more
-elements. The value of the tag varies depending on the meaning. The following
-are possible tag values:
-
-.. code-block:: llvm
-
- DW_TAG_array_type = 1
- DW_TAG_enumeration_type = 4
- DW_TAG_structure_type = 19
- DW_TAG_union_type = 23
- DW_TAG_subroutine_type = 21
- DW_TAG_inheritance = 28
-
-The vector flag indicates that an array type is a native packed vector.
-
-The members of array types (tag = ``DW_TAG_array_type``) are
-:ref:`subrange descriptors <format_subrange>`, each
-representing the range of subscripts at that level of indexing.
-
-The members of enumeration types (tag = ``DW_TAG_enumeration_type``) are
-:ref:`enumerator descriptors <format_enumerator>`, each representing the
-definition of enumeration value for the set. All enumeration type descriptors
-are collected inside the named metadata ``!llvm.dbg.cu``.
-
-The members of structure (tag = ``DW_TAG_structure_type``) or union (tag =
-``DW_TAG_union_type``) types are any one of the :ref:`basic
-<format_basic_type>`, :ref:`derived <format_derived_type>` or :ref:`composite
-<format_composite_type>` type descriptors, each representing a field member of
-the structure or union.
-
-For C++ classes (tag = ``DW_TAG_structure_type``), member descriptors provide
-information about base classes, static members and member functions. If a
-member is a :ref:`derived type descriptor <format_derived_type>` and has a tag
-of ``DW_TAG_inheritance``, then the type represents a base class. If the member
-of is a :ref:`global variable descriptor <format_global_variables>` then it
-represents a static member. And, if the member is a :ref:`subprogram
-descriptor <format_subprograms>` then it represents a member function. For
-static members and member functions, ``getName()`` returns the members link or
-the C++ mangled name. ``getDisplayName()`` the simplied version of the name.
-
-The first member of subroutine (tag = ``DW_TAG_subroutine_type``) type elements
-is the return type for the subroutine. The remaining elements are the formal
-arguments to the subroutine.
-
-:ref:`Composite type <format_composite_type>` location can be determined from
-the context and line number. The size, alignment and offset are expressed in
-bits and can be 64 bit values. The alignment is used to round the offset when
-embedded in a :ref:`composite type <format_composite_type>` (as an example, to
-keep float doubles on 64 bit boundaries). The offset is the bit offset if
-embedded in a :ref:`composite type <format_composite_type>`.
-
-.. _format_subrange:
-
-Subrange descriptors
-^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !42 = metadata !{
- i32, ;; Tag = 33 (DW_TAG_subrange_type)
- i64, ;; Low value
- i64 ;; High value
- }
-
-These descriptors are used to define ranges of array subscripts for an array
-:ref:`composite type <format_composite_type>`. The low value defines the lower
-bounds typically zero for C/C++. The high value is the upper bounds. Values
-are 64 bit. ``High - Low + 1`` is the size of the array. If ``Low > High``
-the array bounds are not included in generated debugging information.
-
-.. _format_enumerator:
-
-Enumerator descriptors
-^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !6 = metadata !{
- i32, ;; Tag = 40 (DW_TAG_enumerator)
- metadata, ;; Name
- i64 ;; Value
- }
-
-These descriptors are used to define members of an enumeration :ref:`composite
-type <format_composite_type>`, it associates the name to the value.
-
-Local variables
-^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !7 = metadata !{
- i32, ;; Tag (see below)
- metadata, ;; Context
- metadata, ;; Name
- metadata, ;; Reference to file where defined
- i32, ;; 24 bit - Line number where defined
- ;; 8 bit - Argument number. 1 indicates 1st argument.
- metadata, ;; Reference to the type descriptor
- i32, ;; flags
- metadata ;; (optional) Reference to inline location
- metadata ;; (optional) Reference to a complex expression (see below)
- }
-
-These descriptors are used to define variables local to a sub program. The
-value of the tag depends on the usage of the variable:
-
-.. code-block:: llvm
-
- DW_TAG_auto_variable = 256
- DW_TAG_arg_variable = 257
-
-An auto variable is any variable declared in the body of the function. An
-argument variable is any variable that appears as a formal argument to the
-function.
-
-The context is either the subprogram or block where the variable is defined.
-Name the source variable name. Context and line indicate where the variable
-was defined. Type descriptor defines the declared type of the variable.
-
-The ``OpPiece`` operator is used for (typically larger aggregate)
-variables that are fragmented across several locations. It takes two
-i32 arguments, an offset and a size in bytes to describe which piece
-of the variable is at this location.
-