Können Zweige mit undefiniertem Verhalten als nicht erreichbar angenommen und als toter Code optimiert werden?

Betrachten Sie die folgende Aussage:

*((char*)NULL) = 0; //undefined behavior

Es ruft eindeutig undefiniertes Verhalten hervor. Bedeutet das Vorhandensein einer solchen Anweisung in einem bestimmten Programm, dass das gesamte Programm undefiniert ist oder dass das Verhalten erst dann undefiniert wird, wenn der Kontrollfluss diese Anweisung trifft?

Wäre das folgende Programm genau definiert, falls der Benutzer die Nummer nie eingibt 3?

while (true) {
 int num = ReadNumberFromConsole();
 if (num == 3)
  *((char*)NULL) = 0; //undefined behavior
}

Oder ist es völlig undefiniertes Verhalten, egal was der Benutzer eingibt?

Kann der Compiler auch davon ausgehen, dass undefiniertes Verhalten zur Laufzeit niemals ausgeführt wird? Das würde es ermöglichen, rechtzeitig rückwärts zu argumentieren:

int num = ReadNumberFromConsole();

if (num == 3) {
 PrintToConsole(num);
 *((char*)NULL) = 0; //undefined behavior
}

Hier könnte der Compiler argumentieren, dass für den Fall, dass num == 3wir immer undefiniertes Verhalten aufrufen. Daher muss dieser Fall unmöglich sein und die Nummer muss nicht gedruckt werden. Die gesamte ifAussage könnte optimiert werden. Ist diese Art des Rückwärtsdenkens nach dem Standard zulässig?

Bedeutet das Vorhandensein einer solchen Anweisung in einem bestimmten Programm, dass das gesamte Programm undefiniert ist oder dass das Verhalten erst dann undefiniert wird, wenn der Kontrollfluss diese Anweisung trifft?

Weder. Die erste Bedingung ist zu stark und die zweite zu schwach.

Der Objektzugriff wird manchmal sequenziert, aber der Standard beschreibt das Verhalten des Programms außerhalb der Zeit. Danvil zitierte bereits:

Wenn eine solche Ausführung eine undefinierte Operation enthält, stellt diese Internationale Norm keine Anforderung an die Implementierung, die dieses Programm mit dieser Eingabe ausführt (nicht einmal in Bezug auf Operationen, die der ersten undefinierten Operation vorausgehen).

Dies kann interpretiert werden:

Wenn die Ausführung des Programms ein undefiniertes Verhalten ergibt, hat das gesamte Programm ein undefiniertes Verhalten.

Eine nicht erreichbare Anweisung mit UB gibt dem Programm also nicht UB. Eine erreichbare Aussage, die (aufgrund der Werte von Eingaben) niemals erreicht wird, gibt dem Programm keine UB. Deshalb ist Ihre erste Bedingung zu stark.

Jetzt kann der Compiler im Allgemeinen nicht sagen, was UB hat. Damit der Optimierer Anweisungen mit potenziellem UB neu anordnen kann, die bei Definition ihres Verhaltens nachbestellbar wären, muss UB vor dem vorhergehenden Sequenzpunkt (oder in C) in die Zeit zurückgreifen und einen Fehler machen ++ 11 Terminologie, damit die UB Dinge beeinflusst, die vor der UB-Sache sequenziert werden). Daher ist Ihre zweite Bedingung zu schwach.

Ein wichtiges Beispiel hierfür ist, wenn der Optimierer auf striktem Aliasing beruht. Der Sinn der strengen Aliasing-Regeln besteht darin, dem Compiler zu ermöglichen, Vorgänge neu zu ordnen, die nicht gültig neu angeordnet werden könnten, wenn es möglich wäre, dass die fraglichen Zeiger denselben Speicher aliasen. Wenn Sie also illegal Aliasing-Zeiger verwenden und UB auftritt, kann dies leicht eine Anweisung "vor" der UB-Anweisung beeinflussen. Für die abstrakte Maschine wurde die UB-Anweisung noch nicht ausgeführt. Der eigentliche Objektcode wurde teilweise oder vollständig ausgeführt. Der Standard versucht jedoch nicht, detailliert darzulegen, was es für den Optimierer bedeutet, Anweisungen neu zu ordnen oder welche Auswirkungen dies auf UB hat. Es gibt nur die Implementierungslizenz, um schief zu gehen, sobald es gefällt.

Sie können sich das als "UB hat eine Zeitmaschine" vorstellen.

Speziell um Ihre Beispiele zu beantworten:

• Das Verhalten ist nur undefiniert, wenn 3 gelesen wird.
• Compiler können und können Code als tot eliminieren, wenn ein Basisblock eine Operation enthält, die sicher undefiniert ist. Sie sind in Fällen zulässig (und ich vermute es auch), die kein grundlegender Block sind, in denen jedoch alle Zweige zu UB führen. Dieses Beispiel ist kein Kandidat, es PrintToConsole(3)sei denn, es ist bekannt, dass es sicher zurückkehren wird. Es könnte eine Ausnahme auslösen oder was auch immer.

Ein ähnliches Beispiel wie bei Ihrem zweiten ist die Option gcc -fdelete-null-pointer-checks, die Code wie diesen annehmen kann (ich habe dieses spezielle Beispiel nicht überprüft, betrachte es als Beispiel für die allgemeine Idee):

void foo(int *p) {
    if (p) *p = 3;
    std::cout << *p << '\n';
}

und ändern Sie es zu:

*p = 3;
std::cout << "3\n";

Warum? Wenn if pnull ist, hat der Code ohnehin UB, sodass der Compiler davon ausgehen kann, dass er nicht null ist, und entsprechend optimieren kann. Der Linux - Kernel über diese angesprochen ( https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2009-1897 ) im Wesentlichen , weil es in einem Modus arbeitet , wo dereferencing ein Null - Zeiger nicht sollte Bei UB wird erwartet, dass dies zu einer definierten Hardware-Ausnahme führt, die der Kernel verarbeiten kann. Wenn die Optimierung aktiviert ist, muss gcc verwendet -fno-delete-null-pointer-checkswerden, um diese über den Standard hinausgehende Garantie zu gewährleisten.

PS Die praktische Antwort auf die Frage "Wann schlägt undefiniertes Verhalten zu?" ist "10 Minuten bevor Sie für den Tag abreisen wollten".

Der Standard besagt 1,9 / 4

[Hinweis: Diese Internationale Norm stellt keine Anforderungen an das Verhalten von Programmen, die undefiniertes Verhalten enthalten. - Endnote]

Der interessante Punkt ist wahrscheinlich, was "enthalten" bedeutet. Wenig später bei 1,9 / 5 heißt es:

Wenn eine solche Ausführung jedoch eine undefinierte Operation enthält, stellt diese Internationale Norm keine Anforderung an die Implementierung, die dieses Programm mit dieser Eingabe ausführt (nicht einmal in Bezug auf Operationen, die der ersten undefinierten Operation vorausgehen).

Hier wird ausdrücklich "Ausführung ... mit dieser Eingabe" erwähnt. Ich würde das so interpretieren, dass undefiniertes Verhalten in einem möglichen Zweig, der gerade nicht ausgeführt wird, keinen Einfluss auf den aktuellen Ausführungszweig hat.

Ein anderes Problem sind jedoch Annahmen, die auf undefiniertem Verhalten während der Codegenerierung basieren. Weitere Informationen hierzu finden Sie in der Antwort von Steve Jessop.

Ein lehrreiches Beispiel ist

int foo(int x)
{
    int a;
    if (x)
        return a;
    return 0;
}

Sowohl der aktuelle GCC als auch der aktuelle Clang optimieren dies (auf x86) auf

xorl %eax,%eax
ret

weil sie daraus ableiten, dassx der UB im Steuerpfad immer Null istif (x) . GCC gibt Ihnen nicht einmal eine Warnung zur Verwendung eines nicht initialisierten Werts! (weil der Durchlauf, der die obige Logik anwendet, vor dem Durchlauf ausgeführt wird, der Warnungen mit nicht initialisierten Werten generiert)

Der aktuelle C ++ - Arbeitsentwurf besagt dies in 1.9.4

Diese Internationale Norm stellt keine Anforderungen an das Verhalten von Programmen, die unbestimmtes Verhalten enthalten.

