main.c

win32program disassembler

//
//
// This program was written by Sang Cho, associate professor at 
//                                       the department of 
//                                       computer science and engineering
//                                       chongju university
// language used: gcc 
//
// date of second release: August 30, 1998 (alpha version)
// many fixed after release: October 9, 1998 
//
//
//      you can contact me: e-mail address: [e-mail]
//                            hitel id: chokhas
//                        phone number: [phone]    [phone]
//
//            real address: Sang Cho
//                      Computer and Information Engineering
//                      ChongJu University
//                      NaeDok-Dong 36 
//                      ChongJu 360-764
//                      South Korea
//
//   Copyright (C) 1997,1998,1999                            by Sang Cho.
//
// Permission is granted to make and distribute verbatim copies of this
// program provided the copyright notice and this permission notice are
// preserved on all copies.
//
// File: main.c 

# include "disasm.h"        

#define  INT_MAX   0x7FFFFFFF

#define  jLmax     50000
#define  hMax      5120
#define  hintMax   1024
#define  NAMEMAX   256
#define  COLSIZE   78

//FILE     *d_fp;
int      nextMode=0;           // some role in preprocessing
int      printMode=0;  
int      zeroCheckMode=0;
int      lineno=0;
int      errorCount=0;
int      debugx=0;
int      debugTab[256]={0,};
char     mname[NAMEMAX];
int      fsize;
int      showDotsNum=0;
DWORD    debugAdd=0;
DWORD    debugAdd1=0;

int      jLc;
_labels  pArray[jLmax];
_labels  suspicious[hMax]; // I am lazy so i will use _labes to store suspicious places...

int      dmc=0;
DWORD    dmLabels[32];
int      HintCnt=0;
_key_    Hints[hintMax]; // I am lazy so i will use _key_ structure to store hints...
int      hCnt=0;
history  History[hMax];
int      needJump=0;
DWORD    needJumpNext;
int      needCall=0;
DWORD    needCallRef, needCallNext;
DWORD    fatalPosition;
DWORD    fatalReference;

// *********************************************************
// ****************** main here ****************************
// *********************************************************

