¿Existe un fragmento de C que calcule la adición segura contra desbordamiento de manera eficiente sin usar compiladores integrados?

Aquí hay una función C que agrega una inta otra, fallando si se produce un desbordamiento:

int safe_add(int *value, int delta) {
        if (*value >= 0) {
                if (delta > INT_MAX - *value) {
                        return -1;
                }
        } else {
                if (delta < INT_MIN - *value) {
                        return -1;
                }
        }

        *value += delta;
        return 0;
}

Lamentablemente, no está optimizado por GCC o Clang:

safe_add(int*, int):
        movl    (%rdi), %eax
        testl   %eax, %eax
        js      .L2
        movl    $2147483647, %edx
        subl    %eax, %edx
        cmpl    %esi, %edx
        jl      .L6
.L4:
        addl    %esi, %eax
        movl    %eax, (%rdi)
        xorl    %eax, %eax
        ret
.L2:
        movl    $-2147483648, %edx
        subl    %eax, %edx
        cmpl    %esi, %edx
        jle     .L4
.L6:
        movl    $-1, %eax
        ret

Esta versión con __builtin_add_overflow()

int safe_add(int *value, int delta) {
        int result;
        if (__builtin_add_overflow(*value, delta, &result)) {
                return -1;
        } else {
                *value = result;
                return 0;
        }
}

está optimizado mejor :

safe_add(int*, int):
        xorl    %eax, %eax
        addl    (%rdi), %esi
        seto    %al
        jo      .L5
        movl    %esi, (%rdi)
        ret
.L5:
        movl    $-1, %eax
        ret

pero tengo curiosidad por saber si hay una manera sin usar incorporados que GCC o Clang coincidan con los patrones.

Lo mejor que se me ocurrió, si no tienes acceso a la bandera de desbordamiento de la arquitectura, es hacer cosas unsigned. Solo piense en toda la aritmética de bits aquí, ya que solo estamos interesados ​​en el bit más alto, que es el bit de signo cuando se interpreta como valores con signo.

(Todos esos errores de signo de módulo, no lo revisé a fondo, pero espero que la idea sea clara)

#include <stdbool.h>

bool overadd(int a[static 1], int b) {
  unsigned A = a[0];
  unsigned B = b;
  // This computation will be done anyhow
  unsigned AB = A + B;
  // See if the sign bits are equal
  unsigned AeB = ~(A^B);
  unsigned AuAB = (A^AB);
  // The function result according to these should be:
  //
  // AeB \ AuAB | false | true
  //------------+-------+------
  // false      | false | false
  // true       | false | true
  //
  // So the expression to compute from the sign bits is (AeB & AuAB)

  // This is INT_MAX
  unsigned M = -1U/2;
  bool ret = (AeB & AuAB) > M;

  if (!ret) a[0] += b;
  return ret;
}

Si encuentra una versión de la adición que esté libre de UB, como una atómica, el ensamblador es incluso sin ramificación (pero con un prefijo de bloqueo)

#include <stdbool.h>
#include <stdatomic.h>
bool overadd(_Atomic(int) a[static 1], int b) {
  unsigned A = a[0];
  atomic_fetch_add_explicit(a, b, memory_order_relaxed);
  unsigned B = b;
  // This computation will be done anyhow
  unsigned AB = A + B;
  // See if the sign bits are equal
  unsigned AeB = ~(A^B);
  unsigned AuAB = (A^AB);
  // The function result according to these should be:
  //
  // AeB \ AuAB | false | true
  //------------+-------+------
  // false      | false | false
  // true       | false | true
  //
  // So the expression to compute from the sign bits is (AeB & AuAB)

  // This is INT_MAX
  unsigned M = -1U/2;
  bool ret = (AeB & AuAB) > M;
  return ret;
}

Entonces, si tuviéramos tal operación, pero aún más "relajada", esto podría mejorar aún más la situación.

Take3: si usamos un "reparto" especial del resultado sin firmar al firmado, esto ahora no tiene ramificación:

#include <stdbool.h>
#include <stdatomic.h>

bool overadd(int a[static 1], int b) {
  unsigned A = a[0];
  //atomic_fetch_add_explicit(a, b, memory_order_relaxed);
  unsigned B = b;
  // This computation will be done anyhow
  unsigned AB = A + B;
  // See if the sign bits are equal
  unsigned AeB = ~(A^B);
  unsigned AuAB = (A^AB);
  // The function result according to these should be:
  //
  // AeB \ AuAB | false | true
  //------------+-------+------
  // false      | false | false
  // true       | false | true
  //
  // So the expression to compute from the sign bits is (AeB & AuAB)

  // This is INT_MAX
  unsigned M = -1U/2;
  unsigned res = (AeB & AuAB);
  signed N = M-1;
  N = -N - 1;
  a[0] =  ((AB > M) ? -(int)(-AB) : ((AB != M) ? (int)AB : N));
  return res > M;
}

La situación con las operaciones firmadas es mucho peor que con las no firmadas, y solo veo un patrón para la adición firmada, solo para el sonido metálico y solo cuando hay un tipo más amplio disponible:

int safe_add(int *value, int delta)
{
    long long result = (long long)*value + delta;

    if (result > INT_MAX || result < INT_MIN) {
        return -1;
    } else {
        *value = result;
        return 0;
    }
}

clang da exactamente el mismo asm que con __builtin_add_overflow:

safe_add:                               # @safe_add
        addl    (%rdi), %esi
        movl    $-1, %eax
        jo      .LBB1_2
        movl    %esi, (%rdi)
        xorl    %eax, %eax
.LBB1_2:
        retq

De lo contrario, la solución más simple que se me ocurre es esta (con la interfaz que usó Jens):

_Bool overadd(int a[static 1], int b)
{
    // compute the unsigned sum
    unsigned u = (unsigned)a[0] + b;

    // convert it to signed
    int sum = u <= -1u / 2 ? (int)u : -1 - (int)(-1 - u);

    // see if it overflowed or not
    _Bool overflowed = (b > 0) != (sum > a[0]);

    // return the results
    a[0] = sum;
    return overflowed;
}

gcc y clang generan asm muy similares . gcc da esto:

overadd:
        movl    (%rdi), %ecx
        testl   %esi, %esi
        setg    %al
        leal    (%rcx,%rsi), %edx
        cmpl    %edx, %ecx
        movl    %edx, (%rdi)
        setl    %dl
        xorl    %edx, %eax
        ret

Queremos calcular la suma unsigned, por lo unsignedque debemos ser capaces de representar todos los valores intsin que ninguno se pegue. Para convertir fácilmente el resultado de unsigneda int, lo contrario también es útil. En general, se supone el complemento de dos.

En todas las plataformas populares, creo que podemos convertir de unsigneda intmediante una asignación simple como int sum = u;, pero, como mencionó Jens, incluso la última variante del estándar C2x le permite generar una señal. La siguiente forma más natural es hacer algo así: *(unsigned *)&sum = u;pero las variantes de relleno sin trampa aparentemente podrían diferir para los tipos con y sin signo. Entonces, el ejemplo anterior va por el camino difícil. Afortunadamente, tanto gcc como clang optimizan esta difícil conversión.

PD Las dos variantes anteriores no se pudieron comparar directamente ya que tienen un comportamiento diferente. El primero sigue la pregunta original y no golpea *valueen caso de desbordamiento. El segundo sigue la respuesta de Jens y siempre marca la variable señalada por el primer parámetro, pero no tiene ramificaciones.

La mejor versión que se me ocurre es:

int safe_add(int *value, int delta) {
    long long t = *value + (long long)delta;
    if (t != ((int)t))
        return -1;
    *value = (int) t;
    return 0;
}

que produce:

safe_add(int*, int):
    movslq  %esi, %rax
    movslq  (%rdi), %rsi
    addq    %rax, %rsi
    movslq  %esi, %rax
    cmpq    %rsi, %rax
    jne     .L3
    movl    %eax, (%rdi)
    xorl    %eax, %eax
    ret
.L3:
    movl    $-1, %eax
    ret

Podría hacer que el compilador use el indicador de signo asumiendo (y afirmando) una representación de complemento a dos sin bytes de relleno. Dichas implementaciones deberían producir el comportamiento requerido en la línea anotada por un comentario, aunque no puedo encontrar una confirmación formal positiva de este requisito en el estándar (y probablemente no haya ninguna).

Tenga en cuenta que el siguiente código solo maneja la suma de enteros positivos, pero puede ampliarse.

int safe_add(int* lhs, int rhs) {
    _Static_assert(-1 == ~0, "integers are not two's complement");
    _Static_assert(
        1u << (sizeof(int) * CHAR_BIT - 1) == (unsigned) INT_MIN,
        "integers have padding bytes"
    );
    unsigned value = *lhs;
    value += rhs;
    if ((int) value < 0) return -1; // impl. def., 6.3.1.3/3
    *lhs = value;
    return 0;
}

Esto produce tanto en clang como en GCC:

safe_add:
        add     esi, DWORD PTR [rdi]
        js      .L3
        mov     DWORD PTR [rdi], esi
        xor     eax, eax
        ret
.L3:
        mov     eax, -1
        ret