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
``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.)
+does not restrict the use of the information supplied to DWARF targets.
The details of the various descriptors follow.
.. code-block:: llvm
!0 = metadata !{
- i32, ;; Tag = 17 + LLVMDebugVersion (DW_TAG_compile_unit)
- i32, ;; Unused field.
+ i32, ;; Tag = 17 (DW_TAG_compile_unit)
+ metadata, ;; Source directory (including trailing slash) & file pair
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 retained types
metadata ;; List of subprograms
metadata ;; List of global variables
+ metadata ;; List of imported entities
+ metadata ;; Split debug filename
}
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
+ 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, ;; Tag = 52 (DW_TAG_variable)
i32, ;; Unused field.
metadata, ;; Reference to context descriptor
metadata, ;; Name
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.
+ 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++)
- 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.
+ i32, ;; Flags - Artificial, 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
+ metadata, ;; List of function variables
+ i32 ;; Line number where the scope of the subprogram begins
}
These descriptors provide debug information about functions, methods and
.. 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
+ 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
.. 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.
+ 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
.. code-block:: llvm
!4 = metadata !{
- i32, ;; Tag = 36 + LLVMDebugVersion (DW_TAG_base_type)
+ 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)
- 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
!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)
- 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
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
+ ;; 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.
.. 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_const_type = 38
- DW_TAG_volatile_type = 53
- DW_TAG_restrict_type = 55
+ 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
!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)
- 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
i32, ;; Flags
metadata, ;; Reference to type derived from
metadata, ;; Reference to array of member descriptors
- i32 ;; Runtime languages
+ 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
DW_TAG_enumeration_type = 4
DW_TAG_structure_type = 19
DW_TAG_union_type = 23
- DW_TAG_vector_type = 259
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``) or vector types (tag =
-``DW_TAG_vector_type``) are :ref:`subrange descriptors <format_subrange>`, each
+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
.. code-block:: llvm
!42 = metadata !{
- i32, ;; Tag = 33 + LLVMDebugVersion (DW_TAG_subrange_type)
- i64, ;; Low value
- i64 ;; High value
+ 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)
+ i32, ;; Tag = 40 (DW_TAG_enumerator)
metadata, ;; Name
i64 ;; Value
}
metadata, ;; Reference to file where defined
i32, ;; 24 bit - Line number where defined
;; 8 bit - Argument number. 1 indicates 1st argument.
- metadata, ;; Type descriptor
+ 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
DW_TAG_auto_variable = 256
DW_TAG_arg_variable = 257
- DW_TAG_return_variable = 258
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. A return variable is used to track the result of a function and has
-no source correspondent.
+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
.. 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,
+ 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,
+ 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.
;;
;; 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
+ !0 = metadata !{
+ i32 786449, ;; Tag
+ metadata !1, ;; File/directory name
+ i32 4, ;; Language Id
+ metadata !"clang version 3.4 ",
+ i1 false, ;; Optimized compile unit
+ metadata !"", ;; Compiler flags
+ i32 0, ;; Runtime version
+ metadata !2, ;; Enumeration types
+ metadata !2, ;; Retained types
+ metadata !3, ;; Subprograms
+ metadata !2, ;; Global variables
+ metadata !2, ;; Imported entities (declarations and namespaces)
+ metadata !"" ;; Split debug filename
+ }
;;
;; 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
+ metadata !"/Users/mine/sources"
+ }
+ !5 = metadata !{
+ i32 786473, ;; Tag
+ metadata !1
}
;;
;; Define the file for the file "/Users/mine/sources/Myheader.h"
;;
- !3 = metadata !{
- i32 524329, ;; Tag
- metadata !"Myheader.h"
+ !14 = metadata !{
+ i32 786473, ;; Tag
+ metadata !15
+ }
+ !15 = metadata !{
+ metadata !"./MyHeader.h",
metadata !"/Users/mine/sources",
- metadata !2 ;; Compile unit
}
...
metadata !1, ;; Enum Types
metadata !1, ;; Retained Types
metadata !1, ;; Subprograms
- metadata !3 ;; Global Variables
+ metadata !3, ;; Global Variables
+ metadata !1, ;; Imported entities
+ "", ;; Split debug filename
} ; [ DW_TAG_compile_unit ]
;; The Array of Global Variables
metadata !4
}
- !4 = metadata !{
- metadata !5
- }
-
;;
;; Define the global variable itself.
;;
- !5 = metadata !{
+ !4 = metadata !{
i32 786484, ;; Tag
i32 0, ;; Unused
null, ;; Unused
metadata !7, ;; Type
i32 0, ;; IsLocalToUnit
i32 1, ;; IsDefinition
- i32* @MyGlobal ;; LLVM-IR Value
+ i32* @MyGlobal, ;; LLVM-IR Value
+ null ;; Static member declaration
} ; [ DW_TAG_variable ]
;;
;; Define the file
;;
- !6 = metadata !{
- i32 786473, ;; Tag
+ !5 = metadata !{
metadata !"foo.cpp", ;; File
metadata !"/Volumes/Data/tmp", ;; Directory
- null ;; Unused
+ }
+ !6 = metadata !{
+ i32 786473, ;; Tag
+ metadata !5 ;; Unused
} ; [ DW_TAG_file_type ]
;;
!7 = metadata !{
i32 786468, ;; Tag
null, ;; Unused
- metadata !"int", ;; Name
null, ;; Unused
+ metadata !"int", ;; Name
i32 0, ;; Line
i64 32, ;; Size in Bits
i64 32, ;; Align in Bits
.. 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
+ i32 786484, ;; Tag
+ metadata !1, ;; File
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
i32 0, ;; Flags
i1 false, ;; True if this function is optimized
Function *, ;; Pointer to llvm::Function
- null ;; Function template parameters
+ null, ;; Function template parameters
+ null, ;; List of function variables (emitted when optimizing)
+ 1 ;; Line number of the opening '{' of the function
}
;;
;; Define the subprogram itself.
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"bool", ;; Name
- metadata !1, ;; File
i32 0, ;; Line number
i64 8, ;; Size in Bits
i64 8, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"char", ;; Name
- metadata !1, ;; File
i32 0, ;; Line number
i64 8, ;; Size in Bits
i64 8, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"unsigned char",
- metadata !1, ;; File
i32 0, ;; Line number
i64 8, ;; Size in Bits
i64 8, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"short int",
- metadata !1, ;; File
i32 0, ;; Line number
i64 16, ;; Size in Bits
i64 16, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"short unsigned int",
- metadata !1, ;; File
i32 0, ;; Line number
i64 16, ;; Size in Bits
i64 16, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"int", ;; Name
- metadata !1, ;; File
i32 0, ;; Line number
i64 32, ;; Size in Bits
i64 32, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"unsigned int",
- metadata !1, ;; File
i32 0, ;; Line number
i64 32, ;; Size in Bits
i64 32, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"long long int",
- metadata !1, ;; File
i32 0, ;; Line number
i64 64, ;; Size in Bits
i64 64, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"long long unsigned int",
- metadata !1, ;; File
i32 0, ;; Line number
i64 64, ;; Size in Bits
i64 64, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"float",
- metadata !1, ;; File
i32 0, ;; Line number
i64 32, ;; Size in Bits
i64 32, ;; Align in Bits
.. code-block:: llvm
!2 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"double",;; Name
- metadata !1, ;; File
i32 0, ;; Line number
i64 64, ;; Size in Bits
i64 64, ;; Align in Bits
;; Define the typedef "IntPtr".
;;
!2 = metadata !{
- i32 524310, ;; Tag
+ i32 786454, ;; Tag
+ metadata !3, ;; File
metadata !1, ;; Context
metadata !"IntPtr", ;; Name
- metadata !3, ;; File
i32 0, ;; Line number
i64 0, ;; Size in bits
i64 0, ;; Align in bits
;; Define the pointer type.
;;
!4 = metadata !{
- i32 524303, ;; Tag
- metadata !1, ;; Context
+ i32 786447, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"", ;; Name
- metadata !1, ;; File
i32 0, ;; Line number
i64 64, ;; Size in bits
i64 64, ;; Align in bits
;; Define the const type.
;;
!5 = metadata !{
- i32 524326, ;; Tag
- metadata !1, ;; Context
+ i32 786470, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"", ;; Name
- metadata !1, ;; File
i32 0, ;; Line number
- i64 32, ;; Size in bits
- i64 32, ;; Align in bits
+ i64 0, ;; Size in bits
+ i64 0, ;; 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
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; 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
+ i32 5 ;; Encoding
}
C/C++ struct/union types
;; Define basic type for unsigned int.
;;
!5 = metadata !{
- i32 524324, ;; Tag
- metadata !1, ;; Context
+ i32 786468, ;; Tag
+ null, ;; File
+ null, ;; Context
metadata !"unsigned int",
- metadata !1, ;; File
i32 0, ;; Line number
i64 32, ;; Size in Bits
i64 32, ;; Align in Bits
;; Define composite type for struct Color.
;;
!2 = metadata !{
- i32 524307, ;; Tag
- metadata !1, ;; Context
- metadata !"Color", ;; Name
+ i32 786451, ;; Tag
metadata !1, ;; Compile unit
+ null, ;; Context
+ metadata !"Color", ;; Name
i32 1, ;; Line number
i64 96, ;; Size in bits
i64 32, ;; Align in bits
i32 0, ;; Flags
null, ;; Derived From
metadata !3, ;; Elements
- i32 0 ;; Runtime Language
+ i32 0, ;; Runtime Language
+ null, ;; Base type containing the vtable pointer for this type
+ null ;; Template parameters
}
;;
;; Define the Red field.
;;
!4 = metadata !{
- i32 524301, ;; Tag
+ i32 786445, ;; Tag
+ metadata !1, ;; File
metadata !1, ;; Context
metadata !"Red", ;; Name
- metadata !1, ;; File
i32 2, ;; Line number
i64 32, ;; Size in bits
i64 32, ;; Align in bits
;; Define the Green field.
;;
!6 = metadata !{
- i32 524301, ;; Tag
+ i32 786445, ;; Tag
+ metadata !1, ;; File
metadata !1, ;; Context
metadata !"Green", ;; Name
- metadata !1, ;; File
i32 3, ;; Line number
i64 32, ;; Size in bits
i64 32, ;; Align in bits
;; Define the Blue field.
;;
!7 = metadata !{
- i32 524301, ;; Tag
+ i32 786445, ;; Tag
+ metadata !1, ;; File
metadata !1, ;; Context
metadata !"Blue", ;; Name
- metadata !1, ;; File
i32 4, ;; Line number
i64 32, ;; Size in bits
i64 32, ;; Align in bits
;; Define composite type for enum Trees
;;
!2 = metadata !{
- i32 524292, ;; Tag
+ i32 786436, ;; Tag
+ metadata !1, ;; File
metadata !1, ;; Context
metadata !"Trees", ;; Name
- metadata !1, ;; File
i32 1, ;; Line number
i64 32, ;; Size in bits
i64 32, ;; Align in bits
;;
;; Define Spruce enumerator.
;;
- !4 = metadata !{i32 524328, metadata !"Spruce", i64 100}
+ !4 = metadata !{i32 786472, metadata !"Spruce", i64 100}
;;
;; Define Oak enumerator.
;;
- !5 = metadata !{i32 524328, metadata !"Oak", i64 200}
+ !5 = metadata !{i32 786472, metadata !"Oak", i64 200}
;;
;; Define Maple enumerator.
;;
- !6 = metadata !{i32 524328, metadata !"Maple", i64 300}
+ !6 = metadata !{i32 786472, metadata !"Maple", i64 300}
Debugging information format
============================
| 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
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