Auf dieser Grundlage würde ich sagen, dass ein Programm, das undefiniertes Verhalten auf einem beliebigen Ausführungspfad enthält, zu jedem Zeitpunkt seiner Ausführung alles tun kann.

Es gibt zwei wirklich gute Artikel über undefiniertes Verhalten und was Compiler normalerweise tun:

• Eine Anleitung zum undefinierten Verhalten in C und C ++
• Was jeder C-Programmierer über undefiniertes Verhalten wissen sollte

Das Wort "Verhalten" bedeutet, dass etwas getan wird . Ein Status, der niemals ausgeführt wird, ist kein "Verhalten".

Eine Illustration:

*ptr = 0;

Ist das undefiniertes Verhalten? Angenommen, wir sind uns ptr == nullptrmindestens einmal während der Programmausführung 100% sicher . Die Antwort sollte ja sein.

Was ist damit?

 if (ptr) *ptr = 0;

Ist das undefiniert? (Erinnerst ptr == nullptrdu dich mindestens einmal?) Ich hoffe nicht, sonst kannst du überhaupt kein nützliches Programm schreiben.

Bei der Beantwortung dieser Antwort wurde kein Srandardese verletzt.

Das undefinierte Verhalten tritt auf, wenn das Programm undefiniertes Verhalten verursacht, unabhängig davon, was als nächstes passiert. Sie haben jedoch das folgende Beispiel angegeben.

int num = ReadNumberFromConsole();

if (num == 3) {
 PrintToConsole(num);
 *((char*)NULL) = 0; //undefined behavior
}

Wenn der Compiler die Definition von nicht kennt PrintToConsole, kann er die if (num == 3)Bedingung nicht entfernen . Nehmen wir an, Sie haben einen LongAndCamelCaseStdio.hSystemheader mit der folgenden Deklaration von PrintToConsole.

void PrintToConsole(int);

Nichts zu hilfreich, alles klar. Lassen Sie uns nun sehen, wie böse (oder vielleicht nicht so böse, undefiniertes Verhalten hätte schlimmer sein können) der Anbieter ist, indem wir die tatsächliche Definition dieser Funktion überprüfen.

int printf(const char *, ...);
void exit(int);

void PrintToConsole(int num) {
    printf("%d\n", num);
    exit(0);
}

Der Compiler muss tatsächlich davon ausgehen, dass eine beliebige Funktion, von der der Compiler nicht weiß, was er tut, eine Ausnahme beenden oder auslösen kann (im Fall von C ++). Sie können feststellen, dass dies *((char*)NULL) = 0;nicht ausgeführt wird, da die Ausführung nach dem PrintToConsoleAufruf nicht fortgesetzt wird .

Das undefinierte Verhalten tritt auf, wenn es PrintToConsoletatsächlich zurückkehrt. Der Compiler erwartet, dass dies nicht geschieht (da dies dazu führen würde, dass das Programm undefiniertes Verhalten ausführt, egal was passiert), daher kann alles passieren.

Betrachten wir jedoch etwas anderes. Angenommen, wir führen eine Nullprüfung durch und verwenden die Variable nach der Nullprüfung.

int putchar(int);

const char *warning;

void lol_null_check(const char *pointer) {
    if (!pointer) {
        warning = "pointer is null";
    }
    putchar(*pointer);
}

In diesem Fall ist leicht zu erkennen, dass lol_null_checkein Nicht-NULL-Zeiger erforderlich ist. Das Zuweisen zur globalen nichtflüchtigen warningVariablen kann das Programm nicht beenden oder Ausnahmen auslösen. Das pointerist auch nicht flüchtig, so dass es seinen Wert in der Mitte der Funktion nicht magisch ändern kann (wenn ja, ist es undefiniertes Verhalten). Das Aufrufen lol_null_check(NULL)führt zu einem undefinierten Verhalten, das dazu führen kann, dass die Variable nicht zugewiesen wird (da zu diesem Zeitpunkt bekannt ist, dass das Programm das undefinierte Verhalten ausführt).

Das undefinierte Verhalten bedeutet jedoch, dass das Programm alles tun kann. Daher hindert nichts das undefinierte Verhalten daran, in die Zeit zurückzukehren und Ihr Programm vor der ersten int main()Ausführungszeile zum Absturz zu bringen . Es ist undefiniertes Verhalten, es muss keinen Sinn ergeben. Es kann auch nach der Eingabe von 3 abstürzen, aber das undefinierte Verhalten wird in der Zeit zurückgehen und abstürzen, bevor Sie überhaupt 3 eingeben. Und wer weiß, vielleicht überschreibt undefiniertes Verhalten Ihren System-RAM und führt dazu, dass Ihr System 2 Wochen später abstürzt. während Ihr undefiniertes Programm nicht läuft.

Wenn das Programm eine Anweisung erreicht, die undefiniertes Verhalten aufruft, werden keinerlei Anforderungen an die Ausgabe / das Verhalten des Programms gestellt. Es spielt keine Rolle, ob sie "vor" oder "nach" stattfinden, wenn undefiniertes Verhalten aufgerufen wird.

Ihre Argumentation zu allen drei Codefragmenten ist richtig. Insbesondere kann ein Compiler jede Anweisung, die bedingungslos undefiniertes Verhalten aufruft, so behandeln, __builtin_unreachable()wie GCC es behandelt : als Optimierungshinweis, dass die Anweisung nicht erreichbar ist (und damit alle Codepfade, die bedingungslos zu ihr führen, auch nicht erreichbar sind). Andere ähnliche Optimierungen sind natürlich möglich.

Viele Standards für viele Arten von Dingen erfordern viel Aufwand bei der Beschreibung von Dingen, die Implementierungen SOLLTEN oder NICHT tun SOLLTEN, wobei eine Nomenklatur verwendet wird, die der in IETF RFC 2119 definierten ähnlich ist (obwohl nicht unbedingt die Definitionen in diesem Dokument zitiert werden). In vielen Fällen sind Beschreibungen von Dingen, die Implementierungen ausführen sollten, außer in Fällen, in denen sie nutzlos oder unpraktisch wären, wichtiger als die Anforderungen, denen alle konformen Implementierungen entsprechen müssen.

Leider neigen C- und C ++ - Standards dazu, Beschreibungen von Dingen zu vermeiden, die zwar nicht zu 100% erforderlich sind, aber dennoch von Qualitätsimplementierungen erwartet werden sollten, die kein gegenteiliges Verhalten dokumentieren. Ein Vorschlag, dass Implementierungen etwas tun sollten, könnte bedeuten, dass diejenigen, die nicht minderwertig sind, und in Fällen, in denen es im Allgemeinen offensichtlich ist, welche Verhaltensweisen bei einer bestimmten Implementierung nützlich oder praktisch oder unpraktisch und nutzlos sind, vorhanden sind wenig wahrgenommene Notwendigkeit für den Standard, solche Urteile zu stören.

Ein cleverer Compiler könnte dem Standard entsprechen und gleichzeitig jeden Code eliminieren, der keine Auswirkungen hätte, außer wenn Code Eingaben empfängt, die unweigerlich undefiniertes Verhalten verursachen würden, aber "clever" und "dumm" sind keine Antonyme. Die Tatsache, dass die Autoren des Standards entschieden haben, dass es einige Arten von Implementierungen geben könnte, bei denen ein nützliches Verhalten in einer bestimmten Situation nutzlos und unpraktisch wäre, impliziert keine Beurteilung, ob solche Verhaltensweisen für andere als praktisch und nützlich angesehen werden sollten. Wenn eine Implementierung eine Verhaltensgarantie ohne Kosten aufrechterhalten könnte, die über den Verlust einer Beschneidungsmöglichkeit für "tote Zweige" hinausgeht, würde fast jeder Wert, den Benutzercode aus dieser Garantie erhalten könnte, die Kosten für deren Bereitstellung übersteigen. Die Beseitigung von toten Ästen kann in Fällen in Ordnung sein, in denen dies nicht der Fall ist.Wenn der Benutzercode jedoch in einer bestimmten Situation fast jedes andere mögliche Verhalten als die Beseitigung von Totzweigen hätte handhaben können , müsste der Benutzercode zur Vermeidung von UB wahrscheinlich den von DBE erzielten Wert überschreiten.