[ResGen] weak symbol support

kynex7510 · kynex7510 · commit 5bd0a055418d · 2025-04-06T09:53:45.000+02:00
diff --git a/ResGen/README.md b/ResGen/README.md
@@ -4,11 +4,11 @@ Resolver generator.
 
 ## Usage
 
-> ResGen [options] [inputs...] -o [output]
+> ResGen [options] [inputs...] -o|--out [output]
 
 Options:
-- `--rules`: JSON file(s) containing symbol definitions
-- `--name`: Set the symbol name for the resolver (default: `ctrdlProgramResolver`)
+- `-r|--rules`: JSON file(s) containing symbol definitions
+- `-n|--name`: Set the symbol name for the resolver (default: `ctrdlProgramResolver`)
 
 ### Symbol definition files (SymDefs)
 
@@ -19,6 +19,7 @@ SymDefs specify rules for certain symbols.
     // Match symbols by regex pattern
     "{PATTERN}" : {
         "name" : "{NEW NAME}", // Replace the symbol name (default: null (retain name))
+        "weak" : true | false, // Define as weak (default: false)
         "exclude" : true | false, // Exclude this symbol (default: false)
         "partial_match" : true | false // Match name partially (default: false)
     }
diff --git a/ResGen/Source/Binary.cpp b/ResGen/Source/Binary.cpp
@@ -192,12 +192,20 @@ static bool parse(const std::string& fileName, std::ifstream& f, SymList& out) {
     }
 
     // Read symbols.
+    const auto& isWeak = [](unsigned char info) {
+        if constexpr (std::is_same_v<HeaderType, Elf64_Ehdr>) {
+            return ELF64_ST_BIND(info) == STB_WEAK;
+        } else {
+            return ELF32_ST_BIND(info) == STB_WEAK;
+        }
+    };
+    
     for (auto& sym : symEntries) {
         if (sym.st_name == STN_UNDEF || sym.st_shndx != SHN_UNDEF)
             continue;
 
         const char* name = &stringTable[sym.st_name];
-        out.insert(name);
+        out.insert({name, isWeak(sym.st_info) });
     }
 
     return true;
