fenv_access pragma

Desabilita (on) ou habilita (off) otimizações que poderiam alterar testes de sinalizadores de ambiente de ponto flutuante e alterações de modo.

Sintaxe

#pragma fenv_access (on | off { })

Comentários

Por padrão, fenv_access é off. O compilador pressupõe que o código não acessa nem manipula o ambiente de ponto flutuante. Se o acesso ao ambiente não for necessário, o compilador poderá fazer mais para otimizar o código de ponto flutuante.

Habilite fenv_access se o código testar sinalizadores de status de ponto flutuante, exceções ou definir sinalizadores do modo de controle. O compilador desabilita otimizações de ponto flutuante para que o código possa acessar o ambiente de ponto flutuante de modo consistente.

A opção /fp:strict de linha de comando habilita fenv_access automaticamente. Para mais informações sobre esse e outros comportamentos de ponto flutuante, confira /fp (Especificar Comportamento de Ponto Flutuante).

Há restrições aos modos como você pode usar fenv_accesspragma em combinação com outras configurações de ponto flutuante:

• Você não pode habilitar fenv_access, a menos que a semântica precisa esteja habilitada. A semântica precisa pode ser habilitada pelas opções float_controlpragma ou usando as opções de compilador /fp:precise ou /fp:strict. O compilador usará /fp:precise como padrão se nenhuma outra opção de linha de comando de ponto flutuante for especificada.

• Você não pode usar float_control para desabilitar a semântica precisa quando fenv_access(on) estiver definido.

Os tipos de otimizações sujeitos a fenv_access são:

• Eliminação de subexpressão comum global

• Movimentação de código

• Dobra de constante

Outras diretivas pragma de ponto flutuante incluem:

• float_control

• fp_contract

Exemplos

Este exemplo define fenv_access como on para definir o registro de controle de ponto flutuante para precisão de 24 bits:

// pragma_directive_fenv_access_x86.cpp
// compile with: /O2 /arch:IA32
// processor: x86
#include <stdio.h>
#include <float.h>
#include <errno.h>
#pragma fenv_access (on)

int main() {
   double z, b = 0.1, t = 0.1;
   unsigned int currentControl;
   errno_t err;

   err = _controlfp_s(&currentControl, _PC_24, _MCW_PC);
   if (err != 0) {
      printf_s("The function _controlfp_s failed!\n");
      return -1;
   }
   z = b * t;
   printf_s ("out=%.15e\n",z);
}

out=9.999999776482582e-03

Se você excluir por comentário #pragma fenv_access (on) do exemplo anterior, a saída será diferente. Isso ocorre porque o compilador faz a avaliação de tempo de compilação, que não usa o modo de controle.

// pragma_directive_fenv_access_2.cpp
// compile with: /O2 /arch:IA32
#include <stdio.h>
#include <float.h>

int main() {
   double z, b = 0.1, t = 0.1;
   unsigned int currentControl;
   errno_t err;

   err = _controlfp_s(&currentControl, _PC_24, _MCW_PC);
   if (err != 0) {
      printf_s("The function _controlfp_s failed!\n");
      return -1;
   }
   z = b * t;
   printf_s ("out=%.15e\n",z);
}

out=1.000000000000000e-02

Confira também

Pragmadiretivas e as __pragma palavras-chave e _Pragma