From: Toni Wilen <twilen@winuae.net>
Date: Thu, 28 Apr 2022 18:42:15 +0000 (+0300)
Subject: Cycle counting is now 64-bit
X-Git-Tag: 41000~249
X-Git-Url: https://git.unchartedbackwaters.co.uk/w/?a=commitdiff_plain;h=7d22bbc6484b16af147d3c2f0b3f5baedb23a925;p=francis%2Fwinuae.git

Cycle counting is now 64-bit
---

diff --git a/blitter.cpp b/blitter.cpp
index f10c7675..7815cf71 100644
--- a/blitter.cpp
+++ b/blitter.cpp
@@ -89,8 +89,8 @@ static int blitter_hcounter;
 static int blitter_vcounter;
 #endif
 
-static long blit_firstline_cycles;
-static long blit_first_cycle;
+static evt_t blit_firstline_cycles;
+static evt_t blit_first_cycle;
 static int blit_last_cycle, blit_dmacount, blit_cyclecount;
 static int blit_linecycles, blit_extracycles;
 static int blit_faulty;
@@ -429,6 +429,7 @@ static void blitter_end(void)
 	if (log_blitter & 1) {
 		write_log(_T("cycles %d, missed %d, total %d\n"),
 			blit_totalcyclecounter, blit_misscyclecounter, blit_totalcyclecounter + blit_misscyclecounter);
+
 	}
 	blt_info.blitter_dangerous_bpl = 0;
 }
@@ -1976,7 +1977,7 @@ void maybe_blit (int hpos, int hack)
 		goto end;
 	}
 
-	if (hack == 1 && (int)get_cycles() - (int)blit_firstline_cycles < 0)
+	if (hack == 1 && get_cycles() < blit_firstline_cycles)
 		goto end;
 
 	blitter_handler(0);
@@ -2013,7 +2014,7 @@ int blitnasty (void)
 	}
 	if (blit_last_cycle >= blit_cyclecount && blit_dmacount == blit_cyclecount)
 		return 0;
-	cycles = (get_cycles() - blit_first_cycle) / CYCLE_UNIT;
+	cycles = int((get_cycles() - blit_first_cycle) / CYCLE_UNIT);
 	ccnt = 0;
 	while (blit_last_cycle + blit_cyclecount < cycles) {
 		ccnt += blit_dmacount;
@@ -2204,6 +2205,7 @@ uae_u8 *restore_blitter_new(uae_u8 *src)
 	restore_u8();
 	restore_u8();
 	restore_u8();
+	restore_u8();
 
 	if (restore_u16() != 0x1234) {
 		write_log(_T("blitter state restore error\n"));
@@ -2277,12 +2279,12 @@ uae_u8 *save_blitter_new(int *len, uae_u8 *dstptr)
 			blitter_dump();
 	}
 
-	save_u32(blit_first_cycle);
+	save_u32((uae_u32)blit_first_cycle);
 	save_u32(blit_last_cycle);
 	save_u32(blit_waitcyclecounter);
 	save_u32(0); //(blit_startcycles);
 	save_u32(blit_maxcyclecounter);
-	save_u32(blit_firstline_cycles);
+	save_u32((uae_u32)blit_firstline_cycles);
 	save_u32(blit_cyclecounter);
 	save_u32(blit_slowdown);
 	save_u32(blit_misscyclecounter);
@@ -2337,6 +2339,9 @@ uae_u8 *save_blitter_new(int *len, uae_u8 *dstptr)
 	save_u8(blt_info.blit_finald);
 	save_u8(blit_ovf);
 
+	save_u32(blit_first_cycle >> 32);
+	save_u32(blit_firstline_cycles >> 32);
+
 	*len = dst - dstbak;
 	return dstbak;
 }
diff --git a/custom.cpp b/custom.cpp
index 564a21ab..f5cfa1ae 100644
--- a/custom.cpp
+++ b/custom.cpp
@@ -117,8 +117,8 @@ extern float vsync_vblank, vsync_hblank;
 
 /* Events */
 
-uae_u32 vsync_cycles;
-static uae_u32 extra_cycle;
+evt_t vsync_cycles;
+static int extra_cycle;
 
 static int rpt_did_reset;
 struct ev eventtab[ev_max];
@@ -140,8 +140,8 @@ static bool lof_lace;
 static bool bplcon0_interlace_seen;
 static int scandoubled_line;
 static bool vsync_rendered, frame_rendered, frame_shown;
-static int vsynctimeperline;
-static int frameskiptime;
+static frame_time_t vsynctimeperline;
+static frame_time_t frameskiptime;
 static bool genlockhtoggle;
 static bool genlockvtoggle;
 static bool graphicsbuffer_retry;
@@ -322,7 +322,7 @@ static int vblank_hz_mult, vblank_hz_state;
 static struct chipset_refresh *stored_chipset_refresh;
 int doublescan;
 int programmedmode;
-int syncbase;
+frame_time_t syncbase;
 static int fmode_saved, fmode;
 uae_u16 beamcon0, new_beamcon0;
 uae_u16 bemcon0_hsync_mask, bemcon0_vsync_mask;
@@ -511,9 +511,11 @@ static int copper_enabled_thisline;
 /*
 * Statistics
 */
-unsigned long int frametime = 0, lastframetime = 0, timeframes = 0;
-unsigned long hsync_counter = 0, vsync_counter = 0;
-unsigned long int idletime;
+uae_u32 timeframes;
+evt_t frametime;
+frame_time_t lastframetime;
+uae_u32 hsync_counter, vsync_counter;
+frame_time_t idletime;
 int bogusframe;
 
 /* Recording of custom chip register changes.  */
@@ -7329,14 +7331,15 @@ static void DMACON(int hpos, uae_u16 v)
 	}
 }
 
-static int irq_forced, irq_delay;
+static int irq_forced;
+static evt_t irq_delay;
 
 void IRQ_forced(int lvl, int delay)
 {
 	irq_forced = lvl;
-	irq_delay = -1;
+	irq_delay = 0;
 	if (delay > 0 && currprefs.cpu_compatible) {
-		irq_delay = get_cycles() + irq_delay * CYCLE_UNIT;
+		irq_delay = get_cycles() + delay * CYCLE_UNIT;
 	}
 	doint();
 }
