parse.c

Linux下的类似softice的调试工具

					        tempCmd[j*2]=' ';
					        tempCmd[j*2+1]=' ';
                    }
			    }
		    }
            strcat(tempCmd,"\n");

            if(ulWindowOffset)
            {
                LONG len = PICE_strlen(tempCmd);
                if(ulWindowOffset < len)
                    PICE_memcpy(tempCmd,&tempCmd[ulWindowOffset],len-ulWindowOffset);
                else
                    tempCmd[0]='\n';
            }

		    Print(SOURCE_WINDOW,tempCmd);

            if(addrbefore==pFrame->eip)
		    {
			    ResetColor();
		    }

		    // if potential SW breakpoint, undo marked text
		    if(IsSwBpAtAddress(addrbefore))
		    {
				HatchLine(wWindow[SOURCE_WINDOW].y+i);
		    }
		    
		    // if breakpoint was installed before disassembly, put it back
		    if(bSWBpAtAddr)
		    {
			    ReInstallSWBreakpoint(addrbefore);
		    }

	    }

        if(ulLastDisassStartAddress==0 && ulLastDisassEndAddress==0)
        {
            ulLastDisassStartAddress=addrstart;
            ulLastDisassEndAddress=addr;
        }

	    if(!IsAddressValid(addrstart))
	    {
            ulLastDisassStartAddress=0;
            ulLastDisassEndAddress=0;
	    }

    }

	EnableScroll(SOURCE_WINDOW);

Quit:
	LEAVE_FUNC();
	return TRUE;
}

//*************************************************************************
// ShowModules()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowModules)
{
	struct module *pMod;

	ENTER_FUNC();

    if(pmodule_list)
    {
        pMod = pmodule_list;
        do
        {
			if(pMod->size)
			{
                if(pMod == pCurrentMod)
                {
				    PICE_sprintf(tempCmd,"%.8X - %.8X *%-32s (%6u symbols @ %.8X)\n",
						    (unsigned int)pMod,
						    (unsigned int) ((unsigned int)pMod+pMod->size),pMod->name,pMod->nsyms,pMod->syms);
                }
                else
                {
				    PICE_sprintf(tempCmd,"%.8X - %.8X  %-32s (%6u symbols @ %.8X)\n",
						    (unsigned int)pMod,
						    (unsigned int) ((unsigned int)pMod+pMod->size),pMod->name,pMod->nsyms,pMod->syms);
                }
			}
			else
			{
				PICE_sprintf(tempCmd,"%.8X - %.8X  vmlinux                          (%6u symbols @ %.8X)\n",
						(unsigned int)pMod,
						kernel_end,pMod->nsyms,pMod->syms);
			}
            Print(OUTPUT_WINDOW,tempCmd);
			if(WaitForKey()==FALSE)
				break; 
        }while((pMod = pMod->next));
    }

	LEAVE_FUNC();
	return TRUE;
}

//*************************************************************************
// DecodeVmFlags()
//
//*************************************************************************
LPSTR DecodeVmFlags(ULONG flags)
{
    ULONG i;
/*
#define VM_READ		0x0001	
#define VM_WRITE	0x0002
#define VM_EXEC		0x0004
#define VM_SHARED	0x0008

#define VM_MAYREAD	0x0010	
#define VM_MAYWRITE	0x0020
#define VM_MAYEXEC	0x0040
#define VM_MAYSHARE	0x0080

#define VM_GROWSDOWN	0x0100	
#define VM_GROWSUP	0x0200
#define VM_SHM		0x0400	
#define VM_DENYWRITE	0x0800	

#define VM_EXECUTABLE	0x1000
#define VM_LOCKED	0x2000
#define VM_IO           0x4000  

#define VM_STACK_FLAGS	0x0177
*/
    static LPSTR flags_syms_on[]={"R","W","X","S","MR","MW","MX","MS","GD","GU","SHM","exe","LOCK","IO",""};
    static char temp[256];

    // terminate string
    *temp = 0;

    if(flags == VM_STACK_FLAGS)
    {
        strcpy(temp," (STACK)");
    }
    else
    {
        for(i=0;i<15;i++)
        {
            if(flags&0x1)
            {
                strcat(temp," ");
                strcat(temp,flags_syms_on[i]);
            }
            flags >>= 1;
        }
    }

    return temp;
}

