word.h

#ifndef WORD_H_
#define WORD_H_

#include <stdint.h>

#include "config.h"

typedef struct {
  uint32_t e;
  uint32_t o;
} word_t;

__forceinline word_t WORD_T(uint64_t x) {
  return (word_t){.o = x >> 32, .e = x};
}

__forceinline uint64_t UINT64_T(word_t x) { return (uint64_t)x.o << 32 | x.e; }

uint64_t TOBI32(uint64_t in);

uint64_t FROMBI32(uint64_t in);

__forceinline word_t U64TOWORD(uint64_t x) {
  uint64_t w = TOBI32(x);
  return (word_t){.o = w >> 32, .e = w};
}

__forceinline uint64_t WORDTOU64(word_t w) {
  return FROMBI32((uint64_t)w.o << 32 | w.e);
}

#define XOR(a, b)  \
  do {             \
    word_t tb = b; \
    (a).e ^= tb.e; \
    (a).o ^= tb.o; \
  } while (0)

#define AND(a, b)  \
  do {             \
    word_t tb = b; \
    (a).e &= tb.e; \
    (a).o &= tb.o; \
  } while (0)

__forceinline uint32_t ROR32(uint32_t x, int n) {
  return x >> n | x << (32 - n);
}

__forceinline word_t ROR64(word_t x, int n) {
  word_t r;
  r.e = (n % 2) ? ROR32(x.o, (n - 1) / 2) : ROR32(x.e, n / 2);
  r.o = (n % 2) ? ROR32(x.e, (n + 1) / 2) : ROR32(x.o, n / 2);
  return r;
}

__forceinline word_t KEYROT(word_t lo2hi, word_t hi2lo) {
  word_t r;
  r.o = lo2hi.o << 16 | hi2lo.o >> 16;
  r.e = lo2hi.e << 16 | hi2lo.e >> 16;
  return r;
}

__forceinline int NOTZERO(word_t a, word_t b) {
  int result = 0;
  for (int i = 0; i < 8; ++i) result |= ((uint8_t*)&a)[i];
  for (int i = 0; i < 8; ++i) result |= ((uint8_t*)&b)[i];
  return result;
}

/* set padding byte in 64-bit Ascon word */
__forceinline word_t PAD(int i) {
  return WORD_T((uint64_t)(0x08 << (28 - 4 * i)) << 32);
}

/* byte mask for 64-bit Ascon word (1 <= n <= 8) */
__forceinline word_t XMASK(int n) {
  uint32_t mask = 0x0fffffff >> (n * 4 - 4);
  return WORD_T((uint64_t)mask << 32 | mask);
}

#endif /* WORD_H_ */