Une étude d'un comportement vague

introduction

• un comportement indéfini peut ne pas sembler suffisamment dangereux en raison de l'abstraction des conséquences possibles;
• on ne sait pas toujours où est la ligne.

Lire la norme

6.6.3 L'instruction return
...
La sortie d'une fin de fonction équivaut à un retour sans valeur; cela se traduit par un
comportement indéfini dans une fonction de retour de valeur.
...

Atteindre la fin d'une fonction équivaut à retourner sans valeur de retour; pour une fonction dont la valeur de retour est fournie, cela conduit à un comportement indéfini.

9.6.3 L'instruction return
...
S'écoulant de la fin d'un constructeur, d'un destructeur ou d'une fonction avec un type de retour cv void est équivalent à un retour sans opérande. Sinon, la sortie d'une fin de fonction autre que main (6.8.3.1) entraîne un comportement indéfini.
...

Atteindre la fin d'un constructeur, d'un destructeur ou d'une fonction avec une valeur de retour vide (éventuellement avec des qualificateurs const et volatile) équivaut à retourner sans valeur de retour. Pour toutes les autres fonctions, cela conduit à un comportement indéfini (à l'exception de la fonction principale).

• son exécution doit se terminer par une instruction return avec une instance du type approprié;
• sinon, comportement vague;
• un comportement indéfini ne démarre pas au moment où la fonction est appelée et non pas au moment où la valeur retournée est utilisée, mais à partir du moment où la fonction n'est pas terminée correctement;
• si la fonction contient des chemins d'exécution corrects et incorrects - un comportement indéfini ne se produira que sur des chemins incorrects;
• le comportement indéfini en question n'affecte pas l'exécution des instructions contenues dans le corps de la fonction.

Exemple 1 - bool

#include <iostream>

bool bad() {};

int main()
{
    std::cout << bad();

    return 0;
}

#include <iostream>
#include <stdlib.h>

bool bad()
{
    if (rand() == 0) {
        return true;
    }
}

int main()
{
    std::cout << bad();

    return 0;
}

Linux x86-x64 Clang 10.0.0, -O0

UD2—Undefined Instruction
Generates an invalid opcode exception. This instruction is provided for software testing to explicitly generate an invalid opcode exception. The opcode for this instruction is reserved for this purpose.
Other than raising the invalid opcode exception, this instruction has no effect on processor state or memory.

Even though it is the execution of the UD2 instruction that causes the invalid opcode exception, the instruction pointer saved by delivery of the exception references the UD2 instruction (and not the following instruction).

This instruction’s operation is the same in non-64-bit modes and 64-bit mode.

Linux x86-x64 Clang 10.0.0, -O1, -O2

Linux x86-x64 gcc 9.3, -O0

Linux x86-x64 gcc 9.3, -O1, -O2, -O3

macOs X Apple clang version 11.0.0, -O0

macOs X Apple clang version 11.0.0, -O1, -O2

Windows MSVC 2019 16.5.4, exemple avancé, / Od

Windows MSVC 2019 16.5.4 Exemple compliqué, / O1, / O2

• copie un octet de ebx de la mémoire située à [rsp + 30h];
• si rand () a retourné zéro, copiez l'unité d'ecx vers ebx (ligne 11);
• copie la même valeur dans dl (plus précisément, son octet le moins significatif) (ligne 13);
• appelle la fonction de sortie dans stream, qui produit la valeur dl (ligne 14).

La conclusion de l'exemple 1

Exemple 1a - Gestion d'un comportement indéfini

Linux x86-x64 gcc 9.3, -O0

#include <iostream>

bool bad() {}

bool goodTrue()
{
    return rand();
}

bool goodFalse()
{
    return !goodTrue();
}

unsigned char goodChar(unsigned char ch)
{
    return ch;
}

int main()
{
    goodTrue();
    std::cout << bad() << std::endl;

    goodChar(85);
    std::cout << bad() << std::endl;

    goodFalse();
    std::cout << bad() << std::endl;

    goodChar(240);
    std::cout << bad() << std::endl;

    return 0;
}

1
85
0
240

Windows MSVC 2019 16.5.4, / Od

#include <iostream>
#include <stdlib.h>

void control(unsigned char value)
{
    uint32_t count = 0;
    srand(0);
    while ((rand() & 0xff) != value) {
        ++count;
    }

    srand(0);
    for (uint32_t i = 0; i < count; ++i) {
        rand();
    }
}

bool bad()
{
    if (rand() == 0) {
        return true;
    }
}

int main()
{
    control(1);
    std::cout << bad() << std::endl;

    control(85);
    std::cout << bad() << std::endl;

    control(0);
    std::cout << bad() << std::endl;

    control(240);
    std::cout << bad() << std::endl;

    return 0;
}

