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, 51 insertions, 4 deletions

diff --git a/src/custommem.c b/src/custommem.c
index 06b48328..5862ed13 100644
--- a/src/custommem.c
+++ b/src/custommem.c
@@ -1521,21 +1521,68 @@ static void atfork_child_custommem(void)
     // (re)init mutex if it was lock before the fork
     init_mutexes();
 }
-
+#ifdef BOX32
+void reverveHigMem32(void)
+{
+    loadProtectionFromMap();
+    uintptr_t cur_size = 1024LL*1024*1024*1024; // start with 1TB check
+    void* cur;
+    while(cur_size>=65536) {
+        cur = internal_mmap(NULL, cur_size, 0, MAP_ANONYMOUS|MAP_PRIVATE|MAP_NORESERVE, -1, 0);
+        if((cur==MAP_FAILED) || (cur<(void*)0x100000000LL)) {
+            if(cur!=MAP_FAILED) {
+                //printf_log(LOG_DEBUG, " Failed to reserve high %p (%zx)\n", cur, cur_size);
+                internal_munmap(cur, cur_size);
+            } //else 
+              //  printf_log(LOG_DEBUG, " Failed to reserve %zx sized block\n", cur_size);
+            cur_size>>=1;
+        } else {
+            rb_set(mapallmem, (uintptr_t)cur, (uintptr_t)cur+cur_size, 1);
+            //printf_log(LOG_DEBUG, "Reserved high %p (%zx)\n", cur, cur_size);
+        }
+    }
+    printf_log(LOG_INFO, "Memory higher than 32bits reserved\n");
+    if(box64_log>=LOG_DEBUG) {
+        uintptr_t start=0x100000000LL;
+        int prot;
+        uintptr_t bend;
+        while (bend!=0xffffffffffffffffLL) {
+            if(rb_get_end(mapallmem, start, &prot, &bend)) {
+                    printf_log(LOG_DEBUG, " Reserved: %p - %p (%d)\n", (void*)start, (void*)bend, prot);
+            }
+            start = bend;
+        }
+    }
+}
+#endif
 void my_reserveHighMem()
 {
     static int reserved = 0;
     if(reserved || (!have48bits && !box64_is32bits))
         return;
     reserved = 1;
+    #ifdef BOX32
+    if(box64_is32bits) {
+        reverveHigMem32();
+        return;
+    }
+    #endif
     uintptr_t cur = box64_is32bits?(1ULL<<32):(1ULL<<47);
     uintptr_t bend = 0;
     uint32_t prot;
     while (bend!=0xffffffffffffffffLL) {
         if(!rb_get_end(mapallmem, cur, &prot, &bend)) {
-            void* ret = internal_mmap((void*)cur, bend-cur, 0, MAP_ANONYMOUS|MAP_FIXED|MAP_PRIVATE|MAP_NORESERVE, -1, 0);
-            printf_log(LOG_DEBUG, "Reserve %p-%p => %p (%s)\n", (void*)cur, bend, ret, strerror(errno));
-            printf_log(LOG_DEBUG, "mmap %p-%p\n", cur, bend);
+            // create a border at 39bits...
+            if(cur<(1ULL<<39) && bend>(1ULL<<39))
+                bend = 1ULL<<39;
+            // create a border at 47bits
+            if(cur<(1ULL<<47) && bend>(1ULL<<47))
+                bend = 1ULL<<47;
+            // create a border at 48bits
+            if(cur<(1ULL<<48) && bend>(1ULL<<48))
+                bend = 1ULL<<48;
+            void* ret = internal_mmap((void*)cur, bend-cur, 0, MAP_ANONYMOUS|MAP_PRIVATE|MAP_NORESERVE, -1, 0);
+            printf_log(LOG_DEBUG, "Reserve %p-%p => %p (%s)\n", (void*)cur, bend, ret, (ret==MAP_FAILED)?strerror(errno):"ok");
             if(ret!=(void*)-1) {
                 rb_set(mapallmem, cur, bend, 1);
             }