Refactored how wrapped symbols are fetch and stored

6 files changed, 229 insertions, 136 deletions

diff --git a/src/librarian/library.c b/src/librarian/library.c
index 18fbe24f..33c3d91e 100644
--- a/src/librarian/library.c
+++ b/src/librarian/library.c
@@ -51,7 +51,7 @@ typedef struct bridged_s {
 
 KHASH_MAP_INIT_STR(bridgemap, bridged_t)
 
-KHASH_MAP_IMPL_STR(symbolmap, wrapper_t)
+KHASH_MAP_IMPL_STR(symbolmap, symbol1_t)
 KHASH_MAP_IMPL_STR(symbol2map, symbol2_t)
 KHASH_MAP_IMPL_STR(datamap, uint64_t)
 
@@ -799,18 +799,23 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
     // check in mysymbolmap
     khint_t k = kh_get(symbolmap, lib->w.mysymbolmap, name);
     if (k!=kh_end(lib->w.mysymbolmap)) {
-        char buff[200];
-        if(lib->w.altmy)
-            strcpy(buff, lib->w.altmy);
-        else
-            strcpy(buff, "my_");
-        strcat(buff, name);
-        symbol = dlsym(my_context->box64lib, buff);
-        if(!symbol) {
-            printf_log(LOG_NONE, "Warning, function %s not found\n", buff);
-        } else 
-            AddOffsetSymbol(my_context->maplib, symbol, name);
-        *addr = AddBridge(lib->w.bridge, kh_value(lib->w.mysymbolmap, k), symbol, 0, name);
+        symbol1_t *s = &kh_value(lib->w.mysymbolmap, k);
+        if(!s->resolved) {
+            char buff[200];
+            if(lib->w.altmy)
+                strcpy(buff, lib->w.altmy);
+            else
+                strcpy(buff, "my_");
+            strcat(buff, name);
+            symbol = dlsym(my_context->box64lib, buff);
+            if(!symbol) {
+                printf_log(LOG_NONE, "Warning, function %s not found\n", buff);
+                return 0;
+            }
+            s->addr = AddBridge(lib->w.bridge, s->w, symbol, 0, name);
+            s->resolved = 1;
+        }
+        *addr = s->addr;
         *size = sizeof(void*);
         *weak = 0;
         return 1;
@@ -818,54 +823,8 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
     // check in stsymbolmap (return struct...)
     k = kh_get(symbolmap, lib->w.stsymbolmap, name);
     if (k!=kh_end(lib->w.stsymbolmap)) {
-        char buff[200];
-        if(lib->w.altmy)
-            strcpy(buff, lib->w.altmy);
-        else
-            strcpy(buff, "my_");
-        strcat(buff, name);
-        symbol = dlsym(my_context->box64lib, buff);
-        if(!symbol) {
-            printf_log(LOG_NONE, "Warning, function %s not found\n", buff);
-        } else 
-            AddOffsetSymbol(my_context->maplib, symbol, name);
-        *addr = AddBridge(lib->w.bridge, kh_value(lib->w.stsymbolmap, k), symbol, sizeof(void*), name);
-        *size = sizeof(void*);
-        *weak = 0;
-        return 1;
-    }
-    // check in symbolmap
-    k = kh_get(symbolmap, lib->w.symbolmap, name);
-    if (k!=kh_end(lib->w.symbolmap)) {
-        symbol = dlsym(lib->w.lib, name);
-        if(!symbol && lib->w.altprefix) {
-            char newname[200];
-            strcpy(newname, lib->w.altprefix);
-            strcat(newname, name);
-            symbol = dlsym(lib->w.lib, newname);
-        }
-        if(!symbol)
-            symbol = GetNativeSymbolUnversioned(lib->w.lib, name);
-        if(!symbol && lib->w.altprefix) {
-            char newname[200];
-            strcpy(newname, lib->w.altprefix);
-            strcat(newname, name);
-            symbol = GetNativeSymbolUnversioned(lib->w.lib, newname);
-        }
-        if(!symbol) {
-            printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", name, lib->name);
-            return 0;
-        } else 
-            AddOffsetSymbol(my_context->maplib, symbol, name);
-        *addr = AddBridge(lib->w.bridge, kh_value(lib->w.symbolmap, k), symbol, 0, name);
-        *size = sizeof(void*);
-        *weak = 0;
-        return 1;
-    }
-    if(!noweak) {
-        // check in wmysymbolmap
-        khint_t k = kh_get(symbolmap, lib->w.wmysymbolmap, name);
-        if (k!=kh_end(lib->w.wmysymbolmap)) {
+        symbol1_t *s = &kh_value(lib->w.stsymbolmap, k);
+        if(!s->resolved) {
             char buff[200];
             if(lib->w.altmy)
                 strcpy(buff, lib->w.altmy);
@@ -875,15 +834,21 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
             symbol = dlsym(my_context->box64lib, buff);
             if(!symbol) {
                 printf_log(LOG_NONE, "Warning, function %s not found\n", buff);
-            } else 
-                AddOffsetSymbol(my_context->maplib, symbol, name);
-            *addr = AddBridge(lib->w.bridge, kh_value(lib->w.wmysymbolmap, k), symbol, 0, name);
-            *size = sizeof(void*);
-            *weak = 1;
-            return 1;
+                return 0;
+            }
+            s->addr = AddBridge(lib->w.bridge, s->w, symbol, sizeof(void*), name);
+            s->resolved = 1;
         }
-        k = kh_get(symbolmap, lib->w.wsymbolmap, name);
-        if (k!=kh_end(lib->w.wsymbolmap)) {
+        *addr = s->addr;
+        *size = sizeof(void*);
+        *weak = 0;
+        return 1;
+    }
+    // check in symbolmap
+    k = kh_get(symbolmap, lib->w.symbolmap, name);
+    if (k!=kh_end(lib->w.symbolmap)) {
+        symbol1_t *s = &kh_value(lib->w.symbolmap, k);
+        if(!s->resolved) {
             symbol = dlsym(lib->w.lib, name);
             if(!symbol && lib->w.altprefix) {
                 char newname[200];
@@ -902,9 +867,67 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
             if(!symbol) {
                 printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", name, lib->name);
                 return 0;
-            } else 
-                AddOffsetSymbol(my_context->maplib, symbol, name);
-            *addr = AddBridge(lib->w.bridge, kh_value(lib->w.wsymbolmap, k), symbol, 0, name);
+            }
+            s->addr = AddBridge(lib->w.bridge, s->w, symbol, 0, name);
+            s->resolved = 1;
+        }
+        *addr = s->addr;
+        *size = sizeof(void*);
+        *weak = 0;
+        return 1;
+    }
+    if(!noweak) {
+        // check in wmysymbolmap
+        khint_t k = kh_get(symbolmap, lib->w.wmysymbolmap, name);
+        if (k!=kh_end(lib->w.wmysymbolmap)) {
+            symbol1_t *s = &kh_value(lib->w.wmysymbolmap, k);
+            if(!s->resolved) {
+                char buff[200];
+                if(lib->w.altmy)
+                    strcpy(buff, lib->w.altmy);
+                else
+                    strcpy(buff, "my_");
+                strcat(buff, name);
+                symbol = dlsym(my_context->box64lib, buff);
+                if(!symbol) {
+                    printf_log(LOG_NONE, "Warning, function %s not found\n", buff);
+                    return 0;
+                }
+                s->addr = AddBridge(lib->w.bridge, s->w, symbol, 0, name);
+                s->resolved = 1;
+            }
+            *addr = s->addr;
+            *size = sizeof(void*);
+            *weak = 1;
+            return 1;
+        }
+        k = kh_get(symbolmap, lib->w.wsymbolmap, name);
+        if (k!=kh_end(lib->w.wsymbolmap)) {
+            symbol1_t *s = &kh_value(lib->w.wsymbolmap, k);
+            if(!s->resolved) {
+                symbol = dlsym(lib->w.lib, name);
+                if(!symbol && lib->w.altprefix) {
+                    char newname[200];
+                    strcpy(newname, lib->w.altprefix);
+                    strcat(newname, name);
+                    symbol = dlsym(lib->w.lib, newname);
+                }
+                if(!symbol)
+                    symbol = GetNativeSymbolUnversioned(lib->w.lib, name);
+                if(!symbol && lib->w.altprefix) {
+                    char newname[200];
+                    strcpy(newname, lib->w.altprefix);
+                    strcat(newname, name);
+                    symbol = GetNativeSymbolUnversioned(lib->w.lib, newname);
+                }
+                if(!symbol) {
+                    printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", name, lib->name);
+                    return 0;
+                }
+                s->addr = AddBridge(lib->w.bridge, s->w, symbol, 0, name);
+                s->resolved = 1;
+            }
+            *addr = s->addr;
             *size = sizeof(void*);
             *weak = 1;
             return 1;
@@ -912,25 +935,29 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
     }
     // check in symbol2map
     k = kh_get(symbol2map, lib->w.symbol2map, name);
-    if (k!=kh_end(lib->w.symbol2map)) 
-        if(!noweak || !kh_value(lib->w.symbol2map, k).weak)
+    if (k!=kh_end(lib->w.symbol2map))  {
+        symbol2_t *s = &kh_value(lib->w.symbol2map, k);
+        if(!noweak || !s->weak)
         {
-            symbol = dlsym(lib->w.lib, kh_value(lib->w.symbol2map, k).name);
-            if(!symbol)
-                symbol = dlsym(RTLD_DEFAULT, kh_value(lib->w.symbol2map, k).name);    // search globaly maybe
-            if(!symbol)
-                symbol = GetNativeSymbolUnversioned(lib->w.lib, kh_value(lib->w.symbol2map, k).name);
-            if(!symbol) {
-                printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", kh_value(lib->w.symbol2map, k).name, lib->name);
-                return 0;
-            } else 
-                AddOffsetSymbol(my_context->maplib, symbol, name);
-            *addr = AddBridge(lib->w.bridge, kh_value(lib->w.symbol2map, k).w, symbol, 0, name);
+            if(!s->resolved) {
+                symbol = dlsym(lib->w.lib, kh_value(lib->w.symbol2map, k).name);
+                if(!symbol)
+                    symbol = dlsym(RTLD_DEFAULT, kh_value(lib->w.symbol2map, k).name);    // search globaly maybe
+                if(!symbol)
+                    symbol = GetNativeSymbolUnversioned(lib->w.lib, kh_value(lib->w.symbol2map, k).name);
+                if(!symbol) {
+                    printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", kh_value(lib->w.symbol2map, k).name, lib->name);
+                    return 0;
+                }
+                s->addr = AddBridge(lib->w.bridge, s->w, symbol, 0, name);
+                s->resolved = 1;
+            }
+            *addr = s->addr;
             *size = sizeof(void*);
-            *weak = kh_value(lib->w.symbol2map, k).weak;
+            *weak = s->weak;
             return 1;
         }
-
+    }
     return 0;
 }
 
diff --git a/src/librarian/library_private.h b/src/librarian/library_private.h
index 27d3fef6..c502306c 100644
--- a/src/librarian/library_private.h
+++ b/src/librarian/library_private.h
@@ -17,13 +17,21 @@ typedef struct x64emu_s         x64emu_t;
 
 typedef void (*wrapper_t)(x64emu_t* emu, uintptr_t fnc);
 
+typedef struct symbol1_s {
+    wrapper_t   w;
+    int         resolved;
+    uintptr_t   addr;
+} symbol1_t;
+
 typedef struct symbol2_s {
     wrapper_t    w;
     const char*  name;
     int          weak;
+    int          resolved;
+    uintptr_t    addr;
 } symbol2_t;
 
-KHASH_MAP_DECLARE_STR(symbolmap, wrapper_t)
+KHASH_MAP_DECLARE_STR(symbolmap, symbol1_t)
 KHASH_MAP_DECLARE_STR(symbol2map, symbol2_t)
 KHASH_MAP_DECLARE_STR(datamap, uint64_t)
 
diff --git a/src/wrapped/wrappedlib_init.h b/src/wrapped/wrappedlib_init.h
index f6b52668..da1c785d 100644
--- a/src/wrapped/wrappedlib_init.h
+++ b/src/wrapped/wrappedlib_init.h
@@ -154,10 +154,12 @@ int FUNC(_init)(library_t* lib, box64context_t* box64)
 	for (int i = 0; i < cnt; ++i) {                                                 \
         if (MAPNAME(mapname)[i].weak) {                                             \
             k = kh_put(symbolmap, lib->w.w##mapname, MAPNAME(mapname)[i].name, &ret); \
-            kh_value(lib->w.w##mapname, k) = MAPNAME(mapname)[i].w;                   \
+            kh_value(lib->w.w##mapname, k).w = MAPNAME(mapname)[i].w;               \
+            kh_value(lib->w.w##mapname, k).resolved = 0;                            \
         } else {                                                                    \
-            k = kh_put(symbolmap, lib->w.mapname, MAPNAME(mapname)[i].name, &ret);    \
-            kh_value(lib->w.mapname, k) = MAPNAME(mapname)[i].w;                      \
+            k = kh_put(symbolmap, lib->w.mapname, MAPNAME(mapname)[i].name, &ret);  \
+            kh_value(lib->w.mapname, k).w = MAPNAME(mapname)[i].w;                  \
+            kh_value(lib->w.mapname, k).resolved = 0;                               \
         }                                                                           \
         if (strchr(MAPNAME(mapname)[i].name, '@'))                                  \
             AddDictionnary(box64->versym, MAPNAME(mapname)[i].name);                \
@@ -168,7 +170,7 @@ int FUNC(_init)(library_t* lib, box64context_t* box64)
     cnt = sizeof(MAPNAME(stsymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, lib->w.stsymbolmap, MAPNAME(stsymbolmap)[i].name, &ret);
-        kh_value(lib->w.stsymbolmap, k) = MAPNAME(stsymbolmap)[i].w;
+        kh_value(lib->w.stsymbolmap, k).w = MAPNAME(stsymbolmap)[i].w;
         if(strchr(MAPNAME(stsymbolmap)[i].name, '@'))
             AddDictionnary(box64->versym, MAPNAME(stsymbolmap)[i].name);
     }
@@ -178,6 +180,7 @@ int FUNC(_init)(library_t* lib, box64context_t* box64)
         kh_value(lib->w.symbol2map, k).name = MAPNAME(symbol2map)[i].name2;
         kh_value(lib->w.symbol2map, k).w = MAPNAME(symbol2map)[i].w;
         kh_value(lib->w.symbol2map, k).weak = MAPNAME(symbol2map)[i].weak;
+        kh_value(lib->w.symbol2map, k).resolved = 0;
         if(strchr(MAPNAME(symbol2map)[i].name, '@'))
             AddDictionnary(box64->versym, MAPNAME(symbol2map)[i].name);
     }
diff --git a/src/wrapped/wrappedlibgl.c b/src/wrapped/wrappedlibgl.c
index 1d5eb930..7712287e 100644
--- a/src/wrapped/wrappedlibgl.c
+++ b/src/wrapped/wrappedlibgl.c
@@ -264,8 +264,22 @@ static void* find_glGetVkProcAddrNV_Fct(void* fct)
 
 #define PRE_INIT if(box64_libGL) {lib->w.lib = dlopen(box64_libGL, RTLD_LAZY | RTLD_GLOBAL); lib->path = strdup(box64_libGL);} else
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->w.priv = dlsym(lib->w.lib, "glXGetProcAddress"); \
+    my_lib = lib;                                                               \
+    lib->w.priv = dlsym(lib->w.lib, "glXGetProcAddress");                       \
+    void* symb = dlsym(lib->w.lib, "glDebugMessageCallback");                   \
+    if(symb) {                                                                  \
+        k = kh_get(symbolmap, lib->w.mysymbolmap, "glDebugMessageCallback");    \
+        symbol1_t *s = &kh_value(lib->w.mysymbolmap, k);                        \
+        s->resolved = 1;                                                        \
+        s->addr = (uintptr_t)find_glDebugMessageCallback_Fct(symb);             \
+    }                                                                           \
+    symb = dlsym(lib->w.lib, "glXSwapIntervalMESA");                            \
+    if(symb) {                                                                  \
+        k = kh_get(symbolmap, lib->w.mysymbolmap, "glXSwapIntervalMESA");       \
+        symbol1_t *s = &kh_value(lib->w.mysymbolmap, k);                        \
+        s->resolved = 1;                                                        \
+        s->addr = (uintptr_t)find_glXSwapIntervalMESA_Fct(symb);                \
+    }                                                                           \
 
 #include "wrappedlib_init.h"
 
@@ -297,20 +311,23 @@ gl_wrappers_t* getGLProcWrapper(box64context_t* context, glprocaddress_t procadd
     cnt = sizeof(libglsymbolmap)/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, wrappers->glwrappers, libglsymbolmap[i].name, &ret);
-        kh_value(wrappers->glwrappers, k) = libglsymbolmap[i].w;
+        kh_value(wrappers->glwrappers, k).w = libglsymbolmap[i].w;
+        kh_value(wrappers->glwrappers, k).resolved = 0;
     }
     // and the my_ symbols map
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, wrappers->glwrappers, libglmysymbolmap[i].name, &ret);
-        kh_value(wrappers->glwrappers, k) = libglmysymbolmap[i].w;
+        kh_value(wrappers->glwrappers, k).w = libglmysymbolmap[i].w;
+        kh_value(wrappers->glwrappers, k).resolved = 0;
     }
     // my_* map
     wrappers->glmymap = kh_init(symbolmap);
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, wrappers->glmymap, libglmysymbolmap[i].name, &ret);
-        kh_value(wrappers->glmymap, k) = libglmysymbolmap[i].w;
+        kh_value(wrappers->glmymap, k).w = libglmysymbolmap[i].w;
+        kh_value(wrappers->glmymap, k).resolved = 0;
     }
     return wrappers;
 }
@@ -392,9 +409,14 @@ void* getGLProcAddress(x64emu_t* emu, glprocaddress_t procaddr, const char* rnam
         printf_dlsym(LOG_INFO, "Warning, no wrapper for %s\n", rname);
         return NULL;
     }
-    const char* constname = kh_key(wrappers->glwrappers, k);
-    AddOffsetSymbol(emu->context->maplib, symbol, rname);
-    ret = AddBridge(emu->context->system, kh_value(wrappers->glwrappers, k), symbol, 0, constname);
+    symbol1_t* s = &kh_value(wrappers->glwrappers, k);
+    if(!s->resolved) {
+        const char* constname = kh_key(wrappers->glwrappers, k);
+        AddOffsetSymbol(emu->context->maplib, symbol, rname);
+        s->addr = AddBridge(emu->context->system, s->w, symbol, 0, constname);
+        s->resolved = 1;
+    }
+    ret = s->addr;
     printf_dlsym(LOG_DEBUG, "%p\n", (void*)ret);
     return (void*)ret;
 }
