arm: cortex_m: update docs to reflect the lazy stacking functionality

Update the documentation for Lazy Stacking in Cortex-M, to
reflect the functionality changes (activate the lazy stacking
dynamically when building with MPU stack guards).

Make a note that the FP sharing mode is now default in Cortex-M.

Signed-off-by: Ioannis Glaropoulos <[email protected]>

Author: ioannisg

doc/reference/kernel/other/float.rst

@@ -75,6 +75,10 @@ or SSE user are not impacted by the computations performed by the other users.
 ARM Cortex-M architecture (with the Floating Point Extension)
 -------------------------------------------------------------
 
+.. note::
+    The Shared FP registers mode is the default Floating Point
+    Services mode in ARM Cortex-M.
+
 On the ARM Cortex-M architecture with the Floating Point Extension, the kernel
 treats *all* threads as FPU users when shared FP registers mode is enabled.
 This means that any thread is allowed to access the floating point registers.
@@ -92,7 +96,8 @@ using one of the techniques listed below.
 
 Pretagging a thread with the :c:macro:`K_FP_REGS` option instructs the
 MPU-based stack protection mechanism to properly configure the size of
-the thread's guard region to always guarantee stack overflow detection.
+the thread's guard region to always guarantee stack overflow detection,
+and enable lazy stacking for the given thread upon thread creation.
 
 During thread context switching the ARM kernel saves the *callee-saved*
 floating point registers, if the switched-out thread has been using them.
@@ -113,6 +118,17 @@ is currently enabled in Zephyr applications on ARM Cortex-M
 architecture, minimizing interrupt latency, when the floating
 point context is active.
 
+When the MPU-based stack protection mechanism is not enabled, lazy stacking
+is always active in the Zephyr application. When the MPU-based stack protection
+is enabled, the following rules apply with respect to lazy stacking:
+
+* Lazy stacking is activated by default on threads that are pretagged with
+  :c:macro:`K_FP_REGS`
+* Lazy stacking is activated dynamically on threads that are not pretagged with
+  :c:macro:`K_FP_REGS`, as soon as the kernel detects that they are using the
+  floating point registers.
+
+
 If an ARM thread does not require use of the floating point registers any
 more, it can call :c:func:`k_float_disable`. This instructs the kernel
 not to save or restore its FP context during thread context switching.