[AGC/Vulkan] Extend PS5 runtime and rendering compatibility (#216)

* [Core] Add POSIX native execution and PS5 SELF support

Extend the native backend, guest TLS, fixed-address memory, and loader paths needed by PS5 titles on Windows, Linux, and macOS. Keep workstation GC so high-core-count hosts do not reserve over fixed guest image bases.

* [HLE] Expand PS5 service and media compatibility

Add the kernel, threading, save-data, networking, audio, video-codec, font, dialog, and service exports required by newer PS5 software. Preserve every SysAbi NID currently registered by main while adding the compatibility surface used by ASTRO BOT.

* [AGC/Vulkan] Extend Gen5 shader and presentation support

Expand PM4 handling, Gen5 shader translation, MRT and packed export support, guest image tracking, depth initialization, texture aliasing, and Vulkan presentation. Add the performance overlay and address-filtered diagnostics used to validate ASTRO BOT with original shaders.

* [Core] Align static TLS reservation across hosts

* [Pad] Align primary user ID with UserService

* [Gpu] Preserve runtime scalar buffers across renderer seam

* [AGC] Restore omitted command helper exports

* [Vulkan] Reuse primary views for promoted MRT targets

* [Vulkan] Preserve scratch storage bindings in compute dispatches

src/SharpEmu.Libs/Fiber/FiberExports.cs

@@ -3,6 +3,7 @@
 
 using System.Buffers.Binary;
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Text;
 using SharpEmu.HLE;
 
@@ -22,6 +23,10 @@ public static class FiberExports
     private const uint FiberStateIdle = 2;
     private const uint FiberStateTerminated = 3;
     private const uint FiberFlagContextSizeCheck = 0x10;
+    private const uint FiberFlagSetFpuRegs = 0x100;
+    private const uint Firmware350BuildVersion = 0x03500000;
+    private const ushort InitialFpuControlWord = 0x037F;
+    private const uint InitialMxcsr = 0x9FC0;
 
     private const int FiberErrorNull = unchecked((int)0x80590001);
     private const int FiberErrorAlignment = unchecked((int)0x80590002);
@@ -45,13 +50,26 @@ public static class FiberExports
 
     private static int _contextSizeCheck;
 
-    [ThreadStatic]
-    private static ulong _currentFiberAddress;
-
     private static readonly object _fiberGate = new();
     private static readonly ConcurrentDictionary<ulong, FiberContinuation> _continuations = new();
-    private static readonly ConcurrentDictionary<ulong, FiberReturnTarget> _returnTargets = new();
     private static readonly ConcurrentDictionary<ulong, FiberStackRange> _stackRanges = new();
+    private static readonly ConcurrentDictionary<ulong, FiberThreadState> _threadStates = new();
+
+    static FiberExports()
+    {
+        RunFiberSelfChecks();
+    }
+
+    public static void ResetRuntimeState()
+    {
+        lock (_fiberGate)
+        {
+            _continuations.Clear();
+            _stackRanges.Clear();
+            _threadStates.Clear();
+            Volatile.Write(ref _contextSizeCheck, 0);
+        }
+    }
 
     [SysAbiExport(
         Nid = "hVYD7Ou2pCQ",
@@ -61,6 +79,7 @@ public static class FiberExports
     public static int FiberInitialize(CpuContext ctx)
     {
         var optParam = ReadStackArg64(ctx, 0);
+        var buildVersion = unchecked((uint)ReadStackArg64(ctx, 1));
         return FiberInitializeCore(
             ctx,
             ctx[CpuRegister.Rdi],
@@ -70,7 +89,8 @@ public static class FiberExports
             ctx[CpuRegister.R8],
             ctx[CpuRegister.R9],
             optParam,
-            flags: 0);
+            flags: 0,
+            buildVersion);
     }
 
     [SysAbiExport(
@@ -82,6 +102,7 @@ public static class FiberExports
     {
         var optParam = ReadStackArg64(ctx, 0);
         var flags = unchecked((uint)ReadStackArg64(ctx, 1));
+        var buildVersion = unchecked((uint)ReadStackArg64(ctx, 2));
         return FiberInitializeCore(
             ctx,
             ctx[CpuRegister.Rdi],
@@ -91,7 +112,8 @@ public static class FiberExports
             ctx[CpuRegister.R8],
             ctx[CpuRegister.R9],
             optParam,
-            flags);
+            flags,
+            buildVersion);
     }
 
     [SysAbiExport(
@@ -104,17 +126,17 @@ public static class FiberExports
         var optParam = ctx[CpuRegister.Rdi];
         if (optParam == 0)
         {
-            return ctx.SetReturn(FiberErrorNull);
+            return SetReturn(ctx, FiberErrorNull);
         }
 
         if ((optParam & 7) != 0)
         {
-            return ctx.SetReturn(FiberErrorAlignment);
+            return SetReturn(ctx, FiberErrorAlignment);
         }
 
-        return ctx.TryWriteUInt32(optParam, FiberOptSignature)
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(FiberErrorInvalid);
+        return TryWriteUInt32(ctx, optParam, FiberOptSignature)
+            ? SetReturn(ctx, 0)
+            : SetReturn(ctx, FiberErrorInvalid);
     }
 
     [SysAbiExport(
@@ -127,24 +149,23 @@ public static class FiberExports
         var fiber = ctx[CpuRegister.Rdi];
         if (!TryValidateFiber(ctx, fiber, out var error))
         {
-            return ctx.SetReturn(error);
+            return SetReturn(ctx, error);
         }
 
-        if (!ctx.TryReadUInt32(fiber + FiberStateOffset, out var state))
+        if (!TryReadUInt32(ctx, fiber + FiberStateOffset, out var state))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         if (state != FiberStateIdle)
         {
-            return ctx.SetReturn(FiberErrorState);
+            return SetReturn(ctx, FiberErrorState);
         }
 
         _continuations.TryRemove(fiber, out _);
-        _returnTargets.TryRemove(fiber, out _);
         _stackRanges.TryRemove(fiber, out _);
-        _ = ctx.TryWriteUInt32(fiber + FiberStateOffset, FiberStateTerminated);
-        return ctx.SetReturn(0);
+        _ = TryWriteUInt32(ctx, fiber + FiberStateOffset, FiberStateTerminated);
+        return SetReturn(ctx, 0);
     }
 
     [SysAbiExport(
@@ -229,74 +250,47 @@ public static class FiberExports
         var fiberAddress = ResolveCurrentFiberAddress(ctx);
         if (fiberAddress == 0)
         {
-            return ctx.SetReturn(FiberErrorPermission);
+            return SetReturn(ctx, FiberErrorPermission);
         }
 
         if (GuestThreadExecution.Scheduler is not { SupportsGuestContextTransfer: true } ||
             !GuestThreadExecution.TryGetCurrentImportCallFrame(out var frame))
         {
-            return ctx.SetReturn(FiberErrorPermission);
+            return SetReturn(ctx, FiberErrorPermission);
         }
 
         var returnArgument = ctx[CpuRegister.Rdi];
         var argOnRunAddress = ctx[CpuRegister.Rsi];
-        if (argOnRunAddress != 0 && !ctx.TryWriteUInt64(argOnRunAddress, 0))
-        {
-            return ctx.SetReturn(FiberErrorInvalid);
-        }
-
         GuestCpuContinuation transferTarget;
-        ulong previousFiber;
         lock (_fiberGate)
         {
             _continuations[fiberAddress] = new FiberContinuation(
                 CaptureContinuation(ctx, frame.ReturnRip, frame.ResumeRsp, frame.ReturnSlotAddress),
                 argOnRunAddress);
 
-            if (!_returnTargets.TryRemove(fiberAddress, out var returnTarget))
+            var threadKey = GetThreadKey(ctx);
+            if (!_threadStates.TryGetValue(threadKey, out var threadState) ||
+                !TryWriteResumeArgument(ctx, threadState.RootContinuation, returnArgument))
             {
                 _continuations.TryRemove(fiberAddress, out _);
-                return ctx.SetReturn(FiberErrorPermission);
+                return SetReturn(ctx, FiberErrorPermission);
             }
 
-            previousFiber = returnTarget.PreviousFiber;
-            if (previousFiber != 0)
+            if (!TryWriteUInt32(ctx, fiberAddress + FiberStateOffset, FiberStateIdle))
             {
-                if (!_continuations.TryRemove(previousFiber, out var previousContinuation) ||
-                    !TryWriteResumeArgument(ctx, previousContinuation, returnArgument) ||
-                    !ctx.TryWriteUInt32(previousFiber + FiberStateOffset, FiberStateRun))
-                {
-                    _continuations.TryRemove(fiberAddress, out _);
-                    return ctx.SetReturn(FiberErrorState);
-                }
-
-                transferTarget = previousContinuation.Context with { Rax = 0 };
-            }
-            else
-            {
-                if (!returnTarget.ThreadContinuation.HasValue ||
-                    !TryWriteResumeArgument(ctx, returnTarget.ThreadContinuation.Value, returnArgument))
-                {
-                    _continuations.TryRemove(fiberAddress, out _);
-                    return ctx.SetReturn(FiberErrorState);
-                }
-
-                transferTarget = returnTarget.ThreadContinuation.Value.Context with { Rax = 0 };
+                return SetReturn(ctx, FiberErrorInvalid);
             }
 
-            if (!ctx.TryWriteUInt32(fiberAddress + FiberStateOffset, FiberStateIdle))
-            {
-                return ctx.SetReturn(FiberErrorInvalid);
-            }
+            transferTarget = threadState.RootContinuation.Context with { Rax = 0 };
+            _threadStates.TryRemove(threadKey, out _);
         }
 
-        _currentFiberAddress = previousFiber;
-        _ = GuestThreadExecution.EnterFiber(previousFiber);
+        _ = GuestThreadExecution.EnterFiber(0);
         GuestThreadExecution.RequestCurrentContextTransfer(transferTarget);
         TraceFiber(
-            $"return fiber=0x{fiberAddress:X16} to=0x{previousFiber:X16} " +
+            $"return-to-thread fiber=0x{fiberAddress:X16} " +
             $"resume=0x{transferTarget.Rip:X16} rsp=0x{transferTarget.Rsp:X16} arg=0x{returnArgument:X16}");
-        return ctx.SetReturn(0);
+        return SetReturn(ctx, 0);
     }
 
     [SysAbiExport(
@@ -309,18 +303,18 @@ public static class FiberExports
         var outAddress = ctx[CpuRegister.Rdi];
         if (outAddress == 0)
         {
-            return ctx.SetReturn(FiberErrorNull);
+            return SetReturn(ctx, FiberErrorNull);
         }
 
         var fiberAddress = ResolveCurrentFiberAddress(ctx);
         if (fiberAddress == 0)
         {
-            return ctx.SetReturn(FiberErrorPermission);
+            return SetReturn(ctx, FiberErrorPermission);
         }
 
-        return ctx.TryWriteUInt64(outAddress, fiberAddress)
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(FiberErrorInvalid);
+        return TryWriteUInt64(ctx, outAddress, fiberAddress)
+            ? SetReturn(ctx, 0)
+            : SetReturn(ctx, FiberErrorInvalid);
     }
 
     [SysAbiExport(
@@ -334,35 +328,35 @@ public static class FiberExports
         var info = ctx[CpuRegister.Rsi];
         if (info == 0)
         {
-            return ctx.SetReturn(FiberErrorNull);
+            return SetReturn(ctx, FiberErrorNull);
         }
 
         if (!TryValidateFiber(ctx, fiber, out var error))
         {
-            return ctx.SetReturn(error);
+            return SetReturn(ctx, error);
         }
 
-        if (!ctx.TryReadUInt64(info, out var size) || size != FiberInfoSize)
+        if (!TryReadUInt64(ctx, info, out var size) || size != FiberInfoSize)
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         if (!TryReadFiberFields(ctx, fiber, out var fields))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
-        if (!ctx.TryWriteUInt64(info + 8, fields.Entry) ||
-            !ctx.TryWriteUInt64(info + 16, fields.ArgOnInitialize) ||
-            !ctx.TryWriteUInt64(info + 24, fields.ContextAddress) ||
-            !ctx.TryWriteUInt64(info + 32, fields.ContextSize) ||
+        if (!TryWriteUInt64(ctx, info + 8, fields.Entry) ||
+            !TryWriteUInt64(ctx, info + 16, fields.ArgOnInitialize) ||
+            !TryWriteUInt64(ctx, info + 24, fields.ContextAddress) ||
+            !TryWriteUInt64(ctx, info + 32, fields.ContextSize) ||
             !TryWriteName(ctx, info + 40, fields.Name) ||
-            !ctx.TryWriteUInt64(info + 72, ulong.MaxValue))
+            !TryWriteUInt64(ctx, info + 72, ulong.MaxValue))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
-        return ctx.SetReturn(0);
+        return SetReturn(ctx, 0);
     }
 
     [SysAbiExport(
@@ -376,22 +370,22 @@ public static class FiberExports
         var nameAddress = ctx[CpuRegister.Rsi];
         if (!TryValidateFiber(ctx, fiber, out var error))
         {
-            return ctx.SetReturn(error);
+            return SetReturn(ctx, error);
         }
 
         if (nameAddress == 0)
         {
-            return ctx.SetReturn(FiberErrorNull);
+            return SetReturn(ctx, FiberErrorNull);
         }
 
-        if (!ctx.TryReadNullTerminatedUtf8(nameAddress, MaxNameLength + 1, out var name))
+        if (!TryReadNullTerminatedUtf8(ctx, nameAddress, MaxNameLength + 1, out var name))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         return TryWriteName(ctx, fiber + FiberNameOffset, name)
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(FiberErrorInvalid);
+            ? SetReturn(ctx, 0)
+            : SetReturn(ctx, FiberErrorInvalid);
     }
 
     [SysAbiExport(
@@ -403,12 +397,12 @@ public static class FiberExports
     {
         if (ctx[CpuRegister.Rdi] != 0)
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         return Interlocked.Exchange(ref _contextSizeCheck, 1) == 0
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(FiberErrorState);
+            ? SetReturn(ctx, 0)
+            : SetReturn(ctx, FiberErrorState);
     }
 
     [SysAbiExport(
@@ -419,8 +413,8 @@ public static class FiberExports
     public static int FiberStopContextSizeCheck(CpuContext ctx)
     {
         return Interlocked.Exchange(ref _contextSizeCheck, 0) == 1
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(FiberErrorState);
+            ? SetReturn(ctx, 0)
+            : SetReturn(ctx, FiberErrorState);
     }
 
     [SysAbiExport(
@@ -433,17 +427,18 @@ public static class FiberExports
         var outAddress = ctx[CpuRegister.Rdi];
         if (outAddress == 0)
         {
-            return ctx.SetReturn(FiberErrorNull);
+            return SetReturn(ctx, FiberErrorNull);
         }
 
-        if (ResolveCurrentFiberAddress(ctx) == 0)
+        if (ResolveCurrentFiberAddress(ctx) == 0 ||
+            !_threadStates.TryGetValue(GetThreadKey(ctx), out var threadState))
         {
-            return ctx.SetReturn(FiberErrorPermission);
+            return SetReturn(ctx, FiberErrorPermission);
         }
 
-        return ctx.TryWriteUInt64(outAddress, ctx[CpuRegister.Rbp])
-            ? ctx.SetReturn(0)
-            : ctx.SetReturn(FiberErrorInvalid);
+        return TryWriteUInt64(ctx, outAddress, threadState.RootContinuation.Context.Rbp)
+            ? SetReturn(ctx, 0)
+            : SetReturn(ctx, FiberErrorInvalid);
     }
 
     private static int FiberInitializeCore(
@@ -455,69 +450,70 @@ public static class FiberExports
         ulong contextAddress,
         ulong contextSize,
         ulong optParam,
-        uint flags)
+        uint flags,
+        uint buildVersion)
     {
         if (fiber == 0 || nameAddress == 0 || entry == 0)
         {
-            return ctx.SetReturn(FiberErrorNull);
+            return SetReturn(ctx, FiberErrorNull);
         }
 
         if ((fiber & 7) != 0 ||
             (contextAddress & 15) != 0 ||
             (optParam & 7) != 0)
         {
-            return ctx.SetReturn(FiberErrorAlignment);
+            return SetReturn(ctx, FiberErrorAlignment);
         }
 
         if (contextSize != 0 && contextSize < FiberContextMinimumSize)
         {
-            return ctx.SetReturn(FiberErrorRange);
+            return SetReturn(ctx, FiberErrorRange);
         }
 
         if ((contextSize & 15) != 0 ||
             (contextAddress == 0 && contextSize != 0) ||
             (contextAddress != 0 && contextSize == 0))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         if (optParam != 0 &&
-            (!ctx.TryReadUInt32(optParam, out var optMagic) || optMagic != FiberOptSignature))
+            (!TryReadUInt32(ctx, optParam, out var optMagic) || optMagic != FiberOptSignature))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
-        if (!ctx.TryReadNullTerminatedUtf8(nameAddress, MaxNameLength + 1, out var name))
+        if (!TryReadNullTerminatedUtf8(ctx, nameAddress, MaxNameLength + 1, out var name))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
-        if (Volatile.Read(ref _contextSizeCheck) != 0)
-        {
-            flags |= FiberFlagContextSizeCheck;
-        }
+        flags = ApplyInitializationFlags(
+            flags,
+            buildVersion,
+            Volatile.Read(ref _contextSizeCheck) != 0);
 
-        if (!ctx.TryWriteUInt32(fiber + FiberMagicStartOffset, FiberSignature0) ||
-            !ctx.TryWriteUInt32(fiber + FiberStateOffset, FiberStateIdle) ||
-            !ctx.TryWriteUInt64(fiber + FiberEntryOffset, entry) ||
-            !ctx.TryWriteUInt64(fiber + FiberArgOnInitializeOffset, argOnInitialize) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextAddressOffset, contextAddress) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextSizeOffset, contextSize) ||
+        if (!TryWriteUInt32(ctx, fiber + FiberMagicStartOffset, FiberSignature0) ||
+            !TryWriteUInt32(ctx, fiber + FiberStateOffset, FiberStateIdle) ||
+            !TryWriteUInt64(ctx, fiber + FiberEntryOffset, entry) ||
+            !TryWriteUInt64(ctx, fiber + FiberArgOnInitializeOffset, argOnInitialize) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextAddressOffset, contextAddress) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextSizeOffset, contextSize) ||
             !TryWriteName(ctx, fiber + FiberNameOffset, name) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextPointerOffset, 0) ||
-            !ctx.TryWriteUInt32(fiber + FiberFlagsOffset, flags) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextStartOffset, contextAddress) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextEndOffset, contextAddress == 0 ? 0 : contextAddress + contextSize) ||
-            !ctx.TryWriteUInt32(fiber + FiberMagicEndOffset, FiberSignature1))
+            !TryWriteUInt64(ctx, fiber + FiberContextPointerOffset, 0) ||
+            !TryWriteUInt32(ctx, fiber + FiberFlagsOffset, flags) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextStartOffset, contextAddress) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextEndOffset, contextAddress == 0 ? 0 : contextAddress + contextSize) ||
+            !TryWriteUInt32(ctx, fiber + FiberMagicEndOffset, FiberSignature1))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         if (contextAddress != 0)
         {
-            if (!ctx.TryWriteUInt64(contextAddress, FiberStackSignature))
+            if (!TryWriteUInt64(ctx, contextAddress, FiberStackSignature))
             {
-                return ctx.SetReturn(FiberErrorInvalid);
+                return SetReturn(ctx, FiberErrorInvalid);
             }
 
             if ((flags & FiberFlagContextSizeCheck) != 0)
@@ -531,8 +527,10 @@ public static class FiberExports
             _stackRanges[fiber] = new FiberStackRange(contextAddress, contextSize);
         }
 
-        TraceFiber($"init fiber=0x{fiber:X16} entry=0x{entry:X16} ctx=0x{contextAddress:X16} size=0x{contextSize:X} name='{name}'");
-        return ctx.SetReturn(0);
+        TraceFiber(
+            $"init fiber=0x{fiber:X16} entry=0x{entry:X16} ctx=0x{contextAddress:X16} " +
+            $"size=0x{contextSize:X} flags=0x{flags:X} build=0x{buildVersion:X8} name='{name}'");
+        return SetReturn(ctx, 0);
     }
 
     private static int FiberRunCore(
@@ -547,12 +545,12 @@ public static class FiberExports
     {
         if (!TryValidateFiber(ctx, fiber, out var error))
         {
-            return ctx.SetReturn(error);
+            return SetReturn(ctx, error);
         }
 
         if (!TryReadFiberFields(ctx, fiber, out var fields))
         {
-            return ctx.SetReturn(FiberErrorInvalid);
+            return SetReturn(ctx, FiberErrorInvalid);
         }
 
         if (attachContextAddress != 0 || attachContextSize != 0)
@@ -560,7 +558,7 @@ public static class FiberExports
             var attachResult = AttachContext(ctx, fiber, attachContextAddress, attachContextSize, ref fields);
             if (attachResult != 0)
             {
-                return ctx.SetReturn(attachResult);
+                return SetReturn(ctx, attachResult);
             }
         }
 
@@ -568,78 +566,96 @@ public static class FiberExports
         if ((isSwitch && previousFiber == 0) ||
             (!isSwitch && previousFiber != 0))
         {
-            return ctx.SetReturn(FiberErrorPermission);
+            return SetReturn(ctx, FiberErrorPermission);
         }
         if (previousFiber == fiber)
         {
-            return ctx.SetReturn(FiberErrorState);
+            return SetReturn(ctx, FiberErrorState);
         }
         if (GuestThreadExecution.Scheduler is not { SupportsGuestContextTransfer: true } ||
             !GuestThreadExecution.TryGetCurrentImportCallFrame(out var frame))
         {
-            return ctx.SetReturn(FiberErrorPermission);
+            return SetReturn(ctx, FiberErrorPermission);
         }
 
         GuestCpuContinuation transferTarget;
         var resumed = false;
         lock (_fiberGate)
         {
+            var threadKey = GetThreadKey(ctx);
             if (!TryReadFiberFields(ctx, fiber, out fields))
             {
-                return ctx.SetReturn(FiberErrorInvalid);
+                return SetReturn(ctx, FiberErrorInvalid);
             }
             if (fields.State != FiberStateIdle)
             {
                 TraceFiber($"run-state-error reason={reason} fiber=0x{fiber:X16} state=0x{fields.State:X8}");
-                return ctx.SetReturn(FiberErrorState);
+                return SetReturn(ctx, FiberErrorState);
             }
 
-            FiberContinuation targetContinuation;
+            FiberContinuation targetContinuation = default;
             if (_continuations.TryGetValue(fiber, out var savedContinuation))
             {
                 targetContinuation = savedContinuation;
                 resumed = true;
             }
-            else if (!TryCreateInitialContinuation(ctx, fields, argOnRun, out targetContinuation))
-            {
-                return ctx.SetReturn(FiberErrorInvalid);
-            }
-
-            if (resumed && !TryWriteResumeArgument(ctx, targetContinuation, argOnRun))
-            {
-                return ctx.SetReturn(FiberErrorInvalid);
-            }
-
             var callerContinuation = new FiberContinuation(
                 CaptureContinuation(ctx, frame.ReturnRip, frame.ResumeRsp, frame.ReturnSlotAddress),
                 outArgumentAddress);
 
+            if (!resumed)
+            {
+                var rootStackTop = _threadStates.TryGetValue(threadKey, out var existingThreadState)
+                    ? existingThreadState.RootContinuation.Context.Rsp
+                    : callerContinuation.Context.Rsp;
+                if (!TryCreateInitialContinuation(
+                        ctx,
+                        fields,
+                        argOnRun,
+                        rootStackTop,
+                        out targetContinuation))
+                {
+                    return SetReturn(ctx, FiberErrorInvalid);
+                }
+            }
+            else if (!TryWriteResumeArgument(ctx, targetContinuation, argOnRun))
+            {
+                return SetReturn(ctx, FiberErrorInvalid);
+            }
+
             if (previousFiber != 0)
             {
-                if (!ctx.TryReadUInt32(previousFiber + FiberStateOffset, out var previousState) ||
+                if (!TryReadUInt32(ctx, previousFiber + FiberStateOffset, out var previousState) ||
                     previousState != FiberStateRun ||
-                    !ctx.TryWriteUInt32(previousFiber + FiberStateOffset, FiberStateIdle))
+                    !TryWriteUInt32(ctx, previousFiber + FiberStateOffset, FiberStateIdle))
                 {
-                    return ctx.SetReturn(FiberErrorState);
+                    return SetReturn(ctx, FiberErrorState);
                 }
 
                 _continuations[previousFiber] = callerContinuation;
-                _returnTargets[fiber] = new FiberReturnTarget(previousFiber, null);
             }
             else
             {
-                _returnTargets[fiber] = new FiberReturnTarget(0, callerContinuation);
+                if (_threadStates.ContainsKey(threadKey))
+                {
+                    return SetReturn(ctx, FiberErrorPermission);
+                }
+
+                _threadStates[threadKey] = new FiberThreadState(callerContinuation, fiber, previousFiber);
             }
 
-            if (!ctx.TryWriteUInt32(fiber + FiberStateOffset, FiberStateRun))
+            if (!TryWriteUInt32(ctx, fiber + FiberStateOffset, FiberStateRun))
             {
                 if (previousFiber != 0)
                 {
                     _continuations.TryRemove(previousFiber, out _);
-                    _ = ctx.TryWriteUInt32(previousFiber + FiberStateOffset, FiberStateRun);
+                    _ = TryWriteUInt32(ctx, previousFiber + FiberStateOffset, FiberStateRun);
                 }
-                _returnTargets.TryRemove(fiber, out _);
-                return ctx.SetReturn(FiberErrorInvalid);
+                else
+                {
+                    _threadStates.TryRemove(threadKey, out _);
+                }
+                return SetReturn(ctx, FiberErrorInvalid);
             }
 
             if (resumed)
@@ -648,35 +664,66 @@ public static class FiberExports
             }
 
             transferTarget = targetContinuation.Context with { Rax = 0 };
+            if (_threadStates.TryGetValue(threadKey, out var activeState))
+            {
+                _threadStates[threadKey] = activeState with
+                {
+                    CurrentFiber = fiber,
+                    PreviousFiber = previousFiber,
+                };
+            }
         }
 
-        _currentFiberAddress = fiber;
         _ = GuestThreadExecution.EnterFiber(fiber);
         GuestThreadExecution.RequestCurrentContextTransfer(transferTarget);
         TraceFiber(
             $"transfer reason={reason} from=0x{previousFiber:X16} to=0x{fiber:X16} resume={resumed} " +
             $"rip=0x{transferTarget.Rip:X16} rsp=0x{transferTarget.Rsp:X16} arg=0x{argOnRun:X16}");
-        return ctx.SetReturn(0);
+        return SetReturn(ctx, 0);
     }
 
     private static bool TryCreateInitialContinuation(
         CpuContext ctx,
         FiberFields fields,
         ulong argOnRun,
+        ulong rootStackTop,
         out FiberContinuation continuation)
     {
         continuation = default;
-        if (fields.ContextAddress == 0 || fields.ContextSize < FiberContextMinimumSize)
+        ulong stackEnd;
+        if (fields.ContextAddress == 0)
+        {
+            if (rootStackTop < 32)
+            {
+                return false;
+            }
+
+            // Contextless fibers are specified to execute on the root
+            // sceFiberRun stack.  Keep the suspended import return record
+            // above the entry stack and use a synthetic transfer slot below it.
+            stackEnd = rootStackTop & ~15UL;
+        }
+        else
+        {
+            if (fields.ContextSize < FiberContextMinimumSize)
+            {
+                return false;
+            }
+
+            stackEnd = fields.ContextAddress + fields.ContextSize;
+        }
+
+        if (!TryCalculateInitialStackLayout(stackEnd, out var entryRsp, out var transferSlot))
+        {
+            return false;
+        }
+        if (!TryWriteUInt64(ctx, transferSlot, fields.Entry) ||
+            !TryWriteUInt64(ctx, entryRsp, 0))
         {
             return false;
         }
 
-        var stackEnd = fields.ContextAddress + fields.ContextSize;
-        var entryRsp = (stackEnd & ~15UL) - sizeof(ulong);
-        if (!ctx.TryWriteUInt64(entryRsp, 0))
-        {
-            return false;
-        }
+        var setFpuRegisters = (fields.Flags & FiberFlagSetFpuRegs) != 0;
 
         continuation = new FiberContinuation(
             new GuestCpuContinuation(
@@ -698,7 +745,12 @@ public static class FiberExports
                 0,
                 0,
                 0,
-                0),
+                0,
+                0,
+                0,
+                setFpuRegisters ? InitialFpuControlWord : ctx.FpuControlWord,
+                setFpuRegisters ? InitialMxcsr : ctx.Mxcsr,
+                RestoreFullFpuState: setFpuRegisters),
             0);
         return true;
     }
@@ -708,7 +760,7 @@ public static class FiberExports
         FiberContinuation continuation,
         ulong argument) =>
         continuation.ArgOnRunAddress == 0 ||
