Um estudo de um comportamento vago

Introdução

• comportamento indefinido pode não parecer perigoso o suficiente devido à abstração das possíveis conseqüências;
• nem sempre é claro onde está a linha.

Ler Padrão

6.6.3 A declaração de retorno
...
Fluir do final de uma função é equivalente a um retorno sem valor; isso resulta em
comportamento indefinido em uma função de retorno de valor.
...

Atingir o final de uma função é equivalente a retornar sem um valor de retorno; para uma função cujo valor de retorno é fornecido, isso leva a um comportamento indefinido.

9.6.3 A declaração de retorno
...
Fluir do final de um construtor, destruidor ou função com um tipo de retorno cv void é equivalente a um retorno sem operando. Caso contrário, o fluxo do final de uma função que não seja main (6.8.3.1) resulta em comportamento indefinido.
...

Atingir o final de um construtor, destruidor ou função com um valor de retorno nulo (possivelmente com qualificadores const e voláteis) é equivalente a retornar sem um valor de retorno. Para todas as outras funções, isso leva a um comportamento indefinido (exceto para a função principal).

• sua execução deve terminar com uma declaração de retorno com uma instância do tipo apropriado;
• caso contrário, comportamento vago;
• o comportamento indefinido não inicia no momento em que a função é chamada e não no momento em que o valor retornado é usado, mas a partir do momento em que a função não é concluída corretamente;
• se a função contiver caminhos de execução corretos e incorretos - o comportamento indefinido ocorrerá apenas em caminhos incorretos;
• o comportamento indefinido em questão não afeta a execução das instruções contidas no corpo da função.

Exemplo 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 versão 11.0.0, -O0

macOs X Apple clang versão 11.0.0, -O1, -O2

Windows MSVC 2019 16.5.4, Exemplo avançado, / Od

Exemplo complicado do Windows MSVC 2019 16.5.4, / O1, / O2

• copia um byte do ebx da memória localizada em [rsp + 30h];
• se rand () retornou zero, copie a unidade de ecx para ebx (linha 11);
• copia o mesmo valor para dl (mais precisamente, seu byte menos significativo) (linha 13);
• chama a função de saída no fluxo, que gera o valor dl (linha 14).

A conclusão do exemplo 1

Exemplo 1a - Gerenciando comportamento 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 versão 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

A conclusão do exemplo 1a

Exemplo 1b - bool quebrado

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 , verdadeiro, falso} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, verdadeiro, falso} .size (): 4

• operadores de comparação para valores booleanos;
• função 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): true
if (! badBool1): false
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , verdadeiro, falso} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, verdadeiro, falso} .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 , verdadeiro, falso} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, verdadeiro, falso} .size (): 4

A conclusão do exemplo 1b

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

• em alguns casos, a execução continuou sem chamar o construtor - nesse caso, o objeto estava em algum estado aleatório;
• em outros casos, uma chamada de construtor não foi fornecida no caminho de execução, o que é bastante estranho.

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

• se a segunda condição for verdadeira - você precisará chamar o construtor Test com o argumento 142;
• se a segunda condição não for verdadeira, a função sairá sem retornar um valor, o que significa comportamento indefinido no qual o compilador pode fazer qualquer coisa. Incluindo - chame o mesmo construtor com o mesmo argumento;
• verificação é supérflua; o construtor Test com argumento 142 pode ser chamado sem verificar a condição.

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

• preenchendo uma variável cujo endereço é passado através do registro rcx (aqui vemos o RVO em ação);
• retornando o endereço dessa variável através do registro rax.

• em eax, o valor 0xCCCCCCCC é inserido, o que vimos na mensagem de violação de acesso (linha 9) (observe que são apenas 4 bytes, enquanto na mensagem de AccessViolation o endereço consiste em 8 bytes);
• o comando rep stos é chamado, executando ciclos 0xC de gravação do conteúdo do eax na memória, iniciando no endereço rdi (linha 10). São 48 bytes - exatamente o que está alocado na pilha na linha 6;
• nos caminhos de execução corretos, o valor de rsp + 40h é inserido em rax (linhas 23, 36);
• o valor do registrador rcx (através do qual main () passou o endereço de destino) é empurrado para a pilha em rsp + 8 (linha 4);
• rdi é empurrado para a pilha, o que reduz a rsp em 8 (linha 5);
• Os bytes de 30 h são alocados na pilha diminuindo a rsp (linha 6).

• zeros na parte superior do endereço - pode haver algum lixo;
• acidentalmente, o endereço estava incorreto.

Exemplo 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 ()

Conclusão

• coletar cerca de 10 manifestações diferentes de comportamento indefinido;
• aprenda em detalhes exatamente como essas opções serão executadas.