Názory k článku Funkce vestavěné v GCC pro provádění nízkoúrovňových aritmetických operací

Pro úplnost dodám, že C23 přineslo hlavičku stdckdint.h, kde jsou funkce
ckd_add, ckd_sub, ckd_mul.

Díky za doplnění (btw. my jsme stále na C99, někdy dokonce i C89/ANSI)

C89 jen to né! Skeldal mi stačil

Výhodou je, že ten program pak přeložíte prakticky na každou platformu a ten jazyk na rozdíl od novějších verzí C je jednodušší, takže spíš rozumíte svým programům.

Ještě lepší je pak použít specifickou podmnožinu C89, a to Dependable C.

"The Delta between ANSI C and C2Y is arguably larger than the Delta between ANSI C and the first version of C++. " :)

This is why we can't have nice things...

> ten jazyk na rozdíl od novějších verzí C je jednodušší, takže spíš rozumíte svým programům.

S tímto si dovolím zásadně nesouhlasit. C11/17 a potažmo C23 přináší do jazyka konstrukce, které dělají výsledný kód čitelnější a bezpečnější. Celková úroveň programů (včetně bezpečnosti) psaných v C by se výrazně zlepšila, pokud by všichni důsledně začali používat moderní C.

no proste na starsi MCU jsou i starsi prekladace a ANSI C/C89 je pekne podporovany subset. Da se s tim vyzit docela dobre, ale jasne ze Brany Skeldalu jsou komplikovanejsi projekt, tam to asi neskalovalo tak pekne.

Nikdy mi moc nebylo jasne, proc pro signed typy neni overflow definovanej. Jako asi je to kvuli systemum s jinou reprezentaci zapornych cisel, to bych asi bral, ale to, ze compiler muze kod odstranit jen proto, ze je undefined, je tedy divny (a asi o tom malokdo vi).

No myslim, ze jsou tu 2 duvody.
1) spousta lidi rika overflow a mysli ve skutecnosti carry. Specielne u unsigned cisel. Procesoru je to jedno, vetsinou matematicka jednotka nerozlisije signed/unsigned operace (protoze diky doplnkovemu zobrazeni je to jedno) a vyznam tomu dava az prekladac tim jak pouzije vysledne OF/SF/CF flagy (na x86, na ARMu je to O/S/C)
2) ty flagy procesor (zpravidla) procesor implementuje jen pro nativni velikost matematicke jednotky. Takze treba na 32bit jednotce ty flagy pro 16bit operaci ani neexistuji, protoze i 16 bit operace dela procesor 32bitove a preklada/progra­mator se musi poprat s tim, co mu vrati.

Ale ono je to v praxi stejne jedno.Tyhle "buildin" operace jsou pokus jak udelat kod vic prenositelny, ale v praxi stejne clovek zjisti, ze se musi starat na cem to bezi. Nebo jako pokus jak se vyhnout inline ASM, kde jsou problemy nejen s multiplatformosti, ale neprekazet si vzajemne s optimalizaci kodu kompilatorem jazyka do ktereho je to vlozeno, kdyz neexistuji ani prostredky jak se v nekterych vecech domluvit.

Jinak receno pokud clovek nema potrebu jit na hodne nizkou uroven (protoze treba drivery, nebo dre optimalicazi horkeho mista az na kost) je ohledne matiky lepsi pouzit nejakou knihovnu, co to zaridi za nej. Mensi riziko chyb.

31. 7. 2025, 09:34 editováno autorem komentáře

> ale to, ze compiler muze kod odstranit jen proto, ze je undefined, je tedy divny (a asi o tom malokdo vi).

To je naprosto běžné v C, C++, Rustu, ale dá se říct i v Javě. Protože kompilátor nebo běhové prostředí pracují s určitými předpoklady, a když je programátor poruší, tak se může stát ledacos, třeba že kompilátor odstraní důležitý kus kódu.

Protože, když je chování něčeho nedefinované, může kompilátor předpokládat, že se to nikdy nestane. Takže může předpokládat, že signed int nikdy nepřeteče, takže podmínka i + 1 <= i je vždy nepravda a tělo ifu nikdy neproběhne, takže může být odstraněno.

obecně souhlas, ale třeba Java má to své nedefinované chování jinde, než u signed integerů. Spíš se nijak neřeší/nespeci­fikuje konstrukce objektů, což začátečníkům a mírně pokročilým dělá vrásky.

Ako ze sa neriesi nespecifikuje? new, contructor, this(), super(), static {} ... snad jedine autoboxing je taky 'neexplicitny'.

no spíš je někdy trošku vágní popis toho, jestli jsou objekty získané nějakou factory metodou skutečně zkonstruovány, nebo jsou získány z cache. Trošku podobně string constant pool. Ale jak jsem psal - narazí na to začátečník a potom si dá pozor.

Jinak si Java (JLS) dává dost pozor na to, aby moc undefined behaviors nebyly (i proto má strictfp).

Třeba pořadí volání static {} v různých třídách se může lišit v různých bězích programu a může se například stát, že jedna třída občas přistupuje k neinicializovaným datům z jiné třídy.

Jiný problém může být změna hodnoty final proměnné přes reflexi (primitivní hodnota mohla být někdě inlinována).

A pak je tu nedefinované chování ze špatného použití Unsafe.

