Deprecate the old memory_install_* macros. Dynamic installation is now handled

directly by calling methods on the address_space, which have been expanded with
aliases to cover all previous situations. In addition, variants with no mirror
or mask value are provided to cover the common cases:

memory_install_read*_handler(space, begin, end, mirror, mask, handler) ==>
    space->install_legacy_read_handler(begin, end [, mirror, mask], FUNC(handler))

memory_install_write*_handler(space, begin, end, mirror, mask, handler) ==>
    space->install_legacy_write_handler(begin, end [, mirror, mask], FUNC(handler))

memory_install_readwrite*_handler(space, begin, end, mirror, mask, rhandler, whandler) ==>
    space->install_legacy_readwrite_handler(begin, end [, mirror, mask], FUNC(rhandler), FUNC(whandler))

memory_install_read*_device_handler(space, device, begin, end, mirror, mask, handler) ==>
    space->install_legacy_read_handler(*device, begin, end [, mirror, mask], FUNC(handler))

memory_install_write*_device_handler(space, device, begin, end, mirror, mask, handler) ==>
    space->install_legacy_write_handler(*device, begin, end [, mirror, mask], FUNC(handler))

memory_install_readwrite*_device_handler(space, device, begin, end, mirror, mask, rhandler, whandler) ==>
    space->install_legacy_readwrite_handler(*device, begin, end [, mirror, mask], FUNC(rhandler), FUNC(whandler))

memory_install_read_port(space, begin, end, mirror, mask, port) ==>
    space->install_read_port(begin, end [, mirror, mask], port)

memory_install_read_bank(space, begin, end, mirror, mask, bank) ==>
    space->install_read_bank(begin, end [, mirror, mask], bank)

memory_install_rom(space, begin, end, mirror, mask, ptr) ==>
    space->install_rom(begin, end [, mirror, mask], ptr)

memory_install_ram(space, begin, end, mirror, mask, ptr) ==>
    space->install_ram(begin, end [, mirror, mask], ptr)

memory_unmap_read(space, begin, end, mirror, mask) ==>
    space->unmap_read(begin, end [, mirror, mask])

memory_nop_read(space, begin, end, mirror, mask) ==>
    space->nop_read(begin, end [, mirror, mask])


Below are the bulk search & replace regex'es used for this

memory_install_read([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_read([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_write([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_write([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_readwrite([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\4->install_legacy_readwrite_handler\2\(\3\5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\4->install_legacy_readwrite_handler\2\(\3\5FUNC\(\6\)\7FUNC\(\8\)\9\)



memory_install_read([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_read([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_write([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_write([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_readwrite8_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite8_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite16_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite16_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite32_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite32_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite64_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite64_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)



memory_install_read_port( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_read_port\1\(\2\4,

memory_install_read_port( *)\(( *)([^,]+), *
\3->install_read_port\1\(\2

memory_install_write_port( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_write_port\1\(\2\4,

memory_install_write_port( *)\(( *)([^,]+), *
\3->install_write_port\1\(\2

memory_install_readwrite_port( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_readwrite_port\1\(\2\4,

memory_install_readwrite_port( *)\(( *)([^,]+), *
\3->install_readwrite_port\1\(\2



memory_install_read_bank( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_read_bank\1\(\2\4,

memory_install_read_bank( *)\(( *)([^,]+), *
\3->install_read_bank\1\(\2

memory_install_write_bank( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_write_bank\1\(\2\4,

memory_install_write_bank( *)\(( *)([^,]+), *
\3->install_write_bank\1\(\2

memory_install_readwrite_bank( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_readwrite_bank\1\(\2\4,

memory_install_readwrite_bank( *)\(( *)([^,]+), *
\3->install_readwrite_bank\1\(\2



memory_install_rom( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_rom\1\(\2\4,

memory_install_rom( *)\(( *)([^,]+), *
\3->install_rom\1\(\2

memory_install_ram( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_ram\1\(\2\4,

memory_install_ram( *)\(( *)([^,]+), *
\3->install_ram\1\(\2

memory_install_writeonly( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_writeonly\1\(\2\4,

memory_install_writeonly( *)\(( *)([^,]+), *
\3->install_writeonly\1\(\2



memory_unmap_read( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->unmap_read\1\(\2\4\)

memory_unmap_read( *)\(( *)([^,]+), *
\3->unmap_read\1\(\2

memory_unmap_write( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->unmap_write\1\(\2\4\)

memory_unmap_write( *)\(( *)([^,]+), *
\3->unmap_write\1\(\2

memory_unmap_readwrite( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->unmap_readwrite\1\(\2\4\)

memory_unmap_readwrite( *)\(( *)([^,]+), *
\3->unmap_readwrite\1\(\2



memory_nop_read( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->nop_read\1\(\2\4\)

memory_nop_read( *)\(( *)([^,]+), *
\3->nop_read\1\(\2

memory_nop_write( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->nop_write\1\(\2\4\)

memory_nop_write( *)\(( *)([^,]+), *
\3->nop_write\1\(\2

memory_nop_readwrite( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->nop_readwrite\1\(\2\4\)

memory_nop_readwrite( *)\(( *)([^,]+), *
\3->nop_readwrite\1\(\2

src/emu/cpu/mips/psx.c

@@ -1256,16 +1256,16 @@ void psxcpu_device::update_scratchpad()
 {
 	if( ( m_biu & BIU_RAM ) == 0 )
 	{
-		memory_install_readwrite32_device_handler( m_program, this, 0x1f800000, 0x1f8003ff, 0, 0, psx_berr_r, psx_berr_w );
+		m_program->install_legacy_readwrite_handler( *this, 0x1f800000, 0x1f8003ff, FUNC(psx_berr_r), FUNC(psx_berr_w) );
 	}
 	else if( ( m_biu & BIU_DS ) == 0 )
 	{
-		memory_install_read32_device_handler( m_program, this, 0x1f800000, 0x1f8003ff, 0, 0, psx_berr_r );
+		m_program->install_legacy_read_handler( *this, 0x1f800000, 0x1f8003ff, FUNC(psx_berr_r) );
-		memory_nop_write( m_program, 0x1f800000, 0x1f8003ff, 0, 0 );
+		m_program->nop_write( 0x1f800000, 0x1f8003ff);
 	}
 	else
 	{
-		memory_install_ram( m_program, 0x1f800000, 0x1f8003ff, 0, 0, m_dcache );
+		m_program->install_ram( 0x1f800000, 0x1f8003ff, m_dcache );
 	}
 }
 

src/emu/machine/s3c2400.c

@@ -47,28 +47,28 @@ DEVICE_START( s3c2400 )
 {
 	address_space *space = device->machine->device( "maincpu")->memory().space( AS_PROGRAM);
 	DEVICE_START_CALL(s3c24xx);
-	memory_install_readwrite32_device_handler( space, device, 0x14000000, 0x1400003b, 0, 0, s3c24xx_memcon_r, s3c24xx_memcon_w);
+	space->install_legacy_readwrite_handler( *device, 0x14000000, 0x1400003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14200000, 0x1420005b, 0, 0, s3c24xx_usb_host_r, s3c24xx_usb_host_w);
+	space->install_legacy_readwrite_handler( *device, 0x14200000, 0x1420005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14400000, 0x14400017, 0, 0, s3c24xx_irq_r, s3c24xx_irq_w);
+	space->install_legacy_readwrite_handler( *device, 0x14400000, 0x14400017, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14600000, 0x1460001b, 0, 0, s3c24xx_dma_0_r, s3c24xx_dma_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x14600000, 0x1460001b, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14600020, 0x1460003b, 0, 0, s3c24xx_dma_1_r, s3c24xx_dma_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x14600020, 0x1460003b, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14600040, 0x1460005b, 0, 0, s3c24xx_dma_2_r, s3c24xx_dma_2_w);
+	space->install_legacy_readwrite_handler( *device, 0x14600040, 0x1460005b, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14600060, 0x1460007b, 0, 0, s3c24xx_dma_3_r, s3c24xx_dma_3_w);
+	space->install_legacy_readwrite_handler( *device, 0x14600060, 0x1460007b, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14800000, 0x14800017, 0, 0, s3c24xx_clkpow_r, s3c24xx_clkpow_w);
+	space->install_legacy_readwrite_handler( *device, 0x14800000, 0x14800017, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14a00000, 0x14a003ff, 0, 0, s3c2400_lcd_r, s3c24xx_lcd_w);
+	space->install_legacy_readwrite_handler( *device, 0x14a00000, 0x14a003ff, FUNC(s3c2400_lcd_r), FUNC(s3c24xx_lcd_w));
-	memory_install_readwrite32_device_handler( space, device, 0x14a00400, 0x14a007ff, 0, 0, s3c24xx_lcd_palette_r, s3c24xx_lcd_palette_w);
+	space->install_legacy_readwrite_handler( *device, 0x14a00400, 0x14a007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15000000, 0x1500002b, 0, 0, s3c24xx_uart_0_r, s3c24xx_uart_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x15000000, 0x1500002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15004000, 0x1500402b, 0, 0, s3c24xx_uart_1_r, s3c24xx_uart_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x15004000, 0x1500402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15100000, 0x15100043, 0, 0, s3c24xx_pwm_r, s3c24xx_pwm_w);
+	space->install_legacy_readwrite_handler( *device, 0x15100000, 0x15100043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15200140, 0x152001fb, 0, 0, s3c24xx_usb_device_r, s3c24xx_usb_device_w);
+	space->install_legacy_readwrite_handler( *device, 0x15200140, 0x152001fb, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15300000, 0x1530000b, 0, 0, s3c24xx_wdt_r, s3c24xx_wdt_w);
+	space->install_legacy_readwrite_handler( *device, 0x15300000, 0x1530000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15400000, 0x1540000f, 0, 0, s3c24xx_iic_r, s3c24xx_iic_w);
+	space->install_legacy_readwrite_handler( *device, 0x15400000, 0x1540000f, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15508000, 0x15508013, 0, 0, s3c24xx_iis_r, s3c24xx_iis_w);
+	space->install_legacy_readwrite_handler( *device, 0x15508000, 0x15508013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15600000, 0x1560005b, 0, 0, s3c24xx_gpio_r, s3c24xx_gpio_w);
+	space->install_legacy_readwrite_handler( *device, 0x15600000, 0x1560005b, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15700040, 0x1570008b, 0, 0, s3c24xx_rtc_r, s3c24xx_rtc_w);
+	space->install_legacy_readwrite_handler( *device, 0x15700040, 0x1570008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15800000, 0x15800007, 0, 0, s3c24xx_adc_r, s3c24xx_adc_w);
+	space->install_legacy_readwrite_handler( *device, 0x15800000, 0x15800007, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15900000, 0x15900017, 0, 0, s3c24xx_spi_0_r, s3c24xx_spi_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x15900000, 0x15900017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x15a00000, 0x15a0003f, 0, 0, s3c24xx_mmc_r, s3c24xx_mmc_w);
+	space->install_legacy_readwrite_handler( *device, 0x15a00000, 0x15a0003f, FUNC(s3c24xx_mmc_r), FUNC(s3c24xx_mmc_w));
 }
 
 DEVICE_GET_INFO( s3c2400 )

src/emu/machine/s3c2410.c

@@ -47,31 +47,31 @@ DEVICE_START( s3c2410 )
 {
 	address_space *space = device->machine->device( "maincpu")->memory().space( AS_PROGRAM);
 	DEVICE_START_CALL(s3c24xx);
-	memory_install_readwrite32_device_handler( space, device, 0x48000000, 0x4800003b, 0, 0, s3c24xx_memcon_r, s3c24xx_memcon_w);
+	space->install_legacy_readwrite_handler( *device, 0x48000000, 0x4800003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w));
-	memory_install_readwrite32_device_handler( space, device, 0x49000000, 0x4900005b, 0, 0, s3c24xx_usb_host_r, s3c24xx_usb_host_w);
+	space->install_legacy_readwrite_handler( *device, 0x49000000, 0x4900005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4a000000, 0x4a00001f, 0, 0, s3c24xx_irq_r, s3c24xx_irq_w);
+	space->install_legacy_readwrite_handler( *device, 0x4a000000, 0x4a00001f, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b000000, 0x4b000023, 0, 0, s3c24xx_dma_0_r, s3c24xx_dma_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b000000, 0x4b000023, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b000040, 0x4b000063, 0, 0, s3c24xx_dma_1_r, s3c24xx_dma_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b000040, 0x4b000063, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b000080, 0x4b0000a3, 0, 0, s3c24xx_dma_2_r, s3c24xx_dma_2_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b000080, 0x4b0000a3, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b0000c0, 0x4b0000e3, 0, 0, s3c24xx_dma_3_r, s3c24xx_dma_3_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b0000c0, 0x4b0000e3, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4c000000, 0x4c000017, 0, 0, s3c24xx_clkpow_r, s3c24xx_clkpow_w);
+	space->install_legacy_readwrite_handler( *device, 0x4c000000, 0x4c000017, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4d000000, 0x4d000063, 0, 0, s3c2410_lcd_r, s3c24xx_lcd_w);
+	space->install_legacy_readwrite_handler( *device, 0x4d000000, 0x4d000063, FUNC(s3c2410_lcd_r), FUNC(s3c24xx_lcd_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4d000400, 0x4d0007ff, 0, 0, s3c24xx_lcd_palette_r, s3c24xx_lcd_palette_w);
+	space->install_legacy_readwrite_handler( *device, 0x4d000400, 0x4d0007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4e000000, 0x4e000017, 0, 0, s3c24xx_nand_r, s3c24xx_nand_w);
+	space->install_legacy_readwrite_handler( *device, 0x4e000000, 0x4e000017, FUNC(s3c24xx_nand_r), FUNC(s3c24xx_nand_w));
-	memory_install_readwrite32_device_handler( space, device, 0x50000000, 0x5000002b, 0, 0, s3c24xx_uart_0_r, s3c24xx_uart_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x50000000, 0x5000002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x50004000, 0x5000402b, 0, 0, s3c24xx_uart_1_r, s3c24xx_uart_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x50004000, 0x5000402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x50008000, 0x5000802b, 0, 0, s3c24xx_uart_2_r, s3c24xx_uart_2_w);
+	space->install_legacy_readwrite_handler( *device, 0x50008000, 0x5000802b, FUNC(s3c24xx_uart_2_r), FUNC(s3c24xx_uart_2_w));
-	memory_install_readwrite32_device_handler( space, device, 0x51000000, 0x51000043, 0, 0, s3c24xx_pwm_r, s3c24xx_pwm_w);
+	space->install_legacy_readwrite_handler( *device, 0x51000000, 0x51000043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w));
-	memory_install_readwrite32_device_handler( space, device, 0x52000140, 0x5200026f, 0, 0, s3c24xx_usb_device_r, s3c24xx_usb_device_w);
+	space->install_legacy_readwrite_handler( *device, 0x52000140, 0x5200026f, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w));
-	memory_install_readwrite32_device_handler( space, device, 0x53000000, 0x5300000b, 0, 0, s3c24xx_wdt_r, s3c24xx_wdt_w);
+	space->install_legacy_readwrite_handler( *device, 0x53000000, 0x5300000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w));
-	memory_install_readwrite32_device_handler( space, device, 0x54000000, 0x5400000f, 0, 0, s3c24xx_iic_r, s3c24xx_iic_w);
+	space->install_legacy_readwrite_handler( *device, 0x54000000, 0x5400000f, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w));
-	memory_install_readwrite32_device_handler( space, device, 0x55000000, 0x55000013, 0, 0, s3c24xx_iis_r, s3c24xx_iis_w);
+	space->install_legacy_readwrite_handler( *device, 0x55000000, 0x55000013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w));
-	memory_install_readwrite32_device_handler( space, device, 0x56000000, 0x560000bf, 0, 0, s3c24xx_gpio_r, s3c24xx_gpio_w);
+	space->install_legacy_readwrite_handler( *device, 0x56000000, 0x560000bf, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w));
-	memory_install_readwrite32_device_handler( space, device, 0x57000040, 0x5700008b, 0, 0, s3c24xx_rtc_r, s3c24xx_rtc_w);
+	space->install_legacy_readwrite_handler( *device, 0x57000040, 0x5700008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w));
-	memory_install_readwrite32_device_handler( space, device, 0x58000000, 0x58000013, 0, 0, s3c24xx_adc_r, s3c24xx_adc_w);
+	space->install_legacy_readwrite_handler( *device, 0x58000000, 0x58000013, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w));
-	memory_install_readwrite32_device_handler( space, device, 0x59000000, 0x59000017, 0, 0, s3c24xx_spi_0_r, s3c24xx_spi_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x59000020, 0x59000037, 0, 0, s3c24xx_spi_1_r, s3c24xx_spi_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x5a000000, 0x5a000043, 0, 0, s3c24xx_sdi_r, s3c24xx_sdi_w);
+	space->install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w));
 }
 
 DEVICE_GET_INFO( s3c2410 )

src/emu/machine/s3c2440.c

@@ -46,33 +46,33 @@ SCREEN_UPDATE( s3c2440 )
 DEVICE_START( s3c2440 )
 {
 	address_space *space = device->machine->device( "maincpu")->memory().space( AS_PROGRAM);
-	memory_install_readwrite32_device_handler( space, device, 0x48000000, 0x4800003b, 0, 0, s3c24xx_memcon_r, s3c24xx_memcon_w);
+	space->install_legacy_readwrite_handler( *device, 0x48000000, 0x4800003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w));
-	memory_install_readwrite32_device_handler( space, device, 0x49000000, 0x4900005b, 0, 0, s3c24xx_usb_host_r, s3c24xx_usb_host_w);
+	space->install_legacy_readwrite_handler( *device, 0x49000000, 0x4900005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4a000000, 0x4a00001f, 0, 0, s3c24xx_irq_r, s3c24xx_irq_w);
+	space->install_legacy_readwrite_handler( *device, 0x4a000000, 0x4a00001f, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b000000, 0x4b000023, 0, 0, s3c24xx_dma_0_r, s3c24xx_dma_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b000000, 0x4b000023, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b000040, 0x4b000063, 0, 0, s3c24xx_dma_1_r, s3c24xx_dma_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b000040, 0x4b000063, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b000080, 0x4b0000a3, 0, 0, s3c24xx_dma_2_r, s3c24xx_dma_2_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b000080, 0x4b0000a3, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4b0000c0, 0x4b0000e3, 0, 0, s3c24xx_dma_3_r, s3c24xx_dma_3_w);
+	space->install_legacy_readwrite_handler( *device, 0x4b0000c0, 0x4b0000e3, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4c000000, 0x4c00001b, 0, 0, s3c24xx_clkpow_r, s3c24xx_clkpow_w);
+	space->install_legacy_readwrite_handler( *device, 0x4c000000, 0x4c00001b, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4d000000, 0x4d000063, 0, 0, s3c2440_lcd_r, s3c24xx_lcd_w);
+	space->install_legacy_readwrite_handler( *device, 0x4d000000, 0x4d000063, FUNC(s3c2440_lcd_r), FUNC(s3c24xx_lcd_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4d000400, 0x4d0007ff, 0, 0, s3c24xx_lcd_palette_r, s3c24xx_lcd_palette_w);
+	space->install_legacy_readwrite_handler( *device, 0x4d000400, 0x4d0007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4e000000, 0x4e00003f, 0, 0, s3c24xx_nand_r, s3c24xx_nand_w);
+	space->install_legacy_readwrite_handler( *device, 0x4e000000, 0x4e00003f, FUNC(s3c24xx_nand_r), FUNC(s3c24xx_nand_w));
-	memory_install_readwrite32_device_handler( space, device, 0x4f000000, 0x4f0000a3, 0, 0, s3c24xx_cam_r, s3c24xx_cam_w);
+	space->install_legacy_readwrite_handler( *device, 0x4f000000, 0x4f0000a3, FUNC(s3c24xx_cam_r), FUNC(s3c24xx_cam_w));
-	memory_install_readwrite32_device_handler( space, device, 0x50000000, 0x5000002b, 0, 0, s3c24xx_uart_0_r, s3c24xx_uart_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x50000000, 0x5000002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x50004000, 0x5000402b, 0, 0, s3c24xx_uart_1_r, s3c24xx_uart_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x50004000, 0x5000402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x50008000, 0x5000802b, 0, 0, s3c24xx_uart_2_r, s3c24xx_uart_2_w);
+	space->install_legacy_readwrite_handler( *device, 0x50008000, 0x5000802b, FUNC(s3c24xx_uart_2_r), FUNC(s3c24xx_uart_2_w));
-	memory_install_readwrite32_device_handler( space, device, 0x51000000, 0x51000043, 0, 0, s3c24xx_pwm_r, s3c24xx_pwm_w);
+	space->install_legacy_readwrite_handler( *device, 0x51000000, 0x51000043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w));
-	memory_install_readwrite32_device_handler( space, device, 0x52000140, 0x5200026f, 0, 0, s3c24xx_usb_device_r, s3c24xx_usb_device_w);
+	space->install_legacy_readwrite_handler( *device, 0x52000140, 0x5200026f, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w));
-	memory_install_readwrite32_device_handler( space, device, 0x53000000, 0x5300000b, 0, 0, s3c24xx_wdt_r, s3c24xx_wdt_w);
+	space->install_legacy_readwrite_handler( *device, 0x53000000, 0x5300000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w));
-	memory_install_readwrite32_device_handler( space, device, 0x54000000, 0x54000013, 0, 0, s3c24xx_iic_r, s3c24xx_iic_w);
+	space->install_legacy_readwrite_handler( *device, 0x54000000, 0x54000013, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w));
-	memory_install_readwrite32_device_handler( space, device, 0x55000000, 0x55000013, 0, 0, s3c24xx_iis_r, s3c24xx_iis_w);
+	space->install_legacy_readwrite_handler( *device, 0x55000000, 0x55000013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w));
-	memory_install_readwrite32_device_handler( space, device, 0x56000000, 0x560000df, 0, 0, s3c24xx_gpio_r, s3c24xx_gpio_w);
+	space->install_legacy_readwrite_handler( *device, 0x56000000, 0x560000df, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w));
-	memory_install_readwrite32_device_handler( space, device, 0x57000040, 0x5700008b, 0, 0, s3c24xx_rtc_r, s3c24xx_rtc_w);
+	space->install_legacy_readwrite_handler( *device, 0x57000040, 0x5700008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w));
-	memory_install_readwrite32_device_handler( space, device, 0x58000000, 0x58000017, 0, 0, s3c24xx_adc_r, s3c24xx_adc_w);
+	space->install_legacy_readwrite_handler( *device, 0x58000000, 0x58000017, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w));
-	memory_install_readwrite32_device_handler( space, device, 0x59000000, 0x59000017, 0, 0, s3c24xx_spi_0_r, s3c24xx_spi_0_w);
+	space->install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w));
-	memory_install_readwrite32_device_handler( space, device, 0x59000020, 0x59000037, 0, 0, s3c24xx_spi_1_r, s3c24xx_spi_1_w);
+	space->install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w));
-	memory_install_readwrite32_device_handler( space, device, 0x5a000000, 0x5a000043, 0, 0, s3c24xx_sdi_r, s3c24xx_sdi_w);
+	space->install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w));
-	memory_install_readwrite32_device_handler( space, device, 0x5b000000, 0x5b00001f, 0, 0, s3c24xx_ac97_r, s3c24xx_ac97_w);
+	space->install_legacy_readwrite_handler( *device, 0x5b000000, 0x5b00001f, FUNC(s3c24xx_ac97_r), FUNC(s3c24xx_ac97_w));
 	DEVICE_START_CALL(s3c24xx);
 }
 

src/emu/memory.c

@@ -906,7 +906,7 @@ public:
 		UINT8 buffer[16];
 		for (int index = 0; index < 16; index++)
 			buffer[index ^ ((_Endian == ENDIANNESS_NATIVE) ? 0 : (data_width()/8 - 1))] = index * 0x11;
-		install_ram(0x00, 0x0f, 0x0f, 0, ROW_READWRITE, buffer);
+		install_ram_generic(0x00, 0x0f, 0x0f, 0, ROW_READWRITE, buffer);
 		printf("\n\naddress_space(%d, %s, %s)\n", NATIVE_BITS, (_Endian == ENDIANNESS_LITTLE) ? "little" : "big", _Large ? "large" : "small");
 
 		// walk through the first 8 addresses
@@ -2052,15 +2052,15 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
 			// fall through to the RAM case otherwise
 
 		case AMH_RAM:
-			install_ram(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite);
+			install_ram_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, NULL);
 			break;
 
 		case AMH_NOP:
-			unmap(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, true);
+			unmap_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, true);
 			break;
 
 		case AMH_UNMAP:
-			unmap(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, false);
+			unmap_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, false);
 			break;
 
 		case AMH_DRIVER_DELEGATE:
@@ -2139,13 +2139,13 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
 			break;
 
 		case AMH_PORT:
-			install_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
+			install_readwrite_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
 							(readorwrite == ROW_READ) ? data.m_tag : NULL,
 							(readorwrite == ROW_WRITE) ? data.m_tag : NULL);
 			break;
 
 		case AMH_BANK:
-			install_bank(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
+			install_bank_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
 							(readorwrite == ROW_READ) ? data.m_tag : NULL,
 							(readorwrite == ROW_WRITE) ? data.m_tag : NULL);
 			break;
@@ -2409,7 +2409,7 @@ void address_space::dump_map(FILE *file, read_or_write readorwrite)
 //  unmap - unmap a section of address space
 //-------------------------------------------------
 
-void address_space::unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet)
+void address_space::unmap_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet)
 {
 	VPRINTF(("address_space::unmap(%s-%s mask=%s mirror=%s, %s, %s)\n",
 			 core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
@@ -2428,13 +2428,13 @@ void address_space::unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, off
 
 
 //-------------------------------------------------
-//  install_port - install a new I/O port handler
+//  install_readwrite_port - install a new I/O port 
-//  into this address space
+//  handler into this address space
 //-------------------------------------------------
 
-void address_space::install_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
+void address_space::install_readwrite_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
 {
-	VPRINTF(("address_space::install_port(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
+	VPRINTF(("address_space::install_readwrite_port(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
 			 core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
 			 core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars),
 			 (rtag != NULL) ? rtag : "(none)", (wtag != NULL) ? wtag : "(none)"));
@@ -2470,13 +2470,13 @@ void address_space::install_port(offs_t addrstart, offs_t addrend, offs_t addrma
 
 
 //-------------------------------------------------
-//  install_bank - install a range as mapping to
+//  install_bank_generic - install a range as 
-//  a particular bank
+//  mapping to a particular bank
 //-------------------------------------------------
 
-void address_space::install_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
+void address_space::install_bank_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
 {
-	VPRINTF(("address_space::install_bank(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
+	VPRINTF(("address_space::install_readwrite_bank(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
 			 core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
 			 core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars),
 			 (rtag != NULL) ? rtag : "(none)", (wtag != NULL) ? wtag : "(none)"));
@@ -2501,15 +2501,15 @@ void address_space::install_bank(offs_t addrstart, offs_t addrend, offs_t addrma
 
 
 //-------------------------------------------------
-//  install_ram - install a simple fixed RAM
+//  install_ram_generic - install a simple fixed 
-//  region into the given address space
+//  RAM region into the given address space
 //-------------------------------------------------
 
-void *address_space::install_ram(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr)
+void *address_space::install_ram_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr)
 {
 	memory_private *memdata = m_machine.memory_data;
 
-	VPRINTF(("address_space::install_ram(%s-%s mask=%s mirror=%s, %s, %p)\n",
+	VPRINTF(("address_space::install_ram_generic(%s-%s mask=%s mirror=%s, %s, %p)\n",
 			 core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
 			 core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars),
 			 (readorwrite == ROW_READ) ? "read" : (readorwrite == ROW_WRITE) ? "write" : (readorwrite == ROW_READWRITE) ? "read/write" : "??",
@@ -2538,7 +2538,7 @@ void *address_space::install_ram(offs_t addrstart, offs_t addrend, offs_t addrma
 		if (bank.base() == NULL && memdata->initialized)
 		{
 			if (m_machine.phase() >= MACHINE_PHASE_RESET)
-				fatalerror("Attempted to call memory_install_ram() after initialization time without a baseptr!");
+				fatalerror("Attempted to call install_ram_generic() after initialization time without a baseptr!");
 			memory_block &block = memdata->blocklist.append(*auto_alloc(&m_machine, memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
 			bank.set_base(block.data());
 		}
@@ -2567,7 +2567,7 @@ void *address_space::install_ram(offs_t addrstart, offs_t addrend, offs_t addrma
 		if (bank.base() == NULL && memdata->initialized)
 		{
 			if (m_machine.phase() >= MACHINE_PHASE_RESET)
-				fatalerror("Attempted to call memory_install_ram() after initialization time without a baseptr!");
+				fatalerror("Attempted to call install_ram_generic() after initialization time without a baseptr!");
 			memory_block &block = memdata->blocklist.append(*auto_alloc(&m_machine, memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
 			bank.set_base(block.data());
 		}

src/emu/memory.h

@@ -431,17 +431,45 @@ public:
 	direct_update_delegate set_direct_update_handler(direct_update_delegate function) { return m_direct.set_direct_update(function); }
 	bool set_direct_region(offs_t &byteaddress);
 
-	// static handler installation
+	// umap ranges (short form)
-	void unmap(offs_t addrstart, offs_t addrend, read_or_write readorwrite, bool quiet) { unmap(addrstart, addrend, 0, 0, readorwrite, quiet); }
+	void unmap_read(offs_t addrstart, offs_t addrend) { unmap_read(addrstart, addrend, 0, 0); }
-	void unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet);
+	void unmap_write(offs_t addrstart, offs_t addrend) { unmap_write(addrstart, addrend, 0, 0); }
-	void install_port(offs_t addrstart, offs_t addrend, const char *rtag, const char *wtag) { install_port(addrstart, addrend, 0, 0, rtag, wtag); }
+	void unmap_readwrite(offs_t addrstart, offs_t addrend) { unmap_readwrite(addrstart, addrend, 0, 0); }
-	void install_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
+	void nop_read(offs_t addrstart, offs_t addrend) { nop_read(addrstart, addrend, 0, 0); }
-	void install_bank(offs_t addrstart, offs_t addrend, const char *rtag, const char *wtag) { install_bank(addrstart, addrend, 0, 0, rtag, wtag); }
+	void nop_write(offs_t addrstart, offs_t addrend) { nop_write(addrstart, addrend, 0, 0); }
-	void install_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
+	void nop_readwrite(offs_t addrstart, offs_t addrend) { nop_readwrite(addrstart, addrend, 0, 0); }
-	void *install_ram(offs_t addrstart, offs_t addrend, read_or_write readorwrite, void *baseptr = NULL) { return install_ram(addrstart, addrend, 0, 0, readorwrite, baseptr); }
-	void *install_ram(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr = NULL);
 
-	// install new-style delegate handlers
+	// umap ranges (with mirror/mask)
+	void unmap_read(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READ, false); }
+	void unmap_write(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, false); }
+	void unmap_readwrite(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, false); }
+	void nop_read(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READ, true); }
+	void nop_write(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, true); }
+	void nop_readwrite(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, true); }
+
+	// install ports, banks, RAM (short form)
+	void install_read_port(offs_t addrstart, offs_t addrend, const char *rtag) { install_read_port(addrstart, addrend, 0, 0, rtag); }
+	void install_write_port(offs_t addrstart, offs_t addrend, const char *wtag) { install_write_port(addrstart, addrend, 0, 0, wtag); }
+	void install_readwrite_port(offs_t addrstart, offs_t addrend, const char *rtag, const char *wtag) { install_readwrite_port(addrstart, addrend, 0, 0, rtag, wtag); }
+	void install_read_bank(offs_t addrstart, offs_t addrend, const char *tag) { install_read_bank(addrstart, addrend, 0, 0, tag); }
+	void install_write_bank(offs_t addrstart, offs_t addrend, const char *tag) { install_write_bank(addrstart, addrend, 0, 0, tag); }
+	void install_readwrite_bank(offs_t addrstart, offs_t addrend, const char *tag) { install_readwrite_bank(addrstart, addrend, 0, 0, tag); }
+	void *install_rom(offs_t addrstart, offs_t addrend, void *baseptr = NULL) { return install_rom(addrstart, addrend, 0, 0, baseptr); }
+	void *install_writeonly(offs_t addrstart, offs_t addrend, void *baseptr = NULL) { return install_writeonly(addrstart, addrend, 0, 0, baseptr); }
+	void *install_ram(offs_t addrstart, offs_t addrend, void *baseptr = NULL) { return install_ram(addrstart, addrend, 0, 0, baseptr); }
+
+	// install ports, banks, RAM (with mirror/mask)
+	void install_read_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag) { install_readwrite_port(addrstart, addrend, addrmask, addrmirror, rtag, NULL); }
+	void install_write_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *wtag) { install_readwrite_port(addrstart, addrend, addrmask, addrmirror, NULL, wtag); }
+	void install_readwrite_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
+	void install_read_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *tag) { install_bank_generic(addrstart, addrend, addrmask, addrmirror, tag, NULL); }
+	void install_write_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *tag) { install_bank_generic(addrstart, addrend, addrmask, addrmirror, NULL, tag); }
+	void install_readwrite_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *tag)  { install_bank_generic(addrstart, addrend, addrmask, addrmirror, tag, tag); }
+	void *install_rom(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, void *baseptr = NULL) { return install_ram_generic(addrstart, addrend, addrmask, addrmirror, ROW_READ, baseptr); } 
+	void *install_writeonly(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, void *baseptr = NULL) { return install_ram_generic(addrstart, addrend, addrmask, addrmirror, ROW_WRITE, baseptr); } 
+	void *install_ram(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, void *baseptr = NULL) { return install_ram_generic(addrstart, addrend, addrmask, addrmirror, ROW_READWRITE, baseptr); } 
+
+	// install new-style delegate handlers (short form)
 	UINT8 *install_read_handler(offs_t addrstart, offs_t addrend, read8_delegate rhandler, UINT64 unitmask = 0) { return install_read_handler(addrstart, addrend, 0, 0, rhandler, unitmask); }
 	UINT8 *install_write_handler(offs_t addrstart, offs_t addrend, write8_delegate whandler, UINT64 unitmask = 0) { return install_write_handler(addrstart, addrend, 0, 0, whandler, unitmask); }
 	UINT8 *install_readwrite_handler(offs_t addrstart, offs_t addrend, read8_delegate rhandler, write8_delegate whandler, UINT64 unitmask = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, rhandler, whandler, unitmask); }
@@ -455,6 +483,7 @@ public:
 	UINT64 *install_write_handler(offs_t addrstart, offs_t addrend, write64_delegate whandler, UINT64 unitmask = 0) { return install_write_handler(addrstart, addrend, 0, 0, whandler, unitmask); }
 	UINT64 *install_readwrite_handler(offs_t addrstart, offs_t addrend, read64_delegate rhandler, write64_delegate whandler, UINT64 unitmask = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, rhandler, whandler, unitmask); }
 
+	// install new-style delegate handlers (with mirror/mask)
 	UINT8 *install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_delegate rhandler, UINT64 unitmask = 0);
 	UINT8 *install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_delegate whandler, UINT64 unitmask = 0);
 	UINT8 *install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_delegate rhandler, write8_delegate whandler, UINT64 unitmask = 0);
@@ -468,7 +497,7 @@ public:
 	UINT64 *install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write64_delegate whandler, UINT64 unitmask = 0);
 	UINT64 *install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_delegate rhandler, write64_delegate whandler, UINT64 unitmask = 0);
 
-	// install legacy address space handlers
+	// install legacy address space handlers (short form)
 	UINT8 *install_legacy_read_handler(offs_t addrstart, offs_t addrend, read8_space_func rhandler, const char *rname, UINT64 unitmask = 0) { return install_legacy_read_handler(addrstart, addrend, 0, 0, rhandler, rname, unitmask); }
 	UINT8 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, write8_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(addrstart, addrend, 0, 0, whandler, wname, unitmask); }
 	UINT8 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, read8_space_func rhandler, const char *rname, write8_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
@@ -482,6 +511,7 @@ public:
 	UINT64 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, write64_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(addrstart, addrend, 0, 0, whandler, wname, unitmask); }
 	UINT64 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, read64_space_func rhandler, const char *rname, write64_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
 
+	// install legacy address space handlers (with mirror/mask)
 	UINT8 *install_legacy_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rname, UINT64 unitmask = 0);
 	UINT8 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_space_func whandler, const char *wname, UINT64 unitmask = 0);
 	UINT8 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rname, write8_space_func whandler, const char *wname, UINT64 unitmask = 0);
@@ -495,7 +525,7 @@ public:
 	UINT64 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write64_space_func whandler, const char *wname, UINT64 unitmask = 0);
 	UINT64 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_space_func rhandler, const char *rname, write64_space_func whandler, const char *wname, UINT64 unitmask = 0);
 
-	// install legacy device handlers
+	// install legacy device handlers (short form)
 	UINT8 *install_legacy_read_handler(device_t &device, offs_t addrstart, offs_t addrend, read8_device_func rhandler, const char *rname, UINT64 unitmask = 0) { return install_legacy_read_handler(device, addrstart, addrend, 0, 0, rhandler, rname, unitmask); }
 	UINT8 *install_legacy_write_handler(device_t &device, offs_t addrstart, offs_t addrend, write8_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(device, addrstart, addrend, 0, 0, whandler, wname, unitmask); }
 	UINT8 *install_legacy_readwrite_handler(device_t &device, offs_t addrstart, offs_t addrend, read8_device_func rhandler, const char *rname, write8_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(device, addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
@@ -509,6 +539,7 @@ public:
 	UINT64 *install_legacy_write_handler(device_t &device, offs_t addrstart, offs_t addrend, write64_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(device, addrstart, addrend, 0, 0, whandler, wname, unitmask); }
 	UINT64 *install_legacy_readwrite_handler(device_t &device, offs_t addrstart, offs_t addrend, read64_device_func rhandler, const char *rname, write64_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(device, addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
 
+	// install legacy device handlers (with mirror/mask)
 	UINT8 *install_legacy_read_handler(device_t &device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, const char *rname, UINT64 unitmask = 0);
 	UINT8 *install_legacy_write_handler(device_t &device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_device_func whandler, const char *wname, UINT64 unitmask = 0);
 	UINT8 *install_legacy_readwrite_handler(device_t &device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, const char *rname, write8_device_func whandler, const char *wname, UINT64 unitmask = 0);
@@ -533,6 +564,9 @@ private:
 	virtual address_table_read &read() = 0;
 	virtual address_table_write &write() = 0;
 	void populate_map_entry(const address_map_entry &entry, read_or_write readorwrite);
+	void unmap_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet);
+	void *install_ram_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr);
+	void install_bank_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
 	void bind_and_install_handler(const address_map_entry &entry, read_or_write readorwrite, device_t *device);
 	void adjust_addresses(offs_t &start, offs_t &end, offs_t &mask, offs_t &mirror);
 	void *find_backing_memory(offs_t addrstart, offs_t addrend);
@@ -667,97 +701,6 @@ protected:
 #define DWORD_XOR_LE(a) 				((a) ^ NATIVE_ENDIAN_VALUE_LE_BE(0,4))
 
 
-// wrappers for dynamic read handler installation
-#define memory_install_read8_handler(space, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
-#define memory_install_read16_handler(space, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
-#define memory_install_read32_handler(space, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
-#define memory_install_read64_handler(space, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
-
-#define memory_install_read8_device_handler(space, device, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
-#define memory_install_read16_device_handler(space, device, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
-#define memory_install_read32_device_handler(space, device, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
-#define memory_install_read64_device_handler(space, device, start, end, mask, mirror, rhandler) \
-	(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
-
-#define memory_install_read_port(space, start, end, mask, mirror, rtag) \
-	(space)->install_port(start, end, mask, mirror, rtag, NULL)
-#define memory_install_read_bank(space, start, end, mask, mirror, rtag) \
-	(space)->install_bank(start, end, mask, mirror, rtag, NULL)
-#define memory_install_rom(space, start, end, mask, mirror, baseptr) \
-	(space)->install_ram(start, end, mask, mirror, ROW_READ, baseptr)
-#define memory_unmap_read(space, start, end, mask, mirror) \
-	(space)->unmap(start, end, mask, mirror, ROW_READ, false)
-#define memory_nop_read(space, start, end, mask, mirror) \
-	(space)->unmap(start, end, mask, mirror, ROW_READ, true)
-
-// wrappers for dynamic write handler installation
-#define memory_install_write8_handler(space, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
-#define memory_install_write16_handler(space, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
-#define memory_install_write32_handler(space, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
-#define memory_install_write64_handler(space, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
-
-#define memory_install_write8_device_handler(space, device, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
-#define memory_install_write16_device_handler(space, device, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
-#define memory_install_write32_device_handler(space, device, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
-#define memory_install_write64_device_handler(space, device, start, end, mask, mirror, whandler) \
-	(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
-
-#define memory_install_write_port(space, start, end, mask, mirror, wtag) \
-	(space)->install_port(start, end, mask, mirror, NULL, wtag)
-#define memory_install_write_bank(space, start, end, mask, mirror, wtag) \
-	(space)->install_bank(start, end, mask, mirror, NULL, wtag)
-#define memory_install_writeonly(space, start, end, mask, mirror, baseptr) \
-	(space)->install_ram(start, end, mask, mirror, ROW_WRITE, baseptr)
-#define memory_unmap_write(space, start, end, mask, mirror) \
-	(space)->unmap(start, end, mask, mirror, ROW_WRITE, false)
-#define memory_nop_write(space, start, end, mask, mirror) \
-	(space)->unmap(start, end, mask, mirror, ROW_WRITE, true)
-
-// wrappers for dynamic read/write handler installation
-#define memory_install_readwrite8_handler(space, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-#define memory_install_readwrite16_handler(space, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-#define memory_install_readwrite32_handler(space, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-#define memory_install_readwrite64_handler(space, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-
-#define memory_install_readwrite8_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-#define memory_install_readwrite16_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-#define memory_install_readwrite32_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-#define memory_install_readwrite64_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
-	(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
-
-#define memory_install_readwrite_port(space, start, end, mask, mirror, rtag, wtag) \
-	(space)->install_port(start, end, mask, mirror, rtag, wtag)
-#define memory_install_readwrite_bank(space, start, end, mask, mirror, tag) \
-	(space)->install_bank(start, end, mask, mirror, tag, tag)
-#define memory_install_ram(space, start, end, mask, mirror, baseptr) \
-	(space)->install_ram(start, end, mask, mirror, ROW_READWRITE, baseptr)
-#define memory_unmap_readwrite(space, start, end, mask, mirror) \
-	(space)->unmap(start, end, mask, mirror, ROW_READWRITE, false)
-#define memory_nop_readwrite(space, start, end, mask, mirror) \
-	(space)->unmap(start, end, mask, mirror, ROW_READWRITE, true)
-
-
 
 //**************************************************************************
 //  GLOBAL VARIABLES

src/emu/sound/okim6295.c

@@ -258,7 +258,7 @@ void okim6295_device::set_bank_base(offs_t base)
 	if (!m_bank_installed && base != 0)
 	{
 		// override our memory map with a bank
-		memory_install_read_bank(space(), 0x00000, 0x3ffff, 0, 0, tag());
+		space()->install_read_bank(0x00000, 0x3ffff, tag());
 		m_bank_installed = true;
 	}
 

src/emu/video/pc_vga.c

@@ -682,17 +682,17 @@ static void vga_cpu_interface(running_machine *machine)
 				sel = vga.gc.data[6] & 0x0c;
 				if (sel)
 				{
-					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler) ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler) ); else space->nop_read(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler) ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler) ); else space->nop_read(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler) ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler) ); else space->nop_read(0xb8000, 0xbffff);
-					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler)); else space->nop_write(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler)); else space->nop_write(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler)); else space->nop_write(0xb8000, 0xbffff);
 				}
 				else
 				{
-					memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
-					memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
 					memory_set_bankptr(machine,"vgabank", vga.memory);
 				}
 				break;
@@ -701,17 +701,17 @@ static void vga_cpu_interface(running_machine *machine)
 				sel = vga.gc.data[6] & 0x0c;
 				if (sel)
 				{
-					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler16) ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler16) ); else space->nop_read(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler16) ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler16) ); else space->nop_read(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler16) ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler16) ); else space->nop_read(0xb8000, 0xbffff);
-					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler16)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler16)); else space->nop_write(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler16)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler16)); else space->nop_write(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler16)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler16)); else space->nop_write(0xb8000, 0xbffff);
 				}
 				else
 				{
-					memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
-					memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
 					memory_set_bankptr(machine,"vgabank", vga.memory);
 				}
 				break;
@@ -720,17 +720,17 @@ static void vga_cpu_interface(running_machine *machine)
 				sel = vga.gc.data[6] & 0x0c;
 				if (sel)
 				{
-					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler32) ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler32) ); else space->nop_read(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler32) ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler32) ); else space->nop_read(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler32) ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler32) ); else space->nop_read(0xb8000, 0xbffff);
-					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler32)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler32)); else space->nop_write(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler32)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler32)); else space->nop_write(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler32)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler32)); else space->nop_write(0xb8000, 0xbffff);
 				}
 				else
 				{
-					memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
-					memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
 					memory_set_bankptr(machine,"vgabank", vga.memory);
 				}
 				break;
