maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/tools/dsymutil/X86/basic-linking-x86.test

145 lines
7.9 KiB
Plaintext
Raw Normal View History

[dsymutil] Add the DwarfStreamer class. This class is responsible for getting the linked data to the disk in the appropriate form. Today it it an empty shell that just instantiates an MC layer. As we do not put anything in the resulting file yet, we just check it has the right architecture (and check that -o does the right thing). To be able to create all the components, this commit adds a few dependencies to llvm-dsymutil, namely all-targets, MC and AsmPrinter. Also add a -no-output option, so that tests that do not need the binary result can continue to run even if they do not have the required target linked in. llvm-svn: 230824
2015-02-28 08:29:11 +08:00
RUN: cat %p/../Inputs/basic.macho.x86_64 > %t1
RUN: llvm-dsymutil -oso-prepend-path=%p/.. %t1
RUN: llvm-dwarfdump %t1.dwarf | FileCheck %s
RUN: llvm-dsymutil -o %t2 -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64
RUN: llvm-dwarfdump %t2 | FileCheck %s
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
RUN: llvm-dsymutil -o - -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK --check-prefix=BASIC
RUN: llvm-dsymutil -o - -oso-prepend-path=%p/.. %p/../Inputs/basic-archive.macho.x86_64 | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK --check-prefix=ARCHIVE
[dsymutil] Add the DwarfStreamer class. This class is responsible for getting the linked data to the disk in the appropriate form. Today it it an empty shell that just instantiates an MC layer. As we do not put anything in the resulting file yet, we just check it has the right architecture (and check that -o does the right thing). To be able to create all the components, this commit adds a few dependencies to llvm-dsymutil, namely all-targets, MC and AsmPrinter. Also add a -no-output option, so that tests that do not need the binary result can continue to run even if they do not have the required target linked in. llvm-svn: 230824
2015-02-28 08:29:11 +08:00
CHECK: file format Mach-O 64-bit x86-64
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: debug_info contents
CHECK: Compile Unit:
CHECK: DW_TAG_compile_unit [1] *
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_producer [DW_FORM_strp] ( .debug_str[0x00000001] = "Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_language [DW_FORM_data2] (DW_LANG_C99)
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000040] = "basic1.c")
CHECK: DW_AT_comp_dir [DW_FORM_strp] ( .debug_str[0x00000049] = "/Inputs")
[dsymutil] Add relocation of compile_units low_pc/high_pc. They need to be handled specifically as they could vary pretty widely depending on how the linker moves functions around. llvm-svn: 232192
2015-03-14 02:35:54 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000ea0)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_subprogram [2] *
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000051] = "main")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_decl_line [DW_FORM_data1] (23)
CHECK: DW_AT_prototyped [DW_FORM_flag] (0x01)
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0063 => {0x00000063})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_external [DW_FORM_flag] (0x01)
CHECK: DW_AT_accessibility [DW_FORM_data1] (DW_ACCESS_public)
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000ea0)
[dsymutil] Correctly clone address attributes. DW_AT_low_pc on functions is taken care of by the relocation processing, but DW_AT_high_pc and DW_AT_low_pc on other lexical scopes need special handling. llvm-svn: 231955
2015-03-12 02:45:52 +08:00
CHECK: DW_AT_high_pc [DW_FORM_addr] (0x0000000100000ec4)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
CHECK: DW_TAG_formal_parameter [3]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000056] = "argc")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_decl_line [DW_FORM_data1] (23)
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0063 => {0x00000063})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_location [DW_FORM_block1] (<0x02> 91 78 )
CHECK: DW_TAG_formal_parameter [3]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000005b] = "argv")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_decl_file [DW_FORM_data1] (0x01)
CHECK: DW_AT_decl_line [DW_FORM_data1] (23)
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x006a => {0x0000006a})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_location [DW_FORM_block1] (<0x02> 91 70 )
CHECK: NULL
CHECK: DW_TAG_base_type [4]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000060] = "int")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_encoding [DW_FORM_data1] (DW_ATE_signed)
CHECK: DW_AT_byte_size [DW_FORM_data1] (0x04)
CHECK: DW_TAG_pointer_type [5]
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x006f => {0x0000006f})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_pointer_type [5]
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0074 => {0x00000074})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_const_type [6]
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0079 => {0x00000079})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_base_type [4]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000064] = "char")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_encoding [DW_FORM_data1] (DW_ATE_signed_char)
CHECK: DW_AT_byte_size [DW_FORM_data1] (0x01)
CHECK: NULL
CHECK: Compile Unit:
CHECK: DW_TAG_compile_unit [1] *
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_producer [DW_FORM_strp] ( .debug_str[0x00000001] = "Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000069] = "basic2.c")
CHECK: DW_AT_comp_dir [DW_FORM_strp] ( .debug_str[0x00000049] = "/Inputs")
[dsymutil] Add relocation of compile_units low_pc/high_pc. They need to be handled specifically as they could vary pretty widely depending on how the linker moves functions around. llvm-svn: 232192
2015-03-14 02:35:54 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000ed0)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_base_type [4]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000060] = "int")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_variable [7]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000072] = "private_int")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0026 => {0x000000a7})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
BASIC: DW_AT_location [DW_FORM_block1] (<0x09> 03 08 10 00 00 01 00 00 00 )
ARCHIVE: DW_AT_location [DW_FORM_block1] (<0x09> 03 04 10 00 00 01 00 00 00 )
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_variable [7]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000007e] = "baz")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0026 => {0x000000a7})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
CHECK: DW_AT_location [DW_FORM_block1] (<0x09> 03 00 10 00 00 01 00 00 00 )
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_subprogram [2] *
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000082] = "foo")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0026 => {0x000000a7})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000ed0)
[dsymutil] Correctly clone address attributes. DW_AT_low_pc on functions is taken care of by the relocation processing, but DW_AT_high_pc and DW_AT_low_pc on other lexical scopes need special handling. llvm-svn: 231955
2015-03-12 02:45:52 +08:00
CHECK: DW_AT_high_pc [DW_FORM_addr] (0x0000000100000f19)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
CHECK: DW_TAG_formal_parameter [3]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000086] = "arg")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0026 => {0x000000a7})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_location [DW_FORM_block1] (<0x02> 91 7c )
CHECK: NULL
CHECK: DW_TAG_subprogram [8]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000008a] = "inc")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0026 => {0x000000a7})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f20)
[dsymutil] Correctly clone address attributes. DW_AT_low_pc on functions is taken care of by the relocation processing, but DW_AT_high_pc and DW_AT_low_pc on other lexical scopes need special handling. llvm-svn: 231955
2015-03-12 02:45:52 +08:00
CHECK: DW_AT_high_pc [DW_FORM_addr] (0x0000000100000f37)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
CHECK: NULL
CHECK: Compile Unit:
CHECK: DW_TAG_compile_unit [1] *
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_producer [DW_FORM_strp] ( .debug_str[0x00000001] = "Apple LLVM version 6.0 (clang-600.0.39) (based on LLVM 3.5svn)")
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000008e] = "basic3.c")
CHECK: DW_AT_comp_dir [DW_FORM_strp] ( .debug_str[0x00000049] = "/Inputs")
[dsymutil] Add relocation of compile_units low_pc/high_pc. They need to be handled specifically as they could vary pretty widely depending on how the linker moves functions around. llvm-svn: 232192
2015-03-14 02:35:54 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f40)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_variable [9]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000097] = "val")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x003c => {0x00000162})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
BASIC: DW_AT_location [DW_FORM_block1] (<0x09> 03 04 10 00 00 01 00 00 00 )
ARCHIVE: DW_AT_location [DW_FORM_block1] (<0x09> 03 08 10 00 00 01 00 00 00 )
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_volatile_type [10]
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0041 => {0x00000167})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_base_type [4]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHACK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000060] = "int")
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_TAG_subprogram [2] *
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000009b] = "bar")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0041 => {0x00000167})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f40)
[dsymutil] Correctly clone address attributes. DW_AT_low_pc on functions is taken care of by the relocation processing, but DW_AT_high_pc and DW_AT_low_pc on other lexical scopes need special handling. llvm-svn: 231955
2015-03-12 02:45:52 +08:00
CHECK: DW_AT_high_pc [DW_FORM_addr] (0x0000000100000f84)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
CHECK: DW_TAG_formal_parameter [3]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000086] = "arg")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0041 => {0x00000167})
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_location [DW_FORM_block1] (<0x02> 91 78 )
CHECK: NULL
CHECK: DW_TAG_subprogram [8]
[dsymutil] Add debug_str construction support. With this comes the ability to correctly clone string attributes in DIEs. llvm-svn: 231493
2015-03-07 01:56:30 +08:00
CHECK: DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000008a] = "inc")
[dsymutil] Support cloning DIE reference attributes. Reference attributes are mainly handled by just creating DIEEntry attributes for them. There is a special case for DW_FORM_ref_addr attributes though, because the DIEEntry code needs a DwarfDebug code to emit them (and we don't have one as we do no CodeGen). In that case, just use DIEInteger attributes with the right form. llvm-svn: 231531
2015-03-07 07:22:53 +08:00
CHECK: DW_AT_type [DW_FORM_ref4] (cu + 0x0041 => {0x00000167})
[dsymutil] Apply relocations to DIE data before cloning. Doing this gets function's low_pc and global variable's locations right in the output debug info. It also could get right other attributes that need to be relocated (in linker terms), but I don't know of any other than the address attributes. This doesn't fixup low_pc attributes in compile_unit, lexical_block or inlined subroutine, nor does it get right high_pc attributes for function. This will come in a subsequent commit. llvm-svn: 231544
2015-03-07 09:25:09 +08:00
CHECK: DW_AT_low_pc [DW_FORM_addr] (0x0000000100000f90)
[dsymutil] Correctly clone address attributes. DW_AT_low_pc on functions is taken care of by the relocation processing, but DW_AT_high_pc and DW_AT_low_pc on other lexical scopes need special handling. llvm-svn: 231955
2015-03-12 02:45:52 +08:00
CHECK: DW_AT_high_pc [DW_FORM_addr] (0x0000000100000fa9)
[dsymutil] Add minimal code to emit DIE trees. This commit adds code to emit DIE trees that have been pruned from the parts that haven't been marked as kept in the previous pass. It works by 'cloning' the input DIE tree (as read by libDebugInfoDwarf) into a tree of DIE objects. Cloning the DIEs means essentially cloning their attributes. The code in this commit does only handle scalar and block attributes (scalar because they are trivial, blocks because they can't be easily replaced by a scalr placeholder), all the other ones are replaced by placeholder zero values and will be handled in further commits. The added tests mostly check that the DIE tree has the correct layout and also verify that a few chosen scalar and block attributes correctly make their way into the output. llvm-svn: 231300
2015-03-05 06:07:44 +08:00
CHECK: DW_AT_frame_base [DW_FORM_block1] (<0x01> 56 )
CHECK: NULL
[dsymutil] Add support for debug_loc section. There is no need to look into the location expressions to transfer them, the only modification to apply is to patch their base address to reflect the linked function address. llvm-svn: 232267
2015-03-14 23:49:07 +08:00
CHECK: .debug_loc contents
CHECK-NOT: Location
[dsymutil] Generate debug_aranges section. This actually shares most of its implementation with the generation of the debug_ranges (the absence of 'a' is not a typo) contribution for the unit's DW_AT_ranges attribute. llvm-svn: 232246
2015-03-14 11:46:51 +08:00
CHECK:.debug_aranges contents:
CHECK-NEXT:Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
CHECK-NEXT:[0x0000000100000ea0 - 0x0000000100000ec4)
CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
CHECK-NEXT:[0x0000000100000ed0 - 0x0000000100000f19)
CHECK-NEXT:[0x0000000100000f20 - 0x0000000100000f37)
CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000126, addr_size = 0x08, seg_size = 0x00
CHECK-NEXT:[0x0000000100000f40 - 0x0000000100000f84)
CHECK-NEXT:[0x0000000100000f90 - 0x0000000100000fa9)