Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

DWARF Data Representation

606 views

Published on

Note about DWARF data format. (32-bit DWARF only)

Published in: Software
  • Login to see the comments

DWARF Data Representation

  1. 1. DWARF Data Representation Kai
  2. 2. .debug_info compilation unit header a series of debugging information entries (DIE) .debug_abbrev length of .debug_info dwarf version offset into .debug_abbrev (size of an address) .section .debug_info,"",@progbits .Ldebug_info0: .long 0x3a8 .value 0x2 // dwarf versino 2 .long .Ldebug_abbrev0 .byte 0x8 // 64 bits addressing .uleb128 0x1 .long .LASF55 .byte 0xc .long .LASF56 .long .LASF57 .quad .Ltext0 .quad .Letext0 .long .Ldebug_line0 a series of abbreviation declarations * DWARFv3 supports 64-bits DWARF format. Initial length = 0xffffffff to indicate 64-bits DWARF. The following 64-bits value is the real initial length. (4-byte unsigned) (2-byte unsigned) (4-byte unsigned)
  3. 3. .debug_info compilation unit header a series of debugging information entries (DIE) .debug_abbrev .section .debug_info,"",@progbits .Ldebug_info0: .long 0x3a8 .value 0x2 .long .Ldebug_abbrev0 .byte 0x8 .uleb128 0x1 .long .LASF55 .byte 0xc .long .LASF56 .long .LASF57 .quad .Ltext0 .quad .Letext0 .long .Ldebug_line0 .uleb128 0x2 .long .LASF7 .byte 0x2 .byte 0xd8 .long 0x38 .uleb128 0x3 .byte 0x8 .byte 0x7 .long .LASF0 .uleb128 0x3 .byte 0x1 .byte 0x8 .long .LASF1 a series of abbreviation declarations abbreviation code attribute values Each abbreviation declaration specifies the tag and attributes for a particular form of debugging information entry.
  4. 4. .section .debug_info,"",@progbits .Ldebug_info0: .long 0x3a8 .value 0x2 .long .Ldebug_abbrev0 .byte 0x8 .uleb128 0x1 .long .LASF55 .byte 0xc .long .LASF56 .long .LASF57 .quad .Ltext0 .quad .Letext0 .long .Ldebug_line0 .uleb128 0x2 .long .LASF7 .byte 0x2 .byte 0xd8 .long 0x38 .uleb128 0x3 .byte 0x8 .byte 0x7 .long .LASF0 .uleb128 0x3 .byte 0x1 .byte 0x8 .long .LASF1 abbreviation code attribute values .section .debug_abbrev,"",@progbits .Ldebug_abbrev0: .uleb128 0x1 .uleb128 0x11 .byte 0x1 .uleb128 0x25 .uleb128 0xe .uleb128 0x13 .uleb128 0xb .uleb128 0x3 .uleb128 0xe .uleb128 0x1b .uleb128 0xe .uleb128 0x11 .uleb128 0x1 .uleb128 0x12 .uleb128 0x1 .uleb128 0x10 .uleb128 0x6 .byte 0 .byte 0 .uleb128 0x2 .uleb128 0x16 .byte 0 .uleb128 0x3 .uleb128 0xe .uleb128 0x3a .uleb128 0xb .uleb128 0x3b .uleb128 0xb .uleb128 0x49 .uleb128 0x13 .byte 0 .byte 0 .uleb128 0x3 abbreviation code tag, 0x11(DW_TAG_compile_unit) has child or not attribute’s name (DW_AT_producer) attribute’s form (DW_FORM_strp) end of attribute spec end of attribute spec .section .debug_str,"MS",@progbits,1 .LASF55: .string "GNU C11 6.2.0 -mtune=generic -march= attribute’s name attribute’s form attribute’s name attribute’s form attribute’s name attribute’s form attribute’s name attribute’s form attribute’s name attribute’s form attribute’s name attribute’s form
  5. 5. unsigned LEB128 encoding 12857 = 0011001000111001 Chop 7 bits as a chunk _0111001_110010000 Place each chunk into a byte Discard zero byte. 1_______0_______ There are other bytes.Last byte. 1011100101100100 First byte.Second byte.
  6. 6. signed LEB128 encoding -2 = 11111111111111111111111111111110 Chop 7 bits as a chunk _1111110_1111111 Place each chunk into a byte If all sign bits, discard. 0_______ Last byte. 01111110 First byte. _1111111_11111111111
  7. 7. signed LEB128 encoding 127 = 00000000000000000000000001111111 Chop 7 bits as a chunk _1111111_0000000 Place each chunk into a byte 11111111 First byte. 1_______0_______ There are other bytes.Last byte. 00000000 Second byte.
  8. 8. .debug_pubnames header entries of global names in the .debug_info length of this set dwarf version offset into .debug_info length of the .debug_info compilation unit compilation unit compilation unit .debug_info .debug_info .debug_info set .debug_pubtypes (DWARFv3)
  9. 9. .debug_aranges header entries of addresses in the .debug_info length of this set dwarf version offset into .debug_info compilation unit compilation unit compilation unit .debug_info .debug_info .debug_info set (size of an address) (size of a segment descriptor) (padding if necessary) First entry is aligned with the size of one entry, 2 x (size of an address).
  10. 10. Activation Record • An activation consists of • A code location that is within the subroutine. • An area of memory that is allocated on a stack called a “call frame.” • A set of registers that are in use by the subroutine at the code location.
  11. 11. Call Frame Information • Recording how procedures save and restore registers throughout their lifetimes. • Construct a very large table as following: LOC CFA R0 R1 … RN L0 L1 … LM • The table is a mapping between program addresses and architecture registers. • The table is a mapping between program addresses and architecture registers. • The table entries are the rules to find the register values in the previous frame.
  12. 12. The Register Rules • undefined • Has no value in the previous frame. (It is not callee-save register.) • same value • This register has not been modified from the previous frame. (It is callee-save register, but the callee has not modified it.) • offset(N) • The previous value of this register is saved at the address CFA +N. • register(R) • The previous value of this register is stored in another register numbered R. • architectural • Architecture defined.
  13. 13. .debug_frame CIE FDE CIE length of this CIE (uword) CIE_id (uword) augmentation (string) code_alignment_factor (uleb218) FDE FDE FDE FDE FDE FDE FDE FDE FDE version (ubyte) data_alignment_factor (sleb128) return_address_register (ubyte) initial_instructions padding code_alignment_factor: A constant that is factored out of all advance location instructions. data_alignment_factor: A constant that is factored out of all offset instructions. initial_instructions: A sequence of rules that are interpreted to create the initial setting of each column in the table. (uleb128 for DWARFv3)
  14. 14. .debug_frame CIE FDE CIE length of this FDE (uword) CIE_pointer (uword) address_range (addressing unit) instructions FDE FDE FDE FDE FDE FDE FDE FDE FDE initial_location (addressing unit) initial_location: A constant indicates the address of the first location associated with this table entry. address_range: A constant indicates the number of bytes of program instructions described by this entry. instructions: A sequence of table defining instructions. padding
  15. 15. .section .debug_frame,"",@progbits .Lframe0: .long .LECIE0-.LSCIE0 // length of this CIE .LSCIE0: .long 0xffffffff // CIE_id .byte 0x1 // version .string “" // augmentation .uleb128 0x1 // code_alignment_factor .sleb128 -8 // data_alignment_factor .byte 0x10 // return address register, ra = r16 .byte 0xc // instruction (0xc = DW_CFA_def_cfa) .uleb128 0x7 // operand1 (register) .uleb128 0x8 // operand2 (offset) CFA = r7(rsp) + 0x8 .byte 0x90 // instruction (0x90 = DW_CFA_offset, register = 0x10) .uleb128 0x1 // operand1 (offset) r16(ra) = CFA + (0x1 * (-8)) .align 8 // padding .LECIE0: .LSFDE0: .long .LEFDE0-.LASFDE0 .LASFDE0: .long .Lframe0 .quad .LFB0 .quad .LFE0-.LFB0 .byte 0x4 .long .LCFI0-.LFB0 .byte 0xe .uleb128 0x10 .byte 0x86 .uleb128 0x2 .byte 0x4 .long .LCFI1-.LCFI0 .byte 0xd .uleb128 0x6 .byte 0x4 .long .LCFI2-.LCFI1 .byte 0xc .uleb128 0x7 .uleb128 0x8 .align 8 .LEFDE0: instructions 00000000 0000000000000014 ffffffff CIE "" cf=1 df=-8 ra=16 LOC CFA ra 0000000000000000 rsp+8 c-8
  16. 16. .section .debug_frame,"",@progbits .Lframe0: .long .LECIE0-.LSCIE0 // length of this CIE .LSCIE0: .long 0xffffffff .byte 0x1 .string “" .uleb128 0x1 .sleb128 -8 .byte 0x10 .byte 0xc .uleb128 0x7 .uleb128 0x8 .byte 0x90 .uleb128 0x1 .align 8 .LECIE0: .LSFDE0: .long .LEFDE0-.LASFDE0 // length of this FDE .LASFDE0: .long .Lframe0 // CIE_pointer .quad .LFB0 // initial location .quad .LFE0-.LFB0 // address range .byte 0x4 // instruction (0x4 = DW_CFA_advance_loc4) .long .LCFI0-.LFB0 // operand1 (4-byte delta) location = location + (delta * (1)) = 0x40050e .byte 0xe // instruction (0xe = DW_CFA_def_cfa_offset) .uleb128 0x10 // operand1 (offset) CFA = rsp + 0x10 .byte 0x86 // instruction (0x86 = DW_CFA_offset, register = 0x6) .uleb128 0x2 // operand1 (offset) r6(rbp) = CFA + (0x2 * (-8)) .byte 0x4 // instruction (0x4 = DW_CFA_advance_loc4) .long .LCFI1-.LCFI0 // operand1 (4-byte delta) location = location + (delta * (1)) = 0x400511 .byte 0xd // instruction (0xd = DW_CFA_def_cfa_register) .uleb128 0x6 // operand1 (register) CFA = r6(rbp) + 0x10 .byte 0x4 // instruction (0x4 = DW_CFA_advance_loc4) .long .LCFI2-.LCFI1 // operand1 (4-byte delta) location = location + (delta * (1)) = 0x400528 .byte 0xc // instruction (0xc = DW_CFA_def_cfa) .uleb128 0x7 // operand1 (register) .uleb128 0x8 // operand2 (offset) CFA = r7(rsp) + 0x8 .align 8 // padding .LEFDE0: 00000018 0000000000000024 00000000 FDE cie=00000000 pc=000000000040050d..0000000000400529 LOC CFA rbp ra 000000000040050d rsp+8 u c-8 // initial rules, defined by CIE 000000000040050e rsp+16 c-16 c-8 0000000000400511 rbp+16 c-16 c-8 0000000000400528 rsp+8 c-16 c-8 instructions

×