Mercurial > vba-linux

     1 #include <cstdlib>

     2 #include <cstdio>

     3 #include <cstring>

     4 

     5 #ifndef WIN32

     6 # include <unistd.h>

     7 # include <sys/socket.h>

     8 # include <netdb.h>

     9 # ifdef HAVE_NETINET_IN_H

    10 #  include <netinet/in.h>

    11 # endif // HAVE_NETINET_IN_H

    12 # ifdef HAVE_ARPA_INET_H

    13 #  include <arpa/inet.h>

    14 # else // ! HAVE_ARPA_INET_H

    15 #  define socklen_t int

    16 # endif // ! HAVE_ARPA_INET_H

    17 #else // WIN32

    18 # include "../win32/stdafx.h"

    19 # include <winsock.h>

    20 # include <io.h>

    21 # define socklen_t int

    22 # define close closesocket

    23 # define read _read

    24 # define write _write

    25 #endif // WIN32

    26 

    27 #include "GBA.h"

    28 #include "GBAGlobals.h"

    29 

    30 extern bool debugger;

    31 extern void CPUUpdateCPSR();

    32 #ifdef SDL

    33 extern void (*dbgMain)();

    34 extern void (*dbgSignal)(int, int);

    35 extern void debuggerMain();

    36 extern void debuggerSignal(int, int);

    37 #endif

    38 

    39 int  remotePort         = 55555;

    40 int  remoteSignal       = 5;

    41 int  remoteSocket       = -1;

    42 int  remoteListenSocket = -1;

    43 bool remoteConnected    = false;

    44 bool remoteResumed      = false;

    45 

    46 int  (*remoteSendFnc)(char *, int) = NULL;

    47 int  (*remoteRecvFnc)(char *, int) = NULL;

    48 bool (*remoteInitFnc)()    = NULL;

    49 void (*remoteCleanUpFnc)() = NULL;

    50 

    51 #if (defined WIN32 && !defined SDL)

    52 void remoteSetSockets(SOCKET l, SOCKET r)

    53 {

    54 	remoteSocket       = r;

    55 	remoteListenSocket = l;

    56 }

    57 

    58 #endif

    59 

    60 int remoteTcpSend(char *data, int len)

    61 {

    62 	return send(remoteSocket, data, len, 0);

    63 }

    64 

    65 int remoteTcpRecv(char *data, int len)

    66 {

    67 	return recv(remoteSocket, data, len, 0);

    68 }

    69 

    70 bool remoteTcpInit()

    71 {

    72 	if (remoteSocket == -1)

    73 	{

    74 #ifdef WIN32

    75 		WSADATA wsaData;

    76 		int     error = WSAStartup(MAKEWORD(1, 1), &wsaData);

    77 #endif // WIN32

    78 		int s = socket(PF_INET, SOCK_STREAM, 0);

    79 

    80 		remoteListenSocket = s;

    81 

    82 		if (s < 0)

    83 		{

    84 			fprintf(stderr, "Error opening socket\n");

    85 			exit(-1);

    86 		}

    87 		int tmp = 1;

    88 		setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp, sizeof(tmp));

    89 

    90 		//    char hostname[256];

    91 		//    gethostname(hostname, 256);

    92 

    93 		//    hostent *ent = gethostbyname(hostname);

    94 		//    unsigned long a = *((unsigned long *)ent->h_addr);

    95 

    96 		sockaddr_in addr;

    97 		addr.sin_family      = AF_INET;

    98 		addr.sin_port        = htons(remotePort);

    99 		addr.sin_addr.s_addr = htonl(0);

   100 		int count = 0;

   101 		while (count < 3)

   102 		{

   103 			if (bind(s, (sockaddr *)&addr, sizeof(addr)))

   104 			{

   105 				addr.sin_port = htons(ntohs(addr.sin_port)+1);

   106 			}

   107 			else

   108 				break;

   109 		}

   110 		if (count == 3)

   111 		{

   112 			fprintf(stderr, "Error binding \n");

   113 			exit(-1);

   114 		}

   115 

   116 		fprintf(stderr, "Listening for a connection at port %d\n",

   117 		        ntohs(addr.sin_port));

   118 

   119 		if (listen(s, 1))

   120 		{

   121 			fprintf(stderr, "Error listening\n");

   122 			exit(-1);

   123 		}

   124 		socklen_t len = sizeof(addr);

   125 

   126 #ifdef WIN32

   127 		int flag = 0;

   128 		ioctlsocket(s, FIONBIO, (unsigned long *)&flag);

   129 #endif // WIN32

   130 		int s2 = accept(s, (sockaddr *)&addr, &len);

   131 		if (s2 > 0)

   132 		{

   133 			fprintf(stderr, "Got a connection from %s %d\n",

   134 			        inet_ntoa((in_addr)addr.sin_addr),

   135 			        ntohs(addr.sin_port));

   136 		}

   137 		else

   138 		{

   139 #ifdef WIN32

   140 			int error = WSAGetLastError();

   141 #endif // WIN32

   142 		}

   143 		char dummy;

   144 		recv(s2, &dummy, 1, 0);

   145 		if (dummy != '+')

   146 		{

   147 			fprintf(stderr, "ACK not received\n");

   148 			exit(-1);

   149 		}

   150 		remoteSocket = s2;

   151 		//    close(s);

   152 	}

   153 	return true;

   154 }

   155 

   156 void remoteTcpCleanUp()

   157 {

   158 	if (remoteSocket > 0)

   159 	{

   160 		fprintf(stderr, "Closing remote socket\n");

   161 		close(remoteSocket);

   162 		remoteSocket = -1;

   163 	}

   164 	if (remoteListenSocket > 0)

   165 	{

   166 		fprintf(stderr, "Closing listen socket\n");

   167 		close(remoteListenSocket);

   168 		remoteListenSocket = -1;

   169 	}

   170 }

   171 

   172 int remotePipeSend(char *data, int len)

   173 {

   174 	int res = write(1, data, len);

   175 	return res;

   176 }

   177 

   178 int remotePipeRecv(char *data, int len)

   179 {

   180 	int res = read(0, data, len);

   181 	return res;

   182 }

   183 

   184 bool remotePipeInit()

   185 {

   186 	char dummy;

   187 	read(0, &dummy, 1);

   188 	if (dummy != '+')

   189 	{

   190 		fprintf(stderr, "ACK not received\n");

   191 		exit(-1);

   192 	}

   193 

   194 	return true;

   195 }

   196 

   197 void remotePipeCleanUp()

   198 {}

   199 

   200 void remoteSetPort(int port)

   201 {

   202 	remotePort = port;

   203 }

   204 

   205 void remoteSetProtocol(int p)

   206 {

   207 	if (p == 0)

   208 	{

   209 		remoteSendFnc    = remoteTcpSend;

   210 		remoteRecvFnc    = remoteTcpRecv;

   211 		remoteInitFnc    = remoteTcpInit;

   212 		remoteCleanUpFnc = remoteTcpCleanUp;

   213 	}

   214 	else

   215 	{

   216 		remoteSendFnc    = remotePipeSend;

   217 		remoteRecvFnc    = remotePipeRecv;

   218 		remoteInitFnc    = remotePipeInit;

   219 		remoteCleanUpFnc = remotePipeCleanUp;

   220 	}

   221 }

   222 

   223 void remoteInit()

   224 {

   225 	if (remoteInitFnc)

   226 		remoteInitFnc();

   227 }

   228 

   229 void remotePutPacket(char *packet)

   230 {

   231 	char *hex = "0123456789abcdef";

   232 	char  buffer[1024];

   233 

   234 	int count = strlen(packet);

   235 

   236 	unsigned char csum = 0;

   237 

   238 	char *p = buffer;

   239 	*p++ = '$';

   240 

   241 	for (int i = 0; i < count; i++)

   242 	{

   243 		csum += packet[i];

   244 		*p++  = packet[i];

   245 	}

   246 	*p++ = '#';

   247 	*p++ = hex[csum>>4];

   248 	*p++ = hex[csum & 15];

   249 	*p++ = 0;

   250 	//  printf("Sending %s\n", buffer);

   251 	remoteSendFnc(buffer, count + 4);

   252 

   253 	char c = 0;

   254 	remoteRecvFnc(&c, 1);

   255 	/*

   256 	   if(c == '+')

   257 	   printf("ACK\n");

   258 	   else if(c=='-')

   259 	   printf("NACK\n");

   260 	 */

   261 }

   262 

   263 void remoteOutput(char *s, u32 addr)

   264 {

   265 	char buffer[16384];

   266 

   267 	char *d = buffer;

   268 	*d++ = 'O';

   269 

   270 	if (s)

   271 	{

   272 		char c = *s++;

   273 		while (c)

   274 		{

   275 			sprintf(d, "%02x", c);

   276 			d += 2;

   277 			c  = *s++;

   278 		}

   279 	}

   280 	else

   281 	{

   282 		char c = debuggerReadByte(addr);

   283 		addr++;

   284 		while (c)

   285 		{

   286 			sprintf(d, "%02x", c);

   287 			d += 2;

   288 			c  = debuggerReadByte(addr);

   289 			addr++;

   290 		}

   291 	}

   292 	remotePutPacket(buffer);

   293 	//  fprintf(stderr, "Output sent %s\n", buffer);

   294 }

   295 

   296 void remoteSendSignal()

   297 {

   298 	char buffer[1024];

   299 	sprintf(buffer, "S%02x", remoteSignal);

   300 	remotePutPacket(buffer);

   301 }

   302 

   303 void remoteSendStatus()

   304 {

   305 	char buffer[1024];

   306 	sprintf(buffer, "T%02x", remoteSignal);

   307 	char *s = buffer;

   308 	s += 3;

   309 	for (int i = 0; i < 15; i++)

   310 	{

   311 		u32 v = reg[i].I;

   312 		sprintf(s, "%02x:%02x%02x%02x%02x;", i,

   313 		        (v & 255),

   314 		        (v >> 8) & 255,

   315 		        (v >> 16) & 255,

   316 		        (v >> 24) & 255);

   317 		s += 12;

   318 	}

   319 	u32 v = armNextPC;

   320 	sprintf(s, "0f:%02x%02x%02x%02x;", (v & 255),

   321 	        (v >> 8) & 255,

   322 	        (v >> 16) & 255,

   323 	        (v >> 24) & 255);

   324 	s += 12;

   325 	CPUUpdateCPSR();

   326 	v = reg[16].I;

   327 	sprintf(s, "19:%02x%02x%02x%02x;", (v & 255),

   328 	        (v >> 8) & 255,

   329 	        (v >> 16) & 255,

   330 	        (v >> 24) & 255);

   331 	s += 12;

   332 	*s = 0;

   333 	//  printf("Sending %s\n", buffer);

   334 	remotePutPacket(buffer);

   335 }

   336 

   337 void remoteBinaryWrite(char *p)

   338 {

   339 	u32 address;

   340 	int count;

   341 	sscanf(p, "%x,%x:", &address, &count);

   342 	//  printf("Binary write for %08x %d\n", address, count);

   343 

   344 	p = strchr(p, ':');

   345 	p++;

   346 	for (int i = 0; i < count; i++)

   347 	{

   348 		u8 b = *p++;

   349 		switch (b)

   350 		{

   351 		case 0x7d:

   352 			b = *p++;

   353 			debuggerWriteByte(address, (b^0x20));

   354 			address++;

   355 			break;

   356 		default:

   357 			debuggerWriteByte(address, b);

   358 			address++;

   359 			break;

   360 		}

   361 	}

   362 	//  printf("ROM is %08x\n", debuggerReadMemory(0x8000254));

   363 	remotePutPacket("OK");

   364 }

   365 

   366 void remoteMemoryWrite(char *p)

   367 {

   368 	u32 address;

   369 	int count;

   370 	sscanf(p, "%x,%x:", &address, &count);

   371 	//  printf("Memory write for %08x %d\n", address, count);

   372 

   373 	p = strchr(p, ':');

   374 	p++;

   375 	for (int i = 0; i < count; i++)

   376 	{

   377 		u8   v = 0;

   378 		char c = *p++;

   379 		if (c <= '9')

   380 			v = (c - '0') << 4;

   381 		else

   382 			v = (c + 10 - 'a') << 4;

   383 		c = *p++;

   384 		if (c <= '9')

   385 			v += (c - '0');

   386 		else

   387 			v += (c + 10 - 'a');

   388 		debuggerWriteByte(address, v);

   389 		address++;

   390 	}

   391 	//  printf("ROM is %08x\n", debuggerReadMemory(0x8000254));

   392 	remotePutPacket("OK");

   393 }

   394 

   395 void remoteMemoryRead(char *p)

   396 {

   397 	u32 address;

   398 	int count;

   399 	sscanf(p, "%x,%x:", &address, &count);

   400 	//  printf("Memory read for %08x %d\n", address, count);

   401 

   402 	char buffer[1024];

   403 

   404 	char *s = buffer;

   405 	for (int i = 0; i < count; i++)

   406 	{

   407 		u8 b = debuggerReadByte(address);

   408 		sprintf(s, "%02x", b);

   409 		address++;

   410 		s += 2;

   411 	}

   412 	*s = 0;

   413 	remotePutPacket(buffer);

   414 }

   415 

   416 void remoteStepOverRange(char *p)

   417 {

   418 	u32 address;

   419 	u32 final;

   420 	sscanf(p, "%x,%x", &address, &final);

   421 

   422 	remotePutPacket("OK");

   423 

   424 	remoteResumed = true;

   425 	do

   426 	{

   427 		CPULoop(1);

   428 		if (debugger)

   429 			break;

   430 	}

   431 	while (armNextPC >= address && armNextPC < final);

   432 

   433 	remoteResumed = false;

   434 

   435 	remoteSendStatus();

   436 }

   437 

   438 void remoteWriteWatch(char *p, bool active)

   439 {

   440 	u32 address;

   441 	int count;

   442 	sscanf(p, ",%x,%x#", &address, &count);

   443 

   444 	fprintf(stderr, "Write watch for %08x %d\n", address, count);

   445 

   446 	if (address < 0x2000000 || address > 0x3007fff)

   447 	{

   448 		remotePutPacket("E01");

   449 		return;

   450 	}

   451 

   452 	if (address > 0x203ffff && address < 0x3000000)

   453 	{

   454 		remotePutPacket("E01");

   455 		return;

   456 	}

   457 

   458 	u32 final = address + count;

   459 

   460 	if (address < 0x2040000 && final > 0x2040000)

   461 	{

   462 		remotePutPacket("E01");

   463 		return;

   464 	}

   465 	else if (address < 0x3008000 && final > 0x3008000)

   466 	{

   467 		remotePutPacket("E01");

   468 		return;

   469 	}

   470 

   471 	for (int i = 0; i < count; i++)

   472 	{

   473 		if ((address >> 24) == 2)

   474 			freezeWorkRAM[address & 0x3ffff] = active;

   475 		else

   476 			freezeInternalRAM[address & 0x7fff] = active;

   477 		address++;

   478 	}

   479 

   480 	remotePutPacket("OK");

   481 }

   482 

   483 void remoteReadRegisters(char *p)

   484 {

   485 	char buffer[1024];

   486 

   487 	char *s = buffer;

   488 	int   i;

   489 	// regular registers

   490 	for (i = 0; i < 15; i++)

   491 	{

   492 		u32 v = reg[i].I;

   493 		sprintf(s, "%02x%02x%02x%02x",  v & 255, (v >> 8) & 255,

   494 		        (v >> 16) & 255, (v >> 24) & 255);

   495 		s += 8;

   496 	}

   497 	// PC

   498 	u32 pc = armNextPC;

   499 	sprintf(s, "%02x%02x%02x%02x", pc & 255, (pc >> 8) & 255,

   500 	        (pc >> 16) & 255, (pc >> 24) & 255);

   501 	s += 8;

   502 

   503 	// floating point registers (24-bit)

   504 	for (i = 0; i < 8; i++)

   505 	{

   506 		sprintf(s, "000000000000000000000000");

   507 		s += 24;

   508 	}

   509 

   510 	// FP status register

   511 	sprintf(s, "00000000");

   512 	s += 8;

   513 	// CPSR

   514 	CPUUpdateCPSR();

   515 	u32 v = reg[16].I;

   516 	sprintf(s, "%02x%02x%02x%02x",  v & 255, (v >> 8) & 255,

   517 	        (v >> 16) & 255, (v >> 24) & 255);

   518 	s += 8;

   519 	*s = 0;

   520 	remotePutPacket(buffer);

   521 }

   522 

   523 void remoteWriteRegister(char *p)

   524 {

   525 	int r;

   526 

   527 	sscanf(p, "%x=", &r);

   528 

   529 	p = strchr(p, '=');

   530 	p++;

   531 

   532 	char c = *p++;

   533 

   534 	u32 v = 0;

   535 

   536 	u8 data[4] = {0, 0, 0, 0};

   537 

   538 	int i = 0;

   539 

   540 	while (c != '#')

   541 	{

   542 		u8 b = 0;

   543 		if (c <= '9')

   544 			b = (c - '0') << 4;

   545 		else

   546 			b = (c + 10 - 'a') << 4;

   547 		c = *p++;

   548 		if (c <= '9')

   549 			b += (c - '0');

   550 		else

   551 			b += (c + 10 - 'a');

   552 		data[i++] = b;

   553 		c         = *p++;

   554 	}

   555 

   556 	v = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);

   557 

   558 	//  printf("Write register %d=%08x\n", r, v);

   559 	reg[r].I = v;

   560 	if (r == 15)

   561 	{

   562 		armNextPC = v;

   563 		if (armState)

   564 			reg[15].I = v + 4;

   565 		else

   566 			reg[15].I = v + 2;

   567 	}

   568 	remotePutPacket("OK");

   569 }

   570 

   571 void remoteStubMain()

   572 {

   573 	if (!debugger)

   574 		return;

   575 

   576 	if (remoteResumed)

   577 	{

   578 		remoteSendStatus();

   579 		remoteResumed = false;

   580 	}

   581 

   582 	while (true)

   583 	{

   584 		char buffer[1024];

   585 		int  res = remoteRecvFnc(buffer, 1024);

   586 

   587 		if (res == -1)

   588 		{

   589 			fprintf(stderr, "GDB connection lost\n");

   590 #ifdef SDL

   591 			dbgMain   = debuggerMain;

   592 			dbgSignal = debuggerSignal;

   593 #endif

   594 			debugger = false;

   595 			break;

   596 		}

   597 

   598 		//    fprintf(stderr, "Received %s\n", buffer);

   599 		char *p  = buffer;

   600 		char  c  = *p++;

   601 		char  pp = '+';

   602 		remoteSendFnc(&pp, 1);

   603 

   604 		if (c != '$')

   605 			continue;

   606 		c = *p++;

   607 		switch (c)

   608 		{

   609 		case '?':

   610 			remoteSendSignal();

   611 			break;

   612 		case 'D':

   613 			remotePutPacket("OK");

   614 #ifdef SDL

   615 			dbgMain   = debuggerMain;

   616 			dbgSignal = debuggerSignal;

   617 #endif

   618 			remoteResumed = true;

   619 			debugger      = false;

   620 			return;

   621 		case 'e':

   622 			remoteStepOverRange(p);

   623 			break;

   624 		case 'k':

   625 			remotePutPacket("OK");

   626 #ifdef SDL

   627 			dbgMain   = debuggerMain;

   628 			dbgSignal = debuggerSignal;

   629 #endif

   630 			debugger  = false;

   631 			emulating = false;

   632 			return;

   633 		case 'C':

   634 			remoteResumed = true;

   635 			debugger      = false;

   636 			return;

   637 		case 'c':

   638 			remoteResumed = true;

   639 			debugger      = false;

   640 			return;

   641 		case 's':

   642 			remoteResumed = true;

   643 			remoteSignal  = 5;

   644 			CPULoop(1);

   645 			if (remoteResumed)

   646 			{

   647 				remoteResumed = false;

   648 				remoteSendStatus();

   649 			}

   650 			break;

   651 		case 'g':

   652 			remoteReadRegisters(p);

   653 			break;

   654 		case 'P':

   655 			remoteWriteRegister(p);

   656 			break;

   657 		case 'M':

   658 			remoteMemoryWrite(p);

   659 			break;

   660 		case 'm':

   661 			remoteMemoryRead(p);

   662 			break;

   663 		case 'X':

   664 			remoteBinaryWrite(p);

   665 			break;

   666 		case 'H':

   667 			remotePutPacket("OK");

   668 			break;

   669 		case 'q':

   670 			remotePutPacket("");

   671 			break;

   672 		case 'Z':

   673 			if (*p++ == '2')

   674 			{

   675 				remoteWriteWatch(p, true);

   676 			}

   677 			else

   678 				remotePutPacket("");

   679 			break;

   680 		case 'z':

   681 			if (*p++ == '2')

   682 			{

   683 				remoteWriteWatch(p, false);

   684 			}

   685 			else

   686 				remotePutPacket("");

   687 			break;

   688 		default:

   689 		{

   690 			*(strchr(p, '#') + 3) = 0;

   691 			fprintf(stderr, "Unknown packet %s\n", --p);

   692 			remotePutPacket("");

   693 			break;

   694 		}

   695 		}

   696 	}

   697 }

   698 

   699 void remoteStubSignal(int sig, int number)

   700 {

   701 	remoteSignal  = sig;

   702 	remoteResumed = false;

   703 	remoteSendStatus();

   704 	debugger = true;

   705 }

   706 

   707 void remoteCleanUp()

   708 {

   709 	if (remoteCleanUpFnc)

   710 		remoteCleanUpFnc();

   711 }

   712
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 03 Mar 2012 10:54:39 -0600
parents	f9f4f1b99eed
children	ecd30c5e2f5a