Насыщающая оптимизация добавления в avr-gcc

Вы можете использовать встроенный gcc __builtin_constant_p для возврата к реализации без asm для постоянного случая:

(божий болт)

uint8_t saturating_add_non_asm(uint8_t a, uint8_t b) {
    uint8_t temp = a + b;
    if (temp < a)
        return 0xFF;
    return temp;
}

uint8_t saturating_add(uint8_t a, uint8_t b) {
    if (__builtin_constant_p(a) && __builtin_constant_p(b)) {
        return saturating_add_non_asm(a, b);
    }
    asm (
        "add %[a], %[b]\n\t"
        "brcc no_overflow_%=\n\t"
        "ldi %[a], 255\n\t"
        "no_overflow_%=:"
        : [a] "+r" (a)
        : [b] "r" (b)
        : "cc"
    );
    return a;
}

Кто-нибудь смог заставить avr-gcc правильно оптимизировать это без встроенной сборки?

Да. Кажется, лучший код (и самый простой) код, который вы получаете с помощью поддержки фиксированной точки согласно ISO/IEC TR 18037 «Встроенный C»:

→ божий болт

#include <stdint.h>
#include <stdfix.h>

static inline __attribute__((always_inline))
uint8_t addu8_sat (uint8_t a, uint8_t b)
{
    unsigned short sat fract ha = uhrbits (a);
    unsigned short sat fract hb = uhrbits (b);
    return bitsuhr (ha + hb);
}

static inline __attribute__((always_inline))
int8_t addi8_sat (int8_t a, int8_t b)
{
    short sat fract ha = hrbits (a);
    short sat fract hb = hrbits (b);
    return bitshr (ha + hb);
}

uint8_t test_u8 (uint8_t a, uint8_t b)
{
    return addu8_sat (addu8_sat (a, b), 10);
}

int8_t test_i8 (int8_t a, int8_t b)
{
    return addi8_sat (addi8_sat (a, b), 10);
}

Давайте посмотрим на ассемблерный код, сгенерированный с помощью

$ avr-gcc -Os sat.c -std=gnu99 -S -dp

test_u8:
    add r24,r22  ;  9   [c=4 l=3]  usadduqq3/0
    brcc 0f 
    sbc r24,r24
    0:  
    subi r24,-10     ;  18  [c=4 l=3]  usadduqq3/1
    brcs 0f 
    ldi r24,0xff
    0:  
    ret      ;  24  [c=0 l=1]  return

test_i8:
    add r24,r22  ;  9   [c=4 l=5]  ssaddqq3/0
    brvc 0f 
    ldi r24,0x80
    sbrs r22,7
    dec r24
    0:  
    subi r24,-10     ;  18  [c=4 l=3]  ssaddqq3/1
    brvc 0f 
    ldi r24,0x7f
    0:  
    ret      ;  24  [c=0 l=1]  return

Таким образом, он использует 3 инструкции, за исключением случая со знаком и когда ни одно дополнение не известно во время компиляции. Хитрость заключается в том, что в этом случае насыщенность зависит от знака слагаемого, который неизвестен.

При этом используется тот факт, что сложения Q-формата являются двоичными, как и сложения целых чисел, поэтому реализации в основном связаны с переводом между двумя мирами. Обратите внимание, что это не работает для умножения или деления. А смешивать знаковые и беззнаковые сложнее, поскольку они не коммутируют.

Поддержка фиксированной точки была добавлена ​​в avr-gcc v4.8 как часть GNU-C99.

К вашему сведению, вот соответствующий код для вычитания:

static inline __attribute__((always_inline))
uint8_t subu8_sat (uint8_t a, uint8_t b)
{
    unsigned short sat fract ha = uhrbits (a);
    unsigned short sat fract hb = uhrbits (b);
    return bitsuhr (ha - hb);
}

static inline __attribute__((always_inline))
int8_t subi8_sat (int8_t a, int8_t b)
{
    short sat fract ha = hrbits (a);
    short sat fract hb = hrbits (b);
    return bitshr (ha - hb);
}

uint8_t test_sub_u8 (uint8_t a, uint8_t b)
{
    return subu8_sat (subu8_sat (a, b), 10);
}

int8_t test_sub_i8 (int8_t a, int8_t b)
{
    return subi8_sat (subi8_sat (a, b), 10);
}

test_sub_u8:
    sub r24,r22  ;  9   [c=4 l=3]  ussubuqq3/0
    brcc 0f 
    clr r24 
    0:  
    subi r24,10  ;  18  [c=4 l=3]  ussubuqq3/1
    brcc 0f 
    clr r24 
    0:  
    ret

test_sub_i8:
    sub r24,r22  ;  9   [c=4 l=5]  sssubqq3/0
    brvc 0f 
    ldi r24,0x7f
    sbrs r22,7
    inc r24
    0:  
    subi r24,10  ;  18  [c=4 l=3]  sssubqq3/1
    brvc 0f 
    ldi r24,0x80
    0:  
    ret

И последнее замечание: случай с константой немного сложен, поскольку прибавление 128 — это не то же самое, что вычитание -128, поэтому необходимо соблюдать особую осторожность.

Кроме того, в случае беззнаковой константы используется обратный флаг C, поскольку он вычитает отрицательное значение, хотя на самом деле он реализуется для сложения положительного значения.