dbgcmd.c

< 虚拟机设计与实现> 的source code, linux版本

#include "dbgcmd.h"

#include <stdio.h>
#include "error.h"
#include "dbgdata.h"
#include "exenv.h"
#include "iset.h"

char debugLine[MAX_DBG_CHARS];

struct DbgRange parseRangeStr();
void dumpRamRng(U8 strt, U8 stp);

void printAppData();
void printHelp();
void toggleDebugging(int state);
void printRawBytes(U1 *ptr, U1 len);

void getIdentifierMetaData();
S8 showCurrentProc(U1 display);
U1 matchProcName(char *str, U4 ind);
U1 searchCurrentProc(char *str, U4 ind);
U1 searchForGlobal(char * str);

void searchForStr();
U1 cmpRAMStr(U1 *ptr1, U1 *ptr2, U4 len);

void readDbgCmd()
{
	int size;
    struct DbgRange rng;

	printf("\n");

	while (1)
	{
		printf("debug>");
		scanf("%s", debugLine);

		size = strlen(debugLine);
		if (size >= MAX_DBG_CHARS)
		{ 
			printf("error: input command out of bounds\n");
			continue;
		}

		switch (debugLine[0])
		{
		case '?':
			if (debugLine[1] == '\0')
			{ 
			    printHelp(); 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'f':
		case 'F':
			if (debugLine[1] == '\0')
			{ 
				printAppData(); 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'q':
		case 'Q':
			if (debugLine[1] == '\0')
			{ 
				toggleDebugging(DEBUG_OFF); 
				return; 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'd':
		case 'D':
			if (debugLine[1] == '\0')
			{ 
				rng = parseRangeStr();
				if (rng.ok != BAD_RANGE)
				{
				    dumpRamRng(rng.start,rng.stop);
				}
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'S':
		case 's':
			if (debugLine[1] == '\0')
			{ 
				searchForStr();	
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
         
		case 'L':
		case 'l':
			if (debugLine[1] == '\0')
			{ 
				getIdentifierMetaData(); 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'P':
		case 'p':
			if (debugLine[1] == '\0')
			{ 
				showCurrentProc(TRUE); 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'R':
		case 'r':
			if ((debugLine[1] == 'i') && (debugLine[2] == '\0'))
			{ 
				printBasicRegisters();
				printGeneralRegisters();
			}
			else if ((debugLine[1] == 'f') && (debugLine[2] == '\0'))
			{ 
				printFloatRegisters(); 
			}
			else if ((debugLine[1] == 'd') && (debugLine[2] == '\0'))
			{ 
				printDoubleRegisters(); 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		case 'T':
		case 't':
			if (debugLine[1] == '\0')
			{ 
				return; 
			}
			else
			{ 
				BAD_CMD(); 
			}
            break;
			
		default:
			BAD_CMD();
		}/*end switch*/

		if (fflush(stdin))
		{ 
			ERROR0("error: could not flush STDIN"); 
		}
	}/*end while*/
	return;

}/*end readDbgCmd*/

struct DbgRange parseRangeStr()
{
	struct DbgRange rng;
	int ret;

	rng.ok = VALID_RANGE;
	
	ret = rU8(&rng.start);
	if ((ret == EOF) || (ret == 0))
	{
		printf("bad start range\n");
		rng.ok = BAD_RANGE;
		return rng;
	}

	ret = rU8(&rng.stop);
	if((ret == EOF) || (ret == 0))
	{
		printf("bad end range\n");
		rng.ok = BAD_RANGE;
		return rng;
	}

	if ((rng.start < 0) || (rng.stop < 0))
	{
		printf("negative range values not allowed\n");
		rng.ok = BAD_RANGE;
		return rng;
	}
	else if (rng.start > rng.stop)
	{
		printf(" ( start > stop ) not allowed\n");
		rng.ok = BAD_RANGE;
		return rng;
	}

	if (rng.start > R[$TOP])
	{
		printf("range start value is greater than $TOP\n");
		rng.ok = BAD_RANGE;
		return rng;
	}

	if (rng.stop > R[$TOP])
	{
		printf("range stop value is greater than $TOP\n");
		rng.ok = BAD_RANGE;
		return rng;
	}

	return rng;

}/*end parseRangeStr*/

void printAppData()
{
	printf("\nEXECUTABLE FILE----------------------\n");
	
	printf("file name->%s\n", appMetaData.fileName);
	
	printf("file size->");  
	pU8(appMetaData.fileSize);
	
	printf("\nfile symbol table size->"); 
	pU8(appMetaData.szSymTbl);
	
	printf("\nfile string table size->"); 
	pU8(appMetaData.szStrTbl);
	
	printf("\nfile bytecode size->"); 
	pU8(appMetaData.szByteCode);
	
	printf("\nbytecode offset begin in file->"); 
	pU8(appMetaData.bCodeFileStart);
	
	printf("\nbytecode offset end in file->"); 
	pU8(appMetaData.bCodeFileEnd);
	
	printf("\n\nMEMORY LAYOUT------------------------\n");
	printf("heap allocated->"); 
	pU8(appMetaData.heapSize);
	
	printf("\nstack allocated->"); 
	pU8(appMetaData.stackSize);
	
	printf("\ntotal ram->"); 
	pU8(appMetaData.ram);
	
	printf("\n\n");
	return;

}/*end printFileData*/

void printHelp()
{
	printf("\nHEng debug mode help\n");
	printf("----------------------\n");
	printf("?\ndisplay this help screen\n\n");
	printf("d start stop\ndump bytes of memory in the range [start, stop]\n\n");
	printf("f\ndisplay executable file information\n\n");
	printf("l string\nquery meta-data for a program identifier\n\n");
	printf("p\nquery current procedure\n\n");
	printf("q\nexit debug mode and return to production mode\n\n");
	printf("ri\ndisplay integer registers\n\n");
	printf("rf\ndisplay float registers\n\n");
	printf("rd\ndisplay double registers\n\n");
	printf("s start stop string\nsearch memory range [start, stop] for string\n\n");
	printf("t\ntrace through next instruction\n\n");
	return;

}/*end printHelp*/

void dumpRamRng(U8 strt, U8 stp)
{
	U8 i;
	U8 j;

	j = 0;
	printf("\n");

	for (i = strt; i <= stp; i++)
	{ 
		PRINT_MEM(i); 
		printf("\t");
		
		if ((RAM[i] > 32) && (RAM[i] < 127))
		{
			printf("ASCII= %c ", RAM[i]);
		}
		else
		{
			switch(RAM[i])
			{
			case ' ':
				printf("ASCII=<SP>");
				break;
				
			case '\n':
				printf("ASCII=<TAB>");
				break;
				
			case '\r':
				printf("ASCII=<CR>");
				break;
				
			case '\t':
				printf("ASCII=<NL>");
				break;
				
			default:
				printf("ASCII= control char(%lu)", RAM[i]);
			}
		}
		printf("\n");
		j++;
	}
	printf("\n");
	return;

}/*end dumpRamRng*/

void toggleDebugging(int state)
{
	if (state == DEBUG_ON)
	{ 
		debug = TRUE; 
	}
	else if (state == DEBUG_OFF)
	{ 
		debug = FALSE; 
	}
	else
	{ 
		ERROR0("invalid state change request");
		debug = TRUE;
	}
	return;

}/*end toggleDebugging*/

void printDbgInstr(U8 addr)
{
	/*display in assembler and in binary*/
	
	U8 current_byte;	/*lookahead from addr*/
	U1 raw[11];			/*buffer to hold binary representation*/
	S2 * pS2;
	S4 * pS4;
	S8 * pS8;
	F4 * pF4;
	F8 * pF8;
	U8 * pU8;

	current_byte = addr;
		
	printf("address->"); 
	pU8(addr); 
	printf("\n");

	switch (RAM[current_byte])
	{
	case LBI:	/* LBI $r1, byte constant  BBB */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
		
		current_byte++;
		printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
		
		current_byte++;
		printf("%d\n", (S1)RAM[current_byte]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);
        break;
		
	case LWI:	/* LWI $r1, word constant  BBW */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
			
		current_byte++;
		raw[2] = RAM[current_byte];	
		current_byte++;
		raw[3] = RAM[current_byte];

		pS2 = (S2 *)&RAM[current_byte - 1];
		pS2(*pS2); 
		printf("\n");

		printRawBytes(raw, 4);
        break;
		
	case LDI:	/* LDI $r1, dword constant  BBD */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
			
		current_byte++;
        raw[2] = RAM[current_byte];
		current_byte++;
		raw[3] = RAM[current_byte];
		current_byte++;
		raw[4] = RAM[current_byte];
		current_byte++;
		raw[5] = RAM[current_byte];

		pS4 = (S4 *)&RAM[current_byte - 3];
		pS4(*pS4); 
		printf("\n");

		printRawBytes(raw, 6);
        break;
		
	case LQI:	/* LQI $r1, qword constant  BBQ*/
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
			
		current_byte++;
		raw[2] = RAM[current_byte];
		current_byte++;
		raw[3] = RAM[current_byte];
		current_byte++;
		raw[4] = RAM[current_byte];
		current_byte++;
		raw[5] = RAM[current_byte];
		current_byte++;
		raw[6] = RAM[current_byte];
		current_byte++;
		raw[7] = RAM[current_byte];
		current_byte++;
		raw[8] = RAM[current_byte];
		current_byte++;
		raw[9] = RAM[current_byte];

		pS8 = (S8 *)&RAM[current_byte - 7];
		pS8(*pS8);
		printf("\n");
			
		printRawBytes(raw, 10);	
        break;
		
	case LF1I:  /* LF1I $f, float */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", Rf_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
			
		current_byte++;
		raw[2] = RAM[current_byte];
		current_byte++;
		raw[3] = RAM[current_byte];
		current_byte++;
		raw[4] = RAM[current_byte];
		current_byte++;
		raw[5] = RAM[current_byte];

	    pF4 = (F4 *)&RAM[current_byte - 3];
		printf("%g\n", *pF4);

		printRawBytes(raw, 6);
        break;
		
	case LF2I:	/* LF2I $d, double */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", Rd_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
			
		current_byte++;
		raw[2] = RAM[current_byte];
		current_byte++;
		raw[3] = RAM[current_byte];
		current_byte++;
		raw[4] = RAM[current_byte];
		current_byte++;
		raw[5] = RAM[current_byte];
		current_byte++;
		raw[6] = RAM[current_byte];
		current_byte++;
		raw[7] = RAM[current_byte];
		current_byte++;
		raw[8] = RAM[current_byte];
		current_byte++;
		raw[9] = RAM[current_byte];

		pF8 = (F8 *)&RAM[current_byte - 7];
		printf("%g\n", *pF8);

		printRawBytes(raw, 10);	
		break;
		
	case LAD:	/* LAD $r1, address = BBQ */ 
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
        printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
		
		current_byte++;
		raw[2] = RAM[current_byte];
		current_byte++;
		raw[3] = RAM[current_byte];
		current_byte++;
		raw[4] = RAM[current_byte];
		current_byte++;
		raw[5] = RAM[current_byte];
		current_byte++;
		raw[6] = RAM[current_byte];
		current_byte++;
		raw[7] = RAM[current_byte];
		current_byte++;
		raw[8] = RAM[current_byte];
		current_byte++;
		raw[9] = RAM[current_byte];

		pU8 = (U8 *)&RAM[current_byte - 7];
		pU8(*pU8);
		printf("\n");
			
		printRawBytes(raw, 10);	
		break;
		
	case LAI:   /* LAI $r1, $r2, qword     BBBQ*/
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
			
		current_byte++;
        printf("%s ", R_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];
			
		current_byte++;
		raw[3] = RAM[current_byte];
		current_byte++;
		raw[4] = RAM[current_byte];
		current_byte++;
		raw[5] = RAM[current_byte];
		current_byte++;
		raw[6] = RAM[current_byte];
		current_byte++;
		raw[7] = RAM[current_byte];
		current_byte++;
		raw[8] = RAM[current_byte];
		current_byte++;
		raw[9] = RAM[current_byte];
		current_byte++;
		raw[10] = RAM[current_byte];

		pS8 = (S8 *)&RAM[current_byte - 7];
		pS8(*pS8);
		printf("\n");
			
		printRawBytes(raw, 11);	
        break;
		
	case LB:	/* LB $r1,$r2	BBB */
	case LW:
	case LD:
	case LQ:
	case SB:	/* SB $r1,$r2   BBB*/ 
	case SW:
	case SD:
	case SQ:
	case MOV:	/* MOV $r1, $r2    BBB */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
		printf("%s ", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
		
		current_byte++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);	
        break;
		
	case LF1:	/* LF1  $f, $r */
	case SF1:
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
        printf("%s ", Rf_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];
		
		current_byte++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);	
        break;
		
	case LF2:	/* LF2  $d, $r */
	case SF2:
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;