Skip to content

Gran Turismo 7 (PPSA01317 v01.680) on Linux/RADV: deterministic SIGSEGV in guest code (null deref r14+0x48) while the title's video-out/flip frame-pacing loop runs #6350

Open

Description

@Lberonio

Summary

GT7 boots far enough to create its swapchain, initialise fonts, and compile ~1670 shaders (461 MiB shader cache), then dies with a deterministic SIGSEGV inside guest code (the game's own equeue + libSceVideoOut flip/vblank frame-pacing loop). The fault is mov 0x48(%r14),%rax with r14 = 0 — a null dereference. The same instruction/signature reproduces on the v0.1.2 release build and on main, so this is not a build/regression artefact.

Along the way I had to apply open PR #6083 (shader sampler pairs exceed runtime heap capacity), which GT7 hits on plain main; after that the sampler-capacity error is gone and the crash below is the next (and only) blocker.

Environment

  • OS: Arch Linux, kernel 7.2.9-arch1-1, x86_64
  • CPU: Intel Core i5-12500H (game converted with relinker --to-intel)
  • GPU: AMD Radeon RX 9070 XT (RADV GFX1201), vendor=0x1002 device=0x7550 subgroup=64 (RDNA4, Mesa/RADV, Vulkan 1.4.363)
  • Compiler: GCC 16.2.1, Ninja
  • AnyPS5: main @ 34454bd835ce334c3c395467da50546b433fe200 + PR fix(shader): allow 32 sampler pairs per shader #6083
    • core/shader/recompiler/RuntimeAbi.hpp: Version 12 -> 13, SamplerHeapCapacity 32 -> 64

Game

  • Gran Turismo 7, PPSA01317, v01.680 (USA)
  • Runtime assembled as: relinker --to-intel source/input.elf app.elf, with libs/ (126 .prx) and app0/ (symlinks to the title data + relinker *.guest.prx).

Reproduction

relinker --to-intel conv/source/input.elf conv/app.elf
# assemble app.elf + libs/*.prx + app0/ (game data), then:
cd runtime && ./app.elf          # ~10 s, then SIGSEGV (rc=139)

Deterministic: same faulting instruction and registers on every run (also on the v0.1.2 release binary).

Note on PR #6083

On unpatched main the run stops even earlier:

[Shaders/ShaderRegistry.cpp:1056 operator()] Shader 0x1258d94500 could not be prepared after registration:
  shader 0x1258d94500 stage 0: ShaderRecompiler::Recompile: shader sampler pairs exceed runtime heap capacity

Applying #6083 fixes that and the title proceeds to the crash reported here (so #6083 is currently required for GT7 to get this far).

Crash

Program terminated with signal SIGSEGV, Segmentation fault.
#0  0x000055f16a5b0f2b in ?? ()
#1  0x0000000000000000 in ?? ()

rip 0x55f16a5b0f2b
r14 0x0            <-- null
r15 0x7f8cdb6e4030 (libc.prx)
r13 0x203406b0c
  • Load base that run: 0x55f16861c000 -> faulting guest function starts at app.elf+0x1F94CC0, fault at app.elf+0x1F94F2B.
  • Faulting instruction: 49 8b 46 48 mov 0x48(%r14),%rax
  • The frame was entered from a libkernel.prx thread entry (stack return address 0x0).

The crashing function is the title's frame-pacing/present loop. Resolving every PLT import it calls (via relinker --registry + NID db) gives:

PLT[164] libkernel 9UK1vLZQft4 scePthreadMutexLock
PLT[166] libkernel tn3VlD0hG60 scePthreadMutexUnlock
PLT[173] libkernel JGgj7Uvrl+A scePthreadCondBroadcast
PLT[179] libkernel 23CPPI1tyBY sceKernelGetEventFilter
PLT[181] libkernel mJ7aghmgvfc sceKernelGetEventId
PLT[192] libSceVideoOut U2JJtSqNKZI sceVideoOutGetEventId
PLT[216] libkernel ...      sceVideoOutGetVblankStatus
PLT[217] libkernel utPrVdxio-8 sceVideoOutGetOutputStatus
PLT[224] libkernel R74tt43xP6k sceKernelAddHRTimerEvent
PLT[229] libkernel fgxnMeTNUtY sceKernelGetProcessTimeCounter
PLT[   ] libkernel BNowx2l588E sceKernelGetProcessTimeCounterFrequency

All of these are implemented in AnyPS5 (nothing falls through to a stub), so this looks like a guest-visible behaviour mismatch in the equeue / libSceVideoOut event path rather than a missing export.

Faulting basic block (guest code, r14 is null on entry):

0f1f: lea    0x...(%rip),%rdi        # a global mutex
0f26: call   scePthreadMutexUnlock
0f2b: mov    0x48(%r14),%rax         <-- SIGSEGV here, r14 = 0
0f2f: cmp    $0x10000,%rax
0f35: jb     0x1055
0f3b: mov    0x48(%r14),%rcx
0f48: lock cmpxchg %rdx,0x48(%r14)   ; refcount at +0x48

Other (non-fatal) runtime gaps in the same run

  • 7 shaders: deferred, unsupported MIMG opcode 0xe5
  • 201 shaders: deferred, s_swappc_b64 ... calls a computed target
  • 3 host-import fallbacks: vkAllocateMemory -> -1000072003 (VK_ERROR_INVALID_EXTERNAL_HANDLE)
  • sceSysmoduleLoadModule unknown id: 298 (not in the 285-entry kModuleTable)
  • MSAA-storage shader failures: 0 (these were Intel-only; gone on RADV)

Log tail

[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e89060 self=0x55f1abff2550
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e890c0 self=0x55f1abffa610
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e89120 self=0x55f1ac000560
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e891c0 self=0x55f1abff1370
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe4010b20e0 self=0x55f1ae0948a0
[shader-disk-cache] (10 s): 0 hits, 1670 misses, 1669 writes (461.2 MiB), 0 load failures, 0 write failures; resource plans: 0 hits, 1646 misses, 1645 writes, 0 load failures; 0.0 MiB read in 134.0 ms (totals: 0 hits, 1670 misses, 1669 writes; plans 0 hits, 1646 misses)
[affinity] queue workers and presenter -> 0xff (hybrid=1 efficient=0xff00 performant=0xff process=0xffff)
[gpu] host import of 0xe400000000+0x800000 failed at vkAllocateMemory (-1000072003); falling back to copies
[gpu] host import of 0x1000000000+0x800000 failed at vkAllocateMemory (-1000072003); falling back to copies
timeout: the monitored command dumped core
RUN_NEW2 rc=139
Full log (post-#6083 run)
[src/HostCpu.cpp:193 operator()] host CPU 12th Gen Intel(R) Core(TM) i5-12500H: has SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, POPCNT, LZCNT, BMI1, BMI2, MOVBE, CMPXCHG16B, LAHF/SAHF, AVX, AVX2, FMA, F16C, AES, PCLMULQDQ, RDRAND, RDSEED, ADX, SHA, CLFLUSHOPT, CLWB, RDPID, XSAVEOPT, XSAVEC, PREFETCHW, OS AVX state (XCR0); lacks SSE4A, CLZERO
[src/Open.cpp:215 sceKernelOpen] path=/app0/pdiWheel_2.prx flags=0x0 nativeFlags=0x0 mode=00
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c27f00 self=0x55f1ab63e520
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c28160 self=0x55f1ab65ba50
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab6622d0
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab662a30
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab6631e0
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab663990
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab664140
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab6648f0
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab665230
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab665a30
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab6661e0
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab666990
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab6672d0
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab667ad0
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab668280
[src/Thread.cpp:527 RunThread] RunThread entry=0x7f8ce00b4440 arg=0x7ffdc8bcb800 self=0x55f1ab668a30
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2a840 self=0x55f1ab66c380
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2a9a0 self=0x55f1ab66d0b0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2aa00 self=0x55f1ab66d900
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2aa60 self=0x55f1ab66e0b0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2aac0 self=0x55f1ab66e860
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2b080 self=0x55f1ab66f340
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2b9a0 self=0x55f1ab66fb90
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2c0e0 self=0x55f1ab670780
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c2ff00 self=0x55f1ab670f50
[src/VulkanDevice.cpp:935 VulkanDevice] VulkanDevice constructor window=(nil)
[src/VulkanDevice.cpp:944 VulkanDevice] Vulkan loader loaded library=0x55f1ab67b040
[src/VulkanDevice.cpp:982 VulkanDevice] Vulkan instance created instance=0x55f1ab67c070
WARNING: radv is not a conformant Vulkan implementation, testing use only.
[src/VulkanDevice.cpp:993 VulkanDevice] Physical device count=2
[src/VulkanDevice.cpp:1026 VulkanDevice] Physical device candidate=0x55f1ab6ee6d0 name=Intel(R) Iris(R) Xe Graphics (ADL GT2) api=0x404162 type=1
[src/VulkanDevice.cpp:1026 VulkanDevice] Physical device candidate=0x55f1ab6d97c0 name=AMD Radeon RX 9070 XT (RADV GFX1201) api=0x404162 type=2
[src/VulkanDevice.cpp:1073 VulkanDevice] Physical device selected physical=0x55f1ab6d97c0 queueFamily=0
[src/VulkanDevice.cpp:1086 VulkanDevice] Selected GPU name=AMD Radeon RX 9070 XT (RADV GFX1201) vendor=0x1002 device=0x7550 subgroup=64
[src/VulkanDevice.cpp:1088 VulkanDevice] Memory heap 0 size=19894.1 MiB flags=0x0
[src/VulkanDevice.cpp:1088 VulkanDevice] Memory heap 1 size=16304.0 MiB flags=0x1
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 0 heap=1 flags=0x1
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 1 heap=1 flags=0x1
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 2 heap=0 flags=0x6
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 3 heap=1 flags=0x7
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 4 heap=1 flags=0x7
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 5 heap=0 flags=0xe
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 6 heap=0 flags=0xe
[src/VulkanDevice.cpp:1152 VulkanDevice] Shader clock driver=3 narrowSubgroupClock=0
[src/VulkanDevice.cpp:1475 VulkanDevice] Vulkan features tessellationAvailable=1 mesh=1 depthClip=1 depthRangeUnrestricted=1 pipelineLibrary=1
[src/VulkanDevice.cpp:1718 VulkanDevice] Wave32 programs run on subgroups of 32: compute 1, mesh 1
[src/VulkanDevice.cpp:1824 VulkanDevice] Vulkan device ready device=0x55f1ab739370 queue=0x55f1ab6d7820 family=0
[write-watch] host imports resolve write protection: yes (4 of 4 scratch pages written after a GPU read, 4 after a GPU write, 4 after the import); imported ranges are compared
[write-watch] dma-buf imports keep write protection: yes (0 of 4 scratch pages written after a GPU read, 0 after a GPU write, 0 after the import, 1 seen after a CPU store); imported ranges stay watched
[pipeline-cache] loaded 28.9 KiB from /home/elberonio/anyps5/gt7b/shader_cache/vk-pipelines-1002-7550-06802004-4e76f906814afd8983a0d84594265846.bin
[shader-disk-cache] /home/elberonio/anyps5/gt7b/shader_cache/24b4546de8bc603a (source version 24b4546de8bc603a, format 36)
[src/VulkanDevice.cpp:935 VulkanDevice] VulkanDevice constructor window=0x7f8c4e0a6d60
[src/VulkanDevice.cpp:944 VulkanDevice] Vulkan loader loaded library=0x55f1ab67b040
[src/VulkanDevice.cpp:960 VulkanDevice] Presentation window context=0x7f8ca0008e00 extent=1920x1080 extensions=2
[src/VulkanDevice.cpp:982 VulkanDevice] Vulkan instance created instance=0x7f8ca0225490
[src/VulkanDevice.cpp:987 VulkanDevice] Vulkan surface created surface=0x7f8ca01bef90 window=0x7f8ca0008e00
WARNING: radv is not a conformant Vulkan implementation, testing use only.
[src/VulkanDevice.cpp:993 VulkanDevice] Physical device count=2
[src/VulkanDevice.cpp:1026 VulkanDevice] Physical device candidate=0x7f8ca0285be0 name=Intel(R) Iris(R) Xe Graphics (ADL GT2) api=0x404162 type=1
[src/VulkanDevice.cpp:1026 VulkanDevice] Physical device candidate=0x7f8ca02940e0 name=AMD Radeon RX 9070 XT (RADV GFX1201) api=0x404162 type=2
[src/VulkanDevice.cpp:1073 VulkanDevice] Physical device selected physical=0x7f8ca02940e0 queueFamily=0
[src/VulkanDevice.cpp:1086 VulkanDevice] Selected GPU name=AMD Radeon RX 9070 XT (RADV GFX1201) vendor=0x1002 device=0x7550 subgroup=64
[src/VulkanDevice.cpp:1088 VulkanDevice] Memory heap 0 size=19894.1 MiB flags=0x0
[src/VulkanDevice.cpp:1088 VulkanDevice] Memory heap 1 size=16304.0 MiB flags=0x1
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 0 heap=1 flags=0x1
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 1 heap=1 flags=0x1
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 2 heap=0 flags=0x6
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 3 heap=1 flags=0x7
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 4 heap=1 flags=0x7
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 5 heap=0 flags=0xe
[src/VulkanDevice.cpp:1089 VulkanDevice] Memory type 6 heap=0 flags=0xe
[src/VulkanDevice.cpp:1152 VulkanDevice] Shader clock driver=3 narrowSubgroupClock=0
[src/VulkanDevice.cpp:1475 VulkanDevice] Vulkan features tessellationAvailable=1 mesh=1 depthClip=1 depthRangeUnrestricted=1 pipelineLibrary=1
[src/VulkanDevice.cpp:1718 VulkanDevice] Wave32 programs run on subgroups of 32: compute 1, mesh 1
[src/VulkanDevice.cpp:1824 VulkanDevice] Vulkan device ready device=0x7f8ca02d2980 queue=0x7f8ca0286d50 family=0
[write-watch] host imports resolve write protection: yes (4 of 4 scratch pages written after a GPU read, 4 after a GPU write, 4 after the import); imported ranges are compared
[write-watch] dma-buf imports keep write protection: yes (0 of 4 scratch pages written after a GPU read, 0 after a GPU write, 0 after the import, 1 seen after a CPU store); imported ranges stay watched
[pipeline-cache] loaded 28.9 KiB from /home/elberonio/anyps5/gt7b/shader_cache/vk-pipelines-1002-7550-06802004-4e76f906814afd8983a0d84594265846.bin
[src/VulkanDevice.cpp:1868 VulkanDevice] Surface capabilities drawable=1152x648 min=1x1 max=32768x32768 minImages=3 maxImages=0 usage=0x8009f
[src/VulkanDevice.cpp:1910 VulkanDevice] Swapchain created swapchain=0x7f8ca02beac0 extent=1152x648 images=3
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16a5b0cc0 arg=(nil) self=0x55f1aba374b0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16a5ac000 arg=0x55f16eb29208 self=0x55f1abb4e4f0
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7b700 could not be prepared at registration (its s_swappc_b64 at program counter 0x74 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7bb00 could not be prepared at registration (its s_swappc_b64 at program counter 0x74 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7bf00 could not be prepared at registration (its s_swappc_b64 at program counter 0x74 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7c300 could not be prepared at registration (its s_swappc_b64 at program counter 0x74 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9ae00 could not be prepared at registration (its s_swappc_b64 at program counter 0x48 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9b700 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9c000 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9c900 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9db00 could not be prepared at registration (its s_swappc_b64 at program counter 0x40 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9de00 could not be prepared at registration (its s_swappc_b64 at program counter 0x40 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9e100 could not be prepared at registration (its s_swappc_b64 at program counter 0x40 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df9e400 could not be prepared at registration (its s_swappc_b64 at program counter 0x40 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7eb00 could not be prepared at registration (its s_swappc_b64 at program counter 0xd0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7f100 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7f700 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df7fd00 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df80300 could not be prepared at registration (its s_swappc_b64 at program counter 0xd0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df80800 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df80d00 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16df81200 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfb9200 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfc0600 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfc7a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfcee00 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe0b00 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe0f00 could not be prepared at registration (its s_swappc_b64 at program counter 0x44 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe1300 could not be prepared at registration (its s_swappc_b64 at program counter 0x48 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe1700 could not be prepared at registration (its s_swappc_b64 at program counter 0x48 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe2900 could not be prepared at registration (its s_swappc_b64 at program counter 0x48 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe2d00 could not be prepared at registration (its s_swappc_b64 at program counter 0x68 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe3100 could not be prepared at registration (its s_swappc_b64 at program counter 0x88 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe3500 could not be prepared at registration (its s_swappc_b64 at program counter 0x8c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd7000 could not be prepared at registration (its s_swappc_b64 at program counter 0x8c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd7700 could not be prepared at registration (its s_swappc_b64 at program counter 0x8c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd7e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x8c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd8500 could not be prepared at registration (its s_swappc_b64 at program counter 0x8c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd8c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x98 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd9300 could not be prepared at registration (its s_swappc_b64 at program counter 0x98 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfd9a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x98 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfda100 could not be prepared at registration (its s_swappc_b64 at program counter 0x98 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfdcb00 could not be prepared at registration (its s_swappc_b64 at program counter 0x80 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfdd800 could not be prepared at registration (its s_swappc_b64 at program counter 0x80 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfde500 could not be prepared at registration (its s_swappc_b64 at program counter 0x80 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfdf200 could not be prepared at registration (its s_swappc_b64 at program counter 0x80 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe8c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfe9900 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfea600 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfeb300 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfec000 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfecd00 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfeda00 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dfee700 could not be prepared at registration (its s_swappc_b64 at program counter 0x94 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dff3600 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dff4700 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dff5800 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dff6900 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dffb000 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dffc100 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dffd200 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16dffe300 could not be prepared at registration (its s_swappc_b64 at program counter 0x78 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e002e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x5c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e003000 could not be prepared at registration (its s_swappc_b64 at program counter 0x58 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e003200 could not be prepared at registration (its s_swappc_b64 at program counter 0x5c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e003400 could not be prepared at registration (its s_swappc_b64 at program counter 0x5c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e003c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x50 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e003e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x60 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e004000 could not be prepared at registration (its s_swappc_b64 at program counter 0x60 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e004200 could not be prepared at registration (its s_swappc_b64 at program counter 0x60 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e000c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x70 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e001300 could not be prepared at registration (its s_swappc_b64 at program counter 0x70 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e001a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x70 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e002100 could not be prepared at registration (its s_swappc_b64 at program counter 0x70 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e051500 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e051a00 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e051f00 could not be prepared at registration (its s_swappc_b64 at program counter 0xc8 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e052400 could not be prepared at registration (its s_swappc_b64 at program counter 0xcc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e052900 could not be prepared at registration (its s_swappc_b64 at program counter 0xd8 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e052e00 could not be prepared at registration (its s_swappc_b64 at program counter 0xd8 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e053300 could not be prepared at registration (its s_swappc_b64 at program counter 0xd4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e053800 could not be prepared at registration (its s_swappc_b64 at program counter 0xd8 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05a800 could not be prepared at registration (its s_swappc_b64 at program counter 0x138 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05ac00 could not be prepared at registration (its s_swappc_b64 at program counter 0x134 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05b000 could not be prepared at registration (its s_swappc_b64 at program counter 0x134 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05b400 could not be prepared at registration (its s_swappc_b64 at program counter 0x138 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05b800 could not be prepared at registration (its s_swappc_b64 at program counter 0x128 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05bc00 could not be prepared at registration (its s_swappc_b64 at program counter 0x128 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05c000 could not be prepared at registration (its s_swappc_b64 at program counter 0x128 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e05c400 could not be prepared at registration (its s_swappc_b64 at program counter 0x128 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e091b00 could not be prepared at registration (its s_swappc_b64 at program counter 0xbc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e092800 could not be prepared at registration (its s_swappc_b64 at program counter 0xb4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e093500 could not be prepared at registration (its s_swappc_b64 at program counter 0xb4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e094200 could not be prepared at registration (its s_swappc_b64 at program counter 0xb4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e098a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1d8 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e099400 could not be prepared at registration (its s_swappc_b64 at program counter 0x1d4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e099e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1d0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e09a800 could not be prepared at registration (its s_swappc_b64 at program counter 0x1d0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d6700 could not be prepared at registration (its s_swappc_b64 at program counter 0x13c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d6b00 could not be prepared at registration (its s_swappc_b64 at program counter 0x138 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d6f00 could not be prepared at registration (its s_swappc_b64 at program counter 0x138 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d7300 could not be prepared at registration (its s_swappc_b64 at program counter 0x138 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d7900 could not be prepared at registration (its s_swappc_b64 at program counter 0x708 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d8500 could not be prepared at registration (its s_swappc_b64 at program counter 0x708 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d9100 could not be prepared at registration (its s_swappc_b64 at program counter 0x708 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x55f16e0d9d00 could not be prepared at registration (its s_swappc_b64 at program counter 0x70c calls a computed target); preparing it when it is used
[libSceSysmodule/Export.cpp:141 sceSysmoduleLoadModule] unknown id: 298
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c47e80 self=0x55f1aba136d0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c47ee0 self=0x55f1ababa810
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c55260 self=0x55f1abb71f10
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16bbacc20 arg=0xf4030e5e70 self=0x55f1abb678c0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16bbacc20 arg=0xf4019d4268 self=0x55f1abb6acf0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16bbacc20 arg=0xf4019d4390 self=0x7f8cac272bc0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c57dc0 self=0x55f1ac5fabf0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16a0ad910 arg=(nil) self=0x55f1abeb5130
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16a0ae2f0 arg=(nil) self=0x55f1abeb12b0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c65160 self=0x55f1abefee90
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16a0c9350 arg=(nil) self=0x55f1abec1e40
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c66660 self=0x55f1abf34a60
[memory] configured flexible memory: 0x1c000000 bytes (448 MiB)
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400c57d60 self=0x55f1abf00ed0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400c57080 self=0x55f1abf01060
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400c57e10 self=0x55f1abfd2fb0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b3ffd0 self=0x55f1abeabd90
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b3eff0 self=0x55f1abf60580
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b3b210 self=0x55f1abf369a0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b37fd0 self=0x55f1ac5fb5b0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b373f0 self=0x55f1ac5fbdc0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b33610 self=0x55f1ac5fc530
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b2f810 self=0x55f1ac5fd000
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b2ba30 self=0x55f1ac5fd630
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f16c765600 arg=0xe400b27c30 self=0x55f1ac5fde40
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c67700 self=0x55f1ac5fe650
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c67760 self=0x55f1ac5feef0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c677c0 self=0x55f1ac5ffaf0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c67820 self=0x55f1ac600300
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae8d200 could not be prepared at registration (its s_swappc_b64 at program counter 0x1c0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae8ee00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae90900 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae92400 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae93f00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae95a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae97500 could not be prepared at registration (its s_swappc_b64 at program counter 0x1c0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae99100 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae9ac00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae9c700 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae9e200 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120ae9fd00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1bc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aea1900 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aea3400 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aea4f00 could not be prepared at registration (its s_swappc_b64 at program counter 0x184 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aea6a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aea8500 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeaa000 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeabb00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aead600 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeaf100 could not be prepared at registration (its s_swappc_b64 at program counter 0x184 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeb0c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeb2700 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeb4200 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeb5d00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeb7800 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeb9300 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aebae00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aebc900 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aebe400 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aebff00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aec1a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aec3500 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aec5000 could not be prepared at registration (its s_swappc_b64 at program counter 0x1bc calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aec6c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aec8700 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeca300 could not be prepared at registration (its s_swappc_b64 at program counter 0x1a4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aecbf00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aecda00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aecf500 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aed1000 could not be prepared at registration (its s_swappc_b64 at program counter 0x1a4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aed2c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1a0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aed4700 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aed6400 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aed7f00 could not be prepared at registration (its s_swappc_b64 at program counter 0xae4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aed9c00 could not be prepared at registration (its s_swappc_b64 at program counter 0xa38 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aedb800 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aedd300 could not be prepared at registration (its s_swappc_b64 at program counter 0x1a0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aedee00 could not be prepared at registration (its s_swappc_b64 at program counter 0xb3c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aee0b00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aee2600 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aee4100 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aee5e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aee7900 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aee9400 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeeaf00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeeca00 could not be prepared at registration (its s_swappc_b64 at program counter 0x1b0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aeee500 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aef0000 could not be prepared at registration (its s_swappc_b64 at program counter 0xb60 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aef1d00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aef3800 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aef5300 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aef6e00 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aef8b00 could not be prepared at registration (its s_swappc_b64 at program counter 0x180 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c02800 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c02c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c03000 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c03400 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c03800 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c04f00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c05600 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c05a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c06100 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c06500 could not be prepared at registration (its s_swappc_b64 at program counter 0x168 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c06900 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c07e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c08200 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c08a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c08e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c09200 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c09600 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c09a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c0aa00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c0c600 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c0d900 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c0dd00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c0ed00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c10a00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c10e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x168 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c13800 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c13c00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c14d00 could not be prepared at registration (its s_swappc_b64 at program counter 0x164 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c15100 could not be prepared at registration (its s_swappc_b64 at program counter 0xb6c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c17b00 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c19800 could not be prepared at registration (its s_swappc_b64 at program counter 0x7d0 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c1b400 could not be prepared at registration (its s_swappc_b64 at program counter 0xb74 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c21e00 could not be prepared at registration (its s_swappc_b64 at program counter 0x7f4 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c40400 could not be prepared at registration (its s_swappc_b64 at program counter 0x9f8 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c41200 could not be prepared at registration (its s_swappc_b64 at program counter 0x98c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c42800 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c4cd00 could not be prepared at registration (its s_swappc_b64 at program counter 0x804 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c57700 could not be prepared at registration (its s_swappc_b64 at program counter 0x868 calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c6da00 could not be prepared at registration (unsupported MIMG opcode 0xe5); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258c72000 could not be prepared at registration (its s_swappc_b64 at program counter 0x88c calls a computed target); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x120aefa600 could not be prepared at registration (its program address is not in the shader registers); preparing it when it is used
[Shaders/ShaderRegistry.cpp:760 operator()] Shader 0x1258ddcb00 could not be prepared at registration (its program address is not in the shader registers); preparing it when it is used
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400c67880 self=0x55f1ac01aee0
[gpu] host import of 0xe400800000+0x800000 failed at vkAllocateMemory (-1000072003); falling back to copies
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e88fa0 self=0x55f1abfe8350
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e89000 self=0x55f1abff62e0
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e89060 self=0x55f1abff2550
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e890c0 self=0x55f1abffa610
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e89120 self=0x55f1ac000560
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe400e891c0 self=0x55f1abff1370
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C4 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C7 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x180700C3 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Open.cpp:409 sceFontOpenFontSet] fontSetType=0x1807A444 file=(none)
[src/Thread.cpp:527 RunThread] RunThread entry=0x55f168f0fd80 arg=0xe4010b20e0 self=0x55f1ae0948a0
[shader-disk-cache] (10 s): 0 hits, 1670 misses, 1669 writes (461.2 MiB), 0 load failures, 0 write failures; resource plans: 0 hits, 1646 misses, 1645 writes, 0 load failures; 0.0 MiB read in 134.0 ms (totals: 0 hits, 1670 misses, 1669 writes; plans 0 hits, 1646 misses)
[affinity] queue workers and presenter -> 0xff (hybrid=1 efficient=0xff00 performant=0xff process=0xffff)
[gpu] host import of 0xe400000000+0x800000 failed at vkAllocateMemory (-1000072003); falling back to copies
[gpu] host import of 0x1000000000+0x800000 failed at vkAllocateMemory (-1000072003); falling back to copies
timeout: the monitored command dumped core
RUN_NEW2 rc=139

Activity

  1. MarcZX10 commented on Oct 15, 2026

    @MarcZX10
    Contributor

    I reread the trace wording: it says r14 is already null on entry to this basic block. That means the immediately preceding scePthreadMutexUnlock call is not shown to have clobbered it, so my ABI question does not follow from the evidence. The unresolved point is where the null context originates earlier in the event/present path; without that state or a reproducible current-main trace, I do not see a safe code change.

  2. Lberonio commented on Oct 15, 2026

    @Lberonio
    ContributorAuthor

    Follow-up: origin of the null g_ctx + a current-main trace (2 EOPs, 1 flip)

    I re-ran on current main and traced the whole thing. The null context comes from the guest itself; the second EOP event (the one that consumes the slot a second time) comes from Driver::execute's flip branch, not from the event-queue bookkeeping.

    Test setup: main @ 34454bd + #6083, relinked to x86-64 (relinker --to-intel conv/source/input.elf conv/app.elf), Arch Linux / GCC 16.2.1, AMD Radeon RX 9070 XT (RADV GFX1201, vendor=0x1002 device=0x7550 subgroup=64). Repro: cd ~/anyps5/gt7b && ./app.elf → SIGSEGV (rc=139) within ~10 s.

    1. Guest side

    The guest keeps a single pointer to the "current AGC context" in BSS:

    0x650C9C0  g_ctx
    0x650C9C8  g_ctxSize
    

    Install (0x5FFA82, r15 = new context):

    5ffa89  mov   r15,[rax+0x8]
    5ffa8d  test  r15,r15
    5ffa90  jne   0x5ffaa4
    5ffa92  mov   r15,[0x650c9d0]        ; fallback pending-context slot
    5ffa99  movq  [0x650c9d0],0
    5ffaa4  cmpq  [0x650c9c0],0          ; if (g_ctx != 0)
    5ffaac  je    0x5ffae5               ;   producer otherwise waits on the condvar
    5ffaae  mov   r14,rdi
    5ffab1  call  0x4192300              ; scePthreadMutexLock(0x6511658)
    5ffab6  cmpb  [0x6511668],1
    5ffabd  jne   0x5ffada
    5ffabf  mov   rdi,r13
    5ffac2  mov   rsi,r14
    5ffac5  movb  [0x6511669],1
    5ffacc  call  0x4192350              ; scePthreadCondWait(0x6511658)
    5ffad1  cmpb  [0x6511668],0
    5ffad8  jne   0x5ffabf
    5ffada  mov   rdi,r14
    5ffadd  call  0x4192320              ; scePthreadMutexUnlock
    5ffaeb  movb  [r15+0x8d],1
    5ffaf2  call  0x4192300              ; scePthreadMutexLock (install side)
    5ffaf7  mov   [0x650c9c0],r15        ; g_ctx = ctx          <-- INSTALL
    5ffafe  mov   DWORD [0x650c9c8],0x1c20
    

    Release, at the AGC branch of the event loop (0x1F94EC7):

    1f94ec7  call  0x1b4c6d0             ; dispatch gate -> sceAgcDriverGetEqEventType (PLT 0x4195790)
    1f94ecc  test  al,al
    1f94ece  jne   0x1f94d47             ; not a release -> continue the loop
    1f94edb  mov   r14,[rip+0x4577ade]   ; r14 = g_ctx (0x650C9C0)
    1f94ee2  lea   rdi,[0x6511658]
    1f94eec  call  0x4192300             ; scePthreadMutexLock
    1f94ef1  movb  [0x6511668],0
    1f94ef8  movq  [0x650c9c0],0         ; g_ctx = 0
    1f94f03  cmpb  [0x6511669],1
    1f94f1a  call  0x4192390             ; scePthreadCondBroadcast
    1f94f26  call  0x4192320             ; scePthreadMutexUnlock
    1f94f2b  mov   rax,[r14+0x48]        ; 49 8B 46 48  <-- deref with r14 = 0
    

    Exactly two stores to 0x650C9C0 exist: 0x5FFAF7 (install) and 0x1F94EF8 (release). The producer waits on 0x6511668 while a context is installed; the consumer clears g_ctx and broadcasts. The invariant is one install ↔ one release, and there is no null check on the consumer side.

    2. Runtime side

    Counting AgcDriverDeliverEopInterrupt (and the ++flipsCounted immediately after the flip branch) over a full run:

    E EOP #1  queue=0x0  <- off 0x295a65   Driver::commitLabel   (PacketMemory.cpp:403)
    E EOP #2  queue=0x0  <- off 0x284a2a   Driver::execute      (PacketExecution.cpp:295, flip branch)
    F flip++  #1                            (exactly one flip in the whole run)
    
    • EOP macOS support #1: the guest's own request. It emits a divertable 0x49 RELEASE_MEM with interruptSelect = 1 and address 0 (a pure EOP marker). enqueueLabelPacket hands it to DrawPipeline::Queue0(), and commitLabel delivers at line 403.
    • EOP fix(build): register relinker tests with CTest #2: the flip. PacketExecution.cpp:295, if (!flipInterruptDeferred) AgcDriverDeliverEopInterrupt(submission.queue);. Since the EOP marker took the divert path (which continues), the flip is a different packet in the same command stream.

    Decoding every label packet the guest routes through Pm4::DecodeLabelWrite (the submit-time noteHeldAtSubmit scan and the execution pass agree):

    opcode=0x49 int_sel=3 target=0xE400002D78   (store)
    opcode=0x49 int_sel=0 target=0x100021F8E0   (store)
    opcode=0x49 int_sel=3 target=0xE400002D80   (store)
    opcode=0x49 int_sel=0 target=0x100021F4C0   (store)
    opcode=0x49 int_sel=1 target=0x0            <-- the guest's ONLY EOP-marked packet
    opcode=0x37                           0x100025FCE0
    opcode=0x37                           0x100025FD00
    

    So the guest asks for one EOP and gets two: one for its marker (commitLabel line 403) and one for the flip (Driver::execute line 295). enqueueLabelPacket's own line 276 in that branch is also un-deduplicated against line 295, so a flip whose cursor packet is itself an EOP-marked release delivers twice from the same branch.

    3. Toggles

    APS5_PIPELINE_DRAIN_LABELS=1 and APS5_LABEL_LOCK_EACH=1 don't change anything: still 2 EOPs, and the guest still faults at 0x1F94F2B (g_ctx: 0x1000200000 → 0 → (2nd event) still 0).

    Question

    Is the flip supposed to raise a graphics-core EOP in addition to the release the guest marked with interruptSelect=1? On the guest side both look like the same end-of-frame notification, and only one context is armed/consumed at a time, so the flip's extra EOP is the delivery that removes the entry and then trips the null. If the flip delivery is intended, should it be suppressed when the queue already signalled the guest's EOP marker for that flip (and should lines 276/295 collapse to one delivery)?

    I can capture anything further you'd like (per-delivery equeue data, per-submission EOP counts, longer runs).

  3. frankea commented on Oct 15, 2026

    @frankea
    Contributor

    A second title logs the same unknown sysmodule id, which may help place it. Horizon Call of the Mountain (PPSA05666, PS VR2 only, #6214) logs both sceSysmoduleLoadModule unknown id: 298 and unknown id: 304 right after its thread start-up, on main (fa539dd through 31cbb55, Windows, RTX 4090); like here they do not stop the title. GT7 is PS VR2-capable and Horizon is PS VR2-only, and Horizon's import list has both libSceHmd2 and libSceVrTracker2, while the 285-entry kModuleTable has libSceHmd (0xd4) and libSceVrTracker (0xed) but no entry for either 2 library. So 298 and 304 are probably the module ids of libSceHmd2 and libSceVrTracker2, in some order. I have not found a public source that fixes which is which, so I am not proposing table entries; if someone has a title that imports only one of the two and logs only one of the ids, that would settle it.

    AI-assisted: yes (Claude Code).

  4. frankea commented on Oct 16, 2026

    @frankea
    Contributor

    Windows/NVIDIA reproduction on stock main, and a detail about #6083: on Windows the crash does not need it.

    Setup. Gran Turismo 7 PPSA01317 01.000.001 (base package, no update; the report above is 01.680), extracted with PS5 PKG Tool. Windows 11 (26200), RTX 4090 (NVIDIA 616.92), AMD Ryzen 7 5800X, MinGW-w64 GCC 15.2.0 r7 (UCRT), Release libs. main 31cbb55 libs; app.exe from the same main's relinker with --windows --registry --module-dir . (the dump keeps logiWheel.prx and libSieRdNNabla.prx at its root, and without --module-dir . the loader stops on Failed to load module: libs\logiWheel.prx, error 126). No controller, no input.

    Result. Deterministic, 3 of 3: plain main twice (cold cache 21 s, warm 11 s) and main 5d9dcc4 + #6083 (f7b2ebd) once, same thread, same instruction:

    FATAL: unhandled exception 0xc0000005 on thread 17008 'PGL Event'
      rip 0x0000000141a51e90 app.exe+0x1a51e90
      read of 0x0000000000000048
      rax 0000000000000000 ... r14 00007fff9aba1060 r15 0000000000000000
      frame pointer chain:
        #0 0x00007fff9a74dfe6 libkernel.prx+0x4dfe6
    

    The bytes at that address are your block, with r15 as the null context instead of r14 (different content version):

    48 8d 3d 8d 87 8d 04      lea  rdi, [rip+0x48d878d]   ; the global mutex
    e8 30 8e 4c 02            call scePthreadMutexUnlock
    49 8b 47 48               mov  rax, [r15+0x48]        <-- fault, r15 = 0
    48 3d 00 00 01 00         cmp  rax, 0x10000
    72 4e                     jb   +0x4e
    49 8b 4f 48               mov  rcx, [r15+0x48]
    8d 41 01                  lea  eax, [rcx+1]
    ...
    f0 49 0f b1 57 48         lock cmpxchg [r15+0x48], rdx
    

    So the null context in the frame-pacing loop is the same on Windows/NVIDIA and on the base version of the title, which fits the guest-side origin your follow-up traced rather than anything RADV- or Linux-specific.

    On #6083. On this build the sampler-pair case is only a deferred preparation on Windows, not a stop:

    [Shaders/ShaderRegistry.cpp:1086 operator()] Shader 0x1258d98500 could not be prepared after registration: shader 0x1258d98500 stage 0: ShaderRecompiler::Recompile: shader sampler pairs exceed runtime heap capacity
    

    so plain main reaches the crash without the PR, and the PR does not change the crash. sceSysmoduleLoadModule unknown id: 298 is logged here too (stdout line 71), as in your run and in Horizon's (#6214).

    Logs (stderr of the three runs) are on the bring-up thread: #4697 (comment)

    AI-assisted: yes (Claude Code).

  5. Lberonio commented on Oct 16, 2026

    @Lberonio
    ContributorAuthor

    Thanks @frankea — that's a useful independent data point, because it rules out two things I could only test from one side:

    • Not RADV/Linux-specific. Same consumer block, same mov rax,[rX+0x48] immediately after scePthreadMutexUnlock, with a null context in the frame-pacing loop on Windows/NVIDIA.
    • Not content-version- or PR-specific. It reaches the crash on PPSA01317 01.000.001 (base package, no update) and on stock main without fix(shader): allow 32 sampler pairs per shader #6083.

    On Linux I can see the mechanism that produces the null: the guest arms exactly one context per frame (g_ctx, BSS 0x650C9C0) and the consumer expects one release, but the runtime delivers two AGC EOPs for the guest's single interruptSelect=1 marker — one from Driver::commitLabel (PacketMemory.cpp:403, the guest's diverted 0x49 RELEASE_MEM) and one from Driver::execute's flip branch (PacketExecution.cpp:295). The second delivery releases a slot that was already cleared, so the next loop iteration enters the consumer block with a null pointer. The block you dumped is the same one, so the same two deliveries should be what runs on Windows.

    If you still have that Windows build to hand, the cheapest confirmation on the runtime side would be to count AgcDriverDeliverEopInterrupt calls and flipsCounted increments over a single frame: if that comes out at 2 and 1, then it is the same double-delivery and the platform-independence question is settled from both ends, not only from the guest side.

    On the sceSysmoduleLoadModule unknown id: 298/304 point: that looks orthogonal to the null deref (non-fatal, and consistent with missing libSceHmd2/libSceVrTracker2 entries in kModuleTable) — probably worth its own note rather than this thread.

    @MarcZX100 — does this change the picture? The Windows/NVIDIA run reaches the same consumer block with the same null dereference on the base title version and on stock main, so the origin of the null is on the guest side and is not RADV- or Linux-specific. The open question is still the one in my follow-up: whether the flip branch should deliver a second graphics-core EOP when the queue already honoured the guest's interruptSelect=1 marker for that flip.

  6. MarcZX10 commented on Oct 16, 2026

    @MarcZX10
    Contributor

    It strengthens the diagnosis that the two runtime delivery sites account for GT7's second release, but it does not change my recommendation on the fix. The trace establishes the guest's one-install/one-release expectation for this path and the runtime's two deliveries; it still does not establish whether the synthetic flip EOP is required in addition to a guest EOP for the same frame, or whether the runtime should suppress/coalesce it. The existing Minecraft and Death Stranding 2 reports also show that bare flips are relied on for an EOP. I would want a console trace/spec result for marker-plus-flip versus bare flip before changing delivery semantics. I don't see a safe PR to submit yet.

  7. Lberonio commented on Oct 16, 2026

    @Lberonio
    ContributorAuthor

    @MarcZX100 — you asked whether the synthetic flip EOP is required in addition to a guest EOP for
    the same frame. On GT7 the answer is no, and I now have a runtime experiment rather than only the
    static argument: dropping the flip's EOP turns the frame-1 SIGSEGV into a run that gets well into
    rendering.

    What the guest asks for

    GT7's queue-0 stream carries exactly one interrupting release, and it is not the flip:

    type3 opcode=0x49 int_sel=1 target=0x0   <- the only guest EOP request (null label, no store)
    ... int_sel=0 / int_sel=3 label stores   <- non-interrupting
    FlipPacketHeader 0xc004105c              <- separate submission
    

    The int_sel=1 release and the flip are in different submissions (the release submission has
    flips=0, the flip submission has no release). A same-submission rule cannot express this.

    What the runtime delivers

    Two AgcDriverDeliverEopInterrupt(0) per frame — the guest's own release via commitLabel
    (PacketMemory.cpp:403) and the flip via Driver::execute (PacketExecution.cpp:295 inline, or the
    deferred lambda at :292). Measured on the first frame:

    DELIVER #1 site=lib+0x295a65 ctx=0x1000200000   (guest release)
      consume #1 r14=0x1000200000 g_ctx=0x1000200000 -> released, g_ctx=0
    FLIP #1 (ctx=0x0)
    DELIVER #2 site=lib+0x284a2a ctx=0x0            (flip)
      consume #2 r14=0x0                             -> SIGSEGV
    

    One armed context, two events. That is the null g_ctx.

    Experiment: drop the flip's EOP

    Suppressing the flip's synthetic EOP in both paths (inline call and deferred lambda; the
    AfterRecordedWork call itself is kept, otherwise its completion bookkeeping changes GPU flushing):

    AFTER deliveries=353 consumer=353 nulls=0     # 80 s run under gdb, 0 SIGSEGV
    

    Plain run, 41 s: no SIGSEGV; it now stops on the next, unrelated gap
    (sceSslEnableVerifyOption not implemented; unsupported primitive type 21 in another run).

    Suppressing only the inline call is not enough: the fault moves from frame 1 to ~frame 33, where the
    Recorder::finish completion drain fires deferred EOP callbacks back to back (deliveries #34/#35 at
    site lib+0x411372, one armed context) — the same over-delivery through the other path, so the flip
    branch is not the only place that needs the rule.

    Scope

    I no longer propose a per-submission rule (the two packets are in different submissions).
    What I ran is a per-queue sticky rule: once a queue's guest asks for its own end-of-pipe interrupt,
    the runtime stops injecting the synthetic flip interrupt on that queue. Flip-only titles never set it,
    so Minecraft/DS2 keep the flip interrupt exactly as today.

    Patch (~20 lines, Driver.hpp + Submission.cpp + PacketExecution.cpp) attached below; built from
    34454bd + #6083, --to-intel, RX 9070 XT / RADV.

    I still cannot produce a console trace (no PS5 here), so the "one event per armed frame" reading rests
    on the guest-side invariant plus this runtime A/B. If you would rather have it as a PR, say on which
    base and I'll open one; if you want a narrower predicate than "the queue self-signals", tell me which
    and I'll re-run it.

    --- a/Execution/include/Driver/Driver.hpp
    +++ b/Execution/include/Driver/Driver.hpp
    @@ -315,6 +315,10 @@
         std::atomic<std::uint64_t> flipsCounted{0};
    +    // Set when the guest submits its own end-of-pipe release (sceAgcCbReleaseMem with an interrupt
    +    // selector). Such titles drive their own frame pacing, so the runtime must not add its
    +    // synthetic flip interrupt on top of the guest's own end-of-pipe interrupt.
    +    std::atomic<bool> guestSelfSignalsEop{false};
         std::atomic<std::uint64_t> flipSerial{0};
    @@ -36,6 +36,14 @@  (Submission.cpp)
    +bool GuestEopRelease(std::span<const std::uint32_t> words) {
    +    if (words.size() < 3 || (words[0] >> 30u) != 3u || ((words[0] >> 8u) & 0xffu) != 0x49u) return false;
    +    const auto interruptSelect = (words[2] >> 24u) & 7u;
    +    return interruptSelect != 0u && interruptSelect != 3u;
    +}
    @@ -261,7 +261,9 @@  (Submission.cpp, reserveOutputs)
    +        if (!isFlip && GuestEopRelease(std::span(submission.commands).subspan(cursor))) guestSelfSignalsEop.store(true, std::memory_order_relaxed);
    @@ -279,6 +279,12 @@  (PacketExecution.cpp, flip branch)
    +            const bool skipFlipEop = guestSelfSignalsEop.load(std::memory_order_relaxed);
    @@ -295,2 +295,2 @@
    -                    flipInterruptDeferred = localDevice->AfterRecordedWork([queueId] { AgcDriverDeliverEopInterrupt(queueId); }, false);
    +                    flipInterruptDeferred = localDevice->AfterRecordedWork([queueId, skipFlipEop] { if (!skipFlipEop) AgcDriverDeliverEopInterrupt(queueId); }, false);
    -            if (!flipInterruptDeferred) AgcDriverDeliverEopInterrupt(submission.queue);
    +            if (!flipInterruptDeferred && !skipFlipEop) AgcDriverDeliverEopInterrupt(submission.queue);
  8. MarcZX10 commented on Oct 16, 2026

    @MarcZX10
    Contributor

    Thanks; this A/B closes the key question for GT7. The two delivery sites in current main match the duplicate event in your trace.

    Please open a focused PR on current main (143f1305) with the runtime evidence and a regression test. One behavior needs coverage before the sticky per-queue flag is safe: after any single guest EOP, it suppresses every later synthetic flip EOP, including a later flip with no guest EOP. The existing bare-flip test runs before any guest EOP, so it would not catch that. Could you add a test for the sequence (guest EOP, later bare flip), or otherwise establish that guest self-signaling is a queue-lifetime mode?

    PR #6616 also changes the pipelined EOP-flip path in PacketExecution.cpp; please coordinate/rebase against it and describe any dependency so the two behaviors are reviewed together. The A/B result is promising, and I’ll review the PR once you open it.

  9. MarcZX10 commented on Oct 16, 2026

    @MarcZX10
    Contributor

    For the narrower rule you asked about, I would make suppression pending only until the next queue-0 flip: when a guest EOP is actually delivered, mark one pending guest signal; at the next flip, consume that marker and skip only that flip's synthetic EOP, then clear it. A later bare flip would still get the synthetic event. This handles markers and flips in separate submissions without making one early EOP disable synthetic flip notifications for the rest of the queue lifetime.

    One implementation detail: reserveOutputs() scans a whole submission before execute() processes its packets, so setting the flag during that scan could suppress a flip that appears earlier in the same submission than the guest EOP. The marker should follow execution/delivery order. A focused test should cover guest EOP → flip (one delivered event), then a later bare flip (one synthetic event), and the reverse packet order if valid.

    Please try that predicate against your trace and, if it holds, open the PR on current main; the test will make the cross-submission and ordering behavior reviewable.

  10. MarcZX10 commented on Oct 16, 2026

    @MarcZX10
    Contributor

    Opened #6963 for the guest-EOP / synthetic-flip suppression and focused packet-order regression. It depends on #6616, keeps the suppression marker tied to actual guest queue-0 delivery, and verifies that a later bare flip still triggers. Locally, the focused CTest passed 1/1 on Linux after temporary local-only workarounds for this host’s CPU gate and an unrelated GCC 12 template parse issue; those workarounds are not in the PR. I did not run GT7 or claim GPU validation.

  11. Lberonio commented on Oct 17, 2026

    @Lberonio
    ContributorAuthor

    Built and ran the tree from #6963 against the GT7 dump (PPSA01317 01.000.001, RX 9070 XT / RADV,
    --to-intel): the title still takes the same fault at frame 1 — one guest EOP delivered, one
    synthetic flip EOP still delivered after it, consumer derefs null at guest 0x1F94F2B.

    Full trace, the same-session A/B table, and why the one-shot marker misses GT7 are on the PR:
    #6963 (issuecomment-6231996930).

    Short version: GT7 pairs two flip submissions with one guest-EOP submission
    (flips=0/flips=1/flips=1 repeating over 598 instrumented submissions), so the single pending marker
    is consumed by the first flip and the second flip still delivers. Keying on the queue's
    guest-EOP-issued mode instead of a one-shot marker ran 45 s without the fault.

  12. Lberonio commented on Oct 17, 2026

    @Lberonio
    ContributorAuthor

    The SIGSEGV traced here is now carried as its own change: #7137 (libSceAgcDriver: a flip no longer raises the queue's end-of-pipe event on a queue that has already delivered an interrupt from one of its own release packets). GT7 pairs two flips with one release interrupt per frame, which is why the crash survived the earlier one-shot approach on #6963.

    With the change: 231 deliveries / 231 consumer entries / 0 null contexts, all from the guest release site, none from the flip site; the run no longer faults at 18 s. It then stops on unrelated gaps — sceSslEnableVerifyOption not implemented in a plain run, an unsupported primitive type on another — so this issue is not closed by #7137 and the title still does not reach a playable state.

    Details, the focused test (agc_driver_tests --eop-interrupts), and the scope limits are in #7137 and on #6963.

  13. MarcZX10 commented on Oct 17, 2026

    @MarcZX10
    Contributor

    Thanks for the follow-up and the two-flips-per-release trace. The #7137 report now shows this specific frame-pacing SIGSEGV is avoided by suppressing synthetic flip EOPs after the queue has delivered its own release interrupt. It then reaches separate blockers (sceSslEnableVerifyOption and an unsupported primitive type), so keeping this issue open for those later failures is appropriate; this comment does not claim GT7 is playable.

  14. Lberonio commented on Oct 17, 2026

    @Lberonio
    ContributorAuthor

    Agreed on leaving this open, thanks. Two accuracy notes on the "later failures", since one of them is no longer a gap:

    sceSslEnableVerifyOption is already implemented on main. In core/libs/prx/libSceSsl/Export.cpp it now takes (int sslConnectionId, std::uint32_t option) and sets RequireConnection(...).verifyOptions |= option. The not implemented abort in my runs comes from the runtime I assembled at 34454bd, where that export was still int APS5_VABI sceSslEnableVerifyOption(void) { NotImplemented_nid_no_patch(__func__); }. A runtime built from current main should not hit it; it is stale for that base, not an open gap.

    AGC graphics: unsupported primitive type 21 is still real on main. It is thrown by DecodeState in core/libs/prx/libSceAgcDriver/Graphics/src/State.cpp, whose switch (primitive) covers 1, 2, 3, 4, 5, 6, 7, 9 and 17, and whose default throws. 21 is PrimitiveType::Polygon in core/libs/prx/libSceAgc/Shader/include/ShaderConstants.hpp. On the queue-latch build it surfaces as [gpu] driver failure → [videoout] presentation failed at 41–45 s, after the frame-pacing fault is gone.

    So of the two, the remaining blocker for a main-built runtime is the polygon primitive path in the AGC graphics state decode; the SSL one should be re-checked on such a runtime before being counted. I have not run either against a full main runtime build, so that re-check is a prediction from the sources, not a measurement.

  15. Lberonio commented on Oct 17, 2026

    @Lberonio
    ContributorAuthor

    New finding on current main, independent of #7137: a modern driver cannot reach GT7's frame-pacing loop at all, because the title's display buffer is rejected at registration.

    [libc] unhandled exception 'St13runtime_error' thrown from ...
      what():  VideoOut: 4 KiB display buffer alignment is only supported for linear buffers
    

    It is not caused by #7137. Two runs on the same 34454bd runtime, one with the driver built from the #7137 branch and one with the driver built from unmodified origin/main (e679bab91), produce the same 8.9 KB trace and the same abort; the only differences are thread and pointer addresses (ASLR). Neither reaches the flip path, and neither takes the frame-pacing SIGSEGV.

    Where it comes from. core/libs/prx/libSceAgcDriver/Execution/src/DisplayBuffer.cpp:133:

    require(buffer.alignment == 65536u || (buffer.alignment == 4096u && buffer.tilingMode == 1), "VideoOut: 4 KiB display buffer alignment is only supported for linear buffers");

    That line was added on main in 901b92c79 ("feat(libSceVideoOut): register PS4 display buffers", 2026-10-11). At the runtime base 34454bd the same function only validated the address:

    require(buffer.address != 0 && (buffer.address & (65536 - 1)) == 0, "display buffer requires 64 KiB alignment");

    GT7 passes that older rule — those runs reach frame pacing and present frames — so the new rule is what stops it. The requirement keys off the guest-declared buffer.alignment field, which the older code never read. I do not have GT7's declared alignment/tilingMode values yet; the message covers any pair other than 64 KiB, or 4 KiB with linear tiling.

    Configuration caveat. To load a main-built libSceAgcDriver.prx I also regenerated libc.prx from main: the branch prx imports LibcRegisterFailureReport_nid_no_patch, which the runtime's Oct-15 libc.prx does not export, and main's now does. So both runs above are main driver + main libc on an otherwise 34454bd runtime, not a single-module swap. A full runtime build from main is the clean environment, but since the untouched main driver fails at the same line with the same message, the display-buffer rejection stands on its own.

    Consequence for the trackers: main needs this display-buffer rule checked against GT7 before the title can reach the flip path there, and the two later blockers I mentioned earlier (sceSslEnableVerifyOption, unsupported primitive) sit behind this one rather than in front of it. For #7137 this is also why the exact-artifact GT7 run stays limited to the equivalent change on the older tree.

  16. pushkarreddyy commented on Oct 17, 2026

    @pushkarreddyy
    Contributor

    Taking this remaining blocker (\AGC graphics: unsupported primitive type 21). Implementing \PrimitiveType::Polygon\ (21) mapped to \VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN\ in \DecodeState\ with unit regression tests covering state decode, restart suppression, and rasterization handling, and will open the PR shortly.

  17. frankea commented on Oct 17, 2026

    @frankea
    Contributor

    Windows/NVIDIA run of the stack gjonn lists on D4697 (#7137 + #7207 + #7175 + #5958) on current main, same base layout as my stock-main report above. Short version: the frame-pacing crash is gone here too, and the next stop on a main-built runtime is sceSslConnect, not a graphics gap.

    Setup. Gran Turismo 7 PPSA01317 01.000.001 (base package), Windows 11 (26200), RTX 4090 (NVIDIA 616.92), AMD Ryzen 7 5800X, MinGW-w64 GCC 15.2.0 r7 (UCRT), Release libs. Tree: main e1041f6 + #7137 2aa6bfc + #7207 ec28b6b + #7175 555b7e8 (all three merge clean), and as a second libs set the same plus #5958 87a9b8d, whose only conflict with main is two target_include_directories lines appended for different test targets in core/libs/prx/libSceAgcDriver/CMakeLists.txt (both kept). app.exe is still the relink from main 31cbb55 (--windows --registry --module-dir .); only libs/ was swapped. No controller, no input, nobody at the keyboard.

    Result. Every run on either set (one on the three-PR set, six on the four-PR set; the three quoted below ran with the box otherwise idle) gets past the crash: no 0xc0000005 on PGL Event, no unsupported primitive type 21, no unsupported color format 7, and no 4 KiB display-buffer alignment stop either (this 01.000.001 copy passes the DisplayBuffer.cpp:133 check that @Lberonio's 01.680 copy fails). The title shows its "Sony Interactive Entertainment presents" splash, mounts its save data (mount3 ... dir=DRFILEIV ... -> 0x809f0008) and then aborts, identically every time:

    [libc] unhandled exception 'St13runtime_error' thrown from 00007fff45d7aaa4
    terminate called after throwing an instance of 'std::runtime_error'
      what():  sceSslConnect not implemented
    FATAL: abort() (SIGABRT) on thread 1988
      stack return address candidates:
        ...
        [rsp+0x2f8] 0x00007fff96c27761 libSceSsl.prx+0x7761
        [rsp+0x328] 0x00007fff96c21b20 libSceSsl.prx+0x1b20
        [rsp+0x358] 0x00000001405d741d app.exe+0x5d741d
    

    Wall clock from launch to exit, same run-gt7.cmd as before:

    libs run shader cache exit after stop
    main 31cbb55 (10/16) 3 runs cold / warm 21 s / 11 s / 22 s 0xc0000005 on PGL Event, app.exe+0x1a51e90, r15 = 0
    main + #7137 + #7207 + #7175 1 cold (1,785 misses) 58 s sceSslConnect not implemented
    + #5958 1 warm (1,785 hits) 47 s same
    + #5958 2 warm (1,674 hits) 25 s same
    + #5958 3 warm (1,674 hits) 25 s same

    The stock-main runs died before the logger's first 10 s summary and never reached the save-data mount; the stack runs log the summaries, the mount and the connect attempt. The emulator's title-bar counter is still on the splash when the abort comes (0.7 to 18 FPS across captures, so no rate worth quoting). ~210 shaders are deferred at registration (201 computed s_swappc_b64 targets, 7 unsupported MIMG opcode 0xe5, 2 without a program address), none of them a stop.

    Why it stops there. sceNetCtlGetState answers IPOBTAINED whenever the host has an address (libSceNetCtl/Export.cpp), so the title goes online at boot and reaches sceSslConnect, which is NotImplemented_nid_no_patch at libSceSsl/Export.cpp:497. That fits gjonn's note on D4697 that offline mode is still a local switch in his tree, and it is what a plain main runtime needs next on this path. (sceSslEnableVerifyOption is not hit here, as @Lberonio predicted for a current main runtime.)

    The trimmed stderr of a warm run is on the bring-up thread: #4697 (comment)

    AI-assisted: yes (Claude Code).

  18. MarcZX10 commented on Oct 17, 2026

    @MarcZX10
    Contributor

    Thanks for testing the stack on Windows/NVIDIA. This confirms the title gets past the reported frame-pacing/graphics stop with #7137, #7207, and #7175 on your setup; the later sceSslConnect stop is a separate startup blocker. Please track that SSL failure separately if you have a reproducible log, so this issue stays scoped to the original SIGSEGV.

  19. frankea commented on Oct 18, 2026

    @frankea
    Contributor

    @MarcZX100 agreed on the scope. The sceSslConnect stop doesn't need its own issue: libSceSsl had no transport at all (the call threw NotImplemented), and two open PRs give it one, #6828 (opened first, the base) and my #7319 (now a draft on top of it). With #7319's libSceSsl.prx swapped into the same #7137 + #7207 + #7175 stack, the title gets past the handshake 3 of 3 and stops about 28 s in on the next gap, AGC graphics: blending into an 11_11_10 float color target is unsupported. I'm keeping that and whatever follows on D4697, so this issue stays on the SIGSEGV.

    AI-assisted: yes (Claude Code).

  20. MarcZX10 commented on Oct 18, 2026

    @MarcZX10
    Contributor

    The 01.680 registration refusal looks like a separate concrete follow-up from the resolved frame-pacing crash, but the captured report does not include the guest DisplayBuffer fields that trigger the condition. Could you capture the registered buffer’s alignment, tilingMode, address, pitch, and format from PPSA01317 01.680, and the same fields from 01.000.001 where registration passes? That would let us verify whether main’s 4 KiB/linear restriction rejects a valid guest descriptor before proposing a change.

  21. Lberonio commented on Oct 18, 2026

    @Lberonio
    ContributorAuthor

    First, a correction to what I said earlier, then the numbers.

    The 4 KiB stop came from pairing trees, not from this title's buffer. AgcDriver::DisplayBuffer gained its alignment member in 901b92c79. The runtime's libSceVideoOut.prx is built from 34454bd, whose DescribeVideoOutBuffer constructs the struct with the eight members it has (address, pixelFormat, width, height, tilingMode, pitchInPixel, dccAddress, dccClearColor) and never writes alignment, so a driver built from a newer tree reads a value that no code set. That is why an unmodified origin/main driver stopped at the same line in the same pairing. So that run said nothing about Gran Turismo 7's buffer, and the fields have to be read from a runtime where the driver and libSceVideoOut come from one tree.

    PPSA01317 01.680, read from a runtime directory rebuilt from my branch (relinker + libs, both prx from the same tree). It registers three display buffers:

    address alignment tilingMode pitchInPixel pixelFormat width x height dccAddress
    0x203600000 65536 0 0 0x8100000022000000 3840 x 2160 0x209600000
    0x2055e0000 65536 0 0 0x8100000022000000 3840 x 2160 0x209630000
    0x2075c0000 65536 0 0 0x8100000022000000 3840 x 2160 0x209660000

    dccClearColor is 0 on all three, and the addresses are 64 KiB aligned. It registers and unregisters the same three buffers throughout the run, always with these values (the driver sized them 313 times in one 42 s run and 978 in another).

    So the title registers tiled, DCC-compressed 3840x2160 buffers at 64 KiB alignment, and alignment is 65536 because it defaults to that and only the PS4 registration path in DescribeVideoOutBuffer lowers it to 4096 (for linear buffers, which is the only tiling that path accepts). sceVideoOutRegisterBuffers does not exist in the 34454bd runtime at all, so the title registered through sceVideoOutRegisterBuffers2 in that runtime. With driver and libSceVideoOut from one tree, the 4 KiB requirement is not reachable for this title.

    01.000.001: I cannot capture it here. The local dump is 01.680 and the 01.000.001 copy is frankea's on Windows. If he can run a build with the same [display-buffer] line in DisplayBufferSize, the values will line up directly with the table above.

    For context, not part of this question: with the same runtime built from this branch, the title no longer faults in the flip path (the unmodified runtime faults at 18 s); it reaches 40 s and aborts on unrelated gaps (sceSslConnect unimplemented, and an unsupported primitive type on another run).

  22. frankea commented on Oct 18, 2026

    @frankea
    Contributor

    @Lberonio here are the 01.000.001 values, from a runtime whose libSceAgcDriver.prx and libSceVideoOut.prx (all 127 prx) come from one tree. Your [display-buffer] line is not on a public branch of your fork, so I added the equivalent print at the top of DisplayBufferSize in core/libs/prx/libSceAgcDriver/Execution/src/DisplayBuffer.cpp, gated by an environment variable:

    std::fprintf(stderr, "[display-buffer] address=0x%llx alignment=%u tilingMode=%u pitchInPixel=%u pixelFormat=0x%016llx width=%u height=%u dccAddress=0x%llx dccClearColor=0x%llx\n", ...);

    Setup. Gran Turismo 7 PPSA01317 01.000.001 (base package, no update), Windows 11 (26200), RTX 4090 (NVIDIA 616.92), MinGW-w64 GCC 15.2.0 r7, Release libs target. Tree: main 48d61f5 (2026-10-18, so with #7137, #7207, #7175, #7238, #7240, #7271 and #7626 merged) + #7256 (which carries #7254) + #7243 + #5958, all four merged without conflicts, plus the print above and a local one-line bypass that makes sceHmd2Initialize answer 0x81110016 again (on current main the title aborts 5 to 12 s in on sceHmd2ReprojectionQueryBufferSizeAlign not implemented, since #7323, before it registers anything). app.exe is the relink from main 31cbb55 (--windows --registry --module-dir .); only libs/ is swapped. One run, 138 s, cold shader cache, no input.

    Result. The title registers three display buffers, and the driver sized them 550 times each (1,650 lines) over the run, always with the same values; the first sizing is the sixth stderr line, before the first shader registration:

    address alignment tilingMode pitchInPixel pixelFormat width x height dccAddress
    0x200800000 65536 0 0 0x8100000022000000 3840 x 2160 0x206800000
    0x2027e0000 65536 0 0 0x8100000022000000 3840 x 2160 0x206830000
    0x2047c0000 65536 0 0 0x8100000022000000 3840 x 2160 0x206860000

    dccClearColor is 0 on all three. So 01.000.001 lines up with your 01.680 table field for field: tiled (tilingMode 0, pitchInPixel 0), DCC-compressed, 3840x2160, pixelFormat 0x8100000022000000, alignment 65536. Only the base addresses differ (0x200800000 here against 0x203600000 on 01.680, 0x2e00000 lower); the spacing is identical on both versions, 0x1fe0000 between consecutive buffers and 0x30000 between their DCC addresses. With driver and libSceVideoOut from one tree the 4 KiB requirement at DisplayBuffer.cpp:133 is not reached on this version either, which agrees with your correction that the earlier stop came from pairing trees.

    For the thread's context, on the same tree the title no longer faults in the flip path on this box either: splash, black loading screen at 49 FPS, sceSslConnect now returns SSL_ERROR_UNKNOWN_CA (0x8095f00c) after a few WANT_POLLIN polls on each of its seven connections instead of aborting, and the run ends 37 s in on a ResourceMaterializer refusal (an 8-bit 2D T# read by a pixel shader through DIM 2D_MSAA image loads, the case #6815 is about). I am keeping that on D4697 rather than here, since it is off this issue's topic.

    AI-assisted: yes (Claude Code)

  23. fma-rc commented on Oct 19, 2026

    @fma-rc
    Contributor

    @Lberonio @frankea #7978 replaces the per-queue flip event latch from #7137 that resolved this crash: flips now raise no end-of-pipe event on any queue, and the event carries the release's interrupt context. I don't have Gran Turismo 7, so I can't check that the r14+0x48 null dereference stays gone. Could one of you run the stack you use now with #7978 in place of #7137's latch and say whether it still gets as far as before?

  24. frankea commented on Oct 20, 2026

    @frankea
    Contributor

    @fma-rc ran it: with #7978 the r14+0x48 null dereference stays gone on Windows/NVIDIA, and Gran Turismo 7 gets one stop further than my last stack. Without it, current main hits the crash again even though #7137's latch is still in the tree.

    Setup. Gran Turismo 7 PPSA01317 01.000.001 (base package), Windows 11 (26200), RTX 4090 (NVIDIA 616.92), MinGW-w64 GCC 15.2.0 (UCRT), Release libs, same layout and app.exe relink as my earlier reports here. Trees: main 3fd1cc3; main + #7243 da158d6 (the 11_11_10 replace blend from my last stack, merges clean); and that plus #7978 2c0ce89 (merges clean). Everything else my 10/18 stack needed (#5958, #6815, #7254, #7463, #7690) is on main now. No controller, no input, 240 s cap.

    libs runs exit after stop
    main 3fd1cc3 3 8 s / 6 s / 6 s 0xc0000005 on PGL Event, app.exe+0x1a51e90, read of 0x48, r15 = 0
    main + #7243 3 23 s / 6 s / 6 s same
    main + #7243 + #7978 3 156 s / 128 s / 128 s AGC graphics: layered rendering with a depth target is unsupported

    With #7978 every run gets the splash, the loading screen with the GT spinner at 59.94 FPS on the title-bar counter, the save-data mount (mount3 ... dir=DRFILEIV ... -> 0x809f0008) and about 4,500 to 5,300 presented frames (around 23 FPS late in the run) before the layered-depth refusal. That refusal is what #7256 covers, and it is the stop I reported on #7254 on 10/18 once #7254 was in. So the flip changes don't lose any progress on this title. I saw no stall from flip submissions now waiting for earlier flips: the counter keeps moving until the refusal.

    Without #7978, current main stops 6 to 8 s in at the same instruction as the original report, before the save-data mount. On 10/18 main 48d61f5 + #7137 got past it, so something merged since then reaches this handler again with #7137's per-queue latch still in place. I did not pin it down. #6616 and #6794 both change when the flip event is delivered, but main at the #6616 merge still stops earlier, on sceHmd2ReprojectionQueryBufferSizeAlign, so that build cannot show the crash either way.

    AI-assisted: yes (Claude Code).

  25. Lberonio commented on Oct 20, 2026

    @Lberonio
    ContributorAuthor

    The RADV side of the GT7 run you asked for on #7978 is in that PR. Summary, same setup pattern as frankea (GT7 PPSA01317 v01.680, base package), Arch Linux, Mesa 26.2.4, RADV, RX 9070 XT:

    • current main: SIGSEGV in 4 of 4 runs at 18–22 s, null read at +0x48 with r14 = 0, caller frame libkernel.prx — the same 0x48 null-dereference class frankea hit. Always before GT7 draws.
    • fix(agc): raise no end-of-pipe event from flips and carry the release's interrupt context #7978: no fault in 4 of 4 runs. 4,203 frames presented (title-bar counter 571 → 2,374 → 4,203), reaches the PSN sign-in prompt, and survives clicking OK. It then stops on an unrelated sampled image descriptor uses an unsupported format gap at 98–112 s, with or without the click.

    So the flip changes do not lose progress on this title on RADV either, and the early null dereference is gone there too.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions