Repo sync for protected branch

docs/build/reference/qspectre-jmp.md

@@ -0,0 +1,38 @@
+---
+title: "/Qspectre-jmp"
+description: "Describes the Microsoft C/C++ compiler (MSVC) /Qspectre-jmp option."
+ms.date: 11/30/2023
+helpviewer_keywords: ["/Qspectre-jmp"]
+---
+# `/Qspectre-jmp`
+
+Causes the compiler to generate an `int3` instruction (software interrupt) after unconditional direct branches. This option extends the [`/Qspectre`](qspectre.md) flag and mitigates speculative execution side-channel attacks on unconditional direct branches.
+
+## Syntax
+
+> **/Qspectre-jmp**
+
+## Remarks
+
+**`/Qspectre-jmp`** causes the compiler to detect executable instructions following unconditional direct branches. An `int3` is inserted following unconditional direct branches to ensure that no instructions are speculatively executed beyond the branch. For example, the compiler mitigates `jmp addr` by adding an `int3` instruction following the `jmp` instruction as shown here:
+
+```asm
+jmp addr
+int3
+```
+
+`/Qspectre-jmp` is off by default. It's supported for all optimization levels.
+
+### Set this compiler option programmatically
+
+To set this option programmatically, see [VCCLCompilerTool.AdditionalOptions property](/dotnet/api/microsoft.visualstudio.vcprojectengine.vcclcompilertool.additionaloptions).
+
+## See also
+
+[`/Qspectre`](qspectre.md)\
+[`/Qspectre-jmp`](qspectre-jmp.md)\
+[`/Qspectre-load`](qspectre-load.md)\
+[`/Qspectre-load-cf`](qspectre-load-cf.md)\
+[/Q options (Low-Level Operations)](q-options-low-level-operations.md)\
+[MSVC compiler options](compiler-options.md)\
+[MSVC compiler command-line syntax](compiler-command-line-syntax.md)

docs/build/reference/qspectre-load-cf.md

@@ -15,7 +15,7 @@ Specifies compiler generation of serializing instructions for every control-flow
 
 ## Remarks
 
-**/Qspectre-load-cf** causes the compiler to detect `JMP`, `RET`, and `CALL` control-flow instructions that load from memory, and to insert serializing instructions after the load. Where possible, these instructions are split into a load and a control flow transfer. The load is followed by an `LFENCE` to ensure the load is protected. There are cases where the compiler can't split instructions, such as the `JMP` instruction, so it uses an alternate mitigation technique. For example, the compiler mitigates `jmp [rax]` by adding instructions to load the target non-destructively before inserting an LFENCE, as shown here:
+**/Qspectre-load-cf** causes the compiler to detect `JMP`, `RET`, and `CALL` control-flow instructions that load from memory, and to insert serializing instructions after the load. Where possible, these instructions are split into a load and a control flow transfer. The load is followed by an `LFENCE` to ensure the load is protected. There are cases where the compiler can't split instructions, such as the `JMP` instruction, so it uses an alternate mitigation technique. For example, the compiler mitigates `jmp [rax]` by adding instructions to load the target nondestructively before inserting an LFENCE, as shown here:
 
 ```asm
     xor rbx, [rax]
@@ -44,6 +44,9 @@ The **/Qspectre-load-cf** option is available in Visual Studio 2019 version 16.5
 
 ## See also
 
+[`/Qspectre`](qspectre.md)\
+[`/Qspectre-jmp`](qspectre-jmp.md)\
+[`/Qspectre-load`](qspectre-load.md)\
 [/Q options (Low-level operations)](q-options-low-level-operations.md)\
 [MSVC compiler options](compiler-options.md)\
 [MSVC compiler command-line syntax](compiler-command-line-syntax.md)

docs/build/reference/qspectre-load.md

@@ -14,7 +14,7 @@ Specifies compiler generation of serializing instructions for every load instruc
 
 ## Remarks
 
-**/Qspectre-load** causes the compiler to detect loads from memory, and insert serializing instructions after them. Control flow instructions that load memory, including `RET` and `CALL`, are split into a load and a control flow transfer. The load is followed by an `LFENCE` to ensure the load is protected. There are cases where the compiler can't split control flow instructions, such as the `jmp` instruction, so it uses an alternate mitigation technique. For example, the compiler mitigates `jmp [rax]` by adding instructions to load the target non-destructively before inserting an LFENCE, as shown here:
+**/Qspectre-load** causes the compiler to detect loads from memory, and insert serializing instructions after them. Control flow instructions that load memory, including `RET` and `CALL`, are split into a load and a control flow transfer. The load is followed by an `LFENCE` to ensure the load is protected. There are cases where the compiler can't split control flow instructions, such as the `jmp` instruction, so it uses an alternate mitigation technique. For example, the compiler mitigates `jmp [rax]` by adding instructions to load the target nondestructively before inserting an LFENCE, as shown here:
 
 ```asm
     xor rbx, [rax]
