Compare commits
1 Commits
agent/bitt
...
cdb-clean
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9e76cabe2f |
@@ -53,9 +53,9 @@ Progress
|
||||
<!-- progress:start -->
|
||||
| Decompiled | Matched | Linked | Data |
|
||||
|:---:|:---:|:---:|:---:|
|
||||
| 99.59% | 91.16% | 74.57% | 99.56% |
|
||||
| 99.59% | 91.12% | 74.40% | 99.42% |
|
||||
|
||||
units 964/1027 complete, functions 12378/12563 matched.
|
||||
units 963/1027 complete, functions 12376/12563 matched.
|
||||
|
||||
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 -->
|
||||
|
||||
@@ -1299,7 +1299,7 @@ config.libs = [
|
||||
Object(Matching, "ut/ut_RomFont.cpp"),
|
||||
Object(Matching, "ut/ut_ResFontBase.cpp"),
|
||||
Object(Matching, "ut/ut_ResFont.cpp"),
|
||||
Object(Matching, "ut/ut_ArchiveFontBase.cpp"),
|
||||
Object(NonMatching, "ut/ut_ArchiveFontBase.cpp"),
|
||||
Object(Matching, "ut/ut_ArchiveFont.cpp"),
|
||||
Object(Matching, "ut/ut_CharWriter.cpp"),
|
||||
Object(Matching, "ut/ut_TextWriterBase.cpp"),
|
||||
|
||||
@@ -252,17 +252,14 @@ namespace nw4r {
|
||||
}
|
||||
|
||||
inline void updateSheetFlags(const void* glgrHdr, u32 groupIdx, u16* sheetOffsets, u32 flagsStep, const u32* sheetFlags) {
|
||||
const GlyphGroups* glgr = (const GlyphGroups*)((const u8*)glgrHdr + sizeof(BinaryBlockHeader));
|
||||
int sheetIndex;
|
||||
u32 groupBitOffset;
|
||||
u16* sheetOffset = sheetOffsets;
|
||||
groupBitOffset = groupIdx * flagsStep * 8;
|
||||
for (sheetIndex = 0; sheetIndex < glgr->sheetCount; sheetOffset++, sheetIndex++) {
|
||||
u32 groupBitIdx = sheetIndex + groupBitOffset;
|
||||
const GlyphGroups* glgr = (GlyphGroups*)((u8*)glgrHdr + sizeof(BinaryBlockHeader));
|
||||
for (int sheetI = 0; sheetI < glgr->sheetCount; sheetI++) {
|
||||
u32 groupBitIdx = sheetI + groupIdx * flagsStep * 8;
|
||||
|
||||
const u32* bitBlockPtr = sheetFlags + (groupBitIdx & ~0x1F) / 32;
|
||||
u32 bitBlock = *bitBlockPtr;
|
||||
u32 bitBlock = *(u32*)bitBlockPtr;
|
||||
if (((bitBlock << (groupBitIdx & 0x1F)) & 0x80000000) != 0) {
|
||||
*sheetOffset = 1;
|
||||
sheetOffsets[sheetI] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -271,16 +268,14 @@ namespace nw4r {
|
||||
const u32* bitBlocksPtr, u32 sheetFlagsSize) {
|
||||
HeaderedGlyphGroups* pGlgr = (HeaderedGlyphGroups*)glgrHdr;
|
||||
|
||||
int i;
|
||||
u16* sheetOffset;
|
||||
for (i = 0, sheetOffset = sheetOffsets; i < pGlgr->inner.sheetCount; sheetOffset++, i++) {
|
||||
*sheetOffset = 0;
|
||||
for (int i = 0; i < pGlgr->inner.sheetCount; i++) {
|
||||
sheetOffsets[i] = 0;
|
||||
}
|
||||
|
||||
for (int i = 0; i < pGlgr->inner.nameCount; i++) {
|
||||
const char* includedGroups = ctx->pIncludedGroups;
|
||||
u16 offset = pGlgr->inner.nameOffsets[i];
|
||||
char* name = (char*)(offset + (u32)hdr);
|
||||
char* name = (char*)((u8*)hdr + offset);
|
||||
if (*includedGroups != 0) {
|
||||
if (!ArchiveFontBase::IncludeName(includedGroups, name)) {
|
||||
continue;
|
||||
@@ -293,23 +288,21 @@ namespace nw4r {
|
||||
|
||||
inline void convertSheetOffsetBooleansToOffsets(const void* glgrHdr, u16* sheetOffsets) {
|
||||
HeaderedGlyphGroups* pGlgr = (HeaderedGlyphGroups*)glgrHdr;
|
||||
int i;
|
||||
u16 glyphIdxOffset = 0;
|
||||
u16* sheetOffset;
|
||||
for (i = 0, sheetOffset = sheetOffsets; i < pGlgr->inner.sheetCount; sheetOffset++, i++) {
|
||||
if (*sheetOffset == 1) {
|
||||
*sheetOffset = glyphIdxOffset;
|
||||
for (int i = 0; i < pGlgr->inner.sheetCount; i++) {
|
||||
if (sheetOffsets[i] == 1) {
|
||||
sheetOffsets[i] = glyphIdxOffset;
|
||||
} else {
|
||||
*sheetOffset = -1;
|
||||
sheetOffsets[i] = -1;
|
||||
glyphIdxOffset += pGlgr->inner.sheetGlyphCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline void copyFlagOffsets(ArchiveFontBase::ConstructContext* ctx, u16* sheetOffsetsScratch, u32 workSize, const u16* sheetOffsetsScratchEnd) {
|
||||
inline void copyFlagOffsets(ArchiveFontBase::ConstructContext* ctx, u16* sheetOffsetsScratch, u32 workSize, u32 scratchSize) {
|
||||
u8* sheetOffsets = ctx->pWorkCurr;
|
||||
ctx->pWorkCurr = sheetOffsets + workSize;
|
||||
memmove(sheetOffsets, sheetOffsetsScratch, (sheetOffsetsScratchEnd - sheetOffsetsScratch) * sizeof(u16));
|
||||
memmove(sheetOffsets, sheetOffsetsScratch, scratchSize);
|
||||
ctx->pSheetOffsets = (u16*)sheetOffsets;
|
||||
}
|
||||
|
||||
@@ -318,64 +311,31 @@ namespace nw4r {
|
||||
// *sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)fontData + remWorkSpace) - sheetOffsetsSize, 2);
|
||||
// return sheetOffsetsSize;
|
||||
// }
|
||||
class FontGlyphGroupsAcs {
|
||||
public:
|
||||
explicit FontGlyphGroupsAcs(const ArchiveFontBinaryLayout* font)
|
||||
: mFont(font), mGroups(&font->glgr) {}
|
||||
const GlyphGroups& GetGroups() const { return mGroups->inner; }
|
||||
void SetSheetFlags(u32 flagsStep, const u32* sheetFlags) {
|
||||
mFlagsStep = flagsStep;
|
||||
mSheetFlags = sheetFlags;
|
||||
}
|
||||
|
||||
u16 GetNumSheet() const { return mGroups->inner.sheetCount; }
|
||||
int GetGlyphsPerSheet() const { return mGroups->inner.sheetGlyphCount; }
|
||||
u16 GetNumSet() const { return mGroups->inner.nameCount; }
|
||||
const char* GetSetName(int groupIndex) const {
|
||||
const u16 nameOffset = mGroups->inner.nameOffsets[groupIndex];
|
||||
return (const char*)(nameOffset + (u32)mFont);
|
||||
}
|
||||
bool IsUseSheet(int groupIndex, int sheetIndex) const {
|
||||
const u32 groupBitIndex = sheetIndex + groupIndex * mFlagsStep * 8;
|
||||
const u32* bitBlock = mSheetFlags + (groupBitIndex & ~0x1F) / 32;
|
||||
return ((*bitBlock << (groupBitIndex & 0x1F)) & 0x80000000) != 0;
|
||||
}
|
||||
|
||||
private:
|
||||
const ArchiveFontBinaryLayout* mFont;
|
||||
const HeaderedGlyphGroups* mGroups;
|
||||
u32 mFlagsStep;
|
||||
const u32* mSheetFlags;
|
||||
};
|
||||
|
||||
ArchiveFontBase::ConstructState ArchiveFontBase::ConstructOpAnalyzeGLGR(ConstructContext* ctx, CachedStreamReader* reader) {
|
||||
const u32* flagsSheets;
|
||||
u32 sheetOffsetsSize;
|
||||
u32 flagsSheetsOff;
|
||||
u32 glgrInnerLen;
|
||||
const ArchiveFontBinaryLayout* font;
|
||||
u16 sheetGlyphCount;
|
||||
u32 countSheet;
|
||||
HeaderedGlyphGroups* pGlgr;
|
||||
const ArchiveFontBinaryLayout* font;
|
||||
u8* glgrEnd;
|
||||
|
||||
u32 expectedMaxSize;
|
||||
u32 dataBlockCount;
|
||||
u16* sheetOffsetsScratch;
|
||||
int groupIndex;
|
||||
|
||||
font = (ArchiveFontBinaryLayout*)ctx->pWorkCurr;
|
||||
|
||||
glgrInnerLen = ctx->mNextBlockHdr.size - sizeof(BinaryBlockHeader);
|
||||
|
||||
// Check for RFNA
|
||||
if (font->hdr.signature != SIGNATURE_FONT_ARCHIVE) {
|
||||
return CONSTRUCT_STATE_FATAL_ERR;
|
||||
}
|
||||
|
||||
// Check that there's enough data available, and the space to
|
||||
// put that data
|
||||
ENSURE_READER_HAS_SIZE(ctx, reader, glgrInnerLen);
|
||||
ENSURE_WORK_HAS_SIZE(ctx, glgrInnerLen);
|
||||
|
||||
expectedMaxSize = ctx->mNextBlockHdr.size + sizeof(BinaryFileHeader);
|
||||
|
||||
// Copy the glgr to work
|
||||
{
|
||||
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
|
||||
glgrEnd = (u8*)pGlgr + (u32)ctx->mNextBlockHdr.size;
|
||||
@@ -388,45 +348,80 @@ namespace nw4r {
|
||||
return CONSTRUCT_STATE_FATAL_ERR;
|
||||
}
|
||||
|
||||
FontGlyphGroupsAcs gg(font);
|
||||
sheetGlyphCount = gg.GetGlyphsPerSheet();
|
||||
dataBlockCount = font->hdr.dataBlocks;
|
||||
countSheet = gg.GetNumSheet();
|
||||
const u32 stepSheetFlags = detail::CalcSizeFlagSet(countSheet);
|
||||
flagsSheetsOff = detail::CalcOffsetSheetFlags(gg.GetGroups().nameCount, countSheet, gg.GetGroups().smthCount_0x0a,
|
||||
gg.GetGroups().smthCount_0x0c);
|
||||
flagsSheets = (const u32*)((flagsSheetsOff & ~3) + (u32)font);
|
||||
gg.SetSheetFlags(stepSheetFlags, flagsSheets);
|
||||
// Before here is fine (other than regswaps)
|
||||
// u16 sheetGlyphCount = FORCE_REACCESS_2(font->glgr.inner.sheetGlyphCount, u16); // 0x1C
|
||||
// u16 dataBlockCount = FORCE_REACCESS_2(font->hdr.dataBlocks, u16); // 0x0E
|
||||
// FORCE_REACCESS_2(font->glgr.inner.sheetCount, u16);
|
||||
// return ConstructOpAnalyzeGLGRInner(ctx, font, pGlgr, glgrEnd);
|
||||
|
||||
sheetOffsetsSize = (RoundUp)(countSheet * sizeof(u16), 4);
|
||||
// u32 fontSizeToEndOfGlgr;
|
||||
|
||||
u16 countSheet;
|
||||
u16 sheetGlyphCount, dataBlockCount;
|
||||
|
||||
u32 stepSheetFlags;
|
||||
u32 flagsSheetsOff;
|
||||
const u32* flagsSheets;
|
||||
|
||||
u32 sheetOffsetsSize;
|
||||
u16* sheetOffsetsScratch;
|
||||
|
||||
u32 sheetOffsetsScratchSize;
|
||||
|
||||
sheetGlyphCount = font->glgr.inner.sheetGlyphCount; // 0x1C
|
||||
dataBlockCount = font->hdr.dataBlocks; // 0x0E
|
||||
// countName = font->glgr.inner.nameCount;
|
||||
countSheet = font->glgr.inner.sheetCount;
|
||||
// count0A = font->glgr.inner.smthCount_0x0a;
|
||||
// count0C = font->glgr.inner.smthCount_0x0c;
|
||||
stepSheetFlags = detail::CalcSizeFlagSet(countSheet);
|
||||
flagsSheetsOff = detail::CalcOffsetSheetFlags(font->glgr.inner.nameCount, countSheet, font->glgr.inner.smthCount_0x0a,
|
||||
font->glgr.inner.smthCount_0x0c);
|
||||
flagsSheets = (const u32*)font + (flagsSheetsOff >> 2);
|
||||
|
||||
sheetOffsetsSize = ROUNDUP(countSheet * sizeof(u16), 4);
|
||||
sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)font + ctx->remWorkSpace()) - sheetOffsetsSize, 2);
|
||||
|
||||
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
|
||||
ENSURE_WORK_HAS_SIZE(ctx, glgrEnd - (u8*)font + sheetOffsetsSize);
|
||||
// if (ctx->pWorkEnd - workCurr < fontSizeToEndOfGlgr + sheetOffsetsSize) {
|
||||
// return CONSTRUCT_STATE_FATAL_ERR;
|
||||
// }
|
||||
|
||||
{
|
||||
u16* sheetOffset;
|
||||
int sheetIndex;
|
||||
for (sheetIndex = 0, sheetOffset = sheetOffsetsScratch; sheetIndex < gg.GetNumSheet(); sheetOffset++, sheetIndex++) {
|
||||
*sheetOffset = 0;
|
||||
}
|
||||
for (groupIndex = 0; groupIndex < gg.GetNumSet(); groupIndex++) {
|
||||
const char* includedGroups = ctx->pIncludedGroups;
|
||||
const char* name = gg.GetSetName(groupIndex);
|
||||
if (*includedGroups && !ArchiveFontBase::IncludeName(includedGroups, name)) {
|
||||
continue;
|
||||
}
|
||||
for (int sheetIndex = 0; sheetIndex < gg.GetNumSheet(); sheetIndex++) {
|
||||
if (gg.IsUseSheet(groupIndex, sheetIndex)) {
|
||||
sheetOffsetsScratch[sheetIndex] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Clear sheet offsets scratch
|
||||
// for (s32 i = 0; i < pGlgr->inner.sheetCount; i++) {
|
||||
// sheetOffsetsScratch[i] = 0;
|
||||
// }
|
||||
|
||||
// for (s32 i = 0; i < pGlgr->inner.nameCount; i++) {
|
||||
// // const char* includedGroups = ctx->pIncludedGroups;
|
||||
// u16 offset = pGlgr->inner.nameOffsets[i];
|
||||
// const char* name = (char*)((u8*)font + offset);
|
||||
// if (*ctx->pIncludedGroups != 0) {
|
||||
// if (!ArchiveFontBase::IncludeName(ctx->pIncludedGroups, name)) {
|
||||
// continue;
|
||||
// }
|
||||
// }
|
||||
|
||||
// updateSheetFlags(pGlgr, i, sheetOffsetsScratch, stepSheetFlags, flagsSheets);
|
||||
// }
|
||||
setSheetOffsetBooleans(ctx, pGlgr, font, sheetOffsetsScratch, flagsSheets, stepSheetFlags);
|
||||
|
||||
// u16 glyphIdxOffset = 0;
|
||||
// for (s32 i = 0; i < pGlgr->inner.sheetCount; i++) {
|
||||
// if (sheetOffsetsScratch[i] == 1) {
|
||||
// sheetOffsetsScratch[i] = glyphIdxOffset;
|
||||
// } else {
|
||||
// sheetOffsetsScratch[i] = -1;
|
||||
// glyphIdxOffset += pGlgr->inner.sheetGlyphCount;
|
||||
// }
|
||||
// }
|
||||
convertSheetOffsetBooleansToOffsets(pGlgr, sheetOffsetsScratch);
|
||||
|
||||
copyFlagOffsets(ctx, sheetOffsetsScratch, sheetOffsetsSize, sheetOffsetsScratch + (u16)countSheet);
|
||||
sheetOffsetsScratchSize = (u32)countSheet << 1;
|
||||
sheetOffsetsScratchSize += (sheetOffsetsScratchSize >> 31);
|
||||
sheetOffsetsScratchSize &= ~1;
|
||||
copyFlagOffsets(ctx, sheetOffsetsScratch, sheetOffsetsSize, sheetOffsetsScratchSize);
|
||||
|
||||
ctx->mSheetCount = countSheet;
|
||||
ctx->mGlyphsPerSheet = sheetGlyphCount;
|
||||
|
||||
@@ -7717,27 +7717,30 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
|
||||
CHANSVmObjHdr* pAcc;
|
||||
CHANSVmExecutionCtx* ctx;
|
||||
CHANSVmModule* dbg;
|
||||
CHANSVmErr loadResult;
|
||||
opSize = 3;
|
||||
operandBuf = VmGetOperand(vm, 1, 3);
|
||||
if (operandBuf == vmNull) {
|
||||
return CHANS_VM_ERR_CODE_RANGE;
|
||||
}
|
||||
pAcc = &pVm->accumulator;
|
||||
loadResult = CHANSVmDeleteObject(vm, pAcc);
|
||||
if (loadResult == CHANS_VM_OK) {
|
||||
result = CHANSVmDeleteObject(vm, pAcc);
|
||||
if (result == CHANS_VM_OK) {
|
||||
imm16Val = VM_READ_BE_U16(operandBuf, 0);
|
||||
ctx = pVm->pActiveCtx;
|
||||
dbg = ctx->pDbg;
|
||||
if (imm16Val >= dbg->stringCount || dbg->pStringTbl[imm16Val].pStringData == vmNull) {
|
||||
loadResult = CHANS_VM_ERR_LOAD_STRING_CONST;
|
||||
} else {
|
||||
pAcc->type = CHANS_VM_OBJ_TYPE_STRING;
|
||||
pAcc->hasData = vmTrue;
|
||||
pAcc->value.wstring_v = (vmWStringObjVal*)&ctx->pDbg->pStringTbl[imm16Val];
|
||||
if (imm16Val < dbg->stringCount) {
|
||||
if (dbg->pStringTbl[imm16Val].pStringData != vmNull) {
|
||||
goto load_str_ok;
|
||||
}
|
||||
}
|
||||
}
|
||||
result = loadResult;
|
||||
result = CHANS_VM_ERR_LOAD_STRING_CONST;
|
||||
break;
|
||||
|
||||
load_str_ok:
|
||||
pAcc->type = CHANS_VM_OBJ_TYPE_STRING;
|
||||
pAcc->hasData = vmTrue;
|
||||
pAcc->value.wstring_v = (vmWStringObjVal*)&ctx->pDbg->pStringTbl[imm16Val];
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
# CHANSVm load-constant error preservation
|
||||
|
||||
Baseline: 449529d92405f8f7fda610660c7794914a81dfe6. Scope: CHANSVm.c only; no linking classifications or headers changed.
|
||||
|
||||
## Retained correction
|
||||
|
||||
LOAD_STRING_CONST must preserve a failure from CHANSVmDeleteObject. The original object tests the deletion return and branches directly to the local result merge when it is nonzero. The load-string error is selected only after deletion succeeds and the constant index is out of range or has no string payload. The prior C instead overwrote every deletion error with CHANS_VM_ERR_LOAD_STRING_CONST.
|
||||
|
||||
A native destructor that returns false is a concrete error-producing path through CHANSVmDeleteObject; this distinction is observable, not merely a compiler-scheduling preference.
|
||||
|
||||
The new local loadResult preserves that error, keeps constant validation and installation inside the successful-deletion block, and merges the result afterward. Target and rebuilt blocks have the same instruction count and control-flow destinations; remaining operand differences are registers. No strings, data layout, or generated jump-table destinations changed.
|
||||
|
||||
## Measurements
|
||||
|
||||
- All 233 target functions have compiled C implementations; this is not a claim that all are exact or independently behavior-proven.
|
||||
- Instruction-exact functions: 221/233 -> 221/233; every objdiff-exact function also passes ctxdiff.
|
||||
- Unit decompiled/fuzzy: 99.364426% -> 99.383840%.
|
||||
- Exact code: 37608/53564 bytes -> 37608/53564 bytes (70.211334%).
|
||||
- Exact data: 6904/6904 bytes -> 6904/6904 bytes (100%).
|
||||
- CHANSVmStep: 96.466080% -> 96.673584%; 1253/1253 instructions; ctxdiff differing positions 314 -> 297.
|
||||
- Per-function score regressions relative to the fresh baseline report: zero.
|
||||
- The unit remains NonMatching/unlinked; no link flags were changed.
|
||||
|
||||
## Attempts
|
||||
|
||||
1. Read previous round/wave logs and recent local trials; establish live baseline and run pool_diff first: 125 strings identical.
|
||||
2. Replace the load-string shared error/goto path with a typed local error result and successful-deletion-only constant validation. Retained: correct error behavior, higher fuzzy score, unchanged exact code/data.
|
||||
3. Separately tried consolidating GET_PROPERTY_NAME's local found flag and removing two unused array-index assignments. Rejected and restored completely: Step shrank to 1249 instructions and data dropped to 2232/6904. This unrelated trial is absent from the final source.
|
||||
|
||||
## Validation
|
||||
|
||||
- Full 43U build passed with the assigned wibo wrapper and WIBO_SJIS_MISSING_IMPORTS=1.
|
||||
- DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d.
|
||||
- pool_diff: 125/125 identical strings.
|
||||
- .data: 4672/4672 bytes identical; all 352 canonical relocations identical.
|
||||
- .rodata: 1432/1432 bytes identical; all 258 canonical relocations identical.
|
||||
- All 233 functions compared with ctxdiff/odiff: 221 exact; no falsely exact objdiff functions.
|
||||
- git diff --check passed.
|
||||
- Source-extracted host C harness passed six load-constant cases: missing operand; deletion failure with valid index; deletion failure with invalid index; invalid index after successful deletion; null payload; successful installation. The harness stubs surrounding VM dependencies and checks C behavior only; no Wii runtime execution is claimed.
|
||||
|
||||
Source is paused after this focused candidate for parent review. The remaining 12 functions are still non-exact.
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user