Update to remove strict, add restrictions

Author: Colin Robertson

docs/preprocessor/fenv-access.md

@@ -1,6 +1,7 @@
 ---
 title: "fenv_access pragma"
-ms.date: "08/29/2019"
+description: "Describes the usage and effects of the fenv_access pragma directive. The fenv_access directive controls access to the floating-point environment at runtime."
+ms.date: "11/19/2019"
 f1_keywords: ["vc-pragma.fenv_access", "fenv_access_CPP"]
 helpviewer_keywords: ["pragmas, fenv_access", "fenv_access pragma"]
 ms.assetid: 2ccea292-0ae4-42ce-9c67-cc189299857b
@@ -19,6 +20,14 @@ By default, **fenv_access** is **off**. If the compiler can assume that your cod
 
 For more information on floating-point behavior, see [/fp (Specify Floating-Point Behavior)](../build/reference/fp-specify-floating-point-behavior.md).
 
+There are restrictions on the ways you can use the **fenv_access** pragma in combination with other floating-point settings:
+
+- You can't enable **fenv_access** unless precise semantics are enabled. Precise semantics can be enabled either by the [float_control](float-control.md) pragma, or by using the [/fp:precise](../build/reference/fp-specify-floating-point-behavior.md) or [/fp:strict](../build/reference/fp-specify-floating-point-behavior.md) compiler options. The compiler defaults to **/fp:precise** if no other floating-point command-line option is specified.
+
+- You can't use **float_control** to disable precise semantics when **fenv_access(on)** is set.
+
+These restrictions mean the order of some floating-point pragmas is significant. For more information, see [float_control](float-control.md).
+
 The kinds of optimizations that are subject to **fenv_access** are:
 
 - Global common subexpression elimination

docs/preprocessor/float-control.md

@@ -1,5 +1,6 @@
 ---
 title: "float_control pragma"
+description: "Describes the usage and effects of the float_control pragma directive. The float_control directive controls the state of floating-point precise semantics and exception semantics at runtime."
 ms.date: "11/18/2019"
 f1_keywords: ["vc-pragma.float_control", "float_control_CPP"]
 helpviewer_keywords: ["float_control pragma", "pragmas, float_control"]
@@ -12,54 +13,66 @@ Specifies floating-point behavior for a function.
 ## Syntax
 
 > **#pragma float_control**\
-> **#pragma float_control(** { **precise** | **strict** | **except** } **,** { **on** | **off** } [ **, push** ] **)**\
+> **#pragma float_control( precise,** { **on** | **off** } [ **, push** ] **)**\
+> **#pragma float_control( except,** { **on** | **off** } [ **, push** ] **)**\
 > **#pragma float_control(** { **push** | **pop** } **)**
 
 ## Options
 
-**precise** | **strict** | **except**, **on** | **off**, **push**\
-Specifies floating-point behavior, which can be **precise**, **strict**, or **except**. The setting can either be **on** or **off**. For information on how these settings differ from the similarly named compiler options, see the Remarks section.
+**precise**, **on** | **off**, **push**\
+Specifies whether to enable (**on**) or disable (**off**) precise floating-point semantics. For information on how this option differs from the similarly named **/fp:precise** compiler option, see the Remarks section. If the optional **push** token is added, the current setting for **float_control** is pushed on to the internal compiler stack.
 
-When **strict**, the settings for both **strict** and **except** are specified by the **on** or **off** setting.
+**except**, **on** | **off**, **push**\
+Specifies whether to enable (**on**) or disable (**off**) floating-point exception semantics. For information on how this option differs from the similarly named **/fp:except** compiler option, see the Remarks section. If the optional **push** token is added, the current setting for **float_control** is pushed on to the internal compiler stack.
 
-If the optional **push** token is added, the current setting for **float_control** is pushed on to the internal compiler stack.
+**except** can only be set to **on** when **precise** is also set to **on**.
 
 **push**\
-Push the current **float_control** setting on to the internal compiler stack
+Pushes the current **float_control** setting on to the internal compiler stack.
 
 **pop**\
-Removes the **float_control** setting from the top of the internal compiler stack and makes that the new **float_control** setting.
+Removes the **float_control** setting from the top of the internal compiler stack, and makes that the new **float_control** setting.
 
 ## Remarks
 
