Reworked vulkan structure wrapping

rebuild_wrappers.py

@@ -1058,8 +1058,8 @@ def generate_files(root: str, files: Iterable[str], ver: str, gbls: SortedGlobal
 		    memcpy(value+4, v->data, 2*sizeof(double));
 		{rbr}
 		
-		void* VulkanFromx86(void* src, void** save);
-		void VulkanTox86(void* src, void* save);
+		void* VulkanFromx86(void* src);
+		void VulkanTox86(void* src);
 		
 		#define ST0val ST0.d
 		
@@ -1259,7 +1259,7 @@ def generate_files(root: str, files: Iterable[str], ver: str, gbls: SortedGlobal
 			delta = 4
 			for c in args:
 				if c == 'P':
-					f.write("void* save{d} = NULL; void *arg{d} = VulkanFromx86(*(void**)(R_ESP + {d}), &save{d}); ".format(d=delta))
+					f.write("void *arg{d} = VulkanFromx86(*(void**)(R_ESP + {d})); ".format(d=delta))
 				if c == 'G':
 					f.write("my_GValue_t arg{d}; alignGValue(&arg{d}, *(void**)(R_ESP + {d})); ".format(d=delta))
 				delta = delta + deltas[FileSpec.values.index(c)]
@@ -1267,7 +1267,7 @@ def generate_files(root: str, files: Iterable[str], ver: str, gbls: SortedGlobal
 			delta = 4
 			for c in args:
 				if c == 'P':
-					f.write("VulkanTox86(arg{d}, save{d}); ".format(d=delta))
+					f.write("VulkanTox86(arg{d}); ".format(d=delta))
 				if c == 'G':
 					f.write("unalignGValue(*(void**)(R_ESP + {d}), &arg{d}); ".format(d=delta))
 				delta = delta + deltas[FileSpec.values.index(c)]

src/libtools/vkalign.h

@@ -1,9 +1,10 @@
 #include <stdint.h>
 
-void* VulkanFromx86(void* src, void** save);
-void VulkanTox86(void* src, void* save);
+void* VulkanFromx86(void* src);
+void* VulkanTox86(void* src);
 
 int vkalignSize(const char* desc);
 void* vkalignStruct(void* src, const char* desc, int cnt);
-void vkunalignStruct(void* dst, void* src, const char* desc, int cnt);
-void* vkStructUnalign(void* src, const char* desc, int cnt);
+void* vkunalignStruct(void* src, const char* desc, int cnt);
+void* vkStructUnalign(void* src, const char* desc, int cnt);
+void* vkunalignNewStruct(void* dst, void* src, const char* desc, int cnt);

src/wrapped/generated/functions_list.txt

@@ -322,7 +322,6 @@
 #() vFpif
 #() vFpid
 #() vFpip
-#() vFpiP
 #() vFpui
 #() vFpuI
 #() vFpuu
@@ -429,11 +428,11 @@
 #() iFppL
 #() iFppp
 #() iFppV
+#() iFppP
 #() iFppG
 #() iFpOu
 #() iFpPU
 #() iFpPp
-#() iFpPP
 #() iFpGG
 #() iFSpi
 #() iFSpL
@@ -585,6 +584,7 @@
 #() vFEpUp
 #() vFEppp
 #() vFEppV
+#() vFEpPp
 #() vFiiii
 #() vFiiip
 #() vFiipp
@@ -728,6 +728,7 @@
 #() iFEppV
 #() iFEpOu
 #() iFEpOV
+#() iFEpPp
 #() iFEPpp
 #() iFwwww
 #() iFwppp
@@ -796,7 +797,6 @@
 #() iFpupu
 #() iFpupp
 #() iFpupV
-#() iFpupP
 #() iFpuPU
 #() iFpUup
 #() iFpUUU
@@ -4403,6 +4403,8 @@ wrappedvulkan:
   - vkDestroyInstance
   - vkGetPhysicalDeviceMemoryProperties
   - vkGetPhysicalDeviceProperties
+  - vkGetPhysicalDeviceProperties2
+  - vkGetPhysicalDeviceProperties2KHR
 - pFpp:
   - vkGetDeviceProcAddr
   - vkGetInstanceProcAddr
@@ -4433,11 +4435,21 @@ wrappedvulkan:
   - vkDestroyValidationCacheEXT
 - vFppp:
   - vkDestroyDebugUtilsMessengerEXT
+- vFpPp:
+  - vkGetImageMemoryRequirements2
+  - vkGetImageMemoryRequirements2KHR
 - iFpUp:
   - vkFreeMemory
+  - vkGetPhysicalDeviceSurfaceCapabilities2EXT
 - iFppp:
   - vkDestroyDebugReportCallbackEXT
   - vkGetPhysicalDeviceDisplayPropertiesKHR
+- iFpPp:
+  - vkGetBufferMemoryRequirements2
+  - vkGetBufferMemoryRequirements2KHR
+  - vkGetPhysicalDeviceImageFormatProperties2
+  - vkGetPhysicalDeviceImageFormatProperties2KHR
+  - vkGetPhysicalDeviceSurfaceCapabilities2KHR
 - iFPpp:
   - vkCreateInstance
 - iFpUup:

src/wrapped/generated/wrappedvulkantypes.h

@@ -15,8 +15,10 @@ typedef void (*vFpp_t)(void*, void*);
 typedef void* (*pFpp_t)(void*, void*);
 typedef void (*vFpUp_t)(void*, uint64_t, void*);
 typedef void (*vFppp_t)(void*, void*, void*);
+typedef void (*vFpPp_t)(void*, void*, void*);
 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 int32_t (*iFpUup_t)(void*, uint64_t, uint32_t, void*);
 typedef int32_t (*iFpUpP_t)(void*, uint64_t, void*, void*);
@@ -34,6 +36,8 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkDestroyInstance, vFpp_t) \
 	GO(vkGetPhysicalDeviceMemoryProperties, vFpp_t) \
 	GO(vkGetPhysicalDeviceProperties, vFpp_t) \
+	GO(vkGetPhysicalDeviceProperties2, vFpp_t) \
+	GO(vkGetPhysicalDeviceProperties2KHR, vFpp_t) \
 	GO(vkGetDeviceProcAddr, pFpp_t) \
 	GO(vkGetInstanceProcAddr, pFpp_t) \
 	GO(vkDestroyBuffer, vFpUp_t) \
@@ -61,9 +65,17 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkDestroySwapchainKHR, vFpUp_t) \
 	GO(vkDestroyValidationCacheEXT, vFpUp_t) \
 	GO(vkDestroyDebugUtilsMessengerEXT, vFppp_t) \
+	GO(vkGetImageMemoryRequirements2, vFpPp_t) \
+	GO(vkGetImageMemoryRequirements2KHR, vFpPp_t) \
 	GO(vkFreeMemory, iFpUp_t) \
+	GO(vkGetPhysicalDeviceSurfaceCapabilities2EXT, iFpUp_t) \
 	GO(vkDestroyDebugReportCallbackEXT, iFppp_t) \
 	GO(vkGetPhysicalDeviceDisplayPropertiesKHR, iFppp_t) \
+	GO(vkGetBufferMemoryRequirements2, iFpPp_t) \
+	GO(vkGetBufferMemoryRequirements2KHR, iFpPp_t) \
+	GO(vkGetPhysicalDeviceImageFormatProperties2, iFpPp_t) \
+	GO(vkGetPhysicalDeviceImageFormatProperties2KHR, iFpPp_t) \
+	GO(vkGetPhysicalDeviceSurfaceCapabilities2KHR, iFpPp_t) \
 	GO(vkCreateInstance, iFPpp_t) \
 	GO(vkGetDisplayPlaneCapabilitiesKHR, iFpUup_t) \
 	GO(vkGetPastPresentationTimingGOOGLE, iFpUpP_t) \

src/wrapped/generated/wrapper.c

@@ -63,8 +63,8 @@ static void unalignGValue(void* value, my_GValue_t* v)
     memcpy(value+4, v->data, 2*sizeof(double));
 }
 
