#include "newalloc.h"
static hTab *bptable = NULL;
+char doingSteps = 0;
char userBpPresent = 0;
/* call stack can be 1024 deep */
STACK_DCL(callStack,function *,1024);
addr,
debug_bp_type_strings[addrType],
debug_bp_type_strings[bpType],
- fileName, lineno));
+ fileName, lineno+1));
/* allocate & init a new bp */
bp = Safe_calloc(1,sizeof(breakp));
/* if this is an user break point then
check if there already exists one for this address */
- if (bpType == USER) {
- for ( bpl = hTabFirstItemWK(bptable,addr) ; bpl;
- bpl = hTabNextItemWK(bptable)) {
-
- /* if also a user break point then issue Note : */
- if (bpl->bpType == USER)
- fprintf(stderr,"Note: breakpoint %d also set at pc 0x%x\n",
- bpl->bpnum,bpl->addr);
- }
-
- fprintf(stderr,"Breakpoint %d at 0x%x: file %s, line %d.\n",
- bp->bpnum, addr, fileName, lineno);
-
- userBpPresent++;
+ if (bpType == USER)
+ {
+ for ( bpl = hTabFirstItemWK(bptable,addr) ; bpl;
+ bpl = hTabNextItemWK(bptable))
+ {
+
+ /* if also a user break point then issue Note : */
+ if (bpl->bpType == USER)
+ fprintf(stderr,"Note: breakpoint %d also set at pc 0x%x\n",
+ bpl->bpnum,bpl->addr);
+ }
+
+ fprintf(stderr,"Breakpoint %d at 0x%x: file %s, line %d.\n",
+ bp->bpnum, addr, fileName, lineno+1);
+
+ userBpPresent++;
}
+ if (bpType != STEP && bpType != NEXT)
+ {
/* if a break point does not already exist then
send command to simulator to add one */
if (!hTabSearch(bptable,addr))
- /* send the break command to the simulator */
- simSetBP (addr);
-
+ /* send the break command to the simulator */
+ simSetBP (addr);
+ }
/* now add the break point to list */
hTabAddItem(&bptable,addr,bp);
if (bp->bpType == STEP) {
hTabDeleteItem(&bptable,bp->addr,bp,DELETE_ITEM,NULL);
+#if 0
/* if this leaves no other break points then
send command to simulator to delete bp from this addr */
if (hTabSearch(bptable,bp->addr) == NULL)
simClearBP (bp->addr);
-
+#endif
free(bp);
}
}
if (bp->bpType == NEXT) {
hTabDeleteItem(&bptable,bp->addr,bp,DELETE_ITEM,NULL);
+#if 0
/* if this leaves no other break points then
send command to simulator to delete bp from this addr */
if (hTabSearch(bptable,bp->addr) == NULL) {
simClearBP(bp->addr);
}
-
+#endif
free(bp);
}
}
if (bp->bpType == USER ) {
fprintf(stdout,"%-3d breakpoint keep y 0x%08x at %s:%d\n",
bp->bpnum,bp->addr,
- bp->filename,bp->lineno);
+ bp->filename,bp->lineno+1);
}
}
/* if no break points set for this address
then use a simulator stop break point */
if ((bp = hTabFirstItemWK(bptable,addr)) == NULL) {
+ if ( doingSteps == 2 ) return 1;
+ if ( doingSteps ) return 0;
return simStopBPCB(addr);
}
bpnum,
ctxt->func->sym->name,
ctxt->func->mod->c_name,
- ctxt->cline);
+ ctxt->cline+1);
if (ctxt->func->mod && ctxt->cline > 0)
- fprintf(stdout,"%d\t%s",ctxt->cline,
+ fprintf(stdout,"%d\t%s",ctxt->cline+1,
ctxt->func->mod->cLines[ctxt->cline]->src);
} else {
fprintf(stdout,"Breakpoint %d, %s() at %s:%d\n",
bpnum,
ctxt->func->sym->name,
ctxt->func->mod->asm_name,
- ctxt->asmline);
+ ctxt->asmline+1);
if (ctxt->func->mod && ctxt->asmline > 0)
- fprintf(stdout,"%d\t%s",ctxt->asmline,
+ fprintf(stdout,"%d\t%s",ctxt->asmline+1,
ctxt->func->mod->asmLines[ctxt->asmline]->src);
}
fprintf(stdout,"%s () at %s:%d\n",
ctxt->func->sym->name,
ctxt->func->mod->c_name,
- ctxt->cline);
+ ctxt->cline+1);
if (ctxt->func->mod && ctxt->cline > 0) {
- fprintf(stdout,"%d\t%s",ctxt->cline ,
+ fprintf(stdout,"%d\t%s",ctxt->cline+1 ,
ctxt->func->mod->cLines[ctxt->cline]->src);
}
} else {
fprintf(stdout,"%s () at %s:%d\n",
ctxt->func->sym->name,
ctxt->func->mod->c_name,
- ctxt->cline);
+ ctxt->cline+1);
if (ctxt->func->mod && ctxt->cline > 0)
- fprintf(stdout,"%d\t%s",ctxt->cline,
+ fprintf(stdout,"%d\t%s",ctxt->cline+1,
ctxt->func->mod->cLines[ctxt->cline]->src);
} else {
if ((lfunc && lfunc != ctxt->func) || !lfunc)
context *ctxt)
extern char userBpPresent;
+extern char doingSteps;
+
int setBreakPoint (unsigned , char , char,
int (*callBack)(unsigned,char,char,int,context *),char *, int);
{
*rmod = mod ;
if (line )
- *line = mod->ncLines;
- return 1;
+ {
+ *line = 0;
+ for ( i=0; i < mod->ncLines; i++ )
+ {
+ if ( mod->cLines[i]->addr > addr)
+ break;
+ *line = i;
+ }
+ return 1;
+ }
}
}
/* find the function we are in */
if (!applyToSet(functions,funcInAddr,addr,&func)) {
- if (!applyToSet(functions,funcWithName,"main") ||
- !applyToSet(modules,moduleLineWithAddr,addr,&mod,&line))
+ if (!applyToSet(functions,funcWithName,"main",&func) ||
+ !applyToSet(modules,moduleLineWithAddr,addr,&mod,NULL))
{
- fprintf(stderr, "Error?:discoverContext: cannot apply to set!\n");
+ fprintf(stderr, "Error?:discoverContext: cannot apply addr 0x%x\n",addr);
return NULL;
}
currCtxt->func = func;
currCtxt->modName = func->modName;
/* find the c line number */
- if(applyToSet(func->cfpoints,lineNearAddr,addr,
+ if(applyToSet(func->cfpoints,lineAtAddr,addr,
+ &line,&currCtxt->block,&currCtxt->level))
+ currCtxt->cline = func->lline = line;
+ else if(applyToSet(func->cfpoints,lineNearAddr,addr,
&line,&currCtxt->block,&currCtxt->level))
currCtxt->cline = func->lline = line;
else
if (!rv) {
if (!initial_break_flag) {
initial_break_flag = 1; // kludge to stop only at first run
+#if 0
fprintf(stdout, "Stopping at entry. You can now list and set breakpoints\n");
+#endif
}
else {
- gaddr = -1;
- goto top ;
+ if ( gaddr == 0 )
+ gaddr = -1;
+ if ( gaddr == -1 || doingSteps == 1 )
+ goto top ;
}
// notes: kpb
else
{
int line = func->exitline;
- applyToSet(func->cfpoints,lineNearAddr,braddr,&line,NULL,NULL);
+ if ( !applyToSet(func->cfpoints,lineAtAddr,braddr,
+ &line,NULL,NULL))
+ applyToSet(func->cfpoints,lineNearAddr,braddr,&line,NULL,NULL);
setBreakPoint ( braddr , CODE , USER , userBpCB ,
func->mod->c_name,line);
}
/* check if line number */
if (isdigit(*s)) {
/* get the lineno */
- int line = atoi(s);
+ int line = atoi(s) -1;
/* if current context not present then we must get the module
which has main & set the break point @ line number provided
/* case c) filename:lineno */
if (isdigit(*(bp +1))) {
- setBPatModLine (mod,atoi(bp+1));
+ setBPatModLine (mod,atoi(bp+1)-1);
goto ret;
}
fprintf(stdout,"The program is not being run.\n");
else
{
+ doingSteps = 2;
simGo(2);
+ doingSteps = 0;
showfull = 1;
}
return 0;
}
}
- simGo(-1);
+ doingSteps = 1;
+ simGo(2);
+ doingSteps = 0;
showfull = 1;
}
return 0;
fprintf(stdout,"The program is not being run.\n");
else
{
+ doingSteps = 2;
simGo(1);
+ doingSteps = 0;
showfull = 1;
}
return 0;
func->aexitline);
}
}
- simGo(-1);
+ doingSteps = 1;
+ simGo(1);
+ doingSteps = 0;
showfull = 1;
}
}
}
+/*-----------------------------------------------------------------*/
+/* infoRegisters - print register information */
+/*-----------------------------------------------------------------*/
+static void infoRegisters( int all, context *ctxt)
+{
+ static unsigned int regaddrs[] = {0x81,0x82,0x83,0xd0,0xe0,0xf0,0};
+ unsigned long val;
+ int i,j,*r;
+
+ i = simGetValue (0xd0,'I',1);
+ fprintf(stdout,"PC : 0x%04X RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
+ for ( j = 0; j < 8 ; j++ )
+ {
+ val = simGetValue (j ,'R',1);
+ fprintf(stdout," 0x%02X",val);
+ }
+ fprintf(stdout,"\n");
+ val = simGetValue (0xe0,'I',1);
+ fprintf(stdout,"ACC : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
+ val = simGetValue (0xf0,'I',1);
+ fprintf(stdout,"B : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
+ val = simGetValue (0x82,'I',2);
+ fprintf(stdout,"DPTR: 0x%04X %d\n",val,val);
+ val = simGetValue (0x81,'I',1);
+ fprintf(stdout,"SP : 0x%02X\n",val);
+ fprintf(stdout,"PSW : 0x%02X | CY : %c | AC : %c | OV : %c | P : %c\n",
+ i,(i&0x80)?'1':'0',(i&0x40)?'1':'0',(i&4)?'1':'0',(i&1)?'1':'0');
+ if ( all )
+ {
+ fprintf(stdout,"Special Function Registers:\n");
+ r = regaddrs;
+ for ( i = 0x80 ; i < 0x100 ; i++ )
+ {
+ symbol *sym = NULL;
+ if ( *r && *r == i )
+ {
+ /* skip normal registers */
+ r++ ;
+ continue;
+ }
+ if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
+ {
+ val = simGetValue (sym->addr,sym->addrspace,sym->size);
+ fprintf(stdout,"%s : 0x%02x",sym->name,val);
+ if ( !(i & 0x07 ))
+ {
+ for ( j = 0 ; j < 8 ; j++ )
+ {
+ sym = NULL;
+ if (applyToSetFTrue(sfrsymbols,symWithAddr,i+j,'J',&sym))
+ {
+ //val = simGetValue (sym->addr,sym->addrspace,sym->size);
+ fprintf(stdout," %s=%c",sym->name,(val&1)? '1':'0');
+ }
+ val >>= 1;
+ }
+ }
+ fprintf(stdout,"\n");
+ }
+ }
+ }
+}
+
/*-----------------------------------------------------------------*/
/* infoStack - print call stack information */
/*-----------------------------------------------------------------*/
/* info stack display call stack */
if (strcmp(s,"registers") == 0) {
- fprintf(stdout,"%s",simRegs());
- return 0;
+ infoRegisters(0,cctxt);
+ return 0;
}
/* info stack display call stack */
if (strcmp(s,"all-registers") == 0)
{
- int i,j;
- fprintf(stdout,"%s",simRegs());
- fprintf(stdout,"Special Function Registers:\n");
- for ( i = 0 ; i < 0x100 ; i++ )
- {
- symbol *sym = NULL;
- unsigned long val;
- if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
- {
- val = simGetValue (sym->addr,sym->addrspace,sym->size);
- fprintf(stdout,"%s=0x%02x",sym->name,val);
- if ( !(i & 0x07 ))
- {
- for ( j = 0 ; j < 8 ; j++ )
- {
- sym = NULL;
- if (applyToSetFTrue(sfrsymbols,symWithAddr,i+j,'J',&sym))
- {
- //val = simGetValue (sym->addr,sym->addrspace,sym->size);
- fprintf(stdout," %s=%c",sym->name,(val&1)? '1':'0');
- }
- val >>= 1;
- }
- }
- fprintf(stdout,"\n");
- }
- }
+ infoRegisters(1,cctxt);
return 0;
}
if (*s) {
/* case a) LINE */
if (isdigit(*s)) {
- sscanf(s,"%d",&pline);
+ pline = strtol(s,0,10) - 1;
if (!cctxt || !cctxt->func || !cctxt->func->mod) {
if (!list_mod) {
fprintf(stdout,"Sdcdb fails to have a proper context at %d.\n", __LINE__);
return 0;
}
}
- sscanf(bp,"%d",&pline);
+ pline = strtol(bp,0,10) - 1;
} else {
/* FILE:FUCTION */
if (!applyToSet(functions,funcWithNameModule,bp,s,&func)) {
}
else {
/* FUNCTION */
+ if (*s == '\'')
+ {
+ /* 'FUNCTION' */
+ s++ ;
+ if ((bp = strrchr(s,'\'')))
+ {
+ *bp = '\0';
+ }
+
+ }
if (!applyToSet(functions,funcWithName,s,&func)) {
fprintf(stderr,"Function \"%s\" not defined.\n",s);
return 0;
if ( infomode )
{
- fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x.\n",pline,
+ fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x.\n",pline+1,
list_mod->c_name, list_mod->cLines[pline]->addr);
infomode=0;
return 0;
if (IS_CHAR(etype))
{
if ( isprint(v.val))
- printFmtInteger("'%c'",fmt,(long)v.val,0,size);
+ printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
+ fmt,(long)v.val,0,size);
else
- printFmtInteger("'\\%o'",fmt,(long)v.val,0,size);
+ printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'\\%o'"),
+ fmt,(long)v.val,0,size);
}
else
{
if ( func )
{
fprintf(stdout,"#%d 0x%08x in %s () at %s:%d\n",
- framenr,func->laddr,func->sym->name,func->mod->c_name,func->lline);
+ framenr,func->laddr,func->sym->name,func->mod->c_name,func->lline+1);
fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
- func->mod->cfullname,func->lline,func->laddr);
+ func->mod->cfullname,func->lline+1,func->laddr);
}
else
fprintf(stdout,"No stack.\n");
/* if symbol then parse the symbol */
case SYM_REC:
- parseSymbol(loop->line,&rs);
+ parseSymbol(loop->line,&rs,2);
break;
case LNK_REC:
for (ep = setFirstItem(func->cfpoints); ep;
ep = setNextItem(func->cfpoints))
Dprintf(D_sdcdb, ("sdcdb: {0x%x,%d} %s",
- ep->addr,ep->line,mod->cLines[ep->line]->src));
+ ep->addr,ep->line+1,mod->cLines[ep->line]->src));
Dprintf(D_sdcdb, ("sdcdb: and the following ASM exePoints\n"));
for (ep = setFirstItem(func->afpoints); ep;
ep = setNextItem(func->afpoints))
Dprintf (D_sdcdb, ("sdcdb: {0x%x,%d} %s",
- ep->addr,ep->line,mod->asmLines[ep->line]->src));
+ ep->addr,ep->line+1,mod->asmLines[ep->line]->src));
}
#endif
}
if (srcMode == SRC_CMODE)
fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
currCtxt->func->mod->cfullname,
- currCtxt->cline,currCtxt->addr);
+ currCtxt->cline+1,currCtxt->addr);
else
fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
currCtxt->func->mod->afullname,
/* XTAL Frequency */
if (strcmp(argv[i],"-X") == 0 ||
- strcmp(argv[i],"-frequency") == 0) {
+ strcmp(argv[i],"-frequency") == 0) {
simArgs[nsimArgs++] = "-X";
simArgs[nsimArgs++] = strdup(argv[++i]);
continue ;
/* serial port */
if ( (strcmp(argv[i],"-S") == 0) ||
(strcmp(argv[i],"-s") == 0)) {
- simArgs[nsimArgs++] = "-s";
+ simArgs[nsimArgs++] = strdup(argv[i]);
simArgs[nsimArgs++] = strdup(argv[++i]);
continue ;
}
{
/* may be interrupt from user: stop debugger and also simulator */
userinterrupt = 1;
- sendSim("\n");
+ sendSim("stop\n");
}
/* the only child can be the simulator */
FILE *simout; /* stream for simulator output */
int sock = -1; /* socket descriptor to comm with simulator */
-pid_t simPid;
+pid_t simPid = -1;
static char simibuff[MAX_SIM_BUFF]; /* sim buffer */
static char regBuff[MAX_SIM_BUFF];
static char *sbp = simibuff; /* simulator buffer pointer */
{
sendSim("di 0x0 0xff\n");
}
+ else if ( cachenum == SREG_CACHE )
+ {
+ sendSim("ds 0x80 0xff\n");
+ }
else
{
laddr = addr & 0xffffffc0;
struct sockaddr_in sin;
int retry = 0;
int i ;
- Dprintf(D_simi, ("simi: openSimulator\n"));
+ Dprintf(D_simi, ("simi: openSimulator\n"));
invalidateCache(XMEM_CACHE);
invalidateCache(IMEM_CACHE);
- /* fork and start the simulator as a subprocess */
- if ((simPid = fork())) {
- Dprintf(D_simi, ("simi: simulator pid %d\n",(int) simPid));
- }
- else {
- /* we are in the child process : start the simulator */
- signal(SIGHUP , SIG_IGN );
- signal(SIGINT , SIG_IGN );
- signal(SIGABRT, SIG_IGN );
- signal(SIGCHLD, SIG_IGN );
-
- if (execvp(args[0],args) < 0) {
- perror("cannot exec simulator");
- exit(1);
- }
- }
+ invalidateCache(SREG_CACHE);
try_connect:
sock = socket(AF_INET,SOCK_STREAM,0);
sin.sin_addr.s_addr = inet_addr("127.0.0.1");
sin.sin_port = htons(9756);
- sleep(1);
/* connect to the simulator */
if (connect(sock,(struct sockaddr *) &sin, sizeof(sin)) < 0) {
/* if failed then wait 1 second & try again
do this for 10 secs only */
if (retry < 10) {
+ if ( !retry )
+ {
+ /* fork and start the simulator as a subprocess */
+ if ((simPid = fork())) {
+ Dprintf(D_simi, ("simi: simulator pid %d\n",(int) simPid));
+ }
+ else {
+ /* we are in the child process : start the simulator */
+ signal(SIGHUP , SIG_IGN );
+ signal(SIGINT , SIG_IGN );
+ signal(SIGABRT, SIG_IGN );
+ signal(SIGCHLD, SIG_IGN );
+
+ if (execvp(args[0],args) < 0) {
+ perror("cannot exec simulator");
+ exit(1);
+ }
+ }
+ }
retry ++;
- sleep (1);
+ sleep (1);
goto try_connect;
}
perror("connect failed :");
static int getMemString(char *buffer, char wrflag,
- unsigned int addr, char mem, int size )
+ unsigned int *addr, char mem, int size )
{
int cachenr = NMEM_CACHE;
char *prefix;
{
cmd = "set bit";
}
- sprintf(buffer,"%s 0x%x\n",cmd,addr);
+ sprintf(buffer,"%s 0x%x\n",cmd,*addr);
return cachenr;
break;
case 'I': /* SFR space */
prefix = "sfr" ;
+ cachenr = SREG_CACHE;
break;
case 'R': /* Register space */
- if ( !wrflag )
- {
- cachenr = REG_CACHE;
- sprintf(buffer,"info reg\n");
- return cachenr;
- }
prefix = "iram";
/* get register bank */
cachenr = simGetValue (0xd0,'I',1);
- addr += cachenr & 0x18 ;
+ *addr += cachenr & 0x18 ;
cachenr = IMEM_CACHE;
break;
default:
return cachenr;
}
if ( wrflag )
- sprintf(buffer,"%s %s 0x%x\n",cmd,prefix,addr,addr);
+ sprintf(buffer,"%s %s 0x%x\n",cmd,prefix,*addr);
else
- sprintf(buffer,"%s %s 0x%x 0x%x\n",cmd,prefix,addr,addr+size-1);
+ sprintf(buffer,"%s %s 0x%x 0x%x\n",cmd,prefix,*addr,*addr+size-1);
return cachenr;
}
if ( size <= 0 )
return 0;
- cachenr = getMemString(buffer,1,addr,mem,size);
+ cachenr = getMemString(buffer,1,&addr,mem,size);
if ( cachenr < NMEM_CACHE )
{
invalidateCache(cachenr);
if ( size <= 0 )
return 0;
- cachenr = getMemString(buffer,0,addr,mem,size);
+ cachenr = getMemString(buffer,0,&addr,mem,size);
resp = NULL;
if ( cachenr < NMEM_CACHE )
/* skip thru the address part */
while (isxdigit(*resp)) resp++;
- /* then make the branch for bit variables */
- if ( cachenr == REG_CACHE )
- {
- /* skip registers */
- for (i = 0 ; i < addr ; i++ )
- {
- while (isspace(*resp)) resp++ ;
- /* skip */
- while (isxdigit(*resp)) resp++;
- }
- }
}
/* make the branch for bit variables */
if ( cachenr == BIT_CACHE)
/*-----------------------------------------------------------------*/
unsigned int simGoTillBp ( unsigned int gaddr)
{
- char *sr, *svr;
+ char *sr;
unsigned addr ;
char *sfmt;
int wait_ms = 1000;
invalidateCache(XMEM_CACHE);
invalidateCache(IMEM_CACHE);
+ invalidateCache(SREG_CACHE);
if (gaddr == 0) {
/* initial start, start & stop from address 0 */
- char buf[20];
+ //char buf[20];
// this program is setting up a bunch of breakpoints automatically
// at key places. Like at startup & main() and other function
sendSim ("run\n");
wait_ms = 100;
}
- else if (gaddr == 1 ) { /* nexti */
+ else if (gaddr == 1 ) { /* nexti or next */
sendSim ("next\n");
wait_ms = 100;
}
- else if (gaddr == 2 ) { /* stepi */
+ else if (gaddr == 2 ) { /* stepi or step */
sendSim ("step\n");
wait_ms = 100;
}
waitForSim(wait_ms, NULL);
/* get the simulator response */
- svr = sr = strdup(simResponse());
-
- if ( gaddr == 1 || gaddr == 2 )
+ sr = simResponse();
+ /* check for errors */
+ while ( *sr )
{
- int nl;
- for ( nl = 0; nl < 3 ; nl++ )
+ while ( *sr && *sr != 'E' ) sr++ ;
+ if ( !*sr )
+ break;
+ if ( ! strncmp(sr,"Error:",6))
{
- while (*sr && *sr != '\n') sr++ ;
- sr++ ;
+ fputs(sr,stdout);
+ break;
}
- if ( nl < 3 )
- return 0;
- gaddr = strtol(sr,0,0);
- /* empty response */
- simibuff[0] = '\0';
- return gaddr;
-
- }
- /* figure out the address of the break point the simulators
- response in a break point situation is of the form
- [... F* <addr> <disassembled instruction> ]
- we will ignore till we get F* then parse the address */
- while (*sr) {
- if (strncmp(sr,"Stop at",7) == 0) {
- sr += 7;
- sfmt = "%x";
- break;
- }
-
- if (*sr == 'F' && ( *(sr+1) == '*' || *(sr+1) == ' ')) {
- sr += 2;
- sfmt = "%x";
- break;
- }
- sr++;
- }
-
- if (!*sr) {
- fprintf(stderr, "Error?, simGoTillBp failed to Stop\n");
- return 0;
+ sr++ ;
}
- while (isspace(*sr)) sr++ ;
-
- if (sscanf(sr,sfmt,&addr) != 1) {
- fprintf(stderr, "Error?, simGoTillBp failed to get Addr\n");
- return 0;
- }
- return addr;
+ /* better solution: ask pc */
+ sendSim ("pc\n");
+ waitForSim(100, NULL);
+ sr = simResponse();
+ gaddr = strtol(sr+3,0,0);
+ return gaddr;
}
/*-----------------------------------------------------------------*/
{
invalidateCache(XMEM_CACHE);
invalidateCache(IMEM_CACHE);
+ invalidateCache(SREG_CACHE);
sendSim("res\n");
waitForSim(100,NULL);
}
-/*-----------------------------------------------------------------*/
-/* getValueStr - read a value followed by a string = */
-/*-----------------------------------------------------------------*/
-static unsigned int getValueStr (char *src,char *cstr)
-{
- int i = strlen(cstr);
- int rv;
- /* look for the string */
- if (! (src = strstr(src,cstr)))
- return 0;
-
- src += i;
- if (!*src) return 0;
-
- /* look for the digit */
- while (*src && !isxdigit(*src)) src++;
- sscanf(src,"%x",&rv);
- return rv;
-}
-
-/*-----------------------------------------------------------------*/
-/* simRegs - returns value of registers */
-/*-----------------------------------------------------------------*/
-char *simRegs()
-{
- char *resp ;
- unsigned int rv;
- char *rb = regBuff;
- int i;
-
- sendSim("info registers\n");
-
- waitForSim(100,NULL);
-
- resp = simResponse();
-
-#if 0
- return resp;
-
-#else
- /*Take this out(2-09-02) cant see as its that useful to reformat, karl.*/
-
- /* the response is of the form
- XXXXXX R0 R1 R2 R3 R4 R5 R6 R7 ........
- XXXXXX XX . ACC=0xxx dd cc B=0xxx dd cc DPTR= 0xxxxx @DPTR= 0xxx dd cc
- XXXXXX XX . PSW= 0xxx CY=[1|0] AC=[0|1] OV=[0|1] P=[1|0]
-
-Format as of 8-4-01:
- 0x00 00 00 00 00 00 00 00 00 ........
- 000000 00 . ACC= 0x00 0 . B= 0x00 DPTR= 0x0000 @DPTR= 0x00 0 .
- 000000 00 . PSW= 0x00 CY=0 AC=0 OV=0 P=0
-F 0x006d 75 87 80 MOV PCON,#80
-*/
-
- memset(regBuff,0,sizeof(regBuff));
- /* skip the first numerics */
- while (*resp && !isxdigit(*resp)) resp++;
-
- if (strncmp(resp, "0x", 2)) {
- fprintf(stderr, "Error: Format1A\n");
- return regBuff;
- }
- resp += 2;
- while (*resp && isxdigit(*resp)) resp++;
-
- /* now get the eight registers */
- for (i = 0 ; i < 7 ; i++) {
- while (*resp && isspace(*resp)) resp++;
- if (!*resp)
- break;
- rv = strtol(resp,&resp,16);
- sprintf(rb,"R%d : 0x%02X %d %c\n",i,rv,rv,(isprint(rv) ? rv : '.'));
- rb += strlen(rb);
- }
-
- if (!*resp) return regBuff;
-
- /* skip till end of line */
- while (*resp && *resp != '\n') resp++;
- while (*resp && !isxdigit(*resp)) resp++;
- while (*resp && isxdigit(*resp)) resp++;
-
- /* accumulator value */
- rv = getValueStr(resp,"ACC");
- sprintf(rb,"ACC : 0x%02X %d %c\n",rv,rv,(isprint(rv) ? rv : '.'));
- rb += strlen(rb);
-
- /* value of B */
- rv = getValueStr(resp,"B=");
- sprintf(rb,"B : 0x%02X %d %c\n",rv,rv,(isprint(rv) ? rv : '.'));
- rb += strlen(rb);
-
- rv = getValueStr(resp,"DPTR=");
- sprintf(rb,"DPTR: 0x%04X %d\n",rv,rv);
- rb += strlen(rb);
-
- rv = getValueStr(resp,"@DPTR=");
- sprintf(rb,"@DPTR: 0x%02X %d %c\n", rv,rv,(isprint(rv) ? rv : '.'));
- rb += strlen(rb);
-
- sprintf(rb,"PSW : 0x%02X | CY : %d | AC : %d | OV : %d | P : %d\n",
- getValueStr(resp,"PSW="),
- getValueStr(resp,"CY="),
- getValueStr(resp,"AC="),
- getValueStr(resp,"OV="),
- getValueStr(resp,"P="));
-
- return regBuff;
-#endif
-
-}
/*-----------------------------------------------------------------*/
/* closeSimulator - close connection to simulator */
simactive = 0;
return;
}
- sendSim("q\n");
- kill (simPid,SIGKILL);
+ sendSim("quit\n");
fclose (simin);
fclose (simout);
shutdown(sock,2);
close(sock);
sock = -1;
+ if ( simPid > 0 )
+ kill (simPid,SIGKILL);
}
/* number of cache */
#define IMEM_CACHE 0
#define XMEM_CACHE 1
-#define NMEM_CACHE 2
+#define SREG_CACHE 2
+#define NMEM_CACHE 3
/* special index */
-#define REG_CACHE 3
#define BIT_CACHE 4
typedef struct _memcache
func = Safe_calloc(1,sizeof(function));
func->sym = NULL;
- applyToSet(symbols,symWithRName,line,&func->sym);
+ applyToSetFTrue(symbols,symWithRName,line,&func->sym);
*rs++ = '0';
if (! func->sym)
- func->sym = parseSymbol(line,&rs);
+ func->sym = parseSymbol(line,&rs,1);
func->sym->isfunc = 1;
func->modName = currModName ;
while(*rs && *rs != ',') rs++;
/* {G|F<filename>|L<functionName>}'$'<name>'$'<level> */
/* '$'<block><type info> */
/*-----------------------------------------------------------------*/
-symbol *parseSymbol (char *s, char **rs)
+symbol *parseSymbol (char *s, char **rs, int doadd)
{
symbol *nsym ;
+ char save_ch;
char *bp = s;
- nsym = Safe_calloc(1,sizeof(symbol));
-
- /* copy over the mangled name */
- while (*bp != '(') bp++;
- bp -= 1;
- nsym->rname = alloccpy(s,bp - s);
-
+ /* go the mangled name */
+ for ( bp = s; *bp && *bp != '('; bp++ );
+ save_ch = *--bp;
+ *bp = '\0';
+ nsym = NULL;
+ if ( doadd == 2 )
+ {
+ /* add only if not present and if linkrecord before symbol record*/
+ if ( applyToSetFTrue(symbols,symWithRName,s,&nsym))
+ {
+ if ( nsym->rname != nsym->name )
+ return;
+ doadd = 0;
+ }
+ }
+ if ( ! nsym )
+ {
+ nsym = Safe_calloc(1,sizeof(symbol));
+ nsym->rname = alloccpy(s,bp - s);
+ }
+ *bp = save_ch;
/* if this is a Global Symbol */
nsym->scopetype = *s;
s++ ;
}
*rs = s;
- addSet(&symbols,nsym);
+ if ( doadd ) addSet(&symbols,nsym);
+
+ Dprintf(D_symtab, ("symtab: par %s(0x%x) add=%d sym=%p\n",nsym->name,nsym->addr,doadd,nsym));
return nsym;
}
offset = strtol(s,&s,10);
while (*s != ':') s++;
s++;
- sym = parseSymbol(s,&s);
+ sym = parseSymbol(s,&s,0);
sym->offset = offset ;
s += 3;
if (!fields)
s++;
sscanf(s,"%x",&func->sym->eaddr);
- Dprintf(D_symtab, ("symtab: %s(eaddr 0x%x)\n",func->sym->name,func->sym->eaddr));
+ Dprintf(D_symtab, ("symtab: ead %s(0x%x)\n",func->sym->name,func->sym->eaddr));
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void lnkSymRec (char *s)
{
- char sname[128], *bp = sname;
+ char *bp, save_ch ;
symbol *sym;
- /* copy till we get to a ':' */
- while ( *s != ':')
- *bp++ = *s++;
- bp -= 1;
+ /* search to a ':' */
+ for ( bp = s; *bp && *bp != ':'; bp++ );
+ save_ch = *--bp;
*bp = '\0';
sym = NULL;
- if (!applyToSet(symbols,symWithRName,sname,&sym))
- return ;
-
- s++;
- sscanf(s,"%x",&sym->addr);
-
- Dprintf(D_symtab, ("symtab: %s(0x%x)\n",sym->name,sym->addr));
+ applyToSetFTrue(symbols,symWithRName,s,&sym);
+ if (! sym)
+ {
+ sym = Safe_calloc(1,sizeof(symbol));
+ sym->rname = alloccpy(s,bp - s);
+ sym->scopetype = *s;
+ sym->name = sym->rname;
+ addSet(&symbols,sym);
+ }
+ *bp = save_ch;
+ if ( *bp )
+ {
+ sscanf(bp+2,"%x",&sym->addr);
+ }
+ Dprintf(D_symtab, ("symtab: lnk %s(0x%x)\n",sym->name,sym->addr));
}
/*-----------------------------------------------------------------*/
line--;
if (line < mod->nasmLines) {
mod->asmLines[line]->addr = addr;
- Dprintf(D_symtab, ("symtab: %s(%d:0x%x) %s",mod->asm_name,line,addr,mod->asmLines[line]->src));
+ Dprintf(D_symtab, ("symtab: asm %s(%d:0x%x) %s",mod->asm_name,line,addr,mod->asmLines[line]->src));
}
}
}
line--;
- if (line < mod->ncLines && line > 0) {
+ /* one line can have more than one address : (for loops !)*/
+ if (line < mod->ncLines && line > 0 &&
+ ( !mod->cLines[line]->addr ||
+ mod->cLines[line]->level > level )) {
mod->cLines[line]->addr = addr;
mod->cLines[line]->block = block;
mod->cLines[line]->level = level;
- Dprintf(D_symtab, ("symtab: %s(%d:0x%x) %s",mod->c_name,
+ Dprintf(D_symtab, ("symtab: ccc %s(%d:0x%x) %s",mod->c_name,
line+1,addr,mod->cLines[line]->src));
}
return;
#define IS_ISR(x) (IS_SPEC(x) && SPEC_INTRTN(x))
-symbol *parseSymbol (char *, char **);
+symbol *parseSymbol (char *, char **, int );
structdef *parseStruct (char *);
void parseFunc (char *);
module *parseModule (char *, bool );
projects / fw / sdcc / commitdiff