//*************************************************************************
// ShowVirtualMemory()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowVirtualMemory)
{
	struct mm_struct *mm;
    struct vm_area_struct * vma;
	char flbuf[5], *cp;
	int flags;
	char filename[17];

	ENTER_FUNC();

    mm = current->mm;

    if(mm && (mm != my_init_mm))
    {
		if(mm->mmap)
		{
			if(pArgs->Count == 0)
			{
				SetForegroundColor(COLOR_TEXT);
				SetBackgroundColor(COLOR_CAPTION);
				PutStatusText("START    END      VMA      FLAGS");
				ResetColor();
				for(vma = mm->mmap;vma;vma = vma->vm_next)
				{
					flags = vma->vm_flags;

					cp = flbuf;
					*cp++ = flags & VM_READ ? 'r' : '-';
					*cp++ = flags & VM_WRITE ? 'w' : '-';
					*cp++ = flags & VM_EXEC ? 'x' : '-';
					*cp++ = flags & VM_MAYSHARE ? 's' : 'p';
					*cp++ = 0;

					*filename = 0;
					if(vma->vm_file)
					{
						unsigned char *name = vma->vm_file->f_dentry->d_iname;
						PICE_memcpy(filename,name,16);
						filename[16] = 0;
					}

					PICE_sprintf(tempCmd,"%.8X %.8X %.8X %s %s\n",
						vma->vm_start,
						vma->vm_end,
#if LINUX_VERSION_CODE < 0x020400
						vma->vm_offset,
#else // LINUX_VERSION_CODE 
						vma->vm_pgoff << PAGE_SHIFT,
#endif // LINUX_VERSION_CODE 
						flbuf,filename);
					Print(OUTPUT_WINDOW,tempCmd);
					
					if(WaitForKey()==FALSE)break;
				}
			}
		}
		else
			Print(OUTPUT_WINDOW,"no memory map!\n");
    }
	else
		Print(OUTPUT_WINDOW,"no context!\n");

	LEAVE_FUNC();
    return TRUE;
}

//*************************************************************************
// Ver()
//
//*************************************************************************
COMMAND_PROTOTYPE(Ver)
{
	ULONG ulFreeMem,ulAllocMem;

	// get memory size
	GetMemoryStatus(&ulFreeMem,&ulAllocMem);

    PICE_sprintf(tempCmd,"pICE: version %u.%u (build %u) for Linux kernel release %s\n",
                 PICE_MAJOR_VERSION,
                 PICE_MINOR_VERSION,
                 PICE_BUILD,
                 UTS_RELEASE);
	Print(OUTPUT_WINDOW,tempCmd);

    PICE_sprintf(tempCmd,"pICE: loaded on %s kernel release %s\n",
		system_utsname.sysname,
		system_utsname.release);
	Print(OUTPUT_WINDOW,tempCmd);
	Print(OUTPUT_WINDOW,"pICE: written and (C) 1998-2001 by Klaus P. Gerlicher\n");

    PICE_sprintf(tempCmd,"pICE: number of CPUs = %u \n", smp_num_cpus );
	Print(OUTPUT_WINDOW,tempCmd);
    PICE_sprintf(tempCmd,"pICE: total memory = %u (%u MB)\n", ulFreeMem + ulAllocMem,(ulFreeMem + ulAllocMem)/(1024*1024) );
	Print(OUTPUT_WINDOW,tempCmd);
    PICE_sprintf(tempCmd,"pICE: free  memory = %u (%u MB)\n", ulFreeMem,ulFreeMem/(1024*1024));
	Print(OUTPUT_WINDOW,tempCmd);
    PICE_sprintf(tempCmd,"pICE: alloc memory = %u (%u MB)\n", ulAllocMem,ulAllocMem/(1024*1024));
	Print(OUTPUT_WINDOW,tempCmd);

	return TRUE;
}

//*************************************************************************
// Hboot()
//
//*************************************************************************
COMMAND_PROTOTYPE(Hboot)
{
	// nudge the reset line through keyboard controller
	__asm__(
		"movb $0xFE,%al\n"
		"outb %al,$0x64");
	// never gets here
	return TRUE;
}

//*************************************************************************
// SetSrcDisplay()
//
//*************************************************************************
COMMAND_PROTOTYPE(SetSrcDisplay)
{
    ARGS Args;

	if(pArgs->Count==0)
	{
		bShowSrc=bShowSrc?FALSE:TRUE;
        PICE_memset(&Args,0,sizeof(ARGS));
        // make unassembler refresh all again 
        ulLastDisassStartAddress=ulLastDisassEndAddress=0;
		Args.Count=0;
		Unassemble(pFrame,&Args);
	}
	return TRUE;
}

//*************************************************************************
// I3here()
//
//*************************************************************************
COMMAND_PROTOTYPE(I3here)
{
	if(pArgs->Count==1)
	{
		if(pArgs->Value[0]==1)
		{
			if(!bInt3Here)
			{
				bInt3Here=TRUE;
				Print(OUTPUT_WINDOW,"I3HERE is now ON\n");
			}
			else
				Print(OUTPUT_WINDOW,"I3HERE is already ON\n");
		}
		else if(pArgs->Value[0]==0)
		{
			if(bInt3Here)
			{
				bInt3Here=FALSE;
				Print(OUTPUT_WINDOW,"I3HERE is now OFF\n");
			}
			else
				Print(OUTPUT_WINDOW,"I3HERE is already OFF\n");
		}
	}
	else if(pArgs->Count==0)
	{
		if(bInt3Here)
		{
			Print(OUTPUT_WINDOW,"I3HERE is ON\n");
		}
		else
		{
			Print(OUTPUT_WINDOW,"I3HERE is OFF\n");
		}
	}
	// never gets here
	return TRUE;
}

