Merge latest TomB version as of 12 Mai 06

Makefile

@@ -226,8 +226,8 @@ OBJS += src/cpuemu_0.o
 OBJS += src/cpuemu_4.o
 OBJS += src/cpuemu_11.o
 OBJS += src/jit/compemu.o
-OBJS += src/jit/compemu_fpp.o
 OBJS += src/jit/compstbl.o
+OBJS += src/jit/compemu_fpp.o
 OBJS += src/jit/compemu_support.o
 
 src/osdep/neon_helper.o: src/osdep/neon_helper.s

src/cfgfile.cpp

@@ -1965,7 +1965,6 @@ int bip_a4000 (struct uae_prefs *p, int rom)
 	roms[2] = 11;
 	roms[3] = -1;
 
-	p->immediate_blits = 1;
 	p->bogomem_size = 0;
 	p->chipmem_size = 0x200000;
 	p->cpu_model = 68030;

src/cpuemu_0.cpp

@@ -1667,7 +1667,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02d0_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 8 * CYCLE_UNIT / 2;
 	}
-}}}}	m68k_incpc (4);
+}
+}}}	m68k_incpc (4);
 return 22 * CYCLE_UNIT / 2;
 }
 
@@ -1686,7 +1687,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02e8_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 12 * CYCLE_UNIT / 2;
 	}
-}}}}	m68k_incpc (6);
+}
+}}}	m68k_incpc (6);
 return 33 * CYCLE_UNIT / 2;
 }
 
@@ -1706,7 +1708,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02f0_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 8 * CYCLE_UNIT / 2;
 	}
-}}}}}return 29 * CYCLE_UNIT / 2;
+}
+}}}}return 29 * CYCLE_UNIT / 2;
 }
 
 /* CHK2.W #<data>.W,(xxx).W */
@@ -1723,7 +1726,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02f8_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 12 * CYCLE_UNIT / 2;
 	}
-}}}}	m68k_incpc (6);
+}
+}}}	m68k_incpc (6);
 return 25 * CYCLE_UNIT / 2;
 }
 
@@ -1741,7 +1745,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02f9_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 16 * CYCLE_UNIT / 2;
 	}
-}}}}	m68k_incpc (8);
+}
+}}}	m68k_incpc (8);
 return 28 * CYCLE_UNIT / 2;
 }
 
@@ -1761,7 +1766,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02fa_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 12 * CYCLE_UNIT / 2;
 	}
-}}}}	m68k_incpc (6);
+}
+}}}	m68k_incpc (6);
 return 33 * CYCLE_UNIT / 2;
 }
 
@@ -1783,7 +1789,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_02fb_0)(uae_u32 opcode, struct regstruct &regs)
 	if ((extra & 0x800) && GET_CFLG ()) { Exception (6, regs);
 		return 8 * CYCLE_UNIT / 2;
   }
-}}}}}return 29 * CYCLE_UNIT / 2;
+}
+}}}}return 29 * CYCLE_UNIT / 2;
 }
 
 /* SUB.B #<data>.B,Dn */
@@ -15159,15 +15166,15 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c3c_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,Dn */
 uae_u32 REGPARAM2 CPUFUNC(op_4c40_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = opcode & 7;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uae_s32 dst = m68k_dreg (regs, dstreg);
 	m68k_incpc (4);
   if (dst == 0) {
   	Exception (5, regs);
-	  return 4 * CYCLE_UNIT / 2;;
+	  return 4 * CYCLE_UNIT / 2;
   }
 	m68k_divl(opcode, dst, extra);
 }}}return 82 * CYCLE_UNIT / 2 + cyc;
