(A + B + C) ≠ (A + C + B) ve derleyici yeniden sıralama

İki 32 bitlik tamsayı eklemek, tamsayı taşmasına neden olabilir:

uint64_t u64_z = u32_x + u32_y;

32 bitlik tam sayılardan biri önce dönüştürülür veya 64 bitlik bir tam sayıya eklenirse bu taşma önlenebilir.

uint64_t u64_z = u32_x + u64_a + u32_y;

Ancak, derleyici eklemeyi yeniden düzenlemeye karar verirse:

uint64_t u64_z = u32_x + u32_y + u64_a;

tamsayı taşması yine de olabilir.

Derleyicilerin böyle bir yeniden sıralama yapmasına izin veriliyor mu yoksa sonuç tutarsızlığını fark edip ifade sırasını olduğu gibi tutmaları için onlara güvenebilir miyiz?

İyileştirici böyle bir yeniden sıralama yaparsa, yine de C spesifikasyonuna bağlıdır, bu nedenle böyle bir yeniden sıralama şöyle olur:

uint64_t u64_z = (uint64_t)u32_x + (uint64_t)u32_y + u64_a;

Gerekçe:

İle başlıyoruz

uint64_t u64_z = u32_x + u64_a + u32_y;

Ekleme soldan sağa gerçekleştirilir.

Tamsayı yükseltme kuralları, orijinal ifadedeki ilk eklemede u32_xyükseltileceğini belirtir uint64_t. İkinci ilavede, u32_yayrıcauint64_t .

Yani, C spesifikasyonu ile uyumlu olması için, herhangi optimizasyoncusu tanıtmalıdır u32_xve u32_y64'e imzasız değerleri ısırdı. Bu, bir oyuncu eklemeye eşdeğerdir. (Gerçek optimizasyon C düzeyinde yapılmaz, ancak C notasyonunu kullanıyorum çünkü bu, anladığımız bir gösterimdir.)

Bir derleyicinin yalnızca sanki kuralına göre yeniden sipariş vermesine izin verilir . Diğer bir deyişle, yeniden sıralama her zaman belirtilen sıralamayla aynı sonucu verecekse, buna izin verilir. Aksi takdirde (örneğinizdeki gibi), hayır.

Örneğin, aşağıdaki ifade verildiğinde

i32big1 - i32big2 + i32small

Büyük ancak benzer olduğu bilinen iki değeri çıkarmak ve ancak o zaman diğer küçük değeri eklemek için (böylece herhangi bir taşmayı önleyerek) dikkatlice yapılandırılmış olan derleyici, aşağıdakileri yeniden sıralamayı seçebilir:

(i32small - i32big2) + i32big1

ve hedef platformun sorunları önlemek için sarmalı iki tamamlayıcı aritmetik kullanması gerçeğine güvenin. (Böyle bir yeniden sıralama, derleyiciye kayıtlar için basılırsa ve i32smallzaten bir kayıtta varsa mantıklı olabilir ).

C, C ++ ve Objective-C'de "sanki" kuralı vardır: Hiçbir uyumlu program farkı anlayamadığı sürece derleyici istediği her şeyi yapabilir.

Bu dillerde a + b + c, (a + b) + c ile aynı şekilde tanımlanır. Bunun ile örneğin a + (b + c) arasındaki farkı anlayabilirseniz, derleyici sırayı değiştiremez. Farkı anlayamazsanız, derleyici sırayı değiştirmekte özgürdür, ancak sorun değil, çünkü farkı anlayamazsınız.

Örneğinizde, b = 64 bit, a ve c 32 bit ile, derleyicinin (b + a) + c veya hatta (b + c) + a'yı değerlendirmesine izin verilir, çünkü farkı anlayamazsınız, ancak (a + c) + b değil çünkü farkı anlayabilirsiniz.

Diğer bir deyişle, derleyicinin, kodunuzun olması gerekenden farklı davranmasını sağlayan hiçbir şey yapmasına izin verilmez. Yaratabileceği düşünüyorum, ya da bunu üretmek gerektiğini düşünüyorum o kodu üretmek için gerekli değildir, ancak kod olacak size gerektiği tam olarak sonuçlar verir.

Standartlardan alıntı yapmak :

[Not: Operatörler, yalnızca operatörlerin gerçekten ilişkisel veya değişmeli olduğu durumlarda olağan matematik kurallarına göre yeniden gruplandırılabilir.7 Örneğin, aşağıdaki parçada int a, b;

/∗ ... ∗/
a = a + 32760 + b + 5;

ifade ifadesi tam olarak aynı şekilde davranır

a = (((a + 32760) + b) + 5);

bu operatörlerin ilişkilendirilebilirliği ve önceliği nedeniyle. Böylece, toplamın sonucu (a + 32760) daha sonra b'ye eklenir ve bu sonuç daha sonra 5'e eklenir ve bu da a'ya atanan değerle sonuçlanır. Taşmaların bir istisna oluşturduğu ve int ile temsil edilebilen değer aralığının [-32768, + 32767] olduğu bir makinede, uygulama bu ifadeyi şu şekilde yeniden yazamaz:

a = ((a + b) + 32765);

çünkü a ve b için değerler sırasıyla -32754 ve -15 olsaydı, a + b toplamı bir istisna üretirken orijinal ifade olmazdı; ne de ifade şu şekilde yeniden yazılamaz:

a = ((a + 32765) + b);

veya

a = (a + (b + 32765));

a ve b için değerler sırasıyla 4 ve -8 veya -17 ve 12 olabileceğinden, ancak taşmaların bir istisna oluşturmadığı ve taşma sonuçlarının tersine çevrilebildiği bir makinede, yukarıdaki ifade ifadesi yukarıdaki yollardan herhangi biri uygulama tarafından yeniden yazılmalıdır çünkü aynı sonuç ortaya çıkacaktır. - son not]

Derleyicilerin böyle bir yeniden sıralama yapmasına izin veriliyor mu yoksa sonuç tutarsızlığını fark edip ifade sırasını olduğu gibi tutmaları için onlara güvenebilir miyiz?

Derleyici yalnızca aynı sonucu verirse yeniden sıralayabilir - burada, gözlemlediğiniz gibi, vermez.

İsterseniz, tüm argümanları std::common_typeeklemeden önce destekleyen bir işlev şablonu yazmak mümkündür - bu güvenli olur ve argüman sırasına veya manuel atamaya bağlı değildir, ancak oldukça kullanışsızdır.

Bit genişliğine bağlıdır unsigned/int.

Aşağıdaki 2 aynı değildir ( unsigned <= 32bit olduğunda ). u32_x + u32_y0 olur.

u64_a = 0; u32_x = 1; u32_y = 0xFFFFFFFF;
uint64_t u64_z = u32_x + u64_a + u32_y;
uint64_t u64_z = u32_x + u32_y + u64_a;  // u32_x + u32_y carry does not add to sum.

Aynıdırlar ( unsigned >= 34bit olduğunda ). Tamsayı promosyonlarının neden olduğu u32_x + u32_y eklemenin 64 bit matematikte gerçekleşmesine . Düzen alakasız.

UB'dir ( unsigned == 33bit olduğunda ). Tamsayı yükseltmeleri, eklemenin işaretli 33 bit matematikte gerçekleşmesine neden oldu ve işaretli taşma UB'dir.

Derleyicilerin böyle bir yeniden sıralama yapmasına izin verilir mi?

(32 bit matematik): Yeniden sipariş evet, ama aynı sonuçlar çok değil, gerçekleşmesi gerekir o yeniden sipariş OP önermektedir. Aşağıda aynı

// Same
u32_x + u64_a + u32_y;
u64_a + u32_x + u32_y;
u32_x + (uint64_t) u32_y + u64_a;
...

// Same as each other below, but not the same as the 3 above.
uint64_t u64_z = u32_x + u32_y + u64_a;
uint64_t u64_z = u64_a + (u32_x + u32_y);

... sonuç tutarsızlığını fark etmeleri ve ifade sırasını olduğu gibi tutmaları için onlara güvenebilir miyiz?

Güvenin evet, ancak OP'nin kodlama hedefi kristal netliğinde değil. Meli u32_x + u32_ykatkıda taşımak? OP bu katkıyı istiyorsa, kod

uint64_t u64_z = u64_a + u32_x + u32_y;
uint64_t u64_z = u32_x + u64_a + u32_y;
uint64_t u64_z = u32_x + (u32_y + u64_a);

Ama değil

uint64_t u64_z = u32_x + u32_y + u64_a;