Fix typos in comments and documentation (#1072 )

Correct "adressing", "constains", "informations", "Aleady" and "interpretor".
[WRAPPER] Added 1 wrapped function to libxml2 (for #1061 )
2026-11-07 17:43:14 -10:00 · 2026-10-20 15:45:11 +02:00 · 2026-09-27 08:26:24 +02:00 · 2026-09-11 09:45:03 +02:00 · 2026-09-11 09:44:05 +02:00 · 2026-09-11 09:42:51 +02:00
101 changed files with 2862 additions and 1029 deletions
@@ -14,7 +14,7 @@ on:
        - GENERIC_ARM
        - A64
        - GAMESHELL
-        - ODROID
+        - ODROIDXU4
        - PANDORA
        - PHYTIUM
        - PYRA
@@ -27,23 +27,23 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [I386, OTHER_ARM, PANDORA, PYRA, GAMESHELL, RPI4, RPI4ARM64, ODROID, RK3399, RK3288, A64, SD845, SD888, ADLINK, PHYTIUM, ANDROID]
+        platform: [I386, OTHER_ARM, PANDORA, PYRA, GAMESHELL, RPI4, RPI4ARM64, ODROIDXU4, RK3399, RK3288, A64, SD845, SD888, ADLINK, PHYTIUM, ANDROID]
        type: [Release, Trace]
        os: [ubuntu-latest]
        
        include:
          - platform: TEGRAX1
            type: Release
-            os: ubuntu-20.04
+            os: ubuntu-22.04
          - platform: TEGRAX1
            type: Trace
-            os: ubuntu-20.04
+            os: ubuntu-22.04
          - platform: TEGRAX1ARM32
            type: Release
-            os: ubuntu-20.04
+            os: ubuntu-22.04
          - platform: TEGRAX1ARM32
            type: Trace
-            os: ubuntu-20.04
+            os: ubuntu-22.04

    runs-on: ${{ matrix.os }}
    steps:
@@ -111,7 +111,7 @@ jobs:
          ctest -j$(nproc)

      - name: "Upload Artifact"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
        with:
          name: box86-${{ matrix.platform }}-${{ matrix.type }}
          path: build/box86
@@ -11,17 +11,18 @@ option(GOA_CLONE "Set to ON if targeting GO Advance clones, like RG351p/v, Gamef
 option(RK3288 "Set to ON if targeting an Rockchip RK3288 based device" ${RK3288})
 option(RK3399 "Set to ON if targeting an Rockchip RK3399 based device" ${RK3399})
 option(RK3588 "Set to ON if targeting an Rockchip RK3588 / RK3588S based device" ${RK3588})
-option(ODROIDN2 "Set to ON if targeting an Odroid-N2 device" ${ODROIDN2})
+option(ODROIDN2 "Set to ON if targeting an ODROID-N2 device" ${ODROIDN2})
 option(TEGRAX1 "Set to ON if targeting an Tegra X1 (ARM64) based device" ${TEGRAX1})
 option(TEGRAX1ARM32 "Set to ON if targeting an Tegra X1 (ARM32) based device" ${TEGRAX1ARM32})
 option(TEGRA_T194 "Set to ON if targeting an Tegra Xavier based device" ${TEGRA_T194})
 option(TEGRA_T234 "Set to ON if targeting an Tegra Orin based device" ${TEGRA_T234})
 option(PHYTIUM "Set to ON if targeting an Phytium (D2000 or FT2000/4) based device" ${PHYTIUM})
 option(GAMESHELL "Set to ON if targeting a GameShell device" ${GAMESHELL})
-option(ODROID "Set to ON if targeting an ODroid device" ${ODROID})
+option(ODROIDXU4 "Set to ON if targeting an ODROID-XU4 device" ${ODROIDXU4})
 option(POWER9 "Set to ON if targeting a POWER9 processor" ${POWER9})
-option(SD845 "Set to ON if targeting a Snapragon 845 based device" ${SD845})
-option(SD888 "Set to ON if targeting a Snapragon 888 based device" ${SD888})
+option(SD845 "Set to ON if targeting a Snapdragon 845 based device" ${SD845})
+option(SD865 "Set to ON if targeting a Snapdragon 865 based device" ${SD865})
+option(SD888 "Set to ON if targeting a Snapdragon 888 based device" ${SD888})
 option(ADLINK "Set to ON if targeting an ADLink AmpereAltra based device" ${ADLINK})
 option(A64 "Set to ON if targeting an Allwinner A64 based device" ${A64})
 option(ARM64 "Set to ON if targeting a generic ARM64 based device" ${ARM64})
@@ -37,7 +38,7 @@ option(NOGIT "Set to ON if not building from a git clone repo (like when buildin
 option(NO_LIB_INSTALL "Set ON to not install a few x86 libs that are used by many program" ${NO_LIB_INSTALL})
 option(NO_CONF_INSTALL "Set ON to not install config files" ${NO_CONF_INSTALL})

-if(PANDORA OR PYRA OR RPI2 OR RPI3 OR RPI4 OR GAMESHELL OR ODROID OR GOA_CLONE OR RK3288 OR RK3399 OR ODROIDN2 OR TEGRAX1 OR TEGRAX1ARM32 OR TEGRA_T194 OR TEGRA_T234 OR RPI3ARM64 OR RPI4ARM64 OR PHYTIUM OR SD845 OR SD888 OR ADLINK OR A64 OR LX2160A OR ARM64 OR RK3588)
+if(PANDORA OR PYRA OR RPI2 OR RPI3 OR RPI4 OR GAMESHELL OR ODROIDXU4 OR GOA_CLONE OR RK3288 OR RK3399 OR ODROIDN2 OR TEGRAX1 OR TEGRAX1ARM32 OR TEGRA_T194 OR TEGRA_T234 OR RPI3ARM64 OR RPI4ARM64 OR PHYTIUM OR SD845 OR SD865 OR SD888 OR ADLINK OR A64 OR LX2160A OR ARM64 OR RK3588)
    set(LD80BITS OFF CACHE BOOL "")
    set(NOALIGN OFF CACHE BOOL "")
    set(ARM_DYNAREC ON CACHE BOOL "")
@@ -76,23 +77,29 @@ else()
 endif()

 cmake_host_system_information(RESULT CMAKE_HOST_SYSTEM_PROCESSOR QUERY OS_PLATFORM)
-string(COMPARE EQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}" "i686"  _x86)
-string(COMPARE EQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}" "x86_64"  _x86_64)
-string(COMPARE EQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}" "aarch64"  _aarch64)
-string(COMPARE EQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}" "armhf"  _armhf)
-string(COMPARE EQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}" "arm"  _arm)
-string(COMPARE EQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}" "armv8l"  _armv8l)

-if(_aarch64 AND (RK3399 OR ODROIDN2 OR TEGRAX1 OR TEGRA_T194 OR TEGRA_T234 OR RPI3ARM64 OR RPI4ARM64 OR PHYTIUM OR SD845 OR SD888 OR ADLINK OR A64 OR LX2160A OR RK3588 OR ARM64))
-    set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
-    #set(CMAKE_ASM_COMPILER arm-linux-gnueabihf-as) #will use gcc in fact
-    set(CMAKE_C_COMPILER_TARGET arm-linux-gnueabihf)
+if("${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "aarch64" AND (RK3399 OR ODROIDN2 OR TEGRAX1 OR TEGRA_T194 OR TEGRA_T234 OR RPI3ARM64 OR RPI4ARM64 OR PHYTIUM OR SD845 OR SD888 OR ADLINK OR A64 OR LX2160A OR RK3588 OR ARM64))
+    set(COMPILER_TRIPLE arm-linux-gnueabihf-gcc)
+    find_program(COMPILER_FOUND ${COMPILER_TRIPLE})
+    
+    if(COMPILER_FOUND)
+        set(CMAKE_C_COMPILER ${COMPILER_FOUND})
+    else()
+        message(STATUS "Cross compiler ${COMPILER_TRIPLE} not found, using CC or -DCMAKE_C_COMPILER")
+    endif()
 endif()

 project(box86 C ASM)

 enable_testing()

+string(COMPARE EQUAL "${CMAKE_SYSTEM_PROCESSOR}" "i686"  _x86)
+string(COMPARE EQUAL "${CMAKE_SYSTEM_PROCESSOR}" "x86_64"  _x86_64)
+string(COMPARE EQUAL "${CMAKE_SYSTEM_PROCESSOR}" "aarch64"  _aarch64)
+string(COMPARE EQUAL "${CMAKE_SYSTEM_PROCESSOR}" "armhf"  _armhf)
+string(COMPARE EQUAL "${CMAKE_SYSTEM_PROCESSOR}" "arm"  _arm)
+string(COMPARE EQUAL "${CMAKE_SYSTEM_PROCESSOR}" "armv8l"  _armv8l)
+
 set(default_build_type "RelwithDebInfo")
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
  message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
@@ -137,10 +144,10 @@ elseif(RPI4ARM64)
    add_definitions(-DRPI4ARM64)
    add_definitions(-marm -march=armv8-a+crc -mtune=cortex-a72 -mfpu=neon-fp-armv8 -mfloat-abi=hard)
    set(CMAKE_ASM_FLAGS  "-marm -march=armv8-a+crc -mtune=cortex-a72 -mfpu=neon-fp-armv8 -mfloat-abi=hard")
-elseif(ODROID)
-    add_definitions(-DODROID)
-    add_definitions(-mcpu=cortex-a9 -mfpu=neon-vfpv4 -mfloat-abi=hard -marm)
-    set(CMAKE_ASM_FLAGS  "-marm -mcpu=cortex-a9 -mfpu=neon-vfpv4 -mfloat-abi=hard")
+elseif(ODROIDXU4)
+    add_definitions(-DODROIDXU4)
+    add_definitions(-marm -mcpu=cortex-a15.cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard)
+    set(CMAKE_ASM_FLAGS  "-marm -mcpu=cortex-a15.cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard")
 elseif(RK3288)
    add_definitions(-DRK3288)
    add_definitions(-mcpu=cortex-a17 -mfpu=neon -mfloat-abi=hard -marm)
@@ -149,6 +156,11 @@ elseif(SD845)
    add_definitions(-DSD845)
    add_definitions(-marm -march=armv8.2-a+simd+crypto -mtune=cortex-a75.cortex-a55 -mfpu=neon-fp-armv8 -mfloat-abi=hard)
    set(CMAKE_ASM_FLAGS  "-marm -march=armv8.2-a+simd+crypto -mtune=cortex-a75.cortex-a55 -mfpu=neon-fp-armv8 -mfloat-abi=hard")
+elseif(SD865)
+    add_definitions(-DSD865)
+    #note that cortex-a77.cortex-a55 is not supported, so fall back to a76 instead
+    add_definitions(-marm -march=armv8.2-a+simd+crypto -mtune=cortex-a76.cortex-a55 -mfpu=neon-fp-armv8 -mfloat-abi=hard)
+    set(CMAKE_ASM_FLAGS  "-marm -march=armv8.2-a+simd+crypto -mtune=cortex-a76.cortex-a55 -mfpu=neon-fp-armv8 -mfloat-abi=hard")
 elseif(SD888)
    add_definitions(-DSD888)
    add_definitions(-marm -march=armv8.4-a+simd+crypto -mfpu=neon-fp-armv8 -mfloat-abi=hard)
@@ -238,6 +250,12 @@ else()
    set(BOX86 box86)
 endif()

+try_compile(HAVE_ST_INO ${CMAKE_BINARY_DIR}/compile_tests ${CMAKE_SOURCE_DIR}/tests/test_st_ino.c)
+
+if(HAVE_ST_INO)
+  message("stat64 has __st_info field")
+  add_definitions(-DHAVE_ST_INO)
+endif()

 set(BOX86_ELF_ADDRESS "0x62800000")

@@ -345,6 +363,8 @@ set(ELFLOADER_SRC
    "${BOX86_ROOT}/src/libtools/auxval.c"
    "${BOX86_ROOT}/src/libtools/myalign.c"
    "${BOX86_ROOT}/src/libtools/myalign64.c"
+    "${BOX86_ROOT}/src/libtools/myalignsys64.c"
+    "${BOX86_ROOT}/src/libtools/stat64_helper.c"
    "${BOX86_ROOT}/src/libtools/myfts.c"
    "${BOX86_ROOT}/src/libtools/sdl1rwops.c"
    "${BOX86_ROOT}/src/libtools/sdl2rwops.c"
@@ -393,6 +413,7 @@ set(WRAPPEDS
    "${BOX86_ROOT}/src/wrapped/wrappedlibbsd.c"
    "${BOX86_ROOT}/src/wrapped/wrappedlibgl.c"
    "${BOX86_ROOT}/src/wrapped/wrappedlibglu.c"
+    "${BOX86_ROOT}/src/wrapped/wrappedlibglx.c"
    "${BOX86_ROOT}/src/wrapped/wrappedlibx11.c"
    "${BOX86_ROOT}/src/wrapped/wrappedlibasound.c"
    "${BOX86_ROOT}/src/wrapped/wrappedlibdl.c"
@@ -788,20 +809,21 @@ if(NOT _x86 AND NOT _x86_64)
 		install(FILES ${CMAKE_SOURCE_DIR}/system/box86.box86rc DESTINATION ${TERMUX_PATH}/usr/etc/)
 	endif()
  endif()
+  set(INSTALL_PATH "/usr/lib/box86-i386-linux-gnu/")
  if(NOT NO_LIB_INSTALL)
    if(NOT TERMUX)
-    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.6 DESTINATION /usr/lib/i386-linux-gnu/)
-    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.5 DESTINATION /usr/lib/i386-linux-gnu/)
-    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libgcc_s.so.1 DESTINATION /usr/lib/i386-linux-gnu/)
-    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libpng12.so.0 DESTINATION /usr/lib/i386-linux-gnu/)
-    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libunwind.so.8 DESTINATION /usr/lib/i386-linux-gnu/)
+    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.6 DESTINATION ${INSTALL_PATH})
+    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.5 DESTINATION ${INSTALL_PATH})
+    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libgcc_s.so.1 DESTINATION ${INSTALL_PATH})
+    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libpng12.so.0 DESTINATION ${INSTALL_PATH})
+    	install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libunwind.so.8 DESTINATION ${INSTALL_PATH})
    else()

-	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.6 DESTINATION ${TERMUX_PATH}/usr/lib/i386-linux-gnu/)
-	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.5 DESTINATION ${TERMUX_PATH}/usr/lib/i386-linux-gnu/)
-	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libgcc_s.so.1 DESTINATION ${TERMUX_PATH}/usr/lib/i386-linux-gnu/)
-	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libpng12.so.0 DESTINATION ${TERMUX_PATH}/usr/lib/i386-linux-gnu/)
-	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libunwind.so.8 DESTINATION ${TERMUX_PATH}/usr/lib/i386-linux-gnu/)
+	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.6 DESTINATION ${TERMUX_PATH}${INSTALL_PATH})
+	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libstdc++.so.5 DESTINATION ${TERMUX_PATH}${INSTALL_PATH})
+	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libgcc_s.so.1 DESTINATION ${TERMUX_PATH}${INSTALL_PATH})
+	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libpng12.so.0 DESTINATION ${TERMUX_PATH}${INSTALL_PATH})
+	    install(FILES ${CMAKE_SOURCE_DIR}/x86lib/libunwind.so.8 DESTINATION ${TERMUX_PATH}${INSTALL_PATH})
    endif()
  endif()
 endif()
@@ -1,3 +1,18 @@
+box86 (0.3.8) unstable; urgency=low
+* Some optimisation of x86 P flags handling
+* Some x87 fixes and improvments
+* Added some of the tim64 wrapped functions to libc and friends
+* Changed the installation folder of x86 libs to avoid conflict with linux distro
+* Some fixes to internal memory tracking
+* Some more Vulkan extensions wrapped
+* Better handling of BOX86_MAXCPU
+* Some changes and improvments on Signal handling
+* More wrapped functions, and fix to some existing ones
+* A few more syscall, and fix to some existing ones
+* New build profile for SD865
+
+-- Sebastien Chevalier <[email protected]>  Fri, 06 Dec 2024 14:06:00 -0100
+
 box86 (0.3.6) unstable; urgency=low
 * Wrapping: More libs and and function wrapping (gtk3, vulkan...)
 * Reworked X11 Callback handling, for better stability
@@ -10,4 +10,9 @@ override_dh_auto_configure:
 		  -DNOGIT=1

 override_dh_shlibdeps:
-	dh_shlibdeps --exclude=libgcc_s.so.1 --exclude=libpng12.so.0 --exclude=libstdc++.so.5 --exclude=libstdc++.so.6 
+	dh_shlibdeps \
+		--exclude=libgcc_s.so.1 \
+		--exclude=libpng12.so.0 \
+		--exclude=libstdc++.so.5 \
+		--exclude=libstdc++.so.6 \
+		--exclude=libunwind.so.8
@@ -1,3 +1,17 @@
+v0.3.8
+======
+* Some optimisation of x86 P flags handling
+* Some x87 fixes and improvments
+* Added some of the tim64 wrapped functions to libc and friends
+* Changed the installation folder of x86 libs to avoid conflict with linux distro
+* Some fixes to internal memory tracking
+* Some more Vulkan extensions wrapped
+* Better handling of BOX86_MAXCPU
+* Some changes and improvments on Signal handling
+* More wrapped functions, and fix to some existing ones
+* A few more syscall, and fix to some existing ones
+* New build profile for SD865
+
 v0.3.6
 ======
 * Wrapping: More libs and function wrapping (gtk3, vulkan...)
@@ -1,18 +1,21 @@
 Compiling/Installing
 ----