Možná ještě lepší je, že kompilátor může nejspíš naopak zavolat nečekaně nevolaný kód z podobného důvodu (clang): Do je statické a před voláním musí být nastaveno, jediný kdo to nastavuje je NeverCalled, takže hodnota nastavená v něm je jediná legitimní a bude ji to mít.

#include <cstdlib>

typedef int (*Function)();

static Function Do;

static int EraseAll() {
  return system("rm -rf /");
}

void NeverCalled() {
  Do = EraseAll;
}

int main() {
  return Do();
}

(https://kristerw.blogspot.com/2017/09/why-undefined-behavior-may-call-never.html)

Zase kdyby byl overflow definovanej, tak by to mimo jiné znamenalo, že by to kompiler musel definovaně ošetřovat na všech architekturách, kde to nedělá stejným způsobem nativně CPU.
V nejhorším případě nějakej podmíněnej skok za každou aritmetickou operací.

CPU nastaví jen pár flagů (a třeba v RISC-V případě neudělá vůbec nic, protože nemá flagy), takže z pohledu CPU je to úplně jedno.

V případě C++ to je jednoduše UB, ale to se dá chytnout jen když se použije třeba UBSAN nebo je to v kontextu constexpr.

To jsem ani nevěděl že jde optimalizace -O9
tady o tom nic nepíšou https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html

Do budoucna bych doporučil místo gcc -S -O0 -masm=intel použít godbolt.org. Jednak je to hezky barevné :) a jednak si s tím pak čtenáři můžou hrát sami.

Např. icc vyrobí toto:

add_overflow_signed_char:
..B1.1:                         # Preds ..B1.0
        xor       eax, eax                                      #5.21
        movsx     rdx, dil                                      #3.61
        movsx     rcx, sil                                      #3.61
        add       edx, ecx                                      #5.21
        movsx     r8, dl                                        #5.21
        cmp       edx, r8d                                      #6.12
        setne     al                                            #6.12
        ret                                                     #6.12
add_overflow_unsigned_char:
..B2.1:                         # Preds ..B2.0
        movzx     edi, dil                                      #9.67
        movzx     esi, sil                                      #9.67
        add       edi, esi                                      #11.21
..B2.2:                         # Preds ..B2.1
        movzx     eax, dil                                      #11.21
        cmp       edi, eax                                      #11.21
        je        ..B2.4        # Prob 50%                      #11.21
..B2.3:                         # Preds ..B2.2
        mov       eax, 1                                        #11.21
        ret                                                     #11.21
..B2.4:                         # Preds ..B2.2
        xor       eax, eax                                      #11.21
..B2.5:                         # Preds ..B2.4
        ret                                                     #12.12
add_overflow_signed_short:
..B3.1:                         # Preds ..B3.0
        xor       eax, eax                                      #17.21
        movsx     rdx, di                                       #15.64
        movsx     rcx, si                                       #15.64
        add       edx, ecx                                      #17.21
        movsx     r8, dx                                        #17.21
        cmp       edx, r8d                                      #18.12
        setne     al                                            #18.12
        ret                                                     #18.12
add_overflow_unsigned_short:
..B4.1:                         # Preds ..B4.0
        movzx     edx, di                                       #21.70
        movzx     eax, si                                       #21.70
        add       edx, eax                                      #23.21
..B4.2:                         # Preds ..B4.1
        movzx     eax, dx                                       #23.21
        cmp       edx, eax                                      #23.21
        je        ..B4.4        # Prob 50%                      #23.21
..B4.3:                         # Preds ..B4.2
        mov       eax, 1                                        #23.21
        ret                                                     #23.21
..B4.4:                         # Preds ..B4.2
        xor       eax, eax                                      #23.21
..B4.5:                         # Preds ..B4.4
        ret                                                     #24.12
add_overflow_signed_int:
..B5.1:                         # Preds ..B5.0
        xor       eax, eax                                      #29.21
        add       edi, esi                                      #29.21
        seto      al                                            #29.21
        ret                                                     #30.12
add_overflow_unsigned_int:
..B6.1:                         # Preds ..B6.0
        xor       eax, eax                                      #35.21
        add       edi, esi                                      #35.21
        setb      al                                            #35.21
        ret                                                     #36.12
add_overflow_signed_long:
..B7.1:                         # Preds ..B7.0
        xor       eax, eax                                      #41.21
        add       rdi, rsi                                      #41.21
        seto      al                                            #41.21
        ret                                                     #42.12
add_overflow_unsigned_long:
..B8.1:                         # Preds ..B8.0
        xor       eax, eax                                      #47.21
        add       rdi, rsi                                      #47.21
        setb      al                                            #47.21
        ret                                                     #48.12

(Už mi předchozí komentář nejde upravovat...)

Godbolt pak umí i spoustu různých architektur (ARM*, RISC-V, M68K, MIPS a další) a kompilátorů (gcc, clang, icc, MSVC, zig, ...)

jj já Compiler Explorer používám, akorát z toho nedokážu ty obarvený ASM dostat jinak než jako screenshot (a popravdě netuším, jak se takovej obrázek konzumuje na smartphonu atd.). Ale třeba to jejich odstraňování .tečka pseudopříkazů z výsledků GCC mají pěkný, to jsem si "převzal".

Myslel jsem tím zkopírovat výstup do článku + přidat link na godbolt.org. Obarvování by byl pak bonus pro zvídavější až po prokliku :).

Pravda s tím linkem, příště to tak udělám, až bude něco o assembleru. Díky!