parse.c

Linux下的类似softice的调试工具

        if(*pSrcLine == 0x0d)
            pSrcLine++;
        if(*pSrcLine == 0x0a)
            pSrcLine++;
    }

    Clear(SOURCE_WINDOW);
    DisableScroll(SOURCE_WINDOW);
    for(i=0;i<wWindow[SOURCE_WINDOW].cy;i++)
    {
        pTemp = tempCmd;

        if(pSrcLine<pSrcEnd)
        {
            PICE_sprintf(tempCmd,".%.5u ",ulLineNumber+i);
            pTemp = tempCmd + strlen(tempCmd);

            while(pSrcLine<pSrcEnd && *pSrcLine!=0x0a && *pSrcLine!=0x0d)
            {
                if(*pSrcLine==0x9) // TAB
                {
                    *pTemp++ = 0x20;
                    *pTemp++ = 0x20;
                    *pTemp++ = 0x20;
                    *pTemp++ = 0x20;
                    pSrcLine++;
                }
                else
                {
                    *pTemp++ = *pSrcLine++;
                }
            }
        
            if(pSrcLine<pSrcEnd)
            {
                // skip over the line end
                if(*pSrcLine == 0x0d)
                    pSrcLine++;
                if(*pSrcLine == 0x0a)
                    pSrcLine++;
            }

            *pTemp++ = '\n';
            *pTemp = 0;

            if(PICE_strlen(tempCmd)>GLOBAL_SCREEN_WIDTH-1)
            {
                tempCmd[GLOBAL_SCREEN_WIDTH-2]='\n';
                tempCmd[GLOBAL_SCREEN_WIDTH-1]=0;
            }

            if( (ulLineNumberToInvert!=-1) &&
               ((int)(ulLineNumberToInvert-ulLineNumber)>=0) &&
               ((ulLineNumberToInvert-ulLineNumber)<wWindow[SOURCE_WINDOW].cy) &&
               (i==(ulLineNumberToInvert-ulLineNumber)) )
            {
                SetForegroundColor(COLOR_BACKGROUND);
                SetBackgroundColor(COLOR_FOREGROUND);
            }

            Print(SOURCE_WINDOW,tempCmd);

            if( (ulLineNumberToInvert!=-1) &&
               ((int)(ulLineNumberToInvert-ulLineNumber)>=0) &&
               ((ulLineNumberToInvert-ulLineNumber)<wWindow[SOURCE_WINDOW].cy) &&
               (i==(ulLineNumberToInvert-ulLineNumber)) )
            {
                ResetColor();
            }

        }
        else
        {
            Print(SOURCE_WINDOW,"---- End of source file --------------\n");
            break;
        }
    }
    EnableScroll(SOURCE_WINDOW);
}

//*************************************************************************
// UnassembleOneLineDown()
//
//*************************************************************************
void UnassembleOneLineDown(EXCEPTION_FRAME* pFrame)
{
    ULONG addr,addrorg;

	ENTER_FUNC();

    addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addr = %.8X\n",addr);

    tempCmd[0]=0;
	Disasm(&addr,tempCmd);

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addr after = %.8X\n",addr);

    ulOldDisasmOffset += (addr - addrorg);
    RepaintSource(pFrame);

	LEAVE_FUNC();
}

//*************************************************************************
// UnassembleOnePageDown()
//
//*************************************************************************
void UnassembleOnePageDown(EXCEPTION_FRAME* pFrame,ULONG page)
{
    ULONG addr,addrorg,i;

	ENTER_FUNC();

    addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addr = %.8X\n",addr);

    tempCmd[0]=0;
    for(i=0;i<page;i++)
	    Disasm(&addr,tempCmd);

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addr after = %.8X\n",addr);

    ulOldDisasmOffset += (addr - addrorg);
    RepaintSource(pFrame);
	LEAVE_FUNC();
}

//*************************************************************************
// UnassembleOneLineUp()
//
//*************************************************************************
void UnassembleOneLineUp(EXCEPTION_FRAME* pFrame)
{
    ULONG addr,addrorg,addrbefore,start,end,addrstart;
    LONG offset;
    LPSTR pSymbol;

	ENTER_FUNC();

    addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addrorg = %.8X\n",addr);

    offset = 1;

    if((pSymbol = FindFunctionByAddress(addrorg-offset,&start,&end)) )
    {
        offset = addrorg - start;
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "%s @ offset = %u\n",pSymbol,offset);
    }
    else
    {
        // max instruction length is 15 bytes 
        offset = 15;
    }

    addrstart = addrorg;

    // start at current address less offset
    addr = addrorg - offset;
    do
    {
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "offset = %u addrorg %x addr %x\n",offset,addrorg,addr);
        // disassemble while not reaching current instruction
        addrbefore = addr;
        tempCmd[0]=0;
	    Disasm(&addr,tempCmd);
        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "%.8X: %s\n",addrbefore,tempCmd);
    }while((addr != addrorg) && (addrbefore < addrorg));

    if((addrorg - addrstart)<=0)
        ulOldDisasmOffset--;
    else
        ulOldDisasmOffset -= (addrorg - addrbefore);

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "new addr = %.4X:%.8X\n",usOldDisasmSegment,ulOldDisasmOffset);

    RepaintSource(pFrame);

	LEAVE_FUNC();
}

