Gewerkschaften und Typ-Punning

Ich habe eine Weile gesucht, kann aber keine klare Antwort finden.

Viele Leute sagen, dass die Verwendung von Gewerkschaften zum Schreiben von Wortspielen undefiniert und eine schlechte Praxis ist. Warum ist das? Ich kann keinen Grund erkennen, warum es etwas Undefiniertes tun würde, wenn man bedenkt, dass sich der Speicher, in den Sie die Originalinformationen schreiben, nicht von selbst ändert (es sei denn, es liegt außerhalb des Gültigkeitsbereichs des Stapels, aber das ist kein Gewerkschaftsproblem , das wäre schlechtes Design).

Die Leute zitieren die strenge Aliasing-Regel, aber das scheint mir so, als würde man sagen, dass man es nicht kann, weil man es nicht kann.

Was ist der Sinn einer Gewerkschaft, wenn sie kein Wortspiel tippt? Ich habe irgendwo gesehen, dass sie verwendet werden sollen, um denselben Speicherort für unterschiedliche Informationen zu unterschiedlichen Zeiten zu verwenden, aber warum nicht einfach die Informationen löschen, bevor sie erneut verwendet werden?

Zusammenfassen:

1. Warum ist es schlecht, Gewerkschaften für Typ Punning zu verwenden?
2. Was ist der Sinn von ihnen, wenn nicht das?

Zusätzliche Informationen: Ich verwende hauptsächlich C ++, möchte aber darüber und über C Bescheid wissen. Insbesondere verwende ich Gewerkschaften, um zwischen Floats und dem rohen Hex zu konvertieren und über den CAN-Bus zu senden.

Um es noch einmal zu wiederholen, ist es in C (aber nicht in C ++) vollkommen in Ordnung, durch Gewerkschaften zu tippen. Im Gegensatz dazu verstößt die Verwendung von Zeigerumwandlungen gegen das strikte C99-Aliasing und ist problematisch, da unterschiedliche Typen unterschiedliche Ausrichtungsanforderungen haben können und Sie einen SIGBUS auslösen können, wenn Sie es falsch machen. Bei Gewerkschaften ist dies nie ein Problem.

Die relevanten Zitate aus den C-Standards sind:

C89 Abschnitt 3.3.2.3 §5:

Wenn auf ein Mitglied eines Vereinigungsobjekts zugegriffen wird, nachdem ein Wert in einem anderen Mitglied des Objekts gespeichert wurde, ist das Verhalten implementierungsdefiniert

C11 Abschnitt 6.5.2.3 §3:

Ein Postfix-Ausdruck gefolgt von. Operator und Bezeichner bezeichnen ein Mitglied einer Struktur oder eines Vereinigungsobjekts. Der Wert ist der des benannten Mitglieds

mit folgender Fußnote 95:

Wenn das zum Lesen des Inhalts eines Vereinigungsobjekts verwendete Element nicht mit dem zuletzt zum Speichern eines Werts im Objekt verwendeten Element identisch ist, wird der entsprechende Teil der Objektdarstellung des Werts als Objektdarstellung im neuen Typ als neu interpretiert beschrieben in 6.2.6 (ein Prozess, der manchmal als "Typ Punning" bezeichnet wird). Dies könnte eine Trap-Darstellung sein.

Dies sollte völlig klar sein.

James ist verwirrt, weil C11 Abschnitt 6.7.2.1 §16 lautet

Der Wert von höchstens einem der Mitglieder kann jederzeit in einem Gewerkschaftsobjekt gespeichert werden.

Dies scheint widersprüchlich, ist es aber nicht: Im Gegensatz zu C ++ gibt es in C kein Konzept für ein aktives Mitglied und es ist vollkommen in Ordnung, über einen Ausdruck eines inkompatiblen Typs auf den einzelnen gespeicherten Wert zuzugreifen.

Siehe auch C11 Anhang J.1 §1:

Die Werte von Bytes, die anderen Gewerkschaftsmitgliedern als dem zuletzt in [gespeicherten entsprechen, sind nicht angegeben].

In C99 wurde dies früher gelesen

