Handle exports resolve

src/core/linker.cpp

@@ -576,7 +576,28 @@ void Linker::Relocate(Module* m)
 	}
 }
 
+template <typename T>
+bool contains(const std::vector<T>& vecObj, const T& element) {
+    auto it = std::find(vecObj.begin(), vecObj.end(), element);
+    return it != vecObj.end();
+}
+
+Module* Linker::FindModuleExp(const ModuleInfo& module, const LibraryInfo& library) {
+    //std::scoped_lock lock{m_mutex};
+
+    for (auto& m : m_modules) {
+        const auto& export_libs = m.dynamic_info.export_libs;
+        const auto& export_modules = m.dynamic_info.export_modules;
+
+		if (contains(export_libs, library) && contains(export_modules,module)) {
+            return &m;
+        }
+    }
+    return nullptr;
+}
+
 void Linker::Resolve(const std::string& name, int Symtype, Module* m, Loader::SymbolRecord* return_info) {
+    //std::scoped_lock lock{m_mutex};
     const auto ids = Common::SplitString(name, '#');
 	if (ids.size() == 3)  // symbols are 3 parts name , library , module
     {
@@ -596,6 +617,12 @@ void Linker::Resolve(const std::string& name, int Symtype, Module* m, Loader::Sy
             const Loader::SymbolRecord* rec = nullptr;
             rec = m_hle_symbols.FindSymbol(sr);
 
+			if (rec == nullptr) {
+                if (auto* p = FindModuleExp(*module, *library); p != nullptr && p->export_sym.GetSize()>0) {
+                    rec = p->export_sym.FindSymbol(sr);
+
+                }
+            }
             if (rec != nullptr) {
                 *return_info = *rec;
             } else {

src/core/linker.h

@@ -17,6 +17,11 @@ struct EntryParams {
 };
 
 struct ModuleInfo {
+
+    bool operator==(const ModuleInfo& other) const {
+        return version_major == other.version_major && version_minor == other.version_minor && name == other.name;
+    }
+
 	std::string name;
     union {
 		u64 value;
@@ -31,6 +36,9 @@ struct ModuleInfo {
 };
 
 struct LibraryInfo {
+
+    bool operator==(const LibraryInfo& other) const { return version == other.version && name == other.name; }
+
 	std::string name;
     union {
 		u64 value;
@@ -119,6 +127,7 @@ public:
 private:
 	const ModuleInfo* FindModule(const Module& m, const std::string& id);
 	const LibraryInfo* FindLibrary(const Module& program, const std::string& id);
+    Module* Linker::FindModuleExp(const ModuleInfo& m, const LibraryInfo& l);
 
     std::vector<Module> m_modules;
     Loader::SymbolsResolver m_hle_symbols{};

src/core/loader/symbols_resolver.cpp

@@ -1,24 +1,26 @@
+#include "core/loader/symbols_resolver.h"
+
 #include "common/log.h"
 #include "common/types.h"
-#include "core/loader/symbols_resolver.h"
 
 namespace Core::Loader {
 
 void SymbolsResolver::AddSymbol(const SymbolRes& s, u64 virtual_addr) {
-	SymbolRecord r{};
+    SymbolRecord r{};
     r.name = GenerateName(s);
-	r.virtual_address = virtual_addr;
-	m_symbols.push_back(r);
+    r.virtual_address = virtual_addr;
+    m_symbols.push_back(r);
 }
 
+int SymbolsResolver::GetSize() { return m_symbols.size(); }
+
 std::string SymbolsResolver::GenerateName(const SymbolRes& s) {
-    return fmt::format("{} lib[{}_v{}]mod[{}_v{}.{}]",
-                       s.name, s.library, s.library_version,
-                       s.module, s.module_version_major, s.module_version_minor);
+    return fmt::format("{} lib[{}_v{}]mod[{}_v{}.{}]", s.name, s.library, s.library_version, s.module, s.module_version_major,
+                       s.module_version_minor);
 }
 
 const SymbolRecord* SymbolsResolver::FindSymbol(const SymbolRes& s) const {
-	const std::string name = GenerateName(s);
+    const std::string name = GenerateName(s);
     for (u32 i = 0; i < m_symbols.size(); i++) {
         if (m_symbols[i].name.compare(name) == 0) {
             return &m_symbols[i];
@@ -26,7 +28,7 @@ const SymbolRecord* SymbolsResolver::FindSymbol(const SymbolRes& s) const {
     }
 
     LOG_INFO("Unresolved! {}\n", name);
-	return nullptr; 
+    return nullptr;
 }
 
-} // namespace Core::Loader
+}  // namespace Core::Loader

src/core/loader/symbols_resolver.h

@@ -30,7 +30,7 @@ public:
 
 	void AddSymbol(const SymbolRes& s, u64 virtual_addr);
     const SymbolRecord* FindSymbol(const SymbolRes& s) const;
-
+    int GetSize();
     static std::string GenerateName(const SymbolRes& s);
 
 private: