debugger.cpp

浙江大学的悟空嵌入式系统模拟器

			case 'g':
				Core::s32 reg[32];
				Core::s32 ret;
				ret = get_registers(reg);
				mem2hex((Core::u8*)reg, outbuf, ret * sizeof(Core::s32), 0);
				break;
			case 'G':
				Core::u8 val[256];
				hex2mem(p,val,256,0);
				reverse_4((char *)val,32);
				write_registers((Core::s32 *)(val));
				
				write_ok(outbuf);
				break;
			case 'p'://phex number of register -- read register packet 
				hex2int(&p,&addri,0);
				get_register((Core::u32)(addri),gvalue);
				mem2hex((Core::u8*)(&gvalue),outbuf,4,0);
				break;
			case 'P'://Pn...=r... -- write register 
				// may need a register convertion?????
				hex2int(&p,&addri,'=');
				if(*p++ != '=')
					break;

				hex2int(&p,(Core::s32 *)&gvalue,0);
				write_register((Core::u32)(addri),gvalue);

				write_ok(outbuf);
				break;
			case 's':
				hex2int(&p, &addri, 0);
				if (addri == 0)
					get_register(PC_IDX, (Core::Register_Int &)addri);

				step(addri, 0);

				resume_reply(outbuf);			
				break;
			case 'c':
				hex2int(&p, &addri,0);
				if (addri == 0)
					get_register(PC_IDX, (Core::Register_Int &)addri);

				con(addri,0);
				// wait for simulator to stop , should get some signal
				resume_reply(outbuf);
				break;
			case 'S':
				hex2int(&p, &sig, ';');
				if (*p++ != ';')
					break;
				hex2int(&p, &addri, 0);
				if (addri == 0)
					get_register(PC_IDX, (Core::Register_Int &)addri);

				step(addri, sig);

				resume_reply(outbuf);
				break;
			case 'C':
				hex2int(&p, &sig, ';');
				if (*p++ != ';')
					break;
				hex2int(&p, &addri, 0);
				if (addri == 0)
					get_register(PC_IDX, (Core::Register_Int &)addri);

				con(addri, sig);

				resume_reply(outbuf);
				break;
			case 'e':
			case 'E': // which are optional
				//break;
				write_ok(outbuf);
				put_packet(csock,outbuf);
			case 'n': // which are optional
				hex2int(&p, &addri, ',');
				if (*p++ != ',')
					break;
				hex2int(&p, &newaddri, 0);

				remove_BPWP(MEMORY_BREAKPOINT, addri, 1);
				insert_BPWP(MEMORY_BREAKPOINT, newaddri, 1);

				con(addri,0);

				resume_reply(outbuf);
				break;
			case 'i': // draft which are optional
				break;
				Core::s32 cyclecount;
				hex2int(&p, &addri,',');
				if (*p++ != ',') 
					break;
				hex2int(&p, &cyclecount, 0);
			//	step();
				break;
			case 'H': // which are optional
				//break;
				handle_H_packet(p, outbuf);
				break;
			case 'q':
				handle_q_packet(p, outbuf);
				break;
			case '?':
				strcpy((char *)outbuf, "S00000001"); //cheat
				break;
			case 'D':   //no response needed
			case 'k'://kill
			case 'R'://restart :no reply
				iscont_ = false;
				return -1;
				break;
			case 't': // which are optional
				break;
				Core::s32 pattern;
				Core::s32 mask;
				hex2int(&p, &addri, ':');
				if (*p++ != ':')
					break;
				hex2int(&p, &pattern, ',');
				if (*p++ != ',')
					break;
				hex2int(&p, &mask, 0);
				search(addri, pattern, mask);
				break;
			case '!': // extended mode
			case 'T': // which are optional
			case 'U': // which are optional
				break;
				write_ok(outbuf);
				break;
			default:
				break;
			}
		}
		return 1;
	}

	void Debugger::handle_H_packet(Core::u8 *inbuf, Core::u8 *outbuf)
	{
		write_ok(outbuf);
		return;
	}

	void Debugger::handle_q_packet(Core::u8 * inbuf, Core::u8 *outbuf)
	{
		if (strncmp((char *)inbuf, "Offset", strlen("Offset")) == 0)
		{
			// I am not sure this is right
			strcpy((char *)outbuf, "Text=0;Data=0;Bss=0");
			return ;	
		}

		write_ok(outbuf);

		return;
	}

	void Debugger::reply_T_packet(Core::u8 *outbuf)
	{
		Core::s32 reg[32];
		Core::s32 ret;
		ret = get_registers(reg);

		int pos = 0;

		Core::u8 *ptr = outbuf;

		*ptr++ = 'T';
		*ptr++ = hexchars[TARGET_SIGNAL_TRAP >> 4];
		*ptr++ = hexchars[TARGET_SIGNAL_TRAP & 0xf];

		// pc 
		*ptr++ = hexchars[PC_IDX >> 4];
		*ptr++ = hexchars[PC_IDX & 0xf];
		*ptr++ = ':';
		ptr = mem2hex((Core::u8 *)(reg+PC_IDX), ptr, sizeof(Core::s32),0);
		*ptr++ = ';';
		
		// LR
		*ptr++ = hexchars[LR_IDX >> 4];
		*ptr++ = hexchars[LR_IDX & 0xf];
		*ptr++ = ':';
		ptr = mem2hex((Core::u8 *)(reg+LR_IDX), ptr, sizeof(Core::s32),0);
		*ptr++ = ';';

		// SP
		*ptr++ = hexchars[SP_IDX >> 4];
		*ptr++ = hexchars[SP_IDX & 0xf];
		*ptr++ = ':';
		ptr = mem2hex((Core::u8 *)(reg+SP_IDX), ptr, sizeof(Core::s32),0);
		*ptr++ = ';';

		// CPSR
		*ptr++ = hexchars[24 >> 4];
		*ptr++ = hexchars[24 & 0xf];
		*ptr++ = ':';
		ptr = mem2hex((Core::u8 *)(reg+CPSR_IDX), ptr, sizeof(Core::s32),0);
		*ptr++ = ';';

		*ptr = 0;

		return ;
	}

	void Debugger::resume_reply(Core::u8 *outbuf)
	{
		while (!get_debug() && !get_stop_simulator());

		if (get_stop_simulator())
			strcpy((char *)outbuf, "S03");
		else reply_T_packet(outbuf);

		return;
	}

	void Debugger::do_with_special_char(Core::u8 *inbuf, size_t len)
	{
		int writepos = 0;
		size_t pos = 0;

		while (pos < len)
		{
			if (inbuf[pos] == 0x7d)
			{
				inbuf[writepos++] = inbuf[++pos] ^ 0x20;
				++pos;
				continue;
			}
			inbuf[writepos++] = inbuf[pos++];
		}

		inbuf[writepos] = 0;

		return;
	}

	void Debugger::put_packet(::wxSocketBase *csock, Core::u8 *buffer)
	{
	//	if (*buffer == 0) return;
		Core::u8 checksum;
		int count,i;
		Core::u8 ch;
		Core::u8 buf[BUFMAX];

		i = 0;
		buf[i++] = '$';
		checksum = 0;
		count = 0;

		while ((ch = buffer[count]) != 0) {
			buf[i++] = ch;
			checksum += ch;
			count += 1;
		}

		buf[i++] = '#';
		buf[i++] = hexchars[checksum >> 4];
		buf[i++] = hexchars[checksum & 0xf];

		csock->Write((char *)buf,i);
	}


	int Debugger::hex(Core::u8 ch)
	{
		if (ch >= 'a' && ch <= 'f')
			return ch-'a'+10;
		if (ch >= '0' && ch <= '9')
			return ch-'0';
		if (ch >= 'A' && ch <= 'F')
			return ch-'A'+10;
		return -1;
	}

	Core::u8 * Debugger::int2hex(Core::s32 value, Core::u8* outbuf)
	{
		int i = 0;
		Core::u8 *ptr = outbuf;

		for (; i < 4; ++i)
		{
			
		}
		return ptr;
	}
	/*
	* Convert the memory pointed to by mem into hex, placing result in buf.
	* Return a pointer to the last Core::u8 put in buf (null), in case of mem fault,
	* return 0.
	* may_fault have not been used
	*/
	Core::u8 * Debugger::mem2hex(Core::u8 *mem, Core::u8 *buf, int count, int may_fault)
	{   //count is bytes number
		Core::u8 ch;
		int i = 0;
		int bufpos = 0;

		while ( i < count ) 
		{
			ch = mem[i];
			buf[bufpos++] = hexchars[ch >> 4];
			buf[bufpos++] = hexchars[ch & 0xf];
			++i;
		}

		buf[bufpos] = 0;
		return (Core::u8 *)(buf+bufpos);
	}

	/*
	* convert the hex array pointed to by buf into binary to be placed in mem
	* return a pointer to the character AFTER the last byte written
	* may_fault has not been used
	*/

	Core::u8 * Debugger::hex2mem(Core::u8 *buf, Core::u8 *mem, int count, int may_fault)
	//count 是buffer里的字符数,即半字节的数目
	{
		int i = 0;
		int mempos = 0;
		Core::u8 ch;

		while (i < count)
		{
			ch = hex(buf[i++]) << 4;
			ch |= hex(buf[i++]);
			mem[mempos++] = ch;
		}
		return mem;
	}

	/* convert only Core::u8 arrays with a length of sizeof(Core::s32) into Core::s32, and then 
	* place the value into the intValue, also you may have ptr point to a array
	* point that contain chars with it Core::u8 number greater than 8 that is need 
	*/
	int Debugger::hex2int(Core::u8 **ptr, Core::s32 *intValue, Core::u8 divchar)
	{
		int numChars = 0;
		int hexValue;

		*intValue = 0;

		while ((**ptr != divchar) && (**ptr))
		{
			hexValue = hex(**ptr);
			if (hexValue < 0)	break;

			*intValue = (*intValue << 4) | hexValue;
			numChars ++;

			(*ptr)++;
		}

		return (numChars);
	}

	int Debugger::hex2long(Core::u8 **ptr, long *longValue, Core::u8 divchar)
	{
		int numChars = 0;
		int hexValue;

		*longValue = 0;

		while ((**ptr != divchar) && (**ptr))
		{
			hexValue = hex(**ptr);
			if (hexValue < 0)
				break;

			*longValue = (*longValue << 4) | hexValue;
			numChars ++;

			(*ptr)++;
		}

		return numChars;
	}

	void Debugger::reverse_4(char *buf, int count)
	{
		int pos = 0;
		
		for (int i = 0; i < count; ++i)
		{
			pos = i * 4;
			buf[pos+0] ^= buf[pos+3];
			buf[pos+3] ^= buf[pos+0];
			buf[pos+0] ^= buf[pos+3];
			buf[pos+1] ^= buf[pos+2];
			buf[pos+2] ^= buf[pos+1];
			buf[pos+1] ^= buf[pos+2];		
		}
		
		return;
	}

	const Core::u8 Debugger:: lnibble_to_hex (Core::s32 i)
	{
		return hexchars[i & 0xf];
	}

	void Debugger::write_err(Core::u8 *buf)
	{
	// ?add some err type here
		strcpy((char *)buf, "E01");
	}

	void Debugger::write_ok(Core::u8 *buf)
	{
		strcpy((char *)buf, "OK");
	}
//! Debugger class end here
//! ======================================================================================
	
	::wxThread::ExitCode DebuggerThread::Entry()
	{
		assert(dbg_);

		dbg_->debug_run();

		return 0;
	}

} //namespace