[32BITS][DYNAREC] Preparing Dynarec to handle 32bits code

8 files changed, 33 insertions, 29 deletions

diff --git a/src/dynarec/dynablock.c b/src/dynarec/dynablock.c
index c0053a1b..d9b668b3 100755
--- a/src/dynarec/dynablock.c
+++ b/src/dynarec/dynablock.c
@@ -184,7 +184,7 @@ void cancelFillBlock()
     return NULL if block is not found / cannot be created. 
     Don't create if create==0
 */
-static dynablock_t* internalDBGetBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr, int create, int need_lock)
+static dynablock_t* internalDBGetBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr, int create, int need_lock, int is32bits)
 {
     if(hasAlternate((void*)addr))
         return NULL;
@@ -217,7 +217,7 @@ static dynablock_t* internalDBGetBlock(x64emu_t* emu, uintptr_t addr, uintptr_t
             mutex_unlock(&my_context->mutex_dyndump);
         return NULL;
     }
-    void* ret = FillBlock64(block, filladdr);
+    void* ret = FillBlock64(block, filladdr, is32bits);
     if(!ret) {
         dynarec_log(LOG_DEBUG, "Fillblock of block %p for %p returned an error\n", block, (void*)addr);
         customFree(block);
@@ -246,9 +246,9 @@ static dynablock_t* internalDBGetBlock(x64emu_t* emu, uintptr_t addr, uintptr_t
     return block;
 }
 
-dynablock_t* DBGetBlock(x64emu_t* emu, uintptr_t addr, int create)
+dynablock_t* DBGetBlock(x64emu_t* emu, uintptr_t addr, int create, int is32bits)
 {
-    dynablock_t *db = internalDBGetBlock(emu, addr, addr, create, 1);
+    dynablock_t *db = internalDBGetBlock(emu, addr, addr, create, 1, is32bits);
     if(db && db->done && db->block && getNeedTest(addr)) {
         if(db->always_test)
             sched_yield();  // just calm down...
@@ -278,7 +278,7 @@ dynablock_t* DBGetBlock(x64emu_t* emu, uintptr_t addr, int create)
             // Free db, it's now invalid!
             dynablock_t* old = InvalidDynablock(db, need_lock);
             // start again... (will create a new block)
-            db = internalDBGetBlock(emu, addr, addr, create, need_lock);
+            db = internalDBGetBlock(emu, addr, addr, create, need_lock, is32bits);
             if(db) {
                 if(db->previous)
                     FreeInvalidDynablock(db->previous, need_lock);
@@ -301,11 +301,11 @@ dynablock_t* DBGetBlock(x64emu_t* emu, uintptr_t addr, int create)
     return db;
 }
 
-dynablock_t* DBAlternateBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr)
+dynablock_t* DBAlternateBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr, int is32bits)
 {
-    dynarec_log(LOG_DEBUG, "Creating AlternateBlock at %p for %p\n", (void*)addr, (void*)filladdr);
+    dynarec_log(LOG_DEBUG, "Creating AlternateBlock at %p for %p%s\n", (void*)addr, (void*)filladdr, is32bits?" 32bits":"");
     int create = 1;
-    dynablock_t *db = internalDBGetBlock(emu, addr, filladdr, create, 1);
+    dynablock_t *db = internalDBGetBlock(emu, addr, filladdr, create, 1, is32bits);
     if(db && db->done && db->block && getNeedTest(filladdr)) {
         if(db->always_test)
             sched_yield();  // just calm down...
@@ -317,7 +317,7 @@ dynablock_t* DBAlternateBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr)
             // Free db, it's now invalid!
             dynablock_t* old = InvalidDynablock(db, need_lock);
             // start again... (will create a new block)
-            db = internalDBGetBlock(emu, addr, filladdr, create, need_lock);
+            db = internalDBGetBlock(emu, addr, filladdr, create, need_lock, is32bits);
             if(db) {
                 if(db->previous)
                     FreeInvalidDynablock(db->previous, need_lock);
diff --git a/src/dynarec/dynarec.c b/src/dynarec/dynarec.c
index e430fa04..f0b8250d 100755
--- a/src/dynarec/dynarec.c
+++ b/src/dynarec/dynarec.c
@@ -31,6 +31,7 @@ uintptr_t getX64Address(dynablock_t* db, uintptr_t arm_addr);
 
 void* LinkNext(x64emu_t* emu, uintptr_t addr, void* x2, uintptr_t* x3)
 {
+    int is32bits = (R_CS == 0x23);
     #ifdef HAVE_TRACE
     if(!addr) {
         dynablock_t* db = FindDynablockFromNativeAddress(x2-4);
@@ -38,7 +39,7 @@ void* LinkNext(x64emu_t* emu, uintptr_t addr, void* x2, uintptr_t* x3)
     }
     #endif
     void * jblock;
-    dynablock_t* block = DBGetBlock(emu, addr, 1);
+    dynablock_t* block = DBGetBlock(emu, addr, 1, is32bits);
     if(!block) {
         // no block, let link table as is...
         if(hasAlternate((void*)addr)) {
@@ -48,7 +49,7 @@ void* LinkNext(x64emu_t* emu, uintptr_t addr, void* x2, uintptr_t* x3)
             R_RIP = addr;   // but also new RIP!
             *x3 = addr; // and the RIP in x27 register
             printf_log(LOG_DEBUG, " -> %p\n", (void*)addr);
-            block = DBGetBlock(emu, addr, 1);
+            block = DBGetBlock(emu, addr, 1, is32bits);
         }
         if(!block) {
             #ifdef HAVE_TRACE
@@ -122,7 +123,7 @@ void DynaCall(x64emu_t* emu, uintptr_t addr)
         emu->df = d_none;
         while(!emu->quit) {
             int is32bits = (emu->segs[_CS]==0x23);
-            dynablock_t* block = (skip || is32bits)?NULL:DBGetBlock(emu, R_RIP, 1);
+            dynablock_t* block = (skip)?NULL:DBGetBlock(emu, R_RIP, 1, is32bits);
             if(!block || !block->block || !block->done) {
                 skip = 0;
                 // no block, of block doesn't have DynaRec content (yet, temp is not null)
@@ -210,7 +211,7 @@ int DynaRun(x64emu_t* emu)
     else {
         while(!emu->quit) {
             int is32bits = (emu->segs[_CS]==0x23);
-            dynablock_t* block = (skip || is32bits)?NULL:DBGetBlock(emu, R_RIP, 1);
+            dynablock_t* block = (skip)?NULL:DBGetBlock(emu, R_RIP, 1, is32bits);
             if(!block || !block->block || !block->done) {
                 skip = 0;
                 // no block, of block doesn't have DynaRec content (yet, temp is not null)
diff --git a/src/dynarec/dynarec_native.c b/src/dynarec/dynarec_native.c
index 0f56828b..0d3bd780 100755
--- a/src/dynarec/dynarec_native.c
+++ b/src/dynarec/dynarec_native.c
@@ -398,10 +398,10 @@ void CancelBlock64(int need_lock)
         mutex_unlock(&my_context->mutex_dyndump);
 }
 
-uintptr_t native_pass0(dynarec_native_t* dyn, uintptr_t addr);
-uintptr_t native_pass1(dynarec_native_t* dyn, uintptr_t addr);
-uintptr_t native_pass2(dynarec_native_t* dyn, uintptr_t addr);
-uintptr_t native_pass3(dynarec_native_t* dyn, uintptr_t addr);
+uintptr_t native_pass0(dynarec_native_t* dyn, uintptr_t addr, int is32bits);
+uintptr_t native_pass1(dynarec_native_t* dyn, uintptr_t addr, int is32bits);
+uintptr_t native_pass2(dynarec_native_t* dyn, uintptr_t addr, int is32bits);
+uintptr_t native_pass3(dynarec_native_t* dyn, uintptr_t addr, int is32bits);
 
 void* CreateEmptyBlock(dynablock_t* block, uintptr_t addr) {
     block->isize = 0;
@@ -426,7 +426,7 @@ void* CreateEmptyBlock(dynablock_t* block, uintptr_t addr) {
     return block;
 }
 
-void* FillBlock64(dynablock_t* block, uintptr_t addr) {
+void* FillBlock64(dynablock_t* block, uintptr_t addr, int is32bits) {
     /*
         A Block must have this layout:
 
@@ -463,7 +463,7 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
     helper.cap = 128;
     helper.insts = (instruction_native_t*)customCalloc(helper.cap, sizeof(instruction_native_t));
     // pass 0, addresses, x64 jump addresses, overall size of the block
-    uintptr_t end = native_pass0(&helper, addr);
+    uintptr_t end = native_pass0(&helper, addr, is32bits);
     // no need for next anymore
     customFree(helper.next);
     helper.next_sz = helper.next_cap = 0;
@@ -514,10 +514,10 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
         pos = updateNeed(&helper, pos, 0);
 
     // pass 1, float optimisations, first pass for flags
-    native_pass1(&helper, addr);
+    native_pass1(&helper, addr, is32bits);
     
     // pass 2, instruction size
-    native_pass2(&helper, addr);
+    native_pass2(&helper, addr, is32bits);
     // keep size of instructions for signal handling
     size_t insts_rsize = (helper.insts_size+2)*sizeof(instsize_t);
     insts_rsize = (insts_rsize+7)&~7;   // round the size...
@@ -555,7 +555,7 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
     size_t oldnativesize = helper.native_size;
     helper.native_size = 0;
     helper.table64size = 0; // reset table64 (but not the cap)
-    native_pass3(&helper, addr);
+    native_pass3(&helper, addr, is32bits);
     // keep size of instructions for signal handling
     block->instsize = instsize;
     // ok, free the helper now
diff --git a/src/dynarec/dynarec_native_pass.c b/src/dynarec/dynarec_native_pass.c
index 1e8ba3aa..90501bd6 100755
--- a/src/dynarec/dynarec_native_pass.c
+++ b/src/dynarec/dynarec_native_pass.c
@@ -27,7 +27,7 @@
 #error No STEP defined
 #endif
 
-uintptr_t native_pass(dynarec_native_t* dyn, uintptr_t addr)
+uintptr_t native_pass(dynarec_native_t* dyn, uintptr_t addr, int is32bits)
 {
     int ok = 1;
     int ninst = 0;
@@ -49,6 +49,9 @@ uintptr_t native_pass(dynarec_native_t* dyn, uintptr_t addr)
     int reset_n = -1;
     dyn->last_ip = (dyn->insts && dyn->insts[0].pred_sz)?0:ip;  // RIP is always set at start of block unless there is a predecessor!
     int stopblock = 2+(FindElfAddress(my_context, addr)?0:1); // if block is in elf_memory, it can be extended with bligblocks==2, else it needs 3
+    // disbling 32bits blocks for now
+    if(is32bits)
+        return addr;
     // ok, go now
     INIT;
     while(ok) {
diff --git a/src/include/dynablock.h b/src/include/dynablock.h
index 4e9d0b36..ed7b3c8a 100755
--- a/src/include/dynablock.h
+++ b/src/include/dynablock.h
@@ -15,8 +15,8 @@ dynablock_t* InvalidDynablock(dynablock_t* db, int need_lock);
 dynablock_t* FindDynablockFromNativeAddress(void* addr);    // defined in box64context.h
 
 // Handling of Dynarec block (i.e. an exectable chunk of x64 translated code)
-dynablock_t* DBGetBlock(x64emu_t* emu, uintptr_t addr, int create);   // return NULL if block is not found / cannot be created. Don't create if create==0
-dynablock_t* DBAlternateBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr);
+dynablock_t* DBGetBlock(x64emu_t* emu, uintptr_t addr, int create, int is32bits);   // return NULL if block is not found / cannot be created. Don't create if create==0
+dynablock_t* DBAlternateBlock(x64emu_t* emu, uintptr_t addr, uintptr_t filladdr, int is32bits);
 
 // for use in signal handler
 void cancelFillBlock();
diff --git a/src/include/dynarec_native.h b/src/include/dynarec_native.h
index eff5a6bf..891485a9 100755
--- a/src/include/dynarec_native.h
+++ b/src/include/dynarec_native.h
@@ -8,6 +8,6 @@ typedef struct instsize_s instsize_t;
 void addInst(instsize_t* insts, size_t* size, int x64_size, int native_size);
 
 void CancelBlock64(int need_lock);
-void* FillBlock64(dynablock_t* block, uintptr_t addr);
+void* FillBlock64(dynablock_t* block, uintptr_t addr, int is32bits);
 
 #endif //__DYNAREC_ARM_H_
\ No newline at end of file
diff --git a/src/libtools/threads.c b/src/libtools/threads.c
index 707d3833..83627da5 100755
--- a/src/libtools/threads.c
+++ b/src/libtools/threads.c
@@ -498,7 +498,7 @@ EXPORT int my_pthread_create(x64emu_t *emu, void* t, void* attr, void* start_rou
 	#ifdef DYNAREC
 	if(box64_dynarec) {
 		// pre-creation of the JIT code for the entry point of the thread
-		DBGetBlock(emu, (uintptr_t)start_routine, 1);
+		DBGetBlock(emu, (uintptr_t)start_routine, 1, 0);	// function wrapping are 64bits only on box64
 	}
 	#endif
 	// create thread
@@ -519,7 +519,7 @@ void* my_prepare_thread(x64emu_t *emu, void* f, void* arg, int ssize, void** pet
 	et->arg = arg;
 	#ifdef DYNAREC
 	// pre-creation of the JIT code for the entry point of the thread
-	DBGetBlock(emu, (uintptr_t)f, 1);
+	DBGetBlock(emu, (uintptr_t)f, 1, 0);	// function wrapping are 64bits only on box64
 	#endif
 	*pet =  et;
 	return pthread_routine;
diff --git a/src/tools/bridge.c b/src/tools/bridge.c
index 73bb8197..bace21ae 100755
--- a/src/tools/bridge.c
+++ b/src/tools/bridge.c
@@ -167,7 +167,7 @@ uintptr_t AddAutomaticBridge(x64emu_t* emu, bridge_t* bridge, wrapper_t w, void*
         #ifdef DYNAREC
         // now, check if dynablock at native address exist
         if(box64_dynarec)
-            DBAlternateBlock(emu, (uintptr_t)fnc, ret);
+            DBAlternateBlock(emu, (uintptr_t)fnc, ret, 0);  // function wrapping is exclusive to 64bits on box64
         #endif
     }
     return ret;