Optimization problem in using static key

[iamroot12a]

source code

typedef enum { false, true } bool;                                                        

static __attribute__((always_inline)) bool static_branch_nop()                            
{                                                                                         
        asm goto(                                                                         
                "1:                                     \n\t"                             
                        "nop                            \n\t"                             
                :::: l_yes);                                                              

        return false;                                                                     
l_yes:                                                                                    
        return true;                                                                      
}                                                                                         

static __attribute__((always_inline)) bool static_branch_jump()                           
{                                                                                         
        asm goto(                                                                         
                "1:                                     \n\t"                             
                        "b      0x55                    \n\t"                             
                        :::: l_yes);                                                      

        return false;                                                                     
l_yes:                                                                                    
        return true;                                                                      
}                                                                                         

void func_nop()                                                                           
{                                                                                         
        __asm__ __volatile__("nop\n\t");                                                  
}                                                                                         

void func_jump()                                                                          
{                                                                                         
        __asm__ __volatile__("nop\n\t");                                                  
        __asm__ __volatile__("nop\n\t");                                                  
}                                                                                         

int main()                                                                                
{                                                                                         
        if (static_branch_nop()) {                                                        
                func_nop();                                                               
        } else {                                                                          
                func_jump();                                                              
        }                                                                                 

        return 0;                                                                         
}  

dump code without optimization

00008220 <func_nop>:
    8220:       e52db004        push    {fp}            ; (str fp, [sp, #-4]!)
    8224:       e28db000        add     fp, sp, #0
    8228:       e1a00000        nop                     ; (mov r0, r0)
    822c:       e1a00000        nop                     ; (mov r0, r0) 
    8230:       e24bd000        sub     sp, fp, #0
    8234:       e49db004        pop     {fp}            ; (ldr fp, [sp], #4) 
    8238:       e12fff1e        bx      lr  

0000823c <func_jump>:
    823c:       e52db004        push    {fp}            ; (str fp, [sp, #-4]!)
    8240:       e28db000        add     fp, sp, #0
    8244:       e1a00000        nop                     ; (mov r0, r0) 
    8248:       e1a00000        nop                     ; (mov r0, r0) 
    824c:       e1a00000        nop                     ; (mov r0, r0) 
    8250:       e24bd000        sub     sp, fp, #0
    8254:       e49db004        pop     {fp}            ; (ldr fp, [sp], #4) 
    8258:       e12fff1e        bx      lr  

0000825c <main>:
    825c:       e92d4800        push    {fp, lr} 
    8260:       e28db004        add     fp, sp, #4
    8264:       e1a00000        nop                     ; (mov r0, r0) 
    8268:       e3a03000        mov     r3, #0
    826c:       ea000000        b       8274 <main+0x18>
    8270:       e3a03001        mov     r3, #1
    8274:       e3530000        cmp     r3, #0
    8278:       0a000001        beq     8284 <main+0x28>
    827c:       ebffffe7        bl      8220 <func_nop>
    8280:       ea000000        b       8288 <main+0x2c>
    8284:       ebffffec        bl      823c <func_jump>
    8288:       e3a03000        mov     r3, #0
    828c:       e1a00003        mov     r0, r3
    8290:       e24bd004        sub     sp, fp, #4
    8294:       e8bd4800        pop     {fp, lr} 
    8298:       e12fff1e        bx      lr  

dump code with optimization

0000804c <main>:
    804c:       e1a00000        nop                     ; (mov r0, r0) 
    8050:       e1a00000        nop                     ; (mov r0, r0) 
    8054:       e1a00000        nop                     ; (mov r0, r0) 
    8058:       e3a00000        mov     r0, #0
    805c:       e12fff1e        bx      lr