Use my_conect directly on Interpreter

3 files changed, 70 insertions, 70 deletions

diff --git a/src/emu/x64run.c b/src/emu/x64run.c
index db68e807..c278bfb2 100644
--- a/src/emu/x64run.c
+++ b/src/emu/x64run.c
@@ -659,12 +659,12 @@ x64emurun:
             GETEB(0);
             GETGB;
             if(!MODREG)
-                pthread_mutex_lock(&emu->context->mutex_lock); // XCHG always LOCK (but when accessing memory only)
+                pthread_mutex_lock(&my_context->mutex_lock); // XCHG always LOCK (but when accessing memory only)
             tmp8u = GB;
             GB = EB->byte[0];
             EB->byte[0] = tmp8u;
             if(!MODREG)
-                pthread_mutex_unlock(&emu->context->mutex_lock);
+                pthread_mutex_unlock(&my_context->mutex_lock);
 #endif                
             break;
         case 0x87:                      /* XCHG Ed,Gd */
@@ -693,7 +693,7 @@ x64emurun:
             GETED(0);
             GETGD;
             if(!MODREG)
-                pthread_mutex_lock(&emu->context->mutex_lock); // XCHG always LOCK (but when accessing memory only)
+                pthread_mutex_lock(&my_context->mutex_lock); // XCHG always LOCK (but when accessing memory only)
             if(rex.w) {
                 tmp64u = GD->q[0];
                 GD->q[0] = ED->q[0];
@@ -707,7 +707,7 @@ x64emurun:
                     ED->dword[0] = tmp32u;
             }
             if(!MODREG)
-                pthread_mutex_unlock(&emu->context->mutex_lock);
+                pthread_mutex_unlock(&my_context->mutex_lock);
 #endif
             break;
         case 0x88:                      /* MOV Eb,Gb */
diff --git a/src/emu/x64run66f0.c b/src/emu/x64run66f0.c
index df302af5..77c02492 100644
--- a/src/emu/x64run66f0.c
+++ b/src/emu/x64run66f0.c
@@ -79,14 +79,14 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         }
                     } while(tmp32s);
 #else
-                    pthread_mutex_lock(&emu->context->mutex_lock);
+                    pthread_mutex_lock(&my_context->mutex_lock);
                     cmp16(emu, R_AX, EW->word[0]);
                     if(ACCESS_FLAG(F_ZF)) {
                         EW->word[0] = GW->word[0];
                     } else {
                         R_AX = EW->word[0];
                     }
-                    pthread_mutex_unlock(&emu->context->mutex_lock);
+                    pthread_mutex_unlock(&my_context->mutex_lock);
 #endif
                     break;
 
@@ -110,11 +110,11 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                     }
                     GD->word[0] = tmp16u;
 #else
-                    pthread_mutex_lock(&emu->context->mutex_lock);
+                    pthread_mutex_lock(&my_context->mutex_lock);
                     tmp16u = add16(emu, ED->word[0], GD->word[0]);
                     GD->word[0] = ED->word[0];
                     ED->word[0] = tmp16u;
-                    pthread_mutex_unlock(&emu->context->mutex_lock);
+                    pthread_mutex_unlock(&my_context->mutex_lock);
 #endif
                     break;
 
@@ -148,22 +148,22 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
             nextop = F8;                                            \
             GETEW(0);                                               \
             GETGW;                                                  \
-            pthread_mutex_lock(&emu->context->mutex_lock);          \
+            pthread_mutex_lock(&my_context->mutex_lock);          \
             EW->word[0] = OP##16(emu, EW->word[0], GW->word[0]);    \
-            pthread_mutex_unlock(&emu->context->mutex_lock);        \
+            pthread_mutex_unlock(&my_context->mutex_lock);        \
             break;                                                  \
         case B+3:                                                   \
             nextop = F8;                                            \
             GETEW(0);                                               \
             GETGW;                                                  \
