Compare commits
13 Commits
agent/bitt
...
fix/readme
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ac78229543 | ||
|
|
3d3448e3a8 | ||
|
|
654c65dd27 | ||
|
|
bb93684b95 | ||
|
|
39648c8aa6 | ||
|
|
230c3af28f | ||
|
|
13881c99fb | ||
|
|
b26e248bb0 | ||
|
|
8350f2b4df | ||
|
|
3851d2cc74 | ||
|
|
7bdf4629fd | ||
|
|
5a222cdec4 | ||
|
|
ac8d46d231 |
20
.github/workflows/readme-progress.yml
vendored
20
.github/workflows/readme-progress.yml
vendored
@@ -2,8 +2,8 @@ name: README progress
|
||||
|
||||
# runs on the self-hosted runner on cole's server so it doesn't use hosted minutes.
|
||||
# only push/schedule/manual triggers, never pull_request, so fork PRs can't reach this machine.
|
||||
# README progress is written inside each landing commit by the orchestrator, so this job never commits;
|
||||
# it only rebuilds and publishes the current numbers to the job summary.
|
||||
# it never commits to main: it rebuilds, publishes the numbers to the job summary, and force-pushes
|
||||
# the README badge JSON as a single commit on the orphan progress-data branch.
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
@@ -17,7 +17,7 @@ concurrency:
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
contents: write
|
||||
|
||||
jobs:
|
||||
progress:
|
||||
@@ -55,3 +55,17 @@ jobs:
|
||||
python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
|
||||
sed -n '/progress:start/,/progress:end/p' README.md >> "$GITHUB_STEP_SUMMARY"
|
||||
git checkout -- README.md
|
||||
|
||||
- name: Publish badges
|
||||
if: github.ref == 'refs/heads/main'
|
||||
run: |
|
||||
out="$RUNNER_TEMP/progress-data"
|
||||
rm -rf "$out"
|
||||
python3 tools/progress_badges.py build/43U/report.json "$out"
|
||||
cd "$out"
|
||||
git init -q -b progress-data
|
||||
git config user.name "github-actions[bot]"
|
||||
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
|
||||
git add .
|
||||
git commit -q -m "progress for $GITHUB_SHA"
|
||||
git push -q -f "https://x-access-token:${{ github.token }}@github.com/$GITHUB_REPOSITORY.git" HEAD:refs/heads/progress-data
|
||||
|
||||
37
README.md
37
README.md
@@ -7,23 +7,23 @@
|
||||
|
||||
<!--- Github Actions Badge -->
|
||||
|
||||
[Build Status]: https://github.com/coah80/wii-ipl/actions/workflows/build.yml/badge.svg
|
||||
[actions]: https://github.com/coah80/wii-ipl/actions/workflows/build.yml
|
||||
[Build Status]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml/badge.svg?branch=main
|
||||
[actions]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml
|
||||
|
||||
<!--- Discord Badge -->
|
||||
|
||||
[Discord Badge]: https://img.shields.io/discord/727908905392275526?color=%237289DA&logo=discord&logoColor=%23FFFFFF
|
||||
[discord]: https://discord.gg/hKx3FJJgrV
|
||||
|
||||
<!-- Progress links -->
|
||||
<!-- Progress badges: JSON on the progress-data branch, refreshed by the README progress workflow on every push to main -->
|
||||
|
||||
[V43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U
|
||||
|
||||
<!--- Version 4.3U progress Badge -->
|
||||
|
||||
[DecompBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=code&label=Decompiled&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
|
||||
[LinkBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=complete_code&label=Linked&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
|
||||
[FuncBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=functions&label=Functions&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
|
||||
[progress]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml
|
||||
[DecompiledBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fdecompiled.json
|
||||
[MatchedBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fmatched.json
|
||||
[LinkedBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Flinked.json
|
||||
[DataBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fdata.json
|
||||
[FunctionsBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Ffunctions.json
|
||||
[UnitsBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Funits.json
|
||||
|
||||
<!--- Header -->
|
||||
|
||||
@@ -43,28 +43,17 @@ Live decomp status
|
||||
|
||||
[![Build status]][actions]
|
||||
|
||||
Open the latest successful [Build workflow run][actions] and check its summary for the current objdiff metrics. It includes perfect-match/decompiled, fuzzy-match, fully linked, data, function, unit, and category breakdowns. The run also publishes the 43U report artifact and generated decomp-status report.
|
||||
Every push to `main` rebuilds 4.3U, checks the DOL hash, and refreshes the progress badges below. Open the latest [README progress run][actions] for the full objdiff summary.
|
||||
|
||||
Supported versions:
|
||||
- `43U` - Version **4.3U** (USA)
|
||||
|
||||
Progress
|
||||
========
|
||||
<!-- progress:start -->
|
||||
| Decompiled | Matched | Linked | Data |
|
||||
|:---:|:---:|:---:|:---:|
|
||||
| 99.59% | 91.16% | 74.57% | 99.56% |
|
||||
|
||||
units 964/1027 complete, functions 12378/12563 matched.
|
||||
[![DecompiledBadge]][progress] [![MatchedBadge]][progress] [![LinkedBadge]][progress] [![DataBadge]][progress]
|
||||
[![FunctionsBadge]][progress] [![UnitsBadge]][progress]
|
||||
|
||||
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
|
||||
<!-- progress:end -->
|
||||
|
||||
| Version | Progress |
|
||||
|-----------------------|------------------------------------------------------------------------------|
|
||||
| [Wii Menu 4.3U][V43U] | [![FuncBadgeV43U]][V43U] [![DecompBadgeV43U]][V43U] [![LinkBadgeV43U]][V43U] |
|
||||
|
||||
> You can see the full progress and its history by clicking on one of the versions in the table.
|
||||
|
||||
Dependencies
|
||||
============
|
||||
|
||||
@@ -37,6 +37,9 @@ force_active:
|
||||
|
||||
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.
|
||||
block_relocations:
|
||||
# Run establishes a fixed stack at 0x81600000, not __pformatter + 0x280.
|
||||
- source: .text:0x8137B468
|
||||
- source: .text:0x8137B46C
|
||||
- source: .data:0x8165E15C
|
||||
- source: .data:0x8165E19C
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
#include <tmc_jpeg_internal.h>
|
||||
|
||||
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo);
|
||||
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
|
||||
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry);
|
||||
static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
|
||||
static s32 TMCJPEGDEC_ThumbnailCheck(TMCCJPEGDecInitParam* param, TMCCJPEGDecExifInfo* info, u32 totalSize);
|
||||
|
||||
@@ -280,7 +280,7 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
|
||||
return -161;
|
||||
}
|
||||
for (index = 0; index < count; index++) {
|
||||
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
|
||||
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
|
||||
entries += 12;
|
||||
}
|
||||
remaining -= entriesSize;
|
||||
@@ -331,19 +331,19 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
|
||||
return -161;
|
||||
}
|
||||
for (index = 0; index < count; index++) {
|
||||
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
|
||||
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
|
||||
entries += 12;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry) {
|
||||
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry) {
|
||||
s32 tag;
|
||||
u16 type;
|
||||
u32 type;
|
||||
|
||||
tag = readU16(entry, byteOrder);
|
||||
type = readU16(entry + 2, byteOrder);
|
||||
tag = readExifU16(entry, byteOrder);
|
||||
type = readExifU16(entry + 2, byteOrder);
|
||||
|
||||
switch (tag) {
|
||||
case 0x0103:
|
||||
@@ -366,7 +366,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
|
||||
return;
|
||||
}
|
||||
pInfo->xResNum = readU32(p, byteOrder);
|
||||
p = (const u8*)(pInfo->thumbnailData + offset + 4);
|
||||
p = pInfo->thumbnailData + (offset + 4);
|
||||
if (pInfo->thumbnailData > p) {
|
||||
return;
|
||||
}
|
||||
@@ -386,7 +386,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
|
||||
return;
|
||||
}
|
||||
pInfo->yResNum = readU32(p, byteOrder);
|
||||
p = (const u8*)(pInfo->thumbnailData + offset + 4);
|
||||
p = pInfo->thumbnailData + (offset + 4);
|
||||
if (pInfo->thumbnailData > p) {
|
||||
return;
|
||||
}
|
||||
@@ -501,6 +501,10 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
|
||||
case 0x8769:
|
||||
case 0x9000:
|
||||
case 0x9101:
|
||||
case 0x011C:
|
||||
case 0xA000:
|
||||
case 0xA001:
|
||||
case 0xA002:
|
||||
case 0xA003: {
|
||||
break;
|
||||
}
|
||||
@@ -516,7 +520,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
|
||||
return;
|
||||
}
|
||||
pInfo->xResNumIfd1 = readU32(p, byteOrder);
|
||||
p = (const u8*)(pInfo->thumbnailData + offset + 4);
|
||||
p = pInfo->thumbnailData + (offset + 4);
|
||||
if (pInfo->thumbnailData > p) {
|
||||
return;
|
||||
}
|
||||
@@ -538,7 +542,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
|
||||
return;
|
||||
}
|
||||
pInfo->planarConfigIfd1 = readU32(p, byteOrder);
|
||||
p = (const u8*)(pInfo->thumbnailData + offset + 4);
|
||||
p = pInfo->thumbnailData + (offset + 4);
|
||||
if (pInfo->thumbnailData > p) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -311,21 +311,21 @@ Zi8UInt Zi8SpellingPY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
|
||||
return length;
|
||||
}
|
||||
|
||||
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,Zi8UInt key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
|
||||
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,ziU16 key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
|
||||
{
|
||||
ziU16 spelling[16];
|
||||
Zi8UInt spellingLength;
|
||||
|
||||
if ((key & 0xffff) == 0) {
|
||||
if (key == 0) {
|
||||
return 0;
|
||||
}
|
||||
if ((inputLength & 0xff) == 0) {
|
||||
return 1;
|
||||
}
|
||||
if (usePinyin != 0) {
|
||||
spellingLength = Zi8SpellingPY(spelling,key & 0xffff,tone & 0xff);
|
||||
spellingLength = Zi8SpellingPY(spelling,key,tone & 0xff);
|
||||
} else {
|
||||
spellingLength = Zi8SpellingZY(spelling,key & 0xffff,tone & 0xff);
|
||||
spellingLength = Zi8SpellingZY(spelling,key,tone & 0xff);
|
||||
}
|
||||
if ((requireFull != 0) && ((inputLength & 0xff) != (spellingLength & 0xff))) {
|
||||
return 0;
|
||||
@@ -1327,7 +1327,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
|
||||
}
|
||||
if (elementIndex == 0) continue;
|
||||
if (!emitWords) {
|
||||
if (trackDuplicates && Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
|
||||
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
|
||||
for (index = 0; index < candidateCount; index++) {
|
||||
if (candidateCharacter == output[index]) break;
|
||||
}
|
||||
@@ -1396,7 +1396,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
|
||||
}
|
||||
if (elementIndex == 0) continue;
|
||||
if (!emitWords) {
|
||||
if (trackDuplicates && Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
|
||||
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
|
||||
for (index = 0; index < candidateCount; index++) {
|
||||
if (candidateCharacter == output[index]) break;
|
||||
}
|
||||
@@ -1519,7 +1519,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
|
||||
}
|
||||
if (elementIndex == 0) goto nextPhrase;
|
||||
if (!emitWords) {
|
||||
if (trackDuplicates && Zi8SetFindCand(params->scratch,phraseCharacter,work) != 0) goto nextPhrase;
|
||||
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,phraseCharacter,work) != 0) goto nextPhrase;
|
||||
for (index = 0; index < candidateCount; index++) {
|
||||
if (firstOrdinal == output[index]) goto nextPhrase;
|
||||
}
|
||||
@@ -1601,7 +1601,7 @@ finishPhrases:
|
||||
}
|
||||
if (elementIndex == 0) goto nextSortedOrdinal;
|
||||
if (!emitWords) {
|
||||
if (trackDuplicates && Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextSortedOrdinal;
|
||||
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextSortedOrdinal;
|
||||
ordinal = Zi8Ord2Uni(ordinal,work);
|
||||
for (index = 0; index < candidateCount; index++) {
|
||||
if (ordinal == output[index]) break;
|
||||
@@ -1629,11 +1629,11 @@ nextSortedOrdinal:
|
||||
;
|
||||
}
|
||||
}
|
||||
if ((options->countOnly == '\0') && Zi8GetZHuwdPtr(&userEntries,&userCount,work) != 0)
|
||||
if ((options->countOnly == '\0') && (ziU8)Zi8GetZHuwdPtr(&userEntries,&userCount,work) != 0)
|
||||
{
|
||||
for (phraseOrdinal = 0; phraseOrdinal < userCount;) {
|
||||
if ((params->elementCount == '\0') || ((userEntries[1] & 0x80) != 0)) {
|
||||
userOrdinal = (userEntries[1] & 0x7f) << 8 | (ziU16)userEntries[2];
|
||||
userOrdinal = (ziU16)(userEntries[1] & 0x7f) << 8 | (ziU16)userEntries[2];
|
||||
phraseTable = syllableTable + (Zi8UInt)userOrdinal * 0xc;
|
||||
if (((*phraseTable & languageMask) != 0) &&
|
||||
((characterSetTable == 0 || ((characterSet & characterSetTable[(Zi8UInt)userOrdinal]) != 0)))) {
|
||||
@@ -1654,7 +1654,7 @@ nextSortedOrdinal:
|
||||
}
|
||||
if (elementIndex == 0) goto nextUserOrdinal;
|
||||
if (!emitWords) {
|
||||
if (trackDuplicates && Zi8SetFindCand(params->scratch,userOrdinal,work) != 0) goto nextUserOrdinal;
|
||||
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,userOrdinal,work) != 0) goto nextUserOrdinal;
|
||||
userCharacter = Zi8Ord2Uni(userOrdinal,work);
|
||||
for (duplicateIndex = 0; duplicateIndex < candidateCount; duplicateIndex++) {
|
||||
if (userCharacter == output[duplicateIndex]) break;
|
||||
@@ -1710,7 +1710,7 @@ nextUserOrdinal:
|
||||
if (unicodeCharacter == previousCharacter) goto nextOrdinal;
|
||||
previousCharacter = unicodeCharacter;
|
||||
if (!emitWords) {
|
||||
if (trackDuplicates && Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextOrdinal;
|
||||
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextOrdinal;
|
||||
for (index = 0; index < candidateCount; index++) {
|
||||
if (unicodeCharacter == output[index]) break;
|
||||
}
|
||||
@@ -1738,8 +1738,7 @@ nextOrdinal:
|
||||
}
|
||||
finishCandidates:
|
||||
if ((emitWords) && (outputIndex != 0)) {
|
||||
output[outputIndex] = 0;
|
||||
outputIndex++;
|
||||
output[outputIndex++] = 0;
|
||||
}
|
||||
params->count = candidateCount;
|
||||
Zi8LogError(100,work);
|
||||
|
||||
@@ -1138,7 +1138,7 @@ prepareCandidate:
|
||||
Zi8ChangeWordCase(wordCursor - prefixCount,language,workData);
|
||||
}
|
||||
if ((((ZiAlphaOptions*)optionData)->suffixOnly != '\0') &&
|
||||
((int)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount))) {
|
||||
((wordLength + prefixCount) > ((ZiAlphaOptions*)optionData)->maxWordLength)) {
|
||||
wordLength = ((ZiAlphaOptions*)optionData)->maxWordLength - prefixCount;
|
||||
wordCursor[wordLength] = 0;
|
||||
}
|
||||
@@ -1210,11 +1210,11 @@ emitCandidate:
|
||||
for (index = 0; index <= wordLength; index++) {
|
||||
if (wordCursor[index] != ((ZiAlphaOptions*)optionData)->dictionary[index]) break;
|
||||
}
|
||||
if ((((((ZiAlphaWork*)workData)->operation != '\0') || ((int)wordLength <= index))
|
||||
if ((((((ZiAlphaWork*)workData)->operation != '\0') || (index >= wordLength))
|
||||
&& ((((ZiAlphaWork*)workData)->operation == '\0' ||
|
||||
((exactLengthOnly == 0 ||
|
||||
((int)(ziU16)Zi8WCharCount(((ZiAlphaOptions*)optionData)->dictionary,workData) <= index)))))) &&
|
||||
((exactLengthOnly != 0 || ((int)wordLength <= index)))) {
|
||||
(index >= (int)(ziU16)Zi8WCharCount(((ZiAlphaOptions*)optionData)->dictionary,workData))))))) &&
|
||||
((exactLengthOnly != 0 || (index >= wordLength)))) {
|
||||
candidateCount = 1;
|
||||
goto finishCandidates;
|
||||
}
|
||||
@@ -1373,7 +1373,7 @@ finishDictionaryPass:;
|
||||
(((parameters->elementCount == 1 &&
|
||||
(((Zi8GetTableCount(parameters->language,0x1f,workData)) & 0x40) == 0)) &&
|
||||
(*parameters->elements >= 0xeff1)))))) &&
|
||||
((*parameters->elements < 0xf011 &&
|
||||
((*parameters->elements <= 0xf010 &&
|
||||
((Zi8getKeyLayout(parameters->language,*parameters->elements,&punctuationBuffer[0],1,workData)) != '\0')))) {
|
||||
punctuationCandidate = ZI8_TRUE;
|
||||
}
|
||||
@@ -1569,17 +1569,17 @@ checkPrefixFields:
|
||||
|
||||
finishCandidates:
|
||||
((ZiAlphaWork*)workData)->usePrefixAsElements = 0;
|
||||
if (((ZiAlphaOptions*)optionData)->countOnly == '\0') {
|
||||
parameters->letters = candidateCount;
|
||||
if (((ZiAlphaOptions*)optionData)->countOnly != '\0') {
|
||||
parameters->letters = 0;
|
||||
}
|
||||
else {
|
||||
parameters->letters = 0;
|
||||
parameters->letters = candidateCount;
|
||||
}
|
||||
wordCursor[-prefixCount] = 0;
|
||||
if (((((ZiAlphaOptions*)optionData)->countOnly == '\0') && (((ZiAlphaOptions*)optionData)->lookupMode == '\0')) && (parameters->elementCount != 0)) {
|
||||
elementIndex = parameters->elementCount - 1;
|
||||
if (((primaryVowelRestriction) || (secondaryVowelRestriction)) &&
|
||||
((((ZiAlphaWork*)workData)->prefixEnabled < 2 ||
|
||||
((((ZiAlphaWork*)workData)->prefixEnabled <= 1 ||
|
||||
(parameters->elements[elementIndex] == 0xEFF1)))) {
|
||||
index = 0;
|
||||
while (elementIndex >= 0) {
|
||||
|
||||
@@ -749,7 +749,8 @@ s32 pfd_sddrv_get_total_sectors(u32* sectors, u16* bytes_per_sector) {
|
||||
minimum_multiplier = multiplier >= 9 ? multiplier : 9;
|
||||
max_multiplier = minimum_multiplier <= 11 ? minimum_multiplier : 11;
|
||||
multiplier_factor = 1;
|
||||
multiplier_factor <<= (u16)(max_multiplier - 9);
|
||||
max_multiplier = (u16)(max_multiplier - 9);
|
||||
multiplier_factor = (u16)(multiplier_factor << max_multiplier);
|
||||
*sectors = cluster_blocks * multiplier_factor;
|
||||
} else {
|
||||
*sectors = ((csd[1] >> 8 & 0x3fffff) + 1) * 0x400;
|
||||
|
||||
@@ -1,11 +1,15 @@
|
||||
#include <private/fa/pdm.h>
|
||||
#include <revolution/types.h>
|
||||
#define MBR_WORD(buf, offset) (((pf_u32)(buf)[(offset) + 3] << 24) + ((pf_u32)(buf)[(offset) + 2] << 16) + ((pf_u32)(buf)[(offset) + 1] << 8) + (buf)[offset])
|
||||
static inline pf_u16 read_boot_u16(pf_u8* buf, pf_u32 offset) {
|
||||
if ((pf_u32)&buf[offset] & 1) { return (buf[offset + 1] << 8) | buf[offset]; }
|
||||
return PF_SWAP_16(*(pf_u16*)&buf[(offset + 1) & ~1]);
|
||||
}
|
||||
|
||||
static inline pf_u32 read_partition_u32(const pf_u8* buf, pf_u32 offset) {
|
||||
return (((pf_u32)buf[offset + 2] << 16) + buf[offset]) +
|
||||
(((pf_u32)buf[offset + 3] << 24) + ((pf_u32)buf[offset + 1] << 8));
|
||||
}
|
||||
|
||||
pf_s32 pdm_part_is_master_boot_sector(pf_u8* buf, pf_u32 total, pf_bool* p_is_mbr) {
|
||||
pf_s16 index;
|
||||
pf_u32 start[4];
|
||||
@@ -18,8 +22,8 @@ pf_s32 pdm_part_is_master_boot_sector(pf_u8* buf, pf_u32 total, pf_bool* p_is_mb
|
||||
p_count = count;
|
||||
for (index = 0; index < 4; index++) {
|
||||
*p_start = 0;
|
||||
*p_start = (((pf_u32)buf[456] << 16) + buf[454]) + (((pf_u32)buf[457] << 24) + ((pf_u32)buf[455] << 8));
|
||||
*p_count = (((pf_u32)buf[460] << 16) + buf[458]) + (((pf_u32)buf[461] << 24) + ((pf_u32)buf[459] << 8));
|
||||
*p_start = read_partition_u32(buf, 454);
|
||||
*p_count = read_partition_u32(buf, 458);
|
||||
if (*p_start != 0 && *p_count != 0) {
|
||||
if (index == 0) { *p_is_mbr = 1; }
|
||||
} else {
|
||||
@@ -91,14 +95,14 @@ pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
|
||||
if (err != 0) { return err; }
|
||||
pdm_part_is_master_boot_sector(buf, p_part->p_disk->disk_info.total_sectors, &is_mbr);
|
||||
if (is_mbr) {
|
||||
start[0] = MBR_WORD(buf, 454);
|
||||
start[1] = MBR_WORD(buf, 470);
|
||||
start[2] = MBR_WORD(buf, 486);
|
||||
start[3] = MBR_WORD(buf, 502);
|
||||
count[0] = MBR_WORD(buf, 458);
|
||||
count[1] = MBR_WORD(buf, 474);
|
||||
count[2] = MBR_WORD(buf, 490);
|
||||
count[3] = MBR_WORD(buf, 506);
|
||||
start[0] = read_partition_u32(buf, 454);
|
||||
start[1] = read_partition_u32(buf, 470);
|
||||
start[2] = read_partition_u32(buf, 486);
|
||||
start[3] = read_partition_u32(buf, 502);
|
||||
count[0] = read_partition_u32(buf, 458);
|
||||
count[1] = read_partition_u32(buf, 474);
|
||||
count[2] = read_partition_u32(buf, 490);
|
||||
count[3] = read_partition_u32(buf, 506);
|
||||
part_index = 0;
|
||||
for (index = 0; index < 4; index++) {
|
||||
sector = start[index];
|
||||
@@ -112,15 +116,15 @@ pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
|
||||
sector = base;
|
||||
for (extended_index = 0; extended_index < 2; extended_index++) {
|
||||
if (extended_index == 0) {
|
||||
sector = sector + MBR_WORD(buf, 454);
|
||||
length = MBR_WORD(buf, 458);
|
||||
sector = sector + read_partition_u32(buf, 454);
|
||||
length = read_partition_u32(buf, 458);
|
||||
err = pdm_disk_physical_read(p_part->p_disk, buf, sector, 1, 512, &success);
|
||||
if (err != 0) { return err; }
|
||||
if (requested == part_index) { p_part->start_sector = sector; p_part->total_sector = length; return 0; }
|
||||
part_index++;
|
||||
} else {
|
||||
sector = base + MBR_WORD(buf, 470);
|
||||
length = MBR_WORD(buf, 474);
|
||||
sector = base + read_partition_u32(buf, 470);
|
||||
length = read_partition_u32(buf, 474);
|
||||
if (sector == 0 || length == 0) { break; }
|
||||
err = pdm_disk_physical_read(p_part->p_disk, buf, sector, 1, 512, &success);
|
||||
if (err != 0) { return err; }
|
||||
|
||||
@@ -557,15 +557,11 @@ static void kbdSendKey(KBDKeyEventData* event) {
|
||||
}
|
||||
}
|
||||
|
||||
static inline u32 kbdChannelFlags(u32 channel) {
|
||||
return kbdData[channel].flags;
|
||||
}
|
||||
|
||||
static void kbd_led_handler(BOOL success, void* callbackArg) {
|
||||
const KBDLEDCallbackData* callback;
|
||||
u32 index;
|
||||
s32 index;
|
||||
u32 err;
|
||||
index = (u32)callbackArg;
|
||||
index = (s32)callbackArg;
|
||||
callback = &kbdLCBuf[index];
|
||||
kbdCmdBuf[index].device = 0;
|
||||
if (callback->callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
|
||||
@@ -579,12 +575,11 @@ static void kbd_led_handler(BOOL success, void* callbackArg) {
|
||||
err = 0;
|
||||
break;
|
||||
}
|
||||
kbdLCBuf[index].callbackAddress(err, kbdLCBuf[index].callbackArg);
|
||||
kbdLCBuf[(u32)callbackArg].callbackAddress(err, kbdLCBuf[(u32)callbackArg].callbackArg);
|
||||
}
|
||||
|
||||
USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback, void* callbackArg) {
|
||||
s32 index;
|
||||
u32 ofs;
|
||||
u32 index;
|
||||
u8 ledBits;
|
||||
BOOL interrupts;
|
||||
USBKBDErr result;
|
||||
@@ -594,14 +589,18 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
|
||||
if (channel >= 4) {
|
||||
return 4;
|
||||
}
|
||||
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
|
||||
return 5;
|
||||
{
|
||||
KBDChannel* data = &kbdData[(s32)channel];
|
||||
if ((s32)data->flags == 1 || (s32)data->flags == 4) {
|
||||
return 5;
|
||||
}
|
||||
}
|
||||
ledBits = leds;
|
||||
interrupts = OSDisableInterrupts();
|
||||
for (index = 0, ofs = 0; index < 12; index++, ofs += sizeof(KBDLEDCommand)) {
|
||||
if (*(u32*)&((u8*)kbdCmdBuf)[ofs] == 0) {
|
||||
*(u32*)&((u8*)kbdCmdBuf)[ofs] = (u32)kbdData[channel].device;
|
||||
for (index = 0; index < 12; index++) {
|
||||
if (kbdCmdBuf[(s32)index].device == 0) {
|
||||
KBDChannel* data = &kbdData[channel];
|
||||
kbdCmdBuf[(s32)index].device = (u32)data->device;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -609,11 +608,14 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
|
||||
if (index == 12) {
|
||||
return 7;
|
||||
}
|
||||
kbdLCBuf[index].callbackAddress = callback;
|
||||
kbdLCBuf[index].callbackArg = callbackArg;
|
||||
result = USBKBDSetLEDAsync((u32)kbdData[channel].device, ledBits,
|
||||
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
|
||||
kbd_led_handler, (void*)index);
|
||||
{
|
||||
KBDChannel* data = &kbdData[channel];
|
||||
kbdLCBuf[index].callbackAddress = callback;
|
||||
kbdLCBuf[index].callbackArg = callbackArg;
|
||||
result = USBKBDSetLEDAsync((u32)data->device, ledBits,
|
||||
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
|
||||
kbd_led_handler, (void*)index);
|
||||
}
|
||||
switch (result) {
|
||||
default:
|
||||
return 7;
|
||||
@@ -624,7 +626,6 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
|
||||
|
||||
USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
|
||||
u32 index;
|
||||
KBDLEDCommand* command;
|
||||
BOOL interrupts;
|
||||
USBKBDErr result;
|
||||
u8 ledBits;
|
||||
@@ -634,20 +635,16 @@ USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
|
||||
if (channel >= 4) {
|
||||
return 4;
|
||||
}
|
||||
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
|
||||
if ((s32)kbdData[(s32)channel].flags == 1 || (s32)kbdData[(s32)channel].flags == 4) {
|
||||
return 5;
|
||||
}
|
||||
ledBits = leds & 0xff;
|
||||
interrupts = OSDisableInterrupts();
|
||||
index = 0;
|
||||
command = kbdCmdBuf;
|
||||
while (index < 12) {
|
||||
if (command->device == 0) {
|
||||
command->device = (u32)kbdData[channel].device;
|
||||
for (index = 0; index < 12; index++) {
|
||||
if (kbdCmdBuf[(s32)index].device == 0) {
|
||||
kbdCmdBuf[(s32)index].device = (u32)kbdData[channel].device;
|
||||
break;
|
||||
}
|
||||
index++;
|
||||
command++;
|
||||
}
|
||||
OSRestoreInterrupts(interrupts);
|
||||
if (index == 12) {
|
||||
@@ -655,7 +652,7 @@ USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
|
||||
}
|
||||
result = USBKBDSetLED((u32)kbdData[channel].device, ledBits,
|
||||
(USBKBDCmdLED*)&kbdCmdBuf[index]);
|
||||
kbdCmdBuf[index].device = 0;
|
||||
kbdCmdBuf[(s32)index].device = 0;
|
||||
switch (result) {
|
||||
default:
|
||||
return 7;
|
||||
|
||||
@@ -169,11 +169,11 @@ static const u32 AESiDecryptTable[] = {
|
||||
};
|
||||
|
||||
#define ROTATE(x,n) (((x) << (n)) | ((x) >> (32 - (n))))
|
||||
#define ENCRYPT(a,b,c,d) (ROTATE(AESiEncryptTable[(a)>>24],24) ^ ROTATE(AESiEncryptTable[((b)>>16)&255],16) ^ ROTATE(AESiEncryptTable[((c)>>8)&255],8) ^ AESiEncryptTable[(d)&255])
|
||||
#define DECRYPT(a,b,c,d) (ROTATE(AESiDecryptTable[(a)>>24],24) ^ ROTATE(AESiDecryptTable[((b)>>16)&255],16) ^ ROTATE(AESiDecryptTable[((c)>>8)&255],8) ^ AESiDecryptTable[(d)&255])
|
||||
#define SUBSTITUTE(table,a,b,c,d) (((u32)table[(a)>>24]<<24) | ((u32)table[((b)>>16)&255]<<16) | ((u32)table[((c)>>8)&255]<<8) | table[(d)&255])
|
||||
#define ENCRYPT(a,b,c,d) (((ROTATE(AESiEncryptTable[((b)>>16)&255],16) ^ ROTATE(AESiEncryptTable[(a)>>24],24)) ^ AESiEncryptTable[(d)&255]) ^ ROTATE(AESiEncryptTable[((c)>>8)&255],8))
|
||||
#define DECRYPT(a,b,c,d) (((ROTATE(AESiDecryptTable[((b)>>16)&255],16) ^ AESiDecryptTable[(d)&255]) ^ ROTATE(AESiDecryptTable[(a)>>24],24)) ^ ROTATE(AESiDecryptTable[((c)>>8)&255],8))
|
||||
#define SUBSTITUTE(table,a,b,c,d) ((((u32)table[(a)>>24]<<24) | table[(d)&255]) | (((u32)table[((b)>>16)&255]<<16) | ((u32)table[((c)>>8)&255]<<8)))
|
||||
|
||||
#define SUBSTITUTE_XOR(table,a,b,c,d) (((u32)table[(a)>>24]<<24) ^ ((u32)table[((b)>>16)&255]<<16) ^ ((u32)table[((c)>>8)&255]<<8) ^ table[(d)&255])
|
||||
#define SUBSTITUTE_XOR(table,a,b,c,d) (((((u32)table[(a)>>24]<<24) ^ table[(d)&255]) ^ ((u32)table[((c)>>8)&255]<<8)) ^ ((u32)table[((b)>>16)&255]<<16))
|
||||
|
||||
void AESiEncryptBlock(AESContext* context, u32* output, const u32* input) {
|
||||
u32 rounds = context->rounds;
|
||||
@@ -210,9 +210,9 @@ void AESiDecryptBlock(AESContext* context, u32* output, const u32* input) {
|
||||
u32 twice=DOUBLE_BYTES(value);
|
||||
u32 four=DOUBLE_BYTES(twice);
|
||||
u32 eight=DOUBLE_BYTES(four)^value;
|
||||
u32 mixed=eight ^ (four ^ ROTATE(eight,8));
|
||||
mixed ^= twice ^ ROTATE(mixed,8);
|
||||
mixed ^= value ^ ROTATE(mixed,8);
|
||||
u32 mixed=(ROTATE(eight,8) ^ (eight ^ four));
|
||||
mixed=(ROTATE(mixed,8) ^ (mixed ^ twice));
|
||||
mixed=(ROTATE(mixed,8) ^ (mixed ^ value));
|
||||
keys[word]=mixed;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -242,8 +242,6 @@ BOOL BS2IsDiagDisc() { return (u8)(*(u8 *)OSPhysicalToCached(OS_ADDR_BOOT_INFO)
|
||||
extern vu32 BS2VideoMode;
|
||||
extern vu32 __DVDLayoutFormat;
|
||||
|
||||
extern void __pformatter(void);
|
||||
|
||||
asm void Run(u32 entryPoint, void *start, u32 blockCount, u32 argument) {
|
||||
// clang-format off
|
||||
#ifdef __MWERKS__
|
||||
@@ -282,8 +280,9 @@ asm void Run(u32 entryPoint, void *start, u32 blockCount, u32 argument) {
|
||||
li r30, 0
|
||||
li r31, 0
|
||||
|
||||
lis r1, __pformatter+640@h
|
||||
ori r1, r1, (__pformatter+640)@l
|
||||
// The application stack is fixed; it is unrelated to the formatter.
|
||||
lis r1, 0x8160
|
||||
ori r1, r1, 0
|
||||
li r6, 0
|
||||
|
||||
b Run_loop_entry
|
||||
@@ -1846,22 +1845,24 @@ invalidRvlRegion:
|
||||
State = BS2_STT_RESET_SYSTEM;
|
||||
break;
|
||||
}
|
||||
if (GamePartition != 0)
|
||||
if (GamePartition != 0) {
|
||||
State = BS2_STT_37;
|
||||
else {
|
||||
} else {
|
||||
State = BS2_STT_54;
|
||||
break;
|
||||
}
|
||||
case 0x25:
|
||||
case 0x25: {
|
||||
u32 partitionOffset = (u32)((DVDPartitionInfo *)GamePartition)->partition;
|
||||
if (BS2BootFromCache != 0) {
|
||||
BS2Report("Open partition from cache.dat\n");
|
||||
NandPending = 1;
|
||||
BS2NANDDivideReadAsync(&BS2CacheFileInfo, &PartitionParams.tmd, 0x4a00, BS2NANDCallback, &BS2NandBlock);
|
||||
} else
|
||||
DVDOpenPartitionAsync(&Block, &PartitionParams.tmd, (u32)((DVDPartitionInfo *)GamePartition)->partition, BS2DVDCallback);
|
||||
DVDOpenPartitionAsync(&Block, &PartitionParams.tmd, partitionOffset, BS2DVDCallback);
|
||||
PartitionOpen = 1;
|
||||
State = BS2_STT_38;
|
||||
break;
|
||||
}
|
||||
case 0x26: {
|
||||
status = CheckBS2CommandStatus();
|
||||
if (status == 0)
|
||||
@@ -1888,13 +1889,16 @@ invalidRvlRegion:
|
||||
titlePrefix = titleCode >> 0x18;
|
||||
titleCharacters[3] = (u8)titleCode;
|
||||
titleCharacters[0] = (char)(titleCode >> 0x18);
|
||||
if (titlePrefix < 'R') {
|
||||
if (titlePrefix == 'D')
|
||||
goto check_title_region;
|
||||
} else if (titlePrefix < 'U')
|
||||
switch (titlePrefix) {
|
||||
case 'D':
|
||||
case 'R':
|
||||
case 'S':
|
||||
case 'T':
|
||||
goto check_title_region;
|
||||
regionMatches = TRUE;
|
||||
goto title_region_checked;
|
||||
default:
|
||||
regionMatches = TRUE;
|
||||
goto title_region_checked;
|
||||
}
|
||||
{
|
||||
check_title_region:
|
||||
if (titleCharacters[3] == 0x41) {
|
||||
@@ -2052,8 +2056,8 @@ invalidRvlRegion:
|
||||
if (status == 0)
|
||||
OSPanic("BS2Mach.c", 0x12c8, "BS2 ERROR >>> Cannnot alloc 0x%08x from MEMAllocator", bannerFile.length);
|
||||
BannerLength = bannerFile.length;
|
||||
BannerBuffer = OSRoundDown32B(BannerAllocation) + 32;
|
||||
BS2Report("BannerBufferAddr : %08X\n");
|
||||
BannerBuffer = BannerAllocation + 32 - BannerAllocation % 32;
|
||||
BS2Report("BannerBufferAddr : %08X\n", BannerBuffer);
|
||||
} else {
|
||||
if ((BannerBuffer != 0) && (BannerLength != 0)) {
|
||||
if (BannerLength < ((bannerFile.length + 0x1fU) & 0xffffffe0))
|
||||
|
||||
83
tools/decomp-assist/allhands-aes-finalround.attempts.md
Normal file
83
tools/decomp-assist/allhands-aes-finalround.attempts.md
Normal file
@@ -0,0 +1,83 @@
|
||||
# AES final-round word reconstruction, 2026-10-02
|
||||
|
||||
Base: `813660b9` plus local cherry-pick `97035641` of the parent's already queued
|
||||
`fce31442`. The imported candidate and its log are unchanged. This follow-on
|
||||
changes only two final-round expression lines in `libs/RevoEX/src/net/aes.c`
|
||||
and this new log. 43U only; no configuration, metadata, headers or linking edits.
|
||||
|
||||
## Retained reconstruction
|
||||
|
||||
The last cipher round substitutes four bytes, places them in distinct unsigned
|
||||
word lanes, and combines them before AddRoundKey. Encryption combines the high
|
||||
and low lanes, combines the two middle lanes, then ORs those pieces. Decryption
|
||||
combines high/low first, then the lower-middle and upper-middle lanes by XOR.
|
||||
These expressions preserve byte indices, shifts, S-box identity, key traversal,
|
||||
output order and all input/state reads. The four lane contributions are disjoint;
|
||||
all operands are unsigned and have no side effects. No value, algorithmic path,
|
||||
or table is newly invented. This is arithmetic-dependency reconstruction rather
|
||||
than a new implementation or an exact-match claim.
|
||||
|
||||
The target evidence is the original split object's final substitution and
|
||||
packing regions in `AESiEncryptBlock` and `AESiDecryptBlock`. Those regions
|
||||
contain the same sixteen byte loads and word-lane insertion/XOR operations.
|
||||
The retained grouping improves the whole-function instruction similarity at
|
||||
the target's existing body sizes. It does not reproduce every target dependency
|
||||
or register assignment: exact matching remains open, and positional ctxdiff
|
||||
counts are slightly worse despite the improved aligned objdiff scores.
|
||||
|
||||
## Explored alternatives
|
||||
|
||||
- MD5 third-round Boolean grouping and four typed step helpers were tested.
|
||||
The best small Boolean change only reached 94.37255% from 94.30719%; a larger
|
||||
helper reached 94.43791%. Both were discarded as too little benefit for the
|
||||
added change. MD5 source is byte-for-byte unchanged.
|
||||
- Typed inverse-key word, round and complete-schedule helper scopes were tested.
|
||||
A round helper reached 69.72908% decrypt similarity, but interacted poorly
|
||||
with the better final-round grouping. No helper is retained.
|
||||
- Fusing AddRoundKey into each intermediate column regressed both directions.
|
||||
- Typed final-substitution helpers, packed-byte intermediates, and explicit
|
||||
T-table column helpers were evaluated. Their source complexity was unnecessary
|
||||
or they scored below the two retained macro changes.
|
||||
- Twelve unsigned lane-combination expressions were checked for each final-round
|
||||
macro. Two independently improving forms are retained. No register/declaration
|
||||
sweep, assembly, volatile qualifier, undefined value, padding or compiler-option
|
||||
change was used.
|
||||
|
||||
## Verification
|
||||
|
||||
Before -> after:
|
||||
- AESiEncryptBlock: 62.58228 -> 65.81013% fuzzy; 158/158 instructions unchanged;
|
||||
final ctxdiff 137 positional differences (baseline 133).
|
||||
- AESiDecryptBlock: 67.64143 -> 69.69323% fuzzy; 251/251 instructions unchanged;
|
||||
final ctxdiff 227 positional differences (baseline 224).
|
||||
- AES unit: 79.601746 -> 81.09157% fuzzy; exact functions 7/9 and exact code
|
||||
1116/2752 bytes unchanged. Data 2800/2800 (100%) and linking unchanged.
|
||||
- All seven exact AES APIs/CBC functions retain objdiff 100% and ctxdiff diffs 0:
|
||||
NETAESCreateEx 108/108, NETAESCreate 2/2, NETAESDelete 1/1, NETAESEncrypt 46/46,
|
||||
NETAESDecrypt 46/46, NETiAESEncryptoBlock 39/39, NETiAESDecryptoBlock 37/37.
|
||||
- AES pool: all four strings identical. .rodata 2592 bytes and .sdata2 8 bytes
|
||||
identical. .data has the same 197-byte prefix of the 200-byte target, retaining
|
||||
the existing three-byte target alignment extent; no padding was introduced.
|
||||
- MD5 remains unit 96.179825%, ProcessBlock 94.30719% (306/306 instructions),
|
||||
exact functions 3/4, exact code 600/1824, data 456/456. Its three exact APIs
|
||||
retain ctxdiff diffs 0. All 448 .data bytes are identical; .sdata retains its
|
||||
existing one-byte source/seven-byte target-alignment extent difference.
|
||||
- Full 1027-unit report: no exact-function, exact-code, data or fuzzy regression
|
||||
versus the locally imported parent candidate.
|
||||
- Full 43U build and build/43U/ok passed. DOL SHA1 remains
|
||||
`26116613f624061ba99c8d1a299aaa6efa85670d`.
|
||||
|
||||
Host tests compile production source unchanged with private copies of the existing
|
||||
PPC type/intrinsic shims. Both final AES and the imported parent baseline passed
|
||||
all 2,406 AES-128/192/256 known-answer and seeded randomized CBC checks, including
|
||||
separate/in-place buffers and single/incremental calls. Unchanged MD5 passed all
|
||||
3,088 known-answer/random/chunking checks. The MD5 test supplies RFC1321 padding
|
||||
externally; GetDigest's target-endian length stores remain outside host coverage.
|
||||
|
||||
Private local evidence: `/tmp/crypto-reconstruction-next/` contains baseline/final
|
||||
reports, pool/section/ctxdiff results, full-build.log, host validation scripts and
|
||||
results, and the rejected experiments. No retail assembly or binary is committed
|
||||
or uploaded. Prior worker logs under `/tmp/crypto-remainder/` are untouched.
|
||||
|
||||
GATE: validated partial arithmetic reconstruction with no report regressions.
|
||||
Exact matching and linking remain open. Candidate frozen for parent validation.
|
||||
71
tools/decomp-assist/allhands-aes-rounds.attempts.md
Normal file
71
tools/decomp-assist/allhands-aes-rounds.attempts.md
Normal file
@@ -0,0 +1,71 @@
|
||||
# AES round-expression reconstruction, 2026-10-02
|
||||
|
||||
Separate follow-on to AES key-cursor candidate `2a537c14`. Frozen MD5 candidate
|
||||
`8a6461f9` and prior logs are untouched. This commit changes five expression
|
||||
lines in `libs/RevoEX/src/net/aes.c`, plus this log. 43U only; no linking changes.
|
||||
|
||||
## Evidence and reconstruction
|
||||
|
||||
Target evidence remains the original split `aes.o`, AESiEncryptBlock and
|
||||
AESiDecryptBlock. Both round bodies use four cyclic T-table columns: rotations
|
||||
of 24, 16 and 8 bits plus the unrotated low-byte column. Their XOR dependencies
|
||||
and the inverse-key transform's successive rotate/XOR dependencies lower in a
|
||||
different order from the previous source. The retained expressions associate
|
||||
these same unsigned contributions so compiler scheduling moves closer to the
|
||||
target. Byte indices, rotation counts, table identity, key traversal, row order,
|
||||
loop conditions and final substitution are unchanged.
|
||||
|
||||
The inverse-key transform still computes doubled/four-times/eight-times byte
|
||||
values in the same GF(2^8) representation. Each subsequent stage combines its
|
||||
old mixed value, its 8-bit rotation and the same added contribution. Explicit
|
||||
XOR assignment replaces the compound assignment; all RHS values are evaluated
|
||||
before the assignment, with no side effects or undefined evaluation order.
|
||||
|
||||
No source body or algorithm was missing. This is further instruction-shape
|
||||
reconstruction, not a new functional path or an exact-match claim.
|
||||
|
||||
## Attempts
|
||||
|
||||
- Eight staged column/round helpers and six explicit table-load stages did not
|
||||
improve both functions; reverted.
|
||||
- Tested 120 associative/permutation forms of four T-table contributions,
|
||||
retaining the independent improving expression for each cipher direction.
|
||||
- Tested twelve uniform inverse-key XOR forms plus per-stage refinements. The
|
||||
retained rotate-first XOR form improves all three stages without new helpers.
|
||||
- Array/struct state views, a 15-by-4 round-key view, initial-key cursor forms,
|
||||
and typed table helpers were evaluated. Small gains that required larger
|
||||
changes were rejected, along with all regressions.
|
||||
- No register declaration sweep, inline assembly, volatile qualifier, padding,
|
||||
undefined input, compiler-option change or table change was used.
|
||||
|
||||
## Verification
|
||||
|
||||
Before -> after:
|
||||
- AESiEncryptBlock fuzzy 60.348103 -> 62.58228%; 158/158 instructions unchanged;
|
||||
final ctxdiff has 133 positional differences.
|
||||
- AESiDecryptBlock fuzzy 63.836655 -> 67.64143%; 251/251 instructions unchanged;
|
||||
final ctxdiff has 224 positional differences.
|
||||
- Unit fuzzy 77.700584 -> 79.601746%.
|
||||
- Exact functions 7/9, exact code 1116/2752 bytes, data 2800/2800 (100%), and
|
||||
linked status are unchanged. All seven exact functions retain ctxdiff diffs 0.
|
||||
- All four pool strings match. Table and data source is unchanged.
|
||||
- Frozen MD5 source/metrics are unchanged: unit96.179825%, ProcessBlock94.30719%.
|
||||
- The full 1027-unit report has zero exact-function/code/data/fuzzy regressions
|
||||
against the immediately preceding frozen MD5/AES source report.
|
||||
- Full 43U build and build/43U/ok passed. DOL SHA1 remains
|
||||
`26116613f624061ba99c8d1a299aaa6efa85670d`.
|
||||
|
||||
`python3 /tmp/crypto-remainder/validate_aes.py` passed all 2,406 production-source
|
||||
known-answer/randomized AES-128/192/256 CBC checks, including in-place buffers
|
||||
and incremental calls. The frozen AES parent source independently passed the
|
||||
same coverage in the same run. Input/key/IV words carry their PPC big-endian
|
||||
numeric values in the native host harness; production source is unmodified.
|
||||
|
||||
Local evidence, not committed or uploaded: `/tmp/crypto-remainder/` contains
|
||||
`aes.xor-results.json`, `aes.invmix-results.json`, `aes-rounds-final.json`,
|
||||
`aes-rounds-AESiEncryptBlock.ctx`, `aes-rounds-AESiDecryptBlock.ctx`,
|
||||
`aes-rounds-vectors.log`, `aes-rounds-full-build.log`, and `validate_aes.py`.
|
||||
No original retail assembly or binary is included in this commit.
|
||||
|
||||
GATE: validated partial arithmetic/data-flow candidate; no regressions. Exact
|
||||
matching and linking remain open.
|
||||
62
tools/decomp-assist/allhands-bs2-tick.attempts.md
Normal file
62
tools/decomp-assist/allhands-bs2-tick.attempts.md
Normal file
@@ -0,0 +1,62 @@
|
||||
# BS2Tick control-flow reconstruction, 2026-10-02
|
||||
|
||||
Baseline BS2Mach source is 449529d9. This candidate changes only BS2Tick in
|
||||
src/BS2/BS2Mach.c. Existing ESMisc and AOSSLink commits remain separate.
|
||||
|
||||
Initial pool_diff: 91/91 strings identical. Read the BS2 round-two/round-three
|
||||
and fz1 attempt records, and compared the current five open functions with
|
||||
fresh target objects. The Run hardware-handoff deficit is separate and is not
|
||||
changed or represented as complete here.
|
||||
|
||||
## Retained source reconstruction
|
||||
|
||||
1. Express the title-family dispatch as the actual sparse set D/R/S/T.
|
||||
The target compares D below R, then dispatches the contiguous R-through-T
|
||||
group using an upper boundary U. The switch restores its branch pair and
|
||||
makes the family set explicit. Exhaustively checked all 256 prefix values.
|
||||
2. Restore the positive game-partition state transition and capture the
|
||||
partition offset at entry to state 0x25, before either cache or disc path.
|
||||
The target loads the partition member before choosing the cache branch;
|
||||
the old source only read it on the disc path. The incoming partition
|
||||
existence check and the state-37 fallthrough remain explicit.
|
||||
3. Restore the banner address diagnostic's missing variadic argument.
|
||||
Target BS2Tick object offsets 0x39B4–0x39D8 compute the aligned banner
|
||||
pointer in r4, store it as BannerBuffer and pass it to BS2Report. The old
|
||||
source supplied the %08X format with no argument on the allocation path.
|
||||
4. Express the same next-cache-line calculation as allocation + 32 minus its
|
||||
remainder modulo 32. This retains the target's strictly-next-line behavior,
|
||||
including when the allocation is already aligned. It does not add padding
|
||||
storage. Checked 196608 address samples including all low 16-bit values at
|
||||
zero, 0x80000000 and near u32 wrap.
|
||||
|
||||
Measured attempts, all retained and individually nonregressing:
|
||||
|
||||
| Attempt | BS2Tick fuzzy | Unit fuzzy |
|
||||
| --- | ---: | ---: |
|
||||
| Baseline | 98.230415% | 98.159485% |
|
||||
| Actual title-family switch | 98.35567% | 98.21673% |
|
||||
| Partition entry and typed member snapshot | 98.58763% | 98.32273% |
|
||||
| Banner diagnostic argument | 98.59278% | 98.32509% |
|
||||
| Explicit next-cache-line remainder | 98.639175% | 98.34629% |
|
||||
|
||||
BS2Tick grows from 1934 to 1937 instructions; target is 1940. The remaining
|
||||
three missing instructions are address-materialization differences, with
|
||||
additional register and instruction-scheduling differences. This is partial
|
||||
reconstruction/matching progress, not an exact function.
|
||||
|
||||
## Verification
|
||||
|
||||
- Full all_source / fresh report / build/43U/ok requested after focused build
|
||||
- DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d
|
||||
- Exact functions unchanged: 24/29; exact code unchanged: 4940/16980
|
||||
- Data unchanged: 155504/158528 (98.092445%)
|
||||
- Every other unit's report unchanged
|
||||
- The 91-string pool is identical; literal reference audit checks 37 arguments
|
||||
across 24 exact functions with no candidates or errors
|
||||
- Compared all 1027 source objects with the initial snapshot: only previously
|
||||
committed ESMisc and this BS2Mach object differ. BS2Mach .text 16828 -> 16840
|
||||
bytes, 1306 relocations on both sides; .data stays 3020 bytes and 155 jump-table
|
||||
relocations; all other allocated sections/objects are unchanged
|
||||
- git diff --check passes
|
||||
|
||||
No BS2Update, shared-header, metadata, link-flag or assembly change is included.
|
||||
@@ -0,0 +1,99 @@
|
||||
# Alpha comparison and output boundary follow-on, 2026-10-02
|
||||
|
||||
Base: 813660b9 plus unchanged one-key candidate 2ec4a57e, locally fe647fe4.
|
||||
Changed source: libs/RVLMiddleware/eZiText/src/clib/zi8alpha.c only.
|
||||
No ABI, shared header, linking flag or other source change is included.
|
||||
|
||||
## Retained target source structure
|
||||
|
||||
- At function +0x25A8, the suffix truncation condition compares the combined
|
||||
word/prefix length first and branches on less-or-equal. Recovered that
|
||||
operand order. The separate bound check at +0x25E0 has the opposite operand
|
||||
order and is deliberately preserved.
|
||||
- The dictionary lookup comparisons at +0x2948, +0x2978 and +0x2990 compare
|
||||
the dictionary scan index first against word length or the halfword-narrowed
|
||||
dictionary count. Recovered those three relational expressions without
|
||||
changing the count helper's declaration or its halfword conversion.
|
||||
- The punctuation fallback at +0x30F8 compares against 0xF010 and uses a
|
||||
strict greater-than failure branch. Replaced the equivalent < 0xF011 test
|
||||
with <= 0xF010.
|
||||
- The output-count branch at +0x3B08 falls through to clear letters when
|
||||
countOnly is true, and branches to the actual-count store otherwise.
|
||||
Restored that original arm order.
|
||||
- Prefix selection at +0x3B84 compares against 1 and uses less-or-equal.
|
||||
Recovered <= 1 instead of the equivalent < 2.
|
||||
|
||||
These are demonstrated control-flow and expression reconstructions, not
|
||||
register/declaration permutations. No new volatile, assembly, forced register,
|
||||
padding, artificial storage, or undefined value is introduced.
|
||||
|
||||
## Isolated trials and rejected work
|
||||
|
||||
Trials used the live 43U Ninja compiler command, separate source/objects and
|
||||
reports under /tmp/ezi-next, without changing the worktree before selection.
|
||||
Columns: unit fuzzy / matched data bytes / exact functions.
|
||||
|
||||
- Output-count arm order: 96.47729 / 516 / 11
|
||||
- Both inclusive boundary expressions: 96.3798 / 516 / 11
|
||||
- Both maximum-length comparison orders: 96.38128 / 516 / 11
|
||||
- Dictionary comparison order: 96.38405 / 516 / 11
|
||||
- Initial four-group combination: 96.48966 / 516 / 11
|
||||
- Final reviewed combination, preserving the second length comparison's
|
||||
original operand order: 96.52474 / 516 / 11
|
||||
|
||||
Further target-evidenced trials were rejected rather than committed:
|
||||
|
||||
- Safe temporary plus postfix prefix append: 94.71085 / 336 / 11
|
||||
- Safe temporary plus postfix highlighted append: 94.60377 / 336 / 11
|
||||
- Dictionary-kind switches: 96.364845 / 408 / 11
|
||||
- Early candidate skip: 96.451996 / 408 / 11
|
||||
- Combined candidate-count limits: 96.402695 / 408 / 11
|
||||
- Full dictionary source structure plus initial boundary combination:
|
||||
96.78767 / 408 / 11; function extent 0x3DB8 versus 0x3DA8
|
||||
- Explicit prefix-mode byte: 96.40805 / 408 / 11
|
||||
- Explicit element-count byte: 96.3582 / 408 / 11
|
||||
- Skip/count/byte combinations retained extent mismatches and were rejected.
|
||||
|
||||
One-key spelling compound count assignment was codegen-neutral. Prefix
|
||||
increment removed the redundant byte narrowing but worsened allocation:
|
||||
unit 98.23523 -> 97.36198. Neither trial is retained.
|
||||
|
||||
Chinese explicit halfword casts at the two paired phonetic comparisons and
|
||||
an alternative proper halfword return declaration with redundant casts removed
|
||||
both reproduce the previously parked result: unit 96.848755, matched data
|
||||
144 -> 72. Adding the demonstrated component-cursor reload gives 96.489876
|
||||
with the same loss. All remain scratch experiments, with no Chinese edit or
|
||||
neutral PUD ABI commit included.
|
||||
|
||||
## Validation
|
||||
|
||||
Fresh full report: /tmp/ezi-next-alpha-full-report.json.
|
||||
Full-build log: /tmp/ezi-next-alpha-full-build.log.
|
||||
Baseline report: /tmp/ezi-next-baseline.json.
|
||||
|
||||
Zi8AlphaGetCandidates: 95.02813% -> 95.23011%.
|
||||
Unit fuzzy: 96.37759% -> 96.52474%, about 31.88 weighted bytes gained.
|
||||
Exact functions remain 11/12; exact code remains 5880/21664;
|
||||
matched data remains 516/564. No complete unit or new exact function claimed.
|
||||
All 1027 units were compared for fuzzy, matched-code, matched-data and exact
|
||||
function measures: the alpha fuzzy improvement is the sole changed measure,
|
||||
with no regressions.
|
||||
|
||||
Pool checked first: identical and empty. Main function stays 3946/3946
|
||||
instructions and 0x3DA8 bytes, with the same 0x2B0 frame. Strict ctxdiff is
|
||||
nonzero (3738 differences); existing scalar-stack displacement and register
|
||||
allocation remain. Each of the 11 existing exact functions retains identical
|
||||
instruction counts and ctxdiff diffs 0.
|
||||
|
||||
Baseline/candidate .rodata, .data, extab and extabindex have identical payloads
|
||||
and canonical relocations. Relative to the target, extab and extabindex remain
|
||||
byte-identical; the unchanged generated switch relocations remain unmatched.
|
||||
The source rodata's pre-existing 330-byte size versus target 336 is unchanged;
|
||||
objdiff still reports 100% for that section and the same exact-data accounting.
|
||||
Advisory branch mapping checks 709 same-mnemonic branch pairs with zero
|
||||
mapped destination mismatches, and 73/73 helper calls. It is not an exactness
|
||||
or formal equivalence claim.
|
||||
|
||||
Full 43U build passes with the approved wrapper and WIBO_SJIS_MISSING_IMPORTS=1.
|
||||
DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d.
|
||||
git diff --check passes. No remote actions were performed.
|
||||
@@ -0,0 +1,108 @@
|
||||
# One-key candidate boundary reconstruction, 2026-10-02
|
||||
|
||||
Parent commits: alpha 94b7f57e and 35677806, neutral Chinese ABI 105f3b45.
|
||||
This pass changes only `libs/RVLMiddleware/eZiText/src/clib/zi81key.c`.
|
||||
Alpha source/logs and Chinese source/log are unchanged.
|
||||
|
||||
## Retained target-defined boundaries
|
||||
|
||||
- `Zi8IsMatch1Key` consumes a halfword key. Six candidate calls narrow that
|
||||
argument after Zi8GetPCode: target +0x0B0C, +0x0F30, +0x16C0, +0x1BA4,
|
||||
+0x1F4C and +0x22A8. Restored the ziU16 formal and removed its three
|
||||
redundant key masks. The helper itself remains 97/97 instructions,
|
||||
objdiff 100%, ctxdiff diffs 0. All source call sites are in this same unit.
|
||||
- Each of the six duplicate-bit checks consumes a byte result in the target.
|
||||
Made the byte conversion explicit at these call boundaries rather than
|
||||
changing the already-exact full-width duplicate helper.
|
||||
- The user-dictionary availability result is narrowed to a byte at target
|
||||
+0x1E00. The existing full-width declaration remains; the caller now
|
||||
performs the demonstrated conversion explicitly.
|
||||
- User ordinal decoding narrows the masked high byte to a halfword before
|
||||
its shift at target +0x1E44. Recovered that type boundary.
|
||||
- Final output termination stores through the current output index and then
|
||||
increments that index without reloading it (+0x2524..+0x2534). Recovered
|
||||
the ordinary postfix-index store. Its right-hand side is constant zero,
|
||||
so there is no unsequenced index read/write.
|
||||
|
||||
These are source/ABI shape reconstructions with demonstrated target
|
||||
conversions; no callee-saved-register or declaration-order sweep was used.
|
||||
|
||||
## Isolated source trials
|
||||
|
||||
Each trial used the exact 43U Ninja compiler command in `/tmp/ezi-onekey-pass`,
|
||||
without modifying the worktree until the final candidate was selected.
|
||||
Below: candidate-function fuzzy / unit fuzzy / matched data / exact functions.
|
||||
|
||||
- Halfword formal retaining old masks: 95.26784 / 97.65741 / 1232 / 4; rejected
|
||||
- Byte duplicate-helper return: 94.73383 / 97.4822 / 1232 / 5; rejected
|
||||
- Explicit duplicate-result bytes alone: same as preceding; not retained alone
|
||||
- User-dictionary result byte alone: 95.240715 / 97.708664 / 1280 / 5
|
||||
- User ordinal halfword alone: 95.30121 / 97.735695 / 1280 / 5
|
||||
- Combined count-limit increments: 95.106384 / 97.64865 / 1232 / 5; rejected
|
||||
- Terminal postfix index alone: 95.4368 / 97.79627 / 1280 / 5
|
||||
- Halfword formal/old masks + duplicate bytes + limits:
|
||||
95.984566 / 97.97763 / 1232 / 4; rejected
|
||||
- Halfword formal with ordinary typed uses:
|
||||
95.26784 / 97.72078 / 1232 / 5; restores the exact helper
|
||||
- Typed key + duplicate bytes: 95.83312 / 97.97334 / 1280 / 5
|
||||
- Typed key + duplicate bytes + count limits:
|
||||
95.984566 / 98.04101 / 1232 / 5; excluded for data regression
|
||||
- Preceding plus terminal postfix: 96.01794 / 98.055916 / 1232 / 5; excluded
|
||||
- Preceding plus user-dictionary/ordinal conversions:
|
||||
95.926155 / 98.01491 / 1232 / 5; excluded
|
||||
- Typed key + duplicate bytes + terminal postfix:
|
||||
95.858154 / 97.98453 / 1280 / 5
|
||||
- Typed key + duplicate bytes + user-dictionary byte:
|
||||
95.87484 / 97.99198 / 1280 / 5
|
||||
- Typed key + duplicate bytes + ordinal halfword:
|
||||
95.93533 / 98.01901 / 1280 / 5
|
||||
- Typed key + duplicate bytes + terminal postfix + user-dictionary byte:
|
||||
95.86858 / 97.98919 / 1280 / 5
|
||||
- Typed key + duplicate bytes + terminal postfix + ordinal halfword:
|
||||
95.98957 / 98.04324 / 1280 / 5
|
||||
- Final complete boundary subset: 96.41927 / 98.23523 / 1280 / 5
|
||||
|
||||
After selecting that subset, the three count-limit blocks were tested
|
||||
individually against it. OEM: 96.17564 / 98.12637 / 1280 / 5; PUD:
|
||||
95.725075 / 97.92507 / 1232 / 5; phrase: 95.93575 / 98.019196 / 1280 / 5.
|
||||
All three were rejected. No count-limit rewrite remains in the candidate.
|
||||
|
||||
## Full validation and exact data disclosure
|
||||
|
||||
Fresh report `/tmp/ezi-onekey-boundary.json`; full-build log
|
||||
`/tmp/ezi-onekey-boundary-build.log`.
|
||||
|
||||
Unit fuzzy 97.778564% -> 98.23523%. Candidate-function fuzzy
|
||||
95.39716% -> 96.41927%, about 98 fewer weighted deficit bytes.
|
||||
Exact functions remain 5/9; exact code remains 3952/21460;
|
||||
matched data remains 1280/1388. All five baseline exact functions have
|
||||
ctxdiff diffs 0 and identical instruction counts.
|
||||
|
||||
Candidate instructions: 2387 -> 2405 versus target 2397; size
|
||||
0x254C -> 0x2594 versus target 0x2574. Frame remains 0x140.
|
||||
It is not exact, and no new exact function is claimed.
|
||||
|
||||
The spelling tables remain 1152 byte-identical bytes. .sdata2 and extab
|
||||
remain byte-identical at 8 and 72 bytes. The switch table's source is 44
|
||||
bytes versus target 48, the pre-existing four-byte section-alignment tail;
|
||||
all 44 bytes and all eleven canonical relocation targets/addends match.
|
||||
No real data object was resized or renamed and no padding was added.
|
||||
|
||||
The already-unmatched 108-byte extabindex still has two differing bytes at
|
||||
0x4F and 0x5B, with the same 98.14815% section score. They are the function
|
||||
extent words: spelling remains 0x1A94 versus target 0x1A90; candidate extent
|
||||
changes from 0x254C to 0x2594 versus target 0x2574. This is changed unmatched
|
||||
metadata, not a claim that all data bytes are unchanged.
|
||||
|
||||
Pool check: identical (no narrow strings). Advisory branch mapping: all 351
|
||||
pairs preserve their destination and all 71 helper calls correspond. A
|
||||
register-value-aware linear audit pairs 621 observable store/call/branch
|
||||
effects. The seven missing byte-boundary differences are resolved; its
|
||||
remaining three differences are the unchanged count-limit reloads, not a
|
||||
formal proof or an exactness claim.
|
||||
|
||||
Full 43U build succeeds with the approved wrapper and
|
||||
WIBO_SJIS_MISSING_IMPORTS=1. DOL SHA1:
|
||||
26116613f624061ba99c8d1a299aaa6efa85670d.
|
||||
`git diff --check` succeeds. No remote, linking, shared-header, assembly,
|
||||
volatile, register-forcing, dummy-storage or undefined-value changes.
|
||||
244
tools/decomp-assist/jpeg-exif-allhands-attempts.md
Normal file
244
tools/decomp-assist/jpeg-exif-allhands-attempts.md
Normal file
@@ -0,0 +1,244 @@
|
||||
# EXIF parser reconstruction and aliasing audit
|
||||
|
||||
Base: `2a33684c` on `agent/bittle/allhands-jpeg-decompile`; EXIF source itself is
|
||||
unchanged from baseline `449529d9`. This is a separate candidate from the prior
|
||||
JPEG converter/IDCT commit. Those files and their logs were left unchanged.
|
||||
|
||||
## Retained reconstruction
|
||||
|
||||
1. The IFD0 entry parameter is `u8*`, with corresponding call-site casts from the
|
||||
parser's read-only directory cursor. With the reconstructed `const u8*`
|
||||
parameter, MWCC hoists all four version-byte loads before their stores.
|
||||
Removing this unsupported qualifier reproduces the original interleaved
|
||||
load/store sequence for tags 0x9000, 0x9101 and 0xA000.
|
||||
2. IFD0's decoded field type is widened to `u32` and both entry fields use the
|
||||
existing `readExifU16` reader. This reproduces the target's eager zero
|
||||
extension and initial instruction order; it does not change TIFF field size.
|
||||
3. IFD1 explicitly includes ignored 0x011C and 0xA000..0xA002 cases alongside
|
||||
existing ignored tags. Target dispatch compares against 0x011C and 0xA004;
|
||||
these case labels improve the recovered decision tree. The precise original
|
||||
no-op case list cannot be proved uniquely, since unknown tags also return
|
||||
unchanged. No new tag interpretation or payload write is introduced.
|
||||
4. IFD1 rational denominators use `thumbnailData + (offset + 4)` without a
|
||||
redundant same-type cast.
|
||||
|
||||
No new exact functions. Exact stays 3/6, matched code 1348/5088 bytes, allocated
|
||||
data 0 bytes / 100%, and linking is unchanged. Unit fuzzy 96.50157 -> 98.94104.
|
||||
|
||||
| Function | Before | After | Source/target instructions |
|
||||
| --- | ---: | ---: | ---: |
|
||||
| TMCCJPEGDecGetOffsetEXIF | 100 | 100 | 155/155, ctxdiff 0 |
|
||||
| TMCCJPEGDecGetInfoEXIF | 100 | 100 | 132/132, ctxdiff 0 |
|
||||
| TMCJPEGDEC_exif_parse | 99.43396 | 99.43396 | 212/212 |
|
||||
| TMCJPEGDEC_IFD0_tag_parse | 94.46986 | 99.386696 | 480/481 |
|
||||
| TMCJPEGDEC_IFD1_tag_parse | 93.099174 | 96.14876 | 239/242 |
|
||||
| TMCJPEGDEC_ThumbnailCheck | 100 | 100 | 50/50, ctxdiff 0 |
|
||||
|
||||
IFD0 still lacks the original low-tag `bltlr` leaf. Aligning that instruction and
|
||||
its branch displacements leaves 32 GPR-operand differences in the two rational
|
||||
field cases. IFD1 still has decision-tree and register differences. The parser
|
||||
retains 21 GPR-operand differences. Nothing here claims exact completion.
|
||||
|
||||
## Concrete behavioral distinction
|
||||
|
||||
An internal IFD0 entry can be arranged with its four version bytes overlapping
|
||||
the destination by one byte. Initial source bytes 01 02 03 04 produce:
|
||||
|
||||
- Baseline compiled code: destination 01 02 03 04
|
||||
- Original object: destination 01 01 01 01
|
||||
- Corrected compiled code: destination 01 01 01 01
|
||||
|
||||
This is evidence about the internal parser's byte-copy/aliasing behavior. It is
|
||||
not a claim that ordinary nonoverlapping EXIF input was decoded incorrectly, or
|
||||
that a public API vulnerability has been established. Both byte orders and all
|
||||
three version fields were checked at offsets -3 through +3, giving 42 overlap
|
||||
cases. The unchanged baseline object fails this regression test; the final
|
||||
object passes all 42. Local destination casts, explicit loops and removal of
|
||||
other const qualifiers did not fix the discrepancy and were restored.
|
||||
|
||||
## Validation
|
||||
|
||||
- Pool checked before tuning and after the final build: identical, zero strings
|
||||
- No allocated non-code sections in either EXIF object
|
||||
- Fresh official report: all six function scores compared with baseline,
|
||||
zero regressions; all three exact functions retain ctxdiff zero differences
|
||||
- Full 4.3U build: PASS
|
||||
- DOL SHA1: `26116613f624061ba99c8d1a299aaa6efa85670d`
|
||||
- `git diff --check 2a33684c`: PASS, including the committed candidate diff
|
||||
- No header/configuration/linking edits, no changes to the separately owned
|
||||
entropy decoder, no remote writes or original binary data committed
|
||||
|
||||
Build/report commands:
|
||||
|
||||
```sh
|
||||
python3 configure.py --version 43U --wrapper ../toolchain/wibo-build/wibo
|
||||
WIBO_SJIS_MISSING_IMPORTS=1 ../.venv/bin/ninja
|
||||
build/tools/objdiff-cli report generate -p . -o build/43U/report.json -f json
|
||||
PYTHONPATH=../local-tools ../.venv/bin/python tools/decomp-assist/pool_diff.py build/43U/src/libs/RVLMiddleware/TMC_JPEG/src/exif/exif_parse.o build/43U/obj/libs/RVLMiddleware/TMC_JPEG/src/exif/exif_parse.o
|
||||
PYTHONPATH=../local-tools ../.venv/bin/python tools/decomp-assist/ctxdiff.py libs/RVLMiddleware/TMC_JPEG/src/exif/exif_parse <symbol>
|
||||
../.venv/bin/python tools/decomp-assist/jpeg_exif_differential_audit.py
|
||||
../.venv/bin/python tools/decomp-assist/jpeg_exif_differential_audit.py --overlap-only
|
||||
```
|
||||
|
||||
## Differential test scope
|
||||
|
||||
`jpeg_exif_differential_audit.py` is a read-only bounded integer PPC interpreter
|
||||
and deterministic test generator. It reads local ELF objects and never writes
|
||||
original executable bytes to the repository. It is a separate test tool; the
|
||||
previous converter/IDCT audit remains unchanged.
|
||||
|
||||
- 267,282 paired calls, seed 449529
|
||||
- Every 16-bit tag selector in both byte orders for both IFD handlers
|
||||
- Field types 0, 3, 4 and 0xFFFF; valid, boundary, out-of-range and wrapping
|
||||
offsets for supported scalar/rational/byte-array tags
|
||||
- Header sizes and offsets, valid/invalid byte order and TIFF magic, truncated
|
||||
entry arrays, IFD0/IFD1/Exif-directory chains and directory-boundary lengths
|
||||
- 42 overlapping version-byte cases that distinguish baseline from original
|
||||
- Every non-stack byte compared, including guard regions; parser return values,
|
||||
stack pointer, LR and GPR14..GPR31 preservation checked
|
||||
- Complete instruction-address coverage of IFD0 and the central parser in both
|
||||
objects; IFD1 covers every source instruction and 241/242 target instructions
|
||||
(one unreachable return in the target dispatch is not visited)
|
||||
|
||||
Limitations: this is not formal equivalence or a Wii runtime test. Instruction
|
||||
coverage is not exhaustive path/input coverage. The custom interpreter models
|
||||
only the observed integer subset, condition comparisons and internal EXIF calls;
|
||||
unsupported instructions/relocations/callees fail closed. FPU, XER overflow,
|
||||
exceptions, timing, cache/MMIO and a full system ABI are not modeled. Relocations
|
||||
use collision-checked symbol tokens; actual linked addresses are not tested.
|
||||
Public JPEG I/O, thumbnail decoding, arbitrary pointer values and all possible
|
||||
payload alias layouts are outside this test. The three exact wrappers are
|
||||
checked by objdiff/ctxdiff rather than executing their external dependencies.
|
||||
|
||||
Run from the repository root with pyelftools and Capstone available, and without
|
||||
Python's `-O` option. `--source-object` and `--target-object` can select separately
|
||||
compiled objects, allowing the overlap regression to be reproduced on baseline
|
||||
without changing the working tree. Final output is in
|
||||
`jpeg-exif-allhands-differential-results.txt`.
|
||||
|
||||
## Existing external branch overlap
|
||||
|
||||
Read-only comparison used the already fetched ref
|
||||
`origin/agent/w1009/tmc` at `cd90be696cb86258a1bc9fb9dc2b304f2bed318d`.
|
||||
No fetch, author communication, branch checkout or merge was performed.
|
||||
|
||||
Its `1c7cf40c` independently removes const from both tag-entry parameters, so the
|
||||
central IFD0 qualifier correction overlaps. Its `81440c32` then uses a u16 tag,
|
||||
u16 type and explicit tag remask. Its no-op case ranges differ from this
|
||||
candidate's explicit ignored tags. It also changes the shared 16-bit reader and
|
||||
parser declaration order. This candidate does not contain those changes.
|
||||
|
||||
An isolated `/tmp` compile of that branch's EXIF source, using the current
|
||||
checkout's original MWCC flags, produced:
|
||||
|
||||
| Measure/function | This candidate | cd90be69 EXIF object |
|
||||
| --- | ---: | ---: |
|
||||
| Unit fuzzy | 98.94104 | 99.01337 |
|
||||
| Central parser | 99.43396 | 98.679245 |
|
||||
| IFD0 | 99.386696 | 98.37838 |
|
||||
| IFD1 | 96.14876 | 99.194214 |
|
||||
| Exact functions | 3/6 | 3/6 |
|
||||
|
||||
Neither candidate wholly supersedes the other. This candidate has the better
|
||||
IFD0 and preserves the current parser score; the external candidate has the
|
||||
better IFD1. Integration must preserve the parser score and independently
|
||||
revalidate any combined source. The isolated comparison is not a full gate of
|
||||
the external branch or its other files.
|
||||
|
||||
Relative to baseline 449529d9, the external RGB565 edits concern its setter and
|
||||
do not overlap the prior candidate's RGB444 body. Its RGBA420 edge edits overlap
|
||||
that prior candidate's changed expression context. It does not change IDCT.
|
||||
The previously committed JPEG candidate remains separate and unchanged.
|
||||
|
||||
## Attempts
|
||||
|
||||
All rejected/equal variants were restored. The lower-tag 0x0100 experiment had a
|
||||
fuzzy improvement but was explicitly discarded after review: the original
|
||||
branch shape does not establish that particular no-op label, and it changed
|
||||
other lower dispatch comparisons. It is absent from the final source.
|
||||
|
||||
### trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse word-width-field-type: 94.469860 -> 95.122660; RETAIN
|
||||
TMCJPEGDEC_IFD0_tag_parse explicit-ignored-compression-return: 95.122660 -> 94.914764; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse explicit-ignored-compression-break: 95.122660 -> 95.122660; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse recognized-ignored-planar-and-pixel-tags: 93.099174 -> 95.942150; RETAIN
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-low-strip-offset-own-return: 95.942150 -> 95.342970; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-orientation-own-return: 95.942150 -> 95.533060; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-datetime-own-return: 95.942150 -> 95.528920; restore
|
||||
```
|
||||
|
||||
### control-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse explicit-unknown-tag-return: 95.122660 -> 94.498960; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse explicit-unknown-tag-break: 95.122660 -> 95.122660; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse explicit-unknown-tag-return: 95.942150 -> 95.876030; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse explicit-unknown-tag-break: 95.942150 -> 95.942150; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ifd1-orientation-uses-unknown-exit: 95.942150 -> 95.756195; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ifd1-planar-uses-unknown-exit: 95.942150 -> 91.694214; restore
|
||||
```
|
||||
|
||||
### ignored-tag-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-image-fields-before-compression: 95.122660 -> 95.110180; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-image-fields: 95.942150 -> 95.735535; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ifd1-planar-logical-case-order: 95.942150 -> 95.942150; restore
|
||||
```
|
||||
|
||||
### reader-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse shared-exif-tag-reader: 95.122660 -> 95.195430; RETAIN
|
||||
TMCJPEGDEC_IFD0_tag_parse shared-exif-type-reader: 95.195430 -> 95.517670; RETAIN
|
||||
TMCJPEGDEC_IFD0_tag_parse shared-exif-short-reader: 95.517670 -> 95.517670; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse shared-exif-tag-reader: 95.942150 -> 95.942150; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse shared-exif-short-reader: 95.942150 -> 95.942150; restore
|
||||
```
|
||||
|
||||
### lower-tag-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(256,): 95.517670 -> 93.004160; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(257,): 95.517670 -> 93.004160; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(258,): 95.517670 -> 95.505196; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(256, 257): 95.517670 -> 93.004160; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(256, 258): 95.517670 -> 93.004160; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(257, 258): 95.517670 -> 95.505196; restore
|
||||
TMCJPEGDEC_IFD0_tag_parse ignored-lower-tags-(256, 257, 258): 95.517670 -> 95.505196; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(256,): 95.942150 -> 96.665290; RETAIN
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(257,): 96.665290 -> 96.665290; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(258,): 96.665290 -> 95.735535; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(256, 257): 96.665290 -> 96.644630; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(256, 258): 96.665290 -> 96.256195; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(257, 258): 96.665290 -> 95.735535; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse ignored-lower-tags-(256, 257, 258): 96.665290 -> 95.735535; restore
|
||||
```
|
||||
|
||||
### byte-copy-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse alias-preserving-version-byte-copy: 95.517670 -> 95.517670; restore
|
||||
```
|
||||
|
||||
### version-loop-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse forward-version-byte-loops: 95.517670 -> 95.517670; restore
|
||||
```
|
||||
|
||||
### qualifier-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD0_tag_parse mutable-entry-view: 95.517670 -> 99.386696; RETAIN
|
||||
TMCJPEGDEC_IFD1_tag_parse mutable-entry-view: 95.942150 -> 95.942150; restore
|
||||
```
|
||||
|
||||
### pointer-trials
|
||||
|
||||
```text
|
||||
TMCJPEGDEC_IFD1_tag_parse mutable-rational-byte-view: 95.942150 -> 95.942150; restore
|
||||
TMCJPEGDEC_IFD1_tag_parse direct-denominator-byte-address: 95.942150 -> 96.148760; RETAIN
|
||||
```
|
||||
@@ -0,0 +1,6 @@
|
||||
TMCJPEGDEC_IFD0_tag_parse 131072 selector cases PASS
|
||||
TMCJPEGDEC_IFD1_tag_parse 131072 selector cases PASS
|
||||
TMCJPEGDEC_IFD0_tag_parse 132746 cases PASS; own-body instruction coverage 480 / 480 source; 481 / 481 original
|
||||
TMCJPEGDEC_IFD1_tag_parse 132704 cases PASS; own-body instruction coverage 239 / 239 source; 241 / 242 original
|
||||
TMCJPEGDEC_exif_parse 1832 cases PASS; own-body instruction coverage 212 / 212 source; 212 / 212 original
|
||||
TOTAL 267282 paired EXIF calls PASS
|
||||
82
tools/decomp-assist/jpeg-next-reconstruction-attempts.md
Normal file
82
tools/decomp-assist/jpeg-next-reconstruction-attempts.md
Normal file
@@ -0,0 +1,82 @@
|
||||
# JPEG follow-on reconstruction
|
||||
|
||||
Base: `813660b9`, branch `agent/bittle/jpeg-reconstruction-next`.
|
||||
The already-reviewed EXIF candidate `b9305280` was preserved unchanged as local
|
||||
cherry-pick `164dbbc5`. This log concerns a separate follow-on to that candidate.
|
||||
|
||||
## Retained change
|
||||
|
||||
IFD0 rational denominator addresses now use the same explicit offset grouping as
|
||||
IFD1: add four to the TIFF offset, then add the thumbnail-data base. The redundant
|
||||
same-type pointer cast is removed. This is a two-line source change; it introduces
|
||||
no new tag interpretation, new memory access, or function.
|
||||
|
||||
- `TMCJPEGDEC_IFD0_tag_parse`: 99.386696 -> 99.49065 fuzzy
|
||||
- EXIF unit: 98.94104 -> 98.98035 fuzzy
|
||||
- EXIF exact functions: 3/6 -> 3/6; matched code remains 1348/5088 bytes
|
||||
- IFD0 remains 480/481 instructions; this is not an exact match or linking result
|
||||
- All other 33 owned functions retain their baseline scores
|
||||
|
||||
No changes are retained in the color converters or IDCT. No declaration-order
|
||||
search, forced registers, volatile, assembly, padding, headers, configuration,
|
||||
linking changes, remote writes, or edits to the entropy decoder were made.
|
||||
|
||||
## Rejected reconstruction trials
|
||||
|
||||
Every equal or regressing trial was restored before validation.
|
||||
|
||||
- Separate rational numerator/denominator pointer lifetimes in IFD0 and IFD1:
|
||||
unchanged from the retained expression; restored
|
||||
- RGB444's common edge-sibling channel evaluation and clipping order with a
|
||||
separate luminance value: 98.71429 -> 98.62637; restored
|
||||
- Explicit odd-coefficient differences in the luminance second-pass butterfly:
|
||||
83.05058 -> 81.42802; restored
|
||||
- Extract the luminance first-pass row transform to a static inline helper:
|
||||
83.05058 -> 81.12062; restored. The trial script initially omitted helper
|
||||
local declarations, causing a compiler error; that experiment was corrected,
|
||||
measured, and then fully restored
|
||||
- Extract RGBA pixel packing to a static inline helper:
|
||||
- 411: 82.6033 -> 81.72314; restored
|
||||
- 422 and edge: unchanged at 87.72298 and 90.08849; restored
|
||||
- 420 and edge: unchanged at 89.40523 and 87.458336; restored
|
||||
- 211 and edge: unchanged at 91.15385 and 92.0; restored
|
||||
- 444: unchanged at 90.670105; restored
|
||||
- 444 edge: 88.90909 -> 87.70909; restored
|
||||
|
||||
These were source-structure trials, not permutations of register declarations.
|
||||
The source-neutral scheduling differences that remain were not chased through
|
||||
artificial source changes.
|
||||
|
||||
## Verification
|
||||
|
||||
The baseline report was generated after building the unchanged cherry-picked
|
||||
candidate. The final report was freshly generated after restoring every rejected
|
||||
trial and rebuilding all four owned objects.
|
||||
|
||||
- Full 4.3U build: PASS
|
||||
- All 34 owned function scores compared against the baseline: zero regressions
|
||||
- All 11 previously exact functions retain exact-name objdiff 100 and ctxdiff 0
|
||||
- Pool checks before trials and after the final build: all four identical,
|
||||
zero strings
|
||||
- Neither source nor original object has allocated non-code sections in any of
|
||||
the four owned units
|
||||
- DOL SHA1: `26116613f624061ba99c8d1a299aaa6efa85670d`
|
||||
- The existing read-only bounded PPC audit tools were inspected before use;
|
||||
their scripts are unchanged
|
||||
- Converter/IDCT audit: all 9,456 paired calls pass
|
||||
|
||||
- EXIF audit: all 267,282 paired calls pass, including the 42 version-byte
|
||||
overlap cases preserved by the preceding candidate
|
||||
- `git diff --check 813660b9`: PASS, including the base-relative committed diff
|
||||
- The working tree is paused for parent review after the focused local commit
|
||||
These interpreter tests are bounded samples, not formal equivalence or Wii
|
||||
runtime tests. Their existing coverage and modeling limitations still apply.
|
||||
|
||||
## Existing external overlap
|
||||
|
||||
The prior EXIF log documents the already fetched
|
||||
`origin/agent/w1009/tmc` branch's overlap with EXIF and color reconstruction.
|
||||
That overlap remains relevant to parent integration. This follow-on was derived
|
||||
from the current source, the prior owned reconstruction, and local object
|
||||
comparisons. No external branch was merged, copied, fetched, or contacted.
|
||||
The parent should preserve the previously queued EXIF candidate separately.
|
||||
63
tools/decomp-assist/jpeg-next-reconstruction-validation.txt
Normal file
63
tools/decomp-assist/jpeg-next-reconstruction-validation.txt
Normal file
@@ -0,0 +1,63 @@
|
||||
main/libs/RVLMiddleware/TMC_JPEG/src/buffer/idct_block_var 89.06892 -> 89.06892
|
||||
POOL IDENTICAL up to 0 (mine=0 base=0)
|
||||
No allocated non-code sections in either object
|
||||
main/libs/RVLMiddleware/TMC_JPEG/src/exif/exif_parse 98.94104 -> 98.98035
|
||||
POOL IDENTICAL up to 0 (mine=0 base=0)
|
||||
TMCCJPEGDecGetOffsetEXIF: src 0x26c base 0x26c insns 155/155; diffs 0: []
|
||||
TMCCJPEGDecGetInfoEXIF: src 0x210 base 0x210 insns 132/132; diffs 0: []
|
||||
TMCJPEGDEC_IFD0_tag_parse 99.386696 -> 99.49065
|
||||
TMCJPEGDEC_ThumbnailCheck: src 0xc8 base 0xc8 insns 50/50; diffs 0: []
|
||||
No allocated non-code sections in either object
|
||||
main/libs/RVLMiddleware/TMC_JPEG/src/texturecvtr/Texture_MCUtoRGB565 96.44502 -> 96.44502
|
||||
POOL IDENTICAL up to 0 (mine=0 base=0)
|
||||
TMCJPEGDEC_converterYUV422toRGB565edge: src 0x1ac base 0x1ac insns 107/107; diffs 0: []
|
||||
TMCJPEGDEC_converterYUV211toRGB565: src 0x188 base 0x188 insns 98/98; diffs 0: []
|
||||
TMCJPEGDEC_converterYUV211toRGB565edge: src 0x1b4 base 0x1b4 insns 109/109; diffs 0: []
|
||||
TMCJPEGDEC_converterYUV444toRGB565edge: src 0x1a0 base 0x1a0 insns 104/104; diffs 0: []
|
||||
TMCJPEGDEC_converterYUV400toRGB565: src 0x118 base 0x118 insns 70/70; diffs 0: []
|
||||
TMCJPEGDEC_converterYUV400toRGB565edge: src 0x14c base 0x14c insns 83/83; diffs 0: []
|
||||
No allocated non-code sections in either object
|
||||
main/libs/RVLMiddleware/TMC_JPEG/src/texturecvtr/Texture_MCUtoRGBA8 90.32323 -> 90.32323
|
||||
POOL IDENTICAL up to 0 (mine=0 base=0)
|
||||
TMCJPEGDEC_converterYUV400toRGBA8: src 0x130 base 0x130 insns 76/76; diffs 0: []
|
||||
TMCJPEGDEC_converterYUV400toRGBA8edge: src 0x164 base 0x164 insns 89/89; diffs 0: []
|
||||
No allocated non-code sections in either object
|
||||
34 owned function scores checked; 11 exact functions preserved; zero regressions
|
||||
26116613f624061ba99c8d1a299aaa6efa85670d build/43U/main.dol
|
||||
|
||||
TMCJPEGDEC_IFD0_tag_parse 131072 selector cases PASS
|
||||
TMCJPEGDEC_IFD1_tag_parse 131072 selector cases PASS
|
||||
TMCJPEGDEC_IFD0_tag_parse 132746 cases PASS; own-body instruction coverage 480 / 480 source; 481 / 481 original
|
||||
TMCJPEGDEC_IFD1_tag_parse 132704 cases PASS; own-body instruction coverage 239 / 239 source; 241 / 242 original
|
||||
TMCJPEGDEC_exif_parse 1832 cases PASS; own-body instruction coverage 212 / 212 source; 212 / 212 original
|
||||
TOTAL 267282 paired EXIF calls PASS
|
||||
|
||||
TMCJPEGDEC_converterYUV411toRGBA8: 100 cases PASS; instruction coverage source 242/242, original 242/242
|
||||
TMCJPEGDEC_converterYUV411toRGBA8edge: 400 cases PASS; instruction coverage source 112/112, original 112/112
|
||||
TMCJPEGDEC_converterYUV422toRGBA8: 100 cases PASS; instruction coverage source 148/148, original 148/148
|
||||
TMCJPEGDEC_converterYUV422toRGBA8edge: 400 cases PASS; instruction coverage source 113/113, original 113/113
|
||||
TMCJPEGDEC_converterYUV420toRGBA8: 100 cases PASS; instruction coverage source 153/153, original 153/153
|
||||
TMCJPEGDEC_converterYUV420toRGBA8edge: 400 cases PASS; instruction coverage source 120/120, original 120/120
|
||||
TMCJPEGDEC_converterYUV211toRGBA8: 100 cases PASS; instruction coverage source 104/104, original 104/104
|
||||
TMCJPEGDEC_converterYUV211toRGBA8edge: 400 cases PASS; instruction coverage source 115/115, original 115/115
|
||||
TMCJPEGDEC_converterYUV444toRGBA8: 100 cases PASS; instruction coverage source 97/97, original 97/97
|
||||
TMCJPEGDEC_converterYUV444toRGBA8edge: 400 cases PASS; instruction coverage source 110/110, original 110/110
|
||||
TMCJPEGDEC_converterYUV400toRGBA8: 100 cases PASS; instruction coverage source 57/76, original 57/76
|
||||
TMCJPEGDEC_converterYUV400toRGBA8edge: 400 cases PASS; instruction coverage source 70/89, original 70/89
|
||||
TMCJPEGDEC_set_converterRGBA8: 1024 cases PASS; instruction coverage source 168/169, original 169/170
|
||||
TMCJPEGDEC_converterYUV411toRGB565: 100 cases PASS; instruction coverage source 217/217, original 217/217
|
||||
TMCJPEGDEC_converterYUV411toRGB565edge: 400 cases PASS; instruction coverage source 106/106, original 106/106
|
||||
TMCJPEGDEC_converterYUV422toRGB565: 100 cases PASS; instruction coverage source 136/136, original 136/136
|
||||
TMCJPEGDEC_converterYUV422toRGB565edge: 400 cases PASS; instruction coverage source 107/107, original 107/107
|
||||
TMCJPEGDEC_converterYUV420toRGB565: 100 cases PASS; instruction coverage source 141/141, original 141/141
|
||||
TMCJPEGDEC_converterYUV420toRGB565edge: 400 cases PASS; instruction coverage source 114/114, original 114/114
|
||||
TMCJPEGDEC_converterYUV211toRGB565: 100 cases PASS; instruction coverage source 98/98, original 98/98
|
||||
TMCJPEGDEC_converterYUV211toRGB565edge: 400 cases PASS; instruction coverage source 109/109, original 109/109
|
||||
TMCJPEGDEC_converterYUV444toRGB565: 100 cases PASS; instruction coverage source 91/91, original 91/91
|
||||
TMCJPEGDEC_converterYUV444toRGB565edge: 400 cases PASS; instruction coverage source 104/104, original 104/104
|
||||
TMCJPEGDEC_converterYUV400toRGB565: 100 cases PASS; instruction coverage source 51/70, original 51/70
|
||||
TMCJPEGDEC_converterYUV400toRGB565edge: 400 cases PASS; instruction coverage source 64/83, original 64/83
|
||||
TMCJPEGDEC_set_converterRGB565: 1024 cases PASS; instruction coverage source 168/169, original 169/170
|
||||
TMCJPEGDEC_IdctBlock_Lumi: 704 cases PASS; instruction coverage source 257/257, original 257/257
|
||||
TMCJPEGDEC_IdctBlock_Col: 704 cases PASS; instruction coverage source 454/454, original 454/454
|
||||
TOTAL: 9456 differential cases PASS; GPR14-GPR31, stack pointer and LR preserved
|
||||
368
tools/decomp-assist/jpeg_exif_differential_audit.py
Normal file
368
tools/decomp-assist/jpeg_exif_differential_audit.py
Normal file
@@ -0,0 +1,368 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Read-only, bounded PPC integer interpreter for differential EXIF checks.
|
||||
Loads source and original ELF .text; never copies original code into sources.
|
||||
Only internal EXIF calls are supported. No FPU/system instructions are supported.
|
||||
"""
|
||||
import random
|
||||
import re
|
||||
import struct
|
||||
import zlib
|
||||
|
||||
import capstone
|
||||
from elftools.elf.elffile import ELFFile
|
||||
U32 = 0xFFFFFFFF
|
||||
|
||||
def signed(x):
|
||||
x &= U32
|
||||
return x - 0x100000000 if x & 0x80000000 else x
|
||||
|
||||
def rotate(x, n):
|
||||
return (x << n | x >> (32 - n if n else 32)) & U32
|
||||
|
||||
def mask(b, e):
|
||||
return sum((1 << 31 - i for i in range(32) if b <= i <= e or (b > e and (i >= b or i <= e))))
|
||||
|
||||
def load_object(path):
|
||||
with open(path, 'rb') as f:
|
||||
e = ELFFile(f)
|
||||
section = e.get_section_by_name('.text')
|
||||
data = bytearray(section.data())
|
||||
syms = e.get_section_by_name('.symtab')
|
||||
calls = {}
|
||||
symbol_addresses = {}
|
||||
rel = e.get_section_by_name('.rela.text')
|
||||
if rel:
|
||||
for r in rel.iter_relocations():
|
||||
name = syms.get_symbol(r['r_info_sym']).name
|
||||
off = r['r_offset']
|
||||
typ = r['r_info_type']
|
||||
addr = 0x800000 + (zlib.crc32(name.encode()) & 0x7FFF) * 4 + r['r_addend']
|
||||
assert addr not in symbol_addresses or symbol_addresses[addr] == name
|
||||
symbol_addresses[addr] = name
|
||||
if typ == 10:
|
||||
calls[off] = name
|
||||
elif typ == 4:
|
||||
data[off:off + 2] = struct.pack('>H', addr & 65535)
|
||||
elif typ == 6:
|
||||
data[off:off + 2] = struct.pack('>H', addr + 0x8000 >> 16 & 65535)
|
||||
else:
|
||||
raise ValueError(('relocation', typ))
|
||||
dis = capstone.Cs(capstone.CS_ARCH_PPC, capstone.CS_MODE_32 | capstone.CS_MODE_BIG_ENDIAN)
|
||||
funcs = {}
|
||||
for sym in syms.iter_symbols():
|
||||
if sym['st_info']['type'] != 'STT_FUNC' or not sym['st_size']:
|
||||
continue
|
||||
start = sym['st_value']
|
||||
size = sym['st_size']
|
||||
inst = {}
|
||||
for i in dis.disasm(bytes(data[start:start + size]), start):
|
||||
ops = []
|
||||
for o in i.op_str.split(', '):
|
||||
if not o:
|
||||
continue
|
||||
if o.startswith('cr'):
|
||||
ops.append(('cr', int(o[2:])))
|
||||
elif o.startswith('r'):
|
||||
ops.append(int(o[1:]))
|
||||
elif '(' in o:
|
||||
off, reg = o.split('(')
|
||||
ops.append((int(off, 0), int(reg[1:-1])))
|
||||
else:
|
||||
ops.append(int(o, 0))
|
||||
inst[i.address] = (i.mnemonic, ops)
|
||||
funcs[sym.name] = (start, inst, calls)
|
||||
return funcs
|
||||
|
||||
def run(functions, name, initial, args):
|
||||
pc = functions[name][0]
|
||||
ins = {address: instruction for _, body, _ in functions.values() for address, instruction in body.items()}
|
||||
calls = functions[name][2]
|
||||
mem = bytearray(initial)
|
||||
r = [i * 1122867 & U32 for i in range(32)]
|
||||
r[1] = 0x3F000
|
||||
r[3:3 + len(args)] = args
|
||||
saved_registers = r[14:].copy()
|
||||
cr = [0] * 8
|
||||
ctr = 0
|
||||
lr = 0
|
||||
steps = 0
|
||||
coverage = set()
|
||||
|
||||
def ld(a, n):
|
||||
assert 0 <= a <= len(mem) - n, hex(a)
|
||||
return int.from_bytes(mem[a:a + n], 'big')
|
||||
|
||||
def st(a, v, n):
|
||||
assert 0 <= a <= len(mem) - n, hex(a)
|
||||
mem[a:a + n] = (v & (1 << 8 * n) - 1).to_bytes(n, 'big')
|
||||
while True:
|
||||
steps += 1
|
||||
if steps > 100000:
|
||||
raise RuntimeError('step bound')
|
||||
coverage.add(pc)
|
||||
op, a = ins[pc]
|
||||
pc += 4
|
||||
dot = op.endswith('.')
|
||||
op = op.rstrip('.')
|
||||
val = None
|
||||
if op == 'blr':
|
||||
if lr == 0:
|
||||
break
|
||||
pc = lr
|
||||
elif op == 'bl':
|
||||
callee = calls.get(pc - 4)
|
||||
assert callee in functions, ('Unsupported external call', callee)
|
||||
lr = pc
|
||||
pc = functions[callee][0]
|
||||
elif op == 'b':
|
||||
pc = a[0]
|
||||
elif op == 'bdnz':
|
||||
ctr = ctr - 1 & U32
|
||||
if ctr:
|
||||
pc = a[0]
|
||||
elif op in ['beqlr', 'bnelr', 'blelr', 'bgelr', 'bltlr', 'bgtlr']:
|
||||
c = cr[a[0][1]] if a else cr[0]
|
||||
condition = {'beqlr': c == 0, 'bnelr': c != 0, 'blelr': c <= 0, 'bgelr': c >= 0, 'bltlr': c < 0, 'bgtlr': c > 0}[op]
|
||||
if condition:
|
||||
if lr == 0:
|
||||
break
|
||||
pc = lr
|
||||
elif op in ['beq', 'bne', 'ble', 'bge', 'blt', 'bgt']:
|
||||
c = cr[a[0][1]] if len(a) > 1 else cr[0]
|
||||
if {'beq': c == 0, 'bne': c != 0, 'ble': c <= 0, 'bge': c >= 0, 'blt': c < 0, 'bgt': c > 0}[op]:
|
||||
pc = a[-1]
|
||||
elif op in ['cmpwi', 'cmpw', 'cmplw', 'cmplwi']:
|
||||
c = a[0][1] if isinstance(a[0], tuple) else 0
|
||||
a = ins[pc - 4][1]
|
||||
if isinstance(a[0], tuple):
|
||||
a = a[1:]
|
||||
x = r[a[0]]
|
||||
y = a[1] if op in ['cmpwi', 'cmplwi'] else r[a[1]]
|
||||
if op not in ['cmplw', 'cmplwi']:
|
||||
x = signed(x)
|
||||
y = signed(y)
|
||||
cr[c] = (x > y) - (x < y)
|
||||
elif op in ['lbz', 'lhz', 'lwz', 'lmw']:
|
||||
off, reg = a[1]
|
||||
addr = (r[reg] if reg else 0) + off & U32
|
||||
if op == 'lmw':
|
||||
for j in range(a[0], 32):
|
||||
r[j] = ld(addr + (j - a[0]) * 4, 4)
|
||||
else:
|
||||
r[a[0]] = ld(addr, {'lbz': 1, 'lhz': 2, 'lwz': 4}[op])
|
||||
elif op in ['stb', 'sth', 'stw', 'stwu', 'stmw']:
|
||||
off, reg = a[1]
|
||||
addr = (r[reg] if reg else 0) + off & U32
|
||||
if op == 'stmw':
|
||||
for j in range(a[0], 32):
|
||||
st(addr + (j - a[0]) * 4, r[j], 4)
|
||||
else:
|
||||
st(addr, r[a[0]], {'stb': 1, 'sth': 2, 'stw': 4, 'stwu': 4}[op])
|
||||
if op == 'stwu':
|
||||
r[reg] = addr
|
||||
elif op in ['stbx', 'sthx']:
|
||||
st((r[a[1]] if a[1] else 0) + r[a[2]] & U32, r[a[0]], 1 if op == 'stbx' else 2)
|
||||
elif op == 'mflr':
|
||||
r[a[0]] = lr
|
||||
elif op == 'mtlr':
|
||||
lr = r[a[0]]
|
||||
elif op == 'mtctr':
|
||||
ctr = r[a[0]]
|
||||
else:
|
||||
d = a[0]
|
||||
if op == 'li':
|
||||
val = a[1]
|
||||
elif op == 'lis':
|
||||
val = a[1] << 16
|
||||
elif op == 'mr':
|
||||
val = r[a[1]]
|
||||
elif op == 'add':
|
||||
val = r[a[1]] + r[a[2]]
|
||||
elif op == 'addi':
|
||||
val = (r[a[1]] if a[1] else 0) + a[2]
|
||||
elif op == 'addis':
|
||||
val = (r[a[1]] if a[1] else 0) + (a[2] << 16)
|
||||
elif op == 'subf':
|
||||
val = r[a[2]] - r[a[1]]
|
||||
elif op == 'subfic':
|
||||
val = a[2] - r[a[1]]
|
||||
elif op == 'mulli':
|
||||
val = r[a[1]] * a[2]
|
||||
elif op == 'mullw':
|
||||
val = r[a[1]] * r[a[2]]
|
||||
elif op == 'divw':
|
||||
x = signed(r[a[1]])
|
||||
y = signed(r[a[2]])
|
||||
val = abs(x) // abs(y) * (-1 if (x < 0) != (y < 0) else 1)
|
||||
elif op == 'or':
|
||||
val = r[a[1]] | r[a[2]]
|
||||
elif op == 'andc':
|
||||
val = r[a[1]] & ~r[a[2]]
|
||||
elif op == 'andi':
|
||||
val = r[a[1]] & a[2]
|
||||
elif op == 'neg':
|
||||
val = -r[a[1]]
|
||||
elif op == 'extsb':
|
||||
val = (r[a[1]] & 255) - (256 if r[a[1]] & 128 else 0)
|
||||
elif op == 'srawi':
|
||||
val = signed(r[a[1]]) >> a[2]
|
||||
elif op == 'srwi':
|
||||
val = r[a[1]] >> a[2]
|
||||
elif op == 'slwi':
|
||||
val = r[a[1]] << a[2]
|
||||
elif op == 'clrlwi':
|
||||
val = r[a[1]] & (1 << 32 - a[2]) - 1
|
||||
elif op == 'rotlwi':
|
||||
val = rotate(r[a[1]], a[2])
|
||||
elif op == 'rlwimi':
|
||||
bits = mask(a[3], a[4])
|
||||
val = (r[d] & ~bits) | (rotate(r[a[1]], a[2]) & bits)
|
||||
elif op == 'rlwinm':
|
||||
val = rotate(r[a[1]], a[2]) & mask(a[3], a[4])
|
||||
else:
|
||||
raise ValueError((hex(pc - 4), op, a))
|
||||
r[d] = val & U32
|
||||
if dot:
|
||||
cr[0] = (signed(val) > 0) - (signed(val) < 0)
|
||||
assert r[1] == 0x3F000, 'Stack pointer not restored'
|
||||
assert lr == 0, 'Link register not restored'
|
||||
assert r[14:] == saved_registers, 'Nonvolatile registers not restored'
|
||||
return (mem, r[3], coverage)
|
||||
|
||||
def put(m, a, v, n=4):
|
||||
m[a:a + n] = (v & (1 << 8 * n) - 1).to_bytes(n, 'big')
|
||||
|
||||
def compare(src, orig, name, m, args, case, returns=False):
|
||||
a, ra, ca = run(src, name, m, args)
|
||||
b, rb, cb = run(orig, name, m, args)
|
||||
# The stack can differ because each implementation owns its frame.
|
||||
if a[:0x3E000] != b[:0x3E000]:
|
||||
diff = [hex(i) for i in range(0x3E000) if a[i] != b[i]][:12]
|
||||
raise AssertionError((name, case, 'memory mismatch', diff))
|
||||
if returns and ra != rb:
|
||||
raise AssertionError((name, case, 'return', ra, rb))
|
||||
return (ca, cb)
|
||||
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
from collections import defaultdict
|
||||
path = 'build/43U/{}/libs/RVLMiddleware/TMC_JPEG/src/exif/exif_parse.o'
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--source-object', default=path.format('src'))
|
||||
parser.add_argument('--target-object', default=path.format('obj'))
|
||||
parser.add_argument('--overlap-only', action='store_true')
|
||||
args = parser.parse_args()
|
||||
src = load_object(args.source_object)
|
||||
orig = load_object(args.target_object)
|
||||
assert src.keys() == orig.keys()
|
||||
assert len(src) == 6
|
||||
names = ['TMCJPEGDEC_IFD0_tag_parse', 'TMCJPEGDEC_IFD1_tag_parse', 'TMCJPEGDEC_exif_parse']
|
||||
coverage = {name: [set(), set()] for name in names}
|
||||
counts = defaultdict(int)
|
||||
rng = random.Random(449529)
|
||||
info, entry, data = 0x1000, 0x2000, 0x3000
|
||||
memory = bytearray([0xA5]) * 0x40000
|
||||
memory[data:data + 0x2000] = bytes(rng.randrange(256) for _ in range(0x2000))
|
||||
put(memory, info + 0x674, data)
|
||||
put(memory, info + 0x678, data + 0x1000)
|
||||
|
||||
def exif_put(m, pos, value, size, order):
|
||||
m[pos:pos + size] = (value & ((1 << (8 * size)) - 1)).to_bytes(size, 'little' if order == 0x4949 else 'big')
|
||||
|
||||
def check(name, m, args, case, returns=False):
|
||||
ca, cb = compare(src, orig, name, m, args, case, returns)
|
||||
coverage[name][0].update(ca)
|
||||
coverage[name][1].update(cb)
|
||||
counts[name] += 1
|
||||
|
||||
for order in [0x4949, 0x4D4D]:
|
||||
for tag, offset in [(0x9000, 0x63C), (0x9101, 0x640), (0xA000, 0x644)]:
|
||||
for delta in range(-3, 4):
|
||||
m = bytearray(memory)
|
||||
destination = info + offset
|
||||
aliased_entry = destination + delta - 8
|
||||
exif_put(m, aliased_entry, tag, 2, order)
|
||||
m[aliased_entry + 8:aliased_entry + 12] = bytes([1, 2, 3, 4])
|
||||
check(names[0], m, [info, order, aliased_entry], ('overlapping-version-bytes', order, tag, delta))
|
||||
|
||||
if args.overlap_only:
|
||||
print('TOTAL', sum(counts.values()), 'overlapping version-byte calls PASS')
|
||||
return
|
||||
|
||||
for name in names[:2]:
|
||||
selector_start = counts[name]
|
||||
for order in [0x4949, 0x4D4D]:
|
||||
exif_put(memory, entry + 2, 4, 2, order)
|
||||
exif_put(memory, entry + 4, 1, 4, order)
|
||||
exif_put(memory, entry + 8, 0x100, 4, order)
|
||||
for tag in range(0x10000):
|
||||
exif_put(memory, entry, tag, 2, order)
|
||||
check(name, memory, [info, order, entry], ('all-tags', order, tag))
|
||||
print(name, counts[name] - selector_start, 'selector cases PASS', flush=True)
|
||||
for order in [0x4949, 0x4D4D]:
|
||||
for tag in [0x103, 0x112, 0x11A, 0x11B, 0x128, 0x12D, 0x132, 0x201, 0x202, 0x213, 0x8769, 0x9000, 0x9101, 0xA000, 0xA001, 0xA002, 0xA003]:
|
||||
exif_put(memory, entry, tag, 2, order)
|
||||
for field_type in [0, 3, 4, 0xFFFF]:
|
||||
exif_put(memory, entry + 2, field_type, 2, order)
|
||||
for offset in [0, 1, 0xFF0, 0xFEC, 0xFF8, 0xFFC, 0xFFE, 0xFFF, 0x1000, 0x1001, 0xFFFFFFFF, 0xFFFFD000]:
|
||||
exif_put(memory, entry + 8, offset, 4, order)
|
||||
check(name, memory, [info, order, entry], ('bounds', order, tag, field_type, offset))
|
||||
|
||||
name = names[2]
|
||||
for order in [0x4949, 0x4D4D, 0, 0x1234]:
|
||||
for size in [0, 1, 7, 8, 9, 10, 13, 14, 25, 26, 40, 64, 128, 0x1000]:
|
||||
for ifd_offset in [0, 2, 8, 10, 0x1000, 0xFFFFFFFF]:
|
||||
for count in [0, 1, 2, 0xFFFF]:
|
||||
m = bytearray(memory)
|
||||
m[data:data + 0x1000] = bytes(0x1000)
|
||||
exif_put(m, data, order, 2, order)
|
||||
exif_put(m, data + 2, 42, 2, order)
|
||||
exif_put(m, data + 4, ifd_offset, 4, order)
|
||||
if 8 <= ifd_offset < 0x1000:
|
||||
exif_put(m, data + ifd_offset, count, 2, order)
|
||||
check(name, m, [data, size, info], ('header-bounds', order, size, ifd_offset, count), True)
|
||||
|
||||
for order in [0x4949, 0x4D4D]:
|
||||
for magic in [0, 41, 43, 0xFFFF]:
|
||||
m = bytearray(memory)
|
||||
exif_put(m, data, order, 2, order)
|
||||
exif_put(m, data + 2, magic, 2, order)
|
||||
check(name, m, [data, 128, info], ('invalid-TIFF-magic', order, magic), True)
|
||||
|
||||
for order in [0x4949, 0x4D4D]:
|
||||
for count0 in [0, 1, 2, 3]:
|
||||
for count1 in [0, 1, 2, 3]:
|
||||
for size in [40, 64, 65, 66, 70, 79, 80, 100, 128, 129, 130, 140, 144, 160, 256]:
|
||||
m = bytearray(memory)
|
||||
m[data:data + 0x1000] = bytes(0x1000)
|
||||
exif_put(m, data, order, 2, order)
|
||||
exif_put(m, data + 2, 42, 2, order)
|
||||
exif_put(m, data + 4, 8, 4, order)
|
||||
exif_put(m, data + 8, count0, 2, order)
|
||||
for index, tag in enumerate([0x112, 0xA002, 0x8769][:count0]):
|
||||
pos = data + 10 + index * 12
|
||||
exif_put(m, pos, tag, 2, order)
|
||||
exif_put(m, pos + 2, 4, 2, order)
|
||||
exif_put(m, pos + 8, 128 if tag == 0x8769 else 3, 4, order)
|
||||
exif_put(m, data + 10 + count0 * 12, 64, 4, order)
|
||||
exif_put(m, data + 64, count1, 2, order)
|
||||
for index, tag in enumerate([0x103, 0x201, 0x202][:count1]):
|
||||
pos = data + 66 + index * 12
|
||||
exif_put(m, pos, tag, 2, order)
|
||||
exif_put(m, pos + 2, 4, 2, order)
|
||||
exif_put(m, pos + 8, 6, 4, order)
|
||||
exif_put(m, data + 128, 1, 2, order)
|
||||
exif_put(m, data + 130, 0xA003, 2, order)
|
||||
exif_put(m, data + 132, 4, 2, order)
|
||||
exif_put(m, data + 138, 640, 4, order)
|
||||
check(name, m, [data, size, info], ('directory-chain', order, count0, count1, size), True)
|
||||
|
||||
for name in names:
|
||||
source_body = set(src[name][1])
|
||||
original_body = set(orig[name][1])
|
||||
print(name, counts[name], 'cases PASS; own-body instruction coverage', len(coverage[name][0] & source_body), '/', len(source_body), 'source;', len(coverage[name][1] & original_body), '/', len(original_body), 'original', flush=True)
|
||||
print('TOTAL', sum(counts.values()), 'paired EXIF calls PASS')
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
51
tools/decomp-assist/run-fixed-stack.attempts.md
Normal file
51
tools/decomp-assist/run-fixed-stack.attempts.md
Normal file
@@ -0,0 +1,51 @@
|
||||
# Run fixed-stack relocation correction
|
||||
|
||||
This is a narrow follow-up to #973, not another Run implementation or a new
|
||||
match. The existing assembly, cache loop, register clearing, labels and handoff
|
||||
remain intact. No linking flag changes.
|
||||
|
||||
## Evidence
|
||||
|
||||
The hash-verified original DOL and linked ELF contain Run at 0x8137B3EC,
|
||||
size 0xAC (43 instructions). Its instructions at 0x8137B468/0x8137B46C establish
|
||||
SP as 0x81600000. This architectural stack value should not depend on placement
|
||||
of an unrelated formatted-output routine.
|
||||
|
||||
Automatic extraction had attached two relocations to __pformatter + 0x280:
|
||||
R_PPC_ADDR16_HI at Run+0x7E and R_PPC_ADDR16_LO at Run+0x82. The linked formatter
|
||||
address happens to make this expression equal 0x81600000 in this target, but
|
||||
that is a false semantic dependency in the reconstruction.
|
||||
|
||||
DTK block_relocations uses instruction addresses, not ELF halfword offsets.
|
||||
The two exclusions are therefore .text:0x8137B468 and .text:0x8137B46C.
|
||||
The source removes the unrelated extern and uses the fixed high/low immediate.
|
||||
No other source instructions or original bytes are replaced.
|
||||
|
||||
## Independent validation
|
||||
|
||||
- Full 43U all_source, progress, report and DOL check pass.
|
||||
- Original app and rebuilt DOL SHA1 both remain
|
||||
26116613f624061ba99c8d1a299aaa6efa85670d.
|
||||
- Run remains 100%, 43/43 instructions, ctxdiff zero. No new match attribution.
|
||||
- Whole report is unchanged: no code, data, function, linking or fuzzy delta.
|
||||
- Pool: all 91 strings identical.
|
||||
- All 1027 native source objects compared: only BS2Mach .text changes; size
|
||||
16960 is unchanged. Exactly the two false text relocations are removed.
|
||||
All other allocated objects and data sections are unchanged.
|
||||
- All 1027 active extracted objects compared, plus the same obsolete cached
|
||||
tiManager.o in both trees. Only BS2Mach .text changes: size 16980 unchanged;
|
||||
only Run's high immediate placeholder bytes at +0x7E/+0x7F become 0x81,0x60.
|
||||
Exactly the two formatter relocations disappear, with no added relocations.
|
||||
Defined target symbols and non-text sections stay unchanged.
|
||||
- Supplemental integer-PPC contract model checks the compiled source for 1,
|
||||
4 and 131072 cache lines, preserved LR entry, SP 0x81600000, cleared GPRs and
|
||||
alternating dcbz/dcbf events. The zero-count prefix retains the original CTR
|
||||
wrap to 0xFFFFFFFF; the full 2^32-iteration path is not executed. This is an
|
||||
abstract contract test, not actual cache/MMIO or console execution.
|
||||
- Workflow/literal/jump-table/pool tests: 8/36/27/8 passed.
|
||||
- Diff check passes.
|
||||
|
||||
Assembly was already introduced by #973. The original isolated full-Run
|
||||
experiment is deliberately not included here. This correction adds no new
|
||||
assembly instructions, forced register uses, retail .s objects or padding.
|
||||
Please review the metadata/source constant attribution explicitly.
|
||||
63
tools/progress_badges.py
Normal file
63
tools/progress_badges.py
Normal file
@@ -0,0 +1,63 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Write shields.io endpoint JSON files from an objdiff report.
|
||||
|
||||
usage: progress_badges.py <report.json> <out-dir>
|
||||
|
||||
The README badges read these files from the progress-data branch, so the
|
||||
numbers update without committing to main.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
COLOR = "33b8ff"
|
||||
DONE_COLOR = "brightgreen"
|
||||
|
||||
|
||||
def badge(label, message, done):
|
||||
return {
|
||||
"schemaVersion": 1,
|
||||
"label": label,
|
||||
"message": message,
|
||||
"color": DONE_COLOR if done else COLOR,
|
||||
"labelColor": "7c7c7c",
|
||||
"style": "plastic",
|
||||
}
|
||||
|
||||
|
||||
def percent(measures, key):
|
||||
value = float(measures.get(key) or 0.0)
|
||||
return f"{value:.2f}%", value >= 100.0
|
||||
|
||||
|
||||
def count(measures, done_key, total_key):
|
||||
done = int(measures.get(done_key) or 0)
|
||||
total = int(measures.get(total_key) or 0)
|
||||
return f"{done:,} / {total:,}", total > 0 and done == total
|
||||
|
||||
|
||||
def main():
|
||||
if len(sys.argv) != 3:
|
||||
raise SystemExit(__doc__)
|
||||
report_path, out_dir = sys.argv[1], sys.argv[2]
|
||||
measures = json.load(open(report_path))["measures"]
|
||||
|
||||
badges = {
|
||||
"decompiled": ("Decompiled", percent(measures, "fuzzy_match_percent")),
|
||||
"matched": ("Matched", percent(measures, "matched_code_percent")),
|
||||
"linked": ("Linked", percent(measures, "complete_code_percent")),
|
||||
"data": ("Data", percent(measures, "matched_data_percent")),
|
||||
"functions": ("Functions", count(measures, "matched_functions", "total_functions")),
|
||||
"units": ("Units", count(measures, "complete_units", "total_units")),
|
||||
}
|
||||
|
||||
os.makedirs(out_dir, exist_ok=True)
|
||||
for name, (label, (message, done)) in badges.items():
|
||||
with open(os.path.join(out_dir, f"{name}.json"), "w", encoding="utf-8") as f:
|
||||
json.dump(badge(label, message, done), f)
|
||||
f.write("\n")
|
||||
print(f"{label}: {message}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user