A plan copies a branch condition only as far as the evaluator reads it,
and an operation the evaluator does not read is kept without its
arguments. Two questions the walk asks still read below such a leaf.
ResolveInvariantPhi compares a phi's incoming values with
EquivalentValue, which follows their arguments, so two leaves with the
same operation looked equal in the copy where their arguments differ
in the program: a phi whose incoming values differ only below a vector
load resolved in the plan and not in the program, and the plan decided
a condition the program leaves open. LoadedFromMemory looks for a read
from memory anywhere below a raw read's handle, so a handle that
reaches memory only below a leaf lost it in the copy: a read from a
null base counted as a null root, and its condition stayed open where
the program decides it.
ownPlanValues now checks both after it copies. Each phi it copied in
part must resolve in the copy to the copy of what it resolves to in
the program, and each raw read's handle must be loaded from memory in
the copy when it is in the program. A phi that differs is copied whole;
a handle that differs keeps the arguments along its shortest path to a
read from memory (its whole closure if that path is already kept), and
the copy is made again. The checks only add values, so the loop ends,
at worst with the whole copy. IsMemoryRead names the operations that
LoadedFromMemory and the path both stop at.
Tested: agc_shader_memory's verifyPlanCopyAnswers walks a phi whose
incoming values differ only below a vector load, and a read from a null
base whose handle reaches memory only through a select arm the active
mask never takes, through the plan's tape, the plan's interpreter and
the program's own walk, and all three agree. Without the checks the
plan decides the first condition and leaves the second open.
The plan of a hand-built program keeps exactly the 40 values its two
branch conditions and two descriptor sources read: none of the 64
additions under the vector load that the conditions reach only through
operations the evaluator does not read, which the whole copy kept (170
values). Its walk decides both conditions and resolves both sources as
the program's own walk does.
The plan of a compute program whose branch condition reads a scalar
load at an address taken from vector data keeps the same number of
values for vector chains of 1, 16 and 64 steps before the load. This is
fable-void's agc_driver_resource_plan_retention from cca1f5a8d, which
runs on his DeviceTableFixture; here the program is built from raw
words and read through GetResourcePlan.
The pruning case also takes the checks of his cb13fecfe: a condition on
a select of a vector load is dropped (main's MayEvaluate drops it), the
readable conditions stay, and no plan value keeps use lists or spare
operand capacity.
Co-authored-by: fablevoid <[email protected]>
A resource plan owns copies of the IR values its run-time evaluation
reads: the descriptor sources, the SRT reads, the uniform fills, and
the branch conditions that tell which images a dispatch can reach.
Below a scalar load from memory, the copy took every value the load
depends on, whether the evaluator can compute it or not. A condition
that reads memory after vector work (a load predicated by a vector
compare, an address computed from vector data) brought the program's
whole vector graph into the plan: in a title's programs 2.4 million of
2.6 million retained values, about 500 MiB, belonged to twelve or so
conditions per program.
Below a condition, the copy now follows only what the evaluator reads:
the arguments of values it can compute, and for a load from memory the
words of its descriptor and its offset; a value the evaluator cannot
compute is kept without its arguments, which is what evaluating it
needs (it does not evaluate). Descriptor sources keep their whole
closure, which the device image pre-pass walks.
Tested with a new test (agc_driver_resource_plan_retention): the plan
of a program whose branch condition reads a scalar load at an address
taken from vector data now keeps the same number of values for vector
chains of 1, 16 and 64 steps before the load (84, 114 and 210 before);
the device table, written image, buffer descriptor, memory and SRT
range and shader disk cache tests pass; in a title's corpus the plans
of 314 programs hold 40 thousand values instead of 837 thousand; the
corpus recompile with SPIR-V validation has no invalid module.
Resolved onto main: the retention test runs on DeviceTableFixture.hpp,
which main does not have, so the test and its CMake line are left out
here; the next commits test this on main.
ExtractPlan copied the whole argument closure of every control-flow
condition into the plan. The draw-time walk (SrtDescriptorEvaluation)
uses a condition only when the evaluator computes it, and an operation
outside the evaluator's set ends the evaluation without reading its
arguments. For conditions on vector loads, image results or values
carried around loops the copy reached most of the program, and none of
it was ever read.
Detail::Evaluator::Reads names what the evaluator reads of a value:
nothing (an operation it does not evaluate, an immediate), its
arguments (the operations it evaluates, identities, phis, and the pairs
CompositeExtract reads through), or its whole closure (a raw read, whose
handle LoadedFromMemory walks). EvaluateInst returns early for a value
it reads nothing of, so the two cannot drift apart. ownPlanValues still
copies descriptor sources, SRT reads and fill values whole, and copies
a condition only as far as Reads goes: an operation it does not read is
copied without its arguments. The pure and guarded flat slots are
computed before the copy, from the same values as before.
Evidence: a title that registers about 5,700 shaders at load held
24.1 M copied IR values in its plans (about 5.4 GiB by value size), of
which 2.1 M were reachable from descriptor sources, SRT reads and fills
(counted by a local report over the recompiler's source map).
Tested: agc_shader_memory gains verifyPlanConditionPruning: a condition
on a load with a 64-addition address keeps the load as a leaf and none
of the additions, and conditions read through an extracted pair and
through a raw read still evaluate. It fails without the change. Full
ctest passes.
Resolved onto main: Reads is a static member of BasicEvaluator next to
MayEvaluate, and its operation list is main's evaluator's
(evaluatedArguments adds BitCount32, FindILsb32 and FindUMsb32; the
undefined values, which main never evaluates, read nothing). The
EvaluateInst guard reads the node's value, so it covers the compact
plans too. ownPlanValues now runs after the flat slots and before the
compact plan, and gives a value it keeps without arguments an empty
operand list, so the leaf drops the operand capacity main's IrValue
constructor reserves. Main's MayEvaluate already drops the condition on
the vector load, so the test checks that it is gone.
The merge resolution had dropped its storage image sentences, which main keeps and this branch does not change.
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
PooledBufferRange and NativeMultisampleDepth match ANYPS5_GPU against
device names with std::strstr and std::string::find, which are
case-sensitive, while the driver and docs/dev/ENVIRONMENT.md match it
ignoring case. A request the driver accepts, such as ANYPS5_GPU=nvidia
for an NVIDIA GPU, matches no device in them: PooledBufferRange keeps
the first device and then refuses it with "selected device does not
match ANYPS5_GPU", NativeMultisampleDepth finds no device. Both report
a skip, or fail under ANYPS5_REQUIRE_VULKAN.
They now pick their device through SelectFixturePhysicalDevice, with
the driver's rule. That also changes two choices on machines with more
than one device: without ANYPS5_GPU, PooledBufferRange ranks devices by
type and needs Vulkan 1.1 instead of taking the first discrete one or
the first device, and with a request NativeMultisampleDepth takes the
first match instead of the best-ranked one, as the driver does. The
selection CPU test covers the second case.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Seven AGC fixtures create their own Vulkan instance and take the first
enumerated device or choose one by device type, without reading ANYPS5_GPU:
PresentationPass, DepthPlaneGuestLayers, DepthStorage,
DepthSurfaceLastWriter, OversizedDescriptorSets, PartiallyResidentSnapshot
and SparseBufferHoles. With a name that matches no device they still pass
on whichever GPU came first, so a run meant for one GPU can report results
from another.
They now pick their device through one shared helper with the driver's
rule: among Vulkan 1.1 devices, the first whose name contains ANYPS5_GPU
ignoring case, otherwise the first of the highest-ranked device type. A
name that matches nothing throws with the device names, which these
fixtures report as a skip, or as a failure under ANYPS5_REQUIRE_VULKAN.
A CPU test covers the selection and the error message.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
ImportWatched opened a blanket host-write window over the whole import range on
macOS, so every block in it read as CPU-written even when the import stored to
none of it, which failed agc_write_tracking (#10344). Add importMayWriteGuest,
defaulting to the previous behaviour. The two GuestBufferMemory callers create
Vulkan imports in-process and never write the range through a kernel API, so
they opt out and only pages actually stored to are marked.
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
On Windows, rename converted ENOENT or ENOTDIR to ELOOP when either parent directory was below a symbolic link loop. A missing source, or a source below a non-directory, paired with a destination through a loop then reported ELOOP. FreeBSD 11.4 kern_renameat returns the failed source lookup before it examines the destination. A loop below the source still gives ELOOP, and a loop below the destination gives ELOOP only when the source lookup succeeded.
guest_filesystem gains the missing-source and non-directory-source-prefix cases paired with a looping destination, for rename and sceKernelRename.
Table accessors returning scalar uint fed the merge Phi a 4-wide
zero, failing SPIR-V validation with SPIRV_TOOLS on. Use ZeroResult
like the unsupported path.
Table T#s keyed at runtime no longer fault on image_atomic_*32: the
table operation stays supported, elements carry the atomic flag through
dedup into the descriptor binding, and the table path binds AtomicView
like the direct path. 64-bit atomics stay unsupported, packed and BY
formats stay unsupported, and the debt entry records the relaxed
Device-scoped emission and the remaining gaps.
A macOS build of main failed 49 objects. Most included
libc/include/FileStream.hpp, whose global-namespace ::feof_unlocked and
::ferror_unlocked do not exist there (they are macros in the macOS SDK).
On macOS:
- FileStream.hpp calls feof_unlocked and ferror_unlocked unqualified.
- ExportMacros.hpp adds the leading underscore Mach-O gives C symbols to
both names in APS5_EXPORT, so the .set alias resolves.
- ThreadPriority.cpp has no rtkit or RLIMIT_RTTIME; "high" asks for the
user-interactive QoS class and "rt" for a Mach time-constraint policy
(period 1 ms, computation 0.5 ms), documented in ENVIRONMENT.md.
- Formatting.cpp maps the SysV va_list builtins to va_list, and
GuestContentSearch.cpp and GuestNpWebApi2.cpp include
<initializer_list>.
With these, 16 objects still fail on macOS; each is in a file changed by
an open macOS PR. Linux and Windows compile the same code as before.
The buffer copy HLE recognises its copy kernel (dst[i] = src[i % period]
for i < count, count and period read from a parameter buffer) by a hash
of its first 38 instruction words. Demon's Souls PPSA01341 01.007.000
ships the same kernel compiled to a different instruction sequence, with
the same descriptors and parameter layout, so every one of its copies ran
as a GPU dispatch and later CPU reads of the copied bytes waited for it.
That hash is now accepted too.
The new agc_driver_period_copy test runs that kernel through the driver:
with the HLE the linear cases must take a copy path, a period below the
count and a launch larger than the count needs must not, and every case
must produce dst[i] = src[i % period]. agc_driver_period_copy_no_hle runs
the same cases as shader dispatches (APS5_NO_COPY_HLE=1), so both paths
are checked against the same results.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
macOS has no link.h or dl_iterate_phdr, so GuestAllocations.cpp did
not compile there. On macOS the main and loaded guest images are found
with _dyld_image_count, _dyld_get_image_header and
_dyld_get_image_vmaddr_slide, and their pages come from the LC_SEGMENT_64
load commands' initial protections. The file-backed writable image scan
stays Linux-only. Linux and Windows are unchanged.
On Windows, mkdirat with a directory descriptor and a relative path that goes through a symbolic link pointing to itself reported EIO. CreateDirectoryW fails with ERROR_CANT_RESOLVE_FILENAME for such a path, and the error mapping had no case for it, so it fell through to GuestEio. FreeBSD fails the lookup with ELOOP. The path form of mkdir and openat with the same descriptor already return ELOOP. ERROR_CANT_RESOLVE_FILENAME now gives ELOOP.
guest_kernel_sys gains a Windows check with a file-type and a directory-type self-loop: mkdirat through the loop returns ELOOP and mkdirat of the link itself still returns EEXIST. The check is skipped when the host denies symbolic link creation.
The last audio frame can be consumed before the decoder marks EOF, so the in-pull check never sees an exhausted stream. Rebase once EOF is visible with an empty queue, and hold the producer in the test so both orderings stay deterministic.
Co-authored-by: Cursor <[email protected]>
The tests for scePadSetLotusEnableIrKey, scePadSetLotusDisableIrKey,
scePadVirtualDeviceDisableButtonRemapping and scePadVirtualDeviceGetRemoteSetting
only checked that an unimplemented call throws. A test of that kind fails as
soon as someone implements the function, so it pins the absence of a feature
rather than behaviour. Tests should cover real behaviour and argument
validation.
This removes those asserts, the Throws helper and the declarations they were the
only users of. The rest of the pad test is unchanged.
Kept both sides of GuestLibcThreads.cpp: main's ThreadHelpers test and this PR's VersionedSync test, both called from main().
Co-Authored-By: Claude Opus 5.5 <[email protected]>
AES_set_encrypt_key zeroed the whole schedule and set rounds before it
checked the key length, so a refused call changed the AES_KEY. As in
LibreSSL 2.5.4's aes_core.c, it now returns -1 or -2 before writing
anything and writes only the 44, 52 or 60 words the key length needs.
The test fills the key with a sentinel and checks, for both setup
functions, that refused calls leave all 244 bytes unchanged, that
AES-128 and AES-192 keep the 16 and 8 unused words, and that every
written word matches the FIPS-197 appendix A schedules and the
decryption schedules computed independently and with OpenSSL 3.0.13.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
ValidationPolicy rejects R_X86_64_GOT32, PLT32, GOTPCREL, 32S, GOTPCRELX
and REX_GOTPCRELX for every DT_RELA and DT_JMPREL entry before the Linux
patcher runs, so the R_X86_64_32S case of the fixed-base relocation
list cannot be reached. It was the only user of R_X86_64_32S, and the
other five constants have none. Remove the case and the six constants;
no behaviour changes.
Copy the source array into this and return this, as the console does
(measured on a PS4 Pro, firmware 10.71). Knowledge is Power: Decades
imports it; the inventory stub threw NotImplemented.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
AES_set_encrypt_key, AES_set_decrypt_key, AES_encrypt, AES_decrypt,
AES_ecb_encrypt, AES_cbc_encrypt, AES_cfb128_encrypt and
AES_ctr128_encrypt threw. They now follow LibreSSL's aes.h and its CBC,
CFB-128 and CTR mode code on the caller's 244-byte AES_KEY: key setup
returns -1 for null arguments and -2 for a key length other than 128,
192 or 256 bits, CBC pads a partial final block with the IV and writes
the whole block, CFB and CTR resume from *num, and the CTR counter
carries across all 128 bits.
The test checks the FIPS-197 appendix A and C vectors and the SP 800-38A
CBC, CFB-128 and CTR vectors, split across calls, in place and with
partial blocks.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
The shader float mode entry said "Other f64 arithmetic does not model
these denormal controls". On main, v_add_f64, v_mul_f64, v_floor_f64,
v_ceil_f64, v_fract_f64, v_frexp_mant_f64, v_frexp_exp_i32_f64,
v_div_fixup_f64, the f64 compares and ds_min/max/cmpst_f64 read the
f16/f64 denormal field, and each has its own entry. The sentence now
names the f64 arithmetic whose translation still does not read it.
The v_floor_f64 entry said its modifier run used 16 of the 23 measured
values. The run's list holds 13 of them plus -1.5, 2.75 and 1 - 2^-53.
Co-Authored-By: Claude <[email protected]>