1
85
0
240

Windows MSVC 2019 16.5.4, / O1, / O2

#include <iostream>
#include <stdlib.h>

bool bad()
{
  if (rand() == 0) {
    return true;
  }
}

int main()
{
  volatile unsigned char ch = 1;
  std::cout << bad() << std::endl;

  ch = 85;
  std::cout << bad() << std::endl;

  ch = 0;
  std::cout << bad() << std::endl;

  ch = 240;
  std::cout << bad() << std::endl;

  return 0;
}

1
85
0
240

macOs X Apple clang version 11.0.0, -O0

#include <iostream>

bool bad() {}

void putToStack(uint8_t value)
{
    uint8_t memory[1]{value};
}

int main()
{
    putToStack(20);
    std::cout << bad() << std::endl;

    putToStack(55);
    std::cout << bad() << std::endl;

    putToStack(0xfe);
    std::cout << bad() << std::endl;

    putToStack(11);
    std::cout << bad() << std::endl;

    return 0;
}

0
1
0
1

La conclusion de l'exemple 1a

Exemple 1b - bool cassé

Windows MSVC 2019 16.5.4, / Od

#include <iostream>
#include <stdlib.h>
#include <set>
#include <unordered_set>

bool bad()
{
    if (rand() == 0) {
        return true;
    }
}

int main()
{
    bool badBool1 = bad();
    bool badBool2 = bad();

    std::cout << "badBool1: " << badBool1 << std::endl;
    std::cout << "badBool2: " << badBool2 << std::endl;

    if (badBool1) {
      std::cout << "if (badBool1): true" << std::endl;
    } else {
      std::cout << "if (badBool1): false" << std::endl;
    }
    if (!badBool1) {
      std::cout << "if (!badBool1): true" << std::endl;
    } else {
      std::cout << "if (!badBool1): false" << std::endl;
    }

    std::cout << "(badBool1 == true || badBool1 == false || badBool1 == badBool2): "
              << std::boolalpha << (badBool1 == true || badBool1 == false || badBool1 == badBool2)
              << std::endl;
    std::cout << "std::set<bool>{badBool1, badBool2, true, false}.size(): "
              << std::set<bool>{badBool1, badBool2, true, false}.size()
              << std::endl;
    std::cout << "std::unordered_set<bool>{badBool1, badBool2, true, false}.size(): "
              << std::unordered_set<bool>{badBool1, badBool2, true, false}.size()
              << std::endl;

    return 0;
}

badBool1: 41
badBool2: 35
if (badBool1): true
if (! badBool1): false
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , vrai, faux} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

• opérateurs de comparaison pour les valeurs booléennes;
• fonction de hachage de la valeur booléenne.

Windows MSVC 2019 16.5.4, / O1, / O2

#include <iostream>
#include <stdlib.h>
#include <set>
#include <unordered_set>

bool bad()
{
  if (rand() == 0) {
    return true;
  }
}

int main()
{
  volatile unsigned char ch = 213;
  bool badBool1 = bad();
  ch = 137;
  bool badBool2 = bad();

  std::cout << "badBool1: " << badBool1 << std::endl;
  std::cout << "badBool2: " << badBool2 << std::endl;

  if (badBool1) {
    std::cout << "if (badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (badBool1): false" << std::endl;
  }
  if (!badBool1) {
    std::cout << "if (!badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (!badBool1): false" << std::endl;
  }

  std::cout << "(badBool1 == true || badBool1 == false || badBool1 == badBool2): "
    << std::boolalpha << (badBool1 == true || badBool1 == false || badBool1 == badBool2)
    << std::endl;
  std::cout << "std::set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;
  std::cout << "std::unordered_set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::unordered_set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;

  return 0;
}

badBool1: 213
badBool2: 137
if (badBool1): true
if (! badBool1): false
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , vrai, faux} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

Linux x86-x64 gcc 9.3, -O0

#include <iostream>
#include <stdlib.h>
#include <set>
#include <unordered_set>

bool bad()
{
}

unsigned char goodChar(unsigned char ch)
{
  return ch;
}

int main()
{
  goodChar(213);
  bool badBool1 = bad();

  goodChar(137);
  bool badBool2 = bad();

  std::cout << "badBool1: " << badBool1 << std::endl;
  std::cout << "badBool2: " << badBool2 << std::endl;

  if (badBool1) {
    std::cout << "if (badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (badBool1): false" << std::endl;
  }
  if (!badBool1) {
    std::cout << "if (!badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (!badBool1): false" << std::endl;
  }

  std::cout << "(badBool1 == true || badBool1 == false || badBool1 == badBool2): "
    << std::boolalpha << (badBool1 == true || badBool1 == false || badBool1 == badBool2)
    << std::endl;
  std::cout << "std::set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;
  std::cout << "std::unordered_set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::unordered_set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;

  return 0;
}