Der Wert eines anderen Gewerkschaftsmitglieds als des zuletzt in [gespeicherten] ist nicht angegeben.

Das war falsch. Da der Anhang nicht normativ ist, hat er seinen eigenen TC nicht bewertet und musste bis zur nächsten Standardrevision warten, um behoben zu werden.

GNU-Erweiterungen auf Standard-C ++ (und auf C90) erlauben explizit Typ-Punning mit Gewerkschaften . Andere Compiler, die keine GNU-Erweiterungen unterstützen, unterstützen möglicherweise auch Union-Type-Punning, sind jedoch nicht Teil des Basissprachenstandards.

Der ursprüngliche Zweck der Gewerkschaften bestand darin, Platz zu sparen, wenn Sie in der Lage sein möchten, verschiedene Typen darzustellen. Dies wird als Variantentyp bezeichnet. Siehe Boost.Variant als gutes Beispiel dafür.

Die andere gebräuchliche Verwendung ist Typ-Punning. Die Gültigkeit dieses Dokuments wird diskutiert, aber praktisch die meisten Compiler unterstützen es. Wir können sehen, dass gcc seine Unterstützung dokumentiert :

Die Praxis, von einem anderen Gewerkschaftsmitglied zu lesen als dem, an das zuletzt geschrieben wurde („Typ-Punning“ genannt), ist üblich. Selbst bei -fstrict-aliasing ist Typ-Punning zulässig, vorausgesetzt, auf den Speicher wird über den Union-Typ zugegriffen. Der obige Code funktioniert also wie erwartet.

Beachten Sie, dass auch bei -fstrict-aliasing Typ-Punning zulässig ist, was darauf hinweist, dass ein Aliasing-Problem vorliegt .

Pascal Cuoq hat argumentiert, dass der Fehlerbericht 283 klarstellte, dass dies in C zulässig war. Der Fehlerbericht 283 fügte die folgende Fußnote als Klarstellung hinzu:

Wenn das Element, das für den Zugriff auf den Inhalt eines Vereinigungsobjekts verwendet wird, nicht mit dem Element identisch ist, das zuletzt zum Speichern eines Werts im Objekt verwendet wurde, wird der entsprechende Teil der Objektdarstellung des Werts als Objektdarstellung im neuen Typ als neu interpretiert beschrieben in 6.2.6 (ein Prozess, der manchmal als "Typ Punning" bezeichnet wird). Dies könnte eine Trap-Darstellung sein.

in C11 wäre das eine Fußnote 95.

Obwohl im std-discussionMail-Gruppenthema Typ Punning über eine Union das Argument vorgebracht wird, ist dies unterbestimmt, was vernünftig erscheint, da DR 283kein neuer normativer Wortlaut hinzugefügt wurde, sondern nur eine Fußnote:

Dies ist meiner Meinung nach ein unterbestimmter semantischer Sumpf in C. Zwischen den Implementierern und dem C-Ausschuss wurde kein Konsens darüber erzielt, welche Fälle genau das Verhalten definiert haben und welche nicht [...]

In C ++ ist unklar, ob Verhalten definiert ist oder nicht .

Diese Diskussion behandelt auch mindestens einen Grund, warum es unerwünscht ist, Typ-Punning durch eine Gewerkschaft zuzulassen:

[...] Die Regeln des C-Standards brechen die typbasierten Alias-Analyseoptimierungen, die aktuelle Implementierungen durchführen.

es bricht einige Optimierungen. Das zweite Argument dagegen ist, dass die Verwendung von memcpy identischen Code generieren sollte und Optimierungen und genau definiertes Verhalten nicht beeinträchtigt, zum Beispiel Folgendes:

std::int64_t n;
std::memcpy(&n, &d, sizeof d);

an Stelle von:

union u1
{
  std::int64_t n;
  double d ;
} ;

u1 u ;
u.d = d ;

und wir können sehen, dass mit godbolt identischer Code generiert wird und das Argument wird gemacht, wenn Ihr Compiler keinen identischen Code generiert, sollte dies als Fehler betrachtet werden:

