Bumped to version v0.2.8

Add MOV GS:od, AL

CMakeLists.txt

@@ -516,7 +516,6 @@ if(ARM_DYNAREC)
         "${BOX86_ROOT}/src/dynarec/dynarec_arm.c"
         "${BOX86_ROOT}/src/dynarec/dynarec_arm_functions.c"
         "${BOX86_ROOT}/src/dynarec/arm_printer.c"
-        "${BOX86_ROOT}/src/dynarec/arm_jmpnext.c"
 
         "${BOX86_ROOT}/src/dynarec/arm_prolog.S"
         "${BOX86_ROOT}/src/dynarec/arm_epilog.S"

docs/CHANGELOG.md

@@ -1,3 +1,22 @@
+v0.2.8
+======
+* Wrapped more vulkan function, dxvk 2.0 now works
+* Added support for overriden malloc/free functions
+* Improved elf loader
+* Improved dlsym handling with RTLD_NEXT
+* Added BOX86_DYNAREC_SAFEFLAGS to allow finetuning Dynarec generated code handling of flags accross function calls and returns.
+* Added BOX86_BASH to setup x86 bash binary, so shell script can be run in x86 world 
+* Added BOX86_ROLLING_LOG to have details log only on crash
+* Improved TLS Size handling (Unity3D games now works)
+* Improved `execv` family of function to have better box86 integration
+* Added a few more wrapped libs, like FAudio
+* Improved gtk, SDL2, GL, vulkan (and more) wrapping
+* Improved Signal Handling and memory protection traking
+* Added some basic support for statically linked program. Thread are not working yet, but memory allocation and file access does.
+=> with the use of the new SafeFlags, some C# Windows program now runs fine (it's forced when the Vara family of software is detected)
+=> With the basic support of statcaly linked program, old emulator like modeler for linux works. Program with threads like mugen for linux still doesn't
+=> The bash integration is usefull for device with no binfmt integration or for script that check the machine it's running on
+
 v0.2.6
 ======
 * Added an option to get generated -NAN on SSE2 operation

docs/README.md

@@ -12,13 +12,13 @@ Box86 lets you run x86 Linux programs (such as games) on non-x86 Linux systems,
 
 You *NEED* a 32-bit subsystem to run and build Box86. Box86 is useless on 64-bit only systems. Also, you *NEED* a 32-bit toolchain to build Box86. A toolchain that only supports 64-bit will not compile Box86, and you'll get errors (typically on aarch64, you get "-marm" not recognized, and you'll need a multiarch or chroot environment).
 
-Because Box86 uses the native versions of some "system" libraries, like libc, libm, SDL, and OpenGL, it's easy to integrate and use with most applications, and performance can be surprisingly high in many cases. Take a look at those bench analysis for an example [here](https://box86.org/index.php/2021/06/game-performances/).
+Because Box86 uses the native versions of some "system" libraries, like libc, libm, SDL, and OpenGL, it's easy to integrate and use with most applications, and performance can be surprisingly high in many cases. Take a look at those bench analysis for an example [here](https://box86.org/index.php/2021/06/game-performances/). That also means that you will need a 32bits userspace on 64bits OS, like `armhf` on top an ̀`aarch64` 64bits OS.
 
-Most x86 Games need OpenGL, so on ARM platforms a solution like [gl4es](https://github.com/ptitSeb/gl4es) is usually necessary. (Most ARM platforms only support OpenGL ES and/or their OpenGL implementation is dodgy (see OpenGL on Android).)
+Most x86 Games need OpenGL, so on ARM platforms a solution like [gl4es](https://github.com/ptitSeb/gl4es) might be necessary. (Some ARM platforms only support OpenGL ES and/or their OpenGL implementation is dodgy (see OpenGL on Android).)
 
 Box86 now integrates a DynaRec (dynamic recompiler) for the ARM platform, providing a speed boost between 5 to 10 times faster than only using the interpreter. Some high level information on how the Dynarec work can be found [here](https://box86.org/2021/07/inner-workings-a-high%e2%80%91level-view-of-box86-and-a-low%e2%80%91level-view-of-the-dynarec/).
 
-Many games already work without much tweaking, for example: WorldOfGoo, Airline Tycoon Deluxe, and FTL. Many of the GameMaker Linux games also run fine. (there's a long list, among them are UNDERTALE, A Risk of Rain, and Cook Serve Delicious)
+Many games just work without much tweaking, for example: WorldOfGoo, Airline Tycoon Deluxe, and FTL. Many of the GameMaker Linux games also run fine. (there's a long list, among them are UNDERTALE, A Risk of Rain, and Cook Serve Delicious). Unity3D games also works fine, but the OpenGL requirement might be an issue on some ARM platforms.
 
 If you are serious about developing Box86, you should install ccache and build Box86 with it. (Use ccmake for example.)
 To enable TRACE (i.e. dumping to stdout all individual x86 instructions executed, with dump of registers), you'll also need [Zydis library](https://github.com/zyantific/zydis) available on your system.
@@ -56,7 +56,7 @@ There are a few environment variables to control the behaviour of Box86.
 
 See [here](USAGE.md) for all environment variables and what they do.
 
-Note: Box86's Dynarec uses a mechanism with Memory Protection and a SegFault signal handler to handle JIT code. In simpler terms, if you want to use GDB to debug a running program that use JIT'd code (like mono/Unity3D), you will still have many "normal" segfaults triggering. It is suggested to use something like `handle SIGSEGV nostop` in GDB to not stop at each segfault, and maybe put a breakpoint inside `my_memprotectionhandler` in `signals.c` if you want to trap SegFaults.
+Note: Box86's Dynarec uses a mechanism with Memory Protection and a SegFault signal handler to handle JIT code. In simpler terms, if you want to use GDB to debug a running program that use JIT'd code (like mono/Unity3D), you will still have many "normal" segfaults triggering. It is suggested to use something like `handle SIGSEGV nostop` in GDB to not stop at each segfault, and maybe put a breakpoint inside `my_box86signalhandler` in `signals.c` if you want to trap SegFaults.
 
 ----
 
@@ -79,10 +79,8 @@ If you look at a 64bits version of box86, look at [Box64](https://github.com/pti
 Notes about Unity game emulation
 ----
 
-Running Unity games is a hit or miss for now. Unity uses Mono (which uses signals that are not well emulated enough), and a runtime embedded in the main binary. A solution would be to use a native version of the libmono library used by Unity (it can be found here: https://github.com/Unity-Technologies/mono and needs to be built from source). But the wrapping of this lib is tricky, and not done for now, so the only solution is to emulate everything. The tricky part is to emulate the "JIT" code emitted by Mono, however with the new "protected memory" mechanism implemented it should be running with correct performance now.
-You should also note that some Unity3D games require OpenGL 3+ which can be tricky to provide on ARM SBC (single-board computers) for now.
-
-TL;DR: Not all Unity games work and can require a high OpenGL profile, but the speed, for the ones running, should be correct now.
+Running Unity games shoudl generaly work now, but you should also note that many Unity3D games require OpenGL 3+ which can be tricky to provide on ARM SBC (single-board computers) for now.
+Hint: on Pi4, use `MESA_GL_VERSION_OVERRIDE=3.2` and with Panfrost use `PAN_MESA_DEBUG=gl3` to use higher profile if the game starts then quits before showing anything.
 
 ----
 
@@ -112,7 +110,7 @@ Note: if you plan to use box86 with Wine on Raspberry Pi 3 or earlier, those mod
 Notes about Vulkan
 ----
 
-Box86 already wrap Vulkan. If your system has a 32bits Vulkan driver, box86 will use it when needed. Note that Vulkan wrapping has not been tested much, due to the limited Vulkan support on the hardware I currently own. Profile 1.0 and 1.1, with some extension, should be OK. 1.2 is not really wrapped. I know some demos work on Pi4 (Sascha Willems demos build for x86 work the same as if build on armhf directly). Note that the Vulkan driver of the Pi4 DOES NOT support dxvk for now (wine DirectX->Vulkan wrapper). It's not a box86 issue, it's missing extensions (hardware support) and a few other things that make dxvk not working on pi4. On Panfrost side, PanVK is a bit young and I haven't tested dxvk with it yet.
+Box86 already wrap Vulkan. If your system has a 32bits Vulkan driver, box86 will use it when needed. Profile 1.0, 1.1, 1.2 and 1.3, with some extensions, should be OK. DXVK, including the 2.0, works. I know some demos work on Pi4 (Sascha Willems demos build for x86 work the same as if build on armhf directly). Note that the Vulkan driver of the Pi4 DOES NOT support dxvk for now (wine DirectX->Vulkan wrapper). It's not a box86 issue, it's missing extensions (hardware support) and a few other things that make dxvk not working on pi4. On Panfrost side, PanVK is a bit young and I haven't tested dxvk with it yet.
 
 ----
 Final word

docs/USAGE.md

@@ -19,7 +19,8 @@ Controls the Dump of elf content
 #### BOX86_ROLLING_LOG
 Show last few wrapped function call when a Signal is caught
  * 0: No last function call printed (Default.)
- * 1: Last few wrapped function call printed when a signal is printed. Incompatible with BOX86_LOG>1 (may need BOX86_SHOWSEGV=1 also)
+ * 1: Last 16 wrapped functions calls printed when a signal is printed. Incompatible with BOX86_LOG>1 (may need BOX86_SHOWSEGV=1 also)
+ * N: Last N wrapped functions calls printed when a signal is printed. Incompatible with BOX86_LOG>1 (may need BOX86_SHOWSEGV=1 also)
 
 #### BOX86_NOBANNER
 Disables Box86 printing its version and build

src/box86context.c

@@ -151,6 +151,31 @@ static void atfork_child_box64context(void)
     init_mutexes(my_context);
 }
 
+void freeCycleLog(box86context_t* ctx)
+{
+    if(cycle_log) {
+        for(int i=0; i<cycle_log; ++i) {
+            box_free(ctx->log_call[i]);
+            box_free(ctx->log_ret[i]);
+        }
+        box_free(ctx->log_call);
+        box_free(ctx->log_ret);
+        ctx->log_call = NULL;
+        ctx->log_ret = NULL;
+    }
+}
+void initCycleLog(box86context_t* context)
+{
+    if(cycle_log) {
+        context->log_call = (char**)box_calloc(cycle_log, sizeof(char*));
+        context->log_ret = (char**)box_calloc(cycle_log, sizeof(char*));
+        for(int i=0; i<cycle_log; ++i) {
+            context->log_call[i] = (char*)box_calloc(256, 1);
+            context->log_ret[i] = (char*)box_calloc(128, 1);
+        }
+    }
+}
+
 EXPORTDYN
 box86context_t *NewBox86Context(int argc)
 {
@@ -163,11 +188,8 @@ box86context_t *NewBox86Context(int argc)
     // init and put default values
     box86context_t *context = my_context = (box86context_t*)box_calloc(1, sizeof(box86context_t));
 
-    if(cycle_log)
-        for(int i=0; i<CYCLE_LOG; ++i) {
-            context->log_call[i] = (char*)box_calloc(256, 1);
-            context->log_ret[i] = (char*)box_calloc(128, 1);
-        }
+    initCycleLog(context);
+
 #ifdef BUILD_LIB
     context->deferedInit = 0;
 #else
@@ -332,11 +354,7 @@ void FreeBox86Context(box86context_t** context)
     pthread_mutex_destroy(&ctx->mutex_thread);
     pthread_mutex_destroy(&ctx->mutex_bridge);
 
-    if(cycle_log)
-        for(int i=0; i<CYCLE_LOG; ++i) {
-            box_free(ctx->log_call[i]);
-            box_free(ctx->log_ret[i]);
-        }
+    freeCycleLog(ctx);
 
     box_free(ctx);
 }

src/box86version.h

@@ -3,6 +3,6 @@
 
 #define BOX86_MAJOR 0
 #define BOX86_MINOR 2
-#define BOX86_REVISION 7
+#define BOX86_REVISION 8
 
 #endif //__BOX86_VERSION_H_

src/custommem.c

@@ -25,7 +25,6 @@
 #ifdef DYNAREC
 #include "dynablock.h"
 #include "dynarec/arm_lock_helper.h"
-#include "dynarec/dynarec_next.h"
 #include "khash.h"
 
 #define USE_MMAP
@@ -33,6 +32,7 @@
 
 // init inside dynablocks.c
 KHASH_MAP_INIT_INT(dynablocks, dynablock_t*)
+static dynablocklist_t*    dynmap[DYNAMAP_SIZE] = {0};     // 4G of memory mapped by 4K block
 static mmaplist_t          *mmaplist = NULL;
 static int                 mmapsize = 0;
 static int                 mmapcap = 0;
@@ -45,12 +45,7 @@ static kh_lockaddress_t    *lockaddress = NULL;
 #endif
 #define MEMPROT_SHIFT 12
 #define MEMPROT_SIZE (1<<(32-MEMPROT_SHIFT))
-typedef struct memprot_s
-{
-    uint8_t prot;
-    uint8_t hot;
-} memprot_t;
-static memprot_t             memprot[MEMPROT_SIZE] = {0};    // protection flags by 4K block
+static uint8_t             memprot[MEMPROT_SIZE] = {0};    // protection flags by 4K block
 static int inited = 0;
 
 typedef struct mapmem_s {
@@ -64,15 +59,13 @@ typedef struct blocklist_s {
     void*               block;
     int                 maxfree;
     size_t              size;
-    void*               first;
 } blocklist_t;
 
 #define MMAPSIZE (256*1024)      // allocate 256kb sized blocks
 
 static pthread_mutex_t     mutex_blocks;
-static int                 n_blocks = 0;        // number of blocks for custom malloc
-static int                 c_blocks = 0;        // capacity of blocks for custom malloc
-static blocklist_t*        p_blocks = NULL;     // actual blocks for custom malloc
+static int                 n_blocks = 0;       // number of blocks for custom malloc
+static blocklist_t*        p_blocks = NULL;    // actual blocks for custom malloc
 
 typedef union mark_s {
     struct {
@@ -116,23 +109,6 @@ static void* getFirstBlock(void* block, size_t maxsize, size_t* size, void* star
     return NULL;
 }
 
-static void* getNextFreeBlock(void* block)
-{
-    blockmark_t *m = (blockmark_t*)block;
-    while (m->next.fill) {
-         m = NEXT_BLOCK(m);
-    };
-    return m;
-}
-static void* getPrevFreeBlock(void* block)
-{
-    blockmark_t *m = (blockmark_t*)block;
-    do {
-         m = PREV_BLOCK(m);
-    } while (m->next.fill);
-    return m;
-}
-
 static size_t getMaxFreeBlock(void* block, size_t block_size, void* start)
 {
     // get start of block
@@ -263,37 +239,19 @@ static size_t sizeBlock(void* sub)
     return s->next.size;
 }
 
-#define THRESHOLD   (128-2*sizeof(blockmark_t))
-
-static size_t roundSize(size_t size)
-{
-    if(!size)
-        return size;
-    size = (size+7)&~7LL;   // 8 bytes align in size
-
-    if(size<THRESHOLD)
-        size = THRESHOLD;
-
-    return size;
-}
-
 void* customMalloc(size_t size)
 {
-    size = roundSize(size);
     // look for free space
     void* sub = NULL;
-    size_t fullsize = size+2*sizeof(blockmark_t);
     pthread_mutex_lock(&mutex_blocks);
     for(int i=0; i<n_blocks; ++i) {
         if(p_blocks[i].maxfree>=size) {
             size_t rsize = 0;
-            sub = getFirstBlock(p_blocks[i].block, size, &rsize, p_blocks[i].first);
+            sub = getFirstBlock(p_blocks[i].block, size, &rsize, NULL);
             if(sub) {
-                if(rsize-size<THRESHOLD)
-                    size = rsize;
                 void* ret = allocBlock(p_blocks[i].block, sub, size, NULL);
                 if(rsize==p_blocks[i].maxfree)
-                    p_blocks[i].maxfree = getMaxFreeBlock(p_blocks[i].block, p_blocks[i].size, p_blocks[i].first);
+                    p_blocks[i].maxfree = getMaxFreeBlock(p_blocks[i].block, p_blocks[i].size, NULL);
                 pthread_mutex_unlock(&mutex_blocks);
                 return ret;
             }
@@ -301,11 +259,10 @@ void* customMalloc(size_t size)
     }
     // add a new block
     int i = n_blocks++;
-    if(n_blocks>c_blocks) {
-        c_blocks += 4;
-        p_blocks = (blocklist_t*)box_realloc(p_blocks, c_blocks*sizeof(blocklist_t));
-    }
-    size_t allocsize = (fullsize>MMAPSIZE)?fullsize:MMAPSIZE;
+    p_blocks = (blocklist_t*)box_realloc(p_blocks, n_blocks*sizeof(blocklist_t));
+    size_t allocsize = MMAPSIZE;
+    if(size+2*sizeof(blockmark_t)>allocsize)
+        allocsize = size+2*sizeof(blockmark_t);
     #ifdef USE_MMAP_MORE
     void* p = mmap(NULL, allocsize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     memset(p, 0, allocsize);
@@ -314,7 +271,6 @@ void* customMalloc(size_t size)
     void* p = box_calloc(1, allocsize);
     #endif
     p_blocks[i].block = p;
-    p_blocks[i].first = p;
     p_blocks[i].size = allocsize;
     // setup marks
     blockmark_t* m = (blockmark_t*)p;
@@ -333,7 +289,7 @@ void* customMalloc(size_t size)
 }
 void* customCalloc(size_t n, size_t size)
 {
-    size_t newsize = roundSize(n*size);
+    size_t newsize = n*size;
     void* ret = customMalloc(newsize);
     memset(ret, 0, newsize);
     return ret;
@@ -342,7 +298,6 @@ void* customRealloc(void* p, size_t size)
 {
     if(!p)
         return customMalloc(size);
-    size = roundSize(size);
     uintptr_t addr = (uintptr_t)p;
     pthread_mutex_lock(&mutex_blocks);
     for(int i=0; i<n_blocks; ++i) {
@@ -350,9 +305,7 @@ void* customRealloc(void* p, size_t size)
          && (addr<((uintptr_t)p_blocks[i].block+p_blocks[i].size))) {
             void* sub = (void*)(addr-sizeof(blockmark_t));
             if(expandBlock(p_blocks[i].block, sub, size)) {
-                if(sub<p_blocks[i].first && p+size<p_blocks[i].first)
-                    p_blocks[i].first = getNextFreeBlock(sub);
-                p_blocks[i].maxfree = getMaxFreeBlock(p_blocks[i].block, p_blocks[i].size, p_blocks[i].first);
+                p_blocks[i].maxfree = getMaxFreeBlock(p_blocks[i].block, p_blocks[i].size, NULL);
                 pthread_mutex_unlock(&mutex_blocks);
                 return p;
             }
@@ -378,10 +331,7 @@ void customFree(void* p)
         if ((addr>(uintptr_t)p_blocks[i].block) 
          && (addr<((uintptr_t)p_blocks[i].block+p_blocks[i].size))) {
             void* sub = (void*)(addr-sizeof(blockmark_t));
-            void* n = NEXT_BLOCK((blockmark_t*)sub);
             size_t newfree = freeBlock(p_blocks[i].block, sub, NULL);
-            if(sub<=p_blocks[i].first)
-                p_blocks[i].first = getPrevFreeBlock(n);
             if(p_blocks[i].maxfree < newfree) p_blocks[i].maxfree = newfree;
             pthread_mutex_unlock(&mutex_blocks);
             return;
@@ -408,40 +358,35 @@ uintptr_t FindFreeDynarecMap(dynablock_t* db, int size)
     // look for free space
     void* sub = NULL;
     for(int i=0; i<mmapsize; ++i) {
-        if(mmaplist[i].maxfree>=size+sizeof(blockmark_t)) {
-            if(!arm_lock_xchg(&mmaplist[i].locked, 1)) {
-                size_t rsize = 0;
-                sub = getFirstBlock(mmaplist[i].block, size, &rsize, mmaplist[i].first);
-                if(sub) {
-                    uintptr_t ret = (uintptr_t)allocBlock(mmaplist[i].block, sub, size, &mmaplist[i].first);
-                    if(rsize==mmaplist[i].maxfree) {
-                        mmaplist[i].maxfree = getMaxFreeBlock(mmaplist[i].block, mmaplist[i].size, mmaplist[i].first);
-                    }
-                    kh_dynablocks_t *blocks = mmaplist[i].dblist;
-                    if(!blocks) {
-                        blocks = mmaplist[i].dblist = kh_init(dynablocks);
-                        kh_resize(dynablocks, blocks, 64);
-                    }
-                    khint_t k;
-                    int r;
-                    k = kh_put(dynablocks, blocks, (uintptr_t)ret, &r);
-                    kh_value(blocks, k) = db;
-                    int size255=(size<256)?size:255;
-                    for(size_t j=0; j<size255; ++j)
-                        mmaplist[i].helper[(uintptr_t)ret-(uintptr_t)mmaplist[i].block+j] = j;
-                    if(size!=size255)
-                        memset(&mmaplist[i].helper[(uintptr_t)ret-(uintptr_t)mmaplist[i].block+256], -1, size-255);
-                    arm_lock_store(&mmaplist[i].locked, 0);
-                    return ret;
-                } else {
-                    printf_log(LOG_INFO, "BOX86: Warning, sub not found, corrupted mmaplist[%d] info (requested size=%d)?\n", i, size);
-                    if(box86_log >= LOG_DEBUG)
-                        printBlock(mmaplist[i].block, mmaplist[i].first);
-                    // reset block meta info
-                    mmaplist[i].first = getFirstBlock(mmaplist[i].block, 1, &rsize, NULL);
-                    mmaplist[i].maxfree = getMaxFreeBlock(mmaplist[i].block, mmaplist[i].size, NULL);
-                    arm_lock_store(&mmaplist[i].locked, 0);
+        if(mmaplist[i].maxfree>=size+sizeof(blockmark_t) && !mmaplist[i].locked) {
+            mmaplist[i].locked = 1;
+            size_t rsize = 0;
+            sub = getFirstBlock(mmaplist[i].block, size, &rsize, mmaplist[i].first);
+            if(sub) {
+                uintptr_t ret = (uintptr_t)allocBlock(mmaplist[i].block, sub, size, &mmaplist[i].first);
+                if(rsize==mmaplist[i].maxfree) {
+                    mmaplist[i].maxfree = getMaxFreeBlock(mmaplist[i].block, mmaplist[i].size, mmaplist[i].first);
                 }
+                kh_dynablocks_t *blocks = mmaplist[i].dblist;
+                if(!blocks) {
+                    blocks = mmaplist[i].dblist = kh_init(dynablocks);
+                    kh_resize(dynablocks, blocks, 64);
+                }
+                khint_t k;
+                int r;
+                k = kh_put(dynablocks, blocks, (uintptr_t)ret, &r);
+                kh_value(blocks, k) = db;
+                int size255=(size<256)?size:255;
+                for(size_t j=0; j<size255; ++j)
+                    mmaplist[i].helper[(uintptr_t)ret-(uintptr_t)mmaplist[i].block+j] = j;
+                if(size!=size255)
+                    memset(&mmaplist[i].helper[(uintptr_t)ret-(uintptr_t)mmaplist[i].block+256], -1, size-255);
+                mmaplist[i].locked = 0;
+                return ret;
+            } else {
+                printf_log(LOG_INFO, "BOX86: Warning, sub not found, corrupted mmaplist[%d] info?\n", i);
+                if(box86_log >= LOG_DEBUG)
+                    printBlock(mmaplist[i].block, mmaplist[i].first);
             }
         }
     }
@@ -474,7 +419,7 @@ uintptr_t AddNewDynarecMap(dynablock_t* db, int size)
     #endif
     setProtection((uintptr_t)p, MMAPSIZE, PROT_READ | PROT_WRITE | PROT_EXEC);
 
-    arm_lock_store(&mmaplist[i].locked, 1);
+    mmaplist[i].locked = 1;
     mmaplist[i].block = p;
     mmaplist[i].size = MMAPSIZE;
     mmaplist[i].helper = (uint8_t*)box_calloc(1, MMAPSIZE);
@@ -499,7 +444,7 @@ uintptr_t AddNewDynarecMap(dynablock_t* db, int size)
     kh_value(blocks, k) = db;
     for(int j=0; j<size; ++j)
         mmaplist[i].helper[(uintptr_t)sub-(uintptr_t)mmaplist[i].block + j] = (j<256)?j:255;
-    arm_lock_store(&mmaplist[i].locked, 0);
+    mmaplist[i].locked = 0;
     return sub;
 }
 
@@ -510,12 +455,6 @@ void ActuallyFreeDynarecMap(dynablock_t* db, uintptr_t addr, int size)
     for(int i=0; i<mmapsize; ++i) {
         if ((addr>(uintptr_t)mmaplist[i].block) 
          && (addr<((uintptr_t)mmaplist[i].block+mmaplist[i].size))) {
-            // wait the map is free
-            int cnt = 100;
-            while(my_context && cnt && arm_lock_store_xchg(&mmaplist[i].locked, (void*)1)) {
-                --cnt;
-                sched_yield();
-            }
             void* sub = (void*)(addr-sizeof(blockmark_t));
             size_t newfree = freeBlock(mmaplist[i].block, sub, &mmaplist[i].first);
             if(mmaplist[i].maxfree < newfree) mmaplist[i].maxfree = newfree;
@@ -526,7 +465,10 @@ void ActuallyFreeDynarecMap(dynablock_t* db, uintptr_t addr, int size)
                     kh_del(dynablocks, blocks, k);
                 memset(&mmaplist[i].helper[(uintptr_t)sub-(uintptr_t)mmaplist[i].block], 0, size);
             }
-            arm_lock_store(&mmaplist[i].locked, 0);
+            if(mmaplist[i].locked) {
+                printf_log(LOG_INFO, "BOX86: Warning, Free a chunk in a locked mmaplist[%d]\n", i);
+                ++mmaplist[i].locked;
+            }
             return;
         }
     }
@@ -616,23 +558,9 @@ void FreeDynarecMap(dynablock_t* db, uintptr_t addr, uint32_t size)
     ActuallyFreeDynarecMap(db, addr, size);
 }
 
-dynablock_t* getDB(uintptr_t addr)
+dynablocklist_t* getDB(uintptr_t idx)
 {
-    if(isJumpTableDefault((void*)addr))
-        return NULL;
-    uintptr_t ret = getJumpAddress(addr);
-    return *(dynablock_t**)(ret-sizeof(void*));
-}
-
-uintptr_t getDefaultSize(uintptr_t addr)
-{
-    uintptr_t idx = ((uintptr_t)addr>>JMPTABL_SHIFT);
-    if(box86_jumptable[idx] == box86_jmptbl_default)
-        return (addr&~((1<<JMPTABL_SHIFT)-1)|0xffff)-addr + 1;
-    uintptr_t idx0 = addr&0xffff;
-    while(box86_jumptable[idx][idx0]==(uintptr_t)arm_next)
-        ++idx0;
-    return idx0 - (addr&0xffff);
+    return dynmap[idx];
 }
 
 // each dynmap is 64k of size
@@ -640,30 +568,38 @@ uintptr_t getDefaultSize(uintptr_t addr)
 void addDBFromAddressRange(uintptr_t addr, uintptr_t size)
 {
     dynarec_log(LOG_DEBUG, "addDBFromAddressRange %p -> %p\n", (void*)addr, (void*)(addr+size-1));
-    // do nothing, dynablock are allowed based on memory protection flags
+    uintptr_t idx = (addr>>DYNAMAP_SHIFT);
+    uintptr_t end = ((addr+size-1)>>DYNAMAP_SHIFT);
+    for (uintptr_t i=idx; i<=end; ++i) {
+        if(!dynmap[i]) {
+            dynablocklist_t* p = NewDynablockList(i<<DYNAMAP_SHIFT, 1<<DYNAMAP_SHIFT, 0);
+            if(arm_lock_storeifnull(&dynmap[i], p)!=p)
+                FreeDynablockList(&p);
+        }
+    }
 }
 
 void cleanDBFromAddressRange(uintptr_t addr, uintptr_t size, int destroy)
 {
     dynarec_log(LOG_DEBUG, "cleanDBFromAddressRange %p -> %p %s\n", (void*)addr, (void*)(addr+size-1), destroy?"destroy":"mark");
-    uintptr_t start_addr = my_context?((addr<my_context->max_db_size)?0:(addr-my_context->max_db_size)):addr;
-    dynarec_log(LOG_DEBUG, "cleanDBFromAddressRange %p/%p -> %p %s\n", (void*)addr, (void*)start_addr, (void*)(addr+size-1), destroy?"destroy":"mark");
-    for (uintptr_t i=start_addr; i<addr+size; ++i) {
-        dynablock_t* db = getDB(i);
-        if(db) {
+    uintptr_t idx = (addr>>DYNAMAP_SHIFT);
+    uintptr_t end = ((addr+size-1)>>DYNAMAP_SHIFT);
+    for (uintptr_t i=idx; i<=end; ++i) {
+        dynablocklist_t* dblist = dynmap[i];
+        if(dblist) {
             if(destroy)
-                FreeRangeDynablock(db, addr, size);
+                FreeRangeDynablock(dblist, addr, size);
             else
-                MarkRangeDynablock(db, addr, size);
-        } else {
-            uintptr_t next = getDefaultSize(i);
-            if(next)
-                i+=next-1;
+                MarkRangeDynablock(dblist, addr, size);
         }
     }
 }
 
-int addJumpTableIfDefault(void* addr, void* jmp)
+#ifdef ARM
+void arm_next(void);
+#endif
+
+void addJumpTableIfDefault(void* addr, void* jmp)
 {
     const uintptr_t idx = ((uintptr_t)addr>>JMPTABL_SHIFT);
     if(box86_jumptable[idx] == box86_jmptbl_default) {
@@ -674,7 +610,7 @@ int addJumpTableIfDefault(void* addr, void* jmp)
             box_free(tbl);
     }
     const uintptr_t off = (uintptr_t)addr&((1<<JMPTABL_SHIFT)-1);
-    return (arm_lock_storeifref(&box86_jumptable[idx][off], jmp, arm_next)==jmp)?1:0;
+    arm_lock_storeifref(&box86_jumptable[idx][off], jmp, arm_next);
 }
 void setJumpTableDefault(void* addr)
 {
@@ -685,28 +621,6 @@ void setJumpTableDefault(void* addr)
     const uintptr_t off = (uintptr_t)addr&((1<<JMPTABL_SHIFT)-1);
     box86_jumptable[idx][off] = (uintptr_t)arm_next;
 }
-void setJumpTableDefaultRef(void* addr, void* jmp)
-{
-    const uintptr_t idx = ((uintptr_t)addr>>JMPTABL_SHIFT);
-    if(box86_jumptable[idx] == box86_jmptbl_default) {
-        return;
-    }
-    const uintptr_t off = (uintptr_t)addr&((1<<JMPTABL_SHIFT)-1);
-    arm_lock_storeifref(&box86_jumptable[idx][off], arm_next, jmp);
-}
-void setJumpTableIfRef(void* addr, void* jmp, void* ref)
-{
-    const uintptr_t idx = ((uintptr_t)addr>>JMPTABL_SHIFT);
-    if(box86_jumptable[idx] == box86_jmptbl_default) {
-        uintptr_t* tbl = (uintptr_t*)box_malloc((1<<JMPTABL_SHIFT)*sizeof(uintptr_t));
-        for(int i=0; i<(1<<JMPTABL_SHIFT); ++i)
-            tbl[i] = (uintptr_t)arm_next;
-        if(arm_lock_storeifref(&box86_jumptable[idx], tbl, box86_jmptbl_default)!=tbl)
-            box_free(tbl);
-    }
-    const uintptr_t off = (uintptr_t)addr&((1<<JMPTABL_SHIFT)-1);
-    arm_lock_storeifref(&box86_jumptable[idx][off], jmp, ref);
-}
 int isJumpTableDefault(void* addr)
 {
     const uintptr_t idx = ((uintptr_t)addr>>JMPTABL_SHIFT);
@@ -735,20 +649,6 @@ uintptr_t getJumpTableAddress(uintptr_t addr)
     return (uintptr_t)&box86_jumptable[idx][off];
 }
 
-uintptr_t getJumpAddress(uintptr_t addr)
-{
-    const uintptr_t idx = ((uintptr_t)addr>>JMPTABL_SHIFT);
-    if(box86_jumptable[idx] == box86_jmptbl_default) {
-        uintptr_t* tbl = (uintptr_t*)box_malloc((1<<JMPTABL_SHIFT)*sizeof(uintptr_t));
-        for(int i=0; i<(1<<JMPTABL_SHIFT); ++i)
-            tbl[i] = (uintptr_t)arm_next;
-        if(arm_lock_storeifref(&box86_jumptable[idx], tbl, box86_jmptbl_default)!=tbl)
-            box_free(tbl);
-    }
-    const uintptr_t off = (uintptr_t)addr&((1<<JMPTABL_SHIFT)-1);
-    return (uintptr_t)box86_jumptable[idx][off];
-}
-
 // Remove the Write flag from an adress range, so DB can be executed
 // no log, as it can be executed inside a signal handler
 void protectDB(uintptr_t addr, uintptr_t size)
@@ -757,16 +657,16 @@ void protectDB(uintptr_t addr, uintptr_t size)
     uintptr_t idx = (addr>>MEMPROT_SHIFT);
     uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
-        uint32_t prot = memprot[i].prot;
+        uint32_t prot = memprot[i];
         uint32_t dyn = prot&PROT_CUSTOM;
         prot&=~PROT_CUSTOM;
         if(!prot)
             prot = PROT_READ | PROT_WRITE | PROT_EXEC;      // comes from malloc & co, so should not be able to execute
         if(prot&PROT_WRITE) {
-            memprot[i].prot = prot|PROT_DYNAREC;
+            memprot[i] = prot|PROT_DYNAREC;
             if(!dyn) mprotect((void*)(i<<MEMPROT_SHIFT), 1<<MEMPROT_SHIFT, prot&~PROT_WRITE);
         } else
-            memprot[i].prot = prot|PROT_DYNAREC_R;
+            memprot[i] = prot|PROT_DYNAREC_R;
     }
 }
 
@@ -778,52 +678,17 @@ void unprotectDB(uintptr_t addr, uintptr_t size, int mark)
     uintptr_t idx = (addr>>MEMPROT_SHIFT);
     uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
-        uint32_t prot = memprot[i].prot;
+        uint32_t prot = memprot[i];
         if(prot&PROT_DYNAREC) {
-            memprot[i].prot = prot&~PROT_DYNAREC;
+            memprot[i] = prot&~PROT_DYNAREC;
             mprotect((void*)(i<<MEMPROT_SHIFT), 1<<MEMPROT_SHIFT, prot&~PROT_DYNAREC);
             if(mark)
                 cleanDBFromAddressRange((i<<MEMPROT_SHIFT), 1<<MEMPROT_SHIFT, 0);
         } else if(prot&PROT_DYNAREC_R)
-            memprot[i].prot = prot&~(PROT_CUSTOM);
+            memprot[i] = prot&~(PROT_CUSTOM);
     }
 }
 
-#define HOTPAGE_STEP 16
-int IsInHotPage(uintptr_t addr) {
-    uintptr_t idx = (addr>>MEMPROT_SHIFT);
-    if(!memprot[idx].hot)
-        return 0;
-    // decrement hot
-    arm_lock_dec_b(&memprot[idx].hot);
-    return 1;
-}
-
-int AreaInHotPage(uintptr_t start, uintptr_t end_) {
-    //dynarec_log(LOG_DEBUG, "AreaInHotPage %p -> %p => ", (void*)start, (void*)end_);
-    uintptr_t idx = (start>>MEMPROT_SHIFT);
-    uintptr_t end = (end_>>MEMPROT_SHIFT);
-    if(end<idx) { // memory addresses higher than 48bits are not tracked
-        //dynarec_log(LOG_DEBUG, "00\n");
-        return 0;
-    }
-    for (uintptr_t i=idx; i<=end; ++i) {
-        if(memprot[i].hot) {
-            // decrement hot
-            arm_lock_dec_b(&memprot[i].hot);
-            //dynarec_log(LOG_DEBUG, "1\n");
-            return 1;
-        }
-    }
-    //dynarec_log(LOG_DEBUG, "0\n");
-    return 0;
-
-}
-
-void AddHotPage(uintptr_t addr) {
-    int idx = (addr>>MEMPROT_SHIFT);
-    arm_lock_store_b(&memprot[idx].hot, HOTPAGE_STEP);
-}
 #endif
 
 void printMapMem()
@@ -923,18 +788,15 @@ void updateProtection(uintptr_t addr, uintptr_t size, uint32_t prot)
     const uintptr_t idx = (addr>>MEMPROT_SHIFT);
     const uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
-        uint32_t dyn=(memprot[i].prot&(PROT_DYNAREC|PROT_DYNAREC_R));
+        uint32_t dyn=(memprot[i]&(PROT_DYNAREC|PROT_DYNAREC_R));
         if(dyn && (prot&PROT_WRITE)) {   // need to remove the write protection from this block
             dyn = PROT_DYNAREC;
             mprotect((void*)(i<<MEMPROT_SHIFT), 1<<MEMPROT_SHIFT, prot&~PROT_WRITE);
         } else if(dyn && !(prot&PROT_WRITE)) {
             dyn = PROT_DYNAREC_R;
         }
-        #ifdef DYNAREC
-        arm_lock_store_b(&memprot[i].prot, prot|dyn);
-        #else
-        memprot[i].prot = prot|dyn;
-        #endif
+
+        memprot[i] = prot|dyn;
     }
 }
 
@@ -946,11 +808,7 @@ void forceProtection(uintptr_t addr, uintptr_t size, uint32_t prot)
     const uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
         mprotect((void*)(i<<MEMPROT_SHIFT), 1<<MEMPROT_SHIFT, prot&~PROT_CUSTOM);
-        #ifdef DYNAREC
-        arm_lock_store_b(&memprot[i].prot, prot);
-        #else
-        memprot[i].prot=prot;
-        #endif
+        memprot[i] = prot;
     }
 }
 
@@ -963,11 +821,7 @@ void setProtection(uintptr_t addr, uintptr_t size, uint32_t prot)
     const uintptr_t idx = (addr>>MEMPROT_SHIFT);
     const uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
-        #ifdef DYNAREC
-        arm_lock_store_b(&memprot[i].prot, prot);
-        #else
-        memprot[i].prot=prot;
-        #endif
+        memprot[i] = prot;
     }
 }
 
@@ -977,15 +831,14 @@ void freeProtection(uintptr_t addr, uintptr_t size)
     const uintptr_t idx = (addr>>MEMPROT_SHIFT);
     const uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
-        memprot[i].prot = 0;
-        memprot[i].hot = 0;
+        memprot[i] = 0;
     }
 }
 
 uint32_t getProtection(uintptr_t addr)
 {
     const uintptr_t idx = (addr>>MEMPROT_SHIFT);
-    uint32_t ret = memprot[idx].prot;
+    uint32_t ret = memprot[idx];
     return ret;
 }
 
@@ -995,8 +848,8 @@ void allocProtection(uintptr_t addr, uintptr_t size, uint32_t prot)
     const uintptr_t idx = (addr>>MEMPROT_SHIFT);
     const uintptr_t end = ((addr+size-1)>>MEMPROT_SHIFT);
     for (uintptr_t i=idx; i<=end; ++i) {
-        if(!memprot[i].prot)
-            memprot[i].prot = prot;
+        if(!memprot[i])
+            memprot[i] = prot;
     }
 }
 
@@ -1048,7 +901,7 @@ static void* findBlockHinted(void* hint, size_t size)
             return hint;
         if(addr>=h && end-addr+1>=size)
             return (void*)addr;
-        if(end>=0xc0000000 & h<0xc0000000)
+        if(end>=0xc0000000 && h<0xc0000000)
             return NULL;
         m = m->next;
     }
@@ -1160,6 +1013,12 @@ void fini_custommem_helper(box86context_t *ctx)
         }
         mmapsize = 0;
         mmapcap = 0;
+        dynarec_log(LOG_DEBUG, "Free dynamic Dynarecblocks\n");
+        uintptr_t idx = 0;
+        uintptr_t end = ((0xFFFFFFFF)>>DYNAMAP_SHIFT);
+        for (uintptr_t i=idx; i<=end; ++i)
+            if(dynmap[i])
+                FreeDynablockList(&dynmap[i]);
         box_free(mmaplist);
         for (int i=0; i<DYNAMAP_SIZE; ++i)
             if(box86_jumptable[i]!=box86_jmptbl_default)

src/dynarec/arm_emitter.h

@@ -391,8 +391,6 @@ Op is 20-27
 // ldrd reg, reg+1, [addr, +rm], reg must be even, reg+1 is implicit
 #define LDRD_REG(reg, addr, rm) EMIT(c__ | 0b000<<25 | 1<<24  | 1<<23 | 0<<22 | 0<<21 | 0<<20 | ((reg) << 12) | ((addr) << 16) | 0b1101<<4 | (rm) )
 
-#define LDR_litteral(reg, imm12)    EMIT(c__ | 0b010<<25 | 0<<24 | ((imm12<0)?0:1)<<23 | 0<<22 | 0<<21 | 1<<20 | 0b1111<<16 | (reg)<<12 | (abs(imm12)))
-
 // str reg, [addr, #+/-imm9]
 #define STR_IMM9(reg, addr, imm9) EMIT(0xe5000000 | (((imm9)<0)?0:1)<<23 | ((reg) << 12) | ((addr) << 16) | brIMM(imm9) )
 // str with cond reg, [addr, #+/-imm9]

src/dynarec/arm_jmpnext.c

@@ -1,12 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "arm_emitter.h"
-
-#define EMIT(A) *block = (A); ++block
-void CreateJmpNextTo(void* addr, void* tonext)
-{
-    uint32_t* block = (uint32_t*)addr;
-    MOV32(x3, (uintptr_t)tonext);
-    BX(x3);
-}

src/dynarec/arm_lock_helper.S

@@ -16,11 +16,6 @@
 .global arm_lock_xchg
 .global arm_lock_storeifnull
 .global arm_lock_storeifref
-.global arm_lock_store_xchg
-.global arm_lock_dec
-.global arm_lock_dec_b
-.global arm_lock_store
-.global arm_lock_store_b
 
 
 arm_lock_read_b:
@@ -118,46 +113,3 @@ arm_lock_storeifref_exit:
     mov     r0, r3
     pop     {r4}
     bx      lr
-
-arm_lock_store_xchg:
-    // address is r0, value is r1, r1 store to r0 only if [r0] is 0. return new [r0] value (so r1 or old value)
-    // r0 needs to be aligned
-    ldrex   r2, [r0]
-    cmp     r2, #0
-    bne     arm_lock_store_xchg_exit
-    mov     r2, r1
-    strex   r3, r2, [r0]
-    cmp     r3, #1
-    beq     arm_lock_store_xchg
-    mov     r2, #0
-arm_lock_store_xchg_exit:
-    mov     r0, r2
-    bx      lr
-
-arm_lock_dec:
-    dmb     ish
-    ldrex   r1, [r0]
-    sub     r1, r1, #1
-    strex   r2, r1, [r0]
-    cmp     r2, #1
-    beq     arm_lock_dec
-    bx      lr
-
-arm_lock_dec_b:
-    dmb     ish
-    ldrexb  r1, [r0]
-    sub     r1, r1, #1
-    strexb  r2, r1, [r0]
-    cmp     r2, #1
-    beq     arm_lock_dec_b
-    bx      lr
-
-arm_lock_store:
-    str     r1, [r0]
-    dmb     ish
-    bx      lr
-
-arm_lock_store_b:
-    strb    r1, [r0]
-    dmb     ish
-    bx      lr

src/dynarec/arm_lock_helper.h

@@ -31,19 +31,4 @@ extern void* arm_lock_storeifnull(void* p, void* val);
 // Atomically store value to [p] only if [p] is ref. Return new [p] value (so val or old)
 extern void* arm_lock_storeifref(void* p, void* val, void* ref);
 
-// Atomically store value to [p] only if [p] is NULL. Return old [p] value
-extern void* arm_lock_store_xchg(void* p, void* val);
-
-// will decrease *p atomicaly
-extern void arm_lock_dec_b(uint8_t* p);
-
-// will decrease *p atomicaly
-extern void arm_lock_dec(int* p);
-
-// store value, with data memory barrier
-extern void arm_lock_store_b(uint8_t* p, uint8_t val);
-
-// store value, with data memory barrier
-extern void arm_lock_store(int* p, int val);
-
 #endif  //__ARM_LOCK_HELPER__H__

src/dynarec/dynablock.c

@@ -4,7 +4,6 @@
 #include <errno.h>
 #include <sys/mman.h>
 #include <setjmp.h>
-#include <sys/mman.h>
 
 #include "debug.h"
 #include "box86context.h"
@@ -42,36 +41,108 @@ uint32_t X31_hash_code(void* addr, int len)
 	return (uint32_t)h;
 }
 
+dynablocklist_t* NewDynablockList(uintptr_t text, int textsz, int direct)
+{
+    if(!textsz) {
+        printf_log(LOG_NONE, "Error, creating a NULL sized Dynablock\n");
+        return NULL;
+    }
+    dynablocklist_t* ret = (dynablocklist_t*)box_calloc(1, sizeof(dynablocklist_t));
+    ret->text = text;
+    ret->textsz = textsz;
+    if(direct && textsz) {
+        ret->direct = (dynablock_t**)box_calloc(textsz, sizeof(dynablock_t*));
+        if(!ret->direct) {printf_log(LOG_NONE, "Warning, fail to create direct block for dynablock @%p\n", (void*)text);}
+    }
+    dynarec_log(LOG_DEBUG, "New Dynablocklist %p, from %p->%p\n", ret, (void*)text, (void*)(text+textsz));
+    return ret;
+}
+
 void FreeDynablock(dynablock_t* db, int need_lock)
 {
     if(db) {
         if(db->gone)
             return; // already in the process of deletion!
-        dynarec_log(LOG_DEBUG, "FreeDynablock(%p), db->block=%p x86=%p:%p already gone=%d\n", db, db->block, db->x86_addr, db->x86_addr+db->x86_size, db->gone);
+        dynarec_log(LOG_DEBUG, "FreeDynablock(%p), db->block=%p x86=%p:%p father=%p, with %d son(s) already gone=%d\n", db, db->block, db->x86_addr, db->x86_addr+db->x86_size, db->father, db->sons_size, db->gone);
         if(need_lock)
             pthread_mutex_lock(&my_context->mutex_dyndump);
-        // remove jumptable
-        setJumpTableDefault(db->x86_addr);
-        dynarec_log(LOG_DEBUG, " -- FreeDyrecMap(%p, %d)\n", db->actual_block, db->size);
         db->done = 0;
         db->gone = 1;
-        FreeDynarecMap(db, (uintptr_t)db->actual_block, db->size);
+        // remove from direct if there
+        uintptr_t startdb = db->parent->text;
+        uintptr_t enddb = db->parent->text + db->parent->textsz;
+        if(db->parent->direct) {
+            uintptr_t addr = (uintptr_t)db->x86_addr;
+            if(addr>=startdb && addr<enddb)
+                db->parent->direct[addr-startdb] = NULL;
+        }
+        // remove jumptable
+        setJumpTableDefault(db->x86_addr);
+        // remove and free the sons
+        for (int i=0; i<db->sons_size; ++i) {
+            dynablock_t *son = (dynablock_t*)arm_lock_xchg(&db->sons[i], 0);
+            FreeDynablock(son, 0);
+        }
+        // only the father free the DynarecMap
+        if(!db->father) {
+            dynarec_log(LOG_DEBUG, " -- FreeDyrecMap(%p, %d)\n", db->block, db->size);
+            FreeDynarecMap(db, (uintptr_t)db->block, db->size);
+            box_free(db->sons);
+            box_free(db->instsize);
+        }
         box_free(db);
         if(need_lock)
             pthread_mutex_unlock(&my_context->mutex_dyndump);
     }
 }
 
+void FreeDynablockList(dynablocklist_t** dynablocks)
+{
+    if(!dynablocks)
+        return;
+    if(!*dynablocks)
+        return;
+    dynarec_log(LOG_DEBUG, "Free Dynablocklist %p, with Direct Blocks %p\n", *dynablocks, (*dynablocks)->direct);
+    if((*dynablocks)->direct) {
+        for (int i=0; i<(*dynablocks)->textsz; ++i) {
+            if((*dynablocks)->direct[i] && !(*dynablocks)->direct[i]->father) 
+                FreeDynablock((*dynablocks)->direct[i], my_context?1:0);
+        }
+        box_free((*dynablocks)->direct);
+    }
+    (*dynablocks)->direct = NULL;
+
+    box_free(*dynablocks);
+    *dynablocks = NULL;
+}
+
 void MarkDynablock(dynablock_t* db)
 {
     if(db) {
+        if(db->father)
+            db = db->father;    // mark only father
         if(db->need_test)
             return; // already done
         db->need_test = 1;
         setJumpTableDefault(db->x86_addr);
+        for(int i=0; i<db->sons_size; ++i)
+            setJumpTableDefault(db->sons[i]->x86_addr);
     }
 }
 
+uintptr_t StartDynablockList(dynablocklist_t* db)
+{
+    if(db)
+        return db->text;
+    return 0;
+}
+uintptr_t EndDynablockList(dynablocklist_t* db)
+{
+    if(db)
+        return db->text+db->textsz-1;
+    return 0;
+}
+
 int IntervalIntersects(uintptr_t start1, uintptr_t end1, uintptr_t start2, uintptr_t end2)
 {
     if(start1 > end2 || start2 > end1)
@@ -79,27 +150,81 @@ int IntervalIntersects(uintptr_t start1, uintptr_t end1, uintptr_t start2, uintp
     return 1;
 }
 
-void MarkRangeDynablock(dynablock_t* db, uintptr_t addr, uintptr_t size)
+void MarkDirectDynablock(dynablocklist_t* dynablocks, uintptr_t addr, uintptr_t size)
 {
-    if(!db)
+    if(!dynablocks)
         return;
-    dynarec_log(LOG_DEBUG, "MarkRangeDynablock %p-%p .. startdb=%p, sizedb=%p\n", (void*)addr, (void*)addr+size-1, (void*)db->x86_addr, (void*)db->x86_size);
-    if(!db->need_test)
-        if(IntervalIntersects((uintptr_t)db->x86_addr, (uintptr_t)db->x86_addr+db->x86_size-1, addr, addr+size+1))
-            MarkDynablock(db);
+    if(!dynablocks->direct)
+        return;
+    uintptr_t startdb = dynablocks->text;
+    uintptr_t enddb = startdb + dynablocks->textsz -1;
+    uintptr_t start = addr;
+    uintptr_t end = addr+size-1;
+    if(start<startdb)
+        start = startdb;
+    if(end>enddb)
+        end = enddb;
+    dynablock_t *db;
+    if(end>startdb && start<enddb)
+        for(uintptr_t i = start; i<end; ++i)
+            if((db=dynablocks->direct[i-startdb]))
+                if(IntervalIntersects((uintptr_t)db->x86_addr, (uintptr_t)db->x86_addr+db->x86_size-1, addr, addr+size+1))
+                    MarkDynablock(db);
 }
 
-int FreeRangeDynablock(dynablock_t* db, uintptr_t addr, uintptr_t size)
+void FreeRangeDynablock(dynablocklist_t* dynablocks, uintptr_t addr, uintptr_t size)
 {
-    if(!db)
-        return 1;
+    if(!dynablocks)
+        return;
 
-    int need_lock = my_context?1:0;
-    if(IntervalIntersects((uintptr_t)db->x86_addr, (uintptr_t)db->x86_addr+db->x86_size-1, addr, addr+size+1)) {
-        FreeDynablock(db, need_lock);
-        return 0;
+    if(dynablocks->direct) {
+        int need_lock = my_context?1:0;
+        dynablock_t* db;
+        int ret;
+        khint_t k;
+        kh_dynablocks_t *blocks = kh_init(dynablocks);
+        // copy in a temporary list
+        if(dynablocks->direct) {
+            uintptr_t startdb = dynablocks->text;
+            uintptr_t enddb = startdb + dynablocks->textsz;
+            uintptr_t start = addr;
+            uintptr_t end = addr+size;
+            if(start<startdb)
+                start = startdb;
+            if(end>enddb)
+                end = enddb;
+            if(end>startdb && start<enddb)
+                for(uintptr_t i = start; i<end; ++i) {
+                    db = (dynablock_t*)arm_lock_xchg(&dynablocks->direct[i-startdb], 0);
+                    if(db) {
+                        if(db->father)
+                            db = db->father;
+                        if(db->parent==dynablocks) {
+                            k = kh_put(dynablocks, blocks, (uintptr_t)db, &ret);
+                            kh_value(blocks, k) = db;
+                        }
+                    }
+                }
+        }
+        // purge the list
+        kh_foreach_value(blocks, db,
+            FreeDynablock(db, need_lock);
+        );
+        kh_destroy(dynablocks, blocks);
+    }
+}
+void MarkRangeDynablock(dynablocklist_t* dynablocks, uintptr_t addr, uintptr_t size)
+{
+    if(!dynablocks)
+        return;
+    if(dynablocks->direct) {
+        uintptr_t new_addr = addr - dynablocks->maxsz;
+        uintptr_t new_size = size + dynablocks->maxsz;
+        MarkDirectDynablock(dynablocks, new_addr, new_size);
+        // the blocks check before
+        for(int idx=(new_addr)>>DYNAMAP_SHIFT; idx<(addr>>DYNAMAP_SHIFT); ++idx)
+            MarkDirectDynablock(getDB(idx), new_addr, new_size);
     }
-    return 1;
 }
 
 dynablock_t* FindDynablockDynablocklist(void* addr, kh_dynablocks_t* dynablocks)
@@ -111,27 +236,66 @@ dynablock_t* FindDynablockDynablocklist(void* addr, kh_dynablocks_t* dynablocks)
         const uintptr_t s = (uintptr_t)db->block;
         const uintptr_t e = (uintptr_t)db->block+db->size;
         if((uintptr_t)addr>=s && (uintptr_t)addr<e)
-            return db;
+            return db->father?db->father:db;
     )
     return NULL;
 }
 
-dynablock_t *AddNewDynablock(uintptr_t addr)
+static dynablocklist_t* getDBFromAddress(uintptr_t addr)
 {
-    dynablock_t* block;
-    #if 0
-    // check if memory as the correct flags
-    int prot = getProtection(addr);
-    if(!(prot&(PROT_EXEC|PROT_DYNAREC|PROT_DYNAREC_R))) {
-        dynarec_log(LOG_VERBOSE, "Block asked on a memory with no execution flags 0x%02X\n", prot);
+    const int idx = (addr>>DYNAMAP_SHIFT);
+    return getDB(idx);
+}
+
+dynablock_t *AddNewDynablock(dynablocklist_t* dynablocks, uintptr_t addr, int* created)
+{
+    if(!dynablocks) {
+        dynarec_log(LOG_INFO, "Warning: Ask to create a dynablock with a NULL dynablocklist (addr=%p)\n", (void*)addr);
+        *created = 0;
         return NULL;
     }
-    #endif
+    if((addr<dynablocks->text) || (addr>=(dynablocks->text+dynablocks->textsz))) {
+        // this should be useless
+        //dynarec_log(LOG_INFO, "Warning: Refused to create a Direct Block that is out-of-bound: dynablocks=%p (%p:%p), addr=%p\n", dynablocks, (void*)(dynablocks->text), (void*)(dynablocks->text+dynablocks->textsz), (void*)addr);
+        //*created = 0;
+        //return NULL;
+        return AddNewDynablock(getDBFromAddress(addr), addr, created);
+    }
+    dynablock_t* block = NULL;
+    // first, check if it exist in direct access mode
+    if(dynablocks->direct) {
+        block = dynablocks->direct[addr-dynablocks->text];
+        if(block) {
+            dynarec_log(LOG_VERBOSE, "Block already exist in Direct Map\n");
+            *created = 0;
+            return block;
+        }
+    }
+    
+    if (!*created)
+        return block;
+    
     pthread_mutex_lock(&my_context->mutex_dyndump);
+    if(!dynablocks->direct) {
+        dynablock_t** p = (dynablock_t**)box_calloc(dynablocks->textsz, sizeof(dynablock_t*));
+        if(arm_lock_storeifnull(&dynablocks->direct, p)!=p)
+            box_free(p);    // someone already create the direct array, too late...
+    }
+
     // create and add new block
     dynarec_log(LOG_VERBOSE, "Ask for DynaRec Block creation @%p\n", (void*)addr);
+
     block = (dynablock_t*)box_calloc(1, sizeof(dynablock_t));
+    block->parent = dynablocks; 
+    dynablock_t* tmp = (dynablock_t*)arm_lock_storeifnull(&dynablocks->direct[addr-dynablocks->text], block);
     pthread_mutex_unlock(&my_context->mutex_dyndump);
+    if(tmp !=  block) {
+        // a block appeard!
+        box_free(block);
+        *created = 0;
+        return tmp;
+    }
+    *created = 1;
     return block;
 }
 
@@ -147,28 +311,41 @@ void cancelFillBlock()
     return NULL if block is not found / cannot be created. 
     Don't create if create==0
 */
-static dynablock_t* internalDBGetBlock(x86emu_t* emu, uintptr_t addr, uintptr_t filladdr, int create, int need_lock)
+static dynablock_t* internalDBGetBlock(x86emu_t* emu, uintptr_t addr, uintptr_t filladdr, int create, dynablock_t* current, int need_lock)
 {
     if(hasAlternate((void*)addr))
         return NULL;
-    dynablock_t* block = getDB(addr);
-    if(block || !create)
-        return block;
-
-    if(need_lock)
-        pthread_mutex_lock(&my_context->mutex_dyndump);
-
-    block = getDB(addr);    // just in case
-    if(block) {
-        if(need_lock)
-            pthread_mutex_unlock(&my_context->mutex_dyndump);
-        return block;
+    // try the quickest way first: get parent of current and check if ok!
+    dynablocklist_t *dynablocks = NULL;
+    dynablock_t* block = NULL;
+    if(current && current->done) {
+        dynablocks = current->parent;
+        if(dynablocks && !(addr>=dynablocks->text && addr<(dynablocks->text+dynablocks->textsz)))
+            dynablocks = NULL;
     }
+    // nope, lets do the long way
+    if(!dynablocks) {
+        dynablocks = getDBFromAddress(addr);
+        if(!dynablocks) {
+            dynablocks = GetDynablocksFromAddress(emu->context, addr);
+            if(!dynablocks)
+                return NULL;
+        }
+    }
+    // check direct first, without lock
+    if(dynablocks->direct/* && (addr>=dynablocks->text) && (addr<(dynablocks->text+dynablocks->textsz))*/)
+        if((block = dynablocks->direct[addr-dynablocks->text]))
+            return block;
 
-    block = AddNewDynablock(addr);
+    int created = create;
+    block = AddNewDynablock(dynablocks, addr, &created);
+    if(!created)
+        return block;   // existing block...
 
     // fill the block
     block->x86_addr = (void*)addr;
+    if(need_lock)
+        pthread_mutex_lock(&my_context->mutex_dyndump);
     if(sigsetjmp(&dynarec_jmpbuf, 1)) {
         printf_log(LOG_INFO, "FillBlock at %p triggered a segfault, cancelling\n", (void*)addr);
         if(need_lock)
@@ -180,60 +357,68 @@ static dynablock_t* internalDBGetBlock(x86emu_t* emu, uintptr_t addr, uintptr_t
         pthread_mutex_unlock(&my_context->mutex_dyndump);
     if(!ret) {
         dynarec_log(LOG_DEBUG, "Fillblock of block %p for %p returned an error\n", block, (void*)addr);
+        void* old = (void*)arm_lock_storeifref(&dynablocks->direct[addr-dynablocks->text], 0, block);
+        if(old!=block && old) { // put it back in place, strange things are happening here!
+            dynarec_log(LOG_INFO, "Warning, a wild block appeared at %p: %p\n", (void*)addr, old);
+            // Doing nothing else, the block has not been written
+        }
         box_free(block);
         block = NULL;
     }
     // check size
-    if(block && (block->x86_size || (!block->x86_size && !block->done))) {
+    if(block && block->x86_size) {
         int blocksz = block->x86_size;
-        if(blocksz>my_context->max_db_size)
-            my_context->max_db_size = blocksz;
-        // fill-in jumptable
-        if(!addJumpTableIfDefault(block->x86_addr, block->block)) {
-            FreeDynablock(block, 1);
-            block = getDB(addr);
-        } else {
-            if(block->x86_size)
-                block->done = 1;    // don't validate the block if the size is null, but keep the block
+        if(dynablocks->maxsz<blocksz) {
+            dynablocks->maxsz = blocksz;
+            for(int idx=(addr>>DYNAMAP_SHIFT)+1; idx<=((addr+blocksz)>>DYNAMAP_SHIFT); ++idx) {
+                dynablocklist_t* dblist;
+                if((dblist = getDB(idx)))
+                    if(dblist->maxsz<blocksz)
+                        dblist->maxsz = blocksz;
+            }
         }
+        //protectDB((uintptr_t)block->x86_addr, block->x86_size);   // already protected in FillBlock
+        // but check if it already need test
+        if(block->need_test || (block->father && block->father->need_test))
+            return NULL;
+        // fill-in jumptable
+        addJumpTableIfDefault(block->x86_addr, block->block);
+        for(int i=0; i<block->sons_size; ++i)
+            addJumpTableIfDefault(block->sons[i]->x86_addr, block->sons[i]->block);
     }
-    if(need_lock)
-        pthread_mutex_unlock(&my_context->mutex_dyndump);
 
-    dynarec_log(LOG_DEBUG, " --- DynaRec Block created @%p:%p (%p, 0x%x bytes)\n", (void*)addr, (void*)(addr+((block)?block->x86_size:0)), (block)?block->block:0, (block)?block->size:0);
+    dynarec_log(LOG_DEBUG, " --- DynaRec Block %s @%p:%p (%p, 0x%x bytes, with %d son(s))\n", created?"created":"recycled", (void*)addr, (void*)(addr+((block)?block->x86_size:0)), (block)?block->block:0, (block)?block->size:0, (block)?block->sons_size:0);
 
     return block;
 }
 
-dynablock_t* DBGetBlock(x86emu_t* emu, uintptr_t addr, int create)
+dynablock_t* DBGetBlock(x86emu_t* emu, uintptr_t addr, int create, dynablock_t** current)
 {
-    dynablock_t *db = internalDBGetBlock(emu, addr, addr, create, 1);
-    if(db && db->done && db->block && db->need_test) {
-        if(AreaInHotPage((uintptr_t)db->x86_addr, (uintptr_t)db->x86_addr + db->x86_size - 1)) {
-            dynarec_log(LOG_DEBUG, "Not running block %p from %p:%p with for %p because it's in a hotpage\n", db, db->x86_addr, db->x86_addr+db->x86_size-1, (void*)addr);
+    dynablock_t *db = internalDBGetBlock(emu, addr, addr, create, *current, 1);
+    if(db && db->done && db->block && (db->need_test || (db->father && db->father->need_test))) {
+        if(pthread_mutex_trylock(&my_context->mutex_dyndump))
             return NULL;
-        }
-        uint32_t hash = X31_hash_code(db->x86_addr, db->x86_size);
-        if(pthread_mutex_trylock(&my_context->mutex_dyndump)) {
-            dynarec_log(LOG_DEBUG, "mutex_dyndump not available when trying to validate block %p from %p:%p (hash:%X) for %p\n", db, db->x86_addr, db->x86_addr+db->x86_size-1, db->hash, (void*)addr);
-            return NULL;
-        }
-        if(hash!=db->hash) {
-            db->done = 0;   // invalidating the block
-            dynarec_log(LOG_DEBUG, "Invalidating block %p from %p:%p (hash:%X/%X) for %p\n", db, db->x86_addr, db->x86_addr+db->x86_size-1, hash, db->hash, (void*)addr);
-            // Free db, it's now invalid!
-            FreeDynablock(db, 0);
+        dynablock_t *father = db->father?db->father:db;
+        uint32_t hash = (getProtection((uintptr_t)father->x86_addr)&PROT_READ)?X31_hash_code(father->x86_addr, father->x86_size):0;
+        if(hash!=father->hash) {
+            dynarec_log(LOG_DEBUG, "Invalidating block %p from %p:%p (hash:%X/%X) with %d son(s) for %p\n", father, father->x86_addr, father->x86_addr+father->x86_size, hash, father->hash, father->sons_size, (void*)addr);
+            // no more current if it gets invalidated too
+            if(*current && father->x86_addr>=(*current)->x86_addr && (father->x86_addr+father->x86_size)<(*current)->x86_addr)
+                *current = NULL;
+            // Free father, it's now invalid!
+            FreeDynablock(father, 0);
             // start again... (will create a new block)
-            db = internalDBGetBlock(emu, addr, addr, create, 0);
+            db = internalDBGetBlock(emu, addr, addr, create, *current, 0);
         } else {
-            db->need_test = 0;
-            dynarec_log(LOG_DEBUG, "Validating block %p from %p:%p (hash:%X) for %p\n", db, db->x86_addr, db->x86_addr+db->x86_size-1, db->hash, (void*)addr);
-            protectDB((uintptr_t)db->x86_addr, db->x86_size);
-            // fill back jumptable        
-            setJumpTableIfRef(db->x86_addr, db->block, db->jmpnext);
+            father->need_test = 0;
+            protectDB((uintptr_t)father->x86_addr, father->x86_size);
+            // fill back jumptable
+            addJumpTableIfDefault(father->x86_addr, father->block);
+            for(int i=0; i<father->sons_size; ++i)
+                addJumpTableIfDefault(father->sons[i]->x86_addr, father->sons[i]->block);
         }
         pthread_mutex_unlock(&my_context->mutex_dyndump);
-    }
+    } 
     return db;
 }
 
@@ -241,25 +426,27 @@ dynablock_t* DBAlternateBlock(x86emu_t* emu, uintptr_t addr, uintptr_t filladdr)
 {
     dynarec_log(LOG_DEBUG, "Creating AlternateBlock at %p for %p\n", (void*)addr, (void*)filladdr);
     int create = 1;
-    dynablock_t *db = internalDBGetBlock(emu, addr, filladdr, create, 1);
-    if(db && db->done && db->block && db->need_test) {
+    dynablock_t *db = internalDBGetBlock(emu, addr, filladdr, create, NULL, 1);
+    if(db && db->done && db->block && (db->need_test || (db->father && db->father->need_test))) {
         if(pthread_mutex_trylock(&my_context->mutex_dyndump))
             return NULL;
-        uint32_t hash = X31_hash_code(db->x86_addr, db->x86_size);
-        if(hash!=db->hash) {
-            db->done = 0;   // invalidating the block
-            dynarec_log(LOG_DEBUG, "Invalidating alt block %p from %p:%p (hash:%X/%X) for %p\n", db, db->x86_addr, db->x86_addr+db->x86_size, hash, db->hash, (void*)addr);
-            // Free db, it's now invalid!
-            FreeDynablock(db, 0);
+        dynablock_t *father = db->father?db->father:db;
+        uint32_t hash = (getProtection((uintptr_t)father->x86_addr)&PROT_READ)?X31_hash_code(father->x86_addr, father->x86_size):0;
+        if(hash!=father->hash) {
+            dynarec_log(LOG_DEBUG, "Invalidating alt block %p from %p:%p (hash:%X/%X) with %d son(s) for %p\n", father, father->x86_addr, father->x86_addr+father->x86_size, hash, father->hash, father->sons_size, (void*)addr);
+            // Free father, it's now invalid!
+            FreeDynablock(father, 0);
             // start again... (will create a new block)
-            db = internalDBGetBlock(emu, addr, filladdr, create, 0);
+            db = internalDBGetBlock(emu, addr, filladdr, create, NULL, 0);
         } else {
-            db->need_test = 0;
-            protectDB((uintptr_t)db->x86_addr, db->x86_size);
+            father->need_test = 0;
+            protectDB((uintptr_t)father->x86_addr, father->x86_size);
             // fill back jumptable
-            addJumpTableIfDefault(db->x86_addr, db->block);
+            addJumpTableIfDefault(father->x86_addr, father->block);
+            for(int i=0; i<father->sons_size; ++i)
+                addJumpTableIfDefault(father->sons[i]->x86_addr, father->sons[i]->block);
         }
         pthread_mutex_unlock(&my_context->mutex_dyndump);
     } 
     return db;
-}
+}

src/dynarec/dynablock_private.h

@@ -1,6 +1,7 @@
 #ifndef __DYNABLOCK_PRIVATE_H_
 #define __DYNABLOCK_PRIVATE_H_
 
+typedef struct dynablocklist_s  dynablocklist_t;
 
 typedef struct instsize_s {
     unsigned char x86:4;
@@ -8,8 +9,8 @@ typedef struct instsize_s {
 } instsize_t;
 
 typedef struct dynablock_s {
-    void*           block;  // block-sizeof(void*) == self
-    void*           actual_block;   // the actual start of the block (so block-sizeof(void*))
+    dynablocklist_t* parent;
+    void*           block;
     int             size;
     void*           x86_addr;
     uintptr_t       x86_size;
@@ -19,8 +20,17 @@ typedef struct dynablock_s {
     uint8_t         gone;
     uint8_t         dummy;
     int             isize;
+    dynablock_t**   sons;   // sons (kind-of dummy dynablock...)
+    int             sons_size;
+    dynablock_t*    father; // set only in the case of a son
     instsize_t*     instsize;
-    void*           jmpnext;    // a branch jmpnext code when block is marked
 } dynablock_t;
 
+typedef struct dynablocklist_s {
+    uintptr_t           text;
+    int                 textsz;
+    int                 maxsz;     // maxblock size (for this block or previous block)
+    dynablock_t**       direct;    // direct mapping (waste of space, so the array is created at first write)
+} dynablocklist_t;
+
 #endif //__DYNABLOCK_PRIVATE_H_

src/dynarec/dynarec.c

@@ -20,7 +20,12 @@
 #include "dynablock.h"
 #include "dynablock_private.h"
 #include "bridge.h"
-#include "dynarec_next.h"
+#endif
+
+#ifdef ARM
+void arm_prolog(x86emu_t* emu, void* addr) EXPORTDYN;
+void arm_epilog() EXPORTDYN;
+void arm_epilog_fast() EXPORTDYN;
 #endif
 
 #ifdef DYNAREC
@@ -39,8 +44,9 @@ void* LinkNext(x86emu_t* emu, uintptr_t addr, void* x2)
         printf_log(LOG_NONE, "Warning, jumping to NULL address from %p (db=%p, x86addr=%p/%s)\n", x2, db, x86addr, pcname);
     }
     #endif
+    dynablock_t* current = NULL;
     void * jblock;
-    dynablock_t* block = DBGetBlock(emu, addr, 1);
+    dynablock_t* block = DBGetBlock(emu, addr, 1, &current);
     if(!block) {
         // no block, let link table as is...
         if(hasAlternate((void*)addr)) {
@@ -48,7 +54,7 @@ void* LinkNext(x86emu_t* emu, uintptr_t addr, void* x2)
             addr = (uintptr_t)getAlternate((void*)addr);
             R_EIP = addr;
             printf_log(LOG_INFO, " -> %p\n", (void*)addr);
-            block = DBGetBlock(emu, addr, 1);
+            block = DBGetBlock(emu, addr, 1, &current);
         }
         if(!block) {
             #ifdef HAVE_TRACE
@@ -108,15 +114,18 @@ void DynaCall(x86emu_t* emu, uintptr_t addr)
         PushExit(emu);
         R_EIP = addr;
         emu->df = d_none;
+        dynablock_t* block = NULL;
+        dynablock_t* current = NULL;
         while(!emu->quit) {
-            dynablock_t* block = DBGetBlock(emu, R_EIP, 1);
+            block = DBGetBlock(emu, R_EIP, 1, &current);
+            current = block;
             if(!block || !block->block || !block->done) {
                 // no block, of block doesn't have DynaRec content (yet, temp is not null)
                 // Use interpreter (should use single instruction step...)
                 dynarec_log(LOG_DEBUG, "%04d|Calling Interpretor @%p, emu=%p\n", GetTID(), (void*)R_EIP, emu);
                 Run(emu, 1);
             } else {
-                dynarec_log(LOG_DEBUG, "%04d|Calling DynaRec Block @%p (%p) of %d x86 instructions emu=%p\n", GetTID(), (void*)R_EIP, block->block, block->isize ,emu);
+                dynarec_log(LOG_DEBUG, "%04d|Calling DynaRec Block @%p (%p) of %d x86 instructions (father=%p) emu=%p\n", GetTID(), (void*)R_EIP, block->block, block->isize ,block->father, emu);
                 CHECK_FLAGS(emu);
                 // block is here, let's run it!
                 #ifdef ARM
@@ -191,15 +200,17 @@ int DynaRun(x86emu_t* emu)
 #ifdef DYNAREC
     else {
         dynablock_t* block = NULL;
+        dynablock_t* current = NULL;
         while(!emu->quit) {
-            block = DBGetBlock(emu, R_EIP, 1);
+            block = DBGetBlock(emu, R_EIP, 1, &current);
+            current = block;
             if(!block || !block->block || !block->done) {
                 // no block, of block doesn't have DynaRec content (yet, temp is not null)
                 // Use interpreter (should use single instruction step...)
                 dynarec_log(LOG_DEBUG, "%04d|Running Interpretor @%p, emu=%p\n", GetTID(), (void*)R_EIP, emu);
                 Run(emu, 1);
             } else {
-                dynarec_log(LOG_DEBUG, "%04d|Running DynaRec Block @%p (%p) of %d x86 insts emu=%p\n", GetTID(), (void*)R_EIP, block->block, block->isize, emu);
+                dynarec_log(LOG_DEBUG, "%04d|Running DynaRec Block @%p (%p) of %d x86 insts (father=%p) emu=%p\n", GetTID(), (void*)R_EIP, block->block, block->isize, block->father, emu);
                 // block is here, let's run it!
                 #ifdef ARM
                 arm_prolog(emu, block->block);

src/dynarec/dynarec_arm.c

@@ -23,7 +23,6 @@
 #include "dynarec_arm_private.h"
 #include "dynarec_arm_functions.h"
 #include "elfloader.h"
-#include "dynarec_next.h"
 
 void printf_x86_instruction(zydis_dec_t* dec, instruction_x86_t* inst, const char* name) {
     uint8_t *ip = (uint8_t*)inst->addr;
@@ -369,46 +368,16 @@ void CancelBlock()
         return;
     box_free(helper->next);
     box_free(helper->insts);
-    box_free(helper->instsize);
     box_free(helper->predecessor);
-    if(helper->dynablock && helper->dynablock->actual_block)
-        FreeDynarecMap(helper->dynablock, (uintptr_t)helper->dynablock->actual_block, helper->dynablock->size);
-    else if(helper->dynablock && helper->block)
-        FreeDynarecMap(helper->dynablock, (uintptr_t)helper->block-sizeof(void*), helper->dynablock->size);
-}
-
-void* CreateEmptyBlock(dynablock_t* block, uintptr_t addr) {
-    block->isize = 0;
-    block->done = 0;
-    size_t sz = 4*sizeof(void*);
-    void* actual_p = (void*)AllocDynarecMap(block, sz);
-    void* p = actual_p + sizeof(void*);
-    if(actual_p==NULL) {
-        dynarec_log(LOG_INFO, "AllocDynarecMap(%p, %zu) failed, cancelling block\n", block, sz);
-        CancelBlock();
-        return NULL;
-    }
-    block->size = sz;
-    block->actual_block = actual_p;
-    block->block = p;
-    block->jmpnext = p;
-    *(dynablock_t**)actual_p = block;
-    CreateJmpNextTo(block->jmpnext, arm_epilog);
-    block->need_test = 0;
-    // all done...
-    __clear_cache(actual_p, actual_p+sz);   // need to clear the cache before execution...
-    return block;
+    if(helper->dynablock && helper->dynablock->block)
+        FreeDynarecMap(helper->dynablock, (uintptr_t)helper->dynablock->block, helper->dynablock->size);
 }
 
 void* FillBlock(dynablock_t* block, uintptr_t addr) {
 dynarec_log(LOG_DEBUG, "Asked to Fill block %p with %p\n", block, (void*)addr);
-    if(IsInHotPage(addr)) {
-        dynarec_log(LOG_DEBUG, "Cancelling dynarec FillBlock on hotpage for %p\n", (void*)addr);
-        return NULL;
-    }
     if(addr>=box86_nodynarec_start && addr<box86_nodynarec_end) {
-        dynarec_log(LOG_INFO, "Create empty block in no-dynarec zone\n");
-        return CreateEmptyBlock(block, addr);
+        dynarec_log(LOG_DEBUG, "Asked to fill a block in fobidden zone\n");
+        return NULL;
     }
     if(!isJumpTableDefault((void*)addr)) {
         dynarec_log(LOG_DEBUG, "Asked to fill a block at %p, but JumpTable is not default\n", (void*)addr);
@@ -432,7 +401,7 @@ dynarec_log(LOG_DEBUG, "Asked to Fill block %p with %p\n", block, (void*)addr);
     if(!helper.size) {
         dynarec_log(LOG_DEBUG, "Warning, null-sized dynarec block (%p)\n", (void*)addr);
         CancelBlock();
-        return CreateEmptyBlock(block, addr);
+        return (void*)block;
     }
     // already protect the block and compute hash signature
     protectDB(addr, end-addr);  //end is 1byte after actual end
@@ -458,7 +427,44 @@ dynarec_log(LOG_DEBUG, "Asked to Fill block %p with %p\n", block, (void*)addr);
         }
     // fill predecessors with the jump address
     fillPredecessors(&helper);
-
+    // check for the optionnal barriers now
+    /*for(int i=helper.size-1; i>=0; --i) {
+        if(helper.insts[i].barrier_maybe) {
+            // out-of-block jump
+            if(helper.insts[i].x86.jmp_insts == -1) {
+                // nothing for now
+            } else {
+                // inside block jump
+                int k = helper.insts[i].x86.jmp_insts;
+                if(k>i) {
+                    // jump in the future
+                    if(helper.insts[k].pred_sz>1) {
+                        // with multiple flow, put a barrier
+                        helper.insts[k].x86.barrier|=BARRIER_FLAGS;
+                    }
+                } else {
+                    // jump back
+                    helper.insts[k].x86.barrier|=BARRIER_FLAGS;
+                }
+            }
+	}
+    }*/
+    // check to remove useless barrier, in case of jump when destination doesn't needs flags
+    /*for(int i=helper.size-1; i>=0; --i) {
+        int k;
+        if(helper.insts[i].x86.jmp
+        && ((k=helper.insts[i].x86.jmp_insts)>=0)
+        && helper.insts[k].x86.barrier&BARRIER_FLAGS) {
+            //TODO: optimize FPU barrier too
+            if((!helper.insts[k].x86.need_flags)
+             ||(helper.insts[k].x86.set_flags==X_ALL
+                  && helper.insts[k].x86.state_flags==SF_SET)
+             ||(helper.insts[k].x86.state_flags==SF_SET_PENDING)) {
+                //if(box86_dynarec_dump) dynarec_log(LOG_NONE, "Removed barrier for inst %d\n", k);
+                helper.insts[k].x86.barrier &= ~BARRIER_FLAGS; // remove flag barrier
+             }
+        }
+    }*/
     int pos = helper.size;
     while (pos>=0)
         pos = updateNeed(&helper, pos, 0);
@@ -468,44 +474,29 @@ dynarec_log(LOG_DEBUG, "Asked to Fill block %p with %p\n", block, (void*)addr);
 
     // pass 2, instruction size
     arm_pass2(&helper, addr);
-    // keep size of instructions for signal handling
-    size_t insts_ursize = 0;
-    {
-        size_t insts_size = 0;
-        size_t cap = 1;
-        for(int i=0; i<helper.size; ++i)
-            cap += 1 + ((helper.insts[i].x86.size>helper.insts[i].size)?helper.insts[i].x86.size:helper.insts[i].size)/15;
-        helper.instsize = (instsize_t*)box_calloc(cap, sizeof(instsize_t));
-        for(int i=0; i<helper.size; ++i)
-            helper.instsize = addInst(helper.instsize, &insts_size, &cap, helper.insts[i].x86.size, helper.insts[i].size/4);
-        helper.instsize = addInst(helper.instsize, &insts_size, &cap, 0, 0);    // add a "end of block" mark, just in case
-        insts_ursize = insts_size*sizeof(instsize_t);
-    }
-    size_t insts_rsize = (insts_ursize+7)&~7;   // round the size...
-    size_t sz = sizeof(void*) + helper.arm_size + 4*sizeof(void*) + insts_rsize;
-    //           dynablock_t*     block (arm insts)    jmpnext code       instsize
-    void* actual_p = (void*)AllocDynarecMap(block, sz);
-    void* p = actual_p + sizeof(void*);
-    void* next = p + helper.arm_size;
-    void* instsize = next + 4*sizeof(void*);
-    if(actual_p==NULL) {
+    // ok, now allocate mapped memory, with executable flag on
+    int sz = helper.arm_size;
+    void* p = (void*)AllocDynarecMap(block, sz);
+    if(p==NULL) {
         dynarec_log(LOG_DEBUG, "AllocDynarecMap(%p, %d) failed, cancelling block\n", block, sz);
         CancelBlock();
         return NULL;
     }
     helper.block = p;
     helper.arm_start = (uintptr_t)p;
-    *(dynablock_t**)actual_p = block;
+    if(helper.sons_size) {
+        helper.sons_x86 = (uintptr_t*)alloca(helper.sons_size*sizeof(uintptr_t));
+        helper.sons_arm = (void**)alloca(helper.sons_size*sizeof(void*));
+    }
     // pass 3, emit (log emit arm opcode)
     if(box86_dynarec_dump) {
         dynarec_log(LOG_NONE, "%s%04d|Emitting %d bytes for %d x86 bytes", (box86_dynarec_dump>1)?"\e[01;36m":"", GetTID(), helper.arm_size, helper.isize); 
         printFunctionAddr(helper.start, " => ");
         dynarec_log(LOG_NONE, "%s\n", (box86_dynarec_dump>1)?"\e[m":"");
     }
-    size_t oldarmsize = helper.arm_size;
     helper.arm_size = 0;
     arm_pass3(&helper, addr);
-    if(oldarmsize!=helper.arm_size) {
+    if(sz!=helper.arm_size) {
         printf_log(LOG_NONE, "BOX86: Warning, size difference in block between pass2 (%d) & pass3 (%d)!\n", sz, helper.arm_size);
         uint8_t *dump = (uint8_t*)helper.start;
         printf_log(LOG_NONE, "Dump of %d x86 opcodes:\n", helper.size);
@@ -517,32 +508,32 @@ dynarec_log(LOG_DEBUG, "Asked to Fill block %p with %p\n", block, (void*)addr);
         }
         printf_log(LOG_NONE, " ------------\n");
     }
+    // all done...
+    __clear_cache(p, p+sz);   // need to clear the cache before execution...
     // keep size of instructions for signal handling
-    memcpy(instsize, helper.instsize, insts_ursize);
-    block->instsize = instsize;
+    {
+        size_t cap = 1;
+        for(int i=0; i<helper.size; ++i)
+            cap += 1 + ((helper.insts[i].x86.size>helper.insts[i].size)?helper.insts[i].x86.size:helper.insts[i].size)/15;
+        size_t size = 0;
+        block->instsize = (instsize_t*)box_calloc(cap, sizeof(instsize_t));
+        for(int i=0; i<helper.size; ++i)
+            block->instsize = addInst(block->instsize, &size, &cap, helper.insts[i].x86.size, helper.insts[i].size/4);
+        block->instsize = addInst(block->instsize, &size, &cap, 0, 0);    // add a "end of block" mark, just in case
+    }
     // ok, free the helper now
     box_free(helper.insts);
     helper.insts = NULL;
     box_free(helper.next);
     helper.next = NULL;
-    box_free(helper.instsize);
-    helper.instsize = NULL;
-    box_free(helper.predecessor);
-    helper.predecessor = NULL;
     block->size = sz;
     block->isize = helper.size;
-    block->actual_block = actual_p;
     block->block = p;
-    block->jmpnext = next+sizeof(void*);
-    *(dynablock_t**)next = block;
-    CreateJmpNextTo(block->jmpnext, arm_next);
     block->need_test = 0;
     //block->x86_addr = (void*)start;
     block->x86_size = end-start;
     if(box86_dynarec_largest<block->x86_size)
         box86_dynarec_largest = block->x86_size;
-    // all done...
-    __clear_cache(actual_p, actual_p+sz);   // need to clear the cache before execution...
     block->hash = X31_hash_code(block->x86_addr, block->x86_size);
     // Check if something changed, to abbort if it as
     if(block->hash != hash) {
@@ -550,6 +541,34 @@ dynarec_log(LOG_DEBUG, "Asked to Fill block %p with %p\n", block, (void*)addr);
         CancelBlock();
         return NULL;
     }
+    // fill sons if any
+    dynablock_t** sons = NULL;
+    int sons_size = 0;
+    if(helper.sons_size) {
+        sons = (dynablock_t**)box_calloc(helper.sons_size, sizeof(dynablock_t*));
+        for (int i=0; i<helper.sons_size; ++i) {
+            int created = 1;
+            dynablock_t *son = AddNewDynablock(block->parent, helper.sons_x86[i], &created);
+            if(created) {    // avoid breaking a working block!
+                son->block = helper.sons_arm[i];
+                son->x86_addr = (void*)helper.sons_x86[i];
+                son->x86_size = end-helper.sons_x86[i];
+                if(!son->x86_size) {printf_log(LOG_NONE, "Warning, son with null x86 size! (@%p / ARM=%p)", son->x86_addr, son->block);}
+                son->father = block;
+                son->done = 1;
+                sons[sons_size++] = son;
+                if(!son->parent)
+                    son->parent = block->parent;
+            }
+        }
+        if(sons_size) {
+            block->sons = sons;
+            block->sons_size = sons_size;
+        } else
+            box_free(sons);
+    }
+    box_free(helper.predecessor);
+    helper.predecessor = NULL;
     current_helper = NULL;
     block->done = 1;
     return (void*)block;

src/dynarec/dynarec_arm_65.c

@@ -416,6 +416,15 @@ uintptr_t dynarecGS(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
             }
             break;
 
+        case 0xA2:
+            INST_NAME("MOV GS:Od, AL");
+            grab_tlsdata(dyn, addr, ninst, x1);
+            u32 = F32;
+            MOV32(x2, u32);
+            ADD_REG_LSL_IMM5(x2, x1, x2, 0);
+            STRB_IMM9(xEAX, x2, 0);
+            break;
+
         case 0xA3:
             INST_NAME("MOV GS:Od, EAX");
             grab_tlsdata(dyn, addr, ninst, x1);

src/dynarec/dynarec_arm_pass.c

@@ -35,6 +35,7 @@ uintptr_t arm_pass(dynarec_arm_t* dyn, uintptr_t addr)
     uintptr_t init_addr = addr;
     MAYUSE(init_addr);
     int need_epilog = 1;
+    dyn->sons_size = 0;
     // Clean up (because there are multiple passes)
     dyn->f.pending = 0;
     dyn->f.dfnone = 0;
@@ -228,6 +229,6 @@ uintptr_t arm_pass(dynarec_arm_t* dyn, uintptr_t addr)
         jump_to_epilog(dyn, ip, 0, ninst);  // no linker here, it's an unknow instruction
     }
     FINI;
-    MESSAGE(LOG_DUMP, "---- END OF BLOCK ---- (%d)\n", dyn->size);
+    MESSAGE(LOG_DUMP, "---- END OF BLOCK ---- (%d, %d sons)\n", dyn->size, dyn->sons_size);
     return addr;
 }

src/dynarec/dynarec_arm_pass2.h

@@ -6,6 +6,8 @@
 #define NEW_INST                                                                                        \
         if(ninst) {                                                                                     \
                 dyn->insts[ninst].address = (dyn->insts[ninst-1].address+dyn->insts[ninst-1].size);     \
+                if(ninst && isInstClean(dyn, ninst))                                                    \
+                        ++dyn->sons_size;                                                               \
         }
 #define INST_EPILOG dyn->insts[ninst].epilog = dyn->arm_size; 
 #define INST_NAME(name) 

src/dynarec/dynarec_arm_pass3.h

@@ -8,6 +8,12 @@
 
 #define MESSAGE(A, ...)  if(box86_dynarec_dump) dynarec_log(LOG_NONE, __VA_ARGS__)
 #define NEW_INST        \
+    if(ninst && isInstClean(dyn, ninst)) {                      \
+        dyn->sons_x86[dyn->sons_size] = (uintptr_t)ip;          \
+        dyn->sons_arm[dyn->sons_size] = dyn->block;             \
+        MESSAGE(LOG_DUMP, "----> potential Son here %p/%p\n", (void*)ip, dyn->block);  \
+        ++dyn->sons_size;                                       \
+    }
 
 #define INST_EPILOG     
 #define INST_NAME(name) \

src/dynarec/dynarec_arm_private.h

@@ -5,7 +5,6 @@
 
 typedef struct x86emu_s x86emu_t;
 typedef struct dynablock_s dynablock_t;
-typedef struct instsize_s instsize_t;
 
 #define BARRIER_MAYBE   8
 
@@ -19,12 +18,12 @@ typedef struct instsize_s instsize_t;
 typedef union neon_cache_s {
     int8_t           v;
     struct {
-        unsigned int t:4;   // reg type
-        unsigned int n:4;   // reg number
+        uint8_t t:4;   // reg type
+        uint8_t n:4;   // reg number
     };
 } neon_cache_t;
 typedef union sse_cache_s {
-    int     v;
+    int8_t     v;
     struct {
         uint8_t reg;
         uint8_t write;
@@ -96,15 +95,16 @@ typedef struct dynarec_arm_s {
     uintptr_t*          next;       // variable array of "next" jump address
     int                 next_sz;
     int                 next_cap;
+    uintptr_t*          sons_x86;   // the x86 address of potential dynablock sons
+    void**              sons_arm;   // the arm address of potential dynablock sons
+    int                 sons_size;  // number of potential dynablock sons
     int*                predecessor;// single array of all predecessor
     dynablock_t*        dynablock;
-    instsize_t*         instsize;
 } dynarec_arm_t;
 
 void add_next(dynarec_arm_t *dyn, uintptr_t addr);
 uintptr_t get_closest_next(dynarec_arm_t *dyn, uintptr_t addr);
 int is_nops(dynarec_arm_t *dyn, uintptr_t addr, int n);
 int is_instructions(dynarec_arm_t *dyn, uintptr_t addr, int n);
-void CreateJmpNextTo(void* addr, void* tonext);
 
 #endif //__DYNAREC_ARM_PRIVATE_H_

src/dynarec/dynarec_next.h

@@ -1,8 +0,0 @@
-#ifndef __DYNAREC_NEXT_H__
-#define __DYNAREC_NEXT_H__
-
-void arm_next(void) EXPORTDYN;
-void arm_prolog(x86emu_t* emu, void* addr) EXPORTDYN;
-void arm_epilog() EXPORTDYN;
-
-#endif //__DYNAREC_NEXT_H__

src/elfs/elfloader.c

@@ -383,7 +383,7 @@ int ReloadElfMemory(FILE* f, box86context_t* context, elfheader_t* head)
     // TLS data are just a copy, no need to re-load it
     return 0;
 }
-int FindR386COPYRel(elfheader_t* h, const char* name, uintptr_t *offs, uint32_t** p, int version, const char* vername)
+int FindR386COPYRel(elfheader_t* h, const char* name, uintptr_t *offs, uint32_t** p, size_t size, int version, const char* vername)
 {
     if(!h)
         return 0;
@@ -396,7 +396,7 @@ int FindR386COPYRel(elfheader_t* h, const char* name, uintptr_t *offs, uint32_t*
             int t = ELF32_R_TYPE(rel[i].r_info);
             Elf32_Sym *sym = &h->DynSym[ELF32_R_SYM(rel[i].r_info)];
             const char* symname = SymName(h, sym);
-            if(t==R_386_COPY && symname && !strcmp(symname, name)) {
+            if(t==R_386_COPY && symname && !strcmp(symname, name) && sym->st_size==size) {
                 int version2 = h->VerSym?((Elf32_Half*)((uintptr_t)h->VerSym+h->delta))[ELF32_R_SYM(rel[i].r_info)]:-1;
                 if(version2!=-1) version2 &= 0x7fff;
                 if(version && !version2) version2=-1;   // match a versionned symbol against a global "local" symbol
@@ -416,7 +416,7 @@ int FindR386COPYRel(elfheader_t* h, const char* name, uintptr_t *offs, uint32_t*
             int t = ELF32_R_TYPE(rela[i].r_info);
             Elf32_Sym *sym = &h->DynSym[ELF32_R_SYM(rela[i].r_info)];
             const char* symname = SymName(h, sym);
-            if(t==R_386_COPY && symname && !strcmp(symname, name)) {
+            if(t==R_386_COPY && symname && !strcmp(symname, name) && sym->st_size==size) {
                 int version2 = h->VerSym?((Elf32_Half*)((uintptr_t)h->VerSym+h->delta))[ELF32_R_SYM(rela[i].r_info)]:-1;
                 if(version2!=-1) version2 &= 0x7fff;
                 if(version && !version2) version2=-1;   // match a versionned symbol against a global "local" symbol
@@ -444,6 +444,7 @@ int RelocateElfREL(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t*
         uint32_t *p = (uint32_t*)(rel[i].r_offset + head->delta);
         uintptr_t offs = 0;
         uintptr_t end = 0;
+        size_t size = sym->st_size;
         elfheader_t* h_tls = NULL;//head;
         int version = head->VerSym?((Elf32_Half*)((uintptr_t)head->VerSym+head->delta))[ELF32_R_SYM(rel[i].r_info)]:-1;
         if(version!=-1) version &=0x7fff;
@@ -494,11 +495,11 @@ int RelocateElfREL(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t*
                 globoffs = offs;
                 globend = end;
                 offs = end = 0;
-                GetSymbolStartEnd(GetGlobalData(maplib), symname, &offs, &end, version, vername, 1, defver); // try globaldata symbols first
+                GetSizedSymbolStartEnd(GetGlobalData(maplib), symname, &offs, &end, size, version, vername, 1, defver); // try globaldata symbols first
                 if(!offs && local_maplib)
-                    GetNoSelfSymbolStartEnd(local_maplib, symname, &offs, &end, head, version, vername);
+                    GetNoSelfSymbolStartEnd(local_maplib, symname, &offs, &end, head, size, version, vername);
                 if(!offs)
-                    GetNoSelfSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername);
+                    GetNoSelfSymbolStartEnd(maplib, symname, &offs, &end, head, size, version, vername);
                 if(!offs) {offs = globoffs; end = globend;}
                 if(offs) {
                     // add r_addend to p?
@@ -510,7 +511,7 @@ int RelocateElfREL(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t*
                 }
                 break;
             case R_386_GLOB_DAT:
-                if(head!=my_context->elfs[0] && !IsGlobalNoWeakSymbolInNative(maplib, symname, version, vername) && FindR386COPYRel(my_context->elfs[0], symname, &globoffs, &globp, version, vername)) {
+                if(head!=my_context->elfs[0] && !IsGlobalNoWeakSymbolInNative(maplib, symname, version, vername) && FindR386COPYRel(my_context->elfs[0], symname, &globoffs, &globp, size, version, vername)) {
                     // set global offs / size for the symbol
                     offs = sym->st_value + head->delta;
                     end = offs + sym->st_size;
@@ -685,6 +686,7 @@ int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t
         uint32_t *p = (uint32_t*)(rela[i].r_offset + head->delta);
         uintptr_t offs = 0;
         uintptr_t end = 0;
+        size_t size = sym->st_size;
         elfheader_t* h_tls = NULL;//head;
         int version = head->VerSym?((Elf32_Half*)((uintptr_t)head->VerSym+head->delta))[ELF32_R_SYM(rela[i].r_info)]:-1;
         if(version!=-1) version &=0x7fff;
@@ -736,9 +738,9 @@ int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t
                 offs = end = 0;
                 GetSymbolStartEnd(GetGlobalData(maplib), symname, &offs, &end, version, vername, 1, defver); // try globaldata symbols first
                 if(!offs && local_maplib)
-                    GetNoSelfSymbolStartEnd(local_maplib, symname, &offs, &end, head, version, vername);
+                    GetNoSelfSymbolStartEnd(local_maplib, symname, &offs, &end, head, size, version, vername);
                 if(!offs)
-                    GetNoSelfSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername);
+                    GetNoSelfSymbolStartEnd(maplib, symname, &offs, &end, head, size, version, vername);
                 if(!offs) {offs = globoffs; end = globend;}
                 if(offs) {
                     // add r_addend to p?
@@ -750,7 +752,7 @@ int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t
                 }
                 break;
             case R_386_GLOB_DAT:
-                if(head!=my_context->elfs[0] && !IsGlobalNoWeakSymbolInNative(maplib, symname, version, vername) && FindR386COPYRel(my_context->elfs[0], symname, &globoffs, &globp, version, vername)) {
+                if(head!=my_context->elfs[0] && !IsGlobalNoWeakSymbolInNative(maplib, symname, version, vername) && FindR386COPYRel(my_context->elfs[0], symname, &globoffs, &globp, size, version, vername)) {
                     // set global offs / size for the symbol
                     offs = sym->st_value + head->delta;
                     end = offs + sym->st_size;
@@ -1558,7 +1560,7 @@ void* ElfSetBrk(void* newbrk)
 }
 
 #ifdef DYNAREC
-dynablock_t* GetDynablocksFromAddress(box86context_t *context, uintptr_t addr)
+dynablocklist_t* GetDynablocksFromAddress(box86context_t *context, uintptr_t addr)
 {
     // if we are here, the there is not block in standard "space"
     /*dynablocklist_t* ret = getDBFromAddress(addr);
@@ -1567,7 +1569,7 @@ dynablock_t* GetDynablocksFromAddress(box86context_t *context, uintptr_t addr)
     }*/
     if(box86_dynarec_forced) {
         addDBFromAddressRange(addr, 1);
-        return getDB(addr);
+        return getDB(addr>>DYNAMAP_SHIFT);
     }
     //check if address is in an elf... if yes, grant a block (should I warn)
     Dl_info info;

src/elfs/elfloader_private.h

@@ -1,6 +1,10 @@
 #ifndef __ELFLOADER_PRIVATE_H_
 #define __ELFLOADER_PRIVATE_H_
 
+#ifdef DYNAREC
+typedef struct dynablocklist_s dynablocklist_t;
+#endif
+
 typedef struct library_s library_t;
 typedef struct needed_libs_s needed_libs_t;
 typedef struct kh_mapsymbols_s kh_mapsymbols_t;

src/emu/x86int3.c

@@ -94,7 +94,7 @@ void x86Int3(x86emu_t* emu)
                 char* buffret = cycle_log?my_context->log_ret[my_context->current_line]:NULL;
                 if(buffret) buffret[0] = '\0';
                 if(cycle_log)
-                    my_context->current_line = (my_context->current_line+1)&(CYCLE_LOG-1);
+                    my_context->current_line = (my_context->current_line+1)%cycle_log;
                 char *tmp;
                 int post = 0;
                 int perr = 0;
@@ -294,9 +294,11 @@ void x86Int3(x86emu_t* emu)
                 } else {
                     snprintf(buff, 255, "%04d|%p: Calling %s (%08X, %08X, %08X...)", tid, *(void**)(R_ESP), s, *(uint32_t*)(R_ESP+4), *(uint32_t*)(R_ESP+8), *(uint32_t*)(R_ESP+12));
                 }
-                pthread_mutex_lock(&emu->context->mutex_trace);
-                if(!cycle_log) printf_log(LOG_NONE, "%s =>", buff);
-                pthread_mutex_unlock(&emu->context->mutex_trace);
+                if(!cycle_log) {
+                    pthread_mutex_lock(&emu->context->mutex_trace);
+                    printf_log(LOG_NONE, "%s =>", buff);
+                    pthread_mutex_unlock(&emu->context->mutex_trace);
+                }
                 w(emu, addr);   // some function never come back, so unlock the mutex first!
                 if(post)
                     switch(post) {
@@ -325,12 +327,13 @@ void x86Int3(x86emu_t* emu)
                     snprintf(buff3, 63, " (errno=%d:\"%s\")", errno, strerror(errno));
                 else if(perr==3 && ((int)R_EAX)==-1)
                     snprintf(buff3, 63, " (errno=%d:\"%s\")", errno, strerror(errno));
-                pthread_mutex_lock(&emu->context->mutex_trace);
                 if(cycle_log)
                     snprintf(buffret, 127, "0x%X%s%s", R_EAX, buff2, buff3);
-                else
+                else {
+                    pthread_mutex_lock(&emu->context->mutex_trace);
                     printf_log(LOG_NONE, " return 0x%08X%s%s\n", R_EAX, buff2, buff3);
-                pthread_mutex_unlock(&emu->context->mutex_trace);
+                    pthread_mutex_unlock(&emu->context->mutex_trace);
+                }
             } else
                 w(emu, addr);
         }
@@ -346,4 +349,17 @@ void x86Int3(x86emu_t* emu)
 int GetTID()
 {
     return syscall(SYS_gettid);
+}
+
+void print_cycle_log(int loglevel) {
+    if(cycle_log) {
+        printf_log(LOG_INFO, "Last calls\n");
+        int j = (my_context->current_line+1)%cycle_log;
+        for (int i=0; i<cycle_log; ++i) {
+            int k = (i+j)%cycle_log;
+            if(my_context->log_call[k][0]) {
+                printf_log(loglevel, "%s => return %s\n", my_context->log_call[k], my_context->log_ret[k]);
+            }
+        }
+    }
 }

src/emu/x86tls.c

@@ -136,7 +136,7 @@ static int sizeDTS(box86context_t* context)
 }
 static int sizeTLSData(int s)
 {
-    uint32_t mask = box86_nogtk?0xffff:0x1fff;
+    uint32_t mask = 0xffff/*box64_nogtk?0xffff:0x1fff*/;    // x86 does the mapping per 64K blocks, so it makes sense to have it this large
     return (s+mask)&~mask;
 }
 

src/include/box86context.h

@@ -27,6 +27,7 @@ typedef struct atfork_fnc_s {
 } atfork_fnc_t;
 #ifdef DYNAREC
 typedef struct dynablock_s      dynablock_t;
+typedef struct dynablocklist_s  dynablocklist_t;
 typedef struct mmaplist_s       mmaplist_t;
 typedef struct kh_dynablocks_s  kh_dynablocks_t;
 #endif
@@ -39,7 +40,6 @@ typedef void* (*procaddess_t)(const char* name);
 typedef void* (*vkprocaddess_t)(void* instance, const char* name);
 
 #define MAX_SIGNAL 64
-#define CYCLE_LOG  16
 
 typedef struct tlsdatasize_s {
     int         tlssize;
@@ -130,7 +130,6 @@ typedef struct box86context_s {
     pthread_mutex_t     mutex_lock;     // dynarec build will use their own mecanism
     #else
     pthread_mutex_t     mutex_dyndump;
-    uintptr_t           max_db_size;    // the biggest (in x86_64 instructions bytes) built dynablock
     int                 trace_dynarec;
     #endif
     pthread_mutex_t     mutex_tls;
@@ -188,8 +187,8 @@ typedef struct box86context_s {
     int                 stack_clone_used;
 
     // rolling logs
-    char*               log_call[CYCLE_LOG];
-    char*               log_ret[CYCLE_LOG];
+    char*               *log_call;
+    char*               *log_ret;
     int                 current_line;
 } box86context_t;
 
@@ -198,6 +197,11 @@ extern box86context_t *my_context; // global context
 box86context_t *NewBox86Context(int argc);
 void FreeBox86Context(box86context_t** context);
 
+// Cycle log handling
+void freeCycleLog(box86context_t* ctx);
+void initCycleLog(box86context_t* context);
+void print_cycle_log(int loglevel);
+
 // return the index of the added header
 int AddElfHeader(box86context_t* ctx, elfheader_t* head);
 

src/include/custommem.h

@@ -18,6 +18,7 @@ void customFree(void* p);
 
 #ifdef DYNAREC
 typedef struct dynablock_s dynablock_t;
+typedef struct dynablocklist_s dynablocklist_t;
 // custom protection flag to mark Page that are Write protected for Dynarec purpose
 uintptr_t AllocDynarecMap(dynablock_t* db, int size);
 void FreeDynarecMap(dynablock_t* db, uintptr_t addr, uint32_t size);
@@ -25,15 +26,12 @@ void FreeDynarecMap(dynablock_t* db, uintptr_t addr, uint32_t size);
 void addDBFromAddressRange(uintptr_t addr, uintptr_t size);
 void cleanDBFromAddressRange(uintptr_t addr, uintptr_t size, int destroy);
 
-dynablock_t* getDB(uintptr_t addr);
-int addJumpTableIfDefault(void* addr, void* jmp); // return 1 if write was succesfull
-void setJumpTableIfRef(void* addr, void* jmp, void* ref); // return 1 if write was succesfull
+dynablocklist_t* getDB(uintptr_t idx);
+void addJumpTableIfDefault(void* addr, void* jmp);
 void setJumpTableDefault(void* addr);
-void setJumpTableDefaultRef(void* addr, void* jmp);
 int isJumpTableDefault(void* addr);
 uintptr_t getJumpTable();
 uintptr_t getJumpTableAddress(uintptr_t addr);
-uintptr_t getJumpAddress(uintptr_t addr);
 #endif
 
 #define PROT_DYNAREC    0x80
@@ -49,9 +47,6 @@ void loadProtectionFromMap();
 #ifdef DYNAREC
 void protectDB(uintptr_t addr, uintptr_t size);
 void unprotectDB(uintptr_t addr, uintptr_t size, int mark); // if mark==0, the blocks are not marked as potentially dirty
-int IsInHotPage(uintptr_t addr);
-int AreaInHotPage(uintptr_t start, uintptr_t end);
-void AddHotPage(uintptr_t addr);
 #endif
 void* find32bitBlock(size_t size);
 void* findBlockNearHint(void* hint, size_t size);

src/include/dynablock.h

@@ -3,21 +3,31 @@
 
 typedef struct x86emu_s x86emu_t;
 typedef struct dynablock_s dynablock_t;
+typedef struct dynablocklist_s dynablocklist_t;
 typedef struct kh_dynablocks_s  kh_dynablocks_t;
 
 uint32_t X31_hash_code(void* addr, int len);
+dynablocklist_t* NewDynablockList(uintptr_t text, int textsz, int direct);
+void FreeDynablockList(dynablocklist_t** dynablocks);
 void FreeDynablock(dynablock_t* db, int need_lock);
 void MarkDynablock(dynablock_t* db);
-void MarkRangeDynablock(dynablock_t* db, uintptr_t addr, uintptr_t size);
-int FreeRangeDynablock(dynablock_t* db, uintptr_t addr, uintptr_t size);
+void FreeRangeDynablock(dynablocklist_t* dynablocks, uintptr_t addr, uintptr_t size);
+void MarkRangeDynablock(dynablocklist_t* dynablocks, uintptr_t addr, uintptr_t size);
 
 dynablock_t* FindDynablockFromNativeAddress(void* addr);    // defined in box86context.h
 dynablock_t* FindDynablockDynablocklist(void* addr, kh_dynablocks_t* dynablocks);
 
+uintptr_t StartDynablockList(dynablocklist_t* db);
+uintptr_t EndDynablockList(dynablocklist_t* db);
+void MarkDirectDynablock(dynablocklist_t* dynablocks, uintptr_t addr, uintptr_t size);
+
 // Handling of Dynarec block (i.e. an exectable chunk of x86 translated code)
-dynablock_t* DBGetBlock(x86emu_t* emu, uintptr_t addr, int create);   // return NULL if block is not found / cannot be created. Don't create if create==0
+dynablock_t* DBGetBlock(x86emu_t* emu, uintptr_t addr, int create, dynablock_t** current);   // return NULL if block is not found / cannot be created. Don't create if create==0
 dynablock_t* DBAlternateBlock(x86emu_t* emu, uintptr_t addr, uintptr_t filladdr);
 
+// Create and Add an new dynablock in the list, handling direct/map
+dynablock_t *AddNewDynablock(dynablocklist_t* dynablocks, uintptr_t addr, int* created);
+
 // for use in signal handler
 void cancelFillBlock();
 

src/include/elfloader.h

@@ -10,7 +10,7 @@ typedef struct box86context_s box86context_t;
 typedef struct x86emu_s x86emu_t;
 typedef struct needed_libs_s needed_libs_t;
 #ifdef DYNAREC
-typedef struct dynablock_s dynablock_t;
+typedef struct dynablocklist_s dynablocklist_t;
 #endif
 
 elfheader_t* LoadAndCheckElfHeader(FILE* f, const char* name, int exec); // exec : 0 = lib, 1 = exec
@@ -49,7 +49,8 @@ uint32_t GetTLSSize(elfheader_t* h);
 void* GetTLSPointer(box86context_t* context, elfheader_t* h);
 void* GetDTatOffset(box86context_t* context, int index, int offset);
 #ifdef DYNAREC
-dynablock_t* GetDynablocksFromAddress(box86context_t *context, uintptr_t addr);
+dynablocklist_t* GetDynablocksFromAddress(box86context_t* context, uintptr_t addr);
+dynablocklist_t* GetDynablocksFromElf(elfheader_t* h);
 #endif
 void ResetSpecialCaseMainElf(elfheader_t* h);
 void CreateMemorymapFile(box86context_t* context, int fd);

src/include/librarian.h

@@ -26,7 +26,7 @@ int AddNeededLib(lib_t* maplib, needed_libs_t* neededlibs, library_t* deplib, in
 library_t* GetLibMapLib(lib_t* maplib, const char* name);
 library_t* GetLibInternal(const char* name);
 uintptr_t FindGlobalSymbol(lib_t *maplib, const char* name, int version, const char* vername);
-int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t* self, int version, const char* vername);
+int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t* self, size_t size, int version, const char* vername);
 int GetGlobalSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t *self, int version, const char* vername);
 int GetGlobalNoWeakSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, int version, const char* vername);
 int GetLocalSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t *self, int version, const char* vername);

src/include/library.h

@@ -24,9 +24,9 @@ void Free1Library(library_t **lib, x86emu_t* emu);
 
 char* GetNameLib(library_t *lib);
 int IsSameLib(library_t* lib, const char* path);    // check if lib is same (path -> name)
-int GetLibGlobalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, int *weak, int version, const char* vername, int local);
-int GetLibWeakSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, int* weak, int version, const char* vername, int local);
-int GetLibLocalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, int* weak, int version, const char* vername, int local);
+int GetLibGlobalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int *weak, int version, const char* vername, int local);
+int GetLibWeakSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int* weak, int version, const char* vername, int local);
+int GetLibLocalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int* weak, int version, const char* vername, int local);
 void fillGLProcWrapper(box86context_t* context);
 void freeGLProcWrapper(box86context_t* context);
 void fillALProcWrapper(box86context_t* context);

src/include/symbols.h

@@ -18,6 +18,7 @@ uintptr_t FindSymbol(kh_mapsymbols_t *mapsymbols, const char* name, int ver, con
 // don't add if already there
 void AddUniqueSymbol(kh_mapsymbols_t *mapsymbols, const char* name, uintptr_t addr, uint32_t sz, int ver, const char* vername);
 int GetSymbolStartEnd(kh_mapsymbols_t* mapsymbols, const char* name, uintptr_t* start, uintptr_t* end, int ver, const char* vername, int local, const char* defver);
+int GetSizedSymbolStartEnd(kh_mapsymbols_t* mapsymbols, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int ver, const char* vername, int local, const char* defver);
 const char* GetSymbolName(kh_mapsymbols_t* mapsymbols, void* p, uintptr_t* offs, uint32_t* sz, const char** vername);
 
 // default version handling

src/include/wrappedlibs.h

@@ -7,7 +7,7 @@ typedef struct box86context_s  box86context_t;
 
 typedef int (*wrappedlib_init_t)(library_t * lib, box86context_t* box86);  // 0 = success
 typedef void (*wrappedlib_fini_t)(library_t * lib);
-typedef int (*wrappedlib_get_t)(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int* weak, int version, const char* vername, int local);
+typedef int (*wrappedlib_get_t)(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t size, int* weak, int version, const char* vername, int local);
 
 void setNeededLibs(library_t* lib, int n, ...);
 #define SETALT(A)       lib->w.altmy = box_strdup(#A)

src/librarian/librarian.c

@@ -385,7 +385,7 @@ static int isLocal(elfheader_t* self, library_t* l)
     return 0;
 }
 
-int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t* self, int version, const char* vername)
+int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t* self, size_t size, int version, const char* vername)
 {
     assert(self);   // need self for this one
     //search for the self, to start "next"
@@ -399,13 +399,13 @@ int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, u
         go = 0; // not found...
     for(int i=go; i<maplib->libsz; ++i) {
         if(GetElfIndex(maplib->libraries[i])==-1 || (my_context->elfs[GetElfIndex(maplib->libraries[i])]!=self))
-            if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, 0))
+            if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, 0))
                 if(*start)
                     return 1;
     }
     for(int i=go; i<maplib->libsz; ++i)
         if(GetElfIndex(maplib->libraries[i])==-1 || (my_context->elfs[GetElfIndex(maplib->libraries[i])]!=self))
-            GetLibWeakSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, 0);
+            GetLibWeakSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, 0);
     // loop done, weak symbol found
     if(weak && *start)
         return 1;
@@ -413,23 +413,23 @@ int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, u
     if(self) {
         if(my_context->elfs[0]!=self) {
             const char* defver = GetDefaultVersion(my_context->globaldefver, name);
-            if(GetSymbolStartEnd(GetMapSymbols(my_context->elfs[0]), name, start, end, version, vername, 1, defver))
+            if(GetSizedSymbolStartEnd(GetMapSymbols(my_context->elfs[0]), name, start, end, size, version, vername, 1, defver))
                 if(*start)
                     return 1;
             defver = GetDefaultVersion(my_context->weakdefver, name);
-            if(GetSymbolStartEnd(GetWeakSymbols(my_context->elfs[0]), name, start, end, version, vername, 1, defver))
+            if(GetSizedSymbolStartEnd(GetWeakSymbols(my_context->elfs[0]), name, start, end, size, version, vername, 1, defver))
                 if(*start)
                     weak = 1;
         }
         for(int i=0; i<go; ++i) {
             if(GetElfIndex(maplib->libraries[i])==-1 || (my_context->elfs[GetElfIndex(maplib->libraries[i])]!=self))
-                if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, 1))
+                if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, 1))
                     if(*start)
                         return 1;
         }
         for(int i=0; i<go; ++i) {
             if(GetElfIndex(maplib->libraries[i])==-1 || (my_context->elfs[GetElfIndex(maplib->libraries[i])]!=self))
-                GetLibWeakSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, 1);
+                GetLibWeakSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, 1);
         }
     if(weak && *start)
         return 1;
@@ -440,6 +440,7 @@ int GetNoSelfSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, u
 static int GetGlobalSymbolStartEnd_internal(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, elfheader_t* self, int version, const char* vername)
 {
     int weak = 0;
+    size_t size = 0;
     // check with default version...
     const char* defver = GetDefaultVersion(my_context->globaldefver, name);
     // search non-weak symbol, from older to newer (first GLOBAL object wins)
@@ -449,12 +450,12 @@ static int GetGlobalSymbolStartEnd_internal(lib_t *maplib, const char* name, uin
     // TODO: create a temporary map to search lib only 1 time, and in order of needed...
     // search in needed libs from neededlibs first, in order
     for(int i=0; i<my_context->neededlibs.size; ++i)
-        if(GetLibGlobalSymbolStartEnd(my_context->neededlibs.libs[i], name, start, end, &weak, version, vername, isLocal(self, my_context->neededlibs.libs[i])))
+        if(GetLibGlobalSymbolStartEnd(my_context->neededlibs.libs[i], name, start, end, size, &weak, version, vername, isLocal(self, my_context->neededlibs.libs[i])))
             if(*start)
                 return 1;
     // search in global symbols
     for(int i=0; i<maplib->libsz; ++i) {
-        if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, isLocal(self, maplib->libraries[i])))
+        if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, isLocal(self, maplib->libraries[i])))
             if(*start)
                 return 1;
     }
@@ -468,7 +469,7 @@ static int GetGlobalSymbolStartEnd_internal(lib_t *maplib, const char* name, uin
             ok = 1;
 
     for(int i=0; i<maplib->libsz; ++i) {
-        if(GetLibWeakSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, isLocal(self, maplib->libraries[i])))
+        if(GetLibWeakSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, isLocal(self, maplib->libraries[i])))
             if(*start)
                 ok = 1;
     }
@@ -514,6 +515,7 @@ elfheader_t* GetGlobalSymbolElf(lib_t *maplib, const char* name, int version, co
 {
     uintptr_t start = 0;
     uintptr_t end = 0;
+    size_t size = 0;
     int weak = 0;
     elfheader_t* ret = NULL;
     // check with default version...
@@ -522,7 +524,7 @@ elfheader_t* GetGlobalSymbolElf(lib_t *maplib, const char* name, int version, co
     if(GetSymbolStartEnd(GetMapSymbols(my_context->elfs[0]), name, &start, &end, version, vername, 1, defver))
         return my_context->elfs[0];
     for(int i=0; i<maplib->libsz; ++i) {
-        if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, &start, &end, &weak, version, vername, 1)) {
+        if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, &start, &end, size, &weak, version, vername, 1)) {
             int idx = GetElfIndex(maplib->libraries[i]);
             if(idx==-1) {
                 printf_log(LOG_NONE, "Warning, getting Elf info for a native symbol \"%s\" from lib \"%s\"\n", name, GetNameLib(maplib->libraries[i]));
@@ -539,7 +541,7 @@ elfheader_t* GetGlobalSymbolElf(lib_t *maplib, const char* name, int version, co
     if(GetSymbolStartEnd(GetWeakSymbols(my_context->elfs[0]), name, &start, &end, version, vername, 1, defver))
         ret = my_context->elfs[0];
     for(int i=0; i<maplib->libsz; ++i) {
-        if(GetLibWeakSymbolStartEnd(maplib->libraries[i], name, &start, &end, &weak, version, vername, 1)) {
+        if(GetLibWeakSymbolStartEnd(maplib->libraries[i], name, &start, &end, size, &weak, version, vername, 1)) {
             int idx = GetElfIndex(maplib->libraries[i]);
             if(idx==-1) {
                 printf_log(LOG_NONE, "Warning, getting Elf info for a native symbol \"%s\" from lib \"%s\"\n", name, GetNameLib(maplib->libraries[i]));
@@ -558,6 +560,7 @@ elfheader_t* GetGlobalSymbolElf(lib_t *maplib, const char* name, int version, co
 int GetGlobalNoWeakSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, uintptr_t* end, int version, const char* vername)
 {
     int weak = 0;
+    size_t size = 0;
     // check with default version...
     const char* defver = GetDefaultVersion(my_context->globaldefver, name);
 
@@ -565,7 +568,7 @@ int GetGlobalNoWeakSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* st
         if(*start || *end)
             return 1;
     for(int i=0; i<maplib->libsz; ++i)
-        if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, 1))
+        if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, 1))
             if(*start || *end)
                 return 1;
     // nope, not found
@@ -575,11 +578,12 @@ int GetGlobalNoWeakSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* st
 int IsGlobalNoWeakSymbolInNative(lib_t *maplib, const char* name, int version, const char* vername)
 {
     uintptr_t start, end;
+    size_t size = 0;
     int weak;
     // check with default version...
     for(int i=0; i<maplib->libsz; ++i)
         if(GetElfIndex(maplib->libraries[i])==-1)
-            if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, &start, &end, &weak, version, vername, 1))
+            if(GetLibGlobalSymbolStartEnd(maplib->libraries[i], name, &start, &end, size, &weak, version, vername, 1))
                 if(start || end)
                     return 1;
     // nope, not found
@@ -591,6 +595,7 @@ int GetLocalSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, ui
 {
     // check with default version...
     int weak;
+    size_t size = 0;
 
     if(my_context->elfs[0]==self || !self) {
         if(GetSymbolStartEnd(GetLocalSymbols(my_context->elfs[0]), name, start, end, version, vername, 1, NULL))
@@ -601,7 +606,7 @@ int GetLocalSymbolStartEnd(lib_t *maplib, const char* name, uintptr_t* start, ui
     }
     for(int i=0; i<maplib->libsz; ++i) {
         if(GetElfIndex(maplib->libraries[i])!=-1 && (!self || my_context->elfs[GetElfIndex(maplib->libraries[i])]==self)) {
-            if(GetLibLocalSymbolStartEnd(maplib->libraries[i], name, start, end, &weak, version, vername, 1))
+            if(GetLibLocalSymbolStartEnd(maplib->libraries[i], name, start, end, size, &weak, version, vername, 1))
                 if(*start)
                     return 1;
             if(self)

src/librarian/library.c

@@ -117,8 +117,9 @@ void WrappedLib_FinishFini(library_t* lib)
     FreeBridge(&lib->w.bridge);
 }
 
-int WrappedLib_GetWeak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int *weak, int version, const char* vername, int local)
+int WrappedLib_GetWeak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t asked_size, int *weak, int version, const char* vername, int local)
 {
+    // ignoring asked size on wrapped libs
     uintptr_t addr = 0;
     uint32_t size = 0;
     int wk = 0;
@@ -135,12 +136,12 @@ int WrappedLib_GetWeak(library_t* lib, const char* name, uintptr_t *offs, uint32
     *weak = wk;
     return 1;
 }
-int EmuLib_GetWeak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int* weak, int version, const char* vername, int local)
+int EmuLib_GetWeak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t asked_size, int* weak, int version, const char* vername, int local)
 {
     uintptr_t start, end;
     const char* defver = GetDefaultVersion(my_context->weakdefver, name);
     // weak symbols...
-    if(GetSymbolStartEnd(GetWeakSymbols(lib->e.elf), name, &start, &end, version, vername, local, defver))
+    if(GetSizedSymbolStartEnd(GetWeakSymbols(lib->e.elf), name, &start, &end, asked_size, version, vername, local, defver))
     {
         *offs = start;
         *sz = end-start;
@@ -149,8 +150,9 @@ int EmuLib_GetWeak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *
     }
     return 0;
 }
-int WrappedLib_GetGlobal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int* weak, int version, const char* vername, int local)
+int WrappedLib_GetGlobal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t asked_size, int* weak, int version, const char* vername, int local)
 {
+    // ignoring asked size on wrapped libs
     uintptr_t addr = 0;
     uint32_t size = 0;
     int wk = 0;
@@ -167,11 +169,11 @@ int WrappedLib_GetGlobal(library_t* lib, const char* name, uintptr_t *offs, uint
     *weak = 0;
     return 1;
 }
-int EmuLib_GetGlobal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int *weak, int version, const char* vername, int local)
+int EmuLib_GetGlobal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t asked_size, int *weak, int version, const char* vername, int local)
 {
     uintptr_t start, end;
     const char* defver = GetDefaultVersion(my_context->globaldefver, name);
-    if(GetSymbolStartEnd(GetMapSymbols(lib->e.elf), name, &start, &end, version, vername, local, defver))
+    if(GetSizedSymbolStartEnd(GetMapSymbols(lib->e.elf), name, &start, &end, asked_size, version, vername, local, defver))
     {
         *offs = start;
         *sz = end-start;
@@ -180,12 +182,12 @@ int EmuLib_GetGlobal(library_t* lib, const char* name, uintptr_t *offs, uint32_t
     }
     return 0;
 }
-int EmuLib_GetLocal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int *weak, int version, const char* vername, int local)
+int EmuLib_GetLocal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t asked_size, int *weak, int version, const char* vername, int local)
 {
     uintptr_t start, end;
     const char* defver = GetDefaultVersion(my_context->globaldefver, name);
     if(!defver) defver = GetDefaultVersion(my_context->weakdefver, name);
-    if(GetSymbolStartEnd(GetLocalSymbols(lib->e.elf), name, &start, &end, version, vername, local, defver))
+    if(GetSizedSymbolStartEnd(GetLocalSymbols(lib->e.elf), name, &start, &end, asked_size, version, vername, local, defver))
     {
         *offs = start;
         *sz = end-start;
@@ -195,7 +197,7 @@ int EmuLib_GetLocal(library_t* lib, const char* name, uintptr_t *offs, uint32_t
     return 0;
 }
 
-int WrappedLib_GetLocal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int* weak, int version, const char* vername, int local)
+int WrappedLib_GetLocal(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, size_t asked_size, int* weak, int version, const char* vername, int local)
 {
     return 0;
 }
@@ -451,7 +453,7 @@ int FinalizeLibrary(library_t* lib, lib_t* local_maplib, int bindnow, x86emu_t*
                 printf_log(LOG_INFO, "TRACE on %s only (%p-%p)\n", trace_func, (void*)trace_start, (void*)trace_end);
                 box_free(trace_func);
                 trace_func = NULL;
-            } else if(GetLibLocalSymbolStartEnd(lib, trace_func, &trace_start, &trace_end, &weak, -1, NULL, 0)) {
+            } else if(GetLibLocalSymbolStartEnd(lib, trace_func, &trace_start, &trace_end, 0, &weak, -1, NULL, 0)) {
                 SetTraceEmu(trace_start, trace_end);
                 printf_log(LOG_INFO, "TRACE on %s only (%p-%p)\n", trace_func, (void*)trace_start, (void*)trace_end);
                 box_free(trace_func);
@@ -621,34 +623,24 @@ int IsSameLib(library_t* lib, const char* path)
     box_free(name);
     return ret;
 }
-int GetLibWeakSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, int* weak, int version, const char* vername, int local)
+int GetLibWeakSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int* weak, int version, const char* vername, int local)
 {
     if(!name[0] || !lib || !lib->active)
         return 0;
     khint_t k;
-    // check first if already in the map
-    k = kh_get(bridgemap, lib->wbridgemap, VersionnedName(name, version, vername));
-    if(k!=kh_end(lib->wbridgemap)) {
-        *start = kh_value(lib->wbridgemap, k).start;
-        *end = kh_value(lib->wbridgemap, k).end;
-        *weak = 1;
-        return 1;
-    }
-    if(local) {
-        k = kh_get(bridgemap, lib->lbridgemap, VersionnedName(name, version, vername));
-        if(k!=kh_end(lib->lbridgemap)) {
-            *start = kh_value(lib->lbridgemap, k).start;
-            *end = kh_value(lib->lbridgemap, k).end;
-            *weak = 0;
+    // get a new symbol
+    if(lib->getweak(lib, name, start, end, size, weak, version, vername, local)) {
+        *end += *start;     // lib->get(...) gives size, not end
+        kh_bridgemap_t *map = local?lib->lbridgemap:((*weak)?lib->wbridgemap:lib->gbridgemap);
+        // check first if already in the map
+        k = kh_get(bridgemap, map, VersionnedName(name, version, vername));
+        if(k!=kh_end(map)) {
+            *start = kh_value(map, k).start;
+            *end = kh_value(map, k).end;
             return 1;
         }
-    }
-    // get a new symbol
-    if(lib->getweak(lib, name, start, end, weak, version, vername, local)) {
-        *end += *start;     // lib->get(...) gives size, not end
         char* symbol = box_strdup(VersionnedName(name, version, vername));
         int ret;
-        kh_bridgemap_t *map = local?lib->lbridgemap:((*weak)?lib->wbridgemap:lib->gbridgemap);
         k = kh_put(bridgemap, map, symbol, &ret);
         kh_value(map, k).name = symbol;
         kh_value(map, k).start = *start;
@@ -658,13 +650,13 @@ int GetLibWeakSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start,
     // nope
     return 0;
 }
-int GetLibGlobalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, int *weak, int version, const char* vername, int local)
+int GetLibGlobalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int *weak, int version, const char* vername, int local)
 {
     if(!name[0] || !lib || !lib->active)
         return 0;
     khint_t k;
     // get a new symbol
-    if(lib->getglobal(lib, name, start, end, weak, version, vername, local)) {
+    if(lib->getglobal(lib, name, start, end, size, weak, version, vername, local)) {
         *end += *start;     // lib->get(...) gives size, not end
         kh_bridgemap_t *map = local?lib->lbridgemap:((*weak)?lib->wbridgemap:lib->gbridgemap);
         // check if already in the map
@@ -685,21 +677,21 @@ int GetLibGlobalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* star
     // nope
     return 0;
 }
-int GetLibLocalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, int* weak, int version, const char* vername, int local)
+int GetLibLocalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int* weak, int version, const char* vername, int local)
 {
     if(!name[0] || !lib || !lib->active)
         return 0;
     khint_t k;
-    // check first if already in the map
-    k = kh_get(bridgemap, lib->lbridgemap, VersionnedName(name, version, vername));
-    if(k!=kh_end(lib->lbridgemap)) {
-        *start = kh_value(lib->lbridgemap, k).start;
-        *end = kh_value(lib->lbridgemap, k).end;
-        return 1;
-    }
     // get a new symbol
-    if(lib->getlocal(lib, name, start, weak, end, version, vername, local)) {
+    if(lib->getlocal(lib, name, start, weak, size, end, version, vername, local)) {
         *end += *start;     // lib->get(...) gives size, not end
+        // check first if already in the map
+        k = kh_get(bridgemap, lib->lbridgemap, VersionnedName(name, version, vername));
+        if(k!=kh_end(lib->lbridgemap)) {
+            *start = kh_value(lib->lbridgemap, k).start;
+            *end = kh_value(lib->lbridgemap, k).end;
+            return 1;
+        }
         char* symbol = box_strdup(VersionnedName(name, version, vername));
         int ret;
         k = kh_put(bridgemap, lib->lbridgemap, symbol, &ret);

src/librarian/symbols.c

@@ -58,89 +58,89 @@ static int SameVersion(versymbol_t* s, int ver, const char* vername)
     
 }
 
-static versymbol_t* FindVersionLocal(versymbols_t* s)
+static versymbol_t* FindVersionLocal(versymbols_t* s, size_t size)
 {
     if(!s || !s->sz)
         return NULL;
     for (int i=0; i<s->sz; ++i)
-        if(s->syms[i].version==0)
+        if(s->syms[i].version==0 && (!size || (size==s->syms[i].sym.sz)))
             return &s->syms[i];
     return NULL;
 }
-static versymbol_t* FindNoVersion(versymbols_t* s)
+static versymbol_t* FindNoVersion(versymbols_t* s, size_t size)
 {
     if(!s || !s->sz)
         return NULL;
     for (int i=0; i<s->sz; ++i)
-        if(s->syms[i].version==-1)
+        if(s->syms[i].version==-1 && (!size || (size==s->syms[i].sym.sz)))
             return &s->syms[i];
     return NULL;
 }
-static versymbol_t* FindVersionGlobal(versymbols_t* s)
+static versymbol_t* FindVersionGlobal(versymbols_t* s, size_t size)
 {
     if(!s || !s->sz)
         return NULL;
     for (int i=0; i<s->sz; ++i)
-        if(s->syms[i].version==1)
+        if(s->syms[i].version==1 && (!size || (size==s->syms[i].sym.sz)))
             return &s->syms[i];
     return NULL;
 }
-static versymbol_t* FindVersion(versymbols_t* s, const char* vername)
+static versymbol_t* FindVersion(versymbols_t* s, size_t size, const char* vername)
 {
     if(!s || !s->sz)
         return NULL;
     for (int i=0; i<s->sz; ++i)
-        if(s->syms[i].vername && !strcmp(s->syms[i].vername, vername))
+        if(s->syms[i].vername && !strcmp(s->syms[i].vername, vername) && (!size || (size==s->syms[i].sym.sz)))
             return &s->syms[i];
     return NULL;
 }
-static versymbol_t* FindFirstVersion(versymbols_t* s)
+static versymbol_t* FindFirstVersion(versymbols_t* s, size_t size)
 {
     if(!s || !s->sz)
         return NULL;
     for (int i=0; i<s->sz; ++i)
-        if(s->syms[i].version>1)
+        if(s->syms[i].version>1 && (!size || (size==s->syms[i].sym.sz)))
             return &s->syms[i];
     return NULL;
 }
 
 // Match version (so ver=0:0, ver=1:-1/1/X, ver=-1:any, ver=X:1/"name")
-static versymbol_t* MatchVersion(versymbols_t* s, int ver, const char* vername, int local, const char* defver)
+static versymbol_t* MatchVersion(versymbols_t* s, int ver, const char* vername, size_t size, int local, const char* defver)
 {
     if(!s || !s->sz)
         return NULL;
     versymbol_t* ret = NULL;
     if(ver==0) {
-        if(local) ret = FindVersionLocal(s);
-        if(!ret) ret = FindNoVersion(s);
-        if(!ret) ret = FindVersionGlobal(s);
-        if(!ret && defver) ret = FindVersion(s, defver);
+        if(local) ret = FindVersionLocal(s, size);
+        if(!ret) ret = FindNoVersion(s, size);
+        if(!ret) ret = FindVersionGlobal(s, size);
+        if(!ret && defver) ret = FindVersion(s, size, defver);
         return ret;
     }
     if(ver==-1) {
-        if(local) ret = FindVersionLocal(s);
-        if(!ret) ret = FindNoVersion(s);
-        if(!ret) ret = FindVersionGlobal(s);
-        if(!ret && defver) ret = FindVersion(s, defver);
+        if(local) ret = FindVersionLocal(s, size);
+        if(!ret) ret = FindNoVersion(s, size);
+        if(!ret) ret = FindVersionGlobal(s, size);
+        if(!ret && defver) ret = FindVersion(s, size, defver);
         //if(!ret) ret = FindFirstVersion(s);
         return ret;
     }
     if(ver==-2) {
-        if(local) ret = FindVersionLocal(s);
-        if(!ret) ret = FindVersionGlobal(s);
+        if(local) ret = FindVersionLocal(s, size);
+        if(!ret) ret = FindVersionGlobal(s, size);
         return ret;
     }
     if(ver==1) {
-        if(local) ret = FindVersionLocal(s);
-        if(!ret) ret = FindVersionGlobal(s);
-        if(!ret) ret = FindNoVersion(s);
-        if(!ret && defver) ret = FindVersion(s, defver);
+        if(local) ret = FindVersionLocal(s, size);
+        if(!ret) ret = FindVersionGlobal(s, size);
+        if(!ret) ret = FindNoVersion(s, size);
+        if(!ret && defver) ret = FindVersion(s, size, defver);
         //if(!ret) ret = FindFirstVersion(s);
         return ret;
     }
-    ret = FindVersion(s, vername);
-    if(local && !ret) ret = FindVersionLocal(s);
-    if(!ret && defver && vername && !strcmp(defver, vername)) ret = FindVersionGlobal(s);
+    ret = FindVersion(s, size, vername);
+    if(local && !ret) ret = FindVersionLocal(s, size);
+    if(!ret && defver && vername && !strcmp(defver, vername)) ret = FindVersionGlobal(s, size);
     //if(!ret) return FindVersionGlobal(s);
     return ret;
 }
@@ -178,7 +178,7 @@ uintptr_t FindSymbol(kh_mapsymbols_t *mapsymbols, const char* name, int ver, con
     if(k==kh_end(mapsymbols))
         return 0;
     versymbols_t * v = &kh_val(mapsymbols, k);
-    versymbol_t * s = MatchVersion(v, ver, vername, local, defver);
+    versymbol_t * s = MatchVersion(v, ver, vername, 0, local, defver);
     if(s)
         return s->sym.offs;
     return 0;
@@ -215,7 +215,24 @@ int GetSymbolStartEnd(kh_mapsymbols_t* mapsymbols, const char* name, uintptr_t*
     if(k==kh_end(mapsymbols))
         return 0;
     versymbols_t * v = &kh_val(mapsymbols, k);
-    versymbol_t* s = MatchVersion(v, ver, vername, local, defver);
+    versymbol_t* s = MatchVersion(v, ver, vername, 0, local, defver);
+    if(s) {
+        *start = s->sym.offs;
+        *end = *start + s->sym.sz;
+        return 1;
+    }
+    return 0;
+}
+
+int GetSizedSymbolStartEnd(kh_mapsymbols_t* mapsymbols, const char* name, uintptr_t* start, uintptr_t* end, size_t size, int ver, const char* vername, int local, const char* defver)
+{
+    if(!mapsymbols)
+        return 0;
+    khint_t k = kh_get(mapsymbols, mapsymbols, name);
+    if(k==kh_end(mapsymbols))
+        return 0;
+    versymbols_t * v = &kh_val(mapsymbols, k);
+    versymbol_t* s = MatchVersion(v, ver, vername, size, local, defver);
     if(s) {
         *start = s->sym.offs;
         *end = *start + s->sym.sz;

src/library_list.h

@@ -112,7 +112,9 @@ GO("libpangoft2-1.0.so", pangoft2)
 GO("libpangoft2-1.0.so.0", pangoft2)
 GO("libpangocairo-1.0.so.0", pangocairo)
 GO("libcairo.so.2", cairo)
+GO("libcairo.so", cairo)
 GO("libpango-1.0.so.0", pango)
+GO("libpango-1.0.so", pango)
 GO("libnm.so.0", libnm)
 GO("libnm-glib.so.4", libnm)
 GO("libnm-util.so.2", libnm)

src/libtools/signals.c

@@ -744,22 +744,12 @@ void my_box86signalhandler(int32_t sig, siginfo_t* info, void * ucntx)
     dynablock_t* db = NULL;
     int db_searched = 0;
     if ((sig==SIGSEGV) && (addr) && (info->si_code == SEGV_ACCERR) && (prot&PROT_CUSTOM)) {
+        // access error, unprotect the block (and mark them dirty)
+        unprotectDB((uintptr_t)addr, 1, 1);    // unprotect 1 byte... But then, the whole page will be unprotected
         // check if SMC inside block
         db = FindDynablockFromNativeAddress(pc);
         db_searched = 1;
-        static uintptr_t repeated_page = 0;
-        dynarec_log(LOG_DEBUG, "SIGSEGV with Access error on %p for %p , db=%p(%p), prot=0x%x (old page=%p)\n", pc, addr, db, db?((void*)db->x86_addr):NULL, prot, (void*)repeated_page);
-        static int repeated_count = 0;
-        if(repeated_page == ((uintptr_t)addr&~0xfff)) {
-            ++repeated_count;   // Access eoor multiple time on same page, disable dynarec on this page a few time...
-            dynarec_log(LOG_DEBUG, "Detecting a Hotpage at %p (%d)\n", (void*)repeated_page, repeated_count);
-            AddHotPage(repeated_page);
-        } else {
-            repeated_page = (uintptr_t)addr&~0xfff;
-            repeated_count = 0;
-        }
-        // access error, unprotect the block (and mark them dirty)
-        unprotectDB((uintptr_t)addr, 1, 1);    // unprotect 1 byte... But then, the whole page will be unprotected
+        dynarec_log(LOG_INFO/*LOG_DEBUG*/, "SIGSEGV with Access error on %p for %p , db=%p(%p)\n", pc, addr, db, db?((void*)db->x86_addr):NULL);
         if(db && ((addr>=db->x86_addr && addr<(db->x86_addr+db->x86_size)) || db->need_test)) {
             // dynablock got auto-dirty! need to get out of it!!!
             emu_jmpbuf_t* ejb = GetJmpBuf();
@@ -897,13 +887,7 @@ exit(-1);
             }
         }
         if(cycle_log) {
-            int j = (my_context->current_line+1)&(CYCLE_LOG-1);
-            for (int i=0; i<CYCLE_LOG; ++i) {
-                int k = (i+j)&(CYCLE_LOG-1);
-                if(my_context->log_call[k][0]) {
-                    printf_log(log_minimum, "%s => return %s\n", my_context->log_call[k], my_context->log_ret[k]);
-                }
-            }
+            print_cycle_log(log_minimum);
         }
 #ifdef DYNAREC
         uint32_t hash = 0;

src/libtools/threads.c

@@ -322,7 +322,8 @@ EXPORT int my_pthread_create(x86emu_t *emu, void* t, void* attr, void* start_rou
 	#ifdef DYNAREC
 	if(box86_dynarec) {
 		// pre-creation of the JIT code for the entry point of the thread
-		DBGetBlock(emu, (uintptr_t)start_routine, 1);
+		dynablock_t *current = NULL;
+		DBGetBlock(emu, (uintptr_t)start_routine, 1, &current);
 	}
 	#endif
 	// create thread
@@ -345,7 +346,8 @@ void* my_prepare_thread(x86emu_t *emu, void* f, void* arg, int ssize, void** pet
 	#ifdef DYNAREC
 	if(box86_dynarec) {
 		// pre-creation of the JIT code for the entry point of the thread
-		DBGetBlock(emu, (uintptr_t)f, 1);
+		dynablock_t *current = NULL;
+		DBGetBlock(emu, (uintptr_t)f, 1, &current);
 	}
 	#endif
 	*pet =  et;

src/libtools/vkalign.c

@@ -254,25 +254,26 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
-    VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000,
+    VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000,
     VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001,
-    VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002,
-    VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003,
-    VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004,
+    VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002,
+    VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003,
+    VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004,
     VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005,
     VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,
     VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,
     VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008,
     VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009,
     VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010,
-    VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011,
-    VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012,
-    VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013,
+    VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012,
+    VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014,
     VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,
-    VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR = 1000023016,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002,
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
@@ -289,27 +290,26 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038005,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038006,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000038006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT = 1000038010,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT = 1000038010,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT = 1000039005,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT = 1000039006,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT = 1000039007,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT = 1000039008,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000039006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT = 1000039008,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040001,
-    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040002,
-    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040003,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_EXT = 1000040003,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040004,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040005,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040006,
@@ -474,7 +474,7 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187001,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187002,
-    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187003,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_EXT = 1000187003,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187004,
     VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187005,
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000,
@@ -575,12 +575,16 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
     VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002,
     VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
     VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
     VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000,
@@ -610,6 +614,8 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001,
     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001,
@@ -622,15 +628,17 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = 1000342000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000,
+    VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001,
+    VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000,
     VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000,
-    VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000,
     VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001,
     VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000,
+    VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000,
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000,
@@ -671,12 +679,23 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000,
+    VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000,
+    VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001,
+    VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002,
+    VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003,
+    VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006,
+    VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007,
+    VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000,
     VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,
@@ -686,6 +705,8 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002,
@@ -694,10 +715,24 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001,
     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002,
     VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005,
+    VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000,
     VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000,
     VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000,
+    VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -860,6 +895,9 @@ typedef enum VkStructureType {
     VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,
     VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
     VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT,
+    VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT,
     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3,
     VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,
@@ -894,7 +932,6 @@ typedef struct my_vkhead_s {
     case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:              \
     case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:               \
     case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:               \
-    case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:               \
     case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:            \
     case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:      \
     case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:     \
@@ -998,6 +1035,13 @@ typedef struct my_vkhead_s {
     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:     \
     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:   \
     case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: \
+    case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:                \
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:         \
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:         \
+    case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:         \
+    case VK_STRUCTURE_TYPE_BUFFER_COPY_2:                               \
+    case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV:                \
+    case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:           \
 
 #define CH(C, B, A) \
     case C:         \
@@ -1011,7 +1055,7 @@ typedef struct my_vkhead_s {
     CH(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,"uPiiiiuuUiuuuu", A)                  \
     CH(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, "uPiUupuuu", A)                   \
     CH(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, "uPiuppppppppppUUuUi", A)   \
-    CH(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, "uPiUiiiiiiiuuuu", A)              \
+    CH(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, "uPiUiiSiiiiSiuuuu", A)            \
     CH(VK_STRUCTURE_TYPE_SUBMIT_INFO, "uPuppupup", A)           \
     CH(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, "uPUuuuippp", A) \
     CH(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, "uPUuuUuuu", A)   \
@@ -1019,7 +1063,7 @@ typedef struct my_vkhead_s {
     CH(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, "uP"     \
     "uuuuiYB"                                                   \
     "SuuuuuuuuuuuUUuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuffuuuffuLUUUiuiuffuuuuiiiiuiiiiiuifuuuuffffffiiUUU"\
-    "Siiiii",A)                                                 \
+    "iiiii",A)                                                 \
     CH(VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, "uPipu", A)                   \
     CH(VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, "uPipu", A)                  \
     CH(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, "uPUUUUu", A)                 \
@@ -1052,6 +1096,20 @@ typedef struct my_vkhead_s {
     CH(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, "uPBBBuiuiiiiuuiuU", A)         \
     CH(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, "uPiYYSuiiiiiiiiiiiiiiiiiuiiiiiiiuuuuuuuuuuuuuuuuuiiiiUu", A)\
     CH(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, "uPuuuuuuuuuuiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiUiUiU", A)\
+    CH(VK_STRUCTURE_TYPE_RENDERING_INFO, "uPiiiuuuuuPPP", A)                        \
+    CH(VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, "uPP", A)               \
+    CH(VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, "uPPi", A)               \
+    CH(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, "uPiiiuuuuuiiiiupi", A)                 \
+    CH(VK_STRUCTURE_TYPE_DEPENDENCY_INFO, "uPiuQuQuQ", A)                           \
+    CH(VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, "uPUUUU", A)                             \
+    CH(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, "uPUUUUuuUUU", A)                 \
+    CH(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, "uPUUUUiiuuUSiuuuu", A)            \
+    CH(VK_STRUCTURE_TYPE_SUBMIT_INFO_2, "upiuQuQuQ", A)                             \
+    CH(VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, "uPUUUu", A)                        \
+    CH(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, "uPUuuSiuuuiiiuuu", A)                \
+    CH(VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, "uPpu", A)                     \
+    CH(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, "uPUiiUiiiffff", A)             \
+    CH(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV, "uPi", A)         \
 
 
 //--------------------------------------------------------------
@@ -1183,8 +1241,10 @@ static my_vkhead_t* alignFromx86(my_vkhead_t* src, uint32_t cnt);
 
 void* vkalignStruct(void* src, const char* desc, int cnt)
 {
+    if(!src)
+        return src;
     int sz = vkalignSize(desc);
-    int count=(cnt)?cnt:1;
+    int count=cnt;
     void* dst = (void*)box_malloc(sz*count+sizeof(void*)*count);
     int c = 0;
     int a = 0;
@@ -1268,6 +1328,7 @@ static my_vkhead_t* alignFromx86(my_vkhead_t* src, uint32_t cnt)
 {
     if(!src)
         return src;
+    //printf_log(LOG_INFO, "alignFromx86(%p:%d, %d)\n", src, src->sType, cnt);
     my_vkhead_t *dst = src;
     const char* s;
     switch(src->sType) {
@@ -1275,7 +1336,7 @@ static my_vkhead_t* alignFromx86(my_vkhead_t* src, uint32_t cnt)
             // no need to align, but follow next...
             dst->pNext = alignFromx86(src->pNext, 1);
             break;
-        CHANGE(dst=vkalignStruct(src, s, 1)) // will follow next
+        CHANGE(dst=vkalignStruct(src, s, cnt)) // will follow next
         default:
             // unknow
             printf_log(LOG_INFO, "BOX86: Warning, unknown Vulkan structure type %d\n", src->sType);
@@ -1298,6 +1359,8 @@ void* VulkanFromx86(void* src)
 static void* unalignTox86(my_vkhead_t* src, int cnt);
 void* vkunalignStruct(void* src, const char* desc, int cnt)
 {
+    if(!src)
+        return src;
     int c = 0;
     int a = 1;
     int sz = vkalignSize(desc);
@@ -1564,6 +1627,7 @@ static void* unalignTox86(my_vkhead_t* src, int cnt)
 {
     if(!cnt || !src)
         return src;
+    //printf_log(LOG_INFO, "unalignTox86(%p:%d, %d)\n", src, src->sType, cnt);
     void* ret = NULL;
     const char* s;
     switch(src->sType) {

src/main.c

@@ -271,17 +271,20 @@ void LoadLogEnv()
     }
     p = getenv("BOX86_ROLLING_LOG");
     if(p) {
-        if(strlen(p)==1) {
-            if(p[0]>='0' && p[0]<='1')
-                cycle_log = p[0]-'0';
-        }
+        int cycle = 0;
+        if(sscanf(p, "%d", &cycle)==1)
+                cycle_log = cycle;
+        if(cycle_log==1)
+            cycle_log = 16;
+        if(cycle_log<0)
+            cycle_log = 0;
         if(cycle_log && box86_log>LOG_INFO) {
             cycle_log = 0;
             printf_log(LOG_NONE, "Incompatible Rolling log and Debug Log, disabling Rolling log\n");
         }
     }
     if(!box86_nobanner && cycle_log)
-        printf_log(LOG_INFO, "Rolling log, showing last %d function call on signals\n", CYCLE_LOG);
+        printf_log(LOG_INFO, "Rolling log, showing last %d function call on signals\n", cycle_log);
     p = getenv("BOX86_DUMP");
     if(p) {
         if(strlen(p)==1) {
@@ -1247,6 +1250,9 @@ int main(int argc, const char **argv, char **env)
         box86_nogtk = 1;
         AddPath("libSDL2-2.0.so.0", &my_context->box86_emulated_libs, 0);
         unsetenv("BOX86_NOGTK");
+        #ifdef DYNAREC
+        box86_dynarec_strongmem = 2;
+        #endif
         #ifdef PANDORA
         x11color16 = 1;
         #endif

src/wrapped/generated/functions_list.txt

@@ -68,6 +68,7 @@
 #() dFG
 #() lFv
 #() lFi
+#() lFu
 #() lFl
 #() lFp
 #() lFG
@@ -278,6 +279,7 @@
 #() vFEpV
 #() vFiii
 #() vFiiu
+#() vFiif
 #() vFiip
 #() vFiII
 #() vFiui
@@ -286,6 +288,7 @@
 #() vFiUU
 #() vFiff
 #() vFidd
+#() vFill
 #() vFilp
 #() vFipi
 #() vFipu
@@ -314,6 +317,9 @@
 #() vFfpp
 #() vFddd
 #() vFdpp
+#() vFlip
+#() vFllp
+#() vFlpp
 #() vFLpL
 #() vFpii
 #() vFpiI
@@ -325,14 +331,17 @@
 #() vFpui
 #() vFpuI
 #() vFpuu
+#() vFpuU
 #() vFpup
 #() vFpUi
 #() vFpUu
 #() vFpUU
 #() vFpUp
+#() vFpUP
 #() vFpff
 #() vFpdd
 #() vFpll
+#() vFplp
 #() vFpLi
 #() vFpLL
 #() vFpLp
@@ -587,21 +596,27 @@
 #() vFEpPp
 #() vFiiii
 #() vFiiip
+#() vFiill
 #() vFiipp
 #() vFiipV
 #() vFiIII
 #() vFiuiu
 #() vFiuip
 #() vFiuuu
+#() vFiuup
 #() vFiulp
 #() vFiupu
 #() vFiupV
 #() vFiUUU
 #() vFifff
 #() vFiddd
+#() vFilil
+#() vFilip
+#() vFilpu
 #() vFilpp
 #() vFipii
 #() vFipup
+#() vFipll
 #() vFippi
 #() vFippu
 #() vFippp
@@ -668,16 +683,19 @@
 #() vFpuuV
 #() vFpudd
 #() vFpupp
+#() vFpupP
 #() vFpUui
 #() vFpUuu
 #() vFpUup
 #() vFpUUi
+#() vFpUUu
 #() vFpUUp
 #() vFpUpp
 #() vFpfff
 #() vFpdii
 #() vFpddi
 #() vFpddd
+#() vFplpp
 #() vFpLLL
 #() vFppii
 #() vFppiu
@@ -903,6 +921,7 @@
 #() pFiipi
 #() pFiipp
 #() pFiIIi
+#() pFillu
 #() pFipii
 #() pFipip
 #() pFipup
@@ -962,10 +981,15 @@
 #() vFEppiV
 #() vFEppup
 #() vFEpppp
+#() vFEpPpp
 #() vFiiiii
 #() vFiiiiu
+#() vFiiuii
 #() vFiiuup
+#() vFiillu
+#() vFiilll
 #() vFiipii
+#() vFiipll
 #() vFiIIII
 #() vFiuiip
 #() vFiuipi
@@ -976,6 +1000,8 @@
 #() vFiffff
 #() vFidddd
 #() vFilill
+#() vFilipi
+#() vFilipl
 #() vFipipu
 #() vFipipp
 #() vFipupi
@@ -985,6 +1011,7 @@
 #() vFuiiiu
 #() vFuiiip
 #() vFuiifi
+#() vFuiill
 #() vFuiIII
 #() vFuiuii
 #() vFuiuiu
@@ -1037,6 +1064,8 @@
 #() vFpiipp
 #() vFpiIiI
 #() vFpiIII
+#() vFpiUUp
+#() vFpilpp
 #() vFpipii
 #() vFpipiu
 #() vFpuiip
@@ -1097,6 +1126,7 @@
 #() iFEpipi
 #() iFEpipp
 #() iFEpipV
+#() iFEpupU
 #() iFEpupp
 #() iFEpupV
 #() iFEpUup
@@ -1139,6 +1169,7 @@
 #() iFpiIip
 #() iFpiuwp
 #() iFpiupu
+#() iFpiUUU
 #() iFpipii
 #() iFpipiL
 #() iFpipip
@@ -1162,6 +1193,7 @@
 #() iFpupup
 #() iFpuppu
 #() iFpuppp
+#() iFpUiUi
 #() iFplluu
 #() iFpLlpp
 #() iFpLLpp
@@ -1299,13 +1331,20 @@
 #() vFEppppp
 #() vFiiiiii
 #() vFiiiuil
+#() vFiiilpi
 #() vFiiuiil
+#() vFiiuilp
+#() vFiiuulp
 #() vFiililp
 #() vFiiplli
 #() vFiiplll
 #() vFiuippp
 #() vFiffiff
 #() vFiddidd
+#() vFililll
+#() vFilipli
+#() vFiliplu
+#() vFipiplp
 #() vFipllli
 #() vFuiiiii
 #() vFuiiiil
@@ -1319,6 +1358,7 @@
 #() vFuiuiuu
 #() vFuiuuip
 #() vFuiuuuu
+#() vFuiuulp
 #() vFuiupii
 #() vFuiupiu
 #() vFuiUUUU
@@ -1564,8 +1604,12 @@
 #() vFEpppppp
 #() vFiiiiiip
 #() vFiiiiuup
+#() vFiiuilil
 #() vFiiffffp
 #() vFiipllli
+#() vFiuulipi
+#() vFilipliu
+#() vFilulipi
 #() vFuiiiiii
 #() vFuiiiuip
 #() vFuiiiuup
@@ -1605,6 +1649,7 @@
 #() vFulipulp
 #() vFulpiill
 #() vFlipuiip
+#() vFlliiiip
 #() vFpiiiipp
 #() vFpiiliip
 #() vFpiipCpp
@@ -1778,6 +1823,7 @@
 #() vFuiiiiuup
 #() vFuiuiiiii
 #() vFuiuiiiip
+#() vFuiuiuuuu
 #() vFuiulplpp
 #() vFuipuliuf
 #() vFuuiiiiii
@@ -1791,6 +1837,7 @@
 #() vFuuuipipp
 #() vFuuuuuuuu
 #() vFuuuuufff
+#() vFuuufffff
 #() vFulllplip
 #() vFffffffff
 #() vFlipuiuip
@@ -1850,6 +1897,7 @@
 #() uFEpppuppp
 #() uFEppppppp
 #() uFuipppppp
+#() uFulpppppp
 #() uFpupuuuCp
 #() uFppuuuupp
 #() uFppuuuppi
@@ -1888,7 +1936,9 @@
 #() vFEppiipppp
 #() vFEpppiippp
 #() vFiiiiiiiii
+#() vFiiiiiiill
 #() vFiiiiillli
+#() vFiiilllilp
 #() vFuiiiiiiii
 #() vFuiiiiiuip
 #() vFuiiiiiuup
@@ -1974,7 +2024,10 @@
 #() vFEiippppppp
 #() vFEpippppppp
 #() vFEpppiipppp
+#() vFiiiiiiiiii
 #() vFiiiiiiiiiu
+#() vFiiiiiiiiui
+#() vFiiillliiip
 #() vFippppppppp
 #() vFuiiiiiiiii
 #() vFuiiiiiiill
@@ -2030,6 +2083,8 @@
 #() pFppuiipuuii
 #() pFpppppppppp
 #() vFEpiiiupupup
+#() vFiiiiillliip
+#() vFiiiiilllilp
 #() vFiippppppppp
 #() vFuiiiiiiiiip
 #() vFuiiiiiiiuip
@@ -2134,6 +2189,7 @@
 #() pFEppCuuWWwwCCup
 #() pFEppuuuWWWWWWWW
 #() pFpuupuupwwwwWWC
+#() vFuiiiiiuiiiiilll
 #() vFuuiiiiuuiiiiiii
 #() vFfffffffffffffff
 #() vFppipppppppppppp
@@ -2146,6 +2202,7 @@
 #() vFpppppppppppppppp
 #() iFpppppppppppppppp
 #() pFppipipipipipipip
+#() vFuuuiiiiiuiiiiilll
 #() vFppiiiiddddiiiiiuu
 #() iFppipipppppppppppp
 #() iFpppippppppppppppp
@@ -3069,6 +3126,7 @@ wrappedlibgl:
   - glDebugMessageCallback
   - glDebugMessageCallbackAMD
   - glDebugMessageCallbackARB
+  - glDebugMessageCallbackKHR
 - vFipp:
   - glProgramCallbackMESA
 wrappedlibglu:
@@ -4421,9 +4479,12 @@ wrappedvulkan:
   - vkDestroyFramebuffer
   - vkDestroyImage
   - vkDestroyImageView
+  - vkDestroyOpticalFlowSessionNV
   - vkDestroyPipeline
   - vkDestroyPipelineCache
   - vkDestroyPipelineLayout
+  - vkDestroyPrivateDataSlot
+  - vkDestroyPrivateDataSlotEXT
   - vkDestroyQueryPool
   - vkDestroyRenderPass
   - vkDestroySampler
@@ -4452,6 +4513,12 @@ wrappedvulkan:
   - vkGetPhysicalDeviceSurfaceCapabilities2KHR
 - iFPpp:
   - vkCreateInstance
+- vFpPpp:
+  - vkGetDeviceImageSparseMemoryRequirements
+  - vkGetDeviceImageSparseMemoryRequirementsKHR
+- iFpupU:
+  - vkQueueSubmit2
+  - vkQueueSubmit2KHR
 - iFpUup:
   - vkGetDisplayPlaneCapabilitiesKHR
 - iFpUpP:
@@ -4477,8 +4544,11 @@ wrappedvulkan:
   - vkCreateHeadlessSurfaceEXT
   - vkCreateImage
   - vkCreateImageView
+  - vkCreateOpticalFlowSessionNV
   - vkCreatePipelineCache
   - vkCreatePipelineLayout
+  - vkCreatePrivateDataSlot
+  - vkCreatePrivateDataSlotEXT
   - vkCreateQueryPool
   - vkCreateRenderPass
   - vkCreateRenderPass2
@@ -4492,6 +4562,7 @@ wrappedvulkan:
   - vkCreateValidationCacheEXT
   - vkCreateXcbSurfaceKHR
   - vkCreateXlibSurfaceKHR
+  - vkGetPhysicalDeviceOpticalFlowImageFormatsNV
   - vkRegisterDeviceEventEXT
 - vFpupup:
   - vkUpdateDescriptorSets

src/wrapped/generated/wrappedlibgltypes.h

@@ -23,6 +23,7 @@ typedef void (*vFipp_t)(int32_t, void*, void*);
 	GO(glDebugMessageCallback, vFpp_t) \
 	GO(glDebugMessageCallbackAMD, vFpp_t) \
 	GO(glDebugMessageCallbackARB, vFpp_t) \
+	GO(glDebugMessageCallbackKHR, vFpp_t) \
 	GO(glProgramCallbackMESA, vFipp_t)
 
 #endif // __wrappedlibglTYPES_H_

src/wrapped/generated/wrappedvulkantypes.h

@@ -20,6 +20,8 @@ typedef int32_t (*iFpUp_t)(void*, uint64_t, void*);
 typedef int32_t (*iFppp_t)(void*, void*, void*);
 typedef int32_t (*iFpPp_t)(void*, void*, void*);
 typedef int32_t (*iFPpp_t)(void*, void*, void*);
+typedef void (*vFpPpp_t)(void*, void*, void*, void*);
+typedef int32_t (*iFpupU_t)(void*, uint32_t, void*, uint64_t);
 typedef int32_t (*iFpUup_t)(void*, uint64_t, uint32_t, void*);
 typedef int32_t (*iFpUpP_t)(void*, uint64_t, void*, void*);
 typedef int32_t (*iFpppp_t)(void*, void*, void*, void*);
@@ -52,9 +54,12 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkDestroyFramebuffer, vFpUp_t) \
 	GO(vkDestroyImage, vFpUp_t) \
 	GO(vkDestroyImageView, vFpUp_t) \
+	GO(vkDestroyOpticalFlowSessionNV, vFpUp_t) \
 	GO(vkDestroyPipeline, vFpUp_t) \
 	GO(vkDestroyPipelineCache, vFpUp_t) \
 	GO(vkDestroyPipelineLayout, vFpUp_t) \
+	GO(vkDestroyPrivateDataSlot, vFpUp_t) \
+	GO(vkDestroyPrivateDataSlotEXT, vFpUp_t) \
 	GO(vkDestroyQueryPool, vFpUp_t) \
 	GO(vkDestroyRenderPass, vFpUp_t) \
 	GO(vkDestroySampler, vFpUp_t) \
@@ -77,6 +82,10 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkGetPhysicalDeviceImageFormatProperties2KHR, iFpPp_t) \
 	GO(vkGetPhysicalDeviceSurfaceCapabilities2KHR, iFpPp_t) \
 	GO(vkCreateInstance, iFPpp_t) \
+	GO(vkGetDeviceImageSparseMemoryRequirements, vFpPpp_t) \
+	GO(vkGetDeviceImageSparseMemoryRequirementsKHR, vFpPpp_t) \
+	GO(vkQueueSubmit2, iFpupU_t) \
+	GO(vkQueueSubmit2KHR, iFpupU_t) \
 	GO(vkGetDisplayPlaneCapabilitiesKHR, iFpUup_t) \
 	GO(vkGetPastPresentationTimingGOOGLE, iFpUpP_t) \
 	GO(vkCreateDebugReportCallbackEXT, iFpppp_t) \
@@ -98,8 +107,11 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkCreateHeadlessSurfaceEXT, iFpPpp_t) \
 	GO(vkCreateImage, iFpPpp_t) \
 	GO(vkCreateImageView, iFpPpp_t) \
+	GO(vkCreateOpticalFlowSessionNV, iFpPpp_t) \
 	GO(vkCreatePipelineCache, iFpPpp_t) \
 	GO(vkCreatePipelineLayout, iFpPpp_t) \
+	GO(vkCreatePrivateDataSlot, iFpPpp_t) \
+	GO(vkCreatePrivateDataSlotEXT, iFpPpp_t) \
 	GO(vkCreateQueryPool, iFpPpp_t) \
 	GO(vkCreateRenderPass, iFpPpp_t) \
 	GO(vkCreateRenderPass2, iFpPpp_t) \
@@ -113,6 +125,7 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkCreateValidationCacheEXT, iFpPpp_t) \
 	GO(vkCreateXcbSurfaceKHR, iFpPpp_t) \
 	GO(vkCreateXlibSurfaceKHR, iFpPpp_t) \
+	GO(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, iFpPpp_t) \
 	GO(vkRegisterDeviceEventEXT, iFpPpp_t) \
 	GO(vkUpdateDescriptorSets, vFpupup_t) \
 	GO(vkCreateSharedSwapchainsKHR, iFpuppp_t) \

src/wrapped/generated/wrapper.c

@@ -140,6 +140,7 @@ typedef double (*dFp_t)(void*);
 typedef double (*dFG_t)(void*);
 typedef intptr_t (*lFv_t)(void);
 typedef intptr_t (*lFi_t)(int32_t);
+typedef intptr_t (*lFu_t)(uint32_t);
 typedef intptr_t (*lFl_t)(intptr_t);
 typedef intptr_t (*lFp_t)(void*);
 typedef intptr_t (*lFG_t)(void*);
@@ -350,6 +351,7 @@ typedef void (*vFEpp_t)(x86emu_t*, void*, void*);
 typedef void (*vFEpV_t)(x86emu_t*, void*, void*);
 typedef void (*vFiii_t)(int32_t, int32_t, int32_t);
 typedef void (*vFiiu_t)(int32_t, int32_t, uint32_t);
+typedef void (*vFiif_t)(int32_t, int32_t, float);
 typedef void (*vFiip_t)(int32_t, int32_t, void*);
 typedef void (*vFiII_t)(int32_t, int64_t, int64_t);
 typedef void (*vFiui_t)(int32_t, uint32_t, int32_t);
@@ -358,6 +360,7 @@ typedef void (*vFiup_t)(int32_t, uint32_t, void*);
 typedef void (*vFiUU_t)(int32_t, uint64_t, uint64_t);
 typedef void (*vFiff_t)(int32_t, float, float);
 typedef void (*vFidd_t)(int32_t, double, double);
+typedef void (*vFill_t)(int32_t, intptr_t, intptr_t);
 typedef void (*vFilp_t)(int32_t, intptr_t, void*);
 typedef void (*vFipi_t)(int32_t, void*, int32_t);
 typedef void (*vFipu_t)(int32_t, void*, uint32_t);
@@ -386,6 +389,9 @@ typedef void (*vFfff_t)(float, float, float);
 typedef void (*vFfpp_t)(float, void*, void*);
 typedef void (*vFddd_t)(double, double, double);
 typedef void (*vFdpp_t)(double, void*, void*);
+typedef void (*vFlip_t)(intptr_t, int32_t, void*);
+typedef void (*vFllp_t)(intptr_t, intptr_t, void*);
+typedef void (*vFlpp_t)(intptr_t, void*, void*);
 typedef void (*vFLpL_t)(uintptr_t, void*, uintptr_t);
 typedef void (*vFpii_t)(void*, int32_t, int32_t);
 typedef void (*vFpiI_t)(void*, int32_t, int64_t);
@@ -397,14 +403,17 @@ typedef void (*vFpip_t)(void*, int32_t, void*);
 typedef void (*vFpui_t)(void*, uint32_t, int32_t);
 typedef void (*vFpuI_t)(void*, uint32_t, int64_t);
 typedef void (*vFpuu_t)(void*, uint32_t, uint32_t);
+typedef void (*vFpuU_t)(void*, uint32_t, uint64_t);
 typedef void (*vFpup_t)(void*, uint32_t, void*);
 typedef void (*vFpUi_t)(void*, uint64_t, int32_t);
 typedef void (*vFpUu_t)(void*, uint64_t, uint32_t);
 typedef void (*vFpUU_t)(void*, uint64_t, uint64_t);
 typedef void (*vFpUp_t)(void*, uint64_t, void*);
+typedef void (*vFpUP_t)(void*, uint64_t, void*);
 typedef void (*vFpff_t)(void*, float, float);
 typedef void (*vFpdd_t)(void*, double, double);
 typedef void (*vFpll_t)(void*, intptr_t, intptr_t);
+typedef void (*vFplp_t)(void*, intptr_t, void*);
 typedef void (*vFpLi_t)(void*, uintptr_t, int32_t);
 typedef void (*vFpLL_t)(void*, uintptr_t, uintptr_t);
 typedef void (*vFpLp_t)(void*, uintptr_t, void*);
@@ -659,21 +668,27 @@ typedef void (*vFEppV_t)(x86emu_t*, void*, void*, void*);
 typedef void (*vFEpPp_t)(x86emu_t*, void*, void*, void*);
 typedef void (*vFiiii_t)(int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFiiip_t)(int32_t, int32_t, int32_t, void*);
+typedef void (*vFiill_t)(int32_t, int32_t, intptr_t, intptr_t);
 typedef void (*vFiipp_t)(int32_t, int32_t, void*, void*);
 typedef void (*vFiipV_t)(int32_t, int32_t, void*, void*);
 typedef void (*vFiIII_t)(int32_t, int64_t, int64_t, int64_t);
 typedef void (*vFiuiu_t)(int32_t, uint32_t, int32_t, uint32_t);
 typedef void (*vFiuip_t)(int32_t, uint32_t, int32_t, void*);
 typedef void (*vFiuuu_t)(int32_t, uint32_t, uint32_t, uint32_t);
+typedef void (*vFiuup_t)(int32_t, uint32_t, uint32_t, void*);
 typedef void (*vFiulp_t)(int32_t, uint32_t, intptr_t, void*);
 typedef void (*vFiupu_t)(int32_t, uint32_t, void*, uint32_t);
 typedef void (*vFiupV_t)(int32_t, uint32_t, void*, void*);
 typedef void (*vFiUUU_t)(int32_t, uint64_t, uint64_t, uint64_t);
 typedef void (*vFifff_t)(int32_t, float, float, float);
 typedef void (*vFiddd_t)(int32_t, double, double, double);
+typedef void (*vFilil_t)(int32_t, intptr_t, int32_t, intptr_t);
+typedef void (*vFilip_t)(int32_t, intptr_t, int32_t, void*);
+typedef void (*vFilpu_t)(int32_t, intptr_t, void*, uint32_t);
 typedef void (*vFilpp_t)(int32_t, intptr_t, void*, void*);
 typedef void (*vFipii_t)(int32_t, void*, int32_t, int32_t);
 typedef void (*vFipup_t)(int32_t, void*, uint32_t, void*);
+typedef void (*vFipll_t)(int32_t, void*, intptr_t, intptr_t);
 typedef void (*vFippi_t)(int32_t, void*, void*, int32_t);
 typedef void (*vFippu_t)(int32_t, void*, void*, uint32_t);
 typedef void (*vFippp_t)(int32_t, void*, void*, void*);
@@ -740,16 +755,19 @@ typedef void (*vFpuup_t)(void*, uint32_t, uint32_t, void*);
 typedef void (*vFpuuV_t)(void*, uint32_t, uint32_t, void*);
 typedef void (*vFpudd_t)(void*, uint32_t, double, double);
 typedef void (*vFpupp_t)(void*, uint32_t, void*, void*);
+typedef void (*vFpupP_t)(void*, uint32_t, void*, void*);
 typedef void (*vFpUui_t)(void*, uint64_t, uint32_t, int32_t);
 typedef void (*vFpUuu_t)(void*, uint64_t, uint32_t, uint32_t);
 typedef void (*vFpUup_t)(void*, uint64_t, uint32_t, void*);
 typedef void (*vFpUUi_t)(void*, uint64_t, uint64_t, int32_t);
+typedef void (*vFpUUu_t)(void*, uint64_t, uint64_t, uint32_t);
 typedef void (*vFpUUp_t)(void*, uint64_t, uint64_t, void*);
 typedef void (*vFpUpp_t)(void*, uint64_t, void*, void*);
 typedef void (*vFpfff_t)(void*, float, float, float);
 typedef void (*vFpdii_t)(void*, double, int32_t, int32_t);
 typedef void (*vFpddi_t)(void*, double, double, int32_t);
 typedef void (*vFpddd_t)(void*, double, double, double);
+typedef void (*vFplpp_t)(void*, intptr_t, void*, void*);
 typedef void (*vFpLLL_t)(void*, uintptr_t, uintptr_t, uintptr_t);
 typedef void (*vFppii_t)(void*, void*, int32_t, int32_t);
 typedef void (*vFppiu_t)(void*, void*, int32_t, uint32_t);
@@ -975,6 +993,7 @@ typedef void* (*pFiiup_t)(int32_t, int32_t, uint32_t, void*);
 typedef void* (*pFiipi_t)(int32_t, int32_t, void*, int32_t);
 typedef void* (*pFiipp_t)(int32_t, int32_t, void*, void*);
 typedef void* (*pFiIIi_t)(int32_t, int64_t, int64_t, int32_t);
+typedef void* (*pFillu_t)(int32_t, intptr_t, intptr_t, uint32_t);
 typedef void* (*pFipii_t)(int32_t, void*, int32_t, int32_t);
 typedef void* (*pFipip_t)(int32_t, void*, int32_t, void*);
 typedef void* (*pFipup_t)(int32_t, void*, uint32_t, void*);
@@ -1034,10 +1053,15 @@ typedef void (*vFEppip_t)(x86emu_t*, void*, void*, int32_t, void*);
 typedef void (*vFEppiV_t)(x86emu_t*, void*, void*, int32_t, void*);
 typedef void (*vFEppup_t)(x86emu_t*, void*, void*, uint32_t, void*);
 typedef void (*vFEpppp_t)(x86emu_t*, void*, void*, void*, void*);
+typedef void (*vFEpPpp_t)(x86emu_t*, void*, void*, void*, void*);
 typedef void (*vFiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFiiiiu_t)(int32_t, int32_t, int32_t, int32_t, uint32_t);
+typedef void (*vFiiuii_t)(int32_t, int32_t, uint32_t, int32_t, int32_t);
 typedef void (*vFiiuup_t)(int32_t, int32_t, uint32_t, uint32_t, void*);
+typedef void (*vFiillu_t)(int32_t, int32_t, intptr_t, intptr_t, uint32_t);
+typedef void (*vFiilll_t)(int32_t, int32_t, intptr_t, intptr_t, intptr_t);
 typedef void (*vFiipii_t)(int32_t, int32_t, void*, int32_t, int32_t);
+typedef void (*vFiipll_t)(int32_t, int32_t, void*, intptr_t, intptr_t);
 typedef void (*vFiIIII_t)(int32_t, int64_t, int64_t, int64_t, int64_t);
 typedef void (*vFiuiip_t)(int32_t, uint32_t, int32_t, int32_t, void*);
 typedef void (*vFiuipi_t)(int32_t, uint32_t, int32_t, void*, int32_t);
@@ -1048,6 +1072,8 @@ typedef void (*vFiUUUU_t)(int32_t, uint64_t, uint64_t, uint64_t, uint64_t);
 typedef void (*vFiffff_t)(int32_t, float, float, float, float);
 typedef void (*vFidddd_t)(int32_t, double, double, double, double);
 typedef void (*vFilill_t)(int32_t, intptr_t, int32_t, intptr_t, intptr_t);
+typedef void (*vFilipi_t)(int32_t, intptr_t, int32_t, void*, int32_t);
+typedef void (*vFilipl_t)(int32_t, intptr_t, int32_t, void*, intptr_t);
 typedef void (*vFipipu_t)(int32_t, void*, int32_t, void*, uint32_t);
 typedef void (*vFipipp_t)(int32_t, void*, int32_t, void*, void*);
 typedef void (*vFipupi_t)(int32_t, void*, uint32_t, void*, int32_t);
@@ -1057,6 +1083,7 @@ typedef void (*vFuiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFuiiiu_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t);
 typedef void (*vFuiiip_t)(uint32_t, int32_t, int32_t, int32_t, void*);
 typedef void (*vFuiifi_t)(uint32_t, int32_t, int32_t, float, int32_t);
+typedef void (*vFuiill_t)(uint32_t, int32_t, int32_t, intptr_t, intptr_t);
 typedef void (*vFuiIII_t)(uint32_t, int32_t, int64_t, int64_t, int64_t);
 typedef void (*vFuiuii_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t);
 typedef void (*vFuiuiu_t)(uint32_t, int32_t, uint32_t, int32_t, uint32_t);
@@ -1109,6 +1136,8 @@ typedef void (*vFpiiff_t)(void*, int32_t, int32_t, float, float);
 typedef void (*vFpiipp_t)(void*, int32_t, int32_t, void*, void*);
 typedef void (*vFpiIiI_t)(void*, int32_t, int64_t, int32_t, int64_t);
 typedef void (*vFpiIII_t)(void*, int32_t, int64_t, int64_t, int64_t);
+typedef void (*vFpiUUp_t)(void*, int32_t, uint64_t, uint64_t, void*);
+typedef void (*vFpilpp_t)(void*, int32_t, intptr_t, void*, void*);
 typedef void (*vFpipii_t)(void*, int32_t, void*, int32_t, int32_t);
 typedef void (*vFpipiu_t)(void*, int32_t, void*, int32_t, uint32_t);
 typedef void (*vFpuiip_t)(void*, uint32_t, int32_t, int32_t, void*);
@@ -1169,6 +1198,7 @@ typedef int32_t (*iFEpiup_t)(x86emu_t*, void*, int32_t, uint32_t, void*);
 typedef int32_t (*iFEpipi_t)(x86emu_t*, void*, int32_t, void*, int32_t);
 typedef int32_t (*iFEpipp_t)(x86emu_t*, void*, int32_t, void*, void*);
 typedef int32_t (*iFEpipV_t)(x86emu_t*, void*, int32_t, void*, void*);
+typedef int32_t (*iFEpupU_t)(x86emu_t*, void*, uint32_t, void*, uint64_t);
 typedef int32_t (*iFEpupp_t)(x86emu_t*, void*, uint32_t, void*, void*);
 typedef int32_t (*iFEpupV_t)(x86emu_t*, void*, uint32_t, void*, void*);
 typedef int32_t (*iFEpUup_t)(x86emu_t*, void*, uint64_t, uint32_t, void*);
@@ -1211,6 +1241,7 @@ typedef int32_t (*iFpiipp_t)(void*, int32_t, int32_t, void*, void*);
 typedef int32_t (*iFpiIip_t)(void*, int32_t, int64_t, int32_t, void*);
 typedef int32_t (*iFpiuwp_t)(void*, int32_t, uint32_t, int16_t, void*);
 typedef int32_t (*iFpiupu_t)(void*, int32_t, uint32_t, void*, uint32_t);
+typedef int32_t (*iFpiUUU_t)(void*, int32_t, uint64_t, uint64_t, uint64_t);
 typedef int32_t (*iFpipii_t)(void*, int32_t, void*, int32_t, int32_t);
 typedef int32_t (*iFpipiL_t)(void*, int32_t, void*, int32_t, uintptr_t);
 typedef int32_t (*iFpipip_t)(void*, int32_t, void*, int32_t, void*);
@@ -1234,6 +1265,7 @@ typedef int32_t (*iFpupuu_t)(void*, uint32_t, void*, uint32_t, uint32_t);
 typedef int32_t (*iFpupup_t)(void*, uint32_t, void*, uint32_t, void*);
 typedef int32_t (*iFpuppu_t)(void*, uint32_t, void*, void*, uint32_t);
 typedef int32_t (*iFpuppp_t)(void*, uint32_t, void*, void*, void*);
+typedef int32_t (*iFpUiUi_t)(void*, uint64_t, int32_t, uint64_t, int32_t);
 typedef int32_t (*iFplluu_t)(void*, intptr_t, intptr_t, uint32_t, uint32_t);
 typedef int32_t (*iFpLlpp_t)(void*, uintptr_t, intptr_t, void*, void*);
 typedef int32_t (*iFpLLpp_t)(void*, uintptr_t, uintptr_t, void*, void*);
@@ -1371,13 +1403,20 @@ typedef void (*vFEpppiu_t)(x86emu_t*, void*, void*, void*, int32_t, uint32_t);
 typedef void (*vFEppppp_t)(x86emu_t*, void*, void*, void*, void*, void*);
 typedef void (*vFiiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFiiiuil_t)(int32_t, int32_t, int32_t, uint32_t, int32_t, intptr_t);
+typedef void (*vFiiilpi_t)(int32_t, int32_t, int32_t, intptr_t, void*, int32_t);
 typedef void (*vFiiuiil_t)(int32_t, int32_t, uint32_t, int32_t, int32_t, intptr_t);
+typedef void (*vFiiuilp_t)(int32_t, int32_t, uint32_t, int32_t, intptr_t, void*);
+typedef void (*vFiiuulp_t)(int32_t, int32_t, uint32_t, uint32_t, intptr_t, void*);
 typedef void (*vFiililp_t)(int32_t, int32_t, intptr_t, int32_t, intptr_t, void*);
 typedef void (*vFiiplli_t)(int32_t, int32_t, void*, intptr_t, intptr_t, int32_t);
 typedef void (*vFiiplll_t)(int32_t, int32_t, void*, intptr_t, intptr_t, intptr_t);
 typedef void (*vFiuippp_t)(int32_t, uint32_t, int32_t, void*, void*, void*);
 typedef void (*vFiffiff_t)(int32_t, float, float, int32_t, float, float);
 typedef void (*vFiddidd_t)(int32_t, double, double, int32_t, double, double);
+typedef void (*vFililll_t)(int32_t, intptr_t, int32_t, intptr_t, intptr_t, intptr_t);
+typedef void (*vFilipli_t)(int32_t, intptr_t, int32_t, void*, intptr_t, int32_t);
+typedef void (*vFiliplu_t)(int32_t, intptr_t, int32_t, void*, intptr_t, uint32_t);
+typedef void (*vFipiplp_t)(int32_t, void*, int32_t, void*, intptr_t, void*);
 typedef void (*vFipllli_t)(int32_t, void*, intptr_t, intptr_t, intptr_t, int32_t);
 typedef void (*vFuiiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFuiiiil_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, intptr_t);
@@ -1391,6 +1430,7 @@ typedef void (*vFuiuiip_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t, void*)
 typedef void (*vFuiuiuu_t)(uint32_t, int32_t, uint32_t, int32_t, uint32_t, uint32_t);
 typedef void (*vFuiuuip_t)(uint32_t, int32_t, uint32_t, uint32_t, int32_t, void*);
 typedef void (*vFuiuuuu_t)(uint32_t, int32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+typedef void (*vFuiuulp_t)(uint32_t, int32_t, uint32_t, uint32_t, intptr_t, void*);
 typedef void (*vFuiupii_t)(uint32_t, int32_t, uint32_t, void*, int32_t, int32_t);
 typedef void (*vFuiupiu_t)(uint32_t, int32_t, uint32_t, void*, int32_t, uint32_t);
 typedef void (*vFuiUUUU_t)(uint32_t, int32_t, uint64_t, uint64_t, uint64_t, uint64_t);
@@ -1636,8 +1676,12 @@ typedef void (*vFEppippp_t)(x86emu_t*, void*, void*, int32_t, void*, void*, void
 typedef void (*vFEpppppp_t)(x86emu_t*, void*, void*, void*, void*, void*, void*);
 typedef void (*vFiiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*);
 typedef void (*vFiiiiuup_t)(int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*);
+typedef void (*vFiiuilil_t)(int32_t, int32_t, uint32_t, int32_t, intptr_t, int32_t, intptr_t);
 typedef void (*vFiiffffp_t)(int32_t, int32_t, float, float, float, float, void*);
 typedef void (*vFiipllli_t)(int32_t, int32_t, void*, intptr_t, intptr_t, intptr_t, int32_t);
+typedef void (*vFiuulipi_t)(int32_t, uint32_t, uint32_t, intptr_t, int32_t, void*, int32_t);
+typedef void (*vFilipliu_t)(int32_t, intptr_t, int32_t, void*, intptr_t, int32_t, uint32_t);
+typedef void (*vFilulipi_t)(int32_t, intptr_t, uint32_t, intptr_t, int32_t, void*, int32_t);
 typedef void (*vFuiiiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFuiiiuip_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, void*);
 typedef void (*vFuiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*);
@@ -1677,6 +1721,7 @@ typedef void (*vFulillli_t)(uint32_t, intptr_t, int32_t, intptr_t, intptr_t, int
 typedef void (*vFulipulp_t)(uint32_t, intptr_t, int32_t, void*, uint32_t, intptr_t, void*);
 typedef void (*vFulpiill_t)(uint32_t, intptr_t, void*, int32_t, int32_t, intptr_t, intptr_t);
 typedef void (*vFlipuiip_t)(intptr_t, int32_t, void*, uint32_t, int32_t, int32_t, void*);
+typedef void (*vFlliiiip_t)(intptr_t, intptr_t, int32_t, int32_t, int32_t, int32_t, void*);
 typedef void (*vFpiiiipp_t)(void*, int32_t, int32_t, int32_t, int32_t, void*, void*);
 typedef void (*vFpiiliip_t)(void*, int32_t, int32_t, intptr_t, int32_t, int32_t, void*);
 typedef void (*vFpiipCpp_t)(void*, int32_t, int32_t, void*, uint8_t, void*, void*);
@@ -1850,6 +1895,7 @@ typedef void (*vFuiiiiill_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32
 typedef void (*vFuiiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*);
 typedef void (*vFuiuiiiii_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFuiuiiiip_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, void*);
+typedef void (*vFuiuiuuuu_t)(uint32_t, int32_t, uint32_t, int32_t, uint32_t, uint32_t, uint32_t, uint32_t);
 typedef void (*vFuiulplpp_t)(uint32_t, int32_t, uint32_t, intptr_t, void*, intptr_t, void*, void*);
 typedef void (*vFuipuliuf_t)(uint32_t, int32_t, void*, uint32_t, intptr_t, int32_t, uint32_t, float);
 typedef void (*vFuuiiiiii_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
@@ -1863,6 +1909,7 @@ typedef void (*vFuuuiuiii_t)(uint32_t, uint32_t, uint32_t, int32_t, uint32_t, in
 typedef void (*vFuuuipipp_t)(uint32_t, uint32_t, uint32_t, int32_t, void*, int32_t, void*, void*);
 typedef void (*vFuuuuuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
 typedef void (*vFuuuuufff_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, float, float, float);
+typedef void (*vFuuufffff_t)(uint32_t, uint32_t, uint32_t, float, float, float, float, float);
 typedef void (*vFulllplip_t)(uint32_t, intptr_t, intptr_t, intptr_t, void*, intptr_t, int32_t, void*);
 typedef void (*vFffffffff_t)(float, float, float, float, float, float, float, float);
 typedef void (*vFlipuiuip_t)(intptr_t, int32_t, void*, uint32_t, int32_t, uint32_t, int32_t, void*);
@@ -1922,6 +1969,7 @@ typedef uint32_t (*uFEppipppp_t)(x86emu_t*, void*, void*, int32_t, void*, void*,
 typedef uint32_t (*uFEpppuppp_t)(x86emu_t*, void*, void*, void*, uint32_t, void*, void*, void*);
 typedef uint32_t (*uFEppppppp_t)(x86emu_t*, void*, void*, void*, void*, void*, void*, void*);
 typedef uint32_t (*uFuipppppp_t)(uint32_t, int32_t, void*, void*, void*, void*, void*, void*);
+typedef uint32_t (*uFulpppppp_t)(uint32_t, intptr_t, void*, void*, void*, void*, void*, void*);
 typedef uint32_t (*uFpupuuuCp_t)(void*, uint32_t, void*, uint32_t, uint32_t, uint32_t, uint8_t, void*);
 typedef uint32_t (*uFppuuuupp_t)(void*, void*, uint32_t, uint32_t, uint32_t, uint32_t, void*, void*);
 typedef uint32_t (*uFppuuuppi_t)(void*, void*, uint32_t, uint32_t, uint32_t, void*, void*, int32_t);
@@ -1960,7 +2008,9 @@ typedef void (*vFEpippippV_t)(x86emu_t*, void*, int32_t, void*, void*, int32_t,
 typedef void (*vFEppiipppp_t)(x86emu_t*, void*, void*, int32_t, int32_t, void*, void*, void*, void*);
 typedef void (*vFEpppiippp_t)(x86emu_t*, void*, void*, void*, int32_t, int32_t, void*, void*, void*);
 typedef void (*vFiiiiiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
+typedef void (*vFiiiiiiill_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t);
 typedef void (*vFiiiiillli_t)(int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t);
+typedef void (*vFiiilllilp_t)(int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t, intptr_t, void*);
 typedef void (*vFuiiiiiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFuiiiiiuip_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, void*);
 typedef void (*vFuiiiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*);
@@ -2046,7 +2096,10 @@ typedef void* (*pFpppppiipp_t)(void*, void*, void*, void*, void*, int32_t, int32
 typedef void (*vFEiippppppp_t)(x86emu_t*, int32_t, int32_t, void*, void*, void*, void*, void*, void*, void*);
 typedef void (*vFEpippppppp_t)(x86emu_t*, void*, int32_t, void*, void*, void*, void*, void*, void*, void*);
 typedef void (*vFEpppiipppp_t)(x86emu_t*, void*, void*, void*, int32_t, int32_t, void*, void*, void*, void*);
+typedef void (*vFiiiiiiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFiiiiiiiiiu_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t);
+typedef void (*vFiiiiiiiiui_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t);
+typedef void (*vFiiillliiip_t)(int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t, int32_t, int32_t, void*);
 typedef void (*vFippppppppp_t)(int32_t, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 typedef void (*vFuiiiiiiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFuiiiiiiill_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t);
@@ -2102,6 +2155,8 @@ typedef void* (*pFplllllllll_t)(void*, intptr_t, intptr_t, intptr_t, intptr_t, i
 typedef void* (*pFppuiipuuii_t)(void*, void*, uint32_t, int32_t, int32_t, void*, uint32_t, uint32_t, int32_t, int32_t);
 typedef void* (*pFpppppppppp_t)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 typedef void (*vFEpiiiupupup_t)(x86emu_t*, void*, int32_t, int32_t, int32_t, uint32_t, void*, uint32_t, void*, uint32_t, void*);
+typedef void (*vFiiiiillliip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t, int32_t, void*);
+typedef void (*vFiiiiilllilp_t)(int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t, int32_t, intptr_t, void*);
 typedef void (*vFiippppppppp_t)(int32_t, int32_t, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 typedef void (*vFuiiiiiiiiip_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*);
 typedef void (*vFuiiiiiiiuip_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, void*);
@@ -2206,6 +2261,7 @@ typedef int32_t (*iFpppppppppppppp_t)(void*, void*, void*, void*, void*, void*,
 typedef void* (*pFEppCuuWWwwCCup_t)(x86emu_t*, void*, void*, uint8_t, uint32_t, uint32_t, uint16_t, uint16_t, int16_t, int16_t, uint8_t, uint8_t, uint32_t, void*);
 typedef void* (*pFEppuuuWWWWWWWW_t)(x86emu_t*, void*, void*, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
 typedef void* (*pFpuupuupwwwwWWC_t)(void*, uint32_t, uint32_t, void*, uint32_t, uint32_t, void*, int16_t, int16_t, int16_t, int16_t, uint16_t, uint16_t, uint8_t);
+typedef void (*vFuiiiiiuiiiiilll_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t);
 typedef void (*vFuuiiiiuuiiiiiii_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
 typedef void (*vFfffffffffffffff_t)(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float);
 typedef void (*vFppipppppppppppp_t)(void*, void*, int32_t, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
@@ -2218,6 +2274,7 @@ typedef void* (*pFppppppppppppppp_t)(void*, void*, void*, void*, void*, void*, v
 typedef void (*vFpppppppppppppppp_t)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 typedef int32_t (*iFpppppppppppppppp_t)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 typedef void* (*pFppipipipipipipip_t)(void*, void*, int32_t, void*, int32_t, void*, int32_t, void*, int32_t, void*, int32_t, void*, int32_t, void*, int32_t, void*);
+typedef void (*vFuuuiiiiiuiiiiilll_t)(uint32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, intptr_t);
 typedef void (*vFppiiiiddddiiiiiuu_t)(void*, void*, int32_t, int32_t, int32_t, int32_t, double, double, double, double, int32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t);
 typedef int32_t (*iFppipipppppppppppp_t)(void*, void*, int32_t, void*, int32_t, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 typedef int32_t (*iFpppippppppppppppp_t)(void*, void*, void*, int32_t, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
@@ -2359,6 +2416,7 @@ void dFp(x86emu_t *emu, uintptr_t fcn) { dFp_t fn = (dFp_t)fcn; double db=fn(*(v
 void dFG(x86emu_t *emu, uintptr_t fcn) { dFG_t fn = (dFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); double db=fn(&arg4); fpu_do_push(emu); ST0val = db; unalignGValue(*(void**)(R_ESP + 4), &arg4); }
 void lFv(x86emu_t *emu, uintptr_t fcn) { lFv_t fn = (lFv_t)fcn; R_EAX=(intptr_t)fn(); }
 void lFi(x86emu_t *emu, uintptr_t fcn) { lFi_t fn = (lFi_t)fcn; R_EAX=(intptr_t)fn(*(int32_t*)(R_ESP + 4)); }
+void lFu(x86emu_t *emu, uintptr_t fcn) { lFu_t fn = (lFu_t)fcn; R_EAX=(intptr_t)fn(*(uint32_t*)(R_ESP + 4)); }
 void lFl(x86emu_t *emu, uintptr_t fcn) { lFl_t fn = (lFl_t)fcn; R_EAX=(intptr_t)fn(*(intptr_t*)(R_ESP + 4)); }
 void lFp(x86emu_t *emu, uintptr_t fcn) { lFp_t fn = (lFp_t)fcn; R_EAX=(intptr_t)fn(*(void**)(R_ESP + 4)); }
 void lFG(x86emu_t *emu, uintptr_t fcn) { lFG_t fn = (lFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); R_EAX=(intptr_t)fn(&arg4); unalignGValue(*(void**)(R_ESP + 4), &arg4); }
@@ -2569,6 +2627,7 @@ void vFEpp(x86emu_t *emu, uintptr_t fcn) { vFEpp_t fn = (vFEpp_t)fcn; fn(emu, *(
 void vFEpV(x86emu_t *emu, uintptr_t fcn) { vFEpV_t fn = (vFEpV_t)fcn; fn(emu, *(void**)(R_ESP + 4), (void*)(R_ESP + 8)); }
 void vFiii(x86emu_t *emu, uintptr_t fcn) { vFiii_t fn = (vFiii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
 void vFiiu(x86emu_t *emu, uintptr_t fcn) { vFiiu_t fn = (vFiiu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); }
+void vFiif(x86emu_t *emu, uintptr_t fcn) { vFiif_t fn = (vFiif_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(float*)(R_ESP + 12)); }
 void vFiip(x86emu_t *emu, uintptr_t fcn) { vFiip_t fn = (vFiip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFiII(x86emu_t *emu, uintptr_t fcn) { vFiII_t fn = (vFiII_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 16)); }
 void vFiui(x86emu_t *emu, uintptr_t fcn) { vFiui_t fn = (vFiui_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
@@ -2577,6 +2636,7 @@ void vFiup(x86emu_t *emu, uintptr_t fcn) { vFiup_t fn = (vFiup_t)fcn; fn(*(int32
 void vFiUU(x86emu_t *emu, uintptr_t fcn) { vFiUU_t fn = (vFiUU_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16)); }
 void vFiff(x86emu_t *emu, uintptr_t fcn) { vFiff_t fn = (vFiff_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12)); }
 void vFidd(x86emu_t *emu, uintptr_t fcn) { vFidd_t fn = (vFidd_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16)); }
+void vFill(x86emu_t *emu, uintptr_t fcn) { vFill_t fn = (vFill_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); }
 void vFilp(x86emu_t *emu, uintptr_t fcn) { vFilp_t fn = (vFilp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFipi(x86emu_t *emu, uintptr_t fcn) { vFipi_t fn = (vFipi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
 void vFipu(x86emu_t *emu, uintptr_t fcn) { vFipu_t fn = (vFipu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); }
@@ -2605,6 +2665,9 @@ void vFfff(x86emu_t *emu, uintptr_t fcn) { vFfff_t fn = (vFfff_t)fcn; fn(*(float
 void vFfpp(x86emu_t *emu, uintptr_t fcn) { vFfpp_t fn = (vFfpp_t)fcn; fn(*(float*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFddd(x86emu_t *emu, uintptr_t fcn) { vFddd_t fn = (vFddd_t)fcn; fn(*(double*)(R_ESP + 4), *(double*)(R_ESP + 12), *(double*)(R_ESP + 20)); }
 void vFdpp(x86emu_t *emu, uintptr_t fcn) { vFdpp_t fn = (vFdpp_t)fcn; fn(*(double*)(R_ESP + 4), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
+void vFlip(x86emu_t *emu, uintptr_t fcn) { vFlip_t fn = (vFlip_t)fcn; fn(*(intptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
+void vFllp(x86emu_t *emu, uintptr_t fcn) { vFllp_t fn = (vFllp_t)fcn; fn(*(intptr_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
+void vFlpp(x86emu_t *emu, uintptr_t fcn) { vFlpp_t fn = (vFlpp_t)fcn; fn(*(intptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFLpL(x86emu_t *emu, uintptr_t fcn) { vFLpL_t fn = (vFLpL_t)fcn; fn(*(uintptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); }
 void vFpii(x86emu_t *emu, uintptr_t fcn) { vFpii_t fn = (vFpii_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
 void vFpiI(x86emu_t *emu, uintptr_t fcn) { vFpiI_t fn = (vFpiI_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12)); }
@@ -2616,14 +2679,17 @@ void vFpip(x86emu_t *emu, uintptr_t fcn) { vFpip_t fn = (vFpip_t)fcn; fn(*(void*
 void vFpui(x86emu_t *emu, uintptr_t fcn) { vFpui_t fn = (vFpui_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
 void vFpuI(x86emu_t *emu, uintptr_t fcn) { vFpuI_t fn = (vFpuI_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12)); }
 void vFpuu(x86emu_t *emu, uintptr_t fcn) { vFpuu_t fn = (vFpuu_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); }
+void vFpuU(x86emu_t *emu, uintptr_t fcn) { vFpuU_t fn = (vFpuU_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 12)); }
 void vFpup(x86emu_t *emu, uintptr_t fcn) { vFpup_t fn = (vFpup_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFpUi(x86emu_t *emu, uintptr_t fcn) { vFpUi_t fn = (vFpUi_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16)); }
 void vFpUu(x86emu_t *emu, uintptr_t fcn) { vFpUu_t fn = (vFpUu_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16)); }
 void vFpUU(x86emu_t *emu, uintptr_t fcn) { vFpUU_t fn = (vFpUU_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16)); }
 void vFpUp(x86emu_t *emu, uintptr_t fcn) { vFpUp_t fn = (vFpUp_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16)); }
+void vFpUP(x86emu_t *emu, uintptr_t fcn) { vFpUP_t fn = (vFpUP_t)fcn; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16)); fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16); VulkanTox86(arg16); }
 void vFpff(x86emu_t *emu, uintptr_t fcn) { vFpff_t fn = (vFpff_t)fcn; fn(*(void**)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12)); }
 void vFpdd(x86emu_t *emu, uintptr_t fcn) { vFpdd_t fn = (vFpdd_t)fcn; fn(*(void**)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16)); }
 void vFpll(x86emu_t *emu, uintptr_t fcn) { vFpll_t fn = (vFpll_t)fcn; fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); }
+void vFplp(x86emu_t *emu, uintptr_t fcn) { vFplp_t fn = (vFplp_t)fcn; fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFpLi(x86emu_t *emu, uintptr_t fcn) { vFpLi_t fn = (vFpLi_t)fcn; fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
 void vFpLL(x86emu_t *emu, uintptr_t fcn) { vFpLL_t fn = (vFpLL_t)fcn; fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); }
 void vFpLp(x86emu_t *emu, uintptr_t fcn) { vFpLp_t fn = (vFpLp_t)fcn; fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
@@ -2878,21 +2944,27 @@ void vFEppV(x86emu_t *emu, uintptr_t fcn) { vFEppV_t fn = (vFEppV_t)fcn; fn(emu,
 void vFEpPp(x86emu_t *emu, uintptr_t fcn) { vFEpPp_t fn = (vFEpPp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8); }
 void vFiiii(x86emu_t *emu, uintptr_t fcn) { vFiiii_t fn = (vFiiii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void vFiiip(x86emu_t *emu, uintptr_t fcn) { vFiiip_t fn = (vFiiip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
+void vFiill(x86emu_t *emu, uintptr_t fcn) { vFiill_t fn = (vFiill_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16)); }
 void vFiipp(x86emu_t *emu, uintptr_t fcn) { vFiipp_t fn = (vFiipp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFiipV(x86emu_t *emu, uintptr_t fcn) { vFiipV_t fn = (vFiipV_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void vFiIII(x86emu_t *emu, uintptr_t fcn) { vFiIII_t fn = (vFiIII_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 16), *(int64_t*)(R_ESP + 24)); }
 void vFiuiu(x86emu_t *emu, uintptr_t fcn) { vFiuiu_t fn = (vFiuiu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
 void vFiuip(x86emu_t *emu, uintptr_t fcn) { vFiuip_t fn = (vFiuip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFiuuu(x86emu_t *emu, uintptr_t fcn) { vFiuuu_t fn = (vFiuuu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
+void vFiuup(x86emu_t *emu, uintptr_t fcn) { vFiuup_t fn = (vFiuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFiulp(x86emu_t *emu, uintptr_t fcn) { vFiulp_t fn = (vFiulp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFiupu(x86emu_t *emu, uintptr_t fcn) { vFiupu_t fn = (vFiupu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
 void vFiupV(x86emu_t *emu, uintptr_t fcn) { vFiupV_t fn = (vFiupV_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void vFiUUU(x86emu_t *emu, uintptr_t fcn) { vFiUUU_t fn = (vFiUUU_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16), *(uint64_t*)(R_ESP + 24)); }
 void vFifff(x86emu_t *emu, uintptr_t fcn) { vFifff_t fn = (vFifff_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16)); }
 void vFiddd(x86emu_t *emu, uintptr_t fcn) { vFiddd_t fn = (vFiddd_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16), *(double*)(R_ESP + 24)); }
+void vFilil(x86emu_t *emu, uintptr_t fcn) { vFilil_t fn = (vFilil_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16)); }
+void vFilip(x86emu_t *emu, uintptr_t fcn) { vFilip_t fn = (vFilip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
+void vFilpu(x86emu_t *emu, uintptr_t fcn) { vFilpu_t fn = (vFilpu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
 void vFilpp(x86emu_t *emu, uintptr_t fcn) { vFilpp_t fn = (vFilpp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFipii(x86emu_t *emu, uintptr_t fcn) { vFipii_t fn = (vFipii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void vFipup(x86emu_t *emu, uintptr_t fcn) { vFipup_t fn = (vFipup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
+void vFipll(x86emu_t *emu, uintptr_t fcn) { vFipll_t fn = (vFipll_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16)); }
 void vFippi(x86emu_t *emu, uintptr_t fcn) { vFippi_t fn = (vFippi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void vFippu(x86emu_t *emu, uintptr_t fcn) { vFippu_t fn = (vFippu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
 void vFippp(x86emu_t *emu, uintptr_t fcn) { vFippp_t fn = (vFippp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
@@ -2959,16 +3031,19 @@ void vFpuup(x86emu_t *emu, uintptr_t fcn) { vFpuup_t fn = (vFpuup_t)fcn; fn(*(vo
 void vFpuuV(x86emu_t *emu, uintptr_t fcn) { vFpuuV_t fn = (vFpuuV_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void vFpudd(x86emu_t *emu, uintptr_t fcn) { vFpudd_t fn = (vFpudd_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(double*)(R_ESP + 12), *(double*)(R_ESP + 20)); }
 void vFpupp(x86emu_t *emu, uintptr_t fcn) { vFpupp_t fn = (vFpupp_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
+void vFpupP(x86emu_t *emu, uintptr_t fcn) { vFpupP_t fn = (vFpupP_t)fcn; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16)); fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), arg16); VulkanTox86(arg16); }
 void vFpUui(x86emu_t *emu, uintptr_t fcn) { vFpUui_t fn = (vFpUui_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void vFpUuu(x86emu_t *emu, uintptr_t fcn) { vFpUuu_t fn = (vFpUuu_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void vFpUup(x86emu_t *emu, uintptr_t fcn) { vFpUup_t fn = (vFpUup_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFpUUi(x86emu_t *emu, uintptr_t fcn) { vFpUUi_t fn = (vFpUUi_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 24)); }
+void vFpUUu(x86emu_t *emu, uintptr_t fcn) { vFpUUu_t fn = (vFpUUu_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 24)); }
 void vFpUUp(x86emu_t *emu, uintptr_t fcn) { vFpUUp_t fn = (vFpUUp_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16), *(void**)(R_ESP + 24)); }
 void vFpUpp(x86emu_t *emu, uintptr_t fcn) { vFpUpp_t fn = (vFpUpp_t)fcn; fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFpfff(x86emu_t *emu, uintptr_t fcn) { vFpfff_t fn = (vFpfff_t)fcn; fn(*(void**)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16)); }
 void vFpdii(x86emu_t *emu, uintptr_t fcn) { vFpdii_t fn = (vFpdii_t)fcn; fn(*(void**)(R_ESP + 4), *(double*)(R_ESP + 8), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void vFpddi(x86emu_t *emu, uintptr_t fcn) { vFpddi_t fn = (vFpddi_t)fcn; fn(*(void**)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16), *(int32_t*)(R_ESP + 24)); }
 void vFpddd(x86emu_t *emu, uintptr_t fcn) { vFpddd_t fn = (vFpddd_t)fcn; fn(*(void**)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16), *(double*)(R_ESP + 24)); }
+void vFplpp(x86emu_t *emu, uintptr_t fcn) { vFplpp_t fn = (vFplpp_t)fcn; fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFpLLL(x86emu_t *emu, uintptr_t fcn) { vFpLLL_t fn = (vFpLLL_t)fcn; fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); }
 void vFppii(x86emu_t *emu, uintptr_t fcn) { vFppii_t fn = (vFppii_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void vFppiu(x86emu_t *emu, uintptr_t fcn) { vFppiu_t fn = (vFppiu_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
@@ -3194,6 +3269,7 @@ void pFiiup(x86emu_t *emu, uintptr_t fcn) { pFiiup_t fn = (pFiiup_t)fcn; R_EAX=(
 void pFiipi(x86emu_t *emu, uintptr_t fcn) { pFiipi_t fn = (pFiipi_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void pFiipp(x86emu_t *emu, uintptr_t fcn) { pFiipp_t fn = (pFiipp_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void pFiIIi(x86emu_t *emu, uintptr_t fcn) { pFiIIi_t fn = (pFiIIi_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 24)); }
+void pFillu(x86emu_t *emu, uintptr_t fcn) { pFillu_t fn = (pFillu_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
 void pFipii(x86emu_t *emu, uintptr_t fcn) { pFipii_t fn = (pFipii_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void pFipip(x86emu_t *emu, uintptr_t fcn) { pFipip_t fn = (pFipip_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void pFipup(x86emu_t *emu, uintptr_t fcn) { pFipup_t fn = (pFipup_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
@@ -3253,10 +3329,15 @@ void vFEppip(x86emu_t *emu, uintptr_t fcn) { vFEppip_t fn = (vFEppip_t)fcn; fn(e
 void vFEppiV(x86emu_t *emu, uintptr_t fcn) { vFEppiV_t fn = (vFEppiV_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void vFEppup(x86emu_t *emu, uintptr_t fcn) { vFEppup_t fn = (vFEppup_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void vFEpppp(x86emu_t *emu, uintptr_t fcn) { vFEpppp_t fn = (vFEpppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
+void vFEpPpp(x86emu_t *emu, uintptr_t fcn) { vFEpPpp_t fn = (vFEpPpp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8); }
 void vFiiiii(x86emu_t *emu, uintptr_t fcn) { vFiiiii_t fn = (vFiiiii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void vFiiiiu(x86emu_t *emu, uintptr_t fcn) { vFiiiiu_t fn = (vFiiiiu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
+void vFiiuii(x86emu_t *emu, uintptr_t fcn) { vFiiuii_t fn = (vFiiuii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void vFiiuup(x86emu_t *emu, uintptr_t fcn) { vFiiuup_t fn = (vFiiuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
+void vFiillu(x86emu_t *emu, uintptr_t fcn) { vFiillu_t fn = (vFiillu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
+void vFiilll(x86emu_t *emu, uintptr_t fcn) { vFiilll_t fn = (vFiilll_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20)); }
 void vFiipii(x86emu_t *emu, uintptr_t fcn) { vFiipii_t fn = (vFiipii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
+void vFiipll(x86emu_t *emu, uintptr_t fcn) { vFiipll_t fn = (vFiipll_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20)); }
 void vFiIIII(x86emu_t *emu, uintptr_t fcn) { vFiIIII_t fn = (vFiIIII_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 16), *(int64_t*)(R_ESP + 24), *(int64_t*)(R_ESP + 32)); }
 void vFiuiip(x86emu_t *emu, uintptr_t fcn) { vFiuiip_t fn = (vFiuiip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFiuipi(x86emu_t *emu, uintptr_t fcn) { vFiuipi_t fn = (vFiuipi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
@@ -3267,6 +3348,8 @@ void vFiUUUU(x86emu_t *emu, uintptr_t fcn) { vFiUUUU_t fn = (vFiUUUU_t)fcn; fn(*
 void vFiffff(x86emu_t *emu, uintptr_t fcn) { vFiffff_t fn = (vFiffff_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20)); }
 void vFidddd(x86emu_t *emu, uintptr_t fcn) { vFidddd_t fn = (vFidddd_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16), *(double*)(R_ESP + 24), *(double*)(R_ESP + 32)); }
 void vFilill(x86emu_t *emu, uintptr_t fcn) { vFilill_t fn = (vFilill_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20)); }
+void vFilipi(x86emu_t *emu, uintptr_t fcn) { vFilipi_t fn = (vFilipi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
+void vFilipl(x86emu_t *emu, uintptr_t fcn) { vFilipl_t fn = (vFilipl_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(intptr_t*)(R_ESP + 20)); }
 void vFipipu(x86emu_t *emu, uintptr_t fcn) { vFipipu_t fn = (vFipipu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void vFipipp(x86emu_t *emu, uintptr_t fcn) { vFipipp_t fn = (vFipipp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFipupi(x86emu_t *emu, uintptr_t fcn) { vFipupi_t fn = (vFipupi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
@@ -3276,6 +3359,7 @@ void vFuiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiii_t fn = (vFuiiii_t)fcn; fn(*
 void vFuiiiu(x86emu_t *emu, uintptr_t fcn) { vFuiiiu_t fn = (vFuiiiu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void vFuiiip(x86emu_t *emu, uintptr_t fcn) { vFuiiip_t fn = (vFuiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFuiifi(x86emu_t *emu, uintptr_t fcn) { vFuiifi_t fn = (vFuiifi_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(float*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
+void vFuiill(x86emu_t *emu, uintptr_t fcn) { vFuiill_t fn = (vFuiill_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20)); }
 void vFuiIII(x86emu_t *emu, uintptr_t fcn) { vFuiIII_t fn = (vFuiIII_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int64_t*)(R_ESP + 20), *(int64_t*)(R_ESP + 28)); }
 void vFuiuii(x86emu_t *emu, uintptr_t fcn) { vFuiuii_t fn = (vFuiuii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void vFuiuiu(x86emu_t *emu, uintptr_t fcn) { vFuiuiu_t fn = (vFuiuiu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
@@ -3328,6 +3412,8 @@ void vFpiiff(x86emu_t *emu, uintptr_t fcn) { vFpiiff_t fn = (vFpiiff_t)fcn; fn(*
 void vFpiipp(x86emu_t *emu, uintptr_t fcn) { vFpiipp_t fn = (vFpiipp_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFpiIiI(x86emu_t *emu, uintptr_t fcn) { vFpiIiI_t fn = (vFpiIiI_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 20), *(int64_t*)(R_ESP + 24)); }
 void vFpiIII(x86emu_t *emu, uintptr_t fcn) { vFpiIII_t fn = (vFpiIII_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int64_t*)(R_ESP + 20), *(int64_t*)(R_ESP + 28)); }
+void vFpiUUp(x86emu_t *emu, uintptr_t fcn) { vFpiUUp_t fn = (vFpiUUp_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 12), *(uint64_t*)(R_ESP + 20), *(void**)(R_ESP + 28)); }
+void vFpilpp(x86emu_t *emu, uintptr_t fcn) { vFpilpp_t fn = (vFpilpp_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFpipii(x86emu_t *emu, uintptr_t fcn) { vFpipii_t fn = (vFpipii_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void vFpipiu(x86emu_t *emu, uintptr_t fcn) { vFpipiu_t fn = (vFpipiu_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void vFpuiip(x86emu_t *emu, uintptr_t fcn) { vFpuiip_t fn = (vFpuiip_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
@@ -3388,6 +3474,7 @@ void iFEpiup(x86emu_t *emu, uintptr_t fcn) { iFEpiup_t fn = (iFEpiup_t)fcn; R_EA
 void iFEpipi(x86emu_t *emu, uintptr_t fcn) { iFEpipi_t fn = (iFEpipi_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void iFEpipp(x86emu_t *emu, uintptr_t fcn) { iFEpipp_t fn = (iFEpipp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void iFEpipV(x86emu_t *emu, uintptr_t fcn) { iFEpipV_t fn = (iFEpipV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
+void iFEpupU(x86emu_t *emu, uintptr_t fcn) { iFEpupU_t fn = (iFEpupU_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint64_t*)(R_ESP + 16)); }
 void iFEpupp(x86emu_t *emu, uintptr_t fcn) { iFEpupp_t fn = (iFEpupp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void iFEpupV(x86emu_t *emu, uintptr_t fcn) { iFEpupV_t fn = (iFEpupV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void iFEpUup(x86emu_t *emu, uintptr_t fcn) { iFEpUup_t fn = (iFEpUup_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
@@ -3430,6 +3517,7 @@ void iFpiipp(x86emu_t *emu, uintptr_t fcn) { iFpiipp_t fn = (iFpiipp_t)fcn; R_EA
 void iFpiIip(x86emu_t *emu, uintptr_t fcn) { iFpiIip_t fn = (iFpiIip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void iFpiuwp(x86emu_t *emu, uintptr_t fcn) { iFpiuwp_t fn = (iFpiuwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFpiupu(x86emu_t *emu, uintptr_t fcn) { iFpiupu_t fn = (iFpiupu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
+void iFpiUUU(x86emu_t *emu, uintptr_t fcn) { iFpiUUU_t fn = (iFpiUUU_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 12), *(uint64_t*)(R_ESP + 20), *(uint64_t*)(R_ESP + 28)); }
 void iFpipii(x86emu_t *emu, uintptr_t fcn) { iFpipii_t fn = (iFpipii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); }
 void iFpipiL(x86emu_t *emu, uintptr_t fcn) { iFpipiL_t fn = (iFpipiL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20)); }
 void iFpipip(x86emu_t *emu, uintptr_t fcn) { iFpipip_t fn = (iFpipip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
@@ -3453,6 +3541,7 @@ void iFpupuu(x86emu_t *emu, uintptr_t fcn) { iFpupuu_t fn = (iFpupuu_t)fcn; R_EA
 void iFpupup(x86emu_t *emu, uintptr_t fcn) { iFpupup_t fn = (iFpupup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFpuppu(x86emu_t *emu, uintptr_t fcn) { iFpuppu_t fn = (iFpuppu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void iFpuppp(x86emu_t *emu, uintptr_t fcn) { iFpuppp_t fn = (iFpuppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
+void iFpUiUi(x86emu_t *emu, uintptr_t fcn) { iFpUiUi_t fn = (iFpUiUi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16), *(uint64_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 28)); }
 void iFplluu(x86emu_t *emu, uintptr_t fcn) { iFplluu_t fn = (iFplluu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void iFpLlpp(x86emu_t *emu, uintptr_t fcn) { iFpLlpp_t fn = (iFpLlpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFpLLpp(x86emu_t *emu, uintptr_t fcn) { iFpLLpp_t fn = (iFpLLpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
@@ -3590,13 +3679,20 @@ void vFEpppiu(x86emu_t *emu, uintptr_t fcn) { vFEpppiu_t fn = (vFEpppiu_t)fcn; f
 void vFEppppp(x86emu_t *emu, uintptr_t fcn) { vFEppppp_t fn = (vFEppppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void vFiiiiii(x86emu_t *emu, uintptr_t fcn) { vFiiiiii_t fn = (vFiiiiii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void vFiiiuil(x86emu_t *emu, uintptr_t fcn) { vFiiiuil_t fn = (vFiiiuil_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24)); }
+void vFiiilpi(x86emu_t *emu, uintptr_t fcn) { vFiiilpi_t fn = (vFiiilpi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void vFiiuiil(x86emu_t *emu, uintptr_t fcn) { vFiiuiil_t fn = (vFiiuiil_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24)); }
+void vFiiuilp(x86emu_t *emu, uintptr_t fcn) { vFiiuilp_t fn = (vFiiuilp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
+void vFiiuulp(x86emu_t *emu, uintptr_t fcn) { vFiiuulp_t fn = (vFiiuulp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFiililp(x86emu_t *emu, uintptr_t fcn) { vFiililp_t fn = (vFiililp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFiiplli(x86emu_t *emu, uintptr_t fcn) { vFiiplli_t fn = (vFiiplli_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void vFiiplll(x86emu_t *emu, uintptr_t fcn) { vFiiplll_t fn = (vFiiplll_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24)); }
 void vFiuippp(x86emu_t *emu, uintptr_t fcn) { vFiuippp_t fn = (vFiuippp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFiffiff(x86emu_t *emu, uintptr_t fcn) { vFiffiff_t fn = (vFiffiff_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24)); }
 void vFiddidd(x86emu_t *emu, uintptr_t fcn) { vFiddidd_t fn = (vFiddidd_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16), *(int32_t*)(R_ESP + 24), *(double*)(R_ESP + 28), *(double*)(R_ESP + 36)); }
+void vFililll(x86emu_t *emu, uintptr_t fcn) { vFililll_t fn = (vFililll_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24)); }
+void vFilipli(x86emu_t *emu, uintptr_t fcn) { vFilipli_t fn = (vFilipli_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
+void vFiliplu(x86emu_t *emu, uintptr_t fcn) { vFiliplu_t fn = (vFiliplu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); }
+void vFipiplp(x86emu_t *emu, uintptr_t fcn) { vFipiplp_t fn = (vFipiplp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFipllli(x86emu_t *emu, uintptr_t fcn) { vFipllli_t fn = (vFipllli_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void vFuiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiiii_t fn = (vFuiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void vFuiiiil(x86emu_t *emu, uintptr_t fcn) { vFuiiiil_t fn = (vFuiiiil_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24)); }
@@ -3610,6 +3706,7 @@ void vFuiuiip(x86emu_t *emu, uintptr_t fcn) { vFuiuiip_t fn = (vFuiuiip_t)fcn; f
 void vFuiuiuu(x86emu_t *emu, uintptr_t fcn) { vFuiuiuu_t fn = (vFuiuiuu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); }
 void vFuiuuip(x86emu_t *emu, uintptr_t fcn) { vFuiuuip_t fn = (vFuiuuip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFuiuuuu(x86emu_t *emu, uintptr_t fcn) { vFuiuuuu_t fn = (vFuiuuuu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); }
+void vFuiuulp(x86emu_t *emu, uintptr_t fcn) { vFuiuulp_t fn = (vFuiuulp_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFuiupii(x86emu_t *emu, uintptr_t fcn) { vFuiupii_t fn = (vFuiupii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void vFuiupiu(x86emu_t *emu, uintptr_t fcn) { vFuiupiu_t fn = (vFuiupiu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); }
 void vFuiUUUU(x86emu_t *emu, uintptr_t fcn) { vFuiUUUU_t fn = (vFuiUUUU_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 12), *(uint64_t*)(R_ESP + 20), *(uint64_t*)(R_ESP + 28), *(uint64_t*)(R_ESP + 36)); }
@@ -3855,8 +3952,12 @@ void vFEppippp(x86emu_t *emu, uintptr_t fcn) { vFEppippp_t fn = (vFEppippp_t)fcn
 void vFEpppppp(x86emu_t *emu, uintptr_t fcn) { vFEpppppp_t fn = (vFEpppppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void vFiiiiiip(x86emu_t *emu, uintptr_t fcn) { vFiiiiiip_t fn = (vFiiiiiip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFiiiiuup(x86emu_t *emu, uintptr_t fcn) { vFiiiiuup_t fn = (vFiiiiuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
+void vFiiuilil(x86emu_t *emu, uintptr_t fcn) { vFiiuilil_t fn = (vFiiuilil_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(intptr_t*)(R_ESP + 28)); }
 void vFiiffffp(x86emu_t *emu, uintptr_t fcn) { vFiiffffp_t fn = (vFiiffffp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFiipllli(x86emu_t *emu, uintptr_t fcn) { vFiipllli_t fn = (vFiipllli_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); }
+void vFiuulipi(x86emu_t *emu, uintptr_t fcn) { vFiuulipi_t fn = (vFiuulipi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); }
+void vFilipliu(x86emu_t *emu, uintptr_t fcn) { vFilipliu_t fn = (vFilipliu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28)); }
+void vFilulipi(x86emu_t *emu, uintptr_t fcn) { vFilulipi_t fn = (vFilulipi_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); }
 void vFuiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiiiii_t fn = (vFuiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); }
 void vFuiiiuip(x86emu_t *emu, uintptr_t fcn) { vFuiiiuip_t fn = (vFuiiiuip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFuiiiuup(x86emu_t *emu, uintptr_t fcn) { vFuiiiuup_t fn = (vFuiiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
@@ -3896,6 +3997,7 @@ void vFulillli(x86emu_t *emu, uintptr_t fcn) { vFulillli_t fn = (vFulillli_t)fcn
 void vFulipulp(x86emu_t *emu, uintptr_t fcn) { vFulipulp_t fn = (vFulipulp_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFulpiill(x86emu_t *emu, uintptr_t fcn) { vFulpiill_t fn = (vFulpiill_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(intptr_t*)(R_ESP + 28)); }
 void vFlipuiip(x86emu_t *emu, uintptr_t fcn) { vFlipuiip_t fn = (vFlipuiip_t)fcn; fn(*(intptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
+void vFlliiiip(x86emu_t *emu, uintptr_t fcn) { vFlliiiip_t fn = (vFlliiiip_t)fcn; fn(*(intptr_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFpiiiipp(x86emu_t *emu, uintptr_t fcn) { vFpiiiipp_t fn = (vFpiiiipp_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFpiiliip(x86emu_t *emu, uintptr_t fcn) { vFpiiliip_t fn = (vFpiiliip_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void vFpiipCpp(x86emu_t *emu, uintptr_t fcn) { vFpiipCpp_t fn = (vFpiipCpp_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint8_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); }
@@ -4069,6 +4171,7 @@ void vFuiiiiill(x86emu_t *emu, uintptr_t fcn) { vFuiiiiill_t fn = (vFuiiiiill_t)
 void vFuiiiiuup(x86emu_t *emu, uintptr_t fcn) { vFuiiiiuup_t fn = (vFuiiiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void vFuiuiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiuiiiii_t fn = (vFuiuiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); }
 void vFuiuiiiip(x86emu_t *emu, uintptr_t fcn) { vFuiuiiiip_t fn = (vFuiuiiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); }
+void vFuiuiuuuu(x86emu_t *emu, uintptr_t fcn) { vFuiuiuuuu_t fn = (vFuiuiuuuu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32)); }
 void vFuiulplpp(x86emu_t *emu, uintptr_t fcn) { vFuiulplpp_t fn = (vFuiulplpp_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void vFuipuliuf(x86emu_t *emu, uintptr_t fcn) { vFuipuliuf_t fn = (vFuipuliuf_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(float*)(R_ESP + 32)); }
 void vFuuiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuuiiiiii_t fn = (vFuuiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); }
@@ -4082,6 +4185,7 @@ void vFuuuiuiii(x86emu_t *emu, uintptr_t fcn) { vFuuuiuiii_t fn = (vFuuuiuiii_t)
 void vFuuuipipp(x86emu_t *emu, uintptr_t fcn) { vFuuuipipp_t fn = (vFuuuipipp_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void vFuuuuuuuu(x86emu_t *emu, uintptr_t fcn) { vFuuuuuuuu_t fn = (vFuuuuuuuu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32)); }
 void vFuuuuufff(x86emu_t *emu, uintptr_t fcn) { vFuuuuufff_t fn = (vFuuuuufff_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32)); }
+void vFuuufffff(x86emu_t *emu, uintptr_t fcn) { vFuuufffff_t fn = (vFuuufffff_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32)); }
 void vFulllplip(x86emu_t *emu, uintptr_t fcn) { vFulllplip_t fn = (vFulllplip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void vFffffffff(x86emu_t *emu, uintptr_t fcn) { vFffffffff_t fn = (vFffffffff_t)fcn; fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32)); }
 void vFlipuiuip(x86emu_t *emu, uintptr_t fcn) { vFlipuiuip_t fn = (vFlipuiuip_t)fcn; fn(*(intptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); }
@@ -4141,6 +4245,7 @@ void uFEppipppp(x86emu_t *emu, uintptr_t fcn) { uFEppipppp_t fn = (uFEppipppp_t)
 void uFEpppuppp(x86emu_t *emu, uintptr_t fcn) { uFEpppuppp_t fn = (uFEpppuppp_t)fcn; R_EAX=(uint32_t)fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void uFEppppppp(x86emu_t *emu, uintptr_t fcn) { uFEppppppp_t fn = (uFEppppppp_t)fcn; R_EAX=(uint32_t)fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void uFuipppppp(x86emu_t *emu, uintptr_t fcn) { uFuipppppp_t fn = (uFuipppppp_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
+void uFulpppppp(x86emu_t *emu, uintptr_t fcn) { uFulpppppp_t fn = (uFulpppppp_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void uFpupuuuCp(x86emu_t *emu, uintptr_t fcn) { uFpupuuuCp_t fn = (uFpupuuuCp_t)fcn; R_EAX=(uint32_t)fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint8_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void uFppuuuupp(x86emu_t *emu, uintptr_t fcn) { uFppuuuupp_t fn = (uFppuuuupp_t)fcn; R_EAX=(uint32_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void uFppuuuppi(x86emu_t *emu, uintptr_t fcn) { uFppuuuppi_t fn = (uFppuuuppi_t)fcn; R_EAX=(uint32_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); }
@@ -4179,7 +4284,9 @@ void vFEpippippV(x86emu_t *emu, uintptr_t fcn) { vFEpippippV_t fn = (vFEpippippV
 void vFEppiipppp(x86emu_t *emu, uintptr_t fcn) { vFEppiipppp_t fn = (vFEppiipppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void vFEpppiippp(x86emu_t *emu, uintptr_t fcn) { vFEpppiippp_t fn = (vFEpppiippp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); }
 void vFiiiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFiiiiiiiii_t fn = (vFiiiiiiiii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); }
+void vFiiiiiiill(x86emu_t *emu, uintptr_t fcn) { vFiiiiiiill_t fn = (vFiiiiiiill_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32), *(intptr_t*)(R_ESP + 36)); }
 void vFiiiiillli(x86emu_t *emu, uintptr_t fcn) { vFiiiiillli_t fn = (vFiiiiillli_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(intptr_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); }
+void vFiiilllilp(x86emu_t *emu, uintptr_t fcn) { vFiiilllilp_t fn = (vFiiilllilp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); }
 void vFuiiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiiii_t fn = (vFuiiiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); }
 void vFuiiiiiuip(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiuip_t fn = (vFuiiiiiuip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); }
 void vFuiiiiiuup(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiuup_t fn = (vFuiiiiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); }
@@ -4265,7 +4372,10 @@ void pFpppppiipp(x86emu_t *emu, uintptr_t fcn) { pFpppppiipp_t fn = (pFpppppiipp
 void vFEiippppppp(x86emu_t *emu, uintptr_t fcn) { vFEiippppppp_t fn = (vFEiippppppp_t)fcn; fn(emu, *(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36)); }
 void vFEpippppppp(x86emu_t *emu, uintptr_t fcn) { vFEpippppppp_t fn = (vFEpippppppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36)); }
 void vFEpppiipppp(x86emu_t *emu, uintptr_t fcn) { vFEpppiipppp_t fn = (vFEpppiipppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36)); }
+void vFiiiiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFiiiiiiiiii_t fn = (vFiiiiiiiiii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40)); }
 void vFiiiiiiiiiu(x86emu_t *emu, uintptr_t fcn) { vFiiiiiiiiiu_t fn = (vFiiiiiiiiiu_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(uint32_t*)(R_ESP + 40)); }
+void vFiiiiiiiiui(x86emu_t *emu, uintptr_t fcn) { vFiiiiiiiiui_t fn = (vFiiiiiiiiui_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40)); }
+void vFiiillliiip(x86emu_t *emu, uintptr_t fcn) { vFiiillliiip_t fn = (vFiiillliiip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(void**)(R_ESP + 40)); }
 void vFippppppppp(x86emu_t *emu, uintptr_t fcn) { vFippppppppp_t fn = (vFippppppppp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40)); }
 void vFuiiiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiiiii_t fn = (vFuiiiiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40)); }
 void vFuiiiiiiill(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiiill_t fn = (vFuiiiiiiill_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(intptr_t*)(R_ESP + 36), *(intptr_t*)(R_ESP + 40)); }
@@ -4321,6 +4431,8 @@ void pFplllllllll(x86emu_t *emu, uintptr_t fcn) { pFplllllllll_t fn = (pFpllllll
 void pFppuiipuuii(x86emu_t *emu, uintptr_t fcn) { pFppuiipuuii_t fn = (pFppuiipuuii_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40)); }
 void pFpppppppppp(x86emu_t *emu, uintptr_t fcn) { pFpppppppppp_t fn = (pFpppppppppp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40)); }
 void vFEpiiiupupup(x86emu_t *emu, uintptr_t fcn) { vFEpiiiupupup_t fn = (vFEpiiiupupup_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(void**)(R_ESP + 40)); }
+void vFiiiiillliip(x86emu_t *emu, uintptr_t fcn) { vFiiiiillliip_t fn = (vFiiiiillliip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(intptr_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(void**)(R_ESP + 44)); }
+void vFiiiiilllilp(x86emu_t *emu, uintptr_t fcn) { vFiiiiilllilp_t fn = (vFiiiiilllilp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(intptr_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(intptr_t*)(R_ESP + 40), *(void**)(R_ESP + 44)); }
 void vFiippppppppp(x86emu_t *emu, uintptr_t fcn) { vFiippppppppp_t fn = (vFiippppppppp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40), *(void**)(R_ESP + 44)); }
 void vFuiiiiiiiiip(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiiiiip_t fn = (vFuiiiiiiiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(void**)(R_ESP + 44)); }
 void vFuiiiiiiiuip(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiiiuip_t fn = (vFuiiiiiiiuip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(void**)(R_ESP + 44)); }
@@ -4425,6 +4537,7 @@ void iFpppppppppppppp(x86emu_t *emu, uintptr_t fcn) { iFpppppppppppppp_t fn = (i
 void pFEppCuuWWwwCCup(x86emu_t *emu, uintptr_t fcn) { pFEppCuuWWwwCCup_t fn = (pFEppCuuWWwwCCup_t)fcn; R_EAX=(uintptr_t)fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint8_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint16_t*)(R_ESP + 24), *(uint16_t*)(R_ESP + 28), *(int16_t*)(R_ESP + 32), *(int16_t*)(R_ESP + 36), *(uint8_t*)(R_ESP + 40), *(uint8_t*)(R_ESP + 44), *(uint32_t*)(R_ESP + 48), *(void**)(R_ESP + 52)); }
 void pFEppuuuWWWWWWWW(x86emu_t *emu, uintptr_t fcn) { pFEppuuuWWWWWWWW_t fn = (pFEppuuuWWWWWWWW_t)fcn; R_EAX=(uintptr_t)fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint16_t*)(R_ESP + 24), *(uint16_t*)(R_ESP + 28), *(uint16_t*)(R_ESP + 32), *(uint16_t*)(R_ESP + 36), *(uint16_t*)(R_ESP + 40), *(uint16_t*)(R_ESP + 44), *(uint16_t*)(R_ESP + 48), *(uint16_t*)(R_ESP + 52)); }
 void pFpuupuupwwwwWWC(x86emu_t *emu, uintptr_t fcn) { pFpuupuupwwwwWWC_t fn = (pFpuupuupwwwwWWC_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(int16_t*)(R_ESP + 32), *(int16_t*)(R_ESP + 36), *(int16_t*)(R_ESP + 40), *(int16_t*)(R_ESP + 44), *(uint16_t*)(R_ESP + 48), *(uint16_t*)(R_ESP + 52), *(uint8_t*)(R_ESP + 56)); }
+void vFuiiiiiuiiiiilll(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiuiiiiilll_t fn = (vFuiiiiiuiiiiilll_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44), *(int32_t*)(R_ESP + 48), *(intptr_t*)(R_ESP + 52), *(intptr_t*)(R_ESP + 56), *(intptr_t*)(R_ESP + 60)); }
 void vFuuiiiiuuiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuuiiiiuuiiiiiii_t fn = (vFuuiiiiuuiiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44), *(int32_t*)(R_ESP + 48), *(int32_t*)(R_ESP + 52), *(int32_t*)(R_ESP + 56), *(int32_t*)(R_ESP + 60)); }
 void vFfffffffffffffff(x86emu_t *emu, uintptr_t fcn) { vFfffffffffffffff_t fn = (vFfffffffffffffff_t)fcn; fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32), *(float*)(R_ESP + 36), *(float*)(R_ESP + 40), *(float*)(R_ESP + 44), *(float*)(R_ESP + 48), *(float*)(R_ESP + 52), *(float*)(R_ESP + 56), *(float*)(R_ESP + 60)); }
 void vFppipppppppppppp(x86emu_t *emu, uintptr_t fcn) { vFppipppppppppppp_t fn = (vFppipppppppppppp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40), *(void**)(R_ESP + 44), *(void**)(R_ESP + 48), *(void**)(R_ESP + 52), *(void**)(R_ESP + 56), *(void**)(R_ESP + 60)); }
@@ -4437,6 +4550,7 @@ void pFppppppppppppppp(x86emu_t *emu, uintptr_t fcn) { pFppppppppppppppp_t fn =
 void vFpppppppppppppppp(x86emu_t *emu, uintptr_t fcn) { vFpppppppppppppppp_t fn = (vFpppppppppppppppp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40), *(void**)(R_ESP + 44), *(void**)(R_ESP + 48), *(void**)(R_ESP + 52), *(void**)(R_ESP + 56), *(void**)(R_ESP + 60), *(void**)(R_ESP + 64)); }
 void iFpppppppppppppppp(x86emu_t *emu, uintptr_t fcn) { iFpppppppppppppppp_t fn = (iFpppppppppppppppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40), *(void**)(R_ESP + 44), *(void**)(R_ESP + 48), *(void**)(R_ESP + 52), *(void**)(R_ESP + 56), *(void**)(R_ESP + 60), *(void**)(R_ESP + 64)); }
 void pFppipipipipipipip(x86emu_t *emu, uintptr_t fcn) { pFppipipipipipipip_t fn = (pFppipipipipipipip_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(void**)(R_ESP + 40), *(int32_t*)(R_ESP + 44), *(void**)(R_ESP + 48), *(int32_t*)(R_ESP + 52), *(void**)(R_ESP + 56), *(int32_t*)(R_ESP + 60), *(void**)(R_ESP + 64)); }
+void vFuuuiiiiiuiiiiilll(x86emu_t *emu, uintptr_t fcn) { vFuuuiiiiiuiiiiilll_t fn = (vFuuuiiiiiuiiiiilll_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44), *(int32_t*)(R_ESP + 48), *(int32_t*)(R_ESP + 52), *(int32_t*)(R_ESP + 56), *(intptr_t*)(R_ESP + 60), *(intptr_t*)(R_ESP + 64), *(intptr_t*)(R_ESP + 68)); }
 void vFppiiiiddddiiiiiuu(x86emu_t *emu, uintptr_t fcn) { vFppiiiiddddiiiiiuu_t fn = (vFppiiiiddddiiiiiuu_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(double*)(R_ESP + 28), *(double*)(R_ESP + 36), *(double*)(R_ESP + 44), *(double*)(R_ESP + 52), *(int32_t*)(R_ESP + 60), *(int32_t*)(R_ESP + 64), *(int32_t*)(R_ESP + 68), *(int32_t*)(R_ESP + 72), *(int32_t*)(R_ESP + 76), *(uint32_t*)(R_ESP + 80), *(uint32_t*)(R_ESP + 84)); }
 void iFppipipppppppppppp(x86emu_t *emu, uintptr_t fcn) { iFppipipppppppppppp_t fn = (iFppipipppppppppppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40), *(void**)(R_ESP + 44), *(void**)(R_ESP + 48), *(void**)(R_ESP + 52), *(void**)(R_ESP + 56), *(void**)(R_ESP + 60), *(void**)(R_ESP + 64), *(void**)(R_ESP + 68)); }
 void iFpppippppppppppppp(x86emu_t *emu, uintptr_t fcn) { iFpppippppppppppppp_t fn = (iFpppippppppppppppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(void**)(R_ESP + 36), *(void**)(R_ESP + 40), *(void**)(R_ESP + 44), *(void**)(R_ESP + 48), *(void**)(R_ESP + 52), *(void**)(R_ESP + 56), *(void**)(R_ESP + 60), *(void**)(R_ESP + 64), *(void**)(R_ESP + 68)); }

src/wrapped/generated/wrapper.h

@@ -100,6 +100,7 @@ void dFp(x86emu_t *emu, uintptr_t fnc);
 void dFG(x86emu_t *emu, uintptr_t fnc);
 void lFv(x86emu_t *emu, uintptr_t fnc);
 void lFi(x86emu_t *emu, uintptr_t fnc);
+void lFu(x86emu_t *emu, uintptr_t fnc);
 void lFl(x86emu_t *emu, uintptr_t fnc);
 void lFp(x86emu_t *emu, uintptr_t fnc);
 void lFG(x86emu_t *emu, uintptr_t fnc);
@@ -310,6 +311,7 @@ void vFEpp(x86emu_t *emu, uintptr_t fnc);
 void vFEpV(x86emu_t *emu, uintptr_t fnc);
 void vFiii(x86emu_t *emu, uintptr_t fnc);
 void vFiiu(x86emu_t *emu, uintptr_t fnc);
+void vFiif(x86emu_t *emu, uintptr_t fnc);
 void vFiip(x86emu_t *emu, uintptr_t fnc);
 void vFiII(x86emu_t *emu, uintptr_t fnc);
 void vFiui(x86emu_t *emu, uintptr_t fnc);
@@ -318,6 +320,7 @@ void vFiup(x86emu_t *emu, uintptr_t fnc);
 void vFiUU(x86emu_t *emu, uintptr_t fnc);
 void vFiff(x86emu_t *emu, uintptr_t fnc);
 void vFidd(x86emu_t *emu, uintptr_t fnc);
+void vFill(x86emu_t *emu, uintptr_t fnc);
 void vFilp(x86emu_t *emu, uintptr_t fnc);
 void vFipi(x86emu_t *emu, uintptr_t fnc);
 void vFipu(x86emu_t *emu, uintptr_t fnc);
@@ -346,6 +349,9 @@ void vFfff(x86emu_t *emu, uintptr_t fnc);
 void vFfpp(x86emu_t *emu, uintptr_t fnc);
 void vFddd(x86emu_t *emu, uintptr_t fnc);
 void vFdpp(x86emu_t *emu, uintptr_t fnc);
+void vFlip(x86emu_t *emu, uintptr_t fnc);
+void vFllp(x86emu_t *emu, uintptr_t fnc);
+void vFlpp(x86emu_t *emu, uintptr_t fnc);
 void vFLpL(x86emu_t *emu, uintptr_t fnc);
 void vFpii(x86emu_t *emu, uintptr_t fnc);
 void vFpiI(x86emu_t *emu, uintptr_t fnc);
@@ -357,14 +363,17 @@ void vFpip(x86emu_t *emu, uintptr_t fnc);
 void vFpui(x86emu_t *emu, uintptr_t fnc);
 void vFpuI(x86emu_t *emu, uintptr_t fnc);
 void vFpuu(x86emu_t *emu, uintptr_t fnc);
+void vFpuU(x86emu_t *emu, uintptr_t fnc);
 void vFpup(x86emu_t *emu, uintptr_t fnc);
 void vFpUi(x86emu_t *emu, uintptr_t fnc);
 void vFpUu(x86emu_t *emu, uintptr_t fnc);
 void vFpUU(x86emu_t *emu, uintptr_t fnc);
 void vFpUp(x86emu_t *emu, uintptr_t fnc);
+void vFpUP(x86emu_t *emu, uintptr_t fnc);
 void vFpff(x86emu_t *emu, uintptr_t fnc);
 void vFpdd(x86emu_t *emu, uintptr_t fnc);
 void vFpll(x86emu_t *emu, uintptr_t fnc);
+void vFplp(x86emu_t *emu, uintptr_t fnc);
 void vFpLi(x86emu_t *emu, uintptr_t fnc);
 void vFpLL(x86emu_t *emu, uintptr_t fnc);
 void vFpLp(x86emu_t *emu, uintptr_t fnc);
@@ -619,21 +628,27 @@ void vFEppV(x86emu_t *emu, uintptr_t fnc);
 void vFEpPp(x86emu_t *emu, uintptr_t fnc);
 void vFiiii(x86emu_t *emu, uintptr_t fnc);
 void vFiiip(x86emu_t *emu, uintptr_t fnc);
+void vFiill(x86emu_t *emu, uintptr_t fnc);
 void vFiipp(x86emu_t *emu, uintptr_t fnc);
 void vFiipV(x86emu_t *emu, uintptr_t fnc);
 void vFiIII(x86emu_t *emu, uintptr_t fnc);
 void vFiuiu(x86emu_t *emu, uintptr_t fnc);
 void vFiuip(x86emu_t *emu, uintptr_t fnc);
 void vFiuuu(x86emu_t *emu, uintptr_t fnc);
+void vFiuup(x86emu_t *emu, uintptr_t fnc);
 void vFiulp(x86emu_t *emu, uintptr_t fnc);
 void vFiupu(x86emu_t *emu, uintptr_t fnc);
 void vFiupV(x86emu_t *emu, uintptr_t fnc);
 void vFiUUU(x86emu_t *emu, uintptr_t fnc);
 void vFifff(x86emu_t *emu, uintptr_t fnc);
 void vFiddd(x86emu_t *emu, uintptr_t fnc);
+void vFilil(x86emu_t *emu, uintptr_t fnc);
+void vFilip(x86emu_t *emu, uintptr_t fnc);
+void vFilpu(x86emu_t *emu, uintptr_t fnc);
 void vFilpp(x86emu_t *emu, uintptr_t fnc);
 void vFipii(x86emu_t *emu, uintptr_t fnc);
 void vFipup(x86emu_t *emu, uintptr_t fnc);
+void vFipll(x86emu_t *emu, uintptr_t fnc);
 void vFippi(x86emu_t *emu, uintptr_t fnc);
 void vFippu(x86emu_t *emu, uintptr_t fnc);
 void vFippp(x86emu_t *emu, uintptr_t fnc);
@@ -700,16 +715,19 @@ void vFpuup(x86emu_t *emu, uintptr_t fnc);
 void vFpuuV(x86emu_t *emu, uintptr_t fnc);
 void vFpudd(x86emu_t *emu, uintptr_t fnc);
 void vFpupp(x86emu_t *emu, uintptr_t fnc);
+void vFpupP(x86emu_t *emu, uintptr_t fnc);
 void vFpUui(x86emu_t *emu, uintptr_t fnc);
 void vFpUuu(x86emu_t *emu, uintptr_t fnc);
 void vFpUup(x86emu_t *emu, uintptr_t fnc);
 void vFpUUi(x86emu_t *emu, uintptr_t fnc);
+void vFpUUu(x86emu_t *emu, uintptr_t fnc);
 void vFpUUp(x86emu_t *emu, uintptr_t fnc);
 void vFpUpp(x86emu_t *emu, uintptr_t fnc);
 void vFpfff(x86emu_t *emu, uintptr_t fnc);
 void vFpdii(x86emu_t *emu, uintptr_t fnc);
 void vFpddi(x86emu_t *emu, uintptr_t fnc);
 void vFpddd(x86emu_t *emu, uintptr_t fnc);
+void vFplpp(x86emu_t *emu, uintptr_t fnc);
 void vFpLLL(x86emu_t *emu, uintptr_t fnc);
 void vFppii(x86emu_t *emu, uintptr_t fnc);
 void vFppiu(x86emu_t *emu, uintptr_t fnc);
@@ -935,6 +953,7 @@ void pFiiup(x86emu_t *emu, uintptr_t fnc);
 void pFiipi(x86emu_t *emu, uintptr_t fnc);
 void pFiipp(x86emu_t *emu, uintptr_t fnc);
 void pFiIIi(x86emu_t *emu, uintptr_t fnc);
+void pFillu(x86emu_t *emu, uintptr_t fnc);
 void pFipii(x86emu_t *emu, uintptr_t fnc);
 void pFipip(x86emu_t *emu, uintptr_t fnc);
 void pFipup(x86emu_t *emu, uintptr_t fnc);
@@ -994,10 +1013,15 @@ void vFEppip(x86emu_t *emu, uintptr_t fnc);
 void vFEppiV(x86emu_t *emu, uintptr_t fnc);
 void vFEppup(x86emu_t *emu, uintptr_t fnc);
 void vFEpppp(x86emu_t *emu, uintptr_t fnc);
+void vFEpPpp(x86emu_t *emu, uintptr_t fnc);
 void vFiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiu(x86emu_t *emu, uintptr_t fnc);
+void vFiiuii(x86emu_t *emu, uintptr_t fnc);
 void vFiiuup(x86emu_t *emu, uintptr_t fnc);
+void vFiillu(x86emu_t *emu, uintptr_t fnc);
+void vFiilll(x86emu_t *emu, uintptr_t fnc);
 void vFiipii(x86emu_t *emu, uintptr_t fnc);
+void vFiipll(x86emu_t *emu, uintptr_t fnc);
 void vFiIIII(x86emu_t *emu, uintptr_t fnc);
 void vFiuiip(x86emu_t *emu, uintptr_t fnc);
 void vFiuipi(x86emu_t *emu, uintptr_t fnc);
@@ -1008,6 +1032,8 @@ void vFiUUUU(x86emu_t *emu, uintptr_t fnc);
 void vFiffff(x86emu_t *emu, uintptr_t fnc);
 void vFidddd(x86emu_t *emu, uintptr_t fnc);
 void vFilill(x86emu_t *emu, uintptr_t fnc);
+void vFilipi(x86emu_t *emu, uintptr_t fnc);
+void vFilipl(x86emu_t *emu, uintptr_t fnc);
 void vFipipu(x86emu_t *emu, uintptr_t fnc);
 void vFipipp(x86emu_t *emu, uintptr_t fnc);
 void vFipupi(x86emu_t *emu, uintptr_t fnc);
@@ -1017,6 +1043,7 @@ void vFuiiii(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiu(x86emu_t *emu, uintptr_t fnc);
 void vFuiiip(x86emu_t *emu, uintptr_t fnc);
 void vFuiifi(x86emu_t *emu, uintptr_t fnc);
+void vFuiill(x86emu_t *emu, uintptr_t fnc);
 void vFuiIII(x86emu_t *emu, uintptr_t fnc);
 void vFuiuii(x86emu_t *emu, uintptr_t fnc);
 void vFuiuiu(x86emu_t *emu, uintptr_t fnc);
@@ -1069,6 +1096,8 @@ void vFpiiff(x86emu_t *emu, uintptr_t fnc);
 void vFpiipp(x86emu_t *emu, uintptr_t fnc);
 void vFpiIiI(x86emu_t *emu, uintptr_t fnc);
 void vFpiIII(x86emu_t *emu, uintptr_t fnc);
+void vFpiUUp(x86emu_t *emu, uintptr_t fnc);
+void vFpilpp(x86emu_t *emu, uintptr_t fnc);
 void vFpipii(x86emu_t *emu, uintptr_t fnc);
 void vFpipiu(x86emu_t *emu, uintptr_t fnc);
 void vFpuiip(x86emu_t *emu, uintptr_t fnc);
@@ -1129,6 +1158,7 @@ void iFEpiup(x86emu_t *emu, uintptr_t fnc);
 void iFEpipi(x86emu_t *emu, uintptr_t fnc);
 void iFEpipp(x86emu_t *emu, uintptr_t fnc);
 void iFEpipV(x86emu_t *emu, uintptr_t fnc);
+void iFEpupU(x86emu_t *emu, uintptr_t fnc);
 void iFEpupp(x86emu_t *emu, uintptr_t fnc);
 void iFEpupV(x86emu_t *emu, uintptr_t fnc);
 void iFEpUup(x86emu_t *emu, uintptr_t fnc);
@@ -1171,6 +1201,7 @@ void iFpiipp(x86emu_t *emu, uintptr_t fnc);
 void iFpiIip(x86emu_t *emu, uintptr_t fnc);
 void iFpiuwp(x86emu_t *emu, uintptr_t fnc);
 void iFpiupu(x86emu_t *emu, uintptr_t fnc);
+void iFpiUUU(x86emu_t *emu, uintptr_t fnc);
 void iFpipii(x86emu_t *emu, uintptr_t fnc);
 void iFpipiL(x86emu_t *emu, uintptr_t fnc);
 void iFpipip(x86emu_t *emu, uintptr_t fnc);
@@ -1194,6 +1225,7 @@ void iFpupuu(x86emu_t *emu, uintptr_t fnc);
 void iFpupup(x86emu_t *emu, uintptr_t fnc);
 void iFpuppu(x86emu_t *emu, uintptr_t fnc);
 void iFpuppp(x86emu_t *emu, uintptr_t fnc);
+void iFpUiUi(x86emu_t *emu, uintptr_t fnc);
 void iFplluu(x86emu_t *emu, uintptr_t fnc);
 void iFpLlpp(x86emu_t *emu, uintptr_t fnc);
 void iFpLLpp(x86emu_t *emu, uintptr_t fnc);
@@ -1331,13 +1363,20 @@ void vFEpppiu(x86emu_t *emu, uintptr_t fnc);
 void vFEppppp(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFiiiuil(x86emu_t *emu, uintptr_t fnc);
+void vFiiilpi(x86emu_t *emu, uintptr_t fnc);
 void vFiiuiil(x86emu_t *emu, uintptr_t fnc);
+void vFiiuilp(x86emu_t *emu, uintptr_t fnc);
+void vFiiuulp(x86emu_t *emu, uintptr_t fnc);
 void vFiililp(x86emu_t *emu, uintptr_t fnc);
 void vFiiplli(x86emu_t *emu, uintptr_t fnc);
 void vFiiplll(x86emu_t *emu, uintptr_t fnc);
 void vFiuippp(x86emu_t *emu, uintptr_t fnc);
 void vFiffiff(x86emu_t *emu, uintptr_t fnc);
 void vFiddidd(x86emu_t *emu, uintptr_t fnc);
+void vFililll(x86emu_t *emu, uintptr_t fnc);
+void vFilipli(x86emu_t *emu, uintptr_t fnc);
+void vFiliplu(x86emu_t *emu, uintptr_t fnc);
+void vFipiplp(x86emu_t *emu, uintptr_t fnc);
 void vFipllli(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiil(x86emu_t *emu, uintptr_t fnc);
@@ -1351,6 +1390,7 @@ void vFuiuiip(x86emu_t *emu, uintptr_t fnc);
 void vFuiuiuu(x86emu_t *emu, uintptr_t fnc);
 void vFuiuuip(x86emu_t *emu, uintptr_t fnc);
 void vFuiuuuu(x86emu_t *emu, uintptr_t fnc);
+void vFuiuulp(x86emu_t *emu, uintptr_t fnc);
 void vFuiupii(x86emu_t *emu, uintptr_t fnc);
 void vFuiupiu(x86emu_t *emu, uintptr_t fnc);
 void vFuiUUUU(x86emu_t *emu, uintptr_t fnc);
@@ -1596,8 +1636,12 @@ void vFEppippp(x86emu_t *emu, uintptr_t fnc);
 void vFEpppppp(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiiip(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiuup(x86emu_t *emu, uintptr_t fnc);
+void vFiiuilil(x86emu_t *emu, uintptr_t fnc);
 void vFiiffffp(x86emu_t *emu, uintptr_t fnc);
 void vFiipllli(x86emu_t *emu, uintptr_t fnc);
+void vFiuulipi(x86emu_t *emu, uintptr_t fnc);
+void vFilipliu(x86emu_t *emu, uintptr_t fnc);
+void vFilulipi(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiuip(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiuup(x86emu_t *emu, uintptr_t fnc);
@@ -1637,6 +1681,7 @@ void vFulillli(x86emu_t *emu, uintptr_t fnc);
 void vFulipulp(x86emu_t *emu, uintptr_t fnc);
 void vFulpiill(x86emu_t *emu, uintptr_t fnc);
 void vFlipuiip(x86emu_t *emu, uintptr_t fnc);
+void vFlliiiip(x86emu_t *emu, uintptr_t fnc);
 void vFpiiiipp(x86emu_t *emu, uintptr_t fnc);
 void vFpiiliip(x86emu_t *emu, uintptr_t fnc);
 void vFpiipCpp(x86emu_t *emu, uintptr_t fnc);
@@ -1810,6 +1855,7 @@ void vFuiiiiill(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiuup(x86emu_t *emu, uintptr_t fnc);
 void vFuiuiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFuiuiiiip(x86emu_t *emu, uintptr_t fnc);
+void vFuiuiuuuu(x86emu_t *emu, uintptr_t fnc);
 void vFuiulplpp(x86emu_t *emu, uintptr_t fnc);
 void vFuipuliuf(x86emu_t *emu, uintptr_t fnc);
 void vFuuiiiiii(x86emu_t *emu, uintptr_t fnc);
@@ -1823,6 +1869,7 @@ void vFuuuiuiii(x86emu_t *emu, uintptr_t fnc);
 void vFuuuipipp(x86emu_t *emu, uintptr_t fnc);
 void vFuuuuuuuu(x86emu_t *emu, uintptr_t fnc);
 void vFuuuuufff(x86emu_t *emu, uintptr_t fnc);
+void vFuuufffff(x86emu_t *emu, uintptr_t fnc);
 void vFulllplip(x86emu_t *emu, uintptr_t fnc);
 void vFffffffff(x86emu_t *emu, uintptr_t fnc);
 void vFlipuiuip(x86emu_t *emu, uintptr_t fnc);
@@ -1882,6 +1929,7 @@ void uFEppipppp(x86emu_t *emu, uintptr_t fnc);
 void uFEpppuppp(x86emu_t *emu, uintptr_t fnc);
 void uFEppppppp(x86emu_t *emu, uintptr_t fnc);
 void uFuipppppp(x86emu_t *emu, uintptr_t fnc);
+void uFulpppppp(x86emu_t *emu, uintptr_t fnc);
 void uFpupuuuCp(x86emu_t *emu, uintptr_t fnc);
 void uFppuuuupp(x86emu_t *emu, uintptr_t fnc);
 void uFppuuuppi(x86emu_t *emu, uintptr_t fnc);
@@ -1920,7 +1968,9 @@ void vFEpippippV(x86emu_t *emu, uintptr_t fnc);
 void vFEppiipppp(x86emu_t *emu, uintptr_t fnc);
 void vFEpppiippp(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiiiiii(x86emu_t *emu, uintptr_t fnc);
+void vFiiiiiiill(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiillli(x86emu_t *emu, uintptr_t fnc);
+void vFiiilllilp(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiuip(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiuup(x86emu_t *emu, uintptr_t fnc);
@@ -2006,7 +2056,10 @@ void pFpppppiipp(x86emu_t *emu, uintptr_t fnc);
 void vFEiippppppp(x86emu_t *emu, uintptr_t fnc);
 void vFEpippppppp(x86emu_t *emu, uintptr_t fnc);
 void vFEpppiipppp(x86emu_t *emu, uintptr_t fnc);
+void vFiiiiiiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFiiiiiiiiiu(x86emu_t *emu, uintptr_t fnc);
+void vFiiiiiiiiui(x86emu_t *emu, uintptr_t fnc);
+void vFiiillliiip(x86emu_t *emu, uintptr_t fnc);
 void vFippppppppp(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiiill(x86emu_t *emu, uintptr_t fnc);
@@ -2062,6 +2115,8 @@ void pFplllllllll(x86emu_t *emu, uintptr_t fnc);
 void pFppuiipuuii(x86emu_t *emu, uintptr_t fnc);
 void pFpppppppppp(x86emu_t *emu, uintptr_t fnc);
 void vFEpiiiupupup(x86emu_t *emu, uintptr_t fnc);
+void vFiiiiillliip(x86emu_t *emu, uintptr_t fnc);
+void vFiiiiilllilp(x86emu_t *emu, uintptr_t fnc);
 void vFiippppppppp(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiiiiip(x86emu_t *emu, uintptr_t fnc);
 void vFuiiiiiiiuip(x86emu_t *emu, uintptr_t fnc);
@@ -2166,6 +2221,7 @@ void iFpppppppppppppp(x86emu_t *emu, uintptr_t fnc);
 void pFEppCuuWWwwCCup(x86emu_t *emu, uintptr_t fnc);
 void pFEppuuuWWWWWWWW(x86emu_t *emu, uintptr_t fnc);
 void pFpuupuupwwwwWWC(x86emu_t *emu, uintptr_t fnc);
+void vFuiiiiiuiiiiilll(x86emu_t *emu, uintptr_t fnc);
 void vFuuiiiiuuiiiiiii(x86emu_t *emu, uintptr_t fnc);
 void vFfffffffffffffff(x86emu_t *emu, uintptr_t fnc);
 void vFppipppppppppppp(x86emu_t *emu, uintptr_t fnc);
@@ -2178,6 +2234,7 @@ void pFppppppppppppppp(x86emu_t *emu, uintptr_t fnc);
 void vFpppppppppppppppp(x86emu_t *emu, uintptr_t fnc);
 void iFpppppppppppppppp(x86emu_t *emu, uintptr_t fnc);
 void pFppipipipipipipip(x86emu_t *emu, uintptr_t fnc);
+void vFuuuiiiiiuiiiiilll(x86emu_t *emu, uintptr_t fnc);
 void vFppiiiiddddiiiiiuu(x86emu_t *emu, uintptr_t fnc);
 void iFppipipppppppppppp(x86emu_t *emu, uintptr_t fnc);
 void iFpppippppppppppppp(x86emu_t *emu, uintptr_t fnc);

src/wrapped/wrappedcrypto_private.h

@@ -44,7 +44,7 @@ GO(AES_wrap_key, iFppppi)
 //GO(asn1_add_error, 
 GO(ASN1_add_oid_module, vFv)
 //GO(ASN1_BIT_STRING_check, 
-//GO(ASN1_BIT_STRING_free, 
+GO(ASN1_BIT_STRING_free, vFp)
 //GO(ASN1_BIT_STRING_get_bit, 
 //GO(ASN1_BIT_STRING_name_print, 
 //GO(ASN1_BIT_STRING_new, 

src/wrapped/wrappedlibdl.c

@@ -197,9 +197,9 @@ int recursive_dlsym_lib(kh_libs_t* collection, library_t* lib, const char* rsymb
     // TODO: should use librarian functions instead!
     int weak;
     // look in the library itself
-    if(lib->getglobal(lib, rsymbol, start, end, &weak, version, vername, 1))
+    if(lib->getglobal(lib, rsymbol, start, end, 0, &weak, version, vername, 1))
         return 1;
-    if(lib->getweak(lib, rsymbol, start, end, &weak, version, vername, 1))
+    if(lib->getweak(lib, rsymbol, start, end, 0, &weak, version, vername, 1))
         return 1;
     // look in other libs
     int n = GetNeededLibN(lib);
@@ -242,7 +242,7 @@ void* my_dlsym(x86emu_t* emu, void *handle, void *symbol)
     if(handle==(void*)0xFFFFFFFF) {
         // special case, look globably but no self (RTLD_NEXT)
         elfheader_t *elf = FindElfAddress(my_context, *(uint32_t*)R_ESP); // use return address to guess "self"
-        if(GetNoSelfSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, elf, -1, NULL)) {
+        if(GetNoSelfSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, elf, 0, -1, NULL)) {
             printf_dlsym(LOG_NEVER, "%p\n", (void*)start);
             return (void*)start;
         }
@@ -383,7 +383,7 @@ void* my_dlvsym(x86emu_t* emu, void *handle, void *symbol, const char* vername)
     if(handle==(void*)0xFFFFFFFF) {
         // special case, look globably but no self (RTLD_NEXT)
         elfheader_t *elf = FindElfAddress(my_context, *(uint32_t*)R_ESP); // use return address to guess "self"
-        if(GetNoSelfSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, elf, version, vername)) {
+        if(GetNoSelfSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, elf, 0, version, vername)) {
             printf_dlsym(LOG_NEVER, "%p\n", (void*)start);
             return (void*)start;
         }

src/wrapped/wrappedlibgl.c

@@ -155,6 +155,7 @@ EXPORT void my_glDebugMessageCallback(x86emu_t* emu, void* prod, void* param)
 }
 EXPORT void my_glDebugMessageCallbackARB(x86emu_t* emu, void* prod, void* param) __attribute__((alias("my_glDebugMessageCallback")));
 EXPORT void my_glDebugMessageCallbackAMD(x86emu_t* emu, void* prod, void* param) __attribute__((alias("my_glDebugMessageCallback")));
+EXPORT void my_glDebugMessageCallbackKHR(x86emu_t* emu, void* prod, void* param) __attribute__((alias("my_glDebugMessageCallback")));
 
 EXPORT int my_glXSwapIntervalMESA(int interval)
 {

src/wrapped/wrappedlibgl_private.h

@@ -3307,3 +3307,411 @@ GO(glResolveDepthValuesNV, vFv)
 
 //GL_OVR_multiview
 GO(glFramebufferTextureMultiviewOVR, vFiiuiil)
+
+// GL_AMD_framebuffer_sample_positions
+GO(glFramebufferSamplePositionsfvAMD, vFiuup)
+GO(glNamedFramebufferSamplePositionsfvAMD, vFuuup)
+GO(glGetFramebufferParameterfvAMD, vFiiuulp)
+GO(glGetNamedFramebufferParameterfvAMD, vFuiuulp)
+
+// GL_ANGLE_framebuffer_blit
+GO(glBlitFramebufferANGLE, vFiiiiiiiiui)
+
+// GL_ANGLE_framebuffer_multisample
+GO(glRenderbufferStorageMultisampleANGLE, vFilill)
+
+// GL_ANGLE_instanced_arrays
+GO(glDrawArraysInstancedANGLE, vFiill)
+GO(glDrawElementsInstancedANGLE, vFilipl)
+GO(glVertexAttribDivisorANGLE, vFuu)
+
+// GL_ANGLE_timer_query
+GO(glBeginQueryANGLE, vFiu)
+GO(glDeleteQueriesANGLE, vFlp)
+GO(glEndQueryANGLE, vFi)
+GO(glGenQueriesANGLE, vFlp)
+GO(glGetQueryObjecti64vANGLE, vFuip)
+GO(glGetQueryObjectivANGLE, vFuip)
+GO(glGetQueryObjectui64vANGLE, vFuip)
+GO(glGetQueryObjectuivANGLE, vFuip)
+GO(glGetQueryivANGLE, vFiip)
+GO(glIsQueryANGLE, iFu)
+GO(glQueryCounterANGLE, vFui)
+
+// GL_APPLE_copy_texture_levels
+GO(glCopyTextureLevelsAPPLE, vFuuil)
+
+// GL_APPLE_framebuffer_multisample
+GO(glRenderbufferStorageMultisampleAPPLE, vFilill)
+
+// GL_APPLE_sync
+GO(glFenceSyncAPPLE, pFiu)
+GO(glIsSyncAPPLE, iFp)
+GO(glDeleteSyncAPPLE, vFp)
+GO(glClientWaitSyncAPPLE, iFpuU)
+GO(glWaitSyncAPPLE, vFpuU)
+GO(glGetInteger64vAPPLE, vFip)
+GO(glGetSyncivAPPLE, vFpilpp)
+
+// GL_EXT_base_instance
+GO(glDrawArraysInstancedBaseInstanceEXT, vFiillu)
+GO(glDrawElementsInstancedBaseInstanceEXT, vFiliplu)
+GO(glDrawElementsInstancedBaseVertexBaseInstanceEXT, vFilipliu)
+
+// GL_EXT_blend_func_extended
+GO(glBindFragDataLocationIndexedEXT, vFuuup)
+GO(glGetProgramResourceLocationIndexEXT, iFuip)
+GO(glGetFragDataIndexEXT, iFup)
+
+// GL_EXT_buffer_storage
+GO(glBufferStorageEXT, vFilpu)
+
+// GL_EXT_clear_texture
+GO(glClearTexImageEXT, vFuiiip)
+GO(glClearTexSubImageEXT, vFuiiiillliip)
+
+// GL_EXT_copy_image
+GO(glCopyImageSubDataEXT, vFuiiiiiuiiiiilll)
+
+// GL_EXT_draw_buffers
+GO(glDrawBuffersEXT, vFlp)
+
+// GL_EXT_draw_buffers_indexed
+GO(glEnableiEXT, vFiu)
+GO(glDisableiEXT, vFiu)
+GO(glBlendEquationiEXT, vFui)
+GO(glBlendEquationSeparateiEXT, vFuii)
+GO(glBlendFunciEXT, vFuii)
+GO(glBlendFuncSeparateiEXT, vFuiiii)
+GO(glColorMaskiEXT, vFuiiii)
+GO(glIsEnablediEXT, iFui)
+
+// GL_EXT_draw_elements_base_vertex
+GO(glDrawElementsBaseVertexEXT, vFilipi)
+GO(glDrawRangeElementsBaseVertexEXT, vFilulipi)
+GO(glDrawElementsInstancedBaseVertexEXT, vFilipli)
+
+// GL_OES_draw_elements_base_vertex
+GO(glDrawElementsBaseVertexOES, vFilipi)
+GO(glDrawRangeElementsBaseVertexOES, vFiuulipi)
+GO(glDrawElementsInstancedBaseVertexOES, vFilipli)
+GO(glMultiDrawElementsBaseVertexEXT, vFipiplp)
+
+// GL_EXT_fragment_lighting
+GO(glFragmentLightModeliEXT, vFii)
+GO(glFragmentLightModelfEXT, vFif)
+GO(glFragmentLightModelivEXT, vFip)
+GO(glFragmentLightModelfvEXT, vFip)
+GO(glFragmentLightiEXT, vFiii)
+GO(glFragmentLightfEXT, vFiif)
+GO(glFragmentLightivEXT, vFiip)
+GO(glFragmentLightfvEXT, vFiip)
+GO(glGetFragmentLightivEXT, vFiip)
+GO(glGetFragmentLightfvEXT, vFiip)
+GO(glFragmentMaterialfEXT, vFiif)
+GO(glFragmentMaterialiEXT, vFiii)
+GO(glFragmentMaterialfvEXT, vFiip)
+GO(glFragmentMaterialivEXT, vFiip)
+GO(glFragmentColorMaterialEXT, vFii)
+GO(glGetFragmentMaterialfvEXT, vFiip)
+GO(glGetFragmentMaterialivEXT, vFiip)
+GO(glLightEnviEXT, vFii)
+
+// GL_EXT_instanced_arrays
+GO(glVertexAttribDivisorEXT, vFuu)
+
+// GL_EXT_map_buffer_range
+GO(glMapBufferRangeEXT, pFillu)
+GO(glFlushMappedBufferRangeEXT, vFill)
+
+// GL_EXT_multi_draw_indirect
+GO(glMultiDrawArraysIndirectEXT, vFipll)
+GO(glMultiDrawElementsIndirectEXT, vFiipll)
+
+// GL_EXT_multiview_draw_buffers
+GO(glReadBufferIndexedEXT, vFii)
+GO(glDrawBuffersIndexedEXT, vFipp)
+GO(glGetIntegeri_vEXT, vFiup)
+
+// GL_EXT_scene_marker
+GO(glBeginSceneEXT, vFv)
+GO(glEndSceneEXT, vFv)
+
+// GL_EXT_shader_pixel_local_storage2
+GO(glFramebufferPixelLocalStorageSizeEXT, vFul)
+GO(glGetFramebufferPixelLocalStorageSizeEXT, lFu)
+GO(glClearPixelLocalStorageuiEXT, vFllp)
+
+// GL_EXT_sparse_texture
+GO(glTexPageCommitmentEXT, vFiiiiillli)
+
+// GL_EXT_texture_storage
+GO(glTexStorage1DEXT, vFilil)
+GO(glTexStorage2DEXT, vFilill)
+GO(glTexStorage3DEXT, vFililll)
+
+// GL_EXT_texture_view
+GO(glTextureViewEXT, vFuiuiuuuu)
+
+// GL_EXT_vertex_array_setXXX
+GO(glCreateArraySetExt, pFv)
+GO(glBindArraySetEXT, vFp)
+GO(glDeleteArraySetsEXT, vFlp)
+
+// GL_INTEL_texture_scissor
+GO(glTexScissorINTEL, vFiff)
+GO(glTexScissorFuncINTEL, vFiii)
+
+// GL_NVX_linked_gpu_multicast
+GO(glLGPUNamedBufferSubDataNVX, vFuullp)
+GO(glLGPUCopyImageSubDataNVX, vFuuuiiiiiuiiiiilll)
+GO(glLGPUInterlockNVX, vFv)
+
+// GL_NV_3dvision_settings
+GO(glStereoParameteriNV, vFii)
+GO(glStereoParameterfNV, vFif)
+
+// GL_NV_copy_buffer
+GO(glCopyBufferSubDataNV, vFiilll)
+
+// GL_NV_draw_buffers
+GO(glDrawBuffersNV, vFlp)
+
+// GL_NV_draw_instanced
+GO(glDrawArraysInstancedNV, vFiill)
+GO(glDrawElementsInstancedNV, vFilipl)
+
+// GL_NV_framebuffer_blit
+GO(glBlitFramebufferNV, vFiiiiiiiiui)
+
+// GL_NV_framebuffer_multisample
+GO(glRenderbufferStorageMultisampleNV, vFilill)
+
+// GL_NV_instanced_arrays
+GO(glVertexAttribDivisorNV, vFuu)
+
+// GL_NV_non_square_matrices
+GO(glUniformMatrix2x3fvNV, vFilip)
+GO(glUniformMatrix3x2fvNV, vFilip)
+GO(glUniformMatrix2x4fvNV, vFilip)
+GO(glUniformMatrix4x2fvNV, vFilip)
+GO(glUniformMatrix3x4fvNV, vFilip)
+GO(glUniformMatrix4x3fvNV, vFilip)
+
+// GL_NV_polygon_mode
+GO(glPolygonModeNV, vFii)
+
+// GL_NV_texture_array
+GO(glTexImage3DNV, vFiiillliiip)
+GO(glTexSubImage3DNV, vFiiiiillliip)
+GO(glCopyTexSubImage3DNV, vFiiiiiiill)
+GO(glCompressedTexImage3DNV, vFiiilllilp)
+GO(glCompressedTexSubImage3DNV, vFiiiiilllilp)
+GO(glFramebufferTextureLayerNV, vFiiuii)
+
+// GL_NV_viewport_array
+GO(glViewportArrayvNV, vFulp)
+GO(glViewportIndexedfNV, vFuffff)
+GO(glViewportIndexedfvNV, vFup)
+GO(glScissorArrayvNV, vFulp)
+GO(glScissorIndexedNV, vFuiill)
+GO(glScissorIndexedvNV, vFup)
+GO(glDepthRangeArrayfvNV, vFulp)
+GO(glDepthRangeIndexedfNV, vFuff)
+GO(glGetFloati_vNV, vFiup)
+GO(glEnableiNV, vFiu)
+GO(glDisableiNV, vFiu)
+GO(glIsEnablediNV, iFiu)
+
+// GL_OVR_multiview_multisampled_render_to_texture
+GO(glFramebufferTextureMultisampleMultiviewOVR, vFiiuilil)
+
+// GL_QCOM_alpha_test
+GO(glAlphaFuncQCOM, vFif)
+
+// GL_QCOM_driver_control
+GO(glGetDriverControlsQCOM, vFplp)
+GO(glGetDriverControlStringQCOM, vFulpp)
+GO(glEnableDriverControlQCOM, vFu)
+GO(glDisableDriverControlQCOM, vFu)
+
+// GL_QCOM_extended_get
+GO(glExtGetTexturesQCOM, vFpip)
+GO(glExtGetBuffersQCOM, vFpip)
+GO(glExtGetRenderbuffersQCOM, vFpip)
+GO(glExtGetFramebuffersQCOM, vFpip)
+GO(glExtGetTexLevelParameterivQCOM, vFuiiip)
+GO(glExtTexObjectStateOverrideiQCOM, vFiii)
+GO(glExtGetTexSubImageQCOM, vFiiiiillliip)
+GO(glExtGetBufferPointervQCOM, vFip)
+
+// GL_QCOM_extended_get2
+GO(glExtGetShadersQCOM, vFpip)
+GO(glExtGetProgramsQCOM, vFpip)
+GO(glExtIsProgramBinaryQCOM, iFu)
+GO(glExtGetProgramBinarySourceQCOM, vFuipp)
+
+// GL_QCOM_framebuffer_foveated
+GO(glFramebufferFoveationConfigQCOM, vFuuuup)
+GO(glFramebufferFoveationParametersQCOM, vFuuufffff)
+
+// GL_QCOM_shader_framebuffer_fetch_noncoherent
+GO(glFramebufferFetchBarrierQCOM, vFv)
+
+// GL_QCOM_tiled_rendering
+GO(glStartTilingQCOM, vFuuuuu)
+GO(glEndTilingQCOM, vFu)
+
+// GLES fixed point
+GO(glAlphaFuncx, vFii)
+GO(glClearColorx, vFiiii)
+GO(glClearDepthx, vFi)
+GO(glClipPlanex, vFip)
+GO(glColor4x, vFiiii)
+GO(glDepthRangex, vFii)
+GO(glFogx, vFii)
+GO(glFogxv, vFip)
+GO(glFrustumx, vFiiiiii)
+GO(glGetClipPlanex, vFip)
+GO(glGetFixedv, vFip)
+GO(glGetTexEnvxv, vFiip)
+GO(glGetTexParameterxv, vFiip)
+GO(glLightModelx, vFii)
+GO(glLightModelxv, vFip)
+GO(glLightx, vFiii)
+GO(glLightxv, vFiip)
+GO(glLineWidthx, vFi)
+GO(glLoadMatrixx, vFp)
+GO(glMaterialx, vFiii)
+GO(glMaterialxv, vFiip)
+GO(glMultMatrixx, vFp)
+GO(glMultiTexCoord4x, vFiiiii)
+GO(glNormal3x, vFiiii)
+GO(glOrthox, vFiiiiii)
+GO(glPointParameterxv, vFip)
+GO(glPointSizex, vFi)
+GO(glPolygonOffsetx, vFii)
+GO(glRotatex, vFiiii)
+GO(glScalex, vFiii)
+GO(glTexEnvx, vFiii)
+GO(glTexEnvxv, vFiip)
+GO(glTexParameterx, vFiii)
+GO(glTexParameterxv, vFiip)
+GO(glTranslatex, vFiii)
+GO(glAccumx, vFii)
+GO(glBitmapx, vFlliiiip)
+GO(glBlendColorx, vFiiii)
+GO(glClearAccumx, vFiiii)
+GO(glColor3x, vFiii)
+GO(glColor3xv, vFp)
+GO(glColor4xv, vFp)
+GO(glConvolutionParameterx, vFiii)
+GO(glConvolutionParameterxv, vFiip)
+GO(glEvalCoord1x, vFi)
+GO(glEvalCoord1xv, vFp)
+GO(glEvalCoord2x, vFii)
+GO(glEvalCoord2xv, vFp)
+GO(glFeedbackBufferx, vFlip)
+GO(glGetConvolutionParameterxv, vFiip)
+GO(glGetHistogramParameterxv, vFiip)
+GO(glGetLightx, vFiip)
+GO(glGetMapxv, vFiip)
+GO(glGetMaterialx, vFiii)
+GO(glGetTexGenxv, vFiip)
+GO(glGetTexLevelParameterxv, vFiiip)
+GO(glIndexx, vFi)
+GO(glIndexxv, vFp)
+GO(glLoadTransposeMatrixx, vFp)
+GO(glMap1x, vFiiiiii)
+GO(glMap2x, vFiiiiiiiiii)
+GO(glMapGrid1x, vFiii)
+GO(glMapGrid2x, vFiiiii)
+GO(glMultTransposeMatrixx, vFp)
+GO(glMultiTexCoord1x, vFii)
+GO(glMultiTexCoord1xv, vFip)
+GO(glMultiTexCoord2x, vFiii)
+GO(glMultiTexCoord2xv, vFip)
+GO(glMultiTexCoord3x, vFiiii)
+GO(glMultiTexCoord3xv, vFip)
+GO(glMultiTexCoord4xv, vFip)
+GO(glNormal3xv, vFp)
+GO(glPassThroughx, vFi)
+GO(glPixelM, vFiip)
+GO(glPixelSto, vFii)
+GO(glPixelTransferx, vFii)
+GO(glPixelZoomx, vFii)
+GO(glPrioritizeTexturesx, vFlpp)
+GO(glRasterPos2x, vFii)
+GO(glRasterPos2xv, vFp)
+GO(glRasterPos3x, vFiii)
+GO(glRasterPos3xv, vFp)
+GO(glRasterPos4x, vFiiii)
+GO(glRasterPos4xv, vFp)
+GO(glRectx, vFiiii)
+GO(glRectxv, vFpp)
+GO(glTexCoord1x, vFi)
+GO(glTexCoord1xv, vFp)
+GO(glTexCoord2x, vFii)
+GO(glTexCoord2xv, vFp)
+GO(glTexCoord3x, vFiii)
+GO(glTexCoord3xv, vFp)
+GO(glTexCoord4x, vFiiii)
+GO(glTexCoord4xv, vFp)
+GO(glTexGenx, vFiii)
+GO(glTexGenxv, vFiip)
+GO(glVertex2x, vFi)
+GO(glVertex2xv, vFp)
+GO(glVertex3x, vFii)
+GO(glVertex3xv, vFp)
+GO(glVertex4x, vFiii)
+GO(glVertex4xv, vFp)
+
+// GL_OES_point_size
+GO(glPointSizePointerOES, vFilp)
+
+// GL_REGAL_error_string
+GO(glErrorStringREGAL, pFi)
+
+// GL_REGAL_extension_query
+GO(glGetExtensionREGAL, iFp)
+GO(glIsSupportedREGAL, iFp)
+
+//glLogMessageCallbackREGAL
+//glGetProcAddressREGAL
+
+// GL_SGIS_multitexture
+GO(glInterleavedTextureCoordSetsSGIS, vFi)
+GO(glSelectTextureCoordSetSGIS, vFi)
+GO(glSelectTextureSGIS, vFi)
+GO(glSelectTextureTransformSGIS, vFi)
+
+// GL_SGIS_shared_multisample
+GO(glMultisampleSubRectPosSGIS, vFii)
+
+// GL_SGIX_datapipe
+GO(glAddressSpace, vFiu)
+GO(glDataPipe, iFi)
+
+// GL_SGIX_fog_layers
+GO(glFogLayersSGIX, vFlp)
+GO(glGetFogLayersSGIX, vFp)
+
+// GL_SGIX_fog_texture
+GO(glTextureFogSGIX, vFu)
+
+// GL_ANGLE_request_extension
+GO(glDisableExtensionANGLE, vFp)
+GO(glRequestExtensionANGLE, vFp)
+
+// GL_KHR_debug
+GO(glDebugMessageControlKHR, vFiiilpi)
+GO(glDebugMessageInsertKHR, vFiiuilp)
+GOM(glDebugMessageCallbackKHR, vFEpp)
+GO(glGetDebugMessageLogKHR, uFulpppppp)
+GO(glPushDebugGroupKHR, vFiulp)
+GO(glPopDebugGroupKHR, vFv)
+GO(glObjectLabelKHR, vFiulp)
+GO(glGetObjectLabelKHR, vFiulpp)
+GO(glObjectPtrLabelKHR, vFplp)
+GO(glGetObjectPtrLabelKHR, vFplpp)
+GO(glGetPointervKHR, vFip)

src/wrapped/wrappedlibx11_private.h

@@ -307,7 +307,7 @@ GO(_XEatDataWords, vFpu)
 //GO(XEHeadOfExtensionList
 GO(XEmptyRegion, iFp)
 //GO(XEnableAccessControl
-// _XEnq
+GO(_XEnq, vFpp)
 GO(XEqualRegion, iFpp)
 // _XError
 DATAB(_XErrorFunction, 4)

src/wrapped/wrappedsdl2_private.h

@@ -516,6 +516,7 @@ GO(SDL_RenderSetViewport, iFpp)
 GO(SDL_RenderTargetSupported, iFp)
 GO(SDL_ReportAssertion, uFpppi)
 GO(SDL_ResetAssertionReport, vFv)
+GO(SDL_ResetKeyboard, vFv)
 GO(SDL_RestoreWindow, vFp)
 GOM(SDL_RWFromConstMem, pFEpi)
 GOM(SDL_RWFromFP, pFEpi)

src/wrapped/wrappedvulkan.c

@@ -521,6 +521,14 @@ DESTROY64(vkDestroySamplerYcbcrConversionKHR)
 
 DESTROY64(vkDestroyValidationCacheEXT)
 
+CREATE(vkCreatePrivateDataSlot)
+CREATE(vkCreatePrivateDataSlotEXT)
+DESTROY64(vkDestroyPrivateDataSlot)
+DESTROY64(vkDestroyPrivateDataSlotEXT)
+
+CREATE(vkCreateOpticalFlowSessionNV)
+DESTROY64(vkDestroyOpticalFlowSessionNV)
+
 EXPORT void my_vkGetPhysicalDeviceProperties(x86emu_t* emu, void* device, void* pProps)
 {
     static const char* desc = 
@@ -562,7 +570,7 @@ EXPORT int my_vkGetDisplayPlaneCapabilitiesKHR(x86emu_t* emu, void* device, uint
 {
     static const char* desc = "iuuuuuuuuuuuuuuuu";
 
-    void* aligned = vkalignStruct(pCap, desc, 0);
+    void* aligned = vkalignStruct(pCap, desc, 1);
     int ret = my->vkGetDisplayPlaneCapabilitiesKHR(device, mode, index, aligned);
     vkunalignStruct(aligned, desc, 0);
     return ret;
@@ -590,7 +598,7 @@ EXPORT void my_vkGetPhysicalDeviceMemoryProperties(x86emu_t* emu, void* device,
     "u" //uint32_t        memoryHeapCount;
     "UiUiUiUiUiUiUiUiUiUiUiUiUiUiUiUi"; //VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS]; //16
 
-    void* aligned = vkalignStruct(pProps, desc, 0);
+    void* aligned = vkalignStruct(pProps, desc, 1);
     my->vkGetPhysicalDeviceMemoryProperties(device, aligned);
     vkunalignStruct(aligned, desc, 0);
 }
@@ -645,21 +653,8 @@ EXPORT int my_vkGetBufferMemoryRequirements2(x86emu_t* emu, void* device, void*
 {
     static const char* desc = "uPSUUu";
     void* m = vkalignStruct(pMemoryRequirement, desc, 1);
-printf_log(LOG_INFO, "\nwill call vkGetBufferMemoryRequirements2 with %p, converted from %p (struct size=%d)\n", m, pMemoryRequirement, vkalignSize(desc));
-printf_log(LOG_INFO, "pMemoryRequirement is\n");
-for(int i=0; i<8; ++i)
-printf_log(LOG_INFO, "%i: %08X\n", i, ((uint32_t*)pMemoryRequirement)[i]);
-printf_log(LOG_INFO, "-------------\nconverted it is\n");
-for(int i=0; i<9; ++i)
-printf_log(LOG_INFO, "%i: %08X\n", i, ((uint32_t*)m)[i]);
     int ret = my->vkGetBufferMemoryRequirements2(device, pInfo, m);
-printf_log(LOG_INFO, "-------------\nafter the call it is\n");
-for(int i=0; i<9; ++i)
-printf_log(LOG_INFO, "%i: %08X\n", i, ((uint32_t*)m)[i]);
     vkunalignStruct(m, desc, 1);
-printf_log(LOG_INFO, "-------------\npMemoryRequirement now is\n");
-for(int i=0; i<8; ++i)
-printf_log(LOG_INFO, "%i: %08X\n", i, ((uint32_t*)pMemoryRequirement)[i]);
     return ret;
 }
 EXPORT int my_vkGetBufferMemoryRequirements2KHR(x86emu_t* emu, void* device, void* pInfo, void* pMemoryRequirement) 
@@ -692,7 +687,7 @@ EXPORT void my_vkGetPhysicalDeviceProperties2(x86emu_t* emu, void* device, void*
     static const char* desc = "uP"
         "uuuuiYB"
         "SuuuuuuuuuuuUUuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuffuuuffuLUUUiuiuffuuuuiiiiuiiiiiuifuuuuffffffiiUUU"
-        "Siiiii";
+        "iiiii";
     void* m = vkalignStruct(pProp, desc, 1);
     my->vkGetPhysicalDeviceProperties2(device, m);
     vkunalignStruct(m, desc, 1);
@@ -703,7 +698,7 @@ __attribute__((alias("my_vkGetPhysicalDeviceProperties2")));
 
 EXPORT int my_vkGetPhysicalDeviceSurfaceCapabilities2EXT(x86emu_t* emu, void* device, uint64_t surface, void* pSurfaceCapabilities)
 {
-    static const char* desc = "uPuuSuuSuuSuuuiiiii";
+    static const char* desc = "uPuuuuuuuuuiiiii";
     void* m = vkalignStruct(pSurfaceCapabilities, desc, 1);
     int ret = my->vkGetPhysicalDeviceSurfaceCapabilities2EXT(device, surface, m);
     vkunalignStruct(m, desc, 1);
@@ -712,9 +707,38 @@ EXPORT int my_vkGetPhysicalDeviceSurfaceCapabilities2EXT(x86emu_t* emu, void* de
 
 EXPORT int my_vkGetPhysicalDeviceSurfaceCapabilities2KHR(x86emu_t* emu, void* device, void* pInfo, void* pSurfaceCapabilities) 
 {
-    static const char* desc = "uPSuuSuuSuuSuuuiiii";
+    static const char* desc = "uPuuuuuuuuuiiii";
     void* m = vkalignStruct(pSurfaceCapabilities, desc, 1);
     int ret = my->vkGetPhysicalDeviceSurfaceCapabilities2KHR(device, pInfo, m);
     vkunalignStruct(m, desc, 1);
     return ret;
 }
+
+EXPORT void my_vkGetDeviceImageSparseMemoryRequirements(x86emu_t* emu, void* device, void* pInfo, uint32_t* count, void* pSparseMemoryRequirements)
+{
+    static const char* desc = "uPiuuuiuUUU";
+    void* m = vkalignStruct(pSparseMemoryRequirements, desc, *count);
+    my->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, count, m);
+    vkunalignStruct(m, desc, *count);   // bad things will happens if *count is changed while pSparseMemoryRequirements is not NULL
+}
+EXPORT void vkGetDeviceImageSparseMemoryRequirementsKHR(x86emu_t* emu, void* device, void* pInfo, uint32_t* count, void* pSparseMemoryRequirements)
+__attribute__((alias("my_vkGetDeviceImageSparseMemoryRequirements")));
+
+EXPORT int my_vkQueueSubmit2(x86emu_t* emu, void* queue, uint32_t count, void* pSubmits, uint64_t fence)
+{
+    static const char* desc = "uPiuQuQuQ";
+    void* m = vkalignStruct(pSubmits, desc, count);
+    int ret = my->vkQueueSubmit2(queue, count, m, fence);
+    vkunalignStruct(m, desc, count);
+    return ret;
+}
+EXPORT int my_vkQueueSubmit2EXT(x86emu_t* emu, void* queue, uint32_t count, void* pSubmits, uint64_t fence)
+__attribute__((alias("my_vkQueueSubmit2")));
+
+EXPORT int my_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(x86emu_t* emu, void* device, void* pInfo, uint32_t* count, void* pImageFormatProperties)
+{
+    static const char* desc = "uPiuuuiuUUU";
+    void* m = vkalignStruct(pImageFormatProperties, desc, *count);
+    my->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(device, pInfo, count, m);
+    vkunalignStruct(m, desc, *count);   // bad things will happens if *count is changed while pSparseMemoryRequirements is not NULL
+}

src/wrapped/wrappedvulkan_private.h

@@ -220,12 +220,44 @@ GO(vkSignalSemaphore, iFpP)
 GO(vkWaitSemaphores, iFpPU)
 
 // VK_VERSION_1_3
+GO(vkCmdBeginRendering, vFpP)
+GO(vkCmdEndRendering, vFp)
 GO(vkCmdBlitImage2, vFpP)
 GO(vkCmdCopyBuffer2, vFpP)
 GO(vkCmdCopyBufferToImage2, vFpP)
 GO(vkCmdCopyImage2, vFpP)
 GO(vkCmdCopyImageToBuffer2, vFpP)
 GO(vkCmdResolveImage2, vFpP)
+GO(vkCmdSetDepthBiasEnable, vFpi)
+GO(vkCmdSetLogicOp, vFpi)
+GO(vkCmdSetPatchControlPoints, vFpu)
+GO(vkCmdSetPrimitiveRestartEnable, vFpi)
+GO(vkCmdSetRasterizerDiscardEnable, vFpi)
+GOM(vkCreatePrivateDataSlot, iFEpPpp)
+GOM(vkDestroyPrivateDataSlot, vFEpUp)
+GO(vkGetPrivateData, vFpiUUp)
+GO(vkSetPrivateData, iFpiUUU)
+GO(vkGetDeviceBufferMemoryRequirements, vFpPP)
+GO(vkGetDeviceImageMemoryRequirements, vFpPP)
+GOM(vkGetDeviceImageSparseMemoryRequirements, vFEpPpp)
+GO(vkCmdPipelineBarrier2, vFpP)
+GO(vkCmdResetEvent2, vFpUU)
+GO(vkCmdSetEvent2, vFpUP)
+GO(vkCmdWaitEvents2, vFpupP)
+GO(vkCmdWriteTimestamp2, vFpUUu)
+GOM(vkQueueSubmit2, iFEpupU)
+GO(vkCmdBindVertexBuffers2, vFpuupppp)
+GO(vkCmdSetCullMode, vFpu)
+GO(vkCmdSetDepthBoundsTestEnable, vFpu)
+GO(vkCmdSetDepthCompareOp, vFpu)
+GO(vkCmdSetDepthTestEnable, vFpu)
+GO(vkCmdSetDepthWriteEnable, vFpu)
+GO(vkCmdSetFrontFace, vFpu)
+GO(vkCmdSetPrimitiveTopology, vFpi)
+GO(vkCmdSetScissorWithCount, vFpup)
+GO(vkCmdSetStencilOp, vFpuiiii)
+GO(vkCmdSetStencilTestEnable, vFpu)
+GO(vkCmdSetViewportWithCount, vFpup)
 
 // VK_EXT_debug_report
 GOM(vkCreateDebugReportCallbackEXT, iFEpppp)
@@ -436,20 +468,6 @@ GO(vkCmdEndRenderPass2KHR, vFpP)
 GO(vkCmdNextSubpass2KHR, vFpPP)
 GOM(vkCreateRenderPass2KHR, iFEpPpp)
 
-// VK_EXT_extended_dynamic_state
-GO(vkCmdBindVertexBuffers2EXT, vFpuupppp)
-GO(vkCmdSetCullModeEXT, vFpu)
-GO(vkCmdSetDepthBoundsTestEnableEXT, vFpu)
-GO(vkCmdSetDepthCompareOpEXT, vFpu)
-GO(vkCmdSetDepthTestEnableEXT, vFpu)
-GO(vkCmdSetDepthWriteEnableEXT, vFpu)
-GO(vkCmdSetFrontFaceEXT, vFpu)
-GO(vkCmdSetPrimitiveTopologyEXT, vFpi)
-GO(vkCmdSetScissorWithCountEXT, vFup)
-GO(vkCmdSetStencilOpEXT, vFpuiiii)
-GO(vkCmdSetStencilTestEnableEXT, vFpu)
-GO(vkCmdSetViewportWithCountEXT, vFpup)
-
 // VK_KHR_draw_indirect_count
 GO(vkCmdDrawIndexedIndirectCountKHR, vFpUUUUuu)
 GO(vkCmdDrawIndirectCountKHR, vFpUUUUuu)
@@ -537,3 +555,58 @@ GO(vkGetDeviceMemoryOpaqueCaptureAddressKHR, UFpp)
 
 // VK_EXT_buffer_device_address
 GO(vkGetBufferDeviceAddressEXT, UFpp)
+
+// VK_KHR_dynamic_rendering
+GO(vkCmdBeginRenderingKHR, vFpP)
+GO(vkCmdEndRenderingKHR, vFp)
+
+// VK_EXT_extended_dynamic_state2
+GO(vkCmdSetDepthBiasEnableEXT, vFpi)
+GO(vkCmdSetLogicOpEXT, vFpi)
+GO(vkCmdSetPatchControlPointsEXT, vFpu)
+GO(vkCmdSetPrimitiveRestartEnableEXT, vFpi)
+GO(vkCmdSetRasterizerDiscardEnableEXT, vFpi)
+
+// VK_EXT_private_data
+GOM(vkCreatePrivateDataSlotEXT, iFEpPpp)
+GOM(vkDestroyPrivateDataSlotEXT, vFEpUp)
+GO(vkGetPrivateDataEXT, vFpiUUp)
+GO(vkSetPrivateDataEXT, iFpiUUU)
+
+// VK_KHR_maintenance4
+GO(vkGetDeviceBufferMemoryRequirementsKHR, vFpPP)
+GO(vkGetDeviceImageMemoryRequirementsKHR, vFpPP)
+GOM(vkGetDeviceImageSparseMemoryRequirementsKHR, vFEpPpp)
+
+// VK_KHR_synchronization2
+GO(vkCmdPipelineBarrier2KHR, vFpP)
+GO(vkCmdResetEvent2KHR, vFpUU)
+GO(vkCmdSetEvent2KHR, vFpUP)
+GO(vkCmdWaitEvents2KHR, vFpupP)
+GO(vkCmdWriteTimestamp2KHR, vFpUUu)
+GOM(vkQueueSubmit2KHR, iFEpupU)
+
+// VK_EXT_extended_dynamic_state
+GO(vkCmdBindVertexBuffers2EXT, vFpuupppp)
+GO(vkCmdSetCullModeEXT, vFpu)
+GO(vkCmdSetDepthBoundsTestEnableEXT, vFpu)
+GO(vkCmdSetDepthCompareOpEXT, vFpu)
+GO(vkCmdSetDepthTestEnableEXT, vFpu)
+GO(vkCmdSetDepthWriteEnableEXT, vFpu)
+GO(vkCmdSetFrontFaceEXT, vFpu)
+GO(vkCmdSetPrimitiveTopologyEXT, vFpi)
+GO(vkCmdSetScissorWithCountEXT, vFpup)
+GO(vkCmdSetStencilOpEXT, vFpuiiii)
+GO(vkCmdSetStencilTestEnableEXT, vFpu)
+GO(vkCmdSetViewportWithCountEXT, vFpup)
+
+// VK_EXT_shader_module_identifier
+GO(vkGetShaderModuleCreateInfoIdentifierEXT, vFpPP)
+GO(vkGetShaderModuleIdentifierEXT, vFpUp)
+
+// VK_NV_optical_flow
+GO(vkBindOpticalFlowSessionImageNV, iFpUiUi)
+GO(vkCmdOpticalFlowExecuteNV, vFpUP)
+GOM(vkCreateOpticalFlowSessionNV, iFEpPpp)
+GOM(vkDestroyOpticalFlowSessionNV, vFEpUp)
+GOM(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, iFEpPpp)