diff --git a/src/wrapped/wrappedopenal.c b/src/wrapped/wrappedopenal.c
index 01b8c8e2..b9d35931 100644
--- a/src/wrapped/wrappedopenal.c
+++ b/src/wrapped/wrappedopenal.c
@@ -83,13 +83,15 @@ void fillALProcWrapper()
     cnt = sizeof(openalsymbolmap)/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, symbolmap, openalsymbolmap[i].name, &ret);
-        kh_value(symbolmap, k) = openalsymbolmap[i].w;
+        kh_value(symbolmap, k).w = openalsymbolmap[i].w;
+        kh_value(symbolmap, k).resolved = 0;
     }
     // and the my_ symbols map
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, symbolmap, openalmysymbolmap[i].name, &ret);
-        kh_value(symbolmap, k) = openalmysymbolmap[i].w;
+        kh_value(symbolmap, k).w = openalmysymbolmap[i].w;
+        kh_value(symbolmap, k).resolved = 0;
     }
     my_context->alwrappers = symbolmap;
     // fill my_* map
@@ -97,7 +99,8 @@ void fillALProcWrapper()
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, symbolmap, openalmysymbolmap[i].name, &ret);
-        kh_value(symbolmap, k) = openalmysymbolmap[i].w;
+        kh_value(symbolmap, k).w = openalmysymbolmap[i].w;
+        kh_value(symbolmap, k).resolved = 0;
     }
     my_context->almymap = symbolmap;
 }
@@ -134,19 +137,19 @@ EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name)
         symbol = my->alGetProcAddress(name);
     if(!symbol)
         return NULL;    // easy
-    // check if alread bridged
-    uintptr_t ret = CheckBridged(emu->context->system, symbol);
-    if(ret)
-        return (void*)ret; // already bridged
     // get wrapper
     k = kh_get(symbolmap, emu->context->alwrappers, rname);
     if(k==kh_end(emu->context->alwrappers)) {
         printf_log(LOG_INFO, "Warning, no wrapper for %s\n", rname);
         return NULL;
     }
-    const char* constname = kh_key(emu->context->alwrappers, k);
-    AddOffsetSymbol(emu->context->maplib, symbol, rname);
-    return (void*)AddBridge(emu->context->system, kh_value(emu->context->alwrappers, k), symbol, 0, constname);
+    symbol1_t *s = &kh_value(emu->context->alwrappers, k);
+    if(!s->resolved) {
+        const char* constname = kh_key(emu->context->alwrappers, k);
+        s->addr = AddBridge(emu->context->system, s->w, symbol, 0, constname);
+        s->resolved = 1;
+    }
+    return (void*)s->addr;
 }
 
 EXPORT void* my_alcGetProcAddress(x64emu_t* emu, void* device, void* name)
@@ -170,18 +173,19 @@ EXPORT void* my_alcGetProcAddress(x64emu_t* emu, void* device, void* name)
         symbol = my->alcGetProcAddress(device, name);
     if(!symbol)
         return NULL;    // easy
-    uintptr_t ret = CheckBridged(emu->context->system, symbol);
-    if(ret)
-        return (void*)ret; // already bridged
     // get wrapper
     k = kh_get(symbolmap, emu->context->alwrappers, rname);
     if(k==kh_end(emu->context->alwrappers)) {
         printf_log(LOG_INFO, "Warning, no wrapper for %s\n", rname);
         return NULL;
     }
-    const char* constname = kh_key(emu->context->alwrappers, k);
-    AddOffsetSymbol(emu->context->maplib, symbol, rname);
-    return (void*)AddBridge(emu->context->system, kh_value(emu->context->alwrappers, k), symbol, 0, constname);
+    symbol1_t *s = &kh_value(emu->context->alwrappers, k);
+    if(!s->resolved) {
+        const char* constname = kh_key(emu->context->alwrappers, k);
+        s->addr = AddBridge(emu->context->system, s->w, symbol, 0, constname);
+        s->resolved = 1;
+    }
+    return (void*)s->addr;
 }
 
 EXPORT void my_alRequestFoldbackStart(x64emu_t *emu, int32_t mode, int32_t count, int32_t length, void* mem, void* cb)