-void* VulkanFromx86(void* src, void** save);
-void VulkanTox86(void* src, void* save);
+void* VulkanFromx86(void* src);
+void VulkanTox86(void* src);
 
 #define ST0val ST0.d
 
@@ -394,7 +394,6 @@ typedef void (*vFpiu_t)(void*, int32_t, uint32_t);
 typedef void (*vFpif_t)(void*, int32_t, float);
 typedef void (*vFpid_t)(void*, int32_t, double);
 typedef void (*vFpip_t)(void*, int32_t, void*);
-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);
@@ -501,11 +500,11 @@ typedef int32_t (*iFppl_t)(void*, void*, intptr_t);
 typedef int32_t (*iFppL_t)(void*, void*, uintptr_t);
 typedef int32_t (*iFppp_t)(void*, void*, void*);
 typedef int32_t (*iFppV_t)(void*, void*, void*);
+typedef int32_t (*iFppP_t)(void*, void*, void*);
 typedef int32_t (*iFppG_t)(void*, void*, void*);
 typedef int32_t (*iFpOu_t)(void*, int32_t, uint32_t);
 typedef int32_t (*iFpPU_t)(void*, void*, uint64_t);
 typedef int32_t (*iFpPp_t)(void*, void*, void*);
-typedef int32_t (*iFpPP_t)(void*, void*, void*);
 typedef int32_t (*iFpGG_t)(void*, void*, void*);
 typedef int32_t (*iFSpi_t)(void*, void*, int32_t);
 typedef int32_t (*iFSpL_t)(void*, void*, uintptr_t);
@@ -657,6 +656,7 @@ typedef void (*vFEpup_t)(x86emu_t*, void*, uint32_t, void*);
 typedef void (*vFEpUp_t)(x86emu_t*, void*, uint64_t, void*);
 typedef void (*vFEppp_t)(x86emu_t*, void*, void*, void*);
 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 (*vFiipp_t)(int32_t, int32_t, void*, void*);
@@ -800,6 +800,7 @@ typedef int32_t (*iFEppp_t)(x86emu_t*, void*, void*, void*);
 typedef int32_t (*iFEppV_t)(x86emu_t*, void*, void*, void*);
 typedef int32_t (*iFEpOu_t)(x86emu_t*, void*, int32_t, uint32_t);
 typedef int32_t (*iFEpOV_t)(x86emu_t*, void*, int32_t, void*);
+typedef int32_t (*iFEpPp_t)(x86emu_t*, void*, void*, void*);
 typedef int32_t (*iFEPpp_t)(x86emu_t*, void*, void*, void*);
 typedef int32_t (*iFwwww_t)(int16_t, int16_t, int16_t, int16_t);
 typedef int32_t (*iFwppp_t)(int16_t, void*, void*, void*);
@@ -868,7 +869,6 @@ typedef int32_t (*iFpupi_t)(void*, uint32_t, void*, int32_t);
 typedef int32_t (*iFpupu_t)(void*, uint32_t, void*, uint32_t);
 typedef int32_t (*iFpupp_t)(void*, uint32_t, void*, void*);
 typedef int32_t (*iFpupV_t)(void*, uint32_t, void*, void*);