int main(argc,argv)
int argc; char **argv;
{
FILE     *my_fp;
//extern FILE  *d_fp;
int       i, n;
DWORD     r;
char      fname[NAMEMAX];

    if (argc == 2)
    {
        strcpy(fname, argv[1]);
        my_fp = fopen (argv[1], "rb");
        if (my_fp == NULL) 
        {
        fprintf (stderr,"canNOTopenFILE: %s", argv[1]);
        exit (0);
        }
    }
    else if (argc == 3)
    {
        strcpy(fname, argv[1]);
        strcpy(mname, argv[2]);
        my_fp = fopen (argv[1], "rb");
        
        if (my_fp == NULL) 
        {
        fprintf (stderr,"canNOTopenFILE: %s", argv[1]);
        exit (0);
        }
        
        readHint();
    }
    else
    {
         fprintf (stderr,"\nusage: dsassm02 input_file_name > output_file_name");
		 fprintf (stderr,"\nversion 0.22 released February 22, 1999\n");
         exit (0);
    }

    //d_fp  = fopen ("xxxxxx.xxx", "w");
    //if (d_fp == NULL) 
    //{
    //    fprintf (stderr,"canNOTopenFILE: %s", "xxxxxx.xxx");
    //    exit (0);
    //}
    
    fseek (my_fp, 0L, SEEK_END);
    fsize = ftell (my_fp);
    rewind (my_fp);

    lpFile = (void *) calloc (fsize,1);
    if (lpFile == NULL)
    {
        fprintf (stderr,"canNOTallocateMEMORY");
        exit (0);
    }

    printf ("Disassembly of File: %s\n\n", argv[1]);
    n = fread (lpFile, fsize, 1, my_fp);

    if (n == -1)
    {
        fprintf(stderr,"failed to read the FILE");
        exit (0);
    }

    // I need to connect pedump and preprocessing.
    
    initHeaders();

    pedump (argc, argv);     /* put together */

	//Myfinish();

    tryAnyAddress();
    tryPascalStrings();

	//Myfinish();
    printf ("\n");
    //printf ("\n*************** BEGINNING OF PROCESSING  ************************** \n");
    fprintf (stderr,"\n*************** PREPROCESSING BEGINS ************************** \n");
    
	showDotsNum=0;
    //fprintf(stderr,"entryPoint=%08X imageBase=%08X imagebaseRVA=%08X CodeOffset=%08X\n",
    //                (int)entryPoint, (int)imageBase, (int)imagebaseRVA, CodeOffset);
    //fprintf(stderr,"CodeSize=%08X",CodeSize);
    
    if (entryPoint>0) resetDisassembler(imageBase+entryPoint);
	else              resetDisassembler(imagebaseRVA);
    orMap(imageBase+entryPoint,0x40);
    EnterLabel(2048, imageBase+entryPoint, imageBase);

    nextMode = 1;       // to say now preprocessing is started.
    zeroCheckMode=1;
    printMode = 0;
    //printMode= 1;

    while (1)
    {
        debugx=0; 
        /*-------------*/pushTrace(1000);
        Disassembler();
        /*-------------*/popTrace();
        if (fatalError) ErrorRecover(); 

        // I have to make sure there is no looping.
        // in a micro level or macro level. think BIG.... be happy.... october 27,1997
        /*-------------*/pushTrace(1010);
        r=GetNextOne();
        /*-------------*/popTrace();
        /*-------------*/pushTrace(1020);
        resetDisassembler(r);
        /*-------------*/popTrace();
        if (r==0) break;
    }

    if (debugAdd>0) MapSummary();
    //ReportMap();

    //Myfinish();
    /*-----------------*/pushTrace(1030);
    PostProcessing1();
    /*-----------------*/popTrace();
    
    //printf ("\n*************** END OF PREPROCESSING **************************** ");
    if (fatalError)
    {   
        //printf("\nError=%d",fatalError);
        fatalError=0;
    }

    if (debugAdd>0)
	{
        printf ("\n\n*************** LABELS COLLECTED ARE: source side ******************** ");
        printf ("\n");

        sortTrees1();
    
        printf ("\n\n*************** LABELS COLLECTED ARE: destination ******************** ");
        printf ("\n");
    
        sortTrees();
    } 

    /*-----------------*/pushTrace(1040);
    LabelProcess();
    /*-----------------*/popTrace();

    //ReportMap();

    //Myfinish();exit(0);
    
    printf ("\n\n+++++++++++++++++++ ASSEMBLY CODE LISTING +++++++++++++++++++");
    printf ("\n//********************** Start of Code in Object CODE **************");
    printf ("\nProgram Entry Point = %08X (%s File Offset:%08X)\n",
            (int)(imageBase+entryPoint),argv[1],CodeOffset); 
    fprintf (stderr,"\n\n*************** LISTING BEGINS *************************** \n");
	
	showDotsNum=0;
    nextMode = 0;        // to say now preporcessing is finished.
    zeroCheckMode=0;
    printMode=1;

    resetDisassembler(imagebaseRVA);

    while (!GotEof)
    {
        debugx=0;
        /*-------------*/pushTrace(1050);
        Disassembler();
        /*-------------*/popTrace();
        
        if(GotEof) break;
        if(getOffset(cur_position)<CodeOffset+CodeSize)
           fprintf(stderr,"\na little disassemble error near :%08X\n", (int)cur_position);
        if(getOffset(cur_position)<CodeOffset+CodeSize)
           fprintf(stdout,"\na little disassemble error near :%08X\n", (int)cur_position);
        fatalError=0;
        i=ReadOneByte(); 
        addressfix();
        a_loc++;   i_col=0;
        pr3ntf("\n:%08X %02X",(int)cur_position, i); 
    }

    Xreference();
    
    //sortTrees1();sortTrees();
	
	/* close files and release memory NOW */
    if (debugAdd>0) fprintf (stderr,
    "\naddL=%5d reset=%5d ErrorR=%5d eraseU=%5d totalZero=%08X",
     addLabelsNum, resetNum, ErrorRecoverNum, eraseUncertainNum,totZero);    
    
    if (debugAdd>0) reportHistory();
	
	printf ("\n*************** END OF LISTING ********************************** \n");
    fprintf(stderr,"\n");
	
	Myfinish();
	return 1;   
}
// **********************************************************************
// **************************end of main ********************************
// **********************************************************************

//
// all the functions used in the main 
//

// **************************************
// disassembler block starts here
// **************************************

