dbgcmd.c

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

        printf("%s ", Rd_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 MOVF:	/*MOVF  $f1, $f2*/
		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", Rf_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);	
        break;
		
	case MOVD:	/*MOVD  $d1, $d2*/
		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++;
        printf("%s\n", Rd_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

        printRawBytes(raw, 3);	
        break;
		
	case PUSHB:	/* PUSHB $r1  BB */
	case PUSHW:
	case PUSHD:
	case PUSHQ:
	case POPB:
	case POPW:
	case POPD:
	case POPQ:
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];

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

		printRawBytes(raw, 2);
        break;
		
	case PUSHF2:	/* PUSHF2 $d */
	case POPF2:
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
        printf("%s\n", Rd_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];

		printRawBytes(raw, 2);
        break;
		
	case JMP:	/* JMP $r1 */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[1] = RAM[current_byte];

		printRawBytes(raw, 2);
        break;
		
	case JE:	/*JE $r1, $r2, $r3 BBBB */
	case JNE:
	case SLT:
	case AND:	/* AND $r1, $r2, $r3 */
	case OR:
	case XOR:
	case BT:
	case SRA:  /*SRA  $r1, $r2, $r3   BBBB */
	case SRL:
	case SL:
	case ADD: /* ADD $r1, $r2, $r3  */
	case SUB:
	case MULT:
		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++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[3] = RAM[current_byte];

		printRawBytes(raw, 4);	
        break; 
		
	case INT: /* INT #vector	BB */
		printf("%s ", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];
			
		current_byte++;
        printf("%u\n", RAM[current_byte]);
		raw[1] = RAM[current_byte];

		printRawBytes(raw, 2);
        break;	
		
	case EI:			/* EI	B */
	case DI:
	case HALT:
	case NOP:
		printf("%s\n", I_Set[RAM[current_byte]]);
		raw[0] = RAM[current_byte];

		printRawBytes(raw, 1);
        break;
		
	case NOT:  /* NOT $r1, $r2 */
	case BS:
		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 DIV:  /* DIV $r1, $r2, $r3, $r4 */
		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++;
        printf("%s ", R_STR[RAM[current_byte]]);
		raw[3] = RAM[current_byte];
			
		current_byte++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[4] = RAM[current_byte];

		printRawBytes(raw, 5);		
        break;
		
	case CAST_IF: /* CAST_IF $r, $f  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", Rf_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);
        break;
		
	case CAST_ID: /* CAST_ID $r, $d  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", Rd_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);
        break;
		
	case CAST_FI: /* CAST_FI $f, $r  BBB*/
		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 CAST_FD: /* CAST_FD $f, $d  BBB*/
		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", Rd_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);
        break;
		
	case CAST_DI: /* CAST_DI $d, $r  BBB*/
		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++;
        printf("%s\n", R_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);
        break;
		
	case CAST_DF: /* CAST_DF $d, $f  BBB*/
		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++;
        printf("%s\n", Rf_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];

		printRawBytes(raw, 3);
        break;
		
	case FADD: /* FADD $f1, $f2, $f3    BBBB */
	case FSUB:
	case FMULT:
	case FDIV:
	case FSLT:
		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 ", Rf_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];
			
		current_byte++;
        printf("%s\n", Rf_STR[RAM[current_byte]]);
		raw[3] = RAM[current_byte];

		printRawBytes(raw, 4);	
        break;
		
	case DADD: /* DADD $d1, $d2, $d3    BBBB */
	case DSUB:
	case DMULT:
	case DDIV:
	case DSLT:
		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++;
        printf("%s ", Rd_STR[RAM[current_byte]]);
		raw[2] = RAM[current_byte];
		
		current_byte++;
        printf("%s\n", Rd_STR[RAM[current_byte]]);
		raw[3] = RAM[current_byte];

		printRawBytes(raw, 4);
        break;
		
	default:
		printf("instruction (%u), not handled\n", RAM[current_byte]);
	}

	printBasicRegisters();
	return;

}/*end void printDbgInstr*/