diff --git a/ResGen/Source/CmdArgs.cpp b/ResGen/Source/CmdArgs.cpp
@@ -9,16 +9,16 @@ CmdArgs::CmdArgs() : m_Options("ResGen", "Resolver Generator") {
     m_Options.add_options()
         ("h,help", "Show help")
         ("inputs", "", cxxopts::value<std::vector<std::string>>())
-        ("o,output", "Output file", cxxopts::value<std::string>())
-        ("rules", "JSON file(s) containing symbol definitions", cxxopts::value<std::vector<std::string>>())
-        ("name", "Set the symbol name for the resolver", cxxopts::value<std::string>()->default_value(DEFAULT_RESOLVER_NAME));
+        ("o,out", "Output file", cxxopts::value<std::string>())
+        ("r,rules", "JSON file(s) containing symbol definitions", cxxopts::value<std::vector<std::string>>())
+        ("n,name", "Set the symbol name for the resolver", cxxopts::value<std::string>()->default_value(DEFAULT_RESOLVER_NAME));
 
     m_Options.parse_positional({ "inputs" });
 }
 
 bool CmdArgs::parse(int argc, const char* const* argv) {
     m_Inputs.clear();
-    m_DefinitionLists.clear();
+    m_Rules.clear();
     m_ResolverName.clear();
 
     auto result = m_Options.parse(argc, argv);
@@ -33,12 +33,12 @@ bool CmdArgs::parse(int argc, const char* const* argv) {
             m_Inputs.insert(entry);
     }
 
-    if (result["output"].count())
-        m_Output = result["output"].as<std::string>();
+    if (result["out"].count())
+        m_Output = result["out"].as<std::string>();
 
     if (result["rules"].count()) {
         for (const auto& entry : result["rules"].as<std::vector<std::string>>())
-            m_DefinitionLists.insert(entry);
+            m_Rules.insert(entry);
     }
         
     m_ResolverName = result["name"].as<std::string>();
diff --git a/ResGen/Source/CmdArgs.h b/ResGen/Source/CmdArgs.h
@@ -13,7 +13,7 @@ class CmdArgs {
     cxxopts::Options m_Options;
     std::unordered_set<std::filesystem::path> m_Inputs;
     std::filesystem::path m_Output;
-    std::unordered_set<std::filesystem::path> m_DefinitionLists;
+    std::unordered_set<std::filesystem::path> m_Rules;
     std::string m_ResolverName;
 
 public:
@@ -23,7 +23,7 @@ class CmdArgs {
 
     const std::unordered_set<std::filesystem::path>& inputs() const { return m_Inputs; }
     const std::filesystem::path& output() const { return m_Output; }
-    const std::unordered_set<std::filesystem::path>& definitionLists() const { return m_DefinitionLists; }
+    const std::unordered_set<std::filesystem::path>& rules() const { return m_Rules; }
     const std::string& resolverName() const { return m_ResolverName; }
 };
 
diff --git a/ResGen/Source/Main.cpp b/ResGen/Source/Main.cpp
@@ -33,19 +33,28 @@ int main(int argc, const char* const* argv) {
             return 1;
     }
 
-    // Parse symdefs.
+    // Parse rules.
     SymDefs defs;
-    for (const auto& defFile : args.definitionLists()) {
-        if (!defs.parse(defFile))
+    for (const auto& ruleFile : args.rules()) {
+        if (!defs.parseFile(ruleFile))
             return 1;
     }
 
     // Generate symbol map.
     SymMap symMap;
 
     for (const auto& sym : syms) {
-        if (auto name = defs.resolve(sym))
-            symMap[sym] = *name;
+        const auto rule = defs.ruleForName(sym.name);
+
+        // Leave the original name if no rule matched.
+        if (!rule) {
+            symMap[sym.name] = sym;
+            continue;
+        } else {
+            // Apply the name given by the rule, if any.
+            if (auto name = rule->nameForSymbol(sym.name))
+                symMap[sym.name] = SymEntry { *name, rule->isWeak() };
+        }
     }
 
     // Generate resolver.
diff --git a/ResGen/Source/ResGenerator.cpp b/ResGen/Source/ResGenerator.cpp
@@ -99,8 +99,13 @@ bool ResGenerator::writeToFile(const std::filesystem::path& path) {
 
     for (const auto& bucket : m_SymTable.buckets()) {
         for (const auto& entry : bucket) {
+            const auto& mapped = m_SymTable.mapped(entry);
+
+            if (mapped.isWeak)
+                f << ".weak " << mapped.name << '\n';
+
             f << ".word " << entry << '\n';
-            f << ".word " << m_SymTable.mapped(entry) << '\n';
+            f << ".word " << mapped.name << '\n';
         }
 
         f << ".word 0\n";
diff --git a/ResGen/Source/SymTable.cpp b/ResGen/Source/SymTable.cpp
@@ -34,7 +34,7 @@ static std::uint32_t nearestPowerOf2(std::uint32_t n) {
     return 0;
 }
 
-size_t SymTable::insertSymbol(const std::string& sym, const std::string& mapped) {
+size_t SymTable::insertSymbol(const std::string& sym, const SymEntry& mapped) {
     const auto strOff = m_StringTable.size();
     m_StringTable.resize(strOff + sym.size() + 1, '\0');
     memcpy(m_StringTable.data() + strOff, sym.data(), sym.size());
diff --git a/ResGen/Source/SymTable.h b/ResGen/Source/SymTable.h
@@ -12,17 +12,17 @@ namespace resgen {
 class SymTable {
     std::vector<std::uint8_t> m_StringTable;
     std::vector<std::vector<size_t>> m_Buckets;
-    std::unordered_map<size_t, std::string> m_Mapped;
+    std::unordered_map<size_t, SymEntry> m_Mapped;
 
-    size_t insertSymbol(const std::string& sym, const std::string& mapped);
+    size_t insertSymbol(const std::string& sym, const SymEntry& mapped);
     void genHashTable(SymMap&& symbols, std::unordered_map<std::string, size_t>&& offsets);
 
 public:
     SymTable(SymMap&& symbols);
 
     const std::vector<std::uint8_t>& stringTable() const { return m_StringTable; }
     const std::vector<std::vector<size_t>>& buckets() const { return m_Buckets; }
-    const std::string& mapped(size_t idx) const { return m_Mapped.at(idx); }
+    const SymEntry& mapped(size_t idx) const { return m_Mapped.at(idx); }
 };
 
 } // namespace resgen
diff --git a/ResGen/Source/Symbol.cpp b/ResGen/Source/Symbol.cpp
@@ -14,22 +14,12 @@ bool SymRule::match(std::string_view s) const {
     return RE2::FullMatch(s, *m_RE);
 }
 
-bool SymDefs::parse(const std::filesystem::path& path) {
-    const auto fileName = path.filename().string();
+bool SymDefs::parseObject(std::string_view fileName, std::string_view content) {
     std::unordered_set<std::string> ruleNames;
     std::vector<SymRule> rules;
 
-    // Read json.
-    std::ifstream f(path);
-    if (!f.is_open()) {
-        resgen::printError(PrintFileInfo {
-            .fileName = fileName,
-            .boldText = true,
-        }, "could not open file");
-        return false;
-    }
-
-    const auto jsonData = nlohmann::json::parse(f, nullptr, false);
+    // Parse json.
+    const auto jsonData = nlohmann::json::parse(content, nullptr, false);
     if (!jsonData.is_object()) {
         resgen::printError( PrintFileInfo {
             .fileName = fileName,
@@ -79,6 +69,19 @@ bool SymDefs::parse(const std::filesystem::path& path) {
             name = value["name"].get<std::string>();
         }
 
+        if (value.contains("weak")) {
+            if (!value["weak"].is_boolean()) {
+                resgen::printError( PrintFileInfo {
+                    .fileName = fileName,
+                    .boldText = true,
+                }, "expected bool for \"weak\" of rule \"{}\"", rule);
+                return false;
+            }
+
+            if (value["weak"].get<bool>())
+                flags |= SymRule::FLAG_WEAK;
+        }
+
         if (value.contains("exclude")) {
             if (!value["exclude"].is_boolean()) {
                 resgen::printError( PrintFileInfo {
@@ -125,6 +128,22 @@ bool SymDefs::parse(const std::filesystem::path& path) {
     return true;
 }
 
+bool SymDefs::parseFile(const std::filesystem::path& path) {
+    const auto fileName = path.filename().string();
+    
+    std::ifstream f(path);
+    if (!f.is_open()) {
+        resgen::printError(PrintFileInfo {
+            .fileName = fileName,
+            .boldText = true,
+        }, "could not open file");
+        return false;
+    }
+
+    const std::string content((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+    return parseObject(fileName, content);
+}
+
 static std::size_t checkSym(std::string_view s) {
     for (auto i = 0u; i < s.size(); ++i) {
         if (s[i] <= '\x20' || s[i] >= '\x7F')
@@ -170,7 +189,7 @@ static bool parseList(const std::filesystem::path& path, SymList& out) {
 
         // Check for duplicates.
         auto tmpIt = syms.find(tmp);
-        auto otherIt = out.find(tmp);
+        auto otherIt = out.find(SymEntry{ tmp, false });
 
         if ((tmpIt != syms.end()) || (otherIt != out.end())) {
             resgen::printWarning(PrintFileInfo {
@@ -193,7 +212,7 @@ static bool parseList(const std::filesystem::path& path, SymList& out) {
     auto it = syms.begin();
     while (it != syms.end()) {
         auto node = syms.extract(it);
-        out.insert(node.key());
+        out.insert({ node.key(), false });
         it = syms.begin();
     }
 
diff --git a/ResGen/Source/Symbol.h b/ResGen/Source/Symbol.h
@@ -17,8 +17,19 @@
 
 namespace resgen {
 
-using SymList = std::unordered_set<std::string>;
-using SymMap = std::unordered_map<std::string, std::string>;
+struct SymEntry {
+    struct Hash {
+        std::size_t operator()(const SymEntry& other) const noexcept { return std::hash<std::string>{}(other.name); }
+    };
+
+    std::string name;
+    bool isWeak = false;
+
+    bool operator==(const SymEntry& other) const noexcept { return name == other.name; }
+};
+
+using SymList = std::unordered_set<SymEntry, SymEntry::Hash>;
+using SymMap = std::unordered_map<std::string, SymEntry>;
 
 class InvalidRuleException final : public std::runtime_error {
 public:
@@ -27,8 +38,9 @@ class InvalidRuleException final : public std::runtime_error {
 
 class SymRule final {
 public:
-    constexpr static std::size_t FLAG_EXCLUDE = 0x01;
-    constexpr static std::size_t FLAG_PARTIAL_MATCH = 0x02;
+    constexpr static std::size_t FLAG_WEAK = 0x01;
+    constexpr static std::size_t FLAG_EXCLUDE = 0x02;
+    constexpr static std::size_t FLAG_PARTIAL_MATCH = 0x04;
 
 private:
     std::unique_ptr<RE2> m_RE;
@@ -56,6 +68,8 @@ class SymRule final {
 
         return std::string(sym);
     }
+
+    bool isWeak() const { return m_Flags & FLAG_WEAK; }
 };
 
 class SymDefs final {
@@ -65,15 +79,16 @@ class SymDefs final {
 public:
     SymDefs() {}
 
-    bool parse(const std::filesystem::path& path);
+    bool parseObject(std::string_view fileName, std::string_view content);
+    bool parseFile(const std::filesystem::path& path);
 
     void clear() {
         m_RuleNames.clear();
         m_Rules.clear();
     }
 
-    std::optional<std::string> resolve(std::string_view sym) const {
-        // Find a rule for this symbol.
+    // Find a rule for this symbol.
+    const SymRule* ruleForName(std::string_view sym) const {
         const SymRule* matched = nullptr;
         std::vector<const SymRule*> otherMatches;
         for (const auto& rule : m_Rules) {
@@ -95,8 +110,7 @@ class SymDefs final {
                 resgen::printNote("matches \"{}\"", rule->pattern());
         }
 
-        // Return the same name if no rule matched.
-        return matched ? matched->nameForSymbol(sym) : std::string(sym);
+        return matched;
     }
 };
 
diff --git a/Tests/InteropApp.c b/Tests/InteropApp.c
@@ -10,10 +10,6 @@
 
 typedef void (*InteropFn)(const char*);
 
-// TODO: remove.
-void __register_frame_info(const void*, struct object*) {}
-void *__deregister_frame_info(const void *) {}
-
 int main(int argc, char* argv[]) {
     gfxInitDefault();
 
diff --git a/Tests/MathApp.c b/Tests/MathApp.c
@@ -7,10 +7,6 @@
 
 typedef void (*DoMathFn)(int, int);
 
-// TODO: remove.
-void __register_frame_info(const void*, struct object*) {}
-void *__deregister_frame_info(const void *) {}
-
 static void enumerateCallback(void* handle) {
     CTRDLInfo info;
     printf("Handle value: 0x%08lx\n", (u32)handle);

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ static std::uint32_t nearestPowerOf2(std::uint32_t n) {`
`34`	`34`	`return 0;`
`35`	`35`	`}`
`36`	`36`
`37`		`-size_t SymTable::insertSymbol(const std::string& sym, const std::string& mapped) {`
	`37`	`+size_t SymTable::insertSymbol(const std::string& sym, const SymEntry& mapped) {`
`38`	`38`	`const auto strOff = m_StringTable.size();`
`39`	`39`	`m_StringTable.resize(strOff + sym.size() + 1, '\0');`
`40`	`40`	`memcpy(m_StringTable.data() + strOff, sym.data(), sym.size());`