Repository navigation
decomp: clarify names and refine pending C (batch 18) - #210
Merged
mateuszklysz merged 111 commits intoOct 17, 2026
Merged
Conversation
arg0 -> transfer_block_size: Retail decompilation names parameter 1 transfer_block_size; 0x0012f06c stores incoming a0 at sp+0, matching source sp_slot[0] = arg0. This is word 0 of the 0x18-byte command 0x3b payload sent at 0x0012f090; supplied caller evidence uses 0x400. arg1 -> staging_buffer_size: Retail decompilation names parameter 2 staging_buffer_size; 0x0012f070 stores incoming a1 at sp+4, matching source sp_slot[1] = arg1. This is word 1 of the 24-byte configuration payload; supplied caller evidence uses 0x1000. arg2 -> staging_block_size: Retail decompilation names parameter 3 staging_block_size; 0x0012f078 stores incoming a2 at sp+8 before a2 becomes the payload pointer at 0x0012f084. Source sp_slot[2] = arg2 preserves that role; supplied caller evidence uses 0x400. arg3 -> initial_offset: Retail decompilation names parameter 4 initial_offset; 0x0012f088 stores incoming a3 at sp+0xc, matching source sp_slot[3] = arg3. This is configuration word 3 sent by command 0x3b; supplied caller evidence initializes it to zero. arg4 -> buffer_count: Retail decompilation names parameter 5 buffer_count; 0x0012f08c stores incoming t0 (fifth argument) at sp+0x10, matching source sp_slot[4] = arg4. This is configuration word 4 in the synchronous command payload; supplied caller evidence uses 5. arg5 -> stream_count: Retail decompilation names parameter 6 stream_count; the call delay-slot store at 0x0012f094 writes incoming t1 to sp+0x14, matching source sp_slot[5] = arg5. This is the last word of the 0x18-byte payload; supplied caller evidence uses 3.
arg0 -> first_grid_x: Prepared retail decompilation identifies nFirstX. At 0x001f278c incoming a0 is saved in s3; the <0.5 path calls 0x001f2690 at 0x001f27b0 with incoming a0 intact, while 0x001f27e8 restores s3 to a0 for fallback. Source arg0 is the first component of the fallback triplet when fparg0 >= 0.5. arg1 -> first_grid_y: Prepared retail decompilation identifies nFirstY. At 0x001f2784 incoming a1 is saved in s4; it remains the second helper argument on the <0.5 call at 0x001f27b0 and is restored to a1 at 0x001f27ec for fallback. Source assigns arg1 to var_5_26, the second fallback argument. arg2 -> first_grid_z: Prepared retail decompilation identifies nFirstZ. At 0x001f2794 incoming a2 is saved in s5; it remains the third helper argument on the <0.5 call at 0x001f27b0 and is restored to a2 at 0x001f27f0 for fallback. Source assigns arg2 to var_6_28, the third fallback argument. arg3 -> second_grid_x: Prepared retail decompilation identifies nSecondX. Incoming a3 is saved in s0 at 0x001f27a4 and moved to helper a0 at 0x001f27d0 for the >=0.5 path or 0x001f27c0 for fallback after first-triplet failure. Source passes arg3 as the first argument of parse_occlusion_grid(arg3,arg4,arg5). arg4 -> second_grid_y: Prepared retail decompilation identifies nSecondY. Incoming t0 (a4) is saved in s1 at 0x001f279c and moved to helper a1 at 0x001f27d4 for the >=0.5 path or 0x001f27c4 for fallback. Source passes arg4 as the second argument of parse_occlusion_grid(arg3,arg4,arg5). arg5 -> second_grid_z: Prepared retail decompilation identifies nSecondZ. Incoming t1 (a5) is saved in s2 at 0x001f27ac and moved to helper a2 at 0x001f27dc for the >=0.5 path or 0x001f27cc for fallback. Source passes arg5 as the third argument of parse_occlusion_grid(arg3,arg4,arg5).
arg2 -> decoder_buffer_base: The authoritative C assigns s32 arg2 directly to decoder_buffer_address. Retail instruction 0x0023a3c0 stores incoming a2 to 0x00161208, matching the original Ghidra assignment DAT_00161208 = work_base. The published address is cleared at 0x0023a44c after term_all; this proves a supplied decoder buffer base without asserting size or ownership. arg3 -> decoder_state_base: The authoritative C assigns s32 arg3 to decoder_state. Retail 0x0023a3e4 stores a3 at gp-0x59f4; 0x0023a408 reloads it, 0x0023a418 forwards that base as read_mpeg's second argument, and 0x0023a420/0x0023a428 derive the first and third arguments by adding 0xd9048 and 0xd9040. This proves the supplied decoder state base address.
a0 -> reverb_request_word_0: In the supplied src/audio/effects/snd_set_reverb_ex.c snapshot (SHA-256 2d81a1142d1673edaf1b6ebdd83fd2bc7638f9baf7a853f5834e0b948e5c56b5), s32 a0 is copied unchanged to sp_slot[0]. Retail 0x0012ef6c stores incoming a0 at sp+0x0. At 0x0012ef74 and 0x0012ef84 the wrapper selects command 0x50 and size 0x14, and 0x0012ef8c passes sp as its payload to 0x0012e6e0. The established snd_set_reverb_ex name identifies this as reverb request word 0; no individual audio-field meaning is asserted. a1 -> reverb_request_word_1: In the supplied src/audio/effects/snd_set_reverb_ex.c snapshot (SHA-256 2d81a1142d1673edaf1b6ebdd83fd2bc7638f9baf7a853f5834e0b948e5c56b5), s32 a1 is copied unchanged to sp_slot[1]. Retail 0x0012ef78 stores incoming a1 at sp+0x4. At 0x0012ef74 and 0x0012ef84 the wrapper selects command 0x50 and size 0x14, and 0x0012ef8c passes sp as its payload to 0x0012e6e0. The established snd_set_reverb_ex name identifies this as reverb request word 1; no individual audio-field meaning is asserted. a2 -> reverb_request_word_2: In the supplied src/audio/effects/snd_set_reverb_ex.c snapshot (SHA-256 2d81a1142d1673edaf1b6ebdd83fd2bc7638f9baf7a853f5834e0b948e5c56b5), s32 a2 is copied unchanged to sp_slot[2]. Retail 0x0012ef80 stores incoming a2 at sp+0x8. At 0x0012ef74 and 0x0012ef84 the wrapper selects command 0x50 and size 0x14, and 0x0012ef8c passes sp as its payload to 0x0012e6e0. The established snd_set_reverb_ex name identifies this as reverb request word 2; no individual audio-field meaning is asserted. a3 -> reverb_request_word_3: In the supplied src/audio/effects/snd_set_reverb_ex.c snapshot (SHA-256 2d81a1142d1673edaf1b6ebdd83fd2bc7638f9baf7a853f5834e0b948e5c56b5), s32 a3 is copied unchanged to sp_slot[3]. Retail 0x0012ef88 stores incoming a3 at sp+0xc. At 0x0012ef74 and 0x0012ef84 the wrapper selects command 0x50 and size 0x14, and 0x0012ef8c passes sp as its payload to 0x0012e6e0. The established snd_set_reverb_ex name identifies this as reverb request word 3; no individual audio-field meaning is asserted. a4 -> reverb_request_word_4: In the supplied src/audio/effects/snd_set_reverb_ex.c snapshot (SHA-256 2d81a1142d1673edaf1b6ebdd83fd2bc7638f9baf7a853f5834e0b948e5c56b5), s32 a4 is copied unchanged to sp_slot[4]. Retail 0x0012ef70 stores incoming t0 (fifth argument) at sp+0x10. At 0x0012ef74 and 0x0012ef84 the wrapper selects command 0x50 and size 0x14, and 0x0012ef8c passes sp as its payload to 0x0012e6e0. The established snd_set_reverb_ex name identifies this as reverb request word 4; no individual audio-field meaning is asserted.
arg0 -> reverb_payload_word_0: In snd_auto_reverb, s32 arg0 is stored at sp_slot+0. Retail 0x0012efe8 stores incoming a0 at 0(sp); 0x0012f000 passes sp as the payload to 0x0012e6e0 with command and size 0x10. This proves it is word 0 of the reverb request payload. arg1 -> reverb_payload_word_1: The source stores s32 arg1 at sp_slot+4. Retail 0x0012efec stores incoming a1 at 4(sp) before replacing a1 with payload size 0x10 at 0x0012eff8. The buffer passed at 0x0012f000 therefore contains this parameter as reverb payload word 1. arg2 -> reverb_payload_word_2: The source stores s32 arg2 at sp_slot+8. Retail 0x0012eff4 stores incoming a2 at 8(sp), then 0x0012f000 replaces a2 with the buffer pointer for command 0x10. This proves the original parameter is reverb payload word 2. arg3 -> reverb_payload_word_3: The source stores s32 arg3 at sp_slot+12. Retail 0x0012effc stores incoming a3 at 0xc(sp), before the call delay slot at 0x0012f00c clears a3. The original value is thus word 3 of the 16-byte reverb command payload.
arg0 -> configuration_word_0: Retail 0x0012eb50 preserves a0 in s0; 0x0012eb8c stores its unchanged 32-bit value at sp+0. At 0x0012eb90-0x0012eba8 command 0x2a receives a 0x10-byte payload at sp. Source args[0] = arg0 and original Ghidra dwConfiguration0 confirm the first configuration word. arg1 -> configuration_word_1: Retail 0x0012eb44 preserves a1 in s1; 0x0012eb94 stores its unchanged 32-bit value at sp+4, the second word of the 0x10-byte command 0x2a payload passed at 0x0012eba4. Source args[1] = arg1 and original Ghidra dwConfiguration1 corroborate this ordered configuration role. arg2 -> configuration_word_2: Retail 0x0012eb3c preserves a2 in s2; 0x0012eb9c stores its unchanged 32-bit value at sp+8. The pointer sp and length 0x10 feed command 0x2a at 0x0012eba4. Source args[2] = arg2 and original Ghidra dwConfiguration2 establish the third configuration word. arg3 -> configuration_word_3: Retail 0x0012eb34 preserves a3 in s3; the call delay slot at 0x0012eba8 stores its unchanged 32-bit value at sp+0xc, completing command 0x2a's 0x10-byte payload. Source args[3] = arg3 and original Ghidra dwConfiguration3 identify the fourth configuration word.
arg0 -> stream_handle: At 0x0012ecd8, sw a0,0(sp) stores the incoming first parameter as the sole payload word; 0x0012ece8 sets size 4 and 0x0012ecf0 passes sp as the buffer. The source serializes arg0 identically, and the established snd_get_vag_stream_time_remaining_cb name plus original Ghidra dwHandle identify this word as the stream handle. arg1 -> callback_address: At 0x0012ecd4, move a3,a1 forwards the incoming second parameter as the fourth argument to snd_send_iop_command_no_wait at 0x0012ecec, outside the four-byte handle payload. The original Ghidra names this value dwCallbackAddress and records its queued completion-route role; source forwards arg1 in precisely that position. arg2 -> callback_context: At 0x0012ecdc, move t0,a2 forwards the incoming third parameter as the fifth transport argument, while 0x0012ecf0 replaces a2 with the payload buffer. The source forwards arg2 in the fifth position, and original Ghidra identifies that transport value as qwCallbackContext. This proves context role without changing the source s32 type.
arg0 -> low_component: In source src/rendering/color/set_background_color.c (SHA-256 7f93b984ba5916333cf2b76b016212649224da67ccdeebdcabd65ff21565b1f2), arg0 is ORed into value without shifting. Retail 0x001fb288 ORs a0 into a1 after a1 shifts by 8; Ghidra likewise shows param_1 unshifted. Thus it supplies the lowest-position component, without implying a bounded width. arg1 -> middle_component: Source computes value = arg1 << 8; retail 0x001fb280 performs dsll a1,a1,0x8, and Ghidra shows param_2 << 8. This contribution lies between the unshifted first input and the third input shifted by 16 in the packing scheme, proving its middle-component role without asserting masking. arg2 -> high_component: Source ORs arg2 << 16 into value. Retail 0x001fb284 shifts a2 by 0x10 and 0x001fb294 ORs it into a1, matching Ghidra param_3 << 0x10. It is the highest-shifted input component before the fixed 0x80000000 flag and store at 0x001fb2a4 to 0x00152078.
arg0 -> payload_word_0: Authoritative source src/audio/mixer/snd_set_group_voice_range.c SHA-256 1a6bd81d1e05b9f6ba5108859e01f39024f5891d4aebf1ea966dd520f7cc860b stores s32 arg0 at sp_slot+0. Retail 0x0012e2c0 stores incoming a0 at 0(sp); 0x0012e2d4 passes sp as the buffer for command 0x4e with length 0xc. Original Ghidra dwWord0 likewise becomes uStack_20, proving payload word zero. arg1 -> payload_word_1: Authoritative source stores s32 arg1 at sp_slot+4. Retail 0x0012e2bc preserves incoming a1 in v0 before a1 becomes length 0xc, and 0x0012e2d8 stores v0 at 4(sp). Original Ghidra dwWord1 becomes uStack_1c; the stack buffer is submitted at 0x0012e2e0, proving payload word one. arg2 -> payload_word_2: Authoritative source stores s32 arg2 at sp_slot+8. Retail 0x0012e2c8 stores incoming a2 at 8(sp) before 0x0012e2d4 replaces a2 with the stack buffer address. Original Ghidra dwWord2 becomes uStack_18, the third word of the twelve-byte command 0x4e payload, proving payload word two.
arg0 -> group: Retail snd_SetMasterVolume names the first int nGroup (sound mixer group selector). At 0x0012e210, sw a0,0(sp) stores it as payload word zero; current source stores s32 arg0 at sp_slot. At 0x0012e214/0x0012e21c/0x0012e224/0x0012e228 this payload is passed to snd_SendIOPCommandNoWait as command 9 with size 8, proving group is the first master-volume command field. arg1 -> volume: Retail snd_SetMasterVolume names the second int nVolume (exact 32-bit volume value). At 0x0012e218, sw a1,4(sp) stores it as payload word one, matching *(s32 *)(sp_slot + 4) = arg1 in the authoritative source. The command 9 call at 0x0012e228 sends both words unchanged with size 8, proving this parameter supplies the master volume value.
arg0 -> sound_handle: In source SHA-256 cac382e72a19dc3b8bb706fd55225e27cd4c1389832c2143d68047d47bcd2cdf, arg0 is stored as the sole s32 payload. Retail 0x0012e450 stores incoming a0 at sp; 0x0012e45c/0x0012e460 select command 25 and size 4, and 0x0012e468 passes sp as payload. The original retail decompilation identifies that value as nSoundHandle. arg1 -> callback_address: Source forwards arg1 as the fourth argument to snd_send_iop_command_no_wait(25, 4, sp_slot, arg1, arg2). Retail 0x0012e44c moves incoming a1 into a3 before jal 0x0012e6e0 at 0x0012e464. Original retail decompilation identifies this unchanged guest address as dwCallbackAddress and records dialogue callers supplying code addresses. arg2 -> context_address: Source forwards arg2 as the fifth argument to snd_send_iop_command_no_wait. Retail 0x0012e454 moves incoming a2 into t0 (the fifth argument register) before jal 0x0012e6e0 at 0x0012e464. Original retail decompilation identifies dwContextAddress and records dialogue callers supplying state addresses for this callback context.
arg0 -> sound_handle: In the authoritative C, arg0 is stored as the sole s32 payload word in sp_slot for command 79, size 4. Retail 0x0012ed08 stores incoming a0 at 0(sp), and 0x0012ed20 passes sp as the buffer. The original decompilation identifies that word as dwHandle, consistent with snd_is_vag_stream_buffered_cb. arg1 -> callback_address: Retail 0x0012ed04 moves incoming a1 into a3, the fourth argument to snd_SendIOPCommandNoWait at 0x0012ed1c; the source passes arg1 in precisely that position. The prepared original decompilation identifies this argument as dwCallbackAddress, recorded separately from the four-byte handle payload. arg2 -> callback_context: Retail 0x0012ed0c moves incoming a2 into t0 (a4), the fifth argument to the queued transport at 0x0012ed1c; the source passes arg2 in that position. The original decompilation identifies it as qwCallbackContext and describes caller channel state as the completion context, separate from the handle payload. The existing s32 type remains unchanged.
arg0 -> byte_count: Source assigns s32 arg0 to local[0]. Retail 0x0012f14c stores a0 at sp+0, then 0x0012f150 passes sp as the payload pointer to command 0x5a at 0x0012f160 with size 8. The supplied original Ghidra decompilation identifies this first word as byte_count; its caller evidence states transfer_mpeg_audio_block supplies 0x400 bytes after SIF DMA completion. arg1 -> staging_byte_offset: Source assigns s32 arg1 to local[1]. Retail 0x0012f154 stores a1 at sp+4, the second 32-bit word of the eight-byte command 0x5a payload passed at 0x0012f160. The supplied original Ghidra decompilation identifies this word as staging_byte_offset and records that caller transfer_mpeg_audio_block passes the current offset in a 0x1000-byte IOP staging ring.
arg0 -> moby: The source declares arg0 as struct Moby *. Retail 0x0020ccc0 preserves a0 in s2; 0x0020ccd4 reads its scale at +0x2c, 0x0020cd08 supplies its +0xc0 rotation to copy_matrix_rotation, and 0x0020cd20 supplies its +0x10 position to add_vector_xyz. Original Ghidra param_1 follows the same object data flow. arg2 -> output_transform: Retail 0x0020ccc8 preserves a2 in s1 and 0x0020ccd0 passes it as a3 to FUN_00210850. At 0x0020ccec its +0x30 vector is scaled in place; 0x0020cd0c-0x0020cd18 use s1 as both destination and operand of multiply_matrix, then 0x0020cd1c-0x0020cd28 add the Moby position to that vector in place. Source arg2 and original Ghidra param_3 share this constructed transform output role.
arg0 -> command_word_0: In authoritative src/audio/effects/snd_pre_alloc_reverb_work_area.c (SHA-256 15dab98d95da1581413a7efb60318264a12c81cac22c05992352fce86ae34af3), s32 arg0 is stored at sp_slot+0. Retail 0x0012efb0 stores incoming a0 at 0(sp); 0x0012efb4 passes sp as buffer a2, and 0x0012efbc/0x0012efc4 select command 0x51 and eight bytes before the call at 0x0012efc8. This proves the first 32-bit command payload word, consistent with original Ghidra uStack_20 = core. arg1 -> command_word_1: Authoritative source stores s32 arg1 at sp_slot+4, then sends sp_slot with size 8 to snd_send_iop_command_no_wait(81,...). Retail 0x0012efb8 stores incoming a1 at 4(sp), following the a0 word at 0(sp); the buffer passed at 0x0012efb4 reaches the transport call at 0x0012efc8. Original Ghidra likewise assigns uStack_1c = word_1. This proves the second 32-bit command payload word without inferring its downstream meaning.
arg0 -> range_start_address: Retail 0x00118f94 saves a0 in s2; 0x00118fc0-0x00118fc4 constructs 0xffffffc0, and 0x00118fd0 masks s2 into a0 in the delay slot of the _sceSDC call at 0x00118fcc. The original decompilation labels this input pStart; the bound source passes arg0 & 0xFFFFFFC0 as the first cache-range argument, proving a start address aligned down to a 64-byte cache line. arg1 -> range_end_address: Retail 0x00118f9c saves a1 in s1; 0x00118fc8 masks s1 with 0xffffffc0 into a1 before the _sceSDC call at 0x00118fcc. The original decompilation labels this input pEnd; the bound source passes arg1 & 0xFFFFFFC0 as the second cache-range argument, proving an end address aligned down to a 64-byte cache line rather than a byte count.
a2 -> entry_base_address: Retail 0x0023d198 stores incoming a2 at buffer+4. At 0x0023d1b8 that word is loaded, 0x0023d1c0 adds the loop byte offset, and 0x0023d1c4 clears the resulting address. The offset begins at zero (0x0023d1ac) and advances by 0x138c0 (0x0023d1a8/0x0023d1b0/0x0023d1d0). Current C expresses this as p[1] = a2 and *(s32 *)(offset + (u32)p[1]) = 0; original Ghidra likewise stores param_3 in param_1[1] and uses it as the base of these strided writes. Thus the unchanged s32 parameter carries the entry base address.
arg0 -> payload_word_0: In the authoritative C, s32 arg0 is assigned unchanged to local[0]. Retail 0x0012e288 stores incoming a0 at 0(sp), and 0x0012e28c passes sp as a2; 0x0012e294/0x0012e29c select command 0xd and size 8 before the call at 0x0012e2a0. Original Ghidra likewise copies dwWord0 to uStack_20, the first word of the submitted payload. arg1 -> payload_word_1: In the authoritative C, s32 arg1 is assigned unchanged to local[1]. Retail 0x0012e290 stores incoming a1 at 4(sp), immediately after the word at 0(sp); 0x0012e28c supplies sp as the payload pointer and 0x0012e29c specifies 8 bytes for the call at 0x0012e2a0. Original Ghidra copies dwWord1 to uStack_1c, proving the second payload word.
arg0 -> output_quaternion: At 0x002144e4 incoming a0 is preserved in s1, restored to a0 at 0x002144f8, and passed to matrix_to_quaternion (0x00214260) at 0x002144fc with the temporary matrix in a1 at 0x00214500. The authoritative C calls matrix_to_quaternion(arg0, sp_slot); retail Ghidra identifies this first parameter as float *output, the destination XYZW quaternion. arg1 -> destination_matrix: At 0x002144e8 incoming a1 is preserved in s0, moved to a0 at 0x00214504, and passed to copy_matrix3x4 (0x001fa2b8) at 0x00214508 with the temporary matrix in a1 at 0x0021450c. The authoritative C calls copy_matrix3x4(arg1, sp_slot); retail Ghidra identifies this parameter as float *matrix receiving the first three matrix columns.
arg0 -> callback: In source src/gameplay/callbacks/enqueue_callback_list_1.c (SHA-256 4bf542312da98d735aa0e15918d56e628dc18a9b295d12d03f6821d4c43d79c8), s32 arg0 is stored into draw_callback_funcs at count*4. Retail 0x001f4608 preserves incoming a0 in a3; 0x001f462c forms array base 0x0018db40, and 0x001f4638 stores a3 at that indexed slot. Original Ghidra identifies the same input as callback and the destination as g_apGraphicsCallbackQueue0. arg1 -> callback_argument: Source stores s32 arg1 into draw_callback_args at the same count*4 offset used for arg0. Retail 0x001f4614 preserves incoming a1 in t0; 0x001f4624 forms argument array base 0x0018dc40, and 0x001f463c stores t0 at its indexed slot before 0x001f4644 commits the incremented count. Original Ghidra names this input argument and the destination g_apGraphicsCallbackQueue0Arguments, proving its pairing with the queued callback.
arg0 -> callback: In the authoritative source (SHA-256 541c01a4d738187c275e2d80e132e6bfce728d368768364b8eef1c6dd54eaf1e), arg0 is stored into draw_callback2_funcs[count * 4]. Retail 0x001f47c0 preserves incoming a0 in a3; 0x001f47d4 scales count by four, 0x001f47e4 forms base 0x0018dd40, and 0x001f47f0 stores a3 into that indexed callback slot. Original Ghidra identifies this parameter as callback. arg1 -> callback_argument: The source stores arg1 in draw_callback2_args at the same count * 4 offset used for arg0's callback slot. Retail 0x001f47cc preserves incoming a1 in t0; 0x001f47dc forms argument-array base 0x0018de40, 0x001f47e0 adds the scaled count, and 0x001f47f4 stores t0 there before count is committed at 0x001f47fc. Original Ghidra identifies the value as the paired opaque callback argument.
arg0 -> destination: Retail 0x00207bc4 saves a0 in s1 and 0x00207bf0 forwards it as decoder a0. In decode_compressed_occlusion_map, 0x00207c3c saves it in s7; 0x00207dac moves s7 to copy destination a0 for copy_blocks_16_forward at 0x00207db8, copying 0x400 bytes from scratchpad each iteration. 0x00207c44 establishes destination+0x8000 and 0x00207c98 advances output by 0x400. This proves the output destination role despite the wrapper's existing s32 type. arg2 -> skip_count_stream: Retail 0x00207bbc saves a2 in s2 and 0x00207bfc forwards it unchanged to decoder a2. Decoder 0x00207c64 saves it in s1; 0x00207c9c reads the first byte, 0x00207ca0 advances the stream, 0x00207ca4 reads the next byte, and 0x00207ca8 adds the first byte to scratch output cursor s2. 0x00207cb8 decrements the second byte once per sb at 0x00207ce4, while 0x00207cb0 advances to the next pair. Caller 0x0021c128/0x0021c134 derives this stream from chunk base plus its offset at +4, proving an input byte-pair skip/count stream rather than a scalar count.
pezzadev
changed the title
Decompilation progress
No function changed its match state compared with main (b91bd28). Compared with main (b91bd28). C_FUZZY uses main's last measurement. |
pezzadev
changed the title
pezzadev
marked this pull request as ready for review
October 17, 2026 01:52
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Before
Existing resident functions used address-based names or generic parameters and locals. Several pending resident and overlay C bodies still differed from retail and retained assembly-oracle fallbacks.
After
FUN_L00_002ebe70measures 29.79% versus 14.61% on current main in the same compilation context.Exact matching coverage is unchanged: the progress report shows no change in C_EXACT, matched-byte totals, matched-function counts, or data in C compared with main (
b91bd2881). No function changes match state. The published C_FUZZY figure reuses main's measurements and does not report this batch's locally measured pending-C changes.The naming changes improve readability while preserving existing byte matches. Passing the retail ELF check demonstrates that the build still reproduces retail; it does not establish additional exact-C coverage.
Verification
make elfmatched the retail ELF SHA-256;make overlayspassed for 2,901 functions, 17,860 copies, and 4,340 data objects.make checkand the PR cleanup check pass locally; GitHub tools, cleanup rules, and progress checks pass.Draft for review; unfinished C bodies remain pending.