main.c

Linux下的类似softice的调试工具

/******************************************************************************
 *
 * PROJECT: pICE
 * $Source: /cvsroot/pice/pice/loader/main.c,v $
 * $Revision: 1.4 $
 * $Date: 2003/06/18 21:58:16 $
 * $Author: lightweave $
 * $Name:  $
 *
 * $Log: main.c,v $
 * Revision 1.4  2003/06/18 21:58:16  lightweave
 * DEBUG and DEBUG_SERIAL added
 *
 *
 *****************************************************************************/

static char *ident = "$Header: /cvsroot/pice/pice/loader/main.c,v 1.4 2003/06/18 21:58:16 lightweave Exp $";


/*++

Copyright (c) 1998-2001 Klaus P. Gerlicher

Module Name:

    main.c

Abstract:
	
    loader/translator for pIce LINUX

Environment:

    User mode only

Author:

    Klaus P. Gerlicher

Revision History:

    04-Aug-1998:	created
    15-Nov-2000:    general cleanup of source files
    
Copyright notice:

  This file may be distributed under the terms of the GNU Public License.

--*/

///////////////////////////////////////////////////////////////////////////////////
// includes
#include "stdinc.h"

#include <linux/errno.h>
#include <asm/ioctl.h>
#include <sys/stat.h>


///////////////////////////////////////////////////////////////////////////////////
// constant defines                                                                   


///////////////////////////////////////////////////////////////////////////////////
// global variables
char SrcFileNames[2048][2048];
ULONG ulCurrentSrcFile = 0;

int debugger_file;

ULONG ulGlobalVerbose = 0;


