The implementation of a switch-statement in ARM assembly seems too minimal

Question

I was learning about how switch-statements work under the hood in C, so I decided to look at the compiled code. From what I understand, C uses a jump table to implement switch-statements. However, I don't see any labels or jump instructions in the assembly code.

I am on Apple silicon, so it is ARM assembly. Please take a look and tell me what you think. Thanks :)

C code:

int main (int argc, char *argv[]) {
    int one;
    int two;
    int three;
    int four;
    
    switch (1) {
        case 1:
            one = 1; 
            break;
        case 2:
            two = 2; 
            break;
        case 3:
            three = 3;
            break;
        default:
            four = 4;
            break;
    }
    
    return 0;
    
}

ARM code:

    .section    __TEXT,__text,regular,pure_instructions
    .build_version macos, 14, 0 sdk_version 14, 4
    .globl  _main                           ; -- Begin function main
    .p2align    2
_main:                                  ; @main
    .cfi_startproc
; %bb.0:
    sub sp, sp, #32
    .cfi_def_cfa_offset 32
    mov x8, x0
    mov w0, #0
    str wzr, [sp, #28]
    str w8, [sp, #24]
    str x1, [sp, #16]
    mov w8, #1
    str w8, [sp, #12]
    add sp, sp, #32
    ret
    .cfi_endproc
                                        ; -- End function
.subsections_via_symbols

Answer 1

A C compiler is free to transform the program under the so-called as-if rule. This means that with sufficient optimization, the OP program can be reduced to just returning 0.

To avoid such optimizations, a common approach is to make variables volatile. With this the complete translation of the OP code can be seen:

main:
        sub     sp, sp, #32
        mov     w0, 1
        str     w0, [sp, 28]
        ldr     w0, [sp, 28]
        cmp     w0, 2
        beq     .L2
        cmp     w0, 3
        beq     .L3
        cmp     w0, 1
        bne     .L4
        str     w0, [sp, 12]
.L5:
        mov     w0, 0
        add     sp, sp, 32
        ret
.L3:
        str     w0, [sp, 20]
        b       .L5
.L2:
        str     w0, [sp, 16]
        b       .L5
.L4:
        mov     w0, 4
        str     w0, [sp, 24]
        b       .L5

As seen, in this case, the compiler still does a series of comparisons, presumably because that is more efficient than a lookup table.

Possibly, if there a more cases, it will use a lookup table, but in any case a modern compiler will go far to make the most efficient code so we can focus on writing the most readable code.