On architectures that allow unaligned loads, we should rewrite b[0] == c1 && b[1] == c2 to *(*uint16)(&b[0]) == (c1 << 8) + c2. And do all architectures for cases in which we know b[0] is appropriately aligned. Also uint32 and uint64 (as appropriate).

See CL 26758 for more discussion; that CL will cause many of these to be generated.

We might also independently want to update the front end (near OCMPSTR) to generate the larger comparisons directly.

package p

import "testing"

var (
    sink   bool
    b1, b2 byte
)

func Benchmark8(b *testing.B) {
    for i := 0; i < b.N; i++ {
        sink = b1 == 5 && b2 == 9
    }
}

func Benchmark16(b *testing.B) {
    u16 := uint16(b1<<8) + uint16(b2)
    const c16 = (5 << 8) + 9
    for i := 0; i < b.N; i++ {
        sink = u16 == c16
    }
}

Benchmark8-8                2000000000           0.99 ns/op
Benchmark16-8               2000000000           0.68 ns/op