///////////////////////////////////////////////////////////////////////////////////
// process_stabs()
//
///////////////////////////////////////////////////////////////////////////////////
void process_stabs(
	char* pExeName,	// name of exe
	int fileout,	// symbol file handle
	Elf32_Shdr* pSHdr,
	int	nSHdrSize,
	void* p,		// ptr to memory where whole exe was read
	PSTAB_ENTRY pStab,	// ptr to stabs	
	int nStabLen,		// size of stabs
	char* pStr,			// ptr to stabs strings
	int nStrLen,		// sizeof stabs strings
	char* pGlobals,		// ptr to global symbols
	int nGlobalLen,		// sizeof of globals
	char* pGlobalsStr,	// ptr to global strings
	int nGlobalStrLen)	// size of global strings
{
    int i,strLen;
    int nOffset=0,nNextOffset=0;
    PSTAB_ENTRY pStabCopy = pStab;
    char* pName,szCurrentPath[2048];
	PICE_SYMBOLFILE_HEADER SymbolFileHeader;
	LPSTR pSlash,pDot;
	char temp[2048];
	char* pCopyExeName = temp;

    //printf("LOADER: enter process_stabs()\n");

    memset((void*)&SymbolFileHeader,0,sizeof(SymbolFileHeader));
	SymbolFileHeader.magic = PICE_MAGIC;
	strcpy(temp,pExeName);
	pSlash = strrchr(temp,'/');
	pDot = strrchr(temp,'.');
	if(pDot)
	{
		*pDot = 0;
	}
	if(pSlash)
	{
		pCopyExeName = pSlash+1;
	}
	strcpy(SymbolFileHeader.name,pCopyExeName);

    for(i=0;i<(nStabLen/sizeof(STAB_ENTRY));i++)
    {
        pName = &pStr[pStabCopy->n_strx + nOffset];

#if 0
        //printf("LOADER: \n%.8x %.2x %.2x %.4x %.8x %s\n",
                pStabCopy->n_strx,
                pStabCopy->n_type,
                pStabCopy->n_other,
                pStabCopy->n_desc,
                pStabCopy->n_value,
                pName
                );
#endif
        switch(pStabCopy->n_type)
        {
            case N_UNDF:
                nOffset += nNextOffset;
                nNextOffset = pStabCopy->n_value;
                //printf("LOADER: changing string offset %x %x\n",nOffset,nNextOffset);
                break;
            case N_SO:
                if((strLen = strlen(pName)))
                {
                    if(pName[strLen-1]!='/')
                    {
                        if(strlen(szCurrentPath))
                        {
                            //printf("LOADER: ###########################################################################\n");
                            strcat(szCurrentPath,pName);
                            //printf("LOADER: changing source file %s\n",szCurrentPath);
                            strcpy(SrcFileNames[ulCurrentSrcFile++],szCurrentPath);
                            szCurrentPath[0]=0;
                        }
                        else
                        {
                            //printf("LOADER: ###########################################################################\n");
                            //printf("LOADER: changing source file %s\n",pName);
                            strcpy(SrcFileNames[ulCurrentSrcFile++],pName);
                        }
                    }
                    else
                        strcpy(szCurrentPath,pName);
                }
                else
                {
                    //printf("LOADER: END source file\n");
                    //printf("LOADER: ###########################################################################\n");
                }
                break;
/*            case N_SLINE:
                //printf("LOADER: code source line number #%u for addr. %x\n",pStabCopy->n_desc,pStabCopy->n_value);
                break;
            case N_DSLINE:
                //printf("LOADER: data source line number #%u for addr. %x\n",pStabCopy->n_desc,pStabCopy->n_value);
                break;
            case N_BSLINE:
                //printf("LOADER: BSS source line number #%u for addr. %x\n",pStabCopy->n_desc,pStabCopy->n_value);
                break;
            case N_GSYM:
                //printf("LOADER: global symbol %s @ addr. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_BINCL:
                //printf("LOADER: include file %s\n",pName);
                break;
            case N_EINCL:
                break;
            case N_FUN:
                if(strlen(pName))
                    //printf("LOADER: function %s @ addr. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                else
                    //printf("LOADER: text segment %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_PSYM:
                //printf("LOADER: parameter %s @ [EBP%+d] (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_RSYM:
                //printf("LOADER: register variable %s @ reg. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_LBRAC:
                //printf("LOADER: lexical block %s @ reg. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_RBRAC:
                //printf("LOADER: END of lexical block %s @ reg. %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_STSYM:
                //printf("LOADER: static variable %s @ %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_LCSYM:
                //printf("LOADER: BSS variable %s @ %x (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                break;
            case N_LSYM:
                if(pStabCopy->n_value)
                {
                    //printf("LOADER: stack variable %s @ [EBP%+d] (%x)\n",pName,pStabCopy->n_value,pStabCopy->n_desc);
                }
                else
                {
                    //printf("LOADER: global variable %s \n",pName);
                }
                break;
*/
        }

        pStabCopy++;
    }

	//printf("LOADER: SymbolFileHeader.ulSizeOfHeader= %x (%x)\n",nSHdrSize,(LPSTR)pSHdr-(LPSTR)p);
	//printf("LOADER: SymbolFileHeader.ulSizeOfGlobals = %x (%x)\n",nGlobalLen,(LPSTR)pGlobals-(LPSTR)p);
	//printf("LOADER: SymbolFileHeader.ulSizeOfGlobalsStrings = %x (%x)\n",nGlobalStrLen,(LPSTR)pGlobalsStr-(LPSTR)p);
	//printf("LOADER: SymbolFileHeader.ulSizeOfStabs = %x (%x)\n",nStabLen,(LPSTR)pStab-(LPSTR)p);
	//printf("LOADER: SymbolFileHeader.ulSizeOfStabsStrings = %x (%x)\n",nStrLen,(LPSTR)pStr-(LPSTR)p);

	SymbolFileHeader.ulOffsetToHeaders = sizeof(PICE_SYMBOLFILE_HEADER);
	SymbolFileHeader.ulSizeOfHeader = nSHdrSize;
	SymbolFileHeader.ulOffsetToGlobals = sizeof(PICE_SYMBOLFILE_HEADER)+nSHdrSize;
	SymbolFileHeader.ulSizeOfGlobals = nGlobalLen;
	SymbolFileHeader.ulOffsetToGlobalsStrings = sizeof(PICE_SYMBOLFILE_HEADER)+nSHdrSize+nGlobalLen;
	SymbolFileHeader.ulSizeOfGlobalsStrings = nGlobalStrLen;
	SymbolFileHeader.ulOffsetToStabs = sizeof(PICE_SYMBOLFILE_HEADER)+nSHdrSize+nGlobalLen+nGlobalStrLen;
	SymbolFileHeader.ulSizeOfStabs = nStabLen;
	SymbolFileHeader.ulOffsetToStabsStrings = sizeof(PICE_SYMBOLFILE_HEADER)+nSHdrSize+nGlobalLen+nGlobalStrLen+nStabLen;
	SymbolFileHeader.ulSizeOfStabsStrings = nStrLen;
    SymbolFileHeader.ulOffsetToSrcFiles = sizeof(PICE_SYMBOLFILE_HEADER)+nSHdrSize+nGlobalLen+nGlobalStrLen+nStabLen+nStrLen;
    SymbolFileHeader.ulNumberOfSrcFiles = ulCurrentSrcFile;

	write(fileout,&SymbolFileHeader,sizeof(SymbolFileHeader));

	write(fileout,pSHdr,nSHdrSize);
	write(fileout,pGlobals,nGlobalLen);
	write(fileout,pGlobalsStr,nGlobalStrLen);
	write(fileout,pStab,nStabLen);
	write(fileout,pStr,nStrLen);

    for(i=0;i<ulCurrentSrcFile;i++)
    {
        int file;
        int len;
        PVOID pFile;
        PICE_SYMBOLFILE_SOURCE pss;
    
        file = open(SrcFileNames[i],O_RDONLY);
        if(file>0)
        {
            //printf("LOADER: [%u] opened %s as FD %x\n",i,SrcFileNames[i],file);

            len = lseek(file,0,SEEK_END);
            //printf("LOADER: length = %x\n",(int)len);
        
            lseek(file,0,SEEK_SET);

            strcpy(pss.filename,SrcFileNames[i]);
            pss.ulOffsetToNext = len+sizeof(PICE_SYMBOLFILE_SOURCE);

            pFile = malloc(len);
            //printf("LOADER: memory for file @ %x\n",pFile);
            if(pFile)
            {
                //printf("LOADER: reading file...\n");
                read(file,pFile,len);
    
                write(fileout,&pss,sizeof(PICE_SYMBOLFILE_SOURCE));
                //printf("LOADER: writing file...\n");
                write(fileout,pFile,len);
                free(pFile);
            }

            close(file);
        }

    }

    //printf("LOADER: leave process_stabs()\n");
}