//*************************************************************************
// UnassembleOneLineUp()
//
//*************************************************************************
void UnassembleOnePageUp(EXCEPTION_FRAME* pFrame,ULONG page)
{
    ULONG addr,addrorg,addrbefore,start,end,i,addrstart;
    LONG offset;
    LPSTR pSymbol;

	ENTER_FUNC();

    for(i=0;i<page;i++)
    {
        addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

        DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "addrorg = %.8X\n",addr);

        offset = 1;

        if((pSymbol = FindFunctionByAddress(addrorg-offset,&start,&end)) )
        {
            offset = addrorg - start;
            DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "%s @ offset = %u\n",pSymbol,offset);
        }
        else
        {
            // max instruction length is 15 bytes 
            offset = 15;
        }

        // start at current address less offset
        addr = addrorg - offset;
        addrstart = addrorg;
        do
        {
            DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "offset = %u addrorg %x addr %x\n",offset,addrorg,addr);
            addrbefore = addr;
            // disassemble while not reaching current instruction
            tempCmd[0]=0;
	        Disasm(&addr,tempCmd);
            DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "%.8X: %s\n",addrbefore,tempCmd);
        }while((addr != addrorg) && (addrbefore < addrorg));

        if((addrorg - addrstart)<=0)
            ulOldDisasmOffset--;
        else
            ulOldDisasmOffset -= (addrorg - addrbefore);

    }

    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "new addr = %.4X:%.8X\n",usOldDisasmSegment,ulOldDisasmOffset);

    RepaintSource(pFrame);

	LEAVE_FUNC();
}

//*************************************************************************
// Unassemble()
//
//*************************************************************************
COMMAND_PROTOTYPE(Unassemble)
{
    ULONG i;
    ULONG addr=0,addrorg,addrstart,ulLineNumber;
    USHORT segment=0;
    ULONG addrbefore;
    LPSTR pSymbolName;
	BOOLEAN bSWBpAtAddr;
    LPSTR pSrc,pFilename,pSrcStart,pSrcEnd;
    BOOLEAN bForceDisassembly = FALSE;

	ENTER_FUNC();

    if(pArgs->CountSwitches>1)
        goto Quit;

    if(pArgs->CountSwitches==1)
    {
        if(pArgs->Switch[0] == 'f')
            bForceDisassembly = TRUE;
    }

	// we have args
	if(pArgs->Count==2)
	{
		addr=pArgs->Value[1];
		segment=(USHORT)pArgs->Value[0];
		addrorg=addrstart=addr;
		addr=GetLinearAddress(segment,addr);

        usOldDisasmSegment = segment;
        ulOldDisasmOffset = addr;
	}
	else if(pArgs->Count==1)
	{
		addr=pArgs->Value[0];
		segment=pFrame->cs;
		addrorg=addrstart=addr;
		addr=GetLinearAddress(segment,addr);

        usOldDisasmSegment = segment;
        ulOldDisasmOffset = addr;
	}
	else if(pArgs->Count==0)
    {
        segment = usOldDisasmSegment;
		addrorg=addrstart=addr;
        addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);
    }
    else
        goto Quit;


	DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "Unassemble(%04X:%08X)\n", segment, addr);

    //
	// unassemble
    //
    DisableScroll(SOURCE_WINDOW);

    // if we're inside last disassembly range we only need to move to highlight
    if(addr>=ulLastDisassStartAddress && 
       addr<ulLastDisassEndAddress )
	{
		addr=ulLastDisassStartAddress;
	}
	else
	{
		ulLastDisassStartAddress=ulLastDisassEndAddress=0;
	}

    SetForegroundColor(COLOR_TEXT);
	SetBackgroundColor(COLOR_CAPTION);

	ClrLines(wWindow[SOURCE_WINDOW].y-1,1);

    ResetColor();

#ifdef ACTIVATE_SYMBOL_LOOKUP
    if(FindSymbolByAddress(&pSymbolName,addr))
    {
        SetForegroundColor(COLOR_TEXT);
	    SetBackgroundColor(COLOR_CAPTION);
		PICE_sprintf(tempCmd," %s ",pSymbolName);
		PutChar(tempCmd,GLOBAL_SCREEN_WIDTH-1-PICE_strlen(tempCmd),wWindow[SOURCE_WINDOW].y-1);
        ResetColor();
    }