void printRawBytes(U1 *ptr, U1 len)
{
	U1 i;

	for (i = 0; i < len; i++)
	{ 
		printf("[%3u]", ptr[i]); 
	}
	printf("\n");
	return;

}/*end printRawBytes*/

void searchForStr()
{
	int ret;
	struct DbgRange rng;
	U8 i;
	U4 size;
	U1 found;

	found = FALSE;

	rng.ok = VALID_RANGE;
	rng = parseRangeStr();
	if (rng.ok == BAD_RANGE)
		return;

	ret = scanf("%s", debugLine);
	if ((ret == EOF) || (ret == 0))
	{
		printf("bad search string entered\n");
		return;
	}

	/* search rng.start->rng.stop for debugLine */
		
	size = strlen(debugLine);
	if (size == 0)
	{
		printf("bad search string entered\n");
		return;
	}

	for(i = rng.start;i <= rng.stop; i++)
	{
		if (RAM[i] == debugLine[0])
		{
			ret = cmpRAMStr(debugLine, &RAM[i], size);
			if (ret == TRUE)
			{
				printf("Match-> address="); 
				pU8(i);
				printf("\n");
				found = TRUE;
			}
		}
	}

	if (found == FALSE)
	{ 
		printf("no such string in memory range ");
		pU8(rng.start);
		printf("->");
		pU8(rng.stop);
		printf("\n");
	}
	return;

}/*end searchForStr*/

U1 cmpRAMStr(U1 *ptr1, U1 *ptr2, U4 len)
{
	U4 i;

	for (i = 0; i < len; i++)
	{
		if (ptr1[i] != ptr2[i])
			return FALSE;
	}
	return TRUE;

}/*end cmpRAMStr*/

void getIdentifierMetaData()
{
	int ret;
	S8 proc_ind;

	ret = scanf("%s", debugLine);
	if ((ret == EOF) || (ret == 0))
	{
		printf("bad identifier entered\n");
		return;
	}

	/* look through globals */

	ret = searchForGlobal(debugLine);
	if (ret == TRUE)
	    return;

	/* if not in globals get current proc */

	proc_ind = showCurrentProc(FALSE);
	if (proc_ind == -1)
	{
		printf("symbol not global, currently outside all procedures\n");
		return;
	}
	
	ret = matchProcName(debugLine, (U4)proc_ind);
	if (ret == TRUE)
		return;

	/* if not proc name, look for ret, args, locals, and labels */
	
	ret = searchCurrentProc(debugLine,(U4)proc_ind);
	if(ret==TRUE){ return; }

	printf("could not resolve symbol\n");

	return;

}/*end getIdentifierMetaData*/

U1 searchForGlobal(char * str)
{
	U4 i;
	U8 j;
	U8 addr;
	char * temp;

	for (i = 0; i < debugData.contents.nGlobVarRec; i++)
	{
		temp = &(debugData.strTbl[debugData.gvRec[i].text]);
		if (strcmp(str,temp) == 0)
		{
			printf("global variable->%s\n", str);
			
			printf("type->%s\n", globSz[debugData.gvRec[i].dType]);
			
			printf("length->"); 
			pU8(debugData.gvRec[i].len); 
			printf("\n");
			
			printf("total size->"); 
			pU8(debugData.gvRec[i].size); 
			printf("\n");
			
			printf("line->"); 
			pU4(debugData.gvRec[i].line); 
			printf("\n");
			
			printf("values:\n");
			addr = R[$TOP] - debugData.gvRec[i].offset;
			for(j = 0; j < debugData.gvRec[i].size; j++)
			{
				printf("\t"); 
				pU8(j + 1);
				printf(") address-> ");
				pU8(addr + j);
				printf(" value->%u\n", RAM[addr + j]);
			}
			return TRUE;
		}
	}
	return FALSE;

}/*end searchForGlobal*/

S8 showCurrentProc(U1 display)
{
	U4 i;
	U4 nprocs;
	
	nprocs = debugData.contents.nProcRec;
	for (i = 0; i < nprocs; i++)
	{
		if (((U8)R[$IP]) > debugData.pRec[nprocs - 1].address)
		{
			if (display == TRUE)
			{
				printf("current proc->%s\n", 
					     &(debugData.strTbl[debugData.pRec[nprocs - 1].text]));
				printf("address->"); 
				pU8(debugData.pRec[nprocs - 1].address);
				printf("\n");
				
				printf("line->"); 
				pU4(debugData.pRec[nprocs - 1].line);
				printf("\n");
			}
			return nprocs - 1;
		}
		else if ((debugData.pRec[i].address <= ((U8)R[$IP]))&&
			     (debugData.pRec[i + 1].address > ((U8)R[$IP])))
		{
			if (display == TRUE)
			{
				printf("current proc->%s\n",
					     &(debugData.strTbl[debugData.pRec[i].text]));
				printf("address->"); 
				pU8(debugData.pRec[i].address);
				printf("\n");
				
				printf("line->"); 
				pU4(debugData.pRec[i].line);
				printf("\n");
			}
			return i;
		}
	}
	printf("could not find current function\n");
	return -1;

}/*end showCurrentProc*/

U1 matchProcName(char * str, U4 ind)
{
	char * procname;

	procname = &debugData.strTbl[debugData.pRec[ind].text];
	if (strcmp(str, procname) == 0)
	{
		printf("function->%s\n", str);
		printf("address->"); 
		pU8(debugData.pRec[ind].address); 
		printf("\n");
		
		printf("line="); 
		pU4(debugData.pRec[ind].line); 
		printf("\n");
		return TRUE;
	}
	return FALSE;

}/*end searchForProc*/

/*-----------------------------------------------------------------*/

U1 searchCurrentProc(char * str, U4 ind)
{
	U4 i;
	char *temp;
	U8 addr;
	U1 narg;
	U1 nloc;
	U2 nlbl;

	narg = debugData.pRec[ind].nArg;
	nloc = debugData.pRec[ind].nLocal;
	nlbl = debugData.pRec[ind].nLabel;
	
	if (debugData.pRec[ind].nRet == 1)
	{
		temp = &(debugData.strTbl[debugData.pRec[ind].ret.text]);
		if (strcmp(str,temp) == 0)
		{
			printf("return value->%s\n", str);
			printf("address->");
			addr = R[$FP] + debugData.pRec[ind].ret.fpOffset;
			pU8(addr);
			printf("\n");
			return TRUE;
		}
	}

	for (i = 0; i < narg; i++)
	{
		temp = &(debugData.strTbl[debugData.pRec[ind].arg[i].text]);
		if (strcmp(str, temp) == 0)
		{
			printf("procedure argument->%s\n", str);
			printf("address->");
			addr = R[$FP] + debugData.pRec[ind].arg[i].fpOffset;
			pU8(addr);
			printf("\n");
			return TRUE;
		}
	}

	for (i = 0; i < nloc; i++)
	{
		temp = &(debugData.strTbl[debugData.pRec[ind].local[i].text]);
		if (strcmp(str, temp) == 0)
		{
			printf("local storage->%s\n", str);
			printf("address->");
			addr = R[$FP] + debugData.pRec[ind].local[i].fpOffset;
			pU8(addr);
			printf("\n");
			return TRUE;
		}
	}

	for (i = 0; i < nlbl; i++)
	{
		temp = &(debugData.strTbl[debugData.pRec[ind].label[i].text]);
		if (strcmp(str, temp) == 0)
		{
			printf("label->%s\n", str);
			printf("address->");
			pU8(debugData.pRec[ind].label[i].address);
			printf("\n");
			return TRUE;
		}
	}
	return FALSE;

}/*end searchCurrentProc*/