fenv_access pragma

Disabilita (on) o abilita le ottimizzazioni (off) che potrebbero modificare i test dei flag dell'ambiente a virgola mobile e le modifiche alla modalità.

Sintassi

#pragma fenv_access ( { on | off } )

Osservazioni:

Per impostazione predefinita, fenv_access è off. Il compilatore presuppone che il codice non possa accedere o modificare l'ambiente a virgola mobile. Se l'accesso all'ambiente non è necessario, il compilatore può eseguire altre operazioni per ottimizzare il codice a virgola mobile.

Abilitare fenv_access se il codice verifica flag di stato a virgola mobile, eccezioni o imposta flag della modalità di controllo. Il compilatore disabilita le ottimizzazioni a virgola mobile, in modo che il codice possa accedere in modo coerente all'ambiente a virgola mobile.

L'opzione /fp:strict della riga di comando abilita fenv_accessautomaticamente . Per altre informazioni su questo e altro comportamento a virgola mobile, vedere /fp (Specificare il comportamento a virgola mobile).For more information on this and other floating-point behavior, see /fp (Specify Floating-Point Behavior).

Esistono restrizioni per i modi in cui è possibile usare l'oggetto fenv_accesspragma in combinazione con altre impostazioni a virgola mobile:

• Non è possibile abilitare a fenv_access meno che non sia abilitata una semantica precisa. La semantica precisa può essere abilitata da float_controlpragmao tramite le opzioni del /fp:precise compilatore o /fp:strict . L'impostazione predefinita del compilatore è /fp:precise se non viene specificata un'altra opzione della riga di comando a virgola mobile.

• Non è possibile usare float_control per disabilitare la semantica precisa quando fenv_access(on) è impostata.

I tipi di ottimizzazioni a cui sono soggetti fenv_access sono:

• Eliminazione di sottoespressioni comuni globali

• Movimento di codice

• Riduzione di costanti

Altre direttive a pragma virgola mobile includono:

• float_control

• fp_contract

Esempi

In questo esempio viene impostato fenv_access su on per impostare il registro di controllo a virgola mobile per la precisione a 24 bit:

// 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 si imposta #pragma fenv_access (on) un commento dall'esempio precedente, l'output è diverso. Perché il compilatore esegue la valutazione in fase di compilazione, che non usa la modalità di controllo.

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

Vedi anche

Pragmadirettive e parole __pragma chiave e _Pragma