Вычисление sqrt(SIZE_MAX+1) с использованием только целочисленных константных выражений, учитывающих странные ABI

Альтернативой решению sqrt(SIZE_MAX+1) является просмотр цели более высокого уровня, показанной здесь и ниже.

/* s1*s2 <= SIZE_MAX if s1 < K and s2 < K, where K = sqrt(SIZE_MAX+1) */
const size_t MUL_NO_OVERFLOW = ((size_t)1) << (sizeof(size_t) * 4);
if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
    nmemb > 0 && SIZE_MAX / nmemb < size)
  abort();

Простое обнаружение переполнения может использовать следующее. Это, к сожалению, выполняет деление - обширный тест, но в остальном "работает". MUL_NO_OVERFLOW не нужно.

if (nmemb > 0 && (SIZE_MAX / nmemb < size))
  abort();

Вместо деления код OP выполняет 2 простых сравнения с MUL_NO_OVERFLOW, чтобы исключить большинство претендентов.

if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) && ...

Тем не менее, вычисление MUL_NO_OVERFLOW на препроцессоре является сложной задачей, поэтому этот пост.

Альтернативой является использование легко вычисляемого MUL_NO_OVERFLOW_ALT для исключения множества пар size, nmemb из теста на деление.

// good for up to SIZE_MAX + 1 == 2**128
#define SQN(x) ( !!(x) )
#define SQ0(x) ( (x) >= 0x2u ? 1 + SQN((x)/0x2u) : SQN(x) )
#define SQ1(x) ( (x) >= 0x4u ? 2 + SQ0((x)/0x4u) : SQ0(x) )
#define SQ2(x) ( (x) >= 0x10u ? 4 + SQ1((x)/0x10u) : SQ1(x) )
#define SQ3(x) ( (x) >= 0x100u ? 8 + SQ2((x)/0x100u) : SQ2(x) )
#define SQ4(x) ( (x) >= 0x10000u ? 16 + SQ3((x)/0x10000u) : SQ3(x) )
#define SQ5(x) ( (x) >= 0x100000000u ? 32 + SQ4((x)/0x100000000u) : SQ4(x) )
#define SQ6(x) ( (x)/0x100000000u >= 0x100000000u ? 64 + SQ5((x)/0x1000000000000000u/16) : SQ5(x) )
#define MUL_NO_OVERFLOW_ALT (((size_t)1) << (SQ6(SIZE_MAX)/2))

printf("%zx %zx\n", SIZE_MAX, MUL_NO_OVERFLOW_ALT);
// Output
// ffffffff 10000

В случае OP, даже если наилучший (size_t)sqrt(SIZE_MAX + 1.0) был возможен во время компиляции, тест деления все равно потребуется для прохождения допустимых пар size, nmemb, таких как 4, SIZE_MAX/100. Так что для этой задачи лучшего ISQRT(SIZE_MAX + 1.0) не нужно, просто что-то близкое и не большее.

С помощью этого кода наилучшее значение вычисляется, когда SIZE_MAX + 1 является четной степенью числа 2 - распространенный случай.

Следующее работает, но нуждается в очистке.

Предполагает:
1) SIZE_MAX + 1 - это некоторая степень числа 2, нечетная или четная.
2) unsigned long long диапазон не менее size_t.
3) sizeof (SIZE_MAX) ‹= 128 бит.

Примечания:
1) SIZE_MAX должно быть не менее 65535.
2) Слишком много ()
3) Требуется дополнительное тестирование.

Метод:
Найдите степень числа 2 числа SIZE_MAX/4 + 1 с помощью вложенных определений. Нужен другой уровень для каждого двойного бита. На каждом уровне разрядности 32, 64, 128, ... тестируются старшие биты SIZE_MAX. Как только будет найдена максимальная разрядность в степени 2, выполните рекурсию вниз, чтобы получить бит с SIZE_MAX.

Сформируйте sqrt(SIZE_MAX + 1) из (1 << Bit_Width(SIZE_MAX/4 + 1)/2)*2. Умножьте на масштабированное sqrt(2), если разрядность была нечетной.

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>

int main(void) {
  // Swap 1 for various powers of 2 like 256, 512. etc. to test
#define M  SIZE_MAX/1
  printf("M %zX\n", (size_t) M);
#define N (M/4 + 1)
  printf("N/4 + 1 %zX\n", (size_t) N);

// Obviously this line can be simplified.
#define M0(x)  ((x & ~0x0U) ? 0 : 0)

#define M1(x)  ((x & ~0x1U) ? 1 + M0(x >> 2) : M0(x))

#define M2(x)  ((x & ~0x3U) ? 2 + M1(x >> 2) : M1(x))

#define M3(x)  ((x & ~0xFU) ? 4 + M2(x >> 4) : M2(x))

#define M4(x)  ((x & ~0xFFU) ? 8 + M3(x >> 8) : M3(x))

#define M5(x)  ((x & ~0xFFFFLLU) ? 16 + M4(x >> 16) : M4(x))

#if (M & ~0xFFFFFFFFLLU)
#define M6(x)  ((x & ~0xFFFFFFFFLLU) ? 32 + M5(x >> 32) : M5(x))
#if (M & ~0xFFFFFFFFFFFFFFFFLLU)
#define MN(x)  ((x & ~0xFFFFFFFFFFFFFFFFLLU) ? 64 + M6(x >> 64) : M6(x))
#define MSQ2(odd, x) ((odd&1) ? (x*13043817825332782212llu)>>63 : x)
#else
#define MN(x)  M6(x)
#define MSQ2(odd, x) ((odd&1) ? (x*3037000499llu)>>31 : x)
#endif
#else
#define MN(x)  M5(x)
#define MSQ2(odd, x) ((odd&1) ? (x*46340llu)>>15 : x)
#endif

  printf("MN(N) %d\n", MN(N));
  printf("MN(M) %d\n", MN(M));

#define MUL_NO_OVERFLOW   ((size_t) MSQ2(MN(N), ((((size_t)1) << (MN(N)/2))*2) ))

  printf("MUL_NO_OVERFLOW %zu\n", MUL_NO_OVERFLOW);
  return 0;
}

Выглядит слишком сложно - посмотрю насчет упрощения. ГТГ