Merge branch 'master' of https://github.com/86Box/86Box

src/86box.c

@@ -293,7 +293,7 @@ void pclog_ensure_stdlog_open(void)
  * being logged, and catch repeating entries.
  */
 void
-pclog_ex(const char *fmt, va_list ap)
+pclog_ex(UNUSED(const char *fmt), UNUSED(va_list ap))
 {
 #ifndef RELEASE_BUILD
     char temp[LOG_SIZE_BUFFER];
@@ -330,7 +330,7 @@ pclog_toggle_suppr(void)
 
 /* Log something. We only do this in non-release builds. */
 void
-pclog(const char *fmt, ...)
+pclog(UNUSED(const char *fmt), ...)
 {
 #ifndef RELEASE_BUILD
     va_list ap;

src/acpi.c

@@ -89,7 +89,7 @@ acpi_timer_get(acpi_t *dev)
 }
 
 static uint8_t
-acpi_gp_timer_get(acpi_t *dev)
+acpi_gp_timer_get(UNUSED(acpi_t *dev))
 {
     uint64_t clock = acpi_clock_get();
     clock -= acpi_last_clock;

src/cdrom/cdrom.c

@@ -593,7 +593,7 @@ read_toc_raw(const cdrom_t *dev, unsigned char *b, const unsigned char start_tra
 }
 
 static int
-track_type_is_valid(const cdrom_t *dev, const int type, const int flags, const int audio,
+track_type_is_valid(UNUSED(const cdrom_t *dev), const int type, const int flags, const int audio,
                     const int mode2)
 {
     if (!(flags & 0x70) && (flags & 0xf8)) { /* 0x08/0x80/0x88 are illegal modes */
@@ -1968,7 +1968,7 @@ cdrom_get_track_buffer(cdrom_t *dev, uint8_t *buf)
 
 /* TODO: Actually implement this properly. */
 void
-cdrom_get_q(cdrom_t *dev, uint8_t *buf, int *curtoctrk, uint8_t mode)
+cdrom_get_q(UNUSED(cdrom_t *dev), uint8_t *buf, UNUSED(int *curtoctrk), UNUSED(uint8_t mode))
 {
     memset(buf, 0x00, 10);
 }
@@ -2641,18 +2641,6 @@ cdrom_read_track_information(cdrom_t *dev, const uint8_t *cdb, uint8_t *buffer)
     return ret;
 }
 
-int
-cdrom_ext_medium_changed(const cdrom_t *dev)
-{
-    int ret = 0;
-
-    if (dev && dev->ops && dev->ops->ext_medium_changed &&
-        (dev->cd_status != CD_STATUS_PLAYING) && (dev->cd_status != CD_STATUS_PAUSED))
-        ret = dev->ops->ext_medium_changed(dev->local);
-
-    return ret;
-}
-
 int
 cdrom_is_empty(const uint8_t id)
 {
@@ -2700,6 +2688,44 @@ cdrom_toc_dump(cdrom_t *dev)
 }
 #endif
 
+void
+cdrom_set_empty(cdrom_t *dev)
+{
+    dev->cd_status      = CD_STATUS_EMPTY;
+}
+
+void
+cdrom_update_status(cdrom_t *dev)
+{
+    const int  was_empty = (dev->cd_status == CD_STATUS_EMPTY);
+
+    if (dev->ops->load != NULL)
+        dev->ops->load(dev->local);
+
+    /* All good, reset state. */
+    dev->seek_pos       = 0;
+    dev->cd_buflen      = 0;
+
+    if ((dev->ops->is_empty != NULL) && dev->ops->is_empty(dev->local))
+        dev->cd_status      = CD_STATUS_EMPTY;
+    else if (dev->ops->is_dvd(dev->local))
+        dev->cd_status      = CD_STATUS_DVD;
+    else
+        dev->cd_status      = dev->ops->has_audio(dev->local) ? CD_STATUS_STOPPED :
+                                                                CD_STATUS_DATA_ONLY;
+
+    dev->cdrom_capacity = dev->ops->get_last_block(dev->local);
+
+    if (dev->cd_status != CD_STATUS_EMPTY) {
+        /* Signal media change to the emulated machine. */
+        cdrom_insert(dev->id);
+
+        /* The drive was previously empty, transition directly to UNIT ATTENTION. */
+        if (was_empty)
+            cdrom_insert(dev->id);
+    }
+}
+
 int
 cdrom_load(cdrom_t *dev, const char *fn, const int skip_insert)
 {
@@ -2728,10 +2754,12 @@ cdrom_load(cdrom_t *dev, const char *fn, const int skip_insert)
         dev->seek_pos       = 0;
         dev->cd_buflen      = 0;
 
+        if ((dev->ops->is_empty != NULL) && dev->ops->is_empty(dev->local))
+            dev->cd_status      = CD_STATUS_EMPTY;
         if (dev->ops->is_dvd(dev->local))
             dev->cd_status      = CD_STATUS_DVD;
         else
-           dev->cd_status      = dev->ops->has_audio(dev->local) ? CD_STATUS_STOPPED :
+            dev->cd_status      = dev->ops->has_audio(dev->local) ? CD_STATUS_STOPPED :
                                                                     CD_STATUS_DATA_ONLY;
 
         dev->cdrom_capacity = dev->ops->get_last_block(dev->local);
@@ -2744,7 +2772,7 @@ cdrom_load(cdrom_t *dev, const char *fn, const int skip_insert)
     cdrom_toc_dump(dev);
 #endif
 
-    if (!skip_insert) {
+    if (!skip_insert && (dev->cd_status != CD_STATUS_EMPTY)) {
         /* Signal media change to the emulated machine. */
         cdrom_insert(dev->id);
 

src/cdrom/cdrom_image.c

@@ -1992,7 +1992,8 @@ static const cdrom_ops_t image_ops = {
     image_is_dvd,
     image_has_audio,
     NULL,
-    image_close
+    image_close,
+    NULL
 };
 
 /* Public functions. */

src/cdrom/cdrom_image_viso.c

@@ -32,13 +32,13 @@
 #include <time.h>
 #include <wchar.h>
 #include <86box/86box.h>
-#include <86box/bswap.h>
 #include <86box/cdrom.h>
 #include <86box/cdrom_image.h>
 #include <86box/cdrom_image_viso.h>
 #include <86box/log.h>
 #include <86box/path.h>
 #include <86box/plat.h>
+#include <86box/bswap.h>
 #include <86box/plat_dir.h>
 #include <86box/version.h>
 #include <86box/nvr.h>

src/chipset/82c100.c

@@ -358,8 +358,7 @@ ct_82c100_init(UNUSED(const device_t *info))
 {
     ct_82c100_t *dev;
 
-    dev = (ct_82c100_t *) malloc(sizeof(ct_82c100_t));
-    memset(dev, 0x00, sizeof(ct_82c100_t));
+    dev = (ct_82c100_t *) calloc(1, sizeof(ct_82c100_t));
 
     ct_82c100_reset(dev);
 

src/chipset/acc2168.c

@@ -184,8 +184,7 @@ acc2168_close(void *priv)
 static void *
 acc2168_init(UNUSED(const device_t *info))
 {
-    acc2168_t *dev = (acc2168_t *) malloc(sizeof(acc2168_t));
-    memset(dev, 0, sizeof(acc2168_t));
+    acc2168_t *dev = (acc2168_t *) calloc(1, sizeof(acc2168_t));
 
     device_add(&port_92_device);
     io_sethandler(0x00f2, 0x0002, acc2168_read, NULL, NULL, acc2168_write, NULL, NULL, dev);

src/chipset/ali1409.c

@@ -40,9 +40,8 @@
 #include <86box/fdc.h>
 #include <86box/smram.h>
 #include <86box/chipset.h>
-
+#include <86box/plat_unused.h>
  
-
 #ifdef ENABLE_ALI1409_LOG 
 int ali1409_do_log = ENABLE_ALI1409_LOG;
 
@@ -161,10 +160,9 @@ ali1409_close(void *priv)
 }
 
 static void *
-ali1409_init(const device_t *info)
+ali1409_init(UNUSED(const device_t *info))
 {
-    ali1409_t *dev = (ali1409_t *) malloc(sizeof(ali1409_t));
-    memset(dev, 0, sizeof(ali1409_t));
+    ali1409_t *dev = (ali1409_t *) calloc(1, sizeof(ali1409_t));
 
     dev->cfg_locked = 1;
 
@@ -173,7 +171,7 @@ ali1409_init(const device_t *info)
                 23h	Data Port
     */
    
-    ali1409_log ("Bus speed: %i",cpu_busspeed);
+    ali1409_log ("Bus speed: %i", cpu_busspeed);
    
 
     io_sethandler(0x0022, 0x0002, ali1409_read, NULL, NULL, ali1409_write, NULL, NULL, dev);

src/chipset/ali1429.c

@@ -331,8 +331,7 @@ ali1429_defaults(ali1429_t *dev)
 static void *
 ali1429_init(const device_t *info)
 {
-    ali1429_t *dev = (ali1429_t *) malloc(sizeof(ali1429_t));
-    memset(dev, 0, sizeof(ali1429_t));
+    ali1429_t *dev = (ali1429_t *) calloc(1, sizeof(ali1429_t));
 
     dev->cfg_locked = 1;
     GREEN           = info->local;

src/chipset/ali1435.c

@@ -282,8 +282,7 @@ ali1435_close(void *priv)
 static void *
 ali1435_init(UNUSED(const device_t *info))
 {
-    ali1435_t *dev = (ali1435_t *) malloc(sizeof(ali1435_t));
-    memset(dev, 0, sizeof(ali1435_t));
+    ali1435_t *dev = (ali1435_t *) calloc(1, sizeof(ali1435_t));
 
     dev->cfg_locked = 1;
 

src/chipset/ali1489.c

@@ -470,8 +470,7 @@ ali1489_close(void *priv)
 static void *
 ali1489_init(UNUSED(const device_t *info))
 {
-    ali1489_t *dev = (ali1489_t *) malloc(sizeof(ali1489_t));
-    memset(dev, 0, sizeof(ali1489_t));
+    ali1489_t *dev = (ali1489_t *) calloc(1, sizeof(ali1489_t));
 
     /* M1487/M1489
        22h Index Port

src/chipset/ali1531.c

@@ -369,8 +369,7 @@ ali1531_close(void *priv)
 static void *
 ali1531_init(UNUSED(const device_t *info))
 {
-    ali1531_t *dev = (ali1531_t *) malloc(sizeof(ali1531_t));
-    memset(dev, 0, sizeof(ali1531_t));
+    ali1531_t *dev = (ali1531_t *) calloc(1, sizeof(ali1531_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, ali1531_read, ali1531_write, dev, &dev->pci_slot);
 

src/chipset/ali1541.c

@@ -643,8 +643,7 @@ ali1541_close(void *priv)
 static void *
 ali1541_init(UNUSED(const device_t *info))
 {
-    ali1541_t *dev = (ali1541_t *) malloc(sizeof(ali1541_t));
-    memset(dev, 0, sizeof(ali1541_t));
+    ali1541_t *dev = (ali1541_t *) calloc(1, sizeof(ali1541_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, ali1541_read, ali1541_write, dev, &dev->pci_slot);
 

src/chipset/ali1543.c

@@ -1599,8 +1599,7 @@ ali1543_close(void *priv)
 static void *
 ali1543_init(const device_t *info)
 {
-    ali1543_t *dev = (ali1543_t *) malloc(sizeof(ali1543_t));
-    memset(dev, 0, sizeof(ali1543_t));
+    ali1543_t *dev = (ali1543_t *) calloc(1, sizeof(ali1543_t));
 
     /* Device 02: M1533 Southbridge */
     pci_add_card(PCI_ADD_SOUTHBRIDGE, ali1533_read, ali1533_write, dev, &dev->pci_slot);

src/chipset/ali1621.c

@@ -669,8 +669,7 @@ ali1621_close(void *priv)
 static void *
 ali1621_init(UNUSED(const device_t *info))
 {
-    ali1621_t *dev = (ali1621_t *) malloc(sizeof(ali1621_t));
-    memset(dev, 0, sizeof(ali1621_t));
+    ali1621_t *dev = (ali1621_t *) calloc(1, sizeof(ali1621_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, ali1621_read, ali1621_write, dev, &dev->pci_slot);
 

src/chipset/ali6117.c

@@ -466,8 +466,7 @@ ali6117_init(const device_t *info)
 
     ali6117_log("ALI6117: init()\n");
 
-    ali6117_t *dev = (ali6117_t *) malloc(sizeof(ali6117_t));
-    memset(dev, 0, sizeof(ali6117_t));
+    ali6117_t *dev = (ali6117_t *) calloc(1, sizeof(ali6117_t));
 
     dev->local = info->local;
 

src/chipset/contaq_82c59x.c

@@ -322,8 +322,7 @@ contaq_82c59x_close(void *priv)
 static void *
 contaq_82c59x_init(const device_t *info)
 {
-    contaq_82c59x_t *dev = (contaq_82c59x_t *) malloc(sizeof(contaq_82c59x_t));
-    memset(dev, 0x00, sizeof(contaq_82c59x_t));
+    contaq_82c59x_t *dev = (contaq_82c59x_t *) calloc(1, sizeof(contaq_82c59x_t));
 
     dev->green = info->local;
 

src/chipset/cs4031.c

@@ -164,8 +164,7 @@ cs4031_close(void *priv)
 static void *
 cs4031_init(UNUSED(const device_t *info))
 {
-    cs4031_t *dev = (cs4031_t *) malloc(sizeof(cs4031_t));
-    memset(dev, 0, sizeof(cs4031_t));
+    cs4031_t *dev = (cs4031_t *) calloc(1, sizeof(cs4031_t));
 
     dev->port_92 = device_add(&port_92_device);
 

src/chipset/cs8230.c

@@ -157,8 +157,7 @@ cs8230_close(void *priv)
 static void *
 cs8230_init(UNUSED(const device_t *info))
 {
-    cs8230_t *cs8230 = (cs8230_t *) malloc(sizeof(cs8230_t));
-    memset(cs8230, 0, sizeof(cs8230_t));
+    cs8230_t *cs8230 = (cs8230_t *) calloc(1, sizeof(cs8230_t));
 
     io_sethandler(0x0022, 0x0002, cs8230_read, NULL, NULL, cs8230_write, NULL, NULL, cs8230);
 

src/chipset/et6000.c

@@ -137,8 +137,7 @@ et6000_close(void *priv)
 static void *
 et6000_init(UNUSED(const device_t *info))
 {
-    et6000_t *dev = (et6000_t *) malloc(sizeof(et6000_t));
-    memset(dev, 0, sizeof(et6000_t));
+    et6000_t *dev = (et6000_t *) calloc(1, sizeof(et6000_t));
 
     /* Port 92h */
     device_add(&port_92_device);

src/chipset/gc100.c

@@ -208,8 +208,7 @@ gc100_close(void *priv)
 static void *
 gc100_init(const device_t *info)
 {
-    gc100_t *dev = (gc100_t *) malloc(sizeof(gc100_t));
-    memset(dev, 0, sizeof(gc100_t));
+    gc100_t *dev = (gc100_t *) calloc(1, sizeof(gc100_t));
 
     dev->reg[0x2] = 0xff;
     dev->reg[0x3] = 0x0;

src/chipset/headland.c

@@ -594,8 +594,7 @@ headland_init(const device_t *info)
     headland_t *dev;
     int         ht386 = 0;
 
-    dev = (headland_t *) malloc(sizeof(headland_t));
-    memset(dev, 0x00, sizeof(headland_t));
+    dev = (headland_t *) calloc(1, sizeof(headland_t));
 
     dev->has_cri   = (info->local & HEADLAND_HAS_CRI);
     dev->has_sleep = (info->local & HEADLAND_HAS_SLEEP);

src/chipset/ims8848.c

@@ -381,8 +381,7 @@ ims8848_close(void *priv)
 static void *
 ims8848_init(UNUSED(const device_t *info))
 {
-    ims8848_t *dev = (ims8848_t *) malloc(sizeof(ims8848_t));
-    memset(dev, 0, sizeof(ims8848_t));
+    ims8848_t *dev = (ims8848_t *) calloc(1, sizeof(ims8848_t));
 
     device_add(&port_92_device);
 

src/chipset/intel_420ex.c

@@ -533,8 +533,7 @@ i420ex_speed_changed(void *priv)
 static void *
 i420ex_init(const device_t *info)
 {
-    i420ex_t *dev = (i420ex_t *) malloc(sizeof(i420ex_t));
-    memset(dev, 0, sizeof(i420ex_t));
+    i420ex_t *dev = (i420ex_t *) calloc(1, sizeof(i420ex_t));
 
     dev->smram = smram_add();
 

src/chipset/intel_4x0.c

@@ -1608,11 +1608,9 @@ i4x0_close(void *priv)
 static void *
 i4x0_init(const device_t *info)
 {
-    i4x0_t  *dev = (i4x0_t *) malloc(sizeof(i4x0_t));
+    i4x0_t  *dev = (i4x0_t *) calloc(1, sizeof(i4x0_t));
     uint8_t *regs;
 
-    memset(dev, 0, sizeof(i4x0_t));
-
     dev->smram_low  = smram_add();
     dev->smram_high = smram_add();
 

src/chipset/intel_82335.c

@@ -171,8 +171,7 @@ intel_82335_close(void *priv)
 static void *
 intel_82335_init(UNUSED(const device_t *info))
 {
-    intel_82335_t *dev = (intel_82335_t *) malloc(sizeof(intel_82335_t));
-    memset(dev, 0, sizeof(intel_82335_t));
+    intel_82335_t *dev = (intel_82335_t *) calloc(1, sizeof(intel_82335_t));
 
     memset(dev->regs, 0, sizeof(dev->regs));
 

src/chipset/intel_i450kx.c

@@ -799,8 +799,8 @@ i450kx_close(void *priv)
 static void *
 i450kx_init(UNUSED(const device_t *info))
 {
-    i450kx_t *dev = (i450kx_t *) malloc(sizeof(i450kx_t));
-    memset(dev, 0, sizeof(i450kx_t));
+    i450kx_t *dev = (i450kx_t *) calloc(1, sizeof(i450kx_t));
+
     pci_add_card(PCI_ADD_NORTHBRIDGE, pb_read, pb_write, dev, &dev->pb_slot);        /* Device 19h: Intel 450KX PCI Bridge PB */
     pci_add_card(PCI_ADD_NORTHBRIDGE_SEC, mc_read, mc_write, dev, &dev->mc_slot);    /* Device 14h: Intel 450KX Memory Controller MC */
 

src/chipset/intel_piix.c

@@ -1538,8 +1538,7 @@ piix_speed_changed(void *priv)
 static void *
 piix_init(const device_t *info)
 {
-    piix_t *dev = (piix_t *) malloc(sizeof(piix_t));
-    memset(dev, 0, sizeof(piix_t));
+    piix_t *dev = (piix_t *) calloc(1, sizeof(piix_t));
 
     dev->type = info->local & 0x0f;
     /* If (dev->type == 4) and (dev->rev & 0x08), then this is PIIX4E. */

src/chipset/intel_sio.c

@@ -508,8 +508,7 @@ sio_speed_changed(void *priv)
 static void *
 sio_init(const device_t *info)
 {
-    sio_t *dev = (sio_t *) malloc(sizeof(sio_t));
-    memset(dev, 0, sizeof(sio_t));
+    sio_t *dev = (sio_t *) calloc(1, sizeof(sio_t));
 
     pci_add_card(PCI_ADD_SOUTHBRIDGE, sio_read, sio_write, dev, &dev->pci_slot);
 

src/chipset/neat.c

@@ -906,8 +906,7 @@ neat_init(UNUSED(const device_t *info))
     uint8_t j;
 
     /* Create an instance. */
-    dev = (neat_t *) malloc(sizeof(neat_t));
-    memset(dev, 0x00, sizeof(neat_t));
+    dev = (neat_t *) calloc(1, sizeof(neat_t));
 
     /* Get configured I/O address. */
     j              = (dev->regs[REG_RB9] & RB9_BASE) >> RB9_BASE_SH;

src/chipset/olivetti_eva.c

@@ -134,8 +134,7 @@ olivetti_eva_close(void *priv)
 static void *
 olivetti_eva_init(UNUSED(const device_t *info))
 {
-    olivetti_eva_t *dev = (olivetti_eva_t *) malloc(sizeof(olivetti_eva_t));
-    memset(dev, 0, sizeof(olivetti_eva_t));
+    olivetti_eva_t *dev = (olivetti_eva_t *) calloc(1, sizeof(olivetti_eva_t));
 
     /* GA98 registers */
     dev->reg_065 = 0x00;

src/chipset/opti283.c

@@ -284,8 +284,7 @@ opti283_close(void *priv)
 static void *
 opti283_init(UNUSED(const device_t *info))
 {
-    opti283_t *dev = (opti283_t *) malloc(sizeof(opti283_t));
-    memset(dev, 0x00, sizeof(opti283_t));
+    opti283_t *dev = (opti283_t *) calloc(1, sizeof(opti283_t));
 
     io_sethandler(0x0022, 0x0001, opti283_read, NULL, NULL, opti283_write, NULL, NULL, dev);
     io_sethandler(0x0023, 0x0001, opti283_read, NULL, NULL, opti283_write, NULL, NULL, dev);

src/chipset/opti291.c

@@ -138,8 +138,7 @@ opti291_close(void *priv)
 static void *
 opti291_init(UNUSED(const device_t *info))
 {
-    opti291_t *dev = (opti291_t *) malloc(sizeof(opti291_t));
-    memset(dev, 0, sizeof(opti291_t));
+    opti291_t *dev = (opti291_t *) calloc(1, sizeof(opti291_t));
 
     io_sethandler(0x022, 0x0001, opti291_read, NULL, NULL, opti291_write, NULL, NULL, dev);
     io_sethandler(0x024, 0x0001, opti291_read, NULL, NULL, opti291_write, NULL, NULL, dev);

src/chipset/opti495.c

@@ -219,8 +219,7 @@ opti495_close(void *priv)
 static void *
 opti495_init(const device_t *info)
 {
-    opti495_t *dev = (opti495_t *) malloc(sizeof(opti495_t));
-    memset(dev, 0, sizeof(opti495_t));
+    opti495_t *dev = (opti495_t *) calloc(1, sizeof(opti495_t));
 
     device_add(&port_92_device);
 

src/chipset/opti499.c

@@ -242,8 +242,7 @@ opti499_close(void *priv)
 static void *
 opti499_init(UNUSED(const device_t *info))
 {
-    opti499_t *dev = (opti499_t *) malloc(sizeof(opti499_t));
-    memset(dev, 0, sizeof(opti499_t));
+    opti499_t *dev = (opti499_t *) calloc(1, sizeof(opti499_t));
 
     device_add(&port_92_device);
 

src/chipset/opti5x7.c

@@ -172,8 +172,7 @@ opti5x7_close(void *priv)
 static void *
 opti5x7_init(const device_t *info)
 {
-    opti5x7_t *dev = (opti5x7_t *) malloc(sizeof(opti5x7_t));
-    memset(dev, 0, sizeof(opti5x7_t));
+    opti5x7_t *dev = (opti5x7_t *) calloc(1, sizeof(opti5x7_t));
 
     dev->is_pci = info->local;
 

src/chipset/opti822.c

@@ -394,8 +394,7 @@ opti822_close(void *priv)
 static void *
 opti822_init(UNUSED(const device_t *info))
 {
-    opti822_t *dev = (opti822_t *) malloc(sizeof(opti822_t));
-    memset(dev, 0, sizeof(opti822_t));
+    opti822_t *dev = (opti822_t *) calloc(1, sizeof(opti822_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, opti822_pci_read, opti822_pci_write, dev, &dev->pci_slot);
 

src/chipset/opti895.c

@@ -259,8 +259,7 @@ opti895_close(void *priv)
 static void *
 opti895_init(const device_t *info)
 {
-    opti895_t *dev = (opti895_t *) malloc(sizeof(opti895_t));
-    memset(dev, 0, sizeof(opti895_t));
+    opti895_t *dev = (opti895_t *) calloc(1, sizeof(opti895_t));
 
     device_add(&port_92_device);
 

src/chipset/scamp.c

@@ -1046,8 +1046,7 @@ static void *
 scamp_init(UNUSED(const device_t *info))
 {
     uint32_t addr;
-    scamp_t *dev = (scamp_t *) malloc(sizeof(scamp_t));
-    memset(dev, 0x00, sizeof(scamp_t));
+    scamp_t *dev = (scamp_t *) calloc(1, sizeof(scamp_t));
 
     dev->cfg_regs[CFG_ID] = ID_VL82C311;
     dev->cfg_enable       = 1;

src/chipset/scat.c

@@ -1403,8 +1403,7 @@ scat_init(const device_t *info)
     uint32_t k;
     int      sx;
 
-    dev = (scat_t *) malloc(sizeof(scat_t));
-    memset(dev, 0x00, sizeof(scat_t));
+    dev = (scat_t *) calloc(1, sizeof(scat_t));
     dev->type = info->local;
 
     sx = (dev->type == 32) ? 1 : 0;

src/chipset/sis_5513_p2i.c

@@ -115,7 +115,7 @@ sis_5513_apc_reset(sis_5513_pci_to_isa_t *dev)
 }
 
 static void
-sis_5513_apc_write(uint16_t addr, uint8_t val, void *priv)
+sis_5513_apc_write(UNUSED(uint16_t addr), uint8_t val, void *priv)
 {
     sis_5513_pci_to_isa_t *dev = (sis_5513_pci_to_isa_t *) priv;
     uint8_t nvr_index = nvr_get_index(dev->nvr, 0);
@@ -135,7 +135,7 @@ sis_5513_apc_write(uint16_t addr, uint8_t val, void *priv)
 }
 
 static uint8_t
-sis_5513_apc_read(uint16_t addr, void *priv)
+sis_5513_apc_read(UNUSED(uint16_t addr), void *priv)
 {
     sis_5513_pci_to_isa_t *dev = (sis_5513_pci_to_isa_t *) priv;
     uint8_t nvr_index = nvr_get_index(dev->nvr, 0);

src/chipset/sis_5571_old.c

@@ -732,8 +732,7 @@ sis_5571_close(void *priv)
 static void *
 sis_5571_init(UNUSED(const device_t *info))
 {
-    sis_5571_t *dev = (sis_5571_t *) malloc(sizeof(sis_5571_t));
-    memset(dev, 0x00, sizeof(sis_5571_t));
+    sis_5571_t *dev = (sis_5571_t *) calloc(1, sizeof(sis_5571_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, memory_pci_bridge_read, memory_pci_bridge_write, dev, &dev->nb_slot);
     pci_add_card(PCI_ADD_SOUTHBRIDGE, pci_isa_bridge_read, pci_isa_bridge_write, dev, &dev->sb_slot);

src/chipset/sis_5595_pmu.c

@@ -119,7 +119,7 @@ sis_5595_pmu_trap_io_mask(int size, uint16_t addr, uint8_t write, uint8_t val, v
 }
 
 static void
-sis_5595_pmu_trap_io_ide_bm(int size, uint16_t addr, uint8_t write, uint8_t val, void *priv)
+sis_5595_pmu_trap_io_ide_bm(UNUSED(int size), UNUSED(uint16_t addr), UNUSED(uint8_t write), UNUSED(uint8_t val), void *priv)
 {
     sis_5595_pmu_io_trap_t *trap = (sis_5595_pmu_io_trap_t *) priv;
     sis_5595_pmu_t *dev = (sis_5595_pmu_t *) trap->priv;

src/chipset/sis_85c310.c

@@ -130,8 +130,7 @@ rabbit_close(void *priv)
 static void *
 rabbit_init(UNUSED(const device_t *info))
 {
-    rabbit_t *dev = (rabbit_t *) malloc(sizeof(rabbit_t));
-    memset(dev, 0, sizeof(rabbit_t));
+    rabbit_t *dev = (rabbit_t *) calloc(1, sizeof(rabbit_t));
 
     io_sethandler(0x0022, 0x0002, rabbit_read, NULL, NULL, rabbit_write, NULL, NULL, dev);
 

src/chipset/sis_85c496.c

@@ -637,8 +637,7 @@ static void
     *
     sis_85c496_init(const device_t *info)
 {
-    sis_85c496_t *dev = malloc(sizeof(sis_85c496_t));
-    memset(dev, 0x00, sizeof(sis_85c496_t));
+    sis_85c496_t *dev = calloc(1, sizeof(sis_85c496_t));
 
     dev->smram = smram_add();
 

src/chipset/sis_85c4xx.c

@@ -368,8 +368,7 @@ sis_85c4xx_close(void *priv)
 static void *
 sis_85c4xx_init(const device_t *info)
 {
-    sis_85c4xx_t *dev = (sis_85c4xx_t *) malloc(sizeof(sis_85c4xx_t));
-    memset(dev, 0, sizeof(sis_85c4xx_t));
+    sis_85c4xx_t *dev = (sis_85c4xx_t *) calloc(1, sizeof(sis_85c4xx_t));
 
     dev->is_471 = (info->local >> 8) & 0xff;
 

src/chipset/stpc.c

@@ -912,8 +912,7 @@ stpc_init(const device_t *info)
 {
     stpc_log("STPC: init()\n");
 
-    stpc_t *dev = (stpc_t *) malloc(sizeof(stpc_t));
-    memset(dev, 0, sizeof(stpc_t));
+    stpc_t *dev = (stpc_t *) calloc(1, sizeof(stpc_t));
 
     dev->local = info->local;
 
@@ -963,8 +962,7 @@ stpc_serial_init(UNUSED(const device_t *info))
 {
     stpc_log("STPC: serial_init()\n");
 
-    stpc_serial_t *dev = (stpc_serial_t *) malloc(sizeof(stpc_serial_t));
-    memset(dev, 0, sizeof(stpc_serial_t));
+    stpc_serial_t *dev = (stpc_serial_t *) calloc(1, sizeof(stpc_serial_t));
 
     dev->uart[0] = device_add_inst(&ns16550_device, 1);
     dev->uart[1] = device_add_inst(&ns16550_device, 2);
@@ -1076,8 +1074,7 @@ stpc_lpt_init(UNUSED(const device_t *info))
 {
     stpc_log("STPC: lpt_init()\n");
 
-    stpc_lpt_t *dev = (stpc_lpt_t *) malloc(sizeof(stpc_lpt_t));
-    memset(dev, 0, sizeof(stpc_lpt_t));
+    stpc_lpt_t *dev = (stpc_lpt_t *) calloc(1, sizeof(stpc_lpt_t));
 
     stpc_lpt_reset(dev);
 

src/chipset/umc_8886.c

@@ -392,8 +392,7 @@ umc_8886_close(void *priv)
 static void *
 umc_8886_init(const device_t *info)
 {
-    umc_8886_t *dev = (umc_8886_t *) malloc(sizeof(umc_8886_t));
-    memset(dev, 0, sizeof(umc_8886_t));
+    umc_8886_t *dev = (umc_8886_t *) calloc(1, sizeof(umc_8886_t));
 
     /* Device 12: UMC 8886xx */
     pci_add_card(PCI_ADD_SOUTHBRIDGE, umc_8886_read, umc_8886_write, dev, &dev->pci_slot);

src/chipset/umc_8890.c

@@ -38,6 +38,7 @@
 #include <86box/smram.h>
 
 #include <86box/chipset.h>
+#include <86box/plat_unused.h>
 
 #ifdef ENABLE_UMC_8890_LOG
 int umc_8890_do_log = ENABLE_UMC_8890_LOG;
@@ -209,7 +210,7 @@ umc_8890_close(void *priv)
 
 
 static void *
-umc_8890_init(const device_t *info)
+umc_8890_init(UNUSED(const device_t *info))
 {
     umc_8890_t *dev = (umc_8890_t *) calloc(1, sizeof(umc_8890_t));
 

src/chipset/umc_hb4.c

@@ -450,8 +450,7 @@ ims8848_read(uint16_t addr, void *priv)
 static void *
 hb4_init(UNUSED(const device_t *info))
 {
-    hb4_t *dev = (hb4_t *) malloc(sizeof(hb4_t));
-    memset(dev, 0, sizeof(hb4_t));
+    hb4_t *dev = (hb4_t *) calloc(1, sizeof(hb4_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, hb4_read, hb4_write, dev, &dev->pci_slot); /* Device 10: UMC 8881x */
 

src/chipset/via_apollo.c

@@ -725,8 +725,7 @@ via_apollo_reset(void *priv)
 static void *
 via_apollo_init(const device_t *info)
 {
-    via_apollo_t *dev = (via_apollo_t *) malloc(sizeof(via_apollo_t));
-    memset(dev, 0, sizeof(via_apollo_t));
+    via_apollo_t *dev = (via_apollo_t *) calloc(1, sizeof(via_apollo_t));
 
     dev->smram = smram_add();
     if (dev->id != VIA_8601)

src/chipset/via_pipc.c

@@ -1627,8 +1627,7 @@ pipc_reset(void *priv)
 static void *
 pipc_init(const device_t *info)
 {
-    pipc_t *dev = (pipc_t *) malloc(sizeof(pipc_t));
-    memset(dev, 0, sizeof(pipc_t));
+    pipc_t *dev = (pipc_t *) calloc(1, sizeof(pipc_t));
 
     pipc_log("PIPC: init()\n");
 

src/chipset/via_vt82c49x.c

@@ -342,8 +342,7 @@ vt82c49x_close(void *priv)
 static void *
 vt82c49x_init(const device_t *info)
 {
-    vt82c49x_t *dev = (vt82c49x_t *) malloc(sizeof(vt82c49x_t));
-    memset(dev, 0x00, sizeof(vt82c49x_t));
+    vt82c49x_t *dev = (vt82c49x_t *) calloc(1, sizeof(vt82c49x_t));
 
     dev->smram_smm  = smram_add();
     dev->smram_low  = smram_add();

src/chipset/via_vt82c505.c

@@ -167,7 +167,7 @@ vt82c505_in(uint16_t addr, void *priv)
 static void
 vt82c505_reset(void *priv)
 {
-    vt82c505_t *dev = (vt82c505_t *) malloc(sizeof(vt82c505_t));
+    vt82c505_t *dev = (vt82c505_t *) calloc(1, sizeof(vt82c505_t));
 
     dev->pci_conf[0x04] = 0x07;
     dev->pci_conf[0x07] = 0x00;
@@ -204,8 +204,7 @@ vt82c505_close(void *priv)
 static void *
 vt82c505_init(UNUSED(const device_t *info))
 {
-    vt82c505_t *dev = (vt82c505_t *) malloc(sizeof(vt82c505_t));
-    memset(dev, 0, sizeof(vt82c505_t));
+    vt82c505_t *dev = (vt82c505_t *) calloc(1, sizeof(vt82c505_t));
 
     pci_add_card(PCI_ADD_NORTHBRIDGE, vt82c505_read, vt82c505_write, dev, &dev->pci_slot);
 

src/chipset/vl82c480.c

@@ -180,8 +180,7 @@ vl82c480_close(void *priv)
 static void *
 vl82c480_init(const device_t *info)
 {
-    vl82c480_t *dev = (vl82c480_t *) malloc(sizeof(vl82c480_t));
-    memset(dev, 0, sizeof(vl82c480_t));
+    vl82c480_t *dev = (vl82c480_t *) calloc(1, sizeof(vl82c480_t));
 
     dev->regs[0x00] = info->local;
     dev->regs[0x01] = 0xff;

src/chipset/wd76c10.c

@@ -37,6 +37,7 @@
 #include <86box/port_92.h>
 #include <86box/serial.h>
 #include <86box/plat_fallthrough.h>
+#include <86box/plat_unused.h>
 #include <86box/chipset.h>
 
 /* Lock/Unlock Procedures */
@@ -879,12 +880,12 @@ wd76c10_reset(void *priv)
 
 
 static void *
-wd76c10_init(const device_t *info)
+wd76c10_init(UNUSED(const device_t *info))
 {
     wd76c10_t *dev = (wd76c10_t *) calloc(1, sizeof(wd76c10_t));
     uint32_t total_mem = mem_size << 10;
     uint32_t accum_mem = 0x00000000;
-    ram_bank_t *rb;
+    ram_bank_t *rb = NULL;
 
     /* Calculate the physical RAM banks. */
     for (uint8_t i = 0; i < 4; i++) {

src/codegen/codegen_ops_arith.h

@@ -1,5 +1,5 @@
 static uint32_t
-ropINC_rw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropINC_rw(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -22,7 +22,7 @@ ropINC_rw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc;
 }
 static uint32_t
-ropINC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropINC_rl(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -45,7 +45,7 @@ ropINC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc;
 }
 static uint32_t
-ropDEC_rw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropDEC_rw(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -68,7 +68,7 @@ ropDEC_rw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc;
 }
 static uint32_t
-ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropDEC_rl(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -93,7 +93,7 @@ ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 
 #define ROP_ARITH_RMW(name, op, writeback)                                                                   \
     static uint32_t                                                                                          \
-    rop##name##_b_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_b_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int     src_reg;                                                                                     \
         int     dst_reg;                                                                                     \
@@ -129,7 +129,7 @@ ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_w_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_w_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int     src_reg;                                                                                     \
         int     dst_reg;                                                                                     \
@@ -165,7 +165,7 @@ ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_l_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_l_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int     src_reg;                                                                                     \
         int     dst_reg;                                                                                     \
@@ -203,7 +203,7 @@ ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 
 #define ROP_ARITH_RM(name, op, writeback)                                                                   \
     static uint32_t                                                                                         \
-    rop##name##_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_b_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                       \
         int src_reg;                                                                                        \
         int dst_reg;                                                                                        \
@@ -233,7 +233,7 @@ ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
         return op_pc + 1;                                                                                   \
     }                                                                                                       \
     static uint32_t                                                                                         \
-    rop##name##_w_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_w_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                       \
         int src_reg;                                                                                        \
         int dst_reg;                                                                                        \
@@ -263,7 +263,7 @@ ropDEC_rl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
         return op_pc + 1;                                                                                   \
     }                                                                                                       \
     static uint32_t                                                                                         \
-    rop##name##_l_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_l_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                       \
         int src_reg;                                                                                        \
         int dst_reg;                                                                                        \
@@ -299,7 +299,7 @@ ROP_ARITH_RM(ADD, ADD, 1)
 ROP_ARITH_RM(SUB, SUB, 1)
 
 static uint32_t
-ropCMP_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_b_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -326,7 +326,7 @@ ropCMP_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc + 1;
 }
 static uint32_t
-ropCMP_w_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_w_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -353,7 +353,7 @@ ropCMP_w_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc + 1;
 }
 static uint32_t
-ropCMP_l_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_l_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -381,7 +381,7 @@ ropCMP_l_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
 }
 
 static uint32_t
-ropCMP_b_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_b_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -408,7 +408,7 @@ ropCMP_b_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropCMP_w_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_w_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -435,7 +435,7 @@ ropCMP_w_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropCMP_l_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_l_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -463,7 +463,7 @@ ropCMP_l_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropADD_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropADD_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -478,7 +478,7 @@ ropADD_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropADD_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropADD_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -493,7 +493,7 @@ ropADD_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropADD_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropADD_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -510,7 +510,7 @@ ropADD_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
 }
 
 static uint32_t
-ropCMP_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -525,7 +525,7 @@ ropCMP_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropCMP_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -540,7 +540,7 @@ ropCMP_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropCMP_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCMP_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -557,7 +557,7 @@ ropCMP_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
 }
 
 static uint32_t
-ropSUB_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropSUB_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -572,7 +572,7 @@ ropSUB_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropSUB_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropSUB_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -587,7 +587,7 @@ ropSUB_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropSUB_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropSUB_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -604,7 +604,7 @@ ropSUB_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
 }
 
 static uint32_t
-rop80(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+rop80(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int      host_reg;
     uint32_t imm;
@@ -679,7 +679,7 @@ rop80(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblo
 }
 
 static uint32_t
-rop81_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+rop81_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int      host_reg;
     uint32_t imm;
@@ -753,7 +753,7 @@ rop81_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc + 3;
 }
 static uint32_t
-rop81_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+rop81_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int      host_reg;
     uint32_t imm;
@@ -827,7 +827,7 @@ rop81_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
 }
 
 static uint32_t
-rop83_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+rop83_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int      host_reg;
     uint32_t imm;
@@ -904,7 +904,7 @@ rop83_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc + 2;
 }
 static uint32_t
-rop83_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+rop83_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int      host_reg;
     uint32_t imm;

src/codegen/codegen_ops_fpu.h

@@ -1,5 +1,5 @@
 static uint32_t
-ropFXCH(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFXCH(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
 
@@ -9,7 +9,7 @@ ropFXCH(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
 }
 
 static uint32_t
-ropFLD(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFLD(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
 
@@ -19,7 +19,7 @@ ropFLD(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codebl
 }
 
 static uint32_t
-ropFST(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFST(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
 
@@ -28,7 +28,7 @@ ropFST(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codebl
     return op_pc;
 }
 static uint32_t
-ropFSTP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSTP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
 
@@ -39,7 +39,7 @@ ropFSTP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
 }
 
 static uint32_t
-ropFLDs(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFLDs(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
 
@@ -57,7 +57,7 @@ ropFLDs(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc + 1;
 }
 static uint32_t
-ropFLDd(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFLDd(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
 
@@ -76,7 +76,7 @@ ropFLDd(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
 }
 
 static uint32_t
-ropFILDw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFILDw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
 
@@ -94,7 +94,7 @@ ropFILDw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc + 1;
 }
 static uint32_t
-ropFILDl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFILDl(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
 
@@ -112,7 +112,7 @@ ropFILDl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc + 1;
 }
 static uint32_t
-ropFILDq(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFILDq(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
 
@@ -133,7 +133,7 @@ ropFILDq(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
 }
 
 static uint32_t
-ropFSTs(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSTs(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
     int     host_reg;
@@ -153,7 +153,7 @@ ropFSTs(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc + 1;
 }
 static uint32_t
-ropFSTd(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSTd(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
     int     host_reg1;
@@ -194,24 +194,28 @@ ropFSTPd(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return new_pc;
 }
 
-#define ropFarith(name, size, load, op)                                                                     \
-    static uint32_t                                                                                         \
-    ropF##name##size(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                       \
-        x86seg *target_seg;                                                                                 \
-                                                                                                            \
-        FP_ENTER();                                                                                         \
-        op_pc--;                                                                                            \
-        target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32);                                \
-                                                                                                            \
-        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                                          \
-                                                                                                            \
-        CHECK_SEG_READ(target_seg);                                                                         \
-        load(target_seg);                                                                                   \
-                                                                                                            \
-        op(FPU_##name);                                                                                     \
-                                                                                                            \
-        return op_pc + 1;                                                                                   \
+#define ropFarith(name, size, load, op)                                      \
+    static uint32_t                                                          \
+    ropF##name##size(UNUSED(uint8_t opcode),                                 \
+                     uint32_t fetchdat,                                      \
+                     uint32_t op_32,                                         \
+                     uint32_t op_pc,                                         \
+                     UNUSED(codeblock_t *block))                             \
+    {                                                                        \
+        x86seg *target_seg;                                                  \
+                                                                             \
+        FP_ENTER();                                                          \
+        op_pc--;                                                             \
+        target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32); \
+                                                                             \
+        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);           \
+                                                                             \
+        CHECK_SEG_READ(target_seg);                                          \
+        load(target_seg);                                                    \
+                                                                             \
+        op(FPU_##name);                                                      \
+                                                                             \
+        return op_pc + 1;                                                    \
     }
 
 ropFarith(ADD, s, MEM_LOAD_ADDR_EA_L, FP_OP_S);
@@ -239,32 +243,40 @@ ropFarith(MUL, il, MEM_LOAD_ADDR_EA_L, FP_OP_IL);
 ropFarith(SUB, il, MEM_LOAD_ADDR_EA_L, FP_OP_IL);
 ropFarith(SUBR, il, MEM_LOAD_ADDR_EA_L, FP_OP_IL);
 
-#define ropFcompare(name, size, load, op)                                                                                      \
-    static uint32_t                                                                                                            \
-    ropF##name##size(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)                    \
-    {                                                                                                                          \
-        x86seg *target_seg;                                                                                                    \
-                                                                                                                               \
-        FP_ENTER();                                                                                                            \
-        op_pc--;                                                                                                               \
-        target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32);                                                   \
-                                                                                                                               \
-        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                                                             \
-                                                                                                                               \
-        CHECK_SEG_READ(target_seg);                                                                                            \
-        load(target_seg);                                                                                                      \
-                                                                                                                               \
-        op();                                                                                                                  \
-                                                                                                                               \
-        return op_pc + 1;                                                                                                      \
-    }                                                                                                                          \
-    static uint32_t ropF##name##P##size(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                                          \
-        uint32_t new_pc = ropF##name##size(opcode, fetchdat, op_32, op_pc, block);                                             \
-                                                                                                                               \
-        FP_POP();                                                                                                              \
-                                                                                                                               \
-        return new_pc;                                                                                                         \
+#define ropFcompare(name, size, load, op)                                          \
+    static uint32_t                                                                \
+    ropF##name##size(UNUSED(uint8_t opcode),                                       \
+                     uint32_t fetchdat,                                            \
+                     uint32_t op_32,                                               \
+                     uint32_t op_pc,                                               \
+                     UNUSED(codeblock_t *block))                                   \
+    {                                                                              \
+        x86seg *target_seg;                                                        \
+                                                                                   \
+        FP_ENTER();                                                                \
+        op_pc--;                                                                   \
+        target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32);       \
+                                                                                   \
+        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                 \
+                                                                                   \
+        CHECK_SEG_READ(target_seg);                                                \
+        load(target_seg);                                                          \
+                                                                                   \
+        op();                                                                      \
+                                                                                   \
+        return op_pc + 1;                                                          \
+    }                                                                              \
+    static uint32_t ropF##name##P##size(uint8_t opcode,                            \
+                                        uint32_t fetchdat,                         \
+                                        uint32_t op_32,                            \
+                                        uint32_t op_pc,                            \
+                                        codeblock_t *block)                        \
+    {                                                                              \
+        uint32_t new_pc = ropF##name##size(opcode, fetchdat, op_32, op_pc, block); \
+                                                                                   \
+        FP_POP();                                                                  \
+                                                                                   \
+        return new_pc;                                                             \
     }
 
 ropFcompare(COM, s, MEM_LOAD_ADDR_EA_L, FP_COMPARE_S);
@@ -348,7 +360,7 @@ ropFSUBs(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
 #endif
 
 static uint32_t
-ropFADD(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFADD(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_ADD, 0, opcode & 7);
@@ -356,7 +368,7 @@ ropFADD(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc;
 }
 static uint32_t
-ropFCOM(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFCOM(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_COMPARE_REG(0, opcode & 7);
@@ -364,7 +376,7 @@ ropFCOM(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc;
 }
 static uint32_t
-ropFDIV(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFDIV(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_DIV, 0, opcode & 7);
@@ -372,7 +384,7 @@ ropFDIV(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc;
 }
 static uint32_t
-ropFDIVR(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFDIVR(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_DIVR, 0, opcode & 7);
@@ -380,7 +392,7 @@ ropFDIVR(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFMUL(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFMUL(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_MUL, 0, opcode & 7);
@@ -388,7 +400,7 @@ ropFMUL(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc;
 }
 static uint32_t
-ropFSUB(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSUB(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_SUB, 0, opcode & 7);
@@ -396,7 +408,7 @@ ropFSUB(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc;
 }
 static uint32_t
-ropFSUBR(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSUBR(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_SUBR, 0, opcode & 7);
@@ -405,7 +417,7 @@ ropFSUBR(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
 }
 
 static uint32_t
-ropFADDr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFADDr(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_ADD, opcode & 7, 0);
@@ -413,7 +425,7 @@ ropFADDr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFDIVr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFDIVr(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_DIV, opcode & 7, 0);
@@ -421,7 +433,7 @@ ropFDIVr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFDIVRr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFDIVRr(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_DIVR, opcode & 7, 0);
@@ -429,7 +441,7 @@ ropFDIVRr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc;
 }
 static uint32_t
-ropFMULr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFMULr(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_MUL, opcode & 7, 0);
@@ -437,7 +449,7 @@ ropFMULr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFSUBr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSUBr(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_SUB, opcode & 7, 0);
@@ -445,7 +457,7 @@ ropFSUBr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFSUBRr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSUBRr(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_SUBR, opcode & 7, 0);
@@ -454,7 +466,7 @@ ropFSUBRr(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropFADDP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFADDP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_ADD, opcode & 7, 0);
@@ -463,7 +475,7 @@ ropFADDP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFCOMP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFCOMP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_COMPARE_REG(0, opcode & 7);
@@ -472,7 +484,7 @@ ropFCOMP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFDIVP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFDIVP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_DIV, opcode & 7, 0);
@@ -481,7 +493,7 @@ ropFDIVP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFDIVRP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFDIVRP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_DIVR, opcode & 7, 0);
@@ -490,7 +502,7 @@ ropFDIVRP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc;
 }
 static uint32_t
-ropFMULP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFMULP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_MUL, opcode & 7, 0);
@@ -499,7 +511,7 @@ ropFMULP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFSUBP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSUBP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_SUB, opcode & 7, 0);
@@ -508,7 +520,7 @@ ropFSUBP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc;
 }
 static uint32_t
-ropFSUBRP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSUBRP(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_OP_REG(FPU_SUBR, opcode & 7, 0);
@@ -518,7 +530,7 @@ ropFSUBRP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropFCOMPP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFCOMPP(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_COMPARE_REG(0, 1);
@@ -528,7 +540,7 @@ ropFCOMPP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropFSTSW_AX(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSTSW_AX(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -540,7 +552,7 @@ ropFSTSW_AX(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
 }
 
 static uint32_t
-ropFISTw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFISTw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
     int     host_reg;
@@ -560,7 +572,7 @@ ropFISTw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc + 1;
 }
 static uint32_t
-ropFISTl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFISTl(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
     int     host_reg;
@@ -599,7 +611,7 @@ ropFISTPl(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return new_pc;
 }
 static uint32_t
-ropFISTPq(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFISTPq(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
     int     host_reg1;
@@ -623,7 +635,7 @@ ropFISTPq(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropFLDCW(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFLDCW(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
 
@@ -640,7 +652,7 @@ ropFLDCW(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc + 1;
 }
 static uint32_t
-ropFSTCW(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFSTCW(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int     host_reg;
     x86seg *target_seg;
@@ -658,7 +670,7 @@ ropFSTCW(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
 }
 
 static uint32_t
-ropFCHS(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFCHS(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_FCHS();
@@ -666,17 +678,21 @@ ropFCHS(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc;
 }
 
-#define opFLDimm(name, v)                                                                               \
-    static uint32_t                                                                                     \
-    ropFLD##name(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                   \
-        static double fp_imm = v;                                                                       \
-        static uint64_t *fptr = (uint64_t *) &fp_imm;                                                   \
-                                                                                                        \
-        FP_ENTER();                                                                                     \
-        FP_LOAD_IMM_Q(*fptr);                                                                           \
-                                                                                                        \
-        return op_pc;                                                                                   \
+#define opFLDimm(name, v)                             \
+    static uint32_t                                   \
+    ropFLD##name(UNUSED(uint8_t opcode),              \
+                 UNUSED(uint32_t fetchdat),           \
+                 UNUSED(uint32_t op_32),              \
+                 uint32_t op_pc,                      \
+                 UNUSED(codeblock_t *block))          \
+    {                                                 \
+        static double fp_imm = v;                     \
+        static uint64_t *fptr = (uint64_t *) &fp_imm; \
+                                                      \
+        FP_ENTER();                                   \
+        FP_LOAD_IMM_Q(*fptr);                         \
+                                                      \
+        return op_pc;                                 \
     }
 
 // clang-format off
@@ -689,7 +705,7 @@ opFLDimm(Z, 0.0)
 // clang-format on
 
 static uint32_t
-ropFLDLN2(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
+ropFLDLN2(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     FP_ENTER();
     FP_LOAD_IMM_Q(0x3fe62e42fefa39f0ULL);

src/codegen/codegen_ops_jump.h

@@ -1,5 +1,5 @@
 static uint32_t
-ropJMP_r8(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropJMP_r8(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t offset = fetchdat & 0xff;
 
@@ -12,7 +12,7 @@ ropJMP_r8(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropJMP_r16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropJMP_r16(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint16_t offset = fetchdat & 0xffff;
 
@@ -22,7 +22,7 @@ ropJMP_r16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
 }
 
 static uint32_t
-ropJMP_r32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropJMP_r32(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t offset = fastreadl(cs + op_pc);
 
@@ -32,7 +32,7 @@ ropJMP_r32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
 }
 
 static uint32_t
-ropJCXZ(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropJCXZ(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t offset = fetchdat & 0xff;
 
@@ -51,7 +51,7 @@ ropJCXZ(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
 }
 
 static uint32_t
-ropLOOP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropLOOP(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t offset = fetchdat & 0xff;
 
@@ -214,45 +214,51 @@ BRANCH_COND_S(int pc_offset, uint32_t op_pc, uint32_t offset, int not )
     }
 }
 
-#define ropBRANCH(name, func, not )                   \
-    static uint32_t                                   \
-    rop##name(uint8_t opcode, uint32_t fetchdat,      \
-              uint32_t op_32, uint32_t op_pc,         \
-              codeblock_t *block)                     \
-    {                                                 \
-        uint32_t offset = fetchdat & 0xff;            \
-                                                      \
-        if (offset & 0x80)                            \
-            offset |= 0xffffff00;                     \
-                                                      \
-        func(1, op_pc, offset, not );                 \
-                                                      \
-        return op_pc + 1;                             \
-    }                                                 \
-    static uint32_t                                   \
-    rop##name##_w(uint8_t  opcode,                    \
-                  uint32_t fetchdat, uint32_t op_32,  \
-                  uint32_t op_pc, codeblock_t *block) \
-    {                                                 \
-        uint32_t offset = fetchdat & 0xffff;          \
-                                                      \
-        if (offset & 0x8000)                          \
-            offset |= 0xffff0000;                     \
-                                                      \
-        func(2, op_pc, offset, not );                 \
-                                                      \
-        return op_pc + 2;                             \
-    }                                                 \
-    static uint32_t                                   \
-    rop##name##_l(uint8_t  opcode,                    \
-                  uint32_t fetchdat, uint32_t op_32,  \
-                  uint32_t op_pc, codeblock_t *block) \
-    {                                                 \
-        uint32_t offset = fastreadl(cs + op_pc);      \
-                                                      \
-        func(4, op_pc, offset, not );                 \
-                                                      \
-        return op_pc + 4;                             \
+#define ropBRANCH(name, func, not )              \
+    static uint32_t                              \
+    rop##name(UNUSED(uint8_t opcode),            \
+              uint32_t fetchdat,                 \
+              UNUSED(uint32_t op_32),            \
+              uint32_t op_pc,                    \
+              UNUSED(codeblock_t *block))        \
+    {                                            \
+        uint32_t offset = fetchdat & 0xff;       \
+                                                 \
+        if (offset & 0x80)                       \
+            offset |= 0xffffff00;                \
+                                                 \
+        func(1, op_pc, offset, not );            \
+                                                 \
+        return op_pc + 1;                        \
+    }                                            \
+    static uint32_t                              \
+    rop##name##_w(UNUSED(uint8_t opcode),        \
+                  uint32_t fetchdat,             \
+                  UNUSED(uint32_t op_32),        \
+                  uint32_t op_pc,                \
+                  UNUSED(codeblock_t *block))    \
+    {                                            \
+        uint32_t offset = fetchdat & 0xffff;     \
+                                                 \
+        if (offset & 0x8000)                     \
+            offset |= 0xffff0000;                \
+                                                 \
+        func(2, op_pc, offset, not );            \
+                                                 \
+        return op_pc + 2;                        \
+    }                                            \
+    static uint32_t                              \
+    rop##name##_l(UNUSED(uint8_t opcode),        \
+                  UNUSED(uint32_t fetchdat),     \
+                  UNUSED(uint32_t op_32),        \
+                  uint32_t op_pc,                \
+                  UNUSED(codeblock_t *block))    \
+    {                                            \
+        uint32_t offset = fastreadl(cs + op_pc); \
+                                                 \
+        func(4, op_pc, offset, not );            \
+                                                 \
+        return op_pc + 4;                        \
     }
 
 // clang-format off

src/codegen/codegen_ops_logic.h

@@ -1,6 +1,6 @@
 #define ROP_LOGIC(name, op, writeback)                                                                       \
     static uint32_t                                                                                          \
-    rop##name##_b_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_b_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int     src_reg;                                                                                     \
         int     dst_reg;                                                                                     \
@@ -33,7 +33,7 @@
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_w_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_w_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int     src_reg;                                                                                     \
         int     dst_reg;                                                                                     \
@@ -66,7 +66,7 @@
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_l_rmw(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    rop##name##_l_rmw(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int     src_reg;                                                                                     \
         int     dst_reg;                                                                                     \
@@ -99,7 +99,7 @@
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)  \
+    rop##name##_b_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int src_reg;                                                                                         \
         int dst_reg;                                                                                         \
@@ -126,7 +126,7 @@
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_w_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)  \
+    rop##name##_w_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int src_reg;                                                                                         \
         int dst_reg;                                                                                         \
@@ -153,7 +153,7 @@
         return op_pc + 1;                                                                                    \
     }                                                                                                        \
     static uint32_t                                                                                          \
-    rop##name##_l_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)  \
+    rop##name##_l_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                        \
         int src_reg;                                                                                         \
         int dst_reg;                                                                                         \
@@ -185,7 +185,7 @@ ROP_LOGIC(OR, OR, 1)
 ROP_LOGIC(XOR, XOR, 1)
 
 static uint32_t
-ropTEST_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropTEST_b_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -209,7 +209,7 @@ ropTEST_b_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropTEST_w_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropTEST_w_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -233,7 +233,7 @@ ropTEST_w_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropTEST_l_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropTEST_l_rm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -258,7 +258,7 @@ ropTEST_l_rm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropAND_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropAND_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -270,7 +270,7 @@ ropAND_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropAND_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropAND_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -282,7 +282,7 @@ ropAND_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropAND_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropAND_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -296,7 +296,7 @@ ropAND_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
 }
 
 static uint32_t
-ropOR_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropOR_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -308,7 +308,7 @@ ropOR_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropOR_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropOR_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -320,7 +320,7 @@ ropOR_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropOR_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropOR_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -334,7 +334,7 @@ ropOR_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropTEST_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropTEST_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -346,7 +346,7 @@ ropTEST_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
     return op_pc + 1;
 }
 static uint32_t
-ropTEST_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropTEST_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -358,7 +358,7 @@ ropTEST_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
     return op_pc + 2;
 }
 static uint32_t
-ropTEST_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropTEST_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -372,7 +372,7 @@ ropTEST_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_p
 }
 
 static uint32_t
-ropXOR_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropXOR_AL_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B(REG_AL);
 
@@ -384,7 +384,7 @@ ropXOR_AL_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropXOR_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropXOR_AX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W(REG_AX);
 
@@ -396,7 +396,7 @@ ropXOR_AX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropXOR_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropXOR_EAX_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_L(REG_EAX);
 
@@ -410,7 +410,7 @@ ropXOR_EAX_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
 }
 
 static uint32_t
-ropF6(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropF6(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg;
     int     host_reg;
@@ -458,7 +458,7 @@ ropF6(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblo
     return 0;
 }
 static uint32_t
-ropF7_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropF7_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg  *target_seg;
     int      host_reg;
@@ -506,7 +506,7 @@ ropF7_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return 0;
 }
 static uint32_t
-ropF7_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropF7_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg  *target_seg;
     int      host_reg;

src/codegen/codegen_ops_misc.h

@@ -1,24 +1,24 @@
 static uint32_t
-ropNOP(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropNOP(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     return op_pc;
 }
 
 static uint32_t
-ropCLD(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCLD(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     CLEAR_BITS((uintptr_t) &cpu_state.flags, D_FLAG);
     return op_pc;
 }
 static uint32_t
-ropSTD(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropSTD(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     SET_BITS((uintptr_t) &cpu_state.flags, D_FLAG);
     return op_pc;
 }
 
 static uint32_t
-ropCLI(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCLI(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if (!IOPLp && (cr4 & (CR4_VME | CR4_PVI)))
         return 0;
@@ -29,7 +29,7 @@ ropCLI(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codebl
     return op_pc;
 }
 static uint32_t
-ropSTI(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropSTI(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if (!IOPLp && (cr4 & (CR4_VME | CR4_PVI)))
         return 0;
@@ -38,7 +38,7 @@ ropSTI(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codebl
 }
 
 static uint32_t
-ropFE(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFE(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     host_reg;
@@ -88,7 +88,7 @@ ropFE(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblo
 }
 static uint32_t codegen_temp;
 static uint32_t
-ropFF_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFF_16(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     host_reg;
@@ -175,7 +175,7 @@ ropFF_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return 0;
 }
 static uint32_t
-ropFF_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropFF_32(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     host_reg;

src/codegen/codegen_ops_mmx.h

@@ -1,5 +1,5 @@
 static uint32_t
-ropMOVQ_q_mm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVQ_q_mm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg1;
     int host_reg2 = 0;
@@ -25,7 +25,7 @@ ropMOVQ_q_mm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOVQ_mm_q(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVQ_mm_q(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     MMX_ENTER();
 
@@ -50,7 +50,7 @@ ropMOVQ_mm_q(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOVD_l_mm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVD_l_mm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -74,7 +74,7 @@ ropMOVD_l_mm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropMOVD_mm_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVD_mm_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     MMX_ENTER();
 
@@ -95,36 +95,40 @@ ropMOVD_mm_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 
-#define MMX_OP(name, func)                                                                      \
-    static uint32_t                                                                             \
-    name(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                           \
-        int src_reg1;                                                                           \
-        int src_reg2;                                                                           \
-        int xmm_src;                                                                            \
-        int xmm_dst;                                                                            \
-                                                                                                \
-        MMX_ENTER();                                                                            \
-                                                                                                \
-        if ((fetchdat & 0xc0) == 0xc0) {                                                        \
-            xmm_src = LOAD_MMX_Q_MMX(fetchdat & 7);                                             \
-        } else {                                                                                \
-            x86seg *target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32);        \
-                                                                                                \
-            STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                          \
-                                                                                                \
-            CHECK_SEG_READ(target_seg);                                                         \
-                                                                                                \
-            MEM_LOAD_ADDR_EA_Q(target_seg);                                                     \
-            src_reg1 = LOAD_Q_REG_1;                                                            \
-            src_reg2 = LOAD_Q_REG_2;                                                            \
-            xmm_src  = LOAD_INT_TO_MMX(src_reg1, src_reg2);                                     \
-        }                                                                                       \
-        xmm_dst = LOAD_MMX_Q_MMX((fetchdat >> 3) & 7);                                          \
-        func(xmm_dst, xmm_src);                                                                 \
-        STORE_MMX_Q_MMX((fetchdat >> 3) & 7, xmm_dst);                                          \
-                                                                                                \
-        return op_pc + 1;                                                                       \
+#define MMX_OP(name, func)                                                               \
+    static uint32_t                                                                      \
+    name(UNUSED(uint8_t opcode),                                                         \
+         uint32_t fetchdat,                                                              \
+         uint32_t op_32,                                                                 \
+         uint32_t op_pc,                                                                 \
+         UNUSED(codeblock_t *block))                                                     \
+    {                                                                                    \
+        int src_reg1;                                                                    \
+        int src_reg2;                                                                    \
+        int xmm_src;                                                                     \
+        int xmm_dst;                                                                     \
+                                                                                         \
+        MMX_ENTER();                                                                     \
+                                                                                         \
+        if ((fetchdat & 0xc0) == 0xc0) {                                                 \
+            xmm_src = LOAD_MMX_Q_MMX(fetchdat & 7);                                      \
+        } else {                                                                         \
+            x86seg *target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32); \
+                                                                                         \
+            STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                   \
+                                                                                         \
+            CHECK_SEG_READ(target_seg);                                                  \
+                                                                                         \
+            MEM_LOAD_ADDR_EA_Q(target_seg);                                              \
+            src_reg1 = LOAD_Q_REG_1;                                                     \
+            src_reg2 = LOAD_Q_REG_2;                                                     \
+            xmm_src  = LOAD_INT_TO_MMX(src_reg1, src_reg2);                              \
+        }                                                                                \
+        xmm_dst = LOAD_MMX_Q_MMX((fetchdat >> 3) & 7);                                   \
+        func(xmm_dst, xmm_src);                                                          \
+        STORE_MMX_Q_MMX((fetchdat >> 3) & 7, xmm_dst);                                   \
+                                                                                         \
+        return op_pc + 1;                                                                \
     }
 
 MMX_OP(ropPAND, MMX_AND)
@@ -179,7 +183,7 @@ MMX_OP(ropPMULHW, MMX_PMULHW);
 MMX_OP(ropPMADDWD, MMX_PMADDWD);
 
 static uint32_t
-ropPSxxW_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPSxxW_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int xmm_dst;
 
@@ -207,7 +211,7 @@ ropPSxxW_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropPSxxD_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPSxxD_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int xmm_dst;
 
@@ -235,7 +239,7 @@ ropPSxxD_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropPSxxQ_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPSxxQ_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int xmm_dst;
 
@@ -264,7 +268,7 @@ ropPSxxQ_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropEMMS(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropEMMS(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc), UNUSED(codeblock_t *block))
 {
     codegen_mmx_entered = 0;
 

src/codegen/codegen_ops_mov.h

@@ -1,19 +1,19 @@
 static uint32_t
-ropMOV_rb_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_rb_imm(uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     STORE_IMM_REG_B(opcode & 7, fetchdat & 0xff);
 
     return op_pc + 1;
 }
 static uint32_t
-ropMOV_rw_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_rw_imm(uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     STORE_IMM_REG_W(opcode & 7, fetchdat & 0xffff);
 
     return op_pc + 2;
 }
 static uint32_t
-ropMOV_rl_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_rl_imm(uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     fetchdat = fastreadl(cs + op_pc);
 
@@ -23,7 +23,7 @@ ropMOV_rl_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOV_b_r(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_b_r(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_B((fetchdat >> 3) & 7);
 
@@ -44,7 +44,7 @@ ropMOV_b_r(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
     return op_pc + 1;
 }
 static uint32_t
-ropMOV_w_r(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_w_r(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg = LOAD_REG_W((fetchdat >> 3) & 7);
 
@@ -66,7 +66,7 @@ ropMOV_w_r(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
 }
 
 static uint32_t
-ropMOV_l_r(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_l_r(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -90,7 +90,7 @@ ropMOV_l_r(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
 }
 
 static uint32_t
-ropMOV_r_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_r_b(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_B(fetchdat & 7);
@@ -109,7 +109,7 @@ ropMOV_r_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
     return op_pc + 1;
 }
 static uint32_t
-ropMOV_r_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_r_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_W(fetchdat & 7);
@@ -128,7 +128,7 @@ ropMOV_r_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
     return op_pc + 1;
 }
 static uint32_t
-ropMOV_r_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_r_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_L(fetchdat & 7);
@@ -148,7 +148,7 @@ ropMOV_r_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
 }
 
 static uint32_t
-ropMOV_b_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_b_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         STORE_IMM_REG_B(fetchdat & 7, (fetchdat >> 8) & 0xff);
@@ -167,7 +167,7 @@ ropMOV_b_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 2;
 }
 static uint32_t
-ropMOV_w_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_w_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         STORE_IMM_REG_W(fetchdat & 7, (fetchdat >> 8) & 0xffff);
@@ -186,7 +186,7 @@ ropMOV_w_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 3;
 }
 static uint32_t
-ropMOV_l_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_l_imm(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         uint32_t imm = fastreadl(cs + op_pc + 1);
@@ -208,7 +208,7 @@ ropMOV_l_imm(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOV_AL_a(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_AL_a(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t addr;
 
@@ -226,7 +226,7 @@ ropMOV_AL_a(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 static uint32_t
-ropMOV_AX_a(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_AX_a(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t addr;
 
@@ -244,7 +244,7 @@ ropMOV_AX_a(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 static uint32_t
-ropMOV_EAX_a(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_EAX_a(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t addr;
 
@@ -263,7 +263,7 @@ ropMOV_EAX_a(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOV_a_AL(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_a_AL(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t addr;
     int      host_reg;
@@ -284,7 +284,7 @@ ropMOV_a_AL(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 static uint32_t
-ropMOV_a_AX(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_a_AX(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t addr;
     int      host_reg;
@@ -305,7 +305,7 @@ ropMOV_a_AX(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 static uint32_t
-ropMOV_a_EAX(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_a_EAX(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t addr;
     int      host_reg;
@@ -327,7 +327,7 @@ ropMOV_a_EAX(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropLEA_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropLEA_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int dest_reg = (fetchdat >> 3) & 7;
 
@@ -341,7 +341,7 @@ ropLEA_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
     return op_pc + 1;
 }
 static uint32_t
-ropLEA_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropLEA_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int dest_reg = (fetchdat >> 3) & 7;
 
@@ -356,7 +356,7 @@ ropLEA_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, code
 }
 
 static uint32_t
-ropMOVZX_w_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVZX_w_b(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_B(fetchdat & 7);
@@ -377,7 +377,7 @@ ropMOVZX_w_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropMOVZX_l_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVZX_l_b(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_B(fetchdat & 7);
@@ -398,7 +398,7 @@ ropMOVZX_l_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropMOVZX_l_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVZX_l_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_W(fetchdat & 7);
@@ -420,7 +420,7 @@ ropMOVZX_l_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOVSX_w_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVSX_w_b(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_B(fetchdat & 7);
@@ -441,7 +441,7 @@ ropMOVSX_w_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropMOVSX_l_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVSX_l_b(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_B(fetchdat & 7);
@@ -462,7 +462,7 @@ ropMOVSX_l_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropMOVSX_l_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOVSX_l_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     if ((fetchdat & 0xc0) == 0xc0) {
         int host_reg = LOAD_REG_W(fetchdat & 7);
@@ -484,7 +484,7 @@ ropMOVSX_l_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropMOV_w_seg(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_w_seg(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -531,7 +531,7 @@ ropMOV_w_seg(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return op_pc + 1;
 }
 static uint32_t
-ropMOV_seg_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropMOV_seg_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -578,7 +578,7 @@ ropMOV_seg_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 #define ropLseg(seg, rseg)                                                                                           \
-    static uint32_t ropL##seg(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
+    static uint32_t ropL##seg(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block)) \
     {                                                                                                                \
         int     dest_reg = (fetchdat >> 3) & 7;                                                                      \
         x86seg *target_seg;                                                                                          \

src/codegen/codegen_ops_shift.h

@@ -43,7 +43,7 @@
     }
 
 static uint32_t
-ropC0(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropC0(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     count;
@@ -57,7 +57,7 @@ ropC0(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblo
     return op_pc + 2;
 }
 static uint32_t
-ropC1_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropC1_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     count;
@@ -71,7 +71,7 @@ ropC1_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc + 2;
 }
 static uint32_t
-ropC1_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropC1_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     count;
@@ -86,7 +86,7 @@ ropC1_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
 }
 
 static uint32_t
-ropD0(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropD0(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     count      = 1;
@@ -100,7 +100,7 @@ ropD0(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblo
     return op_pc + 1;
 }
 static uint32_t
-ropD1_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropD1_w(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     count      = 1;
@@ -114,7 +114,7 @@ ropD1_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeb
     return op_pc + 1;
 }
 static uint32_t
-ropD1_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropD1_l(UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     x86seg *target_seg = NULL;
     int     count      = 1;

src/codegen/codegen_ops_stack.h

@@ -1,5 +1,5 @@
 static uint32_t
-ropPUSH_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPUSH_16(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -12,7 +12,7 @@ ropPUSH_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
     return op_pc;
 }
 static uint32_t
-ropPUSH_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPUSH_32(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -26,7 +26,7 @@ ropPUSH_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, co
 }
 
 static uint32_t
-ropPUSH_imm_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPUSH_imm_16(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint16_t imm = fetchdat & 0xffff;
     int      host_reg;
@@ -40,7 +40,7 @@ ropPUSH_imm_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
     return op_pc + 2;
 }
 static uint32_t
-ropPUSH_imm_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPUSH_imm_32(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t imm = fastreadl(cs + op_pc);
     int      host_reg;
@@ -55,7 +55,7 @@ ropPUSH_imm_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc
 }
 
 static uint32_t
-ropPUSH_imm_b16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPUSH_imm_b16(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint16_t imm = fetchdat & 0xff;
     int      host_reg;
@@ -72,7 +72,7 @@ ropPUSH_imm_b16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_p
     return op_pc + 1;
 }
 static uint32_t
-ropPUSH_imm_b32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPUSH_imm_b32(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t imm = fetchdat & 0xff;
     int      host_reg;
@@ -90,7 +90,7 @@ ropPUSH_imm_b32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_p
 }
 
 static uint32_t
-ropPOP_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPOP_16(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);
     LOAD_STACK_TO_EA(0);
@@ -101,7 +101,7 @@ ropPOP_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc;
 }
 static uint32_t
-ropPOP_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropPOP_32(uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);
     LOAD_STACK_TO_EA(0);
@@ -113,7 +113,7 @@ ropPOP_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropRET_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropRET_16(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc), UNUSED(codeblock_t *block))
 {
     STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);
     LOAD_STACK_TO_EA(0);
@@ -124,7 +124,7 @@ ropRET_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return -1;
 }
 static uint32_t
-ropRET_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropRET_32(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc), UNUSED(codeblock_t *block))
 {
     STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);
     LOAD_STACK_TO_EA(0);
@@ -136,7 +136,7 @@ ropRET_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
 }
 
 static uint32_t
-ropRET_imm_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropRET_imm_16(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc), UNUSED(codeblock_t *block))
 {
     uint16_t offset = fetchdat & 0xffff;
 
@@ -149,7 +149,7 @@ ropRET_imm_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
     return -1;
 }
 static uint32_t
-ropRET_imm_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropRET_imm_32(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc), UNUSED(codeblock_t *block))
 {
     uint16_t offset = fetchdat & 0xffff;
 
@@ -163,7 +163,7 @@ ropRET_imm_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc,
 }
 
 static uint32_t
-ropCALL_r16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCALL_r16(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint16_t offset = fetchdat & 0xffff;
     int      host_reg;
@@ -178,7 +178,7 @@ ropCALL_r16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return -1;
 }
 static uint32_t
-ropCALL_r32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropCALL_r32(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     uint32_t offset = fastreadl(cs + op_pc);
     int      host_reg;
@@ -194,7 +194,7 @@ ropCALL_r32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
 }
 
 static uint32_t
-ropLEAVE_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropLEAVE_16(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -209,7 +209,7 @@ ropLEAVE_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc;
 }
 static uint32_t
-ropLEAVE_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropLEAVE_32(UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int host_reg;
 
@@ -224,32 +224,40 @@ ropLEAVE_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, c
     return op_pc;
 }
 
-#define ROP_PUSH_SEG(seg)                                                                                     \
-    static uint32_t                                                                                           \
-    ropPUSH_##seg##_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                         \
-        int host_reg;                                                                                         \
-                                                                                                              \
-        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                                            \
-        LOAD_STACK_TO_EA(-2);                                                                                 \
-        host_reg = LOAD_VAR_W((uintptr_t) &seg);                                                              \
-        MEM_STORE_ADDR_EA_W(&cpu_state.seg_ss, host_reg);                                                     \
-        SP_MODIFY(-2);                                                                                        \
-                                                                                                              \
-        return op_pc;                                                                                         \
-    }                                                                                                         \
-    static uint32_t                                                                                           \
-    ropPUSH_##seg##_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                         \
-        int host_reg;                                                                                         \
-                                                                                                              \
-        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                                            \
-        LOAD_STACK_TO_EA(-4);                                                                                 \
-        host_reg = LOAD_VAR_W((uintptr_t) &seg);                                                              \
-        MEM_STORE_ADDR_EA_L(&cpu_state.seg_ss, host_reg);                                                     \
-        SP_MODIFY(-4);                                                                                        \
-                                                                                                              \
-        return op_pc;                                                                                         \
+#define ROP_PUSH_SEG(seg)                                          \
+    static uint32_t                                                \
+    ropPUSH_##seg##_16(UNUSED(uint8_t opcode),                     \
+                       UNUSED(uint32_t fetchdat),                  \
+                       UNUSED(uint32_t op_32),                     \
+                       uint32_t op_pc,                             \
+                       UNUSED(codeblock_t *block))                 \
+    {                                                              \
+        int host_reg;                                              \
+                                                                   \
+        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc); \
+        LOAD_STACK_TO_EA(-2);                                      \
+        host_reg = LOAD_VAR_W((uintptr_t) &seg);                   \
+        MEM_STORE_ADDR_EA_W(&cpu_state.seg_ss, host_reg);          \
+        SP_MODIFY(-2);                                             \
+                                                                   \
+        return op_pc;                                              \
+    }                                                              \
+    static uint32_t                                                \
+    ropPUSH_##seg##_32(UNUSED(uint8_t opcode),                     \
+                       UNUSED(uint32_t fetchdat),                  \
+                       UNUSED(uint32_t op_32),                     \
+                       uint32_t op_pc,                             \
+                       UNUSED(codeblock_t *block))                 \
+    {                                                              \
+        int host_reg;                                              \
+                                                                   \
+        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc); \
+        LOAD_STACK_TO_EA(-4);                                      \
+        host_reg = LOAD_VAR_W((uintptr_t) &seg);                   \
+        MEM_STORE_ADDR_EA_L(&cpu_state.seg_ss, host_reg);          \
+        SP_MODIFY(-4);                                             \
+                                                                   \
+        return op_pc;                                              \
     }
 
 ROP_PUSH_SEG(CS)
@@ -259,28 +267,36 @@ ROP_PUSH_SEG(FS)
 ROP_PUSH_SEG(GS)
 ROP_PUSH_SEG(SS)
 
-#define ROP_POP_SEG(seg, rseg)                                                                               \
-    static uint32_t                                                                                          \
-    ropPOP_##seg##_16(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                        \
-        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                                           \
-        LOAD_STACK_TO_EA(0);                                                                                 \
-        MEM_LOAD_ADDR_EA_W(&cpu_state.seg_ss);                                                               \
-        LOAD_SEG(0, &rseg);                                                                                  \
-        SP_MODIFY(2);                                                                                        \
-                                                                                                             \
-        return op_pc;                                                                                        \
-    }                                                                                                        \
-    static uint32_t                                                                                          \
-    ropPOP_##seg##_32(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                        \
-        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc);                                           \
-        LOAD_STACK_TO_EA(0);                                                                                 \
-        MEM_LOAD_ADDR_EA_W(&cpu_state.seg_ss);                                                               \
-        LOAD_SEG(0, &rseg);                                                                                  \
-        SP_MODIFY(4);                                                                                        \
-                                                                                                             \
-        return op_pc;                                                                                        \
+#define ROP_POP_SEG(seg, rseg)                                     \
+    static uint32_t                                                \
+    ropPOP_##seg##_16(UNUSED(uint8_t opcode),                      \
+                      UNUSED(uint32_t fetchdat),                   \
+                      UNUSED(uint32_t op_32),                      \
+                      uint32_t op_pc,                              \
+                      UNUSED(codeblock_t *block))                  \
+    {                                                              \
+        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc); \
+        LOAD_STACK_TO_EA(0);                                       \
+        MEM_LOAD_ADDR_EA_W(&cpu_state.seg_ss);                     \
+        LOAD_SEG(0, &rseg);                                        \
+        SP_MODIFY(2);                                              \
+                                                                   \
+        return op_pc;                                              \
+    }                                                              \
+    static uint32_t                                                \
+    ropPOP_##seg##_32(UNUSED(uint8_t opcode),                      \
+                      UNUSED(uint32_t fetchdat),                   \
+                      UNUSED(uint32_t op_32),                      \
+                      uint32_t op_pc,                              \
+                      UNUSED(codeblock_t *block))                  \
+    {                                                              \
+        STORE_IMM_ADDR_L((uintptr_t) &cpu_state.oldpc, op_old_pc); \
+        LOAD_STACK_TO_EA(0);                                       \
+        MEM_LOAD_ADDR_EA_W(&cpu_state.seg_ss);                     \
+        LOAD_SEG(0, &rseg);                                        \
+        SP_MODIFY(4);                                              \
+                                                                   \
+        return op_pc;                                              \
     }
 
 ROP_POP_SEG(DS, cpu_state.seg_ds)

src/codegen/codegen_ops_x86-64.h

@@ -55,7 +55,7 @@ call_long(uintptr_t func)
 }
 
 static __inline void
-load_param_1_32(codeblock_t *block, uint32_t param)
+load_param_1_32(UNUSED(codeblock_t *block), uint32_t param)
 {
 #if _WIN64
     addbyte(0xb9); /*MOVL $fetchdat,%ecx*/
@@ -93,7 +93,7 @@ static __inline void load_param_1_64(codeblock_t *block, uint64_t param)
 #endif
 
 static __inline void
-load_param_2_32(codeblock_t *block, uint32_t param)
+load_param_2_32(UNUSED(codeblock_t *block), uint32_t param)
 {
 #if _WIN64
     addbyte(0xba); /*MOVL $fetchdat,%edx*/
@@ -118,7 +118,7 @@ load_param_2_reg_32(int reg)
 #endif
 }
 static __inline void
-load_param_2_64(codeblock_t *block, uint64_t param)
+load_param_2_64(UNUSED(codeblock_t *block), uint64_t param)
 {
     addbyte(0x48);
 #if _WIN64
@@ -1492,7 +1492,7 @@ MEM_STORE_ADDR_EA_L(x86seg *seg, int host_reg)
     /*done:*/
 }
 static __inline void
-MEM_STORE_ADDR_EA_Q(x86seg *seg, int host_reg, int host_reg2)
+MEM_STORE_ADDR_EA_Q(x86seg *seg, int host_reg, UNUSED(int host_reg2))
 {
     if ((seg == &cpu_state.seg_ds && codegen_flat_ds && !(cpu_cur_status & CPU_STATUS_NOTFLATDS)) || (seg == &cpu_state.seg_ss && codegen_flat_ss && !(cpu_cur_status & CPU_STATUS_NOTFLATSS))) {
         addbyte(0x31); /*XOR ECX, ECX*/
@@ -3926,7 +3926,7 @@ FP_LOAD_REG(int reg)
     return REG_EBX;
 }
 static __inline void
-FP_LOAD_REG_D(int reg, int *host_reg1, int *host_reg2)
+FP_LOAD_REG_D(int reg, int *host_reg1, UNUSED(int *host_reg2))
 {
     addbyte(0x8b); /*MOV EBX, TOP*/
     addbyte(0x5d);
@@ -4086,7 +4086,7 @@ FP_LOAD_REG_INT(int reg)
     return REG_EBX;
 }
 static __inline void
-FP_LOAD_REG_INT_Q(int reg, int *host_reg1, int *host_reg2)
+FP_LOAD_REG_INT_Q(int reg, int *host_reg1, UNUSED(int *host_reg2))
 {
     addbyte(0x89); /*MOV EBX, EAX*/
     addbyte(0xc3);
@@ -4693,7 +4693,7 @@ LOAD_MMX_D(int guest_reg)
     return host_reg;
 }
 static __inline void
-LOAD_MMX_Q(int guest_reg, int *host_reg1, int *host_reg2)
+LOAD_MMX_Q(int guest_reg, int *host_reg1, UNUSED(int *host_reg2))
 {
     int host_reg = REG_EBX;
 
@@ -4725,7 +4725,7 @@ LOAD_MMX_Q_MMX(int guest_reg)
 }
 
 static __inline int
-LOAD_INT_TO_MMX(int src_reg1, int src_reg2)
+LOAD_INT_TO_MMX(int src_reg1, UNUSED(int src_reg2))
 {
     int dst_reg                   = find_host_xmm_reg();
     host_reg_xmm_mapping[dst_reg] = 100;
@@ -4758,7 +4758,7 @@ STORE_MMX_LQ(int guest_reg, int host_reg1)
     addbyte((uint8_t) cpu_state_offset(MM[guest_reg].l[0]));
 }
 static __inline void
-STORE_MMX_Q(int guest_reg, int host_reg1, int host_reg2)
+STORE_MMX_Q(int guest_reg, int host_reg1, UNUSED(int host_reg2))
 {
     if (host_reg1 & 8)
         addbyte(0x4c);

src/codegen/codegen_ops_xchg.h

@@ -1,16 +1,20 @@
-#define OP_XCHG_AX_(reg)                                                                                    \
-    static uint32_t                                                                                         \
-    ropXCHG_AX_##reg(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                       \
-        int ax_reg, host_reg, temp_reg;                                                                     \
-                                                                                                            \
-        ax_reg   = LOAD_REG_W(REG_AX);                                                                      \
-        host_reg = LOAD_REG_W(REG_##reg);                                                                   \
-        temp_reg = COPY_REG(host_reg);                                                                      \
-        STORE_REG_TARGET_W_RELEASE(ax_reg, REG_##reg);                                                      \
-        STORE_REG_TARGET_W_RELEASE(temp_reg, REG_AX);                                                       \
-                                                                                                            \
-        return op_pc;                                                                                       \
+#define OP_XCHG_AX_(reg)                               \
+    static uint32_t                                    \
+    ropXCHG_AX_##reg(UNUSED(uint8_t opcode),           \
+                     UNUSED(uint32_t fetchdat),        \
+                     UNUSED(uint32_t op_32),           \
+                     uint32_t op_pc,                   \
+                     UNUSED(codeblock_t *block))       \
+    {                                                  \
+        int ax_reg, host_reg, temp_reg;                \
+                                                       \
+        ax_reg   = LOAD_REG_W(REG_AX);                 \
+        host_reg = LOAD_REG_W(REG_##reg);              \
+        temp_reg = COPY_REG(host_reg);                 \
+        STORE_REG_TARGET_W_RELEASE(ax_reg, REG_##reg); \
+        STORE_REG_TARGET_W_RELEASE(temp_reg, REG_AX);  \
+                                                       \
+        return op_pc;                                  \
     }
 
 OP_XCHG_AX_(BX)
@@ -21,19 +25,23 @@ OP_XCHG_AX_(DI)
 OP_XCHG_AX_(SP)
 OP_XCHG_AX_(BP)
 
-#define OP_XCHG_EAX_(reg)                                                                                    \
-    static uint32_t                                                                                          \
-    ropXCHG_EAX_##reg(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) \
-    {                                                                                                        \
-        int eax_reg, host_reg, temp_reg;                                                                     \
-                                                                                                             \
-        eax_reg  = LOAD_REG_L(REG_EAX);                                                                      \
-        host_reg = LOAD_REG_L(REG_##reg);                                                                    \
-        temp_reg = COPY_REG(host_reg);                                                                       \
-        STORE_REG_TARGET_L_RELEASE(eax_reg, REG_##reg);                                                      \
-        STORE_REG_TARGET_L_RELEASE(temp_reg, REG_EAX);                                                       \
-                                                                                                             \
-        return op_pc;                                                                                        \
+#define OP_XCHG_EAX_(reg)                               \
+    static uint32_t                                     \
+    ropXCHG_EAX_##reg(UNUSED(uint8_t opcode),           \
+                      UNUSED(uint32_t fetchdat),        \
+                      UNUSED(uint32_t op_32),           \
+                      uint32_t op_pc,                   \
+                      UNUSED(codeblock_t *block))       \
+    {                                                   \
+        int eax_reg, host_reg, temp_reg;                \
+                                                        \
+        eax_reg  = LOAD_REG_L(REG_EAX);                 \
+        host_reg = LOAD_REG_L(REG_##reg);               \
+        temp_reg = COPY_REG(host_reg);                  \
+        STORE_REG_TARGET_L_RELEASE(eax_reg, REG_##reg); \
+        STORE_REG_TARGET_L_RELEASE(temp_reg, REG_EAX);  \
+                                                        \
+        return op_pc;                                   \
     }
 
 OP_XCHG_EAX_(EBX)
@@ -45,7 +53,7 @@ OP_XCHG_EAX_(ESP)
 OP_XCHG_EAX_(EBP)
 
 static uint32_t
-ropXCHG_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropXCHG_b(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -63,7 +71,7 @@ ropXCHG_b(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc + 1;
 }
 static uint32_t
-ropXCHG_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropXCHG_w(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;
@@ -81,7 +89,7 @@ ropXCHG_w(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, cod
     return op_pc + 1;
 }
 static uint32_t
-ropXCHG_l(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block)
+ropXCHG_l(UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc, UNUSED(codeblock_t *block))
 {
     int src_reg;
     int dst_reg;

src/codegen/codegen_x86-64.c

@@ -125,7 +125,7 @@ add_to_block_list(codeblock_t *block)
 }
 
 static void
-remove_from_block_list(codeblock_t *block, uint32_t pc)
+remove_from_block_list(codeblock_t *block, UNUSED(uint32_t pc))
 {
     if (!block->page_mask)
         return;

src/codegen_new/codegen_ir.c

@@ -2,6 +2,7 @@
 #include <86box/86box.h>
 #include "cpu.h"
 #include <86box/mem.h>
+#include <86box/plat_unused.h>
 
 #include "codegen.h"
 #include "codegen_allocator.h"

src/codegen_new/codegen_ir_defs.h

@@ -410,7 +410,7 @@ uop_gen_reg_src1(uint32_t uop_type, ir_data_t *ir, int src_reg_a)
 }
 
 static inline void
-uop_gen_reg_src1_arg(uint32_t uop_type, ir_data_t *ir, int arg, int src_reg_a)
+uop_gen_reg_src1_arg(uint32_t uop_type, ir_data_t *ir, UNUSED(int arg), int src_reg_a)
 {
     uop_t *uop = uop_alloc(ir, uop_type);
 

src/codegen_new/codegen_ops.c

@@ -2,6 +2,7 @@
 #include <86box/86box.h>
 #include "cpu.h"
 #include <86box/mem.h>
+#include <86box/plat_unused.h>
 
 #include "codegen.h"
 #include "codegen_ir.h"

src/codegen_new/codegen_ops_3dnow.c

@@ -17,7 +17,7 @@
 #include "codegen_ops_helpers.h"
 
 #define ropParith(func)                                                                                                      \
-    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                        \
         int dest_reg = (fetchdat >> 3) & 7;                                                                                  \
                                                                                                                              \
@@ -192,7 +192,7 @@ ropPFRSQRT(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
 }
 
 uint32_t
-ropPFRSQIT1(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPFRSQIT1(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MMX_ENTER(ir);
 

src/codegen_new/codegen_ops_arith.c

@@ -22,7 +22,7 @@ get_cf(ir_data_t *ir, int dest_reg)
 }
 
 uint32_t
-ropADC_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropADC_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -39,7 +39,7 @@ ropADC_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropADC_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropADC_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -274,7 +274,7 @@ ropADC_l_rmw(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropADD_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropADD_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -289,7 +289,7 @@ ropADD_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropADD_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropADD_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -511,7 +511,7 @@ ropADD_l_rmw(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropCMP_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCMP_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -526,7 +526,7 @@ ropCMP_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropCMP_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCMP_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -734,7 +734,7 @@ ropCMP_l_rmw(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropSBB_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSBB_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -751,7 +751,7 @@ ropSBB_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropSBB_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSBB_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -988,7 +988,7 @@ ropSBB_l_rmw(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropSUB_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSUB_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -1003,7 +1003,7 @@ ropSUB_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropSUB_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSUB_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -2293,7 +2293,7 @@ rebuild_c(ir_data_t *ir)
 }
 
 uint32_t
-ropINC_r16(UNUSED(UNUSED(codeblock_t *block)), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropINC_r16(UNUSED(UNUSED(codeblock_t *block)), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     rebuild_c(ir);
 
@@ -2307,7 +2307,7 @@ ropINC_r16(UNUSED(UNUSED(codeblock_t *block)), ir_data_t *ir, UNUSED(uint8_t opc
     return op_pc;
 }
 uint32_t
-ropINC_r32(UNUSED(UNUSED(codeblock_t *block)), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropINC_r32(UNUSED(UNUSED(codeblock_t *block)), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     rebuild_c(ir);
 
@@ -2322,7 +2322,7 @@ ropINC_r32(UNUSED(UNUSED(codeblock_t *block)), ir_data_t *ir, UNUSED(uint8_t opc
 }
 
 uint32_t
-ropDEC_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropDEC_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     rebuild_c(ir);
 
@@ -2336,7 +2336,7 @@ ropDEC_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t f
     return op_pc;
 }
 uint32_t
-ropDEC_r32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropDEC_r32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     rebuild_c(ir);
 

src/codegen_new/codegen_ops_branch.c

@@ -816,7 +816,7 @@ ropJNLE_common(codeblock_t *block, ir_data_t *ir, uint32_t dest_addr, uint32_t n
 }
 
 #define ropJ(cond)                                                                                                                 \
-    uint32_t ropJ##cond##_8(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropJ##cond##_8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         uint32_t offset    = (int32_t) (int8_t) fastreadb(cs + op_pc);                                                             \
         uint32_t dest_addr = op_pc + 1 + offset;                                                                                   \
@@ -829,7 +829,7 @@ ropJNLE_common(codeblock_t *block, ir_data_t *ir, uint32_t dest_addr, uint32_t n
         codegen_mark_code_present(block, cs + op_pc, 1);                                                                           \
         return ret ? dest_addr : (op_pc + 1);                                                                                      \
     }                                                                                                                              \
-    uint32_t ropJ##cond##_16(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropJ##cond##_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc) \
     {                                                                                                                              \
         uint32_t offset    = (int32_t) (int16_t) fastreadw(cs + op_pc);                                                            \
         uint32_t dest_addr = (op_pc + 2 + offset) & 0xffff;                                                                        \
@@ -840,7 +840,7 @@ ropJNLE_common(codeblock_t *block, ir_data_t *ir, uint32_t dest_addr, uint32_t n
         codegen_mark_code_present(block, cs + op_pc, 2);                                                                           \
         return ret ? dest_addr : (op_pc + 2);                                                                                      \
     }                                                                                                                              \
-    uint32_t ropJ##cond##_32(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropJ##cond##_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc) \
     {                                                                                                                              \
         uint32_t offset    = fastreadl(cs + op_pc);                                                                                \
         uint32_t dest_addr = op_pc + 4 + offset;                                                                                   \
@@ -852,6 +852,7 @@ ropJNLE_common(codeblock_t *block, ir_data_t *ir, uint32_t dest_addr, uint32_t n
         return ret ? dest_addr : (op_pc + 4);                                                                                      \
     }
 
+// clang-format off
 ropJ(O)
 ropJ(NO)
 ropJ(B)
@@ -868,9 +869,10 @@ ropJ(L)
 ropJ(NL)
 ropJ(LE)
 ropJ(NLE)
+// clang-format on
 
 uint32_t
-ropJCXZ(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropJCXZ(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int8_t) fastreadb(cs + op_pc);
     uint32_t dest_addr = op_pc + 1 + offset;
@@ -892,7 +894,7 @@ ropJCXZ(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetc
 }
 
 uint32_t
-ropLOOP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropLOOP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int8_t) fastreadb(cs + op_pc);
     uint32_t dest_addr = op_pc + 1 + offset;
@@ -932,7 +934,7 @@ ropLOOP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetc
 }
 
 uint32_t
-ropLOOPE(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropLOOPE(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int8_t) fastreadb(cs + op_pc);
     uint32_t dest_addr = op_pc + 1 + offset;
@@ -965,7 +967,7 @@ ropLOOPE(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
     return op_pc + 1;
 }
 uint32_t
-ropLOOPNE(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropLOOPNE(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int8_t) fastreadb(cs + op_pc);
     uint32_t dest_addr = op_pc + 1 + offset;

src/codegen_new/codegen_ops_fpu_arith.c

@@ -79,7 +79,7 @@ ropFCOMP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
     return op_pc;
 }
 uint32_t
-ropFCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_FCOM(ir, IREG_temp0_W, IREG_ST(0), IREG_ST(1));
@@ -289,7 +289,7 @@ ropFUCOMP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fe
     return op_pc;
 }
 uint32_t
-ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_FCOM(ir, IREG_temp0_W, IREG_ST(0), IREG_ST(1));
@@ -301,7 +301,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
 }
 
 #define ropF_arith_mem(name, load_uop)                                                                                            \
-    uint32_t ropFADD##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFADD##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -318,7 +318,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFCOM##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFCOM##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -329,12 +329,12 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
         codegen_check_seg_read(block, ir, target_seg);                                                                            \
         load_uop(ir, IREG_temp0_D, ireg_seg_base(target_seg), IREG_eaaddr);                                                       \
         uop_FCOM(ir, IREG_temp1_W, IREG_ST(0), IREG_temp0_D);                                                                     \
-        uop_AND_IMM(ir, IREG_NPXS, IREG_NPXS, ~(FPU_SW_C0 | FPU_SW_C2 | FPU_SW_C3));                                                                   \
+        uop_AND_IMM(ir, IREG_NPXS, IREG_NPXS, ~(FPU_SW_C0 | FPU_SW_C2 | FPU_SW_C3));                                              \
         uop_OR(ir, IREG_NPXS, IREG_NPXS, IREG_temp1_W);                                                                           \
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFCOMP##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropFCOMP##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -351,7 +351,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFDIV##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFDIV##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -366,7 +366,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFDIVR##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropFDIVR##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -381,7 +381,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFMUL##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFMUL##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -396,7 +396,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFSUB##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFSUB##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -411,7 +411,7 @@ ropFUCOMPP(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t ropFSUBR##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropFSUBR##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg;                                                                                                       \
                                                                                                                                   \
@@ -433,7 +433,7 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
 // clang-format on
 
 #define ropFI_arith_mem(name, temp_reg)                                                                                            \
-    uint32_t ropFIADD##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFIADD##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -449,7 +449,7 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFICOM##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFICOM##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -461,12 +461,12 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
         uop_MEM_LOAD_REG(ir, temp_reg, ireg_seg_base(target_seg), IREG_eaaddr);                                                    \
         uop_MOV_DOUBLE_INT(ir, IREG_temp0_D, temp_reg);                                                                            \
         uop_FCOM(ir, IREG_temp1_W, IREG_ST(0), IREG_temp0_D);                                                                      \
-        uop_AND_IMM(ir, IREG_NPXS, IREG_NPXS, ~(FPU_SW_C0 | FPU_SW_C2 | FPU_SW_C3));                                                                    \
+        uop_AND_IMM(ir, IREG_NPXS, IREG_NPXS, ~(FPU_SW_C0 | FPU_SW_C2 | FPU_SW_C3));                                               \
         uop_OR(ir, IREG_NPXS, IREG_NPXS, IREG_temp1_W);                                                                            \
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFICOMP##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropFICOMP##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -478,13 +478,13 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
         uop_MEM_LOAD_REG(ir, temp_reg, ireg_seg_base(target_seg), IREG_eaaddr);                                                    \
         uop_MOV_DOUBLE_INT(ir, IREG_temp0_D, temp_reg);                                                                            \
         uop_FCOM(ir, IREG_temp1_W, IREG_ST(0), IREG_temp0_D);                                                                      \
-        uop_AND_IMM(ir, IREG_NPXS, IREG_NPXS, ~(FPU_SW_C0 | FPU_SW_C2 | FPU_SW_C3));                                                                    \
+        uop_AND_IMM(ir, IREG_NPXS, IREG_NPXS, ~(FPU_SW_C0 | FPU_SW_C2 | FPU_SW_C3));                                               \
         uop_OR(ir, IREG_NPXS, IREG_NPXS, IREG_temp1_W);                                                                            \
         fpu_POP(block, ir);                                                                                                        \
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFIDIV##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFIDIV##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -500,7 +500,7 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFIDIVR##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropFIDIVR##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -516,7 +516,7 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFIMUL##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFIMUL##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -532,7 +532,7 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFISUB##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)  \
+    uint32_t ropFISUB##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -548,7 +548,7 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
                                                                                                                                    \
         return op_pc + 1;                                                                                                          \
     }                                                                                                                              \
-    uint32_t ropFISUBR##name(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropFISUBR##name(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                              \
         x86seg *target_seg;                                                                                                        \
                                                                                                                                    \
@@ -565,11 +565,13 @@ ropF_arith_mem(d, uop_MEM_LOAD_DOUBLE)
         return op_pc + 1;                                                                                                          \
     }
 
+// clang-format off
 ropFI_arith_mem(l, IREG_temp0)
 ropFI_arith_mem(w, IREG_temp0_W)
+// clang-format on
 
 uint32_t
-ropFABS(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFABS(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_FABS(ir, IREG_ST(0), IREG_ST(0));
@@ -579,7 +581,7 @@ ropFABS(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint3
 }
 
 uint32_t
-ropFCHS(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFCHS(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_FCHS(ir, IREG_ST(0), IREG_ST(0));
@@ -588,7 +590,7 @@ ropFCHS(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint3
     return op_pc;
 }
 uint32_t
-ropFSQRT(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFSQRT(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_FSQRT(ir, IREG_ST(0), IREG_ST(0));
@@ -597,7 +599,7 @@ ropFSQRT(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint
     return op_pc;
 }
 uint32_t
-ropFTST(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFTST(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_FTST(ir, IREG_temp0_W, IREG_ST(0));

src/codegen_new/codegen_ops_fpu_constant.c

@@ -19,7 +19,7 @@
 #include "codegen_ops_helpers.h"
 
 uint32_t
-ropFLD1(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFLD1(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_MOV_IMM(ir, IREG_temp0, 1);
@@ -30,7 +30,7 @@ ropFLD1(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetc
     return op_pc;
 }
 uint32_t
-ropFLDZ(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFLDZ(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_MOV_IMM(ir, IREG_temp0, 0);

src/codegen_new/codegen_ops_fpu_misc.c

@@ -98,7 +98,7 @@ ropFSTSW(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
     return op_pc + 1;
 }
 uint32_t
-ropFSTSW_AX(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropFSTSW_AX(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_FP_ENTER(ir);
     uop_MOV(ir, IREG_AX, IREG_NPXS);

src/codegen_new/codegen_ops_helpers.h

@@ -71,7 +71,7 @@ fpu_PUSH(codeblock_t *block, ir_data_t *ir)
 }
 
 static inline void
-CHECK_SEG_LIMITS(codeblock_t *block, ir_data_t *ir, x86seg *seg, int addr_reg, int end_offset)
+CHECK_SEG_LIMITS(UNUSED(codeblock_t *block), ir_data_t *ir, x86seg *seg, int addr_reg, int end_offset)
 {
     if ((seg == &cpu_state.seg_ds && codegen_flat_ds && !(cpu_cur_status & CPU_STATUS_NOTFLATDS)) || (seg == &cpu_state.seg_ss && codegen_flat_ss && !(cpu_cur_status & CPU_STATUS_NOTFLATSS)))
         return;
@@ -85,7 +85,7 @@ CHECK_SEG_LIMITS(codeblock_t *block, ir_data_t *ir, x86seg *seg, int addr_reg, i
 }
 
 static inline void
-LOAD_IMMEDIATE_FROM_RAM_8(codeblock_t *block, ir_data_t *ir, int dest_reg, uint32_t addr)
+LOAD_IMMEDIATE_FROM_RAM_8(UNUSED(codeblock_t *block), ir_data_t *ir, int dest_reg, uint32_t addr)
 {
     uop_MOVZX_REG_PTR_8(ir, dest_reg, get_ram_ptr(addr));
 }

src/codegen_new/codegen_ops_jump.c

@@ -15,7 +15,7 @@
 #include "codegen_ops_mov.h"
 
 uint32_t
-ropJMP_r8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropJMP_r8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int8_t) fastreadb(cs + op_pc);
     uint32_t dest_addr = op_pc + 1 + offset;
@@ -29,7 +29,7 @@ ropJMP_r8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fe
     return dest_addr;
 }
 uint32_t
-ropJMP_r16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropJMP_r16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int16_t) fastreadw(cs + op_pc);
     uint32_t dest_addr = op_pc + 2 + offset;
@@ -42,7 +42,7 @@ ropJMP_r16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
     return dest_addr;
 }
 uint32_t
-ropJMP_r32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropJMP_r32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t offset    = fastreadl(cs + op_pc);
     uint32_t dest_addr = op_pc + 4 + offset;
@@ -54,7 +54,7 @@ ropJMP_r32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
 }
 
 uint32_t
-ropJMP_far_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropJMP_far_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t new_pc = fastreadw(cs + op_pc);
     uint16_t new_cs = fastreadw(cs + op_pc + 2);
@@ -69,7 +69,7 @@ ropJMP_far_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return -1;
 }
 uint32_t
-ropJMP_far_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropJMP_far_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t new_pc = fastreadl(cs + op_pc);
     uint16_t new_cs = fastreadw(cs + op_pc + 4);
@@ -85,7 +85,7 @@ ropJMP_far_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
 }
 
 uint32_t
-ropCALL_r16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCALL_r16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t offset    = (int32_t) (int16_t) fastreadw(cs + op_pc);
     uint16_t ret_addr  = op_pc + 2;
@@ -104,7 +104,7 @@ ropCALL_r16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
     return -1;
 }
 uint32_t
-ropCALL_r32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCALL_r32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t offset    = fastreadl(cs + op_pc);
     uint32_t ret_addr  = op_pc + 4;
@@ -122,7 +122,7 @@ ropCALL_r32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropRET_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
+ropRET_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 
@@ -138,7 +138,7 @@ ropRET_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uin
     return -1;
 }
 uint32_t
-ropRET_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
+ropRET_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 
@@ -154,7 +154,7 @@ ropRET_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uin
 }
 
 uint32_t
-ropRET_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropRET_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t offset = fastreadw(cs + op_pc);
 
@@ -173,7 +173,7 @@ ropRET_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return -1;
 }
 uint32_t
-ropRET_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropRET_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t offset = fastreadw(cs + op_pc);
 
@@ -192,7 +192,7 @@ ropRET_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
 }
 
 uint32_t
-ropRETF_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
+ropRETF_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
 {
     if ((msw & 1) && !(cpu_state.eflags & VM_FLAG))
         return 0;
@@ -215,7 +215,7 @@ ropRETF_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), ui
     return -1;
 }
 uint32_t
-ropRETF_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
+ropRETF_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), UNUSED(uint32_t op_pc))
 {
     if ((msw & 1) && !(cpu_state.eflags & VM_FLAG))
         return 0;
@@ -239,7 +239,7 @@ ropRETF_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), ui
 }
 
 uint32_t
-ropRETF_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropRETF_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t offset;
 
@@ -266,7 +266,7 @@ ropRETF_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32
     return -1;
 }
 uint32_t
-ropRETF_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropRETF_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t offset;
 

src/codegen_new/codegen_ops_logic.c

@@ -16,7 +16,7 @@
 #include "codegen_ops_logic.h"
 
 uint32_t
-ropAND_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropAND_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -29,7 +29,7 @@ ropAND_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropAND_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropAND_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -226,7 +226,7 @@ ropAND_l_rmw(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropOR_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropOR_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -239,7 +239,7 @@ ropOR_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
     return op_pc + 1;
 }
 uint32_t
-ropOR_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropOR_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -437,7 +437,7 @@ ropOR_l_rmw(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropTEST_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropTEST_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -449,7 +449,7 @@ ropTEST_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32
     return op_pc + 1;
 }
 uint32_t
-ropTEST_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropTEST_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 
@@ -557,7 +557,7 @@ ropTEST_l_rm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t
 }
 
 uint32_t
-ropXOR_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropXOR_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm_data = fastreadb(cs + op_pc);
 
@@ -570,7 +570,7 @@ ropXOR_AL_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + 1;
 }
 uint32_t
-ropXOR_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropXOR_AX_imm(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm_data = fastreadw(cs + op_pc);
 

src/codegen_new/codegen_ops_misc.c

@@ -485,34 +485,34 @@ ropFF_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
 }
 
 uint32_t
-ropNOP(UNUSED(codeblock_t *block), UNUSED(ir_data_t *ir), UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropNOP(UNUSED(codeblock_t *block), UNUSED(ir_data_t *ir), UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     return op_pc;
 }
 
 uint32_t
-ropCBW(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCBW(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MOVSX(ir, IREG_AX, IREG_AL);
 
     return op_pc;
 }
 uint32_t
-ropCDQ(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCDQ(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_SAR_IMM(ir, IREG_EDX, IREG_EAX, 31);
 
     return op_pc;
 }
 uint32_t
-ropCWD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCWD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_SAR_IMM(ir, IREG_DX, IREG_AX, 15);
 
     return op_pc;
 }
 uint32_t
-ropCWDE(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCWDE(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MOVSX(ir, IREG_EAX, IREG_AX);
 
@@ -520,7 +520,7 @@ ropCWDE(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint3
 }
 
 #define ropLxS(name, seg)                                                                                                         \
-    uint32_t rop##name##_16(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t rop##name##_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg = NULL;                                                                                                \
         int     dest_reg   = (fetchdat >> 3) & 7;                                                                                 \
@@ -542,7 +542,7 @@ ropCWDE(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint3
                                                                                                                                   \
         return op_pc + 1;                                                                                                         \
     }                                                                                                                             \
-    uint32_t rop##name##_32(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t rop##name##_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                             \
         x86seg *target_seg = NULL;                                                                                                \
         int     dest_reg   = (fetchdat >> 3) & 7;                                                                                 \
@@ -572,21 +572,21 @@ ropLxS(LGS, &cpu_state.seg_gs)
 ropLxS(LSS, &cpu_state.seg_ss)
 
 uint32_t
-ropCLC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCLC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_CALL_FUNC(ir, flags_rebuild);
     uop_AND_IMM(ir, IREG_flags, IREG_flags, ~C_FLAG);
     return op_pc;
 }
 uint32_t
-ropCMC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCMC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_CALL_FUNC(ir, flags_rebuild);
     uop_XOR_IMM(ir, IREG_flags, IREG_flags, C_FLAG);
     return op_pc;
 }
 uint32_t
-ropSTC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSTC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_CALL_FUNC(ir, flags_rebuild);
     uop_OR_IMM(ir, IREG_flags, IREG_flags, C_FLAG);
@@ -594,20 +594,20 @@ ropSTC(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32
 }
 
 uint32_t
-ropCLD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCLD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_AND_IMM(ir, IREG_flags, IREG_flags, ~D_FLAG);
     return op_pc;
 }
 uint32_t
-ropSTD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSTD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_OR_IMM(ir, IREG_flags, IREG_flags, D_FLAG);
     return op_pc;
 }
 
 uint32_t
-ropCLI(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropCLI(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     if (!IOPLp && (cr4 & (CR4_VME | CR4_PVI)))
         return 0;
@@ -616,7 +616,7 @@ ropCLI(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32
     return op_pc;
 }
 uint32_t
-ropSTI(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropSTI(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     if (!IOPLp && (cr4 & (CR4_VME | CR4_PVI)))
         return 0;

src/codegen_new/codegen_ops_mmx_arith.c

@@ -2,6 +2,7 @@
 #include <86box/86box.h>
 #include "cpu.h"
 #include <86box/mem.h>
+#include <86box/plat_unused.h>
 
 #include "x86.h"
 #include "x86_flags.h"
@@ -16,7 +17,7 @@
 #include "codegen_ops_helpers.h"
 
 #define ropParith(func)                                                                                                      \
-    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                        \
         int dest_reg = (fetchdat >> 3) & 7;                                                                                  \
                                                                                                                              \
@@ -58,4 +59,4 @@ ropParith(PSUBUSW)
 ropParith(PMADDWD)
 ropParith(PMULHW)
 ropParith(PMULLW)
-    // clang-format on
+// clang-format on

src/codegen_new/codegen_ops_mmx_cmp.c

@@ -2,6 +2,7 @@
 #include <86box/86box.h>
 #include "cpu.h"
 #include <86box/mem.h>
+#include <86box/plat_unused.h>
 
 #include "x86.h"
 #include "x86_flags.h"
@@ -16,7 +17,7 @@
 #include "codegen_ops_helpers.h"
 
 #define ropPcmp(func)                                                                                                        \
-    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                        \
         int dest_reg = (fetchdat >> 3) & 7;                                                                                  \
                                                                                                                              \
@@ -45,4 +46,4 @@ ropPcmp(PCMPEQD)
 ropPcmp(PCMPGTB)
 ropPcmp(PCMPGTW)
 ropPcmp(PCMPGTD)
-    // clang-format on
+// clang-format on

src/codegen_new/codegen_ops_mmx_pack.c

@@ -2,6 +2,7 @@
 #include <86box/86box.h>
 #include "cpu.h"
 #include <86box/mem.h>
+#include <86box/plat_unused.h>
 
 #include "x86.h"
 #include "x86_flags.h"
@@ -16,7 +17,7 @@
 #include "codegen_ops_helpers.h"
 
 #define ropPpack(func)                                                                                                       \
-    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t rop##func(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
     {                                                                                                                        \
         int dest_reg = (fetchdat >> 3) & 7;                                                                                  \
                                                                                                                              \
@@ -48,4 +49,4 @@ ropPpack(PUNPCKLDQ)
 ropPpack(PUNPCKHBW)
 ropPpack(PUNPCKHWD)
 ropPpack(PUNPCKHDQ)
-    // clang-format on
+// clang-format on

src/codegen_new/codegen_ops_mov.c

@@ -15,7 +15,7 @@
 #include "codegen_ops_mov.h"
 
 uint32_t
-ropMOV_rb_imm(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropMOV_rb_imm(codeblock_t *block, ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint8_t imm = fastreadb(cs + op_pc);
 
@@ -25,7 +25,7 @@ ropMOV_rb_imm(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchd
     return op_pc + 1;
 }
 uint32_t
-ropMOV_rw_imm(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropMOV_rw_imm(codeblock_t *block, ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm = fastreadw(cs + op_pc);
 
@@ -172,7 +172,7 @@ ropMOV_r_l(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
 }
 
 uint32_t
-ropMOV_AL_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropMOV_AL_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t addr;
 
@@ -189,7 +189,7 @@ ropMOV_AL_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 uint32_t
-ropMOV_AX_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropMOV_AX_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t addr;
 
@@ -206,7 +206,7 @@ ropMOV_AX_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 uint32_t
-ropMOV_EAX_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropMOV_EAX_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t addr = 0;
 
@@ -233,7 +233,7 @@ ropMOV_EAX_abs(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32
 }
 
 uint32_t
-ropMOV_abs_AL(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropMOV_abs_AL(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t addr;
 
@@ -250,7 +250,7 @@ ropMOV_abs_AL(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 uint32_t
-ropMOV_abs_AX(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropMOV_abs_AX(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t addr;
 
@@ -267,7 +267,7 @@ ropMOV_abs_AX(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_
     return op_pc + ((op_32 & 0x200) ? 4 : 2);
 }
 uint32_t
-ropMOV_abs_EAX(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropMOV_abs_EAX(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uint32_t addr;
 
@@ -614,7 +614,7 @@ ropMOVZX_32_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32
 }
 
 uint32_t
-ropXCHG_AX(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropXCHG_AX(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int reg2 = IREG_16(opcode & 7);
 
@@ -625,7 +625,7 @@ ropXCHG_AX(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t f
     return op_pc;
 }
 uint32_t
-ropXCHG_EAX(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropXCHG_EAX(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int reg2 = IREG_32(opcode & 7);
 
@@ -716,7 +716,7 @@ ropXCHG_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t f
 }
 
 uint32_t
-ropXLAT(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, uint32_t op_32, uint32_t op_pc)
+ropXLAT(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), uint32_t op_32, uint32_t op_pc)
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 

src/codegen_new/codegen_ops_stack.c

@@ -16,7 +16,7 @@
 #include "codegen_ops_misc.h"
 
 uint32_t
-ropPUSH_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSH_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -28,7 +28,7 @@ ropPUSH_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t
     return op_pc;
 }
 uint32_t
-ropPUSH_r32(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSH_r32(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -41,7 +41,7 @@ ropPUSH_r32(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t
 }
 
 uint32_t
-ropPOP_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPOP_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 
@@ -57,7 +57,7 @@ ropPOP_r16(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t f
     return op_pc;
 }
 uint32_t
-ropPOP_r32(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPOP_r32(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 
@@ -74,7 +74,7 @@ ropPOP_r32(UNUSED(codeblock_t *block), ir_data_t *ir, uint8_t opcode, uint32_t f
 }
 
 uint32_t
-ropPUSH_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSH_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm = fastreadw(cs + op_pc);
     int      sp_reg;
@@ -88,7 +88,7 @@ ropPUSH_imm_16(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32
     return op_pc + 2;
 }
 uint32_t
-ropPUSH_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSH_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t imm = fastreadl(cs + op_pc);
     int      sp_reg;
@@ -103,7 +103,7 @@ ropPUSH_imm_32(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32
 }
 
 uint32_t
-ropPUSH_imm_16_8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSH_imm_16_8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint16_t imm = (int16_t) (int8_t) fastreadb(cs + op_pc);
     int      sp_reg;
@@ -117,7 +117,7 @@ ropPUSH_imm_16_8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint
     return op_pc + 1;
 }
 uint32_t
-ropPUSH_imm_32_8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSH_imm_32_8(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uint32_t imm = (int32_t) (int8_t) fastreadb(cs + op_pc);
     int      sp_reg;
@@ -197,7 +197,7 @@ ropPOP_L(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
 }
 
 #define ROP_PUSH_SEG(seg)                                                                                                             \
-    uint32_t ropPUSH_##seg##_16(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropPUSH_##seg##_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc) \
     {                                                                                                                                 \
         int sp_reg;                                                                                                                   \
                                                                                                                                       \
@@ -208,7 +208,7 @@ ropPOP_L(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
                                                                                                                                       \
         return op_pc;                                                                                                                 \
     }                                                                                                                                 \
-    uint32_t ropPUSH_##seg##_32(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropPUSH_##seg##_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc) \
     {                                                                                                                                 \
         int sp_reg;                                                                                                                   \
                                                                                                                                       \
@@ -222,7 +222,7 @@ ropPOP_L(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
     }
 
 #define ROP_POP_SEG(seg, rseg)                                                                                                       \
-    uint32_t ropPOP_##seg##_16(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropPOP_##seg##_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc) \
     {                                                                                                                                \
         uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);                                                                                \
                                                                                                                                      \
@@ -237,7 +237,7 @@ ropPOP_L(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
                                                                                                                                      \
         return op_pc;                                                                                                                \
     }                                                                                                                                \
-    uint32_t ropPOP_##seg##_32(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc) \
+    uint32_t ropPOP_##seg##_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc) \
     {                                                                                                                                \
         uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);                                                                                \
                                                                                                                                      \
@@ -253,6 +253,7 @@ ropPOP_L(codeblock_t *block, ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fet
         return op_pc;                                                                                                                \
     }
 
+// clang-format off
 ROP_PUSH_SEG(CS)
 ROP_PUSH_SEG(DS)
 ROP_PUSH_SEG(ES)
@@ -263,9 +264,10 @@ ROP_POP_SEG(DS, cpu_state.seg_ds)
 ROP_POP_SEG(ES, cpu_state.seg_es)
 ROP_POP_SEG(FS, cpu_state.seg_fs)
 ROP_POP_SEG(GS, cpu_state.seg_gs)
+// clang-format on
 
 uint32_t
-ropLEAVE_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropLEAVE_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 
@@ -281,7 +283,7 @@ ropLEAVE_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), u
     return op_pc;
 }
 uint32_t
-ropLEAVE_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropLEAVE_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     uop_MOV_IMM(ir, IREG_oldpc, cpu_state.oldpc);
 
@@ -298,7 +300,7 @@ ropLEAVE_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), u
 }
 
 uint32_t
-ropPUSHA_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSHA_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -317,7 +319,7 @@ ropPUSHA_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), u
     return op_pc;
 }
 uint32_t
-ropPUSHA_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSHA_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -337,7 +339,7 @@ ropPUSHA_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), u
 }
 
 uint32_t
-ropPOPA_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPOPA_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -355,7 +357,7 @@ ropPOPA_16(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), ui
     return op_pc;
 }
 uint32_t
-ropPOPA_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPOPA_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -374,7 +376,7 @@ ropPOPA_32(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), ui
 }
 
 uint32_t
-ropPUSHF(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSHF(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 
@@ -390,7 +392,7 @@ ropPUSHF(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint
     return op_pc;
 }
 uint32_t
-ropPUSHFD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), uint32_t fetchdat, UNUSED(uint32_t op_32), uint32_t op_pc)
+ropPUSHFD(UNUSED(codeblock_t *block), ir_data_t *ir, UNUSED(uint8_t opcode), UNUSED(uint32_t fetchdat), UNUSED(uint32_t op_32), uint32_t op_pc)
 {
     int sp_reg;
 

src/cpu/386.c

@@ -27,6 +27,7 @@
 #include <86box/fdc.h>
 #include <86box/machine.h>
 #include <86box/plat_fallthrough.h>
+#include <86box/plat_unused.h>
 #include <86box/gdbstub.h>
 #ifndef OPS_286_386
 #    define OPS_286_386

src/cpu/386_common.c

@@ -1825,7 +1825,7 @@ cpu_386_check_instruction_fault(void)
 }
 
 int
-sysenter(uint32_t fetchdat)
+sysenter(UNUSED(uint32_t fetchdat))
 {
 #ifdef ENABLE_386_COMMON_LOG
     x386_common_log("SYSENTER called\n");
@@ -1907,7 +1907,7 @@ sysenter(uint32_t fetchdat)
 }
 
 int
-sysexit(uint32_t fetchdat)
+sysexit(UNUSED(uint32_t fetchdat))
 {
 #ifdef ENABLE_386_COMMON_LOG
     x386_common_log("SYSEXIT called\n");
@@ -1994,7 +1994,7 @@ sysexit(uint32_t fetchdat)
 }
 
 int
-syscall_op(uint32_t fetchdat)
+syscall_op(UNUSED(uint32_t fetchdat))
 {
 #ifdef ENABLE_386_COMMON_LOG
     x386_common_log("SYSCALL called\n");
@@ -2046,7 +2046,7 @@ syscall_op(uint32_t fetchdat)
 }
 
 int
-sysret(uint32_t fetchdat)
+sysret(UNUSED(uint32_t fetchdat))
 {
 #ifdef ENABLE_386_COMMON_LOG
     x386_common_log("SYSRET called\n");

src/cpu/386_dynarec.c

@@ -30,6 +30,7 @@
 #include <86box/fdc.h>
 #include <86box/machine.h>
 #include <86box/plat_fallthrough.h>
+#include <86box/plat_unused.h>
 #include <86box/gdbstub.h>
 #ifdef USE_DYNAREC
 #    include "codegen.h"

src/cpu/808x.c

@@ -35,6 +35,7 @@
 #include <86box/ppi.h>
 #include <86box/timer.h>
 #include <86box/gdbstub.h>
+#include <86box/plat_unused.h>
 
 /* Is the CPU 8088 or 8086. */
 int is8086 = 0;
@@ -815,7 +816,7 @@ pop(void)
 }
 
 static void
-access(int num, int bits)
+access(int num, UNUSED(int bits))
 {
     switch (num) {
         case 0:
@@ -1419,7 +1420,7 @@ set_pzs(int bits)
 }
 
 static void
-set_co_mul(int bits, int carry)
+set_co_mul(UNUSED(int bits), int carry)
 {
     set_cf(carry);
     set_of(carry);

src/cpu/codegen_timing_486.c

@@ -328,7 +328,7 @@ codegen_timing_486_start(void)
 }
 
 void
-codegen_timing_486_prefix(uint8_t prefix, uint32_t fetchdat)
+codegen_timing_486_prefix(uint8_t prefix, UNUSED(uint32_t fetchdat))
 {
     timing_count += COUNT(opcode_timings_486[prefix], 0);
     last_prefix = prefix;

src/cpu/codegen_timing_k5.c

@@ -8,6 +8,7 @@
 #include <86box/mem.h>
 #include "cpu.h"
 #include <86box/machine.h>
+#include <86box/plat_unused.h>
 
 #include "x86.h"
 #include "x86_ops.h"
@@ -2037,7 +2038,7 @@ codegen_timing_k5_start(void)
 }
 
 void
-codegen_timing_k5_prefix(uint8_t prefix, uint32_t fetchdat)
+codegen_timing_k5_prefix(uint8_t prefix, UNUSED(uint32_t fetchdat))
 {
     if (prefix != 0x0f)
         decode_timestamp++;
@@ -2047,7 +2048,7 @@ codegen_timing_k5_prefix(uint8_t prefix, uint32_t fetchdat)
 }
 
 void
-codegen_timing_k5_opcode(uint8_t opcode, uint32_t fetchdat, int op_32, uint32_t op_pc)
+codegen_timing_k5_opcode(uint8_t opcode, UNUSED(uint32_t fetchdat), int op_32, uint32_t op_pc)
 {
     const risc86_instruction_t **ins_table;
     const uint64_t              *deps;

src/cpu/codegen_timing_k6.c

@@ -8,6 +8,7 @@
 #include <86box/mem.h>
 #include "cpu.h"
 #include <86box/machine.h>
+#include <86box/plat_unused.h>
 
 #include "x86.h"
 #include "x86_ops.h"
@@ -2037,7 +2038,7 @@ codegen_timing_k6_start(void)
 }
 
 void
-codegen_timing_k6_prefix(uint8_t prefix, uint32_t fetchdat)
+codegen_timing_k6_prefix(uint8_t prefix, UNUSED(uint32_t fetchdat))
 {
     if (prefix != 0x0f)
         decode_timestamp++;
@@ -2047,7 +2048,7 @@ codegen_timing_k6_prefix(uint8_t prefix, uint32_t fetchdat)
 }
 
 void
-codegen_timing_k6_opcode(uint8_t opcode, uint32_t fetchdat, int op_32, uint32_t op_pc)
+codegen_timing_k6_opcode(uint8_t opcode, UNUSED(uint32_t fetchdat), int op_32, uint32_t op_pc)
 {
     const risc86_instruction_t **ins_table;
     const uint64_t              *deps;

src/cpu/codegen_timing_p6.c

@@ -1845,7 +1845,7 @@ codegen_timing_p6_start(void)
 }
 
 void
-codegen_timing_p6_prefix(uint8_t prefix, uint32_t fetchdat)
+codegen_timing_p6_prefix(uint8_t prefix, UNUSED(uint32_t fetchdat))
 {
     if (prefix != 0x0f)
         decode_timestamp++;
@@ -1855,7 +1855,7 @@ codegen_timing_p6_prefix(uint8_t prefix, uint32_t fetchdat)
 }
 
 void
-codegen_timing_p6_opcode(uint8_t opcode, uint32_t fetchdat, int op_32, UNUSED(uint32_t op_pc))
+codegen_timing_p6_opcode(uint8_t opcode, UNUSED(uint32_t fetchdat), int op_32, UNUSED(uint32_t op_pc))
 {
     const macro_op_t **ins_table;
     const uint64_t    *deps;

src/cpu/codegen_timing_winchip.c

@@ -328,7 +328,7 @@ codegen_timing_winchip_start(void)
 }
 
 void
-codegen_timing_winchip_prefix(uint8_t prefix, uint32_t fetchdat)
+codegen_timing_winchip_prefix(uint8_t prefix, UNUSED(uint32_t fetchdat))
 {
     timing_count += COUNT(opcode_timings_winchip[prefix], 0);
     last_prefix = prefix;

src/cpu/codegen_timing_winchip2.c

@@ -589,7 +589,7 @@ codegen_timing_winchip2_start(void)
 }
 
 static void
-codegen_timing_winchip2_prefix(uint8_t prefix, uint32_t fetchdat)
+codegen_timing_winchip2_prefix(uint8_t prefix, UNUSED(uint32_t fetchdat))
 {
     if (prefix == 0x0f) {
         /*0fh prefix is 'free'*/

src/cpu/x86_ops_3dnow.h

@@ -20,7 +20,7 @@ opPREFETCH_a32(uint32_t fetchdat)
 }
 
 static int
-opFEMMS(uint32_t fetchdat)
+opFEMMS(UNUSED(uint32_t fetchdat))
 {
     ILLEGAL_ON(!cpu_has_feature(CPU_FEATURE_MMX));
     if (cr0 & 0xc) {
@@ -33,7 +33,7 @@ opFEMMS(uint32_t fetchdat)
 }
 
 static int
-opPAVGUSB(uint32_t fetchdat)
+opPAVGUSB(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -54,7 +54,7 @@ opPAVGUSB(uint32_t fetchdat)
     return 0;
 }
 static int
-opPF2ID(uint32_t fetchdat)
+opPF2ID(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -69,7 +69,7 @@ opPF2ID(uint32_t fetchdat)
     return 0;
 }
 static int
-opPF2IW(uint32_t fetchdat)
+opPF2IW(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -84,7 +84,7 @@ opPF2IW(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFACC(uint32_t fetchdat)
+opPFACC(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -101,7 +101,7 @@ opPFACC(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFNACC(uint32_t fetchdat)
+opPFNACC(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -118,7 +118,7 @@ opPFNACC(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFPNACC(uint32_t fetchdat)
+opPFPNACC(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -135,7 +135,7 @@ opPFPNACC(uint32_t fetchdat)
     return 0;
 }
 static int
-opPSWAPD(uint32_t fetchdat)
+opPSWAPD(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -155,7 +155,7 @@ opPSWAPD(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFADD(uint32_t fetchdat)
+opPFADD(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -170,7 +170,7 @@ opPFADD(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFCMPEQ(uint32_t fetchdat)
+opPFCMPEQ(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -185,7 +185,7 @@ opPFCMPEQ(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFCMPGE(uint32_t fetchdat)
+opPFCMPGE(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -200,7 +200,7 @@ opPFCMPGE(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFCMPGT(uint32_t fetchdat)
+opPFCMPGT(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -215,7 +215,7 @@ opPFCMPGT(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFMAX(uint32_t fetchdat)
+opPFMAX(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -232,7 +232,7 @@ opPFMAX(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFMIN(uint32_t fetchdat)
+opPFMIN(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -249,7 +249,7 @@ opPFMIN(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFMUL(uint32_t fetchdat)
+opPFMUL(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -264,7 +264,7 @@ opPFMUL(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFRCP(uint32_t fetchdat)
+opPFRCP(UNUSED(uint32_t fetchdat))
 {
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
 
@@ -293,7 +293,7 @@ opPFRCP(uint32_t fetchdat)
 }
 /*Since opPFRCP() calculates a full precision reciprocal, treat the followup iterations as MOVs*/
 static int
-opPFRCPIT1(uint32_t fetchdat)
+opPFRCPIT1(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -308,7 +308,7 @@ opPFRCPIT1(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFRCPIT2(uint32_t fetchdat)
+opPFRCPIT2(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -323,7 +323,7 @@ opPFRCPIT2(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFRSQRT(uint32_t fetchdat)
+opPFRSQRT(UNUSED(uint32_t fetchdat))
 {
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
 
@@ -352,7 +352,7 @@ opPFRSQRT(uint32_t fetchdat)
 }
 /*Since opPFRSQRT() calculates a full precision inverse square root, treat the followup iteration as a NOP*/
 static int
-opPFRSQIT1(uint32_t fetchdat)
+opPFRSQIT1(UNUSED(uint32_t fetchdat))
 {
     MMX_REG src;
 
@@ -362,7 +362,7 @@ opPFRSQIT1(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFSUB(uint32_t fetchdat)
+opPFSUB(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -377,7 +377,7 @@ opPFSUB(uint32_t fetchdat)
     return 0;
 }
 static int
-opPFSUBR(uint32_t fetchdat)
+opPFSUBR(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -392,7 +392,7 @@ opPFSUBR(uint32_t fetchdat)
     return 0;
 }
 static int
-opPI2FD(uint32_t fetchdat)
+opPI2FD(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -407,7 +407,7 @@ opPI2FD(uint32_t fetchdat)
     return 0;
 }
 static int
-opPI2FW(uint32_t fetchdat)
+opPI2FW(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);
@@ -422,7 +422,7 @@ opPI2FW(uint32_t fetchdat)
     return 0;
 }
 static int
-opPMULHRW(uint32_t fetchdat)
+opPMULHRW(UNUSED(uint32_t fetchdat))
 {
     MMX_REG  src;
     MMX_REG *dst = MMX_GETREGP(cpu_reg);

src/cpu/x86_ops_arith.h

@@ -313,7 +313,7 @@
         return 0;                                                                                           \
     }                                                                                                       \
                                                                                                             \
-    static int op##name##_EAX_imm(uint32_t fetchdat)                                                        \
+    static int op##name##_EAX_imm(UNUSED(uint32_t fetchdat))                                                \
     {                                                                                                       \
         uint32_t dst = EAX;                                                                                 \
         uint32_t src = getlong();                                                                           \
@@ -581,7 +581,7 @@ opCMP_AX_imm(uint32_t fetchdat)
 }
 
 static int
-opCMP_EAX_imm(uint32_t fetchdat)
+opCMP_EAX_imm(UNUSED(uint32_t fetchdat))
 {
     uint32_t src = getlong();
 
@@ -747,7 +747,7 @@ opTEST_AX(uint32_t fetchdat)
     return 0;
 }
 static int
-opTEST_EAX(uint32_t fetchdat)
+opTEST_EAX(UNUSED(uint32_t fetchdat))
 {
     uint32_t temp = getlong();
     if (cpu_state.abrt)

src/cpu/x86_ops_bcd.h

@@ -1,5 +1,5 @@
 static int
-opAAA(uint32_t fetchdat)
+opAAA(UNUSED(uint32_t fetchdat))
 {
     flags_rebuild();
     if ((cpu_state.flags & A_FLAG) || ((AL & 0xF) > 9)) {
@@ -46,7 +46,7 @@ opAAM(uint32_t fetchdat)
 }
 
 static int
-opAAS(uint32_t fetchdat)
+opAAS(UNUSED(uint32_t fetchdat))
 {
     flags_rebuild();
     if ((cpu_state.flags & A_FLAG) || ((AL & 0xF) > 9)) {
@@ -63,7 +63,7 @@ opAAS(uint32_t fetchdat)
 }
 
 static int
-opDAA(uint32_t fetchdat)
+opDAA(UNUSED(uint32_t fetchdat))
 {
     uint16_t tempw;
     uint16_t old_AL;
@@ -100,7 +100,7 @@ opDAA(uint32_t fetchdat)
 }
 
 static int
-opDAS(uint32_t fetchdat)
+opDAS(UNUSED(uint32_t fetchdat))
 {
     uint16_t tempw;
     uint16_t old_AL;

src/cpu/x86_ops_call.h

@@ -209,7 +209,7 @@ opCALL_far_w(uint32_t fetchdat)
     return 0;
 }
 static int
-opCALL_far_l(uint32_t fetchdat)
+opCALL_far_l(UNUSED(uint32_t fetchdat))
 {
     uint32_t old_cs;
     uint32_t old_pc;