Wird beim Verwenden von Zeigern auf Strukturelemente strikter Alias ​​angewendet?

Question

Führt der folgende Snippet test_func undefiniertes Verhalten unter den strengen Aliasregeln aus, wenn sich die beiden Argumente teilweise überschneiden?

Das ist das zweite Argument ein Mitglied der ersten ist:

#include <stdio.h> 

typedef struct 
{ 
    //... Other fields 
    int x; 
    //... Other fields 
} A; 

int test_func(A *a, int *x) 
{ 
    a->x = 0; 
    *x = 1; 
    return a->x; 
} 

int main() 
{ 
    A a = {0}; 

    printf("%d\n", test_func(&a, &a.x)); 

    return 0; 
} 

Ist der Compiler test_func zu denken erlaubt wird nur 0 zurück, basierend auf der Annahme, dass A* und int* wird nicht Alias? also kann die *x das Mitglied nicht überschreiben?

Answer 1

Dies ist keine Verletzung des strengen Aliasing. Die strenge Aliasing-Regel besagt (vereinfacht), dass Sie nur mit einem Lvalue-Ausdruck eines kompatiblen Typs auf den Wert eines Objekts zugreifen können. In diesem Fall ist das Objekt, auf das Sie zugreifen, das Element x von maina Variable. Dieses Mitglied hat den Typ int. Und der Ausdruck, den Sie verwenden, um darauf zuzugreifen (*x), hat auch den Typ int. Also, es gibt kein Problem.

Sie können strenges Aliasing mit restrict verwechseln. Wenn Sie das Schlüsselwort restrict in der Deklaration eines der Zeigerparameter verwendet hätten, wäre der Code ungültig, weil restrict Sie daran hindert, verschiedene Zeiger für den Zugriff auf dasselbe Objekt zu verwenden - dies ist jedoch ein anderes Problem als das strikte Aliasing.

Answer 2

Strict aliasing bezieht sich auf, wenn ein Zeiger in einen anderen Zeigertyp konvertiert wird, nach dem auf den Inhalt zugegriffen wird. Strenges Aliasing bedeutet, dass die beteiligten spitzen Typen kompatibel sein müssen. Das trifft hier nicht zu.

Es gibt jedoch den Begriff Pointer Aliasing, was bedeutet, dass zwei Zeiger auf denselben Speicher verweisen können. Der Compiler darf nicht davon ausgehen, dass dies hier der Fall ist. Wenn es Optimierungen wie die von Ihnen beschriebenen durchführen möchte, müsste es möglicherweise Maschinencode hinzufügen, der die Zeiger miteinander vergleicht, um festzustellen, ob sie identisch sind oder nicht. Was an sich die Funktion etwas langsamer machen würde.

Um den Compiler zu helfen, solchen Code zu optimieren, können Sie die Zeiger als restrict deklarieren, was dem Compiler mitteilt, dass der Programmierer garantiert, dass die Zeiger nicht auf den gleichen Speicher zeigen.

Ihre Funktion mit gcc -O3 Ergebnisse in dieser Maschinencode kompiliert:

0x00402D09 mov $0x1,%edx 

was im Grunde bedeutet, dass die ganze Funktion ersetzt wurde (inlined) mit "a.x auf 1 gesetzt".

Aber wenn ich Ihre Funktion als

int test_func(A* restrict a, int* restrict x) 
{ 
    a->x = 0; 
    *x = 1; 
    return a->x; 
} 

neu schreiben und kompilieren mit gcc -O3, tut es 0 zurück, weil ich jetzt den Compiler gesagt haben, dass a->X und x nicht auf dem gleichen Speicher zeigen, so kann es Nehmen Sie an, dass *x = 1; das Ergebnis nicht beeinflusst und überspringen Sie die Zeile *x = 1; oder Sequenz vor der Zeile a->x = 0;.

Der optimierte Maschinencode der Restricted-Version überspringt tatsächlich den gesamten Funktionsaufruf, da er weiß, dass der Wert gemäß Ihrer Initialisierung bereits 0 ist.

Dies ist natürlich ein Fehler, aber der Programmierer ist dafür verantwortlich, für die sorglose Verwendung von restrict.