Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-17 19:24:59 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Memory references can now explicitly specify logical or physical access

Browse Source 
by prepending with an 'l' or 'p'. Logical remains the default. Example:
ppb@1000 = physical program space byte at address $1000. ldw@2000 =
logical data space word at address $2000.
This commit is contained in:
Aaron Giles 2009-10-01 16:40:33 +00:00
parent 7ca608cabe
commit cb51594344
3 changed files with 123 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/emu/debug/debugcpu.c
View File

@ -99,12 +99,10 @@ static UINT32 dasm_wrapped(const device_config *device, char *buffer, offs_t pc)
/* expression handlers */
static UINT64 expression_read_memory(void *param, const char *name, int space, UINT32 address, int size);
static UINT64 expression_read_address_space(const address_space *space, offs_t address, int size);
static UINT64 expression_read_program_direct(const address_space *space, int opcode, offs_t address, int size);
static UINT64 expression_read_memory_region(running_machine *machine, const char *rgntag, offs_t address, int size);
static UINT64 expression_read_eeprom(running_machine *machine, offs_t address, int size);
static void expression_write_memory(void *param, const char *name, int space, UINT32 address, int size, UINT64 data);
static void expression_write_address_space(const address_space *space, offs_t address, int size, UINT64 data);
static void expression_write_program_direct(const address_space *space, int opcode, offs_t address, int size, UINT64 data);
static void expression_write_memory_region(running_machine *machine, const char *rgntag, offs_t address, int size, UINT64 data);
static void expression_write_eeprom(running_machine *machine, offs_t address, int size, UINT64 data);
@ -2459,21 +2457,40 @@ static const device_config *expression_cpu_index(running_machine *machine, const
space
-------------------------------------------------*/
static UINT64 expression_read_memory(void *param, const char *name, int space, UINT32 address, int size)
static UINT64 expression_read_memory(void *param, const char *name, int spacenum, UINT32 address, int size)
{
running_machine *machine = (running_machine *)param;
UINT64 result = ~(UINT64)0 >> (64 - 8*size);
const device_config *cpu = NULL;
const address_space *space;
switch (space)
switch (spacenum)
{
case EXPSPACE_PROGRAM:
case EXPSPACE_DATA:
case EXPSPACE_IO:
case EXPSPACE_PROGRAM_LOGICAL:
case EXPSPACE_DATA_LOGICAL:
case EXPSPACE_IO_LOGICAL:
case EXPSPACE_SPACE3_LOGICAL:
if (name != NULL)
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
return expression_read_address_space(cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (space - EXPSPACE_PROGRAM)), address, size);
space = cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL));
if (space != NULL)
result = debug_read_memory(space, memory_address_to_byte(space, address), size, TRUE);
break;
case EXPSPACE_PROGRAM_PHYSICAL:
case EXPSPACE_DATA_PHYSICAL:
case EXPSPACE_IO_PHYSICAL:
case EXPSPACE_SPACE3_PHYSICAL:
if (name != NULL)
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
space = cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
if (space != NULL)
result = debug_read_memory(space, memory_address_to_byte(space, address), size, FALSE);
break;
case EXPSPACE_OPCODE:
case EXPSPACE_RAMWRITE:
@ -2481,31 +2498,19 @@ static UINT64 expression_read_memory(void *param, const char *name, int space, U
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
return expression_read_program_direct(cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM), (space == EXPSPACE_OPCODE), address, size);
result = expression_read_program_direct(cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM), (spacenum == EXPSPACE_OPCODE), address, size);
break;
case EXPSPACE_EEPROM:
return expression_read_eeprom(machine, address, size);
result = expression_read_eeprom(machine, address, size);
break;
case EXPSPACE_REGION:
if (name == NULL)
break;
return expression_read_memory_region(machine, name, address, size);
result = expression_read_memory_region(machine, name, address, size);
break;
}
return ~(UINT64)0 >> (64 - 8*size);
}
/*-------------------------------------------------
expression_read_address_space - read memory
from a specific CPU's address space
-------------------------------------------------*/
static UINT64 expression_read_address_space(const address_space *space, offs_t address, int size)
{
UINT64 result = ~(UINT64)0 >> (64 - 8*size);
if (space != NULL)
result = debug_read_memory(space, memory_address_to_byte(space, address), size, TRUE);
return result;
}
@ -2652,21 +2657,38 @@ static UINT64 expression_read_eeprom(running_machine *machine, offs_t address, i
space
-------------------------------------------------*/
static void expression_write_memory(void *param, const char *name, int space, UINT32 address, int size, UINT64 data)
static void expression_write_memory(void *param, const char *name, int spacenum, UINT32 address, int size, UINT64 data)
{
running_machine *machine = (running_machine *)param;
const device_config *cpu = NULL;
const address_space *space;
switch (space)
switch (spacenum)
{
case EXPSPACE_PROGRAM:
case EXPSPACE_DATA:
case EXPSPACE_IO:
case EXPSPACE_PROGRAM_LOGICAL:
case EXPSPACE_DATA_LOGICAL:
case EXPSPACE_IO_LOGICAL:
case EXPSPACE_SPACE3_LOGICAL:
if (name != NULL)
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
expression_write_address_space(cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (space - EXPSPACE_PROGRAM)), address, size, data);
space = cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
if (space != NULL)
debug_write_memory(space, memory_address_to_byte(space, address), data, size, TRUE);
break;
case EXPSPACE_PROGRAM_PHYSICAL:
case EXPSPACE_DATA_PHYSICAL:
case EXPSPACE_IO_PHYSICAL:
case EXPSPACE_SPACE3_PHYSICAL:
if (name != NULL)
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
space = cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
if (space != NULL)
debug_write_memory(space, memory_address_to_byte(space, address), data, size, FALSE);
break;
case EXPSPACE_OPCODE:
@ -2675,7 +2697,7 @@ static void expression_write_memory(void *param, const char *name, int space, UI
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
expression_write_program_direct(cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM), (space == EXPSPACE_OPCODE), address, size, data);
expression_write_program_direct(cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM), (spacenum == EXPSPACE_OPCODE), address, size, data);
break;
case EXPSPACE_EEPROM:
@ -2691,18 +2713,6 @@ static void expression_write_memory(void *param, const char *name, int space, UI
}
/*-------------------------------------------------
expression_write_address_space - write memory
to a specific CPU's address space
-------------------------------------------------*/
static void expression_write_address_space(const address_space *space, offs_t address, int size, UINT64 data)
{
if (space != NULL)
debug_write_memory(space, memory_address_to_byte(space, address), data, size, TRUE);
}
/*-------------------------------------------------
expression_write_program_direct - write memory
directly to an opcode or RAM pointer
@ -2879,9 +2889,10 @@ static EXPRERR expression_validate(void *param, const char *name, int space)
switch (space)
{
case EXPSPACE_PROGRAM:
case EXPSPACE_DATA:
case EXPSPACE_IO:
case EXPSPACE_PROGRAM_LOGICAL:
case EXPSPACE_DATA_LOGICAL:
case EXPSPACE_IO_LOGICAL:
case EXPSPACE_SPACE3_LOGICAL:
if (name != NULL)
{
cpu = expression_cpu_index(machine, name);
@ -2890,7 +2901,23 @@ static EXPRERR expression_validate(void *param, const char *name, int space)
}
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
if (cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (space - EXPSPACE_PROGRAM)) == NULL)
if (cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (space - EXPSPACE_PROGRAM_LOGICAL)) == NULL)
return EXPRERR_NO_SUCH_MEMORY_SPACE;
break;
case EXPSPACE_PROGRAM_PHYSICAL:
case EXPSPACE_DATA_PHYSICAL:
case EXPSPACE_IO_PHYSICAL:
case EXPSPACE_SPACE3_PHYSICAL:
if (name != NULL)
{
cpu = expression_cpu_index(machine, name);
if (cpu == NULL)
return EXPRERR_INVALID_MEMORY_NAME;
}
if (cpu == NULL)
cpu = debug_cpu_get_visible_cpu(machine);
if (cpu_get_address_space(cpu, ADDRESS_SPACE_PROGRAM + (space - EXPSPACE_PROGRAM_PHYSICAL)) == NULL)
return EXPRERR_NO_SUCH_MEMORY_SPACE;
break;

35
src/emu/debug/express.c
View File

@ -81,9 +81,14 @@ enum
TIN_MEMORY_SPACE_SHIFT = 12,
TIN_MEMORY_SPACE_MASK = (0xf << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_PROGRAM = (EXPSPACE_PROGRAM << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_DATA = (EXPSPACE_DATA << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_IO = (EXPSPACE_IO << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_PROGRAM_LOG = (EXPSPACE_PROGRAM_LOGICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_DATA_LOG = (EXPSPACE_DATA_LOGICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_IO_LOG = (EXPSPACE_IO_LOGICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_SPACE3_LOG = (EXPSPACE_SPACE3_LOGICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_PROGRAM_PHYS = (EXPSPACE_PROGRAM_PHYSICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_DATA_PHYS = (EXPSPACE_DATA_PHYSICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_IO_PHYS = (EXPSPACE_IO_PHYSICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_SPACE3_PHYS = (EXPSPACE_SPACE3_PHYSICAL << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_OPCODE = (EXPSPACE_OPCODE << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_RAMWRITE = (EXPSPACE_RAMWRITE << TIN_MEMORY_SPACE_SHIFT),
TIN_MEMORY_EEPROM = (EXPSPACE_EEPROM << TIN_MEMORY_SPACE_SHIFT),
@ -525,6 +530,7 @@ static EXPRERR parse_memory_operator(parsed_expression *expr, int offset, const
const char *startbuffer = buffer;
const char *namestring = NULL;
int space = 'p', size;
int physical = FALSE;
const char *dot;
int length;
@ -543,9 +549,21 @@ static EXPRERR parse_memory_operator(parsed_expression *expr, int offset, const
buffer = dot + 1;
}
/* length 2 means space then size */
/* length 3 means logical/physical, then space, then size */
length = (int)strlen(buffer);
if (length == 2)
if (length == 3)
{
if (buffer[0] != 'l' && buffer[0] != 'p')
return MAKE_EXPRERR_INVALID_MEMORY_SPACE(offset + (buffer - startbuffer));
if (buffer[1] != 'p' && buffer[1] != 'd' && buffer[1] != 'i' && buffer[1] != '3')
return MAKE_EXPRERR_INVALID_MEMORY_SPACE(offset + (buffer - startbuffer));
physical = (buffer[0] == 'p');
space = buffer[1];
size = buffer[2];
}
/* length 2 means space then size */
else if (length == 2)
{
space = buffer[0];
size = buffer[1];
@ -562,9 +580,10 @@ static EXPRERR parse_memory_operator(parsed_expression *expr, int offset, const
/* convert the space to flags */
switch (space)
{
case 'p': *flags |= TIN_MEMORY_PROGRAM; break;
case 'd': *flags |= TIN_MEMORY_DATA; break;
case 'i': *flags |= TIN_MEMORY_IO; break;
case 'p': *flags |= physical ? TIN_MEMORY_PROGRAM_PHYS : TIN_MEMORY_PROGRAM_LOG; break;
case 'd': *flags |= physical ? TIN_MEMORY_DATA_PHYS : TIN_MEMORY_DATA_LOG; break;
case 'i': *flags |= physical ? TIN_MEMORY_IO_PHYS : TIN_MEMORY_IO_LOG; break;
case '3': *flags |= physical ? TIN_MEMORY_SPACE3_PHYS : TIN_MEMORY_SPACE3_LOG; break;
case 'o': *flags |= TIN_MEMORY_OPCODE; break;
case 'r': *flags |= TIN_MEMORY_RAMWRITE; break;
case 'e': *flags |= TIN_MEMORY_EEPROM; break;

19
src/emu/debug/express.h
View File

@ -47,13 +47,18 @@
#define EXPRERR_MISSING_MEMORY_NAME (19)
/* values for the address space passed to external_read/write_memory */
#define EXPSPACE_PROGRAM (0)
#define EXPSPACE_DATA (1)
#define EXPSPACE_IO (2)
#define EXPSPACE_OPCODE (3)
#define EXPSPACE_RAMWRITE (4)
#define EXPSPACE_EEPROM (5)
#define EXPSPACE_REGION (6)
#define EXPSPACE_PROGRAM_LOGICAL (0)
#define EXPSPACE_DATA_LOGICAL (1)
#define EXPSPACE_IO_LOGICAL (2)
#define EXPSPACE_SPACE3_LOGICAL (3)
#define EXPSPACE_PROGRAM_PHYSICAL (4)
#define EXPSPACE_DATA_PHYSICAL (5)
#define EXPSPACE_IO_PHYSICAL (6)
#define EXPSPACE_SPACE3_PHYSICAL (7)
#define EXPSPACE_OPCODE (8)
#define EXPSPACE_RAMWRITE (9)
#define EXPSPACE_EEPROM (10)
#define EXPSPACE_REGION (11)