-            pthread_mutex_lock(&emu->context->mutex_lock);          \
+            pthread_mutex_lock(&my_context->mutex_lock);          \
             GW->word[0] = OP##16(emu, GW->word[0], EW->word[0]);    \
-            pthread_mutex_unlock(&emu->context->mutex_lock);        \
+            pthread_mutex_unlock(&my_context->mutex_lock);        \
             break;                                                  \
         case B+5:                                                   \
-            pthread_mutex_lock(&emu->context->mutex_lock);          \
+            pthread_mutex_lock(&my_context->mutex_lock);          \
             R_AX = OP##16(emu, R_AX, F16);                          \
-            pthread_mutex_unlock(&emu->context->mutex_lock);        \
+            pthread_mutex_unlock(&my_context->mutex_lock);        \
             break;
 #endif
         GO(0x00, add)                   /* ADD 0x00 -> 0x05 */
@@ -205,7 +205,7 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                     case 7:                                                  cmp16(emu, ED->word[0], tmp16u); break;
                 }
 #else
-            pthread_mutex_lock(&emu->context->mutex_lock);
+            pthread_mutex_lock(&my_context->mutex_lock);
             switch((nextop>>3)&7) {
                 case 0: ED->word[0] = add16(emu, ED->word[0], tmp16u); break;
                 case 1: ED->word[0] =  or16(emu, ED->word[0], tmp16u); break;
@@ -216,7 +216,7 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 case 6: ED->word[0] = xor16(emu, ED->word[0], tmp16u); break;
                 case 7:               cmp16(emu, ED->word[0], tmp16u); break;
             }
-            pthread_mutex_unlock(&emu->context->mutex_lock);
+            pthread_mutex_unlock(&my_context->mutex_lock);
 #endif
             break;
 
@@ -241,9 +241,9 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         } while(native_lock_write_h(ED, inc16(emu, tmp16u)));
                     }
 #else
-                    pthread_mutex_lock(&emu->context->mutex_lock);
+                    pthread_mutex_lock(&my_context->mutex_lock);
                     ED->word[0] = inc16(emu, ED->word[0]);
-                    pthread_mutex_unlock(&emu->context->mutex_lock);
+                    pthread_mutex_unlock(&my_context->mutex_lock);
 #endif
                     break;
                 case 1:                 /* DEC Ed */
@@ -252,9 +252,9 @@ uintptr_t Run66F0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         tmp16u = native_lock_read_h(ED);
                     } while(native_lock_write_h(ED, dec16(emu, tmp16u)));
 #else
-                    pthread_mutex_lock(&emu->context->mutex_lock);
+                    pthread_mutex_lock(&my_context->mutex_lock);
                     ED->word[0] = dec16(emu, ED->word[0]);
-                    pthread_mutex_unlock(&emu->context->mutex_lock);
+                    pthread_mutex_unlock(&my_context->mutex_lock);
 #endif
                     break;
                 default:
diff --git a/src/emu/x64runf0.c b/src/emu/x64runf0.c
index 5a75203e..e1dbacea 100644
--- a/src/emu/x64runf0.c
+++ b/src/emu/x64runf0.c
@@ -116,15 +116,15 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
             nextop = F8;                                            \

             GETEB(0);                                               \

             GETGB;                                                  \

-            pthread_mutex_lock(&emu->context->mutex_lock);          \

+            pthread_mutex_lock(&my_context->mutex_lock);          \

             EB->byte[0] = OP##8(emu, EB->byte[0], GB);              \

-            pthread_mutex_unlock(&emu->context->mutex_lock);        \

+            pthread_mutex_unlock(&my_context->mutex_lock);        \

             break;                                                  \

         case B+1:                                                   \

             nextop = F8;                                            \

             GETED(0);                                               \

             GETGD;                                                  \

-            pthread_mutex_lock(&emu->context->mutex_lock);          \

+            pthread_mutex_lock(&my_context->mutex_lock);          \

             if(rex.w)                                               \

                 ED->q[0] = OP##64(emu, ED->q[0], GD->q[0]);         \

             else                                                    \

