Un estudio de un comportamiento vago.

Introducción

• el comportamiento indefinido puede no parecer lo suficientemente peligroso debido a la abstracción de las posibles consecuencias;
• no siempre está claro dónde está la línea.

Leer estándar

6.6.3 La declaración de retorno
... El
flujo del final de una función es equivalente a un retorno sin valor; Esto da como resultado un
comportamiento indefinido en una función de retorno de valor.
...

Alcanzar el final de una función es equivalente a regresar sin un valor de retorno; para una función cuyo valor de retorno se proporciona, esto conduce a un comportamiento indefinido.

9.6.3 La declaración de retorno
...
Que fluye del final de un constructor, un destructor o una función con un tipo de retorno vacío cv es equivalente a un retorno sin operando. De lo contrario, fluir fuera del final de una función que no sea main (6.8.3.1) da como resultado un comportamiento indefinido.
...

Alcanzar el final de un constructor, destructor o función con un valor de retorno nulo (posiblemente con calificadores constantes y volátiles) es equivalente a un retorno sin un valor de retorno. Para todas las demás funciones, esto conduce a un comportamiento indefinido (a excepción de la función principal).

• su ejecución debe terminar con una declaración de retorno con una instancia del tipo apropiado;
• de lo contrario, comportamiento vago;
• el comportamiento indefinido no comienza desde el momento en que se llama la función y no desde el momento en que se utiliza el valor devuelto, sino desde el momento en que la función no se completa correctamente;
• si la función contiene rutas de ejecución correctas e incorrectas, el comportamiento indefinido solo ocurrirá en rutas incorrectas;
• El comportamiento indefinido en cuestión no afecta la ejecución de las instrucciones contenidas en el cuerpo de la función.

Ejemplo 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 versión 11.0.0, -O0

MacOs X Apple clang versión 11.0.0, -O1, -O2

Windows MSVC 2019 16.5.4, Ejemplo avanzado, / Od

Windows MSVC 2019 16.5.4 Ejemplo complicado, / O1, / O2

• copia un byte de ebx de la memoria ubicada en [rsp + 30h];
• si rand () devolvió cero, copie la unidad de ecx a ebx (línea 11);
• copia el mismo valor en dl (más precisamente, su byte menos significativo) (línea 13);
• llama a la función de salida en flujo, que genera el valor dl (línea 14).

La conclusión del ejemplo 1

Ejemplo 1a - Gestión de comportamiento indefinido

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 versión 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 conclusión del ejemplo 1a

Ejemplo 1b - bool roto

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): verdadero
if (! badBool1): falso
(badBool1 == verdadero || badBool1 == falso || badBool1 == badBool2): falso
std :: set <bool> {badBool1, badBool2 , verdadero, falso} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

• operadores de comparación para valores booleanos;
• función hash de valor booleano.

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): verdadero
if (! badBool1): falso
(badBool1 == verdadero || badBool1 == falso || badBool1 == badBool2): falso
std :: set <bool> {badBool1, badBool2 , verdadero, falso} .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): verdadero
if (! badBool1): verdadero
(badBool1 == verdadero || badBool1 == falso || badBool1 == badBool2): falso
std :: set <bool> {badBool1, badBool2 , verdadero, falso} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

La conclusión del ejemplo 1b

Ejemplo 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;
}

• en algunos casos, la ejecución continuó sin llamar al constructor; en este caso, el objeto estaba en algún estado aleatorio;
• en otros casos, no se proporcionó una llamada de constructor en la ruta de ejecución, lo cual es bastante extraño.

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

• si la segunda condición es verdadera, debe llamar al constructor Prueba con el argumento 142;
• Si la segunda condición no es verdadera, la función se cerrará sin devolver un valor, lo que significa un comportamiento indefinido en el que el compilador puede hacer cualquier cosa. Incluyendo: llamar al mismo constructor con el mismo argumento;
• la verificación es superflua; se puede llamar al constructor de prueba con el argumento 142 sin verificar la condición.

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 / RTC

• rellenando una variable cuya dirección se pasa a través del registro rcx (aquí vemos RVO en acción);
• devolviendo la dirección de esta variable a través del registro rax.

• en eax, se ingresa el valor 0xCCCCCCCC, que vimos en el mensaje de infracción de acceso (línea 9) (tenga en cuenta que solo tiene 4 bytes, mientras que en el mensaje de AccessViolation la dirección consta de 8 bytes);
• Se llama al comando rep stos, que ejecuta ciclos 0xC de escritura de los contenidos de eax en la memoria comenzando desde la dirección rdi (línea 10). Estos son 48 bytes, exactamente la cantidad asignada en la pila en la línea 6;
• en las rutas de ejecución correctas, el valor de rsp + 40h se ingresa en rax (líneas 23, 36);
• el valor del registro rcx (a través del cual main () pasó la dirección de destino) se inserta en la pila en rsp + 8 (línea 4);
• rdi es empujado a la pila, lo que reduce rsp en 8 (línea 5);
• Se asignan 30h bytes en la pila disminuyendo rsp (línea 6).

• ceros en la parte superior de la dirección: puede haber basura;
• la dirección resultó accidentalmente incorrecta.

Ejemplo 2a

Windows MSVC 2019 16.5.4, / Od / RTC

#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
Prueba :: ~ Prueba ()

Conclusión

• recolectar alrededor de 10 manifestaciones diferentes de comportamiento indefinido;
• aprenda en detalle exactamente cómo se ejecutarán estas opciones.