@@ -7345,7 +7348,7 @@ int intlev(void)
 {
 	if (irq_forced) {
 		int lvl = irq_forced;
-		if (irq_delay == -1 || ((int)get_cycles()) - irq_delay > 0) {
+		if (irq_delay == -1 || get_cycles() > irq_delay) {
 			irq_forced = 0;
 			irq_delay = -1;
 		}
@@ -10193,10 +10196,10 @@ void init_hardware_for_drawing_frame(void)
 	next_sprite_forced = 1;
 }
 
-static int rpt_vsync(int adjust)
+static frame_time_t rpt_vsync(int adjust)
 {
 	frame_time_t curr_time = read_processor_time();
-	int v = curr_time - vsyncwaittime + adjust;
+	frame_time_t v = curr_time - vsyncwaittime + adjust;
 	if (v > syncbase || v < -syncbase) {
 		vsyncmintime = vsyncmaxtime = vsyncwaittime = curr_time;
 		v = 0;
@@ -10244,10 +10247,10 @@ static bool crender_screen(int monid, int mode, bool immediate)
 #define MAVG_MAX_SIZE 128
 struct mavg_data
 {
-	int values[MAVG_MAX_SIZE];
+	frame_time_t values[MAVG_MAX_SIZE];
 	int size;
 	int offset;
-	int mavg;
+	frame_time_t mavg;
 };
 
 static void mavg_clear (struct mavg_data *md)
@@ -10257,7 +10260,7 @@ static void mavg_clear (struct mavg_data *md)
 	md->mavg = 0;
 }
 
-static int mavg(struct mavg_data *md, int newval, int size)
+static frame_time_t mavg(struct mavg_data *md, frame_time_t newval, int size)
 {
 	if (md->size < size) {
 		md->values[md->size++] = newval;
@@ -10288,7 +10291,7 @@ static bool framewait(void)
 	events_reset_syncline();
 
 	static struct mavg_data ma_frameskipt;
-	int frameskipt_avg = mavg(&ma_frameskipt, frameskiptime, MAVG_VSYNC_SIZE);
+	frame_time_t frameskipt_avg = mavg(&ma_frameskipt, frameskiptime, MAVG_VSYNC_SIZE);
 
 	frameskiptime = 0;
 
@@ -10296,7 +10299,7 @@ static bool framewait(void)
 
 		static struct mavg_data ma_legacy;
 		static frame_time_t vsync_time;
-		int t;
+		frame_time_t t;
 
 		curr_time = read_processor_time();
 		vsyncwaittime = vsyncmaxtime = curr_time + vsynctimebase;
@@ -10319,7 +10322,7 @@ static bool framewait(void)
 
 		maybe_process_pull_audio();
 
-		int legacy_avg = mavg(&ma_legacy, t, MAVG_VSYNC_SIZE);
+		frame_time_t legacy_avg = mavg(&ma_legacy, t, MAVG_VSYNC_SIZE);
 		if (t > legacy_avg) {
 			legacy_avg = t;
 		}
@@ -10368,7 +10371,7 @@ static bool framewait(void)
 	status = 1;
 
 	int clockadjust = 0;
-	int vstb = vsynctimebase;
+	frame_time_t vstb = vsynctimebase;
 
 	if (currprefs.m68k_speed < 0 && !cpu_sleepmode && !currprefs.cpu_memory_cycle_exact) {
 
@@ -10379,7 +10382,7 @@ static bool framewait(void)
 			// this delay can safely overshoot frame time by 1-2 ms, following code will compensate for it.
 			for (;;) {
 				curr_time = read_processor_time();
-				if ((int)vsyncwaittime - (int)curr_time <= 0 || (int)vsyncwaittime - (int)curr_time > 2 * vsynctimebase) {
+				if (vsyncwaittime - curr_time <= 0 || vsyncwaittime - curr_time > 2 * vsynctimebase) {
 					break;
 				}
 				rtg_vsynccheck ();
@@ -10393,8 +10396,8 @@ static bool framewait(void)
 		}
 
 		int max;
-		int adjust = 0;
-		if ((int)curr_time - (int)vsyncwaittime > 0 && (int)curr_time - (int)vsyncwaittime < vstb / 2) {
+		frame_time_t adjust = 0;
+		if (curr_time - vsyncwaittime > 0 && curr_time - vsyncwaittime < vstb / 2) {
 			adjust += curr_time - vsyncwaittime;
 		}
 		adjust += clockadjust;
@@ -10415,7 +10418,7 @@ static bool framewait(void)
 	
 	} else {
 
-		int t = 0;
+		frame_time_t t = 0;
 
 		start = read_processor_time();
 		if (!frame_rendered && !ad->picasso_on) {
@@ -12013,7 +12016,7 @@ static bool linesync_beam_vrr(void)
 				frame_time_t rpt;
 				for (;;) {
 					rpt = read_processor_time();
-					if ((int)rpt - (int)(vsyncmintime - vsynctimebase * 2 / 3) >= 0 || (int)rpt - (int)vsyncmintime < -2 * vsynctimebase)
+					if (rpt - (vsyncmintime - vsynctimebase * 2 / 3) >= 0 || rpt - vsyncmintime < -2 * vsynctimebase)
 						break;
 					maybe_process_pull_audio();
 					if (currprefs.m68k_speed < 0 && !was_syncline) {
@@ -12031,7 +12034,7 @@ static bool linesync_beam_vrr(void)
 
 				for (;;) {
 					rpt = read_processor_time();
-					if ((int)rpt - (int)vsyncmintime >= 0 || (int)rpt - (int)vsyncmintime < -2 * vsynctimebase)
+					if (rpt - vsyncmintime >= 0 || rpt - vsyncmintime < -2 * vsynctimebase)
 						break;
 					maybe_process_pull_audio();
 					if (currprefs.m68k_speed < 0 && !was_syncline) {
@@ -12042,7 +12045,7 @@ static bool linesync_beam_vrr(void)
 					target_spin(0);
 				}
 
-				if ((int)rpt - (int)vsyncmintime < vsynctimebase && (int)rpt - (int)vsyncmintime > -vsynctimebase) {
+				if (rpt - vsyncmintime < vsynctimebase && rpt - vsyncmintime > -vsynctimebase) {
 					vsyncmintime += vsynctimebase;
 				} else {
 					vsyncmintime = rpt + vsynctimebase;
@@ -12421,7 +12424,7 @@ static void hsync_handler_post(bool onvsync)
 			if (regs.stopped && currprefs.cpu_idle) {
 				// CPU in STOP state: sleep if enough time left.
 				frame_time_t rpt = read_processor_time();
-				while (vsync_isdone(NULL) <= 0 && (int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase) {
+				while (vsync_isdone(NULL) <= 0 && vsyncmintime - (rpt + vsynctimebase / 10) > 0 && vsyncmintime - rpt < vsynctimebase) {
 					maybe_process_pull_audio();
 //					if (!execute_other_cpu(rpt + vsynctimebase / 10)) {
 						if (cpu_sleep_millis(1) < 0)
@@ -12446,11 +12449,11 @@ static void hsync_handler_post(bool onvsync)
 			linecounter++;
 			events_reset_syncline();
 			if (vsync_isdone(NULL) <= 0 && !currprefs.turbo_emulation) {
-				if ((int)vsyncmaxtime - (int)vsyncmintime > 0) {
-					if ((int)vsyncwaittime - (int)vsyncmintime > 0) {
+				if (vsyncmaxtime - vsyncmintime > 0) {
+					if (vsyncwaittime - vsyncmintime > 0) {
 						frame_time_t rpt = read_processor_time();
 						/* Extra time left? Do some extra CPU emulation */
-						if ((int)vsyncmintime - (int)rpt > 0) {
+						if (vsyncmintime - rpt > 0) {
 							if (regs.stopped && currprefs.cpu_idle && sleeps_remaining > 0) {
 								// STOP STATE: sleep.
 								cpu_sleep_millis(1);
@@ -12486,7 +12489,7 @@ static void hsync_handler_post(bool onvsync)
 		if (audio_is_pull() > 0 && !currprefs.turbo_emulation) {
 			maybe_process_pull_audio();
 			frame_time_t rpt = read_processor_time();
-			while (audio_pull_buffer() > 1 && (!isvsync() || (vsync_isdone(NULL) <= 0 && (int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase))) {
+			while (audio_pull_buffer() > 1 && (!isvsync() || (vsync_isdone(NULL) <= 0 && vsyncmintime - (rpt + vsynctimebase / 10) > 0 && vsyncmintime - rpt < vsynctimebase))) {
 				cpu_sleep_millis(1);
 				maybe_process_pull_audio();
 				rpt = read_processor_time();
@@ -12498,7 +12501,7 @@ static void hsync_handler_post(bool onvsync)
 			if (vsync_isdone(NULL) <= 0 && !currprefs.turbo_emulation) {
 				frame_time_t rpt = read_processor_time();
 				// sleep if more than 2ms "free" time
-				while (vsync_isdone(NULL) <= 0 && (int)vsyncmintime - (int)(rpt + vsynctimebase / 10) > 0 && (int)vsyncmintime - (int)rpt < vsynctimebase) {
+				while (vsync_isdone(NULL) <= 0 && vsyncmintime - (rpt + vsynctimebase / 10) > 0 && vsyncmintime - rpt < vsynctimebase) {
 					maybe_process_pull_audio();
 //					if (!execute_other_cpu(rpt + vsynctimebase / 10)) {
 						if (cpu_sleep_millis(1) < 0)
@@ -14193,7 +14196,7 @@ uae_u8 *restore_custom_event_delay(uae_u8 *src)
 	int cnt = restore_u8();
 	for (int i = 0; i < cnt; i++) {
 		uae_u8 type = restore_u8();
-		evt e = restore_u64();
+		evt_t e = restore_u64();
 		uae_u32 data = restore_u32();
 		if (type == 1)
 			event2_newevent_xx(-1, e, data, send_interrupt_do);
@@ -14247,7 +14250,7 @@ uae_u8 *save_cycles(int *len, uae_u8 *dstptr)
 	save_u32(CYCLE_UNIT);
 	save_u64(get_cycles());
 	save_u32(extra_cycle);
-	write_log(_T("SAVECYCLES %08lX\n"), get_cycles());
+	write_log(_T("SAVECYCLES %08llX\n"), get_cycles());
 	*len = dst - dstbak;
 	return dstbak;
 }
@@ -14429,7 +14432,7 @@ static int dma_cycle(uaecptr addr, uae_u32 value, int *mode)
 
 static void sync_cycles(void)
 {
-	uae_u32 c;
+	evt_t c;
 	uae_u32 extra;
 
 	c = get_cycles();
@@ -14648,7 +14651,7 @@ void wait_cpu_cycle_write_ce020(uaecptr addr, int mode, uae_u32 v)
 
 }
 
-void do_cycles_ce(uae_u32 cycles)
+void do_cycles_ce(int cycles)
 {
 	cycles += extra_cycle;
 	while (cycles >= CYCLE_UNIT) {
@@ -14665,16 +14668,17 @@ void do_cycles_ce(uae_u32 cycles)
 	extra_cycle = cycles;
 }
 
-void do_cycles_ce020(uae_u32 cycles)
+void do_cycles_ce020(int cycles)
 {
-	uae_u32 c;
-	uae_u32 extra;
+	int c;
+	evt_t cc;
+	int extra;
 
 	if (!cycles) {
 		return;
 	}
-	c = get_cycles();
-	extra = c & (CYCLE_UNIT - 1);
+	cc = get_cycles();
+	extra = cc & (CYCLE_UNIT - 1);
 	if (extra) {
 		extra = CYCLE_UNIT - extra;
 		if (extra >= cycles) {
diff --git a/events.cpp b/events.cpp
index dbbc0c37..b5d818c5 100644
--- a/events.cpp
+++ b/events.cpp
@@ -22,17 +22,18 @@
 
 static const int pissoff_nojit_value = 256 * CYCLE_UNIT;
 
-uae_u32 event_cycles, nextevent, currcycle;
-int is_syncline, is_syncline_end;
+evt_t event_cycles, nextevent, currcycle;
+int is_syncline;
+frame_time_t is_syncline_end;
 int cycles_to_next_event;
 int max_cycles_to_next_event;
 int cycles_to_hsync_event;
-uae_u32 start_cycles;
+evt_t start_cycles;
 bool event_wait;
 
 frame_time_t vsyncmintime, vsyncmintimepre;
 frame_time_t vsyncmaxtime, vsyncwaittime;
-int vsynctimebase;
+frame_time_t vsynctimebase;
 int event2_count;
 
 static void events_fast(void)
@@ -50,15 +51,19 @@ void events_schedule (void)
 {
 	int i;
 
-	uae_u32 mintime = ~0L;
+	evt_t mintime = EVT_MAX;
 	for (i = 0; i < ev_max; i++) {
 		if (eventtab[i].active) {
-			uae_u32 eventtime = eventtab[i].evtime - currcycle;
+			evt_t eventtime = eventtab[i].evtime - currcycle;
 			if (eventtime < mintime)
 				mintime = eventtime;
 		}
 	}
-	nextevent = currcycle + mintime;
+	if (mintime < EVT_MAX) {
+		nextevent = currcycle + mintime;
+	} else {
+		nextevent = EVT_MAX;
+	}
 }
 
 extern void vsync_event_done(void);
@@ -202,8 +207,8 @@ static bool event_check_vsync(void)
 
 		// wait is_syncline_end
 		if (event_wait) {
-			int rpt = read_processor_time();
-			int v = rpt - is_syncline_end;
+			frame_time_t rpt = read_processor_time();
+			frame_time_t v = rpt - is_syncline_end;
 			if (v < 0) {
 #ifdef WITH_PPC
 				if (ppc_state) {
@@ -223,9 +228,9 @@ static bool event_check_vsync(void)
 
 		// wait is_syncline_end/vsyncmintime
 		if (event_wait) {
-			int rpt = read_processor_time();
-			int v = rpt - vsyncmintime;
-			int v2 = rpt - is_syncline_end;
+			frame_time_t rpt = read_processor_time();
+			frame_time_t v = rpt - vsyncmintime;
+			frame_time_t v2 = rpt - is_syncline_end;
 			if (v > vsynctimebase || v < -vsynctimebase) {
 				v = 0;
 			}
@@ -251,7 +256,7 @@ static bool event_check_vsync(void)
 	return false;
 }
 
-void do_cycles_slow (uae_u32 cycles_to_add)
+void do_cycles_slow (int cycles_to_add)
 {
 #ifdef WITH_X86
 #if 0
@@ -278,7 +283,7 @@ void do_cycles_slow (uae_u32 cycles_to_add)
 				return;
 		}
 
-		cycles_to_add -= nextevent - currcycle;
+		cycles_to_add -= (int)(nextevent - currcycle);
 		currcycle = nextevent;
 
 		for (int i = 0; i < ev_max; i++) {
@@ -303,8 +308,8 @@ void MISC_handler (void)
 	static bool dorecheck;
 	bool recheck;
 	int i;
-	evt mintime;
-	evt ct = get_cycles ();
+	evt_t mintime;
+	evt_t ct = get_cycles();
 	static int recursive;
 
 	if (recursive) {
@@ -316,7 +321,7 @@ void MISC_handler (void)
 	recheck = true;
 	while (recheck) {
 		recheck = false;
-		mintime = ~0L;
+		mintime = EVT_MAX;
 		for (i = 0; i < ev2_max; i++) {
 			if (eventtab2[i].active) {
 				if (eventtab2[i].evtime == ct) {
@@ -328,14 +333,14 @@ void MISC_handler (void)
 						dorecheck = false;
 					}
 				} else {
-					evt eventtime = eventtab2[i].evtime - ct;
+					evt_t eventtime = eventtab2[i].evtime - ct;
 					if (eventtime < mintime)
 						mintime = eventtime;
 				}
 			}
 		}
 	}
-	if (mintime != ~0UL) {
+	if (mintime < EVT_MAX) {
 		eventtab[ev_misc].active = true;
 		eventtab[ev_misc].oldcycles = ct;
 		eventtab[ev_misc].evtime = ct + mintime;
@@ -345,9 +350,9 @@ void MISC_handler (void)
 }
 
 
-void event2_newevent_xx (int no, evt t, uae_u32 data, evfunc2 func)
+void event2_newevent_xx (int no, evt_t t, uae_u32 data, evfunc2 func)
 {
-	evt et;
+	evt_t et;
 	static int next = ev2_misc;
 
 	et = t + get_cycles ();
@@ -366,12 +371,12 @@ void event2_newevent_xx (int no, evt t, uae_u32 data, evfunc2 func)
 			if (no == next) {
 				write_log (_T("out of event2's!\n"));
 				// execute most recent event immediately
-				evt mintime = ~0L;
+				evt_t mintime = EVT_MAX;
 				int minevent = -1;
-				evt ct = get_cycles();
+				evt_t ct = get_cycles();
 				for (int i = 0; i < ev2_max; i++) {
 					if (eventtab2[i].active) {
-						evt eventtime = eventtab2[i].evtime - ct;
+						evt_t eventtime = eventtab2[i].evtime - ct;
 						if (eventtime < mintime) {
 							mintime = eventtime;
 							minevent = i;
@@ -394,7 +399,7 @@ void event2_newevent_xx (int no, evt t, uae_u32 data, evfunc2 func)
 	MISC_handler ();
 }
 
-void event2_newevent_x_replace(evt t, uae_u32 data, evfunc2 func)
+void event2_newevent_x_replace(evt_t t, uae_u32 data, evfunc2 func)
 {
 	for (int i = 0; i < ev2_max; i++) {
 		if (eventtab2[i].active && eventtab2[i].handler == func) {
diff --git a/include/custom.h b/include/custom.h
index fa356ef8..aae817e8 100644
--- a/include/custom.h
+++ b/include/custom.h
@@ -67,7 +67,7 @@ extern void set_picasso_hack_rate(int hz);
 /* Set to 1 to leave out the current frame in average frame time calculation.
 * Useful if the debugger was active.  */
 extern int bogusframe;
-extern unsigned long int hsync_counter, vsync_counter;
+extern uae_u32 hsync_counter, vsync_counter;
 
 extern uae_u16 dmacon;
 extern uae_u16 intena, intreq, intreqr;
@@ -176,7 +176,8 @@ extern int display_reset;
 
 #define CYCLE_MASK 0x0f
 
-extern unsigned long frametime, timeframes;
+extern uae_u32 timeframes;
+extern evt_t frametime;
 extern uae_u16 htotal, vtotal, beamcon0, new_beamcon0;
 extern uae_u16 bemcon0_hsync_mask, bemcon0_vsync_mask;
 
@@ -243,7 +244,7 @@ STATIC_INLINE int GET_PLANES(uae_u16 bplcon0)
 }
 
 extern void fpscounter_reset(void);
-extern unsigned long idletime;
+extern frame_time_t idletime;
 extern int lightpen_x[2], lightpen_y[2];
 extern int lightpen_cx[2], lightpen_cy[2], lightpen_active, lightpen_enabled, lightpen_enabled2;
 
diff --git a/include/events.h b/include/events.h
index 403097b8..e29b463c 100644
--- a/include/events.h
+++ b/include/events.h
@@ -18,43 +18,44 @@
 
 #include "machdep/rpt.h"
 
+#define EVT_MAX 0x7fffffffffffffff
+
 extern frame_time_t vsyncmintime, vsyncmintimepre;
 extern frame_time_t vsyncmaxtime, vsyncwaittime;
-extern int vsynctimebase, syncbase;
-extern void reset_frame_rate_hack (void);
-extern uae_u32 vsync_cycles;
-extern uae_u32 start_cycles;
+extern frame_time_t vsynctimebase, syncbase;
+extern void reset_frame_rate_hack(void);
+extern evt_t vsync_cycles;
+extern evt_t start_cycles;
 extern int event2_count;
 extern bool event_wait;
 
-extern void compute_vsynctime (void);
-extern void init_eventtab (void);
-extern void do_cycles_ce (uae_u32 cycles);
-extern void do_cycles_ce020 (uae_u32 cycles);
-extern void events_schedule (void);
-extern void do_cycles_slow (uae_u32 cycles_to_add);
+extern void compute_vsynctime(void);
+extern void init_eventtab(void);
+extern void do_cycles_ce(int cycles);
+extern void do_cycles_ce020(int cycles);
+extern void events_schedule(void);
+extern void do_cycles_slow(int cycles_to_add);
 extern void events_reset_syncline(void);
 
 extern bool is_cycle_ce(uaecptr);
 
-extern uae_u32 currcycle, nextevent;
-extern int is_syncline, is_syncline_end;
+extern evt_t currcycle, nextevent;
+extern int is_syncline;
+extern evt_t is_syncline_end;
 typedef void (*evfunc)(void);
 typedef void (*evfunc2)(uae_u32);
 
-typedef unsigned int evt;
-
 struct ev
 {
     bool active;
-    evt evtime, oldcycles;
+	evt_t evtime, oldcycles;
     evfunc handler;
 };
 
 struct ev2
 {
     bool active;
-    evt evtime;
+	evt_t evtime;
     uae_u32 data;
     evfunc2 handler;
 };
@@ -70,7 +71,7 @@ enum {
 };
 
 extern int pissoff_value;
-extern uae_s32 pissoff;
+extern int pissoff;
 
 #define countdown pissoff
 #define do_cycles do_cycles_slow
@@ -93,17 +94,17 @@ STATIC_INLINE void cycles_do_special (void)
 	}
 }
 
-STATIC_INLINE void do_extra_cycles (uae_u32 cycles_to_add)
+STATIC_INLINE void do_extra_cycles(int cycles_to_add)
 {
 	pissoff -= cycles_to_add;
 }
 
-STATIC_INLINE uae_u32 get_cycles (void)
+STATIC_INLINE evt_t get_cycles(void)
 {
 	return currcycle;
 }
 
-STATIC_INLINE void set_cycles (uae_u32 x)
+STATIC_INLINE void set_cycles (evt_t x)
 {
 	currcycle = x;
 	eventtab[ev_hsync].oldcycles = x;
@@ -114,43 +115,43 @@ STATIC_INLINE void set_cycles (uae_u32 x)
 #endif
 }
 
-STATIC_INLINE int current_hpos_safe (void)
+STATIC_INLINE int current_hpos_safe(void)
 {
-    int hp = (get_cycles () - eventtab[ev_hsync].oldcycles) / CYCLE_UNIT;
+    int hp = (int)((get_cycles () - eventtab[ev_hsync].oldcycles)) / CYCLE_UNIT;
 	return hp;
 }
 
 extern int current_hpos(void);
 
-STATIC_INLINE bool cycles_in_range (uae_u32 endcycles)
+STATIC_INLINE bool cycles_in_range(evt_t endcycles)
 {
-	uae_s32 c = get_cycles ();
-	return (uae_s32)endcycles - c > 0;
+	evt_t c = get_cycles();
+	return endcycles > c;
 }
 
-extern void MISC_handler (void);
-extern void event2_newevent_xx (int no, evt t, uae_u32 data, evfunc2 func);
-extern void event2_newevent_x_replace(evt t, uae_u32 data, evfunc2 func);
+extern void MISC_handler(void);
+extern void event2_newevent_xx(int no, evt_t t, uae_u32 data, evfunc2 func);
+extern void event2_newevent_x_replace(evt_t t, uae_u32 data, evfunc2 func);
 
-STATIC_INLINE void event2_newevent_x (int no, evt t, uae_u32 data, evfunc2 func)
+STATIC_INLINE void event2_newevent_x(int no, evt_t t, uae_u32 data, evfunc2 func)
 {
-	if (((int)t) <= 0) {
-		func (data);
+	if (t <= 0) {
+		func(data);
 		return;
 	}
-	event2_newevent_xx (no, t * CYCLE_UNIT, data, func);
+	event2_newevent_xx(no, t * CYCLE_UNIT, data, func);
 }
 
-STATIC_INLINE void event2_newevent (int no, evt t, uae_u32 data)
+STATIC_INLINE void event2_newevent(int no, evt_t t, uae_u32 data)
 {
-	event2_newevent_x (no, t, data, eventtab2[no].handler);
+	event2_newevent_x(no, t, data, eventtab2[no].handler);
 }
-STATIC_INLINE void event2_newevent2 (evt t, uae_u32 data, evfunc2 func)
+STATIC_INLINE void event2_newevent2(evt_t t, uae_u32 data, evfunc2 func)
 {
-	event2_newevent_x (-1, t, data, func);
+	event2_newevent_x(-1, t, data, func);
 }
 
-STATIC_INLINE void event2_remevent (int no)
+STATIC_INLINE void event2_remevent(int no)
 {
 	eventtab2[no].active = 0;
 }
diff --git a/include/newcpu.h b/include/newcpu.h
index b7076c29..63746225 100644
--- a/include/newcpu.h
+++ b/include/newcpu.h
@@ -252,14 +252,14 @@ struct regstruct
 
 	uae_u32 prefetch040[CPU_PIPELINE_MAX];
 
-	int ce020endcycle;
-	int ce020startcycle;
-	int ce020prefetchendcycle;
+	evt_t ce020endcycle;
+	evt_t ce020startcycle;
+	evt_t ce020prefetchendcycle;
 
-	int ce020extracycles;
+	evt_t ce020extracycles;
 	bool ce020memcycle_data;
 	int ce020_tail;
-	frame_time_t ce020_tail_cycles;
+	evt_t ce020_tail_cycles;
 	int memory_waitstate_cycles;
 };
 
@@ -293,7 +293,7 @@ struct cputracestruct
 	int pipeline_stop;
 	uae_u16 read_buffer, write_buffer;
 
-	uae_u32 startcycles;
+	evt_t startcycles;
 	int needendcycles;
 	int memoryoffset;
 	int cyclecounter, cyclecounter_pre, cyclecounter_post;
@@ -321,7 +321,7 @@ STATIC_INLINE void set_special_exter(uae_u32 x)
 STATIC_INLINE void set_special (uae_u32 x)
 {
 	atomic_or(&regs.spcflags, x);
-	cycles_do_special ();
+	cycles_do_special();
 }
 
 STATIC_INLINE void unset_special (uae_u32 x)
@@ -647,9 +647,9 @@ extern void dfc_nommu_put_byte(uaecptr, uae_u32);
 extern void dfc_nommu_put_word(uaecptr, uae_u32);
 extern void dfc_nommu_put_long(uaecptr, uae_u32);
 
-extern void (*x_do_cycles)(uae_u32);
-extern void (*x_do_cycles_pre)(uae_u32);
-extern void (*x_do_cycles_post)(uae_u32, uae_u32);
+extern void (*x_do_cycles)(int);
+extern void (*x_do_cycles_pre)(int);
+extern void (*x_do_cycles_post)(int, uae_u32);
 
 extern uae_u32 REGPARAM3 x_get_disp_ea_020 (uae_u32 base, int idx) REGPARAM;
 extern uae_u32 REGPARAM3 x_get_disp_ea_ce020 (uae_u32 base, int idx) REGPARAM;
@@ -658,8 +658,8 @@ extern uae_u32 REGPARAM3 x_get_disp_ea_040(uae_u32 base, int idx) REGPARAM;
 extern uae_u32 REGPARAM3 x_get_bitfield (uae_u32 src, uae_u32 bdata[2], uae_s32 offset, int width) REGPARAM;
 extern void REGPARAM3 x_put_bitfield (uae_u32 dst, uae_u32 bdata[2], uae_u32 val, uae_s32 offset, int width) REGPARAM;
 
-extern void m68k_setstopped (void);
-extern void m68k_resumestopped (void);
+extern void m68k_setstopped(void);
+extern void m68k_resumestopped(void);
 extern void m68k_cancel_idle(void);
 
 extern uae_u32 REGPARAM3 get_disp_ea_020 (uae_u32 base, int idx) REGPARAM;
diff --git a/include/uae/time.h b/include/uae/time.h
index be43bd4f..0a9a9ed5 100644
--- a/include/uae/time.h
+++ b/include/uae/time.h
@@ -4,17 +4,15 @@
 #include "uae/types.h"
 
 /* frame_time_t is often cast to int in the code so we use int for now... */
-typedef uae_u32 uae_time_t;
+typedef uae_s64 uae_time_t;
 
 void uae_time_init(void);
 void uae_time_calibrate(void);
 uae_time_t uae_time(void);
 
-extern int syncbase;
-
 #ifdef _WIN32
 void uae_time_use_rdtsc(bool enable);
-uae_u32 read_system_time(void);
+uae_s64 read_system_time(void);
 #endif
 
 typedef uae_time_t frame_time_t;
@@ -24,4 +22,6 @@ static inline frame_time_t read_processor_time(void)
 	return uae_time();
 }
 
+extern frame_time_t syncbase;
+
 #endif /* UAE_TIME_H */
diff --git a/include/uae/types.h b/include/uae/types.h
index b7162f24..77052d30 100644
--- a/include/uae/types.h
+++ b/include/uae/types.h
@@ -89,4 +89,6 @@ typedef char TCHAR;
 #define TRUE (!FALSE)
 #endif
 
+typedef signed long long evt_t;
+
 #endif /* UAE_TYPES_H */
diff --git a/inputdevice.cpp b/inputdevice.cpp
index 179b07fb..919af243 100644
--- a/inputdevice.cpp
+++ b/inputdevice.cpp
@@ -161,7 +161,7 @@ static struct teststore testmode_data[TESTMODE_MAX];
 static struct teststore testmode_wait[TESTMODE_MAX];
 
 static int bouncy;
-static signed long bouncy_cycles;
+static frame_time_t bouncy_cycles;
 static int autopause;
 
 #define HANDLE_IE_FLAG_CANSTOPPLAYBACK 1
diff --git a/newcpu.cpp b/newcpu.cpp
index c3b5b47c..b65e258b 100644
--- a/newcpu.cpp
+++ b/newcpu.cpp
@@ -223,9 +223,9 @@ static uae_u32 (*x2_get_byte)(uaecptr);
 static void (*x2_put_long)(uaecptr,uae_u32);
 static void (*x2_put_word)(uaecptr,uae_u32);
 static void (*x2_put_byte)(uaecptr,uae_u32);
-static void (*x2_do_cycles)(uae_u32);
-static void (*x2_do_cycles_pre)(uae_u32);
-static void (*x2_do_cycles_post)(uae_u32, uae_u32);
+static void (*x2_do_cycles)(int);
+static void (*x2_do_cycles_pre)(int);
+static void (*x2_do_cycles_post)(int, uae_u32);
 
 uae_u32 (*x_prefetch)(int);
 uae_u32 (*x_next_iword)(void);
@@ -250,9 +250,9 @@ void (*x_cp_put_word)(uaecptr,uae_u32);
 void (*x_cp_put_byte)(uaecptr,uae_u32);
 uae_u32 (REGPARAM3 *x_cp_get_disp_ea_020)(uae_u32 base, int idx) REGPARAM;
 
-void (*x_do_cycles)(uae_u32);
-void (*x_do_cycles_pre)(uae_u32);
-void (*x_do_cycles_post)(uae_u32, uae_u32);
+void (*x_do_cycles)(int);
+void (*x_do_cycles_pre)(int);
+void (*x_do_cycles_post)(int, uae_u32);
 
 uae_u32(*x_phys_get_iword)(uaecptr);
 uae_u32(*x_phys_get_ilong)(uaecptr);
@@ -421,7 +421,7 @@ static bool check_trace (void)
 	x_do_cycles_pre = x2_do_cycles_pre;
 	x_do_cycles_post = x2_do_cycles_post;
 	set_x_cp_funcs();
-	write_log(_T("CPU tracer playback complete. STARTCYCLES=%08x NOWCYCLES=%08x\n"), cputrace.startcycles, get_cycles());
+	write_log(_T("CPU tracer playback complete. STARTCYCLES=%016llx NOWCYCLES=%016llx\n"), cputrace.startcycles, get_cycles());
 	cputrace.needendcycles = 1;
 	cpu_tracer = 0;
 	return true;
@@ -675,7 +675,7 @@ static void cputracefunc2_x_put_byte (uaecptr o, uae_u32 val)
 		write_log (_T("cputracefunc2_x_put_byte %d <> %d\n"), v, val);
 }
 
-static void cputracefunc_x_do_cycles (uae_u32 cycles)
+static void cputracefunc_x_do_cycles(int cycles)
 {
 	while (cycles >= CYCLE_UNIT) {
 		cputrace.cyclecounter += CYCLE_UNIT;
@@ -688,7 +688,7 @@ static void cputracefunc_x_do_cycles (uae_u32 cycles)
 	}
 }
 
-static void cputracefunc2_x_do_cycles (uae_u32 cycles)
+static void cputracefunc2_x_do_cycles(int cycles)
 {
 	if (cputrace.cyclecounter > cycles) {
 		cputrace.cyclecounter -= cycles;
@@ -702,7 +702,7 @@ static void cputracefunc2_x_do_cycles (uae_u32 cycles)
 		x_do_cycles (cycles);
 }
 
-static void cputracefunc_x_do_cycles_pre (uae_u32 cycles)
+static void cputracefunc_x_do_cycles_pre(int cycles)
 {
 	cputrace.cyclecounter_post = 0;
 	cputrace.cyclecounter_pre = 0;
@@ -719,7 +719,7 @@ static void cputracefunc_x_do_cycles_pre (uae_u32 cycles)
 }
 // cyclecounter_pre = how many cycles we need to SWALLOW
 // -1 = rerun whole access
-static void cputracefunc2_x_do_cycles_pre (uae_u32 cycles)
+static void cputracefunc2_x_do_cycles_pre (int cycles)
 {
 	if (cputrace.cyclecounter_pre == -1) {
 		cputrace.cyclecounter_pre = 0;
@@ -739,7 +739,7 @@ static void cputracefunc2_x_do_cycles_pre (uae_u32 cycles)
 		x_do_cycles (cycles);
 }
 
-static void cputracefunc_x_do_cycles_post (uae_u32 cycles, uae_u32 v)
+static void cputracefunc_x_do_cycles_post (int cycles, uae_u32 v)
 {
 	if (cputrace.memoryoffset < 1) {
 #if CPUTRACE_DEBUG
@@ -763,9 +763,9 @@ static void cputracefunc_x_do_cycles_post (uae_u32 cycles, uae_u32 v)
 	cputrace.cyclecounter_post = 0;
 }
 // cyclecounter_post = how many cycles we need to WAIT
-static void cputracefunc2_x_do_cycles_post (uae_u32 cycles, uae_u32 v)
+static void cputracefunc2_x_do_cycles_post (int cycles, uae_u32 v)
 {
-	uae_u32 c;
+	int c;
 	if (cputrace.cyclecounter_post) {
 		c = cputrace.cyclecounter_post;
 		cputrace.cyclecounter_post = 0;
@@ -777,15 +777,15 @@ static void cputracefunc2_x_do_cycles_post (uae_u32 cycles, uae_u32 v)
 		x_do_cycles (c);
 }
 
-static void do_cycles_post (uae_u32 cycles, uae_u32 v)
+static void do_cycles_post (int cycles, uae_u32 v)
 {
 	do_cycles (cycles);
 }
-static void do_cycles_ce_post (uae_u32 cycles, uae_u32 v)
+static void do_cycles_ce_post (int cycles, uae_u32 v)
 {
 	do_cycles_ce (cycles);
 }
-static void do_cycles_ce020_post (uae_u32 cycles, uae_u32 v)
+static void do_cycles_ce020_post (int cycles, uae_u32 v)
 {
 	do_cycles_ce020 (cycles);
 }
@@ -979,10 +979,15 @@ static void set_x_funcs (void)
 				x_get_byte = get_byte_dc030;
 			}
 		}
-		x_do_cycles = do_cycles;
-		x_do_cycles_pre = do_cycles;
-		x_do_cycles_post = do_cycles_post;
-
+		if (currprefs.cpu_cycle_exact) {
+			x_do_cycles = do_cycles_ce020;
+			x_do_cycles_pre = do_cycles_ce020;
+			x_do_cycles_post = do_cycles_ce020_post;
+		} else {
+			x_do_cycles = do_cycles;
+			x_do_cycles_pre = do_cycles;
+			x_do_cycles_post = do_cycles_post;
+		}
 	} else if (currprefs.cpu_model < 68020) {
 		// 68000/010
 		if (currprefs.cpu_cycle_exact) {
@@ -2033,15 +2038,24 @@ static void update_68k_cycles (void)
 	if (currprefs.m68k_speed == 0) { // approximate
 		cycles_mult = CYCLES_DIV;
 		if (currprefs.cpu_model >= 68040) {
-			cycles_mult = CYCLES_DIV / 12;
+			if (currprefs.mmu_model) {
+				cycles_mult = CYCLES_DIV / 20;
+			} else {
+				cycles_mult = CYCLES_DIV / 12;
+			}
 		} else if (currprefs.cpu_model >= 68020) {
-			cycles_mult = CYCLES_DIV / 6;
+			if (currprefs.mmu_model) {
+				cycles_mult = CYCLES_DIV / 10;
+			} else {
+				cycles_mult = CYCLES_DIV / 6;
+			}
 		}
+
 		if (!currprefs.cpu_cycle_exact) {
 			if (currprefs.m68k_speed_throttle < 0) {
-				cycles_mult = (cycles_mult * 1000) / (1000 + currprefs.m68k_speed_throttle);
+				cycles_mult = (uae_u32)((cycles_mult * 1000) / (1000 + currprefs.m68k_speed_throttle));
 			} else if (currprefs.m68k_speed_throttle > 0) {
-				cycles_mult = (cycles_mult * 1000) / (1000 + currprefs.m68k_speed_throttle);
+				cycles_mult = (uae_u32)((cycles_mult * 1000) / (1000 + currprefs.m68k_speed_throttle));
 			}
 		}
 	} else {
@@ -4179,7 +4193,7 @@ int cpu_sleep_millis(int ms)
 // 1-9 = wait, levels
 // 10 = max wait
 
-static bool haltloop_do(int vsynctimeline, int rpt_end, int lines)
+static bool haltloop_do(int vsynctimeline, frame_time_t rpt_end, int lines)
 {
 	int ovpos = vpos;
 	while (lines-- >= 0) {
@@ -4215,7 +4229,7 @@ static bool haltloop_do(int vsynctimeline, int rpt_end, int lines)
 #endif
 			if (event_wait)
 				break;
-			int d = read_processor_time() - rpt_end;
+			frame_time_t d = read_processor_time() - rpt_end;
 			if (d < -2 * vsynctimeline || d >= 0)
 				break;
 		}
@@ -4231,10 +4245,10 @@ static bool haltloop(void)
 		int ovpos = vpos;
 
 		while (regs.halted) {
-			int vsynctimeline = vsynctimebase / (maxvpos_display + 1);
+			int vsynctimeline = (int)(vsynctimebase / (maxvpos_display + 1));
 			int lines;
-			int rpt_scanline = read_processor_time();
-			int rpt_end = rpt_scanline + vsynctimeline;
+			frame_time_t rpt_scanline = read_processor_time();
+			frame_time_t rpt_end = rpt_scanline + vsynctimeline;
 
 			// See expansion handling.
 			// Dialog must be opened from main thread.
@@ -4265,7 +4279,7 @@ static bool haltloop(void)
 				check_uae_int_request();
 				uae_ppc_execute_check();
 
-				lines = (read_processor_time() - rpt_scanline) / vsynctimeline + 1;
+				lines = (int)(read_processor_time() - rpt_scanline) / vsynctimeline + 1;
 
 			} else {
 
@@ -4875,7 +4889,7 @@ static void m68k_run_1_ce (void)
 cont:
 				if (cputrace.needendcycles) {
 					cputrace.needendcycles = 0;
-					write_log(_T("STARTCYCLES=%08x ENDCYCLES=%08x\n"), cputrace.startcycles, get_cycles());
+					write_log(_T("STARTCYCLES=%016llx ENDCYCLES=%016llx\n"), cputrace.startcycles, get_cycles());
 					log_dma_record ();
 				}
 
@@ -6909,7 +6923,7 @@ uae_u8 *save_cpu_trace (int *len, uae_u8 *dstptr)
 	else
 		dstbak = dst = xmalloc (uae_u8, 10000);
 
-	save_u32 (2 | 4 | 16 | 32 | 64);
+	save_u32 (2 | 4 | 16 | 32 | 64 | 128);
 	save_u16 (cputrace.opcode);
 	for (int i = 0; i < 16; i++)
 		save_u32 (cputrace.regs[i]);
@@ -6928,7 +6942,7 @@ uae_u8 *save_cpu_trace (int *len, uae_u8 *dstptr)
 	save_u32 (cputrace.readcounter);
 	save_u32 (cputrace.writecounter);
 	save_u32 (cputrace.memoryoffset);
-	write_log (_T("CPUT SAVE: PC=%08x C=%08X %08x %08x %08x %d %d %d\n"),
+	write_log (_T("CPUT SAVE: PC=%08x C=%016llX %08x %08x %08x %d %d %d\n"),
 		cputrace.pc, cputrace.startcycles,
 		cputrace.cyclecounter, cputrace.cyclecounter_pre, cputrace.cyclecounter_post,
 		cputrace.readcounter, cputrace.writecounter, cputrace.memoryoffset);
@@ -6938,7 +6952,7 @@ uae_u8 *save_cpu_trace (int *len, uae_u8 *dstptr)
 		save_u32 (cputrace.ctm[i].mode);
 		write_log (_T("CPUT%d: %08x %08x %08x\n"), i, cputrace.ctm[i].addr, cputrace.ctm[i].data, cputrace.ctm[i].mode);
 	}
-	save_u32 (cputrace.startcycles);
+	save_u32 ((uae_u32)cputrace.startcycles);
 
 	if (currprefs.cpu_model == 68020) {
 		for (int i = 0; i < CACHELINES020; i++) {
@@ -6968,6 +6982,8 @@ uae_u8 *save_cpu_trace (int *len, uae_u8 *dstptr)
 	save_u16(cputrace.read_buffer);
 	save_u16(cputrace.writecounter);
 
+	save_u32(cputrace.startcycles >> 32);
+
 	*len = dst - dstbak;
 	cputrace.needendcycles = 1;
 	return dstbak;
@@ -7003,7 +7019,7 @@ uae_u8 *restore_cpu_trace (uae_u8 *src)
 		cputrace.ctm[i].data = restore_u32 ();
 		cputrace.ctm[i].mode = restore_u32 ();
 	}
-	cputrace.startcycles = restore_u32 ();
+	cputrace.startcycles = restore_u32();
 
 	if (v & 4) {
 		if (currprefs.cpu_model == 68020) {
@@ -7061,6 +7077,10 @@ uae_u8 *restore_cpu_trace (uae_u8 *src)
 				cputrace.write_buffer = restore_u16();
 			}
 		}
+
+		if (v & 128) {
+			cputrace.startcycles |= ((uae_u64)restore_u32()) << 32;
+		}
 	}
 
 	cputrace.needendcycles = 1;
diff --git a/od-win32/win32.cpp b/od-win32/win32.cpp
index 6dace4ab..80ca6740 100644
--- a/od-win32/win32.cpp
+++ b/od-win32/win32.cpp
@@ -314,7 +314,7 @@ int target_sleep_nanos(int nanos)
 		if (nanos < 0)
 			return 800;
 		LARGE_INTEGER interval;
-		int start = read_processor_time();
+		frame_time_t start = read_processor_time();
 		nanos *= 10;
 		if (nanos < ActualTimerResolution)
 			nanos = ActualTimerResolution;
@@ -471,7 +471,7 @@ extern HANDLE waitvblankevent;
 static int sleep_millis2 (int ms, bool main)
 {
 	UINT TimerEvent;
-	int start = 0;
+	frame_time_t start = 0;
 	int cnt;
 	HANDLE sound_event = get_sound_event();
 	bool wasneg = ms < 0;
diff --git a/support/time.cpp b/support/time.cpp
index bd580655..8f83584d 100644
--- a/support/time.cpp
+++ b/support/time.cpp
@@ -29,9 +29,9 @@ static frame_time_t read_processor_time_qpf(void)
 
 static frame_time_t read_processor_time_rdtsc(void)
 {
-	frame_time_t foo = 0;
+	uae_u32 foo = 0;
 #if defined(X86_MSVC_ASSEMBLY)
-	frame_time_t bar;
+	uae_u32 bar;
 	__asm
 	{
 		rdtsc
@@ -39,10 +39,9 @@ static frame_time_t read_processor_time_rdtsc(void)
 			mov bar, edx
 	}
 	/* very high speed CPU's RDTSC might overflow without this.. */
-	foo >>= 6;
-	foo |= bar << 26;
-	if (!foo)
-		foo++;
+	frame_time_t out;
+	out = ((uae_u64)foo << 32) | bar;
+	out >>= 6;
 #endif
 	return foo;
 }
@@ -66,9 +65,9 @@ uae_time_t uae_time(void)
 	return t;
 }
 
-uae_u32 read_system_time(void)
+uae_s64 read_system_time(void)
 {
-	return GetTickCount();
+	return GetTickCount64();
 }
 
 static volatile int dummythread_die;
@@ -79,7 +78,7 @@ static void _cdecl dummythread(void *dummy)
 	while (!dummythread_die);
 }
 
-static uae_u64 win32_read_processor_time(void)
+static uae_s64 win32_read_processor_time(void)
 {
 #if defined(X86_MSVC_ASSEMBLY)
 	uae_u32 foo, bar;
@@ -90,7 +89,7 @@ static uae_u64 win32_read_processor_time(void)
 			mov foo, eax
 			mov bar, edx
 	}
-	return (((uae_u64)bar) << 32) | foo;
+	return (((uae_s64)bar) << 32) | foo;
 #else
 	return 0;
 #endif
@@ -99,7 +98,7 @@ static uae_u64 win32_read_processor_time(void)
 static void figure_processor_speed_rdtsc(void)
 {
 	static int freqset;
-	uae_u64 clockrate;
+	frame_time_t clockrate;
 	int oldpri;
 	HANDLE th;
 
@@ -142,7 +141,7 @@ static void figure_processor_speed_qpf(void)
 	write_log(_T("CLOCKFREQ: QPF %.2fMHz (%.2fMHz, DIV=%d)\n"),
 		  freq.QuadPart / 1000000.0,
 		  qpfrate / 1000000.0, 1 << qpcdivisor);
-	syncbase = (int) qpfrate;
+	syncbase = qpfrate;
 }
 
 void uae_time_calibrate(void)