ihash 0.1.2

World's fastest high-quality non-cryptographic hash, deterministic cross-platform XOF, and seekable stream cipher
Documentation
use crate::{
  backend::{
    aes128::Aes128,
    ctr::{ctr_1x128, split_root},
  },
  const_fn::{CTR_STEP_LI, M_CTR},
  state::BLOCK_LEN,
};

#[inline(always)]
unsafe fn ctr_step_n<L: Aes128, const N: usize, const XOR: bool>(
  ctx: L,
  rk_li: &[L::V; 4],
  mut x_li: [L::V; N],
  ptr: *mut u8,
) {
  // SAFETY: caller satisfies target features and ptr holds N * BLOCK_LEN writable/readable bytes.
  unsafe {
    for x in &mut x_li {
      *x = ctx.ctr_prep_1(*x, rk_li[0]);
    }
    for rk in [rk_li[1], rk_li[2]] {
      for x in &mut x_li {
        *x = ctx.ctr_mid_1(*x, rk);
      }
    }
    for (i, x) in x_li.into_iter().enumerate() {
      let k = ctx.ctr_fin_1(x, rk_li[3], rk_li[0]);
      let p = ptr.add(i * BLOCK_LEN);
      if XOR {
        ctx.st(p, ctx.xor(ctx.ld(p), k));
      } else {
        ctx.st(p, k);
      }
    }
  }
}

#[inline(always)]
unsafe fn ctr_quad<L: Aes128>(ctx: L, c0: L::V, step1: L::V, step2: L::V) -> [L::V; 4] {
  // SAFETY: forwarded from caller contract.
  unsafe {
    let c1 = ctx.add_u64(c0, step1);
    let c2 = ctx.add_u64(c0, step2);
    let c3 = ctx.add_u64(c1, step2);
    [c0, c1, c2, c3]
  }
}

/// Generates or XORs 16-byte AES-CTR keystream blocks across 8 / 4 / 2 SIMD lanes plus 16B tail.
#[inline(always)]
pub(crate) unsafe fn ctr_8x128<L: Aes128, const XOR: bool>(
  ctx: L,
  root: &[u8; 32],
  mut blk: u64,
  buf: &mut [u8],
) {
  debug_assert!(buf.len().is_multiple_of(BLOCK_LEN));
  // SAFETY: caller satisfies target features and buf is valid for buf.len() bytes.
  unsafe {
    let rk_li = split_root(ctx, root);
    let mut ptr = buf.as_mut_ptr();
    let mut rem = buf.len();

    if rem >= 32 {
      let step1 = ctx.ld(CTR_STEP_LI[1].as_ptr());
      let mut c0 = ctx.pair_v(blk, blk.wrapping_mul(M_CTR));

      if rem >= 64 {
        let step2 = ctx.ld(CTR_STEP_LI[2].as_ptr());
        let step4 = ctx.ld(CTR_STEP_LI[4].as_ptr());

        if rem >= 128 {
          let step8 = ctx.ld(CTR_STEP_LI[8].as_ptr());
          let [q0, q1, q2, q3] = ctr_quad(ctx, c0, step1, step2);
          let mut c_li = [
            q0,
            q1,
            q2,
            q3,
            ctx.add_u64(q0, step4),
            ctx.add_u64(q1, step4),
            ctx.add_u64(q2, step4),
            ctx.add_u64(q3, step4),
          ];

          while rem >= 128 {
            ctr_step_n::<L, 8, XOR>(ctx, &rk_li, c_li, ptr);
            for c in &mut c_li {
              *c = ctx.add_u64(*c, step8);
            }
            ptr = ptr.add(128);
            rem -= 128;
            blk = blk.wrapping_add(8);
          }
          c0 = c_li[0];
        }

        if rem >= 64 {
          ctr_step_n::<L, 4, XOR>(ctx, &rk_li, ctr_quad(ctx, c0, step1, step2), ptr);
          c0 = ctx.add_u64(c0, step4);
          ptr = ptr.add(64);
          rem -= 64;
          blk = blk.wrapping_add(4);
        }
      }

      if rem >= 32 {
        let c1 = ctx.add_u64(c0, step1);
        ctr_step_n::<L, 2, XOR>(ctx, &rk_li, [c0, c1], ptr);
        ptr = ptr.add(32);
        rem -= 32;
        blk = blk.wrapping_add(2);
      }
    }

    ctr_1x128::<L, XOR>(ctx, rk_li, blk, ptr, rem);
  }
}