@@ -739,17 +739,17 @@ static void vga_cpu_interface(running_machine *machine)
 				sel = vga.gc.data[6] & 0x0c;
 				if (sel)
 				{
-					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler64) ); else memory_nop_read(space,  0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler64) ); else space->nop_read(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler64) ); else memory_nop_read(space,  0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler64) ); else space->nop_read(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler64) ); else memory_nop_read(space,  0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler64) ); else space->nop_read(0xb8000, 0xbffff);
-					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler64)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
+					if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler64)); else space->nop_write(0xa0000, 0xaffff);
-					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler64)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
+					if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler64)); else space->nop_write(0xb0000, 0xb7fff);
-					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler64)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
+					if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler64)); else space->nop_write(0xb8000, 0xbffff);
 				}
 				else
 				{
-					memory_install_read_bank(space,  0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
-					memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
+					space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
 					memory_set_bankptr(machine,"vgabank", vga.memory);
 				}
 				break;

src/mame/audio/atarijsa.c

@@ -147,7 +147,7 @@ void atarijsa_init(running_machine *machine, const char *testport, int testmask)
 
 	/* install POKEY memory handlers */
 	if (pokey != NULL)
-		memory_install_readwrite8_device_handler(jsacpu->memory().space(AS_PROGRAM), pokey, 0x2c00, 0x2c0f, 0, 0, pokey_r, pokey_w);
+		jsacpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*pokey, 0x2c00, 0x2c0f, FUNC(pokey_r), FUNC(pokey_w));
 
 	init_save_state(machine);
 	atarijsa_reset();

src/mame/audio/cage.c

@@ -172,7 +172,7 @@ void cage_init(running_machine *machine, offs_t speedup)
 	timer[1] = machine->device<timer_device>("cage_timer1");
 
 	if (speedup)
-		speedup_ram = memory_install_write32_handler(cage_cpu->memory().space(AS_PROGRAM), speedup, speedup, 0, 0, speedup_w);
+		speedup_ram = cage_cpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(speedup, speedup, FUNC(speedup_w));
 
 	for (chan = 0; chan < DAC_BUFFER_CHANNELS; chan++)
 	{

src/mame/audio/cinemat.c

@@ -1622,7 +1622,7 @@ static WRITE8_HANDLER( qb3_sound_w )
 static MACHINE_RESET( qb3_sound )
 {
 	MACHINE_RESET_CALL(demon_sound);
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x04, 0x04, 0, 0, qb3_sound_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x04, 0x04, FUNC(qb3_sound_w));
 
 	/* this patch prevents the sound ROM from eating itself when command $0A is sent */
 	/* on a cube rotate */

src/mame/audio/dcs.c

@@ -1035,7 +1035,7 @@ void dcs2_init(running_machine *machine, int dram_in_mb, offs_t polling_offset)
 	/* install the speedup handler */
 	dcs.polling_offset = polling_offset;
 	if (polling_offset)
-		dcs_polling_base = memory_install_readwrite16_handler(dcs.cpu->space(AS_DATA), polling_offset, polling_offset, 0, 0, dcs_polling_r, dcs_polling_w);
+		dcs_polling_base = dcs.cpu->space(AS_DATA)->install_legacy_readwrite_handler(polling_offset, polling_offset, FUNC(dcs_polling_r), FUNC(dcs_polling_w));
 
 	/* allocate a watchdog timer for HLE transfers */
 	transfer.hle_enabled = (ENABLE_HLE_TRANSFERS && dram_in_mb != 0);
@@ -1126,31 +1126,31 @@ static void sdrc_remap_memory(running_machine *machine)
 	/* if SRAM disabled, clean it out */
 	if (SDRC_SM_EN == 0)
 	{
-		memory_unmap_readwrite(dcs.program, 0x0800, 0x3fff, 0, 0);
+		dcs.program->unmap_readwrite(0x0800, 0x3fff);
-		memory_unmap_readwrite(dcs.data, 0x0800, 0x37ff, 0, 0);
+		dcs.data->unmap_readwrite(0x0800, 0x37ff);
 	}
 
 	/* otherwise, map the SRAM */
 	else
 	{
 		/* first start with a clean program map */
-		memory_install_ram(dcs.program, 0x0800, 0x3fff, 0, 0, dcs_sram + 0x4800);
+		dcs.program->install_ram(0x0800, 0x3fff, dcs_sram + 0x4800);
 
 		/* set up the data map based on the SRAM banking */
 		/* map 0: ram from 0800-37ff */
 		if (SDRC_SM_BK == 0)
 		{
-			memory_install_ram(dcs.data, 0x0800, 0x17ff, 0, 0, dcs_sram + 0x0000);
+			dcs.data->install_ram(0x0800, 0x17ff, dcs_sram + 0x0000);
-			memory_install_ram(dcs.data, 0x1800, 0x27ff, 0, 0, dcs_sram + 0x1000);
+			dcs.data->install_ram(0x1800, 0x27ff, dcs_sram + 0x1000);
-			memory_install_ram(dcs.data, 0x2800, 0x37ff, 0, 0, dcs_sram + 0x2000);
+			dcs.data->install_ram(0x2800, 0x37ff, dcs_sram + 0x2000);
 		}
 
 		/* map 1: nothing from 0800-17ff, alternate RAM at 1800-27ff, same RAM at 2800-37ff */
 		else
 		{
-			memory_unmap_readwrite(dcs.data, 0x0800, 0x17ff, 0, 0);
+			dcs.data->unmap_readwrite(0x0800, 0x17ff);
-			memory_install_ram(dcs.data, 0x1800, 0x27ff, 0, 0, dcs_sram + 0x3000);
+			dcs.data->install_ram(0x1800, 0x27ff, dcs_sram + 0x3000);
-			memory_install_ram(dcs.data, 0x2800, 0x37ff, 0, 0, dcs_sram + 0x2000);
+			dcs.data->install_ram(0x2800, 0x37ff, dcs_sram + 0x2000);
 		}
 	}
 
@@ -1159,14 +1159,14 @@ static void sdrc_remap_memory(running_machine *machine)
 	{
 		int baseaddr = (SDRC_ROM_ST == 0) ? 0x0000 : (SDRC_ROM_ST == 1) ? 0x3000 : 0x3400;
 		int pagesize = (SDRC_ROM_SZ == 0 && SDRC_ROM_ST != 0) ? 4096 : 1024;
-		memory_install_read_bank(dcs.data, baseaddr, baseaddr + pagesize - 1, 0, 0, "rompage");
+		dcs.data->install_read_bank(baseaddr, baseaddr + pagesize - 1, "rompage");
 	}
 
 	/* map the DRAM page as bank 26 */
 	if (SDRC_DM_ST != 0)
 	{
 		int baseaddr = (SDRC_DM_ST == 1) ? 0x0000 : (SDRC_DM_ST == 2) ? 0x3000 : 0x3400;
-		memory_install_readwrite_bank(dcs.data, baseaddr, baseaddr + 0x3ff, 0, 0, "drampage");
+		dcs.data->install_readwrite_bank(baseaddr, baseaddr + 0x3ff, "drampage");
 	}
 
 	/* update the bank pointers */
@@ -1174,7 +1174,7 @@ static void sdrc_remap_memory(running_machine *machine)
 
 	/* reinstall the polling hotspot */
 	if (dcs.polling_offset)
-		dcs_polling_base = memory_install_readwrite16_handler(dcs.cpu->space(AS_DATA), dcs.polling_offset, dcs.polling_offset, 0, 0, dcs_polling_r, dcs_polling_w);
+		dcs_polling_base = dcs.cpu->space(AS_DATA)->install_legacy_readwrite_handler(dcs.polling_offset, dcs.polling_offset, FUNC(dcs_polling_r), FUNC(dcs_polling_w));
 }
 
 

src/mame/audio/jaguar.c

@@ -262,7 +262,7 @@ void cojag_sound_init(running_machine *machine)
 	}
 
 #if ENABLE_SPEEDUP_HACKS
-	memory_install_write32_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0xf1a100, 0xf1a103, 0, 0, dsp_flags_w);
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xf1a100, 0xf1a103, FUNC(dsp_flags_w));
 #endif
 }
 

src/mame/audio/leland.c

@@ -1511,12 +1511,12 @@ static WRITE16_DEVICE_HANDLER( i80186_internal_port_w )
 			temp = (state->i80186.mem.peripheral & 0xffc0) << 4;
 			if (state->i80186.mem.middle_size & 0x0040)
 			{
-				memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_PROGRAM), device, temp, temp + 0x2ff, 0, 0, peripheral_r, peripheral_w);
+				state->i80186.cpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*device, temp, temp + 0x2ff, FUNC(peripheral_r), FUNC(peripheral_w));
 			}
 			else
 			{
 				temp &= 0xffff;
-				memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_IO), device, temp, temp + 0x2ff, 0, 0, peripheral_r, peripheral_w);
+				state->i80186.cpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*device, temp, temp + 0x2ff, FUNC(peripheral_r), FUNC(peripheral_w));
 			}
 
 			/* we need to do this at a time when the 80186 context is swapped in */
@@ -1582,12 +1582,12 @@ static WRITE16_DEVICE_HANDLER( i80186_internal_port_w )
 			temp = (data & 0x0fff) << 8;
 			if (data & 0x1000)
 			{
-				memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_PROGRAM), device, temp, temp + 0xff, 0, 0, i80186_internal_port_r, i80186_internal_port_w);
+				state->i80186.cpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*device, temp, temp + 0xff, FUNC(i80186_internal_port_r), FUNC(i80186_internal_port_w));
 			}
 			else
 			{
 				temp &= 0xffff;
-				memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_IO), device, temp, temp + 0xff, 0, 0, i80186_internal_port_r, i80186_internal_port_w);
+				state->i80186.cpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*device, temp, temp + 0xff, FUNC(i80186_internal_port_r), FUNC(i80186_internal_port_w));
 			}
 /*          popmessage("Sound CPU reset");*/
 			break;

src/mame/audio/mario.c

@@ -425,7 +425,7 @@ static SOUND_START( mario )
 	if (audiocpu != NULL && audiocpu->type() != Z80)
 	{
 		state->eabank = "bank1";
-		memory_install_read_bank(audiocpu->memory().space(AS_PROGRAM), 0x000, 0x7ff, 0, 0, "bank1");
+		audiocpu->memory().space(AS_PROGRAM)->install_read_bank(0x000, 0x7ff, "bank1");
 		memory_configure_bank(machine, "bank1", 0, 1, machine->region("audiocpu")->base(), 0);
 	    memory_configure_bank(machine, "bank1", 1, 1, machine->region("audiocpu")->base() + 0x1000, 0x800);
 	}

src/mame/audio/namcoc7x.c

@@ -90,7 +90,7 @@ void namcoc7x_on_driver_init(running_machine *machine)
 	// install speedup cheat
 	for (cpu = machine->device("maincpu"); cpu != NULL; cpu = cpu->typenext())
 		if (cpu->type() == M37702)
-			memory_install_readwrite16_handler(cpu->memory().space(AS_PROGRAM), 0x82, 0x83, 0, 0, speedup_r, speedup_w);
+			cpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x82, 0x83, FUNC(speedup_r), FUNC(speedup_w));
 }
 
 void namcoc7x_set_host_ram(UINT32 *hostram)

src/mame/drivers/1943.c

@@ -603,7 +603,7 @@ static DRIVER_INIT( 1943b )
 	DRIVER_INIT_CALL( 1943 );
 	//it expects 0x00 to be returned from the protection reads because the protection has been patched out.
 	//AM_RANGE(0xc007, 0xc007) AM_READ(c1943_protection_r)
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc007, 0xc007, 0, 0, _1943b_c007_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc007, 0xc007, FUNC(_1943b_c007_r));
 
 }
 

src/mame/drivers/39in1.c

@@ -1460,7 +1460,7 @@ static DRIVER_INIT( 39in1 )
 	state->eeprom = machine->device<eeprom_device>("eeprom");
 
 	address_space *space = machine->device<pxa255_device>("maincpu")->space(AS_PROGRAM);
-	memory_install_read32_handler (space, 0xa0151648, 0xa015164b, 0, 0, prot_cheater_r);
+	space->install_legacy_read_handler (0xa0151648, 0xa015164b, FUNC(prot_cheater_r));
 }
 
 static ADDRESS_MAP_START( 39in1_map, AS_PROGRAM, 32 )

src/mame/drivers/actfancr.c

@@ -616,12 +616,12 @@ static READ8_HANDLER( cyclej_r )
 
 static DRIVER_INIT( actfancr )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1f0026, 0x1f0027, 0, 0, cycle_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x1f0026, 0x1f0027, FUNC(cycle_r));
 }
 
 static DRIVER_INIT( actfancrj )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1f0026, 0x1f0027, 0, 0, cyclej_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x1f0026, 0x1f0027, FUNC(cyclej_r));
 }
 
 

src/mame/drivers/airbustr.c

@@ -798,7 +798,7 @@ ROM_END
 
 static DRIVER_INIT( airbustr )
 {
-	memory_install_read8_handler(machine->device("master")->memory().space(AS_PROGRAM), 0xe000, 0xefff, 0, 0, devram_r); // protection device lives here
+	machine->device("master")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xe000, 0xefff, FUNC(devram_r)); // protection device lives here
 }
 
 

src/mame/drivers/alg.c

@@ -229,11 +229,11 @@ static WRITE8_DEVICE_HANDLER( alg_cia_0_porta_w )
 	/* swap the write handlers between ROM and bank 1 based on the bit */
 	if ((data & 1) == 0)
 		/* overlay disabled, map RAM on 0x000000 */
-		memory_install_write_bank(space, 0x000000, 0x07ffff, 0, 0, "bank1");
+		space->install_write_bank(0x000000, 0x07ffff, "bank1");
 
 	else
 		/* overlay enabled, map Amiga system ROM on 0x000000 */
-		memory_unmap_write(space, 0x000000, 0x07ffff, 0, 0);
+		space->unmap_write(0x000000, 0x07ffff);
 }
 
 

src/mame/drivers/alpha68k.c

@@ -3108,7 +3108,7 @@ static DRIVER_INIT( kyros )
 static DRIVER_INIT( jongbou )
 {
 	alpha68k_state *state = machine->driver_data<alpha68k_state>();
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0c0000, 0x0c0001, 0, 0, jongbou_inputs_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0c0000, 0x0c0001, FUNC(jongbou_inputs_r));
 	state->invert_controls = 0;
 	state->microcontroller_id = 0x00ff;
 	state->coin_id = 0x23 | (0x24 << 8);

src/mame/drivers/arcadia.c

@@ -75,9 +75,9 @@ public:
 static WRITE16_HANDLER( arcadia_multibios_change_game )
 {
 	if (data == 0)
-		memory_install_read_bank(space, 0x800000, 0x97ffff, 0, 0, "bank2");
+		space->install_read_bank(0x800000, 0x97ffff, "bank2");
 	else
-		memory_nop_read(space, 0x800000, 0x97ffff, 0, 0);
+		space->nop_read(0x800000, 0x97ffff);
 }
 
 
@@ -105,11 +105,11 @@ static WRITE8_DEVICE_HANDLER( arcadia_cia_0_porta_w )
 	/* swap the write handlers between ROM and bank 1 based on the bit */
 	if ((data & 1) == 0)
 		/* overlay disabled, map RAM on 0x000000 */
-		memory_install_write_bank(device->machine->device("maincpu")->memory().space(AS_PROGRAM), 0x000000, 0x07ffff, 0, 0, "bank1");
+		device->machine->device("maincpu")->memory().space(AS_PROGRAM)->install_write_bank(0x000000, 0x07ffff, "bank1");
 
 	else
 		/* overlay enabled, map Amiga system ROM on 0x000000 */
-		memory_unmap_write(device->machine->device("maincpu")->memory().space(AS_PROGRAM), 0x000000, 0x07ffff, 0, 0);
+		device->machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0x000000, 0x07ffff);
 
 	/* bit 2 = Power Led on Amiga */
 	set_led_status(device->machine, 0, (data & 2) ? 0 : 1);

src/mame/drivers/arkanoid.c

@@ -1446,10 +1446,10 @@ ROM_END
 
 static void arkanoid_bootleg_init( running_machine *machine )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf000, 0xf000, 0, 0, arkanoid_bootleg_f000_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf000, 0xf000, FUNC(arkanoid_bootleg_f000_r) );
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf002, 0xf002, 0, 0, arkanoid_bootleg_f002_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf002, 0xf002, FUNC(arkanoid_bootleg_f002_r) );
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd018, 0xd018, 0, 0, arkanoid_bootleg_d018_w );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xd018, 0xd018, FUNC(arkanoid_bootleg_d018_w) );
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd008, 0xd008, 0, 0, arkanoid_bootleg_d008_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd008, 0xd008, FUNC(arkanoid_bootleg_d008_r) );
 }
 
 static DRIVER_INIT( arkangc )
@@ -1541,7 +1541,7 @@ static DRIVER_INIT( tetrsark )
 		ROM[x] = ROM[x] ^ 0x94;
 	}
 
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd008, 0xd008, 0, 0, tetrsark_d008_w );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xd008, 0xd008, FUNC(tetrsark_d008_w) );
 }
 
 

src/mame/drivers/artmagic.c

@@ -1172,7 +1172,7 @@ static DRIVER_INIT( ultennis )
 	state->protection_handler = ultennis_protection;
 
 	/* additional (protection?) hack */
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x300000, 0x300001, 0, 0, ultennis_hack_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x300000, 0x300001, FUNC(ultennis_hack_r));
 }
 
 

src/mame/drivers/asteroid.c

@@ -921,14 +921,14 @@ ROM_END
 
 static DRIVER_INIT( asteroidb )
 {
-	memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2000, 0x2000, 0, 0, "IN0");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2000, 0x2000, "IN0");
-	memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2003, 0x2003, 0, 0, "HS");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2003, 0x2003, "HS");
 }
 
 
 static DRIVER_INIT( asterock )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2000, 0x2007, 0, 0, asterock_IN0_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x2000, 0x2007, FUNC(asterock_IN0_r));
 }
 
 

src/mame/drivers/astrocde.c

@@ -431,12 +431,12 @@ static WRITE8_HANDLER( profpac_banksw_w )
 	profpac_bank = data;
 
 	/* set the main banking */
-	memory_install_read_bank(space, 0x4000, 0xbfff, 0, 0, "bank1");
+	space->install_read_bank(0x4000, 0xbfff, "bank1");
 	memory_set_bankptr(space->machine, "bank1", space->machine->region("user1")->base() + 0x8000 * bank);
 
 	/* bank 0 reads video RAM in the 4000-7FFF range */
 	if (bank == 0)
-		memory_install_read8_handler(space, 0x4000, 0x7fff, 0, 0, profpac_videoram_r);
+		space->install_legacy_read_handler(0x4000, 0x7fff, FUNC(profpac_videoram_r));
 
 	/* if we have a 640k EPROM board, map that on top of the 4000-7FFF range if specified */
 	if ((data & 0x80) && space->machine->region("user2")->base() != NULL)
@@ -447,11 +447,11 @@ static WRITE8_HANDLER( profpac_banksw_w )
 		/* if the bank is in range, map the appropriate bank */
 		if (bank < 0x28)
 		{
-			memory_install_read_bank(space, 0x4000, 0x7fff, 0, 0, "bank2");
+			space->install_read_bank(0x4000, 0x7fff, "bank2");
 			memory_set_bankptr(space->machine, "bank2", space->machine->region("user2")->base() + 0x4000 * bank);
 		}
 		else
-			memory_unmap_read(space, 0x4000, 0x7fff, 0, 0);
+			space->unmap_read(0x4000, 0x7fff);
 	}
 }
 
@@ -1729,48 +1729,48 @@ ROM_END
 static DRIVER_INIT( seawolf2 )
 {
 	astrocade_video_config = 0x00;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x40, 0x40, 0, 0xff18, seawolf2_sound_1_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x40, 0x40, 0, 0xff18, FUNC(seawolf2_sound_1_w));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x41, 0x41, 0, 0xff18, seawolf2_sound_2_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x41, 0x41, 0, 0xff18, FUNC(seawolf2_sound_2_w));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x42, 0x43, 0, 0xff18, seawolf2_lamps_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x42, 0x43, 0, 0xff18, FUNC(seawolf2_lamps_w));
 }
 
 
 static DRIVER_INIT( ebases )
 {
 	astrocade_video_config = AC_SOUND_PRESENT;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x20, 0x20, 0, 0xff07, ebases_coin_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x20, 0x20, 0, 0xff07, FUNC(ebases_coin_w));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x28, 0x28, 0, 0xff07, ebases_trackball_select_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x28, 0x28, 0, 0xff07, FUNC(ebases_trackball_select_w));
 }
 
 
 static DRIVER_INIT( spacezap )
 {
 	astrocade_video_config = AC_SOUND_PRESENT | AC_MONITOR_BW;
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x13, 0x13, 0x03ff, 0xff00, spacezap_io_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x13, 0x13, 0x03ff, 0xff00, FUNC(spacezap_io_r));
 }
 
 
 static DRIVER_INIT( wow )
 {
 	astrocade_video_config = AC_SOUND_PRESENT | AC_LIGHTPEN_INTS | AC_STARS;
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x15, 0x15, 0x0fff, 0xff00, wow_io_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x15, 0x15, 0x0fff, 0xff00, FUNC(wow_io_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x17, 0x17, 0xffff, 0xff00, wow_speech_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x17, 0x17, 0xffff, 0xff00, FUNC(wow_speech_r));
 }
 
 
 static DRIVER_INIT( gorf )
 {
 	astrocade_video_config = AC_SOUND_PRESENT | AC_LIGHTPEN_INTS | AC_STARS;
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x15, 0x15, 0x0fff, 0xff00, gorf_io_1_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x15, 0x15, 0x0fff, 0xff00, FUNC(gorf_io_1_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x16, 0x16, 0x0fff, 0xff00, gorf_io_2_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x16, 0x16, 0x0fff, 0xff00, FUNC(gorf_io_2_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x17, 0x17, 0xffff, 0xff00, gorf_speech_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x17, 0x17, 0xffff, 0xff00, FUNC(gorf_speech_r));
 }
 
 
 static DRIVER_INIT( robby )
 {
 	astrocade_video_config = AC_SOUND_PRESENT;
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x15, 0x15, 0x0fff, 0xff00, robby_io_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x15, 0x15, 0x0fff, 0xff00, FUNC(robby_io_r));
 }
 
 
@@ -1779,8 +1779,8 @@ static DRIVER_INIT( profpac )
 	address_space *iospace = machine->device("maincpu")->memory().space(AS_IO);
 
 	astrocade_video_config = AC_SOUND_PRESENT;
-	memory_install_read8_handler(iospace, 0x14, 0x14, 0x0fff, 0xff00, profpac_io_1_r);
+	iospace->install_legacy_read_handler(0x14, 0x14, 0x0fff, 0xff00, FUNC(profpac_io_1_r));
-	memory_install_read8_handler(iospace, 0x15, 0x15, 0x77ff, 0xff00, profpac_io_2_r);
+	iospace->install_legacy_read_handler(0x15, 0x15, 0x77ff, 0xff00, FUNC(profpac_io_2_r));
 
 	/* reset banking */
 	profpac_banksw_w(iospace, 0, 0);
@@ -1793,10 +1793,10 @@ static DRIVER_INIT( demndrgn )
 	address_space *iospace = machine->device("maincpu")->memory().space(AS_IO);
 
 	astrocade_video_config = 0x00;
-	memory_install_read8_handler(iospace, 0x14, 0x14, 0x1fff, 0xff00, demndrgn_io_r);
+	iospace->install_legacy_read_handler(0x14, 0x14, 0x1fff, 0xff00, FUNC(demndrgn_io_r));
-	memory_install_read_port(iospace, 0x1c, 0x1c, 0x0000, 0xff00, "FIREX");
+	iospace->install_read_port(0x1c, 0x1c, 0x0000, 0xff00, "FIREX");
-	memory_install_read_port(iospace, 0x1d, 0x1d, 0x0000, 0xff00, "FIREY");
+	iospace->install_read_port(0x1d, 0x1d, 0x0000, 0xff00, "FIREY");
-	memory_install_write8_handler(iospace, 0x97, 0x97, 0x0000, 0xff00, demndrgn_sound_w);
+	iospace->install_legacy_write_handler(0x97, 0x97, 0x0000, 0xff00, FUNC(demndrgn_sound_w));
 
 	/* reset banking */
 	profpac_banksw_w(iospace, 0, 0);
@@ -1809,15 +1809,15 @@ static DRIVER_INIT( tenpindx )
 	address_space *iospace = machine->device("maincpu")->memory().space(AS_IO);
 
 	astrocade_video_config = 0x00;
-	memory_install_read_port(iospace, 0x60, 0x60, 0x0000, 0xff00, "P60");
+	iospace->install_read_port(0x60, 0x60, 0x0000, 0xff00, "P60");
-	memory_install_read_port(iospace, 0x61, 0x61, 0x0000, 0xff00, "P61");
+	iospace->install_read_port(0x61, 0x61, 0x0000, 0xff00, "P61");
-	memory_install_read_port(iospace, 0x62, 0x62, 0x0000, 0xff00, "P62");
+	iospace->install_read_port(0x62, 0x62, 0x0000, 0xff00, "P62");
-	memory_install_read_port(iospace, 0x63, 0x63, 0x0000, 0xff00, "P63");
+	iospace->install_read_port(0x63, 0x63, 0x0000, 0xff00, "P63");
-	memory_install_read_port(iospace, 0x64, 0x64, 0x0000, 0xff00, "P64");
+	iospace->install_read_port(0x64, 0x64, 0x0000, 0xff00, "P64");
-	memory_install_write8_handler(iospace, 0x65, 0x66, 0x0000, 0xff00, tenpindx_lamp_w);
+	iospace->install_legacy_write_handler(0x65, 0x66, 0x0000, 0xff00, FUNC(tenpindx_lamp_w));
-	memory_install_write8_handler(iospace, 0x67, 0x67, 0x0000, 0xff00, tenpindx_counter_w);
+	iospace->install_legacy_write_handler(0x67, 0x67, 0x0000, 0xff00, FUNC(tenpindx_counter_w));
-	memory_install_write8_handler(iospace, 0x68, 0x68, 0x0000, 0xff00, tenpindx_lights_w);
+	iospace->install_legacy_write_handler(0x68, 0x68, 0x0000, 0xff00, FUNC(tenpindx_lights_w));
-	memory_install_write8_handler(iospace, 0x97, 0x97, 0x0000, 0xff00, tenpindx_sound_w);
+	iospace->install_legacy_write_handler(0x97, 0x97, 0x0000, 0xff00, FUNC(tenpindx_sound_w));
 
 	/* reset banking */
 	profpac_banksw_w(iospace, 0, 0);

src/mame/drivers/astrof.c

@@ -1308,8 +1308,8 @@ static DRIVER_INIT( abattle )
 		rom[i] = prom[rom[i]];
 
 	/* set up protection handlers */
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0, shoot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa003, 0xa003, FUNC(shoot_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa004, 0xa004, 0, 0, abattle_coin_prot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa004, 0xa004, FUNC(abattle_coin_prot_r));
 }
 
 
@@ -1322,8 +1322,8 @@ static DRIVER_INIT( afire )
 		rom[i] = ~rom[i];
 
 	/* set up protection handlers */
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0, shoot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa003, 0xa003, FUNC(shoot_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa004, 0xa004, 0, 0, afire_coin_prot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa004, 0xa004, FUNC(afire_coin_prot_r));
 }
 
 
@@ -1336,8 +1336,8 @@ static DRIVER_INIT( sstarbtl )
 		rom[i] = ~rom[i];
 
 	/* set up protection handlers */
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0, shoot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa003, 0xa003, FUNC(shoot_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa004, 0xa004, 0, 0, abattle_coin_prot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa004, 0xa004, FUNC(abattle_coin_prot_r));
 }
 
 

src/mame/drivers/atarig1.c

@@ -192,7 +192,7 @@ static void pitfightb_cheap_slapstic_init(running_machine *machine)
 	atarig1_state *state = machine->driver_data<atarig1_state>();
 
 	/* install a read handler */
-	state->bslapstic_base = memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x038000, 0x03ffff, 0, 0, pitfightb_cheap_slapstic_r);
+	state->bslapstic_base = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x038000, 0x03ffff, FUNC(pitfightb_cheap_slapstic_r));
 
 	/* allocate memory for a copy of bank 0 */
 	state->bslapstic_bank0 = auto_alloc_array(machine, UINT8, 0x2000);

src/mame/drivers/atarig42.c

@@ -801,7 +801,7 @@ static DRIVER_INIT( roadriot )
 	state->playfield_base = 0x400;
 
 	address_space *main = machine->device<m68000_device>("maincpu")->space(AS_PROGRAM);
-	state->sloop_base = memory_install_readwrite16_handler(main, 0x000000, 0x07ffff, 0, 0, roadriot_sloop_data_r, roadriot_sloop_data_w);
+	state->sloop_base = main->install_legacy_readwrite_handler(0x000000, 0x07ffff, FUNC(roadriot_sloop_data_r), FUNC(roadriot_sloop_data_w));
 	main->set_direct_update_handler(direct_update_delegate_create_static(atarig42_sloop_direct_handler, *machine));
 
 	asic65_config(machine, ASIC65_ROMBASED);
@@ -840,7 +840,7 @@ static DRIVER_INIT( guardian )
 	*(UINT16 *)&machine->region("maincpu")->base()[0x80000] = 0x4E75;
 
 	address_space *main = machine->device<m68000_device>("maincpu")->space(AS_PROGRAM);
-	state->sloop_base = memory_install_readwrite16_handler(main, 0x000000, 0x07ffff, 0, 0, guardians_sloop_data_r, guardians_sloop_data_w);
+	state->sloop_base = main->install_legacy_readwrite_handler(0x000000, 0x07ffff, FUNC(guardians_sloop_data_r), FUNC(guardians_sloop_data_w));
 	main->set_direct_update_handler(direct_update_delegate_create_static(atarig42_sloop_direct_handler, *machine));
 
 	asic65_config(machine, ASIC65_GUARDIANS);

src/mame/drivers/atarigt.c

@@ -1282,7 +1282,7 @@ static DRIVER_INIT( tmek )
 	state->protection_w = tmek_protection_w;
 
 	/* temp hack */
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd72000, 0xd75fff, 0, 0, tmek_pf_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xd72000, 0xd75fff, FUNC(tmek_pf_w));
 }
 
 

src/mame/drivers/atarigx2.c

@@ -2246,7 +2246,7 @@ static DRIVER_INIT( rrreveng )
 
 	state->playfield_base = 0x000;
 
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xca0fc0, 0xca0fc3, 0, 0, rrreveng_prot_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xca0fc0, 0xca0fc3, FUNC(rrreveng_prot_r));
 }
 
 

src/mame/drivers/ataxx.c

@@ -711,7 +711,7 @@ static DRIVER_INIT( ataxx )
 	leland_rotate_memory(machine, "slave");
 
 	/* set up additional input ports */
-	memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x00, 0x03, 0, 0, ataxx_trackball_r);
+	machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x03, FUNC(ataxx_trackball_r));
 }
 
 
@@ -721,7 +721,7 @@ static DRIVER_INIT( ataxxj )
 	leland_rotate_memory(machine, "slave");
 
 	/* set up additional input ports */
-	memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x00, 0x03, 0, 0, ataxx_trackball_r);
+	machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x03, FUNC(ataxx_trackball_r));
 }
 
 
@@ -731,9 +731,9 @@ static DRIVER_INIT( wsf )
 	leland_rotate_memory(machine, "slave");
 
 	/* set up additional input ports */
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P1_P2");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P1_P2");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P3_P4");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P3_P4");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "BUTTONS");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "BUTTONS");
 }
 
 
@@ -743,14 +743,14 @@ static DRIVER_INIT( indyheat )
 	leland_rotate_memory(machine, "slave");
 
 	/* set up additional input ports */
-	memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x00, 0x02, 0, 0, indyheat_wheel_r);
+	machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x02, FUNC(indyheat_wheel_r));
-	memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x08, 0x0b, 0, 0, indyheat_analog_r);
+	machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x08, 0x0b, FUNC(indyheat_analog_r));
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P1");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P1");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P2");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P2");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "P3");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "P3");
 
 	/* set up additional output ports */
-	memory_install_write8_handler(machine->device("master")->memory().space(AS_IO), 0x08, 0x0b, 0, 0, indyheat_analog_w);
+	machine->device("master")->memory().space(AS_IO)->install_legacy_write_handler(0x08, 0x0b, FUNC(indyheat_analog_w));
 }
 
 
@@ -760,9 +760,9 @@ static DRIVER_INIT( brutforc )
 	leland_rotate_memory(machine, "slave");
 
 	/* set up additional input ports */
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P2");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P2");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P1");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P1");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "P3");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "P3");
 }
 
 
@@ -772,12 +772,12 @@ static DRIVER_INIT( asylum )
 	leland_rotate_memory(machine, "slave");
 
 	/* asylum appears to have some extra RAM for the slave CPU */
-	memory_install_ram(machine->device("slave")->memory().space(AS_PROGRAM), 0xf000, 0xfffb, 0, 0, NULL);
+	machine->device("slave")->memory().space(AS_PROGRAM)->install_ram(0xf000, 0xfffb);
 
 	/* set up additional input ports */
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P2");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P2");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P1");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P1");
-	memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "P3");
+	machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "P3");
 }
 
 

src/mame/drivers/backfire.c

@@ -685,7 +685,7 @@ static DRIVER_INIT( backfire )
 	deco156_decrypt(machine);
 	machine->device("maincpu")->set_clock_scale(4.0f); /* core timings aren't accurate */
 	descramble_sound(machine);
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0170018, 0x017001b, 0, 0, backfire_speedup_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0170018, 0x017001b, FUNC(backfire_speedup_r) );
 }
 
 GAME( 1995, backfire,  0,        backfire,   backfire, backfire, ROT0, "Data East Corporation", "Backfire! (set 1)", GAME_SUPPORTS_SAVE )

src/mame/drivers/bagman.c

@@ -934,7 +934,7 @@ static DRIVER_INIT( bagman )
 
 	/* Unmap video enable register, not available on earlier hardware revision(s)
        Bagman is supposed to have glitches during screen transitions */
-	memory_unmap_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0xa003, 0xa003);
 	*state->video_enable = 1;
 }
 

src/mame/drivers/balsente.c

@@ -2135,47 +2135,47 @@ static DRIVER_INIT( toggle )   { expand_roms(machine, EXPAND_ALL);  config_shoot
 static DRIVER_INIT( nametune )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
+	space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
 	expand_roms(machine, EXPAND_NONE | SWAP_HALVES); config_shooter_adc(machine, FALSE, 0 /* noanalog */);
 }
 static DRIVER_INIT( nstocker )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
+	space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
 	expand_roms(machine, EXPAND_NONE | SWAP_HALVES); config_shooter_adc(machine, TRUE, 1);
 }
 static DRIVER_INIT( sfootbal )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
+	space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
 	expand_roms(machine, EXPAND_ALL  | SWAP_HALVES); config_shooter_adc(machine, FALSE, 0);
 }
 static DRIVER_INIT( spiker )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_readwrite8_handler(space, 0x9f80, 0x9f8f, 0, 0, spiker_expand_r, spiker_expand_w);
+	space->install_legacy_readwrite_handler(0x9f80, 0x9f8f, FUNC(spiker_expand_r), FUNC(spiker_expand_w));
-	memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
+	space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
 	expand_roms(machine, EXPAND_ALL  | SWAP_HALVES); config_shooter_adc(machine, FALSE, 1);
 }
 static DRIVER_INIT( stompin )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
+	space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
 	expand_roms(machine, 0x0c | SWAP_HALVES); config_shooter_adc(machine, FALSE, 32);
 }
 static DRIVER_INIT( rescraid ) { expand_roms(machine, EXPAND_NONE); config_shooter_adc(machine, FALSE, 0 /* noanalog */); }
 static DRIVER_INIT( grudge )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_read8_handler(space, 0x9400, 0x9400, 0, 0, grudge_steering_r);
+	space->install_legacy_read_handler(0x9400, 0x9400, FUNC(grudge_steering_r));
 	expand_roms(machine, EXPAND_NONE); config_shooter_adc(machine, FALSE, 0);
 }
 static DRIVER_INIT( shrike )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_readwrite8_handler(space, 0x9e00, 0x9fff, 0, 0, shrike_shared_6809_r, shrike_shared_6809_w);
+	space->install_legacy_readwrite_handler(0x9e00, 0x9fff, FUNC(shrike_shared_6809_r), FUNC(shrike_shared_6809_w));
-	memory_install_write8_handler(space, 0x9e01, 0x9e01, 0, 0, shrike_sprite_select_w );
+	space->install_legacy_write_handler(0x9e01, 0x9e01, FUNC(shrike_sprite_select_w) );
-	memory_install_readwrite16_handler(machine->device("68k")->memory().space(AS_PROGRAM), 0x10000, 0x1001f, 0, 0, shrike_io_68k_r, shrike_io_68k_w);
+	machine->device("68k")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x10000, 0x1001f, FUNC(shrike_io_68k_r), FUNC(shrike_io_68k_w));
 
 	expand_roms(machine, EXPAND_ALL);  config_shooter_adc(machine, FALSE, 32);
 }

src/mame/drivers/berzerk.c

@@ -1210,8 +1210,8 @@ ROM_END
 static DRIVER_INIT( moonwarp )
 {
 	address_space *io = machine->device("maincpu")->memory().space(AS_IO);
-	memory_install_read8_handler (io, 0x48, 0x48, 0, 0, moonwarp_p1_r);
+	io->install_legacy_read_handler (0x48, 0x48, FUNC(moonwarp_p1_r));
-	memory_install_read8_handler (io, 0x4a, 0x4a, 0, 0, moonwarp_p2_r);
+	io->install_legacy_read_handler (0x4a, 0x4a, FUNC(moonwarp_p2_r));
 }
 
 /*************************************

src/mame/drivers/btime.c

@@ -2176,7 +2176,7 @@ static DRIVER_INIT( cookrace )
 	btime_state *state = machine->driver_data<btime_state>();
 	decrypt_C10707_cpu(machine, "maincpu");
 
-	memory_install_read_bank(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0200, 0x0fff, 0, 0, "bank10");
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0200, 0x0fff, "bank10");
 	memory_set_bankptr(machine, "bank10", machine->region("audiocpu")->base() + 0xe200);
 	state->audio_nmi_enable_type = AUDIO_ENABLE_DIRECT;
 }
@@ -2193,9 +2193,9 @@ static DRIVER_INIT( wtennis )
 	btime_state *state = machine->driver_data<btime_state>();
 	decrypt_C10707_cpu(machine, "maincpu");
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc15f, 0xc15f, 0, 0, wtennis_reset_hack_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc15f, 0xc15f, FUNC(wtennis_reset_hack_r));
 
-	memory_install_read_bank(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0200, 0x0fff, 0, 0, "bank10");
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0200, 0x0fff, "bank10");
 	memory_set_bankptr(machine, "bank10", machine->region("audiocpu")->base() + 0xe200);
 	state->audio_nmi_enable_type = AUDIO_ENABLE_AY8910;
 }

src/mame/drivers/bublbobl.c

@@ -1555,7 +1555,7 @@ static DRIVER_INIT( tokiob )
 {
 	DRIVER_INIT_CALL(tokio);
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe00, 0xfe00, 0, 0, tokiob_mcu_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfe00, 0xfe00, FUNC(tokiob_mcu_r) );
 }
 
 static DRIVER_INIT( dland )

src/mame/drivers/bzone.c

@@ -798,11 +798,11 @@ static WRITE8_HANDLER( analog_select_w )
 static DRIVER_INIT( bradley )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-	memory_install_ram(space, 0x400, 0x7ff, 0, 0, NULL);
+	space->install_ram(0x400, 0x7ff);
-	memory_install_read_port(space, 0x1808, 0x1808, 0, 0, "1808");
+	space->install_read_port(0x1808, 0x1808, "1808");
-	memory_install_read_port(space, 0x1809, 0x1809, 0, 0, "1809");
+	space->install_read_port(0x1809, 0x1809, "1809");
-	memory_install_read8_handler(space, 0x180a, 0x180a, 0, 0, analog_data_r);
+	space->install_legacy_read_handler(0x180a, 0x180a, FUNC(analog_data_r));
-	memory_install_write8_handler(space, 0x1848, 0x1850, 0, 0, analog_select_w);
+	space->install_legacy_write_handler(0x1848, 0x1850, FUNC(analog_select_w));
 }
 
 

src/mame/drivers/cd32.c

@@ -60,10 +60,10 @@ static WRITE32_HANDLER( aga_overlay_w )
 		/* swap the write handlers between ROM and bank 1 based on the bit */
 		if ((data & 1) == 0)
 			/* overlay disabled, map RAM on 0x000000 */
-			memory_install_write_bank(space, 0x000000, 0x1fffff, 0, 0, "bank1");
+			space->install_write_bank(0x000000, 0x1fffff, "bank1");
 		else
 			/* overlay enabled, map Amiga system ROM on 0x000000 */
-			memory_unmap_write(space, 0x000000, 0x1fffff, 0, 0);
+			space->unmap_write(0x000000, 0x1fffff);
 	}
 }
 

src/mame/drivers/centiped.c

@@ -1987,8 +1987,8 @@ static DRIVER_INIT( caterplr )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
 	device_t *device = machine->device("pokey");
-	memory_install_readwrite8_device_handler(space, device, 0x1000, 0x100f, 0, 0, caterplr_AY8910_r, caterplr_AY8910_w);
+	space->install_legacy_readwrite_handler(*device, 0x1000, 0x100f, FUNC(caterplr_AY8910_r), FUNC(caterplr_AY8910_w));
-	memory_install_read8_device_handler(space, device, 0x1780, 0x1780, 0, 0, caterplr_rand_r);
+	space->install_legacy_read_handler(*device, 0x1780, 0x1780, FUNC(caterplr_rand_r));
 }
 
 
@@ -1996,8 +1996,8 @@ static DRIVER_INIT( magworm )
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
 	device_t *device = machine->device("pokey");
-	memory_install_write8_device_handler(space, device, 0x1001, 0x1001, 0, 0, ay8910_address_w);
+	space->install_legacy_write_handler(*device, 0x1001, 0x1001, FUNC(ay8910_address_w));
-	memory_install_readwrite8_device_handler(space, device, 0x1003, 0x1003, 0, 0, ay8910_r, ay8910_data_w);
+	space->install_legacy_readwrite_handler(*device, 0x1003, 0x1003, FUNC(ay8910_r), FUNC(ay8910_data_w));
 }
 
 

src/mame/drivers/cham24.c

@@ -304,7 +304,7 @@ static MACHINE_START( cham24 )
 	memcpy(&dst[0xc000], &src[0x0f8000], 0x4000);
 
 	/* uses 8K swapping, all ROM!*/
-	memory_install_read_bank(machine->device("ppu")->memory().space(AS_PROGRAM), 0x0000, 0x1fff, 0, 0, "bank1");
+	machine->device("ppu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x1fff, "bank1");
 	memory_set_bankptr(machine, "bank1", machine->region("gfx1")->base());
 
 	/* need nametable ram, though. I doubt this uses more than 2k, but it starts up configured for 4 */
@@ -315,7 +315,7 @@ static MACHINE_START( cham24 )
 	state->nt_page[3] = state->nt_ram + 0xc00;
 
 	/* and read/write handlers */
-	memory_install_readwrite8_handler(machine->device("ppu")->memory().space(AS_PROGRAM), 0x2000, 0x3eff, 0, 0, nt_r, nt_w);
+	machine->device("ppu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x2000, 0x3eff, FUNC(nt_r), FUNC(nt_w));
 }
 
 static DRIVER_INIT( cham24 )

src/mame/drivers/chqflag.c

@@ -55,19 +55,19 @@ static WRITE8_HANDLER( chqflag_bankswitch_w )
 	/* bit 5 = memory bank select */
 	if (data & 0x20)
 	{
-		memory_install_read_bank(space, 0x1800, 0x1fff, 0, 0, "bank5");
+		space->install_read_bank(0x1800, 0x1fff, "bank5");
-		memory_install_write8_handler(space, 0x1800, 0x1fff, 0, 0, paletteram_xBBBBBGGGGGRRRRR_be_w);
+		space->install_legacy_write_handler(0x1800, 0x1fff, FUNC(paletteram_xBBBBBGGGGGRRRRR_be_w));
 		memory_set_bankptr(space->machine, "bank5", space->machine->generic.paletteram.v);
 
 		if (state->k051316_readroms)
-			memory_install_readwrite8_device_handler(space, state->k051316_1, 0x1000, 0x17ff, 0, 0, k051316_rom_r, k051316_w);	/* 051316 #1 (ROM test) */
+			space->install_legacy_readwrite_handler(*state->k051316_1, 0x1000, 0x17ff, FUNC(k051316_rom_r), FUNC(k051316_w));	/* 051316 #1 (ROM test) */
 		else
-			memory_install_readwrite8_device_handler(space, state->k051316_1, 0x1000, 0x17ff, 0, 0, k051316_r, k051316_w);		/* 051316 #1 */
+			space->install_legacy_readwrite_handler(*state->k051316_1, 0x1000, 0x17ff, FUNC(k051316_r), FUNC(k051316_w));		/* 051316 #1 */
 	}
 	else
 	{
-		memory_install_readwrite_bank(space, 0x1000, 0x17ff, 0, 0, "bank1");				/* RAM */
+		space->install_readwrite_bank(0x1000, 0x17ff, "bank1");				/* RAM */
-		memory_install_readwrite_bank(space, 0x1800, 0x1fff, 0, 0, "bank2");				/* RAM */
+		space->install_readwrite_bank(0x1800, 0x1fff, "bank2");				/* RAM */
 	}
 
 	/* other bits unknown/unused */
@@ -85,9 +85,9 @@ static WRITE8_HANDLER( chqflag_vreg_w )
 	state->k051316_readroms = (data & 0x10);
 
 	if (state->k051316_readroms)
-		memory_install_read8_device_handler(space, state->k051316_2, 0x2800, 0x2fff, 0, 0, k051316_rom_r);	/* 051316 (ROM test) */
+		space->install_legacy_read_handler(*state->k051316_2, 0x2800, 0x2fff, FUNC(k051316_rom_r));	/* 051316 (ROM test) */
 	else
-		memory_install_read8_device_handler(space, state->k051316_2, 0x2800, 0x2fff, 0, 0, k051316_r);		/* 051316 */
+		space->install_legacy_read_handler(*state->k051316_2, 0x2800, 0x2fff, FUNC(k051316_r));		/* 051316 */
 
 	/* Bits 3-7 probably control palette dimming in a similar way to TMNT2/Sunset Riders, */
 	/* however I don't have enough evidence to determine the exact behaviour. */

src/mame/drivers/cinemat.c

@@ -1460,35 +1460,35 @@ static DRIVER_INIT( speedfrk )
 {
 	cinemat_state *state = machine->driver_data<cinemat_state>();
 	state->gear = 0xe;
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x00, 0x03, 0, 0, speedfrk_wheel_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x03, FUNC(speedfrk_wheel_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x04, 0x06, 0, 0, speedfrk_gear_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x04, 0x06, FUNC(speedfrk_gear_r));
 }
 
 
 static DRIVER_INIT( sundance )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x00, 0x0f, 0, 0, sundance_inputs_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x0f, FUNC(sundance_inputs_r));
 }
 
 
 static DRIVER_INIT( tailg )
 {
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x07, 0x07, 0, 0, mux_select_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x07, 0x07, FUNC(mux_select_w));
 }
 
 
 static DRIVER_INIT( boxingb )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0c, 0x0f, 0, 0, boxingb_dial_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0c, 0x0f, FUNC(boxingb_dial_r));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x07, 0x07, 0, 0, mux_select_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x07, 0x07, FUNC(mux_select_w));
 }
 
 
 static DRIVER_INIT( qb3 )
 {
 	cinemat_state *state = machine->driver_data<cinemat_state>();
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, qb3_frame_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0f, 0x0f, FUNC(qb3_frame_r));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x00, 0x00, 0, 0, qb3_ram_bank_w);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x00, 0x00, FUNC(qb3_ram_bank_w));
 
 	memory_configure_bank(machine, "bank1", 0, 4, state->rambase, 0x100*2);
 }

src/mame/drivers/cischeat.c

@@ -2554,7 +2554,7 @@ ROM_END
 
 static DRIVER_INIT( wildplt )
 {
-	memory_install_read16_handler(machine->device("cpu1")->memory().space(AS_PROGRAM), 0x080000, 0x087fff, 0, 0, wildplt_vregs_r );
+	machine->device("cpu1")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x080000, 0x087fff, FUNC(wildplt_vregs_r) );
 
 	DRIVER_INIT_CALL(f1gpstar);
 }

src/mame/drivers/cninja.c

@@ -2032,13 +2032,13 @@ static void cninja_patch( running_machine *machine )
 
 static DRIVER_INIT( cninja )
 {
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1bc0a8, 0x1bc0a9, 0, 0, cninja_sound_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1bc0a8, 0x1bc0a9, FUNC(cninja_sound_w));
 	cninja_patch(machine);
 }
 
 static DRIVER_INIT( stoneage )
 {
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1bc0a8, 0x1bc0a9, 0, 0, stoneage_sound_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1bc0a8, 0x1bc0a9, FUNC(stoneage_sound_w));
 }
 
 static DRIVER_INIT( mutantf )

src/mame/drivers/cojag.c

@@ -1536,10 +1536,10 @@ static void cojag_common_init(running_machine *machine, UINT16 gpu_jump_offs, UI
 
 	/* install synchronization hooks for GPU */
 	if (cojag_is_r3000)
-		memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x04f0b000 + gpu_jump_offs, 0x04f0b003 + gpu_jump_offs, 0, 0, gpu_jump_w);
+		machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x04f0b000 + gpu_jump_offs, 0x04f0b003 + gpu_jump_offs, FUNC(gpu_jump_w));
 	else
-		memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf0b000 + gpu_jump_offs, 0xf0b003 + gpu_jump_offs, 0, 0, gpu_jump_w);
+		machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xf0b000 + gpu_jump_offs, 0xf0b003 + gpu_jump_offs, FUNC(gpu_jump_w));
-	memory_install_read32_handler(machine->device("gpu")->memory().space(AS_PROGRAM), 0xf03000 + gpu_jump_offs, 0xf03003 + gpu_jump_offs, 0, 0, gpu_jump_r);
+	machine->device("gpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf03000 + gpu_jump_offs, 0xf03003 + gpu_jump_offs, FUNC(gpu_jump_r));
 	state->gpu_jump_address = &jaguar_gpu_ram[gpu_jump_offs/4];
 	state->gpu_spin_pc = 0xf03000 + spin_pc;
 
@@ -1555,7 +1555,7 @@ static DRIVER_INIT( area51a )
 
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
-	state->main_speedup = memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa02030, 0xa02033, 0, 0, area51_main_speedup_w);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xa02030, 0xa02033, FUNC(area51_main_speedup_w));
 #endif
 }
 
@@ -1568,7 +1568,7 @@ static DRIVER_INIT( area51 )
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
 	state->main_speedup_max_cycles = 120;
-	state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x100062e8, 0x100062eb, 0, 0, cojagr3k_main_speedup_r);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x100062e8, 0x100062eb, FUNC(cojagr3k_main_speedup_r));
 #endif
 }
 
@@ -1583,7 +1583,7 @@ static DRIVER_INIT( maxforce )
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
 	state->main_speedup_max_cycles = 120;
-	state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1000865c, 0x1000865f, 0, 0, cojagr3k_main_speedup_r);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x1000865c, 0x1000865f, FUNC(cojagr3k_main_speedup_r));
 #endif
 }
 
@@ -1598,7 +1598,7 @@ static DRIVER_INIT( area51mx )
 
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
-	state->main_speedup = memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa19550, 0xa19557, 0, 0, area51mx_main_speedup_w);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xa19550, 0xa19557, FUNC(area51mx_main_speedup_w));
 #endif
 }
 
@@ -1614,7 +1614,7 @@ static DRIVER_INIT( a51mxr3k )
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
 	state->main_speedup_max_cycles = 120;
-	state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10006f0c, 0x10006f0f, 0, 0, cojagr3k_main_speedup_r);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10006f0c, 0x10006f0f, FUNC(cojagr3k_main_speedup_r));
 #endif
 }
 
@@ -1627,7 +1627,7 @@ static DRIVER_INIT( fishfren )
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
 	state->main_speedup_max_cycles = 200;
-	state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10021b60, 0x10021b63, 0, 0, cojagr3k_main_speedup_r);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10021b60, 0x10021b63, FUNC(cojagr3k_main_speedup_r));
 #endif
 }
 
@@ -1641,8 +1641,8 @@ static void init_freeze_common(running_machine *machine, offs_t main_speedup_add
 	/* install speedup for main CPU */
 	state->main_speedup_max_cycles = 200;
 	if (main_speedup_addr != 0)
-		state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), main_speedup_addr, main_speedup_addr + 3, 0, 0, cojagr3k_main_speedup_r);
+		state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(main_speedup_addr, main_speedup_addr + 3, FUNC(cojagr3k_main_speedup_r));
-	state->main_gpu_wait = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0400d900, 0x0400d900 + 3, 0, 0, main_gpu_wait_r);
+	state->main_gpu_wait = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0400d900, 0x0400d900 + 3, FUNC(main_gpu_wait_r));
 #endif
 }
 
@@ -1662,7 +1662,7 @@ static DRIVER_INIT( vcircle )
 #if ENABLE_SPEEDUP_HACKS
 	/* install speedup for main CPU */
 	state->main_speedup_max_cycles = 50;
-	state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x12005b34, 0x12005b37, 0, 0, cojagr3k_main_speedup_r);
+	state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x12005b34, 0x12005b37, FUNC(cojagr3k_main_speedup_r));
 #endif
 }
 

src/mame/drivers/combatsc.c

@@ -251,13 +251,13 @@ static WRITE8_HANDLER( combatscb_bankselect_w )
 		if (data == 0x1f)
 		{
 			memory_set_bank(space->machine, "bank1", 8 + (data & 1));
-			memory_install_write8_handler(space, 0x4000, 0x7fff, 0, 0, combatscb_io_w);
+			space->install_legacy_write_handler(0x4000, 0x7fff, FUNC(combatscb_io_w));
-			memory_install_read8_handler(space, 0x4400, 0x4403, 0, 0, combatscb_io_r);/* IO RAM & Video Registers */
+			space->install_legacy_read_handler(0x4400, 0x4403, FUNC(combatscb_io_r));/* IO RAM & Video Registers */
 		}
 		else
 		{
-			memory_install_read_bank(space, 0x4000, 0x7fff, 0, 0, "bank1");	/* banked ROM */
+			space->install_read_bank(0x4000, 0x7fff, "bank1");	/* banked ROM */
-			memory_unmap_write(space, 0x4000, 0x7fff, 0, 0);	/* banked ROM */
+			space->unmap_write(0x4000, 0x7fff);	/* banked ROM */
 		}
 	}
 }
@@ -995,7 +995,7 @@ ROM_END
 static DRIVER_INIT( combatsc )
 {
 	/* joystick instead of trackball */
-	memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0404, 0x0404, 0, 0, "IN1");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x0404, 0x0404, "IN1");
 }
 
 

src/mame/drivers/coolpool.c

@@ -1200,7 +1200,7 @@ static DRIVER_INIT( amerdart )
 
 static DRIVER_INIT( coolpool )
 {
-	memory_install_read16_handler(machine->device("dsp")->memory().space(AS_IO), 0x07, 0x07, 0, 0, coolpool_input_r);
+	machine->device("dsp")->memory().space(AS_IO)->install_legacy_read_handler(0x07, 0x07, FUNC(coolpool_input_r));
 
 	register_state_save(machine);
 }

src/mame/drivers/coolridr.c

@@ -1187,8 +1187,8 @@ static READ32_HANDLER( coolridr_hack2_r )
 
 static DRIVER_INIT( coolridr )
 {
-//  memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x60d88a4, 0x060d88a7, 0, 0, coolridr_hack1_r );
+//  machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x60d88a4, 0x060d88a7, FUNC(coolridr_hack1_r) );
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x60d8894, 0x060d8897, 0, 0, coolridr_hack2_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x60d8894, 0x060d8897, FUNC(coolridr_hack2_r) );
 }
 
 GAME( 1995, coolridr,    0, coolridr,    coolridr,    coolridr, ROT0,  "Sega", "Cool Riders (US)",GAME_NOT_WORKING|GAME_NO_SOUND )

src/mame/drivers/cosmic.c

@@ -1596,17 +1596,17 @@ static DRIVER_INIT( cosmica )
 
 static DRIVER_INIT( devzone )
 {
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4807, 0x4807, 0, 0, cosmic_background_enable_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x4807, 0x4807, FUNC(cosmic_background_enable_w));
 }
 
 
 static DRIVER_INIT( nomnlnd )
 {
 	device_t *dac = machine->device("dac");
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x5000, 0x5001, 0, 0, nomnlnd_port_0_1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x5000, 0x5001, FUNC(nomnlnd_port_0_1_r));
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4800, 0x4800, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0x4800, 0x4800);
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4807, 0x4807, 0, 0, cosmic_background_enable_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x4807, 0x4807, FUNC(cosmic_background_enable_w));
-	memory_install_write8_device_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), dac, 0x480a, 0x480a, 0, 0, dac_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(*dac, 0x480a, 0x480a, FUNC(dac_w));
 }
 
 static DRIVER_INIT( panic )

src/mame/drivers/cps1.c

@@ -9965,10 +9965,10 @@ static DRIVER_INIT( forgottn )
 
 	/* Forgotten Worlds has a NEC uPD4701AC on the B-board handling dial inputs from the CN-MOWS connector. */
 	/* The memory mapping is handled by PAL LWIO */
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800040, 0x800041, 0, 0, forgottn_dial_0_reset_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x800040, 0x800041, FUNC(forgottn_dial_0_reset_w));
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800048, 0x800049, 0, 0, forgottn_dial_1_reset_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x800048, 0x800049, FUNC(forgottn_dial_1_reset_w));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800052, 0x800055, 0, 0, forgottn_dial_0_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x800052, 0x800055, FUNC(forgottn_dial_0_r));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x80005a, 0x80005d, 0, 0, forgottn_dial_1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80005a, 0x80005d, FUNC(forgottn_dial_1_r));
 
 	state->save_item(NAME(state->dial));
 
@@ -9982,8 +9982,8 @@ static DRIVER_INIT( sf2ee )
 {
 	/* This specific revision of SF2 has the CPS-B custom mapped at a different address. */
 	/* The mapping is handled by the PAL IOB2 on the B-board */
-	memory_unmap_readwrite(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800140, 0x80017f, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_readwrite(0x800140, 0x80017f);
-	memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8001c0, 0x8001ff, 0, 0, cps1_cps_b_r, cps1_cps_b_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x8001c0, 0x8001ff, FUNC(cps1_cps_b_r), FUNC(cps1_cps_b_w));
 
 	DRIVER_INIT_CALL(cps1);
 }
@@ -9991,7 +9991,7 @@ static DRIVER_INIT( sf2ee )
 static DRIVER_INIT( sf2thndr )
 {
 	/* This particular hack uses a modified B-board PAL which mirrors the CPS-B registers at an alternate address */
-	memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8001c0, 0x8001ff, 0, 0, cps1_cps_b_r, cps1_cps_b_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x8001c0, 0x8001ff, FUNC(cps1_cps_b_r), FUNC(cps1_cps_b_w));
 
 	DRIVER_INIT_CALL(cps1);
 }
@@ -9999,7 +9999,7 @@ static DRIVER_INIT( sf2thndr )
 static DRIVER_INIT( sf2hack )
 {
 	/* some SF2 hacks have some inputs wired to the LSB instead of MSB */
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800018, 0x80001f, 0, 0, cps1_hack_dsw_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x800018, 0x80001f, FUNC(cps1_hack_dsw_r));
 
 	DRIVER_INIT_CALL(cps1);
 }
@@ -10032,7 +10032,7 @@ static DRIVER_INIT( pang3n )
 {
 	/* Pang 3 is the only non-QSound game to have an EEPROM. */
 	/* It is mapped in the CPS-B address range so probably is on the C-board. */
-	memory_install_readwrite_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x80017a, 0x80017b, 0, 0, "EEPROMIN", "EEPROMOUT");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_port(0x80017a, 0x80017b, "EEPROMIN", "EEPROMOUT");
 
 	DRIVER_INIT_CALL(cps1);
 }
@@ -10083,11 +10083,11 @@ static DRIVER_INIT( sf2mdt )
 		rom[i + 3] = rom[i + 6];
 		rom[i + 6] = tmp;
 	}
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c01a, 0x70c01b, 0, 0, sf2mdt_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c01a, 0x70c01b, FUNC(sf2mdt_r));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c01c, 0x70c01d, 0, 0, sf2mdt_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c01c, 0x70c01d, FUNC(sf2mdt_r));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c01e, 0x70c01f, 0, 0, sf2mdt_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c01e, 0x70c01f, FUNC(sf2mdt_r));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c010, 0x70c011, 0, 0, sf2mdt_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c010, 0x70c011, FUNC(sf2mdt_r));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c018, 0x70c019, 0, 0, sf2mdt_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c018, 0x70c019, FUNC(sf2mdt_r));
 
 	DRIVER_INIT_CALL(cps1);
 }
@@ -10095,7 +10095,7 @@ static DRIVER_INIT( sf2mdt )
 static DRIVER_INIT( dinohunt )
 {
 	// is this shared with the new sound hw?
-	UINT8* ram = (UINT8*)memory_install_ram(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf18000, 0xf19fff, 0, 0, 0);
+	UINT8* ram = (UINT8*)machine->device("maincpu")->memory().space(AS_PROGRAM)->install_ram(0xf18000, 0xf19fff);
 	memset(ram,0xff,0x2000);
 	DRIVER_INIT_CALL(cps1);
 }

src/mame/drivers/cps2.c

@@ -8012,7 +8012,7 @@ static DRIVER_INIT ( pzloop2 )
 
 	state->save_item(NAME(state->readpaddle));
 
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x804000, 0x804001, 0, 0, joy_or_paddle_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x804000, 0x804001, FUNC(joy_or_paddle_r));
 }
 
 static READ16_HANDLER( gigamn2_dummyqsound_r )
@@ -8039,7 +8039,7 @@ static DRIVER_INIT( gigamn2 )
 	state->gigamn2_dummyqsound_ram = auto_alloc_array(machine, UINT16, 0x20000 / 2);
 	state->save_pointer(NAME(state->gigamn2_dummyqsound_ram), 0x20000 / 2);
 
-	memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x618000, 0x619fff, 0, 0, gigamn2_dummyqsound_r, gigamn2_dummyqsound_w); // no qsound..
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x618000, 0x619fff, FUNC(gigamn2_dummyqsound_r), FUNC(gigamn2_dummyqsound_w)); // no qsound..
 	space->set_decrypted_region(0x000000, (length) - 1, &rom[length/4]);
 	m68k_set_encrypted_opcode_range(machine->device("maincpu"), 0, length);
 }

src/mame/drivers/crgolf.c

@@ -600,7 +600,7 @@ ROM_END
 static DRIVER_INIT( crgolfhi )
 {
 	device_t *msm = machine->device("msm");
-	memory_install_write8_device_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), msm, 0xa000, 0xa003, 0, 0, crgolfhi_sample_w);
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(*msm, 0xa000, 0xa003, FUNC(crgolfhi_sample_w));
 }
 
 

src/mame/drivers/crimfght.c

@@ -410,12 +410,12 @@ static KONAMI_SETLINES_CALLBACK( crimfght_banking )
 	/* bit 5 = select work RAM or palette */
 	if (lines & 0x20)
 	{
-		memory_install_read_bank(device->memory().space(AS_PROGRAM), 0x0000, 0x03ff, 0, 0, "bank3");
+		device->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x03ff, "bank3");
-		memory_install_write8_handler(device->memory().space(AS_PROGRAM), 0x0000, 0x03ff, 0, 0, paletteram_xBBBBBGGGGGRRRRR_be_w);
+		device->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0000, 0x03ff, FUNC(paletteram_xBBBBBGGGGGRRRRR_be_w));
 		memory_set_bankptr(device->machine, "bank3", device->machine->generic.paletteram.v);
 	}
 	else
-		memory_install_readwrite_bank(device->memory().space(AS_PROGRAM), 0x0000, 0x03ff, 0, 0, "bank1");								/* RAM */
+		device->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x03ff, "bank1");								/* RAM */
 
 	/* bit 6 = enable char ROM reading through the video RAM */
 	k052109_set_rmrd_line(state->k052109, (lines & 0x40) ? ASSERT_LINE : CLEAR_LINE);

src/mame/drivers/dassault.c

@@ -865,7 +865,7 @@ static DRIVER_INIT( dassault )
 	auto_free(machine, tmp);
 
 	/* Save time waiting on vblank bit */
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3f8000, 0x3f8001, 0, 0, dassault_main_skip);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3f8000, 0x3f8001, FUNC(dassault_main_skip));
 }
 
 static DRIVER_INIT( thndzone )
@@ -885,7 +885,7 @@ static DRIVER_INIT( thndzone )
 	auto_free(machine, tmp);
 
 	/* Save time waiting on vblank bit */
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3f8000, 0x3f8001, 0, 0, thndzone_main_skip);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3f8000, 0x3f8001, FUNC(thndzone_main_skip));
 }
 
 /**********************************************************************************/

src/mame/drivers/ddealer.c

@@ -671,7 +671,7 @@ static READ16_HANDLER( ddealer_mcu_r )
 
 static DRIVER_INIT( ddealer )
 {
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe01c, 0xfe01d, 0, 0, ddealer_mcu_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfe01c, 0xfe01d, FUNC(ddealer_mcu_r) );
 }
 
 ROM_START( ddealer )

src/mame/drivers/ddenlovr.c

@@ -9107,7 +9107,7 @@ static DRIVER_INIT( rongrong )
        version of the game might be a bootleg with the protection
        patched. (both sets need this)
      */
-	memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x60d4, 0x60d4, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x60d4, 0x60d4);
 }
 
 /***************************************************************************

src/mame/drivers/ddragon.c

@@ -285,9 +285,9 @@ static WRITE8_HANDLER( darktowr_bankswitch_w )
 
 	memory_set_bank(space->machine, "bank1", newbank);
 	if (newbank == 4 && oldbank != 4)
-		memory_install_readwrite8_handler(space, 0x4000, 0x7fff, 0, 0, darktowr_mcu_bank_r, darktowr_mcu_bank_w);
+		space->install_legacy_readwrite_handler(0x4000, 0x7fff, FUNC(darktowr_mcu_bank_r), FUNC(darktowr_mcu_bank_w));
 	else if (newbank != 4 && oldbank == 4)
-		memory_install_readwrite_bank(space, 0x4000, 0x7fff, 0, 0, "bank1");
+		space->install_readwrite_bank(0x4000, 0x7fff, "bank1");
 }
 
 
@@ -2021,7 +2021,7 @@ static DRIVER_INIT( darktowr )
 	state->sound_irq = M6809_IRQ_LINE;
 	state->ym_irq = M6809_FIRQ_LINE;
 	state->technos_video_hw = 0;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3808, 0x3808, 0, 0, darktowr_bankswitch_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x3808, 0x3808, FUNC(darktowr_bankswitch_w));
 }
 
 
@@ -2034,7 +2034,7 @@ static DRIVER_INIT( toffy )
 	state->sound_irq = M6809_IRQ_LINE;
 	state->ym_irq = M6809_FIRQ_LINE;
 	state->technos_video_hw = 0;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3808, 0x3808, 0, 0, toffy_bankswitch_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x3808, 0x3808, FUNC(toffy_bankswitch_w));
 
 	/* the program rom has a simple bitswap encryption */
 	rom = machine->region("maincpu")->base();

src/mame/drivers/deadang.c

@@ -403,8 +403,8 @@ static DRIVER_INIT( ghunter )
 	seibu_sound_decrypt(machine, "audiocpu", 0x2000);
 	seibu_adpcm_decrypt(machine, "adpcm");
 
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x80000, 0x80001, 0, 0, ghunter_trackball_low_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80000, 0x80001, FUNC(ghunter_trackball_low_r));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xb0000, 0xb0001, 0, 0, ghunter_trackball_high_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xb0000, 0xb0001, FUNC(ghunter_trackball_high_r));
 }
 
 /* Game Drivers */

src/mame/drivers/dec0.c

@@ -423,30 +423,30 @@ void slyspy_set_protection_map(running_machine* machine, int type)
 	deco_bac06_device *tilegen1 = (deco_bac06_device*)space->machine->device<deco_bac06_device>("tilegen1");
 	deco_bac06_device *tilegen2 = (deco_bac06_device*)space->machine->device<deco_bac06_device>("tilegen2");
 
-	memory_install_write16_handler( space,  0x240000, 0x24ffff, 0, 0,  unmapped_w);
+	space->install_legacy_write_handler( 0x240000, 0x24ffff, FUNC(unmapped_w));
 
-	memory_install_write16_handler( space,  0x24a000, 0x24a001, 0, 0,  slyspy_state_w);
+	space->install_legacy_write_handler( 0x24a000, 0x24a001, FUNC(slyspy_state_w));
-	memory_install_read16_handler( space,  0x244000, 0x244001, 0, 0,  slyspy_state_r);
+	space->install_legacy_read_handler( 0x244000, 0x244001, FUNC(slyspy_state_r));
 
 	switch (type)
 	{
 
 		case 0:
-			memory_install_write16_device_handler( space,   tilegen2, 0x240000, 0x240007, 0, 0,  deco_bac06_pf_control_0_w);
+			space->install_legacy_write_handler( *tilegen2, 0x240000, 0x240007, FUNC(deco_bac06_pf_control_0_w));
-			memory_install_write16_device_handler( space,   tilegen2, 0x240010, 0x240017, 0, 0,  deco_bac06_pf_control_1_w);
+			space->install_legacy_write_handler( *tilegen2, 0x240010, 0x240017, FUNC(deco_bac06_pf_control_1_w));
 
-			memory_install_write16_device_handler( space, tilegen2, 0x242000, 0x24207f, 0, 0,  deco_bac06_pf_colscroll_w);
+			space->install_legacy_write_handler( *tilegen2, 0x242000, 0x24207f, FUNC(deco_bac06_pf_colscroll_w));
-			memory_install_write16_device_handler( space, tilegen2, 0x242400, 0x2427ff, 0, 0,  deco_bac06_pf_rowscroll_w);
+			space->install_legacy_write_handler( *tilegen2, 0x242400, 0x2427ff, FUNC(deco_bac06_pf_rowscroll_w));
 			
-			memory_install_write16_device_handler( space, tilegen2, 0x246000, 0x247fff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen2, 0x246000, 0x247fff, FUNC(deco_bac06_pf_data_w));
 
-			memory_install_write16_device_handler(  space,    tilegen1, 0x248000, 0x280007, 0, 0,  deco_bac06_pf_control_0_w);
+			space->install_legacy_write_handler( *tilegen1, 0x248000, 0x280007, FUNC(deco_bac06_pf_control_0_w));
-			memory_install_write16_device_handler(  space,    tilegen1, 0x248010, 0x280017, 0, 0,  deco_bac06_pf_control_1_w);
+			space->install_legacy_write_handler( *tilegen1, 0x248010, 0x280017, FUNC(deco_bac06_pf_control_1_w));
 
-			memory_install_write16_device_handler( space, tilegen1, 0x24c000, 0x24c07f, 0, 0,  deco_bac06_pf_colscroll_w);
+			space->install_legacy_write_handler( *tilegen1, 0x24c000, 0x24c07f, FUNC(deco_bac06_pf_colscroll_w));
-			memory_install_write16_device_handler( space, tilegen1, 0x24c400, 0x24c7ff, 0, 0,  deco_bac06_pf_rowscroll_w);
+			space->install_legacy_write_handler( *tilegen1, 0x24c400, 0x24c7ff, FUNC(deco_bac06_pf_rowscroll_w));
 
-			memory_install_write16_device_handler( space, tilegen1, 0x24e000, 0x24ffff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen1, 0x24e000, 0x24ffff, FUNC(deco_bac06_pf_data_w));
 
 			break;
 	
@@ -454,26 +454,26 @@ void slyspy_set_protection_map(running_machine* machine, int type)
 			// 0x240000 - 0x241fff not mapped
 			// 0x242000 - 0x243fff not mapped
 			// 0x246000 - 0x247fff not mapped
-			memory_install_write16_device_handler( space, tilegen1, 0x248000, 0x249fff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen1, 0x248000, 0x249fff, FUNC(deco_bac06_pf_data_w));
-			memory_install_write16_device_handler( space, tilegen2, 0x24c000, 0x24dfff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen2, 0x24c000, 0x24dfff, FUNC(deco_bac06_pf_data_w));
 			// 0x24e000 - 0x24ffff not mapped
 			break;
 
 		case 2:
-			memory_install_write16_device_handler( space, tilegen2, 0x240000, 0x241fff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen2, 0x240000, 0x241fff, FUNC(deco_bac06_pf_data_w));
-			memory_install_write16_device_handler( space, tilegen1, 0x242000, 0x243fff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen1, 0x242000, 0x243fff, FUNC(deco_bac06_pf_data_w));
 			// 0x242000 - 0x243fff not mapped
 			// 0x246000 - 0x247fff not mapped
 			// 0x248000 - 0x249fff not mapped
 			// 0x24c000 - 0x24dfff not mapped
-			memory_install_write16_device_handler( space, tilegen1, 0x24e000, 0x24ffff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen1, 0x24e000, 0x24ffff, FUNC(deco_bac06_pf_data_w));
 			break;
 
 		case 3:
-			memory_install_write16_device_handler( space, tilegen1, 0x240000, 0x241fff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen1, 0x240000, 0x241fff, FUNC(deco_bac06_pf_data_w));
 			// 0x242000 - 0x243fff not mapped
 			// 0x246000 - 0x247fff not mapped
-			memory_install_write16_device_handler( space, tilegen2, 0x248000, 0x249fff, 0, 0,  deco_bac06_pf_data_w);
+			space->install_legacy_write_handler( *tilegen2, 0x248000, 0x249fff, FUNC(deco_bac06_pf_data_w));
 			// 0x24c000 - 0x24dfff not mapped
 			// 0x24e000 - 0x24ffff not mapped
 			break;
@@ -2922,10 +2922,10 @@ static DRIVER_INIT( convert_robocop_gfx4_to_automat )
 
 static DRIVER_INIT( midresb )
 {
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x00180000, 0x0018000f, 0, 0,  dec0_controls_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00180000, 0x0018000f, FUNC(dec0_controls_r) );
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x001a0000, 0x001a000f, 0, 0,  dec0_rotary_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x001a0000, 0x001a000f, FUNC(dec0_rotary_r) );
 
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x00180014, 0x00180015, 0, 0, midres_sound_w );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x00180014, 0x00180015, FUNC(midres_sound_w) );
 }
 
 /******************************************************************************/

src/mame/drivers/deco_mlc.c

@@ -745,7 +745,7 @@ static DRIVER_INIT( avengrgs )
 	sh2drc_add_pcflush(machine->device("maincpu"), 0x32dc);
 
 	state->mainCpuIsArm = 0;
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01089a0, 0x01089a3, 0, 0, avengrgs_speedup_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x01089a0, 0x01089a3, FUNC(avengrgs_speedup_r) );
 	descramble_sound(machine);
 }
 

src/mame/drivers/decocass.c

@@ -1363,8 +1363,8 @@ static DRIVER_INIT( decocrom )
 		state->decrypted2[i] = swap_bits_5_6(rom[i]);
 
 	/* convert charram to a banked ROM */
-	memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x6000, 0xafff, 0, 0, "bank1");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x6000, 0xafff, "bank1");
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x6000, 0xafff, 0, 0, decocass_de0091_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x6000, 0xafff, FUNC(decocass_de0091_w));
 	memory_configure_bank(machine, "bank1", 0, 1, state->charram, 0);
 	memory_configure_bank(machine, "bank1", 1, 1, machine->region("user3")->base(), 0);
 	memory_configure_bank_decrypted(machine, "bank1", 0, 1, &state->decrypted[0x6000], 0);
@@ -1372,7 +1372,7 @@ static DRIVER_INIT( decocrom )
 	memory_set_bank(machine, "bank1", 0);
 
 	/* install the bank selector */
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xe900, 0xe900, 0, 0, decocass_e900_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe900, 0xe900, FUNC(decocass_e900_w));
 
 	state->save_pointer(NAME(state->decrypted2), romlength);
 }

src/mame/drivers/dgpix.c

@@ -583,7 +583,7 @@ static DRIVER_INIT( xfiles )
 	rom[BYTE4_XOR_BE(0x3aa933)] = 0;
 
 //  protection related ?
-//  memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf0c8b440, 0xf0c8b447, 0, 0);
+//  machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0xf0c8b440, 0xf0c8b447);
 
 	state->flash_roms = 2;
 }
@@ -604,7 +604,7 @@ static DRIVER_INIT( kdynastg )
 	rom[BYTE4_XOR_BE(0x3a45c9)] = 0;
 
 //  protection related ?
-//  memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x12341234, 0x12341243, 0, 0);
+//  machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x12341234, 0x12341243);
 
 	state->flash_roms = 4;
 }

src/mame/drivers/dkong.c

@@ -3040,7 +3040,7 @@ static DRIVER_INIT( drakton )
             {7,1,4,0,3,6,2,5},
     };
 
-    memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x3fff, 0, 0, "bank1" );
+    machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x3fff, "bank1" );
 
     /* While the PAL supports up to 16 decryption methods, only four
         are actually used in the PAL.  Therefore, we'll take a little
@@ -3062,7 +3062,7 @@ static DRIVER_INIT( strtheat )
             {6,3,4,1,0,7,2,5},
     };
 
-    memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x3fff, 0, 0, "bank1" );
+    machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x3fff, "bank1" );
 
     /* While the PAL supports up to 16 decryption methods, only four
         are actually used in the PAL.  Therefore, we'll take a little
@@ -3073,8 +3073,8 @@ static DRIVER_INIT( strtheat )
     drakton_decrypt_rom(machine, 0x88, 0x1c000, bs[3]);
 
     /* custom handlers supporting Joystick or Steering Wheel */
-    memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7c00, 0x7c00, 0, 0, strtheat_inputport_0_r);
+    machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7c00, 0x7c00, FUNC(strtheat_inputport_0_r));
-    memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7c80, 0x7c80, 0, 0, strtheat_inputport_1_r);
+    machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7c80, 0x7c80, FUNC(strtheat_inputport_1_r));
 }
 
 
@@ -3086,13 +3086,13 @@ static DRIVER_INIT( dkongx )
 
 	decrypted = auto_alloc_array(machine, UINT8, 0x10000);
 
-	memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x5fff, 0, 0, "bank1" );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x5fff, "bank1" );
-    memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8000, 0xffff, 0, 0, "bank2" );
+    machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x8000, 0xffff, "bank2" );
 
-	memory_install_write8_handler(space, 0xe000, 0xe000, 0, 0, braze_a15_w);
+	space->install_legacy_write_handler(0xe000, 0xe000, FUNC(braze_a15_w));
 
-	memory_install_read8_device_handler(space, eeprom, 0xc800, 0xc800, 0, 0, braze_eeprom_r);
+	space->install_legacy_read_handler(*eeprom, 0xc800, 0xc800, FUNC(braze_eeprom_r));
-	memory_install_write8_device_handler(space, eeprom, 0xc800, 0xc800, 0, 0, braze_eeprom_w);
+	space->install_legacy_write_handler(*eeprom, 0xc800, 0xc800, FUNC(braze_eeprom_w));
 
 	braze_decrypt_rom(machine, decrypted);
 

src/mame/drivers/dynax.c

@@ -6517,7 +6517,7 @@ ROM_END
 
 static DRIVER_INIT( mjreach )
 {
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10060, 0x10060, 0, 0, yarunara_flipscreen_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x10060, 0x10060, FUNC(yarunara_flipscreen_w));
 }
 
 /***************************************************************************

src/mame/drivers/eolith.c

@@ -1138,15 +1138,15 @@ static DRIVER_INIT( hidctch2 )
 
 static DRIVER_INIT( hidctch3 )
 {
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfc200000, 0xfc200003, 0, 0); // this generates pens vibration
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xfc200000, 0xfc200003); // this generates pens vibration
 
 	// It is not clear why the first reads are needed too
 
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfce00000, 0xfce00003, 0, 0, hidctch3_pen1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfce00000, 0xfce00003, FUNC(hidctch3_pen1_r));
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfce80000, 0xfce80003, 0, 0, hidctch3_pen1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfce80000, 0xfce80003, FUNC(hidctch3_pen1_r));
 
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfcf00000, 0xfcf00003, 0, 0, hidctch3_pen2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfcf00000, 0xfcf00003, FUNC(hidctch3_pen2_r));
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfcf80000, 0xfcf80003, 0, 0, hidctch3_pen2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfcf80000, 0xfcf80003, FUNC(hidctch3_pen2_r));
 
 	init_eolith_speedup(machine);
 }

src/mame/drivers/eprom.c

@@ -730,8 +730,8 @@ static DRIVER_INIT( eprom )
 	atarijsa_init(machine, "260010", 0x0002);
 
 	/* install CPU synchronization handlers */
-	state->sync_data = memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x16cc00, 0x16cc01, 0, 0, sync_r, sync_w);
+	state->sync_data = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x16cc00, 0x16cc01, FUNC(sync_r), FUNC(sync_w));
-	state->sync_data = memory_install_readwrite16_handler(machine->device("extra")->memory().space(AS_PROGRAM), 0x16cc00, 0x16cc01, 0, 0, sync_r, sync_w);
+	state->sync_data = machine->device("extra")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x16cc00, 0x16cc01, FUNC(sync_r), FUNC(sync_w));
 }
 
 

src/mame/drivers/equites.c

@@ -1899,8 +1899,8 @@ static DRIVER_INIT( gekisou )
 	unpack_region(machine, "gfx3");
 
 	// install special handlers for unknown device (protection?)
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x580000, 0x580001, 0, 0, gekisou_unknown_0_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x580000, 0x580001, FUNC(gekisou_unknown_0_w));
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x5a0000, 0x5a0001, 0, 0, gekisou_unknown_1_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x5a0000, 0x5a0001, FUNC(gekisou_unknown_1_w));
 }
 
 static DRIVER_INIT( splndrbt )
@@ -1913,7 +1913,7 @@ static DRIVER_INIT( hvoltage )
 	unpack_region(machine, "gfx3");
 
 #if HVOLTAGE_DEBUG
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x000038, 0x000039, 0, 0, hvoltage_debug_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x000038, 0x000039, FUNC(hvoltage_debug_r));
 #endif
 }
 

src/mame/drivers/exidy.c

@@ -1439,7 +1439,7 @@ static DRIVER_INIT( phantoma )
 	state->color_latch[0] = 0x09;
 
 	/* the ROM is actually mapped high */
-	memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf800, 0xffff, 0, 0, "bank1");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0xf800, 0xffff, "bank1");
 	memory_set_bankptr(machine, "bank1", machine->region("maincpu")->base() + 0xf800);
 }
 

src/mame/drivers/exidy440.c

@@ -303,9 +303,9 @@ void exidy440_bank_select(running_machine *machine, UINT8 bank)
 	if (state->showdown_bank_data[0] != NULL)
 	{
 		if (bank == 0 && state->bank != 0)
-			memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4000, 0x7fff, 0, 0, showdown_bank0_r);
+			machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4000, 0x7fff, FUNC(showdown_bank0_r));
 		else if (bank != 0 && state->bank == 0)
-			memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4000, 0x7fff, 0, 0, "bank1");
+			machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x4000, 0x7fff, "bank1");
 	}
 
 	/* select the bank and update the bank pointer */
@@ -1938,7 +1938,7 @@ static DRIVER_INIT( claypign )
 {
 	DRIVER_INIT_CALL(exidy440);
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec0, 0x2ec3, 0, 0, claypign_protection_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x2ec0, 0x2ec3, FUNC(claypign_protection_r));
 }
 
 
@@ -1948,11 +1948,11 @@ static DRIVER_INIT( topsecex )
 	DRIVER_INIT_CALL(exidy440);
 
 	/* extra input ports and scrolling */
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec5, 0x2ec5, 0, 0, topsecex_input_port_5_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x2ec5, 0x2ec5, FUNC(topsecex_input_port_5_r));
-	memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec6, 0x2ec6, 0, 0, "AN0");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2ec6, 0x2ec6, "AN0");
-	memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec7, 0x2ec7, 0, 0, "IN4");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2ec7, 0x2ec7, "IN4");
 
-	state->topsecex_yscroll = memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec1, 0x2ec1, 0, 0, topsecex_yscroll_w);
+	state->topsecex_yscroll = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x2ec1, 0x2ec1, FUNC(topsecex_yscroll_w));
 }
 
 

src/mame/drivers/exprraid.c

@@ -778,13 +778,13 @@ static DRIVER_INIT( exprraid )
 
 static DRIVER_INIT( wexpressb )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3800, 0x3800, 0, 0, vblank_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3800, 0x3800, FUNC(vblank_r));
 	exprraid_gfx_expand(machine);
 }
 
 static DRIVER_INIT( wexpressb2 )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xFFC0, 0xFFC0, 0, 0, vblank_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xFFC0, 0xFFC0, FUNC(vblank_r));
 	exprraid_gfx_expand(machine);
 }
 

src/mame/drivers/fastfred.c

@@ -979,8 +979,8 @@ ROM_END
 static DRIVER_INIT( flyboy )
 {
 	fastfred_state *state = machine->driver_data<fastfred_state>();
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc085, 0xc099, 0, 0, flyboy_custom1_io_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc085, 0xc099, FUNC(flyboy_custom1_io_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc8fb, 0xc900, 0, 0, flyboy_custom2_io_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc8fb, 0xc900, FUNC(flyboy_custom2_io_r));
 	state->hardware_type = 1;
 }
 
@@ -993,32 +993,32 @@ static DRIVER_INIT( flyboyb )
 static DRIVER_INIT( fastfred )
 {
 	fastfred_state *state = machine->driver_data<fastfred_state>();
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, fastfred_custom_io_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(fastfred_custom_io_r));
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
 	state->hardware_type = 1;
 }
 
 static DRIVER_INIT( jumpcoas )
 {
 	fastfred_state *state = machine->driver_data<fastfred_state>();
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, jumpcoas_custom_io_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(jumpcoas_custom_io_r));
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
 	state->hardware_type = 0;
 }
 
 static DRIVER_INIT( boggy84b )
 {
 	fastfred_state *state = machine->driver_data<fastfred_state>();
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, jumpcoas_custom_io_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(jumpcoas_custom_io_r));
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
 	state->hardware_type = 2;
 }
 
 static DRIVER_INIT( boggy84 )
 {
 	fastfred_state *state = machine->driver_data<fastfred_state>();
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, boggy84_custom_io_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(boggy84_custom_io_r));
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
 	state->hardware_type = 2;
 }
 

src/mame/drivers/firebeat.c

@@ -2216,9 +2216,9 @@ static void init_lights(running_machine *machine, write32_space_func out1, write
 	if(!out2) out1 = lamp_output2_w;
 	if(!out3) out1 = lamp_output3_w;
 
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7d000804, 0x7d000807, 0, 0, out1);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x7d000804, 0x7d000807, FUNC(out1));
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7d000320, 0x7d000323, 0, 0, out2);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x7d000320, 0x7d000323, FUNC(out2));
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7d000324, 0x7d000327, 0, 0, out3);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x7d000324, 0x7d000327, FUNC(out3));
 }
 
 static void init_firebeat(running_machine *machine)

src/mame/drivers/fitfight.c

@@ -978,7 +978,7 @@ static DRIVER_INIT( fitfight )
 //  UINT16 *mem16 = (UINT16 *)machine->region("maincpu")->base();
 //  mem16[0x0165B2/2] = 0x4e71; // for now so it boots
 	fitfight_state *state = machine->driver_data<fitfight_state>();
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x700000, 0x700001, 0, 0, fitfight_700000_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x700000, 0x700001, FUNC(fitfight_700000_r));
 	state->bbprot_kludge = 0;
 }
 
@@ -987,7 +987,7 @@ static DRIVER_INIT( histryma )
 //  UINT16 *mem16 = (UINT16 *)machine->region("maincpu")->base();
 //  mem16[0x017FDC/2] = 0x4e71; // for now so it boots
 	fitfight_state *state = machine->driver_data<fitfight_state>();
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x700000, 0x700001, 0, 0, histryma_700000_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x700000, 0x700001, FUNC(histryma_700000_r));
 	state->bbprot_kludge = 0;
 }
 

src/mame/drivers/gaiden.c

@@ -1506,8 +1506,8 @@ static DRIVER_INIT( wildfang )
 
 	state->prot = 0;
 	state->jumpcode = 0;
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a006, 0x07a007, 0, 0, wildfang_protection_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x07a006, 0x07a007, FUNC(wildfang_protection_r));
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a804, 0x07a805, 0, 0, wildfang_protection_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x07a804, 0x07a805, FUNC(wildfang_protection_w));
 }
 
 static DRIVER_INIT( raiga )
@@ -1519,8 +1519,8 @@ static DRIVER_INIT( raiga )
 
 	state->prot = 0;
 	state->jumpcode = 0;
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a006, 0x07a007, 0, 0, raiga_protection_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x07a006, 0x07a007, FUNC(raiga_protection_r));
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a804, 0x07a805, 0, 0, raiga_protection_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x07a804, 0x07a805, FUNC(raiga_protection_w));
 }
 
 static void descramble_drgnbowl_gfx(running_machine *machine)

src/mame/drivers/galaga.c

@@ -3212,7 +3212,7 @@ static DRIVER_INIT (gatsbee)
 	DRIVER_INIT_CALL(galaga);
 
 	/* Gatsbee has a larger character ROM, we need a handler for banking */
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1000, 0x1000, 0, 0, gatsbee_bank_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1000, 0x1000, FUNC(gatsbee_bank_w));
 }
 
 
@@ -3253,8 +3253,8 @@ static DRIVER_INIT( xevios )
 static DRIVER_INIT( battles )
 {
 	/* replace the Namco I/O handlers with interface to the 4th CPU */
-	memory_install_readwrite8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7000, 0x700f, 0, 0, battles_customio_data0_r, battles_customio_data0_w );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x7000, 0x700f, FUNC(battles_customio_data0_r), FUNC(battles_customio_data0_w) );
-	memory_install_readwrite8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7100, 0x7100, 0, 0, battles_customio0_r, battles_customio0_w );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x7100, 0x7100, FUNC(battles_customio0_r), FUNC(battles_customio0_w) );
 
 	DRIVER_INIT_CALL(xevious);
 }

src/mame/drivers/galaxian.c

@@ -2635,9 +2635,9 @@ static void unmap_galaxian_sound(running_machine *machine, offs_t base)
 {
 	address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
 
-	memory_unmap_write(space, base + 0x0004, base + 0x0007, 0, 0x07f8);
+	space->unmap_write(base + 0x0004, base + 0x0007, 0, 0x07f8);
-	memory_unmap_write(space, base + 0x0800, base + 0x0807, 0, 0x07f8);
+	space->unmap_write(base + 0x0800, base + 0x0807, 0, 0x07f8);
-	memory_unmap_write(space, base + 0x1800, base + 0x1800, 0, 0x07ff);
+	space->unmap_write(base + 0x1800, base + 0x1800, 0, 0x07ff);
 }
 
 
@@ -2662,7 +2662,7 @@ static DRIVER_INIT( nolock )
 	DRIVER_INIT_CALL(galaxian);
 
 	/* ...but coin lockout disabled/disconnected */
-	memory_unmap_write(space, 0x6002, 0x6002, 0, 0x7f8);
+	space->unmap_write(0x6002, 0x6002, 0, 0x7f8);
 }
 
 
@@ -2674,7 +2674,7 @@ static DRIVER_INIT( azurian )
 	common_init(machine, scramble_draw_bullet, galaxian_draw_background, NULL, NULL);
 
 	/* coin lockout disabled */
-	memory_unmap_write(space, 0x6002, 0x6002, 0, 0x7f8);
+	space->unmap_write(0x6002, 0x6002, 0, 0x7f8);
 }
 
 
@@ -2686,7 +2686,7 @@ static DRIVER_INIT( gmgalax )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, gmgalax_extend_tile_info, gmgalax_extend_sprite_info);
 
 	/* ROM is banked */
-	memory_install_read_bank(space, 0x0000, 0x3fff, 0, 0, "bank1");
+	space->install_read_bank(0x0000, 0x3fff, "bank1");
 	memory_configure_bank(machine, "bank1", 0, 2, machine->region("maincpu")->base() + 0x10000, 0x4000);
 
 	/* callback when the game select is toggled */
@@ -2703,7 +2703,7 @@ static DRIVER_INIT( pisces )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, pisces_extend_tile_info, pisces_extend_sprite_info);
 
 	/* coin lockout replaced by graphics bank */
-	memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
+	space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
 }
 
 
@@ -2715,7 +2715,7 @@ static DRIVER_INIT( batman2 )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
 
 	/* coin lockout replaced by graphics bank */
-	memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
+	space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
 }
 
 
@@ -2727,7 +2727,7 @@ static DRIVER_INIT( frogg )
 	common_init(machine, galaxian_draw_bullet, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
 
 	/* ...but needs a full 2k of RAM */
-	memory_install_ram(space, 0x4000, 0x47ff, 0, 0, NULL);
+	space->install_ram(0x4000, 0x47ff);
 }
 
 
@@ -2763,7 +2763,7 @@ static DRIVER_INIT( mooncrgx )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
 
 	/* LEDs and coin lockout replaced by graphics banking */
-	memory_install_write8_handler(space, 0x6000, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
+	space->install_legacy_write_handler(0x6000, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
 }
 
 
@@ -2793,7 +2793,7 @@ static DRIVER_INIT( pacmanbl )
 	DRIVER_INIT_CALL(galaxian);
 
 	/* ...but coin lockout disabled/disconnected */
-	memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, (write8_space_func)artic_gfxbank_w);
+	space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(artic_gfxbank_w));
 }
 
 static READ8_HANDLER( tenspot_dsw_read )
@@ -2858,18 +2858,18 @@ static DRIVER_INIT( tenspot )
 	//common_init(machine, galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
 
 	/* coin lockout replaced by graphics bank */
-	//memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
+	//space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
 
 
 	DRIVER_INIT_CALL(galaxian);
 
-	memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, (write8_space_func)artic_gfxbank_w);
+	space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(artic_gfxbank_w));
 
 	tenspot_current_game = 0;
 
 	tenspot_set_game_bank(machine, tenspot_current_game, 0);
 
-	memory_install_read8_handler(space, 0x7000, 0x7000, 0, 0, tenspot_dsw_read);
+	space->install_legacy_read_handler(0x7000, 0x7000, FUNC(tenspot_dsw_read));
 }
 
 
@@ -2893,28 +2893,28 @@ static DRIVER_INIT( zigzag )
 	galaxian_draw_bullet_ptr = NULL;
 
 	/* make ROMs 2 & 3 swappable */
-	memory_install_read_bank(space, 0x2000, 0x2fff, 0, 0, "bank1");
+	space->install_read_bank(0x2000, 0x2fff, "bank1");
-	memory_install_read_bank(space, 0x3000, 0x3fff, 0, 0, "bank2");
+	space->install_read_bank(0x3000, 0x3fff, "bank2");
 	memory_configure_bank(machine, "bank1", 0, 2, machine->region("maincpu")->base() + 0x2000, 0x1000);
 	memory_configure_bank(machine, "bank2", 0, 2, machine->region("maincpu")->base() + 0x2000, 0x1000);
 
 	/* also re-install the fixed ROM area as a bank in order to inform the memory system that
        the fixed area only extends to 0x1fff */
-	memory_install_read_bank(space, 0x0000, 0x1fff, 0, 0, "bank3");
+	space->install_read_bank(0x0000, 0x1fff, "bank3");
 	memory_set_bankptr(machine, "bank3", machine->region("maincpu")->base() + 0x0000);
 
 	/* handler for doing the swaps */
-	memory_install_write8_handler(space, 0x7002, 0x7002, 0, 0x07f8, zigzag_bankswap_w);
+	space->install_legacy_write_handler(0x7002, 0x7002, 0, 0x07f8, FUNC(zigzag_bankswap_w));
 	zigzag_bankswap_w(space, 0, 0);
 
 	/* coin lockout disabled */
-	memory_unmap_write(space, 0x6002, 0x6002, 0, 0x7f8);
+	space->unmap_write(0x6002, 0x6002, 0, 0x7f8);
 
 	/* remove the galaxian sound hardware */
 	unmap_galaxian_sound(machine, 0x6000);
 
 	/* install our AY-8910 handler */
-	memory_install_write8_handler(space, 0x4800, 0x4fff, 0, 0, zigzag_ay8910_w);
+	space->install_legacy_write_handler(0x4800, 0x4fff, FUNC(zigzag_ay8910_w));
 }
 
 
@@ -2934,11 +2934,11 @@ static DRIVER_INIT( checkman )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
 
 	/* move the interrupt enable from $b000 to $b001 */
-	memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
+	space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
-	memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
+	space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
 
 	/* attach the sound command handler */
-	memory_install_write8_handler(iospace, 0x00, 0x00, 0, 0xffff, checkman_sound_command_w);
+	iospace->install_legacy_write_handler(0x00, 0x00, 0, 0xffff, FUNC(checkman_sound_command_w));
 
 	/* decrypt program code */
 	decode_checkman(machine);
@@ -2953,10 +2953,10 @@ static DRIVER_INIT( checkmaj )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
 
 	/* attach the sound command handler */
-	memory_install_write8_handler(space, 0x7800, 0x7800, 0, 0x7ff, checkman_sound_command_w);
+	space->install_legacy_write_handler(0x7800, 0x7800, 0, 0x7ff, FUNC(checkman_sound_command_w));
 
 	/* for the title screen */
-	memory_install_read8_handler(space, 0x3800, 0x3800, 0, 0, checkmaj_protection_r);
+	space->install_legacy_read_handler(0x3800, 0x3800, FUNC(checkmaj_protection_r));
 }
 
 
@@ -2968,10 +2968,10 @@ static DRIVER_INIT( dingo )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
 
 	/* attach the sound command handler */
-	memory_install_write8_handler(space, 0x7800, 0x7800, 0, 0x7ff, checkman_sound_command_w);
+	space->install_legacy_write_handler(0x7800, 0x7800, 0, 0x7ff, FUNC(checkman_sound_command_w));
 
-	memory_install_read8_handler(space, 0x3000, 0x3000, 0, 0, dingo_3000_r);
+	space->install_legacy_read_handler(0x3000, 0x3000, FUNC(dingo_3000_r));
-	memory_install_read8_handler(space, 0x3035, 0x3035, 0, 0, dingo_3035_r);
+	space->install_legacy_read_handler(0x3035, 0x3035, FUNC(dingo_3035_r));
 }
 
 
@@ -2984,13 +2984,13 @@ static DRIVER_INIT( dingoe )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
 
 	/* move the interrupt enable from $b000 to $b001 */
-	memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
+	space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
-	memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
+	space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
 
 	/* attach the sound command handler */
-	memory_install_write8_handler(iospace, 0x00, 0x00, 0, 0xffff, checkman_sound_command_w);
+	iospace->install_legacy_write_handler(0x00, 0x00, 0, 0xffff, FUNC(checkman_sound_command_w));
 
-	memory_install_read8_handler(space, 0x3001, 0x3001, 0, 0, dingoe_3001_r);	/* Protection check */
+	space->install_legacy_read_handler(0x3001, 0x3001, FUNC(dingoe_3001_r));	/* Protection check */
 
 	/* decrypt program code */
 	decode_dingoe(machine);
@@ -3005,13 +3005,13 @@ static DRIVER_INIT( skybase )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, pisces_extend_tile_info, pisces_extend_sprite_info);
 
 	/* coin lockout replaced by graphics bank */
-	memory_install_write8_handler(space, 0xa002, 0xa002, 0, 0x7f8, galaxian_gfxbank_w);
+	space->install_legacy_write_handler(0xa002, 0xa002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
 
 	/* needs a full 2k of RAM */
-	memory_install_ram(space, 0x8000, 0x87ff, 0, 0, NULL);
+	space->install_ram(0x8000, 0x87ff);
 
 	/* extend ROM */
-	memory_install_rom(space, 0x0000, 0x5fff, 0, 0, machine->region("maincpu")->base());
+	space->install_rom(0x0000, 0x5fff, machine->region("maincpu")->base());
 }
 
 
@@ -3100,10 +3100,10 @@ static DRIVER_INIT( kingball )
 	/* video extensions */
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
 
-	memory_install_write8_handler(space, 0xb000, 0xb000, 0, 0x7f8, kingball_sound1_w);
+	space->install_legacy_write_handler(0xb000, 0xb000, 0, 0x7f8, FUNC(kingball_sound1_w));
-	memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
+	space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
-	memory_install_write8_handler(space, 0xb002, 0xb002, 0, 0x7f8, kingball_sound2_w);
+	space->install_legacy_write_handler(0xb002, 0xb002, 0, 0x7f8, FUNC(kingball_sound2_w));
-	memory_install_write8_handler(space, 0xb003, 0xb003, 0, 0x7f8, kingball_speech_dip_w);
+	space->install_legacy_write_handler(0xb003, 0xb003, 0, 0x7f8, FUNC(kingball_speech_dip_w));
 
 	state_save_register_global(machine, kingball_speech_dip);
 	state_save_register_global(machine, kingball_sound);
@@ -3118,17 +3118,17 @@ static DRIVER_INIT( scorpnmc )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
 
 	/* move the interrupt enable from $b000 to $b001 */
-	memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
+	space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
-	memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
+	space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
 
 	/* extra ROM */
-	memory_install_rom(space, 0x5000, 0x67ff, 0, 0, machine->region("maincpu")->base() + 0x5000);
+	space->install_rom(0x5000, 0x67ff, machine->region("maincpu")->base() + 0x5000);
 
 	/* install RAM at $4000-$4800 */
-	memory_install_ram(space, 0x4000, 0x47ff, 0, 0, NULL);
+	space->install_ram(0x4000, 0x47ff);
 
 	/* doesn't appear to use original RAM */
-	memory_unmap_readwrite(space, 0x8000, 0x87ff, 0, 0);
+	space->unmap_readwrite(0x8000, 0x87ff);
 }
 
 static DRIVER_INIT( thepitm )
@@ -3139,14 +3139,14 @@ static DRIVER_INIT( thepitm )
 	common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
 
 	/* move the interrupt enable from $b000 to $b001 */
-	memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
+	space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
-	memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
+	space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
 
 	/* disable the stars */
-	memory_unmap_write(space, 0xb004, 0xb004, 0, 0x07f8);
+	space->unmap_write(0xb004, 0xb004, 0, 0x07f8);
 
 	/* extend ROM */
-	memory_install_rom(space, 0x0000, 0x47ff, 0, 0, machine->region("maincpu")->base());
+	space->install_rom(0x0000, 0x47ff, machine->region("maincpu")->base());
 }
 
 /*************************************
@@ -3163,7 +3163,7 @@ static DRIVER_INIT( theend )
 	common_init(machine, theend_draw_bullet, galaxian_draw_background, NULL, NULL);
 
 	/* coin counter on the upper bit of port C */
-	memory_unmap_write(space, 0x6802, 0x6802, 0, 0x7f8);
+	space->unmap_write(0x6802, 0x6802, 0, 0x7f8);
 }
 
 
@@ -3182,16 +3182,16 @@ static DRIVER_INIT( explorer )
 	common_init(machine, scramble_draw_bullet, scramble_draw_background, NULL, NULL);
 
 	/* watchdog works for writes as well? (or is it just disabled?) */
-	memory_install_write8_handler(space, 0x7000, 0x7000, 0, 0x7ff, watchdog_reset_w);
+	space->install_legacy_write_handler(0x7000, 0x7000, 0, 0x7ff, FUNC(watchdog_reset_w));
 
 	/* I/O appears to be direct, not via PPIs */
-	memory_unmap_readwrite(space, 0x8000, 0xffff, 0, 0);
+	space->unmap_readwrite(0x8000, 0xffff);
-	memory_install_read_port(space, 0x8000, 0x8000, 0, 0xffc, "IN0");
+	space->install_read_port(0x8000, 0x8000, 0, 0xffc, "IN0");
-	memory_install_read_port(space, 0x8001, 0x8001, 0, 0xffc, "IN1");
+	space->install_read_port(0x8001, 0x8001, 0, 0xffc, "IN1");
-	memory_install_read_port(space, 0x8002, 0x8002, 0, 0xffc, "IN2");
+	space->install_read_port(0x8002, 0x8002, 0, 0xffc, "IN2");
-	memory_install_read_port(space, 0x8003, 0x8003, 0, 0xffc, "IN3");
+	space->install_read_port(0x8003, 0x8003, 0, 0xffc, "IN3");
-	memory_install_write8_handler(space, 0x8000, 0x8000, 0, 0xfff, soundlatch_w);
+	space->install_legacy_write_handler(0x8000, 0x8000, 0, 0xfff, FUNC(soundlatch_w));
-	memory_install_write8_handler(space, 0x9000, 0x9000, 0, 0xfff, explorer_sound_control_w);
+	space->install_legacy_write_handler(0x9000, 0x9000, 0, 0xfff, FUNC(explorer_sound_control_w));
 }
 
 
@@ -3202,7 +3202,7 @@ static DRIVER_INIT( sfx )
 	galaxian_sfx_tilemap = TRUE;
 
 	/* sound board has space for extra ROM */
-	memory_install_read_bank(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0000, 0x3fff, 0, 0, "bank1");
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x3fff, "bank1");
 	memory_set_bankptr(machine, "bank1", machine->region("audiocpu")->base());
 }
 
@@ -3215,8 +3215,8 @@ static DRIVER_INIT( atlantis )
 	common_init(machine, scramble_draw_bullet, scramble_draw_background, NULL, NULL);
 
 	/* watchdog is at $7800? (or is it just disabled?) */
-	memory_unmap_read(space, 0x7000, 0x7000, 0, 0x7ff);
+	space->unmap_read(0x7000, 0x7000, 0, 0x7ff);
-	memory_install_read8_handler(space, 0x7800, 0x7800, 0, 0x7ff, watchdog_reset_r);
+	space->install_legacy_read_handler(0x7800, 0x7800, 0, 0x7ff, FUNC(watchdog_reset_r));
 }
 
 
@@ -3256,11 +3256,11 @@ static DRIVER_INIT( froggrmc )
 	/* video extensions */
 	common_init(machine, NULL, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
 
-	memory_install_write8_handler(space, 0xa800, 0xa800, 0, 0x7ff, soundlatch_w);
+	space->install_legacy_write_handler(0xa800, 0xa800, 0, 0x7ff, FUNC(soundlatch_w));
-	memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, froggrmc_sound_control_w);
+	space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(froggrmc_sound_control_w));
 
 	/* actually needs 2k of RAM */
-	memory_install_ram(space, 0x8000, 0x87ff, 0, 0, NULL);
+	space->install_ram(0x8000, 0x87ff);
 
 	/* decrypt */
 	decode_frogger_sound(machine);
@@ -3301,16 +3301,16 @@ static DRIVER_INIT( scorpion )
 	common_init(machine, scramble_draw_bullet, scramble_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
 
 	/* hook up AY8910 */
-	memory_install_readwrite8_handler(machine->device("audiocpu")->memory().space(AS_IO), 0x00, 0xff, 0, 0, scorpion_ay8910_r, scorpion_ay8910_w);
+	machine->device("audiocpu")->memory().space(AS_IO)->install_legacy_readwrite_handler(0x00, 0xff, FUNC(scorpion_ay8910_r), FUNC(scorpion_ay8910_w));
 
 	/* extra ROM */
-	memory_install_read_bank(space, 0x5800, 0x67ff, 0, 0, "bank1");
+	space->install_read_bank(0x5800, 0x67ff, "bank1");
 	memory_set_bankptr(machine, "bank1", machine->region("maincpu")->base() + 0x5800);
 
 	/* no background related */
-//  memory_nop_write(space, 0x6803, 0x6803, 0, 0);
+//  space->nop_write(0x6803, 0x6803);
 
-	memory_install_read8_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x3000, 0x3000, 0, 0, scorpion_digitalker_intr_r);
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3000, 0x3000, FUNC(scorpion_digitalker_intr_r));
 /*
 {
     const UINT8 *rom = machine->region("speech")->base();

src/mame/drivers/galivan.c

@@ -1043,20 +1043,20 @@ static WRITE8_HANDLER( youmab_84_w )
 
 static DRIVER_INIT( youmab )
 {
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x82, 0x82, 0, 0, youmab_extra_bank_w); // banks rom at 0x8000? writes 0xff and 0x00 before executing code there
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x82, 0x82, FUNC(youmab_extra_bank_w)); // banks rom at 0x8000? writes 0xff and 0x00 before executing code there
-	memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank3");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x7fff, "bank3");
 	memory_set_bankptr(machine,  "bank3", machine->region("maincpu")->base());
 
-	memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8000, 0xbfff, 0, 0, "bank2");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x8000, 0xbfff, "bank2");
 	memory_configure_bank(machine, "bank2", 0, 2, machine->region("user2")->base(), 0x4000);
 	memory_set_bank(machine, "bank2", 0);
 
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x81, 0x81, 0, 0, youmab_81_w); // ?? often, alternating values
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x81, 0x81, FUNC(youmab_81_w)); // ?? often, alternating values
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x84, 0x84, 0, 0, youmab_84_w); // ?? often, sequence..
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x84, 0x84, FUNC(youmab_84_w)); // ?? often, sequence..
 
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd800, 0xd81f, 0, 0); // scrolling isn't here..
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xd800, 0xd81f); // scrolling isn't here..
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x8a, 0x8a, 0, 0, youmab_8a_r); // ???
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x8a, 0x8a, FUNC(youmab_8a_r)); // ???
 
 }
 

src/mame/drivers/ghosteo.c

@@ -437,7 +437,7 @@ static READ32_HANDLER( bballoon_speedup_r )
 
 static MACHINE_RESET( bballoon )
 {
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4d000010, 0x4d000013, 0, 0, bballoon_speedup_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4d000010, 0x4d000013, FUNC(bballoon_speedup_r));
 	s3c2410 = machine->device("s3c2410");
 }
 

src/mame/drivers/gladiatr.c

@@ -1030,7 +1030,7 @@ static DRIVER_INIT(ppking)
 		}
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf6a3,0xf6a3,0,0, f6a3_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf6a3,0xf6a3,FUNC(f6a3_r) );
 }
 
 

src/mame/drivers/gng.c

@@ -721,7 +721,7 @@ static READ8_HANDLER( diamond_hack_r )
 
 static DRIVER_INIT( diamond )
 {
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x6000, 0x6000, 0, 0, diamond_hack_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x6000, 0x6000, FUNC(diamond_hack_r));
 }
 
 

src/mame/drivers/goldstar.c

@@ -9853,8 +9853,8 @@ static DRIVER_INIT( schery97 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x1d, 0x1d, 0, 0, fixedvala8_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x1d, 0x1d, FUNC(fixedvala8_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x2a, 0x2a, 0, 0, fixedvalb4_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x2a, 0x2a, FUNC(fixedvalb4_r));
 	/* Oki 6295 at 0x20 */
 }
 
@@ -9883,7 +9883,7 @@ static DRIVER_INIT( schery97a )
 
 
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x16, 0x16, 0, 0, fixedval38_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x16, 0x16, FUNC(fixedval38_r));
 	/* Oki 6295 at 0x20 */
 }
 
@@ -9910,7 +9910,7 @@ static DRIVER_INIT( skill98 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x1e, 0x1e, 0, 0, fixedvalea_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x1e, 0x1e, FUNC(fixedvalea_r));
 	/* Oki 6295 at 0x20 */
 }
 
@@ -9937,7 +9937,7 @@ static DRIVER_INIT( fb36xc1 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x31, 0x31, 0, 0, fixedval68_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x31, 0x31, FUNC(fixedval68_r));
 
 }
 
@@ -9974,11 +9974,11 @@ static DRIVER_INIT( fbse354 )
 		ROM[i] = x;
 	}
 	// nfb96b needs both of these
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x23, 0x23, 0, 0, fixedval80_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x23, 0x23, FUNC(fixedval80_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x5a, 0x5a, 0, 0, fixedvalaa_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x5a, 0x5a, FUNC(fixedvalaa_r));
 
 	// csel96b
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x6e, 0x6e, 0, 0, fixedval96_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x6e, 0x6e, FUNC(fixedval96_r));
 
 }
 
@@ -10006,7 +10006,7 @@ static DRIVER_INIT( fbse362 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x2e, 0x2e, 0, 0, fixedvalbe_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x2e, 0x2e, FUNC(fixedvalbe_r));
 
 }
 
@@ -10038,8 +10038,8 @@ static DRIVER_INIT( rp35 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x5e, 0x5e, 0, 0, fixedval84_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x5e, 0x5e, FUNC(fixedval84_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x36, 0x36, 0, 0, fixedval90_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x36, 0x36, FUNC(fixedval90_r));
 }
 
 static READ8_HANDLER( fixedvalb2_r )
@@ -10066,7 +10066,7 @@ static DRIVER_INIT( rp36 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x34, 0x34, 0, 0, fixedvalb2_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x34, 0x34, FUNC(fixedvalb2_r));
 }
 
 static READ8_HANDLER( fixedval48_r )
@@ -10093,7 +10093,7 @@ static DRIVER_INIT( rp36c3 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x17, 0x17, 0, 0, fixedval48_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x17, 0x17, FUNC(fixedval48_r));
 }
 
 static READ8_HANDLER( fixedval09_r )
@@ -10125,8 +10125,8 @@ static DRIVER_INIT( po33 )
 
 		ROM[i] = x;
 	}
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x32, 0x32, 0, 0, fixedval74_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x32, 0x32, FUNC(fixedval74_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x12, 0x12, 0, 0, fixedval09_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x12, 0x12, FUNC(fixedval09_r));
 	/* oki6295 at 0x20 */
 }
 
@@ -10154,7 +10154,7 @@ static DRIVER_INIT( tc132axt )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x21, 0x21, 0, 0, fixedval58_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x21, 0x21, FUNC(fixedval58_r));
 }
 
 static READ8_HANDLER( fixedvale4_r )
@@ -10186,8 +10186,8 @@ static DRIVER_INIT( match133 )
 		ROM[i] = x;
 	}
 
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x16, 0x16, 0, 0, fixedvalc7_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x16, 0x16, FUNC(fixedvalc7_r));
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x1a, 0x1a, 0, 0, fixedvale4_r);
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x1a, 0x1a, FUNC(fixedvale4_r));
 }
 
 static DRIVER_INIT(cherrys)
@@ -10253,9 +10253,9 @@ static DRIVER_INIT( tonypok )
 {
 	// the ppi doesn't seem to work properly, so just install the inputs directly
 	address_space *io = machine->device("maincpu")->memory().space(AS_IO);
-	memory_install_read_port(io, 0x04, 0x04, 0, 0, "IN0" );
+	io->install_read_port(0x04, 0x04, "IN0" );
-	memory_install_read_port(io, 0x05, 0x05, 0, 0, "IN1" );
+	io->install_read_port(0x05, 0x05, "IN1" );
-	memory_install_read_port(io, 0x06, 0x06, 0, 0, "IN2" );
+	io->install_read_port(0x06, 0x06, "IN2" );
 
 }
 

src/mame/drivers/gottlieb.c

@@ -248,9 +248,9 @@ static MACHINE_START( gottlieb )
 	if (state->laserdisc != NULL)
 	{
 		/* attach to the I/O ports */
-		memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05805, 0x05807, 0, 0x07f8, laserdisc_status_r);
+		machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x05805, 0x05807, 0, 0x07f8, FUNC(laserdisc_status_r));
-		memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05805, 0x05805, 0, 0x07f8, laserdisc_command_w);	/* command for the player */
+		machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x05805, 0x05805, 0, 0x07f8, FUNC(laserdisc_command_w));	/* command for the player */
-		memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05806, 0x05806, 0, 0x07f8, laserdisc_select_w);
+		machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x05806, 0x05806, 0, 0x07f8, FUNC(laserdisc_select_w));
 
 		/* allocate a timer for serial transmission, and one for philips code processing */
 		state->laserdisc_bit_timer = machine->scheduler().timer_alloc(FUNC(laserdisc_bit_callback));
@@ -2613,7 +2613,7 @@ static DRIVER_INIT( romtiles )
 static DRIVER_INIT( stooges )
 {
 	DRIVER_INIT_CALL(ramtiles);
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05803, 0x05803, 0, 0x07f8, stooges_output_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x05803, 0x05803, 0, 0x07f8, FUNC(stooges_output_w));
 }
 
 

src/mame/drivers/groundfx.c

@@ -464,7 +464,7 @@ static DRIVER_INIT( groundfx )
 	int data;
 
 	/* Speedup handlers */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20b574, 0x20b577, 0, 0, irq_speedup_r_groundfx);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x20b574, 0x20b577, FUNC(irq_speedup_r_groundfx));
 
 	/* make piv tile GFX format suitable for gfxdecode */
 	offset = size/2;

src/mame/drivers/gstream.c

@@ -634,7 +634,7 @@ static READ32_HANDLER( gstream_speedup_r )
 
 static DRIVER_INIT( gstream )
 {
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd1ee0, 0xd1ee3, 0, 0, gstream_speedup_r );
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd1ee0, 0xd1ee3, FUNC(gstream_speedup_r) );
 }
 
 

src/mame/drivers/gstriker.c

@@ -1022,11 +1022,11 @@ static void mcu_init( running_machine *machine )
 	state->pending_command = 0;
 	state->mcu_data = 0;
 
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008a, 0x20008b, 0, 0, twrldc94_mcu_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x20008a, 0x20008b, FUNC(twrldc94_mcu_w));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008a, 0x20008b, 0, 0, twrldc94_mcu_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x20008a, 0x20008b, FUNC(twrldc94_mcu_r));
 
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008e, 0x20008f, 0, 0, twrldc94_prot_reg_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x20008e, 0x20008f, FUNC(twrldc94_prot_reg_w));
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008e, 0x20008f, 0, 0, twrldc94_prot_reg_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x20008e, 0x20008f, FUNC(twrldc94_prot_reg_r));
 }
 
 static DRIVER_INIT( twrldc94 )
@@ -1049,8 +1049,8 @@ static DRIVER_INIT( vgoalsoc )
 	state->gametype = 3;
 	mcu_init( machine );
 
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200090, 0x200091, 0, 0, vbl_toggle_w); // vblank toggle
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x200090, 0x200091, FUNC(vbl_toggle_w)); // vblank toggle
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200090, 0x200091, 0, 0, vbl_toggle_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200090, 0x200091, FUNC(vbl_toggle_r));
 }
 
 /*** GAME DRIVERS ************************************************************/

src/mame/drivers/gsword.c

@@ -917,7 +917,7 @@ static DRIVER_INIT( gsword )
 #endif
 #if 1
 	/* hack for sound protection or time out function */
-	memory_install_read8_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0x4004, 0x4005, 0, 0, gsword_hack_r);
+	machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4004, 0x4005, FUNC(gsword_hack_r));
 #endif
 }
 
@@ -932,7 +932,7 @@ static DRIVER_INIT( gsword2 )
 #endif
 #if 1
 	/* hack for sound protection or time out function */
-	memory_install_read8_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0x4004, 0x4005, 0, 0, gsword_hack_r);
+	machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4004, 0x4005, FUNC(gsword_hack_r));
 #endif
 }
 

src/mame/drivers/gunbustr.c

@@ -417,7 +417,7 @@ static READ32_HANDLER( main_cycle_r )
 static DRIVER_INIT( gunbustr )
 {
 	/* Speedup handler */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x203acc, 0x203acf, 0, 0, main_cycle_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x203acc, 0x203acf, FUNC(main_cycle_r));
 }
 
 GAME( 1992, gunbustr, 0,      gunbustr, gunbustr, gunbustr, ORIENTATION_FLIP_X, "Taito Corporation", "Gunbuster (Japan)", 0 )

src/mame/drivers/gundealr.c

@@ -579,7 +579,7 @@ static DRIVER_INIT( yamyam )
 {
 	gundealr_state *state = machine->driver_data<gundealr_state>();
 	state->input_ports_hack = 1;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xe000, 0xe000, 0, 0, yamyam_protection_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe000, 0xe000, FUNC(yamyam_protection_w));
 }
 
 

src/mame/drivers/harddriv.c

@@ -3791,9 +3791,9 @@ static void init_multisync(running_machine *machine, int compact_inputs)
 	/* install handlers for the compact driving games' inputs */
 	if (compact_inputs)
 	{
-		memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x400000, 0x400001, 0, 0, hdc68k_wheel_r);
+		state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x400000, 0x400001, FUNC(hdc68k_wheel_r));
-		memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x408000, 0x408001, 0, 0, hdc68k_wheel_edge_reset_w);
+		state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x408000, 0x408001, FUNC(hdc68k_wheel_edge_reset_w));
-		memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hdc68k_port1_r);
+		state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hdc68k_port1_r));
 	}
 }
 
@@ -3804,18 +3804,18 @@ static void init_adsp(running_machine *machine)
 	harddriv_state *state = machine->driver_data<harddriv_state>();
 
 	/* install ADSP program RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x800000, 0x807fff, 0, 0, hd68k_adsp_program_r, hd68k_adsp_program_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x800000, 0x807fff, FUNC(hd68k_adsp_program_r), FUNC(hd68k_adsp_program_w));
 
 	/* install ADSP data RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x808000, 0x80bfff, 0, 0, hd68k_adsp_data_r, hd68k_adsp_data_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x808000, 0x80bfff, FUNC(hd68k_adsp_data_r), FUNC(hd68k_adsp_data_w));
 
 	/* install ADSP serial buffer RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x810000, 0x813fff, 0, 0, hd68k_adsp_buffer_r, hd68k_adsp_buffer_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x810000, 0x813fff, FUNC(hd68k_adsp_buffer_r), FUNC(hd68k_adsp_buffer_w));
 
 	/* install ADSP control locations */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x818000, 0x81801f, 0, 0, hd68k_adsp_control_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x818000, 0x81801f, FUNC(hd68k_adsp_control_w));
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x818060, 0x81807f, 0, 0, hd68k_adsp_irq_clear_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x818060, 0x81807f, FUNC(hd68k_adsp_irq_clear_w));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x838000, 0x83ffff, 0, 0, hd68k_adsp_irq_state_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x838000, 0x83ffff, FUNC(hd68k_adsp_irq_state_r));
 }
 
 
@@ -3825,21 +3825,21 @@ static void init_ds3(running_machine *machine)
 	harddriv_state *state = machine->driver_data<harddriv_state>();
 
 	/* install ADSP program RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x800000, 0x807fff, 0, 0, hd68k_ds3_program_r, hd68k_ds3_program_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x800000, 0x807fff, FUNC(hd68k_ds3_program_r), FUNC(hd68k_ds3_program_w));
 
 	/* install ADSP data RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x808000, 0x80bfff, 0, 0, hd68k_adsp_data_r, hd68k_adsp_data_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x808000, 0x80bfff, FUNC(hd68k_adsp_data_r), FUNC(hd68k_adsp_data_w));
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x80c000, 0x80dfff, 0, 0, hdds3_special_r, hdds3_special_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x80c000, 0x80dfff, FUNC(hdds3_special_r), FUNC(hdds3_special_w));
 
 	/* install ADSP control locations */
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x820000, 0x8207ff, 0, 0, hd68k_ds3_gdata_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x820000, 0x8207ff, FUNC(hd68k_ds3_gdata_r));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x820800, 0x820fff, 0, 0, hd68k_ds3_girq_state_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x820800, 0x820fff, FUNC(hd68k_ds3_girq_state_r));
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x820000, 0x8207ff, 0, 0, hd68k_ds3_gdata_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x820000, 0x8207ff, FUNC(hd68k_ds3_gdata_w));
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x821000, 0x8217ff, 0, 0, hd68k_adsp_irq_clear_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x821000, 0x8217ff, FUNC(hd68k_adsp_irq_clear_w));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x822000, 0x8227ff, 0, 0, hd68k_ds3_sdata_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x822000, 0x8227ff, FUNC(hd68k_ds3_sdata_r));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x822800, 0x822fff, 0, 0, hd68k_ds3_sirq_state_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x822800, 0x822fff, FUNC(hd68k_ds3_sirq_state_r));
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x822000, 0x8227ff, 0, 0, hd68k_ds3_sdata_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x822000, 0x8227ff, FUNC(hd68k_ds3_sdata_w));
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x823800, 0x823fff, 0, 0, hd68k_ds3_control_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x823800, 0x823fff, FUNC(hd68k_ds3_control_w));
 
 	/* if we have a sound DSP, boot it */
 	if (state->ds4cpu1 != NULL)
@@ -3924,26 +3924,26 @@ static void init_dsk(running_machine *machine)
 	UINT8 *usr3 = machine->region("user3")->base();
 
 	/* install ASIC61 */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x85c000, 0x85c7ff, 0, 0, hd68k_dsk_dsp32_r, hd68k_dsk_dsp32_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x85c000, 0x85c7ff, FUNC(hd68k_dsk_dsp32_r), FUNC(hd68k_dsk_dsp32_w));
 
 	/* install control registers */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x85c800, 0x85c81f, 0, 0, hd68k_dsk_control_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x85c800, 0x85c81f, FUNC(hd68k_dsk_control_w));
 
 	/* install extra RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x90ffff, 0, 0, hd68k_dsk_ram_r, hd68k_dsk_ram_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x900000, 0x90ffff, FUNC(hd68k_dsk_ram_r), FUNC(hd68k_dsk_ram_w));
 	state->dsk_ram = (UINT16 *)(usr3 + 0x40000);
 
 	/* install extra ZRAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x910000, 0x910fff, 0, 0, hd68k_dsk_zram_r, hd68k_dsk_zram_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x910000, 0x910fff, FUNC(hd68k_dsk_zram_r), FUNC(hd68k_dsk_zram_w));
 	state->dsk_zram = (UINT16 *)(usr3 + 0x50000);
 
 	/* install ASIC65 */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x914000, 0x917fff, 0, 0, asic65_data_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x914000, 0x917fff, FUNC(asic65_data_w));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x914000, 0x917fff, 0, 0, asic65_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x914000, 0x917fff, FUNC(asic65_r));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x918000, 0x91bfff, 0, 0, asic65_io_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x918000, 0x91bfff, FUNC(asic65_io_r));
 
 	/* install extra ROM */
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x940000, 0x9fffff, 0, 0, hd68k_dsk_small_rom_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x940000, 0x9fffff, FUNC(hd68k_dsk_small_rom_r));
 	state->dsk_rom = (UINT16 *)(usr3 + 0x00000);
 
 	/* set up the ASIC65 */
@@ -3958,22 +3958,22 @@ static void init_dsk2(running_machine *machine)
 	UINT8 *usr3 = machine->region("user3")->base();
 
 	/* install ASIC65 */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x824000, 0x824003, 0, 0, asic65_data_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x824000, 0x824003, FUNC(asic65_data_w));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x824000, 0x824003, 0, 0, asic65_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x824000, 0x824003, FUNC(asic65_r));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x825000, 0x825001, 0, 0, asic65_io_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x825000, 0x825001, FUNC(asic65_io_r));
 
 	/* install ASIC61 */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x827000, 0x8277ff, 0, 0, hd68k_dsk_dsp32_r, hd68k_dsk_dsp32_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x827000, 0x8277ff, FUNC(hd68k_dsk_dsp32_r), FUNC(hd68k_dsk_dsp32_w));
 
 	/* install control registers */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x827800, 0x82781f, 0, 0, hd68k_dsk_control_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x827800, 0x82781f, FUNC(hd68k_dsk_control_w));
 
 	/* install extra RAM */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x880000, 0x8bffff, 0, 0, hd68k_dsk_ram_r, hd68k_dsk_ram_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x880000, 0x8bffff, FUNC(hd68k_dsk_ram_r), FUNC(hd68k_dsk_ram_w));
 	state->dsk_ram = (UINT16 *)(usr3 + 0x100000);
 
 	/* install extra ROM */
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x9fffff, 0, 0, hd68k_dsk_rom_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x900000, 0x9fffff, FUNC(hd68k_dsk_rom_r));
 	state->dsk_rom = (UINT16 *)(usr3 + 0x000000);
 
 	/* set up the ASIC65 */
@@ -3987,15 +3987,15 @@ static void init_dspcom(running_machine *machine)
 	harddriv_state *state = machine->driver_data<harddriv_state>();
 
 	/* install ASIC65 */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x900003, 0, 0, asic65_data_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x900000, 0x900003, FUNC(asic65_data_w));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x900003, 0, 0, asic65_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x900000, 0x900003, FUNC(asic65_r));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x901000, 0x910001, 0, 0, asic65_io_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x901000, 0x910001, FUNC(asic65_io_r));
 
 	/* set up the ASIC65 */
 	asic65_config(machine, ASIC65_STEELTAL);
 
 	/* install DSPCOM control */
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x904000, 0x90401f, 0, 0, hddspcom_control_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x904000, 0x90401f, FUNC(hddspcom_control_w));
 }
 
 
@@ -4007,9 +4007,9 @@ static void init_driver_sound(running_machine *machine)
 	hdsnd_init(machine);
 
 	/* install sound handlers */
-	memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x840000, 0x840001, 0, 0, hd68k_snd_data_r, hd68k_snd_data_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x840000, 0x840001, FUNC(hd68k_snd_data_r), FUNC(hd68k_snd_data_w));
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x844000, 0x844001, 0, 0, hd68k_snd_status_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x844000, 0x844001, FUNC(hd68k_snd_status_r));
-	memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x84c000, 0x84c001, 0, 0, hd68k_snd_reset_w);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x84c000, 0x84c001, FUNC(hd68k_snd_reset_w));
 }
 
 
@@ -4031,18 +4031,18 @@ static DRIVER_INIT( harddriv )
 	init_driver_sound(machine);
 
 	/* set up gsp speedup handler */
-	state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup1_w);
+	state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup1_w));
-	state->gsp_speedup_addr[1] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfffcfc00, 0xfffcfc0f, 0, 0, hdgsp_speedup2_w);
+	state->gsp_speedup_addr[1] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfffcfc00, 0xfffcfc0f, FUNC(hdgsp_speedup2_w));
-	memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup_r);
+	state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup_r));
 	state->gsp_speedup_pc = 0xffc00f10;
 
 	/* set up msp speedup handler */
