src/emu/memory.c
| r8911 | r8912 | |
| 766 | 766 | _UintType unmap_r(address_space &space, offs_t offset, _UintType mask) |
| 767 | 767 | { |
| 768 | 768 | if (m_space.log_unmap() && !m_space.debugger_access()) |
| 769 | | logerror("%s: unmapped %s memory read from %s & %s\n", |
| 770 | | cpuexec_describe_context(&m_space.m_machine), m_space.name(), |
| 771 | | core_i64_hex_format(m_space.byte_to_address(offset), m_space.addrchars()), |
| 769 | logerror("%s: unmapped %s memory read from %s & %s\n", |
| 770 | cpuexec_describe_context(&m_space.m_machine), m_space.name(), |
| 771 | core_i64_hex_format(m_space.byte_to_address(offset * sizeof(_UintType)), m_space.addrchars()), |
| 772 | 772 | core_i64_hex_format(mask, 2 * sizeof(_UintType))); |
| 773 | 773 | return m_space.unmap(); |
| 774 | 774 | } |
| r8911 | r8912 | |
| 822 | 822 | void unmap_w(address_space &space, offs_t offset, _UintType data, _UintType mask) |
| 823 | 823 | { |
| 824 | 824 | if (m_space.log_unmap() && !m_space.debugger_access()) |
| 825 | | logerror("%s: unmapped %s memory write to %s = %s & %s\n", |
| 826 | | cpuexec_describe_context(&m_space.m_machine), m_space.name(), |
| 827 | | core_i64_hex_format(m_space.byte_to_address(offset), m_space.addrchars()), |
| 825 | logerror("%s: unmapped %s memory write to %s = %s & %s\n", |
| 826 | cpuexec_describe_context(&m_space.m_machine), m_space.name(), |
| 827 | core_i64_hex_format(m_space.byte_to_address(offset * sizeof(_UintType)), m_space.addrchars()), |
| 828 | 828 | core_i64_hex_format(data, 2 * sizeof(_UintType)), |
| 829 | 829 | core_i64_hex_format(mask, 2 * sizeof(_UintType))); |
| 830 | 830 | } |
| r8911 | r8912 | |
| 860 | 860 | class address_space_specific : public address_space |
| 861 | 861 | { |
| 862 | 862 | typedef address_space_specific<_NativeType, _Endian, _Large> this_type; |
| 863 | | |
| 863 | |
| 864 | 864 | // constants describing the native size |
| 865 | 865 | static const UINT32 NATIVE_BYTES = sizeof(_NativeType); |
| 866 | 866 | static const UINT32 NATIVE_MASK = NATIVE_BYTES - 1; |
| r8911 | r8912 | |
| 880 | 880 | #if (TEST_HANDLER) |
| 881 | 881 | // test code to verify the read/write handlers are touching the correct bits |
| 882 | 882 | // and returning the correct results |
| 883 | | |
| 883 | |
| 884 | 884 | // install some dummy RAM for the first 16 bytes with well-known values |
| 885 | 885 | UINT8 buffer[16]; |
| 886 | 886 | for (int index = 0; index < 16; index++) |
| r8911 | r8912 | |
| 903 | 903 | UINT32 expected32 = (_Endian == ENDIANNESS_LITTLE) ? expected64 : (expected64 >> 32); |
| 904 | 904 | UINT16 expected16 = (_Endian == ENDIANNESS_LITTLE) ? expected32 : (expected32 >> 16); |
| 905 | 905 | UINT8 expected8 = (_Endian == ENDIANNESS_LITTLE) ? expected16 : (expected16 >> 8); |
| 906 | | |
| 906 | |
| 907 | 907 | UINT64 result64; |
| 908 | 908 | UINT32 result32; |
| 909 | 909 | UINT16 result16; |
| 910 | 910 | UINT8 result8; |
| 911 | | |
| 911 | |
| 912 | 912 | // validate byte accesses |
| 913 | 913 | printf("\nAddress %d\n", address); |
| 914 | 914 | printf(" read_byte = "); printf("%02X\n", result8 = read_byte(address)); assert(result8 == expected8); |
| r8911 | r8912 | |
| 935 | 935 | if (address % 4 == 0) { printf(" (0x00ffffff) = "); printf("%08X\n", result32 = read_dword(address, 0x00ffffff)); assert((result32 & 0x00ffffff) == (expected32 & 0x00ffffff)); } |
| 936 | 936 | |
| 937 | 937 | // validate unaligned dword accesses |
| 938 | | printf(" read_dword_unaligned = "); printf("%08X\n", result32 = read_dword_unaligned(address)); assert(result32 == expected32); |
| 938 | printf(" read_dword_unaligned = "); printf("%08X\n", result32 = read_dword_unaligned(address)); assert(result32 == expected32); |
| 939 | 939 | printf(" read_dword_unaligned (0xff000000) = "); printf("%08X\n", result32 = read_dword_unaligned(address, 0xff000000)); assert((result32 & 0xff000000) == (expected32 & 0xff000000)); |
| 940 | 940 | printf(" (0x00ff0000) = "); printf("%08X\n", result32 = read_dword_unaligned(address, 0x00ff0000)); assert((result32 & 0x00ff0000) == (expected32 & 0x00ff0000)); |
| 941 | 941 | printf(" (0x0000ff00) = "); printf("%08X\n", result32 = read_dword_unaligned(address, 0x0000ff00)); assert((result32 & 0x0000ff00) == (expected32 & 0x0000ff00)); |
| r8911 | r8912 | |
| 979 | 979 | if (address % 8 == 0) { printf(" (0x00ffffffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffffffff)), 16)); assert((result64 & U64(0x00ffffffffffffff)) == (expected64 & U64(0x00ffffffffffffff))); } |
| 980 | 980 | |
| 981 | 981 | // validate unaligned qword accesses |
| 982 | | printf(" read_qword_unaligned = "); printf("%s\n", core_i64_hex_format(result64 = read_qword_unaligned(address), 16)); assert(result64 == expected64); |
| 982 | printf(" read_qword_unaligned = "); printf("%s\n", core_i64_hex_format(result64 = read_qword_unaligned(address), 16)); assert(result64 == expected64); |
| 983 | 983 | printf(" read_qword_unaligned (0xff00000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword_unaligned(address, U64(0xff00000000000000)), 16)); assert((result64 & U64(0xff00000000000000)) == (expected64 & U64(0xff00000000000000))); |
| 984 | 984 | printf(" (0x00ff000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword_unaligned(address, U64(0x00ff000000000000)), 16)); assert((result64 & U64(0x00ff000000000000)) == (expected64 & U64(0x00ff000000000000))); |
| 985 | 985 | printf(" (0x0000ff0000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword_unaligned(address, U64(0x0000ff0000000000)), 16)); assert((result64 & U64(0x0000ff0000000000)) == (expected64 & U64(0x0000ff0000000000))); |
| r8911 | r8912 | |
| 1187 | 1187 | } |
| 1188 | 1188 | } |
| 1189 | 1189 | |
| 1190 | | // determine our alignment against the native boundaries, and mask the address |
| 1190 | // determine our alignment against the native boundaries, and mask the address |
| 1191 | 1191 | UINT32 offsbits = 8 * (address & (NATIVE_BYTES - 1)); |
| 1192 | 1192 | address &= ~NATIVE_MASK; |
| 1193 | 1193 | |
| r8911 | r8912 | |
| 1225 | 1225 | // read lower bits from upper address |
| 1226 | 1226 | curmask = ljmask << offsbits; |
| 1227 | 1227 | if (curmask != 0) result |= read_native(address + NATIVE_BYTES, curmask) >> offsbits; |
| 1228 | | |
| 1228 | |
| 1229 | 1229 | // return the un-justified result |
| 1230 | 1230 | return result >> LEFT_JUSTIFY_TARGET_TO_NATIVE_SHIFT; |
| 1231 | 1231 | } |
| r8911 | r8912 | |
| 1238 | 1238 | // a fixed number of loops for the compiler to unroll if it desires |
| 1239 | 1239 | const UINT32 MAX_SPLITS_MINUS_ONE = TARGET_BYTES / NATIVE_BYTES - 1; |
| 1240 | 1240 | _TargetType result = 0; |
| 1241 | | |
| 1241 | |
| 1242 | 1242 | // little-endian case |
| 1243 | 1243 | if (_Endian == ENDIANNESS_LITTLE) |
| 1244 | 1244 | { |
| r8911 | r8912 | |
| 1271 | 1271 | offsbits = TARGET_BITS - (NATIVE_BITS - offsbits); |
| 1272 | 1272 | _NativeType curmask = mask >> offsbits; |
| 1273 | 1273 | if (curmask != 0) result = (_TargetType)read_native(address, curmask) << offsbits; |
| 1274 | | |
| 1274 | |
| 1275 | 1275 | // read middle bits from subsequent addresses |
| 1276 | 1276 | for (UINT32 index = 0; index < MAX_SPLITS_MINUS_ONE; index++) |
| 1277 | 1277 | { |
| r8911 | r8912 | |
| 1280 | 1280 | curmask = mask >> offsbits; |
| 1281 | 1281 | if (curmask != 0) result |= (_TargetType)read_native(address, curmask) << offsbits; |
| 1282 | 1282 | } |
| 1283 | | |
| 1283 | |
| 1284 | 1284 | // if we're not aligned and we still have bits left, read lowermost bits from the last address |
| 1285 | 1285 | if (!_Aligned && offsbits != 0) |
| 1286 | 1286 | { |
| r8911 | r8912 | |
| 1292 | 1292 | return result; |
| 1293 | 1293 | } |
| 1294 | 1294 | } |
| 1295 | | |
| 1295 | |
| 1296 | 1296 | // generic direct write |
| 1297 | 1297 | template<typename _TargetType, bool _Aligned> |
| 1298 | 1298 | void write_direct(offs_t address, _TargetType data, _TargetType mask) |
| r8911 | r8912 | |
| 1315 | 1315 | } |
| 1316 | 1316 | } |
| 1317 | 1317 | |
| 1318 | | // determine our alignment against the native boundaries, and mask the address |
| 1318 | // determine our alignment against the native boundaries, and mask the address |
| 1319 | 1319 | UINT32 offsbits = 8 * (address & (NATIVE_BYTES - 1)); |
| 1320 | 1320 | address &= ~NATIVE_MASK; |
| 1321 | 1321 | |
| r8911 | r8912 | |
| 1328 | 1328 | // write lower bits to lower address |
| 1329 | 1329 | _NativeType curmask = (_NativeType)mask << offsbits; |
| 1330 | 1330 | if (curmask != 0) write_native(address, (_NativeType)data << offsbits, curmask); |
| 1331 | | |
| 1331 | |
| 1332 | 1332 | // write upper bits to upper address |
| 1333 | 1333 | offsbits = NATIVE_BITS - offsbits; |
| 1334 | 1334 | curmask = mask >> offsbits; |
| r8911 | r8912 | |
| 1342 | 1342 | const UINT32 LEFT_JUSTIFY_TARGET_TO_NATIVE_SHIFT = ((NATIVE_BITS >= TARGET_BITS) ? (NATIVE_BITS - TARGET_BITS) : 0); |
| 1343 | 1343 | _NativeType ljdata = (_NativeType)data << LEFT_JUSTIFY_TARGET_TO_NATIVE_SHIFT; |
| 1344 | 1344 | _NativeType ljmask = (_NativeType)mask << LEFT_JUSTIFY_TARGET_TO_NATIVE_SHIFT; |
| 1345 | | |
| 1345 | |
| 1346 | 1346 | // write upper bits to lower address |
| 1347 | 1347 | _NativeType curmask = ljmask >> offsbits; |
| 1348 | 1348 | if (curmask != 0) write_native(address, ljdata >> offsbits, curmask); |
| 1349 | | |
| 1349 | |
| 1350 | 1350 | // write lower bits to upper address |
| 1351 | 1351 | offsbits = NATIVE_BITS - offsbits; |
| 1352 | 1352 | curmask = ljmask << offsbits; |
| r8911 | r8912 | |
| 1360 | 1360 | // compute the maximum number of loops; we do it this way so that there are |
| 1361 | 1361 | // a fixed number of loops for the compiler to unroll if it desires |
| 1362 | 1362 | const UINT32 MAX_SPLITS_MINUS_ONE = TARGET_BYTES / NATIVE_BYTES - 1; |
| 1363 | | |
| 1363 | |
| 1364 | 1364 | // little-endian case |
| 1365 | 1365 | if (_Endian == ENDIANNESS_LITTLE) |
| 1366 | 1366 | { |
| 1367 | 1367 | // write lowest bits to first address |
| 1368 | 1368 | _NativeType curmask = mask << offsbits; |
| 1369 | 1369 | if (curmask != 0) write_native(address, data << offsbits, curmask); |
| 1370 | | |
| 1370 | |
| 1371 | 1371 | // write middle bits to subsequent addresses |
| 1372 | 1372 | offsbits = NATIVE_BITS - offsbits; |
| 1373 | 1373 | for (UINT32 index = 0; index < MAX_SPLITS_MINUS_ONE; index++) |
| r8911 | r8912 | |
| 1377 | 1377 | if (curmask != 0) write_native(address, data >> offsbits, curmask); |
| 1378 | 1378 | offsbits += NATIVE_BITS; |
| 1379 | 1379 | } |
| 1380 | | |
| 1380 | |
| 1381 | 1381 | // if we're not aligned and we still have bits left, write uppermost bits to last address |
| 1382 | 1382 | if (!_Aligned && offsbits < TARGET_BITS) |
| 1383 | 1383 | { |
| r8911 | r8912 | |
| 1393 | 1393 | offsbits = TARGET_BITS - (NATIVE_BITS - offsbits); |
| 1394 | 1394 | _NativeType curmask = mask >> offsbits; |
| 1395 | 1395 | if (curmask != 0) write_native(address, data >> offsbits, curmask); |
| 1396 | | |
| 1396 | |
| 1397 | 1397 | // write middle bits to subsequent addresses |
| 1398 | 1398 | for (UINT32 index = 0; index < MAX_SPLITS_MINUS_ONE; index++) |
| 1399 | 1399 | { |
| r8911 | r8912 | |
| 1402 | 1402 | curmask = mask >> offsbits; |
| 1403 | 1403 | if (curmask != 0) write_native(address, data >> offsbits, curmask); |
| 1404 | 1404 | } |
| 1405 | | |
| 1405 | |
| 1406 | 1406 | // if we're not aligned and we still have bits left, write lowermost bits to the last address |
| 1407 | 1407 | if (!_Aligned && offsbits != 0) |
| 1408 | 1408 | { |
| r8911 | r8912 | |
| 2359 | 2359 | void address_space::unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet) |
| 2360 | 2360 | { |
| 2361 | 2361 | VPRINTF(("address_space::unmap(%s-%s mask=%s mirror=%s, %s, %s)\n", |
| 2362 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2363 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2362 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2363 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2364 | 2364 | (readorwrite == ROW_READ) ? "read" : (readorwrite == ROW_WRITE) ? "write" : (readorwrite == ROW_READWRITE) ? "read/write" : "??", |
| 2365 | 2365 | quiet ? "quiet" : "normal")); |
| 2366 | 2366 | |
| r8911 | r8912 | |
| 2382 | 2382 | void address_space::install_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag) |
| 2383 | 2383 | { |
| 2384 | 2384 | VPRINTF(("address_space::install_port(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n", |
| 2385 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2386 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2385 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2386 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2387 | 2387 | (rtag != NULL) ? rtag : "(none)", (wtag != NULL) ? wtag : "(none)")); |
| 2388 | 2388 | |
| 2389 | 2389 | // read handler |
| r8911 | r8912 | |
| 2424 | 2424 | void address_space::install_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag) |
| 2425 | 2425 | { |
| 2426 | 2426 | VPRINTF(("address_space::install_bank(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n", |
| 2427 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2428 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2427 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2428 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2429 | 2429 | (rtag != NULL) ? rtag : "(none)", (wtag != NULL) ? wtag : "(none)")); |
| 2430 | 2430 | |
| 2431 | 2431 | // map the read bank |
| r8911 | r8912 | |
| 2457 | 2457 | memory_private *memdata = m_machine.memory_data; |
| 2458 | 2458 | |
| 2459 | 2459 | VPRINTF(("address_space::install_ram(%s-%s mask=%s mirror=%s, %s, %p)\n", |
| 2460 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2461 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2460 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2461 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2462 | 2462 | (readorwrite == ROW_READ) ? "read" : (readorwrite == ROW_WRITE) ? "write" : (readorwrite == ROW_READWRITE) ? "read/write" : "??", |
| 2463 | 2463 | baseptr)); |
| 2464 | 2464 | |
| r8911 | r8912 | |
| 2532 | 2532 | UINT8 *address_space::install_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_delegate handler, UINT64 unitmask) |
| 2533 | 2533 | { |
| 2534 | 2534 | VPRINTF(("address_space::install_handler(%s-%s mask=%s mirror=%s, %s, %s)\n", |
| 2535 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2536 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2535 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2536 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2537 | 2537 | handler.name(), core_i64_hex_format(unitmask, data_width() / 4))); |
| 2538 | 2538 | |
| 2539 | 2539 | UINT32 entry = read().map_range(addrstart, addrend, addrmask, addrmirror); |
| r8911 | r8912 | |
| 2545 | 2545 | UINT8 *address_space::install_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_delegate handler, UINT64 unitmask) |
| 2546 | 2546 | { |
| 2547 | 2547 | VPRINTF(("address_space::install_handler(%s-%s mask=%s mirror=%s, %s, %s)\n", |
| 2548 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2549 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2548 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2549 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2550 | 2550 | handler.name(), core_i64_hex_format(unitmask, data_width() / 4))); |
| 2551 | 2551 | |
| 2552 | 2552 | UINT32 entry = write().map_range(addrstart, addrend, addrmask, addrmirror); |
| r8911 | r8912 | |
| 2571 | 2571 | UINT8 *address_space::install_legacy_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rname, UINT64 unitmask) |
| 2572 | 2572 | { |
| 2573 | 2573 | VPRINTF(("address_space::install_legacy_handler(%s-%s mask=%s mirror=%s, %s, %s) [read8]\n", |
| 2574 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2575 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2574 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2575 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2576 | 2576 | rname, core_i64_hex_format(unitmask, data_width() / 4))); |
| 2577 | 2577 | |
| 2578 | 2578 | UINT32 entry = read().map_range(addrstart, addrend, addrmask, addrmirror); |
| r8911 | r8912 | |
| 2584 | 2584 | UINT8 *address_space::install_legacy_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_space_func whandler, const char *wname, UINT64 unitmask) |
| 2585 | 2585 | { |
| 2586 | 2586 | VPRINTF(("address_space::install_legacy_handler(%s-%s mask=%s mirror=%s, %s, %s) [write8]\n", |
| 2587 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2588 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2587 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2588 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2589 | 2589 | wname, core_i64_hex_format(unitmask, data_width() / 4))); |
| 2590 | 2590 | |
| 2591 | 2591 | UINT32 entry = write().map_range(addrstart, addrend, addrmask, addrmirror); |
| r8911 | r8912 | |
| 2609 | 2609 | UINT8 *address_space::install_legacy_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) |
| 2610 | 2610 | { |
| 2611 | 2611 | VPRINTF(("address_space::install_legacy_handler(%s-%s mask=%s mirror=%s, %s, %s, \"%s\") [read8]\n", |
| 2612 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2613 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2612 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2613 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2614 | 2614 | rname, core_i64_hex_format(unitmask, data_width() / 4), device.tag())); |
| 2615 | 2615 | |
| 2616 | 2616 | UINT32 entry = read().map_range(addrstart, addrend, addrmask, addrmirror); |
| r8911 | r8912 | |
| 2622 | 2622 | UINT8 *address_space::install_legacy_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) |
| 2623 | 2623 | { |
| 2624 | 2624 | VPRINTF(("address_space::install_legacy_handler(%s-%s mask=%s mirror=%s, %s, %s, \"%s\") [write8]\n", |
| 2625 | | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2626 | | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2625 | core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars), |
| 2626 | core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars), |
| 2627 | 2627 | wname, core_i64_hex_format(unitmask, data_width() / 4), device.tag())); |
| 2628 | 2628 | |
| 2629 | 2629 | UINT32 entry = write().map_range(addrstart, addrend, addrmask, addrmirror); |