Decompiler Listing's local var takes name of register write reference of func call return value, not name of stack var value gets stored in?

[ghost]

Hi,

I'm trying to understand how the decompiler names it's variables. Specifically for a case of a function call return value that being stored in a stack allocated local variable.

I have a very simple Aarch64 program which malloc's some memory for a struct, stores the returned pointer in a stack allocated pointer var and then proceeds to assign values to the struct members via the pointer.

In the disassembly listing the malloc call's return value goes into register x0 (00100768) and I've got a register write reference at that location, which I've named malloc_ret. Immediately after the returned pointer from malloc is stored in a stack allocated var which I've named struct_ptr_stackvar (00100770). There is both a register read reference for malloc_ret and a memory write reference for struct_ptr_stackvar there.

When I look at the decompiler output it's a completely accurate representation of the high-level logic however I end up with two stack vars, one named for the register reference and the other for the actual stack allocated local variable. And it's the var named after the register reference (i.e. malloc_ret) that is used throughout the rest of the decompiler listing's code.

Could you help me understand why the decompiler ends up with two vars like this ... and opts to use the register reference's name throughout it's listing? Ideally I'd want the decompiler's to use struct_ptr_stackvar throughout it's code to match the disassembly.

See disassembly & decompiler listings below.

Note that I've disabled the option Edit -> Tool Options -> Listing Fields -> Operand Field -> Markup Register Variable References because I'm still wrapping my head around how to use register references effectively. I found the markup of register names more confusing than helpful. If you happen to know of some good docs / tutorials on using register references effectively that would be great too!

Thanks in advance for your help!

Disassembly Partial Listing

                         *******************************************************
                         *                      FUNCTION                       *
                         *******************************************************
                         int __cdecl main(void)
           int             w0:4               <RETURN>                           XREF[2]:   00100768(W), 
                                                                                             0010076c(R)  
           HeapStruct *    x0:8               malloc_ret                         XREF[2]:   00100768(W), 
                                                                                             0010076c(R)  
           HeapStruct *    Stack[-0x8]:8      struct_ptr_stackvar                XREF[7]:   0010076c(W), 
                                                                                             00100770(R), 
                                                                                             0010077c(R), 
                                                                                             00100788(R), 
                                                                                             00100794(R), 
                                                                                             001007a0(R), 
                                                                                             001007a8(R)  
           undefined4      Stack[-0x14]:4     local_14                           XREF[1]:   0010075c(W)  
           undefined8      Stack[-0x20]:8     local_20                           XREF[1]:   00100760(W)  
           undefined8      Stack[-0x30]:8     FP_stack_save                      XREF[2]:   00100754(W), 
                                                                                             001007b4(*)  
                         main                                      XREF[4]:   entry:00100660(*), 00100808, 
                                                                               001008a0(*), 00110ff0(*)  
      00100754 fd 7b bd a9     stp       x29,x30,[sp, #FP_stack_save]!
      00100758 fd 03 00 91     mov       x29,sp
      0010075c e0 1f 00 b9     str       w0,[sp, #local_14]
      00100760 e1 0b 00 f9     str       x1,[sp, #local_20]
      00100764 80 01 80 d2     mov       x0,#0xc
      00100768 aa ff ff 97     bl        <EXTERNAL>::malloc                         void * malloc(size_t __size)
      0010076c e0 17 00 f9     str       x0=>malloc_ret,[sp, #struct_ptr_stackvar]
      00100770 e0 17 40 f9     ldr       x0,[sp, #struct_ptr_stackvar]
      00100774 1f 00 00 f1     cmp       x0,#NULL
      00100778 40 01 00 54     b.eq      LAB_001007a0
      0010077c e0 17 40 f9     ldr       x0,[sp, #struct_ptr_stackvar]
      00100780 21 00 80 52     mov       w1,#0x1
      00100784 01 00 00 b9     str       w1,[x0]
      00100788 e0 17 40 f9     ldr       x0,[sp, #struct_ptr_stackvar]
      0010078c 01 02 80 52     mov       w1,#0x10
      00100790 01 04 00 b9     str       w1,[x0, #0x4]
      00100794 e0 17 40 f9     ldr       x0,[sp, #struct_ptr_stackvar]
      00100798 01 e0 81 52     mov       w1,#0xf00
      0010079c 01 08 00 b9     str       w1,[x0, #0x8]

... <SNIP for brevity> ...

Decompiler Full Listing - I realize I didn't free() ;)

int main(void)

{
  HeapStruct *malloc_ret;
  HeapStruct *struct_ptr_stackvar;
  
  malloc_ret = (HeapStruct *)malloc(0xc);
  if (malloc_ret != (HeapStruct *)NULL) {
    malloc_ret->a = 1;
    malloc_ret->b = 0x10;
    malloc_ret->c = 0xf00;
  }
  return malloc_ret->a + malloc_ret->b;
}