#ifndef LINUX 
COMMAND_PROTOTYPE(I1here)
{
	if(pArgs->Count==1)
	{
		if(pArgs->Value[0]==1)
		{
			if(!bInt1Here)
			{
				bInt1Here=TRUE;
				Print(OUTPUT_WINDOW,"I1HERE is now ON\n");
			}
			else
				Print(OUTPUT_WINDOW,"I1HERE is already ON\n");
		}
		else if(pArgs->Value[0]==0)
		{
			if(bInt1Here)
			{
				bInt1Here=FALSE;
				Print(OUTPUT_WINDOW,"I1HERE is now OFF\n");
			}
			else
				Print(OUTPUT_WINDOW,"I1HERE is already OFF\n");
		}
	}
	else if(pArgs->Count==0)
	{
		if(bInt1Here)
		{
			Print(OUTPUT_WINDOW,"I1HERE is ON\n");
		}
		else
		{
			Print(OUTPUT_WINDOW,"I1HERE is OFF\n");
		}
	}
	// never gets here
	return TRUE;
}
#endif // LINUX

COMMAND_PROTOTYPE(NextInstr)
{
    static char tempDisasm[256];
    ULONG addr,addrbefore;

	bNeedToFillBuffer=FALSE;

	if(!pArgs->Count)
	{
		addr=addrbefore=GetLinearAddress(pFrame->cs,pFrame->eip);
		DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addr before %.8X\n",addrbefore);
		Disasm(&addr,tempDisasm);
		DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addr after %.8X\n",addr);
		pFrame->eip = pFrame->eip+(addr-addrbefore);
		// display register contents
		DisplayRegs(pFrame);
		// unassemble
		DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO,  "new CS:EIP %04x:%08X\n", pFrame->cs, pFrame->eip);
        PICE_memset(pArgs,0,sizeof(ARGS));
        // make unassembler refresh all again 
        ulLastDisassStartAddress=ulLastDisassEndAddress=0;
		pArgs->Count=2;
		pArgs->Value[0]=(ULONG)pFrame->cs;
		pArgs->Value[1]=pFrame->eip;
		Unassemble(pFrame,pArgs);
	}
	bNeedToFillBuffer=TRUE;
	return TRUE;
}

COMMAND_PROTOTYPE(SetGetRegisters)
{
	ULONG i;

	if(pArgs->Count==0)
	{
		// display whole set
		for(i=0;RegKeyWords[i].GetValueFunc!=0;i++)
		{
			switch(RegKeyWords[i].ulSize)
			{
				case 1:
					PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,(UCHAR)(RegKeyWords[i].GetValueFunc(pFrame)));
					break;
				case 2:
					PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,(USHORT)(RegKeyWords[i].GetValueFunc(pFrame)));
					break;
				case 4:
					PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,(ULONG)(RegKeyWords[i].GetValueFunc(pFrame)));
					break;
			}
			Print(OUTPUT_WINDOW,tempCmd);
			if(WaitForKey()==FALSE)break;
		}
	}
	else if(pArgs->Count==1)
	{
		// display selected register
		for(i=0;RegKeyWords[i].GetValueFunc!=0;i++)
		{
			if(PICE_strcmpi(pArgs->pToken[0],RegKeyWords[i].KeyWord)==0)
			{
				switch(RegKeyWords[i].ulSize)
				{
					case 1:
						PICE_sprintf(tempCmd,"%s = %.2X\n",RegKeyWords[i].KeyWord,(UCHAR)(RegKeyWords[i].GetValueFunc(pFrame)));
						break;
					case 2:
						PICE_sprintf(tempCmd,"%s = %.4X\n",RegKeyWords[i].KeyWord,(USHORT)(RegKeyWords[i].GetValueFunc(pFrame)));
						break;
					case 4:
						PICE_sprintf(tempCmd,"%s = %.8X\n",RegKeyWords[i].KeyWord,(ULONG)(RegKeyWords[i].GetValueFunc(pFrame)));
						break;
				}
				Print(OUTPUT_WINDOW,tempCmd);
				break;
			}
		}
	}
	else if(pArgs->Count==2)
	{
		// set selected register to value
		for(i=0;RegKeyWords[i].GetValueFunc!=0;i++)
		{
			if(PICE_strcmpi(pArgs->pToken[0],RegKeyWords[i].KeyWord)==0)
			{
				switch(RegKeyWords[i].ulSize)
				{
					case 1:
						RegKeyWords[i].SetValueFunc(pFrame,(UCHAR)pArgs->Value[1]);
						break;
					case 2: