Added preliminary Box32 support (#1760)

* Improve the ReserveHigMemory helper function

* [BOX32] Added some wrapping infrastructure

* [BOX32] More wrapped 32bits lib infrastructure

* [BOX32] Added callback and tls 32bits handling

* [BOX32] Added more 32bits, around wrappers and elfs

* [BOX32] Added the 32bits version of myalign

* [BOX32] More wrapped libs and 32bits fixes and imrpovments

* [BOX32] Added some 32bits tests

* [BOX32] Try to enable some Box32 build and test on the CI

* [BOX32] Disable Box32 testing on CI platform that use qemu

* [BOX32] Another attempt to disable Box32 testing on CI platform that use qemu

* [BOX32] Small fix for another attempt to disable Box32 testing on CI platform that use qemu

* [BOX32] Yet another fix for another attempt to disable Box32 testing on CI platform that use qemu

* [BOX32] Fixed a typo in CI script

* [BOX32] Better scratch alighnment and enabled more tests

* [BOX32] Added (partial) wrapped 32bits librt

* [BOX32] Added mention of Box32 in README

* [BOX32] Added phtread handling, and numerous fixes to 32bits handling. [ARM64_DYNAREC] Fixed access to segment with negative offset

* [BOX32] Added system libs and cpp testing, plus some more fixes

* [BOX32] Fix previous commit

* [BOX32] Better stack adjustment for 32bits processes

* [BOX32] Added getenv wrapped 32bits function and friends

* [BOX32] Don't look for box86 for a Box32 build

* [BOX32] Don't do 32bits cppThreads test for now on CI

* [BOX32] Enabled a few more 32bits tests

* [BOX32] For ld_lib_path for both CppThreads tests

* [BOX32] [ANDROID] Some Fixes for Android Build

* [BOX32] Still need to disable cppThread_32bits test on CI for some reason

* [BOX32] [ANDROID] Don't show PreInit Array Warning (#1751)

* [BOX32] [ANDROID] One More Fix for Android Build That I forgotten to … (#1752)

* [BOX32] [ANDROID] One More Fix for Android Build That I forgotten to push before

* [BOX32] [ANDROID] Try to Create __libc_init

* [BOX32] [ANDROID] Try to disable NEEDED_LIBS for now (libdl is not wrapped)

* [BOX32] Updated generated files

* [BOX32] Added 32bits context functions

* [BOX32] Added 32bits signal handling

* [BOX32] Added some missing 32bits elfloader functions

* [BOX32] Fix build on x86_64 machine

* [BOX32] Better fix for x86_64 build

* [BOX32] Actually added missing libs, and re-enabled cppThreads_32bits test

* [BOX32] Added wrapped 32bits libdl

* [BOX32] Try to re-enabled Box32 test on CI for ARM64 builds

* [BOX32] fine-tuning Box32 test on CI for ARM64 builds

* [BOX32] More fine-tuning to Box32 test on CI for ARM64 builds

* [BOX32] Enabled Box32 test on CI for LA64 and RV64 builds too

* [BOX32] re-Disabled Box32 test on CI for LA64 and RV64 builds, not working for now

* [BOX32] Temporarily disabled cppThreads_32bits test on CI

---------

Co-authored-by: KreitinnSoftware <pablopro5051@gmail.com>
Co-authored-by: KreitinnSoftware <80591934+KreitinnSoftware@users.noreply.github.com>

1 files changed, 114 insertions, 0 deletions

diff --git a/tests32/roundtest.h b/tests32/roundtest.h
new file mode 100644
index 00000000..320e22c9
--- /dev/null
+++ b/tests32/roundtest.h
@@ -0,0 +1,114 @@
+#pragma STDC FENV_ACCESS ON
+#include <assert.h>
+#include <stdio.h>
+
+#ifdef USE_ASM_ROUNDING
+int fesetround_(int rounding_direction) {
+  uint16_t old_cw;
+  __asm__("FNSTCW %0" : "=m"(old_cw)::);
+  uint16_t new_cw = (old_cw & ~0xc00) | rounding_direction;
+  __asm__("FLDCW %0" ::"m"(new_cw));
+  return old_cw & 0xc00;
+}
+int fegetround_() {
+  uint16_t cw;
+  __asm__("FNSTCW %0" : "=m"(cw)::);
+  return cw & 0xc00;
+}
+#define fesetround fesetround_
+#define fegetround fegetround_
+#define FE_TONEAREST 0
+#define FE_DOWNWARD 0x400
+#define FE_UPWARD 0x800
+#define FE_TOWARDZERO 0xc00
+#else
+#include <fenv.h>
+#endif
+
+#define FE_TONEAREST_INDEX 0
+#define FE_DOWNWARD_INDEX 1
+#define FE_UPWARD_INDEX 2
+#define FE_TOWARDZERO_INDEX 3
+int FE_MODES[] = {FE_TONEAREST, FE_DOWNWARD, FE_UPWARD, FE_TOWARDZERO};
+char *FE_MODES_STR[] = {
+    "FE_TONEAREST",
+    "FE_DOWNWARD",
+    "FE_UPWARD",
+    "FE_TOWARDZERO",
+};
+
+void assert_round(double *array) {
+  assert(array[FE_DOWNWARD_INDEX] <= array[FE_TONEAREST_INDEX]);
+  assert(array[FE_TONEAREST_INDEX] <= array[FE_UPWARD_INDEX]);
+  if (array[FE_TOWARDZERO_INDEX] < 0)
+    assert(array[FE_TOWARDZERO_INDEX] == array[FE_UPWARD_INDEX]);
+  else if (array[FE_TOWARDZERO_INDEX] > 0)
+    assert(array[FE_TOWARDZERO_INDEX] == array[FE_DOWNWARD_INDEX]);
+  else if (array[FE_TOWARDZERO_INDEX] == 0)
+    assert(array[FE_TOWARDZERO_INDEX] == array[FE_UPWARD_INDEX] ||
+           array[FE_TOWARDZERO_INDEX] == array[FE_DOWNWARD_INDEX]);
+}
+
+#define TEST_(exec, expr, format)                                              \
+  do {                                                                         \
+    if (sizeof(#exec) == 1)                                                    \
+      printf("Testing: %s\n", #expr);                                          \
+    else                                                                       \
+      printf("Testing: %s -> %s\n", #exec, #expr);                             \
+    for (int i = 0; i < sizeof(FE_MODES) / sizeof(FE_MODES[0]); i++) {         \
+      fesetround(FE_MODES[i]);                                                 \
+      exec;                                                                    \
+      printf("%-15s" format "\n", FE_MODES_STR[i], expr);                      \
+      assert(FE_MODES[i] == fegetround());                                     \
+    }                                                                          \
+    printf("\n");                                                              \
+  } while (0)
+
+#define TEST(exec, expr) TEST_(exec, expr, "%a")
+
+#if defined(i386) || defined(__i386__) || defined(__i386) ||                   \
+    defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+#define TEST_X87(instruction, st0, st1, deep_change)                           \
+  do {                                                                         \
+    double _st0 = (st0), _st1 = (st1);                                         \
+    double array1[4], array2[4];                                               \
+    double __st0, __st1;                                                       \
+    printf("Testing X87 instruction: %s (ST0 = %a, ST1 = %a)\n", #instruction, \
+           _st0, _st1);                                                        \
+    for (int i = 0; i < sizeof(FE_MODES) / sizeof(FE_MODES[0]); i++) {         \
+      fesetround(FE_MODES[i]);                                                 \
+      __st0 = _st0, __st1 = _st1;                                              \
+      switch (deep_change) {                                                   \
+      case -1: /* the instruction pops */                                      \
+        __asm__(instruction : "+t"(__st0) : "u"(__st1) : "st(1)");             \
+        printf("%-15s ST0 = %a\n", FE_MODES_STR[i], __st0);                    \
+        break;                                                                 \
+      case 0:                                                                  \
+        __asm__(instruction : "+t"(__st0) : "u"(__st1) :);                     \
+        printf("%-15s ST0 = %a\n", FE_MODES_STR[i], __st0);                    \
+        break;                                                                 \
+      case 1: /* the instruction pushes */                                     \
+        __asm__(instruction : "+t"(__st0), "=u"(__st1)::);                     \
+        printf("%-15s ST0 = %a, ST1 = %a\n", FE_MODES_STR[i], __st0, __st1);   \
+        array2[i] = __st1;                                                     \
+      }                                                                        \
+      array1[i] = __st0;                                                       \
+      assert(FE_MODES[i] == fegetround());                                     \
+    }                                                                          \
+    if (deep_change == 1)                                                      \
+      assert_round(array2);                                                    \
+    assert_round(array1);                                                      \
+    printf("\n");                                                              \
+  } while (0)
+#else
+#define TEST_X87(instruction, st0, st1, deep_change)                           \
+  do {                                                                         \
+    double _st0 = (st0), _st1 = (st1);                                         \
+    printf("Cannot test X87 instruction: %s (ST0 = %a, ST1 = %a) because it "  \
+           "is not compiled to x86\n\n",                                       \
+           #instruction, _st0, _st1);                                          \
+  } while (0)
+#endif
+
+#define TEST_X87_1(i, st0) TEST_X87(i, st0, 0.0, 0)
+#define TEST_X87_2(i, st0, st1) TEST_X87(i, st0, st1, -1)