Il cast del puntatore interrompe la regola di aliasing rigorosa?

Question

Questa è l'implementazione radice quadrata veloce inversa da Quake III Arena:

float Q_rsqrt(float number) 
{ 
     long i; 
     float x2, y; 
     const float threehalfs = 1.5F; 

     x2 = number * 0.5F; 
     y = number; 
     i = * (long *) &y;      // evil floating point bit level hacking 
     i = 0x5f3759df - (i >> 1);    // what? 
     y = * (float *) &i; 
     y = y * (threehalfs - (x2 * y * y)); // 1st iteration 
//  y = y * (threehalfs - (x2 * y * y)); // 2nd iteration, this can be removed 

     return y; 
} 

ho notato che long inti assume il valore Dereferenced all'indirizzo (cast a un long *) di galleggiantey. Il codice esegue quindi le operazioni su i prima di memorizzare il valore di riferimento sull'indirizzo (assegnato a float *) di i in .

Questo interromperà la rigida regola di aliasing dal i non è dello stesso tipo di ?

Penso che forse non lo è poiché il valore è dereferenziato e copiato; quindi le operazioni vengono eseguite su una copia anziché sull'originale.

Answer 1

Sì, questo codice è gravemente danneggiato e richiama un comportamento non definito. In particolare, si noti queste due linee:

y = number; 
    i = * (long *) &y;      // evil floating point bit level hacking 

Poiché l'oggetto *(long *)&y è digitare long, il compilatore è libera di assumere non può alias un oggetto di tipo float; quindi, il compilatore potrebbe riordinare queste due operazioni l'una rispetto all'altra.

Per risolvere il problema, è necessario utilizzare un raccordo.

Answer 2

i = * (long *) &y;

Questo rompe aliasing regole e invoca pertanto un comportamento indefinito.

Si accede all'oggetto con un tipo diverso da float o una variante firmata/non firmata di char.

y = * (float *) &i;

Questa dichiarazione di cui sopra le regole anche le pause aliasing.

Answer 3

Sì, interrompe le regole di aliasing.

Nella moderna C, è possibile modificare i = * (long *) &y; a:

i = (union { float f; long l; }) {y} .l; 

e y = * (float *) &i; a:

y = (union { long l; float f; }) {i} .f; 

Purché si disponga di garanzie che, nell'attuazione C in uso, long e float hanno adeguato dimensioni e rappresentazioni, quindi il comportamento è definito dallo standard C: i byte dell'oggetto di un tipo verranno reinterpretati come l'altro tipo.

Answer 4

Sì, interrompe le regole di aliasing.

La correzione più pulita per le cose come i = * (long *) &y; sarebbe questo:

memcpy(&i, &y, sizeof(i)); // assuming sizeof(i) == sizeof(y) 

Evita problemi con l'allineamento e aliasing. E con l'ottimizzazione abilitata, la chiamata a memcpy() dovrebbe essere normalmente sostituita con poche istruzioni.

Proprio come qualsiasi altro metodo suggerito, questo approccio non risolve alcun problema relativo alle rappresentazioni di trap. Sulla maggior parte delle piattaforme, tuttavia, non ci sono rappresentazioni di trap nei numeri interi e se si conosce il formato in virgola mobile è possibile evitare rappresentazioni di trap di formato in virgola mobile, se ce ne sono.