///////////////////////////////////////////////////////////////////////////////////
// find_stab_sections()
//
///////////////////////////////////////////////////////////////////////////////////
void find_stab_sections(void* p,Elf32_Shdr* pSHdr,PSTAB_ENTRY* ppStab,int* pLen,char** ppStr,int* pnStabStrLen,int num,int index)
{
int i;
char* pStr = (char*)((int)p + pSHdr[index].sh_offset);

    //printf("LOADER: enter find_stab_sections()\n");
    *ppStab = 0;
    *ppStr = 0;
    for(i=0;i<num;i++,pSHdr++)
    {
        int sh_name = pSHdr->sh_name;
        //printf("LOADER: [%u] %32s %8x %8x %8x %8x %8x\n",i,&pStr[sh_name],pSHdr->sh_offset,pSHdr->sh_size,pSHdr->sh_addr,pSHdr->sh_type,pSHdr->sh_link);
        if(strcmp(&pStr[sh_name],".stab") == 0)
        {
            *ppStab = (PSTAB_ENTRY)((int)p + pSHdr->sh_offset);
            *pLen = pSHdr->sh_size;
            //printf("LOADER: .stab @ %x (offset %x) len = %x\n",*ppStab,pSHdr->sh_offset,pSHdr->sh_size);
        }
        else if(strcmp(&pStr[sh_name],".stabstr") == 0)
        {
            *ppStr = (char*)((int)p + pSHdr->sh_offset);
			*pnStabStrLen = pSHdr->sh_size;
            //printf("LOADER: .stabstr @ %x (offset %x size=%u)\n",*ppStr,pSHdr->sh_offset,pSHdr->sh_size);
        }
    }

    //printf("LOADER: leave find_stab_sections()\n");
}

///////////////////////////////////////////////////////////////////////////////////
// find_symtab()
//
///////////////////////////////////////////////////////////////////////////////////
Elf32_Sym* find_symtab(void* p,Elf32_Shdr* pSHdrOrig,int num,int index,int* pLen,LPSTR* ppStr,int *pnSymStrLen)
{
    int i;
    Elf32_Sym* pSym = NULL,*pSymOrig = NULL;
//    char* pStr = (char*)((int)p + pSHdrOrig[index].sh_offset);
    LPSTR pName;
    ULONG ulSymTabEntries = 0,link=-1;
    Elf32_Shdr* pSHdr;

    //printf("LOADER: enter find_symtab()\n");

    // find global symbol table
    pSHdr = pSHdrOrig;
    for(i=0;i<num;i++,pSHdr++)
    {
        //int sh_name = pSHdr->sh_name;
        //printf("LOADER: [%u] %32s %8x %8x %8x %8x %8x\n",i,pStr,pSHdr->sh_offset,pSHdr->sh_size,pSHdr->sh_addr,pSHdr->sh_type,pSHdr->sh_link);
		if(pSHdr->sh_type == SHT_SYMTAB)
		{
			pSym = (Elf32_Sym*)((int)p+pSHdr->sh_offset);

			//printf("LOADER: symbol table %u %x %u\n",i,pSHdr->sh_offset,pSHdr->sh_link);
			ulSymTabEntries = pSHdr->sh_size;
			link = pSHdr->sh_link;