Wenn dies für Ihre Implementierung zutrifft, empfehle ich Ihnen, einen Fehler zu melden. Es scheint mir eine schlechte Idee zu sein, echte Optimierungen (alles, was auf typbasierter Alias-Analyse basiert) zu brechen, um Leistungsprobleme mit einem bestimmten Compiler zu umgehen.

Der Blog-Beitrag Type Punning, Strict Aliasing und Optimization kommt ebenfalls zu einem ähnlichen Ergebnis.

Die Diskussion über undefiniertes Verhalten in der Mailingliste: Geben Sie punning ein, um das Kopieren zu vermeiden .

Es ist legal in C99:

Aus dem Standard: 6.5.2.3 Struktur und Gewerkschaftsmitglieder

Wenn das Element, das für den Zugriff auf den Inhalt eines Vereinigungsobjekts verwendet wird, nicht mit dem Element identisch ist, das zuletzt zum Speichern eines Werts im Objekt verwendet wurde, wird der entsprechende Teil der Objektdarstellung des Werts als Objektdarstellung im neuen Typ als neu interpretiert beschrieben in 6.2.6 (ein Prozess, der manchmal als "Typ Punning" bezeichnet wird). Dies könnte eine Trap-Darstellung sein.

KURZE ANTWORT: Typ Punning kann unter bestimmten Umständen sicher sein. Auf der anderen Seite scheint es, obwohl es eine sehr bekannte Praxis zu sein scheint, dass Standard nicht sehr daran interessiert ist, sie offiziell zu machen.

Ich werde nur über C sprechen (nicht über C ++).

1. TYP PUNNING und DIE STANDARDS

Wie bereits erwähnt, ist das Typ-Punning im Standard C99 und auch in C11 in Unterabschnitt 6.5.2.3 zulässig . Ich werde jedoch Fakten mit meiner eigenen Wahrnehmung des Problems umschreiben:

• In Abschnitt 6.5 der Standarddokumente C99 und C11 wird das Thema Ausdrücke behandelt .
• Der Unterabschnitt 6.5.2 bezieht sich auf Postfix-Ausdrücke .
• Der Unterabschnitt 6.5.2.3 befasst sich mit Strukturen und Gewerkschaften .
• In Abschnitt 6.5.2.3 (3) wird erläutert , welcher Punktoperator auf ein structoder ein unionObjekt angewendet wird und welcher Wert erhalten wird.
  Genau dort erscheint die Fußnote 95 . Diese Fußnote sagt:

Wenn das Element, das für den Zugriff auf den Inhalt eines Vereinigungsobjekts verwendet wird, nicht mit dem Element identisch ist, das zuletzt zum Speichern eines Werts im Objekt verwendet wurde, wird der entsprechende Teil der Objektdarstellung des Werts als Objektdarstellung im neuen Typ als neu interpretiert beschrieben in 6.2.6 (ein Prozess, der manchmal als "Typ Punning" bezeichnet wird). Dies könnte eine Trap-Darstellung sein.

Die Tatsache, dass Typ-Punning kaum auftritt, und als Fußnote gibt es einen Hinweis darauf, dass es sich bei der C-Programmierung nicht um ein relevantes Problem handelt.
Tatsächlich besteht der Hauptzweck der Verwendung unionsdarin, Platz (im Speicher) zu sparen . Da mehrere Mitglieder dieselbe Adresse verwenden, kann, wenn man weiß, dass jedes Mitglied unterschiedliche Teile des Programms verwendet, niemals gleichzeitig, unionstattdessen a structzum Speichern von Speicher verwendet werden.

• Der Unterabschnitt 6.2.6 wird erwähnt.
• In Unterabschnitt 6.2.6 wird erläutert, wie Objekte dargestellt werden (z. B. im Speicher).

2. VERTRETUNG DER TYPEN UND IHRER STÖRUNGEN

Wenn Sie auf die verschiedenen Aspekte des Standards achten, können Sie sich fast nichts sicher sein:

