Source Level Debugging with LLVM
================================
-.. sectionauthor:: Chris Lattner <sabre@nondot.org> and Jim Laskey <jlaskey@mac.com>
-
.. contents::
:local:
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 LLVM
-debugging information is versioned, allowing backwards compatibility in the
-case that the core structures need to change in some way. Also, all debugging
+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
...
}
-<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. To
-facilitate versioning of debug information, the tag is augmented with the
-current debug version (``LLVMDebugVersion = 8 << 16`` or 0x80000 or
-524288.)
+Most of the string and integer fields in descriptors are packed into a single,
+null-separated ``mdstring``. The first field of the header is always an
+``i32`` containing the DWARF tag value identifying the content of the
+descriptor.
+
+For clarity of definition in this document, these header fields are described
+below split inside an imaginary ``DIHeader`` construct. This is invalid
+assembly syntax. In valid IR, these fields are stringified and concatenated,
+separated by ``\00``.
The details of the various descriptors follow.
.. code-block:: llvm
!0 = metadata !{
- i32, ;; Tag = 17 + LLVMDebugVersion (DW_TAG_compile_unit)
- i32, ;; Unused field.
- i32, ;; DWARF language identifier (ex. DW_LANG_C89)
- metadata, ;; Source file name
- metadata, ;; Source file directory (includes trailing slash)
- metadata ;; Producer (ex. "4.0.1 LLVM (LLVM research group)")
- i1, ;; True if this is a main compile unit.
- 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
+ DIHeader(
+ i32, ;; Tag = 17 (DW_TAG_compile_unit)
+ i32, ;; DWARF language identifier (ex. DW_LANG_C89)
+ mdstring, ;; Producer (ex. "4.0.1 LLVM (LLVM research group)")
+ i1, ;; True if this is optimized.
+ mdstring, ;; Flags
+ i32, ;; Runtime version
+ mdstring, ;; Split debug filename
+ i32 ;; Debug info emission kind (1 = Full Debug Info, 2 = Line Tables Only)
+ ),
+ metadata, ;; Source directory (including trailing slash) & file pair
+ metadata, ;; List of enums types
+ metadata, ;; List of retained types
+ metadata, ;; List of subprograms
+ metadata, ;; List of global variables
+ metadata ;; List of imported entities
}
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), three strings describing the filename, working
-directory of the compiler, and an identifier string for the compiler that
-produced it.
+``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 and type information.
+keep track of subprograms, global variables, type information, and imported
+entities (declarations and namespaces).
.. _format_files:
.. code-block:: llvm
!0 = metadata !{
- i32, ;; Tag = 41 + LLVMDebugVersion (DW_TAG_file_type)
- metadata, ;; Source file name
- metadata, ;; Source file directory (includes trailing slash)
- metadata ;; Unused
+ DIHeader(
+ 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
.. code-block:: llvm
!1 = metadata !{
- i32, ;; Tag = 52 + LLVMDebugVersion (DW_TAG_variable)
- i32, ;; Unused field.
+ DIHeader(
+ i32, ;; Tag = 52 (DW_TAG_variable)
+ mdstring, ;; Name
+ mdstring, ;; Display name (fully qualified C++ name)
+ mdstring, ;; MIPS linkage name (for C++)
+ i32, ;; Line number where defined
+ i1, ;; True if the global is local to compile unit (static)
+ i1 ;; True if the global is defined in the compile unit (not extern)
+ ),
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
+ {}*, ;; Reference to the global variable
+ metadata, ;; The static member declaration, if any
}
-These descriptors provide debug information about globals variables. They
+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``.
.. code-block:: llvm
!2 = metadata !{
- i32, ;; Tag = 46 + LLVMDebugVersion (DW_TAG_subprogram)
- i32, ;; Unused field.
+ DIHeader(
+ i32, ;; Tag = 46 (DW_TAG_subprogram)
+ mdstring, ;; Name
+ mdstring, ;; Display name (fully qualified C++ name)
+ mdstring, ;; MIPS linkage name (for C++)
+ i32, ;; Line number where defined
+ 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
+ i32, ;; Flags - Artificial, Private, Protected, Explicit, Prototyped.
+ i1, ;; isOptimized
+ i32 ;; Line number where the scope of the subprogram begins
+ ),
+ 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++)
- 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)
- i32, ;; Line number where the scope of the subprogram begins
- 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 - Artifical, Private, Protected, Explicit, Prototyped.
- i1, ;; isOptimized
- Function * , ;; Pointer to LLVM function
+ {}*, ;; Reference to the LLVM function
metadata, ;; Lists function template parameters
metadata, ;; Function declaration descriptor
metadata ;; List of function variables
.. code-block:: llvm
!3 = metadata !{
- i32, ;; Tag = 11 + LLVMDebugVersion (DW_TAG_lexical_block)
- metadata,;; Reference to context descriptor
- i32, ;; Line number
- i32, ;; Column number
- metadata,;; Reference to source file
- i32 ;; Unique ID to identify blocks from a template function
+ DIHeader(
+ i32, ;; Tag = 11 (DW_TAG_lexical_block)
+ i32, ;; Line number
+ i32, ;; Column number
+ i32 ;; Unique ID to identify blocks from a template function
+ ),
+ metadata, ;; Source directory (including trailing slash) & file pair
+ metadata ;; Reference to context descriptor
}
This descriptor provides debug information about nested blocks within a
.. code-block:: llvm
!3 = metadata !{
- i32, ;; Tag = 11 + LLVMDebugVersion (DW_TAG_lexical_block)
- metadata ;; Reference to the scope we're annotating with a file change
- metadata,;; Reference to the file the scope is enclosed in.
+ DIHeader(
+ i32, ;; Tag = 11 (DW_TAG_lexical_block)
+ i32 ;; DWARF path discriminator value
+ ),
+ 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
.. code-block:: llvm
!4 = metadata !{
- i32, ;; Tag = 36 + LLVMDebugVersion (DW_TAG_base_type)
- metadata, ;; Reference to context
- metadata, ;; Name (may be "" for anonymous types)
- metadata, ;; Reference to file where defined (may be NULL)
- 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
+ DIHeader(
+ i32, ;; Tag = 36 (DW_TAG_base_type)
+ mdstring, ;; 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
+ ),
+ metadata, ;; Source directory (including trailing slash) & file pair (may be null)
+ metadata ;; Reference to context
}
These descriptors define primitive types used in the code. Example ``int``,
.. code-block:: llvm
!5 = metadata !{
- i32, ;; Tag (see below)
+ DIHeader(
+ i32, ;; Tag (see below)
+ mdstring, ;; 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, ;; Source directory (including trailing slash) & file pair (may be null)
metadata, ;; Reference to context
- metadata, ;; Name (may be "" for anonymous types)
- metadata, ;; Reference to file where defined (may be NULL)
- 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.
+ metadata ;; (optional) Objective C property node
}
These descriptors are used to define types derived from other types. The value
.. code-block:: llvm
!6 = metadata !{
- i32, ;; Tag (see below)
+ DIHeader(
+ i32, ;; Tag (see below)
+ mdstring, ;; 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 ;; Runtime languages
+ ),
+ metadata, ;; Source directory (including trailing slash) & file pair (may be null)
metadata, ;; Reference to context
- metadata, ;; Name (may be "" for anonymous types)
- metadata, ;; Reference to file where defined (may be NULL)
- 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
+ mdstring ;; A unique identifier for type uniquing purpose (may be null)
}
These descriptors are used to define types that are composed of 0 or more
.. code-block:: llvm
!42 = metadata !{
- i32, ;; Tag = 33 + LLVMDebugVersion (DW_TAG_subrange_type)
- i64, ;; Low value
- i64 ;; High value
+ DIHeader(
+ 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
.. code-block:: llvm
!6 = metadata !{
- i32, ;; Tag = 40 + LLVMDebugVersion (DW_TAG_enumerator)
- metadata, ;; Name
- i64 ;; Value
+ DIHeader(
+ i32, ;; Tag = 40 (DW_TAG_enumerator)
+ mdstring, ;; Name
+ i64 ;; Value
+ )
}
These descriptors are used to define members of an enumeration :ref:`composite
.. code-block:: llvm
!7 = metadata !{
- i32, ;; Tag (see below)
+ DIHeader(
+ i32, ;; Tag (see below)
+ mdstring, ;; Name
+ i32, ;; 24 bit - Line number where defined
+ ;; 8 bit - Argument number. 1 indicates 1st argument.
+ i32 ;; flags
+ ),
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, ;; Type descriptor
- i32, ;; flags
+ metadata, ;; Reference to the type descriptor
metadata ;; (optional) Reference to inline location
}
Name the source variable name. Context and line indicate where the variable
was defined. Type descriptor defines the declared type of the variable.
+Complex Expressions
+^^^^^^^^^^^^^^^^^^^
+.. code-block:: llvm
+
+ !8 = metadata !{
+ i32, ;; DW_TAG_expression
+ ...
+ }
+
+Complex expressions describe variable storage locations in terms of
+prefix-notated DWARF expressions. Currently the only supported
+operators are ``DW_OP_plus``, ``DW_OP_deref``, and ``DW_OP_piece``.
+
+The ``DW_OP_piece`` 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.
+
+
.. _format_common_intrinsics:
Debugger intrinsic functions
.. code-block:: llvm
- define void @foo() nounwind ssp {
+ define void @foo() #0 {
entry:
- %X = alloca i32, align 4 ; <i32*> [#uses=4]
- %Y = alloca i32, align 4 ; <i32*> [#uses=4]
- %Z = alloca i32, align 4 ; <i32*> [#uses=3]
- %0 = bitcast i32* %X to {}* ; <{}*> [#uses=1]
- call void @llvm.dbg.declare(metadata !{i32 * %X}, metadata !0), !dbg !7
- store i32 21, i32* %X, !dbg !8
- %1 = bitcast i32* %Y to {}* ; <{}*> [#uses=1]
- call void @llvm.dbg.declare(metadata !{i32 * %Y}, metadata !9), !dbg !10
- store i32 22, i32* %Y, !dbg !11
- %2 = bitcast i32* %Z to {}* ; <{}*> [#uses=1]
- call void @llvm.dbg.declare(metadata !{i32 * %Z}, metadata !12), !dbg !14
- store i32 23, i32* %Z, !dbg !15
- %tmp = load i32* %X, !dbg !16 ; <i32> [#uses=1]
- %tmp1 = load i32* %Y, !dbg !16 ; <i32> [#uses=1]
- %add = add nsw i32 %tmp, %tmp1, !dbg !16 ; <i32> [#uses=1]
- store i32 %add, i32* %Z, !dbg !16
- %tmp2 = load i32* %Y, !dbg !17 ; <i32> [#uses=1]
- store i32 %tmp2, i32* %X, !dbg !17
- ret void, !dbg !18
+ %X = alloca i32, align 4
+ %Y = alloca i32, align 4
+ %Z = alloca i32, align 4
+ call void @llvm.dbg.declare(metadata !{i32* %X}, metadata !10), !dbg !12
+ ; [debug line = 2:7] [debug variable = X]
+ store i32 21, i32* %X, align 4, !dbg !12
+ call void @llvm.dbg.declare(metadata !{i32* %Y}, metadata !13), !dbg !14
+ ; [debug line = 3:7] [debug variable = Y]
+ store i32 22, i32* %Y, align 4, !dbg !14
+ call void @llvm.dbg.declare(metadata !{i32* %Z}, metadata !15), !dbg !17
+ ; [debug line = 5:9] [debug variable = Z]
+ store i32 23, i32* %Z, align 4, !dbg !17
+ %0 = load i32* %X, align 4, !dbg !18
+ [debug line = 6:5]
+ store i32 %0, i32* %Z, align 4, !dbg !18
+ %1 = load i32* %Y, align 4, !dbg !19
+ [debug line = 8:3]
+ store i32 %1, i32* %X, align 4, !dbg !19
+ ret void, !dbg !20
}
- declare void @llvm.dbg.declare(metadata, metadata) nounwind readnone
-
- !0 = metadata !{i32 459008, metadata !1, metadata !"X",
- metadata !3, i32 2, metadata !6}; [ DW_TAG_auto_variable ]
- !1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
- !2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", metadata !"foo",
- metadata !"foo", metadata !3, i32 1, metadata !4,
- i1 false, i1 true}; [DW_TAG_subprogram ]
- !3 = metadata !{i32 458769, i32 0, i32 12, metadata !"foo.c",
- metadata !"/private/tmp", metadata !"clang 1.1", i1 true,
- i1 false, metadata !"", i32 0}; [DW_TAG_compile_unit ]
- !4 = metadata !{i32 458773, metadata !3, metadata !"", null, i32 0, i64 0, i64 0,
- i64 0, i32 0, null, metadata !5, i32 0}; [DW_TAG_subroutine_type ]
- !5 = metadata !{null}
- !6 = metadata !{i32 458788, metadata !3, metadata !"int", metadata !3, i32 0,
- i64 32, i64 32, i64 0, i32 0, i32 5}; [DW_TAG_base_type ]
- !7 = metadata !{i32 2, i32 7, metadata !1, null}
- !8 = metadata !{i32 2, i32 3, metadata !1, null}
- !9 = metadata !{i32 459008, metadata !1, metadata !"Y", metadata !3, i32 3,
- metadata !6}; [ DW_TAG_auto_variable ]
- !10 = metadata !{i32 3, i32 7, metadata !1, null}
- !11 = metadata !{i32 3, i32 3, metadata !1, null}
- !12 = metadata !{i32 459008, metadata !13, metadata !"Z", metadata !3, i32 5,
- metadata !6}; [ DW_TAG_auto_variable ]
- !13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
- !14 = metadata !{i32 5, i32 9, metadata !13, null}
- !15 = metadata !{i32 5, i32 5, metadata !13, null}
- !16 = metadata !{i32 6, i32 5, metadata !13, null}
- !17 = metadata !{i32 8, i32 3, metadata !1, null}
- !18 = metadata !{i32 9, i32 1, metadata !2, null}
+ ; Function Attrs: nounwind readnone
+ declare void @llvm.dbg.declare(metadata, metadata) #1
+
+ attributes #0 = { nounwind ssp uwtable "less-precise-fpmad"="false"
+ "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf"
+ "no-infs-fp-math"="false" "no-nans-fp-math"="false"
+ "stack-protector-buffer-size"="8" "unsafe-fp-math"="false"
+ "use-soft-float"="false" }
+ attributes #1 = { nounwind readnone }
+
+ !llvm.dbg.cu = !{!0}
+ !llvm.module.flags = !{!8}
+ !llvm.ident = !{!9}
+
+ !0 = metadata !{i32 786449, metadata !1, i32 12,
+ metadata !"clang version 3.4 (trunk 193128) (llvm/trunk 193139)",
+ i1 false, metadata !"", i32 0, metadata !2, metadata !2, metadata !3,
+ metadata !2, metadata !2, metadata !""} ; [ DW_TAG_compile_unit ] \
+ [/private/tmp/foo.c] \
+ [DW_LANG_C99]
+ !1 = metadata !{metadata !"t.c", metadata !"/private/tmp"}
+ !2 = metadata !{i32 0}
+ !3 = metadata !{metadata !4}
+ !4 = metadata !{i32 786478, metadata !1, metadata !5, metadata !"foo",
+ metadata !"foo", metadata !"", i32 1, metadata !6,
+ i1 false, i1 true, i32 0, i32 0, null, i32 0, i1 false,
+ void ()* @foo, null, null, metadata !2, i32 1}
+ ; [ DW_TAG_subprogram ] [line 1] [def] [foo]
+ !5 = metadata !{i32 786473, metadata !1} ; [ DW_TAG_file_type ] \
+ [/private/tmp/t.c]
+ !6 = metadata !{i32 786453, i32 0, null, metadata !"", i32 0, i64 0, i64 0,
+ i64 0, i32 0, null, metadata !7, i32 0, null, null, null}
+ ; [ DW_TAG_subroutine_type ] \
+ [line 0, size 0, align 0, offset 0] [from ]
+ !7 = metadata !{null}
+ !8 = metadata !{i32 2, metadata !"Dwarf Version", i32 2}
+ !9 = metadata !{metadata !"clang version 3.4 (trunk 193128) (llvm/trunk 193139)"}
+ !10 = metadata !{i32 786688, metadata !4, metadata !"X", metadata !5, i32 2,
+ metadata !11, i32 0, i32 0} ; [ DW_TAG_auto_variable ] [X] \
+ [line 2]
+ !11 = metadata !{i32 786468, null, null, metadata !"int", i32 0, i64 32,
+ i64 32, i64 0, i32 0, i32 5} ; [ DW_TAG_base_type ] [int] \
+ [line 0, size 32, align 32, offset 0, enc DW_ATE_signed]
+ !12 = metadata !{i32 2, i32 0, metadata !4, null}
+ !13 = metadata !{i32 786688, metadata !4, metadata !"Y", metadata !5, i32 3,
+ metadata !11, i32 0, i32 0} ; [ DW_TAG_auto_variable ] [Y] \
+ [line 3]
+ !14 = metadata !{i32 3, i32 0, metadata !4, null}
+ !15 = metadata !{i32 786688, metadata !16, metadata !"Z", metadata !5, i32 5,
+ metadata !11, i32 0, i32 0} ; [ DW_TAG_auto_variable ] [Z] \
+ [line 5]
+ !16 = metadata !{i32 786443, metadata !1, metadata !4, i32 4, i32 0, i32 0} \
+ ; [ DW_TAG_lexical_block ] [/private/tmp/t.c]
+ !17 = metadata !{i32 5, i32 0, metadata !16, null}
+ !18 = metadata !{i32 6, i32 0, metadata !16, null}
+ !19 = metadata !{i32 8, i32 0, metadata !4, null} ; [ DW_TAG_imported_declaration ]
+ !20 = metadata !{i32 9, i32 0, metadata !4, null}
This example illustrates a few important details about LLVM debugging
information. In particular, it shows how the ``llvm.dbg.declare`` intrinsic and
.. code-block:: llvm
- call void @llvm.dbg.declare(metadata, metadata !0), !dbg !7
+ call void @llvm.dbg.declare(metadata !{i32* %X}, metadata !10), !dbg !12
+ ; [debug line = 2:7] [debug variable = X]
The first intrinsic ``%llvm.dbg.declare`` encodes debugging information for the
-variable ``X``. The metadata ``!dbg !7`` attached to the intrinsic provides
+variable ``X``. The metadata ``!dbg !12`` attached to the intrinsic provides
scope information for the variable ``X``.
.. code-block:: llvm
- !7 = metadata !{i32 2, i32 7, metadata !1, null}
- !1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
- !2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo",
- metadata !"foo", metadata !"foo", metadata !3, i32 1,
- metadata !4, i1 false, i1 true}; [DW_TAG_subprogram ]
+ !12 = metadata !{i32 2, i32 0, metadata !4, null}
+ !4 = metadata !{i32 786478, metadata !1, metadata !5, metadata !"foo",
+ metadata !"foo", metadata !"", i32 1, metadata !6,
+ i1 false, i1 true, i32 0, i32 0, null, i32 0, i1 false,
+ void ()* @foo, null, null, metadata !2, i32 1}
+ ; [ DW_TAG_subprogram ] [line 1] [def] [foo]
-Here ``!7`` is metadata providing location information. It has four fields:
+Here ``!12`` is metadata providing location information. It has four fields:
line number, column number, scope, and original scope. The original scope
represents inline location if this instruction is inlined inside a caller, and
-is null otherwise. In this example, scope is encoded by ``!1``. ``!1``
-represents a lexical block inside the scope ``!2``, where ``!2`` is a
+is null otherwise. In this example, scope is encoded by ``!4``, a
:ref:`subprogram descriptor <format_subprograms>`. This way the location
information attached to the intrinsics indicates that the variable ``X`` is
declared at line number 2 at a function level scope in function ``foo``.
.. code-block:: llvm
- call void @llvm.dbg.declare(metadata, metadata !12), !dbg !14
+ call void @llvm.dbg.declare(metadata !{i32* %Z}, metadata !15), !dbg !17
+ ; [debug line = 5:9] [debug variable = Z]
-The second intrinsic ``%llvm.dbg.declare`` encodes debugging information for
-variable ``Z``. The metadata ``!dbg !14`` attached to the intrinsic provides
+The third intrinsic ``%llvm.dbg.declare`` encodes debugging information for
+variable ``Z``. The metadata ``!dbg !17`` attached to the intrinsic provides
scope information for the variable ``Z``.
.. code-block:: llvm
- !13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
- !14 = metadata !{i32 5, i32 9, metadata !13, null}
+ !16 = metadata !{i32 786443, metadata !1, metadata !4, i32 4, i32 0, i32 0} \
+ ; [ DW_TAG_lexical_block ] [/private/tmp/t.c]
+ !17 = metadata !{i32 5, i32 0, metadata !16, null}
-Here ``!14`` indicates that ``Z`` is declared at line number 5 and
-column number 9 inside of lexical scope ``!13``. The lexical scope itself
-resides inside of lexical scope ``!1`` described above.
+Here ``!15`` indicates that ``Z`` is declared at line number 5 and
+column number 0 inside of lexical scope ``!16``. The lexical scope itself
+resides inside of subprogram ``!4`` described above.
The scope information attached with each instruction provides a straightforward
way to find instructions covered by a scope.
As support for debugging information gets added to the various LLVM
source-language front-ends, the information used should be documented here.
-The following sections provide examples of various C/C++ constructs and the
-debug information that would best describe those constructs.
+The following sections provide examples of a few C/C++ constructs and the debug
+information that would best describe those constructs. The canonical
+references are the ``DIDescriptor`` classes defined in
+``include/llvm/IR/DebugInfo.h`` and the implementations of the helper functions
+in ``lib/IR/DIBuilder.cpp``.
C/C++ source file information
-----------------------------
-Given the source files ``MySource.cpp`` and ``MyHeader.h`` located in the
-directory ``/Users/mine/sources``, the following code:
-
-.. code-block:: c
-
- #include "MyHeader.h"
-
- int main(int argc, char *argv[]) {
- return 0;
- }
-
-a C/C++ front-end would generate the following descriptors:
-
-.. code-block:: llvm
-
- ...
- ;;
- ;; Define the compile unit for the main source file "/Users/mine/sources/MySource.cpp".
- ;;
- !2 = metadata !{
- i32 524305, ;; Tag
- i32 0, ;; Unused
- i32 4, ;; Language Id
- metadata !"MySource.cpp",
- metadata !"/Users/mine/sources",
- metadata !"4.2.1 (Based on Apple Inc. build 5649) (LLVM build 00)",
- i1 true, ;; Main Compile Unit
- i1 false, ;; Optimized compile unit
- metadata !"", ;; Compiler flags
- i32 0} ;; Runtime version
-
- ;;
- ;; Define the file for the file "/Users/mine/sources/MySource.cpp".
- ;;
- !1 = metadata !{
- i32 524329, ;; Tag
- metadata !"MySource.cpp",
- metadata !"/Users/mine/sources",
- metadata !2 ;; Compile unit
- }
-
- ;;
- ;; Define the file for the file "/Users/mine/sources/Myheader.h"
- ;;
- !3 = metadata !{
- i32 524329, ;; Tag
- metadata !"Myheader.h"
- metadata !"/Users/mine/sources",
- metadata !2 ;; Compile unit
- }
-
- ...
-
``llvm::Instruction`` provides easy access to metadata attached with an
instruction. One can extract line number information encoded in LLVM IR using
``Instruction::getMetadata()`` and ``DILocation::getLineNumber()``.
;;
;; Define the global itself.
;;
- %MyGlobal = global int 100
+ @MyGlobal = global i32 100, align 4
...
;;
;; List of debug info of globals
;; Define the compile unit.
!0 = metadata !{
- i32 786449, ;; Tag
- i32 0, ;; Context
- i32 4, ;; Language
- metadata !"foo.cpp", ;; File
- metadata !"/Volumes/Data/tmp", ;; Directory
- metadata !"clang version 3.1 ", ;; Producer
- i1 true, ;; Deprecated field
- i1 false, ;; "isOptimized"?
- metadata !"", ;; Flags
- i32 0, ;; Runtime Version
- metadata !1, ;; Enum Types
- metadata !1, ;; Retained Types
- metadata !1, ;; Subprograms
- metadata !3 ;; Global Variables
+ ; Header(
+ ; i32 17, ;; Tag
+ ; i32 0, ;; Context
+ ; i32 4, ;; Language
+ ; metadata !"clang version 3.6.0 ", ;; Producer
+ ; i1 false, ;; "isOptimized"?
+ ; metadata !"", ;; Flags
+ ; i32 0, ;; Runtime Version
+ ; "", ;; Split debug filename
+ ; 1 ;; Full debug info
+ ; )
+ metadata !"0x11\0012\00clang version 3.6.0 \000\00\000\00\001",
+ metadata !1, ;; File
+ metadata !2, ;; Enum Types
+ metadata !2, ;; Retained Types
+ metadata !2, ;; Subprograms
+ metadata !3, ;; Global Variables
+ metadata !2 ;; Imported entities
} ; [ DW_TAG_compile_unit ]
+ ;; The file/directory pair.
+ !1 = metadata !{
+ metadata !"foo.c", ;; Filename
+ metadata !"/Users/dexonsmith/data/llvm/debug-info" ;; Directory
+ }
+
+ ;; An empty array.
+ !2 = metadata !{}
+
;; The Array of Global Variables
!3 = metadata !{
metadata !4
}
- !4 = metadata !{
- metadata !5
- }
-
;;
;; Define the global variable itself.
;;
- !5 = metadata !{
- i32 786484, ;; Tag
- i32 0, ;; Unused
+ !4 = metadata !{
+ ; Header(
+ ; i32 52, ;; Tag
+ ; metadata !"MyGlobal", ;; Name
+ ; metadata !"MyGlobal", ;; Display Name
+ ; metadata !"", ;; Linkage Name
+ ; i32 1, ;; Line
+ ; i32 0, ;; IsLocalToUnit
+ ; i32 1 ;; IsDefinition
+ ; )
+ metadata !"0x34\00MyGlobal\00MyGlobal\00\001\000\001",
null, ;; Unused
- metadata !"MyGlobal", ;; Name
- metadata !"MyGlobal", ;; Display Name
- metadata !"", ;; Linkage Name
- metadata !6, ;; File
- i32 1, ;; Line
- metadata !7, ;; Type
- i32 0, ;; IsLocalToUnit
- i32 1, ;; IsDefinition
- i32* @MyGlobal ;; LLVM-IR Value
+ metadata !5, ;; File
+ metadata !6, ;; Type
+ i32* @MyGlobal, ;; LLVM-IR Value
+ null ;; Static member declaration
} ; [ DW_TAG_variable ]
;;
;; Define the file
;;
- !6 = metadata !{
- i32 786473, ;; Tag
- metadata !"foo.cpp", ;; File
- metadata !"/Volumes/Data/tmp", ;; Directory
- null ;; Unused
+ !5 = metadata !{
+ ; Header(
+ ; i32 41 ;; Tag
+ ; )
+ metadata !"0x29",
+ metadata !1 ;; File/directory pair
} ; [ DW_TAG_file_type ]
;;
;; Define the type
;;
- !7 = metadata !{
- i32 786468, ;; Tag
- null, ;; Unused
- metadata !"int", ;; Name
- null, ;; Unused
- i32 0, ;; Line
- i64 32, ;; Size in Bits
- i64 32, ;; Align in Bits
- i64 0, ;; Offset
- i32 0, ;; Flags
- i32 5 ;; Encoding
+ !6 = metadata !{
+ ; Header(
+ ; i32 36, ;; Tag
+ ; metadata !"int", ;; Name
+ ; i32 0, ;; Line
+ ; i64 32, ;; Size in Bits
+ ; i64 32, ;; Align in Bits
+ ; i64 0, ;; Offset
+ ; i32 0, ;; Flags
+ ; i32 5 ;; Encoding
+ ; )
+ metadata !"0x24\00int\000\0032\0032\000\000\005",
+ null, ;; Unused
+ null ;; Unused
} ; [ DW_TAG_base_type ]
C/C++ function information
.. code-block:: llvm
;;
- ;; Define the anchor for subprograms. Note that the second field of the
- ;; anchor is 46, which is the same as the tag for subprograms
- ;; (46 = DW_TAG_subprogram.)
+ ;; Define the anchor for subprograms.
;;
!6 = metadata !{
- i32 524334, ;; Tag
- i32 0, ;; Unused
- metadata !1, ;; Context
- metadata !"main", ;; Name
- metadata !"main", ;; Display name
- metadata !"main", ;; Linkage name
- metadata !1, ;; File
- i32 1, ;; Line number
- metadata !4, ;; Type
- i1 false, ;; Is local
- i1 true, ;; Is definition
- i32 0, ;; Virtuality attribute, e.g. pure virtual function
- i32 0, ;; Index into virtual table for C++ methods
- i32 0, ;; Type that holds virtual table.
- i32 0, ;; Flags
- i1 false, ;; True if this function is optimized
- Function *, ;; Pointer to llvm::Function
- null ;; Function template parameters
+ ; Header(
+ ; i32 46, ;; Tag
+ ; metadata !"main", ;; Name
+ ; metadata !"main", ;; Display name
+ ; metadata !"", ;; Linkage name
+ ; i32 1, ;; Line number
+ ; i1 false, ;; Is local
+ ; i1 true, ;; Is definition
+ ; i32 0, ;; Virtuality attribute, e.g. pure virtual function
+ ; i32 0, ;; Index into virtual table for C++ methods
+ ; i32 256, ;; Flags
+ ; i1 0, ;; True if this function is optimized
+ ; 1 ;; Line number of the opening '{' of the function
+ ; )
+ metadata !"0x2e\00main\00main\00\001\000\001\000\000\00256\000\001",
+ metadata !1, ;; File
+ metadata !5, ;; Context
+ metadata !6, ;; Type
+ null, ;; Containing type
+ i32 (i32, i8**)* @main, ;; Pointer to llvm::Function
+ null, ;; Function template parameters
+ null, ;; Function declaration
+ metadata !2 ;; List of function variables (emitted when optimizing)
}
+
;;
;; Define the subprogram itself.
;;
...
}
-C/C++ basic types
------------------
-
-The following are the basic type descriptors for C/C++ core types:
-
-bool
-^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"bool", ;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 8, ;; Size in Bits
- i64 8, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 2 ;; Encoding
- }
-
-char
-^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"char", ;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 8, ;; Size in Bits
- i64 8, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 6 ;; Encoding
- }
-
-unsigned char
-^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"unsigned char",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 8, ;; Size in Bits
- i64 8, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 8 ;; Encoding
- }
-
-short
-^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"short int",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 16, ;; Size in Bits
- i64 16, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 5 ;; Encoding
- }
-
-unsigned short
-^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"short unsigned int",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 16, ;; Size in Bits
- i64 16, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 7 ;; Encoding
- }
-
-int
-^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"int", ;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 32, ;; Size in Bits
- i64 32, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 5 ;; Encoding
- }
-
-unsigned int
-^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"unsigned int",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 32, ;; Size in Bits
- i64 32, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 7 ;; Encoding
- }
-
-long long
-^^^^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"long long int",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 64, ;; Size in Bits
- i64 64, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 5 ;; Encoding
- }
-
-unsigned long long
-^^^^^^^^^^^^^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"long long unsigned int",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 64, ;; Size in Bits
- i64 64, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 7 ;; Encoding
- }
-
-float
-^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"float",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 32, ;; Size in Bits
- i64 32, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 4 ;; Encoding
- }
-
-double
-^^^^^^
-
-.. code-block:: llvm
-
- !2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"double",;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 64, ;; Size in Bits
- i64 64, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 4 ;; Encoding
- }
-
-C/C++ derived types
--------------------
-
-Given the following as an example of C/C++ derived type:
-
-.. code-block:: c
-
- typedef const int *IntPtr;
-
-a C/C++ front-end would generate the following descriptors:
-
-.. code-block:: llvm
-
- ;;
- ;; Define the typedef "IntPtr".
- ;;
- !2 = metadata !{
- i32 524310, ;; Tag
- metadata !1, ;; Context
- metadata !"IntPtr", ;; Name
- metadata !3, ;; File
- i32 0, ;; Line number
- i64 0, ;; Size in bits
- i64 0, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- metadata !4 ;; Derived From type
- }
- ;;
- ;; Define the pointer type.
- ;;
- !4 = metadata !{
- i32 524303, ;; Tag
- metadata !1, ;; Context
- metadata !"", ;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 64, ;; Size in bits
- i64 64, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- metadata !5 ;; Derived From type
- }
- ;;
- ;; Define the const type.
- ;;
- !5 = metadata !{
- i32 524326, ;; Tag
- metadata !1, ;; Context
- metadata !"", ;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- metadata !6 ;; Derived From type
- }
- ;;
- ;; Define the int type.
- ;;
- !6 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"int", ;; Name
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- 5 ;; Encoding
- }
-
-C/C++ struct/union types
-------------------------
-
-Given the following as an example of C/C++ struct type:
-
-.. code-block:: c
-
- struct Color {
- unsigned Red;
- unsigned Green;
- unsigned Blue;
- };
-
-a C/C++ front-end would generate the following descriptors:
-
-.. code-block:: llvm
-
- ;;
- ;; Define basic type for unsigned int.
- ;;
- !5 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
- metadata !"unsigned int",
- metadata !1, ;; File
- i32 0, ;; Line number
- i64 32, ;; Size in Bits
- i64 32, ;; Align in Bits
- i64 0, ;; Offset in Bits
- i32 0, ;; Flags
- i32 7 ;; Encoding
- }
- ;;
- ;; Define composite type for struct Color.
- ;;
- !2 = metadata !{
- i32 524307, ;; Tag
- metadata !1, ;; Context
- metadata !"Color", ;; Name
- metadata !1, ;; Compile unit
- i32 1, ;; Line number
- i64 96, ;; Size in bits
- i64 32, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- null, ;; Derived From
- metadata !3, ;; Elements
- i32 0 ;; Runtime Language
- }
-
- ;;
- ;; Define the Red field.
- ;;
- !4 = metadata !{
- i32 524301, ;; Tag
- metadata !1, ;; Context
- metadata !"Red", ;; Name
- metadata !1, ;; File
- i32 2, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- metadata !5 ;; Derived From type
- }
-
- ;;
- ;; Define the Green field.
- ;;
- !6 = metadata !{
- i32 524301, ;; Tag
- metadata !1, ;; Context
- metadata !"Green", ;; Name
- metadata !1, ;; File
- i32 3, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
- i64 32, ;; Offset in bits
- i32 0, ;; Flags
- metadata !5 ;; Derived From type
- }
-
- ;;
- ;; Define the Blue field.
- ;;
- !7 = metadata !{
- i32 524301, ;; Tag
- metadata !1, ;; Context
- metadata !"Blue", ;; Name
- metadata !1, ;; File
- i32 4, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
- i64 64, ;; Offset in bits
- i32 0, ;; Flags
- metadata !5 ;; Derived From type
- }
-
- ;;
- ;; Define the array of fields used by the composite type Color.
- ;;
- !3 = metadata !{metadata !4, metadata !6, metadata !7}
-
-C/C++ enumeration types
------------------------
-
-Given the following as an example of C/C++ enumeration type:
-
-.. code-block:: c
-
- enum Trees {
- Spruce = 100,
- Oak = 200,
- Maple = 300
- };
-
-a C/C++ front-end would generate the following descriptors:
-
-.. code-block:: llvm
-
- ;;
- ;; Define composite type for enum Trees
- ;;
- !2 = metadata !{
- i32 524292, ;; Tag
- metadata !1, ;; Context
- metadata !"Trees", ;; Name
- metadata !1, ;; File
- i32 1, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
- i64 0, ;; Offset in bits
- i32 0, ;; Flags
- null, ;; Derived From type
- metadata !3, ;; Elements
- i32 0 ;; Runtime language
- }
-
- ;;
- ;; Define the array of enumerators used by composite type Trees.
- ;;
- !3 = metadata !{metadata !4, metadata !5, metadata !6}
-
- ;;
- ;; Define Spruce enumerator.
- ;;
- !4 = metadata !{i32 524328, metadata !"Spruce", i64 100}
-
- ;;
- ;; Define Oak enumerator.
- ;;
- !5 = metadata !{i32 524328, metadata !"Oak", i64 200}
-
- ;;
- ;; Define Maple enumerator.
- ;;
- !6 = metadata !{i32 524328, metadata !"Maple", i64 300}
-
Debugging information format
============================
New DWARF Constants
^^^^^^^^^^^^^^^^^^^
-+--------------------------------+-------+
-| Name | Value |
-+================================+=======+
-| DW_AT_APPLE_PROPERTY_readonly | 0x1 |
-+--------------------------------+-------+
-| DW_AT_APPLE_PROPERTY_readwrite | 0x2 |
-+--------------------------------+-------+
-| DW_AT_APPLE_PROPERTY_assign | 0x4 |
-+--------------------------------+-------+
-| DW_AT_APPLE_PROPERTY_retain | 0x8 |
-+--------------------------------+-------+
-| DW_AT_APPLE_PROPERTY_copy | 0x10 |
-+--------------------------------+-------+
-| DW_AT_APPLE_PROPERTY_nonatomic | 0x20 |
-+--------------------------------+-------+
++--------------------------------------+-------+
+| Name | Value |
++======================================+=======+
+| DW_APPLE_PROPERTY_readonly | 0x01 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_getter | 0x02 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_assign | 0x04 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_readwrite | 0x08 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_retain | 0x10 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_copy | 0x20 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_nonatomic | 0x40 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_setter | 0x80 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_atomic | 0x100 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_weak | 0x200 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_strong | 0x400 |
++--------------------------------------+-------+
+| DW_APPLE_PROPERTY_unsafe_unretained | 0x800 |
++--------------------------------+-----+-------+
Name Accelerator Tables
-----------------------
| HEADER.header_data_len | uint32_t
| HEADER_DATA | HeaderData
|-------------------------|
- | BUCKETS | uint32_t[bucket_count] // 32 bit hash indexes
+ | BUCKETS | uint32_t[n_buckets] // 32 bit hash indexes
|-------------------------|
- | HASHES | uint32_t[hashes_count] // 32 bit hash values
+ | HASHES | uint32_t[n_hashes] // 32 bit hash values
|-------------------------|
- | OFFSETS | uint32_t[hashes_count] // 32 bit offsets to hash value data
+ | OFFSETS | uint32_t[n_hashes] // 32 bit offsets to hash value data
|-------------------------|
| ALL HASH DATA |
`-------------------------'
HeaderData.atoms[0].form = DW_FORM_data4;
This defines the contents to be the DIE offset (eAtomTypeDIEOffset) that is
- encoded as a 32 bit value (DW_FORM_data4). This allows a single name to have
- multiple matching DIEs in a single file, which could come up with an inlined
- function for instance. Future tables could include more information about the
- DIE such as flags indicating if the DIE is a function, method, block,
- or inlined.
+encoded as a 32 bit value (DW_FORM_data4). This allows a single name to have
+multiple matching DIEs in a single file, which could come up with an inlined
+function for instance. Future tables could include more information about the
+DIE such as flags indicating if the DIE is a function, method, block,
+or inlined.
The KeyType for the DWARF table is a 32 bit string table offset into the
- ".debug_str" table. The ".debug_str" is the string table for the DWARF which
- may already contain copies of all of the strings. This helps make sure, with
- help from the compiler, that we reuse the strings between all of the DWARF
- sections and keeps the hash table size down. Another benefit to having the
- compiler generate all strings as DW_FORM_strp in the debug info, is that
- DWARF parsing can be made much faster.
+".debug_str" table. The ".debug_str" is the string table for the DWARF which
+may already contain copies of all of the strings. This helps make sure, with
+help from the compiler, that we reuse the strings between all of the DWARF
+sections and keeps the hash table size down. Another benefit to having the
+compiler generate all strings as DW_FORM_strp in the debug info, is that
+DWARF parsing can be made much faster.
After a lookup is made, we get an offset into the hash data. The hash data
- needs to be able to deal with 32 bit hash collisions, so the chunk of data
- at the offset in the hash data consists of a triple:
+needs to be able to deal with 32 bit hash collisions, so the chunk of data
+at the offset in the hash data consists of a triple:
.. code-block:: c
HashData[hash_data_count]
If "str_offset" is zero, then the bucket contents are done. 99.9% of the
- hash data chunks contain a single item (no 32 bit hash collision):
+hash data chunks contain a single item (no 32 bit hash collision):
.. code-block:: none
* DW_TAG_subrange_type
* DW_TAG_base_type
* DW_TAG_const_type
-* DW_TAG_constant
* DW_TAG_file_type
* DW_TAG_namelist
* DW_TAG_packed_type
Mach-O Changes
""""""""""""""
-The sections names for the apple hash tables are for non mach-o files. For
+The sections names for the apple hash tables are for non-mach-o files. For
mach-o files, the sections should be contained in the ``__DWARF`` segment with
names as follows:
projects / oota-llvm.git / blobdiff