unsigned int GetCurrentValue(struct AddressWatcher *watch)
{
switch (watch->Size)
{
case 0x62: return MappedMemoryReadByte(watch->Address);
case 0x77: return MappedMemoryReadWord(watch->Address);
case 0x64: return MappedMemoryReadLong(watch->Address);
}
return 0;
// return ReadValueAtHardwareAddress(watch.Address, watch.Size == 'd' ? 4 : watch.Size == 'w' ? 2 : 1);
}
void CheatDoPatches(void)
{
int i;
for (i = 0; ; i++)
{
switch (cheatlist[i].type)
{
case CHEATTYPE_NONE:
return;
case CHEATTYPE_ENABLE:
if (cheatlist[i].enable == 0)
continue;
if (MappedMemoryReadWord(cheatlist[i].addr) != cheatlist[i].val)
return;
break;
case CHEATTYPE_BYTEWRITE:
if (cheatlist[i].enable == 0)
continue;
MappedMemoryWriteByte(cheatlist[i].addr, (u8)cheatlist[i].val);
SH2WriteNotify(cheatlist[i].addr, 1);
break;
case CHEATTYPE_WORDWRITE:
if (cheatlist[i].enable == 0)
continue;
MappedMemoryWriteWord(cheatlist[i].addr, (u16)cheatlist[i].val);
SH2WriteNotify(cheatlist[i].addr, 2);
break;
case CHEATTYPE_LONGWRITE:
if (cheatlist[i].enable == 0)
continue;
MappedMemoryWriteLong(cheatlist[i].addr, cheatlist[i].val);
SH2WriteNotify(cheatlist[i].addr, 4);
break;
}
}
}
void gdb_client_received(gdb_client * client, gdb_packet * packet)
{
char ack = '+';
printf("packet received: %s\n", packet->buffer);
YabSockSend(client->sock, &ack, 1, 0);
if (packet->buffer[0] == '?')
gdb_client_break(client);
else if (packet->buffer[0] == 'c')
gdb_client_unlock(client);
else if (packet->buffer[0] == 'g')
{
int i;
char buffer[184+1];
for(i = 0;i < 16;i++)
sprintf(buffer + 8 * i, "%08x", client->context->regs.R[i]);
sprintf(buffer + 8 * 16, "%08x", client->context->regs.PC);
sprintf(buffer + 8 * 17, "%08x", client->context->regs.PR);
sprintf(buffer + 8 * 18, "%08x", client->context->regs.GBR);
sprintf(buffer + 8 * 19, "%08x", client->context->regs.VBR);
sprintf(buffer + 8 * 20, "%08x", client->context->regs.MACH);
sprintf(buffer + 8 * 21, "%08x", client->context->regs.MACL);
sprintf(buffer + 8 * 22, "%08x", client->context->regs.SR);
gdb_client_send(client, buffer, 184);
}
else if (packet->buffer[0] == 'H')
gdb_client_send(client, "OK", 2);
else if (packet->buffer[0] == 'q')
{
if (!strncmp(packet->buffer, "qSupported", 10))
gdb_client_send(client, "PacketSize=1024", 15);
else if (packet->buffer[1] == 'C')
gdb_client_send(client, "", 0);
else if (!strncmp(packet->buffer, "qAttached", 9))
gdb_client_send(client, "0", 1);
else if (!strncmp(packet->buffer, "qTStatus", 8))
gdb_client_send(client, "T0", 2);
else if (!strncmp(packet->buffer, "qTfP", 8))
gdb_client_send(client, "", 0);
else if (!strncmp(packet->buffer, "qTfV", 8))
gdb_client_send(client, "", 0);
else if (!strncmp(packet->buffer, "qTsP", 8))
gdb_client_send(client, "", 0);
}
else if (packet->buffer[0] == 'm')
{
u32 addr;
int len, i;
char * buffer;
char * pos;
sscanf(packet->buffer, "m%x,%d", &addr, &len);
buffer = malloc(2 * len);
pos = buffer;
i = 0;
while(i < len / 4) {
u32 val = MappedMemoryReadLong(addr + 4 * i);
sprintf(pos, "%08x", val);
i += 1;
pos += 8;
}
switch(len % 4) {
case 2: {
u16 val = MappedMemoryReadWord(addr + 4 * i);
sprintf(pos, "%04x", val);
break;
}
case 1: {
u8 val = MappedMemoryReadByte(addr + 4 * i);
sprintf(pos, "%02x", val);
break;
}
}
gdb_client_send(client, buffer, 2 * len);
free(buffer);
}
else if (packet->buffer[0] == 'v')
{
if (!strncmp(packet->buffer, "vCont?", 6))
gdb_client_send(client, "", 0);
}
else if (packet->buffer[0] == 's')
gdb_client_step(client);
else if (packet->buffer[0] == 'Z') /* insert breakpoint */
{
if (packet->buffer[1] == '0') /* code breakpoint */
{
u32 addr;
int dummy;
sscanf(packet->buffer, "Z0,%x,%d", &addr, &dummy);
SH2AddCodeBreakpoint(client->context, addr);
}
gdb_client_send(client, "OK", 2);
}
else if (packet->buffer[0] == 'z') /* remove breakpoint */
{
if (packet->buffer[1] == '0') /* code breakpoint */
{
u32 addr;
int dummy;
sscanf(packet->buffer, "Z0,%x,%d", &addr, &dummy);
SH2DelCodeBreakpoint(client->context, addr);
}
gdb_client_send(client, "OK", 2);
}
}
result_struct *MappedMemorySearch(u32 startaddr, u32 endaddr, int searchtype,
const char *searchstr,
result_struct *prevresults, u32 *maxresults)
{
u32 i=0;
result_struct *results;
u32 numresults=0;
unsigned long searchval;
int issigned=0;
u32 addr;
if ((results = (result_struct *)malloc(sizeof(result_struct) * maxresults[0])) == NULL)
return NULL;
switch (searchtype & 0x70)
{
case SEARCHSTRING:
case SEARCHREL8BIT:
case SEARCHREL16BIT:
{
// String/8-bit relative/16-bit relative search(not supported, yet)
if (SearchString(startaddr, endaddr, searchtype, searchstr,
results, maxresults) == 0)
{
maxresults[0] = 0;
free(results);
return NULL;
}
return results;
}
case SEARCHHEX:
sscanf(searchstr, "%08lx", &searchval);
break;
case SEARCHUNSIGNED:
searchval = (unsigned long)strtoul(searchstr, NULL, 10);
issigned = 0;
break;
case SEARCHSIGNED:
searchval = (unsigned long)strtol(searchstr, NULL, 10);
issigned = 1;
break;
}
if (prevresults)
{
addr = prevresults[i].addr;
i++;
}
else
addr = startaddr;
// Regular value search
for (;;)
{
u32 val=0;
u32 newaddr;
// Fetch byte/word/etc.
switch (searchtype & 0x3)
{
case SEARCHBYTE:
val = MappedMemoryReadByte(addr);
// sign extend if neccessary
if (issigned)
val = (s8)val;
if (SearchIncrementAndCheckBounds(prevresults, maxresults, numresults, &i, addr+1, &newaddr, endaddr))
return results;
break;
case SEARCHWORD:
val = MappedMemoryReadWord(addr);
// sign extend if neccessary
if (issigned)
val = (s16)val;
if (SearchIncrementAndCheckBounds(prevresults, maxresults, numresults, &i, addr+2, &newaddr, endaddr))
return results;
break;
case SEARCHLONG:
val = MappedMemoryReadLong(addr);
if (SearchIncrementAndCheckBounds(prevresults, maxresults, numresults, &i, addr+4, &newaddr, endaddr))
return results;
break;
default:
maxresults[0] = 0;
if (results)
free(results);
return NULL;
}
// Do a comparison
switch (searchtype & 0xC)
{
case SEARCHEXACT:
if (val == searchval)
MappedMemoryAddMatch(addr, val, searchtype, results, &numresults);
break;
case SEARCHLESSTHAN:
if ((!issigned && val < searchval) || (issigned && (signed)val < (signed)searchval))
MappedMemoryAddMatch(addr, val, searchtype, results, &numresults);
break;
case SEARCHGREATERTHAN:
if ((!issigned && val > searchval) || (issigned && (signed)val > (signed)searchval))
MappedMemoryAddMatch(addr, val, searchtype, results, &numresults);
break;
default:
maxresults[0] = 0;
if (results)
free(results);
return NULL;
}
addr = newaddr;
}
maxresults[0] = numresults;
return results;
}
static int SearchString(u32 startaddr, u32 endaddr, int searchtype,
const char *searchstr, result_struct *results,
u32 *maxresults)
{
u8 *buf=NULL;
u32 *buf32=NULL;
u32 buflen=0;
u32 counter;
u32 addr;
u32 numresults=0;
buflen=(u32)strlen(searchstr);
if ((buf32=(u32 *)malloc(buflen*sizeof(u32))) == NULL)
return 0;
buf = (u8 *)buf32;
// Copy string to buffer
switch (searchtype & 0x70)
{
case SEARCHSTRING:
strcpy((char *)buf, searchstr);
break;
case SEARCHREL8BIT:
case SEARCHREL16BIT:
{
char *text;
char *searchtext=strdup(searchstr);
// Calculate buffer length and read values into table
buflen = 0;
for (text=strtok((char *)searchtext, " ,"); text != NULL; text=strtok(NULL, " ,"))
{
buf32[buflen] = strtoul(text, NULL, 0);
buflen++;
}
free(searchtext);
break;
}
}
addr = startaddr;
counter = 0;
for (;;)
{
// Fetch byte/word/etc.
switch (searchtype & 0x70)
{
case SEARCHSTRING:
{
u8 val = MappedMemoryReadByte(addr);
addr++;
if (val == buf[counter])
{
counter++;
if (counter == buflen)
MappedMemoryAddMatch(addr-buflen, val, searchtype, results, &numresults);
}
else
counter = 0;
break;
}
case SEARCHREL8BIT:
{
int diff;
u32 j;
u8 val2;
u8 val = MappedMemoryReadByte(addr);
for (j = 1; j < buflen; j++)
{
// grab the next value
val2 = MappedMemoryReadByte(addr+j);
// figure out the diff
diff = (int)val2 - (int)val;
// see if there's a match
if (((int)buf32[j] - (int)buf32[j-1]) != diff)
break;
if (j == (buflen - 1))
MappedMemoryAddMatch(addr, val, searchtype, results, &numresults);
val = val2;
}
addr++;
break;
}
case SEARCHREL16BIT:
{
int diff;
u32 j;
u16 val2;
u16 val = MappedMemoryReadWord(addr);
for (j = 1; j < buflen; j++)
{
// grab the next value
val2 = MappedMemoryReadWord(addr+(j*2));
// figure out the diff
diff = (int)val2 - (int)val;
// see if there's a match
if (((int)buf32[j] - (int)buf32[j-1]) != diff)
break;
if (j == (buflen - 1))
MappedMemoryAddMatch(addr, val, searchtype, results, &numresults);
val = val2;
}
addr+=2;
break;
}
}
if (addr > endaddr || numresults >= maxresults[0])
break;
}
free(buf);
maxresults[0] = numresults;
return 1;
}
int SH2Dis(u32 addr, char *string)
{
SH2Disasm(addr, MappedMemoryReadWord(addr), 0, NULL, string);
return 2;
}