-typedef int32_t (*iFpupP_t)(void*, uint32_t, 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 (*iFpUUU_t)(void*, uint64_t, uint64_t, uint64_t);
@@ -2419,7 +2419,7 @@ void vFpL(x86emu_t *emu, uintptr_t fcn) { vFpL_t fn = (vFpL_t)fcn; fn(*(void**)(
 void vFpp(x86emu_t *emu, uintptr_t fcn) { vFpp_t fn = (vFpp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); }
 void vFpV(x86emu_t *emu, uintptr_t fcn) { vFpV_t fn = (vFpV_t)fcn; fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8)); }
 void vFpS(x86emu_t *emu, uintptr_t fcn) { vFpS_t fn = (vFpS_t)fcn; fn(*(void**)(R_ESP + 4), io_convert(*(void**)(R_ESP + 8))); }
-void vFpP(x86emu_t *emu, uintptr_t fcn) { vFpP_t fn = (vFpP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8, save8); }
+void vFpP(x86emu_t *emu, uintptr_t fcn) { vFpP_t fn = (vFpP_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8); }
 void vFpG(x86emu_t *emu, uintptr_t fcn) { vFpG_t fn = (vFpG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); fn(*(void**)(R_ESP + 4), &arg8); unalignGValue(*(void**)(R_ESP + 8), &arg8); }
 void vFSi(x86emu_t *emu, uintptr_t fcn) { vFSi_t fn = (vFSi_t)fcn; fn(io_convert(*(void**)(R_ESP + 4)), *(int32_t*)(R_ESP + 8)); }
 void vFGc(x86emu_t *emu, uintptr_t fcn) { vFGc_t fn = (vFGc_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); fn(&arg4, *(int8_t*)(R_ESP + 8)); unalignGValue(*(void**)(R_ESP + 4), &arg4); }
@@ -2466,7 +2466,7 @@ void iFpL(x86emu_t *emu, uintptr_t fcn) { iFpL_t fn = (iFpL_t)fcn; R_EAX=fn(*(vo
 void iFpp(x86emu_t *emu, uintptr_t fcn) { iFpp_t fn = (iFpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); }
 void iFpV(x86emu_t *emu, uintptr_t fcn) { iFpV_t fn = (iFpV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8)); }
 void iFpO(x86emu_t *emu, uintptr_t fcn) { iFpO_t fn = (iFpO_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8))); }
-void iFpP(x86emu_t *emu, uintptr_t fcn) { iFpP_t fn = (iFpP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8, save8); }
+void iFpP(x86emu_t *emu, uintptr_t fcn) { iFpP_t fn = (iFpP_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); R_EAX=fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8); }
 void iFpG(x86emu_t *emu, uintptr_t fcn) { iFpG_t fn = (iFpG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); R_EAX=fn(*(void**)(R_ESP + 4), &arg8); unalignGValue(*(void**)(R_ESP + 8), &arg8); }
 void iFSi(x86emu_t *emu, uintptr_t fcn) { iFSi_t fn = (iFSi_t)fcn; R_EAX=fn(io_convert(*(void**)(R_ESP + 4)), *(int32_t*)(R_ESP + 8)); }
 void iFGG(x86emu_t *emu, uintptr_t fcn) { iFGG_t fn = (iFGG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); R_EAX=fn(&arg4, &arg8); unalignGValue(*(void**)(R_ESP + 4), &arg4); unalignGValue(*(void**)(R_ESP + 8), &arg8); }
@@ -2613,7 +2613,6 @@ void vFpiu(x86emu_t *emu, uintptr_t fcn) { vFpiu_t fn = (vFpiu_t)fcn; fn(*(void*
 void vFpif(x86emu_t *emu, uintptr_t fcn) { vFpif_t fn = (vFpif_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(float*)(R_ESP + 12)); }
 void vFpid(x86emu_t *emu, uintptr_t fcn) { vFpid_t fn = (vFpid_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(double*)(R_ESP + 12)); }
 void vFpip(x86emu_t *emu, uintptr_t fcn) { vFpip_t fn = (vFpip_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
-void vFpiP(x86emu_t *emu, uintptr_t fcn) { vFpiP_t fn = (vFpiP_t)fcn; void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12, save12); }
 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)); }
@@ -2636,8 +2635,8 @@ void vFppL(x86emu_t *emu, uintptr_t fcn) { vFppL_t fn = (vFppL_t)fcn; fn(*(void*
 void vFppp(x86emu_t *emu, uintptr_t fcn) { vFppp_t fn = (vFppp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFppV(x86emu_t *emu, uintptr_t fcn) { vFppV_t fn = (vFppV_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); }
 void vFppG(x86emu_t *emu, uintptr_t fcn) { vFppG_t fn = (vFppG_t)fcn; my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), &arg12); unalignGValue(*(void**)(R_ESP + 12), &arg12); }
-void vFpPp(x86emu_t *emu, uintptr_t fcn) { vFpPp_t fn = (vFpPp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8, save8); }
-void vFpPP(x86emu_t *emu, uintptr_t fcn) { vFpPP_t fn = (vFpPP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8, save8); VulkanTox86(arg12, save12); }
+void vFpPp(x86emu_t *emu, uintptr_t fcn) { vFpPp_t fn = (vFpPp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8); }
+void vFpPP(x86emu_t *emu, uintptr_t fcn) { vFpPP_t fn = (vFpPP_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8); VulkanTox86(arg12); }
 void iFEiw(x86emu_t *emu, uintptr_t fcn) { iFEiw_t fn = (iFEiw_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(int16_t*)(R_ESP + 8)); }
 void iFEip(x86emu_t *emu, uintptr_t fcn) { iFEip_t fn = (iFEip_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); }
 void iFEWW(x86emu_t *emu, uintptr_t fcn) { iFEWW_t fn = (iFEWW_t)fcn; R_EAX=fn(emu, *(uint16_t*)(R_ESP + 4), *(uint16_t*)(R_ESP + 8)); }
@@ -2695,11 +2694,11 @@ void iFpuL(x86emu_t *emu, uintptr_t fcn) { iFpuL_t fn = (iFpuL_t)fcn; R_EAX=fn(*
 void iFpup(x86emu_t *emu, uintptr_t fcn) { iFpup_t fn = (iFpup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void iFpuV(x86emu_t *emu, uintptr_t fcn) { iFpuV_t fn = (iFpuV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), (void*)(R_ESP + 12)); }
 void iFpu2(x86emu_t *emu, uintptr_t fcn) { iFpu2_t fn = (iFpu2_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), (_2uint_struct_t){*(uintptr_t*)(R_ESP + 12),*(uintptr_t*)(R_ESP + 12 + 4)}); }
-void iFpuP(x86emu_t *emu, uintptr_t fcn) { iFpuP_t fn = (iFpuP_t)fcn; void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12, save12); }
+void iFpuP(x86emu_t *emu, uintptr_t fcn) { iFpuP_t fn = (iFpuP_t)fcn; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12); }
 void iFpUi(x86emu_t *emu, uintptr_t fcn) { iFpUi_t fn = (iFpUi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16)); }
 void iFpUU(x86emu_t *emu, uintptr_t fcn) { iFpUU_t fn = (iFpUU_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16)); }
 void iFpUp(x86emu_t *emu, uintptr_t fcn) { iFpUp_t fn = (iFpUp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16)); }
-void iFpUP(x86emu_t *emu, uintptr_t fcn) { iFpUP_t fn = (iFpUP_t)fcn; void* save16 = NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16); VulkanTox86(arg16, save16); }
+void iFpUP(x86emu_t *emu, uintptr_t fcn) { iFpUP_t fn = (iFpUP_t)fcn; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16)); R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16); VulkanTox86(arg16); }
 void iFpfu(x86emu_t *emu, uintptr_t fcn) { iFpfu_t fn = (iFpfu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(float*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); }
 void iFpff(x86emu_t *emu, uintptr_t fcn) { iFpff_t fn = (iFpff_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12)); }
 void iFpdd(x86emu_t *emu, uintptr_t fcn) { iFpdd_t fn = (iFpdd_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16)); }
@@ -2720,11 +2719,11 @@ void iFppl(x86emu_t *emu, uintptr_t fcn) { iFppl_t fn = (iFppl_t)fcn; R_EAX=fn(*
 void iFppL(x86emu_t *emu, uintptr_t fcn) { iFppL_t fn = (iFppL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); }
 void iFppp(x86emu_t *emu, uintptr_t fcn) { iFppp_t fn = (iFppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void iFppV(x86emu_t *emu, uintptr_t fcn) { iFppV_t fn = (iFppV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); }
+void iFppP(x86emu_t *emu, uintptr_t fcn) { iFppP_t fn = (iFppP_t)fcn; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), arg12); VulkanTox86(arg12); }
 void iFppG(x86emu_t *emu, uintptr_t fcn) { iFppG_t fn = (iFppG_t)fcn; my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), &arg12); unalignGValue(*(void**)(R_ESP + 12), &arg12); }
 void iFpOu(x86emu_t *emu, uintptr_t fcn) { iFpOu_t fn = (iFpOu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8)), *(uint32_t*)(R_ESP + 12)); }
-void iFpPU(x86emu_t *emu, uintptr_t fcn) { iFpPU_t fn = (iFpPU_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(uint64_t*)(R_ESP + 12)); VulkanTox86(arg8, save8); }
-void iFpPp(x86emu_t *emu, uintptr_t fcn) { iFpPp_t fn = (iFpPp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8, save8); }
-void iFpPP(x86emu_t *emu, uintptr_t fcn) { iFpPP_t fn = (iFpPP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8, save8); VulkanTox86(arg12, save12); }
+void iFpPU(x86emu_t *emu, uintptr_t fcn) { iFpPU_t fn = (iFpPU_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(uint64_t*)(R_ESP + 12)); VulkanTox86(arg8); }
+void iFpPp(x86emu_t *emu, uintptr_t fcn) { iFpPp_t fn = (iFpPp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8); }
 void iFpGG(x86emu_t *emu, uintptr_t fcn) { iFpGG_t fn = (iFpGG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), &arg8, &arg12); unalignGValue(*(void**)(R_ESP + 8), &arg8); unalignGValue(*(void**)(R_ESP + 12), &arg12); }
 void iFSpi(x86emu_t *emu, uintptr_t fcn) { iFSpi_t fn = (iFSpi_t)fcn; R_EAX=fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); }
 void iFSpL(x86emu_t *emu, uintptr_t fcn) { iFSpL_t fn = (iFSpL_t)fcn; R_EAX=fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); }