@@ -132,39 +132,39 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                     ED->q[0] = OP##32(emu, ED->dword[0], GD->dword[0]);     \

                 else                                                        \

                     ED->dword[0] = OP##32(emu, ED->dword[0], GD->dword[0]); \

-            pthread_mutex_unlock(&emu->context->mutex_lock);        \

+            pthread_mutex_unlock(&my_context->mutex_lock);        \

             break;                                                  \

         case B+2:                                                   \

             nextop = F8;                                            \

             GETEB(0);                                               \

             GETGB;                                                  \

-            pthread_mutex_lock(&emu->context->mutex_lock);          \

+            pthread_mutex_lock(&my_context->mutex_lock);          \

             GB = OP##8(emu, GB, EB->byte[0]);                       \

-            pthread_mutex_unlock(&emu->context->mutex_lock);        \

+            pthread_mutex_unlock(&my_context->mutex_lock);        \

             break;                                                  \

         case B+3:                                                   \

             nextop = F8;                                            \

             GETED(0);                                               \

             GETGD;                                                  \

-            pthread_mutex_lock(&emu->context->mutex_lock);          \

+            pthread_mutex_lock(&my_context->mutex_lock);          \

             if(rex.w)                                               \

                 GD->q[0] = OP##64(emu, GD->q[0], ED->q[0]);         \

             else                                                    \

                 GD->q[0] = OP##32(emu, GD->dword[0], ED->dword[0]); \

-            pthread_mutex_unlock(&emu->context->mutex_lock);        \

+            pthread_mutex_unlock(&my_context->mutex_lock);        \

             break;                                                  \

         case B+4:                                                   \

-            pthread_mutex_lock(&emu->context->mutex_lock);          \

+            pthread_mutex_lock(&my_context->mutex_lock);          \

             R_AL = OP##8(emu, R_AL, F8);                            \

-            pthread_mutex_unlock(&emu->context->mutex_lock);        \

+            pthread_mutex_unlock(&my_context->mutex_lock);        \

             break;                                                  \

         case B+5:                                                   \

-            pthread_mutex_lock(&emu->context->mutex_lock);          \

+            pthread_mutex_lock(&my_context->mutex_lock);          \

             if(rex.w)                                               \

                 R_RAX = OP##64(emu, R_RAX, F32S64);                 \

             else                                                    \

                 R_RAX = OP##32(emu, R_EAX, F32);                    \

-            pthread_mutex_unlock(&emu->context->mutex_lock);        \

+            pthread_mutex_unlock(&my_context->mutex_lock);        \

             break;

 #endif

         GO(0x00, add)                   /* ADD 0x00 -> 0x05 */

@@ -245,7 +245,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         } while(tmp32s);

                 }

 #else

-                pthread_mutex_lock(&emu->context->mutex_lock);

+                pthread_mutex_lock(&my_context->mutex_lock);

                 if(rex.w) {

                     tmp8u&=63;

                     if(ED->q[0] & (1LL<<tmp8u))

@@ -265,7 +265,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                     if(MODREG)

                         ED->dword[1] = 0;

                 }

-                pthread_mutex_unlock(&emu->context->mutex_lock);

+                pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                 break;

 

@@ -286,14 +286,14 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         }

                     } while(tmp32s);

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     cmp8(emu, R_AL, EB->byte[0]);

                     if(ACCESS_FLAG(F_ZF)) {

                         EB->byte[0] = GB;

                     } else {

                         R_AL = EB->byte[0];

                     }

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 case 0xB1:                      /* CMPXCHG Ed,Gd */

@@ -343,7 +343,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                             ED->dword[1] = 0;

                     }

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     if(rex.w) {

                         cmp64(emu, R_RAX, ED->q[0]);

                         if(ACCESS_FLAG(F_ZF)) {

@@ -362,7 +362,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         if(MODREG)

                             ED->dword[1] = 0;

                     }

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

 

@@ -416,7 +416,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                             ED->dword[1] = 0;

                     }

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     if(rex.w) {

                         if(ED->q[0] & (1<<tmp8u)) {

                             SET_FLAG(F_CF);

@@ -432,7 +432,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         if(MODREG)

                             ED->dword[1] = 0;

                     }

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

 

@@ -490,7 +490,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                     } while(tmp32s);

                                 }

 #else

-                                pthread_mutex_lock(&emu->context->mutex_lock);

+                                pthread_mutex_lock(&my_context->mutex_lock);

                                 if(rex.w) {

                                     tmp8u&=63;

                                     if(ED->q[0] & (1LL<<tmp8u)) {

@@ -508,7 +508,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                         CLEAR_FLAG(F_CF);

                                     }

                                 }

-                                pthread_mutex_unlock(&emu->context->mutex_lock);

+                                pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                                 break;

                             case 6:             /* BTR Ed, Ib */

@@ -544,7 +544,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                     } while(tmp32s);

                                 }

 #else

-                                pthread_mutex_lock(&emu->context->mutex_lock);

+                                pthread_mutex_lock(&my_context->mutex_lock);

                                 if(rex.w) {

                                     tmp8u&=63;

                                     if(ED->q[0] & (1LL<<tmp8u)) {

@@ -560,7 +560,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                     } else

                                         CLEAR_FLAG(F_CF);

                                 }

-                                pthread_mutex_unlock(&emu->context->mutex_lock);

+                                pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                                 break;

                             case 7:             /* BTC Ed, Ib */

@@ -592,7 +592,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                     } while(tmp32s);

                                 }

 #else

-                                pthread_mutex_lock(&emu->context->mutex_lock);

+                                pthread_mutex_lock(&my_context->mutex_lock);

                                 if(rex.w) {

                                     tmp8u&=63;

                                     if(ED->q[0] & (1LL<<tmp8u))

@@ -608,7 +608,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                         CLEAR_FLAG(F_CF);

                                     ED->dword[0] ^= (1<<tmp8u);

                                 }

-                                pthread_mutex_unlock(&emu->context->mutex_lock);

+                                pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                                 break;

 

@@ -628,11 +628,11 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                     } while(native_lock_write_b(EB, tmp8u2));

                     GB = tmp8u;

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     tmp8u = add8(emu, EB->byte[0], GB);

                     GB = EB->byte[0];

                     EB->byte[0] = tmp8u;

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 case 0xC1:                      /* XADD Gd,Ed */

@@ -665,7 +665,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                             ED->dword[1] = 0;

                     }

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     if(rex.w) {

                         tmp64u = add64(emu, ED->q[0], GD->q[0]);

                         GD->q[0] = ED->q[0];

@@ -678,7 +678,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         else

                             ED->dword[0] = tmp32u;

                     }

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

 

@@ -717,7 +717,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                     }

                                 } while(tmp32s);

 #else

-                            pthread_mutex_lock(&emu->context->mutex_lock);

+                            pthread_mutex_lock(&my_context->mutex_lock);

                             if(rex.w) {

                                 #ifdef TEST_INTERPRETER

                                 test->memsize = 16;

@@ -749,7 +749,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                                     R_RDX = tmp32u2;

                                 }

                             }

-                            pthread_mutex_unlock(&emu->context->mutex_lock);

+                            pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                             break;

                         default:

@@ -785,7 +785,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 case 7:               cmp8(emu, EB->byte[0], tmp8u); break;

             }

 #else

-            pthread_mutex_lock(&emu->context->mutex_lock);

+            pthread_mutex_lock(&my_context->mutex_lock);

             switch((nextop>>3)&7) {

                 case 0: EB->byte[0] = add8(emu, EB->byte[0], tmp8u); break;

                 case 1: EB->byte[0] =  or8(emu, EB->byte[0], tmp8u); break;

@@ -796,7 +796,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 case 6: EB->byte[0] = xor8(emu, EB->byte[0], tmp8u); break;

                 case 7:               cmp8(emu, EB->byte[0], tmp8u); break;

             }

