มีข้อมูลโค้ด C ที่คำนวณการเพิ่มความปลอดภัยมากเกินไปอย่างมีประสิทธิภาพโดยไม่ใช้คอมไพเลอร์ builtins หรือไม่

นี่คือฟังก์ชั่น C ที่เพิ่มintอีกอันหนึ่งซึ่งล้มเหลวหากเกิดโอเวอร์โฟลว์:

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;
}

น่าเสียดายที่GCC หรือ 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

รุ่นนี้ด้วย __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;
        }
}

ได้รับการปรับปรุงให้ดีขึ้น :

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

แต่ฉันอยากรู้ว่ามีวิธีการไม่ใช้ builtins ที่จะได้รับการจับคู่รูปแบบโดย GCC หรือ Clang

สิ่งที่ดีที่สุดที่ฉันได้รับหากคุณไม่สามารถเข้าถึงธงล้นของสถาปัตยกรรมคือการทำสิ่งต่างunsignedๆ แค่คิดเลขคณิตทุกบิตตรงนี้เราแค่สนใจบิตที่สูงที่สุดซึ่งเป็นบิตเครื่องหมายเมื่อตีความว่าเป็นค่าที่เซ็นชื่อ

(ทุกข้อผิดพลาดที่โมดูโล่ลงชื่อฉันไม่ได้ตรวจสอบเรื่องนี้อย่างเด็ดขาด แต่ฉันหวังว่าความคิดนั้นชัดเจน)

#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;
}

หากคุณพบรุ่นของการเพิ่มที่ไม่มี UB เช่นอะตอมมิกแอสเซมเบลอร์จะไม่มีสาขา (แต่มีคำนำหน้าล็อก)

#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;
}

ดังนั้นหากเรามีการดำเนินการดังกล่าว แต่ยิ่ง“ ผ่อนคลาย” มากขึ้นก็สามารถปรับปรุงสถานการณ์ให้ดียิ่งขึ้นไปอีก

Take3:ถ้าเราใช้ "cast" พิเศษจากผลลัพธ์ที่ไม่ได้ลงชื่อกับผลลัพธ์ที่ลงชื่อแล้วตอนนี้ไม่มีสาขา:

#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;
}

สถานการณ์ที่มีการดำเนินการที่ลงนามนั้นแย่กว่าที่ไม่ได้ลงนามมากและฉันเห็นเพียงรูปแบบเดียวสำหรับการเพิ่มที่ลงชื่อแล้วเฉพาะสำหรับเสียงดังกราวและเฉพาะเมื่อมีประเภทที่กว้างกว่า:

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;
    }
}

เสียงดังกราวให้เหมือนกันกับasm __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

มิฉะนั้นทางออกที่ง่ายที่สุดที่ฉันคิดได้คือ (โดยใช้อินเตอร์เฟสเป็น 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 และเสียงดังกราวสร้างคล้ายกันมากasm gcc ให้สิ่งนี้:

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

เราต้องการคำนวณผลรวมunsignedดังนั้นunsignedจะต้องสามารถแสดงค่าทั้งหมดintโดยไม่ต้องผสานเข้าด้วยกัน ในการแปลงผลลัพธ์จากunsignedเป็นintง่าย ๆ ตรงกันข้ามจะมีประโยชน์เช่นกัน โดยรวมแล้วจะถือว่าส่วนประกอบสองอย่าง

บนแพลตฟอร์มยอดนิยมทั้งหมดที่ผมคิดว่าเราสามารถแปลงจากunsignedไปintโดยการโอนง่ายเหมือนint sum = u;แต่เป็น Jens กล่าวถึงแม้ตัวแปรล่าสุดของมาตรฐาน C2x ช่วยให้สามารถเพิ่มสัญญาณ วิธีที่เป็นธรรมชาติที่สุดต่อไปคือการทำสิ่งนั้น: *(unsigned *)&sum = u;แต่ตัวแปรที่ไม่ใช่กับดักของการแพ็ดดิ้งนั้นอาจแตกต่างกันสำหรับประเภทที่เซ็นชื่อและไม่ได้ลงนาม ตัวอย่างข้างต้นเป็นไปอย่างยากลำบาก โชคดีที่ทั้ง gcc และ clang ช่วยให้การแปลงนี้ยุ่งยาก

PS ตัวแปรสองตัวข้างต้นไม่สามารถเปรียบเทียบได้โดยตรงเนื่องจากมีพฤติกรรมที่แตกต่างกัน คำถามแรกติดตามคำถามเดิมและไม่ปิดบัง*valueในกรณีที่มีการล้น ส่วนที่สองตามหลังคำตอบจาก Jensและมักจะปิดบังตัวแปรที่ชี้ไปตามพารามิเตอร์ตัวแรก แต่มันก็ไม่แตกกิ่งก้านสาขา

รุ่นที่ดีที่สุดที่ฉันจะได้รับคือ:

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;
}

ซึ่งผลิต:

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

ฉันสามารถรับคอมไพเลอร์เพื่อใช้ธงสัญญาณโดยสมมติว่า (และยืนยัน) การแสดงส่วนประกอบสองอย่างโดยไม่ต้องเติมเต็มไบต์ การใช้งานดังกล่าวควรทำให้เกิดพฤติกรรมที่ต้องการในบรรทัดที่มีคำอธิบายประกอบโดยความคิดเห็นแม้ว่าฉันจะไม่สามารถหาการยืนยันที่เป็นทางการเชิงบวกของข้อกำหนดนี้ในมาตรฐาน (และอาจไม่มี)

โปรดทราบว่ารหัสต่อไปนี้จะจัดการกับการเพิ่มจำนวนเต็มบวกเท่านั้น แต่สามารถขยายได้

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;
}

อัตราผลตอบแทนนี้ทั้งเสียงดังกราวและ GCC:

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