@@ -2876,6 +2875,7 @@ void vFEpup(x86emu_t *emu, uintptr_t fcn) { vFEpup_t fn = (vFEpup_t)fcn; fn(emu,
 void vFEpUp(x86emu_t *emu, uintptr_t fcn) { vFEpUp_t fn = (vFEpUp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16)); }
 void vFEppp(x86emu_t *emu, uintptr_t fcn) { vFEppp_t fn = (vFEppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); }
 void vFEppV(x86emu_t *emu, uintptr_t fcn) { vFEppV_t fn = (vFEppV_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); }
+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 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)); }
@@ -2996,7 +2996,7 @@ void vFpppp(x86emu_t *emu, uintptr_t fcn) { vFpppp_t fn = (vFpppp_t)fcn; fn(*(vo
 void vFpppV(x86emu_t *emu, uintptr_t fcn) { vFpppV_t fn = (vFpppV_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void vFpppG(x86emu_t *emu, uintptr_t fcn) { vFpppG_t fn = (vFpppG_t)fcn; my_GValue_t arg16; alignGValue(&arg16, *(void**)(R_ESP + 16)); fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), &arg16); unalignGValue(*(void**)(R_ESP + 16), &arg16); }
 void vFppGu(x86emu_t *emu, uintptr_t fcn) { vFppGu_t fn = (vFppGu_t)fcn; my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), &arg12, *(uint32_t*)(R_ESP + 16)); unalignGValue(*(void**)(R_ESP + 12), &arg12); }
-void vFpPpp(x86emu_t *emu, uintptr_t fcn) { vFpPpp_t fn = (vFpPpp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); }
+void vFpPpp(x86emu_t *emu, uintptr_t fcn) { vFpPpp_t fn = (vFpPpp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8); }
 void vFSppi(x86emu_t *emu, uintptr_t fcn) { vFSppi_t fn = (vFSppi_t)fcn; fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void cFpiii(x86emu_t *emu, uintptr_t fcn) { cFpiii_t fn = (cFpiii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void iFEiip(x86emu_t *emu, uintptr_t fcn) { iFEiip_t fn = (iFEiip_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); }
@@ -3019,7 +3019,8 @@ void iFEppp(x86emu_t *emu, uintptr_t fcn) { iFEppp_t fn = (iFEppp_t)fcn; R_EAX=f
 void iFEppV(x86emu_t *emu, uintptr_t fcn) { iFEppV_t fn = (iFEppV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); }
 void iFEpOu(x86emu_t *emu, uintptr_t fcn) { iFEpOu_t fn = (iFEpOu_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8)), *(uint32_t*)(R_ESP + 12)); }
 void iFEpOV(x86emu_t *emu, uintptr_t fcn) { iFEpOV_t fn = (iFEpOV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8)), (void*)(R_ESP + 12)); }
-void iFEPpp(x86emu_t *emu, uintptr_t fcn) { iFEPpp_t fn = (iFEPpp_t)fcn; void* save4 = NULL; void *arg4 = VulkanFromx86(*(void**)(R_ESP + 4), &save4); R_EAX=fn(emu, arg4, *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); VulkanTox86(arg4, save4); }
+void iFEpPp(x86emu_t *emu, uintptr_t fcn) { iFEpPp_t fn = (iFEpPp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); R_EAX=fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8); }
+void iFEPpp(x86emu_t *emu, uintptr_t fcn) { iFEPpp_t fn = (iFEPpp_t)fcn; void *arg4 = VulkanFromx86(*(void**)(R_ESP + 4)); R_EAX=fn(emu, arg4, *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); VulkanTox86(arg4); }
 void iFwwww(x86emu_t *emu, uintptr_t fcn) { iFwwww_t fn = (iFwwww_t)fcn; R_EAX=fn(*(int16_t*)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16)); }
 void iFwppp(x86emu_t *emu, uintptr_t fcn) { iFwppp_t fn = (iFwppp_t)fcn; R_EAX=fn(*(int16_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void iFiiii(x86emu_t *emu, uintptr_t fcn) { iFiiii_t fn = (iFiiii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
@@ -3087,8 +3088,7 @@ void iFpupi(x86emu_t *emu, uintptr_t fcn) { iFpupi_t fn = (iFpupi_t)fcn; R_EAX=f
 void iFpupu(x86emu_t *emu, uintptr_t fcn) { iFpupu_t fn = (iFpupu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); }
 void iFpupp(x86emu_t *emu, uintptr_t fcn) { iFpupp_t fn = (iFpupp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void iFpupV(x86emu_t *emu, uintptr_t fcn) { iFpupV_t fn = (iFpupV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
-void iFpupP(x86emu_t *emu, uintptr_t fcn) { iFpupP_t fn = (iFpupP_t)fcn; void* save16 = NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), arg16); VulkanTox86(arg16, save16); }
-void iFpuPU(x86emu_t *emu, uintptr_t fcn) { iFpuPU_t fn = (iFpuPU_t)fcn; void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12, *(uint64_t*)(R_ESP + 16)); VulkanTox86(arg12, save12); }
+void iFpuPU(x86emu_t *emu, uintptr_t fcn) { iFpuPU_t fn = (iFpuPU_t)fcn; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12, *(uint64_t*)(R_ESP + 16)); VulkanTox86(arg12); }
 void iFpUup(x86emu_t *emu, uintptr_t fcn) { iFpUup_t fn = (iFpUup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFpUUU(x86emu_t *emu, uintptr_t fcn) { iFpUUU_t fn = (iFpUUU_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16), *(uint64_t*)(R_ESP + 24)); }
 void iFpUpp(x86emu_t *emu, uintptr_t fcn) { iFpUpp_t fn = (iFpUpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
@@ -3119,7 +3119,7 @@ void iFpppu(x86emu_t *emu, uintptr_t fcn) { iFpppu_t fn = (iFpppu_t)fcn; R_EAX=f
 void iFpppU(x86emu_t *emu, uintptr_t fcn) { iFpppU_t fn = (iFpppU_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint64_t*)(R_ESP + 16)); }
 void iFpppL(x86emu_t *emu, uintptr_t fcn) { iFpppL_t fn = (iFpppL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); }
 void iFpppp(x86emu_t *emu, uintptr_t fcn) { iFpppp_t fn = (iFpppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
-void iFpPpp(x86emu_t *emu, uintptr_t fcn) { iFpPpp_t fn = (iFpPpp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); }
+void iFpPpp(x86emu_t *emu, uintptr_t fcn) { iFpPpp_t fn = (iFpPpp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8); }
 void iFpGGi(x86emu_t *emu, uintptr_t fcn) { iFpGGi_t fn = (iFpGGi_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), &arg8, &arg12, *(int32_t*)(R_ESP + 16)); unalignGValue(*(void**)(R_ESP + 8), &arg8); unalignGValue(*(void**)(R_ESP + 12), &arg12); }
 void IFEpIi(x86emu_t *emu, uintptr_t fcn) { IFEpIi_t fn = (IFEpIi_t)fcn; ui64_t r; r.i=fn(emu, *(void**)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16)); R_EAX=r.d[0]; R_EDX=r.d[1]; }
 void IFpIip(x86emu_t *emu, uintptr_t fcn) { IFpIip_t fn = (IFpIip_t)fcn; ui64_t r; r.i=fn(*(void**)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); R_EAX=r.d[0]; R_EDX=r.d[1]; }
@@ -3391,7 +3391,7 @@ void iFEpipV(x86emu_t *emu, uintptr_t fcn) { iFEpipV_t fn = (iFEpipV_t)fcn; R_EA
 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)); }
-void iFEpUpP(x86emu_t *emu, uintptr_t fcn) { iFEpUpP_t fn = (iFEpUpP_t)fcn; void* save20 = NULL; void *arg20 = VulkanFromx86(*(void**)(R_ESP + 20), &save20); R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16), arg20); VulkanTox86(arg20, save20); }
+void iFEpUpP(x86emu_t *emu, uintptr_t fcn) { iFEpUpP_t fn = (iFEpUpP_t)fcn; void *arg20 = VulkanFromx86(*(void**)(R_ESP + 20)); R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16), arg20); VulkanTox86(arg20); }
 void iFEpLpp(x86emu_t *emu, uintptr_t fcn) { iFEpLpp_t fn = (iFEpLpp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void iFEpLpV(x86emu_t *emu, uintptr_t fcn) { iFEpLpV_t fn = (iFEpLpV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
 void iFEppii(x86emu_t *emu, uintptr_t fcn) { iFEppii_t fn = (iFEppii_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
@@ -3401,7 +3401,7 @@ void iFEpplp(x86emu_t *emu, uintptr_t fcn) { iFEpplp_t fn = (iFEpplp_t)fcn; R_EA
 void iFEpppi(x86emu_t *emu, uintptr_t fcn) { iFEpppi_t fn = (iFEpppi_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); }
 void iFEpppp(x86emu_t *emu, uintptr_t fcn) { iFEpppp_t fn = (iFEpppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void iFEpppV(x86emu_t *emu, uintptr_t fcn) { iFEpppV_t fn = (iFEpppV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); }
-void iFEpPpp(x86emu_t *emu, uintptr_t fcn) { iFEpPpp_t fn = (iFEpPpp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); }
+void iFEpPpp(x86emu_t *emu, uintptr_t fcn) { iFEpPpp_t fn = (iFEpPpp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); R_EAX=fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8); }
 void iFiiipu(x86emu_t *emu, uintptr_t fcn) { iFiiipu_t fn = (iFiiipu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); }
 void iFiiipp(x86emu_t *emu, uintptr_t fcn) { iFiiipp_t fn = (iFiiipp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFiiupp(x86emu_t *emu, uintptr_t fcn) { iFiiupp_t fn = (iFiiupp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
@@ -3709,7 +3709,7 @@ void iFEpippi(x86emu_t *emu, uintptr_t fcn) { iFEpippi_t fn = (iFEpippi_t)fcn; R
 void iFEpippp(x86emu_t *emu, uintptr_t fcn) { iFEpippp_t fn = (iFEpippp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFEpuuip(x86emu_t *emu, uintptr_t fcn) { iFEpuuip_t fn = (iFEpuuip_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFEpuppp(x86emu_t *emu, uintptr_t fcn) { iFEpuppp_t fn = (iFEpuppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
-void iFEpUPpp(x86emu_t *emu, uintptr_t fcn) { iFEpUPpp_t fn = (iFEpUPpp_t)fcn; void* save16 = NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16, *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); VulkanTox86(arg16, save16); }
+void iFEpUPpp(x86emu_t *emu, uintptr_t fcn) { iFEpUPpp_t fn = (iFEpUPpp_t)fcn; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16)); R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16, *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); VulkanTox86(arg16); }
 void iFEpLppp(x86emu_t *emu, uintptr_t fcn) { iFEpLppp_t fn = (iFEpLppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFEppppp(x86emu_t *emu, uintptr_t fcn) { iFEppppp_t fn = (iFEppppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); }
 void iFiiiiii(x86emu_t *emu, uintptr_t fcn) { iFiiiiii_t fn = (iFiiiiii_t)fcn; R_EAX=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)); }
@@ -4337,7 +4337,7 @@ void vFuuddiiddiip(x86emu_t *emu, uintptr_t fcn) { vFuuddiiddiip_t fn = (vFuuddi
 void vFuffffffffff(x86emu_t *emu, uintptr_t fcn) { vFuffffffffff_t fn = (vFuffffffffff_t)fcn; fn(*(uint32_t*)(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)); }
 void vFpipipiipiii(x86emu_t *emu, uintptr_t fcn) { vFpipipiipiii_t fn = (vFpipipiipiii_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); }
 void vFpipppiiiipi(x86emu_t *emu, uintptr_t fcn) { vFpipppiiiipi_t fn = (vFpipppiiiipi_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(void**)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); }
-void vFpupiiuPuPuP(x86emu_t *emu, uintptr_t fcn) { vFpupiiuPuPuP_t fn = (vFpupiiuPuPuP_t)fcn; void* save28 = NULL; void *arg28 = VulkanFromx86(*(void**)(R_ESP + 28), &save28); void* save36 = NULL; void *arg36 = VulkanFromx86(*(void**)(R_ESP + 36), &save36); void* save44 = NULL; void *arg44 = VulkanFromx86(*(void**)(R_ESP + 44), &save44); fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), arg28, *(uint32_t*)(R_ESP + 32), arg36, *(uint32_t*)(R_ESP + 40), arg44); VulkanTox86(arg28, save28); VulkanTox86(arg36, save36); VulkanTox86(arg44, save44); }
+void vFpupiiuPuPuP(x86emu_t *emu, uintptr_t fcn) { vFpupiiuPuPuP_t fn = (vFpupiiuPuPuP_t)fcn; void *arg28 = VulkanFromx86(*(void**)(R_ESP + 28)); void *arg36 = VulkanFromx86(*(void**)(R_ESP + 36)); void *arg44 = VulkanFromx86(*(void**)(R_ESP + 44)); fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), arg28, *(uint32_t*)(R_ESP + 32), arg36, *(uint32_t*)(R_ESP + 40), arg44); VulkanTox86(arg28); VulkanTox86(arg36); VulkanTox86(arg44); }
 void vFppiiiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFppiiiiiiiii_t fn = (vFppiiiiiiiii_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), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); }
 void vFppiiiiipiii(x86emu_t *emu, uintptr_t fcn) { vFppiiiiipiii_t fn = (vFppiiiiipiii_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), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); }
 void vFppiiiiddddi(x86emu_t *emu, uintptr_t fcn) { vFppiiiiddddi_t fn = (vFppiiiiddddi_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)); }

src/wrapped/generated/wrapper.h

@@ -354,7 +354,6 @@ void vFpiu(x86emu_t *emu, uintptr_t fnc);
 void vFpif(x86emu_t *emu, uintptr_t fnc);
 void vFpid(x86emu_t *emu, uintptr_t fnc);
 void vFpip(x86emu_t *emu, uintptr_t fnc);
-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);
@@ -461,11 +460,11 @@ void iFppl(x86emu_t *emu, uintptr_t fnc);
 void iFppL(x86emu_t *emu, uintptr_t fnc);
 void iFppp(x86emu_t *emu, uintptr_t fnc);
 void iFppV(x86emu_t *emu, uintptr_t fnc);
+void iFppP(x86emu_t *emu, uintptr_t fnc);
 void iFppG(x86emu_t *emu, uintptr_t fnc);
 void iFpOu(x86emu_t *emu, uintptr_t fnc);
 void iFpPU(x86emu_t *emu, uintptr_t fnc);
 void iFpPp(x86emu_t *emu, uintptr_t fnc);
-void iFpPP(x86emu_t *emu, uintptr_t fnc);
 void iFpGG(x86emu_t *emu, uintptr_t fnc);
 void iFSpi(x86emu_t *emu, uintptr_t fnc);
 void iFSpL(x86emu_t *emu, uintptr_t fnc);
@@ -617,6 +616,7 @@ void vFEpup(x86emu_t *emu, uintptr_t fnc);
 void vFEpUp(x86emu_t *emu, uintptr_t fnc);
 void vFEppp(x86emu_t *emu, uintptr_t fnc);
 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 vFiipp(x86emu_t *emu, uintptr_t fnc);
@@ -760,6 +760,7 @@ void iFEppp(x86emu_t *emu, uintptr_t fnc);
 void iFEppV(x86emu_t *emu, uintptr_t fnc);
 void iFEpOu(x86emu_t *emu, uintptr_t fnc);
 void iFEpOV(x86emu_t *emu, uintptr_t fnc);
+void iFEpPp(x86emu_t *emu, uintptr_t fnc);
 void iFEPpp(x86emu_t *emu, uintptr_t fnc);
 void iFwwww(x86emu_t *emu, uintptr_t fnc);
 void iFwppp(x86emu_t *emu, uintptr_t fnc);
@@ -828,7 +829,6 @@ void iFpupi(x86emu_t *emu, uintptr_t fnc);
 void iFpupu(x86emu_t *emu, uintptr_t fnc);
 void iFpupp(x86emu_t *emu, uintptr_t fnc);
 void iFpupV(x86emu_t *emu, uintptr_t fnc);
-void iFpupP(x86emu_t *emu, uintptr_t fnc);
 void iFpuPU(x86emu_t *emu, uintptr_t fnc);
 void iFpUup(x86emu_t *emu, uintptr_t fnc);
 void iFpUUU(x86emu_t *emu, uintptr_t fnc);

src/wrapped/wrappedvulkan.c

@@ -292,7 +292,7 @@ static void* find_DebugReportCallbackEXT_Fct(void* fct)
 
 #undef SUPER
 
-//#define PRE_INIT if(libGL) {lib->w.lib = dlopen(libGL, RTLD_LAZY | RTLD_GLOBAL); lib->path = strdup(libGL);} else
+//#define PRE_INIT if(libGL) {lib->w.lib = dlopen(libGL, RTLD_LAZY | RTLD_GLOBAL); lib->path = box_strdup(libGL);} else
 
 #define PRE_INIT        \
     if(box86_novulkan)  \
@@ -392,7 +392,7 @@ EXPORT int my_vkCreateComputePipelines(x86emu_t* emu, void* device, uint64_t pip
     const char* desc="upiSupiiUppUUi";
     aligned = vkalignStruct(pCreateInfos, desc, count);
     int ret = my->vkCreateComputePipelines(device, pipelineCache, count, aligned, find_VkAllocationCallbacks(&my_alloc, pAllocator), pPipelines);
-    vkunalignStruct(pCreateInfos, aligned, desc, count);
+    vkunalignStruct(aligned, desc, count);
     return ret;
 }
 
@@ -420,7 +420,7 @@ EXPORT int my_vkCreateGraphicsPipelines(x86emu_t* emu, void* device, uint64_t pi
     const char* desc="upiuppppppppppUUuUi"; //TODO: check if any substruct need alignement!
     aligned = vkalignStruct(pCreateInfos, desc, count);
     int ret = my->vkCreateGraphicsPipelines(device, pipelineCache, count, aligned, find_VkAllocationCallbacks(&my_alloc, pAllocator), pPipelines);
-    vkunalignStruct(pCreateInfos, aligned, desc, count);
+    vkunalignStruct(aligned, desc, count);
     return ret;
 }
 
@@ -449,7 +449,7 @@ EXPORT int my_vkCreateSharedSwapchainsKHR(x86emu_t* emu, void* device, uint32_t
     const char* desc="upiUuiiuuuiiupiiiiU";
     aligned = vkalignStruct(pCreateInfos, desc, count);
     int ret = my->vkCreateSharedSwapchainsKHR(device, count, aligned, find_VkAllocationCallbacks(&my_alloc, pAllocator), pSwapchains);
-    vkunalignStruct(pCreateInfos, aligned, desc, count);
+    vkunalignStruct(aligned, desc, count);
     return ret;
 }
 
@@ -524,12 +524,12 @@ DESTROY64(vkDestroyValidationCacheEXT)
 EXPORT void my_vkGetPhysicalDeviceProperties(x86emu_t* emu, void* device, void* pProps)
 {
     static const char* desc = 
-    "uuuuiYB"
-    "SuuuuuuuuuuuUUuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuffuuuffuLUUUiuiuffuuuuiiiiuiiiiiuifuuuuffffffiiUUU"
-    "iiiii";
+        "uuuuiYB"
+        "SuuuuuuuuuuuUUuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuffuuuffuLUUUiuiuffuuuuiiiiuiiiiiuifuuuuffffffiiUUU"
+        "Siiiii";
     void* my_props = malloc(vkalignSize(desc));
     my->vkGetPhysicalDeviceProperties(device, my_props);
-    vkunalignStruct(pProps, my_props, desc, 0);
+    vkunalignNewStruct(pProps, my_props, desc, 0);
 }
 
 EXPORT void my_vkGetPhysicalDeviceSparseImageFormatProperties(x86emu_t* emu, void* device, int format, int type, int samples, int usage, int tiling, uint32_t* count, void** pProps)
@@ -543,7 +543,7 @@ EXPORT void my_vkGetPhysicalDeviceSparseImageFormatProperties(x86emu_t* emu, voi
     my->vkGetPhysicalDeviceSparseImageFormatProperties(device, format, type, samples, usage, tiling, &cnt, NULL);
     void* my_props = malloc(cnt*sz);
     my->vkGetPhysicalDeviceSparseImageFormatProperties(device, format, type, samples, usage, tiling, count, my_props);
-    vkunalignStruct(pProps, my_props, desc, cnt);
+    vkunalignNewStruct(pProps, my_props, desc, cnt);
 }
 
 EXPORT void my_vkUpdateDescriptorSets(x86emu_t* emu, void* device, uint32_t writeCount, void* writeSet, uint32_t copyCount, void* copySet)
@@ -554,8 +554,8 @@ EXPORT void my_vkUpdateDescriptorSets(x86emu_t* emu, void* device, uint32_t writ
     void* writeAligned = writeCount?vkalignStruct(writeSet, writeDesc, writeCount):NULL; // TODO: Align pNext....
     void* copyAligned = copyCount?vkalignStruct(copySet, copyDesc, copyCount):NULL; // TODO: Align pNext....
     my->vkUpdateDescriptorSets(device, writeCount, writeAligned, copyCount, copyAligned);
-    if(writeCount)  vkunalignStruct(writeSet, writeAligned, writeDesc, writeCount);
-    if(copyCount)   vkunalignStruct(copySet, copyAligned, copyDesc, copyCount);
+    if(writeCount)  vkunalignStruct(writeAligned, writeDesc, writeCount);
+    if(copyCount)   vkunalignStruct(copyAligned, copyDesc, copyCount);
 }
 
 EXPORT int my_vkGetDisplayPlaneCapabilitiesKHR(x86emu_t* emu, void* device, uint64_t mode, uint32_t index, void* pCap)
@@ -564,7 +564,7 @@ EXPORT int my_vkGetDisplayPlaneCapabilitiesKHR(x86emu_t* emu, void* device, uint
 
     void* aligned = vkalignStruct(pCap, desc, 0);
     int ret = my->vkGetDisplayPlaneCapabilitiesKHR(device, mode, index, aligned);
-    vkunalignStruct(pCap, aligned, desc, 0);
+    vkunalignStruct(aligned, desc, 0);
     return ret;
 }
 
@@ -578,7 +578,7 @@ EXPORT int my_vkGetPhysicalDeviceDisplayPropertiesKHR(x86emu_t* emu, void* devic
     my->vkGetPhysicalDeviceDisplayPropertiesKHR(device, &cnt, NULL);
     void* aligned = vkalignStruct(pProp, desc, cnt);
     int ret = my->vkGetPhysicalDeviceDisplayPropertiesKHR(device, count, aligned);
-    vkunalignStruct(pProp, aligned, desc, cnt);
+    vkunalignStruct(aligned, desc, cnt);
     return ret;
 }
 
@@ -592,7 +592,7 @@ EXPORT void my_vkGetPhysicalDeviceMemoryProperties(x86emu_t* emu, void* device,
 
     void* aligned = vkalignStruct(pProps, desc, 0);
     my->vkGetPhysicalDeviceMemoryProperties(device, aligned);
-    vkunalignStruct(pProps, aligned, desc, 0);
+    vkunalignStruct(aligned, desc, 0);
 }
 
 EXPORT void my_vkCmdPipelineBarrier(x86emu_t* emu, void* device, int src, int dst, int dep, 
@@ -602,7 +602,7 @@ EXPORT void my_vkCmdPipelineBarrier(x86emu_t* emu, void* device, int src, int ds
 
     void* aligned = (imageCount)?vkalignStruct(pImages, desc, imageCount):NULL;
     my->vkCmdPipelineBarrier(device, src, dst, dep, barrierCount, pBarriers, bufferCount, pBuffers, imageCount, aligned);
-    if(imageCount) vkunalignStruct(pImages, aligned, desc, imageCount);
+    if(imageCount) vkunalignStruct(aligned, desc, imageCount);
 }
 
 typedef struct my_VkDebugReportCallbackCreateInfoEXT_s {
@@ -637,6 +637,84 @@ EXPORT int my_vkGetPastPresentationTimingGOOGLE(x86emu_t* emu, void* device, uin
 
     void* aligned = (timings)?vkalignStruct(timings, desc, *count):NULL;
     int ret = my->vkGetPastPresentationTimingGOOGLE(device, swapchain, count, aligned);
-    if(timings) vkunalignStruct(timings, aligned, desc, *count);
+    if(timings) vkunalignStruct(aligned, desc, *count);
+    return ret;
+}
+
+EXPORT int my_vkGetBufferMemoryRequirements2(x86emu_t* emu, void* device, void* pInfo, void* pMemoryRequirement)
+{
+    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) 
+__attribute__((alias("my_vkGetBufferMemoryRequirements2")));
+
+EXPORT void my_vkGetImageMemoryRequirements2(x86emu_t* emu, void* device, void* pInfo, void* pMemoryRequirement)
+{
+    static const char* desc = "uPSUUu";
+    void* m = vkalignStruct(pMemoryRequirement, desc, 1);
+    my->vkGetImageMemoryRequirements2(device, pInfo, m);
+    vkunalignStruct(m, desc, 1);
+}
+EXPORT void my_vkGetImageMemoryRequirements2KHR(x86emu_t* emu, void* device, void* pInfo, void* pMemoryRequirement) 
+__attribute__((alias("my_vkGetImageMemoryRequirements2")));
+
+EXPORT int my_vkGetPhysicalDeviceImageFormatProperties2(x86emu_t* emu, void* device, void* pInfo, void* pImageFormatProperties)
+{
+    static const char* desc = "uPSSuuuuuiU";
+    void* m = vkalignStruct(pImageFormatProperties, desc, 1);
+    int ret = my->vkGetPhysicalDeviceImageFormatProperties2(device, pInfo, m);
+    vkunalignStruct(m, desc, 1);
+    return ret;
+}
+EXPORT int my_vkGetPhysicalDeviceImageFormatProperties2KHR(x86emu_t* emu, void* device, void* pInfo, void* pImageFormatProperties) 
+__attribute__((alias("my_vkGetPhysicalDeviceImageFormatProperties2")));
+
+
+EXPORT void my_vkGetPhysicalDeviceProperties2(x86emu_t* emu, void* device, void* pProp)
+{
+    static const char* desc = "uP"
+        "uuuuiYB"
+        "SuuuuuuuuuuuUUuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuffuuuffuLUUUiuiuffuuuuiiiiuiiiiiuifuuuuffffffiiUUU"
+        "Siiiii";
+    void* m = vkalignStruct(pProp, desc, 1);
+    my->vkGetPhysicalDeviceProperties2(device, m);
+    vkunalignStruct(m, desc, 1);
+    
+}
+EXPORT void my_vkGetPhysicalDeviceProperties2KHR(x86emu_t* emu, void* device, void* pProp) 
+__attribute__((alias("my_vkGetPhysicalDeviceProperties2")));
+
+EXPORT int my_vkGetPhysicalDeviceSurfaceCapabilities2EXT(x86emu_t* emu, void* device, uint64_t surface, void* pSurfaceCapabilities)
+{
+    static const char* desc = "uPuuSuuSuuSuuuiiiii";
+    void* m = vkalignStruct(pSurfaceCapabilities, desc, 1);
+    int ret = my->vkGetPhysicalDeviceSurfaceCapabilities2EXT(device, surface, m);
+    vkunalignStruct(m, desc, 1);
+    return ret;
+}
+
+EXPORT int my_vkGetPhysicalDeviceSurfaceCapabilities2KHR(x86emu_t* emu, void* device, void* pInfo, void* pSurfaceCapabilities) 
+{
+    static const char* desc = "uPSuuSuuSuuSuuuiiii";
+    void* m = vkalignStruct(pSurfaceCapabilities, desc, 1);
+    int ret = my->vkGetPhysicalDeviceSurfaceCapabilities2KHR(device, pInfo, m);
+    vkunalignStruct(m, desc, 1);
     return ret;
 }

src/wrapped/wrappedvulkan_private.h

@@ -33,6 +33,7 @@
 // VkSwapchainKHR = VK_DEFINE_NON_DISPATCHABLE_HANDLE
 
 // P = Vulkan input Param Structure
+// Warning with vkGetXXX function, the structure that get the asnwer cannot be 'P'
 
 // VK_VERSION_1_0
 GO(vkAllocateCommandBuffers, iFpPp)
@@ -182,21 +183,21 @@ GOM(vkCreateDescriptorUpdateTemplate, iFEpPpp)
 GOM(vkCreateSamplerYcbcrConversion, iFEpPpp)
 GOM(vkDestroyDescriptorUpdateTemplate, vFEpUp)
 GO(vkEnumerateInstanceVersion, iFp)
-GO(vkEnumeratePhysicalDeviceGroups, iFppp)  //VkPhysicalDeviceGroupProperties seems OK
-GO(vkGetBufferMemoryRequirements2, iFpPP)
-GO(vkGetImageMemoryRequirements2, vFpPP)
+GO(vkEnumeratePhysicalDeviceGroups, iFppP)
+GOM(vkGetBufferMemoryRequirements2, iFEpPp)
+GOM(vkGetImageMemoryRequirements2, vFEpPp)
 GO(vkGetImageSparseMemoryRequirements2, vFpppp)
 GO(vkGetDescriptorSetLayoutSupport, vFpPp)
 GO(vkGetDeviceGroupPeerMemoryFeatures, vFpuuup)
 GO(vkGetDeviceQueue2, vFpPp)
-GO(vkGetPhysicalDeviceExternalBufferProperties, vFpPP)
-GO(vkGetPhysicalDeviceExternalFenceProperties, vFpPP)
-GO(vkGetPhysicalDeviceExternalSemaphoreProperties, vFpPP)
-GO(vkGetPhysicalDeviceFeatures2, vFpP)
-GO(vkGetPhysicalDeviceFormatProperties2, vFpiP)
-GO(vkGetPhysicalDeviceImageFormatProperties2, vFpPP)
-GO(vkGetPhysicalDeviceMemoryProperties2, vFpP)
-GO(vkGetPhysicalDeviceProperties2, vFpP)
+GO(vkGetPhysicalDeviceExternalBufferProperties, vFpPp)
+GO(vkGetPhysicalDeviceExternalFenceProperties, vFpPp)
+GO(vkGetPhysicalDeviceExternalSemaphoreProperties, vFpPp)
+GO(vkGetPhysicalDeviceFeatures2, vFpp)  // VkPhysicalDeviceFeatures seems OK
+GO(vkGetPhysicalDeviceFormatProperties2, vFpip)
+GOM(vkGetPhysicalDeviceImageFormatProperties2, iFEpPp)
+GO(vkGetPhysicalDeviceMemoryProperties2, vFpp)
+GOM(vkGetPhysicalDeviceProperties2, vFEpp)
 GO(vkGetPhysicalDeviceQueueFamilyProperties2, vFppp)    //VkQueueFamilyProperties2 seems OK
 GO(vkGetPhysicalDeviceSparseImageFormatProperties2, vFpPpp) //VkSparseImageFormatProperties2 seems OK
 GO(vkGetPhysicalDeviceToolProperties, iFppp)
@@ -245,19 +246,19 @@ GO(vkSetDebugUtilsObjectTagEXT, iFpp)
 //GOM(vkSubmitDebugUtilsMessageEXT, vFEpppp)    // callback in last arguments
 
 // VK_KHR_external_memory_capabilities
-GO(vkGetPhysicalDeviceExternalBufferPropertiesKHR, vFpPP)
+GO(vkGetPhysicalDeviceExternalBufferPropertiesKHR, vFpPp)
 
 // VK_KHR_get_physical_device_properties2
-GO(vkGetPhysicalDeviceFeatures2KHR, vFpP)
-GO(vkGetPhysicalDeviceFormatProperties2KHR, vFpiP)
-GO(vkGetPhysicalDeviceImageFormatProperties2KHR, vFpPP)
-GO(vkGetPhysicalDeviceMemoryProperties2KHR, vFpP)
-GO(vkGetPhysicalDeviceProperties2KHR, vFpP)
+GO(vkGetPhysicalDeviceFeatures2KHR, vFpp)
+GO(vkGetPhysicalDeviceFormatProperties2KHR, vFpip)
+GOM(vkGetPhysicalDeviceImageFormatProperties2KHR, iFEpPp)
+GO(vkGetPhysicalDeviceMemoryProperties2KHR, vFpp)
+GOM(vkGetPhysicalDeviceProperties2KHR, vFEpp)
 GO(vkGetPhysicalDeviceQueueFamilyProperties2KHR, vFppp)
 GO(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, vFpPpp)  //VkSparseImageFormatProperties2 seems OK
 
 // VK_KHR_get_surface_capabilities2
-GO(vkGetPhysicalDeviceSurfaceCapabilities2KHR, iFpPP)
+GOM(vkGetPhysicalDeviceSurfaceCapabilities2KHR, iFEpPp)
 GO(vkGetPhysicalDeviceSurfaceFormats2KHR, iFpPpp)   //VkSurfaceFormat2KHR seems OK (but array)
 
 // VK_KHR_surface
@@ -280,7 +281,7 @@ GO(vkAcquireNextImageKHR, iFpUUUUp)
 GO(vkAcquireNextImage2KHR, iFpPp)
 GOM(vkCreateSwapchainKHR, iFEpPpp)
 GOM(vkDestroySwapchainKHR, vFEpUp)
-GO(vkGetDeviceGroupPresentCapabilitiesKHR, iFpP)
+GO(vkGetDeviceGroupPresentCapabilitiesKHR, iFpp)
 GO(vkGetDeviceGroupSurfacePresentModesKHR, iFpUp)
 GO(vkGetPhysicalDevicePresentRectanglesKHR, iFpUpp)
 GO(vkGetSwapchainImagesKHR, iFpUpp)
@@ -306,7 +307,7 @@ GO(vkUpdateDescriptorSetWithTemplateKHR, vFpUUp)
 GO(vkCmdPushDescriptorSetWithTemplateKHR, vFpUUup)
 
 // VK_EXT_display_surface_counter
-GO(vkGetPhysicalDeviceSurfaceCapabilities2EXT, iFpUP)
+GOM(vkGetPhysicalDeviceSurfaceCapabilities2EXT, iFEpUp)
 
 // VK_KHR_get_display_properties2
 GO(vkGetDisplayModeProperties2KHR, iFpUpp)
@@ -334,15 +335,15 @@ GO(vkGetPhysicalDeviceWaylandPresentationSupportKHR, iFpup)
 GO(vkEnumeratePhysicalDeviceGroupsKHR, iFppp)
 
 // VK_KHR_get_memory_requirements2
-GO(vkGetBufferMemoryRequirements2KHR, iFpPP)
-GO(vkGetImageMemoryRequirements2KHR, vFpPP)
+GOM(vkGetBufferMemoryRequirements2KHR, iFEpPp)
+GOM(vkGetImageMemoryRequirements2KHR, vFEpPp)
 GO(vkGetImageSparseMemoryRequirements2KHR, vFpppp)
 
 // VK_KHR_external_fence_capabilities
-GO(vkGetPhysicalDeviceExternalFencePropertiesKHR, vFpPP)
+GO(vkGetPhysicalDeviceExternalFencePropertiesKHR, vFpPp)
 
 // VK_KHR_external_semaphore_capabilities
-GO(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, vFpPP)
+GO(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, vFpPp)
 
 // VK_KHR_maintenance1
 GO(vkTrimCommandPoolKHR, vFpUi)
@@ -405,7 +406,7 @@ GO(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, iFppp)
 
 // VK_EXT_sample_locations
 GO(vkCmdSetSampleLocationsEXT, vFpP)
-GO(vkGetPhysicalDeviceMultisamplePropertiesEXT, vFpiP)
+GO(vkGetPhysicalDeviceMultisamplePropertiesEXT, vFpip)
 
 // VK_EXT_headless_surface
 GOM(vkCreateHeadlessSurfaceEXT, iFEpPpp)
@@ -480,7 +481,7 @@ GOM(vkRegisterDeviceEventEXT, iFEpPpp)
 GOM(vkRegisterDisplayEventEXT, iFEpUPpp)
 
 // VK_EXT_external_memory_host
-GO(vkGetMemoryHostPointerPropertiesEXT, iFpupP)
+GO(vkGetMemoryHostPointerPropertiesEXT, iFpupp)
 
 // VK_EXT_hdr_metadata
 GO(vkSetHdrMetadataEXT, vFpupp)