-The **strict** option is effectively the same as the combination of **precise** and **except**. If you set **strict** on or off, it also sets **except** on or off. **except** can only be set to **on** when **precise** or **strict** is also set to **on**.
+The **precise** and **except** options don't have exactly the same behavior as the [/fp](../build/reference/fp-specify-floating-point-behavior.md) compiler options of the same names. The **float_control** pragma only governs part of the floating-point behavior. It must be combined with [fp_contract](../preprocessor/fp-contract.md) and [fenv_access](../preprocessor/fenv-access.md) pragmas to recreate the **/fp** compiler options. The following table shows the equivalent pragma settings for each compiler option:
 
-The **precise**, **strict**, and **except** options don't have exactly the same behavior as the [/fp](../build/reference/fp-specify-floating-point-behavior.md) compiler options of the same names. The **float_control** pragma only governs part of the floating-point behavior. It must be combined with [fp_contract](../preprocessor/fp-contract.md) and [fenv_access](../preprocessor/fenv-access.md) pragmas to recreate the `/fp` compiler options. The following table shows the equivalent pragma settings for each compiler option:
-
-| | float_control(precise) | float_control(except) | fenv_access | fp_contract |
+| | float_control(precise, \*) | float_control(except, \*) | fp_contract(\*) | fenv_access(\*) |
 |-|-|-|-|-|
-|`/fp:fast`|off|off|off|on|
-|`/fp:precise`|on|off|off|on|
-|`/fp:strict`|on|on|on|off|
+| /fp:strict             | on  | on  | off | on  |
+| /fp:strict /fp:except- | on  | off | off | on  |
+| /fp:precise            | on  | off | on  | off |
+| /fp:precise /fp:except | on  | on  | on  | off |
+| /fp:fast               | off | off | on  | off |
+
+In other words, you must use several pragmas in combination to emulate the **/fp:fast**, **/fp:precise**, **/fp:strict**, and **/fp:except** command-line options.
+
+There are restrictions on the ways you can use the **float_control** and [fenv_access](../preprocessor/fenv-access.md) floating-point pragmas in combination:
+
+- You can only use **float_control** to set **except** to **on** if precise semantics are enabled. Precise semantics can be enabled either by the **float_control** pragma, or by using the **/fp:precise** or **/fp:strict** compiler options.
+
+- You can't use **float_control** to turn **precise** off when exception semantics are enabled, whether by a **float_control** pragma or a **/fp:except** compiler option.
+
+- You can't enable [fenv_access](../preprocessor/fenv-access.md) unless precise semantics are enabled, whether by a **float_control** pragma or a compiler option.
 
-For example, you must use several pragmas in combination to change from `/fp:fast` behavior to `/fp:precise` or `/fp:strict` and back again. To recreate [/fp:strict](../build/reference/fp-specify-floating-point-behavior.md), you must set **float_control(precise, on)**, **fenv_access(on)**, **float_control(except, on)**, and **fp_contract(off)**.
+- You can't use **float_control** to turn **precise** off when **fenv_access(on)** is set.
 
-You can't use **float_control** to turn **precise** off when **except** is on. Similarly, **precise** can't be turned off when [fenv_access](../preprocessor/fenv-access.md) is on. That means, the order of some floating-point pragmas is significant. To go from a strict model to a fast model by using the **float_control** pragma, use the following code:
+These restrictions mean the order of some floating-point pragmas is significant. To go from a fast model to a strict model using the **float_control** and related pragmas, use the following code:
 
 ```cpp
-#pragma float_control(except, off)
-#pragma fenv_access(off)
-#pragma float_control(precise, off)
-#pragma fp_contract(on)
+#pragma float_control(precise, on)  // enable precise semantics
+#pragma fenv_access(on)             // enable environment sensitivity
+#pragma float_control(except, on)   // enable exception semantics
+#pragma fp_contract(off)            // disable contractions
 ```
 
-To go from fast model to a strict model with the **float_control** pragma, use the following code:
+To go from a strict model to a fast model by using the **float_control** pragma, use the following code:
 
 ```cpp
-#pragma float_control(precise, on)
-#pragma fenv_access(on)
-#pragma float_control(except, on)
-#pragma fp_contract(off)
+#pragma float_control(except, off)  // disable exception semantics
+#pragma fenv_access(off)            // disable environment sensitivity
+#pragma float_control(precise, off) // disable precise semantics
+#pragma fp_contract(on)             // ensable contractions
 ```
 
 If no options are specified, **float_control** has no effect.