summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author Aaron Giles <aaron@aarongiles.com>2012-04-05 18:25:39 +0000
committer Aaron Giles <aaron@aarongiles.com>2012-04-05 18:25:39 +0000
commitf87e01ed81d2af9d403b37de913a89597e23955a (patch)
tree4b2fd769786d163bcaaf3c4057ab2c681bbc42f7
parentafa1478b7cc1423a9734f4b795599a196bf03aaa (diff)
Converted memory_private to memory_manager and moved global memory
operations into methods on it. Converted the less-popular cases over in drivers that used them, leaving the bank management APIs global for now.
-rw-r--r--src/emu/debug/debugcmd.c2
-rw-r--r--src/emu/devcb.h8
-rw-r--r--src/emu/device.c13
-rw-r--r--src/emu/device.h5
-rw-r--r--src/emu/machine.c4
-rw-r--r--src/emu/machine.h4
-rw-r--r--src/emu/machine/6821pia.h8
-rw-r--r--src/emu/machine/6840ptm.h4
-rw-r--r--src/emu/machine/microtch.c2
-rw-r--r--src/emu/machine/nvram.c6
-rw-r--r--src/emu/memory.c475
-rw-r--r--src/emu/memory.h268
-rw-r--r--src/emu/sound/spu.c4
-rw-r--r--src/mame/audio/atarijsa.c8
-rw-r--r--src/mame/audio/dcs.c8
-rw-r--r--src/mame/audio/mcr.c8
-rw-r--r--src/mame/audio/segasnd.c2
-rw-r--r--src/mame/audio/taito_en.c4
-rw-r--r--src/mame/drivers/actfancr.c2
-rw-r--r--src/mame/drivers/adp.c2
-rw-r--r--src/mame/drivers/cd32.c2
-rw-r--r--src/mame/drivers/ddragon.c2
-rw-r--r--src/mame/drivers/meritm.c2
-rw-r--r--src/mame/drivers/mpu4.c2
-rw-r--r--src/mame/drivers/r2dtank.c2
-rw-r--r--src/mame/drivers/segac2.c2
-rw-r--r--src/mame/drivers/tmaster.c4
-rw-r--r--src/mame/includes/cischeat.h7
-rw-r--r--src/mame/machine/leland.c4
-rw-r--r--src/mame/machine/psx.c4
-rw-r--r--src/mame/machine/qix.c2
-rw-r--r--src/mame/machine/s24fd.c2
-rw-r--r--src/mame/video/cischeat.c6
-rw-r--r--src/mame/video/sei_crtc.c2
34 files changed, 454 insertions, 426 deletions
diff --git a/src/emu/debug/debugcmd.c b/src/emu/debug/debugcmd.c
index 5bba55c55d3..3bb8eb97581 100644
--- a/src/emu/debug/debugcmd.c
+++ b/src/emu/debug/debugcmd.c
@@ -2596,7 +2596,7 @@ static void execute_memdump(running_machine &machine, int ref, int params, const
file = fopen(filename, "w");
if (file)
{
- memory_dump(machine, file);
+ machine.memory().dump(file);
fclose(file);
}
}
diff --git a/src/emu/devcb.h b/src/emu/devcb.h
index cbb39d4feb9..04f9d7938bd 100644
--- a/src/emu/devcb.h
+++ b/src/emu/devcb.h
@@ -112,7 +112,7 @@ template<class _Class, UINT8 (_Class::*_Function)(address_space &, offs_t, UINT8
UINT8 devcb_stub(device_t *device, offs_t offset)
{
_Class *target = downcast<_Class *>(device);
- return (target->*_Function)(*memory_nonspecific_space(device->machine()), offset, 0xff);
+ return (target->*_Function)(*device->machine().memory().first_space(), offset, 0xff);
}
// static template for a read16 stub function that calls through a given READ16_MEMBER
@@ -120,7 +120,7 @@ template<class _Class, UINT16 (_Class::*_Function)(address_space &, offs_t, UINT
UINT16 devcb_stub16(device_t *device, offs_t offset)
{
_Class *target = downcast<_Class *>(device);
- return (target->*_Function)(*memory_nonspecific_space(device->machine()), offset, 0xffff);
+ return (target->*_Function)(*device->machine().memory().first_space(), offset, 0xffff);
}
// static template for a write_line stub function that calls through a given WRITE_LINE_MEMBER
@@ -136,7 +136,7 @@ template<class _Class, void (_Class::*_Function)(address_space &, offs_t, UINT8,
void devcb_stub(device_t *device, offs_t offset, UINT8 data)
{
_Class *target = downcast<_Class *>(device);
- (target->*_Function)(*memory_nonspecific_space(device->machine()), offset, data, 0xff);
+ (target->*_Function)(*device->machine().memory().first_space(), offset, data, 0xff);
}
// static template for a write16 stub function that calls through a given WRITE16_MEMBER
@@ -144,7 +144,7 @@ template<class _Class, void (_Class::*_Function)(address_space &, offs_t, UINT16
void devcb_stub16(device_t *device, offs_t offset, UINT16 data)
{
_Class *target = downcast<_Class *>(device);
- (target->*_Function)(*memory_nonspecific_space(device->machine()), offset, data, 0xffff);
+ (target->*_Function)(*device->machine().memory().first_space(), offset, data, 0xffff);
}
#define DEVCB_NULL { DEVCB_TYPE_NULL }
diff --git a/src/emu/device.c b/src/emu/device.c
index f813a5e0441..cccec2644b7 100644
--- a/src/emu/device.c
+++ b/src/emu/device.c
@@ -855,6 +855,19 @@ device_t::finder_base::~finder_base()
}
+//-------------------------------------------------
+// find_memory - find memory
+//-------------------------------------------------
+
+void *device_t::finder_base::find_memory(size_t &size)
+{
+ memory_share *share = m_base.machine().memory().shared(m_base, m_tag);
+ if (share == NULL)
+ return NULL;
+ size = share->bytes();
+ return share->ptr();
+}
+
//**************************************************************************
// LIVE DEVICE INTERFACES
diff --git a/src/emu/device.h b/src/emu/device.h
index 066ec20ba22..0e96b9572e3 100644
--- a/src/emu/device.h
+++ b/src/emu/device.h
@@ -302,6 +302,9 @@ protected:
virtual void findit() = 0;
protected:
+ // static helpers
+ void *find_memory(size_t &size);
+
// internal state
finder_base *m_next;
device_t &m_base;
@@ -401,7 +404,7 @@ protected:
}
// finder
- virtual void findit() { astring subtag; m_target = reinterpret_cast<_PointerType *>(memory_get_shared(m_base.machine(), m_base.subtag(subtag, m_tag), m_bytes)); }
+ virtual void findit() { m_target = reinterpret_cast<_PointerType *>(find_memory(m_bytes)); }
protected:
// internal state
diff --git a/src/emu/machine.c b/src/emu/machine.c
index f2c9445d5e7..2d131978b66 100644
--- a/src/emu/machine.c
+++ b/src/emu/machine.c
@@ -143,7 +143,6 @@ running_machine::running_machine(const machine_config &_config, osd_interface &o
colortable(NULL),
shadow_table(NULL),
debug_flags(0),
- memory_data(NULL),
palette_data(NULL),
romload_data(NULL),
input_port_data(NULL),
@@ -159,6 +158,7 @@ running_machine::running_machine(const machine_config &_config, osd_interface &o
m_regionlist(m_respool),
m_save(*this),
m_scheduler(*this),
+ m_memory(NULL),
m_cheat(NULL),
m_render(NULL),
m_input(NULL),
@@ -283,7 +283,7 @@ void running_machine::start()
// first load ROMs, then populate memory, and finally initialize CPUs
// these operations must proceed in this order
rom_init(*this);
- memory_init(*this);
+ m_memory = auto_alloc(*this, memory_manager(*this));
watchdog_init(*this);
// allocate the gfx elements prior to device initialization
diff --git a/src/emu/machine.h b/src/emu/machine.h
index 159894e9d22..cc6dddf1fe3 100644
--- a/src/emu/machine.h
+++ b/src/emu/machine.h
@@ -183,7 +183,6 @@ class tilemap_manager;
class debug_view_manager;
class osd_interface;
-typedef struct _memory_private memory_private;
typedef struct _palette_private palette_private;
typedef struct _romload_private romload_private;
typedef struct _input_port_private input_port_private;
@@ -319,6 +318,7 @@ public:
resource_pool &respool() { return m_respool; }
device_scheduler &scheduler() { return m_scheduler; }
save_manager &save() { return m_save; }
+ memory_manager &memory() { assert(m_memory != NULL); return *m_memory; }
cheat_manager &cheat() const { assert(m_cheat != NULL); return *m_cheat; }
render_manager &render() const { assert(m_render != NULL); return *m_render; }
input_manager &input() const { assert(m_input != NULL); return *m_input; }
@@ -407,7 +407,6 @@ public:
UINT32 debug_flags; // the current debug flags
// internal core information
- memory_private * memory_data; // internal data from memory.c
palette_private * palette_data; // internal data from palette.c
romload_private * romload_data; // internal data from romload.c
input_port_private * input_port_data; // internal data from inptport.c
@@ -446,6 +445,7 @@ private:
device_scheduler m_scheduler; // scheduler object
// managers
+ memory_manager * m_memory; // internal data from memory.c
cheat_manager * m_cheat; // internal data from cheat.c
render_manager * m_render; // internal data from render.c
input_manager * m_input; // internal data from input.c
diff --git a/src/emu/machine/6821pia.h b/src/emu/machine/6821pia.h
index 5405b5badc4..4cb7099dc83 100644
--- a/src/emu/machine/6821pia.h
+++ b/src/emu/machine/6821pia.h
@@ -94,9 +94,9 @@ public:
void set_port_a_z_mask(UINT8 data) { m_port_a_z_mask = data; }// see second note in .c
DECLARE_READ8_MEMBER( porta_r );
- UINT8 porta_r() { return porta_r(*memory_nonspecific_space(machine()), 0); }
+ UINT8 porta_r() { return porta_r(*machine().memory().first_space(), 0); }
DECLARE_WRITE8_MEMBER( porta_w );
- void porta_w(UINT8 data) { porta_w(*memory_nonspecific_space(machine()), 0, data); }
+ void porta_w(UINT8 data) { porta_w(*machine().memory().first_space(), 0, data); }
void set_a_input(UINT8 data, UINT8 z_mask);
UINT8 a_output();
@@ -109,9 +109,9 @@ public:
int ca2_output_z();
DECLARE_READ8_MEMBER( portb_r );
- UINT8 portb_r() { return portb_r(*memory_nonspecific_space(machine()), 0); }
+ UINT8 portb_r() { return portb_r(*machine().memory().first_space(), 0); }
DECLARE_WRITE8_MEMBER( portb_w );
- void portb_w(UINT8 data) { portb_w(*memory_nonspecific_space(machine()), 0, data); }
+ void portb_w(UINT8 data) { portb_w(*machine().memory().first_space(), 0, data); }
UINT8 b_output();
DECLARE_READ_LINE_MEMBER( cb1_r );
diff --git a/src/emu/machine/6840ptm.h b/src/emu/machine/6840ptm.h
index fbf8f18a77d..ea10790e98e 100644
--- a/src/emu/machine/6840ptm.h
+++ b/src/emu/machine/6840ptm.h
@@ -61,9 +61,9 @@ public:
int ext_clock(int counter) const { return m_external_clock[counter]; } // get clock frequency
DECLARE_WRITE8_MEMBER( write );
- void write(offs_t offset, UINT8 data) { write(*memory_nonspecific_space(machine()), offset, data); }
+ void write(offs_t offset, UINT8 data) { write(*machine().memory().first_space(), offset, data); }
DECLARE_READ8_MEMBER( read );
- UINT8 read(offs_t offset) { return read(*memory_nonspecific_space(machine()), offset); }
+ UINT8 read(offs_t offset) { return read(*machine().memory().first_space(), offset); }
void set_gate(int idx, int state);
DECLARE_WRITE_LINE_MEMBER( set_g1 );
diff --git a/src/emu/machine/microtch.c b/src/emu/machine/microtch.c
index 92f04402463..1ca1ae76edc 100644
--- a/src/emu/machine/microtch.c
+++ b/src/emu/machine/microtch.c
@@ -343,5 +343,5 @@ void microtouch_serial_device::tra_complete()
void microtouch_serial_device::rcv_complete()
{
receive_register_extract();
- microtouch_device::rx(*memory_nonspecific_space(machine()), 0, get_received_char());
+ microtouch_device::rx(*machine().memory().first_space(), 0, get_received_char());
}
diff --git a/src/emu/machine/nvram.c b/src/emu/machine/nvram.c
index c0a8e45fa56..fed1c07a192 100644
--- a/src/emu/machine/nvram.c
+++ b/src/emu/machine/nvram.c
@@ -187,9 +187,11 @@ void nvram_device::determine_final_base()
// find our shared pointer with the target RAM
if (m_base == NULL)
{
- m_base = memory_get_shared(machine(), tag(), m_length);
- if (m_base == NULL)
+ memory_share *share = machine().memory().shared(*owner(), tag());
+ if (share == NULL)
throw emu_fatalerror("NVRAM device '%s' has no corresponding AM_SHARE region", tag());
+ m_base = share->ptr();
+ m_length = share->bytes();
}
// if we are region-backed for the default, find it now and make sure it's the right size
diff --git a/src/emu/memory.c b/src/emu/memory.c
index 61642bf731d..78861eb89e0 100644
--- a/src/emu/memory.c
+++ b/src/emu/memory.c
@@ -248,174 +248,6 @@ enum
//**************************************************************************
-// ======================> memory_block
-
-// a memory block is a chunk of RAM associated with a range of memory in a device's address space
-class memory_block
-{
- DISABLE_COPYING(memory_block);
-
- friend class simple_list<memory_block>;
- friend resource_pool_object<memory_block>::~resource_pool_object();
-
-public:
- // construction/destruction
- memory_block(address_space &space, offs_t bytestart, offs_t byteend, void *memory = NULL);
- ~memory_block();
-
- // getters
- running_machine &machine() const { return m_machine; }
- memory_block *next() const { return m_next; }
- offs_t bytestart() const { return m_bytestart; }
- offs_t byteend() const { return m_byteend; }
- UINT8 *data() const { return m_data; }
-
- // is the given range contained by this memory block?
- bool contains(address_space &space, offs_t bytestart, offs_t byteend) const
- {
- return (&space == &m_space && m_bytestart <= bytestart && m_byteend >= byteend);
- }
-
-private:
- // internal state
- memory_block * m_next; // next memory block in the list
- running_machine & m_machine; // need the machine to free our memory
- address_space & m_space; // which address space are we associated with?
- offs_t m_bytestart, m_byteend; // byte-normalized start/end for verifying a match
- UINT8 * m_data; // pointer to the data for this block
- UINT8 * m_allocated; // pointer to the actually allocated block
-};
-
-
-// ======================> memory_bank
-
-// a memory bank is a global pointer to memory that can be shared across devices and changed dynamically
-class memory_bank
-{
- friend class simple_list<memory_bank>;
- friend resource_pool_object<memory_bank>::~resource_pool_object();
-
- // a bank reference is an entry in a list of address spaces that reference a given bank
- class bank_reference
- {
- friend class simple_list<bank_reference>;
- friend resource_pool_object<bank_reference>::~resource_pool_object();
-
- public:
- // construction/destruction
- bank_reference(address_space &space, read_or_write readorwrite)
- : m_next(NULL),
- m_space(space),
- m_readorwrite(readorwrite) { }
-
- // getters
- bank_reference *next() const { return m_next; }
- address_space &space() const { return m_space; }
-
- // does this reference match the space+read/write combination?
- bool matches(address_space &space, read_or_write readorwrite) const
- {
- return (&space == &m_space && (readorwrite == ROW_READWRITE || readorwrite == m_readorwrite));
- }
-
- private:
- // internal state
- bank_reference * m_next; // link to the next reference
- address_space & m_space; // address space that references us
- read_or_write m_readorwrite; // used for read or write?
- };
-
- // a bank_entry contains a raw and decrypted pointer
- struct bank_entry
- {
- UINT8 * m_raw;
- UINT8 * m_decrypted;
- };
-
-public:
- // construction/destruction
- memory_bank(address_space &space, int index, offs_t bytestart, offs_t byteend, const char *tag = NULL);
- ~memory_bank();
-
- // getters
- memory_bank *next() const { return m_next; }
- running_machine &machine() const { return m_machine; }
- int index() const { return m_index; }
- int entry() const { return m_curentry; }
- bool anonymous() const { return m_anonymous; }
- offs_t bytestart() const { return m_bytestart; }
- void *base() const { return *m_baseptr; }
- void *base_decrypted() const { return *m_basedptr; }
- const char *tag() const { return m_tag; }
- const char *name() const { return m_name; }
-
- // compare a range against our range
- bool matches_exactly(offs_t bytestart, offs_t byteend) const { return (m_bytestart == bytestart && m_byteend == byteend); }
- bool fully_covers(offs_t bytestart, offs_t byteend) const { return (m_bytestart <= bytestart && m_byteend >= byteend); }
- bool is_covered_by(offs_t bytestart, offs_t byteend) const { return (m_bytestart >= bytestart && m_byteend <= byteend); }
- bool straddles(offs_t bytestart, offs_t byteend) const { return (m_bytestart < byteend && m_byteend > bytestart); }
-
- // track and verify address space references to this bank
- bool references_space(address_space &space, read_or_write readorwrite) const;
- void add_reference(address_space &space, read_or_write readorwrite);
-
- // set the base explicitly
- void set_base(void *base);
- void set_base_decrypted(void *base);
-
- // configure and set entries
- void configure(int entrynum, void *base);
- void configure_decrypted(int entrynum, void *base);
- void set_entry(int entrynum);
-
-private:
- // internal helpers
- void invalidate_references();
- void expand_entries(int entrynum);
-
- // internal state
- memory_bank * m_next; // next bank in sequence
- running_machine & m_machine; // need the machine to free our memory
- UINT8 ** m_baseptr; // pointer to our base pointer in the global array
- UINT8 ** m_basedptr; // same for the decrypted base pointer
- UINT8 m_index; // array index for this handler
- bool m_anonymous; // are we anonymous or explicit?
- offs_t m_bytestart; // byte-adjusted start offset
- offs_t m_byteend; // byte-adjusted end offset
- int m_curentry; // current entry
- bank_entry * m_entry; // array of entries (dynamically allocated)
- int m_entry_count; // number of allocated entries
- astring m_name; // friendly name for this bank
- astring m_tag; // tag for this bank
- simple_list<bank_reference> m_reflist; // linked list of address spaces referencing this bank
-};
-
-
-// ======================> memory_share
-
-// a memory share contains information about shared memory region
-class memory_share
-{
-public:
- // construction/destruction
- memory_share(size_t size, void *ptr = NULL)
- : m_ptr(ptr),
- m_size(size) { }
-
- // getters
- void *ptr() const { return m_ptr; }
- size_t size() const { return m_size; }
-
- // setters
- void set_ptr(void *ptr) { m_ptr = ptr; }
-
-private:
- // internal state
- void * m_ptr; // pointer to the memory backing the region
- size_t m_size; // size of the shared region
-};
-
-
// ======================> handler_entry
// a handler entry contains information about a memory handler
@@ -1057,8 +889,8 @@ class address_space_specific : public address_space
public:
// construction/destruction
- address_space_specific(device_memory_interface &memory, address_spacenum spacenum)
- : address_space(memory, spacenum, _Large),
+ address_space_specific(memory_manager &manager, device_memory_interface &memory, address_spacenum spacenum)
+ : address_space(manager, memory, spacenum, _Large),
m_read(*this, _Large),
m_write(*this, _Large)
{
@@ -1667,27 +1499,6 @@ typedef address_space_specific<UINT64, ENDIANNESS_LITTLE, true> address_space_64
typedef address_space_specific<UINT64, ENDIANNESS_BIG, true> address_space_64be_large;
-// ======================> _memory_private
-
-// holds internal state for the memory system
-struct _memory_private
-{
- bool initialized; // have we completed initialization?
-
- UINT8 * bank_ptr[STATIC_COUNT]; // array of bank pointers
- UINT8 * bankd_ptr[STATIC_COUNT]; // array of decrypted bank pointers
-
- simple_list<address_space> spacelist; // list of address spaces
- simple_list<memory_block> blocklist; // head of the list of memory blocks
-
- simple_list<memory_bank> banklist; // data gathered for each bank
- tagmap_t<memory_bank *> bankmap; // map for fast bank lookups
- UINT8 banknext; // next bank to allocate
-
- tagmap_t<memory_share *> sharemap; // map for share lookups
-};
-
-
//**************************************************************************
// GLOBAL VARIABLES
@@ -1702,9 +1513,6 @@ UINT8 address_table::s_watchpoint_table[1 << LEVEL1_BITS];
// FUNCTION PROTOTYPES
//**************************************************************************
-// banking helpers
-static void bank_reattach(running_machine &machine);
-
// debugging
static void generate_memdump(running_machine &machine);
@@ -1718,11 +1526,13 @@ static void generate_memdump(running_machine &machine);
// memory_init - initialize the memory system
//-------------------------------------------------
-void memory_init(running_machine &machine)
+memory_manager::memory_manager(running_machine &machine)
+ : m_machine(machine),
+ m_initialized(false),
+ m_banknext(STATIC_BANK1)
{
- // allocate our private data
- memory_private *memdata = machine.memory_data = auto_alloc_clear(machine, memory_private);
- memdata->banknext = STATIC_BANK1;
+ memset(m_bank_ptr, 0, sizeof(m_bank_ptr));
+ memset(m_bankd_ptr, 0, sizeof(m_bankd_ptr));
// loop over devices and spaces within each device
memory_interface_iterator iter(machine.root_device());
@@ -1732,39 +1542,33 @@ void memory_init(running_machine &machine)
// if there is a configuration for this space, we need an address space
const address_space_config *spaceconfig = memory->space_config(spacenum);
if (spaceconfig != NULL)
- memdata->spacelist.append(address_space::allocate(machine, *spaceconfig, *memory, spacenum));
+ m_spacelist.append(address_space::allocate(*this, *spaceconfig, *memory, spacenum));
}
// construct and preprocess the address_map for each space
- for (address_space *space = memdata->spacelist.first(); space != NULL; space = space->next())
+ for (address_space *space = m_spacelist.first(); space != NULL; space = space->next())
space->prepare_map();
// create the handlers from the resulting address maps
- for (address_space *space = memdata->spacelist.first(); space != NULL; space = space->next())
+ for (address_space *space = m_spacelist.first(); space != NULL; space = space->next())
space->populate_from_map();
// allocate memory needed to back each address space
- for (address_space *space = memdata->spacelist.first(); space != NULL; space = space->next())
+ for (address_space *space = m_spacelist.first(); space != NULL; space = space->next())
space->allocate_memory();
// find all the allocated pointers
- for (address_space *space = memdata->spacelist.first(); space != NULL; space = space->next())
+ for (address_space *space = m_spacelist.first(); space != NULL; space = space->next())
space->locate_memory();
// register a callback to reset banks when reloading state
- machine.save().register_postload(save_prepost_delegate(FUNC(bank_reattach), &machine));
+ machine.save().register_postload(save_prepost_delegate(FUNC(memory_manager::bank_reattach), this));
// dump the final memory configuration
generate_memdump(machine);
// we are now initialized
- memdata->initialized = true;
-}
-
-address_space *memory_nonspecific_space(running_machine &machine)
-{
- memory_private *memdata = machine.memory_data;
- return memdata->spacelist.first();
+ m_initialized = true;
}
@@ -1774,30 +1578,24 @@ address_space *memory_nonspecific_space(running_machine &machine)
//**************************************************************************
//-------------------------------------------------
-// memory_configure_bank - configure the
-// addresses for a bank
+// configure_bank - configure the addresses for a
+// bank
//-------------------------------------------------
-void memory_configure_bank(running_machine &machine, const char *tag, int startentry, int numentries, void *base, offs_t stride)
+void memory_manager::configure_bank(const char *tag, int startentry, int numentries, void *base, offs_t stride)
{
- memory_configure_bank(machine.root_device(), tag, startentry, numentries, base, stride);
+ configure_bank(machine().root_device(), tag, startentry, numentries, base, stride);
}
-
-//-------------------------------------------------
-// memory_configure_bank - configure the
-// addresses for a bank
-//-------------------------------------------------
-
-void memory_configure_bank(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride)
+void memory_manager::configure_bank(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride)
{
// validation checks
astring fulltag;
- memory_bank *bank = device.machine().memory_data->bankmap.find_hash_only(device.subtag(fulltag, tag));
+ memory_bank *bank = m_bankmap.find_hash_only(device.subtag(fulltag, tag));
if (bank == NULL)
- fatalerror("memory_configure_bank called for unknown bank '%s'", fulltag.cstr());
+ fatalerror("configure_bank called for unknown bank '%s'", fulltag.cstr());
if (base == NULL)
- fatalerror("memory_configure_bank called NULL base");
+ fatalerror("configure_bank called NULL base");
// fill in the requested bank entries (backwards to improve allocation)
for (int entrynum = startentry + numentries - 1; entrynum >= startentry; entrynum--)
@@ -1806,30 +1604,24 @@ void memory_configure_bank(device_t &device, const char *tag, int startentry, in
//-------------------------------------------------
-// memory_configure_bank_decrypted - configure
-// the decrypted addresses for a bank
+// configure_bank_decrypted - configure the
+// decrypted addresses for a bank
//-------------------------------------------------
-void memory_configure_bank_decrypted(running_machine &machine, const char *tag, int startentry, int numentries, void *base, offs_t stride)
+void memory_manager::configure_bank_decrypted(const char *tag, int startentry, int numentries, void *base, offs_t stride)
{
- memory_configure_bank_decrypted(machine.root_device(), tag, startentry, numentries, base, stride);
+ memory_configure_bank_decrypted(machine().root_device(), tag, startentry, numentries, base, stride);
}
-
-//-------------------------------------------------
-// memory_configure_bank_decrypted - configure
-// the decrypted addresses for a bank
-//-------------------------------------------------
-
-void memory_configure_bank_decrypted(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride)
+void memory_manager::configure_bank_decrypted(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride)
{
// validation checks
astring fulltag;
- memory_bank *bank = device.machine().memory_data->bankmap.find_hash_only(device.subtag(fulltag, tag));
+ memory_bank *bank = m_bankmap.find_hash_only(device.subtag(fulltag, tag));
if (bank == NULL)
- fatalerror("memory_configure_bank_decrypted called for unknown bank '%s'", fulltag.cstr());
+ fatalerror("configure_bank_decrypted called for unknown bank '%s'", fulltag.cstr());
if (base == NULL)
- fatalerror("memory_configure_bank_decrypted called NULL base");
+ fatalerror("configure_bank_decrypted called NULL base");
// fill in the requested bank entries (backwards to improve allocation)
for (int entrynum = startentry + numentries - 1; entrynum >= startentry; entrynum--)
@@ -1838,28 +1630,22 @@ void memory_configure_bank_decrypted(device_t &device, const char *tag, int star
//-------------------------------------------------
-// memory_set_bank - select one pre-configured
-// entry to be the new bank base
+// set_bank - select one pre-configured entry to
+// be the new bank base
//-------------------------------------------------
-void memory_set_bank(running_machine &machine, const char *tag, int entrynum)
+void memory_manager::set_bank(const char *tag, int entrynum)
{
- memory_set_bank(machine.root_device(), tag, entrynum);
+ set_bank(machine().root_device(), tag, entrynum);
}
-
-//-------------------------------------------------
-// memory_set_bank - select one pre-configured
-// entry to be the new bank base
-//-------------------------------------------------
-
-void memory_set_bank(device_t &device, const char *tag, int entrynum)
+void memory_manager::set_bank(device_t &device, const char *tag, int entrynum)
{
// validation checks
astring fulltag;
- memory_bank *bank = device.machine().memory_data->bankmap.find_hash_only(device.subtag(fulltag, tag));
+ memory_bank *bank = m_bankmap.find_hash_only(device.subtag(fulltag, tag));
if (bank == NULL)
- fatalerror("memory_set_bank called for unknown bank '%s'", fulltag.cstr());
+ fatalerror("set_bank called for unknown bank '%s'", fulltag.cstr());
// set the base
bank->set_entry(entrynum);
@@ -1867,28 +1653,21 @@ void memory_set_bank(device_t &device, const char *tag, int entrynum)
//-------------------------------------------------
-// memory_get_bank - return the currently
-// selected bank
+// get_bank - return the currently selected bank
//-------------------------------------------------
-int memory_get_bank(running_machine &machine, const char *tag)
+int memory_manager::bank(const char *tag)
{
- return memory_get_bank(machine.root_device(), tag);
+ return bank(machine().root_device(), tag);
}
-
-//-------------------------------------------------
-// memory_get_bank - return the currently
-// selected bank
-//-------------------------------------------------
-
-int memory_get_bank(device_t &device, const char *tag)
+int memory_manager::bank(device_t &device, const char *tag)
{
// validation checks
astring fulltag;
- memory_bank *bank = device.machine().memory_data->bankmap.find_hash_only(device.subtag(fulltag, tag));
+ memory_bank *bank = m_bankmap.find_hash_only(device.subtag(fulltag, tag));
if (bank == NULL)
- fatalerror("memory_get_bank called for unknown bank '%s'", fulltag.cstr());
+ fatalerror("bank() called for unknown bank '%s'", fulltag.cstr());
// return the current entry
return bank->entry();
@@ -1896,24 +1675,19 @@ int memory_get_bank(device_t &device, const char *tag)
//-------------------------------------------------
-// memory_set_bankptr - set the base of a bank
+// set_bankptr - set the base of a bank
//-------------------------------------------------
-void memory_set_bankptr(running_machine &machine, const char *tag, void *base)
+void memory_manager::set_bankptr(const char *tag, void *base)
{
- memory_set_bankptr(machine.root_device(), tag, base);
+ set_bankptr(machine().root_device(), tag, base);
}
-
-//-------------------------------------------------
-// memory_set_bankptr - set the base of a bank
-//-------------------------------------------------
-
-void memory_set_bankptr(device_t &device, const char *tag, void *base)
+void memory_manager::set_bankptr(device_t &device, const char *tag, void *base)
{
// validation checks
astring fulltag;
- memory_bank *bank = device.machine().memory_data->bankmap.find_hash_only(device.subtag(fulltag, tag));
+ memory_bank *bank = m_bankmap.find_hash_only(device.subtag(fulltag, tag));
if (bank == NULL)
throw emu_fatalerror("memory_set_bankptr called for unknown bank '%s'", fulltag.cstr());
@@ -1923,40 +1697,35 @@ void memory_set_bankptr(device_t &device, const char *tag, void *base)
//-------------------------------------------------
-// memory_get_shared - get a pointer to a shared
-// memory region by tag
+// shared - get a pointer to a shared memory
+// region by tag
//-------------------------------------------------
-void *memory_get_shared(running_machine &machine, const char *tag)
+memory_share *memory_manager::shared(const char *tag)
{
- size_t size;
- return memory_get_shared(machine, tag, size);
+ return shared(machine().root_device(), tag);
}
-void *memory_get_shared(running_machine &machine, const char *tag, size_t &length)
+memory_share *memory_manager::shared(device_t &device, const char *tag)
{
astring fulltag;
- memory_share *share = machine.memory_data->sharemap.find(machine.root_device().subtag(fulltag, tag));
- if (share == NULL)
- return NULL;
- length = share->size();
- return share->ptr();
+ return m_sharelist.find(device.subtag(fulltag, tag).cstr());
}
//-------------------------------------------------
-// memory_dump - dump the internal memory tables
-// to the given file
+// dump - dump the internal memory tables to the
+// given file
//-------------------------------------------------
-void memory_dump(running_machine &machine, FILE *file)
+void memory_manager::dump(FILE *file)
{
// skip if we can't open the file
if (file == NULL)
return;
// loop over address spaces
- for (address_space *space = machine.memory_data->spacelist.first(); space != NULL; space = space->next())
+ for (address_space *space = m_spacelist.first(); space != NULL; space = space->next())
{
fprintf(file, "\n\n"
"====================================================\n"
@@ -1984,7 +1753,7 @@ static void generate_memdump(running_machine &machine)
FILE *file = fopen("memdump.log", "w");
if (file)
{
- memory_dump(machine, file);
+ machine.memory().dump(file);
fclose(file);
}
}
@@ -1995,10 +1764,10 @@ static void generate_memdump(running_machine &machine)
// bank_reattach - reconnect banks after a load
//-------------------------------------------------
-static void bank_reattach(running_machine &machine)
+void memory_manager::bank_reattach()
{
// for each non-anonymous bank, explicitly reset its entry
- for (memory_bank *bank = machine.memory_data->banklist.first(); bank != NULL; bank = bank->next())
+ for (memory_bank *bank = m_banklist.first(); bank != NULL; bank = bank->next())
if (!bank->anonymous() && bank->entry() != BANK_ENTRY_UNSPECIFIED)
bank->set_entry(bank->entry());
}
@@ -2013,7 +1782,7 @@ static void bank_reattach(running_machine &machine)
// address_space - constructor
//-------------------------------------------------
-address_space::address_space(device_memory_interface &memory, address_spacenum spacenum, bool large)
+address_space::address_space(memory_manager &manager, device_memory_interface &memory, address_spacenum spacenum, bool large)
: m_next(NULL),
m_config(*memory.space_config(spacenum)),
m_device(memory.device()),
@@ -2030,6 +1799,7 @@ address_space::address_space(device_memory_interface &memory, address_spacenum s
m_name(memory.space_config(spacenum)->name()),
m_addrchars((m_config.m_addrbus_width + 3) / 4),
m_logaddrchars((m_config.m_logaddr_width + 3) / 4),
+ m_manager(manager),
m_machine(memory.device().machine())
{
// notify the device
@@ -2052,7 +1822,7 @@ address_space::~address_space()
// allocate - static smart allocator of subtypes
//-------------------------------------------------
-address_space &address_space::allocate(running_machine &machine, const address_space_config &config, device_memory_interface &memory, address_spacenum spacenum)
+address_space &address_space::allocate(memory_manager &manager, const address_space_config &config, device_memory_interface &memory, address_spacenum spacenum)
{
// allocate one of the appropriate type
bool large = (config.addr2byte_end(0xffffffffUL >> (32 - config.m_addrbus_width)) >= (1 << 18));
@@ -2063,64 +1833,64 @@ address_space &address_space::allocate(running_machine &machine, const address_s
if (config.endianness() == ENDIANNESS_LITTLE)
{
if (large)
- return *auto_alloc(machine, address_space_8le_large(memory, spacenum));
+ return *global_alloc(address_space_8le_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_8le_small(memory, spacenum));
+ return *global_alloc(address_space_8le_small(manager, memory, spacenum));
}
else
{
if (large)
- return *auto_alloc(machine, address_space_8be_large(memory, spacenum));
+ return *global_alloc(address_space_8be_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_8be_small(memory, spacenum));
+ return *global_alloc(address_space_8be_small(manager, memory, spacenum));
}
case 16:
if (config.endianness() == ENDIANNESS_LITTLE)
{
if (large)
- return *auto_alloc(machine, address_space_16le_large(memory, spacenum));
+ return *global_alloc(address_space_16le_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_16le_small(memory, spacenum));
+ return *global_alloc(address_space_16le_small(manager, memory, spacenum));
}
else
{
if (large)
- return *auto_alloc(machine, address_space_16be_large(memory, spacenum));
+ return *global_alloc(address_space_16be_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_16be_small(memory, spacenum));
+ return *global_alloc(address_space_16be_small(manager, memory, spacenum));
}
case 32:
if (config.endianness() == ENDIANNESS_LITTLE)
{
if (large)
- return *auto_alloc(machine, address_space_32le_large(memory, spacenum));
+ return *global_alloc(address_space_32le_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_32le_small(memory, spacenum));
+ return *global_alloc(address_space_32le_small(manager, memory, spacenum));
}
else
{
if (large)
- return *auto_alloc(machine, address_space_32be_large(memory, spacenum));
+ return *global_alloc(address_space_32be_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_32be_small(memory, spacenum));
+ return *global_alloc(address_space_32be_small(manager, memory, spacenum));
}
case 64:
if (config.endianness() == ENDIANNESS_LITTLE)
{
if (large)
- return *auto_alloc(machine, address_space_64le_large(memory, spacenum));
+ return *global_alloc(address_space_64le_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_64le_small(memory, spacenum));
+ return *global_alloc(address_space_64le_small(manager, memory, spacenum));
}
else
{
if (large)
- return *auto_alloc(machine, address_space_64be_large(memory, spacenum));
+ return *global_alloc(address_space_64be_large(manager, memory, spacenum));
else
- return *auto_alloc(machine, address_space_64be_small(memory, spacenum));
+ return *global_alloc(address_space_64be_small(manager, memory, spacenum));
}
}
throw emu_fatalerror("Invalid width %d specified for address_space::allocate", config.data_width());
@@ -2190,11 +1960,11 @@ void address_space::prepare_map()
{
// if we can't find it, add it to our map
astring fulltag;
- if (machine().memory_data->sharemap.find(device().siblingtag(fulltag, entry->m_share)) == NULL)
+ if (manager().m_sharelist.find(device().siblingtag(fulltag, entry->m_share).cstr()) == NULL)
{
VPRINTF(("Creating share '%s' of length 0x%X\n", fulltag.cstr(), entry->m_byteend + 1 - entry->m_bytestart));
- memory_share *share = auto_alloc(machine(), memory_share(entry->m_byteend + 1 - entry->m_bytestart));
- machine().memory_data->sharemap.add(fulltag, share, false);
+ memory_share *share = auto_alloc(machine(), memory_share(m_map->m_databits, entry->m_byteend + 1 - entry->m_bytestart));
+ manager().m_sharelist.append(fulltag, *share);
}
}
@@ -2399,14 +2169,14 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
void address_space::allocate_memory()
{
- simple_list<memory_block> &blocklist = machine().memory_data->blocklist;
+ simple_list<memory_block> &blocklist = manager().m_blocklist;
// make a first pass over the memory map and track blocks with hardcoded pointers
// we do this to make sure they are found by space_find_backing_memory first
memory_block *prev_memblock_tail = blocklist.last();
for (address_map_entry *entry = m_map->m_entrylist.first(); entry != NULL; entry = entry->next())
if (entry->m_memory != NULL)
- blocklist.append(*auto_alloc(machine(), memory_block(*this, entry->m_bytestart, entry->m_byteend, entry->m_memory)));
+ blocklist.append(*global_alloc(memory_block(*this, entry->m_bytestart, entry->m_byteend, entry->m_memory)));
// loop over all blocks just allocated and assign pointers from them
address_map_entry *unassigned = NULL;
@@ -2453,7 +2223,7 @@ void address_space::allocate_memory()
// we now have a block to allocate; do it
offs_t curbytestart = curblockstart * MEMORY_BLOCK_CHUNK;
offs_t curbyteend = curblockend * MEMORY_BLOCK_CHUNK + (MEMORY_BLOCK_CHUNK - 1);
- memory_block &block = blocklist.append(*auto_alloc(machine(), memory_block(*this, curbytestart, curbyteend)));
+ memory_block &block = blocklist.append(*global_alloc(memory_block(*this, curbytestart, curbyteend)));
// assign memory that intersected the new block
unassigned = block_assign_intersecting(curbytestart, curbyteend, block.data());
@@ -2482,7 +2252,7 @@ void address_space::locate_memory()
}
// once this is done, find the starting bases for the banks
- for (memory_bank *bank = machine().memory_data->banklist.first(); bank != NULL; bank = bank->next())
+ for (memory_bank *bank = manager().m_banklist.first(); bank != NULL; bank = bank->next())
if (bank->base() == NULL && bank->references_space(*this, ROW_READWRITE))
{
// set the initial bank pointer
@@ -2513,7 +2283,7 @@ void address_space::set_decrypted_region(offs_t addrstart, offs_t addrend, void
bool found = false;
// loop over banks looking for a match
- for (memory_bank *bank = machine().memory_data->banklist.first(); bank != NULL; bank = bank->next())
+ for (memory_bank *bank = manager().m_banklist.first(); bank != NULL; bank = bank->next())
{
// consider this bank if it is used for reading and matches the address space
if (bank->references_space(*this, ROW_READ))
@@ -2545,7 +2315,6 @@ void address_space::set_decrypted_region(offs_t addrstart, offs_t addrend, void
address_map_entry *address_space::block_assign_intersecting(offs_t bytestart, offs_t byteend, UINT8 *base)
{
- memory_private *memdata = machine().memory_data;
address_map_entry *unassigned = NULL;
// loop over the adjusted map and assign memory to any blocks we can
@@ -2555,7 +2324,7 @@ address_map_entry *address_space::block_assign_intersecting(offs_t bytestart, of
if (entry->m_memory == NULL && entry->m_share != NULL)
{
astring fulltag;
- memory_share *share = memdata->sharemap.find(device().siblingtag(fulltag, entry->m_share));
+ memory_share *share = manager().m_sharelist.find(device().siblingtag(fulltag, entry->m_share).cstr());
if (share != NULL && share->ptr() != NULL)
{
entry->m_memory = share->ptr();
@@ -2578,7 +2347,7 @@ address_map_entry *address_space::block_assign_intersecting(offs_t bytestart, of
if (entry->m_memory != NULL && entry->m_share != NULL)
{
astring fulltag;
- memory_share *share = memdata->sharemap.find(device().siblingtag(fulltag, entry->m_share));
+ memory_share *share = manager().m_sharelist.find(device().siblingtag(fulltag, entry->m_share).cstr());
if (share != NULL && share->ptr() == NULL)
{
share->set_ptr(entry->m_memory);
@@ -2749,8 +2518,6 @@ void address_space::install_bank_generic(offs_t addrstart, offs_t addrend, offs_
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 = machine().memory_data;
-
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),
@@ -2777,11 +2544,11 @@ void *address_space::install_ram_generic(offs_t addrstart, offs_t addrend, offs_
}
// if we still don't have a pointer, and we're past the initialization phase, allocate a new block
- if (bank.base() == NULL && memdata->initialized)
+ if (bank.base() == NULL && manager().m_initialized)
{
if (machine().phase() >= MACHINE_PHASE_RESET)
fatalerror("Attempted to call install_ram_generic() after initialization time without a baseptr!");
- memory_block &block = memdata->blocklist.append(*auto_alloc(machine(), memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
+ memory_block &block = manager().m_blocklist.append(*global_alloc(memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
bank.set_base(block.data());
}
}
@@ -2806,11 +2573,11 @@ void *address_space::install_ram_generic(offs_t addrstart, offs_t addrend, offs_
}
// if we still don't have a pointer, and we're past the initialization phase, allocate a new block
- if (bank.base() == NULL && memdata->initialized)
+ if (bank.base() == NULL && manager().m_initialized)
{
if (machine().phase() >= MACHINE_PHASE_RESET)
fatalerror("Attempted to call install_ram_generic() after initialization time without a baseptr!");
- memory_block &block = memdata->blocklist.append(*auto_alloc(machine(), memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
+ memory_block &block = manager().m_blocklist.append(*global_alloc(memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
bank.set_base(block.data());
}
}
@@ -3199,7 +2966,7 @@ void *address_space::find_backing_memory(offs_t addrstart, offs_t addrend)
}
// if not found there, look in the allocated blocks
- for (memory_block *block = machine().memory_data->blocklist.first(); block != NULL; block = block->next())
+ for (memory_block *block = manager().m_blocklist.first(); block != NULL; block = block->next())
if (block->contains(*this, bytestart, byteend))
{
VPRINTF(("found in allocated memory block %08X-%08X [%p]\n", block->bytestart(), block->byteend(), block->data() + (bytestart - block->bytestart())));
@@ -3227,7 +2994,7 @@ bool address_space::needs_backing_store(const address_map_entry *entry)
if (entry->m_share != NULL)
{
astring fulltag;
- memory_share *share = machine().memory_data->sharemap.find(device().siblingtag(fulltag, entry->m_share));
+ memory_share *share = manager().m_sharelist.find(device().siblingtag(fulltag, entry->m_share).cstr());
if (share != NULL && share->ptr() == NULL)
return true;
}
@@ -3260,8 +3027,6 @@ bool address_space::needs_backing_store(const address_map_entry *entry)
memory_bank &address_space::bank_find_or_allocate(const char *tag, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite)
{
- memory_private *memdata = machine().memory_data;
-
// adjust the addresses, handling mirrors and such
offs_t bytemirror = addrmirror;
offs_t bytestart = addrstart;
@@ -3272,11 +3037,11 @@ memory_bank &address_space::bank_find_or_allocate(const char *tag, offs_t addrst
// if this bank is named, look it up
memory_bank *bank = NULL;
if (tag != NULL)
- bank = memdata->bankmap.find_hash_only(tag);
+ bank = manager().m_bankmap.find_hash_only(tag);
// else try to find an exact match
else
- for (bank = memdata->banklist.first(); bank != NULL; bank = bank->next())
+ for (bank = manager().m_banklist.first(); bank != NULL; bank = bank->next())
if (bank->anonymous() && bank->references_space(*this, ROW_READWRITE) && bank->matches_exactly(bytestart, byteend))
break;
@@ -3284,7 +3049,7 @@ memory_bank &address_space::bank_find_or_allocate(const char *tag, offs_t addrst
if (bank == NULL)
{
// handle failure
- int banknum = memdata->banknext++;
+ int banknum = manager().m_banknext++;
if (banknum > STATIC_BANKMAX)
{
if (tag != NULL)
@@ -3294,12 +3059,12 @@ memory_bank &address_space::bank_find_or_allocate(const char *tag, offs_t addrst
}
// allocate the bank
- bank = auto_alloc(machine(), memory_bank(*this, banknum, bytestart, byteend, tag));
- memdata->banklist.append(*bank);
+ bank = global_alloc(memory_bank(*this, banknum, bytestart, byteend, tag));
+ manager().m_banklist.append(*bank);
// for named banks, add to the map and register for save states
if (tag != NULL)
- memdata->bankmap.add_unique_hash(tag, bank, false);
+ manager().m_bankmap.add_unique_hash(tag, bank, false);
}
// add a reference for this space
@@ -4145,7 +3910,7 @@ const char *address_table::handler_name(UINT8 entry) const
// banks have names
if (entry >= STATIC_BANK1 && entry <= STATIC_BANKMAX)
- for (memory_bank *info = m_space.machine().memory_data->banklist.first(); info != NULL; info = info->next())
+ for (memory_bank *info = m_space.manager().first_bank(); info != NULL; info = info->next())
if (info->index() == entry)
return info->name();
@@ -4173,7 +3938,7 @@ address_table_read::address_table_read(address_space &space, bool large)
// allocate handlers for each entry, prepopulating the bankptrs for banks
for (int entrynum = 0; entrynum < ARRAY_LENGTH(m_handlers); entrynum++)
{
- UINT8 **bankptr = (entrynum >= STATIC_BANK1 && entrynum <= STATIC_BANKMAX) ? &space.machine().memory_data->bank_ptr[entrynum] : NULL;
+ UINT8 **bankptr = (entrynum >= STATIC_BANK1 && entrynum <= STATIC_BANKMAX) ? space.manager().bank_pointer_addr(entrynum) : NULL;
m_handlers[entrynum] = auto_alloc(space.machine(), handler_entry_read(space.data_width(), space.endianness(), bankptr));
}
@@ -4249,7 +4014,7 @@ address_table_write::address_table_write(address_space &space, bool large)
// allocate handlers for each entry, prepopulating the bankptrs for banks
for (int entrynum = 0; entrynum < ARRAY_LENGTH(m_handlers); entrynum++)
{
- UINT8 **bankptr = (entrynum >= STATIC_BANK1 && entrynum <= STATIC_BANKMAX) ? &space.machine().memory_data->bank_ptr[entrynum] : NULL;
+ UINT8 **bankptr = (entrynum >= STATIC_BANK1 && entrynum <= STATIC_BANKMAX) ? space.manager().bank_pointer_addr(entrynum) : NULL;
m_handlers[entrynum] = auto_alloc(space.machine(), handler_entry_write(space.data_width(), space.endianness(), bankptr));
}
@@ -4379,8 +4144,8 @@ bool direct_read_data::set_direct_region(offs_t &byteaddress)
}
// if no decrypted opcodes, point to the same base
- UINT8 *base = m_space.machine().memory_data->bank_ptr[m_entry];
- UINT8 *based = m_space.machine().memory_data->bankd_ptr[m_entry];
+ UINT8 *base = *m_space.manager().bank_pointer_addr(m_entry, false);
+ UINT8 *based = *m_space.manager().bank_pointer_addr(m_entry, true);
if (based == NULL)
based = base;
@@ -4559,8 +4324,8 @@ memory_block::~memory_block()
memory_bank::memory_bank(address_space &space, int index, offs_t bytestart, offs_t byteend, const char *tag)
: m_next(NULL),
m_machine(space.machine()),
- m_baseptr(&space.machine().memory_data->bank_ptr[index]),
- m_basedptr(&space.machine().memory_data->bankd_ptr[index]),
+ m_baseptr(space.manager().bank_pointer_addr(index, false)),
+ m_basedptr(space.manager().bank_pointer_addr(index, true)),
m_index(index),
m_anonymous(tag == NULL),
m_bytestart(bytestart),
@@ -4621,7 +4386,7 @@ void memory_bank::add_reference(address_space &space, read_or_write readorwrite)
// if we already have a reference, skip it
if (references_space(space, readorwrite))
return;
- m_reflist.append(*auto_alloc(space.machine(), bank_reference(space, readorwrite)));
+ m_reflist.append(*global_alloc(bank_reference(space, readorwrite)));
}
@@ -5888,3 +5653,21 @@ void handler_entry_write::write_stub_legacy(address_space &space, offs_t offset,
{
m_legacy_info.handler.space64(m_legacy_info.object.space, offset, data, mask);
}
+
+
+
+// configure the addresses for a bank
+void memory_configure_bank(running_machine &machine, const char *tag, int startentry, int numentries, void *base, offs_t stride) { machine.memory().configure_bank(tag, startentry, numentries, base, stride); }
+void memory_configure_bank(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride) { device.machine().memory().configure_bank(device, tag, startentry, numentries, base, stride); }
+
+// configure the decrypted addresses for a bank
+void memory_configure_bank_decrypted(running_machine &machine, const char *tag, int startentry, int numentries, void *base, offs_t stride) { machine.memory().configure_bank_decrypted(tag, startentry, numentries, base, stride); }
+void memory_configure_bank_decrypted(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride) { device.machine().memory().configure_bank_decrypted(device, tag, startentry, numentries, base, stride); }
+
+// select one pre-configured entry to be the new bank base
+void memory_set_bank(running_machine &machine, const char *tag, int entrynum) { machine.memory().set_bank(tag, entrynum); }
+void memory_set_bank(device_t &device, const char *tag, int entrynum) { device.machine().memory().set_bank(device, tag, entrynum); }
+
+// set the absolute address of a bank base
+void memory_set_bankptr(running_machine &machine, const char *tag, void *base) { machine.memory().set_bankptr(tag, base); }
+void memory_set_bankptr(device_t &device, const char *tag, void *base) { device.machine().memory().set_bankptr(device, tag, base); }
diff --git a/src/emu/memory.h b/src/emu/memory.h
index 717b77eeaf5..aa81d9e8130 100644
--- a/src/emu/memory.h
+++ b/src/emu/memory.h
@@ -90,7 +90,10 @@ struct game_driver;
// forward declarations of classes defined here
class address_map;
class address_map_entry;
+class memory_manager;
class memory_bank;
+class memory_block;
+class memory_share;
class direct_read_data;
class address_space;
class address_table;
@@ -302,15 +305,16 @@ class address_space
protected:
// construction/destruction
- address_space(device_memory_interface &memory, address_spacenum spacenum, bool large);
+ address_space(memory_manager &manager, device_memory_interface &memory, address_spacenum spacenum, bool large);
virtual ~address_space();
public:
// public allocator
- static address_space &allocate(running_machine &machine, const address_space_config &config, device_memory_interface &memory, address_spacenum spacenum);
+ static address_space &allocate(memory_manager &manager, const address_space_config &config, device_memory_interface &memory, address_spacenum spacenum);
// getters
address_space *next() const { return m_next; }
+ memory_manager &manager() const { return m_manager; }
device_t &device() const { return m_device; }
running_machine &machine() const { return m_machine; }
const char *name() const { return m_name; }
@@ -554,10 +558,254 @@ protected:
UINT8 m_logaddrchars; // number of characters to use for logical addresses
private:
+ memory_manager & m_manager; // reference to the owning manager
running_machine & m_machine; // reference to the owning machine
};
+// ======================> memory_block
+
+// a memory block is a chunk of RAM associated with a range of memory in a device's address space
+class memory_block
+{
+ DISABLE_COPYING(memory_block);
+
+ friend class simple_list<memory_block>;
+ friend resource_pool_object<memory_block>::~resource_pool_object();
+
+public:
+ // construction/destruction
+ memory_block(address_space &space, offs_t bytestart, offs_t byteend, void *memory = NULL);
+ ~memory_block();
+
+ // getters
+ running_machine &machine() const { return m_machine; }
+ memory_block *next() const { return m_next; }
+ offs_t bytestart() const { return m_bytestart; }
+ offs_t byteend() const { return m_byteend; }
+ UINT8 *data() const { return m_data; }
+
+ // is the given range contained by this memory block?
+ bool contains(address_space &space, offs_t bytestart, offs_t byteend) const
+ {
+ return (&space == &m_space && m_bytestart <= bytestart && m_byteend >= byteend);
+ }
+
+private:
+ // internal state
+ memory_block * m_next; // next memory block in the list
+ running_machine & m_machine; // need the machine to free our memory
+ address_space & m_space; // which address space are we associated with?
+ offs_t m_bytestart, m_byteend; // byte-normalized start/end for verifying a match
+ UINT8 * m_data; // pointer to the data for this block
+ UINT8 * m_allocated; // pointer to the actually allocated block
+};
+
+
+// ======================> memory_bank
+
+// a memory bank is a global pointer to memory that can be shared across devices and changed dynamically
+class memory_bank
+{
+ friend class simple_list<memory_bank>;
+ friend resource_pool_object<memory_bank>::~resource_pool_object();
+
+ // a bank reference is an entry in a list of address spaces that reference a given bank
+ class bank_reference
+ {
+ friend class simple_list<bank_reference>;
+ friend resource_pool_object<bank_reference>::~resource_pool_object();
+
+ public:
+ // construction/destruction
+ bank_reference(address_space &space, read_or_write readorwrite)
+ : m_next(NULL),
+ m_space(space),
+ m_readorwrite(readorwrite) { }
+
+ // getters
+ bank_reference *next() const { return m_next; }
+ address_space &space() const { return m_space; }
+
+ // does this reference match the space+read/write combination?
+ bool matches(address_space &space, read_or_write readorwrite) const
+ {
+ return (&space == &m_space && (readorwrite == ROW_READWRITE || readorwrite == m_readorwrite));
+ }
+
+ private:
+ // internal state
+ bank_reference * m_next; // link to the next reference
+ address_space & m_space; // address space that references us
+ read_or_write m_readorwrite; // used for read or write?
+ };
+
+ // a bank_entry contains a raw and decrypted pointer
+ struct bank_entry
+ {
+ UINT8 * m_raw;
+ UINT8 * m_decrypted;
+ };
+
+public:
+ // construction/destruction
+ memory_bank(address_space &space, int index, offs_t bytestart, offs_t byteend, const char *tag = NULL);
+ ~memory_bank();
+
+ // getters
+ memory_bank *next() const { return m_next; }
+ running_machine &machine() const { return m_machine; }
+ int index() const { return m_index; }
+ int entry() const { return m_curentry; }
+ bool anonymous() const { return m_anonymous; }
+ offs_t bytestart() const { return m_bytestart; }
+ void *base() const { return *m_baseptr; }
+ void *base_decrypted() const { return *m_basedptr; }
+ const char *tag() const { return m_tag; }
+ const char *name() const { return m_name; }
+
+ // compare a range against our range
+ bool matches_exactly(offs_t bytestart, offs_t byteend) const { return (m_bytestart == bytestart && m_byteend == byteend); }
+ bool fully_covers(offs_t bytestart, offs_t byteend) const { return (m_bytestart <= bytestart && m_byteend >= byteend); }
+ bool is_covered_by(offs_t bytestart, offs_t byteend) const { return (m_bytestart >= bytestart && m_byteend <= byteend); }
+ bool straddles(offs_t bytestart, offs_t byteend) const { return (m_bytestart < byteend && m_byteend > bytestart); }
+
+ // track and verify address space references to this bank
+ bool references_space(address_space &space, read_or_write readorwrite) const;
+ void add_reference(address_space &space, read_or_write readorwrite);
+
+ // set the base explicitly
+ void set_base(void *base);
+ void set_base_decrypted(void *base);
+
+ // configure and set entries
+ void configure(int entrynum, void *base);
+ void configure_decrypted(int entrynum, void *base);
+ void set_entry(int entrynum);
+
+private:
+ // internal helpers
+ void invalidate_references();
+ void expand_entries(int entrynum);
+
+ // internal state
+ memory_bank * m_next; // next bank in sequence
+ running_machine & m_machine; // need the machine to free our memory
+ UINT8 ** m_baseptr; // pointer to our base pointer in the global array
+ UINT8 ** m_basedptr; // same for the decrypted base pointer
+ UINT8 m_index; // array index for this handler
+ bool m_anonymous; // are we anonymous or explicit?
+ offs_t m_bytestart; // byte-adjusted start offset
+ offs_t m_byteend; // byte-adjusted end offset
+ int m_curentry; // current entry
+ bank_entry * m_entry; // array of entries (dynamically allocated)
+ int m_entry_count; // number of allocated entries
+ astring m_name; // friendly name for this bank
+ astring m_tag; // tag for this bank
+ simple_list<bank_reference> m_reflist; // linked list of address spaces referencing this bank
+};
+
+
+// ======================> memory_share
+
+// a memory share contains information about shared memory region
+class memory_share
+{
+ friend class simple_list<memory_share>;
+
+public:
+ // construction/destruction
+ memory_share(UINT8 width, size_t bytes, void *ptr = NULL)
+ : m_ptr(ptr),
+ m_bytes(bytes),
+ m_width(width) { }
+
+ // getters
+ memory_share *next() const { return m_next; }
+ void *ptr() const { return m_ptr; }
+ size_t bytes() const { return m_bytes; }
+ UINT8 width() const { return m_width; }
+
+ // setters
+ void set_ptr(void *ptr) { m_ptr = ptr; }
+
+private:
+ // internal state
+ memory_share * m_next; // next share in the list
+ void * m_ptr; // pointer to the memory backing the region
+ size_t m_bytes; // size of the shared region in bytes
+ UINT8 m_width; // width of the shared region
+};
+
+
+// ======================> memory_manager
+
+// holds internal state for the memory system
+class memory_manager
+{
+ friend class address_space;
+
+public:
+ // construction/destruction
+ memory_manager(running_machine &machine);
+
+ // getters
+ running_machine &machine() const { return m_machine; }
+ address_space *first_space() const { return m_spacelist.first(); }
+ memory_bank *first_bank() const { return m_banklist.first(); }
+
+ // configure the addresses for a bank
+ void configure_bank(const char *tag, int startentry, int numentries, void *base, offs_t stride);
+ void configure_bank(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride);
+
+ // configure the decrypted addresses for a bank
+ void configure_bank_decrypted(const char *tag, int startentry, int numentries, void *base, offs_t stride);
+ void configure_bank_decrypted(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride);
+
+ // select one pre-configured entry to be the new bank base
+ void set_bank(const char *tag, int entrynum);
+ void set_bank(device_t &device, const char *tag, int entrynum);
+
+ // return the currently selected bank
+ int bank(const char *tag);
+ int bank(device_t &device, const char *tag);
+
+ // set the absolute address of a bank base
+ void set_bankptr(const char *tag, void *base) ATTR_NONNULL(3);
+ void set_bankptr(device_t &device, const char *tag, void *base) ATTR_NONNULL(3);
+
+ // get a pointer to a shared memory region by tag
+ memory_share *shared(const char *tag);
+ memory_share *shared(device_t &device, const char *tag);
+
+ // dump the internal memory tables to the given file
+ void dump(FILE *file);
+
+ // pointers to a bank pointer (internal usage only)
+ UINT8 **bank_pointer_addr(UINT8 index, bool decrypted = false) { return decrypted ? &m_bankd_ptr[index] : &m_bank_ptr[index]; }
+
+private:
+ // internal helpers
+ void bank_reattach();
+
+ // internal state
+ running_machine & m_machine; // reference to the machine
+ bool m_initialized; // have we completed initialization?
+
+ UINT8 * m_bank_ptr[256]; // array of bank pointers
+ UINT8 * m_bankd_ptr[256]; // array of decrypted bank pointers
+
+ simple_list<address_space> m_spacelist; // list of address spaces
+ simple_list<memory_block> m_blocklist; // head of the list of memory blocks
+
+ simple_list<memory_bank> m_banklist; // data gathered for each bank
+ tagmap_t<memory_bank *> m_bankmap; // map for fast bank lookups
+ UINT8 m_banknext; // next bank to allocate
+
+ tagged_list<memory_share> m_sharelist; // map for share lookups
+};
+
+
//**************************************************************************
// MACROS
@@ -671,9 +919,6 @@ extern const char *const address_space_names[ADDRESS_SPACES];
// FUNCTION PROTOTYPES FOR CORE MEMORY FUNCTIONS
//**************************************************************************
-// initialize the memory system
-void memory_init(running_machine &machine);
-
// configure the addresses for a bank
void memory_configure_bank(running_machine &machine, const char *tag, int startentry, int numentries, void *base, offs_t stride) ATTR_NONNULL(5);
void memory_configure_bank(device_t &device, const char *tag, int startentry, int numentries, void *base, offs_t stride) ATTR_NONNULL(5);
@@ -686,22 +931,10 @@ void memory_configure_bank_decrypted(device_t &device, const char *tag, int star
void memory_set_bank(running_machine &machine, const char *tag, int entrynum);
void memory_set_bank(device_t &device, const char *tag, int entrynum);
-// return the currently selected bank
-int memory_get_bank(running_machine &machine, const char *tag);
-int memory_get_bank(device_t &device, const char *tag);
-
// set the absolute address of a bank base
void memory_set_bankptr(running_machine &machine, const char *tag, void *base) ATTR_NONNULL(3);
void memory_set_bankptr(device_t &device, const char *tag, void *base) ATTR_NONNULL(3);
-// get a pointer to a shared memory region by tag
-void *memory_get_shared(running_machine &machine, const char *tag);
-void *memory_get_shared(running_machine &machine, const char *tag, size_t &length);
-
-// dump the internal memory tables to the given file
-void memory_dump(running_machine &machine, FILE *file);
-
-address_space *memory_nonspecific_space(running_machine &machine);
//**************************************************************************
@@ -808,5 +1041,4 @@ inline UINT64 direct_read_data::read_decrypted_qword(offs_t byteaddress, offs_t
return m_space.read_qword(byteaddress);
}
-
#endif /* __MEMORY_H__ */
diff --git a/src/emu/sound/spu.c b/src/emu/sound/spu.c
index 57a806ce59f..fd8fa159373 100644
--- a/src/emu/sound/spu.c
+++ b/src/emu/sound/spu.c
@@ -3090,14 +3090,14 @@ void spu_device::flush_cdda(const unsigned int sector)
void spu_device::dma_read( UINT32 n_address, INT32 n_size )
{
- UINT8 *psxram = (UINT8 *)memory_get_shared(machine(), "share1");
+ UINT8 *psxram = (UINT8 *)machine().memory().shared("share1")->ptr();
start_dma(psxram + n_address, false, n_size*4);
}
void spu_device::dma_write( UINT32 n_address, INT32 n_size )
{
- UINT8 *psxram = (UINT8 *)memory_get_shared(machine(), "share1");
+ UINT8 *psxram = (UINT8 *)machine().memory().shared("share1")->ptr();
// printf("SPU DMA write from %x, size %x\n", n_address, n_size);
diff --git a/src/mame/audio/atarijsa.c b/src/mame/audio/atarijsa.c
index 4555caa2a8d..1517aa58c5d 100644
--- a/src/mame/audio/atarijsa.c
+++ b/src/mame/audio/atarijsa.c
@@ -548,7 +548,7 @@ static WRITE8_HANDLER( jsa3_io_w )
/* update the OKI bank */
if (oki6295 != NULL)
- memory_set_bank(space->machine(), "bank12", (memory_get_bank(space->machine(), "bank12") & 2) | ((data >> 1) & 1));
+ memory_set_bank(space->machine(), "bank12", (space->machine().memory().bank("bank12") & 2) | ((data >> 1) & 1));
/* update the bank */
memcpy(bank_base, &bank_source_data[0x1000 * ((data >> 6) & 3)], 0x1000);
@@ -572,7 +572,7 @@ static WRITE8_HANDLER( jsa3_io_w )
/* update the OKI bank */
if (oki6295 != NULL)
- memory_set_bank(space->machine(), "bank12", (memory_get_bank(space->machine(), "bank12") & 1) | ((data >> 3) & 2));
+ memory_set_bank(space->machine(), "bank12", (space->machine().memory().bank("bank12") & 1) | ((data >> 3) & 2));
/* update the volumes */
ym2151_volume = ((data >> 1) & 7) * 100 / 7;
@@ -681,7 +681,7 @@ static WRITE8_HANDLER( jsa3s_io_w )
if ((data&1) == 0) devtag_reset(space->machine(), "ymsnd");
/* update the OKI bank */
- memory_set_bank(space->machine(), "bank12", (memory_get_bank(space->machine(), "bank12") & 2) | ((data >> 1) & 1));
+ memory_set_bank(space->machine(), "bank12", (space->machine().memory().bank("bank12") & 2) | ((data >> 1) & 1));
/* update the bank */
memcpy(bank_base, &bank_source_data[0x1000 * ((data >> 6) & 3)], 0x1000);
@@ -705,7 +705,7 @@ static WRITE8_HANDLER( jsa3s_io_w )
*/
/* update the OKI bank */
- memory_set_bank(space->machine(), "bank12", (memory_get_bank(space->machine(), "bank12") & 1) | ((data >> 3) & 2));
+ memory_set_bank(space->machine(), "bank12", (space->machine().memory().bank("bank12") & 1) | ((data >> 3) & 2));
memory_set_bank(space->machine(), "bank14", data >> 6);
/* update the volumes */
diff --git a/src/mame/audio/dcs.c b/src/mame/audio/dcs.c
index 54c2615bf29..d182898a48c 100644
--- a/src/mame/audio/dcs.c
+++ b/src/mame/audio/dcs.c
@@ -943,8 +943,8 @@ void dcs_init(running_machine &machine)
memset(&dcs, 0, sizeof(dcs));
dcs.sram = NULL;
- dcs.internal_program_ram = (UINT32 *)memory_get_shared(machine, "dcsint");
- dcs.external_program_ram = (UINT32 *)memory_get_shared(machine, "dcsext");
+ dcs.internal_program_ram = (UINT32 *)machine.memory().shared("dcsint")->ptr();
+ dcs.external_program_ram = (UINT32 *)machine.memory().shared("dcsext")->ptr();
/* find the DCS CPU and the sound ROMs */
dcs.cpu = machine.device<adsp21xx_device>("dcs");
@@ -982,8 +982,8 @@ void dcs2_init(running_machine &machine, int dram_in_mb, offs_t polling_offset)
int soundbank_words;
memset(&dcs, 0, sizeof(dcs));
- dcs.internal_program_ram = (UINT32 *)memory_get_shared(machine, "dcsint");
- dcs.external_program_ram = (UINT32 *)memory_get_shared(machine, "dcsext");
+ dcs.internal_program_ram = (UINT32 *)machine.memory().shared("dcsint")->ptr();
+ dcs.external_program_ram = (UINT32 *)machine.memory().shared("dcsext")->ptr();
/* find the DCS CPU and the sound ROMs */
dcs.cpu = machine.device<adsp21xx_device>("dcs2");
diff --git a/src/mame/audio/mcr.c b/src/mame/audio/mcr.c
index 2a4eb833a40..be8025b4ae2 100644
--- a/src/mame/audio/mcr.c
+++ b/src/mame/audio/mcr.c
@@ -533,18 +533,18 @@ static READ16_DEVICE_HANDLER( csdeluxe_pia_r )
/* low bytes. */
pia6821_device *pia = downcast<pia6821_device *>(device);
if (ACCESSING_BITS_8_15)
- return pia->read_alt(*memory_nonspecific_space(device->machine()), offset) << 8;
+ return pia->read_alt(*device->machine().memory().first_space(), offset) << 8;
else
- return pia->read_alt(*memory_nonspecific_space(device->machine()), offset);
+ return pia->read_alt(*device->machine().memory().first_space(), offset);
}
static WRITE16_DEVICE_HANDLER( csdeluxe_pia_w )
{
pia6821_device *pia = downcast<pia6821_device *>(device);
if (ACCESSING_BITS_8_15)
- pia->write_alt(*memory_nonspecific_space(device->machine()), offset, data >> 8);
+ pia->write_alt(*device->machine().memory().first_space(), offset, data >> 8);
else
- pia->write_alt(*memory_nonspecific_space(device->machine()), offset, data);
+ pia->write_alt(*device->machine().memory().first_space(), offset, data);
}
diff --git a/src/mame/audio/segasnd.c b/src/mame/audio/segasnd.c
index 9adc91eb917..def30f88400 100644
--- a/src/mame/audio/segasnd.c
+++ b/src/mame/audio/segasnd.c
@@ -736,7 +736,7 @@ static DEVICE_START( usb_sound )
assert(usb->cpu != NULL);
/* allocate RAM */
- usb->program_ram = (UINT8 *)memory_get_shared(device->machine(), "pgmram");
+ usb->program_ram = (UINT8 *)machine.memory().shared("pgmram")->ptr();
usb->work_ram = auto_alloc_array(machine, UINT8, 0x400);
/* create a sound stream */
diff --git a/src/mame/audio/taito_en.c b/src/mame/audio/taito_en.c
index 043e4faaeff..f76ea936c00 100644
--- a/src/mame/audio/taito_en.c
+++ b/src/mame/audio/taito_en.c
@@ -305,7 +305,7 @@ SOUND_RESET( taito_f3_soundsystem_reset )
{
/* Sound cpu program loads to 0xc00000 so we use a bank */
UINT16 *ROM = (UINT16 *)machine.region("audiocpu")->base();
- UINT16 *sound_ram = (UINT16 *)memory_get_shared(machine, "share1");
+ UINT16 *sound_ram = (UINT16 *)machine.memory().shared("share1")->ptr();
memory_set_bankptr(machine, "bank1",&ROM[0x80000]);
memory_set_bankptr(machine, "bank2",&ROM[0x90000]);
memory_set_bankptr(machine, "bank3",&ROM[0xa0000]);
@@ -319,7 +319,7 @@ SOUND_RESET( taito_f3_soundsystem_reset )
machine.device("audiocpu")->reset();
//cputag_set_input_line(machine, "audiocpu", INPUT_LINE_RESET, ASSERT_LINE);
- f3_shared_ram = (UINT32 *)memory_get_shared(machine, "f3_shared");
+ f3_shared_ram = (UINT32 *)machine.memory().shared("f3_shared")->ptr();
}
static const es5505_interface es5505_taito_f3_config =
diff --git a/src/mame/drivers/actfancr.c b/src/mame/drivers/actfancr.c
index d9954f656a8..47837c0032d 100644
--- a/src/mame/drivers/actfancr.c
+++ b/src/mame/drivers/actfancr.c
@@ -64,7 +64,7 @@ WRITE8_MEMBER(actfancr_state::actfancr_sound_w)
WRITE8_MEMBER(actfancr_state::actfancr_buffer_spriteram_w)
{
- UINT8 *src = reinterpret_cast<UINT8 *>(memory_get_shared(machine(), "spriteram"));
+ UINT8 *src = reinterpret_cast<UINT8 *>(machine().memory().shared("spriteram")->ptr());
// copy to a 16-bit region for our sprite draw code too
for (int i=0;i<0x800/2;i++)
{
diff --git a/src/mame/drivers/adp.c b/src/mame/drivers/adp.c
index 29260f0ebe9..30fea3a9b5b 100644
--- a/src/mame/drivers/adp.c
+++ b/src/mame/drivers/adp.c
@@ -276,7 +276,7 @@ static void duart_tx( device_t *device, int channel, UINT8 data )
adp_state *state = device->machine().driver_data<adp_state>();
if (channel == 0)
{
- state->m_microtouch->rx(*memory_nonspecific_space(device->machine()), 0, data);
+ state->m_microtouch->rx(*device->machine().memory().first_space(), 0, data);
}
}
diff --git a/src/mame/drivers/cd32.c b/src/mame/drivers/cd32.c
index 80e1bad5b07..c4e8057a398 100644
--- a/src/mame/drivers/cd32.c
+++ b/src/mame/drivers/cd32.c
@@ -1448,7 +1448,7 @@ static void serial_w(running_machine &machine, UINT16 data)
cd32_state *state = machine.driver_data<cd32_state>();
UINT8 data8 = data & 0xff;
if ( data8 != 0x00 )
- state->m_microtouch->rx(*memory_nonspecific_space(machine), 0, data8);
+ state->m_microtouch->rx(*machine.memory().first_space(), 0, data8);
}
WRITE8_MEMBER (cd32_state::microtouch_tx)
diff --git a/src/mame/drivers/ddragon.c b/src/mame/drivers/ddragon.c
index fe9ff0cfe26..eb6d7865fc5 100644
--- a/src/mame/drivers/ddragon.c
+++ b/src/mame/drivers/ddragon.c
@@ -268,7 +268,7 @@ static WRITE8_HANDLER( darktowr_mcu_bank_w )
static WRITE8_HANDLER( darktowr_bankswitch_w )
{
ddragon_state *state = space->machine().driver_data<ddragon_state>();
- int oldbank = memory_get_bank(space->machine(), "bank1");
+ int oldbank = space->machine().memory().bank("bank1");
int newbank = (data & 0xe0) >> 5;
state->m_scrollx_hi = (data & 0x01);
diff --git a/src/mame/drivers/meritm.c b/src/mame/drivers/meritm.c
index 5827e9de003..01bdec6c028 100644
--- a/src/mame/drivers/meritm.c
+++ b/src/mame/drivers/meritm.c
@@ -286,7 +286,7 @@ static void pc16650d_tx_callback(running_machine &machine, int channel, int coun
{
meritm_state *state = machine.driver_data<meritm_state>();
for(int i = 0; i < count; i++)
- state->m_microtouch->rx(*memory_nonspecific_space(machine), 0, data[i]);
+ state->m_microtouch->rx(*machine.memory().first_space(), 0, data[i]);
}
WRITE8_MEMBER(meritm_state::microtouch_tx)
diff --git a/src/mame/drivers/mpu4.c b/src/mame/drivers/mpu4.c
index e78aa6e86f7..1da7d967e14 100644
--- a/src/mame/drivers/mpu4.c
+++ b/src/mame/drivers/mpu4.c
@@ -528,7 +528,7 @@ WRITE8_MEMBER(mpu4_state::bankswitch_w)
READ8_MEMBER(mpu4_state::bankswitch_r)
{
- return memory_get_bank(machine(), "bank1");
+ return machine().memory().bank("bank1");
}
diff --git a/src/mame/drivers/r2dtank.c b/src/mame/drivers/r2dtank.c
index a77eb363c07..9c6a70d32ce 100644
--- a/src/mame/drivers/r2dtank.c
+++ b/src/mame/drivers/r2dtank.c
@@ -410,7 +410,7 @@ static const mc6845_interface mc6845_intf =
static WRITE8_DEVICE_HANDLER( pia_comp_w )
{
- downcast<pia6821_device *>(device)->write(*memory_nonspecific_space(device->machine()), offset, ~data);
+ downcast<pia6821_device *>(device)->write(*device->machine().memory().first_space(), offset, ~data);
}
diff --git a/src/mame/drivers/segac2.c b/src/mame/drivers/segac2.c
index af8ecc18787..f071300163b 100644
--- a/src/mame/drivers/segac2.c
+++ b/src/mame/drivers/segac2.c
@@ -111,7 +111,7 @@ static MACHINE_START( segac2 )
static MACHINE_RESET( segac2 )
{
segac2_state *state = machine.driver_data<segac2_state>();
- megadrive_ram = reinterpret_cast<UINT16 *>(memory_get_shared(machine, "nvram"));
+ megadrive_ram = reinterpret_cast<UINT16 *>(machine.memory().shared("nvram")->ptr());
/* set up interrupts and such */
MACHINE_RESET_CALL(megadriv);
diff --git a/src/mame/drivers/tmaster.c b/src/mame/drivers/tmaster.c
index 41727d3fdeb..5657fc68066 100644
--- a/src/mame/drivers/tmaster.c
+++ b/src/mame/drivers/tmaster.c
@@ -205,7 +205,7 @@ static void duart_tx(device_t *device, int channel, UINT8 data)
tmaster_state *state = device->machine().driver_data<tmaster_state>();
if ( channel == 0 )
{
- state->m_microtouch->rx(*memory_nonspecific_space(device->machine()), 0, data);
+ state->m_microtouch->rx(*device->machine().memory().first_space(), 0, data);
}
};
@@ -658,7 +658,7 @@ static void galgames_update_rombank(running_machine &machine, UINT32 cart)
state->m_gfx_offs = 0x200000 * cart;
- if (memory_get_bank(machine, GALGAMES_BANK_000000_R) == GALGAMES_RAM)
+ if (machine.memory().bank(GALGAMES_BANK_000000_R) == GALGAMES_RAM)
memory_set_bank(machine, GALGAMES_BANK_200000_R, GALGAMES_ROM0 + state->m_galgames_cart); // rom
memory_set_bank(machine, GALGAMES_BANK_240000_R, GALGAMES_ROM0 + state->m_galgames_cart); // rom
diff --git a/src/mame/includes/cischeat.h b/src/mame/includes/cischeat.h
index 733307a67b8..f575ff18ed9 100644
--- a/src/mame/includes/cischeat.h
+++ b/src/mame/includes/cischeat.h
@@ -50,13 +50,6 @@ public:
};
-/*----------- defined in drivers/cischeat.c -----------*/
-
-READ16_HANDLER( scudhamm_motor_pos_r );
-READ16_HANDLER( scudhamm_motor_status_r );
-READ16_HANDLER( scudhamm_analog_r );
-
-
/*----------- defined in video/cischeat.c -----------*/
WRITE16_HANDLER( cischeat_scrollram_0_w );
diff --git a/src/mame/machine/leland.c b/src/mame/machine/leland.c
index 74420a0160d..e69b72ad1c5 100644
--- a/src/mame/machine/leland.c
+++ b/src/mame/machine/leland.c
@@ -326,7 +326,7 @@ MACHINE_START( leland )
{
leland_state *state = machine.driver_data<leland_state>();
/* allocate extra stuff */
- state->m_battery_ram = reinterpret_cast<UINT8 *>(memory_get_shared(machine, "battery"));
+ state->m_battery_ram = reinterpret_cast<UINT8 *>(machine.memory().shared("battery")->ptr());
/* start scanline interrupts going */
state->m_master_int_timer = machine.scheduler().timer_alloc(FUNC(leland_interrupt_callback));
@@ -376,7 +376,7 @@ MACHINE_START( ataxx )
{
leland_state *state = machine.driver_data<leland_state>();
/* set the odd data banks */
- state->m_battery_ram = reinterpret_cast<UINT8 *>(memory_get_shared(machine, "battery"));
+ state->m_battery_ram = reinterpret_cast<UINT8 *>(machine.memory().shared("battery")->ptr());
state->m_extra_tram = auto_alloc_array(machine, UINT8, ATAXX_EXTRA_TRAM_SIZE);
/* start scanline interrupts going */
diff --git a/src/mame/machine/psx.c b/src/mame/machine/psx.c
index 6c779c50201..510f94260bb 100644
--- a/src/mame/machine/psx.c
+++ b/src/mame/machine/psx.c
@@ -28,7 +28,9 @@ void psx_driver_init( running_machine &machine )
{
psx_state *p_psx = machine.driver_data<psx_state>();
- p_psx->m_p_n_psxram = (UINT32 *)memory_get_shared(machine, "share1", p_psx->m_n_psxramsize);
+ memory_share *share = machine.memory().shared("share1");
+ p_psx->m_p_n_psxram = (UINT32 *)share->ptr();
+ p_psx->m_n_psxramsize = share->bytes();
}
WRITE32_HANDLER( psx_com_delay_w )
diff --git a/src/mame/machine/qix.c b/src/mame/machine/qix.c
index 0f0bde980ed..7eca216e4d4 100644
--- a/src/mame/machine/qix.c
+++ b/src/mame/machine/qix.c
@@ -472,7 +472,7 @@ WRITE8_HANDLER( qix_68705_portC_w )
static TIMER_CALLBACK( pia_w_callback )
{
pia6821_device *device = (pia6821_device *)ptr;
- device->write(*memory_nonspecific_space(device->machine()), param >> 8, param & 0xff);
+ device->write(*device->machine().memory().first_space(), param >> 8, param & 0xff);
}
diff --git a/src/mame/machine/s24fd.c b/src/mame/machine/s24fd.c
index 2d20b9daee8..332154983a0 100644
--- a/src/mame/machine/s24fd.c
+++ b/src/mame/machine/s24fd.c
@@ -156,7 +156,7 @@ void s24_fd1094_driver_init(running_machine &machine)
{
int i;
- s24_fd1094_cpuregion = (UINT16*)memory_get_shared(machine, "share2");
+ s24_fd1094_cpuregion = (UINT16*)machine.memory().shared("share2")->ptr();
s24_fd1094_cpuregionsize = 0x40000;
s24_fd1094_key = machine.region("fd1094key")->base();
diff --git a/src/mame/video/cischeat.c b/src/mame/video/cischeat.c
index b278f35e331..23d53fb04ad 100644
--- a/src/mame/video/cischeat.c
+++ b/src/mame/video/cischeat.c
@@ -1441,9 +1441,9 @@ if ( screen.machine().input().code_pressed(KEYCODE_Z) || screen.machine().input(
popmessage("Cmd: %04X Pos:%04X Lim:%04X Inp:%04X",
state->m_scudhamm_motor_command,
- scudhamm_motor_pos_r(space,0,0xffff),
- scudhamm_motor_status_r(space,0,0xffff),
- scudhamm_analog_r(space,0,0xffff) );
+ state->scudhamm_motor_pos_r(*space,0,0xffff),
+ state->scudhamm_motor_status_r(*space,0,0xffff),
+ state->scudhamm_analog_r(*space,0,0xffff) );
}
#endif
diff --git a/src/mame/video/sei_crtc.c b/src/mame/video/sei_crtc.c
index b4f94928c7b..97b40afca23 100644
--- a/src/mame/video/sei_crtc.c
+++ b/src/mame/video/sei_crtc.c
@@ -208,7 +208,7 @@ static TILE_GET_INFO( seibucrtc_sc3_tile_info )
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect,int pri)
{
- UINT16 *spriteram16 = reinterpret_cast<UINT16 *>(memory_get_shared(machine, "spriteram"));
+ UINT16 *spriteram16 = reinterpret_cast<UINT16 *>(machine.memory().shared("spriteram")->ptr());
int offs,fx,fy,x,y,color,sprite;
int dx,dy,ax,ay;