@@ -43,6 +43,9 @@ The **/Qspectre-load** option is available in Visual Studio 2019 version 16.5 an
 
 ## See also
 
+[`/Qspectre`](qspectre.md)\
+[`/Qspectre-jmp`](qspectre-jmp.md)\
+[`/Qspectre-load-cf`](qspectre-load-cf.md)\
 [/Q options (Low-Level Operations)](q-options-low-level-operations.md)\
 [MSVC compiler options](compiler-options.md)\
 [MSVC compiler command-line syntax](compiler-command-line-syntax.md)

docs/build/reference/qspectre.md

@@ -23,7 +23,7 @@ The **`/Qspectre`** option is off by default.
 
 In its initial release, the **`/Qspectre`** option only worked on optimized code. Starting in Visual Studio 2017 version 15.7, the **`/Qspectre`** option is supported at all optimization levels.
 
-Several Microsoft C++ libraries are also available in versions with Spectre mitigation. The Spectre-mitigated libraries for Visual Studio can be downloaded in the Visual Studio Installer. They're found in the **Individual Components** tab under **Compilers, build tools, and runtimes**, and have "Libs for Spectre" in the name. Both DLL and static runtime libraries with mitigation enabled are available for a subset of the Visual C++ runtimes: VC++ start-up code, vcruntime140, msvcp140, concrt140, and vcamp140. The DLLs are supported for application-local deployment only. The contents of the Visual C++ Runtime Libraries Redistributable haven't been modified.
+Several Microsoft C++ libraries are also available in versions with Spectre mitigation. The Spectre-mitigated libraries for Visual Studio can be downloaded in the Visual Studio Installer. They're found in the **Individual Components** tab under **Compilers, build tools, and runtimes**, and have "Libs for Spectre" in the name. Both DLL and static runtime libraries with mitigation enabled are available for a subset of the Visual C++ runtimes: VC++ start-up code, vcruntime140, msvcp140, concrt140, and vcamp140. The DLLs are supported for application-local deployment only. The contents of the Visual C++ Runtime Libraries Redistributable are unmodified.
 
 You can also install Spectre-mitigated libraries for MFC and ATL. They're found in the **Individual Components** tab under **SDKs, libraries, and frameworks**.
 
@@ -72,7 +72,7 @@ The default MSBuild-based project system in the Visual Studio IDE lets you speci
 
 ::: moniker range="msvc-150"
 
-The default MSBuild-based project system in the Visual Studio IDE lets you specify a [Spectre Mitigation](./c-cpp-prop-page.md#spectre-mitigation) property for your projects. This property sets the **`/Qspectre`** compiler option and changes the library paths to link the Spectre-mitigated runtime libraries. If these libraries aren't installed when you build your code, the build system reports warning MSB8038: "Spectre mitigation is enabled but Spectre mitigated libraries are not found". If your MFC or ATL code fails to build, and the linker reports an error such as "fatal error LNK1104: cannot open file 'oldnames.lib'", these missing libraries may be the cause.
+The default MSBuild-based project system in the Visual Studio IDE lets you specify a [Spectre Mitigation](./c-cpp-prop-page.md#spectre-mitigation) property for your projects. This property sets the **`/Qspectre`** compiler option and changes the library paths to link the Spectre-mitigated runtime libraries. If these libraries aren't installed when you build your code, the build system reports warning MSB8038: "Spectre mitigation is enabled but Spectre mitigated libraries are not found." If your MFC or ATL code fails to build, and the linker reports an error such as "fatal error LNK1104: cannot open file 'oldnames.lib'", these missing libraries may be the cause.
 
 ::: moniker-end
 
@@ -134,6 +134,9 @@ For an overview of Spectre vulnerabilities addressed by the MSVC mitigations, se
 
 ## See also
 
+[`/Qspectre-jmp`](qspectre-jmp.md)\
+[`/Qspectre-load`](qspectre-load.md)\
+[`/Qspectre-load-cf`](qspectre-load-cf.md)\
 [`/Q` options (Low-level operations)](q-options-low-level-operations.md)\
 [MSVC compiler options](compiler-options.md)\
 [MSVC compiler command-line syntax](compiler-command-line-syntax.md)

docs/build/toc.yml

@@ -700,6 +700,8 @@ items:
                       href: ../build/reference/qsafe-fp-loads.md
                     - name: /Qspectre
                       href: ../build/reference/qspectre.md
+                    - name: /Qspectre-jmp
+                      href: ../build/reference/qspectre-jmp.md
                     - name: /Qspectre-load
                       href: ../build/reference/qspectre-load.md
                     - name: /Qspectre-load-cf

docs/c-runtime-library/reference/splitpath-wsplitpath.md

@@ -1,18 +1,17 @@
 ---
 description: "Learn more about: _splitpath, _wsplitpath"
 title: "_splitpath, _wsplitpath"
-ms.date: "4/2/2020"
+ms.date: 11/30/2023
 api_name: ["_wsplitpath", "_splitpath", "_o__splitpath", "_o__wsplitpath"]
 api_location: ["msvcrt.dll", "msvcr80.dll", "msvcr90.dll", "msvcr100.dll", "msvcr100_clr0400.dll", "msvcr110.dll", "msvcr110_clr0400.dll", "msvcr120.dll", "msvcr120_clr0400.dll", "ucrtbase.dll", "api-ms-win-crt-filesystem-l1-1-0.dll"]
 api_type: ["DLLExport"]
 topic_type: ["apiref"]
 f1_keywords: ["wsplitpath", "_splitpath", "splitpath", "_wsplitpath", "_tsplitpath"]
 helpviewer_keywords: ["_splitpath function", "pathnames", "wsplitpath function", "splitpath function", "_wsplitpath function", "tsplitpath function", "path names", "_tsplitpath function"]
-ms.assetid: 32bd76b5-1385-4ee8-a64c-abcb541cd2e4
 ---
 # `_splitpath`, `_wsplitpath`
 
-Break a path name into components. More secure versions of these functions are available, see [`_splitpath_s`, `_wsplitpath_s`](splitpath-s-wsplitpath-s.md).
+Break a path into components. For more secure versions of these functions are available, see [`_splitpath_s`, `_wsplitpath_s`](splitpath-s-wsplitpath-s.md).
 
 ## Syntax
 
@@ -42,19 +41,19 @@ Full path.
 Drive letter, followed by a colon (**:**). You can pass `NULL` for this parameter if you don't need the drive letter.
 
 *`dir`*\
-Directory path, including trailing slash. Forward slashes ( **/** ), backslashes ( **\\** ), or both may be used. You can pass `NULL` for this parameter if you don't need the directory path.
+Directory path, including trailing slash. Forward slashes ( `/` ), backslashes ( `\` ), or both may be used. Pass `NULL` for this parameter if you don't need the directory path.
 
 *`fname`*\
-Base filename (no extension). You can pass `NULL` for this parameter if you don't need the filename.
+Base filename (no extension). Pass `NULL` for this parameter if you don't need the filename.
 
 *`ext`*\
-Filename extension, including leading period (**.**). You can pass `NULL` for this parameter if you don't need the filename extension.
+Filename extension, including leading period (`.`). Pass `NULL` for this parameter if you don't need the filename extension.
 
 ## Remarks
 
 The **`_splitpath`** function breaks a path into its four components. **`_splitpath`** automatically handles multibyte-character string arguments as appropriate, recognizing multibyte-character sequences according to the multibyte code page currently in use. **`_wsplitpath`** is a wide-character version of **`_splitpath`**; the arguments to **`_wsplitpath`** are wide-character strings. These functions behave identically otherwise.
 
-**Security Note** These functions incur a potential threat brought about by a buffer overrun problem. Buffer overrun problems are a frequent method of system attack, resulting in an unwarranted elevation of privilege. For more information, see [Avoiding buffer overruns](/windows/win32/SecBP/avoiding-buffer-overruns). More secure versions of these functions are available; see [`_splitpath_s`, `_wsplitpath_s`](splitpath-s-wsplitpath-s.md).
+**Security Note** These functions are subject to buffer overrun. Buffer overrun problems are a frequent method of system attack, resulting in an unwarranted elevation of privilege. For more information, see [Avoiding buffer overruns](/windows/win32/SecBP/avoiding-buffer-overruns). More secure versions of these functions are available; see [`_splitpath_s`, `_wsplitpath_s`](splitpath-s-wsplitpath-s.md).
 
 By default, this function's global state is scoped to the application. To change this behavior, see [Global state in the CRT](../global-state.md).
 
@@ -81,7 +80,7 @@ If the full path doesn't contain a component (for example, a filename), **`_spli
 
 You can pass `NULL` to **`_splitpath`** for any parameter other than *`path`* that you don't need.
 
-If *`path`* is `NULL`, the invalid parameter handler is invoked, as described in [Parameter validation](../parameter-validation.md). If execution is allowed to continue, `errno` is set to `EINVAL` and the function returns `EINVAL`.
+If *`path`* is `NULL`, the invalid parameter handler is invoked, as described in [Parameter validation](../parameter-validation.md). If execution is allowed to continue, `errno` is set to `EINVAL`.
 
 ## Requirements