X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=docs%2FSourceLevelDebugging.rst;h=b98fd33002a40600944ff18e85c0f2ead85af5d5;hb=0e593a62f657547c6a7af6dc9710fc055a9c4da0;hp=ad038717cb9b8c5554159b91ebf7918fb06f0e38;hpb=61212bcaff0629b03feeebd649078a91e6f13a53;p=oota-llvm.git diff --git a/docs/SourceLevelDebugging.rst b/docs/SourceLevelDebugging.rst index ad038717cb9..b98fd33002a 100644 --- a/docs/SourceLevelDebugging.rst +++ b/docs/SourceLevelDebugging.rst @@ -153,443 +153,21 @@ debugger to interpret the information. To provide basic functionality, the LLVM debugger does have to make some assumptions about the source-level language being debugged, though it keeps these to a minimum. The only common features that the LLVM debugger assumes -exist are :ref:`source files `, and :ref:`program objects -`. These abstract objects are used by a debugger to -form stack traces, show information about local variables, etc. +exist are `source files `_, and `program objects +`_. These abstract objects are used by a +debugger to form stack traces, show information about local variables, etc. This section of the documentation first describes the representation aspects common to any source-language. :ref:`ccxx_frontend` describes the data layout conventions used by the C and C++ front-ends. -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 - ... - } - -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 - } - -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 globals 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 - Artifical, Private, Protected, Explicit, Prototyped. - i1, ;; isOptimized - Function * , ;; Pointer to 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 ;; 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 -` (example to keep float doubles on 64 bit boundaries). -The offset is the bit offset if embedded in a :ref:`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 -` or :ref:`subprogram `. The type -of the member is the :ref:`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 `. - -:ref:`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 ` (example to keep -float doubles on 64 bit boundaries.) The offset is the bit offset if embedded -in a :ref:`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 - } - -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 `, 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 `, 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 -`, :ref:`derived ` or :ref:`composite -` 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 ` 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 ` then it -represents a static member. And, if the member is a :ref:`subprogram -descriptor ` 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 ` 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 ` (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_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 `. 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 `, 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, ;; Type descriptor - i32, ;; flags - metadata ;; (optional) Reference to inline location - } - -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. +Debug information descriptors are `specialized metadata nodes +`_, first-class subclasses of ``Metadata``. .. _format_common_intrinsics: Debugger intrinsic functions -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +---------------------------- LLVM uses several intrinsic functions (name prefixed with "``llvm.dbg``") to provide debug information at various points in generated code. @@ -599,24 +177,27 @@ provide debug information at various points in generated code. .. code-block:: llvm - void %llvm.dbg.declare(metadata, metadata) + void @llvm.dbg.declare(metadata, metadata, metadata) This intrinsic provides information about a local element (e.g., variable). The first argument is metadata holding the alloca for the variable. The second -argument is metadata containing a description of the variable. +argument is a `local variable `_ containing a +description of the variable. The third argument is a `complex expression +`_. ``llvm.dbg.value`` ^^^^^^^^^^^^^^^^^^ .. code-block:: llvm - void %llvm.dbg.value(metadata, i64, metadata) + void @llvm.dbg.value(metadata, i64, metadata, metadata) This intrinsic provides information when a user source variable is set to a new value. The first argument is the new value (wrapped as metadata). The second argument is the offset in the user source variable where the new value is -written. The third argument is metadata containing a description of the user -source variable. +written. The third argument is a `local variable +`_ containing a description of the variable. The +third argument is a `complex expression `_. Object lifetimes and scoping ============================ @@ -649,85 +230,61 @@ Compiled to LLVM, this function would be represented like this: .. code-block:: llvm - define void @_Z3foov() #0 { + ; Function Attrs: nounwind ssp uwtable + define void @foo() #0 { entry: - %X = alloca i32, align 4 ; [#uses=3 type=i32*] - %Y = alloca i32, align 4 ; [#uses=2 type=i32*] - %Z = alloca i32, align 4 ; [#uses=2 type=i32*] - call void @llvm.dbg.declare(metadata !{i32* %X}, metadata !8), !dbg !10 - ; [debug line = 2:7] [debug variable = X] - store i32 21, i32* %X, align 4, !dbg !11 ; [debug line = 2:13] - call void @llvm.dbg.declare(metadata !{i32* %Y}, metadata !12), !dbg !13 - ; [debug line = 3:7] [debug variable = Y] - store i32 22, i32* %Y, align 4, !dbg !14 ; [debug line = 3:13] - 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 !18 ; [debug line = 5:15] - %0 = load i32* %X, align 4, !dbg !19 ; [#uses=1 type=i32] \ - [debug line = 6:5] - store i32 %0, i32* %Z, align 4, !dbg !19 ; [debug line = 6:5] - %1 = load i32* %Y, align 4, !dbg !20 ; [#uses=1 type=i32] \ - [debug line = 8:3] - store i32 %1, i32* %X, align 4, !dbg !20 ; [debug line = 8:3] - ret void, !dbg !21 ; [debug line = 9:1] + %X = alloca i32, align 4 + %Y = alloca i32, align 4 + %Z = alloca i32, align 4 + call void @llvm.dbg.declare(metadata i32* %X, metadata !11, metadata !13), !dbg !14 + store i32 21, i32* %X, align 4, !dbg !14 + call void @llvm.dbg.declare(metadata i32* %Y, metadata !15, metadata !13), !dbg !16 + store i32 22, i32* %Y, align 4, !dbg !16 + call void @llvm.dbg.declare(metadata i32* %Z, metadata !17, metadata !13), !dbg !19 + store i32 23, i32* %Z, align 4, !dbg !19 + %0 = load i32, i32* %X, align 4, !dbg !20 + store i32 %0, i32* %Z, align 4, !dbg !21 + %1 = load i32, i32* %Y, align 4, !dbg !22 + store i32 %1, i32* %X, align 4, !dbg !23 + ret void, !dbg !24 } - ; [#uses=3] ; Function Attrs: nounwind readnone - declare void @llvm.dbg.declare(metadata, metadata) #1 + declare void @llvm.dbg.declare(metadata, metadata, metadata) #1 - attributes #0 = { optsize zeroext "less-precise-fpmad"="false" - "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf"="true" - "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" - "use-soft-float"="false" } + 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} - - !0 = metadata !{i32 786449, metadata !1, i32 12, - metadata !"clang version 3.4 ", 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_C] - !1 = metadata !{metadata !"foo.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 !"_Z3foov", i32 1, metadata !6, - i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 false, - void ()* @_Z3foov, 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/foo.c] - !6 = metadata !{i32 786453, i32 0, i32 0, metadata !"", i32 0, i64 0, i64 0, - i64 0, i32 0, null, metadata !7, i32 0, i32 0} - ; [ DW_TAG_subroutine_type ] \ - [line 0, size 0, align 0, offset 0] [from ] - !7 = metadata !{null} - !8 = metadata !{i32 786688, metadata !4, metadata !"X", metadata !5, i32 2, \ - metadata !9, i32 0, i32 0} ; [ DW_TAG_auto_variable ] [X] \ - [line 2] - !9 = 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] - !10 = metadata !{i32 2, i32 7, metadata !4, null} - !11 = metadata !{i32 2, i32 13, metadata !4, null} - !12 = metadata !{i32 786688, metadata !4, metadata !"Y", metadata !5, i32 3, \ - metadata !9, i32 0, i32 0} ; [ DW_TAG_auto_variable ] [Y] \ - [line 3] - !13 = metadata !{i32 3, i32 7, metadata !4, null} - !14 = metadata !{i32 3, i32 13, metadata !4, null} - !15 = metadata !{i32 786688, metadata !16, metadata !"Z", metadata !5, i32 5, \ - metadata !9, i32 0, i32 0} ; [ DW_TAG_auto_variable ] [Z] \ - [line 5] - !16 = metadata !{i32 786443, metadata !1, metadata !4, i32 4, i32 3, i32 0} - ; [ DW_TAG_lexical_block ] [/private/tmp/foo.c] - !17 = metadata !{i32 5, i32 9, metadata !16, null} - !18 = metadata !{i32 5, i32 15, metadata !16, null} - !19 = metadata !{i32 6, i32 5, metadata !16, null} - !20 = metadata !{i32 8, i32 3, metadata !4, null} - !21 = metadata !{i32 9, i32 1, metadata !4, null} + !llvm.module.flags = !{!7, !8, !9} + !llvm.ident = !{!10} + + !0 = !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2) + !1 = !DIFile(filename: "/dev/stdin", directory: "/Users/dexonsmith/data/llvm/debug-info") + !2 = !{} + !3 = !{!4} + !4 = !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, function: void ()* @foo, variables: !2) + !5 = !DISubroutineType(types: !6) + !6 = !{null} + !7 = !{i32 2, !"Dwarf Version", i32 2} + !8 = !{i32 2, !"Debug Info Version", i32 3} + !9 = !{i32 1, !"PIC Level", i32 2} + !10 = !{!"clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)"} + !11 = !DILocalVariable(name: "X", scope: !4, file: !1, line: 2, type: !12) + !12 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed) + !13 = !DIExpression() + !14 = !DILocation(line: 2, column: 9, scope: !4) + !15 = !DILocalVariable(name: "Y", scope: !4, file: !1, line: 3, type: !12) + !16 = !DILocation(line: 3, column: 9, scope: !4) + !17 = !DILocalVariable(name: "Z", scope: !18, file: !1, line: 5, type: !12) + !18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5) + !19 = !DILocation(line: 5, column: 11, scope: !18) + !20 = !DILocation(line: 6, column: 11, scope: !18) + !21 = !DILocation(line: 6, column: 9, scope: !18) + !22 = !DILocation(line: 8, column: 9, scope: !4) + !23 = !DILocation(line: 8, column: 7, scope: !4) + !24 = !DILocation(line: 9, column: 3, scope: !4) + This example illustrates a few important details about LLVM debugging information. In particular, it shows how the ``llvm.dbg.declare`` intrinsic and @@ -737,27 +294,24 @@ variable definitions, and the code used to implement the function. .. code-block:: llvm - call void @llvm.dbg.declare(metadata !{i32* %X}, metadata !8), !dbg !10 + call void @llvm.dbg.declare(metadata i32* %X, metadata !11, metadata !13), !dbg !14 ; [debug line = 2:7] [debug variable = X] The first intrinsic ``%llvm.dbg.declare`` encodes debugging information for the -variable ``X``. The metadata ``!dbg !10`` attached to the intrinsic provides +variable ``X``. The metadata ``!dbg !14`` attached to the intrinsic provides scope information for the variable ``X``. .. code-block:: llvm - !10 = metadata !{i32 2, i32 7, metadata !4, null} - !4 = metadata !{i32 786478, metadata !1, metadata !5, metadata !"foo", - metadata !"foo", metadata !"_Z3foov", i32 1, metadata !6, - i1 false, i1 true, i32 0, i32 0, null, i32 256, i1 false, - void ()* @_Z3foov, null, null, metadata !2, i32 1} - ; [ DW_TAG_subprogram ] [line 1] [def] [foo] - -Here ``!10`` 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 ``!4``, a -:ref:`subprogram descriptor `. This way the location + !14 = !DILocation(line: 2, column: 9, scope: !4) + !4 = !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, + isLocal: false, isDefinition: true, scopeLine: 1, + isOptimized: false, function: void ()* @foo, + variables: !2) + +Here ``!14`` is metadata providing `location information +`_. In this example, scope is encoded by ``!4``, a +`subprogram descriptor `_. 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``. @@ -765,22 +319,21 @@ Now lets take another example. .. code-block:: llvm - call void @llvm.dbg.declare(metadata !{i32* %Z}, metadata !15), !dbg !17 + call void @llvm.dbg.declare(metadata i32* %Z, metadata !17, metadata !13), !dbg !19 ; [debug line = 5:9] [debug variable = Z] The third intrinsic ``%llvm.dbg.declare`` encodes debugging information for -variable ``Z``. The metadata ``!dbg !17`` attached to the intrinsic provides +variable ``Z``. The metadata ``!dbg !19`` attached to the intrinsic provides scope information for the variable ``Z``. .. code-block:: llvm - !16 = metadata !{i32 786443, metadata !1, metadata !4, i32 4, i32 3, i32 0} - ; [ DW_TAG_lexical_block ] [/private/tmp/foo.c] - !17 = metadata !{i32 5, i32 9, metadata !16, null} + !18 = distinct !DILexicalBlock(scope: !4, file: !1, line: 4, column: 5) + !19 = !DILocation(line: 5, column: 11, scope: !18) -Here ``!15`` indicates that ``Z`` is declared at line number 5 and -column number 9 inside of lexical scope ``!16``. The lexical scope itself -resides inside of subprogram ``!4`` described above. +Here ``!19`` indicates that ``Z`` is declared at line number 5 and column +number 0 inside of lexical scope ``!18``. 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. @@ -804,84 +357,25 @@ to provide completely different forms if they don't fit into the DWARF model. 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". - ;; - !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 !{ - metadata !"MySource.cpp", - metadata !"/Users/mine/sources" - } - !5 = metadata !{ - i32 786473, ;; Tag - metadata !1 - } - - ;; - ;; Define the file for the file "/Users/mine/sources/Myheader.h" - ;; - !14 = metadata !{ - i32 786473, ;; Tag - metadata !15 - } - !15 = metadata !{ - metadata !"./MyHeader.h", - metadata !"/Users/mine/sources", - } - - ... - ``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()``. +``Instruction::getDebugLoc()`` and ``DILocation::getLine()``. .. code-block:: c++ - if (MDNode *N = I->getMetadata("dbg")) { // Here I is an LLVM instruction - DILocation Loc(N); // DILocation is in DebugInfo.h - unsigned Line = Loc.getLineNumber(); - StringRef File = Loc.getFilename(); - StringRef Dir = Loc.getDirectory(); + if (DILocation *Loc = I->getDebugLoc()) { // Here I is an LLVM instruction + unsigned Line = Loc->getLine(); + StringRef File = Loc->getFilename(); + StringRef Dir = Loc->getDirectory(); } C/C++ global variable information @@ -900,84 +394,53 @@ a C/C++ front-end would generate the following descriptors: ;; ;; Define the global itself. ;; - %MyGlobal = global int 100 - ... + @MyGlobal = global i32 100, align 4 + ;; ;; List of debug info of globals ;; !llvm.dbg.cu = !{!0} - ;; 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 - metadata !1, ;; Imported entities - "", ;; Split debug filename - } ; [ DW_TAG_compile_unit ] + ;; Some unrelated metadata. + !llvm.module.flags = !{!6, !7} - ;; The Array of Global Variables - !3 = metadata !{ - metadata !4 - } + ;; Define the compile unit. + !0 = !DICompileUnit(language: DW_LANG_C99, file: !1, + producer: + "clang version 3.7.0 (trunk 231150) (llvm/trunk 231154)", + isOptimized: false, runtimeVersion: 0, emissionKind: 1, + enums: !2, retainedTypes: !2, subprograms: !2, globals: + !3, imports: !2) ;; - ;; Define the global variable itself. + ;; Define the file ;; - !4 = metadata !{ - i32 786484, ;; Tag - i32 0, ;; Unused - 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 - null ;; Static member declaration - } ; [ DW_TAG_variable ] + !1 = !DIFile(filename: "/dev/stdin", + directory: "/Users/dexonsmith/data/llvm/debug-info") + + ;; An empty array. + !2 = !{} + + ;; The Array of Global Variables + !3 = !{!4} ;; - ;; Define the file + ;; Define the global variable itself. ;; - !5 = metadata !{ - metadata !"foo.cpp", ;; File - metadata !"/Volumes/Data/tmp", ;; Directory - } - !6 = metadata !{ - i32 786473, ;; Tag - metadata !5 ;; Unused - } ; [ DW_TAG_file_type ] + !4 = !DIGlobalVariable(name: "MyGlobal", scope: !0, file: !1, line: 1, + type: !5, isLocal: false, isDefinition: true, + variable: i32* @MyGlobal) ;; ;; Define the type ;; - !7 = metadata !{ - i32 786468, ;; Tag - null, ;; Unused - null, ;; Unused - 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 - } ; [ DW_TAG_base_type ] + !5 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed) + + ;; Dwarf version to output. + !6 = !{i32 2, !"Dwarf Version", i32 2} + + ;; Debug info schema version. + !7 = !{i32 2, !"Debug Info Version", i32 3} C/C++ function information -------------------------- @@ -997,27 +460,11 @@ a C/C++ front-end would generate the following descriptors: ;; ;; Define the anchor for subprograms. ;; - !6 = metadata !{ - i32 786484, ;; Tag - metadata !1, ;; File - metadata !1, ;; Context - metadata !"main", ;; Name - metadata !"main", ;; Display name - metadata !"main", ;; Linkage name - 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 - null, ;; List of function variables (emitted when optimizing) - 1 ;; Line number of the opening '{' of the function - } + !4 = !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !5, + isLocal: false, isDefinition: true, scopeLine: 1, + flags: DIFlagPrototyped, isOptimized: false, + function: i32 (i32, i8**)* @main, variables: !2) + ;; ;; Define the subprogram itself. ;; @@ -1025,443 +472,6 @@ a C/C++ front-end would generate the following descriptors: ... } -C/C++ basic types ------------------ - -The following are the basic type descriptors for C/C++ core types: - -bool -^^^^ - -.. code-block:: llvm - - !2 = metadata !{ - i32 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"bool", ;; Name - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"char", ;; Name - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"unsigned char", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"short int", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"short unsigned int", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"int", ;; Name - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"unsigned int", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"long long int", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"long long unsigned int", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"float", - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"double",;; Name - 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 786454, ;; Tag - metadata !3, ;; File - metadata !1, ;; Context - metadata !"IntPtr", ;; Name - 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 786447, ;; Tag - null, ;; File - null, ;; Context - metadata !"", ;; Name - 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 786470, ;; Tag - null, ;; File - null, ;; Context - metadata !"", ;; Name - i32 0, ;; Line number - 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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"int", ;; Name - 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 - } - -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 786468, ;; Tag - null, ;; File - null, ;; Context - metadata !"unsigned int", - 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 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 - i64 0, ;; Offset in bits - i32 0, ;; Flags - null, ;; Derived From - metadata !3, ;; Elements - i32 0, ;; Runtime Language - null, ;; Base type containing the vtable pointer for this type - null ;; Template parameters - } - - ;; - ;; Define the Red field. - ;; - !4 = metadata !{ - i32 786445, ;; Tag - metadata !1, ;; File - metadata !1, ;; Context - metadata !"Red", ;; Name - 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 786445, ;; Tag - metadata !1, ;; File - metadata !1, ;; Context - metadata !"Green", ;; Name - 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 786445, ;; Tag - metadata !1, ;; File - metadata !1, ;; Context - metadata !"Blue", ;; Name - 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 786436, ;; Tag - metadata !1, ;; File - metadata !1, ;; Context - metadata !"Trees", ;; Name - 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 786472, metadata !"Spruce", i64 100} - - ;; - ;; Define Oak enumerator. - ;; - !5 = metadata !{i32 786472, metadata !"Oak", i64 200} - - ;; - ;; Define Maple enumerator. - ;; - !6 = metadata !{i32 786472, metadata !"Maple", i64 300} - Debugging information format ============================ @@ -1644,21 +654,33 @@ New DWARF Attributes 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 ----------------------- @@ -2225,7 +1247,6 @@ tag is one of: * 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 @@ -2304,7 +1325,7 @@ stringWithCString:]``") and the basename is the selector only 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: