Merge pull request #2 from Masterkatze/update

Masterkatze · web-flow · commit 08b6d7f0f2ec · 2025-11-08T16:48:22.000+03:00
Add class variable support, fix some issues
diff --git a/src/formatter.cpp b/src/formatter.cpp
@@ -63,8 +63,8 @@ std::vector<Out2> formatVTable(const ClassInfo &classInfo)
 
                 while ((linuxIndex - (1 + previousOverloads)) >= 0)
                 {
-                    auto previousFunctionIndex = linuxIndex - (1 + previousOverloads);
-                    auto previousFunctionInfo = vtableInfo.functions.at(previousFunctionIndex);
+                    const auto previousFunctionIndex = linuxIndex - (1 + previousOverloads);
+                    const auto previousFunctionInfo = vtableInfo.functions.at(previousFunctionIndex);
 
                     if (functionInfo->symbol.name.empty() || shouldSkipWindowsFunction(classInfo, vtableIndex, previousFunctionIndex, *previousFunctionInfo))
                     {
@@ -81,8 +81,8 @@ std::vector<Out2> formatVTable(const ClassInfo &classInfo)
 
                 while ((linuxIndex + 1 + remainingOverloads) < static_cast<int>(vtableInfo.functions.size()))
                 {
-                    auto nextFunctionIndex = linuxIndex + 1 + remainingOverloads;
-                    auto nextFunctionInfo = vtableInfo.functions.at(nextFunctionIndex);
+                    const auto nextFunctionIndex = linuxIndex + 1 + remainingOverloads;
+                    const auto nextFunctionInfo = vtableInfo.functions.at(nextFunctionIndex);
 
                     if (functionInfo->symbol.name.empty() || shouldSkipWindowsFunction(classInfo, vtableIndex, nextFunctionIndex, *nextFunctionInfo))
                     {
diff --git a/src/main.cpp b/src/main.cpp
@@ -246,5 +246,5 @@ int main(int argc, char *argv[])
         }
     }
 
-    return writeGamedataFile(out.classes, inputFilePaths, outputDirectoryPaths);
+    return writeGamedataFile(out.classes, programInfo.vtableFieldDataEntries, inputFilePaths, outputDirectoryPaths);
 }
diff --git a/src/parser.cpp b/src/parser.cpp
@@ -7,7 +7,7 @@
 
 std::unique_ptr<char, DemangledSymbolDeallocator> demangleSymbol(const char *abiName)
 {
-    int status;
+    int status = -4;
     char *ret = abi::__cxa_demangle(abiName, 0, 0, &status);
 
     DemangledSymbolDeallocator deallocator = [](char *mem)
@@ -34,7 +34,7 @@ std::unique_ptr<char, DemangledSymbolDeallocator> demangleSymbol(const char *abi
 std::span<const unsigned char> getDataForSymbol(const ProgramInfo &programInfo, const SymbolInfo &symbol)
 {
     LargeNumber dataStart;
-    const std::vector<RodataChunk> *dataChunks;
+    const std::vector<RodataChunk> *dataChunks = nullptr;
 
     if (symbol.section == 0)
     {
@@ -149,12 +149,12 @@ Out parse(ProgramInfo &programInfo)
             functionAddress.low = symbolDataView[functionIndex];
             functionAddress.isUnsigned = true;
 
+            // Note: Relocations not supported for 64-bit bins
             if (programInfo.addressSize > BYTES_PER_ELEMENT)
             {
                 functionAddress.high = symbolDataView[++functionIndex];
             }
-
-            if (programInfo.addressSize == BYTES_PER_ELEMENT)
+            else if (programInfo.addressSize == BYTES_PER_ELEMENT)
             {
                 LargeNumber localAddress;
                 localAddress.high = 0;
@@ -167,10 +167,6 @@ Out parse(ProgramInfo &programInfo)
                     functionAddress = targetAddress;
                 }
             }
-            else
-            {
-                std::cout << "Relocations not supported for 64-bit bins" << std::endl;
-            }
 
             auto functionSymbolsIterator = addressToSymbolMap.find(functionAddress);
 
@@ -186,7 +182,7 @@ Out parse(ProgramInfo &programInfo)
             // This could be the end of the vtable, or it could just be a pure/deleted func.
             if (functionSymbolsIterator == addressToSymbolMap.end())
             {
-                if (classInfo.vtables.size() == 0 || static_cast<unsigned long long>(functionAddress) != 0)
+                if (classInfo.vtables.empty() || static_cast<unsigned long long>(functionAddress) != 0)
                 {
                     auto& newClassVTable = classInfo.vtables.emplace_back();
                     classVTable = &newClassVTable;
@@ -206,7 +202,7 @@ Out parse(ProgramInfo &programInfo)
             }
 
             auto functionSymbols = functionSymbolsIterator->second;
-            auto functionSymbol = functionSymbols.back();
+            const auto& functionSymbol = functionSymbols.back();
 
             auto functionSymbolName = functionSymbol.name;
             if (functionSymbolName == "__cxa_deleted_virtual" || functionSymbolName == "__cxa_pure_virtual")
@@ -215,7 +211,7 @@ Out parse(ProgramInfo &programInfo)
                 continue;
             }
 
-            FunctionInfo *functionInfoPtr;
+            FunctionInfo *functionInfoPtr = nullptr;
 
             auto functionInfoIterator = addressToFunctionMap.find(functionAddress);
             if (functionInfoIterator != addressToFunctionMap.end())
@@ -235,6 +231,7 @@ Out parse(ProgramInfo &programInfo)
                 if (startOfName != std::string::npos)
                 {
                     name = name.substr(startOfName + 2);
+                    nameSpace.resize(startOfName);
                 }
 
                 auto startOfArgs = demangledSymbol.rfind('(');
@@ -243,9 +240,6 @@ Out parse(ProgramInfo &programInfo)
                     shortName = shortName.substr(startOfName + 2, startOfArgs - startOfName - 2);
                 }
 
-
-                nameSpace = nameSpace.substr(0, startOfName);
-
                 FunctionInfo functionInfo;
 
                 functionInfo.id = functionAddress;
diff --git a/src/reader.cpp b/src/reader.cpp
@@ -19,6 +19,13 @@
 #include <unistd.h>
 #include <fcntl.h>
 
+struct VTableFieldOffsetDataRaw
+{
+    uint64_t class_name_ptr;
+    uint64_t member_name_ptr;
+    uint64_t offset;
+};
+
 LargeNumber::LargeNumber() : high{}, low{}, isUnsigned{}
 {
 
@@ -92,14 +99,14 @@ ProgramInfo process(char *image, std::size_t size)
         return programInfo;
     }
 
-    size_t numberOfSections;
+    size_t numberOfSections = 0;
     if (elf_getshdrnum(elf, &numberOfSections) != 0)
     {
         programInfo.error = "Failed to get number of ELF sections. (" + std::string(elf_errmsg(-1)) + ")";
         return programInfo;
     }
 
-    size_t sectionNameStringTableIndex;
+    size_t sectionNameStringTableIndex = 0;
     if (elf_getshdrstrndx(elf, &sectionNameStringTableIndex) != 0)
     {
         programInfo.error = "Failed to get ELF section names. (" + std::string(elf_errmsg(-1)) + ")";
@@ -113,14 +120,14 @@ ProgramInfo process(char *image, std::size_t size)
     Elf_Scn *symbolTableScn = nullptr;
 
     size_t stringTableIndex = SHN_UNDEF;
-    Elf_Scn *stringTableScn = nullptr;
+    const Elf_Scn *stringTableScn = nullptr;
 
     size_t rodataIndex = SHN_UNDEF;
-    Elf64_Addr rodataOffset;
+    Elf64_Addr rodataOffset = 0;
     Elf_Scn *rodataScn = nullptr;
 
     size_t relRodataIndex = SHN_UNDEF;
-    Elf64_Addr relRodataOffset;
+    Elf64_Addr relRodataOffset = 0;
     Elf_Scn *relRodataScn = nullptr;
 
     for (size_t elfSectionIndex = 0; elfSectionIndex < numberOfSections; ++elfSectionIndex)
@@ -175,6 +182,26 @@ ProgramInfo process(char *image, std::size_t size)
             relRodataOffset = elfSectionHeader.sh_addr;
             relRodataScn = elfScn;
         }
+        else if(elfSectionHeader.sh_type == SHT_PROGBITS && strcmp(name, ".member_offsets") == 0)
+        {
+            Elf_Data* data = elf_getdata(elfScn, nullptr);
+            if (data && data->d_size > 0)
+            {
+                size_t entry_count = data->d_size / sizeof(VTableFieldOffsetDataRaw);
+                auto entries = static_cast<const VTableFieldOffsetDataRaw*>(data->d_buf);
+
+                for (size_t i = 0; i < entry_count; ++i)
+                {
+#if 0
+                    std::cout << "VTableFieldOffsetData entry " << i << ":\n";
+                    std::cout << "  Class name: " << &image[entries[i].class_name_ptr] << "\n";
+                    std::cout << "  Member name: " << &image[entries[i].member_name_ptr] << "\n";
+                    std::cout << "  Offset: " << entries[i].offset << " (0x" << std::hex << entries[i].offset << std::dec << ")\n";
+#endif
+                    programInfo.vtableFieldDataEntries.emplace_back(&image[entries[i].class_name_ptr], &image[entries[i].member_name_ptr], entries[i].offset);
+                }
+            }
+        }
 
         if (relocationTableScn && dynamicSymbolTableScn && symbolTableScn && stringTableScn && rodataScn && relRodataScn)
         {
@@ -196,7 +223,7 @@ ProgramInfo process(char *image, std::size_t size)
         Elf_Data *relocationData = nullptr;
         while ((relocationData = elf_getdata(relocationTableScn, relocationData)) != nullptr)
         {
-            size_t relocationIndex = 0;
+            int relocationIndex = 0;
             GElf_Rel relocation;
             while (gelf_getrel(relocationData, relocationIndex++, &relocation) == &relocation)
             {
@@ -210,7 +237,7 @@ ProgramInfo process(char *image, std::size_t size)
                 while ((symbolData = elf_getdata(dynamicSymbolTableScn, symbolData)) != nullptr)
                 {
                     GElf_Sym symbol;
-                    size_t symbolIndex = GELF_R_SYM(relocation.r_info);
+                    int symbolIndex = GELF_R_SYM(relocation.r_info);
                     if (gelf_getsym(symbolData, symbolIndex, &symbol) != &symbol)
                     {
                         continue;
diff --git a/src/reader.hpp b/src/reader.hpp
@@ -50,6 +50,13 @@ struct RelocationInfo
     LargeNumber target;
 };
 
+struct MemberOffset
+{
+    std::string className;
+    std::string memberName;
+    uint64_t offset;
+};
+
 struct ProgramInfo
 {
     std::string error;
@@ -62,6 +69,7 @@ struct ProgramInfo
     std::vector<RodataChunk> relRodataChunks;
     std::vector<SymbolInfo> symbols;
     std::vector<RelocationInfo> relocations;
+    std::vector<MemberOffset> vtableFieldDataEntries;
 };
 
 ProgramInfo process(char *image, std::size_t size);
diff --git a/src/writer.cpp b/src/writer.cpp
diff --git a/src/writer.hpp b/src/writer.hpp

Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,8 @@ std::vector<Out2> formatVTable(const ClassInfo &classInfo)`
`63`	`63`
`64`	`64`	`while ((linuxIndex - (1 + previousOverloads)) >= 0)`
`65`	`65`	`{`
`66`		`- auto previousFunctionIndex = linuxIndex - (1 + previousOverloads);`
`67`		`- auto previousFunctionInfo = vtableInfo.functions.at(previousFunctionIndex);`
	`66`	`+ const auto previousFunctionIndex = linuxIndex - (1 + previousOverloads);`
	`67`	`+ const auto previousFunctionInfo = vtableInfo.functions.at(previousFunctionIndex);`
`68`	`68`
`69`	`69`	`if (functionInfo->symbol.name.empty() \|\| shouldSkipWindowsFunction(classInfo, vtableIndex, previousFunctionIndex, *previousFunctionInfo))`
`70`	`70`	`{`
`@@ -81,8 +81,8 @@ std::vector<Out2> formatVTable(const ClassInfo &classInfo)`
`81`	`81`
`82`	`82`	`while ((linuxIndex + 1 + remainingOverloads) < static_cast<int>(vtableInfo.functions.size()))`
`83`	`83`	`{`
`84`		`- auto nextFunctionIndex = linuxIndex + 1 + remainingOverloads;`
`85`		`- auto nextFunctionInfo = vtableInfo.functions.at(nextFunctionIndex);`
	`84`	`+ const auto nextFunctionIndex = linuxIndex + 1 + remainingOverloads;`
	`85`	`+ const auto nextFunctionInfo = vtableInfo.functions.at(nextFunctionIndex);`
`86`	`86`
`87`	`87`	`if (functionInfo->symbol.name.empty() \|\| shouldSkipWindowsFunction(classInfo, vtableIndex, nextFunctionIndex, *nextFunctionInfo))`
`88`	`88`	`{`
Original file line number	Diff line number	Diff line change
`@@ -246,5 +246,5 @@ int main(int argc, char *argv[])`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`
`249`		`- return writeGamedataFile(out.classes, inputFilePaths, outputDirectoryPaths);`
	`249`	`+ return writeGamedataFile(out.classes, programInfo.vtableFieldDataEntries, inputFilePaths, outputDirectoryPaths);`
`250`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`
`8`	`8`	`std::unique_ptr<char, DemangledSymbolDeallocator> demangleSymbol(const char *abiName)`
`9`	`9`	`{`
`10`		`- int status;`
	`10`	`+ int status = -4;`
`11`	`11`	`char *ret = abi::__cxa_demangle(abiName, 0, 0, &status);`
`12`	`12`
`13`	`13`	`DemangledSymbolDeallocator deallocator = [](char *mem)`
`@@ -34,7 +34,7 @@ std::unique_ptr<char, DemangledSymbolDeallocator> demangleSymbol(const char *abi`
`34`	`34`	`std::span<const unsigned char> getDataForSymbol(const ProgramInfo &programInfo, const SymbolInfo &symbol)`
`35`	`35`	`{`
`36`	`36`	`LargeNumber dataStart;`
`37`		`- const std::vector<RodataChunk> *dataChunks;`
	`37`	`+ const std::vector<RodataChunk> *dataChunks = nullptr;`
`38`	`38`
`39`	`39`	`if (symbol.section == 0)`
`40`	`40`	`{`
`@@ -149,12 +149,12 @@ Out parse(ProgramInfo &programInfo)`
`149`	`149`	`functionAddress.low = symbolDataView[functionIndex];`
`150`	`150`	`functionAddress.isUnsigned = true;`
`151`	`151`
	`152`	`+ // Note: Relocations not supported for 64-bit bins`
`152`	`153`	`if (programInfo.addressSize > BYTES_PER_ELEMENT)`
`153`	`154`	`{`
`154`	`155`	`functionAddress.high = symbolDataView[++functionIndex];`
`155`	`156`	`}`
`156`		`-`
`157`		`- if (programInfo.addressSize == BYTES_PER_ELEMENT)`
	`157`	`+ else if (programInfo.addressSize == BYTES_PER_ELEMENT)`
`158`	`158`	`{`
`159`	`159`	`LargeNumber localAddress;`
`160`	`160`	`localAddress.high = 0;`
`@@ -167,10 +167,6 @@ Out parse(ProgramInfo &programInfo)`
`167`	`167`	`functionAddress = targetAddress;`
`168`	`168`	`}`
`169`	`169`	`}`
`170`		`- else`
`171`		`- {`
`172`		`- std::cout << "Relocations not supported for 64-bit bins" << std::endl;`
`173`		`- }`
`174`	`170`
`175`	`171`	`auto functionSymbolsIterator = addressToSymbolMap.find(functionAddress);`
`176`	`172`
`@@ -186,7 +182,7 @@ Out parse(ProgramInfo &programInfo)`
`186`	`182`	`// This could be the end of the vtable, or it could just be a pure/deleted func.`
`187`	`183`	`if (functionSymbolsIterator == addressToSymbolMap.end())`
`188`	`184`	`{`
`189`		`- if (classInfo.vtables.size() == 0 \|\| static_cast<unsigned long long>(functionAddress) != 0)`
	`185`	`+ if (classInfo.vtables.empty() \|\| static_cast<unsigned long long>(functionAddress) != 0)`
`190`	`186`	`{`
`191`	`187`	`auto& newClassVTable = classInfo.vtables.emplace_back();`
`192`	`188`	`classVTable = &newClassVTable;`
`@@ -206,7 +202,7 @@ Out parse(ProgramInfo &programInfo)`
`206`	`202`	`}`
`207`	`203`
`208`	`204`	`auto functionSymbols = functionSymbolsIterator->second;`
`209`		`- auto functionSymbol = functionSymbols.back();`
	`205`	`+ const auto& functionSymbol = functionSymbols.back();`
`210`	`206`
`211`	`207`	`auto functionSymbolName = functionSymbol.name;`
`212`	`208`	`if (functionSymbolName == "__cxa_deleted_virtual" \|\| functionSymbolName == "__cxa_pure_virtual")`
`@@ -215,7 +211,7 @@ Out parse(ProgramInfo &programInfo)`
`215`	`211`	`continue;`
`216`	`212`	`}`
`217`	`213`
`218`		`- FunctionInfo *functionInfoPtr;`
	`214`	`+ FunctionInfo *functionInfoPtr = nullptr;`
`219`	`215`
`220`	`216`	`auto functionInfoIterator = addressToFunctionMap.find(functionAddress);`
`221`	`217`	`if (functionInfoIterator != addressToFunctionMap.end())`
`@@ -235,6 +231,7 @@ Out parse(ProgramInfo &programInfo)`
`235`	`231`	`if (startOfName != std::string::npos)`
`236`	`232`	`{`
`237`	`233`	`name = name.substr(startOfName + 2);`
	`234`	`+ nameSpace.resize(startOfName);`
`238`	`235`	`}`
`239`	`236`
`240`	`237`	`auto startOfArgs = demangledSymbol.rfind('(');`
`@@ -243,9 +240,6 @@ Out parse(ProgramInfo &programInfo)`
`243`	`240`	`shortName = shortName.substr(startOfName + 2, startOfArgs - startOfName - 2);`
`244`	`241`	`}`
`245`	`242`
`246`		`-`
`247`		`- nameSpace = nameSpace.substr(0, startOfName);`
`248`		`-`
`249`	`243`	`FunctionInfo functionInfo;`
`250`	`244`
`251`	`245`	`functionInfo.id = functionAddress;`