• Die Darstellung von Zeigern ist nicht eindeutig festgelegt.
• Am schlimmsten ist, dass Zeiger mit unterschiedlichen Typen eine unterschiedliche Darstellung haben können (als Objekte im Speicher).
• unionMitglieder haben dieselbe Überschriftenadresse im Speicher und dieselbe Adresse wie das unionObjekt selbst.
• structMitglieder haben eine zunehmende relative Adresse, indem sie in genau derselben Speicheradresse beginnen wie das structObjekt selbst. Am Ende jedes Mitglieds können jedoch Füllbytes hinzugefügt werden. Wie viele? Es ist unvorhersehbar. Füllbytes werden hauptsächlich für Speicherzuweisungszwecke verwendet.
• Arithmetische Typen (ganze Zahlen, reelle Gleitkommazahlen und komplexe Zahlen) können auf verschiedene Arten dargestellt werden. Das hängt von der Implementierung ab.
• Insbesondere können ganzzahlige Typen Füllbits aufweisen . Dies gilt meines Erachtens nicht für Desktop-Computer. Der Standard ließ jedoch die Tür für diese Möglichkeit offen. Füllbits werden für räumliche Zwecke (Parität, Signale, wer weiß) und nicht zum Halten mathematischer Werte verwendet.
• signed Typen können drei Arten der Darstellung haben: 1-Komplement, 2-Komplement, nur Vorzeichenbit.
• Die charTypen belegen nur 1 Byte, aber 1 Byte kann eine Anzahl von Bits haben, die sich von 8 unterscheiden (jedoch niemals weniger als 8).

• Bei einigen Details können wir uns jedoch sicher sein:

  ein. Die charTypen haben keine Füllbits.
  b. Die unsignedInteger-Typen werden genau wie in binärer Form dargestellt.
  c. unsigned charbelegt genau 1 Byte ohne Auffüllbits, und es gibt keine Trap-Darstellung, da alle Bits verwendet werden. Darüber hinaus stellt es einen Wert ohne Mehrdeutigkeit dar, der dem Binärformat für Ganzzahlen folgt.

3. TYP PUNNING vs TYPE REPRÄSENTATION

All diese Beobachtungen zeigen, dass wir viel Unklarheit haben können , wenn wir versuchen, mit Mitgliedern mit unterschiedlichen Typen Typ-Punning durchzuführen . Es ist kein portabler Code und insbesondere könnten wir ein unvorhersehbares Verhalten unseres Programms haben. Der Standard erlaubt jedoch diese Art des Zugriffs . unionunsigned char

Selbst wenn wir uns über die spezifische Art und Weise sicher sind, in der jeder Typ in unserer Implementierung dargestellt wird, könnten wir eine Folge von Bits haben, die in anderen Typen überhaupt nichts bedeuten ( Trap-Darstellung ). In diesem Fall können wir nichts tun.

4. DER SICHERE FALL: Zeichen ohne Vorzeichen

Die einzig sichere Art, Typ Punning zu verwenden, ist mit unsigned charoder gut unsigned charArrays (weil wir wissen, dass Mitglieder von Array-Objekten streng zusammenhängend sind und es keine Auffüllbytes gibt, wenn ihre Größe berechnet wird sizeof()).

  union {
     TYPE data;
     unsigned char type_punning[sizeof(TYPE)];
  } xx;  

Da wir wissen, dass dies unsigned charin strikter binärer Form ohne Auffüllen von Bits dargestellt wird, kann hier der Typ punning verwendet werden, um einen Blick auf die binäre Darstellung des Mitglieds zu werfen data.
Mit diesem Tool kann analysiert werden, wie Werte eines bestimmten Typs in einer bestimmten Implementierung dargestellt werden.

Ich bin nicht in der Lage, eine andere sichere und nützliche Anwendung von Typ Punning unter den Standardspezifikationen zu sehen.

5. EIN KOMMENTAR ZU CASTS ...

Wenn man mit Typen spielen möchte, ist es besser, eigene Transformationsfunktionen zu definieren oder einfach Casts zu verwenden . Wir können uns an dieses einfache Beispiel erinnern:

  union {
     unsigned char x;  
     double t;
  } uu;

  bool result;

  uu.x = 7;
  (uu.t == 7.0)? result = true: result = false;
  // You can bet that result == false

  uu.t = (double)(uu.x);
  (uu.t == 7.0)? result = true: result = false;
  // result == true