-        ctx.TryWriteUInt64(continuation.ArgOnRunAddress, argument);
+        TryWriteUInt64(ctx, continuation.ArgOnRunAddress, argument);
 
     private static GuestCpuContinuation CaptureContinuation(
         CpuContext ctx,
@@ -731,26 +783,99 @@ public static class FiberExports
             ctx[CpuRegister.Rdi],
             ctx[CpuRegister.R8],
             ctx[CpuRegister.R9],
+            ctx[CpuRegister.R10],
+            ctx[CpuRegister.R11],
             ctx[CpuRegister.R12],
             ctx[CpuRegister.R13],
             ctx[CpuRegister.R14],
-            ctx[CpuRegister.R15]);
+            ctx[CpuRegister.R15],
+            ctx.FpuControlWord,
+            ctx.Mxcsr,
+            RestoreFullFpuState: false);
 
     private static ulong ResolveCurrentFiberAddress(CpuContext ctx)
     {
-        if (_currentFiberAddress != 0)
-        {
-            return _currentFiberAddress;
-        }
-
         if (GuestThreadExecution.CurrentFiberAddress != 0)
         {
             return GuestThreadExecution.CurrentFiberAddress;
         }
 
+        if (_threadStates.TryGetValue(GetThreadKey(ctx), out var threadState) &&
+            threadState.CurrentFiber != 0)
+        {
+            return threadState.CurrentFiber;
+        }
+
         return TryFindFiberByStack(ctx, out var fiberAddress) ? fiberAddress : 0;
     }
 
+    private static ulong GetThreadKey(CpuContext ctx)
+    {
+        var handle = GuestThreadExecution.CurrentGuestThreadHandle;
+        if (handle != 0)
+        {
+            return handle;
+        }
+
+        // The main guest thread does not always have a scheduler handle.  Its
+        // ABI thread pointer is stable across native/managed transitions.
+        return ctx.FsBase != 0 ? ctx.FsBase : 1;
+    }
+
+    private static uint ApplyInitializationFlags(
+        uint flags,
+        uint buildVersion,
+        bool contextSizeCheck)
+    {
+        if (buildVersion >= Firmware350BuildVersion)
+        {
+            flags |= FiberFlagSetFpuRegs;
+        }
+        if (contextSizeCheck)
+        {
+            flags |= FiberFlagContextSizeCheck;
+        }
+
+        return flags;
+    }
+
+    private static bool TryCalculateInitialStackLayout(
+        ulong stackEnd,
+        out ulong entryRsp,
+        out ulong transferSlot)
+    {
+        var alignedEnd = stackEnd & ~15UL;
+        if (alignedEnd < 2 * sizeof(ulong))
+        {
+            entryRsp = 0;
+            transferSlot = 0;
+            return false;
+        }
+
+        entryRsp = alignedEnd - sizeof(ulong);
+        transferSlot = entryRsp - sizeof(ulong);
+        return true;
+    }
+
+    [Conditional("DEBUG")]
+    private static void RunFiberSelfChecks()
+    {
+        Debug.Assert(
+            ApplyInitializationFlags(0, Firmware350BuildVersion - 1, false) == 0,
+            "Pre-3.50 fibers unexpectedly enable SetFpuRegs.");
+        Debug.Assert(
+            ApplyInitializationFlags(0, Firmware350BuildVersion, false) == FiberFlagSetFpuRegs,
+            "3.50+ fibers must initialize x87/MXCSR control state.");
+        Debug.Assert(
+            ApplyInitializationFlags(1, Firmware350BuildVersion, true) ==
+                (1u | FiberFlagSetFpuRegs | FiberFlagContextSizeCheck),
+            "Fiber initialization discarded caller/internal flags.");
+        Debug.Assert(
+            TryCalculateInitialStackLayout(0x1017, out var rsp, out var slot) &&
+            rsp == 0x1008 && slot == 0x1000 && (rsp & 15) == 8,
+            "Initial fiber transfer slot does not produce SysV entry alignment.");
+    }
+
     internal static ulong GetCurrentFiberAddressForDiagnostics(CpuContext ctx) =>
         ResolveCurrentFiberAddress(ctx);
 
@@ -779,11 +904,11 @@ public static class FiberExports
             return FiberErrorInvalid;
         }
 
-        if (!ctx.TryWriteUInt64(fiber + FiberContextAddressOffset, contextAddress) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextSizeOffset, contextSize) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextStartOffset, contextAddress) ||
-            !ctx.TryWriteUInt64(fiber + FiberContextEndOffset, contextAddress + contextSize) ||
-            !ctx.TryWriteUInt64(contextAddress, FiberStackSignature))
+        if (!TryWriteUInt64(ctx, fiber + FiberContextAddressOffset, contextAddress) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextSizeOffset, contextSize) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextStartOffset, contextAddress) ||
+            !TryWriteUInt64(ctx, fiber + FiberContextEndOffset, contextAddress + contextSize) ||
+            !TryWriteUInt64(ctx, contextAddress, FiberStackSignature))
         {
             return FiberErrorInvalid;
         }
@@ -839,8 +964,8 @@ public static class FiberExports
             return false;
         }
 
-        if (!ctx.TryReadUInt32(fiber + FiberMagicStartOffset, out var magicStart) ||
-            !ctx.TryReadUInt32(fiber + FiberMagicEndOffset, out var magicEnd) ||
+        if (!TryReadUInt32(ctx, fiber + FiberMagicStartOffset, out var magicStart) ||
+            !TryReadUInt32(ctx, fiber + FiberMagicEndOffset, out var magicEnd) ||
             magicStart != FiberSignature0 ||
             magicEnd != FiberSignature1)
         {
@@ -855,12 +980,12 @@ public static class FiberExports
     private static bool TryReadFiberFields(CpuContext ctx, ulong fiber, out FiberFields fields)
     {
         fields = default;
-        if (!ctx.TryReadUInt32(fiber + FiberStateOffset, out var state) ||
-            !ctx.TryReadUInt64(fiber + FiberEntryOffset, out var entry) ||
-            !ctx.TryReadUInt64(fiber + FiberArgOnInitializeOffset, out var argOnInitialize) ||
-            !ctx.TryReadUInt64(fiber + FiberContextAddressOffset, out var contextAddress) ||
-            !ctx.TryReadUInt64(fiber + FiberContextSizeOffset, out var contextSize) ||
-            !ctx.TryReadUInt32(fiber + FiberFlagsOffset, out var flags) ||
+        if (!TryReadUInt32(ctx, fiber + FiberStateOffset, out var state) ||
+            !TryReadUInt64(ctx, fiber + FiberEntryOffset, out var entry) ||
+            !TryReadUInt64(ctx, fiber + FiberArgOnInitializeOffset, out var argOnInitialize) ||
+            !TryReadUInt64(ctx, fiber + FiberContextAddressOffset, out var contextAddress) ||
+            !TryReadUInt64(ctx, fiber + FiberContextSizeOffset, out var contextSize) ||
+            !TryReadUInt32(ctx, fiber + FiberFlagsOffset, out var flags) ||
             !TryReadInlineName(ctx, fiber + FiberNameOffset, out var name))
         {
             return false;
@@ -898,6 +1023,46 @@ public static class FiberExports
         return 0;
     }
 
+    private static bool TryReadUInt32(CpuContext ctx, ulong address, out uint value)
+    {
+        Span<byte> buffer = stackalloc byte[sizeof(uint)];
+        if (!ctx.Memory.TryRead(address, buffer))
+        {
+            value = 0;
+            return false;
+        }
+
+        value = BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+        return true;
+    }
+
+    private static bool TryWriteUInt32(CpuContext ctx, ulong address, uint value)
+    {
+        Span<byte> buffer = stackalloc byte[sizeof(uint)];
+        BinaryPrimitives.WriteUInt32LittleEndian(buffer, value);
+        return ctx.Memory.TryWrite(address, buffer);
+    }
+
+    private static bool TryReadUInt64(CpuContext ctx, ulong address, out ulong value)
+    {
+        Span<byte> buffer = stackalloc byte[sizeof(ulong)];
+        if (!ctx.Memory.TryRead(address, buffer))
+        {
+            value = 0;
+            return false;
+        }
+
+        value = BinaryPrimitives.ReadUInt64LittleEndian(buffer);
+        return true;
+    }
+
+    private static bool TryWriteUInt64(CpuContext ctx, ulong address, ulong value)
+    {
+        Span<byte> buffer = stackalloc byte[sizeof(ulong)];
+        BinaryPrimitives.WriteUInt64LittleEndian(buffer, value);
+        return ctx.Memory.TryWrite(address, buffer);
+    }
+
     private static bool TryWriteName(CpuContext ctx, ulong address, string name)
     {
         Span<byte> buffer = stackalloc byte[MaxNameLength + 1];
@@ -925,6 +1090,37 @@ public static class FiberExports
         return true;
     }
 
+    private static bool TryReadNullTerminatedUtf8(CpuContext ctx, ulong address, int capacity, out string value)
+    {
+        var bytes = new byte[capacity];
+        Span<byte> current = stackalloc byte[1];
+        for (var index = 0; index < bytes.Length; index++)
+        {
+            if (!ctx.Memory.TryRead(address + (ulong)index, current))
+            {
+                value = string.Empty;
+                return false;
+            }
+
+            if (current[0] == 0)
+            {
+                value = Encoding.UTF8.GetString(bytes, 0, index);
+                return true;
+            }
+
+            bytes[index] = current[0];
+        }
+
+        value = Encoding.UTF8.GetString(bytes);
+        return true;
+    }
+
+    private static int SetReturn(CpuContext ctx, int result)
+    {
+        ctx[CpuRegister.Rax] = unchecked((ulong)result);
+        return result;
+    }
+
     private static void TraceFiber(string message)
     {
         if (string.Equals(Environment.GetEnvironmentVariable("SHARPEMU_LOG_FIBER"), "1", StringComparison.Ordinal))
@@ -946,9 +1142,10 @@ public static class FiberExports
         GuestCpuContinuation Context,
         ulong ArgOnRunAddress);
 
-    private readonly record struct FiberReturnTarget(
-        ulong PreviousFiber,
-        FiberContinuation? ThreadContinuation);
+    private sealed record FiberThreadState(
+        FiberContinuation RootContinuation,
+        ulong CurrentFiber,
+        ulong PreviousFiber);
 
     private readonly record struct FiberStackRange(ulong Start, ulong Size)
     {