-	state->msp_speedup_addr = memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_w);
+	state->msp_speedup_addr = state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_w));
-	memory_install_read16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_r);
+	state->msp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_r));
 	state->msp_speedup_pc = 0x00723b00;
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
 }
 
 
@@ -4056,18 +4056,18 @@ static DRIVER_INIT( harddrivc )
 	init_driver_sound(machine);
 
 	/* set up gsp speedup handler */
-	state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup1_w);
+	state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup1_w));
-	state->gsp_speedup_addr[1] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfffcfc00, 0xfffcfc0f, 0, 0, hdgsp_speedup2_w);
+	state->gsp_speedup_addr[1] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfffcfc00, 0xfffcfc0f, FUNC(hdgsp_speedup2_w));
-	memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup_r);
+	state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup_r));
 	state->gsp_speedup_pc = 0xfff40ff0;
 
 	/* set up msp speedup handler */
-	state->msp_speedup_addr = memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_w);
+	state->msp_speedup_addr = state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_w));
-	memory_install_read16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_r);
+	state->msp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_r));
 	state->msp_speedup_pc = 0x00723b00;
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
 }
 
 
@@ -4081,13 +4081,13 @@ static DRIVER_INIT( stunrun )
 	atarijsa_init(machine, "IN0", 0x0020);
 
 	/* set up gsp speedup handler */
-	state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup1_w);
+	state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup1_w));
-	state->gsp_speedup_addr[1] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfffcfc00, 0xfffcfc0f, 0, 0, hdgsp_speedup2_w);
+	state->gsp_speedup_addr[1] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfffcfc00, 0xfffcfc0f, FUNC(hdgsp_speedup2_w));
-	memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup_r);
+	state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup_r));
 	state->gsp_speedup_pc = 0xfff41070;
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
 }
 
 
@@ -4103,14 +4103,14 @@ static DRIVER_INIT( racedriv )
 
 	/* set up the slapstic */
 	slapstic_init(machine, 117);
-	state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, rd68k_slapstic_r, rd68k_slapstic_w);
+	state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(rd68k_slapstic_r), FUNC(rd68k_slapstic_w));
 
 	/* synchronization */
-	state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613c00, 0x613c03, 0, 0, rddsp32_sync0_w);
+	state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613c00, 0x613c03, FUNC(rddsp32_sync0_w));
-	state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613e00, 0x613e03, 0, 0, rddsp32_sync1_w);
+	state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613e00, 0x613e03, FUNC(rddsp32_sync1_w));
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
 }
 
 
@@ -4126,22 +4126,22 @@ static void racedrivc_init_common(running_machine *machine, offs_t gsp_protectio
 
 	/* set up the slapstic */
 	slapstic_init(machine, 117);
-	state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, rd68k_slapstic_r, rd68k_slapstic_w);
+	state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(rd68k_slapstic_r), FUNC(rd68k_slapstic_w));
 
 	/* synchronization */
-	state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613c00, 0x613c03, 0, 0, rddsp32_sync0_w);
+	state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613c00, 0x613c03, FUNC(rddsp32_sync0_w));
-	state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613e00, 0x613e03, 0, 0, rddsp32_sync1_w);
+	state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613e00, 0x613e03, FUNC(rddsp32_sync1_w));
 
 	/* set up protection hacks */
-	state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), gsp_protection, gsp_protection + 0x0f, 0, 0, hdgsp_protection_w);
+	state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(gsp_protection, gsp_protection + 0x0f, FUNC(hdgsp_protection_w));
 
 	/* set up gsp speedup handler */
-	state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff76f60, 0xfff76f6f, 0, 0, rdgsp_speedup1_w);
+	state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff76f60, 0xfff76f6f, FUNC(rdgsp_speedup1_w));
-	memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff76f60, 0xfff76f6f, 0, 0, rdgsp_speedup1_r);
+	state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff76f60, 0xfff76f6f, FUNC(rdgsp_speedup1_r));
 	state->gsp_speedup_pc = 0xfff43a00;
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
 }
 
 static DRIVER_INIT( racedrivc ) { racedrivc_init_common(machine, 0xfff95cd0); }
@@ -4166,34 +4166,34 @@ static void steeltal_init_common(running_machine *machine, offs_t ds3_transfer_p
 	init_dspcom(machine);
 	atarijsa_init(machine, "IN0", 0x0020);
 
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x908000, 0x908001, 0, 0, steeltal_dummy_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x908000, 0x908001, FUNC(steeltal_dummy_r));
 
 	/* set up the SLOOP */
 	if (!proto_sloop)
 	{
-		state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, st68k_sloop_r, st68k_sloop_w);
+		state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(st68k_sloop_r), FUNC(st68k_sloop_w));
-		state->m68k_sloop_alt_base = memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x4e000, 0x4ffff, 0, 0, st68k_sloop_alt_r);
+		state->m68k_sloop_alt_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4e000, 0x4ffff, FUNC(st68k_sloop_alt_r));
 	}
 	else
-		state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, st68k_protosloop_r, st68k_protosloop_w);
+		state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(st68k_protosloop_r), FUNC(st68k_protosloop_w));
 
 	/* synchronization */
 	state->stmsp_sync[0] = &state->msp_ram[TOWORD(0x80010)];
-	memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x80010, 0x8007f, 0, 0, stmsp_sync0_w);
+	state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x80010, 0x8007f, FUNC(stmsp_sync0_w));
 	state->stmsp_sync[1] = &state->msp_ram[TOWORD(0x99680)];
-	memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x99680, 0x9968f, 0, 0, stmsp_sync1_w);
+	state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x99680, 0x9968f, FUNC(stmsp_sync1_w));
 	state->stmsp_sync[2] = &state->msp_ram[TOWORD(0x99d30)];
-	memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x99d30, 0x99d4f, 0, 0, stmsp_sync2_w);
+	state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x99d30, 0x99d4f, FUNC(stmsp_sync2_w));
 
 	/* set up protection hacks */
-	state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff965d0, 0xfff965df, 0, 0, hdgsp_protection_w);
+	state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff965d0, 0xfff965df, FUNC(hdgsp_protection_w));
 
 	/* set up msp speedup handlers */
-	memory_install_read16_handler(state->msp->memory().space(AS_PROGRAM), 0x80020, 0x8002f, 0, 0, stmsp_speedup_r);
+	state->msp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80020, 0x8002f, FUNC(stmsp_speedup_r));
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f99, 0x1f99, 0, 0, hdds3_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f99, 0x1f99, FUNC(hdds3_speedup_r));
 	state->ds3_speedup_addr = &state->adsp_data_memory[0x1f99];
 	state->ds3_speedup_pc = 0xff;
 	state->ds3_transfer_pc = ds3_transfer_pc;
@@ -4216,20 +4216,20 @@ static DRIVER_INIT( strtdriv )
 
 	/* set up the slapstic */
 	slapstic_init(machine, 117);
-	state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, rd68k_slapstic_r, rd68k_slapstic_w);
+	state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(rd68k_slapstic_r), FUNC(rd68k_slapstic_w));
 
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hda68k_port1_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hda68k_port1_r));
 
 	/* synchronization */
-	state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613c00, 0x613c03, 0, 0, rddsp32_sync0_w);
+	state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613c00, 0x613c03, FUNC(rddsp32_sync0_w));
-	state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613e00, 0x613e03, 0, 0, rddsp32_sync1_w);
+	state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613e00, 0x613e03, FUNC(rddsp32_sync1_w));
 
 	/* set up protection hacks */
-	state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff960a0, 0xfff960af, 0, 0, hdgsp_protection_w);
+	state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff960a0, 0xfff960af, FUNC(hdgsp_protection_w));
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f99, 0x1f99, 0, 0, hdds3_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f99, 0x1f99, FUNC(hdds3_speedup_r));
 	state->ds3_speedup_addr = &state->adsp_data_memory[0x1f99];
 	state->ds3_speedup_pc = 0xff;
 	state->ds3_transfer_pc = 0x43672;
@@ -4245,18 +4245,18 @@ static DRIVER_INIT( hdrivair )
 	init_ds3(machine);
 	init_dsk2(machine);
 
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hda68k_port1_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hda68k_port1_r));
 
 	/* synchronization */
-	state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21fe00, 0x21fe03, 0, 0, rddsp32_sync0_w);
+	state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21fe00, 0x21fe03, FUNC(rddsp32_sync0_w));
-	state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21ff00, 0x21ff03, 0, 0, rddsp32_sync1_w);
+	state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21ff00, 0x21ff03, FUNC(rddsp32_sync1_w));
 
 	/* set up protection hacks */
-	state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff943f0, 0xfff943ff, 0, 0, hdgsp_protection_w);
+	state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff943f0, 0xfff943ff, FUNC(hdgsp_protection_w));
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f99, 0x1f99, 0, 0, hdds3_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f99, 0x1f99, FUNC(hdds3_speedup_r));
 	state->ds3_speedup_addr = &state->adsp_data_memory[0x1f99];
 	state->ds3_speedup_pc = 0x2da;
 	state->ds3_transfer_pc = 0x407b8;
@@ -4272,18 +4272,18 @@ static DRIVER_INIT( hdrivairp )
 	init_ds3(machine);
 	init_dsk2(machine);
 
-	memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hda68k_port1_r);
+	state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hda68k_port1_r));
 
 	/* synchronization */
-	state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21fe00, 0x21fe03, 0, 0, rddsp32_sync0_w);
+	state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21fe00, 0x21fe03, FUNC(rddsp32_sync0_w));
-	state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21ff00, 0x21ff03, 0, 0, rddsp32_sync1_w);
+	state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21ff00, 0x21ff03, FUNC(rddsp32_sync1_w));
 
 	/* set up protection hacks */
-	state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff916c0, 0xfff916cf, 0, 0, hdgsp_protection_w);
+	state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff916c0, 0xfff916cf, FUNC(hdgsp_protection_w));
 
 	/* set up adsp speedup handlers */
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
-	memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f9a, 0x1f9a, 0, 0, hdds3_speedup_r);
+	state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f9a, 0x1f9a, FUNC(hdds3_speedup_r));
 	state->ds3_speedup_addr = &state->adsp_data_memory[0x1f9a];
 	state->ds3_speedup_pc = 0x2d9;
 	state->ds3_transfer_pc = 0X407da;

src/mame/drivers/highvdeo.c

@@ -1159,7 +1159,7 @@ static READ16_HANDLER( ciclone_status_r )
 
 static DRIVER_INIT( ciclone )
 {
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0030, 0x0033, 0, 0, ciclone_status_r );
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0030, 0x0033, FUNC(ciclone_status_r) );
 }
 
 /*
@@ -1229,7 +1229,7 @@ static WRITE16_HANDLER( fashion_output_w )
 
 static DRIVER_INIT( fashion )
 {
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0002, 0x0003, 0, 0, fashion_output_w );
+	machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x0002, 0x0003, FUNC(fashion_output_w) );
 }
 
 GAMEL( 2000, tour4000,  0,      tv_vcf,   tv_vcf,   0,       ROT0,  "High Video", "Tour 4000",         0, layout_fashion )

src/mame/drivers/homedata.c

@@ -2032,15 +2032,15 @@ static DRIVER_INIT( jogakuen )
 	/* it seems that Mahjong Jogakuen runs on the same board as the others,
        but with just these two addresses swapped. Instead of creating a new
        MachineDriver, I just fix them here. */
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8007, 0x8007, 0, 0, pteacher_blitter_bank_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x8007, 0x8007, FUNC(pteacher_blitter_bank_w));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8005, 0x8005, 0, 0, pteacher_gfx_bank_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x8005, 0x8005, FUNC(pteacher_gfx_bank_w));
 }
 
 static DRIVER_INIT( mjikaga )
 {
 	/* Mahjong Ikagadesuka is different as well. */
-	memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7802, 0x7802, 0, 0, pteacher_snd_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7802, 0x7802, FUNC(pteacher_snd_r));
-	memory_install_write8_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0123, 0x0123, 0, 0, pteacher_snd_answer_w);
+	machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0123, 0x0123, FUNC(pteacher_snd_answer_w));
 }
 
 static DRIVER_INIT( reikaids )

src/mame/drivers/hshavoc.c

@@ -219,7 +219,7 @@ static DRIVER_INIT(hshavoc)
 
 	{
 		address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
-		memory_nop_write(space, 0x200000, 0x201fff, 0, 0);
+		space->nop_write(0x200000, 0x201fff);
 	}
 
 	DRIVER_INIT_CALL(megadriv);

src/mame/drivers/hyprduel.c

@@ -812,10 +812,10 @@ static DRIVER_INIT( hyprduel )
 	state->int_num = 0x02;
 
 	/* cpu synchronization (severe timings) */
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc0040e, 0xc00411, 0, 0, hyprduel_cpusync_trigger1_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xc0040e, 0xc00411, FUNC(hyprduel_cpusync_trigger1_w));
-	memory_install_read16_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0xc00408, 0xc00409, 0, 0, hyprduel_cpusync_trigger1_r);
+	machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc00408, 0xc00409, FUNC(hyprduel_cpusync_trigger1_r));
-	memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc00408, 0xc00409, 0, 0, hyprduel_cpusync_trigger2_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xc00408, 0xc00409, FUNC(hyprduel_cpusync_trigger2_w));
-	memory_install_read16_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0xfff34c, 0xfff34d, 0, 0, hyprduel_cpusync_trigger2_r);
+	machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff34c, 0xfff34d, FUNC(hyprduel_cpusync_trigger2_r));
 }
 
 static DRIVER_INIT( magerror )

src/mame/drivers/igs011.c

@@ -967,13 +967,13 @@ static WRITE16_HANDLER( igs011_prot_addr_w )
 	UINT8 *rom = space->machine->region("maincpu")->base();
 
 	// Plug previous address range with ROM access
-	memory_install_rom(sp, state->prot1_addr + 0, state->prot1_addr + 9, 0, 0, rom + state->prot1_addr);
+	sp->install_rom(state->prot1_addr + 0, state->prot1_addr + 9, rom + state->prot1_addr);
 
 	state->prot1_addr = (data << 4) ^ 0x8340;
 
 	// Add protection memory range
-	memory_install_write16_handler(sp, state->prot1_addr + 0, state->prot1_addr + 7, 0, 0, igs011_prot1_w);
+	sp->install_legacy_write_handler(state->prot1_addr + 0, state->prot1_addr + 7, FUNC(igs011_prot1_w));
-	memory_install_read16_handler (sp, state->prot1_addr + 8, state->prot1_addr + 9, 0, 0, igs011_prot1_r);
+	sp->install_legacy_read_handler (state->prot1_addr + 8, state->prot1_addr + 9, FUNC(igs011_prot1_r));
 }
 /*
 static READ16_HANDLER( igs011_prot_fake_r )
@@ -1800,7 +1800,7 @@ static DRIVER_INIT( drgnwrldv21 )
 	drgnwrld_type2_decrypt(machine);
 	drgnwrld_gfx_decrypt(machine);
 
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd4c0, 0xd4ff, 0, 0, drgnwrldv21_igs011_prot2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd4c0, 0xd4ff, FUNC(drgnwrldv21_igs011_prot2_r));
 /*
     // PROTECTION CHECKS
     // bp 32ee; bp 11ca8; bp 23d5e; bp 23fd0; bp 24170; bp 24348; bp 2454e; bp 246cc; bp 24922; bp 24b66; bp 24de2; bp 2502a; bp 25556; bp 269de; bp 2766a; bp 2a830
@@ -1940,7 +1940,7 @@ static DRIVER_INIT( dbc )
 
 	dbc_decrypt(machine);
 
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10600, 0x107ff, 0, 0, dbc_igs011_prot2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10600, 0x107ff, FUNC(dbc_igs011_prot2_r));
 /*
     // PROTECTION CHECKS
     rom[0x04c42/2]  =   0x602e;     // 004C42: 6604         bne 4c48  (rom test error otherwise)
@@ -1969,7 +1969,7 @@ static DRIVER_INIT( ryukobou )
 
 	ryukobou_decrypt(machine);
 
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10600, 0x107ff, 0, 0, ryukobou_igs011_prot2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10600, 0x107ff, FUNC(ryukobou_igs011_prot2_r));
 
 	// PROTECTION CHECKS
 //  rom[0x2df68/2]  =   0x4e75;     // 02DF68: 4E56 FE00    link A6, #-$200  (fills palette with pink otherwise)

src/mame/drivers/iqblock.c

@@ -444,7 +444,7 @@ static DRIVER_INIT( iqblock )
 	machine->generic.paletteram2.u8       = rom + 0x12800;
 	state->fgvideoram = rom + 0x16800;
 	state->bgvideoram = rom + 0x17000;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe26, 0xfe26, 0, 0, iqblock_prot_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfe26, 0xfe26, FUNC(iqblock_prot_w));
 	state->video_type=1;
 }
 
@@ -467,7 +467,7 @@ static DRIVER_INIT( grndtour )
 	machine->generic.paletteram2.u8       = rom + 0x12800;
 	state->fgvideoram = rom + 0x16800;
 	state->bgvideoram = rom + 0x17000;
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe39, 0xfe39, 0, 0, grndtour_prot_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfe39, 0xfe39, FUNC(grndtour_prot_w));
 	state->video_type=0;
 }
 

src/mame/drivers/itech32.c

@@ -4008,8 +4008,8 @@ static DRIVER_INIT( drivedge )
 	state->planes = 1;
 	state->is_drivedge = 1;
 
-	memory_install_read32_handler(machine->device("dsp1")->memory().space(AS_PROGRAM), 0x8382, 0x8382, 0, 0, drivedge_tms1_speedup_r);
+	machine->device("dsp1")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x8382, 0x8382, FUNC(drivedge_tms1_speedup_r));
-	memory_install_read32_handler(machine->device("dsp2")->memory().space(AS_PROGRAM), 0x8382, 0x8382, 0, 0, drivedge_tms2_speedup_r);
+	machine->device("dsp2")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x8382, 0x8382, FUNC(drivedge_tms2_speedup_r));
 }
 
 
@@ -4026,11 +4026,11 @@ static DRIVER_INIT( wcbowl )
 	state->vram_height = 1024;
 	state->planes = 1;
 
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680000, 0x680001, 0, 0, trackball_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680000, 0x680001, FUNC(trackball_r));
 
-	memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x578000, 0x57ffff, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x578000, 0x57ffff);
-	memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680080, 0x680081, 0, 0, wcbowl_prot_result_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680080, 0x680081, FUNC(wcbowl_prot_result_r));
-	memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680080, 0x680081, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0x680080, 0x680081);
 }
 
 
@@ -4044,8 +4044,8 @@ static void init_sftm_common(running_machine *machine, int prot_addr)
 
 	state->itech020_prot_address = prot_addr;
 
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x300000, 0x300003, 0, 0, itech020_color2_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x300000, 0x300003, FUNC(itech020_color2_w));
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x380000, 0x380003, 0, 0, itech020_color1_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x380000, 0x380003, FUNC(itech020_color1_w));
 }
 
 
@@ -4076,10 +4076,10 @@ static void init_shuffle_bowl_common(running_machine *machine, int prot_addr)
 
 	state->itech020_prot_address = prot_addr;
 
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x300000, 0x300003, 0, 0, itech020_color2_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x300000, 0x300003, FUNC(itech020_color2_w));
-	memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x380000, 0x380003, 0, 0, itech020_color1_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x380000, 0x380003, FUNC(itech020_color1_w));
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x180800, 0x180803, 0, 0, trackball32_4bit_p1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x180800, 0x180803, FUNC(trackball32_4bit_p1_r));
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x181000, 0x181003, 0, 0, trackball32_4bit_p2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x181000, 0x181003, FUNC(trackball32_4bit_p2_r));
 }
 
 
@@ -4098,7 +4098,7 @@ static DRIVER_INIT( wcbowln )	/* PIC 16C54 labeled as ITBWL-3 */
 static void install_timekeeper(running_machine *machine)
 {
 	device_t *device = machine->device("m48t02");
-	memory_install_readwrite32_device_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), device, 0x681000, 0x6817ff, 0, 0, timekeeper_32be_r, timekeeper_32be_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*device, 0x681000, 0x6817ff, FUNC(timekeeper_32be_r), FUNC(timekeeper_32be_w));
 }
 
 static DRIVER_INIT( wcbowlt )	/* PIC 16C54 labeled as ITBWL-3 */
@@ -4130,7 +4130,7 @@ static DRIVER_INIT( gt3d )
         Hacked versions of this PCB have been found with GT97
         through GTClassic. This is _NOT_ a factory modification
     */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200000, 0x200003, 0, 0, trackball32_8bit_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200000, 0x200003, FUNC(trackball32_8bit_r));
 	init_gt_common(machine);
 }
 
@@ -4143,8 +4143,8 @@ static DRIVER_INIT( aama )
         board share the same sound CPU code and sample ROMs.
         This board has all versions of GT for it, GT3D through GTClassic
     */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x180800, 0x180803, 0, 0, trackball32_4bit_p1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x180800, 0x180803, FUNC(trackball32_4bit_p1_r));
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x181000, 0x181003, 0, 0, trackball32_4bit_p2_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x181000, 0x181003, FUNC(trackball32_4bit_p2_r));
 	init_gt_common(machine);
 }
 
@@ -4168,7 +4168,7 @@ static DRIVER_INIT( s_ver )
         board: GT97 v1.21S, GT98, GT99, GT2K & GT Classic Versions 1.00S
         Trackball info is read through 200202 (actually 200203).
     */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200200, 0x200203, 0, 0, trackball32_4bit_p1_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200200, 0x200203, FUNC(trackball32_4bit_p1_r));
 	init_gt_common(machine);
 }
 
@@ -4182,7 +4182,7 @@ static DRIVER_INIT( gt3dl )
         Player 1 trackball read through 200003
         Player 2 trackball read through 200002
     */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200000, 0x200003, 0, 0, trackball32_4bit_combined_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200000, 0x200003, FUNC(trackball32_4bit_combined_r));
 	init_gt_common(machine);
 }
 
@@ -4190,7 +4190,7 @@ static DRIVER_INIT( gt3dl )
 static DRIVER_INIT( gt2kp )
 {
 	/* a little extra protection */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680000, 0x680003, 0, 0, gt2kp_prot_result_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680000, 0x680003, FUNC(gt2kp_prot_result_r));
 	DRIVER_INIT_CALL(aama);
 
 	/* The protection code is:
@@ -4211,7 +4211,7 @@ Label1  bne.s       Label1          ; Infinite loop if result isn't 0x01
 static DRIVER_INIT( gtclasscp )
 {
 	/* a little extra protection */
-	memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680000, 0x680003, 0, 0, gtclass_prot_result_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680000, 0x680003, FUNC(gtclass_prot_result_r));
 	DRIVER_INIT_CALL(aama);
 
 	/* The protection code is:

src/mame/drivers/itech8.c

@@ -2634,25 +2634,25 @@ ROM_END
 
 static DRIVER_INIT( grmatch )
 {
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0160, 0x0160, 0, 0, grmatch_palette_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0160, 0x0160, FUNC(grmatch_palette_w));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0180, 0x0180, 0, 0, grmatch_xscroll_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0180, 0x0180, FUNC(grmatch_xscroll_w));
-	memory_unmap_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01e0, 0x01ff, 0, 0);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0x01e0, 0x01ff);
 }
 
 
 static DRIVER_INIT( slikshot )
 {
-	memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0180, 0x0180, 0, 0, slikshot_z80_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x0180, 0x0180, FUNC(slikshot_z80_r));
-	memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01cf, 0x01cf, 0, 0, slikshot_z80_control_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x01cf, 0x01cf, FUNC(slikshot_z80_control_r));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01cf, 0x01cf, 0, 0, slikshot_z80_control_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x01cf, 0x01cf, FUNC(slikshot_z80_control_w));
 }
 
 
 static DRIVER_INIT( sstrike )
 {
-	memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1180, 0x1180, 0, 0, slikshot_z80_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x1180, 0x1180, FUNC(slikshot_z80_r));
-	memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x11cf, 0x11cf, 0, 0, slikshot_z80_control_r);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x11cf, 0x11cf, FUNC(slikshot_z80_control_r));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x11cf, 0x11cf, 0, 0, slikshot_z80_control_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x11cf, 0x11cf, FUNC(slikshot_z80_control_w));
 }
 
 
@@ -2691,15 +2691,15 @@ static DRIVER_INIT( neckneck )
 static DRIVER_INIT( rimrockn )
 {
 	/* additional input ports */
-	memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0161, 0x0161, 0, 0, "161");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0161, 0x0161, "161");
-	memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0162, 0x0162, 0, 0, "162");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0162, 0x0162, "162");
-	memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0163, 0x0163, 0, 0, "163");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0163, 0x0163, "163");
-	memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0164, 0x0164, 0, 0, "164");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0164, 0x0164, "164");
-	memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0165, 0x0165, 0, 0, "165");
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0165, 0x0165, "165");
 
 	/* different banking mechanism (disable the old one) */
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01a0, 0x01a0, 0, 0, rimrockn_bank_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x01a0, 0x01a0, FUNC(rimrockn_bank_w));
-	memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01c0, 0x01df, 0, 0, itech8_blitter_w);
+	machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x01c0, 0x01df, FUNC(itech8_blitter_w));
 }