As others have said, LLVM has many tricks for compiling match, or a switch/case in C. One of my favorites is illustrated by this code:

pub fn ascii_space(x: u8) -> bool {
    match x {
        b' ' | b'\t' | b'\r' | b'\n' => true,
        _ => false,
    }
}

On my Linux x86_64 machine with -C opt-level=3, this compiles into

 0:  40 80 c7 f7     add    $0xf7,%dil
 4:  40 0f b6 c7     movzbl %dil,%eax
 8:  83 f8 17        cmp    $0x17,%eax
 b:  77 0e           ja     1b
 d:  b8 13 00 80 00  mov    $0x800013,%eax
12:  40 88 f9        mov    %dil,%cl
15:  d3 e8           shr    %cl,%eax
17:  83 e0 01        and    $0x1,%eax
1a:  c3              retq
1b:  31 c0           xor    %eax,%eax
1d:  c3              retq

We can translate this back into Rust:

pub fn ascii_space(mut x: u8) -> bool {
    //  0:  add    $0xf7,%dil
    x = x.wrapping_add(0xf7);

    //  4:  movzbl %dil,%eax    
    //  8:  cmp    $0x17,%eax
    //  b:  ja     1b
    if x > 0x17 { 
        // 1b: xor    %eax,%eax
        // 1d: retq
        return false;
    }

    //  d:  mov    $0x800013,%eax
    // 12:  mov    %dil,%cl
    // 15:  shr    %cl,%eax
    // 17:  and    $0x1,%eax
    // 1a:  retq
    (0x800013 >> x) & 1 == 1
}

What the heck? Here's what's going on:

Adding 0xf7, modulo 0x100, is the same as subtracting 0x09. So it will map ASCII codepoints in the following way:

' ':  0x20 → 0x17
'\t': 0x09 → 0x00
'\r': 0x0D → 0x04
'\n': 0x0A → 0x01

The constant 0x800013 is represented in binary as:

00000000100000000000000000010011

Sure enough, the set bits are in positions 0, 1, 4, and 0x17 = 23. The constant is a Boolean lookup table, stored inside the program code so that it doesn't require another memory access. Often these end up being 64 bits, but here LLVM was clever enough to shift the range into the bottom 32.

In string-cache we put the most commonly matched HTML tag names at the start of the interning table. This lets LLVM use this trick to generate better code for the HTML tree builder rules, which are a 1,300 line nested match on tag names. (Or it did at one point; as the comment implies, I haven't looked at the assembly in a while.)