How to properly use the libdwarf information to get the local variable location

Question

Preface: I apologize for the lengthy preparation for my question, the reason for this is to make sure this post is self-contained and wanted to include all of the necessary information that I found.

My question correlates to this good post by Mr. Eli Bendersky https://eli.thegreenplace.net/2011/02/07/how-debuggers-work-part-3-debugging-information

Therefore, I will be using the input code below for my question:

#include 
void do_stuff(int my_arg)
{
    int my_local = my_arg + 2;
    int i;

    for (i = 0; i < my_local; ++i)
        printf("i = %d
", i);
}
int main()
{
    do_stuff(2);
    return 0;
}

Above code is compiled gcc -g tracedprog2.c -o tracedprog2

In addition, I will use the libdwarf example shared here https://github.com/timsnyder/libdwarf-code/tree/3e75142a5d8938466e00a942c41a04f69510915d that can be easily built by the following steps to use the program to replicate my findings (this is not needed, just wanted to share in case anyone might be looking for it):

cd libdwarf-code
mkdir build && cd build
cmake -DBUILD_DWARFEXAMPLE=TRUE ..
make -j4
// built binaries will be available in the directory: $HOME/libdwarf-code/build/src/bin/dwarfexample

The question is as stated in the title, how do you use the information gathered by the libdwarf to get the location of the local variable?

So as stated in Mr. Bendersky's post, the first thing to do is obtain libdwarf information by objdump --dwarf=info ./tracedprog2, which will output information like this (I only included information that will be helpful):

<1><8a>: Abbrev Number: 5 (DW_TAG_subprogram)                                                                                                                
    <8b>   DW_AT_external    : 1                                                                                                                              
    <8b>   DW_AT_name        : (indirect string, offset: 0x29): do_stuff                                                                                      
...                                                                                                                          
    <92>   DW_AT_low_pc      : 0x1135
    <9a>   DW_AT_high_pc     : 0x43
       DW_AT_frame_base  : 1 byte block: 9c         (DW_OP_call_frame_cfa)
       DW_AT_GNU_all_tail_call_sites: 1
...
 <2>: Abbrev Number: 7 (DW_TAG_variable)
       DW_AT_name        : (indirect string, offset: 0x0): my_local
...
       DW_AT_type        : <0x57>
       DW_AT_location    : 2 byte block: 91 68      (DW_OP_fbreg: -24)

my understanding is that in order to figure out the location of local variables, many pieces of information are needed (shown as opcodes):

libdwarf's frame base: DW_OP_call_frame_cfa
libdwarf's local variable offset: DW_OP_fbreg

Now here is where things get quite tricky, after reading through DWARF guidebook (https://dwarfstd.org/doc/DWARF5.pdf), it is stated:

The DW_OP_call_frame_cfa operation pushes the value of the CFA, obtained from the Call Frame Information (see Section 6.4 on page 171)

which is where the binary frame1 from dwarfexample shared above (https://github.com/timsnyder/libdwarf-code/tree/3e75142a5d8938466e00a942c41a04f69510915d/src/bin/dwarfexample) tries to parse this CFA information into a readable format for the users.

Upon running the ./frame1 tracedprog2 code, the output you get looks something like this (this program will parse call information entry (CIE) information from the frame description entry (FDE)); Below is the frame information of function do_stuff as that is the focal point of this question. I found a better way to output the data by using readelf -w ./tracedprog2

00000088 000000000000001c 0000005c FDE cie=00000030 pc=0000000000001135..0000000000001178
  DW_CFA_advance_loc: 1 to 0000000000001136
  DW_CFA_def_cfa_offset: 16
  DW_CFA_offset: r6 (rbp) at cfa-16
  DW_CFA_advance_loc: 3 to 0000000000001139
  DW_CFA_def_cfa_register: r6 (rbp)
  DW_CFA_advance_loc: 62 to 0000000000001177
  DW_CFA_def_cfa: r7 (rsp) ofs 8
  DW_CFA_nop
  DW_CFA_nop
  DW_CFA_nop

From the description from the DWARF5 book,

15. DW_CFA_def_cfa takes two unsigned LEB128 arguments representing a
register number and an offset. The required action is to define the
current CFA rule to use the provided register and offset.
16. DW_CFA_def_cfa_register takes a single unsigned LEB128 argument
representing a register number. The required action is to define the
current CFA rule to use the provided register (but to keep the old
offset).
17. DW_CFA_def_cfa_offset takes a single unsigned LEB128 argument
representing an offset. The required action is to define the current CFA
rule to use the provided offset (but to keep the old register).

important information seems to be the value of DW_CFA_def_cfa and DW_CFA_def_cfa_register, which I think might be the frame base I'm looking for.

Therefore, to get the location of the variable my_local, here is what I think needs to be done:

First, CFA is RSP + 8 as defined in DW_CFA_def_cfa. Next, DW_CFA_offset is cfa - 16, which makes it RSP - 8? From there, there is DW_CFA_def_cfa_offset: 16, which seems to suggest I need to add like this RSP - 8 + 16, to make it RSP + 8. Then, using the value DW_CFA_def_cfa_register: r6 (rbp), RSP changes to RBP, so it is now RBP + 8. From here, you add the DW_OP_fbreg: -24 of my_local variable to get the RBP - 0x10. However, I see that in objdump, it is -0x14(%rbp),%eax.

0000000000001135 :
    1135:       55                      push   %rbp
    1136:       48 89 e5                mov    %rsp,%rbp
    1139:       48 83 ec 20             sub    $0x20,%rsp
    113d:       89 7d ec                mov    %edi,-0x14(%rbp)
    1140:       8b 45 ec                mov    -0x14(%rbp),%eax
    1143:       83 c0 02                add    $0x2,%eax
    1146:       89 45 f8                mov    %eax,-0x8(%rbp)

I believe I was able to find all of the necessary information needed to calculate the local variable location but seems like I am missing something somewhere. Could anyone please let me know what I might be missing? Thank you in advance.

How to properly use the libdwarf information to get the local variable location

Answers (1)

Related Questions