#endif // ACTIVATE_SYMBOL_LOOKUP

    pCurrentMod = FindModuleFromAddress(addr);
    if(pCurrentMod)
    {
        ULONG mod_addr;
	    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "pCurrentMod->name = %s\n",pCurrentMod->name);

        // in case we query for the kernel we need to use the fake kernel module
        if(pCurrentMod == &fake_kernel_module)
        {
            mod_addr = KERNEL_START;
        }
        else
        {
            mod_addr = (ULONG)pCurrentMod;
        }

        mod_addr += sizeof(struct module);
        
        pCurrentSymbols = FindSymbolTableForModule(mod_addr);
   	    DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "pCurrentSymbols = %x\n",(ULONG)pCurrentSymbols);
    }
	DPRINT(PICE_DEBUG, DBT_PARSE, DBL_INFO, "pCurrentMod = %p\n", pCurrentMod);

    ulCurrentlyDisplayedLineNumber = 0;

    if(bShowSrc && bForceDisassembly == FALSE && (pSrc = FindSourceLineForAddress(addr,&ulLineNumber,&pSrcStart,&pSrcEnd,&pFilename)) )
    {
        PICE_strcpy(szCurrentFile,pFilename);

        ulCurrentlyDisplayedLineNumber = ulLineNumber;

    	Clear(SOURCE_WINDOW);

        // display file name
        SetForegroundColor(COLOR_TEXT);
	    SetBackgroundColor(COLOR_CAPTION);

        if(PICE_strlen(pFilename)<GLOBAL_SCREEN_WIDTH/2)
        {
		    PutChar(pFilename,1,wWindow[SOURCE_WINDOW].y-1);
        }
        else
        {
            LPSTR p;
            
            p = strrchr(pFilename,'/');
            if(!p)
            {
                p = pFilename;
            }
            else
            {
                p++;
            }

		    PutChar(p,1,wWindow[SOURCE_WINDOW].y-1);
        }

        ResetColor();

        // display the source
        if(ulLineNumber>(wWindow[SOURCE_WINDOW].cy/2) )
        {
            DisplaySourceFile(pSrcStart,pSrcEnd,ulLineNumber-(wWindow[SOURCE_WINDOW].cy/2),ulLineNumber);
        }
        else
        {
            DisplaySourceFile(pSrcStart,pSrcEnd,ulLineNumber,ulLineNumber);
        }
    }
    else
    {
        *szCurrentFile = 0;

		Clear(SOURCE_WINDOW);

        // for each line in the disassembly window
	    for(i=0;i<wWindow[SOURCE_WINDOW].cy;i++)
	    {
            extern ULONG ulWindowOffset;

		    bSWBpAtAddr = FALSE;
		    // if there is a potential SW breakpoint at address
		    // we might have to put back the original opcode
		    // in order to disassemble correctly.
		    if(IsSwBpAtAddress(addr))
		    {
			    // if INT3 is there, remove it while disassembling
			    if((bSWBpAtAddr = IsSwBpAtAddressInstalled(addr)))
			    {
				    DeInstallSWBreakpoint(addr);
			    }
		    }

		    // invert the line that we're about to execute
		    if(addr==pFrame->eip)
		    {
                SetForegroundColor(COLOR_BACKGROUND);
                SetBackgroundColor(COLOR_FOREGROUND);
			    ulLastInvertedAddress = pFrame->eip;
		    }

		    // output segment:offset address 
		    PICE_sprintf(tempCmd,"%0.4X:%0.8X ",segment,addr);
		    Print(SOURCE_WINDOW,tempCmd);

            // disassemble a line
		    addrbefore=addr;
            if(bCodeOn)
            {
                tempCmd[30]=0;
        		Disasm(&addr,&tempCmd[30]);
            }
            else
            {
                tempCmd[0]=0;
        		Disasm(&addr,tempCmd);
            }
		    addrorg+=(addr-addrbefore);

            // want to display opcode bytes
		    if(bCodeOn)
		    {
			    ULONG j;

			    for(j=0;j<15;j++)
			    {
                    if(j<addr-addrbefore)
                    {
				        if(IsAddressValid(addrbefore+j))
				        {
					        tempCmd[j*2]=HexDigit[((*(PUCHAR)(addrbefore+j)&0xF0)>>4)];
					        tempCmd[j*2+1]=HexDigit[((*(PUCHAR)(addrbefore+j)&0xF))];
				        }
				        else
				        {
					        tempCmd[j*2]='?';
					        tempCmd[j*2+1]='?';
				        }
                    }
                    else
                    {