Es gibt (oder gab es zumindest in C90) zwei Modifikationen, um dieses undefinierte Verhalten zu erzeugen. Das erste war, dass ein Compiler zusätzlichen Code generieren durfte, der verfolgte, was in der Union war, und ein Signal generierte, wenn Sie auf das falsche Mitglied zugegriffen hatten. In der Praxis glaube ich nicht, dass es jemals jemand getan hat (vielleicht CenterLine?). Das andere waren die Optimierungsmöglichkeiten, die sich daraus ergaben und die genutzt werden. Ich habe Compiler verwendet, die einen Schreibvorgang bis zum letztmöglichen Zeitpunkt verschieben würden, da dies möglicherweise nicht erforderlich ist (weil die Variable außerhalb des Gültigkeitsbereichs liegt oder ein nachfolgender Schreibvorgang mit einem anderen Wert erfolgt). Logischerweise würde man erwarten, dass diese Optimierung deaktiviert wird, wenn die Union sichtbar ist, aber nicht in den frühesten Versionen von Microsoft C.

Die Probleme der Typ-Punning sind komplex. Das C-Komitee (Ende der 1980er Jahre) vertrat mehr oder weniger die Position, dass Sie dafür Casts (in C ++, reinterpret_cast) und nicht Gewerkschaften verwenden sollten, obwohl beide Techniken zu dieser Zeit weit verbreitet waren. Seitdem haben einige Compiler (z. B. g ++) den entgegengesetzten Standpunkt vertreten und die Verwendung von Gewerkschaften unterstützt, nicht jedoch die Verwendung von Casts. Und in der Praxis funktioniert beides nicht, wenn nicht sofort ersichtlich ist, dass es zu Typ-Punning kommt. Dies könnte die Motivation hinter g ++ sein. Wenn Sie auf ein Gewerkschaftsmitglied zugreifen, ist sofort ersichtlich, dass es zu Typ-Punning kommen kann. Aber natürlich bei etwas wie:

int f(const int* pi, double* pd)
{
    int results = *pi;
    *pd = 3.14159;
    return results;
}

genannt mit:

union U { int i; double d; };
U u;
u.i = 1;
std::cout << f( &u.i, &u.d );

ist nach den strengen Regeln des Standards vollkommen legal, schlägt jedoch mit g ++ (und wahrscheinlich vielen anderen Compilern) fehl; Beim Kompilieren fgeht der Compiler davon aus pi und pdkann keinen Alias erstellen. Er ordnet das Schreiben in *pdund das Lesen von neu an *pi. (Ich glaube, es war nie die Absicht, dies zu garantieren. Aber der aktuelle Wortlaut des Standards garantiert dies.)

BEARBEITEN:

Da andere Antworten argumentiert haben, dass das Verhalten tatsächlich definiert ist (hauptsächlich basierend auf dem Zitieren einer nicht normativen Notiz, die aus dem Kontext genommen wurde):

Die richtige Antwort ist hier die von pablo1977: Der Standard unternimmt keinen Versuch, das Verhalten zu definieren, wenn es um Typ-Punning geht. Der wahrscheinliche Grund dafür ist, dass es kein tragbares Verhalten gibt, das definiert werden könnte. Dies hindert eine bestimmte Implementierung nicht daran, sie zu definieren. Obwohl ich mich an keine spezifischen Diskussionen zu diesem Thema erinnere, bin ich mir ziemlich sicher, dass die Absicht darin bestand, dass Implementierungen etwas definieren (und die meisten, wenn nicht alle, dies tun).

In Bezug auf die Verwendung einer Union für Typ-Punning: Als das C-Komitee C90 entwickelte (Ende der 1980er Jahre), bestand eindeutig die Absicht, Debugging-Implementierungen zuzulassen, die zusätzliche Überprüfungen durchführten (z. B. die Verwendung von Fettzeigern für die Grenzüberprüfung). Aus den damaligen Diskussionen ging hervor, dass die Absicht bestand, dass eine Debugging-Implementierung Informationen zum letzten in einer Union initialisierten Wert zwischenspeichern und abfangen könnte, wenn Sie versuchen, auf etwas anderes zuzugreifen. Dies ist in §6.7.2.1 / 16 klar festgelegt: "Der Wert von höchstens einem der Mitglieder kann jederzeit in einem Gewerkschaftsobjekt gespeichert werden." Der Zugriff auf einen Wert, der nicht vorhanden ist, ist undefiniert. Es kann dem Zugriff auf eine nicht initialisierte Variable gleichgesetzt werden. (Zu dieser Zeit gab es einige Diskussionen darüber, ob der Zugriff auf ein anderes Mitglied mit demselben Typ legal ist oder nicht. Ich weiß jedoch nicht, wie die endgültige Entschließung lautete. Nach ungefähr 1990 wechselte ich zu C ++.)

In Bezug auf das Zitat aus C89 ist es sehr seltsam, zu sagen, dass das Verhalten implementierungsdefiniert ist: Es in Abschnitt 3 (Begriffe, Definitionen und Symbole) zu finden. Ich muss es zu Hause in meiner Kopie von C90 nachschlagen. Die Tatsache, dass es in späteren Versionen der Standards entfernt wurde, deutet darauf hin, dass seine Anwesenheit vom Ausschuss als Fehler angesehen wurde.

Die Verwendung von Gewerkschaften, die der Standard unterstützt, dient der Simulation der Ableitung. Sie können definieren:

struct NodeBase
{
    enum NodeType type;
};

struct InnerNode
{
    enum NodeType type;
    NodeBase* left;
    NodeBase* right;
};

struct ConstantNode
{
    enum NodeType type;
    double value;
};
//  ...

union Node
{
    struct NodeBase base;
    struct InnerNode inner;
    struct ConstantNode constant;
    //  ...
};

und legal auf base.type zugreifen, obwohl der Knoten über initialisiert wurde inner. (Die Tatsache, dass §6.5.2.3 / 6 mit "Eine besondere Garantie wird gemacht ..." beginnt und dies ausdrücklich zulässt, ist ein sehr starker Hinweis darauf, dass alle anderen Fälle als undefiniertes Verhalten gedacht sind. Und natürlich dort ist die Aussage, dass "undefiniertes Verhalten in dieser Internationalen Norm durch die Worte" undefiniertes Verhalten "oder durch das Weglassen einer expliziten Definition des Verhaltens anderweitig angezeigt wird " in §4 / 2, um zu argumentieren, dass das Verhalten nicht undefiniert ist müssen Sie zeigen, wo es im Standard definiert ist.)

Schließlich in Bezug auf Typ-Punning: Alle (oder zumindest alle, die ich verwendet habe) Implementierungen unterstützen dies in irgendeiner Weise. Mein damaliger Eindruck war, dass die Absicht darin bestand, das Zeiger-Casting so zu gestalten, wie es eine Implementierung unterstützte. Im C ++ - Standard gibt es sogar (nicht normativen) Text, der darauf reinterpret_casthinweist , dass die Ergebnisse von a für jemanden, der mit der zugrunde liegenden Architektur vertraut ist, "nicht überraschend" sind. In der Praxis unterstützen die meisten Implementierungen jedoch die Verwendung von Union für Typ-Punning, vorausgesetzt, der Zugriff erfolgt über ein Gewerkschaftsmitglied. Die meisten Implementierungen (aber nicht g ++) unterstützen auch Zeigerumwandlungen, vorausgesetzt, die Zeigerumwandlung ist für den Compiler deutlich sichtbar (für einige nicht spezifizierte Definitionen der Zeigerumwandlung). Und die "Standardisierung" der zugrunde liegenden Hardware bedeutet, dass Dinge wie:

int
getExponent( double d )
{
    return ((*(uint64_t*)(&d) >> 52) & 0x7FF) + 1023;
}

sind eigentlich ziemlich portabel. (Es funktioniert natürlich nicht auf Mainframes.) Was nicht funktioniert, sind Dinge wie mein erstes Beispiel, bei dem das Aliasing für den Compiler unsichtbar ist. (Ich bin mir ziemlich sicher, dass dies ein Defekt im Standard ist. Ich erinnere mich, dass ich sogar einen DR darüber gesehen habe.)