Cesarus85--mjolnir-vr/docs/object_matching_logs/texture_page_obj.md

texture_page.obj exact-match ledger

Scope and invariant

• Translation unit: source/memory/texture_page.c
• Target: January 2002 build/split/source/memory/texture_page.obj
• Closeout base: c53047fb
• Compiler: XDK 3911 CL 13.00.9254.1
• Flags: /O2 /Oy- /DDEBUG /Dxbox
• Acceptance: every function and every target-owned data section must pass the hardened COFF comparator. No inline assembly, volatile codegen coercion, undefined behavior, byte patches, or compiler-flag changes.

This object is already behaviorally reconstructed. Nine of thirteen functions are strict-exact, and all target-owned data is strict-exact. The four remaining functions have equal target/candidate padded sizes and relocation counts.

Baseline residuals

Function	Size T/B	Relocations T/B	Target SHA-256	Candidate SHA-256
code_0010f730	96/96	6/6	4ea8aca9a5fe88693bb7cb72005f6a504b410ad15fd073c0725b08e4ec189953	1549ee0ee677c135307b88208026d6b19fe86540328a518949a03c778b8b5520
code_0010f790	736/736	21/21	451c78bcbdd4d6db18dbfe91ce5e1c6da0bffc6946409f4e62f7657763ec3dca	e318ef56a0771d9c007ca8e236d03c945b93c4175e5c5c670dda2dc548e640a0
texture_page_texture_new	240/240	9/9	d75574be99cf9a26ae8fc060f5d7d51bdf5005cb6699660f647adc2db545e513	1d5abf71760148ec35dca4d32316dc7b661e09a915023f3d1d3e4fe590802e28
texture_page_textures_end	112/112	6/6	6c74519b0d25aba59784237633ae13cb02dccffd26fe8cebc8f018a87b0a5702	3c9dc6840e0ada4946f9f409b77e9b2a6c11341672cb72082844d5bfe94911e5

The production blocker classifier returns UNKNOWN for all four. It confirms that code_0010f790 and texture_page_textures_end already have exact relocation addresses as well as identities. The other two have identical relocation identities but shifted addresses, so their source topology must be corrected before register/scheduler tuning.

Recovered foundation

• af7e2340 / 66bf7aa7: exact lifecycle, accessors, and allocation foundation.
• fab81db6 / 1ee7b15d / afffe8a7: reconstructed packing algorithm and data structures.
• The committed implementation recovers the 512-entry channel stack, 32768 texture-index stack, height comparator, power-of-two spacing, sorted packing, cancel/end transactions, and immediate-allocation rollback.

Experiment log

Record every one-factor source experiment here before rebuilding. Each result must include all four residual sizes, relocation counts/addresses, normalized hashes or first divergence, and the nine exact sibling functions' regression status.

E01 — defer pixel-count multiplication until dimensions fit

Changed texture_page_texture_new so width*height is evaluated only after the width and height bounds pass, matching January's instruction order.

• Result: STRICT EXACT
• Size: 240/240
• Relocations: 9/9, addresses and identities exact
• Normalized SHA-256: d75574be99cf9a26ae8fc060f5d7d51bdf5005cb6699660f647adc2db545e513
• Object state: 10/13 strict-exact
• Regression sweep: all nine previously exact siblings retained

E02 — express comparator through two exact accessor calls

Replaced the manually expanded verify/get pairs with two texture_page_texture_get calls.

• Result: rejected, still 96/96 and 6/6
• Improvement: reproduced January's three-callee-saved-register prologue and epilogue exactly
• Regression: interleaved each validation with its lookup, while January validates both pages before either lookup
• Siblings: unchanged; object remained 10/13
• Do not repeat this direct two-accessor form

E03 — register second page in original comparator topology

Restored the original validate/validate/get/get order and marked the second page pointer register.

• Result: no code-generation change from baseline
• The compiler ignored the hint under /O2
• Siblings: unchanged; object remained 10/13
• Do not repeat register hints for this helper

E04 — function-scope textures alias in texture_page_textures_end

Cached texture_page->textures in an explicit register pointer while leaving the loop variables at function scope.

• Result: no code-generation change from baseline
• The compiler continued to use EDX/EAX/ECX and emitted no inner-block EDI lifetime
• Siblings: unchanged; object remained 10/13
• Do not repeat register hints for this loop

E05 — confine the end-loop locals to the successful-resort block

Moved absolute_index, textures, and texture into the if (code_0010f790(texture_page)) block. January first saves EDI only after that call succeeds, so the shorter source lifetime is directly suggested by the machine code.

• Result: no code-generation change from baseline
• Size/relocations remained 112/112 and 6/6 with exact relocation addresses
• Normalized SHA remained 3c9dc6840e0ada4946f9f409b77e9b2a6c11341672cb72082844d5bfe94911e5
• All ten exact siblings retained
• Declaration scope alone does not control this register allocation

E06 — split masked_dimension assignment from its condition

Separated each masked_dimension &= spacing_mask statement from the following zero test. This tested whether the combined assignment-in-condition caused VC7 to commute the and operands.

• Result: no code-generation change
• code_0010f790 stayed 736/736, 21/21 with exact relocation addresses and candidate SHA e318ef56a0771d9c007ca8e236d03c945b93c4175e5c5c670dda2dc548e640a0
• All ten exact siblings retained
• Do not repeat simple expression splitting for these masks

E07 — use the page global directly at all four helper sites

Removed the two page-pointer locals and referenced bss_00456628 directly for both validation calls and both datum lookups.

• Result: rejected
• Size stayed 96/96 but relocations regressed from 6 to 8 because the compiler reloaded the global for both datum lookups
• All ten exact siblings retained
• The target proves that two loaded page values are preserved; direct repeated global expressions are not the original topology

E08 — statement-initialize both page-pointer locals

Kept the validate/validate/get/get order but changed the first page pointer from a declaration initializer to a normal assignment, giving both page locals the same source form.

• Result: no code-generation change
• code_0010f730 remained 96/96 and 6/6 with candidate SHA 1549ee0ee677c135307b88208026d6b19fe86540328a518949a03c778b8b5520
• All ten exact siblings retained

E09 — loop-local register hints in texture_page_textures_end

Applied register to the loop counter and texture pointer.

• Result: no code-generation change
• The candidate retained EDX/EAX/ECX rather than January's EDI/ECX/EDX
• Do not repeat register hints in this loop

E10 — no-op barrier positions in texture_page_textures_end

Tested _ReadWriteBarrier() after the successful packing call, after loading the texture pointer, and at the loop back edge.

• After the call: no code-generation change
• At the back edge: no code-generation change
• After the pointer load: rejected; candidate SHA changed to d620617f... by adding an unwanted reload
• All ten exact siblings retained
• The barrier family does not reproduce the target register assignment

E11 — success-block declaration initializer for the texture pointer

Declared and initialized the texture pointer inside the successful packing block rather than assigning it after declaration.

• Result: no code-generation change
• Size/relocations stayed 112/112 and 6/6 with exact relocation addresses
• All ten exact siblings retained

E12 — indexed texture access instead of pointer induction

Replaced the pointer-increment loop with textures->data + absolute_index.

• Result: rejected structural regression
• Candidate grew from 112 to 128 bytes; relocations remained 6/6
• Candidate SHA became e92a1c645b9e824dbb94342d209040295f5acbc05c1d31b1e6bfc290c0504fa8
• All ten exact siblings retained
• January proves pointer induction; do not repeat indexed access

E13 — declaration-initialize the data-array and texture pointers

Inside the successful packing block, declare textures = texture_page->textures and texture = textures->data, while retaining January's pointer-increment loop. This directly tests whether the initializer topology assigns the data-array lifetime to EDI and the element pointer to ECX as in the target.

• Result: no code-generation change
• Size/relocations remained 112/112 and 6/6
• Candidate SHA remained 3c9dc6840e0ada4946f9f409b77e9b2a6c11341672cb72082844d5bfe94911e5

Result: no code-generation change. The named boolean was optimized away before register allocation; the function remained at the baseline SHA.

E15 — reverse the loop-local declaration order

Declare the texture pointer before the short absolute index while restoring the direct branch on code_0010f790. This is the only untested declaration-order permutation of the two real loop locals.

• Result: no code-generation change
• VC7 assigned the same stackless SSA values regardless of source declaration order

Result: no code-generation change. The compiler folded both aliases back into the same EDX/EAX/ECX allocation, leaving 112/112, 6/6 and SHA 3c9dc6840e0ada4946f9f409b77e9b2a6c11341672cb72082844d5bfe94911e5.

E14 — explicit packing-result local

Declare boolean resort_succeeded, assign the code_0010f790 return to it, and branch on the named value. The exact sibling texture_page_textures_cancel uses this source topology, making it a target-authored allocator lead rather than a generic perturbation.

• Result: no code-generation change
• The named boolean was optimized away before register allocation

E16 — nested lifetime for the comparator's second page

Declare texture_page_b in a block beginning after the first validation and ending after the first datum_get. This mirrors the measured target lifetime: the first page survives both validation calls while the second page is loaded only after the first call and dies after the first lookup.

• Result: no code-generation change
• The compiler coalesced the nested lifetime to the same SSA value

E17 — make the packing mask temporary unsigned

Change only masked_dimension from signed short to unsigned word. The value is used exclusively as a bitmask and zero predicate, so this is behavior-preserving. It tests whether January's mov width, EDX; and mask, EDX operand choice came from an unsigned mask temporary.

• Result: no code-generation change
• Signedness does not control the commutative and operand choice

E18 — widen the mask temporary's source lifetime

Move masked_dimension from the sorted-texture loop block to function scope while restoring its signed-short type. This tests whether January's schedule came from the mask temporary being live in the function's main local set.

• Result: no code-generation change
• Source scope does not affect the optimized mask SSA value

E19 — named true value for the end-loop store

Declare boolean sorted = TRUE and store that named value instead of the literal. An exact January donor (objects_information_get) gains a late EDI lifetime from an additional live byte value in an otherwise similar no-call data-array loop, so this tests the corresponding topology without adding observable operations.

• Result: no code-generation change
• Constant propagation removed the named boolean before it could influence the loop allocation

E20 — initialize both loop variables in the for initializer

Move the texture-pointer initialization into the comma-separated for initializer beside absolute_index = 0. This preserves January's preheader instructions but changes the source/IR origin of both induction variables as a single loop initialization expression.

• Result: no code-generation change
• VC7 canonicalized the comma initializer to the baseline preheader

E21 — explicit precheck plus do/while

Express the already-measured CFG directly: initialize the pointer and counter, precheck the count, then execute a bottom-tested do/while. The January machine code has exactly this control-flow topology even though a for can also lower to it.

• Result: no code-generation change
• VC7 reconstructed the same preheader and bottom-tested loop emitted by the concise for form

E22 - alternate locally available optimizer backends

Compile the unchanged best source using the two additional backend DLLs found in the workspace's prior compiler-variant research (SP4 and SP5). This tests the patch-level optimizer hypothesis before spending more source shapes.

• Result: rejected before code generation
• Both backends report C1007 for the VC7 front end's -Ob2 intermediate flag
• These are incompatible older optimizer DLLs, not usable XDK 3911 QFEs
• The valid 13.00.9210 and 13.00.9254.1 toolchains remain the only compatible locally available variants; both emit the same three residuals

E23-E24 - remaining declaration-order permutations in the packer

Tested texture_width before texture_height, then masked_dimension before channel_index.

• Result: no code-generation change in either case
• VC7 assigned the same stack slots and SSA values

E25-E26 - direct mask-value expressions

Tested a separate dimension & mask assignment followed by a zero test, then removed masked_dimension and tested the expression directly.

• Separate assignment: no code-generation change
• Direct predicate: rejected; relocation addresses changed and the candidate SHA became 83d76628a4a3f6987ba11fa00c24eaf8d633ce2f1b3a8c3500d0d3494a84f3d6

E27 - comparator page declaration order

Declared the second page before the first while retaining the validate/validate/get/get sequence.

• Result: no code-generation change

E28 - inline verified-page identity helper

Wrapped validation in an inline helper returning the same page. With the first page initialized before calling the helper, this restored January's three-callee-saved-register body and made the function byte-identical from offset 0x0e onward.

• Result: improvement, but not exact
• Candidate SHA: 9600d22f437e4458aebcd785ea57fd1ced3fbb9b5c0b9d23242a03a20cf2c792
• Sole remaining region was the first page's prologue materialization

E29 - assignment inside each validation call

Assigned each global page pointer in the argument expression to code_0010f570.

• Result: canonicalized back to the original two-register baseline

E30 - direct global input to the inline verified-page helper

Leave both page locals uninitialized, then assign each from texture_page_verify_and_return(bss_00456628).

• Result: STRICT EXACT
• Size: 96/96
• Relocations: 6/6, addresses and identities exact
• Normalized SHA-256: 4ea8aca9a5fe88693bb7cb72005f6a504b410ad15fd073c0725b08e4ec189953
• Object state: 11/13 strict-exact

E31-E34 - inline provenance follow-ups

Applied the successful inline-provenance idea to the two residual functions:

• Cached data-array accessor in textures_end: rejected; it removed January's required per-iteration alias reload and produced SHA 4fff2764d551c362047ff666f28e68815b4cb82f60a3e18df0d8ba9e596a1725
• Inline mask helper in the packer: no code-generation change
• Inline first-texture accessor in textures_end: no code-generation change
• Repeated uncached inline data-array accessor at both load sites: no code-generation change

E35 - bounded packer-barrier supersearch

Compiled 127 combinations of zero-byte _ReadWriteBarrier() placements around the remaining packing-mask scheduling window.

• Result: no exact candidate
• Best result still had 26 differing normalized bytes
• The barrier family can move the mask operation, but cannot reproduce all five January operand/order pairs together

E36 - cross the barrier lead with the prior source-shape atlas

Crossed the best packer-barrier placement with 101 previously measured, semantically valid source shapes.

• Result: no exact candidate
• The cross-product did not improve upon the 26-byte barrier residual
• This closes the barrier-plus-expression family rather than repeating it manually

E37 - recover the packing-mask width

Changed spacing_mask from long to word. January consistently performs low-word masks and zero-extends this value; spacing is also a word, so this is type recovery rather than a code-generation hint.

• Result: STRICT EXACT
• Size: 736/736
• Relocations: 21/21, addresses and identities exact
• Normalized SHA-256: 451c78bcbdd4d6db18dbfe91ce5e1c6da0bffc6946409f4e62f7657763ec3dca
• Object state: 12/13 strict-exact

E38 - preserve the packing result through textures_end

Stored the packing result in a boolean and used result ^ TRUE for the final page flag. This reproduced January's EDI/ECX/EDX loop allocation and reduced the residual from 28 to 9 bytes.

• Result: rejected
• The expression is not equivalent for noncanonical nonzero boolean values
• This experiment proved that January keeps the packing result live across the loop, but it was not eligible production C

E39 - bounded end-loop barrier supersearch

Crossed the nine-byte live-result candidate with 127 zero-byte barrier placements around the call, loop, and final store.

• Result: no exact candidate
• Every best candidate retained the same nine-byte tail
• The barrier family cannot convert the dynamic result store into January's literal zero store

E40 - translation-unit order and linkage audit

Tested January's function order, static/external helper linkage, and __forceinline variants.

• January function order did not change textures_end
• Externalizing the private helpers regressed their private register conventions and multiple callers
• __forceinline retained the exact comparator body but still emitted the unreferenced 16-byte helper COMDAT

E41 - recover the textures_end return type

January leaves the packing result in AL across the entire successful loop and returns without replacing it. Changing the function from void to boolean, returning the named packing result, explains that lifetime naturally.

• Result: STRICT EXACT
• Size: 112/112
• Relocations: 6/6, addresses and identities exact
• Normalized SHA-256: 6c74519b0d25aba59784237633ae13cb02dccffd26fe8cebc8f018a87b0a5702
• Object state: 13/13 strict-exact

E42 - inline-helper ownership audit

The exact comparator uses a small inline identity helper to retain January's private-ABI provenance. The compiler emits an unreferenced 16-byte COMDAT copy in addition to inlining both calls.

• Six macro/explicit-parameter replacements removed the extra COMDAT but regressed the exact comparator register allocation
• The emitted helper is COMDAT Selection: Any, has no incoming relocation, and is discarded by the normal reference-eliminating link
• It does not change any target-owned code or data section; ordinary progress reports 100% code, 100% data, and all 13 functions exact

Final strict result

• Target functions: 13/13 strict-exact
• Target code: 1922/1922 meaningful bytes
• Target data: 460/460 bytes
• Hardened relocation identities: exact for every function
• Ordinary object report: 100% code, 100% data, 100% functions
• Full project rebuild: successful
• House-style audit: passed; the recovered boolean function has one explicit return, and all parameters remain one-per-line