PS4 programs load system libraries with sceKernelLoadStartModule and
their console path. The OpenOrbis piglet sample loads
/<sandbox word>/common/lib/libScePigletv2VSH.sprx and
libScePrecompiledShaders.sprx, the sandboxed form of
/system/common/lib/ that sceKernelGetFsSandboxRandomWord names. The path
was opened as a guest file and the load failed with ENOENT.
A path in /system/common/lib/ or in the sandboxed /<word>/common/lib/
whose file name ends in .sprx now loads the host libs/<name>.prx, as
libSceSysmodule does for module IDs. Names with a directory part are
not mapped, so such a path cannot leave libs/.
PS4 titles ship sce_sys/param.sfo instead of param.json. When param.json
is absent, the application metadata now reads the title, title ID,
download data size and user defined parameters from param.sfo, and
/data and /download0 are mounted for it as for param.json. param.json
is still preferred when both files exist.
A coordinate just below 1 truncates to the wrong vertex. The generated evaluation shader is checked at each corner, and a draw records the vertex that lands on each corner of the rectangle.
Co-authored-by: Cursor <[email protected]>
Resolve the XCuZoBSVFG8 import required by Killzone Liberation by adding sceRazorCpuNamedSync as a no-op returning success when capture is inactive.
Extend the RazorCpu behavior test and document the NID source and unverified console signature and capture behavior.
Co-authored-by: Copilot <[email protected]>
Value::setTypeMismatchHandler, setElementAccessFailureHandler and
setSpecialFloatHandler were stubs that threw NotImplemented. PPSA07411
calls all three while it sets up its documents.
The title calls them as members of Value: on its root Value before
parsing into it, with the handler and its context, and treats an int
result of 0 as success. They now store the handler and context on that
Value and on the values it holds, and return 0. A Value keeps its
handlers when its content changes (set, clear, operator=,
Parser::parse), and Parser::parse gives the values it creates the
handlers of the Value it parses into, since the title reads the errors
its handlers record after accessing parsed members. A copy does not
carry them.
A typed getter on a non-null value of another type calls the type
mismatch handler with the requested type, the value, null and the
context, and returns its result when it has the requested type, else
the getter's default.
The element access failure and special float handlers are stored but
not called: the error code the console passes to the first and the
FunctionType it passes to the second are unknown. A failed element
access on a value carrying the first throws instead of reaching the
null-access callback. Serializing a non-finite real already threw; with
the second set it throws naming the unknown FunctionType. The technical
debt entry records what is inferred.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
NVIDIA's compiler predicates a branched LDS load at no cost, while the
selected form costs about 2.5 instructions per dword and splits a
ds_read_b128 into four loads (RTX 4060 measurements by @karanvora2599 in
loads therefore keep the branch of main, in workgroup, function and device
memory alike, and the sentinel dword that only they read goes away: the LDS
array is the program's dwords plus the lock again, and the device-memory
decision reserves the lock alone. The sentinel budget tests become lock
budget tests at that boundary, and the guarded-load test pins the branch.
Co-Authored-By: Claude Fable 5.1 <[email protected]>
A load selected instead of branched still accesses memory, so its fallback
element must be one no write can race with: scratch keeps element 0, LDS in
workgroup or function memory reads a sentinel dword appended after the
program's LDS and lock, and storage buffers read element 0xfffffffe, which
robustBufferAccess2 turns into a zero load without a memory access. The
device enables robustBufferAccess2 when it has it and the target carries the
flag; without it, and for LDS in device memory, buffer loads keep their
selections. The aligned high word of a buffer read re-reads the low word's
element instead of word 0. agc_guarded_memory_loads traces the emitted loads
in both device modes.
Co-Authored-By: Claude Fable 5.1 <[email protected]>
LDS, scratch and direct storage-buffer loads load element 0 when the lane is
inactive or the address is out of bounds and select 0 as the result, instead of
opening a selection per guard. Stores, atomics, formatted and physical-address
accesses keep their branches. A branch guard cost four blocks per lane half, and
the host compiler's time grows with the block count: PPSA11142's merged PSP
vertex program emitted 16,983 blocks and 1,710 conditional branches, 5,907 and
868 with the selects.
Co-Authored-By: Claude Fable 5.1 <[email protected]>
The nid_patcher turns each *_nid_no_patch_cut alias into a second dynamic
symbol with the same name as the plain alias exported next to it, seven
names in all. With those duplicates, LD_DEBUG=bindings shows libstdc++ keeping its own __cxa_allocate_exception, __cxa_throw,
__cxa_begin_catch, __cxa_end_catch, __cxa_rethrow, __gxx_personality_v0
and _Unwind_Resume while taking __cxa_init_primary_exception,
_Unwind_RaiseException and std::terminate from libc.prx. An exception
thrown inside libstdc++ (std::stoi, a stream with exceptions enabled) got
a libc header laid over a libstdc++ allocation, reached the libc
personality as a foreign exception, matched no typed handler and ended in
"terminate called without an active exception". The plain aliases already
export these names, so the duplicates go.
libstdc++ also describes std::__ios_failure with __iosfail_type_info, a
class that privately derives from __si_class_type_info at the same
address. Kind now follows such single same-address bases to the
__cxxabiv1 class, so catching std::ios_base::failure or std::exception
matches a stream failure.
The plain aliases came in a4c519b26 next to the cut aliases from
14f8c16ac.
On RADV the overlay's fragment shader read parameters.palette[paletteIndex]
as palette[0] for the text and graph rectangles, so they were drawn in the
panel's colour (0,0,0,0.6) and darkened the panel a second time instead of
drawing white or green. On an AMD Radeon RX 7600 (NAVI33) with Mesa 26.0.8,
agc_performance_overlay failed in its SDR case at "'6' of 'FPS: 60.0' glyph
pixel 2,0 is not white text: 0x4280161290": 0xff1e140a is the clear colour
(191,128,64) darkened by 0.4 twice, where the panel alone gives 0xff4c331a.
An integrated Radeon 660M failed at the full panel's first glyph.
The shader was valid SPIR-V: a flat uint input indexing a push-constant
array (the palette at offset 0, the extent at 48). The index is per
rectangle, and fragments of the panel and of its glyphs share waves, so it
varies within a wave; RADV read that divergent index into the push-constant
array as 0. The shader now reads each entry at a constant index and selects
one by the colour index. Every case passes on that RX 7600 with this change,
full panel included, and still passes on llvmpipe from the same Mesa.
A build keeps all of its own lookup records, so one over many textures
grows the thread-local log far past the 1024-record bound, and the vector
kept that peak capacity for the life of the thread: 2048 records after a
1500-texture build, on every thread that ever ran one.
When the outermost build or full walk ends, the log is trimmed back to
the newest 1024 records, as logLookup would have kept, and its capacity
is released once it exceeds one and a half times the bound. A log within
the bound never reaches that capacity, whether the vector grows by
doubling or by half, so ordinary builds do not reallocate. Nothing reads
the log after a build ends: captureValidation runs inside it and clears
it, a full walk clears it before its lookups, and resolveImageTables
reads only the record its own lookup just added.
A draw with PA_SC_AA_CONFIG.MSAA_NUM_SAMPLES 0 and MSAA_ENABLE clear
into a 4x depth target threw "the depth target's sample count differs
from the rasterizer's", which stops METAL GEAR SOLID: Peace Walker
(PPSA18216) at its first presentation. Such a draw now rasterizes the
depth target's sample count with every sample at the pixel center, as
a single-sample scan into a multisampled color target already does.
radeonsi programs this MSAA_ENABLE and PA_SC_AA_CONFIG with the depth
buffer's own sample count when GL multisampling is disabled, and GL
then gives full coverage with every depth and stencil sample set from
the pixel center.
Triangles and rectangles are accepted. Points, lines, alpha-to-coverage,
DB_EQAA Z interpolation or overrasterization, a pixel program reading
the sample index and a sample-mask export throw on this path, as does
a single-sample color target next to the multisampled depth target.
The primitive check is shared with the single-sample MSAA_ENABLE rule,
whose behaviour and messages are unchanged.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Adrià