codec: do not check for bounds in bytesDecReader.

Instead, allow the bounds checking to happen and throw an error.
This will be caught during recover and translated to an io.EOF.

codec/helper.go

@@ -107,6 +107,13 @@ package codec
 // but we had to explicitly reference the fields as opposed to using a function
 // to get the better performance that we were looking for.
 // For example, we explicitly call d.d.decRd.fn() instead of d.d.r().fn().
+//
+// ------------------------------------------
+// Bounds Checking
+//    - Allow bytesDecReader to incur "bounds check error", and
+//      recover that as an io.EOF.
+//      This allows the bounds check branch to always be taken by the branch predictor,
+//      giving better performance (in theory), while ensuring that the code is shorter.
 
 import (
 	"bytes"

codec/reader.go

@@ -850,7 +850,7 @@ func (z *bytesDecReader) readn1() (v uint8) {
 }
 
 func (z *bytesDecReader) readn(num uint8) (bs [rwNLen]byte) {
-	// if z.c+2 >= uint(len(z.b)) {
+	// if z.c >= uint(len(z.b)) || z.c+uint(num) >= uint(len(z.b)) {
 	// 	panic(io.EOF)
 	// }
 
@@ -914,8 +914,9 @@ LOOP:
 	z.c = i
 	return
 	// }
-	// END:
 	// panic(io.EOF)
+
+	// END:
 	// // z.a = 0
 	// z.c = blen
 	// return
@@ -992,24 +993,24 @@ func (z *bytesDecReader) readUntil(stop byte, includeLast bool) (out []byte) {
 	// 	}
 	// }
 LOOP:
-	if i < uint(len(z.b)) {
-		if z.b[i] == stop {
-			i++
-			if includeLast {
-				out = z.b[z.c:i]
-			} else {
-				out = z.b[z.c : i-1]
-			}
-			// z.a -= (i - z.c)
-			z.c = i
-			return
-		}
+	// if i < uint(len(z.b)) {
+	if z.b[i] == stop {
 		i++
-		goto LOOP
+		if includeLast {
+			out = z.b[z.c:i]
+		} else {
+			out = z.b[z.c : i-1]
+		}
+		// z.a -= (i - z.c)
+		z.c = i
+		return
 	}
+	i++
+	goto LOOP
+	// }
+	// panic(io.EOF)
 	// z.a = 0
 	// z.c = blen
-	panic(io.EOF)
 }
 
 func (z *bytesDecReader) track() {