From 6df2d7e31e3470b08b34e4d54bf0fc5cc463b9d6 Mon Sep 17 00:00:00 2001 From: Toni Wilen Date: Sat, 22 Mar 2014 20:27:25 +0200 Subject: [PATCH] 2710b12 --- cfgfile.cpp | 48 +- custom.cpp | 4 +- disk.cpp | 97 +- drawing.cpp | 2 +- inputdevice.cpp | 71 +- jit/compemu_fpp.cpp | 2532 +++++++++++++++++----------------- od-win32/caps/CapsAPI.h | 10 + od-win32/caps/CapsLib.h | 2 + od-win32/caps/caps_win32.cpp | 56 +- od-win32/caps/caps_win32.h | 2 +- od-win32/win32.cpp | 2 +- od-win32/win32.h | 4 +- od-win32/winuaechangelog.txt | 53 + table68k | 12 +- tabletlibrary.cpp | 6 +- 15 files changed, 1531 insertions(+), 1370 deletions(-) diff --git a/cfgfile.cpp b/cfgfile.cpp index e77d13bc..d76f6a82 100644 --- a/cfgfile.cpp +++ b/cfgfile.cpp @@ -630,7 +630,7 @@ void cfgfile_target_dwrite_str (struct zfile *f, const TCHAR *option, const TCHA cfg_dowrite (f, option, value, 1, 1); } -void cfgfile_write (struct zfile *f, const TCHAR *option, const TCHAR *optionext, const TCHAR *format,...) +void cfgfile_write_ext (struct zfile *f, const TCHAR *option, const TCHAR *optionext, const TCHAR *format,...) { va_list parms; TCHAR tmp[CONFIG_BLEN], tmp2[CONFIG_BLEN]; @@ -654,7 +654,7 @@ void cfgfile_write (struct zfile *f, const TCHAR *option, const TCHAR *format,.. cfg_dowrite (f, option, tmp, 0, 0); va_end (parms); } -void cfgfile_dwrite (struct zfile *f, const TCHAR *option, const TCHAR *optionext, const TCHAR *format,...) +void cfgfile_dwrite_ext (struct zfile *f, const TCHAR *option, const TCHAR *optionext, const TCHAR *format,...) { va_list parms; TCHAR tmp[CONFIG_BLEN], tmp2[CONFIG_BLEN]; @@ -1212,13 +1212,13 @@ void cfgfile_save_options (struct zfile *f, struct uae_prefs *p, int type) const TCHAR *ext = j == 0 ? NULL : _T("_rtg"); for (int i = 0; i gfx_filtershader[i][0]) - cfgfile_write (f, _T("gfx_filter_pre"), ext, _T("D3D:%s"), gf->gfx_filtershader[i]); + cfgfile_write_ext (f, _T("gfx_filter_pre"), ext, _T("D3D:%s"), gf->gfx_filtershader[i]); if (gf->gfx_filtermask[i][0]) cfgfile_write_str (f, _T("gfx_filtermask_pre"), ext, gf->gfx_filtermask[i]); } for (int i = 0; i gfx_filtershader[i + MAX_FILTERSHADERS][0]) - cfgfile_write (f, _T("gfx_filter_post"), ext, _T("D3D:%s"), gf->gfx_filtershader[i + MAX_FILTERSHADERS]); + cfgfile_write_ext (f, _T("gfx_filter_post"), ext, _T("D3D:%s"), gf->gfx_filtershader[i + MAX_FILTERSHADERS]); if (gf->gfx_filtermask[i + MAX_FILTERSHADERS][0]) cfgfile_write_str (f, _T("gfx_filtermask_post"), ext, gf->gfx_filtermask[i + MAX_FILTERSHADERS]); } @@ -1226,7 +1226,7 @@ void cfgfile_save_options (struct zfile *f, struct uae_prefs *p, int type) { bool d3dfound = false; if (gf->gfx_filtershader[2 * MAX_FILTERSHADERS][0] && p->gfx_api) { - cfgfile_dwrite (f, _T("gfx_filter"), ext, _T("D3D:%s"), gf->gfx_filtershader[2 * MAX_FILTERSHADERS]); + cfgfile_dwrite_ext (f, _T("gfx_filter"), ext, _T("D3D:%s"), gf->gfx_filtershader[2 * MAX_FILTERSHADERS]); d3dfound = true; } if (!d3dfound) { @@ -1241,35 +1241,35 @@ void cfgfile_save_options (struct zfile *f, struct uae_prefs *p, int type) i++; } } else { - cfgfile_dwrite (f, _T("gfx_filter"), ext, _T("no")); + cfgfile_dwrite_ext (f, _T("gfx_filter"), ext, _T("no")); } } } cfgfile_dwrite_str (f, _T("gfx_filter_mode"), ext, filtermode2[gf->gfx_filter_filtermode]); - cfgfile_dwrite (f, _T("gfx_filter_vert_zoomf"), ext, _T("%f"), gf->gfx_filter_vert_zoom); - cfgfile_dwrite (f, _T("gfx_filter_horiz_zoomf"), ext, _T("%f"), gf->gfx_filter_horiz_zoom); - cfgfile_dwrite (f, _T("gfx_filter_vert_zoom_multf"), ext, _T("%f"), gf->gfx_filter_vert_zoom_mult); - cfgfile_dwrite (f, _T("gfx_filter_horiz_zoom_multf"), ext, _T("%f"), gf->gfx_filter_horiz_zoom_mult); - cfgfile_dwrite (f, _T("gfx_filter_vert_offsetf"), ext, _T("%f"), gf->gfx_filter_vert_offset); - cfgfile_dwrite (f, _T("gfx_filter_horiz_offsetf"), ext, _T("%f"), gf->gfx_filter_horiz_offset); - cfgfile_dwrite (f, _T("gfx_filter_scanlines"), ext, _T("%d"), gf->gfx_filter_scanlines); - cfgfile_dwrite (f, _T("gfx_filter_scanlinelevel"), ext, _T("%d"), gf->gfx_filter_scanlinelevel); - cfgfile_dwrite (f, _T("gfx_filter_scanlineratio"), ext, _T("%d"), gf->gfx_filter_scanlineratio); - cfgfile_dwrite (f, _T("gfx_filter_luminance"), ext, _T("%d"), gf->gfx_filter_luminance); - cfgfile_dwrite (f, _T("gfx_filter_contrast"), ext, _T("%d"), gf->gfx_filter_contrast); - cfgfile_dwrite (f, _T("gfx_filter_saturation"), ext, _T("%d"), gf->gfx_filter_saturation); - cfgfile_dwrite (f, _T("gfx_filter_gamma"), ext, _T("%d"), gf->gfx_filter_gamma); - cfgfile_dwrite (f, _T("gfx_filter_blur"), ext, _T("%d"), gf->gfx_filter_blur); - cfgfile_dwrite (f, _T("gfx_filter_noise"), ext, _T("%d"), gf->gfx_filter_noise); + cfgfile_dwrite_ext (f, _T("gfx_filter_vert_zoomf"), ext, _T("%f"), gf->gfx_filter_vert_zoom); + cfgfile_dwrite_ext (f, _T("gfx_filter_horiz_zoomf"), ext, _T("%f"), gf->gfx_filter_horiz_zoom); + cfgfile_dwrite_ext (f, _T("gfx_filter_vert_zoom_multf"), ext, _T("%f"), gf->gfx_filter_vert_zoom_mult); + cfgfile_dwrite_ext (f, _T("gfx_filter_horiz_zoom_multf"), ext, _T("%f"), gf->gfx_filter_horiz_zoom_mult); + cfgfile_dwrite_ext (f, _T("gfx_filter_vert_offsetf"), ext, _T("%f"), gf->gfx_filter_vert_offset); + cfgfile_dwrite_ext (f, _T("gfx_filter_horiz_offsetf"), ext, _T("%f"), gf->gfx_filter_horiz_offset); + cfgfile_dwrite_ext (f, _T("gfx_filter_scanlines"), ext, _T("%d"), gf->gfx_filter_scanlines); + cfgfile_dwrite_ext (f, _T("gfx_filter_scanlinelevel"), ext, _T("%d"), gf->gfx_filter_scanlinelevel); + cfgfile_dwrite_ext (f, _T("gfx_filter_scanlineratio"), ext, _T("%d"), gf->gfx_filter_scanlineratio); + cfgfile_dwrite_ext (f, _T("gfx_filter_luminance"), ext, _T("%d"), gf->gfx_filter_luminance); + cfgfile_dwrite_ext (f, _T("gfx_filter_contrast"), ext, _T("%d"), gf->gfx_filter_contrast); + cfgfile_dwrite_ext (f, _T("gfx_filter_saturation"), ext, _T("%d"), gf->gfx_filter_saturation); + cfgfile_dwrite_ext (f, _T("gfx_filter_gamma"), ext, _T("%d"), gf->gfx_filter_gamma); + cfgfile_dwrite_ext (f, _T("gfx_filter_blur"), ext, _T("%d"), gf->gfx_filter_blur); + cfgfile_dwrite_ext (f, _T("gfx_filter_noise"), ext, _T("%d"), gf->gfx_filter_noise); cfgfile_dwrite_bool (f, _T("gfx_filter_bilinear"), ext, gf->gfx_filter_bilinear != 0); - cfgfile_dwrite (f, _T("gfx_filter_keep_autoscale_aspect"), ext, _T("%d"), gf->gfx_filter_keep_autoscale_aspect); + cfgfile_dwrite_ext (f, _T("gfx_filter_keep_autoscale_aspect"), ext, _T("%d"), gf->gfx_filter_keep_autoscale_aspect); cfgfile_dwrite_str (f, _T("gfx_filter_keep_aspect"), ext, aspects[gf->gfx_filter_keep_aspect]); cfgfile_dwrite_str (f, _T("gfx_filter_autoscale"), ext, autoscale[gf->gfx_filter_autoscale]); - cfgfile_dwrite (f, _T("gfx_filter_aspect_ratio"), ext, _T("%d:%d"), + cfgfile_dwrite_ext (f, _T("gfx_filter_aspect_ratio"), ext, _T("%d:%d"), gf->gfx_filter_aspect >= 0 ? (gf->gfx_filter_aspect / ASPECTMULT) : -1, gf->gfx_filter_aspect >= 0 ? (gf->gfx_filter_aspect & (ASPECTMULT - 1)) : -1); if (gf->gfx_filteroverlay[0]) { - cfgfile_dwrite (f, _T("gfx_filter_overlay"), ext, _T("%s%s"), + cfgfile_dwrite_ext(f, _T("gfx_filter_overlay"), ext, _T("%s%s"), gf->gfx_filteroverlay, _tcschr (gf->gfx_filteroverlay, ',') ? _T(",") : _T("")); } } diff --git a/custom.cpp b/custom.cpp index 5a7ff3c4..a75d9638 100644 --- a/custom.cpp +++ b/custom.cpp @@ -2624,10 +2624,10 @@ STATIC_INLINE void decide_line (int hpos) } if (dmaecs) { - // did we just match ddfstop but missed ddfstrt? DMA starts from passed plfstop state. + // did we just match ddfstop - 3 but missed ddfstrt? DMA starts from passed plfstop state. if (last_decide_line_hpos > plfstrt && (plf_state == plf_active || plf_state == plf_wait_stop) && diwstate == DIW_waiting_stop) { int stop = get_ddfstop_to_test (last_decide_line_hpos); - if (last_decide_line_hpos < stop && hpos >= stop) { + if (last_decide_line_hpos < stop && hpos >= stop - 3) { if (dma) { // we did, fetches start! bplstart = plfstop; diff --git a/disk.cpp b/disk.cpp index 12d9b105..c75c71a5 100644 --- a/disk.cpp +++ b/disk.cpp @@ -168,6 +168,7 @@ typedef struct { uae_u16 bigmfmbuf[0x4000 * DDHDMULT]; uae_u16 tracktiming[0x4000 * DDHDMULT]; int multi_revolution; + int revolution_check; int skipoffset; int mfmpos; int indexoffset; @@ -205,6 +206,7 @@ typedef struct { int amax; int lastdataacesstrack; int lastrev; + bool track_access_done; #endif } drive; @@ -772,8 +774,11 @@ int DISK_validate_filename (struct uae_prefs *p, const TCHAR *fname, int leave_o static void updatemfmpos (drive *drv) { - if (drv->prevtracklen) + if (drv->prevtracklen) { drv->mfmpos = drv->mfmpos * (drv->tracklen * 1000 / drv->prevtracklen) / 1000; + if (drv->mfmpos >= drv->tracklen) + drv->mfmpos = drv->tracklen - 1; + } drv->mfmpos %= drv->tracklen; drv->prevtracklen = drv->tracklen; } @@ -1750,8 +1755,9 @@ static void drive_fill_bigbuf (drive * drv, int force) drv->tracktiming[0] = 0; drv->skipoffset = -1; drv->revolutions = 1; - retrytrack = drv->lastdataacesstrack == drv->cyl * 2 + side; + if (!dskdmaen && !retrytrack) + drv->track_access_done = false; //write_log (_T("%d:%d %d\n"), drv->cyl, side, retrytrack); if (drv->writediskfile && drv->writetrackdata[tr].bitlen > 0) { @@ -2649,6 +2655,8 @@ static void DISK_check_change (void) { if (currprefs.floppy_speed != changed_prefs.floppy_speed) currprefs.floppy_speed = changed_prefs.floppy_speed; + if (currprefs.floppy_read_only != changed_prefs.floppy_read_only) + currprefs.floppy_read_only = changed_prefs.floppy_read_only; for (int i = 0; i < MAX_FLOPPY_DRIVES; i++) { drive *drv = floppy + i; if (currprefs.floppyslots[i].dfxtype != changed_prefs.floppyslots[i].dfxtype) { @@ -2918,7 +2926,7 @@ static void disk_dmafinished (void) dskdmaen = DSKDMA_OFF; dsklength = 0; if (disk_debug_logging > 0) { - int dr, mfmpos = -1; + int dr; write_log (_T("disk dma finished %08X MFMpos="), dskpt); for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) write_log (_T("%d%s"), floppy[dr].mfmpos, dr < MAX_FLOPPY_DRIVES - 1 ? _T(",") : _T("")); @@ -2928,19 +2936,22 @@ static void disk_dmafinished (void) static void fetchnextrevolution (drive *drv) { + if (drv->revolution_check) + return; drv->trackspeed = get_floppy_speed2 (drv); #if 0 if (1 || drv->mfmpos != 0) { - write_log (_T("REVOLUTION: %d %d/%d %d %d\n"), drv->trackspeed, drv->mfmpos, drv->tracklen, drv->floppybitcounter); + write_log (_T("REVOLUTION: DMA=%d %d %d/%d %d %d %d\n"), dskdmaen, drv->trackspeed, drv->mfmpos, drv->tracklen, drv->indexoffset, drv->floppybitcounter); } #endif + drv->revolution_check = 2; if (!drv->multi_revolution) return; switch (drv->filetype) { case ADF_IPF: #ifdef CAPS - caps_loadrevolution (drv->bigmfmbuf, drv->tracktiming, drv - floppy, drv->cyl * 2 + side, &drv->tracklen, &drv->lastrev); + caps_loadrevolution (drv->bigmfmbuf, drv->tracktiming, drv - floppy, drv->cyl * 2 + side, &drv->tracklen, &drv->lastrev, drv->track_access_done); #endif break; case ADF_SCP: @@ -2950,12 +2961,23 @@ static void fetchnextrevolution (drive *drv) break; case ADF_FDI: #ifdef FDI2RAW - fdi2raw_loadrevolution (drv->fdi, drv->bigmfmbuf, drv->tracktiming, drv->cyl * 2 + side, &drv->tracklen, 1); + fdi2raw_loadrevolution(drv->fdi, drv->bigmfmbuf, drv->tracktiming, drv->cyl * 2 + side, &drv->tracklen, 1); #endif break; } } +static void do_disk_index (void) +{ +#if 0 + write_log(_T("INDEX %d\n"), indexdecay); +#endif + if (!indexdecay) { + indexdecay = 2; + cia_diskindex (); + } +} + void DISK_handler (uae_u32 data) { int flag = data & 255; @@ -2976,12 +2998,8 @@ void DISK_handler (uae_u32 data) } if (flag & DISK_WORDSYNC) INTREQ (0x8000 | 0x1000); - if (flag & DISK_INDEXSYNC) { - if (!indexdecay) { - indexdecay = 2; - cia_diskindex (); - } - } + if (flag & DISK_INDEXSYNC) + do_disk_index (); } static void disk_doupdate_write (drive * drv, int floppybits) @@ -3085,7 +3103,7 @@ static void disk_doupdate_predict (int startcycle) drive *drv = &floppy[dr]; if (drv->motoroff) continue; - if (drv->motoroff || !drv->trackspeed) + if (!drv->trackspeed) continue; if (selected & (1 << dr)) continue; @@ -3108,25 +3126,29 @@ static void disk_doupdate_predict (int startcycle) else tword |= getonebit (drv->bigmfmbuf, mfmpos); } - if ((tword & 0xffff) == dsksync && dsksync != 0) + if (dskdmaen != DSKDMA_READ && (tword & 0xffff) == dsksync && dsksync != 0) diskevent_flag |= DISK_WORDSYNC; } mfmpos++; mfmpos %= drv->tracklen; - if (mfmpos == 0 && !dskdmaen) - diskevent_flag |= DISK_REVOLUTION << (drv - floppy); - if (mfmpos == drv->indexoffset) - diskevent_flag |= DISK_INDEXSYNC; + if (!dskdmaen) { + if (mfmpos == 0) + diskevent_flag |= DISK_REVOLUTION << (drv - floppy); + if (mfmpos == drv->indexoffset) + diskevent_flag |= DISK_INDEXSYNC; + } if (dskdmaen != DSKDMA_WRITE && mfmpos == drv->skipoffset) { update_jitter (); int skipcnt = disk_jitter; while (skipcnt-- > 0) { mfmpos++; mfmpos %= drv->tracklen; - if (mfmpos == 0) - diskevent_flag |= DISK_REVOLUTION << (drv - floppy); - if (mfmpos == drv->indexoffset) - diskevent_flag |= DISK_INDEXSYNC; + if (!dskdmaen) { + if (mfmpos == 0) + diskevent_flag |= DISK_REVOLUTION << (drv - floppy); + if (mfmpos == drv->indexoffset) + diskevent_flag |= DISK_INDEXSYNC; + } } } if (diskevent_flag) @@ -3139,6 +3161,7 @@ static void disk_doupdate_predict (int startcycle) finaleventflag = diskevent_flag; } } + if (finaleventflag && (finaleventcycle >> 8) < maxhpos) { event2_newevent (ev2_disk, (finaleventcycle - startcycle) >> 8, ((finaleventcycle >> 8) << 8) | finaleventflag); } @@ -3243,17 +3266,32 @@ static void disk_doupdate_read (drive * drv, int floppybits) if (disk_debug_logging > 1 && drv->indexhack) write_log (_T("indexhack cleared\n")); drv->indexhack = 0; - } - if (drv->mfmpos == drv->skipoffset) { - update_jitter (); - drv->mfmpos += disk_jitter; - drv->mfmpos %= drv->tracklen; + do_disk_index (); } if (drv->mfmpos == 0) { fetchnextrevolution (drv); if (drv->tracktiming[0]) updatetrackspeed (drv, drv->mfmpos); } + if (drv->mfmpos == drv->skipoffset) { + update_jitter (); + int skipcnt = disk_jitter; + while (skipcnt-- > 0) { + drv->mfmpos++; + drv->mfmpos %= drv->tracklen; + if (drv->mfmpos == drv->indexoffset) { + if (disk_debug_logging > 1 && drv->indexhack) + write_log (_T("indexhack cleared\n")); + drv->indexhack = 0; + do_disk_index (); + } + if (drv->mfmpos == 0) { + fetchnextrevolution (drv); + if (drv->tracktiming[0]) + updatetrackspeed (drv, drv->mfmpos); + } + } + } if ((bitoffset & 7) == 7) { dskbytr_val = word & 0xff; dskbytr_val |= 0x8000; @@ -3264,6 +3302,7 @@ static void disk_doupdate_read (drive * drv, int floppybits) if (disk_debug_logging && dma_enable == 0) write_log (_T("Sync match, DMA started at %d PC=%08x\n"), drv->mfmpos, M68K_GETPC); dma_enable = 1; + INTREQ (0x8000 | 0x1000); } if (adkcon & 0x400) { bitoffset = 15; @@ -3305,6 +3344,7 @@ uae_u16 DSKBYTR (int hpos) continue; if (!(selected & (1 << dr))) { drv->lastdataacesstrack = drv->cyl * 2 + side; + drv->track_access_done = true; if (disk_debug_mode & DISK_DEBUG_PIO) { if (disk_debug_track < 0 || disk_debug_track == 2 * drv->cyl + side) { disk_dma_debugmsg (); @@ -3333,6 +3373,7 @@ static void DISK_start (void) if (dskdmaen == DSKDMA_READ) { drv->lastdataacesstrack = drv->cyl * 2 + side; + drv->track_access_done = true; } if (dskdmaen == DSKDMA_WRITE) { @@ -3365,6 +3406,8 @@ void DISK_hsync (void) drive *drv = &floppy[dr]; if (drv->steplimit) drv->steplimit--; + if (drv->revolution_check) + drv->revolution_check--; } if (indexdecay) indexdecay--; diff --git a/drawing.cpp b/drawing.cpp index d02a34a7..572997a3 100644 --- a/drawing.cpp +++ b/drawing.cpp @@ -3152,8 +3152,8 @@ bool vsync_handle_check (void) notice_screen_contents_lost (); notice_new_xcolors (); } - check_prefs_changed_audio (); check_prefs_changed_cd (); + check_prefs_changed_audio (); check_prefs_changed_custom (); check_prefs_changed_cpu (); check_picasso (); diff --git a/inputdevice.cpp b/inputdevice.cpp index 90526668..3dc2cac0 100644 --- a/inputdevice.cpp +++ b/inputdevice.cpp @@ -1063,7 +1063,10 @@ static int lastmx, lastmy; static uaecptr magicmouse_ibase, magicmouse_gfxbase; static int dimensioninfo_width, dimensioninfo_height, dimensioninfo_dbl; static int vp_xoffset, vp_yoffset, mouseoffset_x, mouseoffset_y; -static int tablet_maxx, tablet_maxy, tablet_data; +static int tablet_maxx, tablet_maxy, tablet_maxz; +static int tablet_resx, tablet_resy; +static int tablet_maxax, tablet_maxay, tablet_maxaz; +static int tablet_data; int mousehack_alive (void) { @@ -1207,6 +1210,33 @@ static bool mousehack_enable (void) return true; } +static void inputdevice_update_tablet_params(void) +{ + uae_u8 *p; + if (inputdevice_is_tablet() <= 0 || !mousehack_address) + return; + p = get_real_address(mousehack_address); + + p[MH_MAXX] = tablet_maxx >> 8; + p[MH_MAXX + 1] = tablet_maxx; + p[MH_MAXY] = tablet_maxy >> 8; + p[MH_MAXY + 1] = tablet_maxy; + p[MH_MAXZ] = tablet_maxz >> 8; + p[MH_MAXZ + 1] = tablet_maxz; + + p[MH_RESX] = tablet_resx >> 8; + p[MH_RESX + 1] = tablet_resx; + p[MH_RESY] = tablet_resy >> 8; + p[MH_RESY + 1] = tablet_resy; + + p[MH_MAXAX] = tablet_maxax >> 8; + p[MH_MAXAX + 1] = tablet_maxax; + p[MH_MAXAY] = tablet_maxay >> 8; + p[MH_MAXAY + 1] = tablet_maxay; + p[MH_MAXAZ] = tablet_maxaz >> 8; + p[MH_MAXAZ + 1] = tablet_maxaz; +} + void input_mousehack_mouseoffset (uaecptr pointerprefs) { mouseoffset_x = (uae_s16)get_word (pointerprefs + 28); @@ -1220,6 +1250,7 @@ int input_mousehack_status (int mode, uaecptr diminfo, uaecptr dispinfo, uaecptr } else if (mode == 5) { mousehack_address = m68k_dreg (regs, 0); mousehack_enable (); + inputdevice_update_tablet_params (); } else if (mode == 0) { if (mousehack_address) { uae_u8 v = get_byte (mousehack_address + MH_E); @@ -1340,11 +1371,6 @@ void inputdevice_tablet (int x, int y, int z, int pressure, uae_u32 buttonbits, p[MH_AZ] = az >> 8; p[MH_AZ + 1] = az; - p[MH_MAXX] = tablet_maxx >> 8; - p[MH_MAXX + 1] = tablet_maxx; - p[MH_MAXY] = tablet_maxy >> 8; - p[MH_MAXY + 1] = tablet_maxy; - p[MH_PRESSURE] = pressure >> 8; p[MH_PRESSURE + 1] = pressure; @@ -1381,32 +1407,16 @@ void inputdevice_tablet (int x, int y, int z, int pressure, uae_u32 buttonbits, void inputdevice_tablet_info (int maxx, int maxy, int maxz, int maxax, int maxay, int maxaz, int xres, int yres) { - uae_u8 *p; - - if (!uae_boot_rom || !mousehack_address) - return; - p = get_real_address (mousehack_address); - tablet_maxx = maxx; tablet_maxy = maxy; - p[MH_MAXX] = maxx >> 8; - p[MH_MAXX + 1] = maxx; - p[MH_MAXY] = maxy >> 8; - p[MH_MAXY + 1] = maxy; - p[MH_MAXZ] = maxz >> 8; - p[MH_MAXZ + 1] = maxz; - - p[MH_RESX] = xres >> 8; - p[MH_RESX + 1] = xres; - p[MH_RESY] = yres >> 8; - p[MH_RESY + 1] = yres; + tablet_maxz = maxz; - p[MH_MAXAX] = maxax >> 8; - p[MH_MAXAX + 1] = maxax; - p[MH_MAXAY] = maxay >> 8; - p[MH_MAXAY + 1] = maxay; - p[MH_MAXAZ] = maxaz >> 8; - p[MH_MAXAZ + 1] = maxaz; + tablet_resx = xres; + tablet_resy = yres; + tablet_maxax = maxax; + tablet_maxay = maxay; + tablet_maxaz = maxaz; + inputdevice_update_tablet_params(); } @@ -1446,11 +1456,12 @@ static void inputdevice_mh_abs (int x, int y, uae_u32 buttonbits) p[MH_CNT]++; tablet_data = 1; +#if 0 if (inputdevice_is_tablet () <= 0) { tabletlib_tablet_info (1000, 1000, 0, 0, 0, 0, 1000, 1000); tabletlib_tablet (x, y, 0, 0, buttonbits, -1, 0, 0, 0); } - +#endif } #if 0 diff --git a/jit/compemu_fpp.cpp b/jit/compemu_fpp.cpp index ce1e8dac..33fd32ab 100644 --- a/jit/compemu_fpp.cpp +++ b/jit/compemu_fpp.cpp @@ -6,7 +6,7 @@ * Copyright 1996 Herman ten Brugge * Adapted for JIT compilation (c) Bernd Meyer, 2000 * Modified 2005 Peter Keunecke - */ + */ #include "sysconfig.h" #include "sysdeps.h" @@ -20,29 +20,29 @@ #include "compemu.h" #if defined(JIT) -uae_u32 temp_fp[] = {0,0,0}; /* To convert between FP and */ +uae_u32 temp_fp[] = { 0, 0, 0 }; /* To convert between FP and */ /* 128 words, indexed through the low byte of the 68k fpu control word */ -static const uae_u16 x86_fpucw[]={ - 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, /* E-RN */ - 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, /* E-RZ */ - 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, /* E-RD */ - 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, /* E-RU */ +static const uae_u16 x86_fpucw[] = { + 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, /* E-RN */ + 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, /* E-RZ */ + 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, /* E-RD */ + 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, /* E-RU */ - 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, /* S-RN */ - 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, /* S-RZ */ - 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, /* S-RD */ - 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, /* S-RU */ + 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, 0x107f, /* S-RN */ + 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, 0x1c7f, /* S-RZ */ + 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, 0x147f, /* S-RD */ + 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, 0x187f, /* S-RU */ - 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, /* D-RN */ - 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, /* D-RZ */ - 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, /* D-RD */ - 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, /* D-RU */ + 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, 0x127f, /* D-RN */ + 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, 0x1e7f, /* D-RZ */ + 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, 0x167f, /* D-RD */ + 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, 0x1a7f, /* D-RU */ - 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, /* ?-RN */ - 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, /* ?-RZ */ - 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, /* ?-RD */ - 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f /* ?-RU */ + 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, 0x137f, /* ?-RN */ + 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, 0x1f7f, /* ?-RZ */ + 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, 0x177f, /* ?-RD */ + 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f, 0x1b7f /* ?-RU */ }; static const int sz1[8] = { 4, 4, 12, 12, 2, 8, 1, 0 }; static const int sz2[8] = { 4, 4, 12, 12, 2, 8, 2, 0 }; @@ -60,630 +60,631 @@ static struct { /* return the required floating point precision or -1 for failure, 0=E, 1=S, 2=D */ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg) { - int reg = opcode & 7; - int mode = (opcode >> 3) & 7; - int size = (extra >> 10) & 7; + int reg = opcode & 7; + int mode = (opcode >> 3) & 7; + int size = (extra >> 10) & 7; - if (size == 3 || size == 7) /* 3 = packed decimal, 7 is not defined */ - return -1; - switch (mode) { - case 0: /* Dn */ - switch (size) { - case 0: /* Long */ - mov_l_mr((uae_u32)temp_fp,reg); - fmovi_rm(treg,(uae_u32)temp_fp); - return 2; - case 1: /* Single */ - mov_l_mr((uae_u32)temp_fp,reg); - fmovs_rm(treg,(uae_u32)temp_fp); - return 1; - case 4: /* Word */ - sign_extend_16_rr(S1,reg); - mov_l_mr((uae_u32)temp_fp,S1); - fmovi_rm(treg,(uae_u32)temp_fp); - return 1; - case 6: /* Byte */ - sign_extend_8_rr(S1,reg); - mov_l_mr((uae_u32)temp_fp,S1); - fmovi_rm(treg,(uae_u32)temp_fp); - return 1; - default: - return -1; - } - case 1: /* An, invalid mode */ - return -1; - case 2: /* (An) */ - mov_l_rr(S1,reg+8); - break; - case 3: /* (An)+ */ - mov_l_rr(S1,reg+8); - lea_l_brr(reg+8,reg+8,(reg == 7?sz2[size]:sz1[size])); - break; - case 4: /* -(An) */ - lea_l_brr(reg+8,reg+8,-(reg == 7?sz2[size]:sz1[size])); - mov_l_rr(S1,reg+8); - break; - case 5: /* (d16,An) */ - { - uae_u32 off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_rr(S1,reg+8); - lea_l_brr(S1,S1,off); - break; - } - case 6: /* (d8,An,Xn) or (bd,An,Xn) or ([bd,An,Xn],od) or ([bd,An],Xn,od) */ - { - uae_u32 dp=comp_get_iword((m68k_pc_offset+=2)-2); - calc_disp_ea_020(reg+8,dp,S1,S2); - break; - } - case 7: - switch (reg) { - case 0: /* (xxx).W */ - { - uae_u32 off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_ri(S1,off); - break; - } - case 1: /* (xxx).L */ - { - uae_u32 off=comp_get_ilong((m68k_pc_offset+=4)-4); - mov_l_ri(S1,off); - break; - } - case 2: /* (d16,PC) */ - { - uae_u32 address=start_pc+((uae_char*)comp_pc_p-(uae_char*)start_pc_p)+ - m68k_pc_offset; - uae_s32 PC16off =(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_ri(S1,address+PC16off); - break; - } - case 3: /* (d8,PC,Xn) or (bd,PC,Xn) or ([bd,PC,Xn],od) or ([bd,PC],Xn,od) */ - return -1; /* rarely used, fallback to non-JIT */ - case 4: /* # < data >; Constants should be converted just once by the JIT */ - m68k_pc_offset+=sz2[size]; - switch (size) { - case 0: - { - uae_s32 li = comp_get_ilong(m68k_pc_offset-4); - float si = (float) li; - - if (li == (int) si) { - //write_log (_T("converted immediate LONG constant to SINGLE\n")); - fmovs_ri(treg,*(uae_u32 *)&si); + if (size == 3 || size == 7) /* 3 = packed decimal, 7 is not defined */ + return -1; + switch (mode) { + case 0: /* Dn */ + switch (size) { + case 0: /* Long */ + mov_l_mr ((uae_u32) temp_fp, reg); + fmovi_rm (treg, (uae_u32) temp_fp); + return 2; + case 1: /* Single */ + mov_l_mr ((uae_u32) temp_fp, reg); + fmovs_rm (treg, (uae_u32) temp_fp); return 1; - } - //write_log (_T("immediate LONG constant\n")); - fmovl_ri(treg,li); - return 2; - } - case 1: - //write_log (_T("immediate SINGLE constant\n")); - fmovs_ri(treg,comp_get_ilong(m68k_pc_offset-4)); - return 1; - case 2: - //write_log (_T("immediate LONG DOUBLE constant\n")); - fmov_ext_ri(treg,comp_get_ilong(m68k_pc_offset-4), - comp_get_ilong(m68k_pc_offset-8), - (comp_get_ilong(m68k_pc_offset-12)>>16)&0xffff); - return 0; - case 4: - { - float si = (float)(uae_s16)comp_get_iword(m68k_pc_offset-2); + case 4: /* Word */ + sign_extend_16_rr (S1, reg); + mov_l_mr ((uae_u32) temp_fp, S1); + fmovi_rm (treg, (uae_u32) temp_fp); + return 1; + case 6: /* Byte */ + sign_extend_8_rr (S1, reg); + mov_l_mr ((uae_u32) temp_fp, S1); + fmovi_rm (treg, (uae_u32) temp_fp); + return 1; + default: + return -1; + } + case 1: /* An, invalid mode */ + return -1; + case 2: /* (An) */ + mov_l_rr (S1, reg + 8); + break; + case 3: /* (An)+ */ + mov_l_rr (S1, reg + 8); + lea_l_brr (reg + 8, reg + 8, (reg == 7 ? sz2[size] : sz1[size])); + break; + case 4: /* -(An) */ + lea_l_brr (reg + 8, reg + 8, -(reg == 7 ? sz2[size] : sz1[size])); + mov_l_rr (S1, reg + 8); + break; + case 5: /* (d16,An) */ + { + uae_u32 off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_rr (S1, reg + 8); + lea_l_brr (S1, S1, off); + break; + } + case 6: /* (d8,An,Xn) or (bd,An,Xn) or ([bd,An,Xn],od) or ([bd,An],Xn,od) */ + { + uae_u32 dp = comp_get_iword ((m68k_pc_offset += 2) - 2); + calc_disp_ea_020 (reg + 8, dp, S1, S2); + break; + } + case 7: + switch (reg) { + case 0: /* (xxx).W */ + { + uae_u32 off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_ri (S1, off); + break; + } + case 1: /* (xxx).L */ + { + uae_u32 off = comp_get_ilong ((m68k_pc_offset += 4) - 4); + mov_l_ri (S1, off); + break; + } + case 2: /* (d16,PC) */ + { + uae_u32 address = start_pc + ((uae_char*) comp_pc_p - (uae_char*) start_pc_p) + + m68k_pc_offset; + uae_s32 PC16off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_ri (S1, address + PC16off); + break; + } + case 3: /* (d8,PC,Xn) or (bd,PC,Xn) or ([bd,PC,Xn],od) or ([bd,PC],Xn,od) */ + return -1; /* rarely used, fallback to non-JIT */ + case 4: /* # < data >; Constants should be converted just once by the JIT */ + m68k_pc_offset += sz2[size]; + switch (size) { + case 0: + { + uae_s32 li = comp_get_ilong (m68k_pc_offset - 4); + float si = (float) li; - //write_log (_T("converted immediate WORD constant to SINGLE\n")); - fmovs_ri(treg,*(uae_u32 *)&si); - return 1; - } - case 5: - { - uae_u32 longarray[] = {comp_get_ilong(m68k_pc_offset-4), - comp_get_ilong(m68k_pc_offset-8)}; - float si = (float)*(double *)longarray; + if (li == (int) si) { + //write_log (_T("converted immediate LONG constant to SINGLE\n")); + fmovs_ri (treg, *(uae_u32 *) &si); + return 1; + } + //write_log (_T("immediate LONG constant\n")); + fmovl_ri (treg, li); + return 2; + } + case 1: + //write_log (_T("immediate SINGLE constant\n")); + fmovs_ri (treg, comp_get_ilong (m68k_pc_offset - 4)); + return 1; + case 2: + //write_log (_T("immediate LONG DOUBLE constant\n")); + fmov_ext_ri (treg, comp_get_ilong (m68k_pc_offset - 4), + comp_get_ilong (m68k_pc_offset - 8), + (comp_get_ilong (m68k_pc_offset - 12) >> 16) & 0xffff); + return 0; + case 4: + { + uae_s16 w = (uae_s16) comp_get_iword (m68k_pc_offset - 2); + float si = (float)w; - if (*(double *)longarray == (double)si) { - //write_log (_T("SPEED GAIN: converted a DOUBLE constant to SINGLE\n")); - fmovs_ri(treg,*(uae_u32 *)&si); - return 1; - } - //write_log (_T("immediate DOUBLE constant\n")); - fmov_ri(treg,longarray[0],longarray[1]); - return 2; - } - case 6: - { - float si = (float)(uae_s8)comp_get_ibyte(m68k_pc_offset-2); + //write_log (_T("converted immediate WORD constant %d to SINGLE %f, %x\n"), w, si, m68k_getpc()); + fmovs_ri (treg, *(uae_u32 *) &si); + return 1; + } + case 5: + { + uae_u32 longarray[] = { comp_get_ilong (m68k_pc_offset - 4), + comp_get_ilong (m68k_pc_offset - 8) }; + float si = (float) *(double *) longarray; + + if (*(double *) longarray == (double) si) { + //write_log (_T("SPEED GAIN: converted a DOUBLE constant to SINGLE\n")); + fmovs_ri (treg, *(uae_u32 *) &si); + return 1; + } + //write_log (_T("immediate DOUBLE constant\n")); + fmov_ri (treg, longarray[0], longarray[1]); + return 2; + } + case 6: + { + float si = (float) (uae_s8) comp_get_ibyte (m68k_pc_offset - 1); - //write_log (_T("immediate BYTE constant converted to SINGLE\n")); - fmovs_ri(treg,*(uae_u32 *)&si); - return 1; - } - default: /* never reached */ - return -1; - } - default: /* never reached */ - return -1; + //write_log (_T("immediate BYTE constant converted to SINGLE\n")); + fmovs_ri (treg, *(uae_u32 *) &si); + return 1; + } + default: /* never reached */ + return -1; + } + default: /* never reached */ + return -1; + } } - } - switch (size) { - case 0: /* Long */ - readlong(S1,S2,S3); - mov_l_mr((uae_u32)temp_fp,S2); - fmovi_rm(treg,(uae_u32)temp_fp); - return 2; - case 1: /* Single */ - readlong(S1,S2,S3); - mov_l_mr((uae_u32)temp_fp,S2); - fmovs_rm(treg,(uae_u32)temp_fp); - return 1; - case 2: /* Long Double */ - readword(S1,S2,S3); - mov_w_mr(((uae_u32)temp_fp)+8,S2); - add_l_ri(S1,4); - readlong(S1,S2,S3); - mov_l_mr((uae_u32)(temp_fp)+4,S2); - add_l_ri(S1,4); - readlong(S1,S2,S3); - mov_l_mr((uae_u32)(temp_fp),S2); - fmov_ext_rm(treg,(uae_u32)(temp_fp)); - return 0; - case 4: /* Word */ - readword(S1,S2,S3); - sign_extend_16_rr(S2,S2); - mov_l_mr((uae_u32)temp_fp,S2); - fmovi_rm(treg,(uae_u32)temp_fp); - return 1; - case 5: /* Double */ - readlong(S1,S2,S3); - mov_l_mr(((uae_u32)temp_fp)+4,S2); - add_l_ri(S1,4); - readlong(S1,S2,S3); - mov_l_mr((uae_u32)(temp_fp),S2); - fmov_rm(treg,(uae_u32)(temp_fp)); - return 2; - case 6: /* Byte */ - readbyte(S1,S2,S3); - sign_extend_8_rr(S2,S2); - mov_l_mr((uae_u32)temp_fp,S2); - fmovi_rm(treg,(uae_u32)temp_fp); - return 1; - default: + switch (size) { + case 0: /* Long */ + readlong (S1, S2, S3); + mov_l_mr ((uae_u32) temp_fp, S2); + fmovi_rm (treg, (uae_u32) temp_fp); + return 2; + case 1: /* Single */ + readlong (S1, S2, S3); + mov_l_mr ((uae_u32) temp_fp, S2); + fmovs_rm (treg, (uae_u32) temp_fp); + return 1; + case 2: /* Long Double */ + readword (S1, S2, S3); + mov_w_mr (((uae_u32) temp_fp) + 8, S2); + add_l_ri (S1, 4); + readlong (S1, S2, S3); + mov_l_mr ((uae_u32) (temp_fp) +4, S2); + add_l_ri (S1, 4); + readlong (S1, S2, S3); + mov_l_mr ((uae_u32) (temp_fp), S2); + fmov_ext_rm (treg, (uae_u32) (temp_fp)); + return 0; + case 4: /* Word */ + readword (S1, S2, S3); + sign_extend_16_rr (S2, S2); + mov_l_mr ((uae_u32) temp_fp, S2); + fmovi_rm (treg, (uae_u32) temp_fp); + return 1; + case 5: /* Double */ + readlong (S1, S2, S3); + mov_l_mr (((uae_u32) temp_fp) + 4, S2); + add_l_ri (S1, 4); + readlong (S1, S2, S3); + mov_l_mr ((uae_u32) (temp_fp), S2); + fmov_rm (treg, (uae_u32) (temp_fp)); + return 2; + case 6: /* Byte */ + readbyte (S1, S2, S3); + sign_extend_8_rr (S2, S2); + mov_l_mr ((uae_u32) temp_fp, S2); + fmovi_rm (treg, (uae_u32) temp_fp); + return 1; + default: + return -1; + } return -1; - } - return -1; } /* return of -1 means failure, >=0 means OK */ STATIC_INLINE int comp_fp_put (uae_u32 opcode, uae_u16 extra) { - int reg = opcode & 7; - int sreg = (extra >> 7) &7; - int mode = (opcode >> 3) & 7; - int size = (extra >> 10) & 7; + int reg = opcode & 7; + int sreg = (extra >> 7) & 7; + int mode = (opcode >> 3) & 7; + int size = (extra >> 10) & 7; - if (size == 3 || size == 7) /* 3 = packed decimal, 7 is not defined */ - return -1; - switch (mode) { - case 0: /* Dn */ - switch (size) { - case 0: /* FMOVE.L FPx, Dn */ + if (size == 3 || size == 7) /* 3 = packed decimal, 7 is not defined */ + return -1; + switch (mode) { + case 0: /* Dn */ + switch (size) { + case 0: /* FMOVE.L FPx, Dn */ #if USE_X86_FPUCW && 0 - if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */ - mov_l_ri(S1,0x10); /* use extended round to zero mode */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.l); - mov_l_rm(reg,(uae_u32)temp_fp); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - return 0; - } + if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */ + mov_l_ri(S1,0x10); /* use extended round to zero mode */ + fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.l); + mov_l_rm(reg,(uae_u32)temp_fp); + mov_l_rm(S1,(uae_u32)®s.fpcr); + and_l_ri(S1,0xf0); /* restore control word */ + fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + return 0; + } #endif - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.l); - mov_l_rm(reg,(uae_u32)temp_fp); - return 0; - case 1: /* FMOVE.S FPx, Dn */ - fmovs_mr((uae_u32)temp_fp,sreg); - mov_l_rm(reg,(uae_u32)temp_fp); - return 0; - case 4: /* FMOVE.W FPx, Dn */ + fmovi_mrb ((uae_u32) temp_fp, sreg, clamp_bounds.l); + mov_l_rm (reg, (uae_u32) temp_fp); + return 0; + case 1: /* FMOVE.S FPx, Dn */ + fmovs_mr ((uae_u32) temp_fp, sreg); + mov_l_rm (reg, (uae_u32) temp_fp); + return 0; + case 4: /* FMOVE.W FPx, Dn */ #if USE_X86_FPUCW && 0 - if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */ - mov_l_ri(S1,0x10); /* use extended round to zero mode */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.w); - mov_w_rm(reg,(uae_u32)temp_fp); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - return 0; - } + if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */ + mov_l_ri(S1,0x10); /* use extended round to zero mode */ + fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.w); + mov_w_rm(reg,(uae_u32)temp_fp); + mov_l_rm(S1,(uae_u32)®s.fpcr); + and_l_ri(S1,0xf0); /* restore control word */ + fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + return 0; + } #endif - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.w); - mov_w_rm(reg,(uae_u32)temp_fp); - return 0; - case 6: /* FMOVE.B FPx, Dn */ + fmovi_mrb ((uae_u32) temp_fp, sreg, clamp_bounds.w); + mov_w_rm (reg, (uae_u32) temp_fp); + return 0; + case 6: /* FMOVE.B FPx, Dn */ #if USE_X86_FPUCW && 0 - if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */ - mov_l_ri(S1,0x10); /* use extended round to zero mode */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.b); - mov_b_rm(reg,(uae_u32)temp_fp); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - return 0; - } + if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */ + mov_l_ri(S1,0x10); /* use extended round to zero mode */ + fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.b); + mov_b_rm(reg,(uae_u32)temp_fp); + mov_l_rm(S1,(uae_u32)®s.fpcr); + and_l_ri(S1,0xf0); /* restore control word */ + fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + return 0; + } #endif - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.b); - mov_b_rm(reg,(uae_u32)temp_fp); - return 0; - default: - return -1; + fmovi_mrb ((uae_u32) temp_fp, sreg, clamp_bounds.b); + mov_b_rm (reg, (uae_u32) temp_fp); + return 0; + default: + return -1; + } + case 1: /* An, invalid mode */ + return -1; + case 2: /* (An) */ + mov_l_rr (S1, reg + 8); + break; + case 3: /* (An)+ */ + mov_l_rr (S1, reg + 8); + lea_l_brr (reg + 8, reg + 8, (reg == 7 ? sz2[size] : sz1[size])); + break; + case 4: /* -(An) */ + lea_l_brr (reg + 8, reg + 8, -(reg == 7 ? sz2[size] : sz1[size])); + mov_l_rr (S1, reg + 8); + break; + case 5: /* (d16,An) */ + { + uae_u32 off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_rr (S1, reg + 8); + add_l_ri (S1, off); + break; + } + case 6: /* (d8,An,Xn) or (bd,An,Xn) or ([bd,An,Xn],od) or ([bd,An],Xn,od) */ + { + uae_u32 dp = comp_get_iword ((m68k_pc_offset += 2) - 2); + calc_disp_ea_020 (reg + 8, dp, S1, S2); + break; + } + case 7: + switch (reg) { + case 0: /* (xxx).W */ + { + uae_u32 off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_ri (S1, off); + break; + } + case 1: /* (xxx).L */ + { + uae_u32 off = comp_get_ilong ((m68k_pc_offset += 4) - 4); + mov_l_ri (S1, off); + break; + } + default: /* All other modes are not allowed for FPx to */ + write_log (_T ("JIT FMOVE FPx, Mode is not allowed %04x %04x\n"), opcode, extra); + return -1; + } } - case 1: /* An, invalid mode */ - return -1; - case 2: /* (An) */ - mov_l_rr(S1,reg+8); - break; - case 3: /* (An)+ */ - mov_l_rr(S1,reg+8); - lea_l_brr(reg+8,reg+8,(reg == 7?sz2[size]:sz1[size])); - break; - case 4: /* -(An) */ - lea_l_brr(reg+8,reg+8,-(reg == 7?sz2[size]:sz1[size])); - mov_l_rr(S1,reg+8); - break; - case 5: /* (d16,An) */ - { - uae_u32 off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_rr(S1,reg+8); - add_l_ri(S1,off); - break; - } - case 6: /* (d8,An,Xn) or (bd,An,Xn) or ([bd,An,Xn],od) or ([bd,An],Xn,od) */ - { - uae_u32 dp=comp_get_iword((m68k_pc_offset+=2)-2); - calc_disp_ea_020(reg+8,dp,S1,S2); - break; - } - case 7: - switch (reg) { - case 0: /* (xxx).W */ - { - uae_u32 off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_ri(S1,off); - break; - } - case 1: /* (xxx).L */ - { - uae_u32 off=comp_get_ilong((m68k_pc_offset+=4)-4); - mov_l_ri(S1,off); - break; - } - default: /* All other modes are not allowed for FPx to */ - write_log (_T("JIT FMOVE FPx, Mode is not allowed %04x %04x\n"),opcode,extra); - return -1; + switch (size) { + case 0: /* Long */ + fmovi_mrb ((uae_u32) temp_fp, sreg, clamp_bounds.l); + mov_l_rm (S2, (uae_u32) temp_fp); + writelong_clobber (S1, S2, S3); + return 0; + case 1: /* Single */ + fmovs_mr ((uae_u32) temp_fp, sreg); + mov_l_rm (S2, (uae_u32) temp_fp); + writelong_clobber (S1, S2, S3); + return 0; + case 2:/* Long Double */ + fmov_ext_mr ((uae_u32) temp_fp, sreg); + mov_w_rm (S2, (uae_u32) temp_fp + 8); + writeword_clobber (S1, S2, S3); + add_l_ri (S1, 4); + mov_l_rm (S2, (uae_u32) temp_fp + 4); + writelong_clobber (S1, S2, S3); + add_l_ri (S1, 4); + mov_l_rm (S2, (uae_u32) temp_fp); + writelong_clobber (S1, S2, S3); + return 0; + case 4: /* Word */ + fmovi_mrb ((uae_u32) temp_fp, sreg, clamp_bounds.w); + mov_l_rm (S2, (uae_u32) temp_fp); + writeword_clobber (S1, S2, S3); + return 0; + case 5: /* Double */ + fmov_mr ((uae_u32) temp_fp, sreg); + mov_l_rm (S2, (uae_u32) temp_fp + 4); + writelong_clobber (S1, S2, S3); + add_l_ri (S1, 4); + mov_l_rm (S2, (uae_u32) temp_fp); + writelong_clobber (S1, S2, S3); + return 0; + case 6: /* Byte */ + fmovi_mrb ((uae_u32) temp_fp, sreg, clamp_bounds.b); + mov_l_rm (S2, (uae_u32) temp_fp); + writebyte (S1, S2, S3); + return 0; + default: + return -1; } - } - switch (size) { - case 0: /* Long */ - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.l); - mov_l_rm(S2,(uae_u32)temp_fp); - writelong_clobber(S1,S2,S3); - return 0; - case 1: /* Single */ - fmovs_mr((uae_u32)temp_fp,sreg); - mov_l_rm(S2,(uae_u32)temp_fp); - writelong_clobber(S1,S2,S3); - return 0; - case 2:/* Long Double */ - fmov_ext_mr((uae_u32)temp_fp,sreg); - mov_w_rm(S2,(uae_u32)temp_fp+8); - writeword_clobber(S1,S2,S3); - add_l_ri(S1,4); - mov_l_rm(S2,(uae_u32)temp_fp+4); - writelong_clobber(S1,S2,S3); - add_l_ri(S1,4); - mov_l_rm(S2,(uae_u32)temp_fp); - writelong_clobber(S1,S2,S3); - return 0; - case 4: /* Word */ - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.w); - mov_l_rm(S2,(uae_u32)temp_fp); - writeword_clobber(S1,S2,S3); - return 0; - case 5: /* Double */ - fmov_mr((uae_u32)temp_fp,sreg); - mov_l_rm(S2,(uae_u32)temp_fp+4); - writelong_clobber(S1,S2,S3); - add_l_ri(S1,4); - mov_l_rm(S2,(uae_u32)temp_fp); - writelong_clobber(S1,S2,S3); - return 0; - case 6: /* Byte */ - fmovi_mrb((uae_u32)temp_fp,sreg, clamp_bounds.b); - mov_l_rm(S2,(uae_u32)temp_fp); - writebyte(S1,S2,S3); - return 0; - default: return -1; - } - return -1; } /* return -1 for failure, or register number for success */ STATIC_INLINE int comp_fp_adr (uae_u32 opcode) { - uae_s32 off; - int mode = (opcode >> 3) & 7; - int reg = opcode & 7; + uae_s32 off; + int mode = (opcode >> 3) & 7; + int reg = opcode & 7; - switch (mode) { - case 2: - case 3: - case 4: - mov_l_rr(S1,8+reg); - return S1; - case 5: - off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_rr(S1,8+reg); - add_l_ri(S1,off); - return S1; - case 7: - switch (reg) { - case 0: - off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - mov_l_ri(S1,off); - return S1; - case 1: - off=comp_get_ilong((m68k_pc_offset+=4)-4); - mov_l_ri(S1,off); - return S1; + switch (mode) { + case 2: + case 3: + case 4: + mov_l_rr (S1, 8 + reg); + return S1; + case 5: + off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_rr (S1, 8 + reg); + add_l_ri (S1, off); + return S1; + case 7: + switch (reg) { + case 0: + off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + mov_l_ri (S1, off); + return S1; + case 1: + off = comp_get_ilong ((m68k_pc_offset += 4) - 4); + mov_l_ri (S1, off); + return S1; + } + default: + return -1; } - default: - return -1; - } } void comp_fdbcc_opp (uae_u32 opcode, uae_u16 extra) { - FAIL(1); - return; + FAIL (1); + return; } void comp_fscc_opp (uae_u32 opcode, uae_u16 extra) { - uae_u32 ad; - int cc; - int reg; + uae_u32 ad; + int cc; + int reg; - if (!currprefs.compfpu) { - FAIL(1); - return; - } + if (!currprefs.compfpu) { + FAIL (1); + return; + } #if DEBUG_FPP - write_log (_T("JIT: fscc_opp at %08lx\n"), M68K_GETPC); + write_log (_T("JIT: fscc_opp at %08lx\n"), M68K_GETPC); #endif - if (extra&0x20) { /* only cc from 00 to 1f are defined */ - FAIL(1); - return; - } - if ((opcode & 0x38) != 0) { /* We can only do to integer register */ - FAIL(1); - return; - } + if (extra & 0x20) { /* only cc from 00 to 1f are defined */ + FAIL (1); + return; + } + if ((opcode & 0x38) != 0) { /* We can only do to integer register */ + FAIL (1); + return; + } - fflags_into_flags(S2); - reg=(opcode&7); + fflags_into_flags (S2); + reg = (opcode & 7); - mov_l_ri(S1,255); - mov_l_ri(S4,0); - switch(extra&0x0f) { /* according to fpp.c, the 0x10 bit is ignored */ - case 0: break; /* set never */ - case 1: mov_l_rr(S2,S4); - cmov_l_rr(S4,S1,4); - cmov_l_rr(S4,S2,10); break; - case 2: cmov_l_rr(S4,S1,7); break; - case 3: cmov_l_rr(S4,S1,3); break; - case 4: mov_l_rr(S2,S4); - cmov_l_rr(S4,S1,2); - cmov_l_rr(S4,S2,10); break; - case 5: mov_l_rr(S2,S4); - cmov_l_rr(S4,S1,6); - cmov_l_rr(S4,S2,10); break; - case 6: cmov_l_rr(S4,S1,5); break; - case 7: cmov_l_rr(S4,S1,11); break; - case 8: cmov_l_rr(S4,S1,10); break; - case 9: cmov_l_rr(S4,S1,4); break; - case 10: cmov_l_rr(S4,S1,10); cmov_l_rr(S4,S1,7); break; - case 11: cmov_l_rr(S4,S1,4); cmov_l_rr(S4,S1,3); break; - case 12: cmov_l_rr(S4,S1,2); break; - case 13: cmov_l_rr(S4,S1,6); break; - case 14: cmov_l_rr(S4,S1,5); cmov_l_rr(S4,S1,10); break; - case 15: mov_l_rr(S4,S1); break; - } + mov_l_ri (S1, 255); + mov_l_ri (S4, 0); + switch (extra & 0x0f) { /* according to fpp.c, the 0x10 bit is ignored */ + case 0: break; /* set never */ + case 1: mov_l_rr (S2, S4); + cmov_l_rr (S4, S1, 4); + cmov_l_rr (S4, S2, 10); break; + case 2: cmov_l_rr (S4, S1, 7); break; + case 3: cmov_l_rr (S4, S1, 3); break; + case 4: mov_l_rr (S2, S4); + cmov_l_rr (S4, S1, 2); + cmov_l_rr (S4, S2, 10); break; + case 5: mov_l_rr (S2, S4); + cmov_l_rr (S4, S1, 6); + cmov_l_rr (S4, S2, 10); break; + case 6: cmov_l_rr (S4, S1, 5); break; + case 7: cmov_l_rr (S4, S1, 11); break; + case 8: cmov_l_rr (S4, S1, 10); break; + case 9: cmov_l_rr (S4, S1, 4); break; + case 10: cmov_l_rr (S4, S1, 10); cmov_l_rr (S4, S1, 7); break; + case 11: cmov_l_rr (S4, S1, 4); cmov_l_rr (S4, S1, 3); break; + case 12: cmov_l_rr (S4, S1, 2); break; + case 13: cmov_l_rr (S4, S1, 6); break; + case 14: cmov_l_rr (S4, S1, 5); cmov_l_rr (S4, S1, 10); break; + case 15: mov_l_rr (S4, S1); break; + } - if (!(opcode & 0x38)) - mov_b_rr(reg,S4); + if (!(opcode & 0x38)) + mov_b_rr (reg, S4); #if 0 - else { - abort(); - if (!comp_fp_adr (opcode)) { - m68k_setpc (m68k_getpc () - 4); - op_illg (opcode); + else { + abort(); + if (!comp_fp_adr (opcode)) { + m68k_setpc (m68k_getpc () - 4); + op_illg (opcode); + } + else + put_byte (ad, cc ? 0xff : 0x00); } - else - put_byte (ad, cc ? 0xff : 0x00); - } #endif } void comp_ftrapcc_opp (uae_u32 opcode, uaecptr oldpc) { - FAIL(1); - return; + FAIL (1); + return; } extern unsigned long foink3, oink; void comp_fbcc_opp (uae_u32 opcode) { - uae_u32 start_68k_offset=m68k_pc_offset; - uae_u32 off, v1, v2; - int cc; + uae_u32 start_68k_offset = m68k_pc_offset; + uae_u32 off, v1, v2; + int cc; - if (!currprefs.compfpu) { - FAIL(1); - return; - } + if (!currprefs.compfpu) { + FAIL (1); + return; + } - if (opcode&0x20) { /* only cc from 00 to 1f are defined */ - FAIL(1); - return; - } - if (!(opcode&0x40)) { - off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); - } - else { - off=comp_get_ilong((m68k_pc_offset+=4)-4); - } - mov_l_ri(S1,(uae_u32) - (comp_pc_p+off-(m68k_pc_offset-start_68k_offset))); - mov_l_ri(PC_P,(uae_u32)comp_pc_p); + if (opcode & 0x20) { /* only cc from 00 to 1f are defined */ + FAIL (1); + return; + } + if (!(opcode & 0x40)) { + off = (uae_s32) (uae_s16) comp_get_iword ((m68k_pc_offset += 2) - 2); + } + else { + off = comp_get_ilong ((m68k_pc_offset += 4) - 4); + } + mov_l_ri (S1, (uae_u32) + (comp_pc_p + off - (m68k_pc_offset - start_68k_offset))); + mov_l_ri (PC_P, (uae_u32) comp_pc_p); - /* Now they are both constant. Might as well fold in m68k_pc_offset */ - add_l_ri(S1,m68k_pc_offset); - add_l_ri(PC_P,m68k_pc_offset); - m68k_pc_offset=0; + /* Now they are both constant. Might as well fold in m68k_pc_offset */ + add_l_ri (S1, m68k_pc_offset); + add_l_ri (PC_P, m68k_pc_offset); + m68k_pc_offset = 0; - /* according to fpp.c, the 0x10 bit is ignored - (it handles exception handling, which we don't - do, anyway ;-) */ - cc=opcode&0x0f; - v1=get_const(PC_P); - v2=get_const(S1); - fflags_into_flags(S2); + /* according to fpp.c, the 0x10 bit is ignored + (it handles exception handling, which we don't + do, anyway ;-) */ + cc = opcode & 0x0f; + v1 = get_const (PC_P); + v2 = get_const (S1); + fflags_into_flags (S2); - // mov_l_mi((uae_u32)&foink3,cc); - switch(cc) { - case 0: break; /* jump never */ - case 1: - mov_l_rr(S2,PC_P); - cmov_l_rr(PC_P,S1,4); - cmov_l_rr(PC_P,S2,10); break; - case 2: register_branch(v1,v2,7); break; - case 3: register_branch(v1,v2,3); break; - case 4: - mov_l_rr(S2,PC_P); - cmov_l_rr(PC_P,S1,2); - cmov_l_rr(PC_P,S2,10); break; - case 5: - mov_l_rr(S2,PC_P); - cmov_l_rr(PC_P,S1,6); - cmov_l_rr(PC_P,S2,10); break; - case 6: register_branch(v1,v2,5); break; - case 7: register_branch(v1,v2,11); break; - case 8: register_branch(v1,v2,10); break; - case 9: register_branch(v1,v2,4); break; - case 10: - cmov_l_rr(PC_P,S1,10); - cmov_l_rr(PC_P,S1,7); break; - case 11: - cmov_l_rr(PC_P,S1,4); - cmov_l_rr(PC_P,S1,3); break; - case 12: register_branch(v1,v2,2); break; - case 13: register_branch(v1,v2,6); break; - case 14: - cmov_l_rr(PC_P,S1,5); - cmov_l_rr(PC_P,S1,10); break; - case 15: mov_l_rr(PC_P,S1); break; - } + // mov_l_mi((uae_u32)&foink3,cc); + switch (cc) { + case 0: break; /* jump never */ + case 1: + mov_l_rr (S2, PC_P); + cmov_l_rr (PC_P, S1, 4); + cmov_l_rr (PC_P, S2, 10); break; + case 2: register_branch (v1, v2, 7); break; + case 3: register_branch (v1, v2, 3); break; + case 4: + mov_l_rr (S2, PC_P); + cmov_l_rr (PC_P, S1, 2); + cmov_l_rr (PC_P, S2, 10); break; + case 5: + mov_l_rr (S2, PC_P); + cmov_l_rr (PC_P, S1, 6); + cmov_l_rr (PC_P, S2, 10); break; + case 6: register_branch (v1, v2, 5); break; + case 7: register_branch (v1, v2, 11); break; + case 8: register_branch (v1, v2, 10); break; + case 9: register_branch (v1, v2, 4); break; + case 10: + cmov_l_rr (PC_P, S1, 10); + cmov_l_rr (PC_P, S1, 7); break; + case 11: + cmov_l_rr (PC_P, S1, 4); + cmov_l_rr (PC_P, S1, 3); break; + case 12: register_branch (v1, v2, 2); break; + case 13: register_branch (v1, v2, 6); break; + case 14: + cmov_l_rr (PC_P, S1, 5); + cmov_l_rr (PC_P, S1, 10); break; + case 15: mov_l_rr (PC_P, S1); break; + } } - /* Floating point conditions - The "NotANumber" part could be problematic; Howver, when NaN is - encountered, the ftst instruction sets bot N and Z to 1 on the x87, - so quite often things just fall into place. This is probably not - accurate wrt the 68k FPU, but it is *as* accurate as this was before. - However, some more thought should go into fixing this stuff up so - it accurately emulates the 68k FPU. ->====> 7) & 7; - int source = (extra >> 13) & 7; - int opmode = extra & 0x7f; + int reg; + int sreg, prec = 0; + int dreg = (extra >> 7) & 7; + int source = (extra >> 13) & 7; + int opmode = extra & 0x7f; - if (!currprefs.compfpu) { - FAIL(1); - return; - } - switch (source) { - case 3: /* FMOVE FPx, */ - if (comp_fp_put(opcode,extra) < 0) - FAIL(1); - return; - case 4: /* FMOVE.L , ControlReg */ - if (!(opcode & 0x30)) { /* Dn or An */ - if (extra & 0x1000) { /* FPCR */ - mov_l_mr((uae_u32)®s.fpcr,opcode & 15); + if (!currprefs.compfpu) { + FAIL (1); + return; + } + switch (source) { + case 3: /* FMOVE FPx, */ + if (comp_fp_put (opcode, extra) < 0) + FAIL (1); + return; + case 4: /* FMOVE.L , ControlReg */ + if (!(opcode & 0x30)) { /* Dn or An */ + if (extra & 0x1000) { /* FPCR */ + mov_l_mr ((uae_u32) ®s.fpcr, opcode & 15); #if USE_X86_FPUCW - mov_l_rr(S1,opcode & 15); - and_l_ri(S1,0xf0); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + mov_l_rr (S1, opcode & 15); + and_l_ri (S1, 0xf0); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); #endif - return; - } - if (extra & 0x0800) { /* FPSR */ - FAIL(1); - return; - // set_fpsr(m68k_dreg (regs, opcode & 15)); - } - if (extra & 0x0400) { /* FPIAR */ - mov_l_mr((uae_u32)®s.fpiar,opcode & 15); return; + return; + } + if (extra & 0x0800) { /* FPSR */ + FAIL (1); + return; + // set_fpsr(m68k_dreg (regs, opcode & 15)); + } + if (extra & 0x0400) { /* FPIAR */ + mov_l_mr ((uae_u32) ®s.fpiar, opcode & 15); return; + } } - } - else if ((opcode & 0x3f) == 0x3c) { - if (extra & 0x1000) { /* FPCR */ - uae_u32 val=comp_get_ilong((m68k_pc_offset+=4)-4); - mov_l_mi((uae_u32)®s.fpcr,val); + else if ((opcode & 0x3f) == 0x3c) { + if (extra & 0x1000) { /* FPCR */ + uae_u32 val = comp_get_ilong ((m68k_pc_offset += 4) - 4); + mov_l_mi ((uae_u32) ®s.fpcr, val); #if USE_X86_FPUCW - mov_l_ri(S1,val&0xf0); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + mov_l_ri (S1, val & 0xf0); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); #endif - return; - } - if (extra & 0x0800) { /* FPSR */ - FAIL(1); - return; - } - if (extra & 0x0400) { /* FPIAR */ - uae_u32 val=comp_get_ilong((m68k_pc_offset+=4)-4); - mov_l_mi((uae_u32)®s.fpiar,val); - return; - } - } - FAIL(1); - return; - case 5: /* FMOVE.L ControlReg, */ - if (!(opcode & 0x30)) { /* Dn or An */ - if (extra & 0x1000) { /* FPCR */ - mov_l_rm(opcode & 15,(uae_u32)®s.fpcr); return; - } - if (extra & 0x0800) { /* FPSR */ - FAIL(1); - return; + return; + } + if (extra & 0x0800) { /* FPSR */ + FAIL (1); + return; + } + if (extra & 0x0400) { /* FPIAR */ + uae_u32 val = comp_get_ilong ((m68k_pc_offset += 4) - 4); + mov_l_mi ((uae_u32) ®s.fpiar, val); + return; + } } - if (extra & 0x0400) { /* FPIAR */ - mov_l_rm(opcode & 15,(uae_u32)®s.fpiar); return; + FAIL (1); + return; + case 5: /* FMOVE.L ControlReg, */ + if (!(opcode & 0x30)) { /* Dn or An */ + if (extra & 0x1000) { /* FPCR */ + mov_l_rm (opcode & 15, (uae_u32) ®s.fpcr); return; + } + if (extra & 0x0800) { /* FPSR */ + FAIL (1); + return; + } + if (extra & 0x0400) { /* FPIAR */ + mov_l_rm (opcode & 15, (uae_u32) ®s.fpiar); return; + } } - } - FAIL(1); - return; - case 6: - case 7: - { - uae_u32 list = 0; - int incr = 0; - if (extra & 0x2000) { - uae_u32 ad; + FAIL (1); + return; + case 6: + case 7: + { + uae_u32 list = 0; + int incr = 0; + if (extra & 0x2000) { + uae_u32 ad; - /* FMOVEM FPP->memory */ - switch ((extra >> 11) & 3) { /* Get out early if failure */ - case 0: - case 2: - break; - case 1: - case 3: - default: - FAIL(1); return; - } - ad=comp_fp_adr (opcode); - if (ad<0) { - m68k_setpc (m68k_getpc () - 4); - op_illg (opcode); - return; - } - switch ((extra >> 11) & 3) { - case 0: /* static pred */ - list = extra & 0xff; - incr = -1; - break; - case 2: /* static postinc */ - list = extra & 0xff; - incr = 1; - break; - case 1: /* dynamic pred */ - case 3: /* dynamic postinc */ - abort(); - } - if (incr < 0) { /* Predecrement */ - for (reg = 7; reg >= 0; reg--) { - if (list & 0x80) { - fmov_ext_mr((uintptr)temp_fp,reg); - sub_l_ri(ad,4); - mov_l_rm(S2,(uintptr)temp_fp); - writelong_clobber(ad,S2,S3); - sub_l_ri(ad,4); - mov_l_rm(S2,(uintptr)temp_fp+4); - writelong_clobber(ad,S2,S3); - sub_l_ri(ad,4); - mov_w_rm(S2,(uintptr)temp_fp+8); - writeword_clobber(ad,S2,S3); + /* FMOVEM FPP->memory */ + switch ((extra >> 11) & 3) { /* Get out early if failure */ + case 0: + case 2: + break; + case 1: + case 3: + default: + FAIL (1); return; + } + ad = comp_fp_adr (opcode); + if (ad < 0) { + m68k_setpc (m68k_getpc () - 4); + op_illg (opcode); + return; + } + switch ((extra >> 11) & 3) { + case 0: /* static pred */ + list = extra & 0xff; + incr = -1; + break; + case 2: /* static postinc */ + list = extra & 0xff; + incr = 1; + break; + case 1: /* dynamic pred */ + case 3: /* dynamic postinc */ + abort (); + } + if (incr < 0) { /* Predecrement */ + for (reg = 7; reg >= 0; reg--) { + if (list & 0x80) { + fmov_ext_mr ((uintptr) temp_fp, reg); + sub_l_ri (ad, 4); + mov_l_rm (S2, (uintptr) temp_fp); + writelong_clobber (ad, S2, S3); + sub_l_ri (ad, 4); + mov_l_rm (S2, (uintptr) temp_fp + 4); + writelong_clobber (ad, S2, S3); + sub_l_ri (ad, 4); + mov_w_rm (S2, (uintptr) temp_fp + 8); + writeword_clobber (ad, S2, S3); + } + list <<= 1; + } + } + else { /* Postincrement */ + for (reg = 0; reg <= 7; reg++) { + if (list & 0x80) { + fmov_ext_mr ((uintptr) temp_fp, reg); + mov_w_rm (S2, (uintptr) temp_fp + 8); + writeword_clobber (ad, S2, S3); + add_l_ri (ad, 4); + mov_l_rm (S2, (uintptr) temp_fp + 4); + writelong_clobber (ad, S2, S3); + add_l_ri (ad, 4); + mov_l_rm (S2, (uintptr) temp_fp); + writelong_clobber (ad, S2, S3); + add_l_ri (ad, 4); + } + list <<= 1; + } + } + if ((opcode & 0x38) == 0x18) + mov_l_rr ((opcode & 7) + 8, ad); + if ((opcode & 0x38) == 0x20) + mov_l_rr ((opcode & 7) + 8, ad); + } + else { + /* FMOVEM memory->FPP */ + + uae_u32 ad; + switch ((extra >> 11) & 3) { /* Get out early if failure */ + case 0: + case 2: + break; + case 1: + case 3: + default: + FAIL (1); return; + } + ad = comp_fp_adr (opcode); + if (ad < 0) { + m68k_setpc (m68k_getpc () - 4); + op_illg (opcode); + return; + } + switch ((extra >> 11) & 3) { + case 0: /* static pred */ + list = extra & 0xff; + incr = -1; + break; + case 2: /* static postinc */ + list = extra & 0xff; + incr = 1; + break; + case 1: /* dynamic pred */ + case 3: /* dynamic postinc */ + abort (); + } + + if (incr < 0) { + // not reached + for (reg = 7; reg >= 0; reg--) { + if (list & 0x80) { + sub_l_ri (ad, 4); + readlong (ad, S2, S3); + mov_l_mr ((uintptr) (temp_fp), S2); + sub_l_ri (ad, 4); + readlong (ad, S2, S3); + mov_l_mr ((uintptr) (temp_fp) +4, S2); + sub_l_ri (ad, 4); + readword (ad, S2, S3); + mov_w_mr (((uintptr) temp_fp) + 8, S2); + fmov_ext_rm (reg, (uintptr) (temp_fp)); + } + list <<= 1; + } } - list <<= 1; + else { + for (reg = 0; reg <= 7; reg++) { + if (list & 0x80) { + readword (ad, S2, S3); + mov_w_mr (((uintptr) temp_fp) + 8, S2); + add_l_ri (ad, 4); + readlong (ad, S2, S3); + mov_l_mr ((uintptr) (temp_fp) +4, S2); + add_l_ri (ad, 4); + readlong (ad, S2, S3); + mov_l_mr ((uintptr) (temp_fp), S2); + add_l_ri (ad, 4); + fmov_ext_rm (reg, (uintptr) (temp_fp)); + } + list <<= 1; + } + } + if ((opcode & 0x38) == 0x18) + mov_l_rr ((opcode & 7) + 8, ad); + if ((opcode & 0x38) == 0x20) + mov_l_rr ((opcode & 7) + 8, ad); } } - else { /* Postincrement */ - for (reg = 0; reg <= 7; reg++) { - if (list & 0x80) { - fmov_ext_mr((uintptr)temp_fp,reg); - mov_w_rm(S2,(uintptr)temp_fp+8); - writeword_clobber(ad,S2,S3); + return; +#if 0 + case 6: /* FMOVEM , FPx-FPz */ + if (!(extra & 0x0800)) { + uae_u32 list = extra & 0xff; + int ad; + if ((ad = comp_fp_adr(opcode)) < 0) {FAIL(1);return;} + while (list) { + if (extra & 0x1000) { /* postincrement */ + readword(ad,S2,S3); + mov_w_mr(((uae_u32)temp_fp)+8,S2); add_l_ri(ad,4); - mov_l_rm(S2,(uintptr)temp_fp+4); - writelong_clobber(ad,S2,S3); + readlong(ad,S2,S3); + mov_l_mr((uae_u32)(temp_fp)+4,S2); add_l_ri(ad,4); - mov_l_rm(S2,(uintptr)temp_fp); - writelong_clobber(ad,S2,S3); + readlong(ad,S2,S3); + mov_l_mr((uae_u32)(temp_fp),S2); add_l_ri(ad,4); - } - list <<= 1; - } - } - if ((opcode & 0x38) == 0x18) - mov_l_rr((opcode & 7)+8,ad); - if ((opcode & 0x38) == 0x20) - mov_l_rr((opcode & 7)+8,ad); - } else { - /* FMOVEM memory->FPP */ - - uae_u32 ad; - switch ((extra >> 11) & 3) { /* Get out early if failure */ - case 0: - case 2: - break; - case 1: - case 3: - default: - FAIL(1); return; - } - ad=comp_fp_adr (opcode); - if (ad<0) { - m68k_setpc (m68k_getpc () - 4); - op_illg (opcode); - return; - } - switch ((extra >> 11) & 3) { - case 0: /* static pred */ - list = extra & 0xff; - incr = -1; - break; - case 2: /* static postinc */ - list = extra & 0xff; - incr = 1; - break; - case 1: /* dynamic pred */ - case 3: /* dynamic postinc */ - abort(); - } - - if (incr < 0) { - // not reached - for (reg = 7; reg >= 0; reg--) { - if (list & 0x80) { + fmov_ext_rm(fpp_movem_index1[list],(uae_u32)(temp_fp)); + } else { /* predecrement */ sub_l_ri(ad,4); readlong(ad,S2,S3); - mov_l_mr((uintptr)(temp_fp),S2); + mov_l_mr((uae_u32)(temp_fp),S2); sub_l_ri(ad,4); readlong(ad,S2,S3); - mov_l_mr((uintptr)(temp_fp)+4,S2); + mov_l_mr((uae_u32)(temp_fp)+4,S2); sub_l_ri(ad,4); readword(ad,S2,S3); - mov_w_mr(((uintptr)temp_fp)+8,S2); - fmov_ext_rm(reg,(uintptr)(temp_fp)); + mov_w_mr(((uae_u32)temp_fp)+8,S2); + fmov_ext_rm(fpp_movem_index2[list],(uae_u32)(temp_fp)); } - list <<= 1; + list = fpp_movem_next[list]; } - } - else { - for (reg = 0; reg <= 7; reg++) { - if (list & 0x80) { - readword(ad,S2,S3); - mov_w_mr(((uintptr)temp_fp)+8,S2); + if ((opcode & 0x38) == 0x18) + mov_l_rr((opcode & 7)+8,ad); + return; + } /* no break for dynamic register list */ + case 7: /* FMOVEM FPx-FPz, */ + if (!(extra & 0x0800)) { + uae_u32 list = extra & 0xff; + int ad; + if ((ad = comp_fp_adr(opcode)) < 0) {FAIL(1);return;} + while (list) { + if (extra & 0x1000) { /* postincrement */ + fmov_ext_mr((uae_u32)temp_fp,fpp_movem_index2[list]); + mov_w_rm(S2,(uae_u32)temp_fp+8); + writeword_clobber(ad,S2,S3); add_l_ri(ad,4); - readlong(ad,S2,S3); - mov_l_mr((uintptr)(temp_fp)+4,S2); + mov_l_rm(S2,(uae_u32)temp_fp+4); + writelong_clobber(ad,S2,S3); add_l_ri(ad,4); - readlong(ad,S2,S3); - mov_l_mr((uintptr)(temp_fp),S2); + mov_l_rm(S2,(uae_u32)temp_fp); + writelong_clobber(ad,S2,S3); add_l_ri(ad,4); - fmov_ext_rm(reg,(uintptr)(temp_fp)); + } else { /* predecrement */ + fmov_ext_mr((uae_u32)temp_fp,fpp_movem_index2[list]); + sub_l_ri(ad,4); + mov_l_rm(S2,(uae_u32)temp_fp); + writelong_clobber(ad,S2,S3); + sub_l_ri(ad,4); + mov_l_rm(S2,(uae_u32)temp_fp+4); + writelong_clobber(ad,S2,S3); + sub_l_ri(ad,4); + mov_w_rm(S2,(uae_u32)temp_fp+8); + writeword_clobber(ad,S2,S3); } - list <<= 1; + list = fpp_movem_next[list]; } + if ((opcode & 0x38) == 0x20) + mov_l_rr((opcode & 7)+8,ad); + return; + } /* no break */ + write_log (_T("fallback from JIT FMOVEM dynamic register list\n")); + FAIL(1); + return; +#endif + case 2: /* from to FPx */ + dont_care_fflags (); + if ((extra & 0xfc00) == 0x5c00) { /* FMOVECR */ + //write_log (_T("JIT FMOVECR %x\n"), opmode); + switch (opmode) { + case 0x00: + fmov_pi (dreg); + break; + case 0x0b: + fmov_ext_rm (dreg, (uae_u32) &xhex_l10_2); + break; + case 0x0c: + fmov_ext_rm (dreg, (uae_u32) &xhex_exp_1); + break; + case 0x0d: + fmov_log2_e (dreg); + break; + case 0x0e: + fmov_ext_rm (dreg, (uae_u32) &xhex_l10_e); + break; + case 0x0f: + fmov_0 (dreg); + break; + case 0x30: + fmov_loge_2 (dreg); + break; + case 0x31: + fmov_ext_rm (dreg, (uae_u32) &xhex_ln_10); + break; + case 0x32: + fmov_1 (dreg); + break; + case 0x33: + fmovs_rm (dreg, (uae_u32) &fp_1e1); + break; + case 0x34: + fmovs_rm (dreg, (uae_u32) &fp_1e2); + break; + case 0x35: + fmovs_rm (dreg, (uae_u32) &fp_1e4); + break; + case 0x36: + fmov_rm (dreg, (uae_u32) &fp_1e8); + break; + case 0x37: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e16); + break; + case 0x38: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e32); + break; + case 0x39: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e64); + break; + case 0x3a: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e128); + break; + case 0x3b: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e256); + break; + case 0x3c: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e512); + break; + case 0x3d: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e1024); + break; + case 0x3e: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e2048); + break; + case 0x3f: + fmov_ext_rm (dreg, (uae_u32) &xhex_1e4096); + break; + default: + FAIL (1); + return; + } + fmov_rr (FP_RESULT, dreg); + return; } - if ((opcode & 0x38) == 0x18) - mov_l_rr((opcode & 7)+8,ad); - if ((opcode & 0x38) == 0x20) - mov_l_rr((opcode & 7)+8,ad); - } - } - return; -#if 0 - case 6: /* FMOVEM , FPx-FPz */ - if (!(extra & 0x0800)) { - uae_u32 list = extra & 0xff; - int ad; - if ((ad = comp_fp_adr(opcode)) < 0) {FAIL(1);return;} - while (list) { - if (extra & 0x1000) { /* postincrement */ - readword(ad,S2,S3); - mov_w_mr(((uae_u32)temp_fp)+8,S2); - add_l_ri(ad,4); - readlong(ad,S2,S3); - mov_l_mr((uae_u32)(temp_fp)+4,S2); - add_l_ri(ad,4); - readlong(ad,S2,S3); - mov_l_mr((uae_u32)(temp_fp),S2); - add_l_ri(ad,4); - fmov_ext_rm(fpp_movem_index1[list],(uae_u32)(temp_fp)); - } else { /* predecrement */ - sub_l_ri(ad,4); - readlong(ad,S2,S3); - mov_l_mr((uae_u32)(temp_fp),S2); - sub_l_ri(ad,4); - readlong(ad,S2,S3); - mov_l_mr((uae_u32)(temp_fp)+4,S2); - sub_l_ri(ad,4); - readword(ad,S2,S3); - mov_w_mr(((uae_u32)temp_fp)+8,S2); - fmov_ext_rm(fpp_movem_index2[list],(uae_u32)(temp_fp)); + if (opmode & 0x20) /* two operands, so we need a scratch reg */ + sreg = FS1; + else /* one operand only, thus we can load the argument into dreg */ + sreg = dreg; + if ((prec = comp_fp_get (opcode, extra, sreg)) < 0) { + FAIL (1); + return; } - list = fpp_movem_next[list]; - } - if ((opcode & 0x38) == 0x18) - mov_l_rr((opcode & 7)+8,ad); - return; - } /* no break for dynamic register list */ - case 7: /* FMOVEM FPx-FPz, */ - if (!(extra & 0x0800)) { - uae_u32 list = extra & 0xff; - int ad; - if ((ad = comp_fp_adr(opcode)) < 0) {FAIL(1);return;} - while (list) { - if (extra & 0x1000) { /* postincrement */ - fmov_ext_mr((uae_u32)temp_fp,fpp_movem_index2[list]); - mov_w_rm(S2,(uae_u32)temp_fp+8); - writeword_clobber(ad,S2,S3); - add_l_ri(ad,4); - mov_l_rm(S2,(uae_u32)temp_fp+4); - writelong_clobber(ad,S2,S3); - add_l_ri(ad,4); - mov_l_rm(S2,(uae_u32)temp_fp); - writelong_clobber(ad,S2,S3); - add_l_ri(ad,4); - } else { /* predecrement */ - fmov_ext_mr((uae_u32)temp_fp,fpp_movem_index2[list]); - sub_l_ri(ad,4); - mov_l_rm(S2,(uae_u32)temp_fp); - writelong_clobber(ad,S2,S3); - sub_l_ri(ad,4); - mov_l_rm(S2,(uae_u32)temp_fp+4); - writelong_clobber(ad,S2,S3); - sub_l_ri(ad,4); - mov_w_rm(S2,(uae_u32)temp_fp+8); - writeword_clobber(ad,S2,S3); + if (!opmode) { /* FMOVE ,FPx */ + fmov_rr (FP_RESULT, dreg); + return; } - list = fpp_movem_next[list]; - } - if ((opcode & 0x38) == 0x20) - mov_l_rr((opcode & 7)+8,ad); - return; - } /* no break */ - write_log (_T("fallback from JIT FMOVEM dynamic register list\n")); - FAIL(1); - return; -#endif - case 2: /* from to FPx */ - dont_care_fflags(); - if ((extra & 0xfc00) == 0x5c00) { /* FMOVECR */ - //write_log (_T("JIT FMOVECR %x\n"), opmode); - switch (opmode) { - case 0x00: - fmov_pi(dreg); - break; - case 0x0b: - fmov_ext_rm(dreg,(uae_u32)&xhex_l10_2); - break; - case 0x0c: - fmov_ext_rm(dreg,(uae_u32)&xhex_exp_1); - break; - case 0x0d: - fmov_log2_e(dreg); - break; - case 0x0e: - fmov_ext_rm(dreg,(uae_u32)&xhex_l10_e); - break; - case 0x0f: - fmov_0(dreg); - break; - case 0x30: - fmov_loge_2(dreg); - break; - case 0x31: - fmov_ext_rm(dreg,(uae_u32)&xhex_ln_10); - break; - case 0x32: - fmov_1(dreg); - break; - case 0x33: - fmovs_rm(dreg,(uae_u32)&fp_1e1); - break; - case 0x34: - fmovs_rm(dreg,(uae_u32)&fp_1e2); - break; - case 0x35: - fmovs_rm(dreg,(uae_u32)&fp_1e4); - break; - case 0x36: - fmov_rm(dreg,(uae_u32)&fp_1e8); - break; - case 0x37: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e16); - break; - case 0x38: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e32); - break; - case 0x39: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e64); - break; - case 0x3a: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e128); - break; - case 0x3b: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e256); - break; - case 0x3c: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e512); - break; - case 0x3d: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e1024); - break; - case 0x3e: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e2048); - break; - case 0x3f: - fmov_ext_rm(dreg,(uae_u32)&xhex_1e4096); - break; - default: - FAIL(1); - return; - } - fmov_rr(FP_RESULT,dreg); - return; - } - if (opmode & 0x20) /* two operands, so we need a scratch reg */ - sreg = FS1; - else /* one operand only, thus we can load the argument into dreg */ - sreg = dreg; - if ((prec = comp_fp_get(opcode,extra,sreg)) < 0) { - FAIL(1); - return; - } - if (!opmode) { /* FMOVE ,FPx */ - fmov_rr(FP_RESULT,dreg); - return; - } - /* no break here for to dreg */ - case 0: /* directly from sreg to dreg */ - if (!source) { /* no */ - dont_care_fflags(); - sreg = (extra >> 10) & 7; - } - switch (opmode) { - case 0x00: /* FMOVE */ - fmov_rr(dreg,sreg); - break; - case 0x01: /* FINT */ - frndint_rr(dreg,sreg); - break; - case 0x02: /* FSINH */ - fsinh_rr(dreg,sreg); - break; - case 0x03: /* FINTRZ */ -#if USE_X86_FPUCW /* if we have control over the CW, we can do this */ - if (0 && (regs.fpcr & 0xf0) == 0x10) /* maybe unsafe, because this test is done */ - frndint_rr(dreg,sreg); /* during the JIT compilation and not at runtime */ - else { - mov_l_ri(S1,0x10); /* extended round to zero */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - frndint_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); + /* no break here for to dreg */ + case 0: /* directly from sreg to dreg */ + if (!source) { /* no */ + dont_care_fflags (); + sreg = (extra >> 10) & 7; } - break; + switch (opmode) { + case 0x00: /* FMOVE */ + fmov_rr (dreg, sreg); + break; + case 0x01: /* FINT */ + frndint_rr (dreg, sreg); + break; + case 0x02: /* FSINH */ + fsinh_rr (dreg, sreg); + break; + case 0x03: /* FINTRZ */ +#if USE_X86_FPUCW /* if we have control over the CW, we can do this */ + if (0 && (regs.fpcr & 0xf0) == 0x10) /* maybe unsafe, because this test is done */ + frndint_rr (dreg, sreg); /* during the JIT compilation and not at runtime */ + else { + mov_l_ri (S1, 0x10); /* extended round to zero */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + frndint_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + } + break; #endif - FAIL(1); - return; - case 0x04: /* FSQRT */ - fsqrt_rr(dreg,sreg); - break; - case 0x06: /* FLOGNP1 */ - flogNP1_rr(dreg,sreg); - break; - case 0x08: /* FETOXM1 */ - fetoxM1_rr(dreg,sreg); - break; - case 0x09: /* FTANH */ - ftanh_rr(dreg,sreg); - break; - case 0x0a: /* FATAN */ - fatan_rr(dreg,sreg); - break; - case 0x0c: /* FASIN */ - fasin_rr(dreg,sreg); - break; - case 0x0d: /* FATANH */ - fatanh_rr(dreg,sreg); - break; - case 0x0e: /* FSIN */ - fsin_rr(dreg,sreg); - break; - case 0x0f: /* FTAN */ - ftan_rr(dreg,sreg); - break; - case 0x10: /* FETOX */ - fetox_rr(dreg,sreg); - break; - case 0x11: /* FTWOTOX */ - ftwotox_rr(dreg,sreg); - break; - case 0x12: /* FTENTOX */ - ftentox_rr(dreg,sreg); - break; - case 0x14: /* FLOGN */ - flogN_rr(dreg,sreg); - break; - case 0x15: /* FLOG10 */ - flog10_rr(dreg,sreg); - break; - case 0x16: /* FLOG2 */ - flog2_rr(dreg,sreg); - break; - case 0x18: /* FABS */ - fabs_rr(dreg,sreg); - break; - case 0x19: /* FCOSH */ - fcosh_rr(dreg,sreg); - break; - case 0x1a: /* FNEG */ - fneg_rr(dreg,sreg); - break; - case 0x1c: /* FACOS */ + FAIL (1); + return; + case 0x04: /* FSQRT */ + fsqrt_rr (dreg, sreg); + break; + case 0x06: /* FLOGNP1 */ + flogNP1_rr (dreg, sreg); + break; + case 0x08: /* FETOXM1 */ + fetoxM1_rr (dreg, sreg); + break; + case 0x09: /* FTANH */ + ftanh_rr (dreg, sreg); + break; + case 0x0a: /* FATAN */ + fatan_rr (dreg, sreg); + break; + case 0x0c: /* FASIN */ + fasin_rr (dreg, sreg); + break; + case 0x0d: /* FATANH */ + fatanh_rr (dreg, sreg); + break; + case 0x0e: /* FSIN */ + fsin_rr (dreg, sreg); + break; + case 0x0f: /* FTAN */ + ftan_rr (dreg, sreg); + break; + case 0x10: /* FETOX */ + fetox_rr (dreg, sreg); + break; + case 0x11: /* FTWOTOX */ + ftwotox_rr (dreg, sreg); + break; + case 0x12: /* FTENTOX */ + ftentox_rr (dreg, sreg); + break; + case 0x14: /* FLOGN */ + flogN_rr (dreg, sreg); + break; + case 0x15: /* FLOG10 */ + flog10_rr (dreg, sreg); + break; + case 0x16: /* FLOG2 */ + flog2_rr (dreg, sreg); + break; + case 0x18: /* FABS */ + fabs_rr (dreg, sreg); + break; + case 0x19: /* FCOSH */ + fcosh_rr (dreg, sreg); + break; + case 0x1a: /* FNEG */ + fneg_rr (dreg, sreg); + break; + case 0x1c: /* FACOS */ #if USE_X86_FPUCW - if ((regs.fpcr & 0x30) != 0x10) { /* use round to zero */ - mov_l_ri(S1,(regs.fpcr & 0xC0) | 0x10); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - facos_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - break; - } + if ((regs.fpcr & 0x30) != 0x10) { /* use round to zero */ + mov_l_ri (S1, (regs.fpcr & 0xC0) | 0x10); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + facos_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + break; + } #endif - facos_rr(dreg,sreg); - break; - case 0x1d: /* FCOS */ - fcos_rr(dreg,sreg); - break; - case 0x1e: /* FGETEXP */ - fgetexp_rr(dreg,sreg); - break; - case 0x1f: /* FGETMAN */ - fgetman_rr(dreg,sreg); - break; - case 0x20: /* FDIV */ - fdiv_rr(dreg,sreg); - break; - case 0x21: /* FMOD */ - frem_rr(dreg,sreg); - break; - case 0x22: /* FADD */ - fadd_rr(dreg,sreg); - break; - case 0x23: /* FMUL */ - fmul_rr(dreg,sreg); - break; - case 0x24: /* FSGLDIV is not exactly the same as FSDIV, */ - /* because both operands should be SINGLE precision, too */ - case 0x60: /* FSDIV */ - fdiv_rr(dreg,sreg); - if (!currprefs.fpu_strict) /* faster, but less strict rounding */ - break; + facos_rr (dreg, sreg); + break; + case 0x1d: /* FCOS */ + fcos_rr (dreg, sreg); + break; + case 0x1e: /* FGETEXP */ + fgetexp_rr (dreg, sreg); + break; + case 0x1f: /* FGETMAN */ + fgetman_rr (dreg, sreg); + break; + case 0x20: /* FDIV */ + fdiv_rr (dreg, sreg); + break; + case 0x21: /* FMOD */ + frem_rr (dreg, sreg); + break; + case 0x22: /* FADD */ + fadd_rr (dreg, sreg); + break; + case 0x23: /* FMUL */ + fmul_rr (dreg, sreg); + break; + case 0x24: /* FSGLDIV is not exactly the same as FSDIV, */ + /* because both operands should be SINGLE precision, too */ + case 0x60: /* FSDIV */ + fdiv_rr (dreg, sreg); + if (!currprefs.fpu_strict) /* faster, but less strict rounding */ + break; #if USE_X86_FPUCW - if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ - break; + if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ + break; #endif - fcuts_r(dreg); - break; - case 0x25: /* FREM */ - frem1_rr(dreg,sreg); - break; - case 0x26: /* FSCALE */ - fscale_rr(dreg,sreg); - break; - case 0x27: /* FSGLMUL is not exactly the same as FSMUL, */ - /* because both operands should be SINGLE precision, too */ - case 0x63: /* FSMUL */ - fmul_rr(dreg,sreg); - if (!currprefs.fpu_strict) /* faster, but less strict rounding */ - break; + fcuts_r (dreg); + break; + case 0x25: /* FREM */ + frem1_rr (dreg, sreg); + break; + case 0x26: /* FSCALE */ + fscale_rr (dreg, sreg); + break; + case 0x27: /* FSGLMUL is not exactly the same as FSMUL, */ + /* because both operands should be SINGLE precision, too */ + case 0x63: /* FSMUL */ + fmul_rr (dreg, sreg); + if (!currprefs.fpu_strict) /* faster, but less strict rounding */ + break; #if USE_X86_FPUCW - if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ - break; + if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ + break; #endif - fcuts_r(dreg); - break; - case 0x28: /* FSUB */ - fsub_rr(dreg,sreg); - break; - case 0x30: /* FSINCOS */ - case 0x31: - case 0x32: - case 0x33: - case 0x34: - case 0x35: - case 0x36: - case 0x37: - if (dreg == (extra & 7)) - fsin_rr(dreg, sreg); - else - fsincos_rr(dreg, extra & 7, sreg); - break; - case 0x38: /* FCMP */ - fmov_rr(FP_RESULT,dreg); - fsub_rr(FP_RESULT,sreg); - return; - case 0x3a: /* FTST */ - fmov_rr(FP_RESULT,sreg); - return; - case 0x40: /* FSMOVE */ - if (prec == 1 || !currprefs.fpu_strict) { - if (sreg != dreg) /* no */ - fmov_rr(dreg,sreg); - } else { - fmovs_mr((uae_u32)temp_fp,sreg); - fmovs_rm(dreg,(uae_u32)temp_fp); - } - break; - case 0x44: /* FDMOVE */ - if (prec || !currprefs.fpu_strict) { - if (sreg != dreg) /* no */ - fmov_rr(dreg,sreg); - } else { - fmov_mr((uae_u32)temp_fp,sreg); - fmov_rm(dreg,(uae_u32)temp_fp); - } - break; - case 0x41: /* FSSQRT */ - fsqrt_rr(dreg,sreg); - if (!currprefs.fpu_strict) /* faster, but less strict rounding */ - break; + fcuts_r (dreg); + break; + case 0x28: /* FSUB */ + fsub_rr (dreg, sreg); + break; + case 0x30: /* FSINCOS */ + case 0x31: + case 0x32: + case 0x33: + case 0x34: + case 0x35: + case 0x36: + case 0x37: + if (dreg == (extra & 7)) + fsin_rr (dreg, sreg); + else + fsincos_rr (dreg, extra & 7, sreg); + break; + case 0x38: /* FCMP */ + fmov_rr (FP_RESULT, dreg); + fsub_rr (FP_RESULT, sreg); + return; + case 0x3a: /* FTST */ + fmov_rr (FP_RESULT, sreg); + return; + case 0x40: /* FSMOVE */ + if (prec == 1 || !currprefs.fpu_strict) { + if (sreg != dreg) /* no */ + fmov_rr (dreg, sreg); + } + else { + fmovs_mr ((uae_u32) temp_fp, sreg); + fmovs_rm (dreg, (uae_u32) temp_fp); + } + break; + case 0x44: /* FDMOVE */ + if (prec || !currprefs.fpu_strict) { + if (sreg != dreg) /* no */ + fmov_rr (dreg, sreg); + } + else { + fmov_mr ((uae_u32) temp_fp, sreg); + fmov_rm (dreg, (uae_u32) temp_fp); + } + break; + case 0x41: /* FSSQRT */ + fsqrt_rr (dreg, sreg); + if (!currprefs.fpu_strict) /* faster, but less strict rounding */ + break; #if USE_X86_FPUCW - if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ - break; + if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ + break; #endif - fcuts_r(dreg); - break; - case 0x45: /* FDSQRT */ - if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ - fsqrt_rr(dreg,sreg); - break; - } + fcuts_r (dreg); + break; + case 0x45: /* FDSQRT */ + if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ + fsqrt_rr (dreg, sreg); + break; + } #if USE_X86_FPUCW - if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ - if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ - fsqrt_rr(dreg,sreg); - else { /* if we have SINGLE presision, force DOUBLE */ - mov_l_ri(S1,(regs.fpcr & 0x30) | 0x80); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fsqrt_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - } - break; - } + if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ + if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ + fsqrt_rr (dreg, sreg); + else { /* if we have SINGLE presision, force DOUBLE */ + mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + fsqrt_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + } + break; + } #endif /* in case of EXTENDED precision, just reduce the result to DOUBLE */ - fsqrt_rr(dreg,sreg); - fcut_r(dreg); - break; - case 0x58: /* FSABS */ - fabs_rr(dreg,sreg); - if (prec != 1 && currprefs.fpu_strict) - fcuts_r(dreg); - break; - case 0x5a: /* FSNEG */ - fneg_rr(dreg,sreg); - if (prec != 1 && currprefs.fpu_strict) - fcuts_r(dreg); - break; - case 0x5c: /* FDABS */ - fabs_rr(dreg,sreg); - if (!prec && currprefs.fpu_strict) - fcut_r(dreg); - break; - case 0x5e: /* FDNEG */ - fneg_rr(dreg,sreg); - if (!prec && currprefs.fpu_strict) - fcut_r(dreg); - break; - case 0x62: /* FSADD */ - fadd_rr(dreg,sreg); - if (!currprefs.fpu_strict) /* faster, but less strict rounding */ - break; + fsqrt_rr (dreg, sreg); + fcut_r (dreg); + break; + case 0x58: /* FSABS */ + fabs_rr (dreg, sreg); + if (prec != 1 && currprefs.fpu_strict) + fcuts_r (dreg); + break; + case 0x5a: /* FSNEG */ + fneg_rr (dreg, sreg); + if (prec != 1 && currprefs.fpu_strict) + fcuts_r (dreg); + break; + case 0x5c: /* FDABS */ + fabs_rr (dreg, sreg); + if (!prec && currprefs.fpu_strict) + fcut_r (dreg); + break; + case 0x5e: /* FDNEG */ + fneg_rr (dreg, sreg); + if (!prec && currprefs.fpu_strict) + fcut_r (dreg); + break; + case 0x62: /* FSADD */ + fadd_rr (dreg, sreg); + if (!currprefs.fpu_strict) /* faster, but less strict rounding */ + break; #if USE_X86_FPUCW - if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ - break; + if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ + break; #endif - fcuts_r(dreg); - break; - case 0x64: /* FDDIV */ - if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ - fdiv_rr(dreg,sreg); - break; - } + fcuts_r (dreg); + break; + case 0x64: /* FDDIV */ + if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ + fdiv_rr (dreg, sreg); + break; + } #if USE_X86_FPUCW - if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ - if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ - fdiv_rr(dreg,sreg); - else { /* if we have SINGLE presision, force DOUBLE */ - mov_l_ri(S1,(regs.fpcr & 0x30) | 0x80); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fdiv_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - } - break; - } + if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ + if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ + fdiv_rr (dreg, sreg); + else { /* if we have SINGLE presision, force DOUBLE */ + mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + fdiv_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + } + break; + } #endif /* in case of EXTENDED precision, just reduce the result to DOUBLE */ - fdiv_rr(dreg,sreg); - fcut_r(dreg); - break; - case 0x66: /* FDADD */ - if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ - fadd_rr(dreg,sreg); - break; - } + fdiv_rr (dreg, sreg); + fcut_r (dreg); + break; + case 0x66: /* FDADD */ + if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ + fadd_rr (dreg, sreg); + break; + } #if USE_X86_FPUCW - if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ - if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ - fadd_rr(dreg,sreg); - else { /* if we have SINGLE presision, force DOUBLE */ - mov_l_ri(S1,(regs.fpcr & 0x30) | 0x80); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fadd_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - } - break; - } + if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ + if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ + fadd_rr (dreg, sreg); + else { /* if we have SINGLE presision, force DOUBLE */ + mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + fadd_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + } + break; + } #endif /* in case of EXTENDED precision, just reduce the result to DOUBLE */ - fadd_rr(dreg,sreg); - fcut_r(dreg); - break; - case 0x67: /* FDMUL */ - if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ - fmul_rr(dreg,sreg); - break; - } + fadd_rr (dreg, sreg); + fcut_r (dreg); + break; + case 0x67: /* FDMUL */ + if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ + fmul_rr (dreg, sreg); + break; + } #if USE_X86_FPUCW - if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ - if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ - fmul_rr(dreg,sreg); - else { /* if we have SINGLE presision, force DOUBLE */ - mov_l_ri(S1,(regs.fpcr & 0x30) | 0x80); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fmul_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - } - break; - } + if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ + if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ + fmul_rr (dreg, sreg); + else { /* if we have SINGLE presision, force DOUBLE */ + mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + fmul_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + } + break; + } #endif /* in case of EXTENDED precision, just reduce the result to DOUBLE */ - fmul_rr(dreg,sreg); - fcut_r(dreg); - break; - case 0x68: /* FSSUB */ - fsub_rr(dreg,sreg); - if (!currprefs.fpu_strict) /* faster, but less strict rounding */ - break; + fmul_rr (dreg, sreg); + fcut_r (dreg); + break; + case 0x68: /* FSSUB */ + fsub_rr (dreg, sreg); + if (!currprefs.fpu_strict) /* faster, but less strict rounding */ + break; #if USE_X86_FPUCW - if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ - break; + if ((regs.fpcr & 0xC0) == 0x40) /* if SINGLE precision */ + break; #endif - fcuts_r(dreg); - break; - case 0x6c: /* FDSUB */ - if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ - fsub_rr(dreg,sreg); - break; - } + fcuts_r (dreg); + break; + case 0x6c: /* FDSUB */ + if (!currprefs.fpu_strict) { /* faster, but less strict rounding */ + fsub_rr (dreg, sreg); + break; + } #if USE_X86_FPUCW - if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ - if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ - fsub_rr(dreg,sreg); - else { /* if we have SINGLE presision, force DOUBLE */ - mov_l_ri(S1,(regs.fpcr & 0x30) | 0x80); - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - fsub_rr(dreg,sreg); - mov_l_rm(S1,(uae_u32)®s.fpcr); - and_l_ri(S1,0xf0); /* restore control word */ - fldcw_m_indexed(S1,(uae_u32)x86_fpucw); - } - break; - } + if (regs.fpcr & 0xC0) { /* if we don't have EXTENDED precision */ + if ((regs.fpcr & 0xC0) == 0x80) /* if we have DOUBLE */ + fsub_rr (dreg, sreg); + else { /* if we have SINGLE presision, force DOUBLE */ + mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80); + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + fsub_rr (dreg, sreg); + mov_l_rm (S1, (uae_u32) ®s.fpcr); + and_l_ri (S1, 0xf0); /* restore control word */ + fldcw_m_indexed (S1, (uae_u32) x86_fpucw); + } + break; + } #endif /* in case of EXTENDED precision, just reduce the result to DOUBLE */ - fsub_rr(dreg,sreg); - fcut_r(dreg); - break; - default: - FAIL(1); + fsub_rr (dreg, sreg); + fcut_r (dreg); + break; + default: + FAIL (1); + return; + } + fmov_rr (FP_RESULT, dreg); + return; + default: + write_log (_T ("Unsupported JIT-FPU instruction: 0x%04x %04x\n"), opcode, extra); + FAIL (1); return; } - fmov_rr(FP_RESULT,dreg); - return; - default: - write_log (_T("Unsupported JIT-FPU instruction: 0x%04x %04x\n"),opcode,extra); - FAIL(1); - return; - } } #endif diff --git a/od-win32/caps/CapsAPI.h b/od-win32/caps/CapsAPI.h index 367b646e..796819fa 100644 --- a/od-win32/caps/CapsAPI.h +++ b/od-win32/caps/CapsAPI.h @@ -236,6 +236,16 @@ enum { cgiitRevolution // CapsRevolutionInfo }; +// recognized image types +enum { + citError=0, // error preventing the type identification + citUnknown, // unknown image type + citIPF, // IPF image + citCTRaw, // CT Raw image + citKFStream, // KryoFlux stream files + citDraft // Draft image +}; + // image error status enum { imgeOk=0, diff --git a/od-win32/caps/CapsLib.h b/od-win32/caps/CapsLib.h index 646bc613..498e5c3f 100644 --- a/od-win32/caps/CapsLib.h +++ b/od-win32/caps/CapsLib.h @@ -31,5 +31,7 @@ ExtSub SDWORD __cdecl CAPSFdcInvalidateTrack(PCAPSFDC pc, SDWORD drive); ExtSub SDWORD __cdecl CAPSFormatDataToMFM(PVOID pformattrack, UDWORD flag); ExtSub SDWORD __cdecl CAPSGetInfo(PVOID pinfo, SDWORD id, UDWORD cylinder, UDWORD head, UDWORD inftype, UDWORD infid); ExtSub SDWORD __cdecl CAPSSetRevolution(SDWORD id, UDWORD value); +ExtSub SDWORD __cdecl CAPSGetImageType(PCHAR name); +ExtSub SDWORD __cdecl CAPSGetImageTypeMemory(PUBYTE buffer, UDWORD length); #endif diff --git a/od-win32/caps/caps_win32.cpp b/od-win32/caps/caps_win32.cpp index 39c204f2..a582d509 100644 --- a/od-win32/caps/caps_win32.cpp +++ b/od-win32/caps/caps_win32.cpp @@ -16,8 +16,10 @@ #include "CapsAPI.h" #define CAPS_TRACKTIMING 1 +#define LOG_REVOLUTION 0 static SDWORD caps_cont[4]= {-1, -1, -1, -1}; +static bool caps_revolution_hack[4]; static int caps_locked[4]; static int caps_flags = DI_LOCK_DENVAR|DI_LOCK_DENNOISE|DI_LOCK_NOISE|DI_LOCK_UPDATEFD|DI_LOCK_TYPE|DI_LOCK_OVLBIT; static struct CapsVersionInfo cvi; @@ -47,6 +49,8 @@ typedef SDWORD (__cdecl* CAPSGETINFO)(PVOID pinfo, SDWORD id, UDWORD cylinder, U static CAPSGETINFO pCAPSGetInfo; typedef SDWORD (__cdecl* CAPSSETREVOLUTION)(SDWORD id, UDWORD value); static CAPSSETREVOLUTION pCAPSSetRevolution; +typedef SDWORD (__cdecl* CAPSGETIMAGETYPEMEMORY)(PUBYTE buffer, UDWORD length); +static CAPSGETIMAGETYPEMEMORY pCAPSGetImageTypeMemory; int caps_init (void) { @@ -91,7 +95,8 @@ int caps_init (void) pCAPSUnlockAllTracks = (CAPSUNLOCKALLTRACKS)GetProcAddress (h, "CAPSUnlockAllTracks"); pCAPSGetVersionInfo = (CAPSGETVERSIONINFO)GetProcAddress (h, "CAPSGetVersionInfo"); pCAPSGetInfo = (CAPSGETINFO)GetProcAddress (h, "CAPSGetInfo"); - pCAPSSetRevolution = (CAPSSETREVOLUTION)GetProcAddress (h, "CAPSSetRevolution"); + pCAPSSetRevolution = (CAPSSETREVOLUTION)GetProcAddress(h, "CAPSSetRevolution"); + pCAPSGetImageTypeMemory = (CAPSGETIMAGETYPEMEMORY)GetProcAddress(h, "CAPSGetImageTypeMemory"); init = 1; cvi.type = 1; @@ -123,6 +128,7 @@ int caps_loadimage (struct zfile *zf, int drv, int *num_tracks) uae_u8 *buf; TCHAR s1[100]; struct CapsDateTimeExt *cdt; + int type; if (!caps_init ()) return 0; @@ -130,11 +136,25 @@ int caps_loadimage (struct zfile *zf, int drv, int *num_tracks) zfile_fseek (zf, 0, SEEK_END); len = zfile_ftell (zf); zfile_fseek (zf, 0, SEEK_SET); + if (len <= 0) + return 0; buf = xmalloc (uae_u8, len); if (!buf) return 0; if (zfile_fread (buf, len, 1, zf) == 0) return 0; + type = -1; + if (pCAPSGetImageTypeMemory) { + type = pCAPSGetImageTypeMemory(buf, len); + if (type == citError || type == citUnknown) { + write_log(_T("caps: CAPSGetImageTypeMemory() returned %d\n"), type); + return 0; + } + if (type == citKFStream || type == citDraft) { + write_log(_T("caps: CAPSGetImageTypeMemory() returned unsupported image type %d\n"), type); + return 0; + } + } ret = pCAPSLockImageMemory (caps_cont[drv], buf, len, 0); xfree (buf); if (ret != imgeOk) { @@ -164,10 +184,10 @@ int caps_loadimage (struct zfile *zf, int drv, int *num_tracks) } ret = pCAPSLoadImage(caps_cont[drv], caps_flags); + caps_revolution_hack[drv] = type == citCTRaw; cdt = &ci.crdt; _stprintf (s1, _T("%d.%d.%d %d:%d:%d"), cdt->day, cdt->month, cdt->year, cdt->hour, cdt->min, cdt->sec); - write_log (_T("caps: type:%d date:%s rel:%d rev:%d\n"), - ci.type, s1, ci.release, ci.revision); + write_log (_T("caps: type:%d imagetype:%d date:%s rel:%d rev:%d\n"), ci.type, type, s1, ci.release, ci.revision); return 1; } @@ -228,11 +248,17 @@ static int load (struct CapsTrackInfoT2 *ci, int drv, int track, bool seed, bool return 1; } -int caps_loadrevolution (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, int *tracklength, int *nextrev) +int caps_loadrevolution (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, int *tracklength, int *nextrev, bool track_access_done) { int len; struct CapsTrackInfoT2 ci; + if (!track_access_done && caps_revolution_hack[drv]) { +#if LOG_REVOLUTION + write_log(_T("%03d skipped revolution increase\n"), track); +#endif + return 1; + } if (!load (&ci, drv, track, false, false)) return 0; if (oldlib) @@ -251,7 +277,9 @@ int caps_loadrevolution (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int tra CapsRevolutionInfo pinfo; *nextrev = 0; pCAPSGetInfo(&pinfo, caps_cont[drv], track / 2, track & 1, cgiitRevolution, 0); - //write_log (_T("get next rev = %d\n"), pinfo.next); +#if LOG_REVOLUTION + write_log (_T("%03d load next rev = %d\n"), track, pinfo.next); +#endif if (pinfo.max > 0) *nextrev = pinfo.next; } @@ -270,20 +298,28 @@ int caps_loadtrack (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, i if (nextrev && pCAPSSetRevolution) { if (sametrack) { pCAPSSetRevolution(caps_cont[drv], *nextrev); - //write_log (_T("set rev = %d\n"), *nextrev); +#if LOG_REVOLUTION + write_log(_T("%03d set rev = %d\n"), track, *nextrev); +#endif } else { pCAPSSetRevolution(caps_cont[drv], 0); +#if LOG_REVOLUTION + write_log(_T("%03d clear rev\n"), track, *nextrev); +#endif } } if (!load (&ci, drv, track, true, sametrack != true)) return 0; - if (nextrev && sametrack && pCAPSGetInfo) { - *nextrev = 0; + if (pCAPSGetInfo) { + if (nextrev) + *nextrev = 0; pCAPSGetInfo(&pinfo, caps_cont[drv], track / 2, track & 1, cgiitRevolution, 0); - //write_log (_T("get next rev = %d\n"), pinfo.next); - if (pinfo.max > 0) +#if LOG_REVOLUTION + write_log(_T("%03d get next rev = %d\n"), track, pinfo.next); +#endif + if (nextrev && sametrack && pinfo.max > 0) *nextrev = pinfo.next; } diff --git a/od-win32/caps/caps_win32.h b/od-win32/caps/caps_win32.h index b8b7a9d0..d4b0527f 100644 --- a/od-win32/caps/caps_win32.h +++ b/od-win32/caps/caps_win32.h @@ -2,5 +2,5 @@ int caps_init (void); void caps_unloadimage (int drv); int caps_loadimage (struct zfile *zf, int drv, int *num_tracks); int caps_loadtrack (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, int *tracklength, int *multirev, int *gapoffset, int *nextrev, bool setrev); -int caps_loadrevolution (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, int *tracklength, int *nextrev); +int caps_loadrevolution (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, int *tracklength, int *nextrev, bool track_access_done); diff --git a/od-win32/win32.cpp b/od-win32/win32.cpp index 2e1bfd65..38cd3d55 100644 --- a/od-win32/win32.cpp +++ b/od-win32/win32.cpp @@ -1569,7 +1569,7 @@ static LRESULT CALLBACK AmigaWindowProc (HWND hWnd, UINT message, WPARAM wParam, case WT_PACKET: { PACKET pkt; - if (inputdevice_is_tablet () <= 0) { + if (inputdevice_is_tablet () <= 0 && !currprefs.tablet_library) { close_tablet (tablet); tablet = NULL; return 0; diff --git a/od-win32/win32.h b/od-win32/win32.h index 25c463c4..2c05d6f0 100644 --- a/od-win32/win32.h +++ b/od-win32/win32.h @@ -19,11 +19,11 @@ #define LANG_DLL 1 #if WINUAEPUBLICBETA -#define WINUAEBETA _T("11") +#define WINUAEBETA _T("12") #else #define WINUAEBETA _T("") #endif -#define WINUAEDATE MAKEBD(2014, 3, 18) +#define WINUAEDATE MAKEBD(2014, 3, 22) #define WINUAEEXTRA _T("") //#define WINUAEEXTRA _T("AmiKit Preview") //#define WINUAEEXTRA _T("Amiga Forever Edition") diff --git a/od-win32/winuaechangelog.txt b/od-win32/winuaechangelog.txt index 01fc342c..4857c846 100644 --- a/od-win32/winuaechangelog.txt +++ b/od-win32/winuaechangelog.txt @@ -11,6 +11,59 @@ - restore only single input target to default. +Beta 12: + +- Config file writing created corrupted (and harmless) config file lines, most common being + uaehf line which fortunately isn't important config line entry. (b11) +- BCHG/BCLR/BSET allowed PC-relative addressing modes, broken since the beginning. (from Hatari) +- If program read disk by polling DSKBYTR (not using DMA), index emulation was unstable. +- Switching bitplane DMA on few cycles (not yet confirmed, I assume range that makes sense is 1 to 3) + cycles before DDFSTOP will also trigger ECS/AGA "passed plfstop" state change. (Death Trap) +- Full tablet emulation boot division by zero guru fix. +- Tablet.library emulation now works but at least dpaint5 does not seem to do anything with pressure + data. It reads pressure tag contents but nothing seems to happen. + +Beta 11: + +- Borderblank + bordersprite caused border glitches in some situations. +- CDTV front panel buttons' default state after reset should be enabled, not disabled. +- Added new double options to non-lace modes. Not really useful, maybe be moved somewhere else later.. +- 68040 MOVE16 write access error stack frame is now correct. +- Editing non-existing new style real harddrive config entry opened hardfile properties dialog. +- Separate filter options for native and RTG modes. Currently only following settings are RTG compatible: + Direct3D shader filters (no software filter support and never will be), masks, overlays, scanlines. +- New automatic resolution option was unreliable in some situations. +- Do not detect modes with VTOTAL=350 or less as scandoubled to fix Super72 halved height. +- tablet.library emulation, totally untested, do not enable. +- After long field to short field change last line still showed old background color(s) if line had any + background color changes before field mode was changed. +- Master floppy write protection config option was not loaded from config. (wrong config entry name..) +- Disk emulation multirevolution support was unstable, disk revolution data stream change was not always bit perfect. +- Added Super Card Pro (scp) image file support. (Don't ask me if images don't work, I didn't implement it originally) +- Added support for raw dumps from Softpres Capture Tool and KryoFlux using new capslib v0.5. + +Yes, above two changes in same beta is only a strange coincidence. Note that both are raw dumps which +can't be confirmed easily, don't bother me if there are compatibility problems. + +FPU improvements (Mostly low level stuff that only makes difference if unimplemented checkbox is not ticked, much +more important for Previous emulator, NextStep OS requires FPU and uses it heavily): + +- 6888x any FPU instruction (except FSAVE/FRESTORE) causes null state to idle state transition but + 68040+ conditional FPU instructions won't affect null state. +- 68040 unimplemented FPU instruction emulation was broken, FSAVE exception frame was not emulated, 68040.library + emulation code needs it for proper operation. +- 68040/060 FPU FMOVECR is now unimplemented instruction. +- 68040/060 unimplemented packed-decimal data type exception is now emulated. +- 68060 FMOVEM.X with dynamic list now causes unimplemented effective address exception. +- 68060 F.X #imm,FPn and F.P #imm,FPn now causes unimplemented effective address exception. +- 68060 FMOVEM.L #imm, now causes unimplemented effective address exception. +- FMOVEM.X with dynamic list and -(An) and (An)+ effective address overrides static/dynamic post/pred state. + (for example FMOVEM.X Dn,-(An) uses pre-decrement even if mode bits are set to dynamic post-increment) +- All FPU FPSR register (overflow, div by zero etc..) status bits emulated. (May not be fully reliable) +- 6888x Packed-Decimal Real k-factor support fully implemented. (May still have rounding bugs) + +This should complete emulation all FPU features except arithmetic exceptions (that no one seems to use) + Beta 10: - Programmed display mode positioning bug fixed, should fix remaining problems with clipped left or right edges. diff --git a/table68k b/table68k index ff9aa868..34a290e9 100644 --- a/table68k +++ b/table68k @@ -101,15 +101,15 @@ - 0 0 4 fiea 0000 1000 01ss sSSS:000:--Z--:-----:13: BCHG #1,s[Dreg] - 6 0 6 -0000 1000 01ss sSSS:000:--Z--:-----:13: BCHG #1,s[!Areg,Dreg,Immd] +0000 1000 01ss sSSS:000:--Z--:-----:13: BCHG #1,s[!Areg,Dreg,Immd,PC8r,PC16] - 0 0 6 fiea 0000 1000 10ss sSSS:000:--Z--:-----:13: BCLR #1,s[Dreg] - 6 0 6 -0000 1000 10ss sSSS:000:--Z--:-----:13: BCLR #1,s[!Areg,Dreg,Immd] +0000 1000 10ss sSSS:000:--Z--:-----:13: BCLR #1,s[!Areg,Dreg,Immd,PC8r,PC16] - 0 0 6 fiea 0000 1000 11ss sSSS:000:--Z--:-----:13: BSET #1,s[Dreg] - 6 0 6 -0000 1000 11ss sSSS:000:--Z--:-----:13: BSET #1,s[!Areg,Dreg,Immd] +0000 1000 11ss sSSS:000:--Z--:-----:13: BSET #1,s[!Areg,Dreg,Immd,PC8r,PC16] - 0 0 6 fiea 0000 1010 0011 1100:000:XNZVC:XNZVC:10: EORSR.B #1 @@ -144,15 +144,15 @@ - 0 0 4 fea 0000 rrr1 01ss sSSS:000:--Z--:-----:13: BCHG Dr,s[Dreg] - 6 0 6 -0000 rrr1 01ss sSSS:000:--Z--:-----:13: BCHG Dr,s[!Areg,Dreg,Immd] +0000 rrr1 01ss sSSS:000:--Z--:-----:13: BCHG Dr,s[!Areg,Dreg,Immd,PC8r,PC16] - 0 0 6 fea 0000 rrr1 10ss sSSS:000:--Z--:-----:13: BCLR Dr,s[Dreg] - 6 0 6 -0000 rrr1 10ss sSSS:000:--Z--:-----:13: BCLR Dr,s[!Areg,Dreg,Immd] +0000 rrr1 10ss sSSS:000:--Z--:-----:13: BCLR Dr,s[!Areg,Dreg,Immd,PC8r,PC16] - 0 0 6 fea 0000 rrr1 11ss sSSS:000:--Z--:-----:13: BSET Dr,s[Dreg] - 6 0 6 -0000 rrr1 11ss sSSS:000:--Z--:-----:13: BSET Dr,s[!Areg,Dreg,Immd] +0000 rrr1 11ss sSSS:000:--Z--:-----:13: BSET Dr,s[!Areg,Dreg,Immd,PC8r,PC16] - 0 0 6 fea % Move cycles are special cased in gencpu.c diff --git a/tabletlibrary.cpp b/tabletlibrary.cpp index 4e507e03..58052c77 100644 --- a/tabletlibrary.cpp +++ b/tabletlibrary.cpp @@ -55,6 +55,8 @@ static void filltags (uaecptr tabletdata) put_long (tabletdata + 12, tablet_maxx); put_long (tabletdata + 16, tablet_maxy); + //write_log(_T("P=%d BUT=%08X\n"), tablet_pressure, tablet_buttonbits); + // pressure put_long (p, 0x8003a000 + 6); p += 4; @@ -135,10 +137,10 @@ static uae_u32 REGPARAM2 lib_dofunc (TrapContext *context) uaecptr td = m68k_areg (regs, 1); filltags (td); if (ksversion < 39) - return 1; + return 0; td = get_long (im + 52); if (!td) - return 1; + return 0; return 1; } static uae_u32 REGPARAM2 lib_unkfunc (TrapContext *context) -- 2.47.3