@@ -15176,8 +15183,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c40_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,(An) */
 uae_u32 REGPARAM2 CPUFUNC(op_4c50_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = opcode & 7;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr dsta;
@@ -15195,8 +15202,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c50_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,(An)+ */
 uae_u32 REGPARAM2 CPUFUNC(op_4c58_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = opcode & 7;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr dsta;
@@ -15215,8 +15222,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c58_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,-(An) */
 uae_u32 REGPARAM2 CPUFUNC(op_4c60_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = opcode & 7;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr dsta;
@@ -15235,8 +15242,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c60_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,(d16,An) */
 uae_u32 REGPARAM2 CPUFUNC(op_4c68_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = opcode & 7;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr dsta;
@@ -15254,8 +15261,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c68_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,(d8,An,Xn) */
 uae_u32 REGPARAM2 CPUFUNC(op_4c70_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = opcode & 7;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr dsta;
@@ -15309,8 +15316,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c79_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,(d16,PC) */
 uae_u32 REGPARAM2 CPUFUNC(op_4c7a_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = 2;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr dsta;
@@ -15329,8 +15336,8 @@ uae_u32 REGPARAM2 CPUFUNC(op_4c7a_0)(uae_u32 opcode, struct regstruct &regs)
 /* DIVL.L #<data>.W,(d8,PC,Xn) */
 uae_u32 REGPARAM2 CPUFUNC(op_4c7b_0)(uae_u32 opcode, struct regstruct &regs)
 {
-	uae_u32 cyc = 0;
 	uae_u32 dstreg = 3;
+	uae_u32 cyc = 0;
 {{	uae_s16 extra = get_iword (2);
   if (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;
 {	uaecptr tmppc;

src/custom.cpp

@@ -47,8 +47,10 @@ static int frh_count = 0;
 #define LAST_SPEEDUP_LINE 30
 #define SPEEDUP_CYCLES_JIT 3000
 #define SPEEDUP_CYCLES_NONJIT 600
+#define SPEEDUP_CYCLES_HAM 1000
 #define SPEEDUP_TIMELIMIT_JIT -1000
 #define SPEEDUP_TIMELIMIT_NONJIT -2000
+#define SPEEDUP_TIMELIMIT_HAM -6500
 int pissoff_value = SPEEDUP_CYCLES_JIT * CYCLE_UNIT;
 int speedup_timelimit = SPEEDUP_TIMELIMIT_JIT;
 
@@ -4110,16 +4112,26 @@ static void vsync_handler_post (void)
   if (currprefs.cachesize) {
     vsyncmintime = last_synctime;
     frh_count = 0;
-    pissoff_value = SPEEDUP_CYCLES_JIT * CYCLE_UNIT;
+    if(ham_drawn) {
-    speedup_timelimit = SPEEDUP_TIMELIMIT_JIT;
+      pissoff_value = SPEEDUP_CYCLES_HAM * CYCLE_UNIT;
+      speedup_timelimit = SPEEDUP_TIMELIMIT_HAM;
+    } else {
+      pissoff_value = SPEEDUP_CYCLES_JIT * CYCLE_UNIT;
+      speedup_timelimit = SPEEDUP_TIMELIMIT_JIT;
+    }
   }
   else
 #endif
   {
-    vsyncmintime = last_synctime + vsynctimebase * (maxvpos - LAST_SPEEDUP_LINE) / maxvpos;
+    vsyncmintime = last_synctime + vsynctimebase * (maxvpos_nom - LAST_SPEEDUP_LINE) / maxvpos_nom;
     pissoff_value = SPEEDUP_CYCLES_NONJIT * CYCLE_UNIT;
-    speedup_timelimit = SPEEDUP_TIMELIMIT_NONJIT;
+    if(ham_drawn) {
+      speedup_timelimit = SPEEDUP_TIMELIMIT_HAM;
+    } else {
+      speedup_timelimit = SPEEDUP_TIMELIMIT_NONJIT;
+    }
   }
+  ham_drawn = false;
   
 	if ((beamcon0 & (0x20 | 0x80)) != (new_beamcon0 & (0x20 | 0x80)) || abs (vpos_count - vpos_count_diff) > 1 || lof_changed) {
 		init_hz ();
@@ -4327,13 +4339,13 @@ static void hsync_handler_post (bool onvsync)
 #ifdef JIT
     if (currprefs.cachesize) {
 	    frh_count++;
-	    if (trigger_frh(frh_count) && vpos < maxvpos - LAST_SPEEDUP_LINE) {
+	    if (trigger_frh(frh_count) && vpos < maxvpos_nom - LAST_SPEEDUP_LINE) {
 		    frh_handler();
 	    }
-	    is_syncline = trigger_frh(frh_count+1) && vpos < maxvpos - LAST_SPEEDUP_LINE + 1 && ! rpt_did_reset;
+	    is_syncline = trigger_frh(frh_count+1) && vpos < maxvpos_nom - LAST_SPEEDUP_LINE + 1 && ! rpt_did_reset;
     } else {
 #endif
-	    is_syncline = vpos + 1 == maxvpos + lof_store - LAST_SPEEDUP_LINE;
+	    is_syncline = vpos + 1 == maxvpos_nom + lof_store - LAST_SPEEDUP_LINE;
 #ifdef JIT
     }
 #endif

src/drawing.cpp

@@ -57,6 +57,7 @@ static void lores_reset (void)
 }
 
 bool aga_mode; /* mirror of chipset_mask & CSMASK_AGA */
+bool ham_drawn = false;
 
 #ifdef PANDORA
 #define OFFSET_Y_ADJUST 15
@@ -529,6 +530,7 @@ static void init_ham_decoding (void)
 static void decode_ham (int pix, int stoppos)
 {
 	int todraw_amiga = res_shift_from_window (stoppos - pix);
+	ham_drawn = true;
 	
 	if (!bplham) {
 		while (todraw_amiga-- > 0) {
@@ -1848,7 +1850,11 @@ static void draw_status_line (int line)
   }
   buf = xlinebuffer;
 
-	x+=100 - (TD_WIDTH*(currprefs.nr_floppies-1)) - TD_WIDTH;
+	x += 100 - (TD_WIDTH * (currprefs.nr_floppies - 1)) - TD_WIDTH;
+  if(nr_units() < 1)
+    x += TD_WIDTH;
+  if(currprefs.pandora_hide_idle_led)
+    x += TD_WIDTH;
 #ifdef PICASSO96
   if(picasso_on)
     memset (buf + (x - 4) * 2, 0, (picasso_vidinfo.width - x + 4) * 2);
@@ -1856,8 +1862,10 @@ static void draw_status_line (int line)
 #endif
     memset (buf + (x - 4) * gfxvidinfo.pixbytes, 0, (gfxvidinfo.outwidth - x + 4) * gfxvidinfo.pixbytes);
 
-	for (led = -2; led < (currprefs.nr_floppies+1); led++) {
+	for (led = (currprefs.pandora_hide_idle_led == 0) ? -2 : -1; led < (currprefs.nr_floppies+1); led++) {
 		int track;
+		if(led == 0 && nr_units() < 1)
+		  continue; // skip led for HD if not in use
 		if (led > 0) {
 			/* Floppy */
 			track = gui_data.drive_track[led-1];

src/gencpu.cpp

@@ -2330,8 +2330,12 @@ static void genmovemle_ce (uae_u16 opcode)
 	if (table68k[opcode].size == sz_long) {
 		if (table68k[opcode].dmode == Apdi) {
 			printf ("\tuae_u16 amask = mask & 0xff, dmask = (mask >> 8) & 0xff;\n");
+      if(cpu_level >= 2)
+        printf ("\tint type = get_cpu_model() >= 68020;\n");
 			printf ("\twhile (amask) {\n");
 			printf ("\t\tsrca -= %d;\n", size);
+      if(cpu_level >= 2)
+        printf ("\t\tif (type) m68k_areg (regs, dstreg) = srca;\n");
 			//printf ("\t\t%s (srca, m68k_areg (regs, movem_index2[amask]) >> 16);\n", dstw);
 			//printf ("\t\t%s (srca + 2, m68k_areg (regs, movem_index2[amask]));\n", dstw);
       printf ("\t\t%s (srca, m68k_areg (regs, movem_index2[amask]));\n", dstl);
@@ -2369,8 +2373,12 @@ static void genmovemle_ce (uae_u16 opcode)
 	} else {
 		if (table68k[opcode].dmode == Apdi) {
 			printf ("\tuae_u16 amask = mask & 0xff, dmask = (mask >> 8) & 0xff;\n");
+      if(cpu_level >= 2)
+  			printf ("\tint type = get_cpu_model() >= 68020;\n");
 			printf ("\twhile (amask) {\n");
 			printf ("\t\tsrca -= %d;\n", size);
+      if(cpu_level >= 2)
+  			printf ("\t\tif (type) m68k_areg (regs, dstreg) = srca;\n");
 			printf ("\t\t%s (srca, m68k_areg (regs, movem_index2[amask]));\n", dstw);
 			printf ("\tamask = movem_next[amask];\n");
 			addcycles000_nonce("\t\t", cpu_level > 1 ? 3 : 4);
@@ -3061,6 +3069,9 @@ static void gen_opcode (unsigned int opcode)
 
 	resetvars ();
 	
+  if(curi->mnemo == i_DIVL)
+     printf ("\tuae_u32 cyc = 0;\n");
+
 	start_brace ();
 
 	m68k_pc_offset = 2;
@@ -5070,8 +5081,13 @@ bccl_not68020:
 		break;
 	case i_DIVL:
 		genamode (curi, curi->smode, "srcreg", curi->size, "extra", 1, 0, 0);
+    printf ("\tif (extra & 0x800) cyc = 12 * CYCLE_UNIT / 2;\n");
 		genamode (curi, curi->dmode, "dstreg", curi->size, "dst", 1, 0, 0);
 		sync_m68k_pc ();
+    printf ("\tif (dst == 0) {\n");
+    printf ("\t\tException (5, regs);\n");
+	  printf ("\t\treturn 4 * CYCLE_UNIT / 2;\n");
+    printf ("\t}\n");
 		printf ("\tm68k_divl(opcode, dst, extra);\n");
 		break;
 	case i_MULL:

src/include/drawing.h

@@ -23,6 +23,7 @@
 
 #define lores_shift 0
 extern bool aga_mode;
+extern bool ham_drawn;
 
 STATIC_INLINE int coord_hw_to_window_x (int x)
 {

src/include/options.h

@@ -136,6 +136,7 @@ struct uae_prefs {
   int pandora_horizontal_offset;
   int pandora_vertical_offset;
   int pandora_cpu_speed;
+  int pandora_hide_idle_led;
   
   int pandora_joyConf;
   int pandora_joyPort;
@@ -162,6 +163,9 @@ struct uae_prefs {
   int key_for_menu;
   int key_for_input_switching;
 
+  int Port1_selection;
+  int Port2_selection;
+
   /* input */
 
   int input_joymouse_multiplier;

src/jit/codegen_arm.h

@@ -87,6 +87,9 @@
 
 #define SHIFT_IMM(c) (0x02000000 | (IMM32((c))))
 
+#define UNSHIFTED_IMM8(c) (0x02000000 | (c))
+#define SHIFT_IMM8_ROR(c,r) (0x02000000 | (c) | ((r >> 1) << 8))
+
 #define SHIFT_REG(Rm) (Rm)
 #define SHIFT_LSL_i(Rm,s) ((Rm) | ((s) << 7))
 #define SHIFT_LSL_r(Rm,Rs) ((Rm) | ((Rs) << 8) | 0x10)
@@ -97,6 +100,7 @@
 #define SHIFT_ROR_i(Rm,s) ((Rm) | ((s) << 7) | 0x60)
 #define SHIFT_ROR_r(Rm,Rs) ((Rm) | ((Rs) << 8) | 0x70)
 #define SHIFT_RRX(Rm) ((Rm) | 0x60)
+#define SHIFT_PK(Rm,s) ((Rm) | ((s) << 7))
 
 // Load/Store addressings
 #define ADR_ADD(v) ((1 << 23) | (v))
@@ -201,10 +205,16 @@ enum {
 /* ========================================================================= */
 
 #define	NOP()								_W(0xe1a00000)
+#define SETEND_BE()							_W(0xf1010200)
+#define SETEND_LE()							_W(0xf1010000)
 
 /* Data processing instructions */
 
 /* Opcodes Type 1 */
+// MOVcc rd,#i
+#define CC_MOV_ri8(cc,Rd,i)                 _OP1(cc,_MOV,0,Rd,UNSHIFTED_IMM8(i))
+// MOVcc Rd,#i ROR #s
+#define CC_MOV_ri8RORi(cc,Rd,i,s)           _OP1(cc,_MOV,0,Rd,SHIFT_IMM8_ROR(i,s))
 #define CC_MOV_ri(cc,Rd,i)                  _OP1(cc,_MOV,0,Rd,SHIFT_IMM(i))
 #define CC_MOV_rr(cc,Rd,Rm)                 _OP1(cc,_MOV,0,Rd,SHIFT_REG(Rm))
 #define CC_MOV_rrLSLi(cc,Rd,Rm,i)           _OP1(cc,_MOV,0,Rd,SHIFT_LSL_i(Rm,i))
@@ -217,6 +227,10 @@ enum {
 #define CC_MOV_rrRORr(cc,Rd,Rm,Rs)          _OP1(cc,_MOV,0,Rd,SHIFT_ROR_r(Rm,Rs))
 #define CC_MOV_rrRRX(cc,Rd,Rm)              _OP1(cc,_MOV,0,Rd,SHIFT_RRX(Rm))
 
+// MOV rd,#i
+#define MOV_ri8(Rd,i)                       CC_MOV_ri8(NATIVE_CC_AL,Rd,i)
+// MOV Rd,#i ROR #s
+#define MOV_ri8RORi(Rd,i,s)                 CC_MOV_ri8RORi(NATIVE_CC_AL,Rd,i,s)
 #define MOV_ri(Rd,i)                        CC_MOV_ri(NATIVE_CC_AL,Rd,i)
 #define MOV_rr(Rd,Rm)                       CC_MOV_rr(NATIVE_CC_AL,Rd,Rm)
 #define MOV_rrLSLi(Rd,Rm,i)                 CC_MOV_rrLSLi(NATIVE_CC_AL,Rd,Rm,i)
@@ -253,6 +267,10 @@ enum {
 #define MOVS_rrRORr(Rd,Rm,Rs)               CC_MOVS_rrRORr(NATIVE_CC_AL,Rd,Rm,Rs)
 #define MOVS_rrRRX(Rd,Rm)                   CC_MOVS_rrRRX(NATIVE_CC_AL,Rd,Rm)
 
+// MVNcc rd,#i
+#define CC_MVN_ri8(cc,Rd,i)                 _OP1(cc,_MVN,0,Rd,UNSHIFTED_IMM8(i))
+// MVNcc Rd,#i ROR #s
+#define CC_MVN_ri8RORi(cc,Rd,i,s)           _OP1(cc,_MVN,0,Rd,SHIFT_IMM8_ROR(i,s))
 #define CC_MVN_ri(cc,Rd,i)              	_OP1(cc,_MVN,0,Rd,SHIFT_IMM(i))
 #define CC_MVN_rr(cc,Rd,Rm)             	_OP1(cc,_MVN,0,Rd,SHIFT_REG(Rm))
 #define CC_MVN_rrLSLi(cc,Rd,Rm,i)       	_OP1(cc,_MVN,0,Rd,SHIFT_LSL_i(Rm,i))
@@ -265,6 +283,10 @@ enum {
 #define CC_MVN_rrRORr(cc,Rd,Rm,Rs)      	_OP1(cc,_MVN,0,Rd,SHIFT_ROR_r(Rm,Rs))
 #define CC_MVN_rrRRX(cc,Rd,Rm)           	_OP1(cc,_MVN,0,Rd,SHIFT_RRX(Rm))
 
+// MVN rd,#i
+#define MVN_ri8(Rd,i)                       CC_MVN_ri8(NATIVE_CC_AL,Rd,i)
+// MVN Rd,#i ROR #s
+#define MVN_ri8RORi(Rd,i,s)                 CC_MVN_ri8RORi(NATIVE_CC_AL,Rd,i,s)
 #define MVN_ri(Rd,i)                        CC_MVN_ri(NATIVE_CC_AL,Rd,i)
 #define MVN_rr(Rd,Rm)                       CC_MVN_rr(NATIVE_CC_AL,Rd,Rm)
 #define MVN_rrLSLi(Rd,Rm,i)                 CC_MVN_rrLSLi(NATIVE_CC_AL,Rd,Rm,i)
@@ -591,6 +613,9 @@ enum {
 #define RSBS_rrrRORr(Rd,Rn,Rm,Rs)       	CC_RSBS_rrrRORr(NATIVE_CC_AL,Rd,Rn,Rm,Rs)
 #define RSBS_rrrRRX(Rd,Rn,Rm)           	CC_RSBS_rrrRRX(NATIVE_CC_AL,Rd,Rn,Rm)
 
+#define CC_ADD_rri8(cc,Rd,Rn,i)          	_OP3(cc,_ADD,0,Rd,Rn,UNSHIFT_IMM8(i))
+#define CC_ADD_rri8RORi(cc,Rd,Rn,Rm,i)   	_OP3(cc,_ADD,0,Rd,Rn,SHIFT_IMM8_ROR(Rm,i))
+
 #define CC_ADD_rri(cc,Rd,Rn,i)          	_OP3(cc,_ADD,0,Rd,Rn,SHIFT_IMM(i))
 #define CC_ADD_rrr(cc,Rd,Rn,Rm)         	_OP3(cc,_ADD,0,Rd,Rn,SHIFT_REG(Rm))
 #define CC_ADD_rrrLSLi(cc,Rd,Rn,Rm,i)   	_OP3(cc,_ADD,0,Rd,Rn,SHIFT_LSL_i(Rm,i))
@@ -603,6 +628,9 @@ enum {
 #define CC_ADD_rrrRORr(cc,Rd,Rn,Rm,Rs)  	_OP3(cc,_ADD,0,Rd,Rn,SHIFT_ROR_r(Rm,Rs))
 #define CC_ADD_rrrRRX(cc,Rd,Rn,Rm)     		_OP3(cc,_ADD,0,Rd,Rn,SHIFT_RRX(Rm))
 
+#define ADD_rri8(cc,Rd,Rn,i)          		CC_ADD_rri8(NATIVE_CC_AL,Rd,Rn,i)
+#define ADD_rri8RORi(cc,Rd,Rn,Rm,i)   		CC_ADD_rri8RORi(NATIVE_CC_AL,Rd,Rn,Rm,i)
+
 #define ADD_rri(Rd,Rn,i)                	CC_ADD_rri(NATIVE_CC_AL,Rd,Rn,i)
 #define ADD_rrr(Rd,Rn,Rm)               	CC_ADD_rrr(NATIVE_CC_AL,Rd,Rn,Rm)
 #define ADD_rrrLSLi(Rd,Rn,Rm,i)         	CC_ADD_rrrLSLi(NATIVE_CC_AL,Rd,Rn,Rm,i)
@@ -783,6 +811,11 @@ enum {
 #define RSCS_rrrRORr(Rd,Rn,Rm,Rs)       	CC_RSCS_rrrRORr(NATIVE_CC_AL,Rd,Rn,Rm,Rs)
 #define RSCS_rrrRRX(Rd,Rn,Rm)           	CC_RSCS_rrrRRX(NATIVE_CC_AL,Rd,Rn,Rm)
 
+// ORRcc Rd,Rn,#i
+#define CC_ORR_rri8(cc,Rd,Rn,i)          	_OP3(cc,_ORR,0,Rd,Rn,UNSHIFTED_IMM8(i))
+// ORRcc Rd,Rn,#i ROR #s
+#define CC_ORR_rri8RORi(cc,Rd,Rn,i,s)      	_OP3(cc,_ORR,0,Rd,Rn,SHIFT_IMM8_ROR(i,s))
+
 #define CC_ORR_rri(cc,Rd,Rn,i)          	_OP3(cc,_ORR,0,Rd,Rn,SHIFT_IMM(i))
 #define CC_ORR_rrr(cc,Rd,Rn,Rm)         	_OP3(cc,_ORR,0,Rd,Rn,SHIFT_REG(Rm))
 #define CC_ORR_rrrLSLi(cc,Rd,Rn,Rm,i)   	_OP3(cc,_ORR,0,Rd,Rn,SHIFT_LSL_i(Rm,i))
@@ -795,6 +828,11 @@ enum {
 #define CC_ORR_rrrRORr(cc,Rd,Rn,Rm,Rs)  	_OP3(cc,_ORR,0,Rd,Rn,SHIFT_ROR_r(Rm,Rs))
 #define CC_ORR_rrrRRX(cc,Rd,Rn,Rm)     		_OP3(cc,_ORR,0,Rd,Rn,SHIFT_RRX(Rm))
 
+// ORR Rd,Rn,#i
+#define ORR_rri8(Rd,Rn,i)          			CC_ORR_rri8(NATIVE_CC_AL,Rd,Rn,i)
+// ORR Rd,Rn,#i ROR #s
+#define ORR_rri8RORi(Rd,Rn,i,s)      		CC_ORR_rri8RORi(NATIVE_CC_AL,Rd,Rn,i,s)
+
 #define ORR_rri(Rd,Rn,i)                	CC_ORR_rri(NATIVE_CC_AL,Rd,Rn,i)
 #define ORR_rrr(Rd,Rn,Rm)               	CC_ORR_rrr(NATIVE_CC_AL,Rd,Rn,Rm)
 #define ORR_rrrLSLi(Rd,Rn,Rm,i)         	CC_ORR_rrrLSLi(NATIVE_CC_AL,Rd,Rn,Rm,i)
@@ -1153,6 +1191,8 @@ enum {
 #define SMULLS_rrrr(RdLo,RdHi,Rm,Rs)			CC_SMULLS_rrrr(NATIVE_CC_AL,RdLo,RdHi,Rm,Rs)
 #define CC_MUL_rrr(cc, Rd, Rm, Rs)				_W(((cc) << 28) | (0x00 << 20) | ((Rd) << 16) | ((Rs) << 8) | (0x9 << 4) | (Rm))
 #define MUL_rrr(Rd, Rm, Rs)						CC_MUL_rrr(NATIVE_CC_AL, Rd, Rm, Rs)
+#define CC_MULS_rrr(cc, Rd, Rm, Rs)				_W(((cc) << 28) | (0x01 << 20) | ((Rd) << 16) | ((Rs) << 8) | (0x9 << 4) | (Rm))
+#define MULS_rrr(Rd, Rm, Rs)					CC_MULS_rrr(NATIVE_CC_AL, Rd, Rm, Rs)
 
 #define CC_UMULL_rrrr(cc, RdLo, RdHi, Rm, Rs)	_W(((cc) << 28) | (0x08 << 20) | ((RdHi) << 16) | ((RdLo) << 12) | ((Rs) << 8) | (0x9 << 4) | (Rm))
 #define UMULL_rrrr(RdLo,RdHi,Rm,Rs)				CC_UMULL_rrrr(NATIVE_CC_AL,RdLo,RdHi,Rm,Rs)
@@ -1181,6 +1221,7 @@ enum {
 #define ASRS_rrr(Rd,Rm,Rs)                	MOVS_rrASRr(Rd,Rm,Rs)
 #define RORS_rri(Rd,Rm,i)                   MOVS_rrRORi(Rd,Rm,i)
 #define RORS_rrr(Rd,Rm,Rs)                	MOVS_rrRORr(Rd,Rm,Rs)
+#define RRXS_rr(Rd,Rm)                      MOVS_rrRRX(Rd,Rm)
 
 /* ARMV6 ops */
 #define CC_SXTB_rr(cc,Rd,Rm)				_W(((cc) << 28) | (0x6a << 20) | (0xf << 16) | ((Rd) << 12) | (0x7 << 4) | SHIFT_REG(Rm))
@@ -1241,10 +1282,14 @@ enum {
 #define REVSH_rr(Rd,Rm)						CC_REVSH_rr(NATIVE_CC_AL,Rd,Rm)
 
 #define CC_PKHBT_rrr(cc,Rd,Rn,Rm)			_W(((cc) << 28) | (0x68 << 20) | (Rn << 16) | (Rd << 12) | (0x1 << 4) | (Rm))
+#define CC_PKHBT_rrrLSLi(cc,Rd,Rn,Rm,s)		_W(((cc) << 28) | (0x68 << 20) | (Rn << 16) | (Rd << 12) | (0x1 << 4) | SHIFT_PK(Rm, s))
 #define PKHBT_rrr(Rd,Rn,Rm)					CC_PKHBT_rrr(NATIVE_CC_AL,Rd,Rn,Rm)
+#define PKHBT_rrrLSLi(Rd,Rn,Rm,s)			CC_PKHBT_rrrLSLi(NATIVE_CC_AL,Rd,Rn,Rm,s)
 
-#define CC_PKHTB_rrrASRi(cc,Rd,Rn,Rm,i)			_W(((cc) << 28) | (0x68 << 20) | (Rn << 16) | (Rd << 12) | (0x5 << 4) | SHIFT_ASR_i(Rm,i))
+#define CC_PKHTB_rrrASRi(cc,Rd,Rn,Rm,s)		_W(((cc) << 28) | (0x68 << 20) | (Rn << 16) | (Rd << 12) | (0x5 << 4) | SHIFT_PK(Rm, s))
-#define PKHTB_rrrASRi(Rd,Rn,Rm,i)					CC_PKHTB_rrrASRi(NATIVE_CC_AL,Rd,Rn,Rm,i)
+#define PKHTB_rrrASRi(Rd,Rn,Rm,s)			CC_PKHTB_rrrASRi(NATIVE_CC_AL,Rd,Rn,Rm,s)
+#define CC_PKHTB_rrr(cc,Rd,Rn,Rm)		      _W(((cc) << 28) | (0x68 << 20) | (Rn << 16) | (Rd << 12) | (0x5 << 4) | (Rm))
+#define PKHTB_rrr(Rd,Rn,Rm)			          CC_PKHTB_rrr(NATIVE_CC_AL,Rd,Rn,Rm)
 
 #define CC_SADD16_rrr(cc,Rd,Rn,Rm)    _W(((cc) << 28) | (0x61 << 20) | (Rn << 16) | (Rd << 12) | (0xf1 << 4) | (Rm))
 #define SADD16_rrr(Rd,Rn,Rm)					CC_SADD16_rrr(NATIVE_CC_AL,Rd,Rn,Rm)
@@ -1252,4 +1297,28 @@ enum {
 #define CC_BFI_rrii(cc,Rd,Rn,lsb,msb)   _W(((cc) << 28) | (0x3e << 21) | ((msb) << 16) | (Rd << 12) | ((lsb) << 7) | (0x1 << 4) | (Rn))
 #define BFI_rrii(Rd,Rn,lsb,msb)         CC_BFI_rrii(NATIVE_CC_AL,Rd,Rn,lsb,msb)
 
+#define CC_BFC_rii(cc,Rd,lsb,msb)       _W(((cc) << 28) | (0x3e << 21) | ((msb) << 16) | (Rd << 12) | ((lsb) << 7) | (0x1 << 4) | 15)
+#define BFC_rii(Rd,lsb,msb)             CC_BFC_rii(NATIVE_CC_AL,Rd,lsb,msb)
+
+#define CC_UBFX_rrii(cc,Rd,Rn,lsb,width)   _W(((cc) << 28) | (0x3f << 21) | ((width-1) << 16) | (Rd << 12) | ((lsb) << 7) | (0x5 << 4) | (Rn))
+#define UBFX_rrii(Rd,Rn,lsb,width)         CC_UBFX_rrii(NATIVE_CC_AL,Rd,Rn,lsb,width)
+
+
+// Floatingpoint
+
+#define CC_VMOV_sr(cc,Sd,Rn)        _W(((cc) << 28) | (0x70 << 21) | (0 << 20) | (Sd << 16) | (Rn << 12) | (0x0a << 8) | (0x10))
+#define VMOV_sr(Sd,Rn)              CC_VMOV_sr(NATIVE_CC_AL,Sd,Rn)
+
+#define CC_VMOV_rs(cc,Rd,Sn)        _W(((cc) << 28) | (0x70 << 21) | (1 << 20) | (Sn << 16) | (Rd << 12) | (0x0a << 8) | (0x10))
+#define VMOV_rs(Rd,Sn)              CC_VMOV_rs(NATIVE_CC_AL,Rd,Sn)
+
+#define CC_VCVT_f64_u32(cc,Dd,Sn)   _W(((cc) << 28) | (0x1d << 23) | (0x7 << 19) | (0x0 << 16) | (Dd << 12) | (0xb << 8) | (0x4 << 4) | (Sn))
+#define VCVT_f64_u32(Dd,Sn)         CC_VCVT_f64_u32(NATIVE_CC_AL,Dd,Sn)
+
+#define CC_VCVT_u32_f64(cc,Sd,Dn)   _W(((cc) << 28) | (0x1d << 23) | (0x7 << 19) | (0x4 << 16) | (Sd << 12) | (0xb << 8) | (0xc << 4) | (Dn))
+#define VCVT_u32_f64(Sd,Dn)         CC_VCVT_u32_f64(NATIVE_CC_AL,Sd,Dn)
+
+#define CC_VDIV_ddd(cc,Dd,Dn,Dm)    _W(((cc) << 28) | (0x1d << 23) | (0x0 << 20) | (Dn << 16) | (Dd << 12) | (0xb << 8) | (0x0 << 4) | (Dm))
+#define VDIV_ddd(Dd,Dn,Dm)          CC_VDIV_ddd(NATIVE_CC_AL,Dd,Dn,Dm)
+
 #endif /* ARM_RTASM_H */

src/jit/compemu.h

@@ -33,6 +33,29 @@ typedef uae_u32 uintptr;
 
 #define panicbug printf
 
+/* Flags for Bernie during development/debugging. Should go away eventually */
+#define DISTRUST_CONSISTENT_MEM 0
+#define TAGMASK 0x0000ffff
+#define TAGSIZE (TAGMASK+1)
+#define MAXRUN 1024
+#define cacheline(x) (((uae_u32)x)&TAGMASK)
+
+extern uae_u8* start_pc_p;
+extern uae_u32 start_pc;
+
+struct blockinfo_t;
+
+typedef struct {
+  uae_u16* location;
+  uae_u8  cycles;
+  uae_u8  specmem;
+} cpu_history;
+
+typedef union {
+    cpuop_func* handler;
+    struct blockinfo_t* bi;
+} cacheline;
+
 /* (gb) When on, this option can save save up to 30% compilation time
  *  when many lazy flushes occur (e.g. apps in MacOS 8.x).
  */
@@ -50,35 +73,8 @@ typedef uae_u32 uintptr;
 #define USE_CHECKSUM_INFO 1
 #endif
 
-/* Flags for Bernie during development/debugging. Should go away eventually */
-#define DISTRUST_CONSISTENT_MEM 0
-#define TAGMASK 0x000fffff
-#define TAGSIZE (TAGMASK+1)
-#define MAXRUN 1024
-
-extern uae_u8* start_pc_p;
-extern uae_u32 start_pc;
-
-#define cacheline(x) (((uae_u32)x)&TAGMASK)
-
-typedef struct {
-  uae_u16* location;
-  uae_u8  cycles;
-  uae_u8  specmem;
-  uae_u8  dummy2;
-  uae_u8  dummy3;
-} cpu_history;
-
-struct blockinfo_t;
-
-typedef union {
-    cpuop_func* handler;
-    struct blockinfo_t* bi;
-} cacheline;
-
 #define USE_ALIAS 1
 #define USE_F_ALIAS 1
-#define USE_OFFSET 0
 #define COMP_DEBUG 0
 
 #if COMP_DEBUG
@@ -122,12 +118,10 @@ typedef union {
 #define FLAG_CZNV (FLAG_C | FLAG_Z | FLAG_N | FLAG_V)
 #define FLAG_ZNV  (FLAG_Z | FLAG_N | FLAG_V)
 
-#define KILLTHERAT 1  /* Set to 1 to avoid some partial_rat_stalls */
-
 #if defined(CPU_arm)
-#define USE_DATA_BUFFER
+//#define DEBUG_DATA_BUFFER
 #define ALIGN_NOT_NEEDED
-# define N_REGS 13  /* really 16, but 13 to 15 are SP, LR, PC */
+#define N_REGS 13  /* really 16, but 13 to 15 are SP, LR, PC */
 #else
 #define N_REGS 8  /* really only 7, but they are numbered 0,1,2,3,5,6,7 */
 #endif
@@ -176,10 +170,8 @@ typedef struct {
   uae_u8 status;
   uae_s8 realreg; /* gb-- realreg can hold -1 */
   uae_u8 realind; /* The index in the holds[] array */
-  uae_u8 needflush;
   uae_u8 validsize;
   uae_u8 dirtysize;
-  uae_u8 dummy;
 } reg_status;
 
 #ifdef USE_JIT_FPU
@@ -233,8 +225,6 @@ typedef struct {
   uae_u32 touched;
   uae_s8 holds[VREGS];
   uae_u8 nholds;
-  uae_u8 canbyte;
-  uae_u8 canword;
   uae_u8 locked;
 } n_status;
 
@@ -310,6 +300,7 @@ extern int touchcnt;
 
 #if defined(CPU_arm)
 #include "compemu_midfunc_arm.h"
+#include "compemu_midfunc_arm2.h"
 #else
 #include "compemu_midfunc_x86.h"
 #endif
@@ -331,9 +322,6 @@ extern void writelong_clobber(int address, int source, int tmp);
 extern void get_n_addr(int address, int dest, int tmp);
 extern void get_n_addr_jmp(int address, int dest, int tmp);
 extern void calc_disp_ea_020(int base, uae_u32 dp, int target, int tmp);
-/* Set native Z flag only if register is zero */
-extern void set_zero(int r, int tmp);
-extern int kill_rodent(int r);
 #define SYNC_PC_OFFSET 100
 extern void sync_m68k_pc(void);
 extern uae_u32 get_const(int r);

src/jit/compemu_midfunc_arm.h

@@ -36,155 +36,34 @@ DECLARE_MIDFUNC(arm_ADD_l(RW4 d, RR4 s));
 DECLARE_MIDFUNC(arm_ADD_l_ri(RW4 d, IMM i));
 DECLARE_MIDFUNC(arm_ADD_l_ri8(RW4 d, IMM i));
 DECLARE_MIDFUNC(arm_SUB_l_ri8(RW4 d, IMM i));
-DECLARE_MIDFUNC(arm_AND_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(arm_AND_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(arm_AND_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(arm_AND_l_ri8(RW4 d, IMM i));
-DECLARE_MIDFUNC(arm_EOR_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(arm_EOR_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(arm_EOR_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(arm_ORR_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(arm_ORR_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(arm_ORR_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(arm_ROR_l_ri8(RW4 r, IMM i));
 
 // Emulated midfunc
-DECLARE_MIDFUNC(bt_l_ri(RR4 r, IMM i));
-DECLARE_MIDFUNC(bt_l_rr(RR4 r, RR4 b));
-DECLARE_MIDFUNC(btc_l_rr(RW4 r, RR4 b));
-DECLARE_MIDFUNC(bts_l_rr(RW4 r, RR4 b));
-DECLARE_MIDFUNC(btr_l_rr(RW4 r, RR4 b));
-DECLARE_MIDFUNC(mov_l_rm(W4 d, IMM s));
-DECLARE_MIDFUNC(mov_l_rm_indexed(W4 d, IMM base, RR4 index, IMM factor));
 DECLARE_MIDFUNC(mov_l_mi(IMM d, IMM s));
-DECLARE_MIDFUNC(mov_w_mi(IMM d, IMM s));
-DECLARE_MIDFUNC(mov_b_mi(IMM d, IMM s));
-DECLARE_MIDFUNC(rol_b_ri(RW1 r, IMM i));
-DECLARE_MIDFUNC(rol_w_ri(RW2 r, IMM i));
-DECLARE_MIDFUNC(rol_l_rr(RW4 d, RR1 r));
-DECLARE_MIDFUNC(rol_w_rr(RW2 d, RR1 r));
-DECLARE_MIDFUNC(rol_b_rr(RW1 d, RR1 r));
-DECLARE_MIDFUNC(shll_l_rr(RW4 d, RR1 r));
-DECLARE_MIDFUNC(shll_w_rr(RW2 d, RR1 r));
-DECLARE_MIDFUNC(shll_b_rr(RW1 d, RR1 r));
-DECLARE_MIDFUNC(ror_b_ri(RR1 r, IMM i));
-DECLARE_MIDFUNC(ror_w_ri(RR2 r, IMM i));
-DECLARE_MIDFUNC(ror_l_ri(RR4 r, IMM i));
-DECLARE_MIDFUNC(ror_l_rr(RR4 d, RR1 r));
-DECLARE_MIDFUNC(ror_w_rr(RR2 d, RR1 r));
-DECLARE_MIDFUNC(ror_b_rr(RR1 d, RR1 r));
-DECLARE_MIDFUNC(shrl_l_rr(RW4 d, RR1 r));
-DECLARE_MIDFUNC(shrl_w_rr(RW2 d, RR1 r));
-DECLARE_MIDFUNC(shrl_b_rr(RW1 d, RR1 r));
-DECLARE_MIDFUNC(shra_l_rr(RW4 d, RR1 r));
-DECLARE_MIDFUNC(shra_w_rr(RW2 d, RR1 r));
-DECLARE_MIDFUNC(shra_b_rr(RW1 d, RR1 r));
 DECLARE_MIDFUNC(shll_l_ri(RW4 r, IMM i));
-DECLARE_MIDFUNC(shll_w_ri(RW2 r, IMM i));
-DECLARE_MIDFUNC(shll_b_ri(RW1 r, IMM i));
-DECLARE_MIDFUNC(shrl_l_ri(RW4 r, IMM i));
-DECLARE_MIDFUNC(shrl_w_ri(RW2 r, IMM i));
-DECLARE_MIDFUNC(shrl_b_ri(RW1 r, IMM i));
-DECLARE_MIDFUNC(shra_l_ri(RW4 r, IMM i));
-DECLARE_MIDFUNC(shra_w_ri(RW2 r, IMM i));
-DECLARE_MIDFUNC(shra_b_ri(RW1 r, IMM i));
-DECLARE_MIDFUNC(setcc(W1 d, IMM cc));
-DECLARE_MIDFUNC(setcc_m(IMM d, IMM cc));
-DECLARE_MIDFUNC(cmov_l_rr(RW4 d, RR4 s, IMM cc));
-DECLARE_MIDFUNC(bsf_l_rr(W4 d, RR4 s));
 DECLARE_MIDFUNC(pop_l(W4 d));
 DECLARE_MIDFUNC(push_l(RR4 s));
 DECLARE_MIDFUNC(sign_extend_16_rr(W4 d, RR2 s));
-DECLARE_MIDFUNC(sign_extend_8_rr(W4 d, RR1 s));
-DECLARE_MIDFUNC(zero_extend_16_rr(W4 d, RR2 s));
-DECLARE_MIDFUNC(zero_extend_8_rr(W4 d, RR1 s));
-DECLARE_MIDFUNC(imul_64_32(RW4 d, RW4 s));
-DECLARE_MIDFUNC(mul_64_32(RW4 d, RW4 s));
-DECLARE_MIDFUNC(imul_32_32(RW4 d, RR4 s));
 DECLARE_MIDFUNC(mov_b_rr(W1 d, RR1 s));
 DECLARE_MIDFUNC(mov_w_rr(W2 d, RR2 s));
-DECLARE_MIDFUNC(mov_l_rR(W4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_w_rR(W2 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_l_brR(W4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_w_brR(W2 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_b_brR(W1 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_l_brR24(W4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_w_brR24(W2 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_b_brR24(W1 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_l_Ri(RR4 d, IMM i, IMM offset));
-DECLARE_MIDFUNC(mov_w_Ri(RR4 d, IMM i, IMM offset));
-DECLARE_MIDFUNC(mov_l_Rr(RR4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_w_Rr(RR4 d, RR2 s, IMM offset));
 DECLARE_MIDFUNC(lea_l_brr(W4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(lea_l_brr24(W4 d, RR4 s, IMM offset));
 DECLARE_MIDFUNC(lea_l_brr_indexed(W4 d, RR4 s, RR4 index, IMM factor, IMM offset));
 DECLARE_MIDFUNC(lea_l_rr_indexed(W4 d, RR4 s, RR4 index, IMM factor));
-DECLARE_MIDFUNC(mov_l_bRr(RR4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_w_bRr(RR4 d, RR2 s, IMM offset));
-DECLARE_MIDFUNC(mov_b_bRr(RR4 d, RR1 s, IMM offset));
-DECLARE_MIDFUNC(mov_l_bRr24(RR4 d, RR4 s, IMM offset));
-DECLARE_MIDFUNC(mov_w_bRr24(RR4 d, RR2 s, IMM offset));
-DECLARE_MIDFUNC(mov_b_bRr24(RR4 d, RR1 s, IMM offset));
-DECLARE_MIDFUNC(mid_bswap_32(RW4 r));
-DECLARE_MIDFUNC(mid_bswap_16(RW2 r));
 DECLARE_MIDFUNC(mov_l_rr(W4 d, RR4 s));
 DECLARE_MIDFUNC(mov_l_mr(IMM d, RR4 s));
-DECLARE_MIDFUNC(mov_w_mr(IMM d, RR2 s));
-DECLARE_MIDFUNC(mov_w_rm(W2 d, IMM s));
-DECLARE_MIDFUNC(mov_b_mr(IMM d, RR1 s));
 DECLARE_MIDFUNC(mov_b_rm(W1 d, IMM s));
 DECLARE_MIDFUNC(mov_l_ri(W4 d, IMM s));
 DECLARE_MIDFUNC(mov_w_ri(W2 d, IMM s));
 DECLARE_MIDFUNC(mov_b_ri(W1 d, IMM s));
-DECLARE_MIDFUNC(test_l_ri(RR4 d, IMM i));
-DECLARE_MIDFUNC(test_l_rr(RR4 d, RR4 s));
 DECLARE_MIDFUNC(test_w_rr(RR2 d, RR2 s));
-DECLARE_MIDFUNC(test_b_rr(RR1 d, RR1 s));
-DECLARE_MIDFUNC(and_l_ri(RW4 d, IMM i));
-DECLARE_MIDFUNC(and_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(and_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(and_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(or_l_ri(RW4 d, IMM i));
-DECLARE_MIDFUNC(or_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(or_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(or_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(adc_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(adc_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(adc_b(RW1 d, RR1 s));
 DECLARE_MIDFUNC(add_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(add_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(add_b(RW1 d, RR1 s));
 DECLARE_MIDFUNC(sub_l_ri(RW4 d, IMM i));
 DECLARE_MIDFUNC(sub_w_ri(RW2 d, IMM i));
-DECLARE_MIDFUNC(sub_b_ri(RW1 d, IMM i));
 DECLARE_MIDFUNC(add_l_ri(RW4 d, IMM i));
-DECLARE_MIDFUNC(add_w_ri(RW2 d, IMM i));
-DECLARE_MIDFUNC(add_b_ri(RW1 d, IMM i));
-DECLARE_MIDFUNC(sbb_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(sbb_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(sbb_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(sub_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(sub_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(sub_b(RW1 d, RR1 s));
-DECLARE_MIDFUNC(cmp_l(RR4 d, RR4 s));
-DECLARE_MIDFUNC(cmp_w(RR2 d, RR2 s));
-DECLARE_MIDFUNC(cmp_b(RR1 d, RR1 s));
-DECLARE_MIDFUNC(xor_l(RW4 d, RR4 s));
-DECLARE_MIDFUNC(xor_w(RW2 d, RR2 s));
-DECLARE_MIDFUNC(xor_b(RW1 d, RR1 s));
 DECLARE_MIDFUNC(call_r_02(RR4 r, RR4 in1, RR4 in2, IMM isize1, IMM isize2));
 DECLARE_MIDFUNC(call_r_11(W4 out1, RR4 r, RR4 in1, IMM osize, IMM isize));
 DECLARE_MIDFUNC(live_flags(void));
 DECLARE_MIDFUNC(dont_care_flags(void));
-DECLARE_MIDFUNC(duplicate_carry(void));
-DECLARE_MIDFUNC(restore_carry(void));
-DECLARE_MIDFUNC(start_needflags(void));
-DECLARE_MIDFUNC(end_needflags(void));
 DECLARE_MIDFUNC(make_flags_live(void));
 DECLARE_MIDFUNC(forget_about(W4 r));
 
 DECLARE_MIDFUNC(f_forget_about(FW r));
-
-
-
-

src/jit/compemu_midfunc_arm2.h

@@ -0,0 +1,385 @@
+/*
+ *  compiler/compemu_midfunc_arm2.h - Native MIDFUNCS for ARM (JIT v2)
+ *
+ * Copyright (c) 2014 Jens Heitmann of ARAnyM dev team (see AUTHORS)
+ *
+ * Inspired by Christian Bauer's Basilisk II
+ *
+ *  Original 68040 JIT compiler for UAE, copyright 2000-2002 Bernd Meyer
+ *
+ *  Adaptation for Basilisk II and improvements, copyright 2000-2002
+ *    Gwenole Beauchesne
+ *
+ *  Basilisk II (C) 1997-2002 Christian Bauer
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *  Note:
+ *  	File is included by compemu.h
+ *
+ */
+
+// Arm optimized midfunc
+extern const uae_u32 ARM_CCR_MAP[];
+
+// ADD
+DECLARE_MIDFUNC(jnf_ADD(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jnf_ADD_imm(W4 d, RR4 s, IMM v));
+DECLARE_MIDFUNC(jnf_ADD_im8(W4 d, RR4 s, IMM v));
+DECLARE_MIDFUNC(jff_ADD_b(W4 d, RR1 s, RR1 v));
+DECLARE_MIDFUNC(jff_ADD_w(W4 d, RR2 s, RR2 v));
+DECLARE_MIDFUNC(jff_ADD_l(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_ADD_b_imm(W4 d, RR1 s, IMM v));
+DECLARE_MIDFUNC(jff_ADD_w_imm(W4 d, RR2 s, IMM v));
+DECLARE_MIDFUNC(jff_ADD_l_imm(W4 d, RR4 s, IMM v));
+
+// ADDA
+DECLARE_MIDFUNC(jnf_ADDA_b(W4 d, RR1 s));
+DECLARE_MIDFUNC(jnf_ADDA_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jnf_ADDA_l(W4 d, RR4 s));
+
+// ADDX
+DECLARE_MIDFUNC(jnf_ADDX(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_ADDX_b(W4 d, RR1 s, RR4 v));
+DECLARE_MIDFUNC(jff_ADDX_w(W4 d, RR2 s, RR4 v));
+DECLARE_MIDFUNC(jff_ADDX_l(W4 d, RR4 s, RR4 v));
+
+// AND
+DECLARE_MIDFUNC(jnf_AND(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_AND_b(W4 d, RR1 s, RR1 v));
+DECLARE_MIDFUNC(jff_AND_w(W4 d, RR2 s, RR2 v));
+DECLARE_MIDFUNC(jff_AND_l(W4 d, RR4 s, RR4 v));
+
+// ANDSR
+DECLARE_MIDFUNC(jff_ANDSR(IMM s, IMM x));
+
+// ASL
+DECLARE_MIDFUNC(jff_ASL_b_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_ASL_w_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_ASL_l_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_ASL_b_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ASL_w_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ASL_l_reg(W4 d, RR4 s, RR4 i));
+
+// ASLW
+DECLARE_MIDFUNC(jff_ASLW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_ASLW(W4 d, RR4 s));
+
+// ASR
+DECLARE_MIDFUNC(jnf_ASR_b_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_ASR_w_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_ASR_l_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_ASR_b_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_ASR_w_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_ASR_l_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_ASR_b_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ASR_w_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ASR_l_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ASR_b_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ASR_w_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ASR_l_reg(W4 d, RR4 s, RR4 i));
+
+// ASRW
+DECLARE_MIDFUNC(jff_ASRW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_ASRW(W4 d, RR4 s));
+
+// BCHG
+DECLARE_MIDFUNC(jnf_BCHG_b_imm(RW4 d, IMM s));
+DECLARE_MIDFUNC(jnf_BCHG_l_imm(RW4 d, IMM s));
+
+DECLARE_MIDFUNC(jff_BCHG_b_imm(RW4 d, IMM s));
+DECLARE_MIDFUNC(jff_BCHG_l_imm(RW4 d, IMM s));
+
+DECLARE_MIDFUNC(jnf_BCHG_b(RW4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_BCHG_l(RW4 d, RR4 s));
+
+DECLARE_MIDFUNC(jff_BCHG_b(RW4 d, RR4 s));
+DECLARE_MIDFUNC(jff_BCHG_l(RW4 d, RR4 s));
+
+// BCLR
+DECLARE_MIDFUNC(jnf_BCLR_b_imm(RW4 d, IMM s));
+DECLARE_MIDFUNC(jnf_BCLR_l_imm(RW4 d, IMM s));
+
+DECLARE_MIDFUNC(jnf_BCLR_b(RW4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_BCLR_l(RW4 d, RR4 s));
+
+DECLARE_MIDFUNC(jff_BCLR_b_imm(RW4 d, IMM s));
+DECLARE_MIDFUNC(jff_BCLR_l_imm(RW4 d, IMM s));
+
+DECLARE_MIDFUNC(jff_BCLR_b(RW4 d, RR4 s));
+DECLARE_MIDFUNC(jff_BCLR_l(RW4 d, RR4 s));
+
+// BSET
+DECLARE_MIDFUNC(jnf_BSET_b_imm(RW4 d, IMM s));
+DECLARE_MIDFUNC(jnf_BSET_l_imm(RW4 d, IMM s));
+
+DECLARE_MIDFUNC(jnf_BSET_b(RW4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_BSET_l(RW4 d, RR4 s));
+
+DECLARE_MIDFUNC(jff_BSET_b_imm(RW4 d, IMM s));
+DECLARE_MIDFUNC(jff_BSET_l_imm(RW4 d, IMM s));
+
+DECLARE_MIDFUNC(jff_BSET_b(RW4 d, RR4 s));
+DECLARE_MIDFUNC(jff_BSET_l(RW4 d, RR4 s));
+
+// BTST
+DECLARE_MIDFUNC(jff_BTST_b_imm(RR4 d, IMM s));
+DECLARE_MIDFUNC(jff_BTST_l_imm(RR4 d, IMM s));
+
+DECLARE_MIDFUNC(jff_BTST_b(RR4 d, RR4 s));
+DECLARE_MIDFUNC(jff_BTST_l(RR4 d, RR4 s));
+
+// CLR
+DECLARE_MIDFUNC (jnf_CLR(W4 d));
+DECLARE_MIDFUNC (jff_CLR(W4 d));
+
+// CMP
+DECLARE_MIDFUNC(jff_CMP_b(RR1 d, RR1 s));
+DECLARE_MIDFUNC(jff_CMP_w(RR2 d, RR2 s));
+DECLARE_MIDFUNC(jff_CMP_l(RR4 d, RR4 s));
+
+// CMPA
+DECLARE_MIDFUNC(jff_CMPA_w(RR2 d, RR2 s));
+DECLARE_MIDFUNC(jff_CMPA_l(RR4 d, RR4 s));
+
+// DBCC
+DECLARE_MIDFUNC(jff_DBCC(RR2 d, IMM cc));
+
+// DIVU
+DECLARE_MIDFUNC(jnf_DIVU(W4 d, RR4 s1, RR4 s2));
+DECLARE_MIDFUNC(jff_DIVU(W4 d, RR4 s1, RR4 s2));
+
+// EOR
+DECLARE_MIDFUNC(jnf_EOR(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_EOR_b(W4 d, RR1 s, RR1 v));
+DECLARE_MIDFUNC(jff_EOR_w(W4 d, RR2 s, RR2 v));
+DECLARE_MIDFUNC(jff_EOR_l(W4 d, RR4 s, RR4 v));
+
+// EORSR
+DECLARE_MIDFUNC(jff_EORSR(IMM s, IMM x));
+
+// EXT
+DECLARE_MIDFUNC(jnf_EXT_b(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_EXT_w(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_EXT_l(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_EXT_b(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_EXT_w(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_EXT_l(W4 d, RR4 s));
+
+// LSL
+DECLARE_MIDFUNC(jnf_LSL_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_LSL_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_LSL_b_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_LSL_w_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_LSL_l_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_LSL_b_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_LSL_w_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_LSL_l_reg(W4 d, RR4 s, RR4 i));
+
+// LSLW
+DECLARE_MIDFUNC(jff_LSLW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_LSLW(W4 d, RR4 s));
+
+// LSR
+DECLARE_MIDFUNC(jnf_LSR_b_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_LSR_w_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_LSR_l_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_LSR_b_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_LSR_w_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jff_LSR_l_imm(W4 d, RR4 s, IMM i));
+DECLARE_MIDFUNC(jnf_LSR_b_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_LSR_w_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_LSR_l_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_LSR_b_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_LSR_w_reg(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_LSR_l_reg(W4 d, RR4 s, RR4 i));
+
+// LSRW
+DECLARE_MIDFUNC(jff_LSRW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_LSRW(W4 d, RR4 s));
+
+// MOVE
+DECLARE_MIDFUNC(jnf_MOVE(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_MOVE_b_imm(W4 d, IMM i));
+DECLARE_MIDFUNC(jff_MOVE_w_imm(W4 d, IMM i));
+DECLARE_MIDFUNC(jff_MOVE_l_imm(W4 d, IMM i));
+DECLARE_MIDFUNC(jff_MOVE_b(W4 d, RR1 s));
+DECLARE_MIDFUNC(jff_MOVE_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jff_MOVE_l(W4 d, RR4 s));
+
+// MVMEL
+DECLARE_MIDFUNC(jnf_MVMEL_w(W4 d, RR4 s, IMM offset));
+DECLARE_MIDFUNC(jnf_MVMEL_l(W4 d, RR4 s, IMM offset));
+
+// MVMLE
+DECLARE_MIDFUNC(jnf_MVMLE_w(RR4 d, RR4 s, IMM offset));
+DECLARE_MIDFUNC(jnf_MVMLE_l(RR4 d, RR4 s, IMM offset));
+
+// MOVE16
+DECLARE_MIDFUNC(jnf_MOVE16(RR4 d, RR4 s));
+
+// MOVEA
+DECLARE_MIDFUNC(jnf_MOVEA_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jnf_MOVEA_l(W4 d, RR4 s));
+
+// MULS
+DECLARE_MIDFUNC (jnf_MULS(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jff_MULS(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jnf_MULS32(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jff_MULS32(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jnf_MULS64(RW4 d, RW4 s));
+DECLARE_MIDFUNC (jff_MULS64(RW4 d, RW4 s));
+
+// MULU
+DECLARE_MIDFUNC (jnf_MULU(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jff_MULU(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jnf_MULU32(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jff_MULU32(RW4 d, RR4 s));
+DECLARE_MIDFUNC (jnf_MULU64(RW4 d, RW4 s));
+DECLARE_MIDFUNC (jff_MULU64(RW4 d, RW4 s));
+
+// NEG
+DECLARE_MIDFUNC(jnf_NEG_b(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_NEG_w(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_NEG_l(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_NEG_b(W4 d, RR1 s));
+DECLARE_MIDFUNC(jff_NEG_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jff_NEG_l(W4 d, RR4 s));
+
+// NEGX
+DECLARE_MIDFUNC(jnf_NEGX_b(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_NEGX_w(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_NEGX_l(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_NEGX_b(W4 d, RR1 s));
+DECLARE_MIDFUNC(jff_NEGX_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jff_NEGX_l(W4 d, RR4 s));
+
+// NOT
+DECLARE_MIDFUNC(jnf_NOT(W4 d, RR4 s));
+DECLARE_MIDFUNC(jff_NOT_b(W4 d, RR1 s));
+DECLARE_MIDFUNC(jff_NOT_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jff_NOT_l(W4 d, RR4 s));
+
+// OR
+DECLARE_MIDFUNC(jnf_OR(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_OR_b(W4 d, RR1 s, RR1 v));
+DECLARE_MIDFUNC(jff_OR_w(W4 d, RR2 s, RR2 v));
+DECLARE_MIDFUNC(jff_OR_l(W4 d, RR4 s, RR4 v));
+
+// ORSR
+DECLARE_MIDFUNC(jff_ORSR(IMM s, IMM x));
+
+// ROL
+DECLARE_MIDFUNC(jnf_ROL_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROL_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROL_l(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROL_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROL_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROL_l(W4 d, RR4 s, RR4 i));
+
+// ROLW
+DECLARE_MIDFUNC(jff_ROLW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_ROLW(W4 d, RR4 s));
+
+// RORW
+DECLARE_MIDFUNC(jff_RORW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_RORW(W4 d, RR4 s));
+
+// ROXL
+DECLARE_MIDFUNC(jnf_ROXL_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROXL_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROXL_l(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROXL_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROXL_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROXL_l(W4 d, RR4 s, RR4 i));
+
+// ROXLW
+DECLARE_MIDFUNC(jff_ROXLW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_ROXLW(W4 d, RR4 s));
+
+// ROR
+DECLARE_MIDFUNC(jnf_ROR_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROR_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROR_l(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROR_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROR_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROR_l(W4 d, RR4 s, RR4 i));
+
+// ROXR
+DECLARE_MIDFUNC(jnf_ROXR_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROXR_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jnf_ROXR_l(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROXR_b(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROXR_w(W4 d, RR4 s, RR4 i));
+DECLARE_MIDFUNC(jff_ROXR_l(W4 d, RR4 s, RR4 i));
+
+// ROXRW
+DECLARE_MIDFUNC(jff_ROXRW(W4 d, RR4 s));
+DECLARE_MIDFUNC(jnf_ROXRW(W4 d, RR4 s));
+
+// Scc
+DECLARE_MIDFUNC(jnf_SCC(W4 d, IMM cc));
+
+// SUB
+DECLARE_MIDFUNC(jnf_SUB_b_imm(W4 d, RR4 s, IMM v));
+DECLARE_MIDFUNC(jnf_SUB_b(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jnf_SUB_w_imm(W4 d, RR4 s, IMM v));
+DECLARE_MIDFUNC(jnf_SUB_w(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jnf_SUB_l_imm(W4 d, RR4 s, IMM v));
+DECLARE_MIDFUNC(jnf_SUB_l(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_SUB_b(W4 d, RR1 s, RR1 v));
+DECLARE_MIDFUNC(jff_SUB_w(W4 d, RR2 s, RR2 v));
+DECLARE_MIDFUNC(jff_SUB_l(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_SUB_b_imm(W4 d, RR1 s, IMM v));
+DECLARE_MIDFUNC(jff_SUB_w_imm(W4 d, RR2 s, IMM v));
+DECLARE_MIDFUNC(jff_SUB_l_imm(W4 d, RR4 s, IMM v));
+
+// SUBA
+DECLARE_MIDFUNC(jnf_SUBA_w(W4 d, RR2 s));
+DECLARE_MIDFUNC(jnf_SUBA_l(W4 d, RR4 s));
+
+// SUBX
+DECLARE_MIDFUNC(jnf_SUBX(W4 d, RR4 s, RR4 v));
+DECLARE_MIDFUNC(jff_SUBX_b(W4 d, RR1 s, RR4 v));
+DECLARE_MIDFUNC(jff_SUBX_w(W4 d, RR2 s, RR4 v));
+DECLARE_MIDFUNC(jff_SUBX_l(W4 d, RR4 s, RR4 v));
+
+// SWAP
+DECLARE_MIDFUNC (jnf_SWAP(RW4 d));
+DECLARE_MIDFUNC (jff_SWAP(RW4 d));
+
+// TST
+DECLARE_MIDFUNC (jff_TST_b(RR1 s));
+DECLARE_MIDFUNC (jff_TST_w(RR2 s));
+DECLARE_MIDFUNC (jff_TST_l(RR4 s));
+
+// Memory access functions
+DECLARE_MIDFUNC(jnf_MEM_WRITE_OFF_b(RR4 adr, RR4 b));
+DECLARE_MIDFUNC(jnf_MEM_WRITE_OFF_w(RR4 adr, RR4 w));
+DECLARE_MIDFUNC(jnf_MEM_WRITE_OFF_l(RR4 adr, RR4 l));
+DECLARE_MIDFUNC(jnf_MEM_WRITE24_OFF_b(RR4 adr, RR4 b));
+DECLARE_MIDFUNC(jnf_MEM_WRITE24_OFF_w(RR4 adr, RR4 w));
+DECLARE_MIDFUNC(jnf_MEM_WRITE24_OFF_l(RR4 adr, RR4 l));
+
+DECLARE_MIDFUNC(jnf_MEM_READ_OFF_b(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_READ_OFF_w(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_READ_OFF_l(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_READ24_OFF_b(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_READ24_OFF_w(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_READ24_OFF_l(W4 d, RR4 adr));
+
+DECLARE_MIDFUNC(jnf_MEM_GETADR_OFF(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_GETADR24_OFF(W4 d, RR4 adr));
+DECLARE_MIDFUNC(jnf_MEM_GETBANKFUNC(W4 d, RR4 adr, IMM offset));

src/jit/comptbl.h

@@ -1,3 +1,9 @@
+#ifdef NOFLAGS_SUPPORT
+/* 68040 */
+extern const struct comptbl op_smalltbl_0_nf[];
+#endif
+extern const struct comptbl op_smalltbl_0_comp_nf[];
+extern const struct comptbl op_smalltbl_0_comp_ff[];
 extern compop_func op_0_0_comp_ff;
 extern compop_func op_10_0_comp_ff;
 extern compop_func op_18_0_comp_ff;
@@ -6,6 +12,7 @@ extern compop_func op_28_0_comp_ff;
 extern compop_func op_30_0_comp_ff;
 extern compop_func op_38_0_comp_ff;
 extern compop_func op_39_0_comp_ff;
+extern compop_func op_3c_0_comp_ff;
 extern compop_func op_40_0_comp_ff;
 extern compop_func op_50_0_comp_ff;
 extern compop_func op_58_0_comp_ff;
@@ -41,8 +48,6 @@ extern compop_func op_168_0_comp_ff;
 extern compop_func op_170_0_comp_ff;
 extern compop_func op_178_0_comp_ff;
 extern compop_func op_179_0_comp_ff;
-extern compop_func op_17a_0_comp_ff;
-extern compop_func op_17b_0_comp_ff;
 extern compop_func op_180_0_comp_ff;
 extern compop_func op_190_0_comp_ff;
 extern compop_func op_198_0_comp_ff;
@@ -51,8 +56,6 @@ extern compop_func op_1a8_0_comp_ff;
 extern compop_func op_1b0_0_comp_ff;
 extern compop_func op_1b8_0_comp_ff;
 extern compop_func op_1b9_0_comp_ff;
-extern compop_func op_1ba_0_comp_ff;
-extern compop_func op_1bb_0_comp_ff;
 extern compop_func op_1c0_0_comp_ff;
 extern compop_func op_1d0_0_comp_ff;
 extern compop_func op_1d8_0_comp_ff;
@@ -61,8 +64,6 @@ extern compop_func op_1e8_0_comp_ff;
 extern compop_func op_1f0_0_comp_ff;
 extern compop_func op_1f8_0_comp_ff;
 extern compop_func op_1f9_0_comp_ff;
-extern compop_func op_1fa_0_comp_ff;
-extern compop_func op_1fb_0_comp_ff;
 extern compop_func op_200_0_comp_ff;
 extern compop_func op_210_0_comp_ff;
 extern compop_func op_218_0_comp_ff;
@@ -71,6 +72,7 @@ extern compop_func op_228_0_comp_ff;
 extern compop_func op_230_0_comp_ff;
 extern compop_func op_238_0_comp_ff;
 extern compop_func op_239_0_comp_ff;
+extern compop_func op_23c_0_comp_ff;
 extern compop_func op_240_0_comp_ff;
 extern compop_func op_250_0_comp_ff;
 extern compop_func op_258_0_comp_ff;
@@ -154,8 +156,6 @@ extern compop_func op_868_0_comp_ff;
 extern compop_func op_870_0_comp_ff;
 extern compop_func op_878_0_comp_ff;
 extern compop_func op_879_0_comp_ff;
-extern compop_func op_87a_0_comp_ff;
-extern compop_func op_87b_0_comp_ff;
 extern compop_func op_880_0_comp_ff;
 extern compop_func op_890_0_comp_ff;
 extern compop_func op_898_0_comp_ff;
@@ -164,8 +164,6 @@ extern compop_func op_8a8_0_comp_ff;
 extern compop_func op_8b0_0_comp_ff;
 extern compop_func op_8b8_0_comp_ff;
 extern compop_func op_8b9_0_comp_ff;
-extern compop_func op_8ba_0_comp_ff;
-extern compop_func op_8bb_0_comp_ff;
 extern compop_func op_8c0_0_comp_ff;
 extern compop_func op_8d0_0_comp_ff;
 extern compop_func op_8d8_0_comp_ff;
@@ -174,8 +172,6 @@ extern compop_func op_8e8_0_comp_ff;
 extern compop_func op_8f0_0_comp_ff;
 extern compop_func op_8f8_0_comp_ff;
 extern compop_func op_8f9_0_comp_ff;
-extern compop_func op_8fa_0_comp_ff;
-extern compop_func op_8fb_0_comp_ff;
 extern compop_func op_a00_0_comp_ff;
 extern compop_func op_a10_0_comp_ff;
 extern compop_func op_a18_0_comp_ff;
@@ -184,6 +180,7 @@ extern compop_func op_a28_0_comp_ff;
 extern compop_func op_a30_0_comp_ff;
 extern compop_func op_a38_0_comp_ff;
 extern compop_func op_a39_0_comp_ff;
+extern compop_func op_a3c_0_comp_ff;
 extern compop_func op_a40_0_comp_ff;
 extern compop_func op_a50_0_comp_ff;
 extern compop_func op_a58_0_comp_ff;
@@ -696,6 +693,17 @@ extern compop_func op_4ab9_0_comp_ff;
 extern compop_func op_4aba_0_comp_ff;
 extern compop_func op_4abb_0_comp_ff;
 extern compop_func op_4abc_0_comp_ff;
+extern compop_func op_4c00_0_comp_ff;
+extern compop_func op_4c10_0_comp_ff;
+extern compop_func op_4c18_0_comp_ff;
+extern compop_func op_4c20_0_comp_ff;
+extern compop_func op_4c28_0_comp_ff;
+extern compop_func op_4c30_0_comp_ff;
+extern compop_func op_4c38_0_comp_ff;
+extern compop_func op_4c39_0_comp_ff;
+extern compop_func op_4c3a_0_comp_ff;
+extern compop_func op_4c3b_0_comp_ff;
+extern compop_func op_4c3c_0_comp_ff;
 extern compop_func op_4c90_0_comp_ff;
 extern compop_func op_4c98_0_comp_ff;
 extern compop_func op_4ca8_0_comp_ff;
@@ -855,6 +863,24 @@ extern compop_func op_57e8_0_comp_ff;
 extern compop_func op_57f0_0_comp_ff;
 extern compop_func op_57f8_0_comp_ff;
 extern compop_func op_57f9_0_comp_ff;
+extern compop_func op_58c0_0_comp_ff;
+extern compop_func op_58c8_0_comp_ff;
+extern compop_func op_58d0_0_comp_ff;
+extern compop_func op_58d8_0_comp_ff;
+extern compop_func op_58e0_0_comp_ff;
+extern compop_func op_58e8_0_comp_ff;
+extern compop_func op_58f0_0_comp_ff;
+extern compop_func op_58f8_0_comp_ff;
+extern compop_func op_58f9_0_comp_ff;
+extern compop_func op_59c0_0_comp_ff;
+extern compop_func op_59c8_0_comp_ff;
+extern compop_func op_59d0_0_comp_ff;
+extern compop_func op_59d8_0_comp_ff;
+extern compop_func op_59e0_0_comp_ff;
+extern compop_func op_59e8_0_comp_ff;
+extern compop_func op_59f0_0_comp_ff;
+extern compop_func op_59f8_0_comp_ff;
+extern compop_func op_59f9_0_comp_ff;
 extern compop_func op_5ac0_0_comp_ff;
 extern compop_func op_5ac8_0_comp_ff;
 extern compop_func op_5ad0_0_comp_ff;
@@ -914,6 +940,7 @@ extern compop_func op_6001_0_comp_ff;
 extern compop_func op_60ff_0_comp_ff;
 extern compop_func op_6100_0_comp_ff;
 extern compop_func op_6101_0_comp_ff;
+extern compop_func op_61ff_0_comp_ff;
 extern compop_func op_6200_0_comp_ff;
 extern compop_func op_6201_0_comp_ff;
 extern compop_func op_62ff_0_comp_ff;
@@ -1360,6 +1387,13 @@ extern compop_func op_e098_0_comp_ff;
 extern compop_func op_e0a0_0_comp_ff;
 extern compop_func op_e0a8_0_comp_ff;
 extern compop_func op_e0b8_0_comp_ff;
+extern compop_func op_e0d0_0_comp_ff;
+extern compop_func op_e0d8_0_comp_ff;
+extern compop_func op_e0e0_0_comp_ff;
+extern compop_func op_e0e8_0_comp_ff;
+extern compop_func op_e0f0_0_comp_ff;
+extern compop_func op_e0f8_0_comp_ff;
+extern compop_func op_e0f9_0_comp_ff;
 extern compop_func op_e100_0_comp_ff;
 extern compop_func op_e108_0_comp_ff;
 extern compop_func op_e118_0_comp_ff;
@@ -1378,6 +1412,41 @@ extern compop_func op_e198_0_comp_ff;
 extern compop_func op_e1a0_0_comp_ff;
 extern compop_func op_e1a8_0_comp_ff;
 extern compop_func op_e1b8_0_comp_ff;
+extern compop_func op_e1d0_0_comp_ff;
+extern compop_func op_e1d8_0_comp_ff;
+extern compop_func op_e1e0_0_comp_ff;
+extern compop_func op_e1e8_0_comp_ff;
+extern compop_func op_e1f0_0_comp_ff;
+extern compop_func op_e1f8_0_comp_ff;
+extern compop_func op_e1f9_0_comp_ff;
+extern compop_func op_e2d0_0_comp_ff;
+extern compop_func op_e2d8_0_comp_ff;
+extern compop_func op_e2e0_0_comp_ff;
+extern compop_func op_e2e8_0_comp_ff;
+extern compop_func op_e2f0_0_comp_ff;
+extern compop_func op_e2f8_0_comp_ff;
+extern compop_func op_e2f9_0_comp_ff;
+extern compop_func op_e3d0_0_comp_ff;
+extern compop_func op_e3d8_0_comp_ff;
+extern compop_func op_e3e0_0_comp_ff;
+extern compop_func op_e3e8_0_comp_ff;
+extern compop_func op_e3f0_0_comp_ff;
+extern compop_func op_e3f8_0_comp_ff;
+extern compop_func op_e3f9_0_comp_ff;
+extern compop_func op_e6d0_0_comp_ff;
+extern compop_func op_e6d8_0_comp_ff;
+extern compop_func op_e6e0_0_comp_ff;
+extern compop_func op_e6e8_0_comp_ff;
+extern compop_func op_e6f0_0_comp_ff;
+extern compop_func op_e6f8_0_comp_ff;
+extern compop_func op_e6f9_0_comp_ff;
+extern compop_func op_e7d0_0_comp_ff;
+extern compop_func op_e7d8_0_comp_ff;
+extern compop_func op_e7e0_0_comp_ff;
+extern compop_func op_e7e8_0_comp_ff;
+extern compop_func op_e7f0_0_comp_ff;
+extern compop_func op_e7f8_0_comp_ff;
+extern compop_func op_e7f9_0_comp_ff;
 extern compop_func op_f600_0_comp_ff;
 extern compop_func op_f608_0_comp_ff;
 extern compop_func op_f610_0_comp_ff;
@@ -1391,6 +1460,7 @@ extern compop_func op_28_0_comp_nf;
 extern compop_func op_30_0_comp_nf;
 extern compop_func op_38_0_comp_nf;
 extern compop_func op_39_0_comp_nf;
+extern compop_func op_3c_0_comp_nf;
 extern compop_func op_40_0_comp_nf;
 extern compop_func op_50_0_comp_nf;
 extern compop_func op_58_0_comp_nf;
@@ -1426,8 +1496,6 @@ extern compop_func op_168_0_comp_nf;
 extern compop_func op_170_0_comp_nf;
 extern compop_func op_178_0_comp_nf;
 extern compop_func op_179_0_comp_nf;
-extern compop_func op_17a_0_comp_nf;
-extern compop_func op_17b_0_comp_nf;
 extern compop_func op_180_0_comp_nf;
 extern compop_func op_190_0_comp_nf;
 extern compop_func op_198_0_comp_nf;
@@ -1436,8 +1504,6 @@ extern compop_func op_1a8_0_comp_nf;
 extern compop_func op_1b0_0_comp_nf;
 extern compop_func op_1b8_0_comp_nf;
 extern compop_func op_1b9_0_comp_nf;
-extern compop_func op_1ba_0_comp_nf;
-extern compop_func op_1bb_0_comp_nf;
 extern compop_func op_1c0_0_comp_nf;
 extern compop_func op_1d0_0_comp_nf;
 extern compop_func op_1d8_0_comp_nf;
@@ -1446,8 +1512,6 @@ extern compop_func op_1e8_0_comp_nf;
 extern compop_func op_1f0_0_comp_nf;
 extern compop_func op_1f8_0_comp_nf;
 extern compop_func op_1f9_0_comp_nf;
-extern compop_func op_1fa_0_comp_nf;
-extern compop_func op_1fb_0_comp_nf;
 extern compop_func op_200_0_comp_nf;
 extern compop_func op_210_0_comp_nf;
 extern compop_func op_218_0_comp_nf;
@@ -1456,6 +1520,7 @@ extern compop_func op_228_0_comp_nf;
 extern compop_func op_230_0_comp_nf;
 extern compop_func op_238_0_comp_nf;
 extern compop_func op_239_0_comp_nf;
+extern compop_func op_23c_0_comp_nf;
 extern compop_func op_240_0_comp_nf;
 extern compop_func op_250_0_comp_nf;
 extern compop_func op_258_0_comp_nf;
@@ -1539,8 +1604,6 @@ extern compop_func op_868_0_comp_nf;
 extern compop_func op_870_0_comp_nf;
 extern compop_func op_878_0_comp_nf;
 extern compop_func op_879_0_comp_nf;
-extern compop_func op_87a_0_comp_nf;
-extern compop_func op_87b_0_comp_nf;
 extern compop_func op_880_0_comp_nf;
 extern compop_func op_890_0_comp_nf;
 extern compop_func op_898_0_comp_nf;
@@ -1549,8 +1612,6 @@ extern compop_func op_8a8_0_comp_nf;
 extern compop_func op_8b0_0_comp_nf;
 extern compop_func op_8b8_0_comp_nf;
 extern compop_func op_8b9_0_comp_nf;
-extern compop_func op_8ba_0_comp_nf;
-extern compop_func op_8bb_0_comp_nf;
 extern compop_func op_8c0_0_comp_nf;
 extern compop_func op_8d0_0_comp_nf;
 extern compop_func op_8d8_0_comp_nf;
@@ -1559,8 +1620,6 @@ extern compop_func op_8e8_0_comp_nf;
 extern compop_func op_8f0_0_comp_nf;
 extern compop_func op_8f8_0_comp_nf;
 extern compop_func op_8f9_0_comp_nf;
-extern compop_func op_8fa_0_comp_nf;
-extern compop_func op_8fb_0_comp_nf;
 extern compop_func op_a00_0_comp_nf;
 extern compop_func op_a10_0_comp_nf;
 extern compop_func op_a18_0_comp_nf;
@@ -1569,6 +1628,7 @@ extern compop_func op_a28_0_comp_nf;
 extern compop_func op_a30_0_comp_nf;
 extern compop_func op_a38_0_comp_nf;
 extern compop_func op_a39_0_comp_nf;
+extern compop_func op_a3c_0_comp_nf;
 extern compop_func op_a40_0_comp_nf;
 extern compop_func op_a50_0_comp_nf;
 extern compop_func op_a58_0_comp_nf;
@@ -2251,6 +2311,24 @@ extern compop_func op_57e8_0_comp_nf;
 extern compop_func op_57f0_0_comp_nf;
 extern compop_func op_57f8_0_comp_nf;
 extern compop_func op_57f9_0_comp_nf;
+extern compop_func op_58c0_0_comp_nf;
+extern compop_func op_58c8_0_comp_nf;
+extern compop_func op_58d0_0_comp_nf;
+extern compop_func op_58d8_0_comp_nf;
+extern compop_func op_58e0_0_comp_nf;
+extern compop_func op_58e8_0_comp_nf;
+extern compop_func op_58f0_0_comp_nf;
+extern compop_func op_58f8_0_comp_nf;
+extern compop_func op_58f9_0_comp_nf;
+extern compop_func op_59c0_0_comp_nf;
+extern compop_func op_59c8_0_comp_nf;
+extern compop_func op_59d0_0_comp_nf;
+extern compop_func op_59d8_0_comp_nf;
+extern compop_func op_59e0_0_comp_nf;
+extern compop_func op_59e8_0_comp_nf;
+extern compop_func op_59f0_0_comp_nf;
+extern compop_func op_59f8_0_comp_nf;
+extern compop_func op_59f9_0_comp_nf;
 extern compop_func op_5ac0_0_comp_nf;
 extern compop_func op_5ac8_0_comp_nf;
 extern compop_func op_5ad0_0_comp_nf;
@@ -2310,6 +2388,7 @@ extern compop_func op_6001_0_comp_nf;
 extern compop_func op_60ff_0_comp_nf;
 extern compop_func op_6100_0_comp_nf;
 extern compop_func op_6101_0_comp_nf;
+extern compop_func op_61ff_0_comp_nf;
 extern compop_func op_6200_0_comp_nf;
 extern compop_func op_6201_0_comp_nf;
 extern compop_func op_62ff_0_comp_nf;
@@ -2756,6 +2835,13 @@ extern compop_func op_e098_0_comp_nf;
 extern compop_func op_e0a0_0_comp_nf;
 extern compop_func op_e0a8_0_comp_nf;
 extern compop_func op_e0b8_0_comp_nf;
+extern compop_func op_e0d0_0_comp_nf;
+extern compop_func op_e0d8_0_comp_nf;
+extern compop_func op_e0e0_0_comp_nf;
+extern compop_func op_e0e8_0_comp_nf;
+extern compop_func op_e0f0_0_comp_nf;
+extern compop_func op_e0f8_0_comp_nf;
+extern compop_func op_e0f9_0_comp_nf;
 extern compop_func op_e100_0_comp_nf;
 extern compop_func op_e108_0_comp_nf;
 extern compop_func op_e118_0_comp_nf;
@@ -2774,6 +2860,41 @@ extern compop_func op_e198_0_comp_nf;
 extern compop_func op_e1a0_0_comp_nf;
 extern compop_func op_e1a8_0_comp_nf;
 extern compop_func op_e1b8_0_comp_nf;
+extern compop_func op_e1d0_0_comp_nf;
+extern compop_func op_e1d8_0_comp_nf;
+extern compop_func op_e1e0_0_comp_nf;
+extern compop_func op_e1e8_0_comp_nf;
+extern compop_func op_e1f0_0_comp_nf;
+extern compop_func op_e1f8_0_comp_nf;
+extern compop_func op_e1f9_0_comp_nf;
+extern compop_func op_e2d0_0_comp_nf;
+extern compop_func op_e2d8_0_comp_nf;
+extern compop_func op_e2e0_0_comp_nf;
+extern compop_func op_e2e8_0_comp_nf;
+extern compop_func op_e2f0_0_comp_nf;
+extern compop_func op_e2f8_0_comp_nf;
+extern compop_func op_e2f9_0_comp_nf;
+extern compop_func op_e3d0_0_comp_nf;
+extern compop_func op_e3d8_0_comp_nf;
+extern compop_func op_e3e0_0_comp_nf;
+extern compop_func op_e3e8_0_comp_nf;
+extern compop_func op_e3f0_0_comp_nf;
+extern compop_func op_e3f8_0_comp_nf;
+extern compop_func op_e3f9_0_comp_nf;
+extern compop_func op_e6d0_0_comp_nf;
+extern compop_func op_e6d8_0_comp_nf;
+extern compop_func op_e6e0_0_comp_nf;
+extern compop_func op_e6e8_0_comp_nf;
+extern compop_func op_e6f0_0_comp_nf;
+extern compop_func op_e6f8_0_comp_nf;
+extern compop_func op_e6f9_0_comp_nf;
+extern compop_func op_e7d0_0_comp_nf;
+extern compop_func op_e7d8_0_comp_nf;
+extern compop_func op_e7e0_0_comp_nf;
+extern compop_func op_e7e8_0_comp_nf;
+extern compop_func op_e7f0_0_comp_nf;
+extern compop_func op_e7f8_0_comp_nf;
+extern compop_func op_e7f9_0_comp_nf;
 extern compop_func op_f600_0_comp_nf;
 extern compop_func op_f608_0_comp_nf;
 extern compop_func op_f610_0_comp_nf;

src/main.cpp

@@ -529,6 +529,8 @@ static int real_main2 (int argc, TCHAR **argv)
   	currprefs.produce_sound = 0;
   }
 
+  inputdevice_init();
+
   changed_prefs = currprefs;
   no_gui = ! currprefs.start_gui;
   if (restart_program == 2)
@@ -552,7 +554,7 @@ static int real_main2 (int argc, TCHAR **argv)
     update_display(&currprefs);
   }
 
-  inputdevice_init();
+
 
   fixup_prefs (&currprefs);
   changed_prefs = currprefs;

src/md-pandora/m68k.h

@@ -149,7 +149,7 @@ struct flag_struct {
 #define IOR_CZNV(X)     (regs.ccrflags.nzcv |= (X))
 #define SET_CZNV(X)     (regs.ccrflags.nzcv = (X))
 
-#define COPY_CARRY()      (regs.ccrflags.x = (regs.ccrflags.nzcv)>>29)
+#define COPY_CARRY()      (regs.ccrflags.x = ((regs.ccrflags.nzcv >> 29) & 1))
 
 static inline int cctrue(struct flag_struct &flags, int cc)
 {

src/od-gles/gles_gfx.cpp

@@ -215,9 +215,11 @@ int check_prefs_changed_gfx (void)
     changed = 1;
   }
   if (currprefs.leds_on_screen != changed_prefs.leds_on_screen ||
+      currprefs.pandora_hide_idle_led != changed_prefs.pandora_hide_idle_led ||
       currprefs.pandora_vertical_offset != changed_prefs.pandora_vertical_offset)	
   {
     currprefs.leds_on_screen = changed_prefs.leds_on_screen;
+    currprefs.pandora_hide_idle_led = changed_prefs.pandora_hide_idle_led;
     currprefs.pandora_vertical_offset = changed_prefs.pandora_vertical_offset;
     changed = 1;
   }
@@ -276,7 +278,7 @@ void flush_screen ()
 
   last_synctime = read_processor_time();
   
-  if(last_synctime - next_synctime > time_per_frame - 1000)
+  if(last_synctime - next_synctime > time_per_frame - 1000 || next_synctime < start)
     adjust_idletime(0);
   else
     adjust_idletime(next_synctime - start);

src/od-pandora/gui/Navigation.cpp

@@ -37,7 +37,7 @@ static NavigationMap navMap[] =
   { "Display",        "sldWidth",       "sldWidth",       "Hard drives",    "Sound" },
   { "Sound",          "sndDisable",     "sndDisable",     "Display",        "Input" },
   { "Input",          "cboCtrlConfig",  "cboCtrlConfig",  "Sound",          "Miscellaneous" },
-  { "Miscellaneous",  "Status Line",    "Status Line",    "Input",          "Savestates" },
+  { "Miscellaneous",  "StatusLine",     "StatusLine",     "Input",          "Savestates" },
   { "Savestates",     "State0",         "State0",         "Miscellaneous",  "Reset" },
   { "Reset",          "Start",          "Quit",           "Savestates",     "Paths" },
   { "Quit",           "Reset",          "Start",        "Savestates",     "Paths" },
@@ -216,8 +216,9 @@ static NavigationMap navMap[] =
 #endif
 
 // PanelMisc
-  { "Status Line",    "Miscellaneous",  "Miscellaneous",  "BSDSocket",      "ShowGUI" },
+  { "StatusLine",     "Miscellaneous",  "Miscellaneous",  "BSDSocket",      "HideIdle" },
-  { "ShowGUI",        "Miscellaneous",  "Miscellaneous",  "Status Line",    "BSDSocket" },
+  { "HideIdle",       "Miscellaneous",  "Miscellaneous",  "StatusLine",     "ShowGUI" },
+  { "ShowGUI",        "Miscellaneous",  "Miscellaneous",  "HideIdle",      "BSDSocket" },
   { "BSDSocket",      "Miscellaneous",  "Miscellaneous",  "ShowGUI",      "Status Line" },
   
 // PanelSavestate

src/od-pandora/gui/PanelMisc.cpp

@@ -21,6 +21,7 @@
 
 
 static gcn::UaeCheckBox* chkStatusLine;
+static gcn::UaeCheckBox* chkHideIdleLed;
 static gcn::UaeCheckBox* chkShowGUI;
 #ifdef PANDORA_SPECIFIC
 static gcn::Label* lblPandoraSpeed;
@@ -38,6 +39,9 @@ class MiscActionListener : public gcn::ActionListener
       if (actionEvent.getSource() == chkStatusLine)
         changed_prefs.leds_on_screen = chkStatusLine->isSelected();
       
+      else if (actionEvent.getSource() == chkHideIdleLed)
+        changed_prefs.pandora_hide_idle_led = chkHideIdleLed->isSelected();
+
       else if (actionEvent.getSource() == chkShowGUI)
         changed_prefs.start_gui = chkShowGUI->isSelected();
 
@@ -67,8 +71,13 @@ void InitPanelMisc(const struct _ConfigCategory& category)
   miscActionListener = new MiscActionListener();
 
   chkStatusLine = new gcn::UaeCheckBox("Status Line");
+  chkStatusLine->setId("StatusLine");
   chkStatusLine->addActionListener(miscActionListener);
 
+  chkHideIdleLed = new gcn::UaeCheckBox("Hide idle led");
+  chkHideIdleLed->setId("HideIdle");
+  chkHideIdleLed->addActionListener(miscActionListener);
+
   chkShowGUI = new gcn::UaeCheckBox("Show GUI on startup");
   chkShowGUI->setId("ShowGUI");
   chkShowGUI->addActionListener(miscActionListener);
@@ -94,6 +103,8 @@ void InitPanelMisc(const struct _ConfigCategory& category)
   int posY = DISTANCE_BORDER;
   category.panel->add(chkStatusLine, DISTANCE_BORDER, posY);
   posY += chkStatusLine->getHeight() + DISTANCE_NEXT_Y;
+  category.panel->add(chkHideIdleLed, DISTANCE_BORDER, posY);
+  posY += chkHideIdleLed->getHeight() + DISTANCE_NEXT_Y;
   category.panel->add(chkShowGUI, DISTANCE_BORDER, posY);
   posY += chkShowGUI->getHeight() + DISTANCE_NEXT_Y;
 #ifdef PANDORA_SPECIFIC
@@ -104,6 +115,7 @@ void InitPanelMisc(const struct _ConfigCategory& category)
 #endif
   category.panel->add(chkBSDSocket, DISTANCE_BORDER, posY);
   posY += chkBSDSocket->getHeight() + DISTANCE_NEXT_Y;
+  
   RefreshPanelMisc();
 }
 
@@ -111,6 +123,7 @@ void InitPanelMisc(const struct _ConfigCategory& category)
 void ExitPanelMisc(void)
 {
   delete chkStatusLine;
+  delete chkHideIdleLed;
   delete chkShowGUI;
 #ifdef PANDORA_SPECIFIC
   delete lblPandoraSpeed;
@@ -127,6 +140,7 @@ void RefreshPanelMisc(void)
   char tmp[20];
 
   chkStatusLine->setSelected(changed_prefs.leds_on_screen);
+  chkHideIdleLed->setSelected(changed_prefs.pandora_hide_idle_led);
   chkShowGUI->setSelected(changed_prefs.start_gui);
 #ifdef PANDORA_SPECIFIC
   sldPandoraSpeed->setValue(changed_prefs.pandora_cpu_speed);

src/od-pandora/pandora.cpp

@@ -136,6 +136,7 @@ static bool slow_mouse = false;
 
 static bool cpuSpeedChanged = false;
 static int lastCpuSpeed = 600;
+int defaultCpuSpeed = 600;
 
 
 extern "C" int main( int argc, char *argv[] );
@@ -311,7 +312,8 @@ void target_default_options (struct uae_prefs *p, int type)
 {
   p->pandora_horizontal_offset = 0;
   p->pandora_vertical_offset = 0;
-  p->pandora_cpu_speed = 600;
+  p->pandora_cpu_speed = defaultCpuSpeed;
+  p->pandora_hide_idle_led = 0;
   
   p->pandora_joyConf = 0;
   p->pandora_joyPort = 2;
@@ -346,6 +348,7 @@ void target_default_options (struct uae_prefs *p, int type)
 void target_save_options (struct zfile *f, struct uae_prefs *p)
 {
   cfgfile_write (f, "pandora.cpu_speed", "%d", p->pandora_cpu_speed);
+  cfgfile_write (f, "pandora.hide_idle_led", "%d", p->pandora_hide_idle_led);
   cfgfile_write (f, "pandora.joy_conf", "%d", p->pandora_joyConf);
   cfgfile_write (f, "pandora.joy_port", "%d", p->pandora_joyPort);
   cfgfile_write (f, "pandora.tap_delay", "%d", p->pandora_tapDelay);
@@ -378,6 +381,7 @@ TCHAR *target_expand_environment (const TCHAR *path)
 int target_parse_option (struct uae_prefs *p, const char *option, const char *value)
 {
   int result = (cfgfile_intval (option, value, "cpu_speed", &p->pandora_cpu_speed, 1)
+    || cfgfile_intval (option, value, "hide_idle_led", &p->pandora_hide_idle_led, 1)
     || cfgfile_intval (option, value, "joy_conf", &p->pandora_joyConf, 1)
     || cfgfile_intval (option, value, "joy_port", &p->pandora_joyPort, 1)
     || cfgfile_intval (option, value, "tap_delay", &p->pandora_tapDelay, 1)
@@ -748,38 +752,49 @@ void setCpuSpeed()
 			system("sudo /usr/pandora/scripts/op_lcdrate.sh 50");
 	}
 }
+int getDefaultCpuSpeed(void)
+{
+#ifdef PANDORA_SPECIFIC
+  int speed = 600;
+  FILE* f = fopen ("/etc/pandora/conf/cpu.conf", "rt");
+  if(f)
+  {
+    char line[128];
+    for(int i=0; i<6; ++i)
+    {
+      fscanf(f, "%s\n", &line);
+      if(strncmp(line, "default:", 8) == 0)
+      {
+        int value = 0;
+        sscanf(line, "default:%d", &value);
+        if(value > 500 && value < 1200)
+        {
+          speed = value;
+        }
+      }
+    }
+    fclose(f);
+  }
+  return speed;
+#else
+  return;
+#endif
+}
 
 
 void resetCpuSpeed(void)
 {
-#ifndef PANDORA_SPECIFIC
+#ifdef PANDORA_SPECIFIC
-  return;
-#endif
   if(cpuSpeedChanged)
   {
-    FILE* f = fopen ("/etc/pandora/conf/cpu.conf", "rt");
+    lastCpuSpeed = defaultCpuSpeed - 10;
-    if(f)
+    currprefs.pandora_cpu_speed = changed_prefs.pandora_cpu_speed = defaultCpuSpeed;
-    {
+    setCpuSpeed();
-      char line[128];
+    printf("CPU speed reset to %d\n", defaultCpuSpeed);
-      for(int i=0; i<6; ++i)
-      {
-        fscanf(f, "%s\n", &line);
-        if(strncmp(line, "default:", 8) == 0)
-        {
-          int value = 0;
-          sscanf(line, "default:%d", &value);
-          if(value > 500 && value < 1200)
-          {
-            lastCpuSpeed = value - 10;
-            currprefs.pandora_cpu_speed = changed_prefs.pandora_cpu_speed = value;
-            setCpuSpeed();
-            printf("CPU speed reset to %d\n", value);
-          }
-        }
-      }
-      fclose(f);
-    }
   }
+#else
+  return;
+#endif
 }
 
 
@@ -808,6 +823,8 @@ int main (int argc, char *argv[])
 {
   struct sigaction action;
 
+  defaultCpuSpeed = getDefaultCpuSpeed();
+  
   // Get startup path
 	getcwd(start_path_data, MAX_DPATH);
 	loadAdfDir();

src/od-pandora/pandora_gfx.cpp

@@ -269,9 +269,11 @@ int check_prefs_changed_gfx (void)
     changed = 1;
   }
   if (currprefs.leds_on_screen != changed_prefs.leds_on_screen ||
+      currprefs.pandora_hide_idle_led != changed_prefs.pandora_hide_idle_led ||
       currprefs.pandora_vertical_offset != changed_prefs.pandora_vertical_offset)	
   {
     currprefs.leds_on_screen = changed_prefs.leds_on_screen;
+    currprefs.pandora_hide_idle_led = changed_prefs.pandora_hide_idle_led;
     currprefs.pandora_vertical_offset = changed_prefs.pandora_vertical_offset;
     changed = 1;
   }
@@ -329,7 +331,7 @@ void flush_screen ()
   if(!screen_is_picasso)
   	gfxvidinfo.bufmem = (uae_u8 *)prSDLScreen->pixels;
   
-  if(last_synctime - next_synctime > time_per_frame - 1000)
+  if(last_synctime - next_synctime > time_per_frame - 1000 || next_synctime < start)
     adjust_idletime(0);
   else
     adjust_idletime(next_synctime - start);

src/od-pandora/pandora_mem.cpp

@@ -17,6 +17,9 @@ uae_u32 natmem_size;
 static uae_u64 totalAmigaMemSize;
 #define MAXAMIGAMEM 0x6000000 // 64 MB (16 MB for standard Amiga stuff, 16 MG RTG, 64 MB Z3 fast)
 
+/* JIT can access few bytes outside of memory block of it executes code at the very end of memory block */
+#define BARRIER 32
+
 static uae_u8* additional_mem = (uae_u8*) MAP_FAILED;
 #define ADDITIONAL_MEMSIZE (128 + 16) * 1024 * 1024
 
@@ -56,7 +59,7 @@ void alloc_AmigaMem(void)
 		write_log("Can't allocate 16M of virtual address space!?\n");
     abort();
 	}
-  additional_mem = (uae_u8*) mmap(natmem_offset + 0x10000000, ADDITIONAL_MEMSIZE,
+  additional_mem = (uae_u8*) mmap(natmem_offset + 0x10000000, ADDITIONAL_MEMSIZE + BARRIER,
     PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
   if(additional_mem != MAP_FAILED)
   {
@@ -70,7 +73,7 @@ void alloc_AmigaMem(void)
   
   // Second attempt: allocate huge memory block for entire area
   natmem_size = ADDITIONAL_MEMSIZE + 256 * 1024 * 1024;
-  natmem_offset = (uae_u8*)valloc (natmem_size);
+  natmem_offset = (uae_u8*)valloc (natmem_size + BARRIER);
   if(natmem_offset)
   {
     // Allocation successful
@@ -95,11 +98,11 @@ void alloc_AmigaMem(void)
 		natmem_size = 16 * 1024 * 1024;
 
 	write_log("Total physical RAM %lluM. Attempting to reserve: %uM.\n", total >> 20, natmem_size >> 20);
-	natmem_offset = (uae_u8*)valloc (natmem_size);
+	natmem_offset = (uae_u8*)valloc (natmem_size + BARRIER);
 
 	if (!natmem_offset) {
 		for (;;) {
-			natmem_offset = (uae_u8*)valloc (natmem_size);
+			natmem_offset = (uae_u8*)valloc (natmem_size + BARRIER);
 			if (natmem_offset)
 				break;
 			natmem_size -= 16 * 1024 * 1024;

src/od-pandora/pandora_rp9.cpp

@@ -6,6 +6,7 @@
 #include "options.h"
 #include "gui.h"
 #include "disk.h"
+#include "fsdb.h"
 #include "memory.h"
 #include "newcpu.h"
 #include "custom.h"
@@ -417,6 +418,8 @@ static void extract_media(struct uae_prefs *p, unzFile uz, xmlNode *node)
                   if(readsize == file_info.uncompressed_size)
                   {
                     char target_file[MAX_DPATH];
+                    if(!my_existsdir(rp9tmp_path))
+                      my_mkdir(rp9tmp_path);
                     snprintf(target_file, MAX_DPATH, "%s%s", rp9tmp_path, content);
                     FILE *f = fopen(target_file, "wb");
                     if(f != NULL)

src/od-rasp/rasp_gfx.cpp

@@ -317,9 +317,11 @@ int check_prefs_changed_gfx (void)
     changed = 1;
   }
   if (currprefs.leds_on_screen != changed_prefs.leds_on_screen ||
+      currprefs.pandora_hide_idle_led != changed_prefs.pandora_hide_idle_led ||
       currprefs.pandora_vertical_offset != changed_prefs.pandora_vertical_offset)	
   {
     currprefs.leds_on_screen = changed_prefs.leds_on_screen;
+    currprefs.pandora_hide_idle_led = changed_prefs.pandora_hide_idle_led;
     currprefs.pandora_vertical_offset = changed_prefs.pandora_vertical_offset;
     changed = 1;
   }
@@ -406,7 +408,7 @@ void flush_screen ()
 
   last_synctime = read_processor_time();
   
-  if(last_synctime - next_synctime > time_per_frame - 1000)
+  if(last_synctime - next_synctime > time_per_frame - 1000 || next_synctime < start)
     adjust_idletime(0);
   else
     adjust_idletime(next_synctime - start);