@amritk/nish-aarch64-darwin 0.34.0 → 0.35.0

package/std/bytes.ts

@@ -26,7 +26,10 @@
  * inside a call, and after `getU32LE` inlines, LLVM keeps the checks on
  * `off + 1` to `off + 3`, because the guard compares the length truncated to
  * `i32` and the checks compare it unsigned at 64 bits. A loop that needs them
- * gone indexes the bytes itself.
+ * gone indexes the bytes itself. `getU64BE`, and with it `getI64BE` and
+ * `getF64BE`, is the exception: it checks the whole range once and reads the
+ * eight bytes unchecked, which lowers to one load and a byte swap. An offset
+ * outside the range still goes byte by byte, so it panics as the others do.
  *
  * The in-range answers are byte for byte those of the copies `std/` keeps for
  * itself: `sha256LoadWord` (`std/crypto/sha256.ts`) for `getU32BE`,
@@ -91,8 +94,8 @@ export const getU64LE = (b: u8[], off: i32): u64 => {
   return v
 }
 
-/** The `u64` whose bytes, most significant first, are `b[off]` to `b[off + 7]`. */
-export const getU64BE = (b: u8[], off: i32): u64 => {
+/** `getU64BE` a byte at a time, each index checked: the path for an offset whose eight bytes are not all in the array. */
+const getU64BEByByte = (b: u8[], off: i32): u64 => {
   let v = toU64(0)
   for (let i: i32 = 0; i < 8; i++) {
     v = (v << toU64(8)) | toU64(b[off + i])
@@ -100,6 +103,26 @@ export const getU64BE = (b: u8[], off: i32): u64 => {
   return v
 }
 
+/**
+ * The `u64` whose bytes, most significant first, are `b[off]` to `b[off + 7]`.
+ * The fast path's ors are grouped in pairs, which LLVM folds into one load and
+ * a `bswap`; a flat chain of eight `or`s stayed byte by byte. The byte loop is
+ * its own function so its last load is not merged with the fast path's.
+ */
+export const getU64BE = (b: u8[], off: i32): u64 => {
+  if (off >= 0 && off < 2147483640 && off + 8 <= toI32(b.length)) {
+    return (
+      (toU64(b[off]) << toU64(56)) |
+      (toU64(b[off + 1]) << toU64(48)) |
+      ((toU64(b[off + 2]) << toU64(40)) | (toU64(b[off + 3]) << toU64(32))) |
+      ((toU64(b[off + 4]) << toU64(24)) |
+        (toU64(b[off + 5]) << toU64(16)) |
+        ((toU64(b[off + 6]) << toU64(8)) | toU64(b[off + 7])))
+    )
+  }
+  return getU64BEByByte(b, off)
+}
+
 /** `getU32LE`'s bits as a two's-complement `i32`. */
 export const getI32LE = (b: u8[], off: i32): i32 => toI32(getU32LE(b, off))
 
@@ -278,7 +301,7 @@ export const skipJsonPlain = (b: u8[], from: i32, to: i32): i32 => {
  * panics `copyBytes` before any byte is written. Natively the copy is one
  * `llvm.memmove`.
  */
-export const copyBytes = (dst: u8[], at: i32, src: u8[], from: i32, count: i32): void => {
+export const copyBytes = (dst: u8[], at: i32, src: readonly u8[], from: i32, count: i32): void => {
   if (count < 0 || at < 0 || from < 0 || at > toI32(dst.length) - count || from > toI32(src.length) - count) {
     panic("copyBytes: the range lies outside an array")
   }
@@ -402,7 +425,7 @@ const skipJsonPlainWalk = (b: u8[], from: i32, to: i32): i32 => {
 }
 
 /** `copyBytes`'s walk, once its ranges are checked: forward, or backward when `dst` is `src` and the bytes move up. */
-const copyBytesWalk = (dst: u8[], at: i32, src: u8[], from: i32, count: i32): void => {
+const copyBytesWalk = (dst: u8[], at: i32, src: readonly u8[], from: i32, count: i32): void => {
   if (at <= from) {
     let k: i32 = 0
     while (k < count) {

package/std/crypto/base64url.ts

@@ -127,8 +127,9 @@ export const base64urlEncode = (data: u8[]): string => {
  * one canonical spelling of any byte string — see the module comment for the
  * five refusals.
  *
- * The same accumulator as `base64urlEncode`, run the other way: six bits in per
- * character, eight out per byte.
+ * Each group of four characters becomes one 24-bit word, six bits a
+ * character, which splits into three bytes; a short final group of two or
+ * three characters fills the top of the word and gives one or two.
  */
 export const base64urlDecode = (text: string): u8[] | null => {
   // A text past 2^31 - 1 bytes is refused before `toI32`, which would
@@ -148,31 +149,51 @@ export const base64urlDecode = (text: string): u8[] | null => {
   // short final group; `n * 3 / 4` would overflow for a text over 700 MB.
   const out: u8[] = new Array<u8>((n >> 2) * 3 + (tail === 0 ? 0 : tail - 1))
   const outLen: i32 = toI32(out.length)
-  // All ones once any character is outside the alphabet (its sextet of `-1`
+  // All ones once any character is outside the alphabet (a sextet of `-1`
   // shifted right by 31), and non-zero once the text ends on a bit that
   // encodes no byte.
   let bad: i32 = 0
-  let acc: i32 = 0
-  let bits: i32 = 0
+  // Four characters make one 24-bit word and three bytes, so a full group has
+  // no count of waiting bits to test, and its four sextets are independent.
   let j: i32 = 0
-  for (let k: i32 = 0; k < n; k++) {
-    const v: i32 = base64urlSextetOf(toI32(text.charCodeAt(k)))
-    bad = bad | (v >> 31)
-    acc = ((acc << 6) | (v & 63)) & 0xfff
-    bits += 6
-    if (bits >= 8) {
-      bits -= 8
-      // Always true — `out` was sized from the same length — but written out
-      // so that the store keeps no bounds check.
-      if (j >= 0 && j < outLen) {
-        out[j] = toU8((acc >> bits) & 255)
-      }
-      j++
+  for (let k: i32 = 0; k + 3 < n; k += 4) {
+    const s0: i32 = base64urlSextetOf(toI32(text.charCodeAt(k)))
+    const s1: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 1)))
+    const s2: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 2)))
+    const s3: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 3)))
+    bad = bad | ((s0 | s1 | s2 | s3) >> 31)
+    const word: i32 = ((s0 & 63) << 18) | ((s1 & 63) << 12) | ((s2 & 63) << 6) | (s3 & 63)
+    // Always true — `out` was sized from the same length — but written out so
+    // that the three stores keep no bounds check.
+    if (j >= 0 && j + 2 < outLen) {
+      out[j] = toU8(word >> 16)
+      out[j + 1] = toU8((word >> 8) & 255)
+      out[j + 2] = toU8(word & 255)
     }
+    j += 3
+  }
+  // A short final group of two or three characters: one or two bytes, and the
+  // four or two bits left over belong to no byte, so they must be zero for `AA`
+  // to be the only spelling of a zero byte and `AB` refused (RFC 4648 §3.5).
+  if (tail !== 0) {
+    const k: i32 = n - tail
+    const s0: i32 = base64urlSextetOf(toI32(text.charCodeAt(k)))
+    const s1: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 1)))
+    // A third character only when the tail has one; a two-character tail reads
+    // its place as `A`, the zero sextet, which adds no bits.
+    const s2: i32 = tail === 3 ? base64urlSextetOf(toI32(text.charCodeAt(k + 2))) : 0
+    bad = bad | ((s0 | s1 | s2) >> 31)
+    const word: i32 = ((s0 & 63) << 18) | ((s1 & 63) << 12) | ((s2 & 63) << 6)
+    if (j >= 0 && j < outLen) {
+      out[j] = toU8(word >> 16)
+    }
+    if (tail === 3 && j + 1 >= 0 && j + 1 < outLen) {
+      out[j + 1] = toU8((word >> 8) & 255)
+    }
+    // The bits under the last byte written: sixteen of the word when one byte
+    // was, eight when two were.
+    bad = bad | (word & (tail === 2 ? 0xffff : 0xff))
   }
-  // The two or four bits left over belong to no byte, and must be zero so that
-  // `AA` is the only spelling of a zero byte and `AB` is refused (RFC 4648 §3.5).
-  bad = bad | (acc & ((1 << bits) - 1))
   if (bad !== 0) {
     return null
   }