badBool1: 213
badBool2: 137
if (badBool1): true
if (! badBool1): true
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , vrai, faux} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

La conclusion de l'exemple 1b

Exemple 2 - struct

#include <iostream>
#include <stdlib.h>

struct Test
{
    Test(uint64_t v)
        : value(v)
    {
        std::cout << "Test::Test(" << v << ")" << std::endl;
    }
    ~Test()
    {
        std::cout << "Test::~Test()" << std::endl;
    }

    uint64_t value;
};

Test bad(int v)
{
    if (v == 0) {
        return {42};
    } else if (v == 1) {
        return {142};
    }
}

int main()
{
    const auto rnd = rand();
    std::cout << "rnd: " << rnd << std::endl;

    std::cout << bad(rnd).value << std::endl;

    return 0;
}

• dans certains cas, l'exécution s'est poursuivie sans appeler le constructeur - dans ce cas, l'objet était dans un état aléatoire;
• dans d'autres cas, un appel constructeur n'a pas été prévu sur le chemin d'exécution, ce qui est plutôt étrange.

Linux x86-x64 Clang 10.0.0, -O1, -O2

• si la deuxième condition est vraie - vous devez appeler le constructeur Test avec l'argument 142;
• si la deuxième condition n'est pas vraie, la fonction se fermera sans retourner de valeur, ce qui signifie un comportement indéfini dans lequel le compilateur peut faire n'importe quoi. Y compris - appeler le même constructeur avec le même argument;
• la vérification est superflue; le constructeur Test avec l'argument 142 peut être appelé sans vérifier la condition.

Test bad(int v)
{
    if (v == 0) {
        return {42};
    } else if (v == rand()) {
        return {142};
    }
}

#include <iostream>
#include <stdlib.h>

struct Test
{
    Test(uint64_t v)
        : value(v)
    {
        std::cout << "Test::Test(" << v << ")" << std::endl;
    }
    ~Test()
    {
        std::cout << "Test::~Test()" << std::endl;
    }

    uint64_t value;
};

Test bad(int v)
{
    if (v == 0) {
        return {42};
    } else if (v == rand()) {
        return {142};
    }
}

int main()
{
    const auto rnd = rand();
    std::cout << "rnd: " << rnd << std::endl;

    std::cout << bad(rnd).value << std::endl;

    return 0;
}

Windows MSVC 2019 16.5.4, / Od / RTCs

• remplir une variable dont l'adresse est passée par le registre rcx (ici on voit RVO en action);
• renvoyer l'adresse de cette variable via le registre rax.

• dans eax, la valeur 0xCCCCCCCC est entrée, ce que nous avons vu dans le message de violation d'accès (ligne 9) (notez qu'il ne s'agit que de 4 octets, tandis que dans le message AccessViolation, l'adresse se compose de 8 octets);
• la commande rep stos est appelée, exécutant des cycles 0xC d'écriture du contenu de eax dans la mémoire à partir de l'adresse rdi (ligne 10). Ce sont 48 octets - exactement autant que ce qui est alloué sur la pile de la ligne 6;
• sur les bons chemins d'exécution, la valeur de rsp + 40h est entrée dans rax (lignes 23, 36);
• la valeur du registre rcx (par laquelle main () a transmis l'adresse de destination) est poussée sur la pile à rsp + 8 (ligne 4);
• rdi est poussé sur la pile, ce qui réduit rsp de 8 (ligne 5);
• 30h octets sont alloués sur la pile en diminuant rsp (ligne 6).

• zéros dans la partie supérieure de l'adresse - il pourrait y avoir des ordures;
• l'adresse s'est avérée accidentellement incorrecte.

Exemple 2a

Windows MSVC 2019 16.5.4, / Od / RTCs

#include <iostream>
#include <stdlib.h>

struct Test
{
    Test(uint64_t v)
        : value(v)
    {
        std::cout << "Test::Test(" << v << ")" << std::endl;
    }
    ~Test()
    {
        std::cout << "Test::~Test()" << std::endl;
    }

    uint64_t value;
};

Test bad(int v)
{
  std::cout << "rnd: " << v << std::endl;
  
  if (v == 0) {
        return {42};
    } else if (v == 1) {
        return {142};
    }
}

int main()
{
    const auto rnd = rand();

    std::cout << bad(rnd).value << std::endl;

    return 0;
}

rnd: 41
8791039331928
Test :: ~ Test ()

Conclusion

• recueillir environ 10 manifestations différentes d'un comportement indéfini;
• découvrez en détail comment ces options seront exécutées.