void initDisassembler()
{
    yyfirsttime = 1;                     // to refresh position from the file
    a_loc = 0;
    a_loc_save = 0;
    i_col = 0;
    i_col_save = 0;
    i_psp = 0;
    GotEof =0;
    lineno=0;
    NumberOfBytesProcessed = -1;
    operandOveride = 0;
    addressOveride = 0;
    dmc = 0;
    fatalError = 0;
    needJump=0;
    needCall=0;
    needCallRef=0;
    needCallNext=0;
    needJumpNext=0;
}

int   resetNum=0;
DWORD lastReset=0;
int   resetHistogram[256]={0,};

void  resetDisassembler(DWORD ref)
{
//int      i;

    initDisassembler();
    vCodeOffset = getOffset(ref);
    vCodeSize   = CodeOffset-vCodeOffset+CodeSize;
    delta       = vCodeOffset - CodeOffset;
    
    lastReset    = ref;
    cur_position = ref;

    // mark start position here.
    /*----------*/pushTrace(1060);
    if (nextMode) orMap(ref, 0x20);
    /*----------*/popTrace();

    //printf("\nresetDisassembler :%08X getByte=%02X",ref,getByteFile(ref));
	//if(nextMode)
	//fprintf(stderr,"\nresetDisassembler :%08X getByte=%02X",ref,getByteFile(ref));
    resetHistogram[getByteFile(ref)]+=1;
    resetNum++;
}

int      envSave[32];
void pushEnvironment()
{
    envSave[ 0]=yyfirsttime;
    envSave[ 1]=a_loc;
    envSave[ 2]=a_loc_save;
    envSave[ 3]=i_col;
    envSave[ 4]=i_col_save;
    envSave[ 5]=i_psp;
    envSave[ 6]=NumberOfBytesProcessed;
    envSave[ 7]=operandOveride;
    envSave[ 8]=addressOveride;
    envSave[ 9]=vCodeOffset;
    envSave[10]=vCodeSize;
    envSave[11]=dmc;
    envSave[12]=delta;
    envSave[13]=(int)cur_position;
    envSave[14]=needJump;
    envSave[15]=needCall;
    envSave[16]=GotEof;
    envSave[17]=(int)yyfp;
    envSave[18]=(int)yypmax;
    envSave[19]=nextMode;
    envSave[20]=printMode;
    envSave[21]=zeroCheckMode;
    envSave[22]=needJumpNext;
}

void popEnvironment()
{
    yyfirsttime             = envSave[ 0];
    a_loc                   = envSave[ 1];
    a_loc_save              = envSave[ 2];
    i_col                   = envSave[ 3];
    i_col_save              = envSave[ 4];
    i_psp                   = envSave[ 5];
    NumberOfBytesProcessed  = envSave[ 6];
    operandOveride          = envSave[ 7];
    addressOveride          = envSave[ 8];
    vCodeOffset             = envSave[ 9];
    vCodeSize               = envSave[10];
    dmc                     = envSave[11];
    delta                   = envSave[12];
    cur_position     = (DWORD)envSave[13];
    needJump                = envSave[14];
    needCall                = envSave[15];
    GotEof                  = envSave[16];
    yyfp             = (PBYTE)envSave[17];
    yypmax           = (PBYTE)envSave[18];
    nextMode                = envSave[19];
    printMode               = envSave[20];
    zeroCheckMode           = envSave[21];
    needJumpNext            = envSave[22];
}

void showDots()
{
static int n=0;
    
    n++;
    if (n%20==0) 
	{
	    fprintf(stderr,".");
		showDotsNum++; if (showDotsNum%COLSIZE==0) fprintf(stderr,"\n");
    }
}


//
// the engine of this program
//
void Disassembler()
{
//static BYTE   bb=0x00;
int       tok;
BYTE      c;
int       choice;
//int       i;
			
    showDots();
    
    while (!GotEof)
    {        
            /*-----------*/pushTrace(1100);
            addressfix();
            /*-----------*/popTrace();

            c = getMap(cur_position);
            
            if (nextMode) 
            { 
                     if (c==0x0E)       {fatalError=256;break;} 
                else if ((c&0x08)==0x08){needJump=1;    break;} 
                else if ((c&0x05)==0x05){needJump=1;    break;}  
                choice=0;
            }
            else 
            {
                      if ((c&0x0F)==0x0E)  choice=1;   // address