-#### Debian-based Linux 
-You can use [@Itai-Nelken](https://github.com/Itai-Nelken)'s apt repository to install precompiled box86 debs, updated weekly. 
+If you don't want to compile box86 yourself and prefer to use third-party pre-build version, go to the [end of the document](#pre-build-packages) for alternatives.

-```
-sudo wget https://itai-nelken.github.io/weekly-box86-debs/debian/box86.list -O /etc/apt/sources.list.d/box86.list
-wget -qO- https://itai-nelken.github.io/weekly-box86-debs/debian/KEY.gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/box86-debs-archive-keyring.gpg
-sudo apt update && sudo apt install box86 -y
+You can also generate your own debian package using the [instructions below](https://github.com/ptitSeb/box86/blob/master/docs/COMPILE.md#debian-packaging). 
+
+Important note, if you are using a 64bits OS, you need to have multi-arch enabled, with armhf support, for box86 to works. On Debian/Ubuntu/Armbian OS, you need to do:
+
+```bash
+sudo dpkg --add-architecture armhf && sudo apt-get update
+sudo apt-get install libc6:armhf -y
 ```

-**Note:** On a 64bit OS, install the `box86:armhf` package.
+And of course you will need to install much more library to be able to run software and games (like X11, mesa, SDL, pulseaudio...)

-Alternatively, you can generate your own package using the [instructions below](https://github.com/ptitSeb/box86/blob/master/docs/COMPILE.md#debian-packaging). 
+## Per-platform compiling instructions
+----

 #### for Pandora

@@ -60,9 +63,9 @@ sudo make install
 sudo systemctl restart systemd-binfmt
 ```

-#### for ODROID
+#### for ODROID-XU3/XU4/MC1/HC1/HC2

-`mkdir build; cd build; cmake .. -DODROID=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo; make -j3`
+`mkdir build; cd build; cmake .. -DODROIDXU4=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo; make -j3`

 #### for RK3399

@@ -80,11 +83,11 @@ As most RK3588 devices run an AARCH64 OS, you'll need an `armhf` multiarch envir

 Also, on armbian, you may need to install `libc6-dev-armhf-cross` or you may have an issue with `crt1.o` and a few other files not included with box86.

-#### for ODROID N2/N2+
+#### for ODROID-N2/N2+

 `mkdir build; cd build; cmake .. -DODROIDN2=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo; make -j3`

-As most ODROID N2/N2+ devices run an AARCH64 OS, you'll need an `armhf` multiarch environment, and an armhf gcc: On debian, install it with `sudo apt install gcc-arm-linux-gnueabihf`. 
+As most ODROID-N2/N2+ devices run an AARCH64 OS, you'll need an `armhf` multiarch environment, and an armhf gcc: On debian, install it with `sudo apt install gcc-arm-linux-gnueabihf`. 

 Also, on armbian, you may need to install `libc6-dev-armhf-cross` or you may have an issue with `crt1.o` and a few other files not included with box86.

@@ -172,7 +175,7 @@ Dynarec is only available on the ARM architecture (for the meantime anyways). Ac

 You will most likely need `-marm` in compilation flags (Many compilers default to the Thumb instruction set and Dynarec does not support this).

-###### *Note: If you get error building that "target CPU does not support ARM mode", then try to pick a hardware profile (like ODROID for armv7 or PI4 for armv8).*
+###### *Note: If you get error building that "target CPU does not support ARM mode", then try to pick a hardware profile (like ODROIDXU4 for armv7 or PI4 for armv8).*

 ##### 64bit OS with Dynarec

@@ -185,7 +188,7 @@ If you are not building from a git clone (for example, downloading a release sou

 ----

-Testing
+## Testing
 ----
 A few tests are included with box86.

@@ -201,7 +204,46 @@ NVIDIA doesn't provide armhf libraries for their GPU drivers at this time. There

 ----

-Debian Packaging
+## Debian Packaging
 ----
 Box86 can also be packaged into a .deb file ***using the source code zip from the releases page*** with `DEB_BUILD_OPTIONS=nostrip dpkg-buildpackage -us -uc -nc`. Configure any additional cmake options you might want in `debian/rules`.

+## Pre-build packages
+----
+#### Debian-based Linux 
+You can use the [Pi-Apps-Coders apt repository](https://github.com/Pi-Apps-Coders/box86-debs) to install precompiled box86 debs, updated every 24 hours. 
+
+```
+# check if .list file already exists
+if [ -f /etc/apt/sources.list.d/box86.list ]; then
+  sudo rm -f /etc/apt/sources.list.d/box86.list || exit 1
+fi
+# check if .sources file already exists
+if [ -f /etc/apt/sources.list.d/box86.sources ]; then
+  sudo rm -f /etc/apt/sources.list.d/box86.sources || exit 1
+fi
+# download gpg key from specified url
+if [ -f /usr/share/keyrings/box86-archive-keyring.gpg ]; then
+  sudo rm -f /usr/share/keyrings/box86-archive-keyring.gpg
+fi
+sudo mkdir -p /usr/share/keyrings
+wget -qO- "https://pi-apps-coders.github.io/box86-debs/KEY.gpg" | sudo gpg --dearmor -o /usr/share/keyrings/box86-archive-keyring.gpg
+# create .sources file
+echo "Types: deb
+URIs: https://Pi-Apps-Coders.github.io/box86-debs/debian
+Suites: ./
+Signed-By: /usr/share/keyrings/box86-archive-keyring.gpg" | sudo tee /etc/apt/sources.list.d/box86.sources >/dev/null
+```
+
+On a 32bit OS, run the following additional commands
+```
+sudo apt update
+sudo apt install box86-generic-arm -y
+```
+
+On a 64bit OS, run the following additional commands
+```
+sudo dpkg --add-architecture armhf
+sudo apt update
+sudo apt install box86-generic-arm:armhf -y
+```
@@ -2,7 +2,7 @@

 Емулятор простіра користувача x86_64 із родзинкою

-[Дивитись журнал змін](https://github.com/ptitSeb/box86/blob/master/docs/CHANGELOG.md) | [中文](https://github.com/ptitSeb/box86/blob/master/docs/README_CN.md) | [Українська](https://github.com/ptitSeb/box86/blob/master/docs/README_UK.md) | [Повідомити про помилку](https://github.com/ptitSeb/box86/issues/new)
+[Дивитись журнал змін](https://github.com/ptitSeb/box86/blob/master/docs/CHANGELOG.md) | [中文](https://github.com/ptitSeb/box86/blob/master/docs/README_CN.md) | [English](https://github.com/ptitSeb/box86/blob/master/docs/README.md) | [Повідомити про помилку](https://github.com/ptitSeb/box86/issues/new)

 ![build](https://app.travis-ci.com/ptitSeb/box86.svg?branch=main) ![stars](https://img.shields.io/github/stars/ptitSeb/box86) ![forks](https://img.shields.io/github/forks/ptitSeb/box86) ![contributors](https://img.shields.io/github/contributors/ptitSeb/box86) ![prs](https://img.shields.io/github/issues-pr/ptitSeb/box86) ![issues](https://img.shields.io/github/issues/ptitSeb/box86)

@@ -104,12 +104,7 @@ Linux версія Steam тепер може працювати з Box86, але
 - Якщо у вас виникли проблеми зі встановленням Steam, ви можете знайти `install_steam.sh` у кореневій папці сховища box86. Цей простий скрипт завантажить і встановить Steam у вашу домашню папку, а потім створить ярлик steam у `/usr/local/bin` (для цього він запитає дозвіл sudo). Просто використовуйте `steam` для запуску після встановлення. Зауважте, що інсталяція, яка знаходиться в папці Home, працюватиме лише для одного користувача. Не використовуйте цей скрипт, якщо вам потрібна багатокористувацька інсталяція.
 - Щоб уникнути повідомлення «libc.so.6 відсутній», ви можете використовувати `STEAMOS=1` і `STEAM_RUNTIME=1` як змінні середовища (воно автоматично з’являється, якщо ви використовували сценарій `install_steam.sh`)

-Щоб вимкнути `steamwebhelper`, коли Box64 встановлений і працює, створіть (або відредагуйте) `~/.box64rc` і додайте у ньому:
-```
-[steamwebhelper]
-BOX64_EXIT=1
-```
-І тоді `steamwebhelper` буде вимкнено. Прокоментуйте `#` ці 2 рядки, щоб увімкнути його знову.
+Якщо у вас виникла проблема із запуском Steam (не запускається `steamwebhelper`), вам потрібно запустити Steam за допомогою `-cef-disable-gpu` або `-cef-disable-gpu-compositor`.

 ----

@@ -30,7 +30,7 @@ Disables Box86 printing its version and build

 #### BOX86_LD_LIBRARY_PATH *
 Path to look for x86 libraries. Default is current folder and `lib` in current folder.
-Also, `/usr/lib/i386-linux-gnu` and `/lib/i386-linux-gnu` are added if they exist.
+Also, `/usr/lib/i386-linux-gnu`, `/lib/i386-linux-gnu`, and `/usr/lib/box86-i386-linux-gnu` are added if they exist.

 #### BOX86_PATH *
 Path to look for x86 executable. Default is current folder and `bin` in current folder.
@@ -206,6 +206,11 @@ Handling of x87 80bits long double
 * 0 : Try to handle 80bits long double as precise as possible (Default)
 * 1 : Handle them as double

+#### BOX86_MAXCPU
+Maximum CPU Core exposed
+* 0 : Don't cap the number of cpu core exposed (Default)
+* XXX : Cap the maximum CPU Core exposed to XXX (usefull with wine64 or GridAutosport for example)
+
 #### BOX86_LIBCEF *
 Detect libcef and apply malloc_hack settings
 * 0 : Don't detect libcef
@@ -270,6 +275,11 @@ Disables the load of vulkan libraries.
 * 0 : Load vulkan libraries if found.
 * 1 : Disables the load of vulkan libraries, both the native and the i386 version (can be useful on Pi4, where the vulkan driver is not quite there yet.)

+#### BOX86_NOCRASHHANDLER *
+Diables crashhandler.so
+* 0 : Regular process for crashhandler.so (Default)
+* 1 : Do not load crashhandler.so, even if present
+
 #### BOX86_FUTEX_WAITV *
 Use of the new fuext_waitc syscall
 * 0 : Do not try to use it, return unsupported (Default for BAD_SIGNAL build)
@@ -283,6 +293,11 @@ Use of the new fuext_waitc syscall
 * XXX=yyyy
 will add XXX=yyyy env. var. and continue with BOX86_ENV2 ... until var doesn't exist

+#### BOX86_ARG0
+Define argv[0] of the executable.
+ * yyyy
+Will rewrite argv[0] instead of using program path.
+
 #### BOX86_FIX_64BIT_INODES *
 Fix/Don't fix 64bit inodes
 * 0 : Don't fix 64bit inodes. (Default.)
@@ -306,7 +321,7 @@ Will use yyyy as x86 bash to launch script. yyyy needs to be a full path to a va
 #### BOX86_BOX64
 Define where to find box64 binary
 * yyyy
-Will use yyyy as x86_64 interpretor, to launch x64_64 binaries
+Will use yyyy as x86_64 interpreter, to launch x64_64 binaries

 #### BOX86_JITGDB *

@@ -18,11 +18,11 @@ mv ./usr/* ../
 cd ../ && rm -rf ./tmp/

 # create run script
-echo "#!/bin/bash
+echo '#!/bin/bash
 export STEAMOS=1
 export STEAM_RUNTIME=1
 export DBUS_FATAL_WARNINGS=0
-~/steam/bin/steam $@" > steam
+~/steam/bin/steam $@' > steam

 # make script executable and move
 chmod +x steam
@@ -35,7 +35,7 @@ if [ ${MACHINE_TYPE} == 'aarch64' ] && [ -f '/etc/debian_version' ]; then
 sudo dpkg --add-architecture armhf # enable installation of armhf libraries
 sudo apt update # update package lists with the newly added arch
 # install the libraries that Steam requires
- sudo apt install libc6:armhf libsdl2-2.0-0:armhf libsdl2-image-2.0-0:armhf libsdl2-mixer-2.0-0:armhf libsdl2-ttf-2.0-0:armhf libopenal1:armhf libpng16-16:armhf libfontconfig1:armhf libxcomposite1:armhf libbz2-1.0:armhf libxtst6:armhf libsm6:armhf libice6:armhf libgl1:armhf libxinerama1:armhf libxdamage1:armhf
+ sudo apt install libc6:armhf libsdl2-2.0-0:armhf libsdl2-image-2.0-0:armhf libsdl2-mixer-2.0-0:armhf libsdl2-ttf-2.0-0:armhf libopenal1:armhf libpng16-16:armhf libfontconfig1:armhf libxcomposite1:armhf libbz2-1.0:armhf libxtst6:armhf libsm6:armhf libice6:armhf libgl1:armhf libxinerama1:armhf libxdamage1:armhf libibus-1.0-5
 # this one is not there all the time, so just try it...
 sudo apt install libncurses5:armhf 

@@ -13,6 +13,7 @@ provides=("${pkgname%-git}" "${pkgname%-rk3xxx-git}-git" "${pkgname%-rk3xxx-git}
 conflicts=("${pkgname%-git}" "${pkgname%-rk3xxx-git}-git" "${pkgname%-rk3xxx-git}")
 source=('git+https://github.com/ptitSeb/box86')
 md5sums=('SKIP')
+_rkmodel=`tr -d '\0' < /proc/device-tree/compatible`

 pkgver() {
 	cd "$srcdir/${pkgname%-rk3xxx-git}"
@@ -22,7 +23,7 @@ pkgver() {
 prepare() {
 	cd "${srcdir}/${pkgname%-rk3xxx-git}"
 	# Check for RockChip version number
-	if [[ ${_rkmodel} =~ "rk3288"]]; then
+	if [[ ${_rkmodel} =~ "rk3288" ]]; then
 		_rksuffix=3288
 	elif [[ ${_rkmodel} =~ "rk3399" ]]; then
 		_rksuffix=3399	
@@ -1,4 +1,6 @@
 #!/bin/sh
+# Restart the systemd-binfmt service to load new binary format rules.
+# This ensures the system is immediately ready to run programs with Box86.
 if [ -d '/run/systemd/system' ]; then
    systemctl restart systemd-binfmt || :
 fi
@@ -72,7 +72,7 @@ def main(root, ver, __debug_forceAllDebugging=False):
 		
 		# Get all actual instructions
 		# Ignore white lines and lines beginning with either !, ; or #
-		insts = list(filter(lambda l: not re.match("^\s*$", l) and not re.match("^([!;#])", l), insts.split('\n')))
+		insts = list(filter(lambda l: not re.match("^\\s*$", l) and not re.match("^([!;#])", l), insts.split('\n')))
 		
 		try:
 			# Do not open with `with` to be able to open it in writing mode
@@ -729,7 +729,7 @@ def main(root, ver, __debug_forceAllDebugging=False):
 				
 				variables["u"] = -1 # Unsigned shift
 				
-				variables["w"] = -1 # wback (used in adressing)
+				variables["w"] = -1 # wback (used in addressing)
 				
 				variables["shift"] = False # Shift already detected?
 				
@@ -74,7 +74,7 @@ For each of them:
  NOTE: Those structure letters are "fake types" that are accepted in the macros.

 `gbl` contains the first list, `redirects` the second and
- `filespec` constains file specific informations (eg, structures, typedefs required...).
+ `filespec` contains file specific information (eg, structures, typedefs required...).

 After sorting the data, it generates:

@@ -631,7 +631,7 @@ class Clauses:
 						combinable[len(last_combined) - 1] = True
 						add = (i | attempt[0], m | (i ^ attempt[0]))
 						if add in combined:
-							continue # Aleady added
+							continue # Already added
 						combined.append(add)
 				last_combined.pop()
 			last_combined = combined
@@ -753,6 +753,7 @@ def readFiles(files: Iterable[str]) -> Tuple[JumbledFunctions, JumbledFunctions,
 							 or match("appindicator","appindicator3")\
 							 or match("appindicator","ayatanaappindicator3")\
 							 or match("appindicator3","ayatanaappindicator3")\
+							 or match("libgl",       "libglx")      \
 							 \
 							 or match("libc",        "tcmallocminimal") \
 							 or match("libc",        "ldlinux") 	\
@@ -1150,7 +1151,7 @@ def generate_files(root: str, files: Iterable[str], ver: str, gbls: SortedGlobal
 	for fhdr in files_header:
 		files_guard[fhdr] = trim(files_guard[fhdr])
 	
-	# TODO: put the informations below in a structure (like in box64, where
+	# TODO: put the information below in a structure (like in box64, where
 	# typedefs & co. are stored in an ABI-specific structure)
 	
 	return_x87: str = "DKdf"
@@ -3,6 +3,6 @@

 #define BOX86_MAJOR 0
 #define BOX86_MINOR 3
-#define BOX86_REVISION 6
+#define BOX86_REVISION 9

 #endif //__BOX86_VERSION_H_
@@ -914,6 +914,7 @@ void updateProtection(uintptr_t addr, uintptr_t size, uint32_t prot)
        uintptr_t bend;
        uint32_t oprot;
        rb_get_end(memprot, cur, &oprot, &bend);
+        if(bend>end) bend = end;
        uint32_t dyn=(oprot&PROT_DYN);
        if(!(dyn&PROT_NEVERPROT)) {
            if(dyn && (prot&PROT_WRITE)) {   // need to remove the write protection from this block
@@ -956,6 +957,7 @@ void setProtection_mmap(uintptr_t addr, size_t size, uint32_t prot)
    else {
        mutex_lock(&mutex_prot);
        rb_set(mapallmem, addr, addr+size, 1);
+        rb_unset(memprot, addr, addr+size);
        mutex_unlock(&mutex_prot);
    }
 }
@@ -969,6 +971,7 @@ void setProtection_elf(uintptr_t addr, size_t size, uint32_t prot)
    else {
        mutex_lock(&mutex_prot);
        rb_set(mapallmem, addr, addr+size, 1);
+        rb_unset(memprot, addr, addr+size);
        mutex_unlock(&mutex_prot);
    }
 }
@@ -996,6 +999,9 @@ void allocProtection(uintptr_t addr, size_t size, uint32_t prot)
    // don't need to add precise tracking probably
 }

+uintptr_t pbrk = 0;
+uintptr_t old_brk = 0;
+uintptr_t* cur_brk = NULL;
 void loadProtectionFromMap()
 {
    if(box86_mapclean)
@@ -1012,8 +1018,14 @@ void loadProtectionFromMap()
        if(sscanf(buf, "%x-%x %c%c%c", &s, &e, &r, &w, &x)==5) {
            int prot = ((r=='r')?PROT_READ:0)|((w=='w')?PROT_WRITE:0)|((x=='x')?PROT_EXEC:0);
            allocProtection(s, e-s, prot);
+            if(!pbrk && strstr(buf, "[heap]"))
+                pbrk = s;
        }
    }
+    if(!pbrk) {
+        printf_log(LOG_INFO, "BOX86: Warning, program break not found\n");
+        if(cur_brk) pbrk = *cur_brk;    // approximate is better than nothing
+    }
    fclose(f);
    box86_mapclean = 1;
 }
@@ -1048,12 +1060,18 @@ int getMmapped(uintptr_t addr)
 #define MEDIAN (void*)0x40000000
 static void* findBlockHinted(void* hint, size_t size, uintptr_t mask)
 {
+    // first, check if program break as changed
+    if(pbrk && cur_brk && *cur_brk!=old_brk) {
+        old_brk = *cur_brk;
+        setProtection(pbrk, old_brk-pbrk, PROT_READ|PROT_WRITE);
+    }
    int prot;
    if(hint<LOWEST) hint = LOWEST;
    uintptr_t bend = 0;
    uintptr_t cur = (uintptr_t)hint;
    if(!mask) mask = 0xffff;
-    while(bend!=0xffffffffLL) {
+    uintptr_t end_mem = 0xffffffffLL - mask;
+    while(bend<end_mem) {
        if(!rb_get_end(mapallmem, cur, &prot, &bend)) {
            if(bend-cur>=size)
                return (void*)cur;
@@ -1162,6 +1180,7 @@ void init_custommem_helper(box86context_t* ctx)
    if(inited) // already initialized
        return;
    inited = 1;
+    cur_brk = dlsym(RTLD_NEXT, "__curbrk");
    memprot = init_rbtree();
    init_mutexes();
 #ifdef DYNAREC
@@ -471,8 +471,10 @@ ARM_ cond 0 0 0 1 1 1 1 0 Rn Rd (1) (1) (1) (1) 1 0 0 1 Rt STREXH<c> <Rd>, <Rt>,
 ARM_ cond 0 0 0 1 1 1 1 1 Rn Rt (1) (1) (1) (1) 1 0 0 1 (1) (1) (1) (1) LDREXH<c> <Rt>, [<Rn>]
 ARM_ cond 0 0 1 0 0 0 0 S Rn Rd imm12 AND{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 0 0 1 S Rn Rd imm12 EOR{S}<c> <Rd>, <Rn>, #<const>
+ARM_ cond 0 0 1 0 0 1 0 0 1 1 1 1 Rd imm12 ADR<c> <Rd>, #-<const>
 ARM_ cond 0 0 1 0 0 1 0 S Rn Rd imm12 SUB{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 0 1 1 S Rn Rd imm12 RSB{S}<c> <Rd>, <Rn>, #<const>
+ARM_ cond 0 0 1 0 1 0 0 0 1 1 1 1 Rd imm12 ADR<c> <Rd>, #<const>
 ARM_ cond 0 0 1 0 1 0 0 S Rn Rd imm12 ADD{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 1 0 1 S Rn Rd imm12 ADC{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 1 1 0 S Rn Rd imm12 SBC{S}<c> <Rd>, <Rn>, #<const>
@@ -3944,18 +3944,6 @@ const char* arm_print(uint32_t opcode) {
 		uint8_t shift = ((opcode >> 4) & 0xFF);
 		
 		sprintf(ret, "TEQ%s %s, %s%s", cond, regname[rn], regname[rm], print_shift(shift, 1));
-	} else if ((opcode&0b00001111111111110000000000000000) == 0b00000010100011110000000000000000) {
-		const char* cond = conds[(opcode >> 28) & 0xF];
-		int rd = (opcode >> 16) & 0xF;
-		uint32_t imm12 = opcode&0b111111111111;
-
-		sprintf(ret, "ADR %s, #0x%x", regname[rd], imm12);
-	} else if ((opcode&0b00001111111111110000000000000000) == 0b00000010010011110000000000000000) {
-		const char* cond = conds[(opcode >> 28) & 0xF];
-		int rd = (opcode >> 16) & 0xF;
-		uint32_t imm12 = opcode&0b111111111111;
-
-		sprintf(ret, "ADR %s, #-0x%x", regname[rd], imm12);
 	} else if ((opcode & 0x0FF000F0) == 0x01400090) {
 		const char* cond = conds[(opcode >> 28) & 0xF];
 		int rt = (opcode >> 12) & 0xF;
@@ -4209,6 +4197,12 @@ const char* arm_print(uint32_t opcode) {
 		uint16_t imm12 = ((opcode >> 0) & 0xFFF);
 		
 		sprintf(ret, "EOR%s%s %s, %s, #0x%x", (s ? "S" : ""), cond, regname[rd], regname[rn], print_modified_imm_ARM(imm12));
+	} else if ((opcode & 0x0FFF0000) == 0x024F0000) {
+		const char* cond = conds[(opcode >> 28) & 0xF];
+		int rd = (opcode >> 12) & 0xF;
+		uint16_t imm12 = ((opcode >> 0) & 0xFFF);
+		
+		sprintf(ret, "ADR%s %s, #-0x%x", cond, regname[rd], print_modified_imm_ARM(imm12));
 	} else if ((opcode & 0x0FE00000) == 0x02400000) {
 		int s = (opcode >> 20) & 1;
 		const char* cond = conds[(opcode >> 28) & 0xF];
@@ -4225,6 +4219,12 @@ const char* arm_print(uint32_t opcode) {
 		uint16_t imm12 = ((opcode >> 0) & 0xFFF);
 		
 		sprintf(ret, "RSB%s%s %s, %s, #0x%x", (s ? "S" : ""), cond, regname[rd], regname[rn], print_modified_imm_ARM(imm12));
+	} else if ((opcode & 0x0FFF0000) == 0x028F0000) {
+		const char* cond = conds[(opcode >> 28) & 0xF];
+		int rd = (opcode >> 12) & 0xF;
+		uint16_t imm12 = ((opcode >> 0) & 0xFFF);
+		
+		sprintf(ret, "ADR%s %s, #0x%x", cond, regname[rd], print_modified_imm_ARM(imm12));
 	} else if ((opcode & 0x0FE00000) == 0x02800000) {
 		int s = (opcode >> 20) & 1;
 		const char* cond = conds[(opcode >> 28) & 0xF];
@@ -1667,6 +1667,7 @@ uintptr_t dynarec00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,

        case 0xCC:
            SETFLAGS(X_ALL, SF_SET_NODF);    // Hack, set all flags (to an unknown state...)
+            NOTEST(x1, x14);
            if(PK(0)=='S' && PK(1)=='C') {
                addr+=2;
                BARRIER(BARRIER_FLOAT);
@@ -1674,7 +1675,6 @@ uintptr_t dynarec00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                if((PK(0)==0) && (PK(1)==0) && (PK(2)==0) && (PK(3)==0))
                {
                    addr+=4;
-                    SKIPTEST(x14);
                    MESSAGE(LOG_DEBUG, "Exit x86 Emu\n");
                    MOV32(x14, ip+1+2);
                    SMEND();
@@ -1685,7 +1685,6 @@ uintptr_t dynarec00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                    *need_epilog = 1;
                } else {
                    MESSAGE(LOG_DUMP, "Native Call to %s\n", GetNativeName(GetNativeFnc(ip)));
-                    SKIPTEST(x14);
                    SMEND();
                    x87_forget(dyn, ninst, x3, x14, 0);
                    if((box86_log<2) && !cycle_log) {   // call the wrapper directly
@@ -1735,7 +1734,7 @@ uintptr_t dynarec00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
            break;
        case 0xCD:
            SETFLAGS(X_ALL, SF_SET_NODF);    // Hack, set all flags (to an unknown state...)
-            SKIPTEST(x14);
+            SKIPTEST(x1, x14);
            SMEND();
            u8 = F8;
            if(u8==0x80) {
@@ -2258,26 +2257,26 @@ uintptr_t dynarec00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                case 1:
                    //SETFLAGS(X_ALL, SF_SET_NODF);    // Hack to set flags to "dont'care" state
                    MESSAGE(LOG_DUMP, "Hack for Call 0\n");
-                    SKIPTEST(x14);
+                    SKIPTEST(x1, x14);
                    MOV32(xEIP, addr);
                    PUSH1(xEIP);
                    break;
                case 2:
                    //SETFLAGS(X_ALL, SF_SET_NODF);    // Hack to set flags to "dont'care" state
                    MESSAGE(LOG_DUMP, "Hack for Call x86.get_pc_thunk.reg\n");
-                    SKIPTEST(x14);
+                    SKIPTEST(x1, x14);
                    u8 = PK(i32+1);
                    gd = xEAX+((u8&0x38)>>3);
                    MOV32(gd, addr);
                    break;
                case 3:
                    SETFLAGS(X_ALL, SF_SET_NODF);    // Hack to set flags to "dont'care" state
+                    SKIPTEST(x1, x14);
                    BARRIER(BARRIER_FULL);
                    BARRIER_NEXT(BARRIER_FULL);
                    MOV32(x2, addr);
                    PUSH1(x2);
                    MESSAGE(LOG_DUMP, "Native Call to %s (retn=%d)\n", GetNativeName(GetNativeFnc(dyn->insts[ninst].natcall-1)), dyn->insts[ninst].retn);
-                    SKIPTEST(x14);
                    // calling a native function
                    if(isRetX87Wrapper(*(wrapper_t*)(dyn->insts[ninst].natcall+2))) {
                        // return value will be on the stack, so the stack depth needs to be updated
@@ -2521,13 +2520,25 @@ uintptr_t dynarec00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                        INST_NAME("REP MOVSB");
                        TSTS_REG_LSL_IMM5(xECX, xECX, 0);
                        B_NEXT(cEQ);    // end of loop
-                        GETDIR(x3,1);
                        SMREAD();
+                        GETDIR(x3, 1);
+                        SUBS_REG_LSL_IMM5(x2, xEDI, xESI, 0);
+                        SUBS_IMM8(x2, x2, 4);
+                        B_MARK(cCC);
+                        MARK2;
+                        SUBS_IMM8(x2, xECX, 4);
+                        B_MARK(cCC);
+                        LDRAI_REG_LSL_IMM5(x1, xESI, x3, 2);
+                        STRAI_REG_LSL_IMM5(x1, xEDI, x3, 2);
+                        MOV_REG(xECX, x2);
+                        B_MARK2(cNE);
+                        B_MARK3(c__);
                        MARK;
                        LDRBAI_REG_LSL_IMM5(x1, xESI, x3, 0);
                        STRBAI_REG_LSL_IMM5(x1, xEDI, x3, 0);
                        SUBS_IMM8(xECX, xECX, 1);
                        B_MARK(cNE);
+                        MARK3;
                        SMWRITE();
                        // done
                        break;
@@ -95,7 +95,7 @@ uintptr_t dynarec0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                    addr = fakeed(dyn, addr, ninst, nextop);
                    SETFLAGS(X_ALL, SF_SET_NODF);    // Hack to set flags in "don't care" state
                    //CALL(arm_ud, -1, 0);
-                    SKIPTEST(x14);
+                    SKIPTEST(x1, x14);
                    UDF(0);
                    break;
                case 0xE0:
@@ -149,7 +149,7 @@ uintptr_t dynarec0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
            INST_NAME("UD2");
            SETFLAGS(X_ALL, SF_SET_NODF);    // Hack to set flags in "don't care" state
            //CALL(arm_ud, -1, 0);
-            SKIPTEST(x14);
+            SKIPTEST(x1, x14);
            UDF(0);
            break;

@@ -481,7 +481,7 @@ uintptr_t dynarec0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
        case 0x31:
            INST_NAME("RDTSC");
            MESSAGE(LOG_DUMP, "Need Optimization\n");
-            SKIPTEST(x14);
+            SKIPTEST(x1, x14);
            CALL(ReadTSC, xEAX, 0);   // will return the u64 in x1:xEAX
            MOV_REG(xEDX, x1);
            break;
@@ -717,7 +717,7 @@ uintptr_t dynarec0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
            break;
        case 0x51:
            INST_NAME("SQRTPS Gx, Ex");
-            SKIPTEST(x1);
+            SKIPTEST(x1, x14);
            nextop = F8;
            GETEX(q0, 0);
            gd = (nextop&0x38)>>3;
@@ -786,7 +786,7 @@ uintptr_t dynarec0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
            break;
        case 0x52:
            INST_NAME("RSQRTPS Gx, Ex");
-            SKIPTEST(x1);
+            SKIPTEST(x1, x14);
            nextop = F8;
            GETEX(q0, 0);
            gd = (nextop&0x38)>>3;
@@ -809,7 +809,7 @@ uintptr_t dynarec0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
            break;
        case 0x53:
            INST_NAME("RCPPS Gx, Ex");
-            SKIPTEST(x1);
+            SKIPTEST(x1, x14);
            nextop = F8;
            GETEX(q0, 0);
            gd = (nextop&0x38)>>3;
@@ -138,6 +138,31 @@ uintptr_t dynarecD9(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                    MOV32(x14, 0b100000100000000);
                    B_MARK3(c__);
                } else {                // not in cache, so check Empty status and load it
+                    // load tag
+                    LDRH_IMM8(x3, xEmu, offsetof(x86emu_t, fpu_tags));
+                    if(i2) {
+                        if(i2<0) {
+                            MOV_REG_LSL_IMM5(x3, x3, -i2*2);
+                        } else {
+                            MOV32(x14, 0xffff);
+                            ORR_REG_LSL_IMM5(x3, x3, x14, 16);
+                            MOV_REG_LSR_IMM5(x3, x3, i2*2);
+                        }
+                    }
+                    TSTS_IMM8(x3, 0b11);
+                    MOVW(x14, 0b100000100000000);   // empty
+                    B_MARK3(cNE);
+                    // check stack  TODO: this test should not be needed, something is wrong with tag handling
+                    LDR_IMM9(x3, xEmu, offsetof(x86emu_t, fpu_stack));
+                    if(i2) {
+                        if(i2<0) {
+                            ADD_IMM8(x3, x3, -i2);
+                        } else {
+                            SUB_IMM8(x3, x3, i2);
+                        }
+                    }
+                    CMPS_IMM8(x3, 0);
+                    B_MARK3(cLE);
                    // x14 will be the actual top
                    LDR_IMM9(x14, xEmu, offsetof(x86emu_t, top));
                    i2 = -dyn->n.x87stack;
@@ -149,11 +174,6 @@ uintptr_t dynarecD9(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                        }
                        AND_IMM8(x14, x14, 7);    // (emu->top + i)&7
                    }
-                    // load tag
-                    LDRH_IMM8(x3, xEmu, offsetof(x86emu_t, fpu_tags));
-                    TSTS_IMM8(x3, 0b11);
-                    MOVW_COND(cNE, x14, 0b100000100000000);
-                    B_MARK3(cNE);
                    ADD_REG_LSL_IMM5(x1, xEmu, x14, 3);
                    LDRD_IMM8(x2, x1, offsetof(x86emu_t, x87)); // load r2/r3 with ST0 anyway, for sign extraction
                }
@@ -32,6 +32,7 @@ uintptr_t dynarecDD(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
    uint8_t ed;
    int v1, v2;
    int i1, i2, i3;
+    int j32;

    MAYUSE(v2);
    MAYUSE(v1);
@@ -51,7 +52,7 @@ uintptr_t dynarecDD(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                MESSAGE(LOG_DUMP, "Hack for FFREE ST0 / FINCSTP\n");
                X87_POP_OR_FAIL(dyn, ninst, x1);
                addr+=2;
-                SKIPTEST(x1);
+                SKIPTEST(x1, x14);
            } else
                x87_free(dyn, ninst, x1, x2, x3, nextop&7);
            #else
@@ -178,10 +179,53 @@ uintptr_t dynarecDD(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                    break;
                case 1:
                    INST_NAME("FISTTP i64, ST0");
-                    x87_forget(dyn, ninst, x1, x2, 0);
+                    parity = getedparity(dyn, ninst, addr, nextop, 3);
                    addr = geted(dyn, addr, ninst, nextop, &ed, x1, &fixedaddress, 0, 0, 0, NULL);
-                    if(ed!=x1) {MOV_REG(x1, ed);}
-                    CALL(arm_fistt64, -1, 0);
+                    if(ninst
+                      && dyn->insts[ninst-1].x86.addr
+                      && *(uint8_t*)dyn->insts[ninst-1].x86.addr==0xDF
+                      && (((*(uint8_t*)(dyn->insts[ninst-1].x86.addr+1))>>3)&7)==5)
+                    {
+                        if(parity) {
+                            STRD_IMM8(x2, ed, 0);    // x2/x3 is 64bits
+                        } else {
+                            STR_IMM9(x2, ed, 0);
+                            STR_IMM9(x3, ed, 4);
+                        }
+                    } else {
+                        v1 = x87_get_st(dyn, ninst, x2, x3, 0, NEON_CACHE_ST_D);
+                        //addr = geted(dyn, addr, ninst, nextop, &ed, x1, &fixedaddress, 0, 0, 0, NULL);
+                        fpu_get_scratch_double(dyn); // to alocate v0
+                        v2 = fpu_get_scratch_double(dyn);
+                        //  get TOP
+                        LDR_IMM9(x14, xEmu, offsetof(x86emu_t, top));
+                        int a = 0 - dyn->n.x87stack;
+                        if(a<0) {
+                            SUB_IMM8(x14, x14, -a);
+                            AND_IMM8(x14, x14, 7);    // (emu->top + i)&7
+                        } else if(a>0) {
+                            ADD_IMM8(x14, x14, a);
+                            AND_IMM8(x14, x14, 7);    // (emu->top + i)&7
+                        }
+                        ADD_REG_LSL_IMM5(x14, xEmu, x14, 4);  // each fpu_ll is 2 int64: ref than ll
+                        MOVW(x2, offsetof(x86emu_t, fpu_ll));   //can be optimized?
+                        ADD_REG_LSL_IMM5(x14, x14, x2, offsetof(fpu_ll_t, sref));
+                        VLDR_64(v2, x14, 0);
+                        VCEQ_32(v2, v2, v1);    // compare
+                        VMOVfrV_D(x2, x3, v2);
+                        ANDS_REG_LSL_IMM5(x2, x2, x3, 0);   // if NE then values are the same!
+                        B_MARK(cEQ);    // do the i64 conversion
+                        // memcpy(ed, &STll(0).ll, sizeof(int64_t));
+                        LDRD_IMM8(x2, x14, offsetof(fpu_ll_t, sq));  // load ll
+                        B_MARK3(c__);
+                        MARK;
+                        MOV32(x2, arm_fist64_3);
+                        VMOV_64(0, v1);    // prepare call to log2
+                        CALL_1DR_U64(x2, x2, x3, x14, (1<<x1));
+                        MARK3;
+                        STR_IMM9(x2, ed, 0);
+                        STR_IMM9(x3, ed, 4);
+                    }
                    X87_POP_OR_FAIL(dyn, ninst, x3);
                    break;
                case 2:
@@ -186,9 +186,9 @@ uintptr_t dynarecDF(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                    BIC_IMM8(x3, x3, 0b10011111, 0);
                    VMSR(x3);
                    if(ST_IS_F(0)) {
-                        VCVTR_S32_F32(s0, v1);
+                        VCVT_S32_F32(s0, v1);
                    } else {
-                        VCVTR_S32_F64(s0, v1);
+                        VCVT_S32_F64(s0, v1);
                    }
                    VMRS(x3);   // get the FPCSR reg and test FPU execption (invalid operation only)
                    VMOVfrV(ed, s0);
@@ -337,12 +337,10 @@ uintptr_t dynarecDF(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                            STR_IMM9(x3, ed, 4);
                        }
                    } else {
-                        #if 1
                        v1 = x87_get_st(dyn, ninst, x2, x3, 0, NEON_CACHE_ST_D);
                        //addr = geted(dyn, addr, ninst, nextop, &ed, x1, &fixedaddress, 0, 0, 0, NULL);
                        fpu_get_scratch_double(dyn); // to alocate v0
                        v2 = fpu_get_scratch_double(dyn);
-                        #if 1
                        //  get TOP
                        LDR_IMM9(x14, xEmu, offsetof(x86emu_t, top));
                        int a = 0 - dyn->n.x87stack;
@@ -375,74 +373,6 @@ uintptr_t dynarecDF(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int ninst,
                        MARK3;
                        STR_IMM9(x2, ed, 0);
                        STR_IMM9(x3, ed, 4);
-                        #else
-                        v0 = fpu_get_scratch_double(dyn);
-                        s0 = fpu_get_scratch_single(dyn);
-                        // check STll(0).ref==ST(0).q so emu->fpu_ll[emu->top].ref == emu->mmx87[emu->top]
-                        //  get TOP
-                        LDR_IMM9(x14, xEmu, offsetof(x86emu_t, top));
-                        int a = 0 - dyn->n.x87stack;
-                        if(a<0) {
-                            SUB_IMM8(x14, x14, -a);
-                            AND_IMM8(x14, x14, 7);    // (emu->top + i)&7
-                        } else if(a>0) {
-                            ADD_IMM8(x14, x14, a);
-                            AND_IMM8(x14, x14, 7);    // (emu->top + i)&7
-                        }
-                        ADD_REG_LSL_IMM5(x14, xEmu, x14, 4);  // each fpu_ll is 2 int64: ref than ll
-                        MOVW(x2, offsetof(x86emu_t, fpu_ll));   //can be optimized?
-                        ADD_REG_LSL_IMM5(x14, x14, x2, 0);
-                        VLDR_64(v2, x14, 0);
-                        VCEQ_32(v2, v2, v1);    // compare
-                        VMOVfrV_D(x2, x3, v2);
-                        ANDS_REG_LSL_IMM5(x2, x2, x3, 0);   // if NE then values are the same!
-                        B_MARK(cEQ);    // do the i64 conversion
-                        // memcpy(ed, &STll(0).ll, sizeof(int64_t));
-                        LDRD_IMM8(x2, x14, 8);  // load ll
-                        B_MARK3(c__);
-                        MARK;
-                        VEOR(v0, v0, v0);
-                        MOVW(x2, 0x41F0);
-                        VMOVtoDx_16(v0, 3, x2); // V0 = (1<<32) as double
-                        VMOVfrDx_32(x14, v1, 1);    // get high part to extract sign
-                        VABS_F64(v1 ,v1);    //ST0 will be poped, so lost...
-                        VDIV_F64(v2, v1, v0);   // v2 = abs(ST0)/(1<<32) : so 32 bits high part
-                        MSR_nzcvq_0();
-                        VMRS(x2);               // get fpscr
-                        ORR_IMM8(x3, x2, 0b010, 9); // enable exceptions
-                        BIC_IMM8(x3, x3, 0b10011111, 0);
-                        VMSR(x3);
-                        VCVT_U32_F64(s0, v2);   // convert high part to U32
-                        VMRS(x3);   // get the FPCSR reg and test FPU execption (invalid operation only)
-                        VMSR(x2);               // put back fpscr
-                        TSTS_IMM8_ROR(x3, 0b00000001, 0);
-                        B_MARK2(cEQ);   // not overflow...
-                        MARKLOCK;
-                        MOV_IMM(x3, 0b10, 1);   // 0x80000000
-                        MOVW(x2, 0);
-                        B_MARK3(c__);
-                        MARK2;  // continue conversion, it fits an int64!
-                        VCVT_F64_U32(v2, s0);   // int part now
-                        VMLS_F64(v1, v2, v0);   // compute low part
-                        VMOVfrV(x3, s0);        // transfert high path
-                        TSTS_IMM8_ROR(x14, 0b10, 1);    // test high part with 0x800000000
-                        B_MARKLOCK(cNE);        // int overflow...
-                        VCVT_U32_F64(s0, v1);   // convert low part
-                        VMOVfrV(x2, s0);        // transfert low part
-                        TSTS_IMM8_ROR(x14, 0b10, 1);    // 0x800000000
-                        B_MARK3(cEQ);
-                        RSBS_IMM8(x2, x2, 0);   // NEG(i64)
-                        RSC_IMM8(x3, x3, 0);
-                        MARK3;
-                        STR_IMM9(x2, x1, 0);
-                        STR_IMM9(x3, x1, 4);
-                        #endif
-                        #else
-                        MESSAGE(LOG_DUMP, "Need Optimization\n");
-                        x87_forget(dyn, ninst, x2, x3, 0);
-                        if(ed!=x1) {MOV_REG(x1, ed);}
-                        CALL(arm_fistp64, -1, 0);
-                        #endif
                    }
                    X87_POP_OR_FAIL(dyn, ninst, x3);
                    break;
@@ -53,7 +53,7 @@ void emit_or32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -96,7 +96,7 @@ void emit_or32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -130,7 +130,7 @@ void emit_xor32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -173,7 +173,7 @@ void emit_xor32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -207,7 +207,7 @@ void emit_and32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -258,7 +258,7 @@ void emit_and32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -292,7 +292,7 @@ void emit_or8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -326,7 +326,7 @@ void emit_or8c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -360,7 +360,7 @@ void emit_xor8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -394,7 +394,7 @@ void emit_xor8c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -428,7 +428,7 @@ void emit_and8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -462,7 +462,7 @@ void emit_and8c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -497,7 +497,7 @@ void emit_or16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -540,7 +540,7 @@ void emit_or16c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -574,7 +574,7 @@ void emit_xor16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -617,7 +617,7 @@ void emit_xor16c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -651,7 +651,7 @@ void emit_and16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -694,6 +694,6 @@ void emit_and16c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }
@@ -69,7 +69,7 @@ void emit_add32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -151,7 +151,7 @@ void emit_add32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -203,7 +203,7 @@ void emit_sub32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -288,7 +288,7 @@ void emit_sub32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -338,7 +338,7 @@ void emit_add8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, in
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -390,7 +390,7 @@ void emit_add8c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -442,7 +442,7 @@ void emit_sub8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, in
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_CF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -495,7 +495,7 @@ void emit_sub8c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -547,7 +547,7 @@ void emit_add16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, i
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -615,7 +615,7 @@ void emit_add16c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -668,7 +668,7 @@ void emit_sub16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, i
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_CF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -734,7 +734,7 @@ void emit_sub16c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -778,7 +778,7 @@ void emit_inc32(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -823,7 +823,7 @@ void emit_inc8(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -870,7 +870,7 @@ void emit_inc16(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -915,7 +915,7 @@ void emit_dec32(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -960,7 +960,7 @@ void emit_dec8(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1006,7 +1006,7 @@ void emit_dec16(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1057,7 +1057,7 @@ void emit_adc32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1127,7 +1127,7 @@ void emit_adc32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1179,7 +1179,7 @@ void emit_adc8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, in
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -1232,7 +1232,7 @@ void emit_adc8c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1285,7 +1285,7 @@ void emit_adc16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, i
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -1353,7 +1353,7 @@ void emit_adc16c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1407,7 +1407,7 @@ void emit_sbb32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1479,7 +1479,7 @@ void emit_sbb32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1533,7 +1533,7 @@ void emit_sbb8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, in
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_CF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -1587,7 +1587,7 @@ void emit_sbb8c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1642,7 +1642,7 @@ void emit_sbb16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4, i
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
    IFX(X_AF|X_OF|X_CF|X_PF){if(save_s4) {POP(xSP, 1<<s4);}}
 }
@@ -1710,7 +1710,7 @@ void emit_sbb16c(dynarec_arm_t* dyn, int ninst, int s1, int c, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1758,7 +1758,7 @@ void emit_neg32(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1807,7 +1807,7 @@ void emit_neg16(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1855,6 +1855,6 @@ void emit_neg8(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }
@@ -76,7 +76,7 @@ void emit_shl32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFC_COND(cNE, xFlags, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -130,7 +130,7 @@ void emit_shl32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        }
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -181,7 +181,7 @@ void emit_shr32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -233,7 +233,7 @@ void emit_shr32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -280,7 +280,7 @@ void emit_sar32c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
            BFC(xFlags, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -323,7 +323,7 @@ void emit_shl8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFI_COND(cEQ, xFlags, s4, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -371,7 +371,7 @@ void emit_shl8c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
            }
        }
        IFX(X_PF) {
-            emit_pf(dyn, ninst, s1, s3, s4);
+            emit_pf(dyn, ninst, s1, s4);
        }
    } else {
        IFX(X_CF) {
@@ -433,7 +433,7 @@ void emit_shr8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -479,7 +479,7 @@ void emit_shr8c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -517,7 +517,7 @@ void emit_sar8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFC_COND(cEQ, xFlags, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -557,7 +557,7 @@ void emit_sar8c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s4
            BFC(xFlags, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -597,7 +597,7 @@ void emit_shl16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFI_COND(cEQ, xFlags, s4, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -645,7 +645,7 @@ void emit_shl16c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
            }
        }
        IFX(X_PF) {
-            emit_pf(dyn, ninst, s1, s3, s4);
+            emit_pf(dyn, ninst, s1, s4);
        }
    } else {
        IFX(X_CF) {
@@ -707,7 +707,7 @@ void emit_shr16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -753,7 +753,7 @@ void emit_shr16c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -792,7 +792,7 @@ void emit_sar16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFC_COND(cEQ, xFlags, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -835,7 +835,7 @@ void emit_sar16c(dynarec_arm_t* dyn, int ninst, int s1, int32_t c, int s3, int s
            BFC(xFlags, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -968,7 +968,7 @@ void emit_shrd32c(dynarec_arm_t* dyn, int ninst, int s1, int s2, int32_t c, int
        }
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1035,7 +1035,7 @@ void emit_shld32c(dynarec_arm_t* dyn, int ninst, int s1, int s2, int32_t c, int
        BFI(xFlags, s3, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1096,7 +1096,7 @@ void emit_shrd32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFI_COND(cEQ, xFlags, s4, F_OF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -1160,7 +1160,7 @@ void emit_shld32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -55,7 +55,10 @@ void emit_cmp32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        MOV_REG_LSR_IMM5(s4, s3, 31);
        BFI(xFlags, s4, F_SF, 1);
    }
-    // and now the tricky ones (and mostly unused), PF and AF
+    IFX(X_PF) {
+        emit_pf(dyn, ninst, s3, s4);
+    }
+    // and now the tricky ones (and mostly unused), AF
    IFX(X_AF) {
        // bc = (res & (~d | s)) | (~d & s)
        MVN_REG_LSL_IMM5(s4, s1, 0);        // s4 = ~d
@@ -68,19 +71,6 @@ void emit_cmp32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFI(xFlags, s4, F_AF, 1);    // AF: bc & 0x08
        }
    }
-    IFX(X_PF) {
-        // PF: (((emu->x86emu_parity_tab[(res) / 32] >> ((res) % 32)) & 1) == 0)
-        IFX(X_CF|X_AF) {
-            SUB_REG_LSL_IMM5(s3, s1, s2, 0);
-        }
-        AND_IMM8(s3, s3, 0xE0); // lsr 5 masking pre-applied
-        MOV32(s4, GetParityTab());
-        LDR_REG_LSR_IMM5(s4, s4, s3, 5-2);   // x/32 and then *4 because array is integer
-        SUB_REG_LSL_IMM5(s3, s1, s2, 0);
-        AND_IMM8(s3, s3, 31);
-        MVN_REG_LSR_REG(s4, s4, s3);
-        BFI(xFlags, s4, F_PF, 1);
-    }
 }

 // emit CMP32 instruction, from cmp s1 , 0, using s3 and s4 as scratch
@@ -112,7 +102,7 @@ void emit_cmp32_0(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -140,6 +130,9 @@ void emit_cmp16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        MOV_REG_LSR_IMM5(s4, s3, 15);
        BFI(xFlags, s4, F_SF, 1);
    }
+    IFX(X_PF) {
+        emit_pf(dyn, ninst, s3, s4);
+    }
    // bc = (res & (~d | s)) | (~d & s)
    IFX(X_CF|X_AF|X_OF) {
        MVN_REG_LSL_IMM5(s4, s1, 0);        // s4 = ~d
@@ -161,18 +154,6 @@ void emit_cmp16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFI(xFlags, s4, F_OF, 1);    // OF: ((bc >> 14) ^ ((bc>>14)>>1)) & 1
        }
    }
-    IFX(X_PF) {
-        IFX(X_CF|X_AF|X_OF) {
-            SUB_REG_LSL_IMM5(s3, s1, s2, 0);
-        }
-        AND_IMM8(s3, s3, 0xE0); // lsr 5 masking pre-applied
-        MOV32(s4, GetParityTab());
-        LDR_REG_LSR_IMM5(s4, s4, s3, 5-2);   // x/32 and then *4 because array is integer
-        SUB_REG_LSL_IMM5(s3, s1, s2, 0);
-        AND_IMM8(s3, s3, 31);
-        MVN_REG_LSR_REG(s4, s4, s3);
-        BFI(xFlags, s4, F_PF, 1);
-    }
 }

 // emit CMP16 instruction, from cmp s1 , #0, using s3 and s4 as scratch
@@ -204,7 +185,7 @@ void emit_cmp16_0(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }
 // emit CMP8 instruction, from cmp s1 , s2, using s3 and s4 as scratch
@@ -230,6 +211,9 @@ void emit_cmp8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        MOV_REG_LSR_IMM5(s4, s3, 7);
        BFI(xFlags, s4, F_SF, 1);
    }
+    IFX(X_PF) {
+        emit_pf(dyn, ninst, s3, s4);
+    }
    // bc = (res & (~d | s)) | (~d & s)
    IFX(X_CF|X_AF|X_OF) {
        MVN_REG_LSL_IMM5(s4, s1, 0);        // s4 = ~d
@@ -251,18 +235,6 @@ void emit_cmp8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
            BFI(xFlags, s4, F_OF, 1);    // OF: ((bc >> 6) ^ ((bc>>6)>>1)) & 1
        }
    }
-    IFX(X_PF) {
-        IFX(X_CF|X_AF|X_OF) {
-            SUB_REG_LSL_IMM5(s3, s1, s2, 0);
-        }
-        AND_IMM8(s3, s3, 0xE0); // lsr 5 masking pre-applied
-        MOV32(s4, GetParityTab());
-        LDR_REG_LSR_IMM5(s4, s4, s3, 5-2);   // x/32 and then *4 because array is integer
-        SUB_REG_LSL_IMM5(s3, s1, s2, 0);
-        AND_IMM8(s3, s3, 31);
-        MVN_REG_LSR_REG(s4, s4, s3);
-        BFI(xFlags, s4, F_PF, 1);
-    }
 }
 // emit CMP8 instruction, from cmp s1 , 0, using s3 and s4 as scratch
 void emit_cmp8_0(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
@@ -292,7 +264,7 @@ void emit_cmp8_0(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
        BFI(xFlags, s4, F_SF, 1);
    }
    IFX(X_PF) {
-        emit_pf(dyn, ninst, s1, s3, s4);
+        emit_pf(dyn, ninst, s1, s4);
    }
 }

@@ -321,19 +293,8 @@ void emit_test32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        MOV_REG_LSR_IMM5(s4, s3, 31);
        BFI(xFlags, s4, F_SF, 1);
    }
-    // PF: (((emu->x86emu_parity_tab[(res) / 32] >> ((res) % 32)) & 1) == 0)
    IFX(X_PF) {
-        AND_IMM8(s3, s3, 0xE0); // lsr 5 masking pre-applied
-        MOV32(s4, GetParityTab());
-        LDR_REG_LSR_IMM5(s4, s4, s3, 5-2);   // x/32 and then *4 because array is integer
-        if(s1==s2) {
-            AND_IMM8(s3, s1, 31);
-        } else {
-            AND_REG_LSL_IMM5(s3, s1, s2, 0);
-            AND_IMM8(s3, s3, 31);
-        }
-        MVN_REG_LSR_REG(s4, s4, s3);
-        BFI(xFlags, s4, F_PF, 1);
+        emit_pf(dyn, ninst, s3, s4);
    }
 }

@@ -362,15 +323,8 @@ void emit_test16(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        MOV_REG_LSR_IMM5(s4, s3, 15);
        BFI(xFlags, s4, F_SF, 1);
    }
-    // PF: (((emu->x86emu_parity_tab[(res) / 32] >> ((res) % 32)) & 1) == 0)
    IFX(X_PF) {
-        AND_IMM8(s3, s3, 0xE0); // lsr 5 masking pre-applied
-        MOV32(s4, GetParityTab());
-        LDR_REG_LSR_IMM5(s4, s4, s3, 5-2);   // x/32 and then *4 because array is integer
-        AND_REG_LSL_IMM5(s3, s1, s2, 0);
-        AND_IMM8(s3, s3, 31);
-        MVN_REG_LSR_REG(s4, s4, s3);
-        BFI(xFlags, s4, F_PF, 1);
+        emit_pf(dyn, ninst, s3, s4);
    }
 }

@@ -399,13 +353,7 @@ void emit_test8(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4)
        MOV_REG_LSR_IMM5(s4, s3, 7);
        BFI(xFlags, s4, F_SF, 1);
    }
-    // PF: (((emu->x86emu_parity_tab[(res) / 32] >> ((res) % 32)) & 1) == 0)
    IFX(X_PF) {
-        AND_IMM8(s2, s3, 0xE0); // lsr 5 masking pre-applied
-        MOV32(s4, GetParityTab());
-        LDR_REG_LSR_IMM5(s4, s4, s2, 5-2);   // x/32 and then *4 because array is integer
-        AND_IMM8(s3, s3, 31);
-        MVN_REG_LSR_REG(s4, s4, s3);
-        BFI(xFlags, s4, F_PF, 1);
+        emit_pf(dyn, ninst, s3, s4);
    }
 }
@@ -62,10 +62,20 @@ void arm_fpatan(x86emu_t* emu)
 }
 void arm_fxtract(x86emu_t* emu)
 {
-    int32_t tmp32s = (ST1.q&0x7ff0000000000000LL)>>52;
-    tmp32s -= 1023;
-    ST1.d /= exp2(tmp32s);
-    ST0.d = tmp32s;
+    int tmp32s;
+    if(isnan(ST1.d)) {
+        ST0.d = ST1.d;
+    } else if(isinf(ST1.d)) {
+        ST0.d = ST1.d;
+        ST1.d = INFINITY;
+    } else if(ST1.d==0.0) {
+        ST0.d = ST1.d;
+        ST1.d = -INFINITY;
+    } else {
+        // LD80bits doesn't have implicit "1" bit, so need to adjust for that
+        ST0.d = frexp(ST1.d, &tmp32s)*2;
+        ST1.d = tmp32s-1;
+    }
 }
 void arm_fprem(x86emu_t* emu)
 {
@@ -116,21 +126,6 @@ void arm_fbstp(x86emu_t* emu, uint8_t* ed)
    fpu_fbst(emu, ed);
 }

-void arm_fistp64(x86emu_t* emu, int64_t* ed)
-{
-    // used of memcpy to avoid aligments issues
-    if(STll(0).sref==ST(0).sq) {
-        memcpy(ed, &STll(0).sq, sizeof(int64_t));
-    } else {
-        int64_t tmp;
-        if(isgreater(ST0.d, (double)(int64_t)0x7fffffffffffffffLL) || isless(ST0.d, -(double)(uint64_t)0x8000000000000000LL) || !isfinite(ST0.d))
-            tmp = 0x8000000000000000LL;
-        else
-            tmp = fpu_round(emu, ST0.d);
-        memcpy(ed, &tmp, sizeof(tmp));
-    }
-}
-
 int64_t arm_fist64_0(double d)
 {
    int64_t tmp;
@@ -168,13 +163,6 @@ int64_t arm_fist64_3(double d)
    return tmp;
 }

-void arm_fistt64(x86emu_t* emu, int64_t* ed)
-{
-    // used of memcpy to avoid aligments issues
-    int64_t tmp = ST0.d;
-    memcpy(ed, &tmp, sizeof(tmp));
-}
-
 void arm_fld(x86emu_t* emu, uint8_t* ed)
 {
    memcpy(&STld(0).ld, ed, 10);
@@ -16,8 +16,6 @@ void arm_fscale(x86emu_t* emu);
 void arm_fbld(x86emu_t* emu, uint8_t* ed);
 void arm_fild64(x86emu_t* emu, int64_t* ed);
 void arm_fbst(x86emu_t* emu, uint8_t* ed);
-void arm_fistp64(x86emu_t* emu, int64_t* ed);
-void arm_fistt64(x86emu_t* emu, int64_t* ed);
 void arm_fld(x86emu_t* emu, uint8_t* ed);
 void arm_fsave(x86emu_t* emu, uint8_t* ed);
 void arm_frstor(x86emu_t* emu, uint8_t* ed);
@@ -1044,9 +1044,9 @@ static void x87_unreflectcache(dynarec_arm_t* dyn, int ninst, int s1, int s2, in
        if(a>0) {
            MOV32(s2, 0xffff);
            ORR_REG_LSL_IMM5(s1, s1, s2, 16);
-            MOV_REG_LSR_IMM5(s1, s1, -a*2);
+            MOV_REG_LSR_IMM5(s1, s1, a*2);
        } else {
-            MOV_REG_LSL_IMM5(s1, s1, a*2);
+            MOV_REG_LSL_IMM5(s1, s1, -a*2);
        }
        STRH_IMM8(s1, xEmu, offsetof(x86emu_t, fpu_tags));
        // Sub x87stack to top, with and 7
@@ -2118,14 +2118,13 @@ void fpu_putback_single_reg(dynarec_arm_t* dyn, int ninst, int reg, int idx, int
    }
 }

-void emit_pf(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
+void emit_pf(dynarec_arm_t* dyn, int ninst, int s1, int s4)
 {
-    // PF: (((emu->x86emu_parity_tab[(res) / 32] >> ((res) % 32)) & 1) == 0)
-    AND_IMM8(s3, s1, 0xE0); // lsr 5 masking pre-applied
-    MOV32(s4, GetParityTab());
-    LDR_REG_LSR_IMM5(s4, s4, s3, 5-2);   // x/32 and then *4 because array is integer
-    AND_IMM8(s3, s1, 31);
-    MVN_REG_LSR_REG(s4, s4, s3);
+    // by xor'ing all the bit 2 by two with a shift, pair of bits are removed, and only 1 is left if bit number if odd
+    XOR_REG_LSR_IMM8(s4, s1, s1, 4);
+    XOR_REG_LSR_IMM8(s4, s4, s4, 2);
+    XOR_REG_LSR_IMM8(s4, s4, s4, 1);
+    MVN_REG_LSL_IMM5(s4, s4, 0);
    BFI(xFlags, s4, F_PF, 1);
 }

@@ -316,7 +316,7 @@
 #define IFXN(A, B)  if((dyn->insts[ninst].x86.gen_flags&(A) && !(dyn->insts[ninst].x86.gen_flags&(B))))

 // Generate FCOM with s1 and s2 scratch regs (the VCMP is already done)
-#define FCOM(s1, s2)    \
+#define FCOM(s1, s2)                                                            \
    VMRS_APSR();    /* 0b0100011100000000 */                                    \
    LDRH_IMM8(s1, xEmu, offsetof(x86emu_t, sw));   /*offset is 8bits right?*/   \
    BIC_IMM8(s1, s1, 0b01000111, 12);                                           \
@@ -327,7 +327,7 @@
    STRH_IMM8(s1, xEmu, offsetof(x86emu_t, sw))

 // Generate FCOMI with s1 and s2 scratch regs (the VCMP is already done)
-#define FCOMI(s1, s2)    \
+#define FCOMI(s1, s2)                                                       \
    IFX(X_CF|X_PF|X_ZF|X_PEND) {                                            \
        VMRS_APSR();    /* 0b111 */                                         \
        BIC_IMM8(xFlags, xFlags, 0b1000101, 0);                             \
@@ -335,12 +335,10 @@
        ORR_IMM8_COND(cEQ, xFlags, xFlags, 0b01000000, 0); /* zero */       \
        ORR_IMM8_COND(cMI, xFlags, xFlags, 0b00000001, 0); /* less than */  \
        /* greater than leave 0 */                                          \
-    }                                                                       \
-    SET_DFNONE(s1);                                                         \
-    IFX(X_OF|X_AF|X_SF|X_PEND) {                                            \
        /* clear 0b100010010000 */                                          \
        BIC_IMM8(xFlags, xFlags, 0b10001001, 14);                           \
    }                                                                       \
+    SET_DFNONE(s1);                                                         \


 #if STEP == 0
@@ -745,7 +743,7 @@ void emit_shld32c(dynarec_arm_t* dyn, int ninst, int s1, int s2, int32_t c, int
 void emit_shrd32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4);
 void emit_shld32(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3, int s4);

-void emit_pf(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4);
+void emit_pf(dynarec_arm_t* dyn, int ninst, int s1, int s4);

 // x87 helper
 // cache of the local stack counter, to avoid upadte at every call
@@ -894,21 +892,25 @@ uintptr_t dynarecF30F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nins
 #define MAYUSE(A)   
 #endif

-#define NOTEST(s1)                                          \
+#define NOTEST(s1, s2)                                      \
    if(box86_dynarec_test) {                                \
        MOVW(s1, 0);                                        \
-        STR_IMM9(s1, xEmu, offsetof(x86emu_t, test.test));  \
-        STR_IMM9(s1, xEmu, offsetof(x86emu_t, test.clean)); \
+        MOVW(s2, offsetof(x86emu_t, test.test));            \
+        STR_REG_LSL_IMM5(s1, xEmu, s2, 0);                  \
+        ADD_IMM8(s2, s2, offsetof(x86emu_t, test.clean)-offsetof(x86emu_t, test.test));\
+        STR_REG_LSL_IMM5(s1, xEmu, s2, 0);                  \
    }
-#define SKIPTEST(s1)                                        \
+#define SKIPTEST(s1, s2)                                    \
    if(box86_dynarec_test) {                                \
        MOVW(s1, 0);                                        \
-        STR_IMM9(s1, xEmu, offsetof(x86emu_t, test.clean)); \
+        MOVW(s2, offsetof(x86emu_t, test.clean));           \
+        STR_REG_LSL_IMM5(s1, xEmu, s2, 0);                  \
    }
 #define GOTEST(s1, s2)                                      \
    if(box86_dynarec_test) {                                \
        MOVW(s2, 1);                                        \
-        STR_IMM9(s2, xEmu, offsetof(x86emu_t, test.test));  \
+        MOVW(s1, offsetof(x86emu_t, test.test));            \
+        STR_REG_LSL_IMM5(s2, xEmu, s1, 0);                  \
    }

 #endif //__DYNAREC_ARM_HELPER_H__
@@ -307,14 +307,14 @@ uintptr_t arm_pass(dynarec_arm_t* dyn, uintptr_t addr)
            dyn->insts[ninst].x86.need_after |= X_PEND;
            #endif
            ++ninst;
-            NOTEST(x3);
+            NOTEST(x1, x3);
            fpu_purgecache(dyn, ninst, 0, x1, x2, x3);
            jump_to_next(dyn, addr, 0, ninst);
            ok=0; need_epilog=0;
        }
    }
    if(need_epilog) {
-        NOTEST(x3);
+        NOTEST(x1, x3);
        fpu_purgecache(dyn, ninst, 0, x1, x2, x3);
        jump_to_epilog(dyn, ip, 0, ninst);  // no linker here, it's an unknow instruction
    }
@@ -353,8 +353,10 @@ ARM_ cond 0 0 0 1 1 1 1 0 Rn Rd (1) (1) (1) (1) 1 0 0 1 Rt STREXH<c> <Rd>, <Rt>,
 ARM_ cond 0 0 0 1 1 1 1 1 Rn Rt (1) (1) (1) (1) 1 0 0 1 (1) (1) (1) (1) LDREXH<c> <Rt>, [<Rn>]
 ARM_ cond 0 0 1 0 0 0 0 S Rn Rd imm12 AND{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 0 0 1 S Rn Rd imm12 EOR{S}<c> <Rd>, <Rn>, #<const>
+ARM_ cond 0 0 1 0 0 1 0 0 1 1 1 1 Rd imm12 ADR<c> <Rd>, #-<const>
 ARM_ cond 0 0 1 0 0 1 0 S Rn Rd imm12 SUB{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 0 1 1 S Rn Rd imm12 RSB{S}<c> <Rd>, <Rn>, #<const>
+ARM_ cond 0 0 1 0 1 0 0 0 1 1 1 1 Rd imm12 ADR<c> <Rd>, #<const>
 ARM_ cond 0 0 1 0 1 0 0 S Rn Rd imm12 ADD{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 1 0 1 S Rn Rd imm12 ADC{S}<c> <Rd>, <Rn>, #<const>
 ARM_ cond 0 0 1 0 1 1 0 S Rn Rd imm12 SBC{S}<c> <Rd>, <Rn>, #<const>
@@ -1808,7 +1808,7 @@ static int my_dl_iterate_phdr_##A(struct dl_phdr_info* a, size_t b, void* c)
 {                                                                                   \
    if(!a->dlpi_name)                                                               \
        return 0;                                                                   \
-    if(!a->dlpi_name[0]) /*don't send informations about box86 itself*/             \
+    if(!a->dlpi_name[0]) /*don't send information about box86 itself*/             \
        return 0;                                                                   \
    return RunFunctionFmt(my_dl_iterate_phdr_fct_##A, "pLp", a, b, c);  \
 }
@@ -2033,6 +2033,9 @@ kh_defaultversion_t* GetWeakDefaultVersion(elfheader_t* h)
    return h?h->weakdefver:NULL;
 }

+#ifndef STT_GNU_IFUNC
+#define STT_GNU_IFUNC 10
+#endif

 uintptr_t pltResolver = ~(uintptr_t)0;
 EXPORT void PltResolver(x86emu_t* emu)
@@ -2076,6 +2079,11 @@ EXPORT void PltResolver(x86emu_t* emu)
            printf_dump(LOG_DEBUG, "symbol %s from %s but elf not initialized yet, run Init now (from %s)\n", symname, ElfName(sym_elf), ElfName(h));
            RunElfInitPltResolver(sym_elf, emu);
        }
+        if(sym_elf && sym && ((sym->st_info&0xf)==STT_GNU_IFUNC)) {
+            // this is an IFUNC, needs to evaluate the function first!
+            printf_dump(LOG_DEBUG, "            Indirect function, will call the resolver now at %p\n", (void*)offs);
+            offs = RunFunction(offs, 0);
+        }
        offs = (uintptr_t)getAlternate((void*)offs);

        if(p) {
@@ -108,7 +108,7 @@
            case 7: base =      R_BX; break;    \
        }                                       \
        switch((m>>6)&3) {                      \
-            case 0: if(m&7==6) base = F16S; break; \
+            case 0: if((m&7)==6) base = F16S; break; \
            case 1: base += F8S; break;         \
            case 2: base += F16S; break;        \
        }                                       \
@@ -49,11 +49,6 @@ static uint32_t x86emu_parity_tab[8] =
 	0x69969669,
 };

-uint32_t* GetParityTab()
-{
-    return x86emu_parity_tab;
-}
-
 static void internalX86Setup(x86emu_t* emu, box86context_t *context, uintptr_t start, uintptr_t stack, int stacksize, int ownstack)
 {
    emu->context = context;
@@ -232,10 +227,6 @@ void CloneEmu(x86emu_t *newemu, const x86emu_t* emu)
    newemu->mxcsr = emu->mxcsr;
    newemu->quit = emu->quit;
    newemu->error = emu->error;
-    // adapt R_ESP to new stack frame
-    uintptr_t oldst = (uintptr_t)((emu->init_stack)?emu->init_stack:emu->context->stack);
-    uintptr_t newst = (uintptr_t)((newemu->init_stack)?newemu->init_stack:newemu->context->stack);
-    newemu->regs[_SP].dword[0] = emu->regs[_SP].dword[0] + (intptr_t)(newst - oldst);
 }

 void CopyEmu(x86emu_t *newemu, const x86emu_t* emu)
@@ -338,6 +329,7 @@ const char* DumpCPURegs(x86emu_t* emu, uintptr_t ip)
 {
    static char buff[800];
    static const char* regname[] = {"EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"};
+    static const char* segname[] = {"ES", "CS", "SS", "DS", "FS", "GS"};
    char tmp[80];
    buff[0] = '\0';
    if(trace_emm) {
@@ -358,21 +350,27 @@ const char* DumpCPURegs(x86emu_t* emu, uintptr_t ip)
    }
    // start with FPU regs...
    if(emu->fpu_stack) {
-        if(emu->fpu_stack<9)
-            for (int i=0; i<emu->fpu_stack; i++) {
-                //if(i==4) strcat(buff, "\n");
-                sprintf(tmp, "ST%d=%f", i, emu->x87[(emu->top+i)&7].d);
-                strcat(buff, tmp);
-                int c = 10-strlen(tmp);
-                if(c<1) c=1;
-                while(c--) strcat(buff, " ");
-            }
-        else {
-            sprintf(tmp, "Warning, incoherent fpu_stack=%d", emu->fpu_stack);
+        int stack = emu->fpu_stack;
+        if(stack>8) stack = 8;
+        for (int i=0; i<stack; i++) {
+            sprintf(tmp, "ST%d=%f", i, ST(i).d);
            strcat(buff, tmp);
+            int c = 10-strlen(tmp);
+            if(c<1) c=1;
+            while(c--) strcat(buff, " ");
+            if(i==3) strcat(buff, "\n");
        }
+        sprintf(tmp, " C3210 = %d%d%d%d", emu->sw.f.F87_C3, emu->sw.f.F87_C2, emu->sw.f.F87_C1, emu->sw.f.F87_C0);
+        strcat(buff, tmp);
        strcat(buff, "\n");
    }
+    for (int i=0; i<6; ++i) {
+            sprintf(tmp, "%s=0x%04x", segname[i], emu->segs[i]);
+            strcat(buff, tmp);
+            if(i!=_GS)
+                strcat(buff, " ");
+    }
+    strcat(buff, "\n");
    for (int i=_AX; i<=_DI; ++i) {
        sprintf(tmp, "%s=%08x ", regname[i], emu->regs[i].dword[0]);
        strcat(buff, tmp);
@@ -53,12 +53,12 @@ x86emu_t* x86emu_fork(x86emu_t* emu, int forktype)
        // error...
    } else if(v!=0) {  
        // execute atforks parent functions
-        for (int i=0; i<my_context->atfork_sz; --i)
+        for (int i=0; i<my_context->atfork_sz; ++i)
            if(my_context->atforks[i].parent)
                EmuCall(emu, my_context->atforks[i].parent);
    } else if(v==0) {
        // execute atforks child functions
-        for (int i=0; i<my_context->atfork_sz; --i)
+        for (int i=0; i<my_context->atfork_sz; ++i)
            if(my_context->atforks[i].child)
                EmuCall(emu, my_context->atforks[i].child);
    }
@@ -198,6 +198,8 @@ void x86Int3(x86emu_t* emu)
                    perr = 3;
                } else  if(strstr(s, "strcasecmp")==s || strstr(s, "__strcasecmp")==s) {
                    snprintf(buff, 256, "%04d|%p: Calling %s(\"%s\", \"%s\")", tid, *(void**)(R_ESP), s, *(char**)(R_ESP+4), *(char**)(R_ESP+8));
+                } else  if(strstr(s, "wcsncasecmp")==s) {
+                    snprintf(buff, 256, "%04d|%p: Calling %s(\"%S\", \"%S\", %d)", tid, *(void**)(R_ESP), s, *(wchar_t**)(R_ESP+4), *(wchar_t**)(R_ESP+8), *(int*)(R_ESP+12));
                } else  if(strstr(s, "gtk_signal_connect_full")) {
                    snprintf(buff, 256, "%04d|%p: Calling %s(%p, \"%s\", %p, %p, %p, %p, %d, %d)", tid, *(void**)(R_ESP), "gtk_signal_connect_full", *(void**)(R_ESP+4), *(char**)(R_ESP+8), *(void**)(R_ESP+12), *(void**)(R_ESP+16), *(void**)(R_ESP+20), *(void**)(R_ESP+24), *(int32_t*)(R_ESP+28), *(int32_t*)(R_ESP+32));
                } else  if(strstr(s, "strcmp")==s || strstr(s, "__strcmp")==s) {
@@ -268,6 +270,8 @@ void x86Int3(x86emu_t* emu)
                    snprintf(buff, 256, "%04d|%p: Calling %s(%p, \"%s\")", tid, *(void**)(R_ESP), s, *(void**)(R_ESP+4), *(char**)(R_ESP+8));
                } else  if(strstr(s, "glXGetProcAddress")==s) {
                    snprintf(buff, 256, "%04d|%p: Calling %s(\"%s\")", tid, *(void**)(R_ESP), s, *(char**)(R_ESP+4));
+                } else if (!strcmp(s, "glTexImage2D")) {
+                    snprintf(buff, 256, "%04d|%p: Calling %s(0x%x, %d, 0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", tid, *(void**)(R_ESP), s, *(uint32_t*)(R_ESP+4), *(int*)(R_ESP+8), *(int*)(R_ESP+12), *(int*)(R_ESP+16), *(int*)(R_ESP+20), *(int*)(R_ESP+24), *(uint32_t*)(R_ESP+28), *(uint32_t*)(R_ESP+32), *(void**)(R_ESP+36));
                } else  if(strstr(s, "sscanf")==s) {
                    snprintf(buff, 256, "%04d|%p: Calling %s(\"%s\", \"%s\", ...)", tid, *(void**)(R_ESP), s, *(char**)(R_ESP+4), *(char**)(R_ESP+8));
                } else  if(!strcmp(s, "vsscanf")) {
@@ -298,6 +302,10 @@ void x86Int3(x86emu_t* emu)
                } else  if(strstr(s, "__tls_get_addr")) {
                    pu32 = *(uint32_t**)(R_ESP+4);
                    snprintf(buff, 256, "%04d|%p: Calling %s(%p[%d, %d])", tid, *(void**)(R_ESP), s, pu32, pu32[0], pu32[1]);
+                } else if (!strcmp(s, "FT_Outline_Get_CBox")) {
+                    pu32 = *(uint32_t**)(R_ESP+8);
+                    snprintf(buff, 256, "%04d|%p: Calling %s(%p, %p)", tid, *(void**)(R_ESP), s, *(void**)(R_ESP+4), *(void**)(R_ESP+8));
+                    post = 7;
                } else if (!strcmp(s, "XDrawImageString")) {
                    snprintf(buff, 256, "%04d|%p: Calling %s(%p, %p, %p, %i, %i, %p\"%s\", %d)", tid, *(void**)(R_ESP), s, *(void**)(R_ESP+4), *(void**)(R_ESP+8), *(void**)(R_ESP+12), *(int*)(R_ESP+16), *(int*)(R_ESP+20), *(char**)(R_ESP+24), *(char**)(R_ESP+24), *(int*)(R_ESP+28));
                } else {
@@ -329,6 +337,8 @@ void x86Int3(x86emu_t* emu)
                            break;
                    case 6: snprintf(buff2, 63, "(%S)", pu32?((wchar_t*)pu32):L"nil");
                            break;
+                    case 7: snprintf(buff2, 63, " [%d / %d / %d /%d]", pu32[0], pu32[1], pu32[2], pu32[3]);
+                            break;
                }
                if(perr==1 && ((int)R_EAX)<0)
                    snprintf(buff3, 63, " (errno=%d:\"%s\")", errno, strerror(errno));
@@ -229,6 +229,15 @@ uintptr_t Run0F(x86emu_t *emu, uintptr_t addr, int *step)
            nextop = F8;
            GET_ED_;
            break;
+        case 0x20:                      /* MOV REG, crX */
+        case 0x21:                      /* MOV REG, drX */
+        case 0x22:                      /* MOV cxR, REG */
+        case 0x23:                      /* MOV drX, REG */
+            // this is a privilege opcode...
+            #ifndef TEST_INTERPRETER
+            emit_signal(emu, SIGSEGV, (void*)R_EIP, 0);
+            #endif
+            break;

        case 0x28:                      /* MOVAPS Gx,Ex */
            nextop = F8;
@@ -261,7 +270,7 @@ uintptr_t Run0F(x86emu_t *emu, uintptr_t addr, int *step)
                GM.sd[1] = 0x80000000;
            else
                GM.sd[1] = EX->f[1];
-            if(isnanf(EX->f[0]) || isinff(EX->f[0]) || EX->f[0]>=(float)0x80000000U || EX->f[1]<-(float)0x80000000U)
+            if(isnanf(EX->f[0]) || isinff(EX->f[0]) || EX->f[0]>=(float)0x80000000U || EX->f[0]<-(float)0x80000000U)
                GM.sd[0] = 0x80000000;
            else
                GM.sd[0] = EX->f[0];
@@ -12,6 +12,7 @@
 #include "x86trace.h"
 #include "box86context.h"
 #include "bridge.h"
+#include "signals.h"
 #ifdef DYNAREC
 #include "../dynarec/arm_lock_helper.h"
 #endif
@@ -416,6 +417,40 @@ uintptr_t Run64(x86emu_t *emu, int seg, uintptr_t addr)
            return addr-1;       // ignore FS: to execute regular opcode
            break;

+        case 0xF7:                      /* GRP3 Ed(,Id) */
+            nextop = F8;
+            GET_ED_OFFS(tlsdata);
+            switch((nextop>>3)&7) {
+                case 0: 
+                case 1:                 /* TEST Ed,Id */
+                    tmp32u = F32;
+                    test32(emu, ED->dword[0], tmp32u);
+                    break;
+                case 2:                 /* NOT Ed */
+                    ED->dword[0] = not32(emu, ED->dword[0]);
+                    break;
+                case 3:                 /* NEG Ed */
+                    ED->dword[0] = neg32(emu, ED->dword[0]);
+                    break;
+                case 4:                 /* MUL EAX,Ed */
+                    mul32_eax(emu, ED->dword[0]);
+                    break;
+                case 5:                 /* IMUL EAX,Ed */
+                    imul32_eax(emu, ED->dword[0]);
+                    break;
+                case 6:                 /* DIV Ed */
+                    if(!ED->dword[0])
+                        emit_div0(emu, (void*)R_EIP, 0);
+                    div32(emu, ED->dword[0]);
+                    break;
+                case 7:                 /* IDIV Ed */
+                    if(!ED->dword[0])
+                        emit_div0(emu, (void*)R_EIP, 0);
+                    idiv32(emu, ED->dword[0]);
+                    break;
+            }
+            break;
+
        case 0xFF:              /* GRP 5 Ed */
            nextop = F8;
            GET_ED_OFFS(tlsdata);
@@ -48,6 +48,12 @@ uintptr_t Run6466(x86emu_t *emu, uintptr_t tlsdata, uintptr_t addr)
            GW.word[0] = EW->word[0];
            break;

+        case 0x8D:                      	    /* LEA Gw,M */
+            nextop = F8;
+            GET_ED_;    // segment doesn't enter in the computation
+            GW.word[0] = (uint16_t)(uint32_t)ED;
+            break;
+
        default:
            return 0;
    }
@@ -284,7 +284,11 @@ uintptr_t Run66(x86emu_t *emu, int rep, uintptr_t addr)
            GET_EW;
            EW->word[0] = emu->segs[(nextop&0x38)>>3];
            break;
-        
+        case 0x8D:                      	/* LEA Gw,M */
+            nextop = F8;
+            GET_ED_;
+            GW.word[0] = (uint16_t)(uint32_t)ED;
+            break;
        case 0x8E:                               /* MOV Seg,Ew */
            nextop = F8;
            GET_EW;
@@ -584,4 +588,4 @@ uintptr_t Run66(x86emu_t *emu, int rep, uintptr_t addr)
            return 0;
    }
    return addr;
-}
+}
@@ -812,7 +812,10 @@ uintptr_t GetSegmentBaseEmu(x86emu_t* emu, int seg)

 const char* getAddrFunctionName(uintptr_t addr)
 {
-    static char ret[1000];
+    static char rets[8][1000];
+    static int idx = 0;
+    char* ret = rets[idx];
+    idx = (idx+1)&7;
    uint32_t sz = 0;
    uintptr_t start = 0;
    elfheader_t* elf = FindElfAddress(my_context, addr);
@@ -920,7 +923,11 @@ void PrintTrace(x86emu_t* emu, uintptr_t ip, int dynarec)
            if(peek==0xC3 || peek==0xC2) {
                printf_log(LOG_NONE, " => %p", *(void**)(R_ESP));
                printFunctionAddr(*(uintptr_t*)(R_ESP), "=> ");
-            } else if(peek==0x55) {
+            } else if(peek==0x55 || peek==0x57 || peek==0x53) {
+                printf_log(LOG_NONE, " => STACK_TOP: %p", *(void**)(R_ESP));
+                printFunctionAddr(*(uintptr_t*)(R_ESP), "top:");
+                printFunctionAddr(ip, "here: ");
+            } else if(peek==0x83 && PK(1)==0xEC) {
                printf_log(LOG_NONE, " => STACK_TOP: %p", *(void**)(R_ESP));
                printFunctionAddr(*(uintptr_t*)(R_ESP), "top:");
                printFunctionAddr(ip, "here: ");
@@ -144,9 +144,20 @@ uintptr_t RunD9(x86emu_t *emu, uintptr_t addr)
            emu->sw.f.F87_C1 = 0;
            break;
        case 0xF4:  /* FXTRACT */
-            ST0.d = frexp(ST0.d, &tmp32s);
            fpu_do_push(emu);
-            ST0.d = tmp32s;
+            if(isnan(ST1.d)) {
+                ST0.d = ST1.d;
+            } else if(isinf(ST1.d)) {
+                ST0.d = ST1.d;
+                ST1.d = INFINITY;
+            } else if(ST1.d==0.0) {
+                ST0.d = ST1.d;
+                ST1.d = -INFINITY;
+            } else {
+                // LD80bits doesn't have implicit "1" bit, so need to adjust for that
+                ST0.d = frexp(ST1.d, &tmp32s)*2;
+                ST1.d = tmp32s-1;
+            }
            // C1 set only if stack under/overflow occurs
            break;

@@ -172,10 +172,10 @@ uintptr_t RunDB(x86emu_t *emu, uintptr_t addr)
                break;
            case 7: /* FSTP tbyte */
                GET_EDT;
-                if(ST0.q!=STld(0).uref)
-                    D2LD(&ST0.d, ED);
-                else
+                if(STld(0).uref && (ST0.q==STld(0).uref))
                    memcpy(ED, &STld(0).ld, 10);
+                else
+                    D2LD(&ST0.d, ED);
                fpu_do_pop(emu);
                break;
            default:
@@ -147,7 +147,7 @@ uintptr_t RunF066(x86emu_t *emu, uintptr_t addr)
                        } while(arm_lock_write_h(ED, inc16(emu, tmp16u)));
 #else
                    pthread_mutex_lock(&emu->context->mutex_lock);
-                    ED->dword[0] = inc32(emu, ED->dword[0]);
+                    ED->word[0] = inc16(emu, ED->word[0]);
                    pthread_mutex_unlock(&emu->context->mutex_lock);
 #endif
                    break;
@@ -168,7 +168,7 @@ uintptr_t RunF066(x86emu_t *emu, uintptr_t addr)
                        } while(arm_lock_write_h(ED, dec16(emu, tmp16u)));
 #else
                    pthread_mutex_lock(&emu->context->mutex_lock);
-                    ED->dword[0] = dec32(emu, ED->dword[0]);
+                    ED->word[0] = dec16(emu, ED->word[0]);
                    pthread_mutex_unlock(&emu->context->mutex_lock);
 #endif
                    break;
@@ -116,6 +116,7 @@ int my_socketcall(x86emu_t* emu, int n, unsigned long *args) {
 #define O_NONBLOCK 04000
 #endif
 int my_fcntl(x86emu_t* emu, int fd, int cmd, ... /* arg */ );
+long my_ptrace(x86emu_t* emu, int request, pid_t pid, void* addr, uint32_t* data);

 // Syscall table for x86 can be found here: http://shell-storm.org/shellcode/files/syscalls.html
 typedef struct scwrap_s {
@@ -141,6 +142,7 @@ scwrap_t syscallwrap[] = {
    [19] { __NR_lseek, 3 },
    [20] { __NR_getpid, 0 },
    [24] { __NR_getuid, 0 },
+    //[26] ={__NR_ptrace, 4},
 #ifdef __NR_alarm
    [27] { __NR_alarm, 1 },
 #endif
@@ -485,6 +487,11 @@ void EXPORT x86Syscall(x86emu_t *emu)
                S_EAX = -errno;
            break;
 #endif
+        case 26:    // sys_ptrace
+            S_EAX = my_ptrace(emu, R_EBX, R_ECX, (void*)R_EDX, (void*)R_ESI);
+            if(S_EAX==-1 && errno>0)
+                S_EAX = -errno;
+            break;
 #ifndef __NR_alarm
        case 27:
            R_EAX = alarm(R_EBX);
@@ -581,6 +588,7 @@ void EXPORT x86Syscall(x86emu_t *emu)
            break;
        case 120:   // clone
            // x86 raw syscall is long clone(unsigned long flags, void *stack, int *parent_tid, unsigned long tls, int *child_tid);
+            printf_log(LOG_DEBUG, "clone syscall flags=0x%x, stack=%p, parent_tid=%d,tls=%p, child_tid=%d\n", R_EBX, (void*)R_ECX, R_EDX, (void*)R_ESI, R_EDI);
            // so flags=R_EBX, stack=R_ECX, parent_tid=R_EDX, tls=R_ESI, child_tid=R_EDI
            if((R_EBX&~0xff)==0x4100) {
                // this is a case of vfork...
@@ -592,6 +600,7 @@ void EXPORT x86Syscall(x86emu_t *emu)
                {
                    void* stack_base = (void*)R_ECX;
                    int stack_size = 0;
+                    uintptr_t sp = R_ECX;
                    if(!R_ECX) {
                        // allocate a new stack...
                        int currstack = 0;
@@ -600,18 +609,19 @@ void EXPORT x86Syscall(x86emu_t *emu)
                        stack_size = (currstack)?emu->size_stack:(1024*1024);
                        stack_base = mmap(NULL, stack_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_GROWSDOWN, -1, 0);
                        // copy value from old stack to new stack
-                        if(currstack)
+                        if(currstack) {
                            memcpy(stack_base, emu->init_stack, stack_size);
-                        else {
+                            sp = (uintptr_t)emu->init_stack + R_ESP - (uintptr_t)stack_base;
+                        } else {
                            int size_to_copy = (uintptr_t)emu->init_stack + emu->size_stack - (R_ESP);
                            memcpy(stack_base+stack_size-size_to_copy, (void*)R_ESP, size_to_copy);
+                            sp = (uintptr_t)stack_base+stack_size-size_to_copy;
                        }
                    }
                    x86emu_t * newemu = NewX86Emu(emu->context, R_EIP, (uintptr_t)stack_base, stack_size, (R_ECX)?0:1);
                    SetupX86Emu(newemu);
                    CloneEmu(newemu, emu);
-                    Push32(newemu, 0);
-                    PushExit(newemu);
+                    newemu->regs[_SP].dword[0] = sp;  // setupnew stack pointer
                    void* mystack = NULL;
                    if(my_context->stack_clone_used) {
                        mystack = box_malloc(1024*1024);  // stack for own process... memory leak, but no practical way to remove it
@@ -685,7 +695,7 @@ void EXPORT x86Syscall(x86emu_t *emu)
            {   
                struct stat64 st;
                unsigned int r = syscall(__NR_stat64, R_EBX, &st);
-                UnalignStat64(&st, (void*)R_ECX);
+                UnalignSysStat64(&st, (void*)R_ECX);
                
                R_EAX = r;
            }
@@ -696,7 +706,7 @@ void EXPORT x86Syscall(x86emu_t *emu)
            {   
                struct stat64 st;
                unsigned int r = syscall(__NR_lstat64, R_EBX, &st);
-                UnalignStat64(&st, (void*)R_ECX);
+                UnalignSysStat64(&st, (void*)R_ECX);
                
                R_EAX = r;
            }
@@ -707,7 +717,7 @@ void EXPORT x86Syscall(x86emu_t *emu)
            {   
                struct stat64 st;
                unsigned int r = syscall(__NR_fstat64, R_EBX, &st);
-                UnalignStat64(&st, (void*)R_ECX);
+                UnalignSysStat64(&st, (void*)R_ECX);
                
                R_EAX = r;
            }
@@ -850,6 +860,7 @@ long EXPORT my_syscall(x86emu_t *emu)
            {
                void* stack_base = p(8);
                int stack_size = 0;
+                uintptr_t sp = u32(8);
                if(!stack_base) {
                    // allocate a new stack...
                    int currstack = 0;
@@ -858,18 +869,19 @@ long EXPORT my_syscall(x86emu_t *emu)
                    stack_size = (currstack)?emu->size_stack:(1024*1024);
                    stack_base = mmap(NULL, stack_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_GROWSDOWN, -1, 0);
                    // copy value from old stack to new stack
-                    if(currstack)
+                    if(currstack) {
                        memcpy(stack_base, emu->init_stack, stack_size);
-                    else {
+                        sp = (uintptr_t)emu->init_stack + R_ESP - (uintptr_t)stack_base;
+                    } else {
                        int size_to_copy = (uintptr_t)emu->init_stack + emu->size_stack - (R_ESP);
                        memcpy(stack_base+stack_size-size_to_copy, (void*)R_ESP, size_to_copy);
+                        sp = (uintptr_t)stack_base+stack_size-size_to_copy;
                    }
                }
                x86emu_t * newemu = NewX86Emu(emu->context, R_EIP, (uintptr_t)stack_base, stack_size, (p(8))?0:1);
                SetupX86Emu(newemu);
                CloneEmu(newemu, emu);
-                Push32(newemu, 0);
-                PushExit(newemu);
+                newemu->regs[_SP].dword[0] = sp;
                void* mystack = NULL;
                if(my_context->stack_clone_used) {
                    mystack = box_malloc(1024*1024);  // stack for own process... memory leak, but no practical way to remove it
@@ -924,7 +936,7 @@ long EXPORT my_syscall(x86emu_t *emu)
 #endif
 #ifndef __NR_memfd_create
        case 356:  // memfd_create
-            return my_memfd_create(emu, (void*)R_EBX, R_ECX);
+            return my_memfd_create(emu, p(4), u32(8));
 #endif
        case 449:
            #ifdef __NR_futex_waitv
@@ -241,8 +241,8 @@ void* resizeTLSData(box86context_t *context, void* oldptr)
                for (int i=oldata->n_elfs; i<context->elfsize; ++i) {
                    // set pointer
                    dtp = (uintptr_t)ptr + GetTLSBase(context->elfs[i]);
-                    *(uint64_t*)((uintptr_t)ptr+POS_TLS+i*8) = dtp;
-                    *(uint64_t*)((uintptr_t)ptr+POS_TLS+i*8+4) = i; // index
+                    *(uint32_t*)((uintptr_t)ptr+POS_TLS+i*8) = dtp;
+                    *(uint32_t*)((uintptr_t)ptr+POS_TLS+i*8+4) = i; // index
                }
                oldata->n_elfs = context->elfsize;
            }
@@ -77,53 +77,45 @@ void LD2D(void* ld, void* d)
        *(uint64_t*)d = *(uint64_t*)ld;
        return;
    }
-	FPU_t result;
+    FPU_t result;
    #pragma pack(push, 1)
-	struct {
-		FPU_t f;
-		int16_t b;
-	} val;
+    struct {
+        FPU_t f;
+        int16_t b;
+    } val;
    #pragma pack(pop)
    #if 1
    memcpy(&val, ld, 10);
    #else
-	val.f.ud[0] = *(uint32_t*)ld;
+    val.f.ud[0] = *(uint32_t*)ld;
    val.f.ud[1] = *(uint32_t*)(char*)(ld+4);
-	val.b  = *(int16_t*)((char*)ld+8);
+    val.b  = *(int16_t*)((char*)ld+8);
    #endif
-	int32_t exp64 = (((uint32_t)(val.b&0x7fff) - BIAS80) + BIAS64);
-	int32_t exp64final = exp64&0x7ff;
    // do specific value first (0, infinite...)
    // bit 63 is "integer part"
-    // bit 62 is sign
    if((uint32_t)(val.b&0x7fff)==0x7fff) {
        // infinity and nans
-        int t = 0; //nan
-        switch((val.f.ud[1]>>30)) {
-            case 0: if((val.f.ud[1]&(1<<29))==0) t = 1;
-                    break;
-            case 2: if((val.f.ud[1]&(1<<29))==0) t = 1;
-                    break;
-        }
+        int t = (val.f.q&0x7fffffffffffffffLL)?0:1;
        if(t) {    // infinite
-            result.d = HUGE_VAL;
-        } else {      // NaN
-            result.ud[1] = 0x7ff << 20;
+            result.ud[1] = (val.b>>4) << 20;
            result.ud[0] = 0;
+        } else {      // NaN
+            result.ud[1] = (val.b>>4) << 20 | ((val.f.q>>(63-20))&0x000fffff);
+            result.ud[0] = (val.f.q>>(63-56))&0xffffffff;
+            if(!(result.q&0x000fffffffffffffLL))
+                result.q |= 1;
        }
-        if(val.b&0x8000)
-            result.ud[1] |= 0x80000000;
        *(uint64_t*)d = result.q;
        return;
    }
+    int32_t exp64 = (((uint32_t)(val.b&0x7fff) - BIAS80) + BIAS64);
+    int32_t exp64final = exp64&0x7ff;
    if(((uint32_t)(val.b&0x7fff)==0) || (exp64<-1074)) {
-        //if(val.f.ll==0)
+        //if(val.f.q==0)
        // zero
-        //if(val.f.ll!=0)
+        //if(val.f.q!=0)
        // denormal, but that's to small value for double 
-        uint64_t r = 0;
-        if(val.b&0x8000)
-            r |= 0x8000000000000000LL;
+        uint64_t r = (val.b&0x8000)?0x8000000000000000LL:0LL;
        *(uint64_t*)d = r;
        return;
    }
@@ -149,12 +141,12 @@ void LD2D(void* ld, void* d)
        return;
    }

-	uint64_t mant64 = (val.f.q >> 11) & 0xfffffffffffffLL;
-	uint32_t sign = (val.b&0x8000)?1:0;
+    uint64_t mant64 = (val.f.q >> 11) & 0xfffffffffffffL;
+    uint32_t sign = (val.b&0x8000)?1:0;
    result.q = mant64;
-	result.ud[1] |= (sign <<31)|((exp64final&0x7ff) << 20);
+    result.ud[1] |= (sign <<31)|((exp64final&0x7ff) << 20);

-	*(uint64_t*)d = result.q;
+    *(uint64_t*)d = result.q;
 }

 // double (64bits) -> long double (80bits)
@@ -165,40 +157,37 @@ void D2LD(void* d, void* ld)
        return;
    }
    #pragma pack(push, 1)
-	struct {
-		FPU_t f;
-		int16_t b;
-	} val;
+    struct {
+        FPU_t f;
+        int16_t b;
+    } val;
    #pragma pack(pop)
    FPU_t s;
    s.q = *(uint64_t*)d;   // use memcpy to avoid risk of Bus Error?
    // do special value first
-    if((s.q&0x7fffffffffffffffLL)==0) {
+    if((s.q&0x7fffffffffffffffL)==0) {
        // zero...
        val.f.q = 0;
-        if(s.ud[1]&0x8000)
-            val.b = 0x8000;
-        else
-            val.b = 0;
+        val.b = (s.ud[1]&0x80000000)?0x8000:0;
        memcpy(ld, &val, 10);
        return;
    }

-	int32_t sign80 = (s.ud[1]&0x80000000)?1:0;
-	int32_t exp80 =  s.ud[1]&0x7ff00000;
-	int32_t exp80final = (exp80>>20);
-	int64_t mant80 = s.sq&0x000fffffffffffffLL;
-	int64_t mant80final = (mant80 << 11);
+    int32_t sign80 = (s.ud[1]&0x80000000)?1:0;
+    int32_t exp80 =  s.ud[1]&0x7ff00000;
+    int32_t exp80final = (exp80>>20);
+    uint64_t mant80 = s.q&0x000fffffffffffffL;
+    uint64_t mant80final = (mant80 << 11);
    if(exp80final==0x7ff) {
        // NaN and Infinite
        exp80final = 0x7fff;
        if(mant80==0x0)
-            mant80final = 0x8000000000000000LL; //infinity
+            mant80final = 0x8000000000000000L; //infinity
        else
-            mant80final = 0xc000000000000000LL; //(quiet)NaN
+            mant80final |= 0x8000000000000000L; //(quiet)NaN
    } else {
        if(exp80!=0){ 
-            mant80final |= 0x8000000000000000LL;
+            mant80final |= 0x8000000000000000L;
            exp80final += (BIAS80 - BIAS64);
        } else if(mant80final!=0) {
            // denormals -> normal
@@ -208,8 +197,8 @@ void D2LD(void* d, void* ld)
            mant80final<<=one;
        }
    }
-	val.b = ((int16_t)(sign80)<<15)| (int16_t)(exp80final);
-	val.f.sq = mant80final;
+    val.b = ((int16_t)(sign80)<<15)| (int16_t)(exp80final);
+    val.f.q = mant80final;
    memcpy(ld, &val, 10);
    /*memcpy(ld, &f.ll, 8);
    memcpy((char*)ld + 8, &val.b, 2);*/
@@ -295,7 +284,7 @@ void fpu_fxsave(x86emu_t* emu, void* ed)
    int top = emu->top&7;
    int stack = 8-top;
    if(top==0)  // check if stack is full or empty, based on tag[0]
-        stack = (emu->fpu_tags&0b11)?8:0;
+        stack = (emu->fpu_tags)?8:0;
    emu->sw.f.F87_TOP = top;
    p->ControlWord = emu->cw.x16;
    p->StatusWord = emu->sw.x16;
@@ -303,7 +292,7 @@ void fpu_fxsave(x86emu_t* emu, void* ed)
    p->MxCsr_Mask = 0;
    uint8_t tags = 0;
    for (int i=0; i<8; ++i)
-        tags |= ((emu->fpu_tags>>(i*2))&0b11)?0:1;
+        tags |= (((emu->fpu_tags>>(i*2))&0b11)?0:1)<<i;
    p->TagWord = tags;
    p->ErrorOpcode = 0;
    p->ErrorOffset = 0;
@@ -327,12 +316,12 @@ void fpu_fxrstor(x86emu_t* emu, void* ed)
    uint8_t tags = p->TagWord;
    emu->fpu_tags = 0;
    for(int i=0; i<8; ++i)
-        emu->fpu_tags |= (((tags>>(i*2))&0b1)?0:0b11)<<(i*2);
+        emu->fpu_tags |= (((tags>>i)&0b1)?0:0b11)<<(i*2);
    // copy back MMX regs...
    int top = emu->top&7;
    int stack = 8-top;
    if(top==0)  // check if stack is full or empty, based on tag[0]
-        stack = (emu->fpu_tags&0b11)?8:0;
+        stack = (emu->fpu_tags)?0:8;
    for(int i=0; i<8; ++i)
        memcpy((i<stack)?&ST(i):&emu->mmx[i], &p->FloatRegisters[i].q[0], sizeof(mmx87_regs_t));
    // copy SSE regs
@@ -10,6 +10,8 @@ extern int box86_dynarec;
 extern uintptr_t box86_pagesize;
 extern uintptr_t box86_load_addr;
 extern int box86_showbt;
+extern int box86_maxcpu;
+extern int box86_maxcpu_immutable;
 #ifdef DYNAREC
 extern int box86_dynarec_dump;
 extern int box86_dynarec_trace;
@@ -59,6 +61,7 @@ extern int box86_musl;
 extern int box86_nopulse;   // disabling the use of wrapped pulseaudio
 extern int box86_nogtk; // disabling the use of wrapped gtk
 extern int box86_novulkan;  // disabling the use of wrapped vulkan
+extern int box86_nocrashhandler;
 extern int box86_futex_waitv;
 extern int box86_mapclean;
 extern int box86_showsegv;
@@ -25,8 +25,11 @@ void myStackAlignW(const char* fmt, uint32_t* st, uint32_t* mystack);

 void AlignStat64(const void* source, void* dest);
 void UnalignStat64(const void* source, void* dest);
+void UnalignSysStat64(const void* source, void* dest);
+void UnalignStat(const void* source, void* dest);

 void UnalignStatFS64(const void* source, void* dest);
+void UnalignStatFS(const void* source, void* dest);

 void UnalignOggVorbis(void* dest, void* source); // Arm -> x86
 void AlignOggVorbis(void* dest, void* source);   // x86 -> Arm
@@ -43,6 +46,9 @@ void AlignEpollEvent(void* dest, void* source, int nbr); // x86 -> Arm
 void UnalignSmpegInfo(void* dest, void* source); // Arm -> x86
 void AlignSmpegInfo(void* dest, void* source);   // x86 -> Arm

+void Timespec2Timespec64(void* dest, const void* source);
+void Timespec642Timespec(void* dest, const void* source);
+
 // stat64 is packed on i386, not on arm (and possibly other structures)
 #undef st_atime
 #undef st_atime_nsec
@@ -50,19 +56,43 @@ void AlignSmpegInfo(void* dest, void* source);   // x86 -> Arm
 #undef st_mtime_nsec
 #undef st_ctime
 #undef st_ctime_nsec
+
+struct i386_stat {
+	uint64_t  st_dev;
+	uint32_t  __pad1;
+	uint32_t  st_ino;
+	uint32_t  st_mode;
+	uint32_t  st_nlink;
+	uint32_t  st_uid;
+	uint32_t  st_gid;
+	uint64_t  st_rdev;
+	uint32_t  __pad2;
+	int32_t   st_size;
+	int32_t   st_blksize;
+	int32_t   st_blocks;
+	int32_t   st_atime_sec;
+	uint32_t  st_atime_nsec;
+	int32_t   st_mtime_sec;
+	uint32_t  st_mtime_nsec;
+	int32_t   st_ctime_sec;
+	uint32_t  st_ctime_nsec;
+	uint32_t  __unused4;
+	uint32_t  __unused5;
+} __attribute__((packed));
+
 struct i386_stat64 {
 	uint64_t	st_dev;
-	uint8_t		__pad0[4];
-	uint32_t		__st_ino;
-	uint32_t		st_mode;
-	uint32_t		st_nlink;
-	uint32_t		st_uid;
-	uint32_t		st_gid;
+	uint32_t	__pad0;
+	uint32_t	__st_ino;
+	uint32_t	st_mode;
+	uint32_t	st_nlink;
+	uint32_t	st_uid;
+	uint32_t	st_gid;
 	uint64_t	st_rdev;
-	uint8_t		__pad3[4];
+	uint32_t	__pad3;
 	int64_t		st_size;
-	uint32_t		st_blksize;
-	uint64_t		st_blocks;
+	uint32_t	st_blksize;
+	uint64_t	st_blocks;
 	uint32_t	st_atime;
 	uint32_t	st_atime_nsec;
 	uint32_t	st_mtime;
@@ -0,0 +1,9 @@
+#ifndef __STAT64_HELPER_H_
+#define __STAT64_HELPER_H_
+
+int stat64_time64_helper(void *path, void *buf);
+int fstatat64_time64_helper(int dirfd, void *path, void *buf, int flags);
+int fstat64_time64_helper(int fd, void *buf);
+int lstat64_time64_helper(void *path, void *buf);
+
+#endif
@@ -14,7 +14,6 @@ void CopyEmu(x86emu_t *newemu, const x86emu_t* emu);
 void SetTraceEmu(uintptr_t trace_start, uintptr_t trace_end);

 box86context_t* GetEmuContext(x86emu_t* emu);
-uint32_t* GetParityTab();

 uint32_t GetEAX(x86emu_t *emu);
 uint64_t GetEDXEAX(x86emu_t *emu);
@@ -380,14 +380,14 @@ static void initDummyLib(library_t *lib)

 static const char* essential_libs[] = {
    "libc.so.6", "libpthread.so.0", "librt.so.1", "libGL.so.1", "libGL.so", "libX11.so.6", 
-    "libasound.so.2", "libdl.so.2", "libm.so.6",
+    "libasound.so.2", "libdl.so.2", "libm.so.6", "libbsd.so.0", "libbsd.so", "ld-linux.so.2",
    "libXxf86vm.so.1", "libXinerama.so.1", "libXrandr.so.2", "libXext.so.6", "libXfixes.so.3", "libXcursor.so.1",
    "libXrender.so.1", "libXft.so.2", "libXi.so.6", "libXss.so.1", "libXpm.so.4", "libXau.so.6", "libXdmcp.so.6",
    "libX11-xcb.so.1", "libxcb.so.1", "libxcb-xfixes.so.0", "libxcb-shape.so.0", "libxcb-shm.so.0", "libxcb-randr.so.0",
    "libxcb-image.so.0", "libxcb-keysyms.so.1", "libxcb-xtest.so.0", "libxcb-glx.so.0", "libxcb-dri2.so.0", "libxcb-dri3.so.0",
    "libXtst.so.6", "libXt.so.6", "libXcomposite.so.1", "libXdamage.so.1", "libXmu.so.6", "libxkbcommon.so.0", 
    "libxkbcommon-x11.so.0", "libpulse-simple.so.0", "libpulse.so.0", "libvulkan.so.1", "libvulkan.so",
-    "ld-linux-x86-64.so.2", "crashhandler.so", "libtcmalloc_minimal.so.0", "libtcmalloc_minimal.so.4"
+    "crashhandler.so", "libtcmalloc_minimal.so.0", "libtcmalloc_minimal.so.4"
 };
 static int isEssentialLib(const char* name) {
    for (int i=0; i<sizeof(essential_libs)/sizeof(essential_libs[0]); ++i)
@@ -452,6 +452,15 @@ library_t *NewLibrary(const char* path, box86context_t* context, elfheader_t* ve
            return NULL;
        }
    }
+    if(box86_nocrashhandler) {
+        if(strstr(lib->name, "crashhandler.so")==lib->name) {
+            box_free(lib->name);
+            box_free(lib->path);
+            initDummyLib(lib);
+            //box_free(lib);
+            return NULL;
+        }
+    }
    int notwrapped = FindInCollection(lib->name, &context->box86_emulated_libs);
    int essential = isEssentialLib(lib->name);
    if(!notwrapped && box86_prefer_emulated && !essential)
@@ -5,9 +5,12 @@
 GO("libpthread.so.0", libpthread)
 GO("librt.so.1", librt)
 GO("libbsd.so.0", libbsd)
+GO("libbsd.so", libbsd)
 GO("libGL.so.1", libgl)
 GO("libGL.so", libgl)
 GO("libGLU.so.1", libglu)
+GO("libGLX.so.0", libglx)
+GO("libGLX.so", libglx)
 GO("libX11.so.6", libx11)
 GO("libasound.so.2", libasound)
 GO("libSDL2-2.0.so.0", sdl2)
@@ -183,7 +186,6 @@ GO("libpcre.so.3", libpcre)
 #ifdef ANDROID
 GO("libc.so", libc)
 GO("libm.so", libm)
-GO("libbsd.so", libbsd)
 GO("libdl.so", libdl)
 GO("libcups.so", libcups)
 GO("liblber-2.4.so", lber)
@@ -265,5 +267,5 @@ GO("libxml2.so.2", xml2)

 GO("ld-linux.so.2", ldlinux)

-GO("crashhandler.so", crashhandler)
+//GO("crashhandler.so", crashhandler)
 GO("libv4l2.so.0", libv4l2)
@@ -1,5 +1,6 @@
 #undef _LARGEFILE_SOURCE
 #undef _FILE_OFFSET_BITS
+#undef _TIME_BITS
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -7,6 +8,8 @@
 #include <wchar.h>
 #include <sys/epoll.h>
 #include <fts.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>

 #include "x86emu.h"
 #include "emu/x86emu_private.h"
@@ -917,3 +920,87 @@ void unalignNGValue(void* value, my_GValue_t* v, int n)
        --n;
    }
 }
+
+void UnalignStat(const void* source, void* dest)
+{
+    struct i386_stat *i386st = (struct i386_stat*)dest;
+    struct stat *st = (struct stat*) source;
+    
+    i386st->__pad1 = 0;
+	i386st->__pad2 = 0;
+    i386st->st_dev      = st->st_dev;
+    i386st->st_ino      = st->st_ino;
+    i386st->st_mode     = st->st_mode;
+    i386st->st_nlink    = st->st_nlink;
+    i386st->st_uid      = st->st_uid;
+    i386st->st_gid      = st->st_gid;
+    i386st->st_rdev     = st->st_rdev;
+    i386st->st_size     = st->st_size;
+    i386st->st_blksize  = st->st_blksize;
+    i386st->st_blocks   = st->st_blocks;
+    #if defined(__USE_XOPEN2K8) || defined(ANDROID) || defined(PANDORA)
+    i386st->st_atime_sec    = st->st_atim.tv_sec;
+    i386st->st_atime_nsec   = st->st_atim.tv_nsec;
+    i386st->st_mtime_sec    = st->st_mtim.tv_sec;
+    i386st->st_mtime_nsec   = st->st_mtim.tv_nsec;
+    i386st->st_ctime_sec    = st->st_ctim.tv_sec;
+    i386st->st_ctime_nsec   = st->st_ctim.tv_nsec;
+    #else
+    i386st->st_atime_sec    = st->st_atime;
+    i386st->st_atime_nsec   = st->st_atimensec;
+    i386st->st_mtime_sec    = st->st_mtime;
+    i386st->st_mtime_nsec   = st->st_mtimensec;
+    i386st->st_ctime_sec    = st->st_ctime;
+    i386st->st_ctime_nsec   = st->st_ctimensec;
+    #endif
+}
+
+void UnalignStatFS(const void* source, void* dest)
+{
+    struct i386_statfs *i386st = (struct i386_statfs*)dest;
+    struct statfs *st = (struct statfs*) source;
+
+    i386st->f_type      = st->f_type;
+    i386st->f_bsize     = st->f_bsize;
+    i386st->f_blocks    = st->f_blocks;
+    i386st->f_bfree     = st->f_bfree;
+    i386st->f_bavail    = st->f_bavail;
+    i386st->f_files     = st->f_files;
+    i386st->f_ffree     = st->f_ffree;
+    memcpy(&i386st->f_fsid, &st->f_fsid, sizeof(i386st->f_fsid));
+    i386st->f_namelen   = st->f_namelen;
+    i386st->f_frsize    = st->f_frsize;
+    #ifndef PANDORA
+    i386st->f_flags     = st->f_flags;
+    #endif
+    i386st->f_spare[0]  = st->f_spare[0];
+    i386st->f_spare[1]  = st->f_spare[1];
+    i386st->f_spare[2]  = st->f_spare[2];
+    i386st->f_spare[3]  = st->f_spare[3];
+}
+
+typedef struct my_timespec_s {
+    int     tv_sec;
+    int     tv_nsec;
+} my_timespec_t;
+
+typedef struct my_timespec64_s {
+    int64_t tv_sec;
+    int     tv_nsec;
+    int     :32;
+} my_timespec64_t;
+
+void Timespec2Timespec64(void* dest, const void* source)
+{
+    my_timespec64_t* dst = (my_timespec64_t*)dest;
+    my_timespec_t* src = (my_timespec_t*)source;
+    dst->tv_sec = src->tv_sec;
+    dst->tv_nsec = src->tv_nsec;
+}
+void Timespec642Timespec(void* dest, const void* source)
+{
+    my_timespec_t* dst = (my_timespec_t*)dest;
+    my_timespec64_t* src = (my_timespec64_t*)source;
+    dst->tv_sec = src->tv_sec;
+    dst->tv_nsec = src->tv_nsec;
+}
@@ -5,27 +5,28 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
-#include <asm/stat.h>
+#include <sys/stat.h>
 #include <sys/vfs.h>
 #include <signal.h>
+#include <stddef.h>

 #include "x86emu.h"
 #include "emu/x86emu_private.h"
 #include "myalign.h"
+#include "debug.h"

 void UnalignStat64(const void* source, void* dest)
 {
    struct i386_stat64 *i386st = (struct i386_stat64*)dest;
    struct stat64 *st = (struct stat64*) source;
    
-    memset(i386st->__pad0, 0, sizeof(i386st->__pad0));
-	memset(i386st->__pad3, 0, sizeof(i386st->__pad3));
+    i386st->__pad0 = 0;
+	i386st->__pad3 = 0;
    i386st->st_dev      = st->st_dev;
-#ifndef POWERPCLE
-    i386st->__st_ino    = st->__st_ino;
+#if defined(__USE_TIME64_REDIRECTS) || defined(POWERPCLE) || !defined(HAVE_ST_INO)
+    i386st->__st_ino    = st->st_ino; 
 #else
-    i386st->__st_ino    = st->st_ino; // Separate __st_ino doesn't 
-                                      // exist on powerpc
+    i386st->__st_ino    = st->__st_ino;
 #endif
    i386st->st_mode     = st->st_mode;
    i386st->st_nlink    = st->st_nlink;
@@ -35,12 +36,21 @@ void UnalignStat64(const void* source, void* dest)
    i386st->st_size     = st->st_size;
    i386st->st_blksize  = st->st_blksize;
    i386st->st_blocks   = st->st_blocks;
+#if defined(__USE_XOPEN2K8) || defined(ANDROID) || defined(PANDORA)
+    i386st->st_atime    = st->st_atim.tv_sec;
+    i386st->st_atime_nsec   = st->st_atim.tv_nsec;
+    i386st->st_mtime    = st->st_mtim.tv_sec;
+    i386st->st_mtime_nsec   = st->st_mtim.tv_nsec;
+    i386st->st_ctime    = st->st_ctim.tv_sec;
+    i386st->st_ctime_nsec   = st->st_ctim.tv_nsec;
+#else
    i386st->st_atime    = st->st_atime;
    i386st->st_atime_nsec   = st->st_atime_nsec;
    i386st->st_mtime    = st->st_mtime;
    i386st->st_mtime_nsec   = st->st_mtime_nsec;
    i386st->st_ctime    = st->st_ctime;
    i386st->st_ctime_nsec   = st->st_ctime_nsec;
+#endif
    i386st->st_ino      = st->st_ino;
 }

@@ -50,11 +60,10 @@ void AlignStat64(const void* source, void* dest)
    struct i386_stat64 *i386st = (struct i386_stat64*)source;
    
    st->st_dev          = i386st->st_dev;
-#ifndef POWERPCLE
-    st->__st_ino        = i386st->__st_ino;
+#if defined(__USE_TIME64_REDIRECTS) || defined(POWERPCLE)|| !defined(HAVE_ST_INO)
+    // Separate __st_ino doesn't exist
 #else
-    st->st_ino          = i386st->__st_ino; // Separate __st_ino doesn't 
-                                            // exist on powerpc
+    st->__st_ino        = i386st->__st_ino;
 #endif
    st->st_mode         = i386st->st_mode;
    st->st_nlink        = i386st->st_nlink;
@@ -64,12 +73,21 @@ void AlignStat64(const void* source, void* dest)
    st->st_size         = i386st->st_size;
    st->st_blksize      = i386st->st_blksize;
    st->st_blocks       = i386st->st_blocks;
+#if defined(__USE_XOPEN2K8) || defined(ANDROID) || defined(PANDORA)
+    st->st_atim.tv_sec  = i386st->st_atime;
+    st->st_atim.tv_nsec = i386st->st_atime_nsec;
+    st->st_mtim.tv_sec  = i386st->st_mtime;
+    st->st_mtim.tv_nsec = i386st->st_mtime_nsec;
+    st->st_ctim.tv_sec  = i386st->st_ctime;
+    st->st_ctim.tv_nsec = i386st->st_ctime_nsec;
+#else
    st->st_atime        = i386st->st_atime;
    st->st_atime_nsec   = i386st->st_atime_nsec;
    st->st_mtime        = i386st->st_mtime;
    st->st_mtime_nsec   = i386st->st_mtime_nsec;
    st->st_ctime        = i386st->st_ctime;
    st->st_ctime_nsec   = i386st->st_ctime_nsec;
+#endif
    st->st_ino          = i386st->st_ino;
 }

@@ -0,0 +1,47 @@
+#define _LARGEFILE_SOURCE 1
+#define _FILE_OFFSET_BITS 64
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <asm/stat.h>
+#include <sys/vfs.h>
+#include <signal.h>
+#include <stddef.h>
+
+#include "x86emu.h"
+#include "emu/x86emu_private.h"
+#include "myalign.h"
+#include "debug.h"
+
+void UnalignSysStat64(const void* source, void* dest)
+{
+    struct i386_stat64 *i386st = (struct i386_stat64*)dest;
+    struct stat64 *st = (struct stat64*) source;
+    
+    i386st->__pad0 = 0;
+	i386st->__pad3 = 0;
+    i386st->st_dev      = st->st_dev;
+#ifndef POWERPCLE
+    i386st->__st_ino    = st->__st_ino;
+#else
+    i386st->__st_ino    = st->st_ino; // Separate __st_ino doesn't 
+                                      // exist on powerpc
+#endif
+    i386st->st_mode     = st->st_mode;
+    i386st->st_nlink    = st->st_nlink;
+    i386st->st_uid      = st->st_uid;
+    i386st->st_gid      = st->st_gid;
+    i386st->st_rdev     = st->st_rdev;
+    i386st->st_size     = st->st_size;
+    i386st->st_blksize  = st->st_blksize;
+    i386st->st_blocks   = st->st_blocks;
+    i386st->st_atime    = st->st_atime;
+    i386st->st_atime_nsec   = st->st_atime_nsec;
+    i386st->st_mtime    = st->st_mtime;
+    i386st->st_mtime_nsec   = st->st_mtime_nsec;
+    i386st->st_ctime    = st->st_ctime;
+    i386st->st_ctime_nsec   = st->st_ctime_nsec;
+    i386st->st_ino      = st->st_ino;
+}
@@ -607,12 +607,12 @@ void my_sigactionhandler_oldcode(int32_t sig, int simple, int Locks, siginfo_t*
            sigcontext->uc_mcontext.gregs[REG_TRAPNO] = ((info->si_code==SEGV_ACCERR) || (info->si_errno==0x1234) || ((uintptr_t)info->si_addr==0))?13:14;
        } else if((info->si_code==SEGV_ACCERR) && !(prot&PROT_WRITE)) {
            sigcontext->uc_mcontext.gregs[REG_ERR] = 0x0002;    // write flag issue
-            if(abs((intptr_t)info->si_addr-(intptr_t)sigcontext->uc_mcontext.gregs[REG_ESP])<8)
+            sigcontext->uc_mcontext.gregs[REG_TRAPNO] = 14;
+        } else {
+            if((info->si_code!=SEGV_ACCERR) && abs((intptr_t)info->si_addr-(intptr_t)sigcontext->uc_mcontext.gregs[REG_ESP])<8)
                sigcontext->uc_mcontext.gregs[REG_TRAPNO] = 12; // stack overflow probably
            else
-                sigcontext->uc_mcontext.gregs[REG_TRAPNO] = 14;
-        } else {
-            sigcontext->uc_mcontext.gregs[REG_TRAPNO] = (info->si_code==SEGV_ACCERR)?13:14;
+                sigcontext->uc_mcontext.gregs[REG_TRAPNO] = (info->si_code==SEGV_ACCERR)?13:14;
            //REG_ERR seems to be INT:8 CODE:8. So for write access segfault it's 0x0002 For a read it's 0x0004 (and 8 for exec). For an int 2d it could be 0x2D01 for example
            sigcontext->uc_mcontext.gregs[REG_ERR] = 0x0004;    // read error? there is no execute control in box86 anyway, and no easy way to see if it's a write error
        }
@@ -1005,10 +1005,9 @@ exit(-1);
            esp = (void*)p->uc_mcontext.arm_r8;
        }
 #endif
-        x86name = getAddrFunctionName(x86pc);
        elfheader_t* elf = FindElfAddress(my_context, x86pc);
        if(elf)
-            elfname = ElfName(elf);
+            x86name = getAddrFunctionName(x86pc);
        if(jit_gdb) {
            pid_t pid = getpid();
            int v = fork(); // is this ok in a signal handler???
@@ -1039,8 +1038,8 @@ exit(-1);
        uint32_t hash = 0;
        if(db && ((addr<db->x86_addr || addr>(db->x86_addr+db->x86_size)) || (prot&PROT_READ)))
            hash = X31_hash_code(db->x86_addr, db->x86_size);
-        printf_log(log_minimum, "%04d|%s @%p (%s) (x86pc=%p/%s:\"%s\", esp=%p, stack=%p:%p own=%p fp=%p), for accessing %p (code=%d/prot=%x), db=%p(%p:%p/%p:%p/%s:%s, hash:%x/%x)", 
-            GetTID(), signame, pc, name, (void*)x86pc, elfname?elfname:"???", x86name?x86name:"???", esp, 
+        printf_log(log_minimum, "%04d|%s @%p (%s) (x86pc=%p/\"%s\", esp=%p, stack=%p:%p own=%p fp=%p), for accessing %p (code=%d/prot=%x), db=%p(%p:%p/%p:%p/%s:%s, hash:%x/%x)", 
+            GetTID(), signame, pc, name, (void*)x86pc, x86name?x86name:"???", esp, 
            emu->init_stack, emu->init_stack+emu->size_stack, emu->stack2free, (void*)R_EBP, 
            addr, info->si_code, prot, db, db?db->block:0, db?(db->block+db->size):0, 
            db?db->x86_addr:0, db?(db->x86_addr+db->x86_size):0, 
@@ -1060,7 +1059,7 @@ exit(-1);
        #warning TODO
 #endif
 #else
-        printf_log(log_minimum, "%04d|%s @%p (%s) (x86pc=%p/%s:\"%s\", esp=%p), for accessing %p (code=%d)", GetTID(), signame, pc, name, (void*)x86pc, elfname?elfname:"???", x86name?x86name:"???", esp, addr, info->si_code);
+        printf_log(log_minimum, "%04d|%s @%p (%s) (x86pc=%p/\"%s\", esp=%p), for accessing %p (code=%d)", GetTID(), signame, pc, name, (void*)x86pc, x86name?x86name:"???", esp, addr, info->si_code);
 #endif
        if(sig==SIGILL) {
            printf_log(log_minimum, " opcode=%02X %02X %02X %02X %02X %02X %02X %02X", ((uint8_t*)pc)[0], ((uint8_t*)pc)[1], ((uint8_t*)pc)[2], ((uint8_t*)pc)[3], ((uint8_t*)pc)[4], ((uint8_t*)pc)[5], ((uint8_t*)pc)[6], ((uint8_t*)pc)[7]);
@@ -1381,8 +1380,8 @@ EXPORT int my_getcontext(x86emu_t* emu, void* ucp)
    u->uc_mcontext.gregs[REG_CS] = R_CS;
    u->uc_mcontext.gregs[REG_SS] = R_SS;
    // get FloatPoint status
-    if(u->uc_mcontext.fpregs)
-        save_fpreg(emu, u->uc_mcontext.fpregs);
+    u->uc_mcontext.fpregs = ucp + 236;    // magic offset of fpregs in an actual i386 u_context
+    fpu_savenv(emu, (void*)u->uc_mcontext.fpregs, 1);   // it seems getcontext only save fpu env, not fpu regs
    // get signal mask
    sigprocmask(SIG_SETMASK, NULL, (sigset_t*)&u->uc_sigmask);
    // ensure uc_link is properly initialized
@@ -1417,7 +1416,7 @@ EXPORT int my_setcontext(x86emu_t* emu, void* ucp)
    R_SS = u->uc_mcontext.gregs[REG_SS];
    // set FloatPoint status
    if(u->uc_mcontext.fpregs)
-        load_fpreg(emu, u->uc_mcontext.fpregs);
+        fpu_loadenv(emu, (void*)u->uc_mcontext.fpregs, 1);
    // set signal mask
    sigprocmask(SIG_SETMASK, (sigset_t*)&u->uc_sigmask, NULL);
    // set uc_link
@@ -0,0 +1,87 @@
+#define _TIME_BITS 64
+#define _FILE_OFFSET_BITS 64
+#ifdef PANDORA
+#define _ATFILE_SOURCE
+#endif
+#include <string.h>
+#include <sys/stat.h>
+
+void stat64_time64_armhf_to_i386(struct stat *src, char *dest) {
+  /*
+  i386 t64
+  size of stat struct 108
+  Offset of st_dev 0 size 8
+  Offset of st_ino 8 size 8
+  Offset of st_mode 16 size 4
+  Offset of st_nlink 20 size 4
+  Offset of st_uid 24 size 4
+  Offset of st_gid 28 size 4
+  Offset of st_rdev 32 size 8
+  Offset of st_size 40 size 8
+  Offset of st_blksize 48 size 4
+  Offset of st_blocks 52 size 8
+  Offset of st_atim 60 size 16
+  Offset of st_mtim 76 size 16
+  Offset of st_ctim 92 size 16
+
+  armhf t64
+  size of stat struct 112
+  Offset of st_dev 0 size 8
+  Offset of st_ino 8 size 8
+  Offset of st_mode 16 size 4
+  Offset of st_nlink 20 size 4
+  Offset of st_uid 24 size 4
+  Offset of st_gid 28 size 4
+  Offset of st_rdev 32 size 8
+  Offset of st_size 40 size 8
+  Offset of st_blksize 48 size 4
+  Offset of st_blocks 56 size 8
+  Offset of st_atim 64 size 16
+  Offset of st_mtim 80 size 16
+  Offset of st_ctim 96 size 16
+  */
+
+  char *st = (char *)src;
+  memset(dest, 0, 108);
+  memcpy(dest, st, 8);
+  memcpy(dest + 8, st + 8, 8);
+  memcpy(dest + 16, st + 16, 4);
+  memcpy(dest + 20, st + 20, 4);
+  memcpy(dest + 24, st + 24, 4);
+  memcpy(dest + 28, st + 28, 4);
+  memcpy(dest + 32, st + 32, 8);
+  memcpy(dest + 40, st + 40, 8);
+  memcpy(dest + 48, st + 48, 4);
+  memcpy(dest + 52, st + 56, 8);
+  memcpy(dest + 60, st + 64, 16);
+  memcpy(dest + 76, st + 80, 16);
+  memcpy(dest + 92, st + 96, 16);
+}
+
+int stat64_time64_helper(void *path, void *buf) {
+  struct stat st;
+  int r = stat(path, &st);
+  stat64_time64_armhf_to_i386(&st, buf);
+  return r;
+}
+
+int fstatat64_time64_helper(int dirfd, void *path, void *buf, int flags) {
+  struct stat st;
+  int r = fstatat(dirfd, path, &st, flags);
+  stat64_time64_armhf_to_i386(&st, buf);
+  return r;
+}
+
+int fstat64_time64_helper(int fd, void *buf) {
+  struct stat st;
+  int r = fstat(fd, &st);
+  stat64_time64_armhf_to_i386(&st, buf);
+  return r;
+}
+
+int lstat64_time64_helper(void *path, void *buf) {
+  struct stat st;
+  int r = lstat(path, &st);
+  stat64_time64_armhf_to_i386(&st, buf);
+  return r;
+}
@@ -478,100 +478,71 @@ EXPORT int my_pthread_key_delete(x86emu_t* emu, pthread_key_t key)
 	int ret = pthread_key_delete(key);
 	return ret;
 }
-// phtread_cond_init with null attr seems to only write 1 (NULL) dword on x86, while it's 48 bytes on ARM. 
-// Not sure why as sizeof(pthread_cond_init) is 48 on both platform... But Neverwinter Night init seems to rely on that
-// What about cond that are statically initialized? 
-// Note, this is is a versionned function (the pthread_cond_*), and this seems to correspond to an old behaviour
+typedef struct pthread_cond_old_s {
+	pthread_cond_t* cond;
+} pthread_cond_old_t;

-KHASH_MAP_INIT_INT(mapcond, pthread_cond_t*);
-
-// should all access to that map be behind a mutex?
-kh_mapcond_t *mapcond = NULL;
-
-static pthread_cond_t* add_cond(void* cond)
-{
-	mutex_lock(&my_context->mutex_thread);
-	khint_t k;
-	int ret;
-	pthread_cond_t *c;
-	k = kh_put(mapcond, mapcond, (uintptr_t)cond, &ret);
-	if(!ret)
-		c = kh_value(mapcond, k);	// already there... reinit an existing one?
-	else 
-		c = kh_value(mapcond, k) = (pthread_cond_t*)box_calloc(1, sizeof(pthread_cond_t));
-	*(void**)cond = cond;
-	mutex_unlock(&my_context->mutex_thread);
-	return c;
-}
-static pthread_cond_t* get_cond(void* cond)
-{
-	pthread_cond_t* ret;
-	int r;
-	mutex_lock(&my_context->mutex_thread);
-	khint_t k = kh_get(mapcond, mapcond, *(uintptr_t*)cond);
-	if(k==kh_end(mapcond)) {
-		khint_t k = kh_get(mapcond, mapcond, (uintptr_t)cond);
-		if(k==kh_end(mapcond)) {
-			printf_log(LOG_DEBUG, "BOX86: Note: phtread_cond not found, create a new empty one\n");
-			ret = (pthread_cond_t*)box_calloc(1, sizeof(pthread_cond_t));
-			k = kh_put(mapcond, mapcond, (uintptr_t)cond, &r);
-			kh_value(mapcond, k) = ret;
-		} else
-			ret = kh_value(mapcond, k);
-		*(void**)cond = cond;
-		pthread_cond_init(ret, NULL);
-	} else
-		ret = kh_value(mapcond, k);
-	mutex_unlock(&my_context->mutex_thread);
-	return ret;
-}
-static void del_cond(void* cond)
-{
-	if(!mapcond)
-		return;
-	mutex_lock(&my_context->mutex_thread);
-	khint_t k = kh_get(mapcond, mapcond, *(uintptr_t*)cond);
-	if(k!=kh_end(mapcond)) {
-		box_free(kh_value(mapcond, k));
-		kh_del(mapcond, mapcond, k);
+static pthread_cond_t* get_cond(pthread_cond_old_t* cond) {
+	if(!cond->cond) {
+		pthread_cond_t* newcond = box_calloc(1, sizeof(pthread_cond_t));
+		#ifdef DYNAREC
+		if(arm_lock_storeifnull(&cond->cond, newcond))
+			box_free(newcond);
+		#else
+		static pthread_mutex_t mutex_cond = PTHREAD_MUTEX_INITIALIZER;
+		pthread_mutex_lock(&mutex_cond);
+		if(!cond->cond)
+			cond->cond = newcond;
+		else
+			box_free(newcond);
+		#endif
 	}
-	mutex_unlock(&my_context->mutex_thread);
+	return cond->cond;
 }
+
 static pthread_mutex_t* getAlignedMutex(pthread_mutex_t* m);

-EXPORT int my_pthread_cond_broadcast_old(x86emu_t* emu, void* cond)
+EXPORT int my_pthread_cond_broadcast_old(x86emu_t* emu, pthread_cond_old_t* cond)
 {
    (void)emu;
 	pthread_cond_t * c = get_cond(cond);
 	return pthread_cond_broadcast(c);
 }
-EXPORT int my_pthread_cond_destroy_old(x86emu_t* emu, void* cond)
+EXPORT int my_pthread_cond_destroy_old(x86emu_t* emu, pthread_cond_old_t* cond)
 {
    (void)emu;
 	pthread_cond_t * c = get_cond(cond);
 	int ret = pthread_cond_destroy(c);
-	if(c!=cond) del_cond(cond);
+	box_free(cond->cond);
 	return ret;
 }
-EXPORT int my_pthread_cond_init_old(x86emu_t* emu, void* cond, void* attr)
+EXPORT int my_pthread_cond_init_old(x86emu_t* emu, pthread_cond_old_t* cond, void* attr)
 {
    (void)emu;
-	pthread_cond_t *c = add_cond(cond);
+	pthread_cond_t *c = get_cond(cond);
 	return pthread_cond_init(c, (const pthread_condattr_t*)attr);
 }
-EXPORT int my_pthread_cond_signal_old(x86emu_t* emu, void* cond)
+EXPORT int my_pthread_cond_signal_old(x86emu_t* emu, pthread_cond_old_t* cond)
 {
    (void)emu;
 	pthread_cond_t * c = get_cond(cond);
 	return pthread_cond_signal(c);
 }
-EXPORT int my_pthread_cond_timedwait_old(x86emu_t* emu, void* cond, void* mutex, void* abstime)
+EXPORT int my_pthread_cond_timedwait_old(x86emu_t* emu, pthread_cond_old_t* cond, void* mutex, void* abstime)
 {
    (void)emu;
 	pthread_cond_t * c = get_cond(cond);
-	return pthread_cond_timedwait(c, getAlignedMutex((pthread_mutex_t*)mutex), (const struct timespec*)abstime);
+	#ifdef __USE_TIME64_REDIRECTS
+    struct timespec t1;
+    Timespec2Timespec64(&t1, abstime);
+	#define T abstime?(&t1):NULL
+	#else
+	#define T (const struct timespec*)abstime
+	#endif
+	return pthread_cond_timedwait(c, getAlignedMutex((pthread_mutex_t*)mutex), T);
+	#undef T
 }
-EXPORT int my_pthread_cond_wait_old(x86emu_t* emu, void* cond, void* mutex)
+EXPORT int my_pthread_cond_wait_old(x86emu_t* emu, pthread_cond_old_t* cond, void* mutex)
 {
    (void)emu;
 	pthread_cond_t * c = get_cond(cond);
@@ -581,7 +552,15 @@ EXPORT int my_pthread_cond_wait_old(x86emu_t* emu, void* cond, void* mutex)
 EXPORT int my_pthread_cond_timedwait(x86emu_t* emu, void* cond, void* mutex, void* abstime)
 {
    (void)emu;
-	return pthread_cond_timedwait((pthread_cond_t*)cond, getAlignedMutex((pthread_mutex_t*)mutex), (const struct timespec*)abstime);
+	#ifdef __USE_TIME64_REDIRECTS
+    struct timespec t1;
+    Timespec2Timespec64(&t1, abstime);
+	#define T abstime?(&t1):NULL
+	#else
+	#define T (const struct timespec*)abstime
+	#endif
+	return pthread_cond_timedwait((pthread_cond_t*)cond, getAlignedMutex((pthread_mutex_t*)mutex), T);
+	#undef T
 }
 EXPORT int my_pthread_cond_wait(x86emu_t* emu, void* cond, void* mutex)
 {
@@ -914,9 +893,17 @@ EXPORT int my_pthread_mutex_lock(pthread_mutex_t *m)
 }
 EXPORT int my___pthread_mutex_lock(pthread_mutex_t *m) __attribute__((alias("my_pthread_mutex_lock")));

-EXPORT int my_pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec * t)
+EXPORT int my_pthread_mutex_timedlock(pthread_mutex_t *m, void* abstime)
 {
-	return pthread_mutex_timedlock(getAlignedMutex(m), t);
+	#ifdef __USE_TIME64_REDIRECTS
+    struct timespec t1;
+    Timespec2Timespec64(&t1, abstime);
+	#define T abstime?(&t1):NULL
+	#else
+	#define T (const struct timespec*)abstime
+	#endif
+	return pthread_mutex_timedlock(getAlignedMutex(m), T);
+	#undef T
 }

 EXPORT int my_pthread_mutex_trylock(pthread_mutex_t *m)
@@ -951,7 +938,6 @@ void init_pthread_helper()
 		real_phtread_kill_old = (iFli_t)pthread_kill;
 	}

-	mapcond = kh_init(mapcond);
 	pthread_key_create(&thread_key, emuthread_destroy);
 	pthread_setspecific(thread_key, NULL);
 #if !defined(NOALIGN) && defined(ANDROID)
@@ -971,13 +957,6 @@ void clean_current_emuthread()
 void fini_pthread_helper(box86context_t* context)
 {
 	CleanStackSize(context);
-	pthread_cond_t *cond;
-	kh_foreach_value(mapcond, cond, 
-		pthread_cond_destroy(cond);
-		box_free(cond);
-	);
-	kh_destroy(mapcond, mapcond);
-	mapcond = NULL;
 #ifndef NOALIGN
 #ifdef ANDROID
 	pthread_mutex_t *m;
@@ -1,5 +1,3 @@
-#undef _LARGEFILE_SOURCE
-#undef _FILE_OFFSET_BITS
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -285,34 +283,40 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,
-    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001,
-    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_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_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_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_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,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000038001,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000038002,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR = 1000038003,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR = 1000038004,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR = 1000038005,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR = 1000038006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR = 1000038007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR = 1000038008,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR = 1000038009,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR = 1000038010,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR = 1000038011,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR = 1000038012,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000038013,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR = 1000039000,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000039001,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000039002,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR = 1000039003,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR = 1000039004,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR = 1000039005,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR = 1000039006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR = 1000039007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR = 1000039009,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR = 1000039010,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR = 1000039011,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR = 1000039012,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR = 1000039013,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000039014,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006,
    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
    VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006,
    VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007,
@@ -367,6 +371,7 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,
    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG = 1000110000,
    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
@@ -402,6 +407,11 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
    VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX = 1000134000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX = 1000134001,
+    VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX = 1000134002,
+    VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX = 1000134003,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004,
    VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
    VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
    VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
@@ -469,21 +479,18 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
    VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
-    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
-    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_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_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005,
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000,
    VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001,
    VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
-    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,
    VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,
@@ -515,7 +522,11 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = 1000232000,
+    VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = 1000232001,
+    VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = 1000232002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,
    VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
@@ -540,11 +551,7 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
    VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
    VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,
    VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,
@@ -552,6 +559,21 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
    VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = 1000270000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = 1000270001,
+    VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = 1000270002,
+    VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = 1000270003,
+    VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = 1000270004,
+    VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = 1000270005,
+    VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = 1000270006,
+    VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = 1000270007,
+    VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = 1000270008,
+    VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009,
+    VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000,
+    VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001,
+    VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
    VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000,
    VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001,
@@ -560,7 +582,7 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001,
    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002,
    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003,
-    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004,    
+    VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004,
    VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000,
    VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001,
@@ -575,12 +597,12 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,
    VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000,
+    VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001,
+    VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,
    VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,
    VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000,
-    VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001,
-    VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002,    
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
    VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
@@ -597,8 +619,20 @@ typedef enum VkStructureType {
    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_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,
    VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,
+    VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000,
+    VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001,
+    VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004,
+    VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000,
    VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000,
    VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001,
    VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002,
@@ -613,6 +647,19 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011,
    VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008,
    VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004,
+    VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005,
+    VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007,
+    VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008,
+    VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001,
    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002,
@@ -635,8 +682,6 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000,
    VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001,
-    VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = 1000338002,
-    VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = 1000338003,
    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,
@@ -677,6 +722,8 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001,
    VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000,
+    VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000,
    VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001,
    VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002,
@@ -691,6 +738,8 @@ 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_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001,
    VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000,
    VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001,
    VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002,
@@ -701,28 +750,59 @@ typedef enum VkStructureType {
    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_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001,
+    VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI = 1000404002,
    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_SHADER_CORE_PROPERTIES_ARM = 1000415000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = 1000416000,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001,
    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_RENDER_PASS_STRIPED_FEATURES_ARM = 1000424000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM = 1000424001,
+    VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002,
+    VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003,
+    VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,
    VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000,
+    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001,
+    VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000,
    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_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000,
    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,
    VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003,
+    VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000,
+    VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001,
    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002,
@@ -737,21 +817,98 @@ typedef enum VkStructureType {
    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_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = 1000470000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = 1000470001,
-    VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = 1000338002,
    VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = 1000470003,
    VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = 1000470004,
+    VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = 1000338002,
+    VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR = 1000338003,
    VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = 1000470005,
    VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = 1000470006,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001,
+    VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002,
    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_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000,
    VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002,
+    VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT = 1000496000,
    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_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000,
+    VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000,
+    VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001,
+    VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002,
+    VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003,
+    VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004,
+    VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005,
+    VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007,
+    VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000,
+    VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000,
+    VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004,
+    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000,
+    VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001,
+    VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002,
+    VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001,
+    VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = 1000528000,
+    VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000,
+    VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001,
+    VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002,
+    VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = 1000265000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = 1000259000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = 1000259001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = 1000259002,
+    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = 1000544000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = 1000545000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = 1000545001,
+    VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = 1000545002,
+    VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = 1000545003,
+    VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = 1000545004,
+    VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = 1000545005,
+    VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = 1000545006,
+    VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007,
+    VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
    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,
@@ -852,6 +1009,9 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+    VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR,
    VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
@@ -884,7 +1044,11 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
    VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
    VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,
@@ -914,6 +1078,8 @@ 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_SUBRESOURCE_LAYOUT_2_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR,
+    VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR,
    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,
@@ -925,6 +1091,7 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES,
    VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS,
    VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,
+    VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;

@@ -1086,6 +1253,9 @@ typedef struct my_vkhead_s {
    case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR:                     \
    case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:     \
    case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:        \
+    case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:               \
+    case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:                   \
+    case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:               \

 #define CH(C, B, A) \
    case C:         \
@@ -1158,6 +1328,9 @@ typedef struct my_vkhead_s {
    CH(VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT, "uPUup", A)             \
    CH(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, "uPSuuu", A)             \
    CH(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR, "uPPP", A)              \
+    CH(VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR, "uPuUUU", A)           \
+    CH(VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, "uPuUUup", A)                 \
+    CH(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, "uPuUU", A)      \


 //--------------------------------------------------------------
@@ -51,6 +51,8 @@ int box86_dynarec_log = LOG_NONE;
 uintptr_t box86_pagesize;
 uintptr_t box86_load_addr = 0;
 int box86_showbt = 0;
+int box86_maxcpu = 0;
+int box86_maxcpu_immutable = 0;
 int box86_isglibc234 = 0;
 int box86_nosandbox = 0;
 int box86_malloc_hack = 0;
@@ -129,6 +131,7 @@ int box86_musl = 0;
 int box86_nopulse = 0;
 int box86_nogtk = 0;
 int box86_novulkan = 0;
+int box86_nocrashhandler = 0;
 #ifdef BAD_SIGNAL
 int box86_futex_waitv = 0;
 #else
@@ -571,6 +574,15 @@ void LoadLogEnv()
        if(!box86_libcef)
            printf_log(LOG_INFO, "Dynarec will not detect libcef\n");
    }
+    p = getenv("BOX86_NOCRASHHANDLER");
+    if(p) {
+        if(strlen(p)==1) {
+            if(p[0]>='0' && p[0]<='1')
+                box86_nocrashhandler = p[0]-'0';
+        }
+        if(box86_nocrashhandler)
+            printf_log(LOG_INFO, "Box86 will consider crashhnadler.so to not be present\n");
+    }
    p = getenv("BOX86_SDL2_JGUID");
    if(p) {
        if(strlen(p)==1) {
@@ -759,6 +771,19 @@ void LoadLogEnv()
        if(box86_showbt)
            printf_log(LOG_INFO, "Show Backtrace for signals\n");
    }
+    p = getenv("BOX86_MAXCPU");
+    if(p) {
+        int maxcpu = 0;
+        if(sscanf(p, "%d", &maxcpu)==1)
+            box86_maxcpu = maxcpu;
+        if(box86_maxcpu<0)
+            box86_maxcpu = 0;
+        if(box86_maxcpu) {
+            printf_log(LOG_INFO, "Will not expose more than %d cpu cores\n", box86_maxcpu);
+        } else {
+            printf_log(LOG_INFO, "Will not limit the number of cpu cores exposed\n");
+        }
+    }
    box86_pagesize = sysconf(_SC_PAGESIZE);
    if(!box86_pagesize)
        box86_pagesize = 4096;
@@ -888,8 +913,8 @@ void PrintFlags() {
    printf(" BOX86_LIBGL=libXXXX set the name (and optionnaly full path) for libGL.so.1\n");
    printf(" BOX86_LD_PRELOAD=XXXX[:YYYYY] force loading XXXX (and YYYY...) libraries with the binary\n");
    printf(" BOX86_ALLOWMISSINGLIBS with 1 to allow to continue even if a lib is missing (unadvised, will probably crash later)\n");
-    printf(" BOX64_PREFER_EMULATED=1 to prefer emulated libs first (execpt for glibc, alsa, pulse, GL, vulkan and X11)\n");
-    printf(" BOX64_PREFER_WRAPPED if box86 will use wrapped libs even if the lib is specified with absolute path\n");
+    printf(" BOX86_PREFER_EMULATED=1 to prefer emulated libs first (execpt for glibc, alsa, pulse, GL, vulkan and X11)\n");
+    printf(" BOX86_PREFER_WRAPPED if box86 will use wrapped libs even if the lib is specified with absolute path\n");
    printf(" BOX86_NOPULSE=1 to disable the loading of pulseaudio libs\n");
    printf(" BOX86_NOGTK=1 to disable the loading of wrapped gtk libs\n");
    printf(" BOX86_NOVULKAN=1 to disable the loading of wrapped vulkan libs\n");
@@ -949,6 +974,10 @@ void LoadEnvVars(box86context_t *context)
        AddPath("/mnt/utmp/codeblocks/usr/lib/i386-linux-gnu", &context->box86_ld_lib, 1);
    if(FileExist("/mnt/utmp/box86/lib/i386-linux-gnu", 0))
        AddPath("/mnt/utmp/box86/lib/i386-linux-gnu", &context->box86_ld_lib, 1);
+    if(FileExist("/mnt/utmp/codeblocks/usr/lib/box86-i386-linux-gnu", 0))
+        AddPath("/mnt/utmp/codeblocks/usr/lib/box86-i386-linux-gnu", &context->box86_ld_lib, 1);
+    if(FileExist("/mnt/utmp/box86/lib/box86-i386-linux-gnu", 0))
+        AddPath("/mnt/utmp/box86/lib/box86-i386-linux-gnu", &context->box86_ld_lib, 1);
    //TODO: add relative path to box86 location
 #endif
 #ifndef TERMUX
@@ -966,11 +995,17 @@ void LoadEnvVars(box86context_t *context)
        AddPath("/usr/lib/i686-pc-linux-gnu", &context->box86_ld_lib, 1);
    if(FileExist("/usr/lib32", 0))
        AddPath("/usr/lib32", &context->box86_ld_lib, 1);
+    if(FileExist("/lib/box86-i386-linux-gnu", 0))
+        AddPath("/lib/box86-i386-linux-gnu", &context->box86_ld_lib, 1);
+    if(FileExist("/usr/lib/box86-i386-linux-gnu", 0))
+        AddPath("/usr/lib/box86-i386-linux-gnu", &context->box86_ld_lib, 1);
 #else
    if(FileExist("/data/data/com.termux/files/usr/lib/i386-linux-gnu", 0))
        AddPath("/data/data/com.termux/files/usr/lib/i386-linux-gnu", &context->box86_ld_lib, 1);
    if(FileExist("/data/data/com.termux/files/usr/lib/i686-linux-gnu", 0))
        AddPath("/data/data/com.termux/files/usr/lib/i686-linux-gnu", &context->box86_ld_lib, 1);
+    if(FileExist("/data/data/com.termux/files/usr/lib/box86-i386-linux-gnu", 0))
+        AddPath("/data/data/com.termux/files/usr/lib/box86-i386-linux-gnu", &context->box86_ld_lib, 1);
 #endif
    if(getenv("LD_LIBRARY_PATH"))
        PrependList(&context->box86_ld_lib, getenv("LD_LIBRARY_PATH"), 1);   // in case some of the path are for x86 world
@@ -1306,7 +1341,7 @@ int main(int argc, const char **argv, char **env)

    // check BOX86_LOG debug level
    LoadLogEnv();
-    if(!getenv("BOX64_NORCFILES")) {
+    if(!getenv("BOX86_NORCFILES")) {
        load_rcfiles();
    }
    char* bashpath = NULL;
@@ -1424,8 +1459,10 @@ int main(int argc, const char **argv, char **env)
        my_context->box64path = getenv("BOX86_BOX64");
        if(!my_context->box64path) {
            my_context->box64path = box_strdup(my_context->box86path);
-            char* p = strrchr(my_context->box64path, '8');  // get the 8 of box86
-            p[0] = '6'; p[1] = '4'; // change 86 to 64
+            if (strstr(my_context->box64path, "box86")) {
+                char* p = strrchr(my_context->box64path, '8');  // get the 8 of box86
+                p[0] = '6'; p[1] = '4'; // change 86 to 64
+            }
        }
        if(!FileExist(my_context->box64path, IS_FILE)) {
            box_free(my_context->box64path);
@@ -1569,6 +1606,9 @@ int main(int argc, const char **argv, char **env)
        my_context->argv[i] = box_strdup(argv[i+nextarg]);
        printf_log(LOG_INFO, "argv[%i]=\"%s\"\n", i, my_context->argv[i]);
    }
+    if(box86_wine) {
+        box86_maxcpu_immutable = 1; // cannot change once wine is loaded
+    }
    if(box86_nosandbox)
    {
        add_argv("--no-sandbox");
@@ -692,7 +692,7 @@ EXPORT void* my_safer_scalable_aligned_realloc(void* p, size_t size, size_t alig
    void* new_p = box_memalign(align, size);
    memcpy(new_p, p, (old_size<size)?old_size:size);
    box_free(p);
-    return p;
+    return new_p;
 }

 EXPORT void my_safer_scalable_free(void*p , void* old)
@@ -740,7 +740,7 @@ EXPORT void* my_scalable_aligned_realloc(void* p, size_t size, size_t align)
    void* new_p = box_memalign(align, size);
    memcpy(new_p, p, (old_size<size)?old_size:size);
    box_free(p);
-    return p;
+    return new_p;
 }

 EXPORT size_t my_scalable_msize(void* p)
@@ -93,8 +93,8 @@ int getNCpu()
 {
    if(!nCPU)
        grabNCpu();
-    if(box86_wine && nCPU>32)
-        return 32;
+    if(box86_maxcpu && nCPU>box86_maxcpu)
+        return box86_maxcpu;
    return nCPU;
 }

@@ -52,9 +52,11 @@ ENTRYSTRING_(BOX86_BOX64, box64)                        \
 ENTRYSTRING_(BOX86_LD_PRELOAD, ld_preload)              \
 ENTRYBOOL(BOX86_NOSANDBOX, box86_nosandbox)             \
 ENTRYBOOL(BOX86_LIBCEF, box86_libcef)                   \
+ENTRYBOOL(BOX86_NOCRASHHANDLER, box86_nocrashhandler)   \
 ENTRYBOOL(BOX86_SDL2_JGUID, box86_sdl2_jguid)           \
 ENTRYBOOL(BOX86_MUTEX_ALIGNED, box86_mutex_aligned)     \
 ENTRYINT(BOX86_MALLOC_HACK, box86_malloc_hack, 0, 2, 2) \
+ENTRYINTPOS(BOX86_MAXCPU, new_maxcpu)                   \

 #ifdef HAVE_TRACE
 #define SUPER2()                                        \
@@ -109,7 +111,7 @@ IGNORE(BOX86_DYNAREC_X87DOUBLE)                                     \
 IGNORE(BOX86_DYNAREC_FASTNAN)                                       \
 IGNORE(BOX86_DYNAREC_FASTROUND)                                     \
 IGNORE(BOX86_DYNAREC_SAFEFLAGS)                                     \
-IGNORE(BOX64_DYNAREC_CALLRET)                                       \
+IGNORE(BOX86_DYNAREC_CALLRET)                                       \
 IGNORE(BOX86_DYNAREC_HOTPAGE)                                       \
 IGNORE(BOX86_DYNAREC_FASTPAGE)                                      \
 IGNORE(BOX86_DYNAREC_WAIT)                                          \
@@ -399,6 +401,7 @@ void ApplyParams(const char* name, path_collection_t* preload)
        return;
    static const char* old_name = NULL;
    int new_cycle_log = cycle_log;
+    int new_maxcpu = box86_maxcpu;
    if(old_name && !strcmp(name, old_name))
        return;
    old_name = name;
@@ -442,6 +445,13 @@ void ApplyParams(const char* name, path_collection_t* preload)
        cycle_log = new_cycle_log;
        initCycleLog(my_context);
    }
+    if(!box86_maxcpu_immutable) {
+        if(new_maxcpu!=box86_maxcpu && box86_maxcpu && box86_maxcpu<new_maxcpu) {
+            printf_log(LOG_INFO, "Not applying BOX86_MAXCPU=%d because a lesser value is already active: %d\n", new_maxcpu, box86_maxcpu);
+        } else
+            box86_maxcpu = new_maxcpu;
+    } else if(new_maxcpu!=box86_maxcpu)
+        printf_log(LOG_INFO, "Not applying BOX86_MAXCPU=%d because it's too late\n", new_maxcpu);
    if(param->is_ld_library_path_present) AppendList(&my_context->box86_ld_lib, param->ld_library_path, 1);
    if(param->is_box86_path_present) AppendList(&my_context->box86_path, param->box86_path, 1);
    if(param->is_trace_file_present) {
@@ -187,6 +187,7 @@
 #() iFuu
 #() iFup
 #() iFli
+#() iFLL
 #() iFLp
 #() iFpw
 #() iFpi
@@ -491,6 +492,7 @@
 #() iFpOu
 #() iFpPU
 #() iFpPp
+#() iFpPP
 #() iFpGG
 #() iFSpi
 #() iFSpL
@@ -1297,6 +1299,7 @@
 #() iFpupup
 #() iFpuppu
 #() iFpuppp
+#() iFpuPpp
 #() iFpUiUi
 #() iFplluu
 #() iFpLlpp
@@ -1332,6 +1335,7 @@
 #() iFppppL
 #() iFppppp
 #() iFpppGp
+#() iFpPPpp
 #() IFppIII
 #() uFEippp
 #() uFEpipp
@@ -1587,6 +1591,7 @@
 #() iFiiiuwp
 #() iFiuiipi
 #() iFiuUuUu
+#() iFipiipi
 #() iFipipuu
 #() iFipuIup
 #() iFipupup
@@ -2418,8 +2423,7 @@
 #defined(HAVE_LD80BITS) DFDD
 #defined(HAVE_LD80BITS) DFDp
 #defined(HAVE_LD80BITS) DFppi
-#defined(HAVE_LD80BITS) DFppu
-#defined(HAVE_LD80BITS) DFppip
+#defined(HAVE_LD80BITS) DFppp
 #defined(HAVE_LD80BITS) iFDipppL
 #defined(HAVE_LD80BITS) vFppippDDC
 #!defined(HAVE_LD80BITS) iFK
@@ -2429,8 +2433,7 @@
 #!defined(HAVE_LD80BITS) KFKp
 #!defined(HAVE_LD80BITS) KFpp
 #!defined(HAVE_LD80BITS) KFppi
-#!defined(HAVE_LD80BITS) KFppu
-#!defined(HAVE_LD80BITS) KFppip
+#!defined(HAVE_LD80BITS) KFppp
 #!defined(HAVE_LD80BITS) iFKipppL
 #!defined(HAVE_LD80BITS) vFppippKKC
 #() iFEvpp -> iFEpp
@@ -3175,10 +3178,13 @@ wrappedlibc:
 - vFpp:
 - vFpV:
 - iFip:
+  - __fstat64_time64
  - fstat
 - iFpi:
 - iFpL:
 - iFpp:
+  - __lstat64_time64
+  - __stat64_time64
  - execvp
  - lstat
  - lstat64
@@ -3223,6 +3229,7 @@ wrappedlibc:
 - iFppL:
 - iFppp:
  - _IO_vfscanf
+  - execvpe
 - iFppV:
  - __isoc23_fscanf
  - __isoc23_sscanf
@@ -3242,7 +3249,8 @@ wrappedlibc:
  - __isoc23_strtoull
 - KFppi:
  - __strtold_internal
- KFppu:
+- KFppp:
+  - __strtold_l
  - strtold_l
 - lFipL:
  - __read_nocancel
@@ -3263,7 +3271,9 @@ wrappedlibc:
  - ptrace
 - iFipii:
 - iFipuu:
+  - sendmmsg
 - iFippi:
+  - __fstatat64_time64
 - iFippL:
  - readlinkat
 - iFpvpp:
@@ -3282,8 +3292,6 @@ wrappedlibc:
  - __isoc23_strtoll_l
 - UFppip:
  - __isoc23_strtoull_l
- KFppip:
-  - __strtold_l
 - lFipiI:
 - lFpupp:
 - vFpLLpp:
@@ -3374,6 +3382,10 @@ wrappedlibglu:
  - gluNurbsCallback
  - gluQuadricCallback
  - gluTessCallback
+wrappedlibglx:
+- pFp:
+  - glXGetProcAddress
+  - glXGetProcAddressARB
 wrappedlibharfbuzz:
 wrappedlibibus:
 - vFpippp:
@@ -3656,6 +3668,7 @@ wrappedlibpthread:
  - pthread_mutex_timedlock
  - pthread_once
  - pthread_setname_np
+  - sem_timedwait
 - vFppp:
  - _pthread_cleanup_push
  - _pthread_cleanup_push_defer
@@ -3687,6 +3700,7 @@ wrappedlibrt:
  - aio_cancel
 - iFupp:
  - timer_create
+- iFiipp:
 - iFipip:
  - lio_listio
 wrappedlibsm:
@@ -4820,6 +4834,8 @@ wrappedvulkan:
  - vkDestroySurfaceKHR
  - vkDestroySwapchainKHR
  - vkDestroyValidationCacheEXT
+  - vkDestroyVideoSessionKHR
+  - vkDestroyVideoSessionParametersKHR
 - vFppp:
  - vkDestroyDebugUtilsMessengerEXT
 - vFpPp:
@@ -4846,12 +4862,15 @@ wrappedvulkan:
  - vkQueueSubmit2
  - vkQueueSubmit2KHR
 - iFpUup:
+  - vkBindVideoSessionMemoryKHR
  - vkGetDisplayPlaneCapabilitiesKHR
 - iFpUpP:
  - vkGetPastPresentationTimingGOOGLE
 - iFpppp:
  - vkCreateDebugReportCallbackEXT
  - vkCreateDebugUtilsMessengerEXT
+  - vkCreateVideoSessionKHR
+  - vkCreateVideoSessionParametersKHR
  - vkCreateWaylandSurfaceKHR
 - iFpPpp:
  - vkAllocateMemory
@@ -67,7 +67,7 @@ typedef int32_t (*iFpOV_t)(void*, int32_t, ...);
 typedef int64_t (*IFppi_t)(void*, void*, int32_t);
 typedef uint64_t (*UFppi_t)(void*, void*, int32_t);
 typedef double (*KFppi_t)(void*, void*, int32_t);
-typedef double (*KFppu_t)(void*, void*, uint32_t);
+typedef double (*KFppp_t)(void*, void*, void*);
 typedef intptr_t (*lFipL_t)(int32_t, void*, uintptr_t);
 typedef intptr_t (*lFppi_t)(void*, void*, int32_t);
 typedef void* (*pFpii_t)(void*, int32_t, int32_t);
@@ -96,7 +96,6 @@ typedef int32_t (*iFppiV_t)(void*, void*, int32_t, ...);
 typedef int32_t (*iFpppp_t)(void*, void*, void*, void*);
 typedef int64_t (*IFppip_t)(void*, void*, int32_t, void*);
 typedef uint64_t (*UFppip_t)(void*, void*, int32_t, void*);
-typedef double (*KFppip_t)(void*, void*, int32_t, void*);
 typedef intptr_t (*lFipiI_t)(int32_t, void*, int32_t, int64_t);
 typedef intptr_t (*lFpupp_t)(void*, uint32_t, void*, void*);
 typedef void (*vFpLLpp_t)(void*, uintptr_t, uintptr_t, void*, void*);
@@ -136,7 +135,10 @@ typedef int32_t (*iFpLiLppp_t)(void*, uintptr_t, int32_t, uintptr_t, void*, void
 	GO(getpwuid, pFu_t) \
 	GO(__secure_getenv, pFp_t) \
 	GO(secure_getenv, pFp_t) \
+	GO(__fstat64_time64, iFip_t) \
 	GO(fstat, iFip_t) \
+	GO(__lstat64_time64, iFpp_t) \
+	GO(__stat64_time64, iFpp_t) \
 	GO(execvp, iFpp_t) \
 	GO(lstat, iFpp_t) \
 	GO(lstat64, iFpp_t) \
@@ -156,6 +158,7 @@ typedef int32_t (*iFpLiLppp_t)(void*, uintptr_t, int32_t, uintptr_t, void*, void
 	GO(getopt, iFipp_t) \
 	GO(dprintf, iFipV_t) \
 	GO(_IO_vfscanf, iFppp_t) \
+	GO(execvpe, iFppp_t) \
 	GO(__isoc23_fscanf, iFppV_t) \
 	GO(__isoc23_sscanf, iFppV_t) \
 	GO(__isoc23_sscanf, iFppV_t) \
@@ -169,18 +172,20 @@ typedef int32_t (*iFpLiLppp_t)(void*, uintptr_t, int32_t, uintptr_t, void*, void
 	GO(__isoc23_strtoll, IFppi_t) \
 	GO(__isoc23_strtoull, UFppi_t) \
 	GO(__strtold_internal, KFppi_t) \
-	GO(strtold_l, KFppu_t) \
+	GO(__strtold_l, KFppp_t) \
+	GO(strtold_l, KFppp_t) \
 	GO(__read_nocancel, lFipL_t) \
 	GO(__isoc23_strtol, lFppi_t) \
 	GO(__syslog_chk, vFiipV_t) \
 	GO(__libc_init, vFpppp_t) \
 	GO(ptrace, iFiupp_t) \
+	GO(sendmmsg, iFipuu_t) \
+	GO(__fstatat64_time64, iFippi_t) \
 	GO(readlinkat, iFippL_t) \
 	GO(__vfwprintf_chk, iFpvpp_t) \
 	GO(_IO_vfprintf, iFpppp_t) \
 	GO(__isoc23_strtoll_l, IFppip_t) \
 	GO(__isoc23_strtoull_l, UFppip_t) \
-	GO(__strtold_l, KFppip_t) \
 	GO(prctl, iFiLLLL_t) \
 	GO(getopt_long, iFipppp_t) \
 	GO(getopt_long_only, iFipppp_t)
@@ -0,0 +1,8 @@
+/*******************************************************************
+ * File automatically generated by rebuild_wrappers.py (v2.0.0.11) *
+ *******************************************************************/
+#ifndef __wrappedlibglxDEFS_H_
+#define __wrappedlibglxDEFS_H_
+
+
+#endif // __wrappedlibglxDEFS_H_
@@ -0,0 +1,20 @@
+/*******************************************************************
+ * File automatically generated by rebuild_wrappers.py (v2.0.0.11) *
+ *******************************************************************/
+#ifndef __wrappedlibglxTYPES_H_
+#define __wrappedlibglxTYPES_H_
+
+#ifndef LIBNAME
+#error You should only #include this file inside a wrapped*.c file
+#endif
+#ifndef ADDED_FUNCTIONS
+#define ADDED_FUNCTIONS() 
+#endif
+
+typedef void* (*pFp_t)(void*);
+
+#define SUPER() ADDED_FUNCTIONS() \
+	GO(glXGetProcAddress, pFp_t) \
+	GO(glXGetProcAddressARB, pFp_t)
+
+#endif // __wrappedlibglxTYPES_H_
@@ -0,0 +1,8 @@
+/*******************************************************************
+ * File automatically generated by rebuild_wrappers.py (v2.0.0.11) *
+ *******************************************************************/
+#ifndef __wrappedlibglxUNDEFS_H_
+#define __wrappedlibglxUNDEFS_H_
+
+
+#endif // __wrappedlibglxUNDEFS_H_
@@ -67,6 +67,7 @@ typedef int32_t (*iFpppp_t)(void*, void*, void*, void*);
 	GO(pthread_mutex_timedlock, iFpp_t) \
 	GO(pthread_once, iFpp_t) \
 	GO(pthread_setname_np, iFpp_t) \
+	GO(sem_timedwait, iFpp_t) \
 	GO(_pthread_cleanup_push, vFppp_t) \
 	GO(_pthread_cleanup_push_defer, vFppp_t) \
 	GO(pthread_setaffinity_np, iFLup_t) \
@@ -14,6 +14,7 @@
 typedef int32_t (*iFp_t)(void*);
 typedef int32_t (*iFip_t)(int32_t, void*);
 typedef int32_t (*iFupp_t)(uint32_t, void*, void*);
+typedef int32_t (*iFiipp_t)(int32_t, int32_t, void*, void*);
 typedef int32_t (*iFipip_t)(int32_t, void*, int32_t, void*);

 #define SUPER() ADDED_FUNCTIONS() \
@@ -69,6 +69,8 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkDestroySurfaceKHR, vFpUp_t) \
 	GO(vkDestroySwapchainKHR, vFpUp_t) \
 	GO(vkDestroyValidationCacheEXT, vFpUp_t) \
+	GO(vkDestroyVideoSessionKHR, vFpUp_t) \
+	GO(vkDestroyVideoSessionParametersKHR, vFpUp_t) \
 	GO(vkDestroyDebugUtilsMessengerEXT, vFppp_t) \
 	GO(vkGetImageMemoryRequirements2, vFpPp_t) \
 	GO(vkGetImageMemoryRequirements2KHR, vFpPp_t) \
@@ -86,10 +88,13 @@ typedef void (*vFpiiiupupup_t)(void*, int32_t, int32_t, int32_t, uint32_t, void*
 	GO(vkGetDeviceImageSparseMemoryRequirementsKHR, vFpPpp_t) \
 	GO(vkQueueSubmit2, iFpupU_t) \
 	GO(vkQueueSubmit2KHR, iFpupU_t) \
+	GO(vkBindVideoSessionMemoryKHR, iFpUup_t) \
 	GO(vkGetDisplayPlaneCapabilitiesKHR, iFpUup_t) \
 	GO(vkGetPastPresentationTimingGOOGLE, iFpUpP_t) \
 	GO(vkCreateDebugReportCallbackEXT, iFpppp_t) \
 	GO(vkCreateDebugUtilsMessengerEXT, iFpppp_t) \
+	GO(vkCreateVideoSessionKHR, iFpppp_t) \
+	GO(vkCreateVideoSessionParametersKHR, iFpppp_t) \
 	GO(vkCreateWaylandSurfaceKHR, iFpppp_t) \
 	GO(vkAllocateMemory, iFpPpp_t) \
 	GO(vkCreateBuffer, iFpPpp_t) \
@@ -259,6 +259,7 @@ typedef int32_t (*iFui_t)(uint32_t, int32_t);
 typedef int32_t (*iFuu_t)(uint32_t, uint32_t);
 typedef int32_t (*iFup_t)(uint32_t, void*);
 typedef int32_t (*iFli_t)(intptr_t, int32_t);
+typedef int32_t (*iFLL_t)(uintptr_t, uintptr_t);
 typedef int32_t (*iFLp_t)(uintptr_t, void*);
 typedef int32_t (*iFpw_t)(void*, int16_t);
 typedef int32_t (*iFpi_t)(void*, int32_t);
@@ -563,6 +564,7 @@ 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);
@@ -1369,6 +1371,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 (*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*);
@@ -1404,6 +1407,7 @@ typedef int32_t (*iFppppu_t)(void*, void*, void*, void*, uint32_t);
 typedef int32_t (*iFppppL_t)(void*, void*, void*, void*, uintptr_t);
 typedef int32_t (*iFppppp_t)(void*, void*, void*, void*, void*);
 typedef int32_t (*iFpppGp_t)(void*, void*, void*, void*, void*);
+typedef int32_t (*iFpPPpp_t)(void*, void*, void*, void*, void*);
 typedef int64_t (*IFppIII_t)(void*, void*, int64_t, int64_t, int64_t);
 typedef uint32_t (*uFEippp_t)(x86emu_t*, int32_t, void*, void*, void*);
 typedef uint32_t (*uFEpipp_t)(x86emu_t*, void*, int32_t, void*, void*);
@@ -1659,6 +1663,7 @@ typedef int32_t (*iFiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, void*
 typedef int32_t (*iFiiiuwp_t)(int32_t, int32_t, int32_t, uint32_t, int16_t, void*);
 typedef int32_t (*iFiuiipi_t)(int32_t, uint32_t, int32_t, int32_t, void*, int32_t);
 typedef int32_t (*iFiuUuUu_t)(int32_t, uint32_t, uint64_t, uint32_t, uint64_t, uint32_t);
+typedef int32_t (*iFipiipi_t)(int32_t, void*, int32_t, int32_t, void*, int32_t);
 typedef int32_t (*iFipipuu_t)(int32_t, void*, int32_t, void*, uint32_t, uint32_t);
 typedef int32_t (*iFipuIup_t)(int32_t, void*, uint32_t, int64_t, uint32_t, void*);
 typedef int32_t (*iFipupup_t)(int32_t, void*, uint32_t, void*, uint32_t, void*);
@@ -2504,8 +2509,7 @@ typedef long double (*DFED_t)(x86emu_t*, long double);
 typedef long double (*DFDD_t)(long double, long double);
 typedef long double (*DFDp_t)(long double, void*);
 typedef long double (*DFppi_t)(void*, void*, int32_t);
-typedef long double (*DFppu_t)(void*, void*, uint32_t);
-typedef long double (*DFppip_t)(void*, void*, int32_t, void*);
+typedef long double (*DFppp_t)(void*, void*, void*);
 typedef int32_t (*iFDipppL_t)(long double, int32_t, void*, void*, void*, uintptr_t);
 typedef void (*vFppippDDC_t)(void*, void*, int32_t, void*, void*, long double, long double, uint8_t);
 #endif
@@ -2518,8 +2522,7 @@ typedef double (*KFKK_t)(double, double);
 typedef double (*KFKp_t)(double, void*);
 typedef double (*KFpp_t)(void*, void*);
 typedef double (*KFppi_t)(void*, void*, int32_t);
-typedef double (*KFppu_t)(void*, void*, uint32_t);
-typedef double (*KFppip_t)(void*, void*, int32_t, void*);
+typedef double (*KFppp_t)(void*, void*, void*);
 typedef int32_t (*iFKipppL_t)(double, int32_t, void*, void*, void*, uintptr_t);
 typedef void (*vFppippKKC_t)(void*, void*, int32_t, void*, void*, double, double, uint8_t);
 #endif
@@ -2713,6 +2716,7 @@ void iFui(x86emu_t *emu, uintptr_t fcn) { iFui_t fn = (iFui_t)fcn; R_EAX=fn(*(ui
 void iFuu(x86emu_t *emu, uintptr_t fcn) { iFuu_t fn = (iFuu_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8)); }
 void iFup(x86emu_t *emu, uintptr_t fcn) { iFup_t fn = (iFup_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); }
 void iFli(x86emu_t *emu, uintptr_t fcn) { iFli_t fn = (iFli_t)fcn; R_EAX=fn(*(intptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); }
+void iFLL(x86emu_t *emu, uintptr_t fcn) { iFLL_t fn = (iFLL_t)fcn; R_EAX=fn(*(uintptr_t*)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8)); }
 void iFLp(x86emu_t *emu, uintptr_t fcn) { iFLp_t fn = (iFLp_t)fcn; R_EAX=fn(*(uintptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); }
 void iFpw(x86emu_t *emu, uintptr_t fcn) { iFpw_t fn = (iFpw_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8)); }
 void iFpi(x86emu_t *emu, uintptr_t fcn) { iFpi_t fn = (iFpi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); }
@@ -3017,6 +3021,7 @@ void iFppG(x86emu_t *emu, uintptr_t fcn) { iFppG_t fn = (iFppG_t)fcn; my_GValue_
 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 *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 iFpPP(x86emu_t *emu, uintptr_t fcn) { iFpPP_t fn = (iFpPP_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8); VulkanTox86(arg12); }
 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)); }
@@ -3823,6 +3828,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 iFpuPpp(x86emu_t *emu, uintptr_t fcn) { iFpuPpp_t fn = (iFpuPpp_t)fcn; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12, *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); VulkanTox86(arg12); }
 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)); }
@@ -3858,6 +3864,7 @@ void iFppppu(x86emu_t *emu, uintptr_t fcn) { iFppppu_t fn = (iFppppu_t)fcn; R_EA
 void iFppppL(x86emu_t *emu, uintptr_t fcn) { iFppppL_t fn = (iFppppL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20)); }
 void iFppppp(x86emu_t *emu, uintptr_t fcn) { iFppppp_t fn = (iFppppp_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 iFpppGp(x86emu_t *emu, uintptr_t fcn) { iFpppGp_t fn = (iFpppGp_t)fcn; my_GValue_t arg16; alignGValue(&arg16, *(void**)(R_ESP + 16)); R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), &arg16, *(void**)(R_ESP + 20)); unalignGValue(*(void**)(R_ESP + 16), &arg16); }
+void iFpPPpp(x86emu_t *emu, uintptr_t fcn) { iFpPPpp_t fn = (iFpPPpp_t)fcn; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8)); void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), arg8, arg12, *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); VulkanTox86(arg8); VulkanTox86(arg12); }
 void IFppIII(x86emu_t *emu, uintptr_t fcn) { IFppIII_t fn = (IFppIII_t)fcn; ui64_t r; r.i=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int64_t*)(R_ESP + 20), *(int64_t*)(R_ESP + 28)); R_EAX=r.d[0]; R_EDX=r.d[1]; }
 void uFEippp(x86emu_t *emu, uintptr_t fcn) { uFEippp_t fn = (uFEippp_t)fcn; R_EAX=(uint32_t)fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
 void uFEpipp(x86emu_t *emu, uintptr_t fcn) { uFEpipp_t fn = (uFEpipp_t)fcn; R_EAX=(uint32_t)fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); }
@@ -4113,6 +4120,7 @@ void iFiiiiip(x86emu_t *emu, uintptr_t fcn) { iFiiiiip_t fn = (iFiiiiip_t)fcn; R
 void iFiiiuwp(x86emu_t *emu, uintptr_t fcn) { iFiiiuwp_t fn = (iFiiiuwp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int16_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
 void iFiuiipi(x86emu_t *emu, uintptr_t fcn) { iFiuiipi_t fn = (iFiuiipi_t)fcn; R_EAX=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), *(int32_t*)(R_ESP + 24)); }
 void iFiuUuUu(x86emu_t *emu, uintptr_t fcn) { iFiuUuUu_t fn = (iFiuUuUu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 20), *(uint64_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 32)); }
+void iFipiipi(x86emu_t *emu, uintptr_t fcn) { iFipiipi_t fn = (iFipiipi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); }
 void iFipipuu(x86emu_t *emu, uintptr_t fcn) { iFipipuu_t fn = (iFipipuu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); }
 void iFipuIup(x86emu_t *emu, uintptr_t fcn) { iFipuIup_t fn = (iFipuIup_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int64_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); }
 void iFipupup(x86emu_t *emu, uintptr_t fcn) { iFipupup_t fn = (iFipupup_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); }
@@ -4958,8 +4966,7 @@ void DFED(x86emu_t *emu, uintptr_t fcn) { DFED_t fn = (DFED_t)fcn; long double l
 void DFDD(x86emu_t *emu, uintptr_t fcn) { DFDD_t fn = (DFDD_t)fcn; long double ld=fn(LD2localLD((void*)(R_ESP + 4)), LD2localLD((void*)(R_ESP + 16))); fpu_do_push(emu); ST0val = ld; }
 void DFDp(x86emu_t *emu, uintptr_t fcn) { DFDp_t fn = (DFDp_t)fcn; long double ld=fn(LD2localLD((void*)(R_ESP + 4)), *(void**)(R_ESP + 16)); fpu_do_push(emu); ST0val = ld; }
 void DFppi(x86emu_t *emu, uintptr_t fcn) { DFppi_t fn = (DFppi_t)fcn; long double ld=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); fpu_do_push(emu); ST0val = ld; }
-void DFppu(x86emu_t *emu, uintptr_t fcn) { DFppu_t fn = (DFppu_t)fcn; long double ld=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); fpu_do_push(emu); ST0val = ld; }
-void DFppip(x86emu_t *emu, uintptr_t fcn) { DFppip_t fn = (DFppip_t)fcn; long double ld=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); fpu_do_push(emu); ST0val = ld; }
+void DFppp(x86emu_t *emu, uintptr_t fcn) { DFppp_t fn = (DFppp_t)fcn; long double ld=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); fpu_do_push(emu); ST0val = ld; }
 void iFDipppL(x86emu_t *emu, uintptr_t fcn) { iFDipppL_t fn = (iFDipppL_t)fcn; R_EAX=fn(LD2localLD((void*)(R_ESP + 4)), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(uintptr_t*)(R_ESP + 32)); }
 void vFppippDDC(x86emu_t *emu, uintptr_t fcn) { vFppippDDC_t fn = (vFppippDDC_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), LD2localLD((void*)(R_ESP + 24)), LD2localLD((void*)(R_ESP + 36)), *(uint8_t*)(R_ESP + 48)); }
 #endif
@@ -4972,8 +4979,7 @@ void KFKK(x86emu_t *emu, uintptr_t fcn) { KFKK_t fn = (KFKK_t)fcn; double db=fn(
 void KFKp(x86emu_t *emu, uintptr_t fcn) { KFKp_t fn = (KFKp_t)fcn; double db=fn(FromLD((void*)(R_ESP + 4)), *(void**)(R_ESP + 16)); fpu_do_push(emu); ST0val = db; }
 void KFpp(x86emu_t *emu, uintptr_t fcn) { KFpp_t fn = (KFpp_t)fcn; double db=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); fpu_do_push(emu); ST0val = db; }
 void KFppi(x86emu_t *emu, uintptr_t fcn) { KFppi_t fn = (KFppi_t)fcn; double db=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); fpu_do_push(emu); ST0val = db; }
-void KFppu(x86emu_t *emu, uintptr_t fcn) { KFppu_t fn = (KFppu_t)fcn; double db=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); fpu_do_push(emu); ST0val = db; }
-void KFppip(x86emu_t *emu, uintptr_t fcn) { KFppip_t fn = (KFppip_t)fcn; double db=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); fpu_do_push(emu); ST0val = db; }
+void KFppp(x86emu_t *emu, uintptr_t fcn) { KFppp_t fn = (KFppp_t)fcn; double db=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); fpu_do_push(emu); ST0val = db; }
 void iFKipppL(x86emu_t *emu, uintptr_t fcn) { iFKipppL_t fn = (iFKipppL_t)fcn; R_EAX=fn(FromLD((void*)(R_ESP + 4)), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(uintptr_t*)(R_ESP + 32)); }
 void vFppippKKC(x86emu_t *emu, uintptr_t fcn) { vFppippKKC_t fn = (vFppippKKC_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), FromLD((void*)(R_ESP + 24)), FromLD((void*)(R_ESP + 36)), *(uint8_t*)(R_ESP + 48)); }
 #endif
@@ -5045,8 +5051,7 @@ int isRetX87Wrapper(wrapper_t fun) {
 	if (fun == &DFDD) return 1;
 	if (fun == &DFDp) return 1;
 	if (fun == &DFppi) return 1;
-	if (fun == &DFppu) return 1;
-	if (fun == &DFppip) return 1;
+	if (fun == &DFppp) return 1;
 #endif
 #if !defined(HAVE_LD80BITS)
 	if (fun == &KFK) return 1;
@@ -5054,8 +5059,7 @@ int isRetX87Wrapper(wrapper_t fun) {
 	if (fun == &KFKp) return 1;
 	if (fun == &KFpp) return 1;
 	if (fun == &KFppi) return 1;
-	if (fun == &KFppu) return 1;
-	if (fun == &KFppip) return 1;
+	if (fun == &KFppp) return 1;
 #endif
 	return 0;
 }
@@ -219,6 +219,7 @@ void iFui(x86emu_t *emu, uintptr_t fnc);
 void iFuu(x86emu_t *emu, uintptr_t fnc);
 void iFup(x86emu_t *emu, uintptr_t fnc);
 void iFli(x86emu_t *emu, uintptr_t fnc);
+void iFLL(x86emu_t *emu, uintptr_t fnc);
 void iFLp(x86emu_t *emu, uintptr_t fnc);
 void iFpw(x86emu_t *emu, uintptr_t fnc);
 void iFpi(x86emu_t *emu, uintptr_t fnc);
@@ -523,6 +524,7 @@ 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);
@@ -1329,6 +1331,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 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);
@@ -1364,6 +1367,7 @@ void iFppppu(x86emu_t *emu, uintptr_t fnc);
 void iFppppL(x86emu_t *emu, uintptr_t fnc);
 void iFppppp(x86emu_t *emu, uintptr_t fnc);
 void iFpppGp(x86emu_t *emu, uintptr_t fnc);
+void iFpPPpp(x86emu_t *emu, uintptr_t fnc);
 void IFppIII(x86emu_t *emu, uintptr_t fnc);
 void uFEippp(x86emu_t *emu, uintptr_t fnc);
 void uFEpipp(x86emu_t *emu, uintptr_t fnc);
@@ -1619,6 +1623,7 @@ void iFiiiiip(x86emu_t *emu, uintptr_t fnc);
 void iFiiiuwp(x86emu_t *emu, uintptr_t fnc);
 void iFiuiipi(x86emu_t *emu, uintptr_t fnc);
 void iFiuUuUu(x86emu_t *emu, uintptr_t fnc);
+void iFipiipi(x86emu_t *emu, uintptr_t fnc);
 void iFipipuu(x86emu_t *emu, uintptr_t fnc);
 void iFipuIup(x86emu_t *emu, uintptr_t fnc);
 void iFipupup(x86emu_t *emu, uintptr_t fnc);
@@ -2464,8 +2469,7 @@ void DFED(x86emu_t *emu, uintptr_t fnc);
 void DFDD(x86emu_t *emu, uintptr_t fnc);
 void DFDp(x86emu_t *emu, uintptr_t fnc);
 void DFppi(x86emu_t *emu, uintptr_t fnc);
-void DFppu(x86emu_t *emu, uintptr_t fnc);
-void DFppip(x86emu_t *emu, uintptr_t fnc);
+void DFppp(x86emu_t *emu, uintptr_t fnc);
 void iFDipppL(x86emu_t *emu, uintptr_t fnc);
 void vFppippDDC(x86emu_t *emu, uintptr_t fnc);
 #endif
@@ -2478,8 +2482,7 @@ void KFKK(x86emu_t *emu, uintptr_t fnc);
 void KFKp(x86emu_t *emu, uintptr_t fnc);
 void KFpp(x86emu_t *emu, uintptr_t fnc);
 void KFppi(x86emu_t *emu, uintptr_t fnc);
-void KFppu(x86emu_t *emu, uintptr_t fnc);
-void KFppip(x86emu_t *emu, uintptr_t fnc);
+void KFppp(x86emu_t *emu, uintptr_t fnc);
 void iFKipppL(x86emu_t *emu, uintptr_t fnc);
 void vFppippKKC(x86emu_t *emu, uintptr_t fnc);
 #endif
@@ -58,7 +58,7 @@ GO(FcConfigGetFonts, pFpi)
 //GO(FcConfigHome, 
 //GO(FcConfigParseAndLoad, 
 //GO(FcConfigReference, 
-//GO(FcConfigSetCurrent, 
+GO(FcConfigSetCurrent, iFp)
 //GO(FcConfigSetRescanInterval, 
 //GO(FcConfigSetRescanInverval, 
 GO(FcConfigSubstitute, iFppi)
@@ -161,7 +161,7 @@ GO(gnutls_dh_params_export_raw, iFpppp)
 GO(gnutls_dh_params_generate2, iFpu)
 //GO(gnutls_dh_params_import_dsa, 
 //GO(gnutls_dh_params_import_pkcs3, 
-//GO(gnutls_dh_params_import_raw, 
+GO(gnutls_dh_params_import_raw, iFppp)
 GO(gnutls_dh_params_import_raw2, iFpppu)
 GO(gnutls_dh_params_init, iFp)
 //GO(gnutls_dh_set_prime_bits, 
@@ -266,7 +266,7 @@ GO(g_thread_get_type, iFv)
 GO(g_time_zone_get_type, iFv)
 //GOM(g_type_add_class_cache_func, vFEpB)
 GO(g_type_add_class_private, vFpiu)
-//GO(g_type_add_instance_private, 
+GO(g_type_add_instance_private, iFLL)
 //GOM(g_type_add_interface_check, vFEpB)
 //GOM(g_type_add_interface_dynamic, vFEiip)
 GOM(g_type_add_interface_static, vFEiip)
@@ -36,7 +36,7 @@ EXPORT void* my____tls_get_addr(x86emu_t* emu)
 EXPORT void* my___libc_stack_end;
 void stSetup(box86context_t* context)
 {
-    my___libc_stack_end = context->stack;   // is this the end, or should I add stasz?
+    my___libc_stack_end = context->stack + context->stacksz;
 }

 const char* ldlinuxName = "ld-linux.so.3";
@@ -19,11 +19,9 @@
 #include "callback.h"


-#ifdef ANDROID
-const char* libbsdName = "libbsd.so";
-#else
 const char* libbsdName = "libbsd.so.0";
-#endif
+#define ALTNAME "libbsd.so"
+
 #define LIBNAME libbsd

 #define PRE_INIT\
@@ -60,6 +60,7 @@
 #include "bridge.h"
 #include "globalsymbols.h"
 #include "rcfile.h"
+#include "stat64_helper.h"

 #ifdef PANDORA
 #ifndef __NR_preadv
@@ -1196,29 +1197,6 @@ EXPORT void my__ITM_registerTMCloneTable(x86emu_t* emu, void* p, uint32_t s) { (
 EXPORT void my__ITM_deregisterTMCloneTable(x86emu_t* emu, void* p) { (void)emu; (void)p; }


-struct i386_stat {
-	uint64_t  st_dev;
-	uint32_t  __pad1;
-	uint32_t  st_ino;
-	uint32_t  st_mode;
-	uint32_t  st_nlink;
-	uint32_t  st_uid;
-	uint32_t  st_gid;
-	uint64_t  st_rdev;
-	uint32_t  __pad2;
-	int32_t   st_size;
-	int32_t   st_blksize;
-	int32_t   st_blocks;
-	int32_t   st_atime_sec;
-	uint32_t  st_atime_nsec;
-	int32_t   st_mtime_sec;
-	uint32_t  st_mtime_nsec;
-	int32_t   st_ctime_sec;
-	uint32_t  st_ctime_nsec;
-	uint32_t  __unused4;
-	uint32_t  __unused5;
-} __attribute__((packed));
-
 static int FillStatFromStat64(int vers, const struct stat64 *st64, void *st32)
 {
    struct i386_stat *i386st = (struct i386_stat *)st32;
@@ -1263,23 +1241,21 @@ static int FillStatFromStat64(int vers, const struct stat64 *st64, void *st32)
        errno = EOVERFLOW;
        return -1;
    }
-    i386st->st_atime_sec = st64->st_atim.tv_sec;
+    i386st->st_atime_sec  = st64->st_atim.tv_sec;
    i386st->st_atime_nsec = st64->st_atim.tv_nsec;
-    i386st->st_mtime_sec = st64->st_mtim.tv_sec;
+    i386st->st_mtime_sec  = st64->st_mtim.tv_sec;
    i386st->st_mtime_nsec = st64->st_mtim.tv_nsec;
-    i386st->st_ctime_sec = st64->st_ctim.tv_sec;
+    i386st->st_ctime_sec  = st64->st_ctim.tv_sec;
    i386st->st_ctime_nsec = st64->st_ctim.tv_nsec;
-    i386st->__unused4 = 0;
-    i386st->__unused5 = 0;
+    i386st->st_ino = 0;
    return 0;
 }

-#ifdef ANDROID
 EXPORT int my_stat(char* path, void* buf)
 {
    struct stat64 st;
    int r = stat64(path, &st);
-    UnalignStat64(&st, buf);
+    FillStatFromStat64(3, &st, buf);
    return r;
 }

@@ -1287,7 +1263,7 @@ EXPORT int my_fstat(int fd, void* buf)
 {
    struct stat64 st;
    int r = fstat64(fd, &st);
-    UnalignStat64(&st, buf);
+    FillStatFromStat64(3, &st, buf);
    return r;
 }

@@ -1295,10 +1271,9 @@ EXPORT int my_lstat(char* path, void* buf)
 {
    struct stat64 st;
    int r = lstat64(path, &st);
-    UnalignStat64(&st, buf);
+    FillStatFromStat64(3, &st, buf);
    return r;
 }
-#endif

 EXPORT int my___fxstat(x86emu_t *emu, int vers, int fd, void* buf)
 {
@@ -1343,6 +1318,7 @@ EXPORT int my_stat64(x86emu_t* emu, void* path, void* buf)
    UnalignStat64(&st, buf);
    return r;
 }
+
 EXPORT int my_lstat64(x86emu_t* emu, void* path, void* buf)
 {
    (void)emu;
@@ -1352,6 +1328,26 @@ EXPORT int my_lstat64(x86emu_t* emu, void* path, void* buf)
    return r;
 }

+EXPORT int my___stat64_time64(x86emu_t* emu, void* path, void* buf)
+{
+    return stat64_time64_helper(path, buf);
+}
+
+EXPORT int my___fstatat64_time64(x86emu_t* emu, int dirfd, void* path, void* buf, int flags)
+{
+    return fstatat64_time64_helper(dirfd, path, buf, flags);
+}
+
+EXPORT int my___fstat64_time64(x86emu_t* emu, int fd, void* buf)
+{
+    return fstat64_time64_helper(fd, buf);
+}
+
+EXPORT int my___lstat64_time64(x86emu_t* emu, void* path, void* buf)
+{
+    return lstat64_time64_helper(path, buf);
+}
+
 EXPORT int my___xstat(x86emu_t* emu, int v, void* path, void* buf)
 {
    (void)emu;
@@ -1464,6 +1460,21 @@ EXPORT int my_statfs64(const char* path, void* buf)
    return r;
 }

+EXPORT int my_fstatfs(int fd, void* buf)
+{
+    struct statfs st;
+    int r = fstatfs(fd, &st);
+    UnalignStatFS(&st, buf);
+    return r;
+}
+
+EXPORT int my_statfs(const char* path, void* buf)
+{
+    struct statfs st;
+    int r = statfs(path, &st);
+    UnalignStatFS(&st, buf);
+    return r;
+}

 #ifdef ANDROID
 typedef int (*__compar_d_fn_t)(const void*, const void*, void*);
@@ -1870,6 +1881,15 @@ EXPORT int32_t my_open(x86emu_t* emu, void* pathname, int32_t flags, uint32_t mo
        lseek(tmp, 0, SEEK_SET);
        return tmp;
    }
+    if(box86_maxcpu && (!strcmp(pathname, "/sys/devices/system/cpu/present") || !strcmp(pathname, "/sys/devices/system/cpu/online")) && (getNCpu()>=box86_maxcpu)) {
+        // special case for cpu present (to limit to box86_maxcpu cores)
+        int tmp = shm_open(TMP_CPUPRESENT, O_RDWR | O_CREAT, S_IRWXU);
+        if(tmp<0) return open(pathname, flags, mode); // error fallback
+        shm_unlink(TMP_CPUPRESENT);    // remove the shm file, but it will still exist because it's currently in use
+        CreateCPUPresentFile(tmp);
+        lseek(tmp, 0, SEEK_SET);
+        return tmp;
+    }
    if(isCpuTopology((const char*)pathname)!=-1) {
        int n = isCpuTopology((const char*)pathname);
        char buf[512];
@@ -1987,6 +2007,15 @@ EXPORT int32_t my_open64(x86emu_t* emu, void* pathname, int32_t flags, uint32_t
        lseek(tmp, 0, SEEK_SET);
        return tmp;
    }
+    if(box86_maxcpu && (!strcmp(pathname, "/sys/devices/system/cpu/present") || !strcmp(pathname, "/sys/devices/system/cpu/online")) && (getNCpu()>=box86_maxcpu)) {
+        // special case for cpu present (to limit to box86_maxcpu cores)
+        int tmp = shm_open(TMP_CPUPRESENT, O_RDWR | O_CREAT, S_IRWXU);
+        if(tmp<0) return open64(pathname, flags, mode); // error fallback
+        shm_unlink(TMP_CPUPRESENT);    // remove the shm file, but it will still exist because it's currently in use
+        CreateCPUPresentFile(tmp);
+        lseek(tmp, 0, SEEK_SET);
+        return tmp;
+    }
    if(isCpuTopology((const char*)pathname)!=-1) {
        int n = isCpuTopology((const char*)pathname);
        char buf[512];
@@ -2062,8 +2091,8 @@ EXPORT FILE* my_fopen(x86emu_t* emu, const char* path, const char* mode)
        lseek(tmp, 0, SEEK_SET);
        return fdopen(tmp, mode);;
    }
-    if(box86_wine && (!strcmp(path, "/sys/devices/system/cpu/present") || !strcmp(path, "/sys/devices/system/cpu/online")) && (getNCpu()>=32)) {
-        // special case for cpu present (to limit to 64 cores)
+    if(box86_maxcpu && (!strcmp(path, "/sys/devices/system/cpu/present") || !strcmp(path, "/sys/devices/system/cpu/online")) && (getNCpu()>=box86_maxcpu)) {
+        // special case for cpu present (to limit to box86_maxcpu cores)
        int tmp = shm_open(TMP_CPUPRESENT, O_RDWR | O_CREAT, S_IRWXU);
        if(tmp<0) return fopen(path, mode); // error fallback
        shm_unlink(TMP_CPUPRESENT);    // remove the shm file, but it will still exist because it's currently in use
@@ -2138,8 +2167,8 @@ EXPORT FILE* my_fopen64(x86emu_t* emu, const char* path, const char* mode)
        lseek(tmp, 0, SEEK_SET);
        return fdopen(tmp, mode);;
    }
-    if(box86_wine && (!strcmp(path, "/sys/devices/system/cpu/present") || !strcmp(path, "/sys/devices/system/cpu/online")) && (getNCpu()>=32)) {
-        // special case for cpu present (to limit to 64 cores)
+    if(box86_maxcpu && (!strcmp(path, "/sys/devices/system/cpu/present") || !strcmp(path, "/sys/devices/system/cpu/online")) && (getNCpu()>=box86_maxcpu)) {
+        // special case for cpu present (to limit to box86_maxcpu cores)
        int tmp = shm_open(TMP_CPUPRESENT, O_RDWR | O_CREAT, S_IRWXU);
        if(tmp<0) return fopen64(path, mode); // error fallback
        shm_unlink(TMP_CPUPRESENT);    // remove the shm file, but it will still exist because it's currently in use
@@ -2543,6 +2572,62 @@ EXPORT int32_t my_execvp(x86emu_t* emu, const char* path, char* const argv[])
    // fullpath is gone, so the search will only be on PATH, not on BOX86_PATH (is that an issue?)
    return execvp(path, argv);
 }
+// execvpe should use PATH to search for the program first
+EXPORT int32_t my_execvpe(x86emu_t* emu, const char* path, char* const argv[], char* const envv[])
+{
+    // need to use BOX86_PATH / PATH here...
+    char* fullpath = ResolveFile(path, &my_context->box86_path);
+    // use fullpath...
+    int self = isProcSelf(fullpath, "exe");
+    int x86 = FileIsX86ELF(fullpath);
+    int x64 = my_context->box86path?FileIsX64ELF(path):0;
+    int script = (my_context->bashpath && FileIsShell(path))?1:0;
+    if(script && FileIsX64ELF(my_context->bashpath)) x64 = 1;
+    printf_log(LOG_DEBUG, "execvp(\"%s\", %p), IsX86=%d / fullpath=\"%s\"\n", path, argv, x86, fullpath);
+    if (x86 || x64 || script || self) {
+        // count argv...
+        int i=0;
+        while(argv[i]) ++i;
+        int toadd = script?2:1;
+        char** newargv = (char**)alloca((i+toadd+1)*sizeof(char*));
+        memset(newargv, 0, (i+toadd+1)*sizeof(char*));
+        newargv[0] = x64?emu->context->box64path:emu->context->box86path;
+        if(script) newargv[1] = emu->context->bashpath; // script needs to be launched with bash
+        for (int j=0; j<i; ++j)
+            newargv[j+1] = argv[j];
+        if(self) newargv[1] = emu->context->fullpath;
+        if(script) newargv[2] = emu->context->bashpath;
+        printf_log(LOG_DEBUG, " => execvp(\"%s\", %p [\"%s\", \"%s\"...:%d])\n", newargv[0], newargv, newargv[1], i?newargv[2]:"", i);
+        #ifdef PANDORA
+        int ret = execve(newargv[0], newargv, envv);
+        #else
+        int ret = execvpe(newargv[0], newargv, envv);
+        #endif
+        box_free(fullpath);
+        return ret;
+    }
+    #ifndef PANDORA
+    box_free(fullpath);
+    #endif
+    if((!strcmp(path + strlen(path) - strlen("/uname"), "/uname") || !strcmp(path, "uname"))
+     && argv[1] && (!strcmp(argv[1], "-m") || !strcmp(argv[1], "-p") || !strcmp(argv[1], "-i"))
+     && !argv[2]) {
+        // uname -m is redirected to box86 -m
+        path = my_context->box86path;
+        char *argv2[3] = { my_context->box86path, argv[1], NULL };
+        #ifdef PANDORA
+        return execve(fullpath, argv2, envv);
+        #else
+        return execvpe(path, argv2, envv);
+        #endif
+    }
+    #ifdef PANDORA
+    return execve(fullpath, argv, envv);
+    #else
+    // fullpath is gone, so the search will only be on PATH, not on BOX86_PATH (is that an issue?)
+    return execvpe(path, argv, envv);
+    #endif
+}

 // execvp should use PATH to search for the program first
 EXPORT int32_t my_posix_spawnp(x86emu_t* emu, pid_t* pid, const char* path, 
@@ -2757,6 +2842,34 @@ EXPORT int32_t my_fcntl(x86emu_t* emu, int32_t a, int32_t b, uint32_t d1, uint32
 }
 EXPORT int32_t my___fcntl(x86emu_t* emu, int32_t a, int32_t b, uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4, uint32_t d5, uint32_t d6) __attribute__((alias("my_fcntl")));

+EXPORT int32_t my___fcntl_time64(x86emu_t* emu, int32_t a, int32_t b, uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4, uint32_t d5, uint32_t d6)
+{
+    (void)emu; (void)d2; (void)d3; (void)d4; (void)d5; (void)d6;
+    // Implemented starting glibc 2.14+
+    library_t* lib = my_lib;
+    if(!lib) return 0;
+    iFiiV_t f = dlsym(lib->w.lib, "__fcntl_time64");
+    if(b==F_SETFL)
+        d1 = of_convert(d1);
+    if(b==F_GETLK64 || b==F_SETLK64 || b==F_SETLKW64)
+    {
+        my_flock64_t fl;
+        AlignFlock64(&fl, (void*)d1);
+        int ret = f?f(a, b, &fl):fcntl(a, b, &fl);
+        UnalignFlock64((void*)d1, &fl);
+        return ret;
+    }
+    //TODO: check if better to use the syscall or regular fcntl?
+    //return syscall(__NR_fcntl64, a, b, d1);   // should be enough
+    int ret = f?f(a, b, d1):fcntl(a, b, d1);
+
+    if(b==F_GETFL && ret!=-1)
+        ret = of_unconvert(ret);
+
+    return ret;
+}
+
+
 EXPORT int32_t my_preadv64(x86emu_t* emu, int32_t fd, void* v, int32_t c, int64_t o)
 {
    (void)emu;
@@ -3317,7 +3430,16 @@ EXPORT int my_nanosleep(const struct timespec *req, struct timespec *rem)
 {
    if(!req)
        return 0;   // workaround for some strange calls
+    #ifdef __USE_TIME64_REDIRECTS
+    struct timespec t1, t2;
+    Timespec2Timespec64(&t1, req);
+    int ret = nanosleep(&t1, rem?(&t2):NULL);
+    if(rem)
+        Timespec642Timespec(rem, &t2);
+    return ret;
+    #else
    return nanosleep(req, rem);
+    #endif
 }

 #ifndef NOALIGN
@@ -3573,10 +3695,11 @@ EXPORT char my___libc_single_threaded = 0;
    "libm.so",              \
    "libbsd.so"
 #else
-#define NEEDED_LIBS   4,\
+#define NEEDED_LIBS   5,\
    "ld-linux.so.2",    \
    "libpthread.so.0",  \
    "librt.so.1",       \
+    "libm.so.6",        \
    "libbsd.so.0"
 #define NEEDED_LIBS_234 6,  \
    "ld-linux.so.2",        \
@@ -293,6 +293,7 @@ GO2(execlp, iFpV, execvp)
 GOWM(execv, iFEpp)     //%%
 GOM(execve, iFEppp)   //%% and this one too...
 GOWM(execvp, iFEpp)
+GOWM(execvpe, iFEppp)
 GOM(exit, vFEi)
 GOM(_exit, vFEi)
 GOWM(_Exit, vFEi)
@@ -417,7 +418,7 @@ GO(__fsetlocking, iFpi)
 GO(fsetpos, iFpp)
 GO(fsetpos64, iFpp)
 GO(fsetxattr, iFippui)
-GOW(fstatfs, iFip)
+GOWM(fstatfs, iFip)      //%%,noE
 GOWM(fstatfs64, iFip)    //%%,noE
 GO(fstatvfs, iFip)
 GOW(fstatvfs64, iFip)   // alignment?
@@ -1281,20 +1282,20 @@ GO(posix_fallocate64, iFiII)
 GOW(posix_memalign, iFpLL)
 // posix_openpt // Weak
 GO(posix_spawn, iFpppppp)
-// posix_spawnattr_destroy
-// posix_spawnattr_getflags
-// posix_spawnattr_getpgroup
-// posix_spawnattr_getschedparam
-// posix_spawnattr_getschedpolicy
-// posix_spawnattr_getsigdefault
-// posix_spawnattr_getsigmask
-// posix_spawnattr_init
-// posix_spawnattr_setflags
-// posix_spawnattr_setpgroup
-// posix_spawnattr_setschedparam
-// posix_spawnattr_setschedpolicy
-// posix_spawnattr_setsigdefault
-// posix_spawnattr_setsigmask
+GOW(posix_spawnattr_destroy, iFp)
+GO(posix_spawnattr_getflags, iFpp)
+GO(posix_spawnattr_getpgroup, iFpp)
+GO(posix_spawnattr_getschedparam, iFpp)
+GO(posix_spawnattr_getschedpolicy, iFpp)
+GO(posix_spawnattr_getsigdefault, iFpp)
+GO(posix_spawnattr_getsigmask, iFpp)
+GOW(posix_spawnattr_init, iFp)
+GOW(posix_spawnattr_setflags, iFpw)
+GO(posix_spawnattr_setpgroup, iFpi)
+GO(posix_spawnattr_setschedparam, iFpp)
+GO(posix_spawnattr_setschedpolicy, iFpi)
+GOW(posix_spawnattr_setsigdefault, iFpp)
+GOW(posix_spawnattr_setsigmask, iFpp)
 GO(posix_spawn_file_actions_addclose, iFpi)
 GO(posix_spawn_file_actions_adddup2, iFpii)
 GO(posix_spawn_file_actions_addopen, iFpipii)
@@ -1509,6 +1510,7 @@ GOW(send, lFipLi)
 GO(sendfile, lFiipL)
 GO(sendfile64, lFiipL)
 GOW(sendmsg, lFipi)
+GO2(sendmmsg, iFEipuu, my___sendmmsg)
 GOM(__sendmmsg, iFEipuu)    //%% actual __sendmmsg is glibc 2.14+. The syscall is Linux 3.0+, so use syscall...
 GOW(sendto, lFipLipu)
 // setaliasent
@@ -1573,6 +1575,7 @@ GO(setxattr, iFpppui)
 // sgetspent_r  // Weak
 GOW(shmat, pFipi)
 GOW(shmctl, iFiip)
+GO(__shmctl64, iFiip)
 GOW(shmdt, iFp)
 GOW(shmget, iFuui)
 GOW(shutdown, iFii)
@@ -1644,7 +1647,7 @@ GO2(sscanf, iFppV, vsscanf)     // sscanf va_list is only pointer, no realign to
 GOM(__stack_chk_fail, vFEv) //%%
 GOM(lstat64, iFEpp)
 GOM(stat64, iFEpp)
-GOW(statfs, iFpp)
+GOWM(statfs, iFpp)       //%%,noE
 // __statfs
 GOWM(statfs64, iFpp)     //%%,noE
 GO(statvfs, iFpp)
@@ -1742,13 +1745,13 @@ GO2(__isoc23_strtol, lFppi, strtol)
 #ifdef HAVE_LD80BITS
 GO(strtold, DFpp)
 GO(__strtold_internal, DFppi)
-GO(__strtold_l, DFppip)
-GOW(strtold_l, DFppu)
+GO(__strtold_l, DFppp)
+GOW(strtold_l, DFppp)
 #else
 GO(strtold, KFpp)
 GO2(__strtold_internal, KFppi, __strtod_internal)
-GO2(__strtold_l, KFppip, __strtod_l)
-GOW2(strtold_l, KFppu, strtod_l)
+GO2(__strtold_l, KFppp, __strtod_l)
+GOW2(strtold_l, KFppp, strtod_l)
 #endif
 GO(__strtol_internal, lFppi)
 GO(strtoll, IFppi)
@@ -2240,12 +2243,11 @@ GO(asctime64_r, pFpp)
 GO(ctime64, pFp)
 GO(ctime64_r, pFpp)
 GO(gmtime64, pFp)
+GOM(__fcntl_time64, iFEiiN) //%%
 GO(gmtime64_r, pFpp)
 GO(localtime64, pFpp)
 GO(localtime64_r, pFpp)
-GO(mktime64, UFp)
-GO(timegm64, UFp)
-GO(timelocal64, UFp)
+GO(__ppoll64, iFpupp)
 GO(__clock_gettime64, iFpp)
 GO(__stat_time64, iFpp)  //needs alignement?
 GO(__fstat_time64, iFip)
@@ -2253,6 +2255,32 @@ GO(__lstat_time64, iFpp)
 GO(__fstatat_time64, iFippi)
 GO(__futimens_time64, iFip)
 GO(__utimensat_time64, iFippi)
+//tested
+GOW(__gettimeofday64, iFpp)
+GO(__mktime64, IFp)
+GOM(__lstat64_time64, iFEpp)
+GOM(__stat64_time64, iFEpp)
+GOM(__fstatat64_time64, iFEippi)
+GOM(__fstat64_time64, iFEip)
+GO(__ctime64, pFp)
+GO(__gmtime64, pFp)
+GO(__localtime64, pFpp)
+GO(mktime64, IFp)
+GO(timegm64, IFp)
+GO(timelocal64, IFp)
+GO(__clock_getres64, iFpp)
+GO(__futimens64, iFip)
+GO(__time64, IFp)
+GO(timespec_get, iFpi)
+
+//untested
+GOW(__getrusage64, iFip)
+GOW(__getsockopt64, iFiiipp)
+GO(__ioctl_time64, iFiLN)
+GOW(__recvmsg64, lFipi)
+GOW(__select64, iFipppp)
+GOW(__sendmsg64, lFipi)
+GOW(__setsockopt64, iFiiipu)

 GOM(fstatat64, iFippi)  //%%,noE
 GOM(fstat64, iFip)  //%%,noE
@@ -2266,17 +2294,14 @@ GO(dummy_safer_scalable_aligned_realloc, pFpLLp)    // for mallochook.c

 #ifdef ANDROID
 GOM(__libc_init, vFEpppp)
-GOM(stat, iFpp)             //%noE
-GOM(lstat, iFpp)            //%noE
-GOM(fstat, iFip)            //%noE
 GO(__errno, pFv)
 #include "wrappedlibpthread_private.h"
 #include "wrappedlibrt_private.h"
 #else
 // Those symbols don't exist in non-Android builds
 //GOM(__libc_init,
-//GOM(stat,
-//GOM(lstat,
-//GOM(fstat,
 //GO(__errno,
 #endif
+GOM(stat, iFpp)             //%noE
+GOM(lstat, iFpp)            //%noE
+GOM(fstat, iFip)            //%noE
@@ -100,7 +100,7 @@ void* my_dlopen(x86emu_t* emu, void *filename, int flag)
            if(sys)
                return sys;
        }
-        if(!strcmp(rfilename, "/usr/lib/x86_64-linux-gnu/d3d")) {
+        if(!strcmp(rfilename, "/usr/lib/i386-linux-gnu/d3d")) {
            void* sys = my_dlopen(emu, "d3dadapter9.so.1", flag);
            if(sys)
                return sys;
@@ -121,7 +121,7 @@ void* my_dlopen(x86emu_t* emu, void *filename, int flag)
            box_free(origin);
        }
        while(strstr(rfilename, "${PLATFORM}")) {
-            char* platform = box_strdup("x86_64");
+            char* platform = box_strdup("i386");
            char* p = strrchr(platform, '/');
            if(p) *p = '\0';    // remove file name to have only full path, without last '/'
            char* tmp = (char*)box_calloc(1, strlen(rfilename)-strlen("${PLATFORM}")+strlen(platform)+1);
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+#include <dlfcn.h>
+
+#include "wrappedlibs.h"
+
+#include "debug.h"
+#include "wrapper.h"
+#include "bridge.h"
+#include "librarian/library_private.h"
+#include "x86emu.h"
+#include "emu/x86emu_private.h"
+#include "callback.h"
+#include "librarian.h"
+#include "box86context.h"
+#include "myalign.h"
+#include "gltools.h"
+
+const char* libglxName = "libGLX.so.0";
+#define LIBNAME libglx
+
+#include "generated/wrappedlibglxtypes.h"
+
+#include "wrappercallback.h"
+
+#define SUPER() \
+GO(0)   \
+GO(1)   \
+GO(2)   \
+GO(3)   \
+
+
+#undef SUPER
+
+EXPORT void* myx_glXGetProcAddress(x86emu_t* emu, void* name) 
+{
+    khint_t k;
+    const char* rname = (const char*)name;
+    return getGLProcAddress(emu, (glprocaddress_t)my->glXGetProcAddress, rname);
+}
+
+EXPORT void* myx_glXGetProcAddressARB(x86emu_t* emu, void* name) 
+{
+    khint_t k;
+    const char* rname = (const char*)name;
+    return getGLProcAddress(emu, (glprocaddress_t)my->glXGetProcAddressARB, rname);
+}
+
+#define ALTMY myx_
+
+#include "wrappedlib_init.h"
@@ -0,0 +1,45 @@
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
+#error meh!
+#endif
+
+// __glXGLLoadGLXFunction
+GO(glXChooseFBConfig, pFpipp)
+GO(glXChooseVisual, pFpip)
+GO(glXCopyContext,vFppp)
+GO(glXCreateContext,pFpppi)
+GO(glXCreateGLXPixmap,pFppp)
+GO(glXCreateNewContext,pFppipi)
+GO(glXCreatePbuffer,pFppp)
+GO(glXCreatePixmap,pFppp)
+GO(glXCreateWindow,pFpppp)
+GO(glXDestroyContext,vFpp)
+GO(glXDestroyGLXPixmap,vFpp)
+GO(glXDestroyPbuffer,vFpp)
+GO(glXDestroyPixmap,vFpp)
+GO(glXDestroyWindow,vFpp)
+GO(glXGetClientString, pFpi)
+GO(glXGetConfig, iFppip)
+GO(glXGetCurrentContext, pFv)
+GO(glXGetCurrentDisplay, pFv)
+GO(glXGetCurrentDrawable, pFv)
+GO(glXGetCurrentReadDrawable, pFv)
+GO(glXGetFBConfigAttrib, iFppip)
+GO(glXGetFBConfigs,pFpip)
+GOM(glXGetProcAddress, pFEp)
+GOM(glXGetProcAddressARB, pFEp)
+GO(glXGetSelectedEvent, vFppp)
+GO(glXGetVisualFromFBConfig, pFpp)
+GO(glXIsDirect,iFpp)
+GO(glXMakeContextCurrent,iFpppp)
+GO(glXMakeCurrent,iFppp)
+GO(glXQueryContext,iFppip)
+GO(glXQueryDrawable, iFppip)
+GO(glXQueryExtension, iFppp)
+GO(glXQueryExtensionsString,pFpi)
+GO(glXQueryServerString,pFpii)
+GO(glXQueryVersion,iFppp)
+GO(glXSelectEvent, vFppu)
+GO(glXSwapBuffers,vFpp)
+GO(glXUseXFont,vFpiii)
+GO(glXWaitGL,vFv)
+GO(glXWaitX,vFv)
@@ -5,6 +5,7 @@
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
+#include <semaphore.h>

 #include "wrappedlibs.h"

@@ -132,6 +133,33 @@ EXPORT void my___pthread_initialize()
    // nothing, the lib initialize itself now
 }

+void Timespec2Timespec64(void* dest, const void* source);
+EXPORT int my_sem_timedwait(sem_t* sem, struct timespec * t)
+{
+    // some x86 game are not computing timeout correctly (ex: Anomaly Warzone Earth linux version)
+    #ifdef __USE_TIME64_REDIRECTS
+    struct timespec t1;
+    Timespec2Timespec64(&t1, t);
+    while(t1.tv_nsec>=1000000000) {
+        t1.tv_nsec-=1000000000;
+        t1.tv_sec+=1;
+    }
+    return sem_timedwait(sem, &t1);
+    #else
+    if(t->tv_nsec>=1000000000) {
+        struct timespec t1;
+        t1.tv_sec=t->tv_sec+1;
+        t1.tv_nsec=t->tv_nsec-1000000000;
+        while(t1.tv_nsec>=1000000000) {
+            t1.tv_nsec-=1000000000;
+            t1.tv_sec+=1;
+        }        
+        return sem_timedwait(sem, &t1);
+    }
+    return sem_timedwait(sem, t);
+    #endif
+}
+
 #define PRE_INIT\
    if(1)                                                           \
        lib->w.lib = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);    \
@@ -202,7 +202,7 @@ GO(sem_getvalue, iFpp)
 GO(sem_init, iFpiu)
 GO(sem_open, pFpOM)
 GO(sem_post, iFp)
-GO(sem_timedwait, iFpp)
+GOM(sem_timedwait, iFpp) //%noE
 GO(sem_trywait, iFp)
 GO(sem_unlink, iFp)
 GO(sem_wait, iFp)
@@ -85,7 +85,7 @@ GO(__res_mkquery, iFipiipippi)
 GOW(res_mkquery, iFipiipippi)
 GO(__res_nameinquery, iFpiipp)
 //GO(__res_nmkquery
-//GO(__res_nquery
+GO(__res_nquery, iFipiipi)
 //GO(__res_nquerydomain
 GO(__res_nsearch, iFppiipi)
 //GO(__res_nsend
@@ -22,6 +22,7 @@
 #include "librarian.h"
 #include "box86context.h"
 #include "emu/x86emu_private.h"
+#include "myalign.h"

 #undef aio_suspend
 #undef aio_return
@@ -29,8 +30,6 @@
 #undef aio_read
 #undef aio_error

-#undef clock_gettime
-
 const char* librtName = "librt.so.1";
 #define LIBNAME librt

@@ -155,6 +154,43 @@ EXPORT int mylio_listio(x86emu_t* emu, int mode, void* list[], int nent, struct
 }
 #endif

+EXPORT int my_clock_gettime(int clock, void* buf)
+{
+    #ifdef __USE_TIME64_REDIRECTS
+    struct timespec spec;
+    int ret = clock_gettime(clock, &spec);
+    Timespec642Timespec(buf, &spec);
+    return ret;
+    #else
+    return clock_gettime(clock, buf);
+    #endif
+}
+EXPORT int my_clock_settime(int clock, void* buf)
+{
+    #ifdef __USE_TIME64_REDIRECTS
+    struct timespec spec;
+    Timespec2Timespec64(&spec, buf);
+    return clock_settime(clock, &spec);
+    #else
+    return clock_settime(clock, buf);
+    #endif
+}
+
+EXPORT int my_clock_nanosleep(int clock, int flags, void* _t1, void* _t2)
+{
+    #ifdef __USE_TIME64_REDIRECTS
+    struct timespec t1, t2;
+    if(_t1)
+        Timespec2Timespec64(&t1, _t1);
+    int ret = clock_nanosleep(clock, flags, _t1?(&t1):NULL, _t2?(&t2):NULL);
+    if(_t2)
+        Timespec642Timespec(_t2, &t2);
+    return ret;
+    #else
+    return clock_nanosleep(clock, flags, _t1, _t2);
+    #endif
+}
+
 #define CUSTOM_INIT \
    getMy(lib);

@@ -23,9 +23,9 @@ GOM(aio_write, iFEp)
 GOM(aio_write64, iFEp)
 GO(clock_getcpuclockid, iFup)
 GO(clock_getres, iFup)
-GO(clock_gettime, iFup)
-GO(clock_nanosleep, iFuipp)
-GO(clock_settime, iFup)
+GOM(clock_gettime, iFip)    //%%,noE
+GOM(clock_nanosleep, iFiipp)    //%%,noE
+GOM(clock_settime, iFip)    //%%,noE
 GOM(lio_listio, iFEipip)
 // lio_listio64
 // mq_close
@@ -290,7 +290,7 @@ GO(XDisplayWidthMM, iFpi)
 GO(XDrawArc, iFpppiiuuii)
 //GO(XDrawArcs
 GO(XDrawImageString, iFpppiipi)
-//GO(XDrawImageString16
+GO(XDrawImageString16, iFpppiipi)
 GO(XDrawLine, iFpppiiii)
 GO(XDrawLines, iFppppii)
 GO(XDrawPoint, iFpppii)
@@ -397,7 +397,7 @@ GOS(xcb_open_font_checked, xFEpuWp)
 //GO(xcb_open_font_name_end, 
 //GO(xcb_open_font_name_length, 
 //GO(xcb_open_font_sizeof, 
-//GO(xcb_parse_display, 
+GO(xcb_parse_display, iFpppp)
 //GO(xcb_pixmap_end, 
 //GO(xcb_pixmap_next, 
 //GO(xcb_point_end, 
@@ -911,7 +911,7 @@ static void* find_io_new_Fct(void* fct)
 // io_enable
 #define GO(A)                                                   \
 static uintptr_t my_io_enable_fct_##A = 0;                      \
-static void* my_io_enable_##A(void* api, int events)            \
+static void my_io_enable_##A(void* api, int events)             \
 {                                                               \
    RunFunctionFmt(my_io_enable_fct_##A, "pi", api, events);    \
 }
@@ -933,7 +933,7 @@ static void* find_io_enable_Fct(void* fct)
 // io_free
 #define GO(A)                                   \
 static uintptr_t my_io_free_fct_##A = 0;        \
-static void* my_io_free_##A(void* e)            \
+static void my_io_free_##A(void* e)             \
 {                                               \
    RunFunctionFmt(my_io_free_fct_##A, "p", e); \
 }
@@ -999,7 +999,7 @@ static void* find_time_new_Fct(void* fct)
 // time_restart
 #define GO(A)                                               \
 static uintptr_t my_time_restart_fct_##A = 0;               \
-static void* my_time_restart_##A(void* e, void* t)          \
+static void my_time_restart_##A(void* e, void* t)           \
 {                                                           \
    RunFunctionFmt(my_time_restart_fct_##A, "pp", e, t);    \
 }
@@ -1021,7 +1021,7 @@ static void* find_time_restart_Fct(void* fct)
 // time_free
 #define GO(A)                                       \
 static uintptr_t my_time_free_fct_##A = 0;          \
-static void* my_time_free_##A(void* e)              \
+static void my_time_free_##A(void* e)               \
 {                                                   \
    RunFunctionFmt(my_time_free_fct_##A, "p", e);   \
 }
@@ -1087,7 +1087,7 @@ static void* find_defer_new_Fct(void* fct)
 // defer_enable
 #define GO(A)                                               \
 static uintptr_t my_defer_enable_fct_##A = 0;               \
-static void* my_defer_enable_##A(void* e, int b)            \
+static void my_defer_enable_##A(void* e, int b)             \
 {                                                           \
    RunFunctionFmt(my_defer_enable_fct_##A, "pi", e, b);    \
 }
@@ -1109,7 +1109,7 @@ static void* find_defer_enable_Fct(void* fct)
 // defer_free
 #define GO(A)                                       \
 static uintptr_t my_defer_free_fct_##A = 0;         \
-static void* my_defer_free_##A(void* e)             \
+static void my_defer_free_##A(void* e)              \
 {                                                   \
    RunFunctionFmt(my_defer_free_fct_##A, "p", e);  \
 }
@@ -1153,7 +1153,7 @@ static void* find_defer_set_destroy_Fct(void* fct)
 // quit
 #define GO(A)                                           \
 static uintptr_t my_quit_fct_##A = 0;                   \
-static void* my_quit_##A(void* e, int retval)           \
+static void my_quit_##A(void* e, int retval)            \
 {                                                       \
    RunFunctionFmt(my_quit_fct_##A, "pi", e, retval);   \
 }
@@ -681,6 +681,12 @@ DESTROY64(vkDestroyPrivateDataSlotEXT)
 CREATE(vkCreateOpticalFlowSessionNV)
 DESTROY64(vkDestroyOpticalFlowSessionNV)

+CREATE(vkCreateVideoSessionKHR)
+CREATE(vkCreateVideoSessionParametersKHR)
+DESTROY64(vkDestroyVideoSessionKHR)
+DESTROY64(vkDestroyVideoSessionParametersKHR)
+
+
 EXPORT void my_vkGetPhysicalDeviceProperties(x86emu_t* emu, void* device, void* pProps)
 {
    (void)emu;
@@ -906,3 +912,13 @@ EXPORT int my_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(x86emu_t* emu, void*
    vkunalignStruct(m, desc, *count);   // bad things will happens if *count is changed while pSparseMemoryRequirements is not NULL
    return ret;
 }
+
+EXPORT int my_vkBindVideoSessionMemoryKHR(x86emu_t* emu, void* device, uint64_t session, uint32_t count, void* pInfos)
+{
+    (void)emu;
+    static const char* desc = "uPuUUU";
+    void* m = vkalignStruct(pInfos, desc, count);
+    int ret = my->vkBindVideoSessionMemoryKHR(device, session, count, m);
+    vkunalignStruct(m, desc, count);
+    return ret;
+}
@@ -433,7 +433,7 @@ GO(vkReleaseFullScreenExclusiveModeEXT, iFpU)
 GO(vkGetDeviceGroupSurfacePresentModes2EXT, iFpPp)

 // VK_EXT_calibrated_timestamps
-GO(vkGetCalibratedTimestampsEXT, iFpuppp)
+GO(vkGetCalibratedTimestampsEXT, iFpuPpp)
 GO(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, iFppp)

 // VK_EXT_sample_locations
@@ -660,4 +660,27 @@ GO(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, iFppp)    // last arg shou
 GO(vkCmdBindIndexBuffer2KHR, vFpUUUu)
 GO(vkGetDeviceImageSubresourceLayoutKHR, vFpPP)
 GO(vkGetImageSubresourceLayout2KHR, vFpUPP)
-GO(vkGetRenderingAreaGranularityKHR, vFpPp)
+GO(vkGetRenderingAreaGranularityKHR, vFpPp)
+
+// VK_KHR_calibrated_timestamps
+GO(vkGetCalibratedTimestampsKHR, iFpuPpp)
+GO(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, iFppp)
+
+// VK_KHR_video_queue
+GOM(vkBindVideoSessionMemoryKHR, iFEpUup)
+GO(vkCmdBeginVideoCodingKHR, vFpP)
+GO(vkCmdControlVideoCodingKHR, vFpP)
+GO(vkCmdEndVideoCodingKHR, vFpP)
+GOM(vkCreateVideoSessionKHR, iFEpppp)
+GOM(vkCreateVideoSessionParametersKHR, iFEpppp)
+GOM(vkDestroyVideoSessionKHR, vFEpUp)
+GOM(vkDestroyVideoSessionParametersKHR, vFEpUp)
+GO(vkGetPhysicalDeviceVideoCapabilitiesKHR, iFpPp)
+GO(vkGetPhysicalDeviceVideoFormatPropertiesKHR, iFpPpp)
+GO(vkGetVideoSessionMemoryRequirementsKHR, iFpUpp)
+GO(vkUpdateVideoSessionParametersKHR, iFpUp)
+
+//VK_KHR_video_encode_queue
+GO(vkCmdEncodeVideoKHR, vFpP)
+GO(vkGetEncodedVideoSessionParametersKHR, iFpPPpp)
+GO(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, iFpPP)
@@ -203,7 +203,7 @@ GO(xmlCheckFilename, iFp)
 GO(xmlCheckHTTPInput, pFpp)
 GO(xmlCheckLanguageID, iFp)
 GO(xmlCheckUTF8, iFp)
-//GO(xmlCheckVersion, 
+GO(xmlCheckVersion,  vFi)
 GO(xmlChildElementCount, LFp)
 GO(xmlCleanupCharEncodingHandlers, vFv)
 GO(xmlCleanupEncodingAliases, vFv)
@@ -76,6 +76,7 @@ BOX86_NOGTK=1
 BOX86_DYNAREC_STRONGMEM=1
 BOX86_X11COLOR16=1
 BOX86_DYNAREC_CALLRET=0 #it seems to be unstable in some cases, so disabling (for #920)
+#BOX86_NOCRASHHANDLER=1

 [streaming_client]
 BOX86_EMULATED_LIBS=libSDL2-2.0.so.0:libSDL2_ttf-2.0.so.0
@@ -113,6 +114,11 @@ BOX86_DYNAREC_FORWARD=512
 # Wine process
 #

+[EAappInstaller.exe]
+BOX86_DYNAREC_SAFEFLAGS=2
+BOX86_DYNAREC_BIGBLOCK=0
+BOX86_DYNAREC_STRONGMEM=1
+
 [MassEffect.exe]
 BOX86_DYNAREC_STRONGMEM=1
 BOX86_DYNAREC_FASTNAN=0
@@ -32,7 +32,7 @@ uint64_t _fucompp_(double a, double b)
    :"=a" (ret):"m"(a), "m"(b):"cc");
    return ret;
 }
-uint64_t _fistpw_(double a)
+uint64_t _fistpw_(double a, uint8_t rd)
 {
    uint16_t ret;
    uint16_t t1, t2;
@@ -40,15 +40,31 @@ uint64_t _fistpw_(double a)
    "fldl %1\n"
    "fstcw %2\n"
    "mov %2, %%ax\n"
-    "mov $0x0c, %%ah\n"
+    "mov %4, %%ah\n"
    "mov %%ax, %3\n"
    "fldcw %3\n"
    "fistp %0\n"
    "fldcw %2\n"
-    :"=m" (ret):"m"(a), "m"(t1), "m"(t2):"cc");
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
    return ret;
 }
-uint64_t _fistpl_(double a)
+uint64_t _fisttpw_(double a, uint8_t rd)
+{
+    uint16_t ret;
+    uint16_t t1, t2;
+    asm volatile (
+    "fldl %1\n"
+    "fstcw %2\n"
+    "mov %2, %%ax\n"
+    "mov %4, %%ah\n"
+    "mov %%ax, %3\n"
+    "fldcw %3\n"
+    "fisttp %0\n"
+    "fldcw %2\n"
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
+    return ret;
+}
+uint64_t _fistpl_(double a, uint8_t rd)
 {
    uint32_t ret;
    uint16_t t1, t2;
@@ -56,15 +72,31 @@ uint64_t _fistpl_(double a)
    "fldl %1\n"
    "fstcw %2\n"
    "mov %2, %%ax\n"
-    "mov $0x0c, %%ah\n"
+    "mov %4, %%ah\n"
    "mov %%ax, %3\n"
    "fldcw %3\n"
    "fistpl %0\n"
    "fldcw %2\n"
-    :"=m" (ret):"m"(a), "m"(t1), "m"(t2):"cc");
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
    return ret;
 }
-uint64_t _fistpq_(double a)
+uint64_t _fisttpl_(double a, uint8_t rd)
+{
+    uint32_t ret;
+    uint16_t t1, t2;
+    asm volatile (
+    "fldl %1\n"
+    "fstcw %2\n"
+    "mov %2, %%ax\n"
+    "mov %4, %%ah\n"
+    "mov %%ax, %3\n"
+    "fldcw %3\n"
+    "fisttpl %0\n"
+    "fldcw %2\n"
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
+    return ret;
+}
+uint64_t _fistpq_(double a, uint8_t rd)
 {
    uint64_t ret;
    uint16_t t1, t2;
@@ -72,15 +104,15 @@ uint64_t _fistpq_(double a)
    "fldl %1\n"
    "fstcw %2\n"
    "mov %2, %%ax\n"
-    "mov $0x0c, %%ah\n"
+    "mov %4, %%ah\n"
    "mov %%ax, %3\n"
    "fldcw %3\n"
    "fistpq %0\n"
    "fldcw %2\n"
-    :"=m" (ret):"m"(a), "m"(t1), "m"(t2):"cc");
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
    return ret;
 }
-uint64_t _frndint_(double a)
+uint64_t _fisttpq_(double a, uint8_t rd)
 {
    uint64_t ret;
    uint16_t t1, t2;
@@ -88,13 +120,29 @@ uint64_t _frndint_(double a)
    "fldl %1\n"
    "fstcw %2\n"
    "mov %2, %%ax\n"
-    "mov $0x0c, %%ah\n"
+    "mov %4, %%ah\n"
+    "mov %%ax, %3\n"
+    "fldcw %3\n"
+    "fisttpq %0\n"
+    "fldcw %2\n"
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
+    return ret;
+}
+uint64_t _frndint_(double a, uint8_t rd)
+{
+    uint64_t ret;
+    uint16_t t1, t2;
+    asm volatile (
+    "fldl %1\n"
+    "fstcw %2\n"
+    "mov %2, %%ax\n"
+    "mov %4, %%ah\n"
    "mov %%ax, %3\n"
    "fldcw %3\n"
    "frndint\n"
    "fstpl %0\n"
    "fldcw %2\n"
-    :"=m" (ret):"m"(a), "m"(t1), "m"(t2):"cc");
+    :"=m" (ret):"m"(a), "m"(t1), "m"(t2), "m"(rd):"cc");
    return ret;
 }
 #endif
@@ -105,44 +153,54 @@ int main(int argc, const char** argv)
 char pf, cf, zf;
 char pa, ca, za;
 uint64_t flags;
- uint64_t tests[][2] = {
-  {0x0, 0x4082c00000000000LL},
-  {0x8000000000000000LL, 0x4082c00000000000LL},
-  {0x8000000000000000LL, 0x0},
-  {0x8000000000000000LL, 0x3ff0000000000000LL},
-  {0x3ff0000000000000LL, 0x3fe89d9000000000LL},
-  {0x3ff0000000000000LL, 0x7ff0000000000000LL},
-  {0xfff0000000000000LL, 0x7ff0000000000000LL},
-  {0x3ff0002ca0000000LL, 0xaeff000025000000LL},
-  {0x3ff0000050000000LL, 0xc082c00000000000LL},
-  {0x0, 0x7ff8000000000001LL},
-  {0x7ff8000000000001LL, 0x7ff8000000000001LL},
- };
- int n = sizeof(tests)/sizeof(tests[0]); 
- for(int i=0; i<n; ++i)
-  for(int j=0; j<2; ++j) {
-   *(uint64_t*)&a = tests[i][0+j];
-   *(uint64_t*)&b = tests[i][1-j];
-   printf("FUCOMI 0x%llx 0x%llx ", *(uint64_t*)&a, *(uint64_t*)&b);
-   flags = _fucomip_(a, b);
-   ca = (flags>>0)&1?'C':'-';
-   za = (flags>>(0+6))&1?'Z':'-';
-   pa = (flags>>(0+2))&1?'P':'-';
-   printf("%c%c%c\n", za, pa, ca);
-   printf("FUCOMPP 0x%llx 0x%llx ", *(uint64_t*)&a, *(uint64_t*)&b);
-   flags = _fucompp_(a, b);
-   ca = (flags>>8)&1?'C':'-';
-   za = (flags>>(8+6))&1?'Z':'-';
-   pa = (flags>>(8+2))&1?'P':'-';
-   printf("%c%c%c\n", za, pa, ca);
-   printf("FRNDINT 0x%llx => 0x%llx\n", *(uint64_t*)&a, _frndint_(a));
-   printf("FRNDINT 0x%llx => 0x%llx\n", *(uint64_t*)&b, _frndint_(b));
-   printf("FISTP 0x%llx => word: %x\n", *(uint64_t*)&a, _fistpw_(a));
-   printf("FISTP 0x%llx => word: %x\n", *(uint64_t*)&b, _fistpw_(b));
-   printf("FISTP 0x%llx => long: %x\n", *(uint64_t*)&a, _fistpl_(a));
-   printf("FISTP 0x%llx => long: %x\n", *(uint64_t*)&b, _fistpl_(b));
-   printf("FISTP 0x%llx => quad: %llx\n", *(uint64_t*)&a, _fistpq_(a));
-   printf("FISTP 0x%llx => quad: %llx\n", *(uint64_t*)&b, _fistpq_(b));
+ uint64_t tests[] = {
+    0x0,
+    0x4082c00000000000LL,
+    0x8000000000000000LL,
+    0x40dfffc000000000LL, 
+    0x40e0002000000000LL, 	// 0x7fff and 0x8001 as double
+    0xc0e0002000000000LL, 
+    0xc0dfffc000000000LL,	// -0x8001 and -0x7fff as double
+    0x3ff0000000000000LL,
+    0x3fe89d9000000000LL,
+    0x7ff0000000000000LL,
+    0xfff0000000000000LL, 
+    0x3ff0002ca0000000LL, 
+    0xaeff000025000000LL,
+    0x3ff0000050000000LL, 
+    0xc082c00000000000LL,
+    0x7ff8000000000001LL,
+};
+int n = sizeof(tests)/sizeof(tests[0]); 
+for(int i=0; i<n; ++i)
+    for(int j=0; j<n; ++j) {
+        *(uint64_t*)&a = tests[i];
+        *(uint64_t*)&b = tests[j];
+        printf("FUCOMI 0x%llx 0x%llx ", *(uint64_t*)&a, *(uint64_t*)&b);
+        flags = _fucomip_(a, b);
+        ca = (flags>>0)&1?'C':'-';
+        za = (flags>>(0+6))&1?'Z':'-';
+        pa = (flags>>(0+2))&1?'P':'-';
+        printf("%c%c%c\n", za, pa, ca);
+        printf("FUCOMPP 0x%llx 0x%llx ", *(uint64_t*)&a, *(uint64_t*)&b);
+        flags = _fucompp_(a, b);
+        ca = (flags>>8)&1?'C':'-';
+        za = (flags>>(8+6))&1?'Z':'-';
+        pa = (flags>>(8+2))&1?'P':'-';
+        printf("%c%c%c\n", za, pa, ca);
+    }
+for(int i=0; i<n; ++i) {
+    *(uint64_t*)&a = tests[i];
+    for(int rd=0; rd<3; ++rd) {
+        printf("Rounding %d\n", rd);
+        printf(" FRNDINT 0x%llx => 0x%llx\n", *(uint64_t*)&a, _frndint_(a, rd<<2));
+        printf(" FISTP 0x%llx => word: %x\n", *(uint64_t*)&a, _fistpw_(a, rd<<2));
+        printf(" FISTP 0x%llx => long: %x\n", *(uint64_t*)&a, _fistpl_(a, rd<<2));
+        printf(" FISTP 0x%llx => quad: %llx\n", *(uint64_t*)&a, _fistpq_(a, rd<<2));
+        printf(" FISTTP 0x%llx => word: %x\n", *(uint64_t*)&a, _fisttpw_(a, rd<<2));
+        printf(" FISTTP 0x%llx => long: %x\n", *(uint64_t*)&a, _fisttpl_(a, rd<<2));
+        printf(" FISTTP 0x%llx => quad: %llx\n", *(uint64_t*)&a, _fisttpq_(a, rd<<2));
+    }
 }
 printf("\nDone\n");
 }
Author	SHA1	Message	Date
JWWTSL	bb716a2a65	Fix typos in comments and documentation (#1072 ) Correct "adressing", "constains", "informations", "Aleady" and "interpretor".	2026-10-20 15:45:11 +02:00
ptitSeb	7dec0819b5	[WRAPPER] Added 1 wrapped function to libxml2 (for #1061 )	2026-09-27 08:26:24 +02:00
SpongeBob	b05cb3ab54	Fix LOCK 16-bit INC/DEC using 32-bit primop in interpreter path (#1070 ) RunF066 handles F0 66 FF /0,/1 (LOCK INC/DEC Ew). The non-DYNAREC path applied inc32/dec32 to ED->dword[0], corrupting the upper 16 bits and computing OF/SF/ZF/AF/PF at the wrong operand width. The DYNAREC path just above correctly uses inc16/dec16, as does the non-LOCK Grp5 Ew handler in x86run66.c (EW->word[0] = inc16/dec16). Narrow the interpreter LOCK path to ED->word[0] with inc16/dec16.	2026-09-11 09:45:03 +02:00
SpongeBob	dea645b38d	Fix aligned_realloc returning freed pointer (use-after-free) (#1069 ) my_safer_scalable_aligned_realloc and my_scalable_aligned_realloc grew the allocation via box_memalign+memcpy+box_free(p), then returned p instead of new_p. Callers received a dangling pointer while the live copy leaked, causing double-ownership, heap corruption, and crashes on TBB aligned growth. Return new_p.	2026-09-11 09:44:05 +02:00
SpongeBob	707a141e0d	Fix CVTTPS2PI low lane using high lane for lower-bound check (#1068 ) Case 0x2C (CVTTPS2PI Gm,Ex) validated GM.sd[0] against EX->f[1] for the negative-overflow test instead of EX->f[0]. The high lane just above correctly tests f[1] twice, and CVTPS2PI just below loops per-lane with f[i]. A low lane in range paired with an out-of-range high lane (e.g. f0=1.0, f1=-3e9) wrongly produced the 0x80000000 indefinite value, and a truly underflowing low lane could slip through. Test the low lane against itself.	2026-09-11 09:42:51 +02:00
SpongeBob	14181b503b	Fix atfork parent/child loop decrement causing infinite loop and OOB (#1067 ) x86emu_fork ran parent/child atfork handlers with 'for (i=0; i<sz; --i)'. With sz>0, i goes 0,-1,-2... staying <sz forever: infinite loop plus out-of-bounds atforks[i] access. The prepare loop just above correctly iterates reverse with '--i' from sz-1. Change parent/child loops to '++i' for forward iteration.	2026-09-10 09:18:54 +02:00
SpongeBob	9a67cb9355	Fix 16-bit disp16 precedence bug in getecommon16o (#1066 ) In C, == binds tighter than &, so 'm&7==6' parsed as 'm&(7==6)' = 'm&0' = always false. Disp16 was never fetched for mod==00,rm==110 16-bit addressing (GET_EW16_OFFS), leaving a wrong effective address and unadvanced EIP. Parenthesize as '(m&7)==6' to match getecommon16.	2026-09-10 08:54:49 +02:00
ptitSeb	39d3ed2033	[INTPER] Added 64 66 8D opcode (for #1064 )	2026-08-12 22:27:32 +02:00
ptitSeb	646fc2d3a8	[INTERP] Added 66 8D opcode (for #1064 )	2026-08-12 19:35:09 +02:00
ptitSeb	0579f8b9c4	[PANDORA] Fix build	2026-01-07 18:00:58 +01:00
docgalaxyblock	50a2603027	Fix typo 'Snapragon' in CMakeLists.txt (#1057 )	2025-11-22 15:21:33 +01:00
ptitSeb	10224524df	[ELFLOADER] Fixed regression from previous commit (for #1055 )	2025-11-11 13:29:51 +01:00
ptitSeb	0886bb79c4	[ELFLOADER] Added support for IFUNC in PltResolver	2025-11-06 16:26:48 +01:00
Loyalburrito	fa14e0ab14	Add comments to systemd-binfmt restart script (#1050 ) This script checks for the presence of systemd and restarts the binfmt_misc service	2025-09-20 18:37:35 +02:00
ptitSeb	ac48800fbb	Added 64/65 F7 opcode (for #1048 )	2025-07-28 13:58:03 +02:00
ptitSeb	b197194e2d	[CI] Changed TAGRA build to use ubunt 22.04 as 20.04 has been removed	2025-06-22 13:41:26 +02:00
ptitSeb	2796d6ef92	[WRAPPER] Added 1 more wrapped function to libgobject2 (used by steam)	2025-06-22 13:23:14 +02:00
ptitSeb	d60937b1ac	[WRAPPER] Added wrapped libGLX (backported from box64)	2025-04-28 12:02:52 +02:00
ptitSeb	d0aad67ba0	[WRAPPER] Add libm to the libc collection of libs	2025-03-07 16:59:22 +01:00
ptitSeb	66fc843ae8	[WRAPPER] Fixed ld-linux.so.2 being an essential (not emulated) lib	2025-03-07 16:21:08 +01:00
ptitSeb	7e56375859	[WRAPPER] Some fixes to bsd wrapper and essential libs handling	2025-03-07 15:54:03 +01:00
Hugh Cole-Baker	c13b3cc9cd	[DEBIAN] exclude x86 libunwind from shlibdeps (#1032 )	2025-02-22 22:22:32 +01:00
ptitSeb	ba5b9e9954	Fixed a potential issue with findBlockHinted (for #1031 )	2025-02-21 15:10:56 +01:00
ptitSeb	fa59e748f9	[DYNAREC] Added a test for optimized REP MOVSB to avoid optim on overlapping addresses move	2025-02-12 12:49:37 +01:00
ptitSeb	c467c05112	[CI] Update to upload-artifact v4	2025-02-10 09:18:51 +01:00
ptitSeb	bb164a299f	[DYNAREC] Optimized REP MOVSB opcode	2025-02-10 09:05:52 +01:00
ptitSeb	eaf2e84e19	[INTERPRETER] Removed some useless tests on x87 comp	2025-01-08 15:54:50 +01:00
ptitSeb	7dcba89c71	[DYNAREC] Removed some bloated x87 code, improved test19 (backported from box64)	2025-01-08 15:31:14 +01:00
ptitSeb	5c5639be09	Trace program break to not allocate memory over there (backported from box64)	2025-01-07 15:39:44 +01:00
ValdikSS	ee0c949bc2	Document `BOX86_ARG0` argv[0] rewriting variable (#1021 )	2025-01-04 17:00:37 +01:00
ValdikSS	d9402213f6	Fix crash with incorrect argv[0]: rewrite it only if "box86" is present (#1020 )	2025-01-04 16:58:17 +01:00
ValdikSS	efe8bb4e6c	Bumped version to v0.3.8 (#1019 )	2025-01-04 13:27:06 +01:00
ptitSeb	ec278bd784	Bumped version to v0.3.8	2024-12-06 15:04:39 +01:00
ptitSeb	f1559b066c	[DYNAREC] Improved x87 comparison (backporteed from Box64)	2024-12-04 11:13:17 +01:00
ptitSeb	c9d20f60c8	[TRACE] Improved x87 trace (backported from Box64)	2024-12-04 11:12:45 +01:00
ptitSeb	512f0a6c92	[INTERPRETER] Improve x87 comparison (backported from Box64)	2024-12-04 10:25:46 +01:00
ptitSeb	1c280bd8a0	[INTERPRETER] Fixed x87 long double store that would loose sign on negative 0.0	2024-12-04 10:09:56 +01:00
ptitSeb	20432122de	[INTERPRETER] Fixed D9 F4 opcode ([DYNAREC] too) (backported from box64)	2024-12-03 14:36:23 +01:00
ptitSeb	e754df0fb1	[INTERPRETER] Fixes some longdoub / double conversion cases (on nan/infinites/0.0) (backported from Box64)"	2024-12-03 14:26:46 +01:00
ptitSeb	b9d565f444	[INTERPRETER] Added 0F 20..23 opcodes	2024-11-23 14:32:29 +01:00
theofficialgman	58f1b5d1e3	[X86LIBS] Changed x86 libs install directory to prevent conflicts (#1014 )	2024-11-20 17:52:53 +01:00
ptitSeb	f921c0cdbe	[WRAPPER] Added 1 wrapped function to fontconfig (for hl2)	2024-11-16 14:02:22 +01:00
ptitSeb	1e749beb2e	Added BOX86_NOCRASHHANDLER to ignore crashhandler.so (for #1012 )	2024-11-09 09:53:48 +01:00
ptitSeb	4caece4c0c	Improved syscall 120 and added syscal 26 (for #1012 )	2024-11-08 17:54:27 +01:00
ptitSeb	d6b76922e7	Yet another adjustment to getcontext / setcontext wrapped functons	2024-11-08 16:46:12 +01:00
ptitSeb	69a021454a	Adjusted getcontext / setcontext wrapped functons (should help #1012 )	2024-11-08 16:19:58 +01:00
ptitSeb	336dc5b676	[VULKAN] Added 1 more extention	2024-11-07 16:50:08 +01:00
Mike Wang	450347f099	Fixed some typos: BOX64 -> BOX86 (#1011 )	2024-11-06 17:12:55 +01:00
ptitSeb	30c72e23bd	Added some new functions and a few fixes (for Steam)	2024-11-06 16:06:13 +01:00
ptitSeb	ce0b4d1884	[CMAKE] Fixed SD865 profile, as a77.a55 is not supported in current build chain	2024-11-06 11:52:31 +01:00
ptitSeb	72d934b34c	Added SD865 profile (for the new Retroid Pocket mini 5)	2024-11-05 15:43:49 +01:00
ptitSeb	4e8d4a2bff	Added SD865 profile (for the new Retroid Pocket mini 5)	2024-11-05 15:41:26 +01:00
Mike Wang	c993aacd04	[CMAKE] Check CMAKE_SYSTEM_PROCESSOR after project() (#1008 )	2024-10-29 16:56:37 +01:00
ptitSeb	a7855d3bcb	Fixed a warning	2024-10-09 20:24:08 +02:00
ptitSeb	7b8a6aa91d	Changed hack for sem_timedwait to avoid changing const timespec	2024-10-09 10:09:52 +02:00
ptitSeb	c65c514882	Added a fix for old game that use sem_timewait in an incorrect way	2024-10-08 19:10:09 +02:00
ptitSeb	62bc6bb1f3	[VULKAN] Added one vulkan extension	2024-10-04 15:13:41 +02:00
ptitSeb	0504c042f4	[TRACE] Improved some freetype function trace	2024-10-04 15:13:18 +02:00
ptitSeb	54c806c576	Another attempt to fix the __st_ino build issue (for #983 )	2024-09-17 15:25:22 +02:00
ptitSeb	55e08ab0be	Try to fix some build issue (might help #983 )	2024-09-17 13:35:53 +02:00
ptitSeb	e717b959c6	[TRACE] A bit more traces details	2024-09-16 15:27:03 +02:00
ptitSeb	f97763cacd	[PANDORA] Fixed OpenPandora build	2024-09-13 17:59:35 +02:00
ptitSeb	fc43e4c22b	[WRAPPER] Fixed some warning on wrapped libpulse	2024-09-13 17:59:11 +02:00
ptitSeb	b01829b7d6	[RCFILE] Fixed a typo in a profile	2024-09-12 10:34:54 +02:00
ptitSeb	d1fcdee8a8	Simplified old pthread cond functions	2024-09-12 10:26:16 +02:00
ptitSeb	56b23e0668	Fixed a libc syscall fallback	2024-09-12 10:25:50 +02:00
ptitSeb	d927dae7e7	[WRAPPER] Fixed a few libc functions signatures	2024-09-12 10:25:01 +02:00
ptitSeb	a49c286214	Better wrapping of legacy stat/fstat/lstat using stat64 this time	2024-08-27 10:41:33 +02:00
ptitSeb	80e092ae44	re-wrapped legacy stat/fstat/lstat using 32bits stat and not 64bits ones	2024-08-26 10:13:53 +02:00
ptitSeb	05017f46d2	Added 1 wrapped function to libX11	2024-08-25 16:34:55 +02:00
ptitSeb	0caa80f9f1	Fixed a potential issue with glibc TLS block building	2024-08-25 16:34:35 +02:00
Raezroth	66a91b8580	Fix missing space in PKGBUILD-rk3xxx causing syntax error (#994 )	2024-08-15 08:56:08 +02:00
ptitSeb	bcd36a3152	[WRAPPER] Added 1 wrapped symbol to libc (for #985 )	2024-08-11 15:35:24 +02:00
ptitSeb	6aba6364c4	[WRAPPER] Added 1 wrapped function to libxcb (for #986 )	2024-08-11 15:30:35 +02:00
ptitSeb	0cf5179d7f	[ANDROID] Try to fix this f***** android build	2024-08-11 15:22:13 +02:00
ptitSeb	3c9823198c	[WRAPPER] Added 1 wrapped function to libgnutls (for #988 )	2024-08-11 15:10:24 +02:00
ptitSeb	664956aaa0	Fixed some issue when build OS is _time64 aware (should help #987 #983 #976 #975 , maybe some other)	2024-08-11 14:51:26 +02:00
ptitSeb	9811f140ce	Fixed some copy/pasta issues with some not offten used libdl capabilities	2024-08-06 14:21:11 +02:00
Ilya114	26ddd6e9ef	Update README_UK.md (#984 )	2024-07-28 09:44:48 +02:00
ptitSeb	c5bccdf300	Added 3 more wrapped function, not exclusive to android after all	2024-07-17 18:22:35 +02:00
ptitSeb	4b20581753	Fixed another typo	2024-07-16 20:45:32 +02:00
ptitSeb	a4f38779eb	Fixed some typos	2024-07-16 18:55:34 +02:00
ptitSeb	27c21f6979	Changed how TRAPNO 12 is triggered	2024-07-16 17:24:36 +02:00
rajdakin	e14d8abb61	[MAXCPU] Added support for maxcpu (backport from box64) (#982 ) * [MAXCPU] Added support for maxcpu (backport from box64) * [MAXCPU] Added documentation for maxcpu * [ARM PRINTER] Fixed ADR decoder * [WRAPPED] Fixed wrapped libc	2024-07-16 11:15:33 +02:00
ptitSeb	54ed80f68a	[VULKAN] Added 1 more extension (for #980 )	2024-07-16 10:23:19 +02:00
ptitSeb	a187c7ccd3	Added 2 new time64 wrapped libc functions	2024-07-16 10:12:41 +02:00
Panda	f6a5322cf3	chore: check if arm-linux-gnueabihf-gcc exists else user defined value (#981 ) closes #978	2024-07-16 10:00:03 +02:00
Panda	5da8235b18	build: fix PKGBUILD-rk3xxx, _rkmodel was never set (#979 ) Code was taken from box64's PKGBUILD-rk3xxx	2024-07-16 08:11:18 +02:00
ptitSeb	21e9a43d21	[TRACE] Fixed some issue with function name printing	2024-07-13 10:11:04 +02:00
ptitSeb	dcc0355113	Fixed some issue on tracking when protecting memory with PROT=0	2024-07-13 10:07:51 +02:00
ptitSeb	666b5a6ce6	Fixed a nasty bug on memory permission tracking	2024-07-11 12:16:16 +02:00
ptitSeb	fcbebfa8c8	[RCFILE] Added 1 new profile	2024-07-05 10:04:32 +02:00
ptitSeb	9354744f68	[DOCS] Change organisation of COMPILE.md	2024-07-03 09:56:52 +02:00
ptitSeb	fc0b51f3b8	Added a few more wrapped function (for steam)	2024-06-19 21:15:36 +02:00
theofficialgman	cd88702516	switch to maintained Pi-Apps-Coders apt repo (#971 )	2024-06-19 18:40:26 +02:00
MichaIng	223fa8ea17	Update ODROID-XU4 target (#970 ) The ODROID target was meant for the ODROID-XU4, hence it is renamed accordingly, to better indicate that. Furthermore, gcc 4.9 added support for `-mcpu=cortex-a15.cortex-a7` to optimise support for this ARM big.LITTLE chip: https://www.gnu.org/software/gcc/gcc-4.9/changes.html#arm `-mcpu=cortex-a9` was used as compatible option, while the Samsung Exynos 5422 SoC of the ODROID-XU4 actually has 4x Cortex-A15 and 4x Cortex-A7 CPUs: https://wiki.odroid.com/odroid-xu4/odroid-xu4 Signed-off-by: MichaIng <[email protected]>	2024-06-17 22:56:11 +02:00
Krzysztof Aleksander PyrkoszandKrzysztof Aleksander Pyrkosz	d3d971d449	Wrapped a handful of time64 functions (#969 ) Co-authored-by: Krzysztof Aleksander Pyrkosz <[email protected]>	2024-06-15 22:59:26 +02:00
Kaze	2e589f42fe	Update install_steam.sh (#963 ) Fixes : $@ was not escaped so it was not included in the steam launch script. Added libibus-1.0-5 package that is required by newer versions of steam. I didn't had to specify armhf on Pi 5 so I don't know if it's required for other platforms?	2024-05-23 19:50:52 +02:00
ptitSeb	96a34a2a40	Fixed a typo in x87 stack restauration	2024-05-22 23:48:08 +02:00
ptitSeb	69f0c979d4	More x87 fixes ([DYNAREC] too)	2024-05-22 23:34:47 +02:00
ptitSeb	ff702c0318	[DYNAREC] Fixed a regression with the improved emit_pf helper	2024-05-22 21:58:50 +02:00
ptitSeb	968fc3fcfe	[DYNAREC] Fixes to Cosim and to some x87 utility functions	2024-05-22 20:25:59 +02:00
ptitSeb	4abaa3d835	[DYNAREC] Simplified emit_pf helper	2024-05-22 11:08:24 +02:00
ptitSeb	121c67655b	Start of a new dev. cycle	2024-05-22 10:38:48 +02:00