1078 lines
24 KiB
Plaintext
1078 lines
24 KiB
Plaintext
InstructionEntry **disasm_table=NULL;
|
|
I8 disasm_table_entries=0;
|
|
|
|
I8 CompareInstructionEntries(InstructionEntry **tempi1,InstructionEntry **tempi2)
|
|
{
|
|
I8 i1,i2,j=0,result=0;
|
|
while (TRUE) {
|
|
if (j<(*tempi1)->opcode_cnt && j<(*tempi2)->opcode_cnt) {
|
|
i1=(*tempi1)->opcode[j];
|
|
i2=(*tempi2)->opcode[j];
|
|
result=i1-i2;
|
|
if (result) return result;
|
|
j++;
|
|
} else {
|
|
i1=(*tempi1)->opcode_cnt;
|
|
i2=(*tempi2)->opcode_cnt;
|
|
result=i1-i2;
|
|
if (result) return result;
|
|
|
|
i1=(*tempi1)->slash_value;
|
|
i2=(*tempi2)->slash_value;
|
|
if (i1==8) i1=-1;
|
|
if (i2==8) i2=-1;
|
|
result=i1-i2;
|
|
if (result) return result;
|
|
|
|
i1=(*tempi1)->operand_size32;
|
|
i2=(*tempi2)->operand_size32;
|
|
result=i1-i2;
|
|
if (result) return result;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LoadDisasmTable()
|
|
{
|
|
SysHashTable *h=asm_hash;
|
|
OpcodeHashEntry *temph;
|
|
InstructionEntry *tempi;
|
|
U8 cnt=0;
|
|
I8 i,j,k;
|
|
|
|
for (i=0;i<=h->mask;i++) {
|
|
temph=h->body[i];
|
|
while (temph) {
|
|
if (temph->type==HTT_OPCODE)
|
|
cnt+=temph->instruction_entry_cnt;
|
|
temph=temph->next;
|
|
}
|
|
}
|
|
disasm_table_entries=cnt;
|
|
|
|
j=0;
|
|
disasm_table=MAlloc(cnt*PTR_SIZE);
|
|
for (i=0;i<=h->mask;i++) {
|
|
temph=h->body[i];
|
|
while (temph) {
|
|
if (temph->type==HTT_OPCODE) {
|
|
tempi=&temph->ins;
|
|
for (k=0;k<temph->instruction_entry_cnt;k++) {
|
|
disasm_table[j++]=tempi;
|
|
tempi+=sizeof(InstructionEntry);
|
|
}
|
|
}
|
|
temph=temph->next;
|
|
}
|
|
}
|
|
|
|
QSort(disasm_table,cnt,PTR_SIZE,&CompareInstructionEntries);
|
|
}
|
|
|
|
if (!disasm_table)
|
|
LoadDisasmTable;
|
|
|
|
|
|
BoolU4 PutSourceLine(U4 *add,U8 cnt)
|
|
{
|
|
ClassStruct *tempc;
|
|
U8 i,minl,maxl,offset;
|
|
DbgInfo *dbg;
|
|
U4 *body;
|
|
I1 *src,*src2;
|
|
tempc=FindPSect(add,&offset);
|
|
if (tempc) {
|
|
dbg=tempc->debug;
|
|
if (dbg) {
|
|
body=dbg->body;
|
|
minl=dbg->min_line;
|
|
maxl=dbg->max_line;
|
|
for (i=minl;i<=maxl;i++) {
|
|
if ((body[i-minl]>=add) &&
|
|
(body[i-minl]<add+cnt)) {
|
|
src=NewString(tempc->source_link);
|
|
src2=MAlloc(StrLen(src)+1);
|
|
RemoveFirstSeg(src,":",src2);
|
|
RemoveLastSeg(src,",",src2);
|
|
PrintF("$$LK -A \"FL:%s,%d\"$$",src,i);
|
|
Free(src);
|
|
Free(src2);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
public void DasmIns(I1 *buf,U1 **add,BoolU4 use16=FALSE)
|
|
{
|
|
U1 *ip=*add,*bb;
|
|
U2 *ww;
|
|
U4 *dd;
|
|
I4 disp,imm;
|
|
BoolU4 opsize16=use16,opadd16=use16,cont;
|
|
I4 i,j,k,l,m,o1,o2,a1,a2,aa1,aa2,arg1_size=0,arg2_size=0,a1_size,a2_size,
|
|
ModrM=-1,SIB=-1,scale,r1,r2,
|
|
Mod=-1,RM1=-1,RM2=-1;
|
|
InstructionEntry *tempi;
|
|
OpcodeHashEntry *tempo,dummy;
|
|
I1 *a1_st,*a2_st,*bin_data_area,*bin_data_area2,
|
|
buf2[256],buf3[256],seg_overrides[40],arg1_st[256],arg2_st[256];
|
|
|
|
*arg1_st=0;
|
|
*arg2_st=0;
|
|
a1_st=arg1_st;
|
|
a2_st=arg2_st;
|
|
|
|
if (PutSourceLine(ip,1))
|
|
CrLf;
|
|
SPrintF(buf,"%16tP ",ip);
|
|
bin_data_area=buf+StrLen(buf);
|
|
for (i=0;i<6;i++) {
|
|
SPrintF(buf2,"%02X",ip[i]);
|
|
StrCat(buf,buf2);
|
|
}
|
|
StrCat(buf," ");
|
|
|
|
SPrintF(buf3,"%16tP ",ip+6);
|
|
bin_data_area2=buf3+StrLen(buf3);
|
|
for (i=6;i<12;i++) {
|
|
SPrintF(buf2,"%02X",ip[i]);
|
|
StrCat(buf3,buf2);
|
|
}
|
|
|
|
*seg_overrides=0;
|
|
cont=TRUE;
|
|
do {
|
|
switch (*ip++) {
|
|
case 0x2E: StrCat(seg_overrides,"CS:"); break;
|
|
case 0x36: StrCat(seg_overrides,"SS:"); break;
|
|
case 0x3E: StrCat(seg_overrides,"DS:"); break;
|
|
case 0x26: StrCat(seg_overrides,"ES:"); break;
|
|
case 0x64: StrCat(seg_overrides,"FS:"); break;
|
|
case 0x65: StrCat(seg_overrides,"GS:"); break;
|
|
case 0x66: opsize16=!opsize16; break;
|
|
case 0x67: opadd16=!opadd16; break;
|
|
default: cont=FALSE;
|
|
}
|
|
} while (cont);
|
|
ip--;
|
|
|
|
i=0;
|
|
j=disasm_table_entries-1;
|
|
do {
|
|
k=(i+j)>>1; //binary search
|
|
tempi=disasm_table[k];
|
|
m=0;
|
|
l=0;
|
|
while (TRUE) {
|
|
if (l<tempi->opcode_cnt) {
|
|
o1=ip[l];
|
|
if (l==tempi->opcode_cnt-1 &&
|
|
tempi->plus_opcode)
|
|
o1&=-8;
|
|
o2=tempi->opcode[l];
|
|
m=o1-o2;
|
|
l++;
|
|
if (m)
|
|
break;
|
|
} else {
|
|
if (tempi->slash_value<8) {
|
|
o1=(ip[l] >> 3) & 7;
|
|
o2=tempi->slash_value;
|
|
m=o1-o2;
|
|
if (!m) {
|
|
if (opsize16) {
|
|
if (tempi->operand_size32)
|
|
m=-1;
|
|
} else {
|
|
if (tempi->operand_size16)
|
|
m=1;
|
|
}
|
|
}
|
|
break;
|
|
} else {
|
|
m=0;
|
|
if (opsize16) {
|
|
if (tempi->operand_size32)
|
|
m=-1;
|
|
} else {
|
|
if (tempi->operand_size16)
|
|
m=1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m>0) {
|
|
if (k==i) {
|
|
k=j;
|
|
break;
|
|
} else
|
|
i=k;
|
|
} else if (m<0) {
|
|
if (k-i<=1) {
|
|
k=i;
|
|
break;
|
|
} else
|
|
j=k;
|
|
} else
|
|
break;
|
|
} while (TRUE);
|
|
|
|
tempi=disasm_table[k];
|
|
ip+=tempi->opcode_cnt;
|
|
tempo=tempi-(tempi->ins_entry_num*sizeof(InstructionEntry))+&dummy-&dummy.ins;
|
|
StrCat(buf,tempo->string);
|
|
|
|
a1=tempi->arg1;
|
|
a2=tempi->arg2;
|
|
aa1=a1;
|
|
aa2=a2;
|
|
|
|
StrCpy(buf2,SysTextSub(a1,"ST_ARGUMENT_TYPES"));
|
|
if (StrStr(buf2,"8"))
|
|
arg1_size=1;
|
|
else if (StrStr(buf2,"16"))
|
|
arg1_size=2;
|
|
else if (StrStr(buf2,"32"))
|
|
arg1_size=4;
|
|
|
|
StrCpy(buf2,SysTextSub(a2,"ST_ARGUMENT_TYPES"));
|
|
if (StrStr(buf2,"8"))
|
|
arg2_size=1;
|
|
else if (StrStr(buf2,"16"))
|
|
arg2_size=2;
|
|
else if (StrStr(buf2,"32"))
|
|
arg2_size=4;
|
|
|
|
a1_size=arg1_size;
|
|
a2_size=arg2_size;
|
|
if (tempi->plus_opcode && (tempi->slash_value==8 ||
|
|
tempi->opcode_modifier>=OM_RB && tempi->opcode_modifier<=OM_RD)) {
|
|
ip--;
|
|
RM1=*(ip++) - tempi->opcode[tempi->opcode_cnt-1];
|
|
*buf2=0;
|
|
if (a1>=ARGT_R8 && a1<=ARGT_R32) {
|
|
if (a1_size==1)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U1_REGS");
|
|
else if (a1_size==2)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U2_REGS");
|
|
else if (a1_size==4)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U4_REGS");
|
|
StrCat(a1_st,buf2);
|
|
} else {
|
|
if (a2_size==1)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U1_REGS");
|
|
else if (a2_size==2)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U2_REGS");
|
|
else if (a2_size==4)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U4_REGS");
|
|
StrCat(a2_st,buf2);
|
|
}
|
|
}
|
|
if ((a1>=ARGT_RM8 && a1<=ARGT_RM32) ||
|
|
(a2>=ARGT_RM8 && a2<=ARGT_RM32)) {
|
|
if (a2>=ARGT_RM8 && a2<=ARGT_RM32) {
|
|
a1_st=arg2_st;
|
|
a2_st=arg1_st;
|
|
a1_size=arg2_size;
|
|
a2_size=arg1_size;
|
|
aa1=a2;
|
|
aa2=a1;
|
|
}
|
|
StrCat(a1_st,seg_overrides);
|
|
ModrM=*(ip++);
|
|
Mod=(ModrM>>6) & 3;
|
|
RM1=ModrM & 7;
|
|
RM2=(ModrM>>3) & 7;
|
|
if (Mod<3 && RM1==4) {
|
|
SIB=*(ip++);
|
|
}
|
|
if (Mod==1) {
|
|
bb=ip;
|
|
disp=*bb;
|
|
SPrintF(buf2,"%02X",disp);
|
|
StrCat(a1_st,buf2);
|
|
ip++;
|
|
}
|
|
if (Mod==2) {
|
|
dd=ip;
|
|
disp=*dd;
|
|
SPrintF(buf2,"%08X",disp);
|
|
StrCat(a1_st,buf2);
|
|
ip=ip+4;
|
|
}
|
|
if (tempi->slash_value<8)
|
|
RM2=-1;
|
|
else {
|
|
*buf2=0;
|
|
if (aa2==ARGT_SREG)
|
|
SPrintF(buf2,"%Z",RM2,"ST_SEG_REGS");
|
|
else if (!(aa2>=ARGT_IMM8 && aa2<=ARGT_IMM32) &&
|
|
!(aa2>=ARGT_UIMM8 && aa2<=ARGT_UIMM32)) {
|
|
if (a2_size==1)
|
|
SPrintF(buf2,"%Z",RM2,"ST_U1_REGS");
|
|
else if (a2_size==2)
|
|
SPrintF(buf2,"%Z",RM2,"ST_U2_REGS");
|
|
else if (a2_size==4)
|
|
SPrintF(buf2,"%Z",RM2,"ST_U4_REGS");
|
|
}
|
|
StrCat(a2_st,buf2);
|
|
}
|
|
if (RM1==5 && Mod==0) {
|
|
dd=ip;
|
|
disp=*dd;
|
|
SPrintF(buf2,"[%X] ",disp);
|
|
StrCat(a1_st,buf2);
|
|
ip=ip+4;
|
|
RM1=-1;
|
|
} else {
|
|
if (Mod<3) {
|
|
if (RM1==4) {
|
|
RM1=-1;
|
|
r1=SIB & 7;
|
|
r2=(SIB >> 3) & 7;
|
|
scale=(SIB >> 6) &3;
|
|
if (scale==3)
|
|
scale=8;
|
|
else if (scale==2)
|
|
scale=4;
|
|
else if (scale==1)
|
|
scale=2;
|
|
else
|
|
scale=1;
|
|
if (r1==5 && Mod==0) {
|
|
dd=ip;
|
|
disp=*dd;
|
|
SPrintF(buf2,"%08X",disp);
|
|
StrCat(a1_st,buf2);
|
|
ip=ip+4;
|
|
SPrintF(buf2,"[%Z*%d]",r2,"ST_U4_REGS",scale);
|
|
StrCat(a1_st,buf2);
|
|
} else {
|
|
SPrintF(buf2,"[%Z+%Z*%d]",r1,"ST_U4_REGS",
|
|
r2,"ST_U4_REGS",scale);
|
|
StrCat(a1_st,buf2);
|
|
}
|
|
} else {
|
|
*buf2=0;
|
|
if (opadd16)
|
|
SPrintF(buf2,"[%Z]",RM1,"ST_U2_REGS");
|
|
else
|
|
SPrintF(buf2,"[%Z]",RM1,"ST_U4_REGS");
|
|
StrCat(a1_st,buf2);
|
|
}
|
|
} else {
|
|
*buf2=0;
|
|
if (a1_size==1)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U1_REGS");
|
|
else if (a1_size==2)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U2_REGS");
|
|
else if (a1_size==4)
|
|
SPrintF(buf2,"%Z",RM1,"ST_U4_REGS");
|
|
StrCat(a1_st,buf2);
|
|
}
|
|
}
|
|
}
|
|
if (a1>=ARGT_MOFFS8 && a1<=ARGT_MOFFS32) {
|
|
StrCat(arg1_st,seg_overrides);
|
|
if (arg1_size==1) {
|
|
bb=ip;
|
|
disp=*bb;
|
|
ip++;
|
|
SPrintF(buf2,"[%X]",disp);
|
|
StrCat(arg1_st,buf2);
|
|
} else if (opadd16) {
|
|
ww=ip;
|
|
disp=*ww;
|
|
ip=ip+2;
|
|
SPrintF(buf2,"[%X]",disp);
|
|
StrCat(arg1_st,buf2);
|
|
} else {
|
|
dd=ip;
|
|
disp=*dd;
|
|
ip=ip+4;
|
|
SPrintF(buf2,"[%X]",disp);
|
|
StrCat(arg1_st,buf2);
|
|
}
|
|
}
|
|
|
|
if (a2>=ARGT_MOFFS8 && a2<=ARGT_MOFFS32) {
|
|
StrCat(arg2_st,seg_overrides);
|
|
if (arg2_size==1) {
|
|
bb=ip;
|
|
disp=*bb;
|
|
ip++;
|
|
SPrintF(buf2,"[%X]",disp);
|
|
StrCat(arg2_st,buf2);
|
|
} else if (opadd16) {
|
|
ww=ip;
|
|
disp=*ww;
|
|
ip=ip+2;
|
|
SPrintF(buf2,"[%X]",disp);
|
|
StrCat(arg2_st,buf2);
|
|
} else {
|
|
dd=ip;
|
|
disp=*dd;
|
|
ip=ip+4;
|
|
SPrintF(buf2,"[%X]",disp);
|
|
StrCat(arg2_st,buf2);
|
|
}
|
|
}
|
|
|
|
if (a1==ARGT_IMM8 || a1==ARGT_UIMM8) {
|
|
bb=ip;
|
|
imm=*bb;
|
|
SPrintF(buf2,"%02X",imm);
|
|
StrCat(arg1_st,buf2);
|
|
ip++;
|
|
} else if (a1==ARGT_IMM16 || a1==ARGT_UIMM16) {
|
|
ww=ip;
|
|
imm=*ww;
|
|
SPrintF(buf2,"%04X",imm);
|
|
StrCat(arg1_st,buf2);
|
|
ip=ip+2;
|
|
} else if (a1==ARGT_IMM32 || a1==ARGT_UIMM32) {
|
|
dd=ip;
|
|
imm=*dd;
|
|
SPrintF(buf2,"%08X",imm);
|
|
StrCat(arg1_st,buf2);
|
|
ip=ip+4;
|
|
} else if (a1==ARGT_REL8) {
|
|
bb=ip;
|
|
disp=*bb;
|
|
if (disp>=0x80)
|
|
disp=disp | 0xFFFFFF00;
|
|
ip++;
|
|
disp=disp+ip;
|
|
SPrintF(buf2,"%P ",disp);
|
|
StrCat(arg1_st,buf2);
|
|
} else if (a1==ARGT_REL16) {
|
|
ww=ip;
|
|
disp=*ww;
|
|
if (disp>=0x8000)
|
|
disp=disp | 0xFFFF0000;
|
|
ip=ip+2;
|
|
disp=disp+ip;
|
|
SPrintF(buf2,"%P ",disp);
|
|
StrCat(arg1_st,buf2);
|
|
} else if (a1==ARGT_REL32) {
|
|
dd=ip;
|
|
disp=*dd;
|
|
ip=ip+4;
|
|
disp=disp+ip;
|
|
SPrintF(buf2,"%P ",disp);
|
|
StrCat(arg1_st,buf2);
|
|
} else if (a1==ARGT_CL)
|
|
StrCat(arg1_st,"CL");
|
|
else if (a1==ARGT_AL)
|
|
StrCat(arg1_st,"AL");
|
|
else if (a1==ARGT_AX)
|
|
StrCat(arg1_st,"AX");
|
|
else if (a1==ARGT_EAX)
|
|
StrCat(arg1_st,"EAX");
|
|
else if (a1==ARGT_DX)
|
|
StrCat(arg1_st,"DX");
|
|
else if (a1==ARGT_SS)
|
|
StrCat(arg1_st,"SS");
|
|
else if (a1==ARGT_DS)
|
|
StrCat(arg1_st,"DS");
|
|
else if (a1==ARGT_ES)
|
|
StrCat(arg1_st,"ES");
|
|
else if (a1==ARGT_FS)
|
|
StrCat(arg1_st,"FS");
|
|
else if (a1==ARGT_GS)
|
|
StrCat(arg1_st,"GS");
|
|
else if (a1==ARGT_CS)
|
|
StrCat(arg1_st,"CS");
|
|
|
|
if (a2==ARGT_IMM8 || a2==ARGT_UIMM8) {
|
|
bb=ip;
|
|
imm=*bb;
|
|
SPrintF(buf2,"%02X",imm);
|
|
StrCat(arg2_st,buf2);
|
|
ip++;
|
|
} else if (a2==ARGT_IMM16 || a2==ARGT_UIMM16) {
|
|
ww=ip;
|
|
imm=*ww;
|
|
SPrintF(buf2,"%04X",imm);
|
|
StrCat(arg2_st,buf2);
|
|
ip=ip+2;
|
|
} else if (a2==ARGT_IMM32 || a2==ARGT_UIMM32) {
|
|
dd=ip;
|
|
imm=*dd;
|
|
SPrintF(buf2,"%08X",imm);
|
|
StrCat(arg2_st,buf2);
|
|
ip=ip+4;
|
|
} else if (a2==ARGT_CL)
|
|
StrCat(arg2_st,"CL");
|
|
else if (a2==ARGT_AL)
|
|
StrCat(arg2_st,"AL");
|
|
else if (a2==ARGT_AX)
|
|
StrCat(arg2_st,"AX");
|
|
else if (a2==ARGT_EAX)
|
|
StrCat(arg2_st,"EAX");
|
|
else if (a2==ARGT_DX)
|
|
StrCat(arg2_st,"DX");
|
|
else if (a2==ARGT_SS)
|
|
StrCat(arg2_st,"SS");
|
|
else if (a2==ARGT_DS)
|
|
StrCat(arg2_st,"DS");
|
|
else if (a2==ARGT_ES)
|
|
StrCat(arg2_st,"ES");
|
|
else if (a2==ARGT_FS)
|
|
StrCat(arg2_st,"FS");
|
|
else if (a2==ARGT_GS)
|
|
StrCat(arg2_st,"GS");
|
|
else if (a2==ARGT_CS)
|
|
StrCat(arg2_st,"CS");
|
|
|
|
if (*arg1_st) {
|
|
StrCat(buf,"\t");
|
|
StrCat(buf,arg1_st);
|
|
}
|
|
if (*arg2_st) {
|
|
StrCat(buf,",");
|
|
StrCat(buf,arg2_st);
|
|
}
|
|
for (i=ip-*add;i<6;i++) {
|
|
bin_data_area[i<<1]=CH_SPACE;
|
|
bin_data_area[i<<1+1]=CH_SPACE;
|
|
}
|
|
for (i=ip-*add;i<12;i++) {
|
|
bin_data_area2[(i-6)<<1]=CH_SPACE;
|
|
bin_data_area2[(i-6)<<1+1]=CH_SPACE;
|
|
}
|
|
StrCat(buf,"\r\n");
|
|
if (ip-*add>6) {
|
|
StrCat(buf,buf3);
|
|
StrCat(buf,"\r\n");
|
|
}
|
|
*add=ip;
|
|
}
|
|
|
|
|
|
public U1 *Dasm(U1 *ip,U8 cnt=20,BoolU4 use16=FALSE)
|
|
{ //This counts instructions
|
|
I8 i;
|
|
I1 buf[512];
|
|
for (i=0;i<cnt;i++) {
|
|
DasmIns(buf,&ip,use16);
|
|
cout buf;
|
|
}
|
|
return ip;
|
|
}
|
|
|
|
public I8 Dasm2(U1 *ip,U8 cnt=0x80,BoolU4 use16=FALSE)
|
|
{ //This does an address range, not instruction count
|
|
I8 i=0;
|
|
U1 *end_ip=ip+cnt;
|
|
I1 buf[512];
|
|
while (ip<end_ip) {
|
|
DasmIns(buf,&ip,use16);
|
|
cout buf;
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
#define PF_ARRAY_CNT 8192
|
|
U8 pf_jiffies=0;
|
|
U8 pf_low=0,pf_high=SYS_CS_SIZE,pf_size=PF_ARRAY_CNT;
|
|
U4 pf_array[PF_ARRAY_CNT];
|
|
U4 chained_timer_routine=ext[EXT_IRQ00];
|
|
BoolU4 prof_on=FALSE;
|
|
|
|
void ProfileTimerIrq(U8 ip)
|
|
{
|
|
void my_Chained();
|
|
U8 i;
|
|
if (prof_on) {
|
|
i=(ip-pf_low) * pf_size/(pf_high-pf_low);
|
|
if (i>=0 && i<pf_size)
|
|
pf_array[i]++;
|
|
}
|
|
my_Chained=chained_timer_routine;
|
|
my_Chained();
|
|
}
|
|
ext[EXT_IRQ00]=&ProfileTimerIrq;
|
|
|
|
public void Prof(U1 *start,U8 cnt=PF_ARRAY_CNT*3)
|
|
{
|
|
if (cnt<PF_ARRAY_CNT)
|
|
pf_size=cnt;
|
|
else
|
|
pf_size=PF_ARRAY_CNT;
|
|
pf_low=start;
|
|
pf_high=start+cnt;
|
|
MemSet(pf_array,0,PF_ARRAY_CNT<<2);
|
|
pf_jiffies=jiffies;
|
|
prof_on=TRUE;
|
|
}
|
|
|
|
public void ProfRep(U8 filter_cnt=1)
|
|
{
|
|
I8 i,ip,last_ip=pf_low,hits;
|
|
U8 total_time=jiffies-pf_jiffies,
|
|
routine_total=0;
|
|
I1 buf[128],buf2[128],buf3[128],last_buf[128];
|
|
prof_on=FALSE;
|
|
if (!total_time) total_time=1;
|
|
*last_buf=0;
|
|
for (i=0;i<pf_size;i++) {
|
|
ip=pf_low+i*(pf_high-pf_low)/pf_size;
|
|
SPrintF(buf,"%P",ip);
|
|
StrCpy(buf3,buf);
|
|
RemoveFirstSeg(buf3,",",buf2);
|
|
if (StrCmp(buf2,last_buf)) {
|
|
if (*last_buf && routine_total>=filter_cnt) {
|
|
PrintF("$$FG GREEN$$%3d.%02d%% %08X:",routine_total*100/total_time,
|
|
routine_total*10000/total_time%100,routine_total);
|
|
PrintF("%s\r\n$$FG$$",last_buf);
|
|
}
|
|
StrCpy(last_buf,buf2);
|
|
routine_total=0;
|
|
}
|
|
hits=pf_array[i];
|
|
routine_total+=hits;
|
|
if (hits>=filter_cnt) {
|
|
PrintF("%3d.%02d%% %08X:",hits*100/total_time,
|
|
hits*10000/total_time%100,hits);
|
|
if (!PutSourceLine(ip,ip-last_ip+1))
|
|
PrintF("%s\r\n",buf);
|
|
else
|
|
CrLf;
|
|
last_ip=ip;
|
|
}
|
|
}
|
|
if (*last_buf && routine_total>=filter_cnt) {
|
|
PrintF("$$FG GREEN$$%3d.%02d%% %08X:",routine_total*100/total_time,
|
|
routine_total*10000/total_time%100,routine_total);
|
|
PrintF("%s\r\n$$FG$$",last_buf);
|
|
}
|
|
prof_on=TRUE;
|
|
}
|
|
|
|
public void FunRep(I1 *st)
|
|
{
|
|
ClassStruct *tempc=FindLocalHash(st,HTT_FUNCTION);
|
|
MemberListStruct *tempm;
|
|
if (tempc) {
|
|
tempm=tempc->member_list;
|
|
while (tempm) {
|
|
PrintF("%08X %s\r\n",tempm->offset,tempm->string);
|
|
tempm=tempm->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
public BoolU4 CheckPtr(U1 *ptr)
|
|
{
|
|
if (ptr>=sys_heap_base && ptr<=sys_heap_limit)
|
|
return TRUE;
|
|
else if (ptr<sys_boot_base)
|
|
return FALSE;
|
|
else if (ptr<SYS_CS_SIZE)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void ClassRep2(Ltf *l,U1 *d,I1 *class_name,I8 depth,U8 types=HTT_CLASS)
|
|
{
|
|
U8 i,j;
|
|
MemberListStruct *ml;
|
|
I1 ch,*s,*s2;
|
|
U4 *ptr;
|
|
U8 *ptr2;
|
|
ClassStruct *cl2,*cl=FindLocalHash(class_name,types);
|
|
if (!cl) {
|
|
LtfPutS(l,"Class Not Found.\r\n");
|
|
return;
|
|
}
|
|
if (!CheckPtr(d) || !CheckPtr(d+cl->size)) {
|
|
LtfPrintF(l,"Bad Ptr:%08X\r\n",d);
|
|
return;
|
|
}
|
|
LtfPrintF(l,"Class:\"%s\"\r\n",class_name);
|
|
ml=cl->member_list;
|
|
while (ml) {
|
|
cl2=ml->member_class;
|
|
ptr=d+ml->offset;
|
|
LtfPrintF(l,"%08X ",ptr);
|
|
j=cl2->pointer_cnt;
|
|
cl2-=cl2->pointer_cnt*sizeof(ClassStruct);
|
|
while (cl2->return_class) {
|
|
cl2=cl2->return_class;
|
|
cl2-=cl2->pointer_cnt*sizeof(ClassStruct);
|
|
}
|
|
if (cl2->type & HTT_INTERNAL_TYPE) {
|
|
LtfPrintF(l,"$$FG GREEN$$%-20ts:$$FG$$",ml->string);
|
|
if (!j && ml->cnt==0) {
|
|
switch (cl2->sub_type) {
|
|
case IT_I1:
|
|
LtfPrintF(l,"%02X '%c'",ptr->u1[0],ptr->u1[0]);
|
|
break;
|
|
case IT_U1:
|
|
LtfPrintF(l,"%02X",ptr->u1[0]);
|
|
break;
|
|
case IT_I2:
|
|
LtfPrintF(l,"%04X",ptr->u2[0]);
|
|
break;
|
|
case IT_U2:
|
|
LtfPrintF(l,"%04X",ptr->u2[0]);
|
|
break;
|
|
case IT_I4:
|
|
LtfPrintF(l,"%08X",*ptr);
|
|
break;
|
|
case IT_U4:
|
|
LtfPrintF(l,"%08X",*ptr);
|
|
break;
|
|
case IT_I8:
|
|
ptr2=ptr;
|
|
LtfPrintF(l,"%016X",*ptr2);
|
|
break;
|
|
case IT_U8:
|
|
ptr2=ptr;
|
|
LtfPrintF(l,"%016X",*ptr2);
|
|
break;
|
|
case IT_DOUBLE:
|
|
ptr2=ptr;
|
|
LtfPrintF(l,"%16g",*ptr2);
|
|
break;
|
|
default:
|
|
LtfPrintF(l,"%08X",*ptr);
|
|
break;
|
|
}
|
|
} else if ((j==1 || ml->cnt) &&
|
|
cl2->sub_type==IT_I1) {
|
|
if (j==1) {
|
|
if (CheckPtr(*ptr)) {
|
|
s2=MStringUtil(*ptr,SU_SAFE_DOLLAR);
|
|
LtfPrintF(l,"\"%40ts\"",s2);
|
|
Free(s2);
|
|
}
|
|
} else {
|
|
if (ml->cnt<40)
|
|
s=ptr+ml->cnt;
|
|
else
|
|
s=ptr+40;
|
|
ch=*s;
|
|
*s=0;
|
|
s2=MStringUtil(ptr,SU_SAFE_DOLLAR);
|
|
LtfPrintF(l,"\"%s\"",s2);
|
|
Free(s2);
|
|
*s=ch;
|
|
}
|
|
} else if (ml->cnt>0 && ml->cnt<=32 && !j) {
|
|
for (i=0;i<ml->cnt;i++) {
|
|
switch (cl2->sub_type) {
|
|
case IT_I1:
|
|
LtfPrintF(l,"%02X '%c' ",ptr->u1[0],ptr->u1[0]);
|
|
ptr+=1;
|
|
break;
|
|
case IT_U1:
|
|
LtfPrintF(l,"%02X ",ptr->u1[0]);
|
|
ptr+=1;
|
|
break;
|
|
case IT_I2:
|
|
LtfPrintF(l,"%04X ",ptr->u2[0]);
|
|
ptr+=2;
|
|
break;
|
|
case IT_U2:
|
|
LtfPrintF(l,"%04X ",ptr->u2[0]);
|
|
ptr+=2;
|
|
break;
|
|
case IT_I4:
|
|
LtfPrintF(l,"%08X ",*ptr);
|
|
ptr+=4;
|
|
break;
|
|
case IT_U4:
|
|
LtfPrintF(l,"%08X ",*ptr);
|
|
ptr+=4;
|
|
break;
|
|
case IT_I8:
|
|
ptr2=ptr;
|
|
LtfPrintF(l,"%016X ",*ptr2);
|
|
ptr+=8;
|
|
break;
|
|
case IT_U8:
|
|
ptr2=ptr;
|
|
LtfPrintF(l,"%016X ",*ptr2);
|
|
ptr+=8;
|
|
break;
|
|
case IT_DOUBLE:
|
|
ptr2=ptr;
|
|
LtfPrintF(l,"%16g ",*ptr2);
|
|
ptr+=8;
|
|
break;
|
|
default:
|
|
LtfPrintF(l,"%08X ",*ptr);
|
|
ptr+=4;
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
LtfPrintF(l,"%08X",*ptr);
|
|
LtfPutS(l,"\r\n");
|
|
} else {
|
|
if (depth<2) {
|
|
if (j==1 && !CheckPtr(*ptr))
|
|
LtfPrintF(l,"%-20ts:%08X\r\n",ml->string,*ptr);
|
|
else {
|
|
LtfPrintF(l,"$$TR,\"%s\"$$\r\n",ml->string);
|
|
LtfPutS(l,"$$ID,2$$");
|
|
if (!j)
|
|
ClassRep2(l,ptr,cl2->string,depth+1);
|
|
else if (j==1)
|
|
ClassRep2(l,*ptr,cl2->string,depth+1);
|
|
LtfPutS(l,"$$ID,-2$$");
|
|
}
|
|
} else
|
|
LtfPrintF(l,"%-20ts\r\n",ml->string);
|
|
}
|
|
ml=ml->next;
|
|
}
|
|
}
|
|
|
|
public void ClassRep(U1 *d,I1 *class_name)
|
|
{
|
|
BoolU4 old_preempt=Preempt(OFF);
|
|
LtfSetMax(MAX_I4);
|
|
ClassRep2(Fs->cur_ltf,d,class_name,0);
|
|
LtfPutS(Fs->cur_ltf,"\r\n");
|
|
LtfRecalc(Fs->cur_ltf);
|
|
Preempt(old_preempt);
|
|
}
|
|
|
|
public void MachineRegsRep()
|
|
{
|
|
ClassStruct *cl,*cn;
|
|
MemberListStruct *ml;
|
|
MachineRegsStruct m;
|
|
I4 *i_ptr;
|
|
|
|
GetMachineRegs(&m);
|
|
cl=FindLocalHash("MachineRegsStruct",HTT_CLASS);
|
|
ml=cl->member_list;
|
|
while (ml) {
|
|
if (ml->fmtstr) {
|
|
i_ptr=&m+ml->offset;
|
|
cn=ml->member_class;
|
|
if (cn->type==HTT_INTERNAL_TYPE && ml->cnt==0) {
|
|
if (ml->fmtdata)
|
|
PrintF(ml->fmtstr,*i_ptr,ml->fmtdata);
|
|
else
|
|
PrintF(ml->fmtstr,*i_ptr);
|
|
PrintF(" %P",*i_ptr);
|
|
} else {
|
|
if (ml->fmtdata)
|
|
PrintF(ml->fmtstr,i_ptr,ml->fmtdata);
|
|
else
|
|
PrintF(ml->fmtstr,i_ptr);
|
|
PrintF(" %P",*i_ptr);
|
|
}
|
|
CrLf;
|
|
}
|
|
ml=ml->next;
|
|
}
|
|
CrLf;
|
|
}
|
|
|
|
public void TssRep(TssStruct *tss=NULL)
|
|
{
|
|
ClassStruct *cl,*cn;
|
|
MemberListStruct *ml;
|
|
I4 *i_ptr;
|
|
|
|
if (!tss) tss=Fs;
|
|
cl=FindLocalHash("TssStruct",HTT_CLASS);
|
|
ml=cl->member_list;
|
|
while (ml) {
|
|
if (ml->fmtstr) {
|
|
i_ptr=tss+ml->offset;
|
|
cn=ml->member_class;
|
|
if ((cn->type & HTT_INTERNAL_TYPE) && ml->cnt==0) {
|
|
if (ml->fmtdata)
|
|
PrintF(ml->fmtstr,*i_ptr,ml->fmtdata);
|
|
else
|
|
PrintF(ml->fmtstr,*i_ptr);
|
|
PrintF(" %P",*i_ptr);
|
|
} else {
|
|
if (ml->fmtdata)
|
|
PrintF(ml->fmtstr,i_ptr,ml->fmtdata);
|
|
else
|
|
PrintF(ml->fmtstr,i_ptr);
|
|
PrintF(" %P",*i_ptr);
|
|
}
|
|
CrLf;
|
|
}
|
|
ml=ml->next;
|
|
}
|
|
CrLf;
|
|
}
|
|
|
|
public void StackRep(U4 *esp)
|
|
{
|
|
U8 i;
|
|
U4 my_esp[32];
|
|
BoolU4 old_preempt=Preempt(OFF);
|
|
for (i=0;i<32;i++) {
|
|
my_esp[i]=*esp;
|
|
esp=esp+4;
|
|
}
|
|
Preempt(old_preempt);
|
|
for (i=0;i<32;i++)
|
|
PrintF("%08X [ESP+%04X]: %08X %P\r\n",my_esp+i<<2,i<<2,my_esp[i],my_esp[i]);
|
|
CrLf;
|
|
}
|
|
|
|
|
|
void DrawIt()
|
|
{
|
|
ClearWindowText;
|
|
}
|
|
|
|
public void ViewDisk(I1 drive=0)
|
|
{
|
|
LTPartition *p=DriveToPartition(drive);
|
|
U1 *old_update_window=Fs->update_window;
|
|
Ltf *old_ltf=Fs->cur_ltf;
|
|
U8 lohi,c1,i,x,y,
|
|
l=(grheight-3*FONT_HEIGHT)*(grwidth-FONT_WIDTH<<1),
|
|
s=(p->size+p->spc-1)/p->spc;
|
|
U8 sc,ch;
|
|
U1 *bitmap;
|
|
GrBitMap *base=GrNew(grbase);
|
|
if (p->type!=PT_LT)
|
|
return;
|
|
|
|
MaximizeWindow;
|
|
UpdateDerivedTssValues(Fs);
|
|
Fs->update_window=&DrawIt;
|
|
Fs->cur_ltf=NULL;
|
|
GrClear;
|
|
ClearWindowText;
|
|
try {
|
|
i=((s+7)>>3+BLK_SIZE-1)/BLK_SIZE;
|
|
bitmap=MAlloc(BLK_SIZE*i);
|
|
RBlks(p,bitmap,p->MAP1,i,TRUE);
|
|
i=0;
|
|
for (y=0;y<(grheight-3*FONT_HEIGHT);y++) {
|
|
if (ScanChar(&sc,&ch))
|
|
break;
|
|
for (x=0;x<(grwidth-FONT_WIDTH<<1);x++) {
|
|
lohi=MulI8(i,s);
|
|
c1=lohi/l;
|
|
if (Bt(bitmap,c1))
|
|
base->color=ROP_XOR+(GR_BLUE^GR_WHITE);
|
|
else
|
|
base->color=ROP_XOR+(GR_WHITE^GR_WHITE);
|
|
GrPlot3(base,x,y,0);
|
|
i++;
|
|
}
|
|
}
|
|
Free(bitmap);
|
|
} catch
|
|
UnlockPartition(p);
|
|
GetChar;
|
|
Fs->update_window=old_update_window;
|
|
GrClear;
|
|
Fs->cur_ltf=old_ltf;
|
|
}
|
|
|
|
void ChkDskList(LTDirEntry *tempm1,U1 *bits,U1 *bits2,U8 size,U8 bpc)
|
|
{
|
|
LTDirEntry *tempm2;
|
|
U8 i,j;
|
|
tempm2=tempm1->next; //skip "." directory
|
|
while (tempm1) {
|
|
tempm2=tempm1->next;
|
|
if (tempm1->attr & LT_ATTR_DIR) {
|
|
if (tempm1->sub) {
|
|
coutln SysText("ST_SCANNING_DIRECTORY"),tempm1->full_name;
|
|
ChkDskList(tempm1->sub,bits,bits2,size,bpc);
|
|
}
|
|
}
|
|
j=(tempm1->size+bpc-1)/bpc;
|
|
for (i=0;i<j;i++) {
|
|
if (i+tempm1->cluster>size) {
|
|
PutSysText("ST_ERR_START");
|
|
coutln "Invalid Cluster:",tempm1->full_name,
|
|
" Cluster:",i+tempm1->cluster;
|
|
PutSysText("ST_ERR_END");
|
|
break;
|
|
}
|
|
if (Bts(bits,i+tempm1->cluster)) {
|
|
PutSysText("ST_ERR_START");
|
|
coutln "Double Alloc:",tempm1->full_name,
|
|
" Cluster:",i+tempm1->cluster;
|
|
PutSysText("ST_ERR_END");
|
|
}
|
|
if (!Btr(bits2,i+tempm1->cluster)) {
|
|
PutSysText("ST_ERR_START");
|
|
coutln "UnAlloc:",tempm1->full_name,
|
|
" Cluster:",i+tempm1->cluster;
|
|
PutSysText("ST_ERR_END");
|
|
}
|
|
}
|
|
DelLTDirEntry(tempm1);
|
|
tempm1=tempm2;
|
|
}
|
|
}
|
|
|
|
public void ChkDsk(I1 drive=0)
|
|
{
|
|
U8 i,j,bpc,size,my_flags=(1<<FUf_RECURSE);
|
|
LTPartition *p=DriveToPartition(drive);
|
|
I1 *mask=MSPrintF("%c:/*",PartitionToDrive(p));
|
|
U1 *bits,*bits2;
|
|
|
|
if (p->type!=PT_LT) {
|
|
PutSysText("ST_NOT_LT");
|
|
return;
|
|
}
|
|
size=(p->size-(p->data-p->offset))/p->spc;
|
|
bits=MAllocZ((size+7)>>3);
|
|
bits2=MAllocZ((size+7)>>3+BLK_SIZE);
|
|
RBlks(p,bits2,p->MAP1,((size+7)>>3+BLK_SIZE-1)/BLK_SIZE,TRUE);
|
|
bpc=p->spc*BLK_SIZE;
|
|
|
|
j=1; //TODO: get rootdir size
|
|
for (i=0;i<j;i++) {
|
|
if (i+p->root_cluster>size) {
|
|
PutSysText("ST_ERR_START");
|
|
coutln "Invalid Cluster: RootDir",
|
|
" Cluster:",i+p->root_cluster;
|
|
PutSysText("ST_ERR_END");
|
|
break;
|
|
}
|
|
if (Bts(bits,i+p->root_cluster)) {
|
|
PutSysText("ST_ERR_START");
|
|
coutln "Double Alloc: RootDir",
|
|
" Cluster:",i+p->root_cluster;
|
|
PutSysText("ST_ERR_END");
|
|
}
|
|
if (!Btr(bits2,i+p->root_cluster)) {
|
|
PutSysText("ST_ERR_START");
|
|
coutln "UnAlloc: RootDir",
|
|
" Cluster:",i+p->root_cluster;
|
|
PutSysText("ST_ERR_END");
|
|
}
|
|
}
|
|
|
|
ChkDskList(FindFiles(mask,&my_flags),bits,bits2,size,bpc);
|
|
for (i=1;i<size;i++)
|
|
if (Bt(bits2,i))
|
|
coutln "Shouldn't Alloc Cluster:",i;
|
|
|
|
Free(mask);
|
|
Free(bits);
|
|
Free(bits2);
|
|
}
|
|
|