问调用库函数是否仍然是非叶函数？x86程序集如何处理库函数？

EN

#include <stdlib.h>
#include <string.h>

int bar(int,int);

int leaf(int *p, int a){
    *p = 0;
    int c = (a<10);
    memcpy(&a, &c, sizeof(a));   // defined by GCC as __builtin_memcpy, optimizes away to a=c
    *p = c;
    return bar(a, a);           // tailcall
}

leaf:
        mov     r8, rdi            # silly compiler, could have avoided this by materializing the boolean into ESI, leaving EDI untouched until after the store
        xor     edi, edi           # zero a register to setcc into to get a zero-extended 0/1
        cmp     esi, 9
        setle   dil                # EDI = (a<=9) // (a<10)
        mov     DWORD PTR [r8], edi  # store to the pointer.  The store of 0 earlier is optimized out as a dead store
        mov     esi, edi           # copy the arg for bar(a,a)
        jmp     bar

int non_leaf(int *p, int a){
    *p = 0;
    int c = rand();
    *p = c;
    return bar(a, a);
}

non_leaf:
        push    rbp                  # save a call-preserved reg
        mov     ebp, esi             # use it to save a for use after rand
        push    rbx
        mov     rbx, rdi             # and another for the pointer
        sub     rsp, 8               # realign the stack by 16
   # end of function prologue
        mov     DWORD PTR [rdi], 0   # *p = 0;   not optimized away because GCC doesn't know that p won't be pointing into memory that rand() reads or writes
        call    rand                 # int c = rand()
        mov     esi, ebp
        mov     edi, ebp             # set up both args for the tailcall to bar
        mov     DWORD PTR [rbx], eax # store *p = c
   # start of function epilogue
        add     rsp, 8               # epilogue: restore stack stuff back to function-entry state
        pop     rbx
        pop     rbp
        jmp     bar                  # tailcall with edi=esi = incoming ESI

int helper(int a){
    return a+1;
}
int call_inline(int *p, int a){
    *p = 0;
    int c = helper(a);
    *p = c;
    return c;
}

# Not declared static, so GCC emits a stand-alone definition in case another file wants to call it.
helper:
        lea     eax, [rdi+1]
        ret

# But the call from this function fully inlined:
call_inline:
        lea     eax, [rsi+1]              # c(eax) = helper(a) = a+1
        mov     DWORD PTR [rdi], eax      # *p = c;
        ret                               # return c (still in EAX)