diff --git a/src/wrapped/wrappedvulkan.c b/src/wrapped/wrappedvulkan.c
index 8cba5772..973b4ef1 100644
--- a/src/wrapped/wrappedvulkan.c
+++ b/src/wrapped/wrappedvulkan.c
@@ -34,26 +34,21 @@ typedef void(*vFpUp_t)      (void*, uint64_t, void*);
 #define ADDED_SUPER 1
 #include "wrappercallback.h"
 
-void updateInstance(vulkan_my_t* my)
+static void updateInstance(x64emu_t* emu, vulkan_my_t* my)
 {
     void* p;
     #define GO(A, W) p = my_context->vkprocaddress(my->currentInstance, #A); if(p) my->A = p;
     SUPER()
     #undef GO
+    symbol1_t* s;
+    kh_foreach_value_ref(emu->context->vkwrappers, s, s->resolved = 0;)
 }
 
 void fillVulkanProcWrapper(box64context_t*);
 void freeVulkanProcWrapper(box64context_t*);
 
-static void* resolveSymbol(x64emu_t* emu, void* symbol, const char* rname)
+static symbol1_t* getWrappedSymbol(x64emu_t* emu, const char* rname, int warning)
 {
-    // check if alread bridged
-    uintptr_t ret = CheckBridged(emu->context->system, symbol);
-    if(ret) {
-        printf_dlsym(LOG_DEBUG, "%p\n", (void*)ret);
-        return (void*)ret; // already bridged
-    }
-    // get wrapper
     khint_t k = kh_get(symbolmap, emu->context->vkwrappers, rname);
     if(k==kh_end(emu->context->vkwrappers) && strstr(rname, "KHR")==NULL) {
         // try again, adding KHR at the end if not present
@@ -63,15 +58,28 @@ static void* resolveSymbol(x64emu_t* emu, void* symbol, const char* rname)
         k = kh_get(symbolmap, emu->context->vkwrappers, tmp);
     }
     if(k==kh_end(emu->context->vkwrappers)) {
-        printf_dlsym(LOG_DEBUG, "%p\n", NULL);
-        printf_dlsym(LOG_INFO, "Warning, no wrapper for %s\n", rname);
+        if(warning) {
+            printf_dlsym(LOG_DEBUG, "%p\n", NULL);
+            printf_dlsym(LOG_INFO, "Warning, no wrapper for %s\n", rname);
+        }
         return NULL;
     }
-    const char* constname = kh_key(emu->context->vkwrappers, k);
-    AddOffsetSymbol(emu->context->maplib, symbol, constname);
-    ret = AddBridge(emu->context->system, kh_value(emu->context->vkwrappers, k), symbol, 0, constname);
-    printf_dlsym(LOG_DEBUG, "%p (%p)\n", (void*)ret, symbol);
-    return (void*)ret;
+    return &kh_value(emu->context->vkwrappers, k);
+}
+
+static void* resolveSymbol(x64emu_t* emu, void* symbol, const char* rname)
+{
+    // get wrapper
+    symbol1_t *s = getWrappedSymbol(emu, rname, 1);
+    if(!s->resolved) {
+        khint_t k = kh_get(symbolmap, emu->context->vkwrappers, rname);
+        const char* constname = kh_key(emu->context->vkwrappers, k);
+        s->addr = AddBridge(emu->context->system, s->w, symbol, 0, constname);
+        s->resolved = 1;
+    }
+    void* ret = (void*)s->addr;
+    printf_dlsym(LOG_DEBUG, "%p (%p)\n", ret, symbol);
+    return ret;
 }
 
 EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name)