-            pthread_mutex_unlock(&emu->context->mutex_lock);

+            pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

             break;

         case 0x81:              /* GRP Ed,Id */

@@ -845,7 +845,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                     }

             }

 #else

-            pthread_mutex_lock(&emu->context->mutex_lock);

+            pthread_mutex_lock(&my_context->mutex_lock);

             if(rex.w) {

                 switch((nextop>>3)&7) {

                     case 0: ED->q[0] = add64(emu, ED->q[0], tmp64u); break;

@@ -881,7 +881,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         case 7:                cmp32(emu, ED->dword[0], tmp64u); break;

                     }

             }

-            pthread_mutex_unlock(&emu->context->mutex_lock);

+            pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

             break;

 

@@ -904,12 +904,12 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
             GETEB(0);

             GETGB;

             if(!MODREG)

-                pthread_mutex_lock(&emu->context->mutex_lock); // XCHG always LOCK (but when accessing memory only)

+                pthread_mutex_lock(&my_context->mutex_lock); // XCHG always LOCK (but when accessing memory only)

             tmp8u = GB;

             GB = EB->byte[0];

             EB->byte[0] = tmp8u;

             if(!MODREG)

-                pthread_mutex_unlock(&emu->context->mutex_lock);

+                pthread_mutex_unlock(&my_context->mutex_lock);

 #endif                

             break;

         case 0x87:                      /* XCHG Ed,Gd */

@@ -937,7 +937,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
 #else

             GETED(0);

             GETGD;

-            pthread_mutex_lock(&emu->context->mutex_lock);

+            pthread_mutex_lock(&my_context->mutex_lock);

             if(rex.w) {

                 tmp64u = GD->q[0];

                 GD->q[0] = ED->q[0];

@@ -950,7 +950,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 else

                     ED->dword[0] = tmp32u;

             }

-            pthread_mutex_unlock(&emu->context->mutex_lock);

+            pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

             break;            

 

@@ -966,9 +966,9 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         tmp8u2 = not8(emu, tmp8u2);

                     } while(native_lock_write_b(EB, tmp8u2));

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     EB->byte[0] = not8(emu, EB->byte[0]);

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 default:

@@ -986,9 +986,9 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         tmp8u = native_lock_read_b(ED);

                     } while(native_lock_write_b(ED, inc8(emu, tmp8u)));

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     ED->byte[0] = inc8(emu, ED->byte[0]);

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 case 1:                 /* DEC Ed */

@@ -997,9 +997,9 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         tmp8u = native_lock_read_b(ED);

                     } while(native_lock_write_b(ED, dec8(emu, tmp8u)));

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     ED->byte[0] = dec8(emu, ED->byte[0]);

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 default:

@@ -1047,7 +1047,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         if(MODREG) ED->dword[1] = 0;

                     }

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     if(rex.w) {

                         ED->q[0] = inc64(emu, ED->q[0]);

                     } else {

@@ -1056,7 +1056,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         else

                             ED->dword[0] = inc32(emu, ED->dword[0]);

                     }

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 case 1:                 /* DEC Ed */

@@ -1082,7 +1082,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         if(MODREG) ED->dword[1] = 0;

                     }

 #else

-                    pthread_mutex_lock(&emu->context->mutex_lock);

+                    pthread_mutex_lock(&my_context->mutex_lock);

                     if(rex.w) {

                         ED->q[0] = dec64(emu, ED->q[0]);

                     } else {

@@ -1091,7 +1091,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
                         else

                             ED->dword[0] = dec32(emu, ED->dword[0]);

                     }

-                    pthread_mutex_unlock(&emu->context->mutex_lock);

+                    pthread_mutex_unlock(&my_context->mutex_lock);

 #endif

                     break;

                 default: