Les branches avec un comportement non défini peuvent-elles être considérées comme inaccessibles et optimisées en tant que code mort?

Considérez la déclaration suivante:

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

Il invoque clairement un comportement indéfini. L'existence d'une telle instruction dans un programme donné signifie-t-elle que l'ensemble du programme est indéfini ou que le comportement ne devient indéfini qu'une fois que le flux de contrôle atteint cette instruction?

Le programme suivant serait-il bien défini au cas où l'utilisateur n'entrerait jamais le numéro 3?

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

Ou s'agit-il d'un comportement totalement indéfini, peu importe ce que l'utilisateur entre?

De plus, le compilateur peut-il supposer qu'un comportement non défini ne sera jamais exécuté lors de l'exécution? Cela permettrait de raisonner à rebours dans le temps:

int num = ReadNumberFromConsole();

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

Ici, le compilateur pourrait penser qu'au cas où num == 3nous invoquerions toujours un comportement non défini. Par conséquent, ce cas doit être impossible et le numéro n'a pas besoin d'être imprimé. La ifdéclaration entière pourrait être optimisée. Ce type de raisonnement à rebours est-il autorisé selon la norme?

L'existence d'une telle instruction dans un programme donné signifie-t-elle que l'ensemble du programme n'est pas défini ou que le comportement ne devient indéfini qu'une fois que le flux de contrôle atteint cette instruction?

Ni. La première condition est trop forte et la seconde est trop faible.

Les accès aux objets sont parfois séquencés, mais la norme décrit le comportement du programme en dehors du temps. Danvil a déjà cité:

si une telle exécution contient une opération indéfinie, la présente Norme internationale n'impose aucune exigence sur l'implémentation exécutant ce programme avec cette entrée (pas même en ce qui concerne les opérations précédant la première opération non définie)

Cela peut être interprété:

Si l'exécution du programme produit un comportement indéfini, alors tout le programme a un comportement indéfini.

Ainsi, une instruction inaccessible avec UB ne donne pas au programme UB. Une instruction accessible qui (à cause des valeurs des entrées) n'est jamais atteinte, ne donne pas au programme UB. C'est pourquoi votre première condition est trop forte.

Maintenant, le compilateur ne peut pas en général dire ce que contient UB. Donc, pour permettre à l'optimiseur de réorganiser les instructions avec UB potentiel qui serait réordonnable si leur comportement était défini, il est nécessaire de permettre à UB de "remonter dans le temps" et de se tromper avant le point de séquence précédent (ou en C ++ 11, pour que l'UB affecte les choses qui sont séquencées avant la chose UB). Par conséquent, votre deuxième condition est trop faible.

Un exemple majeur de ceci est lorsque l'optimiseur s'appuie sur un aliasing strict. L'intérêt des règles strictes d'aliasing est de permettre au compilateur de réorganiser les opérations qui ne pourraient pas être réordonnées valablement s'il était possible que les pointeurs en question alias la même mémoire. Ainsi, si vous utilisez des pointeurs d'aliasing illégal et que UB se produit, cela peut facilement affecter une instruction "avant" l'instruction UB. En ce qui concerne la machine abstraite, l'instruction UB n'a pas encore été exécutée. En ce qui concerne le code objet réel, il a été partiellement ou entièrement exécuté. Mais la norme n'essaie pas d'entrer dans les détails sur ce que signifie pour l'optimiseur de réorganiser les instructions, ou quelles en sont les implications pour UB. Cela donne simplement à la licence d'implémentation une erreur dès qu'il le souhaite.

Vous pouvez penser à cela comme "UB a une machine à remonter le temps".

Plus précisément pour répondre à vos exemples:

• Le comportement n'est indéfini que si 3 est lu.
• Les compilateurs peuvent éliminer le code comme étant mort et le font si un bloc de base contient une opération qui ne sera certainement pas définie. Ils sont autorisés (et je suppose que oui) dans les cas qui ne sont pas un bloc de base mais où toutes les branches mènent à UB. Cet exemple n'est pas un candidat à moins PrintToConsole(3)d'être connu pour être sûr de revenir. Cela pourrait lever une exception ou autre.

Un exemple similaire à votre deuxième est l'option gcc -fdelete-null-pointer-checks, qui peut prendre un code comme celui-ci (je n'ai pas vérifié cet exemple spécifique, considérez-le comme illustratif de l'idée générale):

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

et changez-le en:

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

Pourquoi? Parce que si pest nul, le code a de toute façon UB, de sorte que le compilateur peut supposer qu'il n'est pas nul et optimiser en conséquence. Le noyau Linux a trébuché là-dessus ( https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2009-1897 ) essentiellement parce qu'il fonctionne dans un mode où le déréférencement d'un pointeur nul n'est pas censé be UB, cela devrait entraîner une exception matérielle définie que le noyau peut gérer. Lorsque l'optimisation est activée, gcc nécessite l'utilisation de-fno-delete-null-pointer-checks afin de fournir cette garantie hors norme.

PS La réponse pratique à la question "Quand un comportement indéfini frappe-t-il?" est "10 minutes avant votre départ pour la journée".

La norme indique à 1,9 / 4

[Remarque: La présente Norme internationale n'impose aucune exigence sur le comportement des programmes qui contiennent un comportement indéfini. - note de fin]

Le point intéressant est probablement ce que signifie «contenir». Un peu plus tard, à 1,9 / 5, il déclare:

Cependant, si une telle exécution contient une opération indéfinie, la présente Norme internationale n'impose aucune exigence sur l'implémentation exécutant ce programme avec cette entrée (pas même en ce qui concerne les opérations précédant la première opération non définie)

Ici, il mentionne spécifiquement "l'exécution ... avec cette entrée". J'interpréterais cela comme un comportement indéfini dans une branche possible qui n'est pas exécutée actuellement n'influence pas la branche d'exécution actuelle.

Les hypothèses basées sur un comportement indéfini lors de la génération de code constituent un autre problème. Voir la réponse de Steve Jessop pour plus de détails à ce sujet.

Un exemple instructif est

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

Le GCC actuel et le Clang actuel optimiseront cela (sur x86) pour

xorl %eax,%eax
ret

car ils en déduisent xtoujours zéro de l'UB dans le if (x)chemin de contrôle. GCC ne vous donnera même pas d'avertissement d'utilisation d'une valeur non initialisée! (parce que la passe qui applique la logique ci-dessus s'exécute avant la passe qui génère des avertissements de valeur non initialisée)

Le projet de travail actuel du C ++ indique dans la version 1.9.4 que

La présente Norme internationale n'impose aucune exigence sur le comportement des programmes qui contiennent un comportement non défini.

Sur cette base, je dirais qu'un programme contenant un comportement indéfini sur n'importe quel chemin d'exécution peut faire n'importe quoi à chaque fois de son exécution.

Il y a deux très bons articles sur le comportement indéfini et ce que font habituellement les compilateurs:

• Guide du comportement indéfini en C et C ++
• Ce que tout programmeur C doit savoir sur un comportement indéfini

Le mot «comportement» signifie que quelque chose est en train d'être fait . Un état qui n'est jamais exécuté n'est pas un «comportement».

Une illustration:

*ptr = 0;

Est-ce un comportement indéfini? Supposons que nous soyons sûrs à 100%ptr == nullptr à au moins une fois pendant l'exécution du programme. La réponse devrait être oui.

Et ça?

 if (ptr) *ptr = 0;

Est-ce indéfini? (Rappelez-vous ptr == nullptrau moins une fois?) J'espère bien que non, sinon vous ne pourrez pas du tout écrire de programme utile.

Aucun srandardese n'a été blessé dans l'élaboration de cette réponse.

Le comportement non défini survient lorsque le programme provoquera un comportement non défini, quoi qu'il arrive ensuite. Cependant, vous avez donné l'exemple suivant.

int num = ReadNumberFromConsole();

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

Sauf si le compilateur connaît la définition de PrintToConsole, il ne peut pas supprimer if (num == 3)conditionnel. Supposons que vous ayez LongAndCamelCaseStdio.hun en-tête système avec la déclaration suivante de PrintToConsole.

void PrintToConsole(int);

Rien de bien utile, d'accord. Maintenant, voyons à quel point le vendeur est mauvais (ou peut-être pas si mauvais, un comportement indéfini), en vérifiant la définition réelle de cette fonction.

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

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

Le compilateur doit en fait supposer que toute fonction arbitraire dont le compilateur ne sait pas ce qu'il fait peut quitter ou lancer une exception (dans le cas de C ++). Vous pouvez remarquer que *((char*)NULL) = 0;cela ne sera pas exécuté, car l'exécution ne continuera pas après l' PrintToConsoleappel.

Le comportement indéfini frappe lorsque PrintToConsole revient réellement. Le compilateur s'attend à ce que cela ne se produise pas (car cela amènerait le programme à exécuter un comportement indéfini quoi qu'il arrive), donc tout peut arriver.

Cependant, considérons autre chose. Disons que nous faisons une vérification nulle et que nous utilisons la variable après une vérification nulle.

int putchar(int);

const char *warning;

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

Dans ce cas, il est facile de remarquer que cela lol_null_checknécessite un pointeur non NULL. L'affectation à la warningvariable non volatile globale n'est pas quelque chose qui pourrait quitter le programme ou lever une exception. Le pointerest également non volatile, donc il ne peut pas changer sa valeur par magie au milieu de la fonction (si c'est le cas, c'est un comportement indéfini). Appellol_null_check(NULL) entraînera un comportement indéfini qui peut empêcher l'affectation de la variable (car à ce stade, le fait que le programme exécute le comportement non défini est connu).

Cependant, le comportement non défini signifie que le programme peut tout faire. Par conséquent, rien n'empêche le comportement non défini de remonter dans le temps et de planter votre programme avant la première ligne d' int main()exécutions. C'est un comportement indéfini, cela n'a pas à avoir de sens. Il peut tout aussi bien planter après avoir tapé 3, mais le comportement non défini remontera dans le temps et plantera avant même que vous ne tapiez 3. Et qui sait, peut-être qu'un comportement non défini écrasera la RAM de votre système, et fera planter votre système 2 semaines plus tard, pendant que votre programme non défini n'est pas en cours d'exécution.

Si le programme atteint une instruction qui invoque un comportement non défini, aucune exigence n'est imposée à la sortie / au comportement du programme. peu importe qu'ils aient lieu "avant" ou "après" un comportement non défini est invoqué.

Votre raisonnement sur les trois extraits de code est correct. En particulier, un compilateur peut traiter toute instruction invoquant de manière inconditionnelle un comportement indéfini comme GCC le traite __builtin_unreachable(): comme une indication d'optimisation que l'instruction est inaccessible (et par conséquent, que tous les chemins de code qui y mènent sans condition sont également inaccessibles). D'autres optimisations similaires sont bien entendu possibles.

De nombreuses normes pour de nombreux types de choses consacrent beaucoup d'efforts à décrire les choses que les implémentations DEVRAIENT ou NE DOIVENT PAS faire, en utilisant une nomenclature similaire à celle définie dans IETF RFC 2119 (sans nécessairement citer les définitions de ce document). Dans de nombreux cas, les descriptions des choses que les implémentations devraient faire sauf dans les cas où elles seraient inutiles ou peu pratiques sont plus importantes que les exigences auxquelles toutes les implémentations conformes doivent se conformer.

Malheureusement, les standards C et C ++ ont tendance à éviter les descriptions de choses qui, bien qu'elles ne soient pas obligatoires à 100%, devraient néanmoins être attendues d'implémentations de qualité qui ne documentent pas un comportement contraire. Une suggestion selon laquelle les implémentations devraient faire quelque chose pourrait être considérée comme impliquant que celles qui ne le sont pas sont inférieures, et dans les cas où il serait généralement évident quels comportements seraient utiles ou pratiques, par opposition à peu pratiques et inutiles, sur une implémentation donnée, il y avait il est peu perçu que la norme interfère avec ces jugements.

Un compilateur intelligent pourrait se conformer à la norme tout en éliminant tout code qui n'aurait aucun effet sauf lorsque le code reçoit des entrées qui provoqueraient inévitablement un comportement indéfini, mais «intelligent» et «stupide» ne sont pas des antonymes. Le fait que les auteurs de la norme aient décidé qu'il pourrait y avoir certains types de mises en œuvre où un comportement utile dans une situation donnée serait inutile et irréalisable n'implique aucun jugement sur la question de savoir si de tels comportements devraient être considérés comme pratiques et utiles pour d'autres. Si une mise en œuvre pouvait maintenir une garantie comportementale sans frais au-delà de la perte d'une opportunité d'élagage "de branche morte", presque toute valeur que le code utilisateur pourrait recevoir de cette garantie dépasserait le coût de sa fourniture. L'élimination des branches mortes peut être bien dans les cas où cela ne le serait pas, mais si, dans une situation donnée, le code utilisateur aurait pu gérer presque n'importe quel comportement possible autre que l'élimination des branches mortes, tout effort que le code utilisateur aurait à dépenser pour éviter UB dépasserait probablement la valeur obtenue à partir de DBE.