Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

17 files changed, 3451 insertions, 0 deletions

diff --git a/src/VBox/Runtime/common/compiler/vcc/atexit-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/atexit-vcc.cpp
new file mode 100644
index 00000000..f6fad758
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/atexit-vcc.cpp
@@ -0,0 +1,145 @@
+/* $Id: atexit-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - Simple atexit implementation.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+
+#include <iprt/asm.h>
+#include <iprt/mem.h>
+#include <iprt/nocrt/stdlib.h>
+
+#include "internal/compiler-vcc.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef struct RTNOCRTATEXITCHUNK
+{
+    PFNRTNOCRTATEXITCALLBACK apfnCallbacks[256];
+} RTNOCRTATEXITCHUNK;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** The first atexit() registration chunk. */
+static RTNOCRTATEXITCHUNK   g_aAtExitPrealloc;
+/** Array of atexit() callback chunk pointers. */
+static RTNOCRTATEXITCHUNK  *g_apAtExit[8192 / 256] = { &g_aAtExitPrealloc, };
+/** Chunk and callback index in one. */
+static volatile uint32_t    g_idxNextAtExit        = 0;
+
+
+/* Note! not using atexit here because it'll clash with built-in prototype.  */
+extern "C" int nocrt_atexit(PFNRTNOCRTATEXITCALLBACK pfnCallback) RT_NOEXCEPT
+{
+    AssertPtr(pfnCallback);
+
+    /*
+     * Allocate a table index.
+     */
+    uint32_t idx = ASMAtomicIncU32(&g_idxNextAtExit) - 1;
+    AssertReturnStmt(idx < RT_ELEMENTS(g_apAtExit) * RT_ELEMENTS(g_apAtExit[0]->apfnCallbacks),
+                     ASMAtomicDecU32(&g_idxNextAtExit), -1);
+
+    /*
+     * Make sure the table chunk is there.
+     */
+    uint32_t            idxChunk = idx / RT_ELEMENTS(g_apAtExit[0]->apfnCallbacks);
+    RTNOCRTATEXITCHUNK *pChunk   = ASMAtomicReadPtrT(&g_apAtExit[idxChunk], RTNOCRTATEXITCHUNK *);
+    if (!pChunk)
+    {
+        pChunk = (RTNOCRTATEXITCHUNK *)RTMemAllocZ(sizeof(*pChunk)); /* ASSUMES that the allocator works w/o initialization! */
+        AssertReturn(pChunk, -1); /* don't try decrement, someone could be racing us... */
+
+        if (!ASMAtomicCmpXchgPtr(&g_apAtExit[idxChunk], pChunk, NULL))
+        {
+            RTMemFree(pChunk);
+
+            pChunk = ASMAtomicReadPtrT(&g_apAtExit[idxChunk], RTNOCRTATEXITCHUNK *);
+            Assert(pChunk);
+        }
+    }
+
+    /*
+     * Add our callback.
+     */
+    pChunk->apfnCallbacks[idxChunk % RT_ELEMENTS(pChunk->apfnCallbacks)] = pfnCallback;
+    return 0;
+}
+RT_ALIAS_AND_EXPORT_NOCRT_SYMBOL(atexit);
+
+
+void rtVccTermRunAtExit(void) RT_NOEXCEPT
+{
+    uint32_t idxAtExit = ASMAtomicReadU32(&g_idxNextAtExit);
+    if (idxAtExit-- > 0)
+    {
+        uint32_t idxChunk    = idxAtExit / RT_ELEMENTS(g_apAtExit[0]->apfnCallbacks);
+        uint32_t idxCallback = idxAtExit % RT_ELEMENTS(g_apAtExit[0]->apfnCallbacks);
+        for (;;)
+        {
+            RTNOCRTATEXITCHUNK *pChunk = ASMAtomicReadPtrT(&g_apAtExit[idxChunk], RTNOCRTATEXITCHUNK *);
+            if (pChunk)
+            {
+                do
+                {
+                    g_idxNextAtExit = idxAtExit--; /* Make sure we don't try problematic atexit callbacks! */
+
+                    PFNRTNOCRTATEXITCALLBACK pfnCallback = pChunk->apfnCallbacks[idxCallback];
+                    if (pfnCallback) /* Can be NULL see registration code */
+                    {
+                        pfnCallback();
+                        pChunk->apfnCallbacks[idxCallback] = NULL;
+                    }
+                } while (idxCallback-- > 0);
+            }
+            else
+                idxAtExit -= RT_ELEMENTS(g_apAtExit[0]->apfnCallbacks);
+            if (idxChunk == 0)
+                break;
+            idxChunk--;
+            idxCallback = RT_ELEMENTS(g_apAtExit[0]->apfnCallbacks) - 1;
+        }
+
+        g_idxNextAtExit = 0;
+    }
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/except-seh-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/except-seh-vcc.cpp
new file mode 100644
index 00000000..3a873673
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/except-seh-vcc.cpp
@@ -0,0 +1,243 @@
+/* $Id: except-seh-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - SEH exception handler (__try/__except/__finally).
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/nocrt.h"
+
+#include "except-vcc.h"
+
+
+#if !defined(RT_ARCH_AMD64)
+# error "This file is for AMD64 (and probably ARM, but needs porting)"
+#endif
+
+
+/**
+ * Calls an exception filter w/o doing any control guard checks.
+ *
+ * Doing this within an inline function to prevent disabling CFG for any other
+ * calls that __C_specific_handler might be doing.
+ *
+ * Presumably, the presumption here is that since the target address here is
+ * taken from tables assumed to be readonly and generated by the compiler, there
+ * is no need to do any CFG checks.  Besides, the target isn't a function that
+ * is safe to be called out of context and thus doesn't belong in the CFG tables
+ * in any way.
+ */
+__declspec(guard(ignore))
+DECLINLINE(LONG) CallFilterFunction(PEXCEPTION_FILTER pfnFilter, PEXCEPTION_POINTERS pXcptPtrs,
+                                    PEXCEPTION_REGISTRATION_RECORD pXcptRegRec)
+{
+    return pfnFilter(pXcptPtrs, pXcptRegRec);
+}
+
+
+/**
+ * Calls an exception finally block w/o doing any control guard checks.
+ *
+ * See CallFilterFunction for details.
+ */
+__declspec(guard(ignore))
+DECLINLINE(void) CallFinallyFunction(PTERMINATION_HANDLER const pfnTermHandler, BOOLEAN fAbend,
+                                     PEXCEPTION_REGISTRATION_RECORD pXcptRegRec)
+{
+    pfnTermHandler(fAbend, pXcptRegRec);
+}
+
+
+/**
+ * Call exception filters, handlers and unwind code.
+ *
+ * This is called for windows' structured exception handling (SEH), i.e. the
+ * __try/__except/__finally stuff in Visual C++.  The compiler generate scope
+ * records for the __try/__except blocks as well as unwind records for __finally
+ * and probably C++ stack object destructors.
+ *
+ * @returns Exception disposition.
+ * @param   pXcptRec    The exception record.
+ * @param   pXcptRegRec The exception registration record, taken to be the frame
+ *                      address.
+ * @param   pCpuCtx     The CPU context for the exception.
+ * @param   pDispCtx    Dispatcher context.
+ */
+EXCEPTION_DISPOSITION __C_specific_handler(PEXCEPTION_RECORD pXcptRec, PEXCEPTION_REGISTRATION_RECORD pXcptRegRec,
+                                           PCONTEXT pCpuCtx, PDISPATCHER_CONTEXT pDispCtx)
+{
+    /*
+     * This function works the scope table, starting at ScopeIndex
+     * from the dispatcher context.
+     */
+    SCOPE_TABLE const * const   pScopeTab   = (SCOPE_TABLE const *)pDispCtx->HandlerData;
+    uint32_t const              cScopes     = pScopeTab->Count;
+    uint32_t                    idxScope    = pDispCtx->ScopeIndex;
+
+    /*
+     * The table addresses are RVAs, so convert the program counter (PC) to an RVA.
+     */
+    uint32_t const              uRvaPc      = pDispCtx->ControlPc - pDispCtx->ImageBase;
+
+    /*
+     * Before we get any further, there are two types of scope records:
+     *      1. Unwind (aka termination) handler (JumpTarget == 0).
+     *      2. Exception filter & handler (JumpTarget != 0).
+     */
+
+    if (IS_DISPATCHING(pXcptRec->ExceptionFlags))
+    {
+        /*
+         * Call exception filter functions when dispatching.
+         */
+        for (; idxScope < cScopes; idxScope++)
+        {
+            /* Skip unwind entries (exception handler set to zero). */
+            uint32_t const uXcptHandler = pScopeTab->ScopeRecord[idxScope].JumpTarget;
+            if (uXcptHandler != 0)
+            {
+                uint32_t const uBegin  = pScopeTab->ScopeRecord[idxScope].BeginAddress;
+                uint32_t const uEnd    = pScopeTab->ScopeRecord[idxScope].EndAddress;
+                uint32_t const cbScope = uEnd - uBegin;
+                if (   uRvaPc - uBegin < cbScope
+                    && uBegin < uEnd /* paranoia */)
+                {
+                    /* The special HandlerAddress value 1 translates to a
+                       EXCEPTION_EXECUTE_HANDLER filter return value. */
+                    LONG lRet = EXCEPTION_EXECUTE_HANDLER;
+                    uint32_t const uFltTermHandler = pScopeTab->ScopeRecord[idxScope].HandlerAddress;
+                    if (uFltTermHandler != 1)
+                    {
+                        PEXCEPTION_FILTER  const pfnFilter = (PEXCEPTION_FILTER)(pDispCtx->ImageBase + uFltTermHandler);
+                        EXCEPTION_POINTERS       XcptPtrs  = { pXcptRec, pCpuCtx };
+                        lRet = CallFilterFunction(pfnFilter, &XcptPtrs, pXcptRegRec);
+
+                        AssertCompile(EXCEPTION_CONTINUE_SEARCH == 0);
+                        if (lRet == EXCEPTION_CONTINUE_SEARCH)
+                            continue;
+                    }
+
+                    /* Return if we're supposed to continue execution (the convention
+                       it to match negative values rather than the exact defined value):  */
+                    AssertCompile(EXCEPTION_CONTINUE_EXECUTION == -1);
+                    AssertCompile(EXCEPTION_EXECUTE_HANDLER == 1);
+                    if (lRet <= EXCEPTION_CONTINUE_EXECUTION)
+                        return ExceptionContinueExecution;
+
+                    /* Execute the handler (lRet >= EXCEPTION_EXECUTE_HANDLER). */
+                    uintptr_t const uPtrXcptHandler = uXcptHandler + pDispCtx->ImageBase;
+                    /** @todo shouldn't we do a guard check on this call? */
+
+                    /// @todo _NLG_Notify(uPtrXcptHandler, pXcptRegRec, 1); - debugger notification.
+
+                    RtlUnwindEx(pXcptRegRec, (void *)uPtrXcptHandler, pXcptRec,
+                                (PVOID)(uintptr_t)pXcptRec->ExceptionCode, pCpuCtx, pDispCtx->HistoryTable);
+
+                    /// @todo _NLG_Return2(); - debugger notification.
+                }
+            }
+        }
+    }
+    else
+    {
+        /*
+         * Do unwinding.
+         */
+
+        /* Convert the target unwind address to an RVA up front for efficiency.
+           (I think target unwinding is what the RtlUnwindEx call above does.) */
+        uint32_t const uTargetPc = pXcptRec->ExceptionFlags & EXCEPTION_TARGET_UNWIND
+                                 ? pDispCtx->TargetIp - pDispCtx->ImageBase
+                                 : UINT32_MAX;
+        //RTAssertMsg2("__C_specific_handler: unwind: idxScope=%#x cScopes=%#x uTargetPc=%#x fXcpt=%#x\n", idxScope, cScopes, uTargetPc, pXcptRec->ExceptionFlags);
+
+        for (; idxScope < cScopes; idxScope++)
+        {
+            uint32_t const uBegin  = pScopeTab->ScopeRecord[idxScope].BeginAddress;
+            uint32_t const uEnd    = pScopeTab->ScopeRecord[idxScope].EndAddress;
+            uint32_t const cbScope = uEnd - uBegin;
+            if (   uRvaPc - uBegin < cbScope
+                && uBegin < uEnd /* paranoia */)
+            {
+                uint32_t const uFltTermHandler = pScopeTab->ScopeRecord[idxScope].HandlerAddress;
+                uint32_t const uXcptHandler    = pScopeTab->ScopeRecord[idxScope].JumpTarget;
+
+                /* Target unwind requires us to stop if the target PC is in the same
+                   scope as the control PC.  Happens for goto out of inner __try scope
+                   or when longjmp'ing into a __try scope. */
+                if (pXcptRec->ExceptionFlags & EXCEPTION_TARGET_UNWIND)
+                {
+                    /* The scope same-ness is identified by the same handler and jump target rva values. */
+                    for (uint32_t idxTgtScope = 0; idxTgtScope < cScopes; idxTgtScope++)
+                        if (   pScopeTab->ScopeRecord[idxTgtScope].JumpTarget     == uXcptHandler
+                            && pScopeTab->ScopeRecord[idxTgtScope].HandlerAddress == uFltTermHandler)
+                        {
+                            uint32_t const uTgtBegin  = pScopeTab->ScopeRecord[idxTgtScope].BeginAddress;
+                            uint32_t const uTgtEnd    = pScopeTab->ScopeRecord[idxTgtScope].EndAddress;
+                            uint32_t const cbTgtScope = uTgtEnd - uTgtBegin;
+                            if (   uTargetPc - uTgtBegin < cbTgtScope
+                                && uTgtBegin < uTgtEnd /* paranoia */)
+                            {
+                                //RTAssertMsg2("__C_specific_handler: ExceptionContinueSearch (#1)\n");
+                                return ExceptionContinueSearch;
+                            }
+                        }
+                }
+
+                /* The unwind handlers are what we're here for. */
+                if (uXcptHandler == 0)
+                {
+                    PTERMINATION_HANDLER const pfnTermHandler = (PTERMINATION_HANDLER)(pDispCtx->ImageBase + uFltTermHandler);
+                    pDispCtx->ScopeIndex = idxScope + 1;
+                    //RTAssertMsg2("__C_specific_handler: Calling __finally %p (idxScope=%#x)\n", pfnTermHandler, idxScope);
+                    CallFinallyFunction(pfnTermHandler, TRUE /*fAbend*/, pXcptRegRec);
+                }
+                /* Exception filter & handler entries are skipped, unless the exception
+                   handler is being targeted by the unwind, in which case we're done
+                   unwinding and the caller should transfer control there. */
+                else if (   uXcptHandler == uTargetPc
+                         && (pXcptRec->ExceptionFlags & EXCEPTION_TARGET_UNWIND))
+                {
+                    //RTAssertMsg2("__C_specific_handler: ExceptionContinueSearch (#2)\n");
+                    return ExceptionContinueSearch;
+                }
+            }
+        }
+    }
+
+    return ExceptionContinueSearch;
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/except-vcc.h b/src/VBox/Runtime/common/compiler/vcc/except-vcc.h
new file mode 100644
index 00000000..f611adb6
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/except-vcc.h
@@ -0,0 +1,251 @@
+/* $Id: except-vcc.h $ */
+/** @file
+ * IPRT - Visual C++ Compiler - Exception Management.
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+#ifndef IPRT_INCLUDED_SRC_common_compiler_vcc_except_vcc_h
+#define IPRT_INCLUDED_SRC_common_compiler_vcc_except_vcc_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#define __C_specific_handler their___C_specific_handler
+#include <iprt/win/windows.h>
+#undef __C_specific_handler
+
+#include <iprt/types.h>
+#include <iprt/assertcompile.h>
+
+
+RT_C_DECLS_BEGIN
+
+#if 0
+/** This is part of the AMD64 and ARM (?) exception interface, but appear to
+ * live in the runtime headers for some weird reason. */
+typedef enum
+{
+    ExceptionContinueExecution = 0,
+    ExceptionContinueSearch,
+    ExceptionNestedException,
+    ExceptionCollidedUnwind
+} EXCEPTION_DISPOSITION;
+#endif
+
+/* The following two are borrowed from pecoff.h, as we typically want to include
+   winnt.h with this header and the two header cannot co-exist. */
+
+/**
+ * An unwind code for AMD64 and ARM64.
+ *
+ * @note Also known as UNWIND_CODE or _UNWIND_CODE.
+ */
+typedef union IMAGE_UNWIND_CODE
+{
+    struct
+    {
+        /** The prolog offset where the change takes effect.
+         * This means the instruction following the one being described.  */
+        uint8_t CodeOffset;
+        /** Unwind opcode.
+         * For AMD64 see IMAGE_AMD64_UNWIND_OP_CODES. */
+        RT_GCC_EXTENSION uint8_t UnwindOp : 4;
+        /** Opcode specific. */
+        RT_GCC_EXTENSION uint8_t OpInfo   : 4;
+    } u;
+    uint16_t    FrameOffset;
+} IMAGE_UNWIND_CODE;
+AssertCompileSize(IMAGE_UNWIND_CODE, 2);
+
+/**
+ * Unwind information for AMD64 and ARM64.
+ *
+ * Pointed to by IMAGE_RUNTIME_FUNCTION_ENTRY::UnwindInfoAddress,
+ *
+ * @note Also known as UNWIND_INFO or _UNWIND_INFO.
+ */
+typedef struct IMAGE_UNWIND_INFO
+{
+    /** Version, currently 1 or 2.  The latter if IMAGE_AMD64_UWOP_EPILOG is used. */
+    RT_GCC_EXTENSION uint8_t    Version : 3;
+    /** IMAGE_UNW_FLAG_XXX */
+    RT_GCC_EXTENSION uint8_t    Flags : 5;
+    /** Size of function prolog. */
+    uint8_t                     SizeOfProlog;
+    /** Number of opcodes in aOpcodes. */
+    uint8_t                     CountOfCodes;
+    /** Initial frame register. */
+    RT_GCC_EXTENSION uint8_t    FrameRegister : 4;
+    /** Scaled frame register offset. */
+    RT_GCC_EXTENSION uint8_t    FrameOffset : 4;
+    /** Unwind opcodes. */
+    RT_FLEXIBLE_ARRAY_EXTENSION
+    IMAGE_UNWIND_CODE           aOpcodes[RT_FLEXIBLE_ARRAY];
+} IMAGE_UNWIND_INFO;
+AssertCompileMemberOffset(IMAGE_UNWIND_INFO, aOpcodes, 4);
+typedef IMAGE_UNWIND_INFO *PIMAGE_UNWIND_INFO;
+typedef IMAGE_UNWIND_INFO const *PCIMAGE_UNWIND_INFO;
+
+
+
+#ifdef RT_ARCH_AMD64
+/**
+ * The Visual C++ 2019 layout of the GS_HANDLER_DATA data type for AMD64.
+ *
+ * This is pointed to by DISPATCHER_CONTEXT::HandlerData when dispatching
+ * exceptions.  The data resides after the unwind info for the function.
+ */
+typedef struct _GS_HANDLER_DATA
+{
+    union
+    {
+        struct
+        {
+            uint32_t    fEHandler : 1;
+#define GS_HANDLER_OFF_COOKIE_IS_EHANDLER   RT_BIT(0) /**< Handles exceptions. */
+            uint32_t    fUHandler : 1;
+#define GS_HANDLER_OFF_COOKIE_IS_UHANDLER   RT_BIT(1) /**< Handles unwind. */
+            uint32_t    fHasAlignment : 1;
+#define GS_HANDLER_OFF_COOKIE_HAS_ALIGNMENT RT_BIT(2) /**< Has the uAlignmentMask member. */
+        } Bits;
+#define GS_HANDLER_OFF_COOKIE_MASK          UINT32_C(0xfffffff8) /**< Mask to apply to offCookie to the the value. */
+        uint32_t        offCookie;
+    } u;
+    int32_t             offAlignedBase;
+    /** This field is only there when GS_HANDLER_OFF_COOKIE_HAS_ALIGNMENT is set.
+     * it seems. */
+    uint32_t            uAlignmentMask;
+} GS_HANDLER_DATA;
+typedef GS_HANDLER_DATA *PGS_HANDLER_DATA;
+typedef GS_HANDLER_DATA const *PCGS_HANDLER_DATA;
+#endif /* RT_ARCH_AMD64 */
+
+#ifdef RT_ARCH_X86
+void __fastcall __security_check_cookie(uintptr_t uCookieToCheck);
+#else
+void __cdecl    __security_check_cookie(uintptr_t uCookieToCheck);
+#endif
+
+
+#ifdef RT_ARCH_X86
+
+/**
+ * Exception registration record for _except_handler4 users
+ * (aka EH4_EXCEPTION_REGISTRATION_RECORD).
+ *
+ * This record is emitted immediately following the stack frame setup, i.e.
+ * after doing PUSH EBP and MOV EBP, ESP.  So, EBP equals the address following
+ * this structure.
+ */
+typedef struct EH4_XCPT_REG_REC_T
+{
+    /** The saved ESP after setting up the stack frame and before the __try. */
+    uintptr_t                       uSavedEsp;
+    PEXCEPTION_POINTERS             pXctpPtrs;
+    /** The SEH exception registration record (chained). */
+    EXCEPTION_REGISTRATION_RECORD   XcptRec;
+    uintptr_t                       uEncodedScopeTable;
+    uint32_t                        uTryLevel;
+    /* uintptr_t                    uSavedCallerEbp; */
+} EH4_XCPT_REG_REC_T;
+AssertCompileSize(EH4_XCPT_REG_REC_T, 24);
+/** Pointer to an exception registration record for _except_handler4 (aka
+ *  PEH4_EXCEPTION_REGISTRATION_RECORD). */
+typedef EH4_XCPT_REG_REC_T *PEH4_XCPT_REG_REC_T;
+
+
+/** Exception filter function for _except_handler4 users (aka
+ * PEXCEPTION_FILTER_X86). */
+typedef uint32_t (__cdecl *PFN_EH4_XCPT_FILTER_T)(void);
+/** Exception handler block function for _except_handler4 users (aka
+ * PEXCEPTION_HANDLER_X86). */
+typedef void     (__cdecl *PFN_EH4_XCPT_HANDLER_T)(void);
+/** Exception finally block function for _except_handler4 users (aka
+ * PTERMINATION_HANDLER_X86).
+ */
+typedef void  (__fastcall *PFN_EH4_FINALLY_T)(BOOL fAbend);
+
+/**
+ * Scope table record describing  __try / __except / __finally blocks (aka
+ * EH4_SCOPETABLE_RECORD).
+ */
+typedef struct EH4_SCOPE_TAB_REC_T
+{
+    uint32_t                    uEnclosingLevel;
+    /** Pointer to the filter sub-function if this is a __try/__except, NULL for
+     *  __try/__finally. */
+    PFN_EH4_XCPT_FILTER_T       pfnFilter;
+    union
+    {
+        PFN_EH4_XCPT_HANDLER_T  pfnHandler;
+        PFN_EH4_FINALLY_T       pfnFinally;
+    };
+} EH4_SCOPE_TAB_REC_T;
+AssertCompileSize(EH4_SCOPE_TAB_REC_T, 12);
+/** Pointer to a const _except_handler4 scope table entry. */
+typedef EH4_SCOPE_TAB_REC_T const *PCEH4_SCOPE_TAB_REC_T;
+
+/** Special EH4_SCOPE_TAB_REC_T::uEnclosingLevel used to terminate the chain. */
+#define EH4_TOPMOST_TRY_LEVEL   UINT32_C(0xfffffffe)
+
+/**
+ * Scope table used by _except_handler4 (aka EH4_SCOPETABLE).
+ */
+typedef struct EH4_SCOPE_TAB_T
+{
+    uint32_t                    offGSCookie;
+    uint32_t                    offGSCookieXor;
+    uint32_t                    offEHCookie;
+    uint32_t                    offEHCookieXor;
+    EH4_SCOPE_TAB_REC_T         aScopeRecords[RT_FLEXIBLE_ARRAY];
+} EH4_SCOPE_TAB_T;
+AssertCompileMemberOffset(EH4_SCOPE_TAB_T, aScopeRecords, 16);
+/** Pointer to a const _except_handler4 scope table. */
+typedef EH4_SCOPE_TAB_T const *PCEH4_SCOPE_TAB_T;
+
+/** Special EH4_SCOPE_TAB_T::offGSCookie value. */
+# define EH4_NO_GS_COOKIE       UINT32_C(0xfffffffe)
+
+#endif /* RT_ARCH_X86 */
+
+
+
+#if defined(RT_ARCH_AMD64)
+EXCEPTION_DISPOSITION __C_specific_handler(PEXCEPTION_RECORD pXcptRec, PEXCEPTION_REGISTRATION_RECORD pXcptRegRec,
+                                           PCONTEXT pCpuCtx, PDISPATCHER_CONTEXT pDispCtx);
+#endif
+
+RT_C_DECLS_END
+
+#endif /* !IPRT_INCLUDED_SRC_common_compiler_vcc_except_vcc_h */
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/except-x86-vcc-asm.asm b/src/VBox/Runtime/common/compiler/vcc/except-x86-vcc-asm.asm
new file mode 100644
index 00000000..dfc47415
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/except-x86-vcc-asm.asm
@@ -0,0 +1,358 @@
+; $Id: except-x86-vcc-asm.asm $
+;; @file
+; IPRT - Visual C++ Compiler - x86 Exception Handler Support Code.
+;
+
+;
+; Copyright (C) 2022-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+; in the VirtualBox distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+; SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+;
+
+
+
+;*********************************************************************************************************************************
+;*  Header Files                                                                                                                 *
+;*********************************************************************************************************************************
+%include "iprt/asmdefs.mac"
+
+
+;*********************************************************************************************************************************
+;*  Defined Constants And Macros                                                                                                 *
+;*********************************************************************************************************************************
+
+;; @def WITH_NLG_STUFF
+; Enabled NLG debugger hooks/whatever - no idea how it's used.
+;
+; So far vsdebugeng.manimpl.dll in the VS2019 remote debugger directory is the
+; only component with any _NLG_ strings in it.  Could not find any references
+; to _NLG_ in windbg.
+%define WITH_NLG_STUFF 1
+
+
+;*********************************************************************************************************************************
+;*  Structures and Typedefs                                                                                                      *
+;*********************************************************************************************************************************
+
+struc EH4_XCPT_REG_REC_T
+    .uSavedEsp                  resd 1      ;   0 / 0x00
+    .pXctpPtrs                  resd 1      ;   4 / 0x04
+    .XcptRec                    resd 2      ;   8 / 0x08
+    .uEncodedScopeTable         resd 1      ;  16 / 0x10
+    .uTryLevel                  resd 1      ;  20 / 0x14
+endstruc                                    ;  24 / 0x18
+
+
+;;
+; Scope table record describing  __try / __except / __finally blocks (aka
+; EH4_SCOPETABLE_RECORD).
+;
+struc EH4_SCOPE_TAB_REC_T
+    .uEnclosingLevel            resd 1
+    .pfnFilter                  resd 1
+    .pfnHandlerOrFinally        resd 1
+endstruc
+
+;; Special EH4_SCOPE_TAB_REC_T::uEnclosingLevel used to terminate the chain.
+%define EH4_TOPMOST_TRY_LEVEL   0xfffffffe
+
+;;
+; Scope table used by _except_handler4 (aka EH4_SCOPETABLE).
+;
+struc EH4_SCOPE_TAB_T
+    .offGSCookie                resd 1
+    .offGSCookieXor             resd 1
+    .offEHCookie                resd 1
+    .offEHCookieXor             resd 1
+    .aScopeRecords              resb 12
+endstruc
+
+
+;*********************************************************************************************************************************
+;*  External Symbols                                                                                                             *
+;*********************************************************************************************************************************
+BEGINCODE
+extern IMPNAME(RtlUnwind@16)
+extern _rtVccEh4DoLocalUnwindHandler@16
+
+
+;*********************************************************************************************************************************
+;*  Global Variables                                                                                                             *
+;*********************************************************************************************************************************
+
+;; Delcare rtVccEh4DoLocalUnwindHandler() in except-x86.cpp as a save exception handler.
+; This adds the symbol table number of the exception handler to the special .sxdata section.
+safeseh _rtVccEh4DoLocalUnwindHandler@16
+
+%ifdef WITH_NLG_STUFF
+BEGINDATA
+GLOBALNAME_RAW __NLG_Destination, data, hidden
+        dd      019930520h
+        dd      0
+        dd      0
+        dd      0
+%endif
+
+
+BEGINCODE
+
+%ifdef WITH_NLG_STUFF
+
+;;
+; Some VS debugger interface, I think.
+;
+; @param        EDX     Notification code.
+; @uses         EBP, EAX & ECX are preserved.  This differs from other implementation,
+;               but simplifies the calling code.
+;
+ALIGNCODE(32)
+GLOBALNAME_RAW __NLG_Notify, function, hidden
+        ;
+        ; Save registers.
+        ;
+        push    eax
+        push    ecx
+        push    ebp
+        push    ebx
+
+
+        ;
+        ; ECX = notification code.
+        ; EBX = __NLG_Destination
+        ;
+        mov     ecx, edx                    ; Originally held in ECX, so moving it there for now.
+        mov     ebx, __NLG_Destination
+
+__NLG_Go:
+        ;
+        ; Save info to __NLG_Destination and the stack (same layout).
+        ;
+        mov     [ebx + 0ch], ebp
+        push    ebp
+        mov     [ebx + 08h], ecx
+        push    ecx
+        mov     [ebx + 04h], eax
+        push    eax
+
+        ;
+        ; This is presumably the symbol the debugger hooks on to as the string
+        ; "__NLG_Dispatch" was found in vsdebugeng.manimpl.dll in VS2019.
+        ;
+global __NLG_Dispatch
+__NLG_Dispatch:
+
+        ; Drop the info structure from the stack.
+        add     esp, 4*3
+
+        ;
+        ; Restore registers and drop the parameter as we return.
+        ;
+        ; Note! This may sabotage attempts by the debugger to modify the state...
+        ;       But that can be fixed once we know this is a requirement. Just
+        ;       keep things simple for the caller for now.
+        ;
+        pop     ebx
+        pop     ebp
+        pop     ecx
+        pop     eax
+        ret
+
+;;
+; NLG call + return2.
+;
+; The "__NLG_Return2" symbol was observed in several vsdebugeng.manimpl.dll
+; strings in VS2019.
+;
+ALIGNCODE(4)
+GLOBALNAME_RAW __NLG_Call, function, hidden
+        call    eax
+
+global __NLG_Return2
+__NLG_Return2:
+        ret
+
+%endif
+
+
+;;
+; Calls the filter sub-function for a __finally statement.
+;
+; This sets all GRPs to zero, except for ESP, EBP and EAX.
+;
+; @param    pfnFilter   [ebp + 08h]
+; @param    fAbend      [ebp + 0ch]
+; @param    pbFrame     [ebp + 10h]
+;
+ALIGNCODE(64)
+BEGINPROC   rtVccEh4DoFinally
+        push    ebp
+        mov     ebp, esp
+        push    ebx
+        push    edi
+        push    esi
+
+        xor     edi, edi
+        xor     esi, esi
+%ifndef WITH_NLG_STUFF
+        xor     edx, edx
+%endif
+        xor     ebx, ebx
+
+        mov     eax, [ebp + 08h]            ; pfnFilter
+        movzx   ecx, byte [ebp + 0ch]       ; fAbend
+        mov     ebp, [ebp + 10h]            ; pbFrame
+
+%ifdef WITH_NLG_STUFF
+        mov     edx, 101h
+        call    __NLG_Notify
+        xor     edx, edx
+
+        call    __NLG_Call
+%else
+        call    eax
+%endif
+
+        pop     esi
+        pop     edi
+        pop     ebx
+        pop     ebp
+        ret
+ENDPROC   rtVccEh4DoFinally
+
+
+;;
+; Calls the filter sub-function for an __except statement.
+;
+; This sets all GRPs to zero, except for ESP, EBP and ECX.
+;
+; @param    pfnFilter   [ebp + 08h]
+; @param    pbFrame     [ebp + 0ch]
+;
+ALIGNCODE(32)
+BEGINPROC   rtVccEh4DoFiltering
+        push    ebp
+        push    ebx
+        push    edi
+        push    esi
+
+        mov     ecx, [esp + 5 * 4 + 0]      ; pfnFilter
+        mov     ebp, [esp + 5 * 4 + 4]      ; pbFrame
+
+        xor     edi, edi
+        xor     esi, esi
+        xor     edx, edx
+        xor     ebx, ebx
+        xor     eax, eax
+
+        call    ecx
+
+        pop     esi
+        pop     edi
+        pop     ebx
+        pop     ebp
+        ret
+ENDPROC   rtVccEh4DoFiltering
+
+
+;;
+; Resumes executing in an __except block (never returns).
+;
+; @param    pfnHandler  [ebp + 08h]
+; @param    pbFrame     [ebp + 0ch]
+;
+ALIGNCODE(32)
+BEGINPROC   rtVccEh4JumpToHandler
+        ;
+        ; Since we're never returning there is no need to save anything here.  So,
+        ; just start by loading parameters into registers.
+        ;
+        mov     esi, [esp + 1 * 4 + 0]      ; pfnFilter
+        mov     ebp, [esp + 1 * 4 + 4]      ; pbFrame
+
+%ifdef WITH_NLG_STUFF
+        ;
+        ; Notify VS debugger/whatever.
+        ;
+        mov     eax, esi
+        mov     edx, 1
+        call    __NLG_Notify
+%endif
+
+        ;
+        ; Zero all GPRs except for ESP, EBP and ESI.
+        ;
+        xor     edi, edi
+        xor     edx, edx
+        xor     ecx, ecx
+        xor     ebx, ebx
+        xor     eax, eax
+
+        jmp     esi
+ENDPROC   rtVccEh4JumpToHandler
+
+
+;;
+; This does global unwinding via RtlUnwind.
+;
+; The interface kind of requires us to do this from assembly.
+;
+; @param    pXcptRec    [ebp + 08h]
+; @param    pXcptRegRec [ebp + 0ch]
+;
+ALIGNCODE(32)
+BEGINPROC   rtVccEh4DoGlobalUnwind
+        push    ebp
+        mov     ebp, esp
+
+        ; Save all non-volatile registers.
+        push    edi
+        push    esi
+        push    ebx
+
+        ;
+        ; Call unwind function.
+        ;
+        push    0                   ; ReturnValue
+        push    dword [ebp + 08h]   ; ExceptionRecord   - pXcptRec
+        push    .return             ; TargetIp
+        push    dword [ebp + 0ch]   ; TargetFrame       - pXcptRegRec
+        call    IMP(RtlUnwind@16)
+
+        ;
+        ; The RtlUnwind code will place us here if it doesn't return the regular way.
+        ;
+.return:
+        ; Restore non-volatile registers.
+        pop     ebx
+        pop     esi
+        pop     edi
+
+        leave
+        ret
+ENDPROC   rtVccEh4DoGlobalUnwind
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/except-x86-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/except-x86-vcc.cpp
new file mode 100644
index 00000000..17dd3a0d
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/except-x86-vcc.cpp
@@ -0,0 +1,329 @@
+/* $Id: except-x86-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - x86 Exception Handler Filter.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/nt/nt-and-windows.h>
+
+#include "internal/compiler-vcc.h"
+#include "except-vcc.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/**
+ * Extended exception registration record used by rtVccEh4DoLocalUnwind
+ * and rtVccEh4DoLocalUnwindHandler.
+ */
+typedef struct EH4_LOCAL_UNWIND_XCPT_REG
+{
+    /** Security cookie. */
+    uintptr_t                       uEHCookieFront;
+    /** The actual registration record.   */
+    EXCEPTION_REGISTRATION_RECORD   XcptRegRec;
+    /** @name rtVccEh4DoLocalUnwind parameters
+     * @{ */
+    PEH4_XCPT_REG_REC_T             pEh4XcptRegRec;
+    uint32_t                        uTargetTryLevel;
+    uint8_t const                  *pbFrame;
+    /** @} */
+    /** Security cookie. */
+    uintptr_t                       uEHCookieBack;
+} EH4_LOCAL_UNWIND_XCPT_REG;
+
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+extern "C" uintptr_t __security_cookie;
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+DECLASM(LONG)                   rtVccEh4DoFiltering(PFN_EH4_XCPT_FILTER_T pfnFilter, uint8_t const *pbFrame);
+DECLASM(DECL_NO_RETURN(void))   rtVccEh4JumpToHandler(PFN_EH4_XCPT_HANDLER_T pfnHandler, uint8_t const *pbFrame);
+DECLASM(void)                   rtVccEh4DoGlobalUnwind(PEXCEPTION_RECORD pXcptRec, PEXCEPTION_REGISTRATION_RECORD pXcptRegRec);
+DECLASM(void)                   rtVccEh4DoFinally(PFN_EH4_FINALLY_T pfnFinally, bool fAbend, uint8_t const *pbFrame);
+extern "C" EXCEPTION_DISPOSITION __stdcall
+rtVccEh4DoLocalUnwindHandler(PEXCEPTION_RECORD pXcptRec, PVOID pvEstFrame, PCONTEXT pCpuCtx, PVOID pvDispCtx);
+
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4733)  /* warning C4733: Inline asm assigning to 'FS:0': handler not registered as safe handler */
+#endif
+
+/**
+ * Calls the __finally blocks up to @a uTargetTryLevel is reached, starting with
+ * @a pEh4XcptRegRec->uTryLevel.
+ *
+ * @param   pEh4XcptRegRec  The EH4 exception registration record.
+ * @param   uTargetTryLevel The target __try level to stop unwinding at.
+ * @param   pbFrame         The frame pointer (EBP).
+ */
+static void rtVccEh4DoLocalUnwind(PEH4_XCPT_REG_REC_T pEh4XcptRegRec, uint32_t uTargetTryLevel, uint8_t const *pbFrame)
+{
+    /*
+     * Manually set up exception handler.
+     */
+    EH4_LOCAL_UNWIND_XCPT_REG RegRec =
+    {
+        __security_cookie ^ (uintptr_t)&RegRec,
+        {
+            (EXCEPTION_REGISTRATION_RECORD *)__readfsdword(RT_UOFFSETOF(NT_TIB, ExceptionList)),
+            rtVccEh4DoLocalUnwindHandler /* safeseh (.sxdata) entry emitted by except-x86-vcc-asm.asm */
+        },
+        pEh4XcptRegRec,
+        uTargetTryLevel,
+        pbFrame,
+        __security_cookie ^ (uintptr_t)&RegRec
+    };
+    __writefsdword(RT_UOFFSETOF(NT_TIB, ExceptionList), (uintptr_t)&RegRec.XcptRegRec);
+
+    /*
+     * Do the unwinding.
+     */
+    uint32_t uCurTryLevel = pEh4XcptRegRec->uTryLevel;
+    while (   uCurTryLevel != EH4_TOPMOST_TRY_LEVEL
+           && (   uCurTryLevel > uTargetTryLevel
+               || uTargetTryLevel == EH4_TOPMOST_TRY_LEVEL /* if we knew what 0xffffffff meant, this could probably be omitted */ ))
+    {
+        PCEH4_SCOPE_TAB_T const pScopeTable = (PCEH4_SCOPE_TAB_T)(pEh4XcptRegRec->uEncodedScopeTable ^ __security_cookie);
+        PCEH4_SCOPE_TAB_REC_T const pEntry  = &pScopeTable->aScopeRecords[uCurTryLevel];
+
+        pEh4XcptRegRec->uTryLevel = uCurTryLevel = pEntry->uEnclosingLevel;
+
+        /* __finally scope table entries have no filter sub-function. */
+        if (!pEntry->pfnFilter)
+        {
+            //RTAssertMsg2("rtVccEh4DoLocalUnwind: Calling %p (level %#x)\n", pEntry->pfnFinally, uCurTryLevel);
+            rtVccEh4DoFinally(pEntry->pfnFinally, true /*fAbend*/, pbFrame);
+
+            /* Read the try level again in case it changed... */
+            uCurTryLevel = pEh4XcptRegRec->uTryLevel;
+        }
+    }
+
+    /*
+     * Deregister exception handler.
+     */
+    __writefsdword(RT_UOFFSETOF(NT_TIB, ExceptionList), (uintptr_t)RegRec.XcptRegRec.Next);
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+/**
+ * Exception handler for rtVccEh4DoLocalUnwind.
+ */
+EXCEPTION_DISPOSITION __stdcall
+rtVccEh4DoLocalUnwindHandler(PEXCEPTION_RECORD pXcptRec, PVOID pvEstFrame, PCONTEXT pCpuCtx, PVOID pvDispCtx)
+{
+    EH4_LOCAL_UNWIND_XCPT_REG *pMyRegRec = RT_FROM_MEMBER(pvEstFrame, EH4_LOCAL_UNWIND_XCPT_REG, XcptRegRec);
+    __security_check_cookie(pMyRegRec->uEHCookieFront ^ (uintptr_t)pMyRegRec);
+    __security_check_cookie(pMyRegRec->uEHCookieBack  ^ (uintptr_t)pMyRegRec);
+
+    /*
+     * This is a little sketchy as it isn't all that well documented by the OS
+     * vendor, but if invoked while unwinding, we return ExceptionCollidedUnwind
+     * and update the *ppDispCtx value to point to the colliding one.
+     */
+    if (pXcptRec->ExceptionFlags & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND))
+    {
+        rtVccEh4DoLocalUnwind(pMyRegRec->pEh4XcptRegRec, pMyRegRec->uTargetTryLevel, pMyRegRec->pbFrame);
+
+        PEXCEPTION_REGISTRATION_RECORD *ppDispCtx = (PEXCEPTION_REGISTRATION_RECORD *)pvDispCtx;
+        *ppDispCtx = &pMyRegRec->XcptRegRec;
+        return ExceptionCollidedUnwind;
+    }
+
+    /*
+     * In all other cases we do nothing special.
+     */
+    RT_NOREF(pCpuCtx);
+    return ExceptionContinueSearch;
+}
+
+
+/**
+ * This validates the CPU context, may terminate the application if invalid.
+ */
+DECLINLINE(void) rtVccValidateExceptionContextRecord(PCONTEXT pCpuCtx)
+{
+    if (RT_LIKELY(   !rtVccIsGuardICallChecksActive()
+                  || rtVccIsPointerOnTheStack(pCpuCtx->Esp)))
+    { /* likely */ }
+    else
+        rtVccCheckContextFailed(pCpuCtx);
+}
+
+
+/**
+ * Helper that validates stack cookies.
+ */
+DECLINLINE(void) rtVccEh4ValidateCookies(PCEH4_SCOPE_TAB_T pScopeTable, uint8_t const *pbFrame)
+{
+    if (pScopeTable->offGSCookie != EH4_NO_GS_COOKIE)
+    {
+        uintptr_t uGsCookie = *(uintptr_t const *)&pbFrame[pScopeTable->offGSCookie];
+        uGsCookie          ^=          (uintptr_t)&pbFrame[pScopeTable->offGSCookieXor];
+        __security_check_cookie(uGsCookie);
+    }
+
+    uintptr_t uEhCookie = *(uintptr_t const *)&pbFrame[pScopeTable->offEHCookie];
+    uEhCookie          ^=          (uintptr_t)&pbFrame[pScopeTable->offEHCookieXor];
+    __security_check_cookie(uEhCookie);
+}
+
+
+/**
+ * Call exception filters, handlers and unwind code for x86 code.
+ *
+ * This is called for windows' structured exception handling (SEH) in x86 32-bit
+ * code, i.e. the __try/__except/__finally stuff in Visual C++.  The compiler
+ * generate scope records for the __try/__except blocks as well as unwind
+ * records for __finally and probably C++ stack object destructors.
+ *
+ * @returns Exception disposition.
+ * @param   pXcptRec    The exception record.
+ * @param   pXcptRegRec The exception registration record, taken to be the frame
+ *                      address.
+ * @param   pCpuCtx     The CPU context for the exception.
+ * @param   pDispCtx    Dispatcher context.
+ */
+extern "C" __declspec(guard(suppress))
+DWORD _except_handler4(PEXCEPTION_RECORD pXcptRec, PEXCEPTION_REGISTRATION_RECORD pXcptRegRec, PCONTEXT pCpuCtx, PVOID pvCtx)
+{
+    /*
+     * The registration record (probably chained on FS:[0] like in the OS/2 days)
+     * points to a larger structure specific to _except_handler4.  The structure
+     * is planted right after the saved caller EBP value when establishing the
+     * stack frame, so EBP = pXcptRegRec + 1;
+     */
+    PEH4_XCPT_REG_REC_T const pEh4XcptRegRec = RT_FROM_MEMBER(pXcptRegRec, EH4_XCPT_REG_REC_T, XcptRec);
+    uint8_t * const           pbFrame        = (uint8_t *)&pEh4XcptRegRec[1];
+    PCEH4_SCOPE_TAB_T const   pScopeTable    = (PCEH4_SCOPE_TAB_T)(pEh4XcptRegRec->uEncodedScopeTable ^ __security_cookie);
+
+    /*
+     * Validate the stack cookie and exception context.
+     */
+    rtVccEh4ValidateCookies(pScopeTable, pbFrame);
+    rtVccValidateExceptionContextRecord(pCpuCtx);
+
+    /*
+     * If dispatching an exception, call the exception filter functions and jump
+     * to the __except blocks if so directed.
+     */
+    if (IS_DISPATCHING(pXcptRec->ExceptionFlags))
+    {
+        uint32_t uTryLevel = pEh4XcptRegRec->uTryLevel;
+        //RTAssertMsg2("_except_handler4: dispatch: uTryLevel=%#x\n", uTryLevel);
+        while (uTryLevel != EH4_TOPMOST_TRY_LEVEL)
+        {
+            PCEH4_SCOPE_TAB_REC_T const pEntry    = &pScopeTable->aScopeRecords[uTryLevel];
+            PFN_EH4_XCPT_FILTER_T const pfnFilter = pEntry->pfnFilter;
+            if (pfnFilter)
+            {
+                /* Call the __except filtering expression: */
+                //RTAssertMsg2("_except_handler4: Calling pfnFilter=%p\n", pfnFilter);
+                EXCEPTION_POINTERS XcptPtrs = { pXcptRec, pCpuCtx };
+                pEh4XcptRegRec->pXctpPtrs = &XcptPtrs;
+                LONG lRet = rtVccEh4DoFiltering(pfnFilter, pbFrame);
+                pEh4XcptRegRec->pXctpPtrs = NULL;
+                //RTAssertMsg2("_except_handler4: pfnFilter=%p -> %ld\n", pfnFilter, lRet);
+                rtVccEh4ValidateCookies(pScopeTable, pbFrame);
+
+                /* Return if we're supposed to continue execution (the convention
+                   it to match negative values rather than the exact defined value):  */
+                AssertCompile(EXCEPTION_CONTINUE_EXECUTION == -1);
+                if (lRet <= EXCEPTION_CONTINUE_EXECUTION)
+                    return ExceptionContinueExecution;
+
+                /* Similarly, the handler is executed for any positive value. */
+                AssertCompile(EXCEPTION_CONTINUE_SEARCH == 0);
+                AssertCompile(EXCEPTION_EXECUTE_HANDLER == 1);
+                if (lRet >= EXCEPTION_EXECUTE_HANDLER)
+                {
+                    /* We're about to resume execution in the __except block, so unwind
+                       up to it first. */
+                    //RTAssertMsg2("_except_handler4: global unwind\n");
+                    rtVccEh4DoGlobalUnwind(pXcptRec, &pEh4XcptRegRec->XcptRec);
+                    if (pEh4XcptRegRec->uTryLevel != EH4_TOPMOST_TRY_LEVEL)
+                    {
+                        //RTAssertMsg2("_except_handler4: local unwind\n");
+                        rtVccEh4DoLocalUnwind(pEh4XcptRegRec, uTryLevel, pbFrame);
+                    }
+                    rtVccEh4ValidateCookies(pScopeTable, pbFrame);
+
+                    /* Now jump to the __except block.  This will _not_ return. */
+                    //RTAssertMsg2("_except_handler4: jumping to __except block %p (level %#x)\n", pEntry->pfnHandler, pEntry->uEnclosingLevel);
+                    pEh4XcptRegRec->uTryLevel = pEntry->uEnclosingLevel;
+                    rtVccEh4ValidateCookies(pScopeTable, pbFrame); /* paranoia^2 */
+
+                    rtVccEh4JumpToHandler(pEntry->pfnHandler, pbFrame);
+                    /* (not reached) */
+                }
+            }
+
+            /*
+             * Next try level.
+             */
+            uTryLevel = pEntry->uEnclosingLevel;
+        }
+    }
+    /*
+     * If not dispatching we're unwinding, so we call any __finally blocks.
+     */
+    else
+    {
+        //RTAssertMsg2("_except_handler4: unwind: uTryLevel=%#x\n", pEh4XcptRegRec->uTryLevel);
+        if (pEh4XcptRegRec->uTryLevel != EH4_TOPMOST_TRY_LEVEL)
+        {
+            rtVccEh4DoLocalUnwind(pEh4XcptRegRec, EH4_TOPMOST_TRY_LEVEL, pbFrame);
+            rtVccEh4ValidateCookies(pScopeTable, pbFrame);
+        }
+    }
+
+    RT_NOREF(pvCtx);
+    return ExceptionContinueSearch;
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/fltused-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/fltused-vcc.cpp
new file mode 100644
index 00000000..d26f2b90
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/fltused-vcc.cpp
@@ -0,0 +1,58 @@
+/* $Id: fltused-vcc.cpp $ */
+/** @file
+ * IPRT - No-CRT - Basic allocators, Windows.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include "internal/compiler-vcc.h"
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Very like some remnant from the 8086, 286 and 386 days of DOS, OS/2 and
+ * similar, where you could link with different floating point libs.  My guess
+ * would be that this constant indicates to the compiled code which floating
+ * point support the library provides, probably especially as it comes to
+ * printf and scanf conversion but probably also emulation/real hw.
+ *
+ * Found some old 16-bit and 32-bit MSC C libraries (probably around v6.0)
+ * which all seems to define it as 0x9876.  They also have a whole bunch of
+ * external dependencies on what seems to be mostly conversion helpers.
+ */
+unsigned _fltused = 0x9875;
diff --git a/src/VBox/Runtime/common/compiler/vcc/ftol2-vcc.asm b/src/VBox/Runtime/common/compiler/vcc/ftol2-vcc.asm
new file mode 100644
index 00000000..40bd3fa2
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/ftol2-vcc.asm
@@ -0,0 +1,80 @@
+; $Id: ftol2-vcc.asm $
+;; @file
+; IPRT - Floating Point to Integer related Visual C++ support routines.
+;
+
+;
+; Copyright (C) 2022-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+; in the VirtualBox distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+; SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+;
+
+
+%include "iprt/asmdefs.mac"
+%include "iprt/x86.mac"
+
+
+;;
+; Convert st0 to integer returning it in eax, popping st0.
+;
+; @returns  value in eax
+; @param    st0     The value to convet.  Will be popped.
+; @uses     eax, st0, FSW.TOP
+;
+GLOBALNAME_RAW  __ftol2_sse_excpt, function, RT_NOTHING
+GLOBALNAME_RAW  __ftol2_sse, function, RT_NOTHING ;; @todo kind of expect __ftol2_sse to take input in xmm0 and return in edx:eax.
+BEGINPROC_RAW   __ftoi2
+        push    ebp
+        mov     ebp, esp
+        sub     esp, 8h
+        fisttp  dword [esp]
+        mov     eax, [esp]
+        leave
+        ret
+ENDPROC_RAW     __ftoi2
+
+
+;;
+; Convert st0 to integer returning it in edx:eax, popping st0.
+;
+; @returns  value in edx:eax
+; @param    st0     The value to convet.  Will be popped.
+; @uses     eax, edx, st0, FSW.TOP
+;
+BEGINPROC_RAW   __ftol2
+        push    ebp
+        mov     ebp, esp
+        sub     esp, 8h
+        and     esp, 0fffffff8h             ; proper alignment.
+        fisttp  qword [esp]
+        mov     eax, [esp]
+        mov     edx, [esp + 4]
+        leave
+        ret
+ENDPROC_RAW     __ftol2
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/guard-vcc.asm b/src/VBox/Runtime/common/compiler/vcc/guard-vcc.asm
new file mode 100644
index 00000000..42e6d5a8
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/guard-vcc.asm
@@ -0,0 +1,108 @@
+; $Id: guard-vcc.asm $
+;; @file
+; IPRT - Control Flow Guard related Visual C++ support routines.
+;
+
+;
+; Copyright (C) 2022-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+; in the VirtualBox distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+; SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+;
+
+
+
+;*********************************************************************************************************************************
+;*      Header Files                                                                                                             *
+;*********************************************************************************************************************************
+%include "iprt/asmdefs.mac"
+%include "iprt/x86.mac"
+
+
+
+;*********************************************************************************************************************************
+;*  Global Variables                                                                                                             *
+;*********************************************************************************************************************************
+
+;
+; Points to a NOP icall checker by default.
+; The loader will replace this when we start advertising it in the load config.
+;
+section .0000cfg rdata align=8
+
+GLOBALNAME __guard_check_icall_fptr
+        RTCCPTR_DEF     NAME(__guard_check_icall_nop)
+
+%ifdef RT_ARCH_AMD64
+GLOBALNAME __guard_dispatch_icall_fptr
+        RTCCPTR_DEF     __guard_dispatch_icall_nop
+
+; xfg stuff (haven't seen it generated or used yet).
+GLOBALNAME __guard_xfg_check_icall_fptr
+        RTCCPTR_DEF     __guard_check_icall_nop
+
+GLOBALNAME __guard_xfg_dispatch_icall_fptr
+        RTCCPTR_DEF     __guard_xfg_dispatch_icall_nop
+
+GLOBALNAME __guard_xfg_table_dispatch_icall_fptr
+        RTCCPTR_DEF     __guard_xfg_dispatch_icall_nop
+
+%endif
+
+
+BEGINCODE
+;;
+; Check that doesn't do anything.
+;
+; This is for older windows versions which doesn't support call flow guard stuff.
+;
+BEGINPROC __guard_check_icall_nop
+        ret
+ENDPROC   __guard_check_icall_nop
+
+%ifdef RT_ARCH_AMD64
+;;
+; Target function in RAX
+;
+; This is for older windows versions which doesn't support call flow guard stuff.
+;
+BEGINPROC __guard_dispatch_icall_nop
+        jmp     rax
+ENDPROC   __guard_dispatch_icall_nop
+%endif
+
+%ifdef RT_ARCH_AMD64
+;;
+; Target function in RAX
+;
+; This is for windows versions which doesn't support extended call flow guard stuff.
+;
+BEGINPROC __guard_xfg_dispatch_icall_nop
+        jmp     [__guard_dispatch_icall_nop wrt RIP]
+ENDPROC   __guard_xfg_dispatch_icall_nop
+%endif
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/initializers-c-cpp-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/initializers-c-cpp-vcc.cpp
new file mode 100644
index 00000000..0fc451db
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/initializers-c-cpp-vcc.cpp
@@ -0,0 +1,158 @@
+/* $Id: initializers-c-cpp-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - C & C++ Initializers and Terminators.
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define IPRT_COMPILER_VCC_WITH_C_INIT_TERM_SECTIONS
+#define IPRT_COMPILER_VCC_WITH_CPP_INIT_SECTIONS
+#include "internal/compiler-vcc.h"
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+typedef void (__cdecl *PFNVCINITTERM)(void);
+typedef int  (__cdecl *PFNVCINITTERMRET)(void);
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** @name Initializer arrays.
+ *
+ * The important thing here are the section names, the linker wi.
+ *
+ * @{ */
+/** Start of the C initializer array. */
+__declspec(allocate(".CRT$XIA"))    PFNVCINITTERMRET    g_apfnRTVccInitializers_C_Start     = NULL;
+/** End of the C initializer array. */
+__declspec(allocate(".CRT$XIZ"))    PFNVCINITTERMRET    g_apfnRTVccInitializers_C_End       = NULL;
+
+/** Start of the C pre-terminator array. */
+__declspec(allocate(".CRT$XPA"))    PFNVCINITTERM       g_apfnRTVccEarlyTerminators_C_Start = NULL;
+/** End of the C pre-terminator array. */
+__declspec(allocate(".CRT$XPZ"))    PFNVCINITTERM       g_apfnRTVccEarlyTerminators_C_End   = NULL;
+
+/** Start of the C terminator array. */
+__declspec(allocate(".CRT$XTA"))    PFNVCINITTERM       g_apfnRTVccTerminators_C_Start      = NULL;
+/** End of the C terminator array. */
+__declspec(allocate(".CRT$XTZ"))    PFNVCINITTERM       g_apfnRTVccTerminators_C_End        = NULL;
+
+/** Start of the C++ initializer array. */
+__declspec(allocate(".CRT$XCA"))    PFNVCINITTERM       g_apfnRTVccInitializers_Cpp_Start   = NULL;
+/** End of the C++ initializer array. */
+__declspec(allocate(".CRT$XCZ"))    PFNVCINITTERM       g_apfnRTVccInitializers_Cpp_End     = NULL;
+
+
+/* Tell the linker to merge the .CRT* sections into .rdata */
+#pragma comment(linker, "/merge:.CRT=.rdata ")
+/** @} */
+
+
+/**
+ * Runs the C and C++ initializers.
+ *
+ * @returns 0 on success, non-zero return from C initalizer on failure.
+ */
+int rtVccInitializersRunInit(void)
+{
+    /*
+     * Run the C initializers first.
+     */
+    for (PFNVCINITTERMRET *ppfn = &g_apfnRTVccInitializers_C_Start;
+         (uintptr_t)ppfn < (uintptr_t)&g_apfnRTVccInitializers_C_End;
+         ppfn++)
+    {
+        PFNVCINITTERMRET const pfn = *ppfn;
+        if (pfn)
+        {
+            int const rc = pfn();
+            if (RT_LIKELY(rc == 0))
+            { /* likely */ }
+            else
+                return rc;
+        }
+    }
+
+    /*
+     * Run the C++ initializers.
+     */
+    for (PFNVCINITTERM *ppfn = &g_apfnRTVccInitializers_Cpp_Start;
+         (uintptr_t)ppfn < (uintptr_t)&g_apfnRTVccInitializers_Cpp_End;
+         ppfn++)
+    {
+        PFNVCINITTERM const pfn = *ppfn;
+        if (pfn)
+            pfn();
+    }
+
+    return 0;
+}
+
+
+/**
+ * Runs the C terminator callbacks.
+ */
+void rtVccInitializersRunTerm(void)
+{
+    /*
+     * First the early terminators.
+     */
+    for (PFNVCINITTERM *ppfn = &g_apfnRTVccEarlyTerminators_C_Start;
+         (uintptr_t)ppfn < (uintptr_t)&g_apfnRTVccEarlyTerminators_C_End;
+         ppfn++)
+    {
+        PFNVCINITTERM const pfn = *ppfn;
+        if (pfn)
+            pfn();
+    }
+
+    /*
+     * Then the real terminator list.
+     */
+    for (PFNVCINITTERM *ppfn = &g_apfnRTVccTerminators_C_Start;
+         (uintptr_t)ppfn < (uintptr_t)&g_apfnRTVccTerminators_C_End;
+         ppfn++)
+    {
+        PFNVCINITTERM const pfn = *ppfn;
+        if (pfn)
+            pfn();
+    }
+
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/loadcfg-vcc.c b/src/VBox/Runtime/common/compiler/vcc/loadcfg-vcc.c
new file mode 100644
index 00000000..c213db19
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/loadcfg-vcc.c
@@ -0,0 +1,154 @@
+/* $Id: loadcfg-vcc.c $ */
+/** @file
+ * IPRT - Visual C++ Compiler - PE/Windows Load Configuration.
+ *
+ * @note This is a C file and not C++ because the compiler generates fixups
+ *       that upsets the linker (ADDR32 + ADDR32_4 instead of ADDR64).
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/formats/pecoff.h>
+
+#include "internal/compiler-vcc.h"
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+extern uintptr_t    __security_cookie;          /**< nocrt-stack-win.asm */
+#ifdef RT_ARCH_X86
+extern uintptr_t    __safe_se_handler_table[];  /**< Linker generated. */
+extern uint8_t      __safe_se_handler_count;    /**< Absolute "address" defined by the linker representing the table size. */
+#endif
+#ifdef RT_ARCH_AMD64
+extern uintptr_t    __guard_dispatch_icall_fptr;/**< nocrt-guard-win.asm */
+#endif
+extern uintptr_t    __guard_fids_table[];       /**< Linker generated. */
+extern uint8_t      __guard_fids_count;         /** Another absolute "address" generated by the linker for a table size. */
+extern uint8_t      __guard_flags;              /** Another absolute "address" generated by the linker, flags value this time. */
+extern uintptr_t    __guard_iat_table[];        /**< Linker generated. */
+extern uint8_t      __guard_iat_count;          /** Another absolute "address" generated by the linker for a table size. */
+extern uintptr_t    __guard_longjmp_table[];    /**< Linker generated. */
+extern uint8_t      __guard_longjmp_count;      /** Another absolute "address" generated by the linker for a table size. */
+extern uint8_t      __enclave_config;           /** Another absolute "address" generated by the linker, flags value this time. */
+extern uintptr_t    __guard_eh_cont_table[];    /**< Linker generated. */
+extern uint8_t      __guard_eh_cont_count;      /** Another absolute "address" generated by the linker for a table size. */
+#ifdef RT_ARCH_AMD64
+extern uintptr_t    __guard_xfg_check_icall_fptr;           /**< nocrt-guard-win.asm */
+extern uintptr_t    __guard_xfg_dispatch_icall_fptr;        /**< nocrt-guard-win.asm */
+extern uintptr_t    __guard_xfg_table_dispatch_icall_fptr;  /**< nocrt-guard-win.asm */
+#endif
+
+
+/**
+ * The load configuration for the PE image.
+ *
+ * The name of this is dictated by the linker, as it looks for a
+ * _load_config_used symbol and puts it's address and (somehow) size in the load
+ * config data dir entry.
+ *
+ * @todo use _MSC_VER to reduce this for older linkers which doesn't support all
+ *       the machinactions we include here for the 2019 (14.29.30139.0) linker.
+ */
+RT_CONCAT(IMAGE_LOAD_CONFIG_DIRECTORY, ARCH_BITS) const _load_config_used =
+{
+    /* .Size                                = */    sizeof(_load_config_used),
+    /* .TimeDateStamp                       = */    0,
+    /* .MajorVersion                        = */    0,
+    /* .MinorVersion                        = */    0,
+    /* .GlobalFlagsClear                    = */    0,
+    /* .GlobalFlagsSet                      = */    0,
+    /* .CriticalSectionDefaultTimeout       = */    0,
+    /* .DeCommitFreeBlockThreshold          = */    0,
+    /* .DeCommitTotalFreeThreshold          = */    0,
+    /* .LockPrefixTable                     = */    0,
+    /* .MaximumAllocationSize               = */    0,
+    /* .VirtualMemoryThreshold              = */    0,
+    /* .ProcessHeapFlags                    = */    0,
+    /* .ProcessAffinityMask                 = */    0,
+    /* .CSDVersion                          = */    0,
+    /* .DependentLoadFlags                  = */    0,
+    /* .EditList                            = */    0,
+    /* .SecurityCookie                      = */    (uintptr_t)&__security_cookie,
+#ifdef RT_ARCH_X86
+    /* .SEHandlerTable                      = */    (uintptr_t)&__safe_se_handler_table[0],
+    /* .SEHandlerCount                      = */    (uintptr_t)&__safe_se_handler_count,    /* Absolute "address", remember. */
+#else
+    /* .SEHandlerTable                      = */    0,
+    /* .SEHandlerCount                      = */    0,
+#endif
+    /* .GuardCFCCheckFunctionPointer        = */    (uintptr_t)&__guard_check_icall_fptr,
+#ifdef RT_ARCH_AMD64
+    /* .GuardCFDispatchFunctionPointer      = */    (uintptr_t)&__guard_dispatch_icall_fptr,
+#else
+    /* .GuardCFDispatchFunctionPointer      = */    0,
+#endif
+    /* .GuardCFFunctionTable                = */    (uintptr_t)&__guard_fids_table[0],
+    /* .GuardCFFunctionCount                = */    (uintptr_t)&__guard_fids_count,         /* Absolute "address", remember. */
+    /* .GuardFlags                          = */    (uint32_t)(uintptr_t)&__guard_flags,    /* Ditto. */
+    /* .CodeIntegrity                       = */    { 0, 0, 0, 0 },
+    /* .GuardAddressTakenIatEntryTable      = */    (uintptr_t)__guard_iat_table,
+    /* .GuardAddressTakenIatEntryCount      = */    (uintptr_t)&__guard_iat_count,          /* The same. */
+    /* .GuardLongJumpTargetTable            = */    (uintptr_t)&__guard_longjmp_table[0],
+    /* .GuardLongJumpTargetCount            = */    (uintptr_t)&__guard_longjmp_count,      /* Another one. */
+    /* .DynamicValueRelocTable              = */    0,
+    /* .CHPEMetadataPointer                 = */    0, /** @todo ARM */
+    /* .GuardRFFailureRoutine               = */    0,
+    /* .GuardRFFailureRoutineFunctionPointer= */    0,
+    /* .DynamicValueRelocTableOffset        = */    0,
+    /* .DynamicValueRelocTableSection       = */    0,
+    /* .Reserved2                           = */    0,
+    /* .GuardRFVerifyStackPointerFunctionPointer=*/ 0,
+    /* .HotPatchTableOffset                 = */    0,
+    /* .Reserved3                           = */    0,
+    /* .EnclaveConfigurationPointer         = */    (uintptr_t)&__enclave_config,           /* And another one. */
+    /* .VolatileMetadataPointer             = */    0,
+    /* .GuardEHContinuationTable            = */    (uintptr_t)&__guard_eh_cont_table[0],
+    /* .GuardEHContinuationCount            = */    (uintptr_t)&__guard_eh_cont_count,      /* Yet another one. */
+#ifdef RT_ARCH_AMD64
+    /* .GuardXFGCheckFunctionPointer        = */    (uintptr_t)&__guard_xfg_check_icall_fptr,
+    /* .GuardXFGDispatchFunctionPointer     = */    (uintptr_t)&__guard_xfg_dispatch_icall_fptr,
+    /* .GuardXFGTableDispatchFunctionPointer= */    (uintptr_t)&__guard_xfg_table_dispatch_icall_fptr,
+#else
+    /* .GuardXFGCheckFunctionPointer        = */    0,
+    /* .GuardXFGDispatchFunctionPointer     = */    0,
+    /* .GuardXFGTableDispatchFunctionPointer= */    0,
+#endif
+    /* .CastGuardOsDeterminedFailureMode    = */    0,
+};
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/purecall-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/purecall-vcc.cpp
new file mode 100644
index 00000000..d76b3b4d
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/purecall-vcc.cpp
@@ -0,0 +1,63 @@
+/* $Id: purecall-vcc.cpp $ */
+/** @file
+ * IPRT - No-CRT - Pure virtual method vtable filler.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/nocrt.h"
+
+#include <iprt/asm.h>
+#ifndef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+# include <iprt/assert.h>
+#endif
+
+#include "internal/compiler-vcc.h"
+
+
+extern "C" int __cdecl _purecall(void)
+{
+#ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!%p called _purecall!!\n\n", ASMReturnAddress());
+#else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!_purecall called from "));
+    rtNoCrtFatalWritePtr(ASMReturnAddress());
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("!!\r\n\r\n"));
+#endif
+    RT_BREAKPOINT();
+    return 0;
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/stack-except-seh-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/stack-except-seh-vcc.cpp
new file mode 100644
index 00000000..ff611e47
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/stack-except-seh-vcc.cpp
@@ -0,0 +1,117 @@
+/* $Id: stack-except-seh-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - Stack Checking, __GSHandlerCheck_SEH.
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/nocrt.h"
+
+#include "except-vcc.h"
+
+
+#if !defined(RT_ARCH_AMD64)
+# error "This file is for AMD64 (and probably ARM, but needs porting)"
+#endif
+
+
+
+/**
+ * Check the stack cookie before calling the exception handler.
+ *
+ * This is to prevent attackers from bypassing stack cookie checking by
+ * triggering an exception.
+ *
+ * This is called for windows' structured exception handling (SEH), i.e. the
+ * __try/__except/__finally stuff in Visual C++, for which the compiler
+ * generates somewhat different strctures compared to the plain __GSHanderCheck
+ * scenario.
+ *
+ * @returns Exception disposition.
+ * @param   pXcptRec    The exception record.
+ * @param   pXcptRegRec The exception registration record, taken to be the frame
+ *                      address.
+ * @param   pCpuCtx     The CPU context for the exception.
+ * @param   pDispCtx    Dispatcher context.
+ */
+extern "C" __declspec(guard(suppress))
+EXCEPTION_DISPOSITION __GSHandlerCheck_SEH(PEXCEPTION_RECORD pXcptRec, PEXCEPTION_REGISTRATION_RECORD pXcptRegRec,
+                                           PCONTEXT pCpuCtx, PDISPATCHER_CONTEXT pDispCtx)
+{
+    /*
+     * The HandlerData points to a scope table, which is then followed by GS_HANDLER_DATA.
+     *
+     * Sample offCookie values: 0521H (tst.cpp), 02caH (installNetLwf), and 0502H (installNetFlt).
+     */
+    SCOPE_TABLE const *pScopeTable  = (SCOPE_TABLE const *)pDispCtx->HandlerData;
+    PCGS_HANDLER_DATA  pHandlerData = (PCGS_HANDLER_DATA)&pScopeTable->ScopeRecord[pScopeTable->Count];
+
+    /*
+     * Locate the stack cookie and call the regular stack cookie checker routine.
+     * (Same code as in __GSHandlerCheck, fixes applies both places.)
+     */
+    /* Calculate the cookie address and read it. */
+    uintptr_t uPtrFrame = (uintptr_t)pXcptRegRec;
+    uint32_t  offCookie = pHandlerData->u.offCookie;
+    if (offCookie & GS_HANDLER_OFF_COOKIE_HAS_ALIGNMENT)
+    {
+        uPtrFrame += pHandlerData->offAlignedBase;
+        uPtrFrame &= ~(uintptr_t)pHandlerData->uAlignmentMask;
+    }
+    uintptr_t uCookie = *(uintptr_t const *)(uPtrFrame + (int32_t)(offCookie & GS_HANDLER_OFF_COOKIE_MASK));
+
+    /* The stored cookie is xor'ed with the frame / registration record address
+       or with the frame pointer register if one is being used.  In the latter
+       case, we have to add the frame offset to get the correct address. */
+    uintptr_t uXorAddr = (uintptr_t)pXcptRegRec;
+    PCIMAGE_UNWIND_INFO pUnwindInfo = (PCIMAGE_UNWIND_INFO)(pDispCtx->ImageBase + pDispCtx->FunctionEntry->UnwindInfoAddress);
+    if (pUnwindInfo->FrameRegister != 0)
+        uXorAddr += pUnwindInfo->FrameOffset << 4;
+
+    /* This call will not return on failure. */
+    __security_check_cookie(uCookie ^ uXorAddr);
+
+
+    /*
+     * Now call the handler if the GS handler data indicates that we ought to.
+     */
+    if (  (IS_UNWINDING(pXcptRec->ExceptionFlags) ? GS_HANDLER_OFF_COOKIE_IS_UHANDLER : GS_HANDLER_OFF_COOKIE_IS_EHANDLER)
+        & pHandlerData->u.offCookie)
+        return __C_specific_handler(pXcptRec, pXcptRegRec, pCpuCtx, pDispCtx);
+
+    return ExceptionContinueSearch;
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/stack-except-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/stack-except-vcc.cpp
new file mode 100644
index 00000000..13ea35b1
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/stack-except-vcc.cpp
@@ -0,0 +1,106 @@
+/* $Id: stack-except-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - Stack Checking, __GSHandlerCheck.
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/nocrt.h"
+
+#include "except-vcc.h"
+
+
+#if !defined(RT_ARCH_AMD64)
+# error "This file is for AMD64 (and probably ARM, but needs porting)"
+#endif
+
+
+
+/**
+ * Check the stack cookie before calling the exception handler.
+ *
+ * This is to prevent attackers from bypassing stack cookie checking by
+ * triggering an exception.
+ *
+ * This does not call any C++ exception handlers, as it's probably (still
+ * figuring this stuff out) only used when C++ exceptions are disabled.
+ *
+ * @returns Exception disposition.
+ * @param   pXcptRec    The exception record.
+ * @param   pXcptRegRec The exception registration record, taken to be the frame
+ *                      address.
+ * @param   pCpuCtx     The CPU context for the exception.
+ * @param   pDispCtx    Dispatcher context.
+ */
+extern "C" __declspec(guard(suppress))
+EXCEPTION_DISPOSITION __GSHandlerCheck(PEXCEPTION_RECORD pXcptRec, PEXCEPTION_REGISTRATION_RECORD pXcptRegRec,
+                                       PCONTEXT pCpuCtx, PDISPATCHER_CONTEXT pDispCtx)
+{
+    RT_NOREF(pXcptRec, pCpuCtx);
+
+    /*
+     * Only GS handler data here.
+     */
+    PCGS_HANDLER_DATA pHandlerData = (PCGS_HANDLER_DATA)pDispCtx->HandlerData;
+
+    /*
+     * Locate the stack cookie and call the regular stack cookie checker routine.
+     * (Same code as in __GSHandlerCheck_SEH, fixes applies both places.)
+     */
+    /* Calculate the cookie address and read it. */
+    uintptr_t uPtrFrame = (uintptr_t)pXcptRegRec;
+    uint32_t  offCookie = pHandlerData->u.offCookie;
+    if (offCookie & GS_HANDLER_OFF_COOKIE_HAS_ALIGNMENT)
+    {
+        uPtrFrame += pHandlerData->offAlignedBase;
+        uPtrFrame &= ~(uintptr_t)pHandlerData->uAlignmentMask;
+    }
+    uintptr_t uCookie = *(uintptr_t const *)(uPtrFrame + (int32_t)(offCookie & GS_HANDLER_OFF_COOKIE_MASK));
+
+    /* The stored cookie is xor'ed with the frame / registration record address
+       or with the frame pointer register if one is being used.  In the latter
+       case, we have to add the frame offset to get the correct address. */
+    uintptr_t uXorAddr = (uintptr_t)pXcptRegRec;
+    PCIMAGE_UNWIND_INFO pUnwindInfo = (PCIMAGE_UNWIND_INFO)(pDispCtx->ImageBase + pDispCtx->FunctionEntry->UnwindInfoAddress);
+    if (pUnwindInfo->FrameRegister != 0)
+        uXorAddr += pUnwindInfo->FrameOffset << 4;
+
+    /* This call will not return on failure. */
+    __security_check_cookie(uCookie ^ uXorAddr);
+
+    return ExceptionContinueSearch;
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/stack-probe-vcc.asm b/src/VBox/Runtime/common/compiler/vcc/stack-probe-vcc.asm
new file mode 100644
index 00000000..da2e2965
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/stack-probe-vcc.asm
@@ -0,0 +1,157 @@
+; $Id: stack-probe-vcc.asm $
+;; @file
+; IPRT - Stack related Visual C++ support routines.
+;
+
+;
+; Copyright (C) 2022-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+; in the VirtualBox distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+; SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+;
+
+
+
+;*********************************************************************************************************************************
+;*      Header Files                                                                                                             *
+;*********************************************************************************************************************************
+%if 0 ; YASM's builtin SEH64 support doesn't cope well with code alignment, so use our own.
+ %define RT_ASM_WITH_SEH64
+%else
+ %define RT_ASM_WITH_SEH64_ALT
+%endif
+%include "iprt/asmdefs.mac"
+%include "iprt/x86.mac"
+
+
+;;
+; Probe stack to trigger guard faults, and for x86 to allocate stack space.
+;
+; @param    xAX     Frame size.
+; @uses     AMD64:  Probably nothing. EAX is certainly not supposed to change.
+;           x86:    ESP = ESP - EAX; EFLAGS, nothing else
+;
+ALIGNCODE(64)
+GLOBALNAME_RAW  __alloca_probe, __alloca_probe, function
+BEGINPROC_RAW   __chkstk
+        push    xBP
+        SEH64_PUSH_xBP
+        mov     xBP, xSP
+        SEH64_SET_FRAME_xBP 0
+        push    xAX
+        SEH64_PUSH_GREG xAX
+        push    xBX
+        SEH64_PUSH_GREG xBX
+        SEH64_END_PROLOGUE
+
+        ;
+        ; Adjust eax so we're relative to [xBP - xCB*2].
+        ;
+        sub     xAX, xCB * 4
+        jle     .touch_loop_done            ; jump if rax < xCB*4, very unlikely
+
+        ;
+        ; Subtract what's left of the current page from eax and only engage
+        ; the touch loop if (int)xAX > 0.
+        ;
+        lea     ebx, [ebp - xCB * 2]
+        and     ebx, PAGE_SIZE - 1
+        sub     xAX, xBX
+        jnl     .touch_loop                 ; jump if pages to touch.
+
+.touch_loop_done:
+        pop     xBX
+        pop     xAX
+        leave
+%ifndef RT_ARCH_X86
+        ret
+%else
+        ;
+        ; Do the stack space allocation and jump to the return location.
+        ;
+        sub     esp, eax
+        add     esp, 4
+        jmp     dword [esp + eax - 4]
+%endif
+
+        ;
+        ; The touch loop.
+        ;
+.touch_loop:
+        sub     xBX, PAGE_SIZE
+%if 1
+        mov     [xBP + xBX - xCB * 2], bl
+%else
+        or      byte [xBP + xBX - xCB * 2], 0   ; non-destructive variant...
+%endif
+        sub     xAX, PAGE_SIZE
+        jnl     .touch_loop
+        jmp     .touch_loop_done
+ENDPROC_RAW     __chkstk
+
+
+%ifdef RT_ARCH_X86
+;;
+; 8 and 16 byte aligned alloca w/ probing.
+;
+; This routine adjusts the allocation size so __chkstk will return a
+; correctly aligned allocation.
+;
+; @param    xAX     Unaligned allocation size.
+;
+%macro __alloc_probe_xxx 1
+ALIGNCODE(16)
+BEGINPROC_RAW   __alloca_probe_ %+ %1
+        push    ecx
+
+        ;
+        ; Calc the ESP address after the allocation and adjust EAX so that it
+        ; will be aligned as desired.
+        ;
+        lea     ecx, [esp + 8]
+        sub     ecx, eax
+        and     ecx, %1 - 1
+        add     eax, ecx
+        jc      .bad_alloc_size
+.continue:
+
+        pop     ecx
+        jmp     __alloca_probe
+
+.bad_alloc_size:
+  %ifdef RT_STRICT
+        int3
+  %endif
+        or      eax, 0xfffffff0
+        jmp     .continue
+ENDPROC_RAW     __alloca_probe_ %+ %1
+%endmacro
+
+__alloc_probe_xxx 16
+__alloc_probe_xxx 8
+%endif ; RT_ARCH_X86
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/stack-vcc.asm b/src/VBox/Runtime/common/compiler/vcc/stack-vcc.asm
new file mode 100644
index 00000000..edfd5750
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/stack-vcc.asm
@@ -0,0 +1,639 @@
+; $Id: stack-vcc.asm $
+;; @file
+; IPRT - Stack related Visual C++ support routines.
+;
+
+;
+; Copyright (C) 2022-2023 Oracle and/or its affiliates.
+;
+; This file is part of VirtualBox base platform packages, as
+; available from https://www.virtualbox.org.
+;
+; This program is free software; you can redistribute it and/or
+; modify it under the terms of the GNU General Public License
+; as published by the Free Software Foundation, in version 3 of the
+; License.
+;
+; This program is distributed in the hope that it will be useful, but
+; WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; General Public License for more details.
+;
+; You should have received a copy of the GNU General Public License
+; along with this program; if not, see <https://www.gnu.org/licenses>.
+;
+; The contents of this file may alternatively be used under the terms
+; of the Common Development and Distribution License Version 1.0
+; (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+; in the VirtualBox distribution, in which case the provisions of the
+; CDDL are applicable instead of those of the GPL.
+;
+; You may elect to license modified versions of this file under the
+; terms and conditions of either the GPL or the CDDL or both.
+;
+; SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+;
+
+
+
+;*********************************************************************************************************************************
+;*      Header Files                                                                                                             *
+;*********************************************************************************************************************************
+%if 0 ; YASM's builtin SEH64 support doesn't cope well with code alignment, so use our own.
+ %define RT_ASM_WITH_SEH64
+%else
+ %define RT_ASM_WITH_SEH64_ALT
+%endif
+%include "iprt/asmdefs.mac"
+%include "iprt/x86.mac"
+%ifdef RT_ARCH_AMD64
+ %include "iprt/win/context-amd64.mac"
+%else
+ %include "iprt/win/context-x86.mac"
+%endif
+
+
+;*********************************************************************************************************************************
+;*      Structures and Typedefs                                                                                                  *
+;*********************************************************************************************************************************
+
+;; Variable descriptor.
+struc RTC_VAR_DESC_T
+        .offFrame               resd 1
+        .cbVar                  resd 1
+        alignb                  RTCCPTR_CB
+        .pszName                RTCCPTR_RES 1
+endstruc
+
+;; Frame descriptor.
+struc RTC_FRAME_DESC_T
+        .cVars                  resd 1
+        alignb                  RTCCPTR_CB
+        .paVars                 RTCCPTR_RES 1   ; Array of RTC_VAR_DESC_T.
+endstruc
+
+;; An alloca allocation.
+struc RTC_ALLOCA_ENTRY_T
+        .uGuard1                resd 1
+        .pNext                  RTCCPTR_RES 1   ; Misaligned.
+%if ARCH_BITS == 32
+        .pNextPad               resd 1
+%endif
+        .cb                     RTCCPTR_RES 1   ; Misaligned.
+%if ARCH_BITS == 32
+        .cbPad                  resd 1
+%endif
+        .auGuard2               resd 3
+endstruc
+
+%ifdef RT_ARCH_X86
+ %define FASTCALL_NAME(a_Name, a_cbArgs)        $@ %+ a_Name %+ @ %+ a_cbArgs
+%else
+ %define FASTCALL_NAME(a_Name, a_cbArgs)        NAME(a_Name)
+%endif
+
+
+;*********************************************************************************************************************************
+;*      Defined Constants And Macros                                                                                             *
+;*********************************************************************************************************************************
+%define VARIABLE_MARKER_PRE     0xcccccccc
+%define VARIABLE_MARKER_POST    0xcccccccc
+
+%define ALLOCA_FILLER_BYTE      0xcc
+%define ALLOCA_FILLER_32        0xcccccccc
+
+
+;*********************************************************************************************************************************
+;*  Global Variables                                                                                                             *
+;*********************************************************************************************************************************
+BEGINDATA
+GLOBALNAME __security_cookie
+        dd  0xdeadbeef
+        dd  0x0c00ffe0
+
+
+;*********************************************************************************************************************************
+;*  External Symbols                                                                                                             *
+;*********************************************************************************************************************************
+BEGINCODE
+extern NAME(rtVccStackVarCorrupted)
+extern NAME(rtVccSecurityCookieMismatch)
+extern NAME(rtVccRangeCheckFailed)
+%ifdef RT_ARCH_X86
+extern NAME(rtVccCheckEspFailed)
+%endif
+
+
+
+;;
+; This just initializes a global and calls _RTC_SetErrorFuncW to NULL, and
+; since we don't have either of those we have nothing to do here.
+BEGINPROC _RTC_InitBase
+        SEH64_END_PROLOGUE
+        ret
+ENDPROC   _RTC_InitBase
+
+
+;;
+; Nothing to do here.
+BEGINPROC _RTC_Shutdown
+        SEH64_END_PROLOGUE
+        ret
+ENDPROC   _RTC_Shutdown
+
+
+
+
+;;
+; Checks stack variable markers.
+;
+; This seems to be a regular C function in the CRT, but x86 is conveniently
+; using the fastcall convention which makes it very similar to amd64.
+;
+; We try make this as sleek as possible, leaving all the trouble for when we
+; find a corrupted stack variable and need to call a C function to complain.
+;
+; @param        pStackFrame     The caller RSP/ESP.  [RCX/ECX]
+; @param        pFrameDesc      Frame descriptor.    [RDX/EDX]
+;
+ALIGNCODE(64)
+BEGINPROC_RAW   FASTCALL_NAME(_RTC_CheckStackVars, 8)
+        push    xBP
+        SEH64_PUSH_xBP
+        SEH64_END_PROLOGUE
+
+        ;
+        ; Load the variable count into eax and check that it's not zero.
+        ;
+        mov     eax, [xDX + RTC_FRAME_DESC_T.cVars]
+        test    eax, eax
+        jz      .return
+
+        ;
+        ; Make edx/rdx point to the current variable and xBP be the frame pointer.
+        ; The latter frees up xCX for scratch use and incidentally make stack access
+        ; go via SS instead of DS (mostly irrlevant in 64-bit and 32-bit mode).
+        ;
+        mov     xDX, [xDX + RTC_FRAME_DESC_T.paVars]
+        mov     xBP, xCX
+
+        ;
+        ; Loop thru the variables and check that their markers/fences haven't be
+        ; trampled over.
+        ;
+.next_var:
+        ; Marker before the variable.
+%if ARCH_BITS == 64
+        movsxd  rcx, dword [xDX + RTC_VAR_DESC_T.offFrame]
+%else
+        mov     xCX, dword [xDX + RTC_VAR_DESC_T.offFrame]
+%endif
+        cmp     dword [xBP + xCX - 4], VARIABLE_MARKER_PRE
+        jne     rtVccCheckStackVarsFailed
+
+        ; Marker after the variable.
+        add     ecx, dword [xDX + RTC_VAR_DESC_T.cbVar]
+%if ARCH_BITS == 64
+        movsxd  rcx, ecx
+%endif
+        cmp     dword [xBP + xCX], VARIABLE_MARKER_POST
+        jne     rtVccCheckStackVarsFailed
+
+        ;
+        ; Advance to the next variable.
+        ;
+.advance:
+        add     xDX, RTC_VAR_DESC_T_size
+        dec     eax
+        jnz     .next_var
+
+        ;
+        ; Return.
+        ;
+.return:
+        pop     xBP
+        ret
+ENDPROC_RAW     FASTCALL_NAME(_RTC_CheckStackVars, 8)
+
+;
+; Sub-function for _RTC_CheckStackVars, for purposes of SEH64 unwinding.
+;
+; Note! While we consider this fatal and will terminate the application, the
+;       compiler guys do not seem to think it is all that horrible and will
+;       report failure, maybe do an int3, and then try continue execution.
+;
+BEGINPROC_RAW   rtVccCheckStackVarsFailed
+        nop     ;push    xBP - done in parent function
+        SEH64_PUSH_xBP
+        mov     xCX, xBP                    ; xCX = caller pStackFrame. xBP free to become frame pointer.
+        mov     xBP, xSP
+        SEH64_SET_FRAME_xBP 0
+        pushf
+        push    xAX
+        SEH64_PUSH_GREG xAX
+        sub     xSP, CONTEXT_SIZE + 20h
+        SEH64_ALLOCATE_STACK (CONTEXT_SIZE + 20h)
+        SEH64_END_PROLOGUE
+
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        call    NAME(rtVccCaptureContext)
+
+        ; rtVccStackVarCorrupted(uint8_t *pbFrame, RTC_VAR_DESC_T const *pVar, PCONTEXT)
+.again:
+%ifdef RT_ARCH_AMD64
+        lea     r8, [xBP - CONTEXT_SIZE]
+%else
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        mov     [xSP + 8], xAX
+        mov     [xSP + 4], xDX
+        mov     [xSP], xCX
+%endif
+        call    NAME(rtVccStackVarCorrupted)
+        jmp     .again
+ENDPROC_RAW     rtVccCheckStackVarsFailed
+
+
+%ifdef RT_ARCH_X86
+;;
+; Called to follow up on a 'CMP ESP, EBP' kind of instruction,
+; expected to report failure if the compare failed.
+;
+; Note! While we consider this fatal and will terminate the application, the
+;       compiler guys do not seem to think it is all that horrible and will
+;       report failure, maybe do an int3, and then try continue execution.
+;
+ALIGNCODE(16)
+BEGINPROC _RTC_CheckEsp
+        jne     .unexpected_esp
+        ret
+
+.unexpected_esp:
+        push    xBP
+        SEH64_PUSH_xBP
+        mov     xBP, xSP
+        SEH64_SET_FRAME_xBP 0
+        pushf
+        push    xAX
+        SEH64_PUSH_GREG xAX
+        sub     xSP, CONTEXT_SIZE + 20h
+        SEH64_ALLOCATE_STACK (CONTEXT_SIZE + 20h)
+        SEH64_END_PROLOGUE
+
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        call    NAME(rtVccCaptureContext)
+
+        ; rtVccCheckEspFailed(PCONTEXT)
+.again:
+        lea     xAX, [xBP - CONTEXT_SIZE]
+%ifdef RT_ARCH_AMD64
+        mov     xCX, xAX
+%else
+        mov     [xSP], xAX
+%endif
+        call    NAME(rtVccCheckEspFailed)
+        jmp     .again
+
+ENDPROC   _RTC_CheckEsp
+%endif ; RT_ARCH_X86
+
+
+
+;;
+; Initialize an alloca allocation list entry and add it to it.
+;
+; When this is call, presumably _RTC_CheckStackVars2 is used to verify the frame.
+;
+; @param        pNewEntry       Pointer to the new entry.               [RCX/ECX]
+; @param        cbEntry         The entry size, including header.       [RDX/EDX]
+; @param        ppHead          Pointer to the list head pointer.       [R8/stack]
+;
+ALIGNCODE(64)
+BEGINPROC_RAW   FASTCALL_NAME(_RTC_AllocaHelper, 12)
+        SEH64_END_PROLOGUE
+
+        ;
+        ; Check that input isn't NULL or the size isn't zero.
+        ;
+        test    xCX, xCX
+        jz      .return
+        test    xDX, xDX
+        jz      .return
+%if ARCH_BITS == 64
+        test    r8, r8
+%else
+        cmp     dword [xSP + xCB], 0
+%endif
+        jz      .return
+
+        ;
+        ; Memset the memory to ALLOCA_FILLER
+        ;
+%if ARCH_BITS == 64
+        mov     r10, rdi                ; save rdi
+        mov     r11, rcx                ; save pNewEntry
+%else
+        push    xDI
+        push    xCX
+        cld                             ; paranoia
+%endif
+
+        mov     al, ALLOCA_FILLER_BYTE
+        mov     xDI, xCX                ; entry pointer
+        mov     xCX, xDX                ; entry size (in bytes)
+        rep stosb
+
+%if ARCH_BITS == 64
+        mov     rdi, r10
+%else
+        pop     xCX
+        pop     xDI
+%endif
+
+        ;
+        ; Fill in the entry and link it as onto the head of the chain.
+        ;
+%if ARCH_BITS == 64
+        mov     [r11 + RTC_ALLOCA_ENTRY_T.cb], xDX
+        mov     xAX, [r8]
+        mov     [r11 + RTC_ALLOCA_ENTRY_T.pNext], xAX
+        mov     [r8], r11
+%else
+        mov     [xCX + RTC_ALLOCA_ENTRY_T.cb], xDX
+        mov     xAX, [xSP + xCB]        ; ppHead
+        mov     xDX, [xAX]
+        mov     [xCX + RTC_ALLOCA_ENTRY_T.pNext], xDX
+        mov     [xAX], xCX
+%endif
+
+.return:
+%if ARCH_BITS == 64
+        ret
+%else
+        ret     4
+%endif
+ENDPROC_RAW     FASTCALL_NAME(_RTC_AllocaHelper, 12)
+
+
+;;
+; Checks if the security cookie ok, complaining and terminating if it isn't.
+;
+ALIGNCODE(16)
+BEGINPROC_RAW   FASTCALL_NAME(__security_check_cookie, 4)
+        SEH64_END_PROLOGUE
+        cmp     xCX, [NAME(__security_cookie) xWrtRIP]
+        jne     rtVccSecurityCookieFailed
+        ;; amd64 version checks if the top 16 bits are zero, we skip that for now.
+        ret
+ENDPROC_RAW     FASTCALL_NAME(__security_check_cookie, 4)
+
+; Sub-function for __security_check_cookie, for purposes of SEH64 unwinding.
+BEGINPROC_RAW   rtVccSecurityCookieFailed
+        push    xBP
+        SEH64_PUSH_xBP
+        mov     xBP, xSP
+        SEH64_SET_FRAME_xBP 0
+        pushf
+        push    xAX
+        SEH64_PUSH_GREG xAX
+        sub     xSP, CONTEXT_SIZE + 20h
+        SEH64_ALLOCATE_STACK (CONTEXT_SIZE + 20h)
+        SEH64_END_PROLOGUE
+
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        call    NAME(rtVccCaptureContext)
+
+        ; rtVccSecurityCookieMismatch(uCookie, PCONTEXT)
+.again:
+%ifdef RT_ARCH_AMD64
+        lea     xDX, [xBP - CONTEXT_SIZE]
+%else
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        mov     [xSP + 4], xAX
+        mov     [xSP], xCX
+%endif
+        call    NAME(rtVccSecurityCookieMismatch)
+        jmp     .again
+ENDPROC_RAW     rtVccSecurityCookieFailed
+
+
+;;
+; Generated when using /GS - buffer security checks - so, fatal.
+;
+; Doesn't seem to take any parameters.
+;
+BEGINPROC __report_rangecheckfailure
+        push    xBP
+        SEH64_PUSH_xBP
+        mov     xBP, xSP
+        SEH64_SET_FRAME_xBP 0
+        pushf
+        push    xAX
+        SEH64_PUSH_GREG xAX
+        sub     xSP, CONTEXT_SIZE + 20h
+        SEH64_ALLOCATE_STACK (CONTEXT_SIZE + 20h)
+        SEH64_END_PROLOGUE
+
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        call    NAME(rtVccCaptureContext)
+
+        ; rtVccRangeCheckFailed(PCONTEXT)
+.again:
+        lea     xAX, [xBP - CONTEXT_SIZE]
+%ifdef RT_ARCH_AMD64
+        mov     xCX, xAX
+%else
+        mov     [xSP], xAX
+%endif
+        call    NAME(rtVccRangeCheckFailed)
+        jmp     .again
+ENDPROC   __report_rangecheckfailure
+
+
+%if 0 ; Currently not treating these as completely fatal, just like the
+      ; compiler guys do.  I'm sure the compiler only generate these calls
+      ; if it thinks a variable could be used uninitialized, however I'm not
+      ; really sure if there is a runtime check in addition or if it's an
+      ; action that always will be taken in a code path deemed to be bad.
+      ; Judging from the warnings, the compile time analysis leave lots to be
+      ; desired (lots of false positives).
+;;
+; Not entirely sure how and when the compiler generates these.
+; extern "C" void __cdecl _RTC_UninitUse(const char *pszVar)
+BEGINPROC   _RTC_UninitUse
+        push    xBP
+        SEH64_PUSH_xBP
+        mov     xBP, xSP
+        SEH64_SET_FRAME_xBP 0
+        pushf
+        push    xAX
+        SEH64_PUSH_GREG xAX
+        sub     xSP, CONTEXT_SIZE + 20h
+        SEH64_ALLOCATE_STACK (CONTEXT_SIZE + 20h)
+        SEH64_END_PROLOGUE
+
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        call    NAME(rtVccCaptureContext)
+
+        extern NAME(rtVccUninitializedVariableUse)
+        ; rtVccUninitializedVariableUse(const char *pszVar, PCONTEXT)
+.again:
+%ifdef RT_ARCH_AMD64
+        lea     xDX, [xBP - CONTEXT_SIZE]
+%else
+        lea     xAX, [xBP - CONTEXT_SIZE]
+        mov     [xSP + xCB], xAX
+        mov     xAX, [xBP + xCB * 2]
+        mov     [xSP], xAX
+%endif
+        call    NAME(rtVccUninitializedVariableUse)
+        jmp     .again
+ENDPROC     _RTC_UninitUse
+%endif
+
+;;
+; Internal worker that creates a CONTEXT record for the caller.
+;
+; This expects a old-style stack frame setup, with xBP as base, such that:
+;       xBP+xCB*1:  Return address  -> Rip/Eip
+;       xBP+xCB*0:  Return xBP      -> Rbp/Ebp
+;       xBP-xCB*1:  EFLAGS          -> EFlags
+;       xBP-xCB*2:  Saved xAX       -> Rax/Eax
+;
+; @param    pCtx        xAX     Pointer to a CONTEXT structure.
+;
+BEGINPROC rtVccCaptureContext
+        SEH64_END_PROLOGUE
+
+%ifdef RT_ARCH_AMD64
+        mov     [xAX + CONTEXT.Rcx], rcx
+        mov     [xAX + CONTEXT.Rdx], rdx
+        mov     rcx, [xBP - xCB*2]
+        mov     [xAX + CONTEXT.Rax], ecx
+        mov     [xAX + CONTEXT.Rbx], rbx
+        lea     rcx, [xBP + xCB*2]
+        mov     [xAX + CONTEXT.Rsp], rcx
+        mov     rdx, [xBP]
+        mov     [xAX + CONTEXT.Rbp], rdx
+        mov     [xAX + CONTEXT.Rdi], rdi
+        mov     [xAX + CONTEXT.Rsi], rsi
+        mov     [xAX + CONTEXT.R8], r8
+        mov     [xAX + CONTEXT.R9], r9
+        mov     [xAX + CONTEXT.R10], r10
+        mov     [xAX + CONTEXT.R11], r11
+        mov     [xAX + CONTEXT.R12], r12
+        mov     [xAX + CONTEXT.R13], r13
+        mov     [xAX + CONTEXT.R14], r14
+        mov     [xAX + CONTEXT.R15], r15
+
+        mov     rcx, [xBP + xCB*1]
+        mov     [xAX + CONTEXT.Rip], rcx
+        mov     edx, [xBP - xCB*1]
+        mov     [xAX + CONTEXT.EFlags], edx
+
+        mov     dx, ss
+        mov     [xAX + CONTEXT.SegSs], dx
+        mov     cx, cs
+        mov     [xAX + CONTEXT.SegCs], cx
+        mov     dx, ds
+        mov     [xAX + CONTEXT.SegDs], dx
+        mov     cx, es
+        mov     [xAX + CONTEXT.SegEs], cx
+        mov     dx, fs
+        mov     [xAX + CONTEXT.SegFs], dx
+        mov     cx, gs
+        mov     [xAX + CONTEXT.SegGs], cx
+
+        mov     dword [xAX + CONTEXT.ContextFlags], CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS
+
+        ; Clear stuff we didn't set.
+        xor     edx, edx
+        mov     [xAX + CONTEXT.P1Home], rdx
+        mov     [xAX + CONTEXT.P2Home], rdx
+        mov     [xAX + CONTEXT.P3Home], rdx
+        mov     [xAX + CONTEXT.P4Home], rdx
+        mov     [xAX + CONTEXT.P5Home], rdx
+        mov     [xAX + CONTEXT.P6Home], rdx
+        mov     [xAX + CONTEXT.MxCsr], edx
+        mov     [xAX + CONTEXT.Dr0], rdx
+        mov     [xAX + CONTEXT.Dr1], rdx
+        mov     [xAX + CONTEXT.Dr2], rdx
+        mov     [xAX + CONTEXT.Dr3], rdx
+        mov     [xAX + CONTEXT.Dr6], rdx
+        mov     [xAX + CONTEXT.Dr7], rdx
+
+        mov     ecx, CONTEXT_size - CONTEXT.FltSave
+        AssertCompile(((CONTEXT_size - CONTEXT.FltSave) % 8) == 0)
+.again:
+        mov     [xAX + CONTEXT.FltSave + xCX - 8], rdx
+        sub     ecx, 8
+        jnz     .again
+
+        ; Restore edx and ecx.
+        mov     rcx, [xAX + CONTEXT.Rcx]
+        mov     rdx, [xAX + CONTEXT.Rdx]
+
+%elifdef RT_ARCH_X86
+
+        mov     [xAX + CONTEXT.Ecx], ecx
+        mov     [xAX + CONTEXT.Edx], edx
+        mov     ecx, [xBP - xCB*2]
+        mov     [xAX + CONTEXT.Eax], ecx
+        mov     [xAX + CONTEXT.Ebx], ebx
+        lea     ecx, [xBP + xCB*2]
+        mov     [xAX + CONTEXT.Esp], ecx
+        mov     edx, [xBP]
+        mov     [xAX + CONTEXT.Ebp], edx
+        mov     [xAX + CONTEXT.Edi], edi
+        mov     [xAX + CONTEXT.Esi], esi
+
+        mov     ecx, [xBP + xCB]
+        mov     [xAX + CONTEXT.Eip], ecx
+        mov     ecx, [xBP - xCB*1]
+        mov     [xAX + CONTEXT.EFlags], ecx
+
+        mov     dx, ss
+        movzx   edx, dx
+        mov     [xAX + CONTEXT.SegSs], edx
+        mov     cx, cs
+        movzx   ecx, cx
+        mov     [xAX + CONTEXT.SegCs], ecx
+        mov     dx, ds
+        movzx   edx, dx
+        mov     [xAX + CONTEXT.SegDs], edx
+        mov     cx, es
+        movzx   ecx, cx
+        mov     [xAX + CONTEXT.SegEs], ecx
+        mov     dx, fs
+        movzx   edx, dx
+        mov     [xAX + CONTEXT.SegFs], edx
+        mov     cx, gs
+        movzx   ecx, cx
+        mov     [xAX + CONTEXT.SegGs], ecx
+
+        mov     dword [xAX + CONTEXT.ContextFlags], CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS
+
+        ; Clear stuff we didn't set.
+        xor     edx, edx
+        mov     [xAX + CONTEXT.Dr0], edx
+        mov     [xAX + CONTEXT.Dr1], edx
+        mov     [xAX + CONTEXT.Dr2], edx
+        mov     [xAX + CONTEXT.Dr3], edx
+        mov     [xAX + CONTEXT.Dr6], edx
+        mov     [xAX + CONTEXT.Dr7], edx
+
+        mov     ecx, CONTEXT_size - CONTEXT.ExtendedRegisters
+.again:
+        mov     [xAX + CONTEXT.ExtendedRegisters + xCX - 4], edx
+        sub     ecx, 4
+        jnz     .again
+
+        ; Restore edx and ecx.
+        mov     ecx, [xAX + CONTEXT.Ecx]
+        mov     edx, [xAX + CONTEXT.Edx]
+
+%else
+ %error RT_ARCH
+%endif
+        ret
+ENDPROC   rtVccCaptureContext
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/stacksup-vcc.cpp b/src/VBox/Runtime/common/compiler/vcc/stacksup-vcc.cpp
new file mode 100644
index 00000000..8794cd07
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/stacksup-vcc.cpp
@@ -0,0 +1,371 @@
+/* $Id: stacksup-vcc.cpp $ */
+/** @file
+ * IPRT - Visual C++ Compiler - Stack Checking C/C++ Support.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "internal/nocrt.h"
+
+#include <iprt/asm.h>
+#include <iprt/asm-amd64-x86.h>
+#ifndef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+# include <iprt/assert.h>
+#endif
+
+#include "internal/compiler-vcc.h"
+#ifdef IN_RING3
+# include <iprt/win/windows.h>
+# include "../../../r3/win/internal-r3-win.h" /* ugly, but need some windows API function pointers */
+#endif
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Gets the program counter member of Windows' CONTEXT structure. */
+#if   defined(RT_ARCH_AMD64)
+# define MY_GET_PC_FROM_CONTEXT(a_pCtx)  ((a_pCtx)->Rip)
+#elif defined(RT_ARCH_X86)
+# define MY_GET_PC_FROM_CONTEXT(a_pCtx)  ((a_pCtx)->Eip)
+#else
+# error "Port Me!"
+#endif
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+/** Variable descriptor. */
+typedef struct RTC_VAR_DESC_T
+{
+    int32_t     offFrame;
+    uint32_t    cbVar;
+    const char *pszName;
+} RTC_VAR_DESC_T;
+
+/** Frame descriptor. */
+typedef struct RTC_FRAME_DESC_T
+{
+    uint32_t                cVars;
+    RTC_VAR_DESC_T const   *paVars;
+} RTC_FRAME_DESC_T;
+
+#define VARIABLE_MARKER_PRE     0xcccccccc
+#define VARIABLE_MARKER_POST    0xcccccccc
+
+
+/**
+ * Alloca allocation entry.
+ * @note For whatever reason the pNext and cb members are misaligned on 64-bit
+ *       targets.  32-bit targets OTOH adds padding to keep the structure size
+ *       and pNext + cb offsets the same.
+ */
+#pragma pack(4)
+typedef struct RTC_ALLOC_ENTRY
+{
+    uint32_t            uGuard1;
+    RTC_ALLOC_ENTRY    *pNext;
+#if ARCH_BITS == 32
+    uint32_t            pNextPad;
+#endif
+    size_t              cb;
+#if ARCH_BITS == 32
+    uint32_t            cbPad;
+#endif
+    uint32_t            auGuard2[3];
+} RTC_ALLOC_ENTRY;
+#pragma pack()
+
+#define ALLOCA_FILLER_BYTE      0xcc
+#define ALLOCA_FILLER_32        0xcccccccc
+
+
+/*********************************************************************************************************************************
+*   External Symbols                                                                                                             *
+*********************************************************************************************************************************/
+extern "C" void __fastcall _RTC_CheckStackVars(uint8_t *pbFrame, RTC_VAR_DESC_T const *pVar); /* nocrt-stack.asm */
+extern "C" uintptr_t __security_cookie;
+
+
+/**
+ * Initializes the security cookie value.
+ *
+ * This must be called as the first thing by the startup code.  We must also no
+ * do anything fancy here.
+ */
+void rtVccInitSecurityCookie(void) RT_NOEXCEPT
+{
+    __security_cookie = (uintptr_t)ASMReadTSC() ^ (uintptr_t)&__security_cookie;
+}
+
+
+/**
+ * Reports a security error.
+ *
+ * @param   uFastFailCode   The fast fail code.
+ * @param   pCpuCtx         The CPU context at the failure location.
+ */
+static DECL_NO_RETURN(void) rtVccFatalSecurityErrorWithCtx(uint32_t uFastFailCode, PCONTEXT pCpuCtx)
+{
+#ifdef IN_RING3
+    /*
+     * Use the __fastfail() approach if available, it is more secure than the stuff below:
+     */
+    if (g_pfnIsProcessorFeaturePresent && g_pfnIsProcessorFeaturePresent(PF_FASTFAIL_AVAILABLE))
+        __fastfail(uFastFailCode);
+
+    /*
+     * Fallback for legacy systems.
+     */
+    if (g_pfnIsDebuggerPresent && g_pfnIsDebuggerPresent())
+        __debugbreak();
+
+    /* If we can, clear the unhandled exception filter and report and unhandled exception. */
+    if (g_pfnSetUnhandledExceptionFilter && g_pfnUnhandledExceptionFilter)
+    {
+        g_pfnSetUnhandledExceptionFilter(NULL);
+
+        EXCEPTION_RECORD   XcptRec  =
+        {
+            /* .ExceptionCode = */          STATUS_STACK_BUFFER_OVERRUN,
+            /* .ExceptionFlags = */         EXCEPTION_NONCONTINUABLE,
+            /* .ExceptionRecord = */        NULL,
+# ifdef RT_ARCH_AMD64
+            /* .ExceptionAddress = */       (void *)pCpuCtx->Rip,
+# elif defined(RT_ARCH_X86)
+            /* .ExceptionAddress = */       (void *)pCpuCtx->Eip,
+# else
+#  error "Port me!"
+# endif
+            /* .NumberParameters = */       1,
+            /* .ExceptionInformation = */   { uFastFailCode, }
+        };
+
+        EXCEPTION_POINTERS XcptPtrs = { &XcptRec, pCpuCtx };
+        g_pfnUnhandledExceptionFilter(&XcptPtrs);
+    }
+
+    for (;;)
+        TerminateProcess(GetCurrentProcess(), STATUS_STACK_BUFFER_OVERRUN);
+
+#else
+# error "Port ME!"
+#endif
+}
+
+
+DECLASM(void) rtVccStackVarCorrupted(uint8_t *pbFrame, RTC_VAR_DESC_T const *pVar, PCONTEXT pCpuCtx)
+{
+#ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!Stack corruption!!\n\n"
+                 "%p LB %#x - %s\n",
+                 pbFrame + pVar->offFrame, pVar->cbVar, pVar->pszName);
+#else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!Stack corruption!!\r\n\r\n"));
+    rtNoCrtFatalWritePtr(pbFrame + pVar->offFrame);
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" LB "));
+    rtNoCrtFatalWriteX32(pVar->cbVar);
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" - "));
+    rtNoCrtFatalWriteStr(pVar->pszName);
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("\r\n"));
+#endif
+    rtVccFatalSecurityErrorWithCtx(FAST_FAIL_INCORRECT_STACK, pCpuCtx);
+}
+
+
+DECLASM(void) rtVccSecurityCookieMismatch(uintptr_t uCookie, PCONTEXT pCpuCtx)
+{
+#ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!Stack cookie corruption!!\n\n"
+                 "expected %p, found %p\n",
+                 __security_cookie, uCookie);
+#else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!Stack cookie corruption!!\r\n\r\n"
+                                        "expected"));
+    rtNoCrtFatalWritePtr((void *)__security_cookie);
+    rtNoCrtFatalWrite(RT_STR_TUPLE(", found "));
+    rtNoCrtFatalWritePtr((void *)uCookie);
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("\r\n"));
+#endif
+    rtVccFatalSecurityErrorWithCtx(FAST_FAIL_STACK_COOKIE_CHECK_FAILURE, pCpuCtx);
+}
+
+
+#ifdef RT_ARCH_X86
+DECLASM(void) rtVccCheckEspFailed(PCONTEXT pCpuCtx)
+{
+# ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!ESP check failed!!\n\n"
+                 "eip=%p esp=%p ebp=%p\n",
+                 pCpuCtx->Eip, pCpuCtx->Esp, pCpuCtx->Ebp);
+# else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!ESP check failed!!\r\n\r\n"
+                                       "eip="));
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Eip);
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" esp="));
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Esp);
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" ebp="));
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Ebp);
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("\r\n"));
+# endif
+    rtVccFatalSecurityErrorWithCtx(FAST_FAIL_INCORRECT_STACK, pCpuCtx);
+}
+#endif
+
+
+/** @todo reimplement in assembly (feeling too lazy right now). */
+extern "C" void __fastcall _RTC_CheckStackVars2(uint8_t *pbFrame, RTC_VAR_DESC_T const *pVar, RTC_ALLOC_ENTRY *pHead)
+{
+    while (pHead)
+    {
+        if (   pHead->uGuard1     == ALLOCA_FILLER_32
+#if 1 && ARCH_BITS == 32
+            && pHead->pNextPad    == ALLOCA_FILLER_32
+            && pHead->cbPad       == ALLOCA_FILLER_32
+#endif
+            && pHead->auGuard2[0] == ALLOCA_FILLER_32
+            && pHead->auGuard2[1] == ALLOCA_FILLER_32
+            && pHead->auGuard2[2] == ALLOCA_FILLER_32
+            && *(uint32_t const *)((uint8_t const *)pHead + pHead->cb - sizeof(uint32_t)) == ALLOCA_FILLER_32)
+        { /* likely */ }
+        else
+        {
+#ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+            RTAssertMsg2("\n\n!!Stack corruption (alloca)!!\n\n"
+                         "%p LB %#x\n",
+                         pHead, pHead->cb);
+#else
+            rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!Stack corruption (alloca)!!\r\n\r\n"));
+            rtNoCrtFatalWritePtr(pHead);
+            rtNoCrtFatalWrite(RT_STR_TUPLE(" LB "));
+            rtNoCrtFatalWriteX64(pHead->cb);
+            rtNoCrtFatalWriteEnd(RT_STR_TUPLE("\r\n"));
+#endif
+#ifdef IN_RING3
+            if (g_pfnIsDebuggerPresent && g_pfnIsDebuggerPresent())
+#endif
+                RT_BREAKPOINT();
+        }
+        pHead = pHead->pNext;
+    }
+
+    _RTC_CheckStackVars(pbFrame, pVar);
+}
+
+
+DECLASM(void) rtVccRangeCheckFailed(PCONTEXT pCpuCtx)
+{
+# ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!Range check failed at %p!!\n\n", MY_GET_PC_FROM_CONTEXT(pCpuCtx));
+# else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!Range check failed at "));
+    rtNoCrtFatalWritePtr((void *)MY_GET_PC_FROM_CONTEXT(pCpuCtx));
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("!!\r\n"));
+# endif
+    rtVccFatalSecurityErrorWithCtx(FAST_FAIL_RANGE_CHECK_FAILURE, pCpuCtx);
+}
+
+
+/** Whether or not this should be a fatal issue remains to be seen. See
+ *  explanation in stack-vcc.asm.  */
+#if 0
+DECLASM(void) rtVccUninitializedVariableUse(const char *pszVar, PCONTEXT pCpuCtx)
+#else
+extern "C" void __cdecl _RTC_UninitUse(const char *pszVar)
+#endif
+{
+#ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!Used uninitialized variable %s at %p!!\n\n",
+                 pszVar ? pszVar : "", ASMReturnAddress());
+#else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!Used uninitialized variable "));
+    rtNoCrtFatalWriteStr(pszVar);
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" at "));
+    rtNoCrtFatalWritePtr(ASMReturnAddress());
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("!!\r\n\r\n"));
+#endif
+#if 0
+    rtVccFatalSecurityErrorWithCtx(FAST_FAIL_FATAL_APP_EXIT, pCpuCtx);
+#else
+# ifdef IN_RING3
+    if (g_pfnIsDebuggerPresent && g_pfnIsDebuggerPresent())
+# endif
+        RT_BREAKPOINT();
+#endif
+}
+
+
+void rtVccCheckContextFailed(PCONTEXT pCpuCtx)
+{
+#ifdef IPRT_NOCRT_WITHOUT_FATAL_WRITE
+    RTAssertMsg2("\n\n!!Context (stack) check failed!!\n\n"
+                 "PC=%p SP=%p BP=%p\n",
+# ifdef RT_ARCH_AMD64
+                 pCpuCtx->Rip, pCpuCtx->Rsp, pCpuCtx->Rbp
+# elif defined(RT_ARCH_X86)
+                 pCpuCtx->Eip, pCpuCtx->Esp, pCpuCtx->Ebp
+# else
+#  error "unsupported arch"
+# endif
+                 );
+#else
+    rtNoCrtFatalWriteBegin(RT_STR_TUPLE("\r\n\r\n!!Context (stack) check failed!!\r\n\r\n"
+                                       "PC="));
+# ifdef RT_ARCH_AMD64
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Rip);
+# elif defined(RT_ARCH_X86)
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Eip);
+# else
+#  error "unsupported arch"
+# endif
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" SP="));
+# ifdef RT_ARCH_AMD64
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Rsp);
+# elif defined(RT_ARCH_X86)
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Esp);
+# endif
+    rtNoCrtFatalWrite(RT_STR_TUPLE(" BP="));
+# ifdef RT_ARCH_AMD64
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Rbp);
+# elif defined(RT_ARCH_X86)
+    rtNoCrtFatalWritePtr((void *)pCpuCtx->Ebp);
+# endif
+    rtNoCrtFatalWriteEnd(RT_STR_TUPLE("\r\n"));
+#endif
+    rtVccFatalSecurityErrorWithCtx(FAST_FAIL_INVALID_SET_OF_CONTEXT, pCpuCtx);
+}
+
diff --git a/src/VBox/Runtime/common/compiler/vcc/tlsdir-vcc.c b/src/VBox/Runtime/common/compiler/vcc/tlsdir-vcc.c
new file mode 100644
index 00000000..b151bbe5
--- /dev/null
+++ b/src/VBox/Runtime/common/compiler/vcc/tlsdir-vcc.c
@@ -0,0 +1,114 @@
+/* $Id: tlsdir-vcc.c $ */
+/** @file
+ * IPRT - Visual C++ Compiler - PE/Windows TLS Directory.
+ *
+ * @note Doing this as a C file for same reasons as loadcfg-vcc.c.
+ */
+
+/*
+ * Copyright (C) 2022-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define IPRT_COMPILER_VCC_WITH_TLS_CALLBACK_SECTIONS
+#define IPRT_COMPILER_VCC_WITH_TLS_DATA_SECTIONS
+#include "internal/iprt.h"
+#include <iprt/win/windows.h>
+
+#include "internal/compiler-vcc.h"
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** @name TLS callback arrays.
+ *
+ * The important thing here are the section names, the linker is told to merge
+ * and sort all the .CRT* sections into .rdata.
+ *
+ * @{ */
+/** Start of the TLS callback array. */
+__declspec(allocate(".CRT$XLA"))    PIMAGE_TLS_CALLBACK     g_apfnRTVccTlsCallbacks_Start[]   = { NULL, };
+/** End of the TLS callback array (not actually used, but seems to be
+ * traditional). */
+__declspec(allocate(".CRT$XLZ"))    PIMAGE_TLS_CALLBACK     g_apfnRTVccTlsCallbacks_End[]     = { NULL, };
+
+/* Tell the linker to merge the .CRT* sections into .rdata */
+#pragma comment(linker, "/merge:.CRT=.rdata ")
+/** @} */
+
+
+/** @name TLS data arrays.
+ *
+ * @{ */
+#pragma data_seg(".tls")
+
+/** Start of the TLS data.
+ * @note The linker has a reference to name '_tls_start' indicating a possible
+ *       required naming convention here.
+ * @note Not sure if the byte here is ignored or not...  In assembly we could
+ *       optimize it out, I think... */
+extern __declspec(allocate(".tls"))      char _tls_start = 0;
+
+/** End of the TLS callback array.
+ * @note The linker has a reference to name '_tls_end' indicating a possible
+ *       required naming convention here. */
+extern __declspec(allocate(".tls$ZZZ"))  char _tls_end   = 0;
+
+#pragma data_seg ()
+/** @} */
+
+
+/** The TLS index for the module we're linked into.
+ * The linker has a reference to the name '_tls_start', so this is probably
+ * fixed in some way. */
+extern ULONG _tls_index = 0;
+
+
+/**
+ * The TLS directory for the PE image.
+ *
+ * The name of this is dictated by the linker, as it looks for a _tls_used
+ * symbol and puts it's address and (somehow) size in the TLS data dir entry.
+ */
+extern __declspec(".rdata$T") /* seems to be tranditional, doubt it is necessary */
+const RT_CONCAT(IMAGE_TLS_DIRECTORY, ARCH_BITS) _tls_used =
+{
+    /* .StartAddressOfRawData   = */    (uintptr_t)&_tls_start,
+    /* .EndAddressOfRawData     = */    (uintptr_t)&_tls_end,
+    /* .AddressOfIndex          = */    (uintptr_t)&_tls_index,
+    /* .AddressOfCallBacks      = */    (uintptr_t)&g_apfnRTVccTlsCallbacks_Start[1],
+    /* .SizeOfZeroFill          = */    0,
+    /* .Characteristics         = */    0,
+};
+