592 lines
19 KiB
C
592 lines
19 KiB
C
/* Pawn disassembler - crude, but (perhaps) useful
|
|
*
|
|
* Copyright (c) ITB CompuPhase, 2007
|
|
*
|
|
* This software is provided "as-is", without any express or implied warranty.
|
|
* In no event will the authors be held liable for any damages arising from
|
|
* the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose,
|
|
* including commercial applications, and to alter it and redistribute it
|
|
* freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you must not
|
|
* claim that you wrote the original software. If you use this software in
|
|
* a product, an acknowledgment in the product documentation would be
|
|
* appreciated but is not required.
|
|
* 2. Altered source versions must be plainly marked as such, and must not be
|
|
* misrepresented as being the original software.
|
|
* 3. This notice may not be removed or altered from any source distribution.
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "sc.h"
|
|
#include "../amx/amx.h"
|
|
#include "../amx/amxdbg.h"
|
|
|
|
static FILE *fpamx;
|
|
static AMX_HEADER amxhdr;
|
|
static int dbgloaded;
|
|
static AMX_DBG amxdbg;
|
|
|
|
typedef cell (*OPCODE_PROC)(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
|
|
cell parm0(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell parm1(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell parm2(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell parm3(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell parm4(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell parm5(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell do_proc(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell do_call(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell do_jump(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell do_sysreq(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
cell do_casetbl(FILE *ftxt,const cell *params,cell opcode,cell cip);
|
|
|
|
|
|
typedef struct {
|
|
char *name;
|
|
OPCODE_PROC func;
|
|
} OPCODE;
|
|
|
|
static OPCODE opcodelist[] = {
|
|
{ /* 0*/ NULL, NULL },
|
|
{ /* 1*/ "load.pri", parm1 },
|
|
{ /* 2*/ "load.alt", parm1 },
|
|
{ /* 3*/ "load.s.pri", parm1 },
|
|
{ /* 4*/ "load.s.alt", parm1 },
|
|
{ /* 5*/ "lref.pri", parm1 },
|
|
{ /* 6*/ "lref.alt", parm1 },
|
|
{ /* 7*/ "lref.s.pri", parm1 },
|
|
{ /* 8*/ "lref.s.alt", parm1 },
|
|
{ /* 9*/ "load.i", parm0 },
|
|
{ /* 10*/ "lodb.i", parm1 },
|
|
{ /* 11*/ "const.pri", parm1 },
|
|
{ /* 12*/ "const.alt", parm1 },
|
|
{ /* 13*/ "addr.pri", parm1 },
|
|
{ /* 14*/ "addr.alt", parm1 },
|
|
{ /* 15*/ "stor.pri", parm1 },
|
|
{ /* 16*/ "stor.alt", parm1 },
|
|
{ /* 17*/ "stor.s.pri", parm1 },
|
|
{ /* 18*/ "stor.s.alt", parm1 },
|
|
{ /* 19*/ "sref.pri", parm1 },
|
|
{ /* 20*/ "sref.alt", parm1 },
|
|
{ /* 21*/ "sref.s.pri", parm1 },
|
|
{ /* 22*/ "sref.s.alt", parm1 },
|
|
{ /* 23*/ "stor.i", parm0 },
|
|
{ /* 24*/ "strb.i", parm1 },
|
|
{ /* 25*/ "lidx", parm0 },
|
|
{ /* 26*/ "lidx.b", parm1 },
|
|
{ /* 27*/ "idxaddr", parm0 },
|
|
{ /* 28*/ "idxaddr.b", parm1 },
|
|
{ /* 29*/ "align.pri", parm1 },
|
|
{ /* 30*/ "align.alt", parm1 },
|
|
{ /* 31*/ "lctrl", parm1 },
|
|
{ /* 32*/ "sctrl", parm1 },
|
|
{ /* 33*/ "move.pri", parm0 },
|
|
{ /* 34*/ "move.alt", parm0 },
|
|
{ /* 35*/ "xchg", parm0 },
|
|
{ /* 36*/ "push.pri", parm0 },
|
|
{ /* 37*/ "push.alt", parm0 },
|
|
{ /* 38*/ "push.r", parm1 }, /* obsolete (never generated) */
|
|
{ /* 39*/ "push.c", parm1 },
|
|
{ /* 40*/ "push", parm1 },
|
|
{ /* 41*/ "push.s", parm1 },
|
|
{ /* 42*/ "pop.pri", parm0 },
|
|
{ /* 43*/ "pop.alt", parm0 },
|
|
{ /* 44*/ "stack", parm1 },
|
|
{ /* 45*/ "heap", parm1 },
|
|
{ /* 46*/ "proc", do_proc },
|
|
{ /* 47*/ "ret", parm0 },
|
|
{ /* 48*/ "retn", parm0 },
|
|
{ /* 49*/ "call", do_call },
|
|
{ /* 50*/ "call.pri", parm0 },
|
|
{ /* 51*/ "jump", do_jump },
|
|
{ /* 52*/ "jrel", parm1 }, /* same as jump, since version 10 */
|
|
{ /* 53*/ "jzer", do_jump },
|
|
{ /* 54*/ "jnz", do_jump },
|
|
{ /* 55*/ "jeq", do_jump },
|
|
{ /* 56*/ "jneq", do_jump },
|
|
{ /* 57*/ "jless", do_jump },
|
|
{ /* 58*/ "jleq", do_jump },
|
|
{ /* 59*/ "jgrtr", do_jump },
|
|
{ /* 60*/ "jgeq", do_jump },
|
|
{ /* 61*/ "jsless", do_jump },
|
|
{ /* 62*/ "jsleq", do_jump },
|
|
{ /* 63*/ "jsgrtr", do_jump },
|
|
{ /* 64*/ "jsgeq", do_jump },
|
|
{ /* 65*/ "shl", parm0 },
|
|
{ /* 66*/ "shr", parm0 },
|
|
{ /* 67*/ "sshr", parm0 },
|
|
{ /* 68*/ "shl.c.pri", parm1 },
|
|
{ /* 69*/ "shl.c.alt", parm1 },
|
|
{ /* 70*/ "shr.c.pri", parm1 },
|
|
{ /* 71*/ "shr.c.alt", parm1 },
|
|
{ /* 72*/ "smul", parm0 },
|
|
{ /* 73*/ "sdiv", parm0 },
|
|
{ /* 74*/ "sdiv.alt", parm0 },
|
|
{ /* 75*/ "umul", parm0 },
|
|
{ /* 76*/ "udiv", parm0 },
|
|
{ /* 77*/ "udiv.alt", parm0 },
|
|
{ /* 78*/ "add", parm0 },
|
|
{ /* 79*/ "sub", parm0 },
|
|
{ /* 80*/ "sub.alt", parm0 },
|
|
{ /* 81*/ "and", parm0 },
|
|
{ /* 82*/ "or", parm0 },
|
|
{ /* 83*/ "xor", parm0 },
|
|
{ /* 84*/ "not", parm0 },
|
|
{ /* 85*/ "neg", parm0 },
|
|
{ /* 86*/ "invert", parm0 },
|
|
{ /* 87*/ "add.c", parm1 },
|
|
{ /* 88*/ "smul.c", parm1 },
|
|
{ /* 89*/ "zero.pri", parm0 },
|
|
{ /* 90*/ "zero.alt", parm0 },
|
|
{ /* 91*/ "zero", parm1 },
|
|
{ /* 92*/ "zero.s", parm1 },
|
|
{ /* 93*/ "sign.pri", parm0 },
|
|
{ /* 94*/ "sign.alt", parm0 },
|
|
{ /* 95*/ "eq", parm0 },
|
|
{ /* 96*/ "neq", parm0 },
|
|
{ /* 97*/ "less", parm0 },
|
|
{ /* 98*/ "leq", parm0 },
|
|
{ /* 99*/ "grtr", parm0 },
|
|
{ /*100*/ "geq", parm0 },
|
|
{ /*101*/ "sless", parm0 },
|
|
{ /*102*/ "sleq", parm0 },
|
|
{ /*103*/ "sgrtr", parm0 },
|
|
{ /*104*/ "sgeq", parm0 },
|
|
{ /*105*/ "eq.c.pri", parm1 },
|
|
{ /*106*/ "eq.c.alt", parm1 },
|
|
{ /*107*/ "inc.pri", parm0 },
|
|
{ /*108*/ "inc.alt", parm0 },
|
|
{ /*109*/ "inc", parm1 },
|
|
{ /*110*/ "inc.s", parm1 },
|
|
{ /*111*/ "inc.i", parm0 },
|
|
{ /*112*/ "dec.pri", parm0 },
|
|
{ /*113*/ "dec.alt", parm0 },
|
|
{ /*114*/ "dec", parm1 },
|
|
{ /*115*/ "dec.s", parm1 },
|
|
{ /*116*/ "dec.i", parm0 },
|
|
{ /*117*/ "movs", parm1 },
|
|
{ /*118*/ "cmps", parm1 },
|
|
{ /*119*/ "fill", parm1 },
|
|
{ /*120*/ "halt", parm1 },
|
|
{ /*121*/ "bounds", parm1 },
|
|
{ /*122*/ "sysreq.pri", parm0 },
|
|
{ /*123*/ "sysreq.c", do_sysreq },
|
|
{ /*124*/ NULL, NULL }, /* file */
|
|
{ /*125*/ NULL, NULL }, /* line */
|
|
{ /*126*/ NULL, NULL }, /* symbol */
|
|
{ /*127*/ NULL, NULL }, /* srange, version 1 */
|
|
{ /*128*/ "jump.pri", parm0 }, /* version 1 */
|
|
{ /*129*/ "switch", do_jump }, /* version 1 */
|
|
{ /*130*/ "casetbl", do_casetbl }, /* version 1 */
|
|
{ /*131*/ "swap.pri", parm0 }, /* version 4 */
|
|
{ /*132*/ "swap.alt", parm0 }, /* version 4 */
|
|
{ /*133*/ "push.adr", parm1 }, /* version 4 */
|
|
{ /*134*/ "nop", parm0 }, /* version 6 */
|
|
{ /*135*/ "sysreq.n", parm2 }, /* version 9 (replaces SYSREQ.d from earlier version) */
|
|
{ /*136*/ NULL, NULL }, /* symtag, version 7 */
|
|
{ /*137*/ "break", parm0 }, /* version 8 */
|
|
{ /*138*/ "push2.c", parm2 }, /* version 9 */
|
|
{ /*139*/ "push2", parm2 }, /* version 9 */
|
|
{ /*140*/ "push2.s", parm2 }, /* version 9 */
|
|
{ /*141*/ "push2.adr", parm2 }, /* version 9 */
|
|
{ /*142*/ "push3.c", parm3 }, /* version 9 */
|
|
{ /*143*/ "push3", parm3 }, /* version 9 */
|
|
{ /*144*/ "push3.s", parm3 }, /* version 9 */
|
|
{ /*145*/ "push3.adr", parm3 }, /* version 9 */
|
|
{ /*146*/ "push4.c", parm4 }, /* version 9 */
|
|
{ /*147*/ "push4", parm4 }, /* version 9 */
|
|
{ /*148*/ "push4.s", parm4 }, /* version 9 */
|
|
{ /*149*/ "push4.adr", parm4 }, /* version 9 */
|
|
{ /*150*/ "push5.c", parm5 }, /* version 9 */
|
|
{ /*151*/ "push5", parm5 }, /* version 9 */
|
|
{ /*152*/ "push5.s", parm5 }, /* version 9 */
|
|
{ /*153*/ "push5.adr", parm5 }, /* version 9 */
|
|
{ /*154*/ "load.both", parm2 }, /* version 9 */
|
|
{ /*155*/ "load.s.both",parm2 }, /* version 9 */
|
|
{ /*156*/ "const", parm2 }, /* version 9 */
|
|
{ /*157*/ "const.s", parm2 }, /* version 9 */
|
|
};
|
|
|
|
void print_opcode(FILE *ftxt,cell opcode,cell cip)
|
|
{
|
|
fprintf(ftxt,"%08"PRIxC" %s",cip,opcodelist[opcode].name);
|
|
}
|
|
|
|
void print_funcname(FILE *ftxt,cell address)
|
|
{
|
|
int idx,numpublics;
|
|
AMX_FUNCSTUBNT func;
|
|
char name[sNAMEMAX+1];
|
|
size_t namelen=0;
|
|
const char *dbgname;
|
|
|
|
/* first look up the address in the debug info and, if failed, find it
|
|
* in the public function table */
|
|
if (dbgloaded && dbg_LookupFunction(&amxdbg,address,&dbgname)==AMX_ERR_NONE) {
|
|
strncpy(name,dbgname,sizeof name);
|
|
} else {
|
|
numpublics=(amxhdr.natives-amxhdr.publics)/sizeof(AMX_FUNCSTUBNT);
|
|
fseek(fpamx,amxhdr.publics,SEEK_SET);
|
|
for (idx=0; idx<numpublics; idx++) {
|
|
if (fread(&func,sizeof func,1,fpamx)==0)
|
|
break;
|
|
if (func.address==address) {
|
|
fseek(fpamx,func.nameofs,SEEK_SET);
|
|
namelen=fread(name,1,sizeof name,fpamx);
|
|
break;
|
|
} /* if */
|
|
} /* for */
|
|
} /* if */
|
|
if (namelen>0)
|
|
fprintf(ftxt,"\t; %s",name);
|
|
}
|
|
|
|
cell parm0(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt,"\n");
|
|
return 1;
|
|
}
|
|
|
|
cell parm1(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC"\n",*params);
|
|
return 2;
|
|
}
|
|
|
|
cell parm2(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC" %08"PRIxC"\n",params[0],params[1]);
|
|
return 3;
|
|
}
|
|
|
|
cell parm3(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC" %08"PRIxC" %08"PRIxC"\n",
|
|
params[0],params[1],params[2]);
|
|
return 4;
|
|
}
|
|
|
|
cell parm4(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC" %08"PRIxC" %08"PRIxC" %08"PRIxC"\n",
|
|
params[0],params[1],params[2],params[3]);
|
|
return 5;
|
|
}
|
|
|
|
cell parm5(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC" %08"PRIxC" %08"PRIxC" %08"PRIxC" %08"PRIxC"\n",
|
|
params[0],params[1],params[2],params[3],params[4]);
|
|
return 6;
|
|
}
|
|
|
|
cell do_proc(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
print_funcname(ftxt,cip);
|
|
fprintf(ftxt,"\n");
|
|
return 1;
|
|
}
|
|
|
|
cell do_call(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC,*params);
|
|
print_funcname(ftxt,*params);
|
|
fputs("\n",ftxt);
|
|
return 2;
|
|
}
|
|
|
|
cell do_jump(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC"\n",*params);
|
|
return 2;
|
|
}
|
|
|
|
cell do_sysreq(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
int idx,numnatives,nameoffset;
|
|
AMX_FUNCSTUBNT func;
|
|
char name[sNAMEMAX+1];
|
|
size_t namelen=0;
|
|
|
|
nameoffset=-1;
|
|
/* find the address in the native function table */
|
|
numnatives=(amxhdr.libraries-amxhdr.natives)/sizeof(AMX_FUNCSTUBNT);
|
|
fseek(fpamx,amxhdr.natives,SEEK_SET);
|
|
for (idx=0; idx<numnatives && nameoffset<0; idx++) {
|
|
if (fread(&func,sizeof func,1,fpamx)==0)
|
|
break;
|
|
if (idx==*params)
|
|
nameoffset=func.nameofs;
|
|
} /* for */
|
|
if (nameoffset>=0) {
|
|
fseek(fpamx,nameoffset,SEEK_SET);
|
|
namelen=fread(name,1,sNAMEMAX+1,fpamx);
|
|
} /* if */
|
|
|
|
print_opcode(ftxt,opcode,cip);
|
|
fprintf(ftxt," %08"PRIxC,*params);
|
|
if (namelen>0)
|
|
fprintf(ftxt,"\t; %s",name);
|
|
fprintf(ftxt,"\n");
|
|
return 2;
|
|
}
|
|
|
|
cell do_casetbl(FILE *ftxt,const cell *params,cell opcode,cell cip)
|
|
{
|
|
cell num;
|
|
int idx;
|
|
|
|
print_opcode(ftxt,opcode,cip);
|
|
num=params[0]+1;
|
|
fprintf(ftxt," %08"PRIxC" %08"PRIxC"\n",params[0],params[1]);
|
|
for (idx=1; idx<num; idx++)
|
|
fprintf(ftxt," %08"PRIxC" %08"PRIxC"\n",
|
|
params[2*idx],params[2*idx+1]);
|
|
return 2*num+1;
|
|
}
|
|
|
|
static void expand(unsigned char *code,long codesize,long memsize)
|
|
{
|
|
ucell c;
|
|
struct {
|
|
long memloc;
|
|
ucell c;
|
|
} spare[AMX_COMPACTMARGIN];
|
|
int sh=0,st=0,sc=0;
|
|
int shift;
|
|
|
|
/* for in-place expansion, move from the end backward */
|
|
assert(memsize % sizeof(cell) == 0);
|
|
while (codesize>0) {
|
|
c=0;
|
|
shift=0;
|
|
do {
|
|
codesize--;
|
|
/* no input byte should be shifted out completely */
|
|
assert(shift<8*sizeof(cell));
|
|
/* we work from the end of a sequence backwards; the final code in
|
|
* a sequence may not have the continuation bit set */
|
|
assert(shift>0 || (code[(size_t)codesize] & 0x80)==0);
|
|
c|=(ucell)(code[(size_t)codesize] & 0x7f) << shift;
|
|
shift+=7;
|
|
} while (codesize>0 && (code[(size_t)codesize-1] & 0x80)!=0);
|
|
/* sign expand */
|
|
if ((code[(size_t)codesize] & 0x40)!=0) {
|
|
while (shift < (int)(8*sizeof(cell))) {
|
|
c|=(ucell)0xff << shift;
|
|
shift+=8;
|
|
} /* while */
|
|
} /* if */
|
|
/* store */
|
|
while (sc && (spare[sh].memloc>codesize)) {
|
|
*(ucell *)(code+(int)spare[sh].memloc)=spare[sh].c;
|
|
sh=(sh+1)%AMX_COMPACTMARGIN;
|
|
sc--;
|
|
} /* while */
|
|
memsize -= sizeof(cell);
|
|
assert(memsize>=0);
|
|
if ((memsize>codesize)||((memsize==codesize)&&(memsize==0))) {
|
|
*(ucell *)(code+(size_t)memsize)=c;
|
|
} else {
|
|
assert(sc<AMX_COMPACTMARGIN);
|
|
spare[st].memloc=memsize;
|
|
spare[st].c=c;
|
|
st=(st+1)%AMX_COMPACTMARGIN;
|
|
sc++;
|
|
} /* if */
|
|
} /* while */
|
|
/* when all bytes have been expanded, the complete memory block should be done */
|
|
assert(memsize==0);
|
|
}
|
|
|
|
static void addchars(char *str,cell value,int pos)
|
|
{
|
|
int v,i;
|
|
|
|
str+=pos*sizeof(cell);
|
|
for (i=0; i<sizeof(cell); i++) {
|
|
v=(value >> 8*(sizeof(cell)-1)) & 0xff;
|
|
value <<= 8;
|
|
*str++= (v>=32) ? (char)v : ' ';
|
|
} /* for */
|
|
*str='\0';
|
|
}
|
|
|
|
int main(int argc,char *argv[])
|
|
{
|
|
char name[FILENAME_MAX];
|
|
FILE *fplist=NULL;
|
|
int codesize,count;
|
|
cell *code=NULL,*cip;
|
|
OPCODE_PROC func;
|
|
const char *filename;
|
|
long nline,nprevline;
|
|
FILE *fpsrc;
|
|
int i,j;
|
|
char line[sLINEMAX];
|
|
int retval=1;
|
|
|
|
fpamx=NULL;
|
|
if (argc<2 || argc>3) {
|
|
printf("Usage: pawndisasm <input> [output]\n");
|
|
goto ret;
|
|
} /* if */
|
|
if (argc==2) {
|
|
char *ptr;
|
|
strcpy(name,argv[1]);
|
|
if ((ptr=strrchr(name,'.'))!=NULL && strpbrk(ptr,"\\/:")==NULL)
|
|
*ptr='\0'; /* erase existing extension */
|
|
strcat(name,".lst"); /* append new extension */
|
|
} else {
|
|
strcpy(name,argv[2]);
|
|
} /* if */
|
|
if ((fpamx=fopen(argv[1],"rb"))==NULL) {
|
|
printf("Unable to open input file \"%s\"\n",argv[1]);
|
|
goto ret;
|
|
} /* if */
|
|
if ((fplist=fopen(name,"wt"))==NULL) {
|
|
printf("Unable to create output file \"%s\"\n",name);
|
|
goto ret;
|
|
} /* if */
|
|
|
|
/* load debug info */
|
|
dbgloaded=(dbg_LoadInfo(&amxdbg, fpamx)==AMX_ERR_NONE);
|
|
|
|
/* load header */
|
|
fseek(fpamx,0,SEEK_SET);
|
|
if (fread(&amxhdr,sizeof amxhdr,1,fpamx)==0) {
|
|
printf("Unable to read AMX header: %s\n",
|
|
feof(fpamx) ? "End of file reached" : strerror(errno));
|
|
goto ret;
|
|
} /* if */
|
|
if (amxhdr.magic!=AMX_MAGIC) {
|
|
printf("Not a valid AMX file\n");
|
|
goto ret;
|
|
} /* if */
|
|
codesize=amxhdr.hea-amxhdr.cod; /* size for both code and data */
|
|
fprintf(fplist,";File version: %d\n",amxhdr.file_version);
|
|
fprintf(fplist,";Flags: ");
|
|
if ((amxhdr.flags & AMX_FLAG_COMPACT)!=0)
|
|
fprintf(fplist," compact-encoding");
|
|
if ((amxhdr.flags & AMX_FLAG_DEBUG)!=0)
|
|
fprintf(fplist," debug-info");
|
|
if ((amxhdr.flags & AMX_FLAG_NOCHECKS)!=0)
|
|
fprintf(fplist," no-checks");
|
|
if ((amxhdr.flags & AMX_FLAG_SLEEP)!=0)
|
|
fprintf(fplist," sleep");
|
|
fprintf(fplist,"\n\n");
|
|
/* load the code block */
|
|
if ((code=malloc(codesize))==NULL) {
|
|
printf("Insufficient memory: need %d bytes\n",codesize);
|
|
goto ret;
|
|
} /* if */
|
|
|
|
/* read and expand the file */
|
|
fseek(fpamx,amxhdr.cod,SEEK_SET);
|
|
if ((int32_t)fread(code,1,codesize,fpamx)<amxhdr.size-amxhdr.cod) {
|
|
printf("Unable to read code: %s\n",
|
|
feof(fpamx) ? "End of file reached" : strerror(errno));
|
|
goto ret;
|
|
} /* if */
|
|
if ((amxhdr.flags & AMX_FLAG_COMPACT)!=0)
|
|
expand((unsigned char *)code,amxhdr.size-amxhdr.cod,amxhdr.hea-amxhdr.cod);
|
|
|
|
/* do a first run through the code to get jump targets (for labels) */
|
|
//???
|
|
|
|
/* browse through the code */
|
|
cip=code;
|
|
codesize=amxhdr.dat-amxhdr.cod;
|
|
nprevline=-1;
|
|
while (((unsigned char*)cip-(unsigned char*)code)<codesize) {
|
|
if (*cip==46) {
|
|
/* beginning of a new function */
|
|
fprintf(fplist,"\n");
|
|
} /* if */
|
|
if (dbgloaded) {
|
|
/* print the location of this instruction */
|
|
dbg_LookupFile(&amxdbg,(cell)(cip-code)*sizeof(cell),&filename);
|
|
dbg_LookupLine(&amxdbg,(cell)(cip-code)*sizeof(cell),&nline);
|
|
if (filename!=NULL && nline!=nprevline) {
|
|
fprintf(fplist,"%s:%ld\n",filename,nline+1);
|
|
/* print the source code for lines in (nprevline,line] */
|
|
fpsrc=fopen(filename,"r");
|
|
if (fpsrc!=NULL) {
|
|
for (i=0; i<=nline; i++) {
|
|
if (fgets(line,sizeof(line),fpsrc)==NULL)
|
|
break;
|
|
for (j=0; line[j]<=' ' && line[j]!='\0'; j++)
|
|
continue;
|
|
if (line[j]!='\0' && i>nprevline)
|
|
fputs(line,fplist);
|
|
} /* for */
|
|
fclose(fpsrc);
|
|
} /* if */
|
|
nprevline=nline;
|
|
} /* if */
|
|
} /* if */
|
|
if (*(ucell *)cip>=(ucell)(sizeof opcodelist/sizeof opcodelist[0])
|
|
|| (func=opcodelist[*cip].func)==NULL) {
|
|
printf("Invalid opcode %08"PRIxC" at address %08"PRIxC"\n",
|
|
*cip, (cell)((unsigned char *)cip-(unsigned char *)code));
|
|
goto ret;
|
|
} /* if */
|
|
cip+=func(fplist,cip+1,*cip,(cell)((unsigned char *)cip-(unsigned char *)code));
|
|
} /* while */
|
|
|
|
/* dump the data section too */
|
|
fprintf(fplist,"\n\n;DATA");
|
|
cip=(cell*)((unsigned char*)code+(amxhdr.dat-amxhdr.cod));
|
|
codesize=amxhdr.hea-amxhdr.cod;
|
|
count=0;
|
|
name[0]='\0';
|
|
while (((unsigned char*)cip-(unsigned char*)code)<codesize) {
|
|
if (count==0) {
|
|
if (strlen(name)>0) {
|
|
fprintf(fplist," %s",name);
|
|
name[0]='\0';
|
|
} /* if */
|
|
fprintf(fplist,"\n%08"PRIxC" ",(cell)((cip-code)*sizeof(cell)-(amxhdr.dat-amxhdr.cod)));
|
|
} /* if */
|
|
fprintf(fplist,"%08"PRIxC" ",*cip);
|
|
addchars(name,*cip,count);
|
|
count=(count+1) % 4;
|
|
cip++;
|
|
} /* while */
|
|
if (strlen(name)>0) {
|
|
fprintf(fplist," %s",name);
|
|
name[0]='\0';
|
|
} /* if */
|
|
|
|
if (dbgloaded) {
|
|
dbg_FreeInfo(&amxdbg);
|
|
} /* if */
|
|
|
|
retval=0;
|
|
ret:
|
|
free(code);
|
|
if (fpamx!=NULL)
|
|
fclose(fpamx);
|
|
if (fplist!=NULL)
|
|
fclose(fplist);
|
|
return retval;
|
|
}
|