xray incorrectly generates tailcall sled kind as exit kind in aarch64 target

[quininer]

__attribute__ ((noinline))                                                                                                                                                                  
int fx(unsigned int a) {                                                                                                                                                                    
  return a + 1;                                                                                                                                                                             
}                                                                                                                                                                                           

int foo(unsigned int a) {                                                                                                                                                                   
  return fx(a);                                                                                                                                                                             
}

Compile the above code using the command

clang foo.c -shared -O2 -fxray-instrument -fxray-instruction-threshold=1 -fuse-ld=lld -nostdlib

output

000000000001047c <foo>:
   1047c: 14000008     	b	0x1049c <foo+0x20>
   10480: d503201f     	nop
   10484: d503201f     	nop
   10488: d503201f     	nop
   1048c: d503201f     	nop
   10490: d503201f     	nop
   10494: d503201f     	nop
   10498: d503201f     	nop
   1049c: 14000008     	b	0x104bc <foo+0x40>
   104a0: d503201f     	nop
   104a4: d503201f     	nop
   104a8: d503201f     	nop
   104ac: d503201f     	nop
   104b0: d503201f     	nop
   104b4: d503201f     	nop
   104b8: d503201f     	nop
   104bc: 14000009     	b	0x104e0 <fx@plt>

You can see that this generates a tail call from function foo to function fx, but it is reported as exit kind in xray_instr_map.

$ llvm-xray extract a.out --output=-
---
- { id: 1, address: 0x10434, function: 0x10434, kind: function-enter, always-instrument: false, function-name: '', version: 2 }
- { id: 1, address: 0x10458, function: 0x10434, kind: function-exit, always-instrument: false, function-name: '', version: 2 }
- { id: 2, address: 0x1047C, function: 0x1047C, kind: function-enter, always-instrument: false, function-name: '', version: 2 }
- { id: 2, address: 0x1049C, function: 0x1047C, kind: function-exit, always-instrument: false, function-name: '', version: 2 }
...

The same code and compiler arguments will correctly generate and report as tailcall kind on x86_64 linux.

[sebastiankreutzer]

Thanks for reporting this. In principle, tail calls should be explicitly handled in AArch64 (they are not on some other targets).
At a first glance, this seems to be an issue related to the emission of the patchable return instruction, rather than on the lowering or patching side.
@quininer Are you working on a patch yourself? Otherwise, I'm happy to prepare a fix.

[quininer]

@sebastiankreutzer No, I'm not doing this. please :D