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

Memory view fixes:

Browse Source 
* Fixed bug that computed the wrong total size if the address
  space was a full 32 bits
* Improved display to show unmapped memory with *s
* Disabled enumeration of disk and 0-length regions
This commit is contained in:
Aaron Giles 2008-12-20 07:25:39 +00:00
parent 9be5d30f20
commit 446f13607f
1 changed files with 63 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
src/emu/debug/debugvw.c
View File

@ -268,7 +268,7 @@ static void memory_view_recompute(debug_view *view);
static int memory_view_needs_recompute(debug_view *view); static int memory_view_needs_recompute(debug_view *view);
static void memory_view_get_cursor_pos(debug_view *view, offs_t *address, UINT8 *shift); static void memory_view_get_cursor_pos(debug_view *view, offs_t *address, UINT8 *shift);
static void memory_view_set_cursor_pos(debug_view *view, offs_t address, UINT8 shift); static void memory_view_set_cursor_pos(debug_view *view, offs_t address, UINT8 shift);
static UINT64 memory_view_read(debug_view_memory *memdata, UINT8 size, offs_t offs); static int memory_view_read(debug_view_memory *memdata, UINT8 size, offs_t offs, UINT64 *data);
static void memory_view_write(debug_view_memory *memdata, UINT8 size, offs_t offs, UINT64 data); static void memory_view_write(debug_view_memory *memdata, UINT8 size, offs_t offs, UINT64 data);
static const debug_view_callbacks callback_table[] = static const debug_view_callbacks callback_table[] =
@ -2446,7 +2446,10 @@ static const memory_subview_item *memory_view_enumerate_subviews(running_machine
/* then add all the memory regions */ /* then add all the memory regions */
for (rgntag = memory_region_next(machine, NULL); rgntag != NULL; rgntag = memory_region_next(machine, rgntag)) for (rgntag = memory_region_next(machine, NULL); rgntag != NULL; rgntag = memory_region_next(machine, rgntag))
{ {
UINT32 length = memory_region_length(machine, rgntag);
UINT32 flags = memory_region_flags(machine, rgntag); UINT32 flags = memory_region_flags(machine, rgntag);
if (length > 0 && (flags & ROMREGION_DATATYPEMASK) == ROMREGION_DATATYPEROM)
{
UINT8 little_endian = ((flags & ROMREGION_ENDIANMASK) == ROMREGION_LE); UINT8 little_endian = ((flags & ROMREGION_ENDIANMASK) == ROMREGION_LE);
UINT8 width = 1 << ((flags & ROMREGION_WIDTHMASK) >> 8); UINT8 width = 1 << ((flags & ROMREGION_WIDTHMASK) >> 8);
memory_subview_item *subview; memory_subview_item *subview;
@ -2474,6 +2477,7 @@ static const memory_subview_item *memory_view_enumerate_subviews(running_machine
*tailptr = subview; *tailptr = subview;
tailptr = &subview->next; tailptr = &subview->next;
} }
}
/* finally add all global array symbols */ /* finally add all global array symbols */
for (itemnum = 0; itemnum < 10000; itemnum++) for (itemnum = 0; itemnum < 10000; itemnum++)
@ -2663,16 +2667,18 @@ static void memory_view_update(debug_view *view)
/* generate the data */ /* generate the data */
for (chunknum = 0; chunknum < memdata->chunks_per_row; chunknum++) for (chunknum = 0; chunknum < memdata->chunks_per_row; chunknum++)
{ {
UINT64 chunkdata = memory_view_read(memdata, memdata->bytes_per_chunk, addrbyte + chunknum * memdata->bytes_per_chunk);
int chunkindex = memdata->reverse_view ? (memdata->chunks_per_row - 1 - chunknum) : chunknum; int chunkindex = memdata->reverse_view ? (memdata->chunks_per_row - 1 - chunknum) : chunknum;
UINT64 chunkdata;
int ismapped;
ismapped = memory_view_read(memdata, memdata->bytes_per_chunk, addrbyte + chunknum * memdata->bytes_per_chunk, &chunkdata);
dest = destrow + memdata->section[1].pos + 1 + chunkindex * posdata->spacing; dest = destrow + memdata->section[1].pos + 1 + chunkindex * posdata->spacing;
for (ch = 0; ch < posdata->spacing; ch++, dest++) for (ch = 0; ch < posdata->spacing; ch++, dest++)
if (dest >= destmin && dest < destmax) if (dest >= destmin && dest < destmax)
{ {
UINT8 shift = posdata->shift[ch]; UINT8 shift = posdata->shift[ch];
if (shift < 64) if (shift < 64)
dest->byte = "0123456789ABCDEF"[(chunkdata >> shift) & 0x0f]; dest->byte = ismapped ? "0123456789ABCDEF"[(chunkdata >> shift) & 0x0f] : '*';
} }
} }
@ -2683,8 +2689,11 @@ static void memory_view_update(debug_view *view)
for (ch = 0; ch < memdata->bytes_per_row; ch++, dest++) for (ch = 0; ch < memdata->bytes_per_row; ch++, dest++)
if (dest >= destmin && dest < destmax) if (dest >= destmin && dest < destmax)
{ {
UINT8 chval = memory_view_read(memdata, 1, addrbyte + ch); int ismapped;
dest->byte = isprint(chval) ? chval : '.'; UINT64 chval;
ismapped = memory_view_read(memdata, 1, addrbyte + ch, &chval);
dest->byte = (ismapped && isprint(chval)) ? chval : '.';
} }
} }
} }
@ -2703,6 +2712,7 @@ static void memory_view_char(debug_view *view, int chval)
debug_view_memory *memdata = view->extra_data; debug_view_memory *memdata = view->extra_data;
offs_t address; offs_t address;
char *hexchar; char *hexchar;
int ismapped;
UINT64 data; UINT64 data;
UINT32 delta; UINT32 delta;
UINT8 shift; UINT8 shift;
@ -2775,7 +2785,9 @@ static void memory_view_char(debug_view *view, int chval)
hexchar = strchr(hexvals, tolower(chval)); hexchar = strchr(hexvals, tolower(chval));
if (hexchar == NULL) if (hexchar == NULL)
break; break;
data = memory_view_read(memdata, memdata->bytes_per_chunk, address); ismapped = memory_view_read(memdata, memdata->bytes_per_chunk, address, &data);
if (!ismapped)
break;
data &= ~((UINT64)0x0f << shift); data &= ~((UINT64)0x0f << shift);
data |= (UINT64)(hexchar - hexvals) << shift; data |= (UINT64)(hexchar - hexvals) << shift;
memory_view_write(memdata, memdata->bytes_per_chunk, address, data); memory_view_write(memdata, memdata->bytes_per_chunk, address, data);
@ -2882,7 +2894,7 @@ static void memory_view_recompute(debug_view *view)
} }
/* derive total sizes from that */ /* derive total sizes from that */
view->total.y = (memdata->maxaddr - memdata->byte_offset + memdata->bytes_per_row - 1) / memdata->bytes_per_row; view->total.y = ((UINT64)memdata->maxaddr - (UINT64)memdata->byte_offset + (UINT64)memdata->bytes_per_row - 1) / memdata->bytes_per_row;
/* reset the current cursor position */ /* reset the current cursor position */
memory_view_set_cursor_pos(view, cursoraddr, cursorshift); memory_view_set_cursor_pos(view, cursoraddr, cursorshift);
@ -3000,39 +3012,52 @@ static void memory_view_set_cursor_pos(debug_view *view, offs_t address, UINT8 s
reader reader
-------------------------------------------------*/ -------------------------------------------------*/
static UINT64 memory_view_read(debug_view_memory *memdata, UINT8 size, offs_t offs) static int memory_view_read(debug_view_memory *memdata, UINT8 size, offs_t offs, UINT64 *data)
{ {
/* if no raw data, just use the standard debug routines */ /* if no raw data, just use the standard debug routines */
if (memdata->desc->space != NULL) if (memdata->desc->space != NULL)
{ {
const address_space *space = memdata->desc->space; const address_space *space = memdata->desc->space;
UINT64 result = ~(UINT64)0; UINT64 result = ~(UINT64)0;
offs_t dummyaddr = offs;
int ismapped;
ismapped = memdata->no_translation ? TRUE : memory_address_physical(space, TRANSLATE_READ_DEBUG, &dummyaddr);
if (ismapped)
{
switch (size) switch (size)
{ {
case 1: result = debug_read_byte(space, offs, !memdata->no_translation); break; case 1: *data = debug_read_byte(space, offs, !memdata->no_translation); break;
case 2: result = debug_read_word(space, offs, !memdata->no_translation); break; case 2: *data = debug_read_word(space, offs, !memdata->no_translation); break;
case 4: result = debug_read_dword(space, offs, !memdata->no_translation); break; case 4: *data = debug_read_dword(space, offs, !memdata->no_translation); break;
case 8: result = debug_read_qword(space, offs, !memdata->no_translation); break; case 8: *data = debug_read_qword(space, offs, !memdata->no_translation); break;
} }
return result; }
return ismapped;
} }
/* if larger than a byte, reduce by half and recurse */ /* if larger than a byte, reduce by half and recurse */
if (size > 1) if (size > 1)
{ {
UINT64 data0, data1;
int ismapped;
size /= 2; size /= 2;
ismapped = memory_view_read(memdata, size, offs + 0 * size, &data0);
ismapped |= memory_view_read(memdata, size, offs + 1 * size, &data1);
if (memdata->desc->endianness == ENDIANNESS_LITTLE) if (memdata->desc->endianness == ENDIANNESS_LITTLE)
return memory_view_read(memdata, size, offs + 0 * size) | ((UINT64)memory_view_read(memdata, size, offs + 1 * size) << (size * 8)); *data = data0 | (data1 << (size * 8));
else else
return memory_view_read(memdata, size, offs + 1 * size) | ((UINT64)memory_view_read(memdata, size, offs + 0 * size) << (size * 8)); *data = data1 | (data0 << (size * 8));
return ismapped;
} }
/* all 0xff if out of bounds */ /* all 0xff if out of bounds */
offs ^= memdata->desc->offsetxor; offs ^= memdata->desc->offsetxor;
if (offs >= memdata->desc->length) if (offs >= memdata->desc->length)
return 0xff; return FALSE;
return *((UINT8 *)memdata->desc->base + offs); *data = *((UINT8 *)memdata->desc->base + offs);
return TRUE;
} }