@@ -82,6 +90,12 @@ EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name)
     printf_dlsym(LOG_DEBUG, "Calling my_vkGetDeviceProcAddr(%p, \"%s\") => ", device, rname);
     if(!emu->context->vkwrappers)
         fillVulkanProcWrapper(emu->context);
+    symbol1_t* s = getWrappedSymbol(emu, rname, 0);
+    if(s && s->resolved) {
+        void* ret = (void*)s->addr;
+        printf_dlsym(LOG_DEBUG, "%p (cached)\n", ret);
+        return ret;
+    }
     k = kh_get(symbolmap, emu->context->vkmymap, rname);
     int is_my = (k==kh_end(emu->context->vkmymap))?0:1;
     void* symbol = my->vkGetDeviceProcAddr(device, name);
@@ -113,7 +127,13 @@ EXPORT void* my_vkGetInstanceProcAddr(x64emu_t* emu, void* instance, void* name)
         fillVulkanProcWrapper(emu->context);
     if(instance!=my->currentInstance) {
         my->currentInstance = instance;
-        updateInstance(my);
+        updateInstance(emu, my);
+    }
+    symbol1_t* s = getWrappedSymbol(emu, rname, 0);
+    if(s && s->resolved) {
+        void* ret = (void*)s->addr;
+        printf_dlsym(LOG_DEBUG, "%p (cached)\n", ret);
+        return ret;
     }
     // check if vkprocaddress is filled, and search for lib and fill it if needed
     // get proc adress using actual glXGetProcAddress
@@ -146,6 +166,12 @@ void* my_GetVkProcAddr(x64emu_t* emu, void* name, void*(*getaddr)(const char*))
     printf_dlsym(LOG_DEBUG, "Calling my_GetVkProcAddr(\"%s\", %p) => ", rname, getaddr);
     if(!emu->context->vkwrappers)
         fillVulkanProcWrapper(emu->context);
+    symbol1_t* s = getWrappedSymbol(emu, rname, 0);
+    if(s && s->resolved) {
+        void* ret = (void*)s->addr;
+        printf_dlsym(LOG_DEBUG, "%p (cached)\n", ret);
+        return ret;
+    }
     // check if vkprocaddress is filled, and search for lib and fill it if needed
     // get proc adress using actual glXGetProcAddress
     k = kh_get(symbolmap, emu->context->vkmymap, rname);
@@ -349,13 +375,15 @@ void fillVulkanProcWrapper(box64context_t* context)
     cnt = sizeof(vulkansymbolmap)/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, symbolmap, vulkansymbolmap[i].name, &ret);
-        kh_value(symbolmap, k) = vulkansymbolmap[i].w;
+        kh_value(symbolmap, k).w = vulkansymbolmap[i].w;
+        kh_value(symbolmap, k).resolved = 0;
     }
     // and the my_ symbols map
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, symbolmap, vulkanmysymbolmap[i].name, &ret);
-        kh_value(symbolmap, k) = vulkanmysymbolmap[i].w;
+        kh_value(symbolmap, k).w = vulkanmysymbolmap[i].w;
+        kh_value(symbolmap, k).resolved = 0;
     }
     context->vkwrappers = symbolmap;
     // my_* map
@@ -363,7 +391,8 @@ void fillVulkanProcWrapper(box64context_t* context)
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
     for (int i=0; i<cnt; ++i) {
         k = kh_put(symbolmap, symbolmap, vulkanmysymbolmap[i].name, &ret);
-        kh_value(symbolmap, k) = vulkanmysymbolmap[i].w;
+        kh_value(symbolmap, k).w = vulkanmysymbolmap[i].w;
+        kh_value(symbolmap, k).resolved = 0;
     }
     context->vkmymap = symbolmap;
 }