under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
+
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
- what you give them. Help stamp out software-hoarding!
+ what you give them. Help stamp out software-hoarding!
-------------------------------------------------------------------------*/
#include "sdcdb.h"
static void printTypeInfo(link *);
static void printValAggregates (symbol *,link *,char,unsigned int,int);
-static int printOrSetSymValue (symbol *sym, context *cctxt,
- int flg, int dnum, int fmt,
+static int printOrSetSymValue (symbol *sym, context *cctxt,
+ int flg, int dnum, int fmt,
char *rs, char *val, char cmp);
int srcMode = SRC_CMODE ;
*funcp = func;
return 1;
}
-
+
return 0;
}
return 0;
if ( sym->addr == laddr &&
- sym->addrspace == laddrspace )
+ sym->addrspace == laddrspace )
{
*rsym = sym;
return 1;
int next_line;
/* look for the first executable line after the line
- specified & get the break point there */
+ specified & get the break point there */
if ( line < 0 )
return;
line,mod->c_name);
return ;
}
-
+
if (srcMode == SRC_AMODE && line > mod->nasmLines) {
fprintf(stderr,"No line %d in file \"%s\".\n",
line,mod->asm_name);
}
next_line = line;
- for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
+ for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
next_line++ ) {
if (srcMode == SRC_CMODE) {
if (mod->cLines[next_line]->addr != INT_MAX) {
- setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType,
+ setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType,
userBpCB, mod->c_name, next_line);
return;
// break;
}
else {
if (mod->asmLines[next_line]->addr != INT_MAX) {
- setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType,
+ setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType,
userBpCB, mod->asm_name, next_line);
return;
// break;
- }
+ }
}
}
line,mod->c_name);
return ;
}
-
+
if (srcMode == SRC_AMODE && line > mod->ncLines) {
fprintf(stderr,"No line %d in file \"%s\".\n",
line,mod->c_name);
return ;
- }
-
- for ( ; line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
+ }
+
+ for ( ; line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
line++ ) {
- if (srcMode == SRC_CMODE)
+ if (srcMode == SRC_CMODE)
if (mod->cLines[line]->addr) {
- clearUSERbp (mod->cLines[line]->addr);
+ clearUSERbp (mod->cLines[line]->addr);
break;
}
else
if (mod->asmLines[line]->addr) {
- clearUSERbp (mod->asmLines[line]->addr);
+ clearUSERbp (mod->asmLines[line]->addr);
break;
}
}
if (*rmod)
return 0;
- for (i=0; i < mod->nasmLines; i++ )
+ for (i=0; i < mod->nasmLines; i++ )
{
if ( mod->asmLines[i]->addr == addr)
{
if (line )
{
*line = 0;
- for ( i=0; i < mod->ncLines; i++ )
+ for ( i=0; i < mod->ncLines; i++ )
{
if ( mod->cLines[i]->addr > addr)
break;
/*-----------------------------------------------------------------*/
/* funcWithNameModule - returns functions with a name module combo */
/*-----------------------------------------------------------------*/
-DEFSETFUNC(funcWithNameModule)
+DEFSETFUNC(funcWithNameModule)
{
function *func = item;
V_ARG(char *,fname);
/* in the address range */
if (func->sym->addr <= addr &&
func->sym->eaddr >= addr) {
-
+
*funcp = func;
return 1;
}
- return 0;
+ return 0;
}
/*-----------------------------------------------------------------*/
DEFSETFUNC(setStepBp)
{
function *func = item;
-
+
if (func->sym && func->sym->addr ) {
-
+
/* set the entry break point */
- setBreakPoint (func->sym->addr , CODE , STEP ,
+ setBreakPoint (func->sym->addr , CODE , STEP ,
stepBpCB ,func->mod->c_name , func->entryline);
return 1;
exePoint *ep = item;
V_ARG(int,bptype);
V_ARG(char *,mname);
-
- setBreakPoint (ep->addr, CODE, bptype,
+
+ setBreakPoint (ep->addr, CODE, bptype,
stepBpCB, mname, ep->line);
return 1;
}
exePoint *ep = item;
V_ARG(int,bptype);
V_ARG(char *,mname);
-
- setBreakPoint (ep->addr, CODE, bptype,
+
+ setBreakPoint (ep->addr, CODE, bptype,
nextBpCB, mname, ep->line);
return 1;
}
}
return 0;
-
+
}
/*-----------------------------------------------------------------*/
}
return 0;
-
+
}
/*-----------------------------------------------------------------*/
currCtxt->func = func;
currCtxt->addr = func->laddr = addr;
currCtxt->modName = func->modName;
-
+
/* find the c line number */
if(applyToSet(func->cfpoints,lineAtAddr,addr,
- &line,&currCtxt->block,&currCtxt->level))
+ &line,&currCtxt->block,&currCtxt->level))
currCtxt->cline = func->lline = line;
else if(applyToSet(func->cfpoints,lineNearAddr,addr,
- &line,&currCtxt->block,&currCtxt->level))
+ &line,&currCtxt->block,&currCtxt->level))
currCtxt->cline = func->lline = line;
else
currCtxt->cline = -1;
- }
+ }
/* find the asm line number */
line = 0;
if (applyToSet(func->afpoints,lineAtAddr,addr,
&line,NULL,NULL))
- currCtxt->asmline = line;
+ currCtxt->asmline = line;
else
currCtxt->asmline = -1;
-
+
return currCtxt ;
}
/* simGo - send 'go' cmd to simulator and wait till a break occurs */
/*-----------------------------------------------------------------*/
void simGo (unsigned int gaddr)
-{
+{
unsigned int addr ;
context *ctxt;
int rv;
stopCommandList();
- top:
+ top:
if ( userinterrupt )
{
userinterrupt = 0;
addr = simGoTillBp (gaddr);
/* got the pc for the break point now first
- discover the program context i.e. module, function
+ discover the program context i.e. module, function
linenumber of the source etc, etc etc */
- currentFrame = 0;
+ currentFrame = 0;
ctxt = discoverContext (addr, NULL);
-
+
/* dispatch all the break point call back functions */
- rv = dispatchCB (addr,ctxt);
- ret:
+ rv = dispatchCB (addr,ctxt);
/* the dispatch call back function will return
non-zero if an user break point has been hit
- if not then we continue with the execution
+ if not then we continue with the execution
of the program */
- if (!rv)
+ if (!rv)
{
if ( gaddr == 0 )
gaddr = -1;
if ( gaddr == -1 || doingSteps == 1 )
goto top ;
}
-
+
}
/*-----------------------------------------------------------------*/
*sym = NULL;
while (isspace(*s)) s++;
- if (!*s)
+ if (!*s)
return (char *)0;
while (isspace(*bp)) bp--;
return bp;
}
-static int printAsmLine( function *func, module *m, long saddr, long eaddr)
+static int printAsmLine( function *func, module *m, unsigned saddr, unsigned eaddr)
{
int i,j,delta;
- int symaddr;
- int lastaddr = saddr+1;
+ unsigned symaddr;
+ unsigned lastaddr = saddr+1;
char *symname;
if ( func )
symaddr = saddr;
symname = "" ;
}
- for (j=0,i=0; i < m->nasmLines; i++ )
+ for (j=0,i=0; i < m->nasmLines; i++ )
{
if ( saddr >= 0 && m->asmLines[i]->addr < saddr)
{
{
continue;
}
- if ( func &&
+ if ( func &&
(m->asmLines[i]->addr < func->sym->addr ||
m->asmLines[i]->addr > func->sym->eaddr ))
{
continue;
- }
+ }
delta = m->asmLines[i]->addr - symaddr;
if ( delta >= 0 )
{
lastaddr = m->asmLines[i]->addr;
printf("0x%08x <%s",lastaddr,symname);
if (delta > 0) printf("+%d",delta);
- printf(">:\t%s",m->asmLines[i]->src);
+ printf(">:\t%s",m->asmLines[i]->src);
}
}
return lastaddr;
}
if ( eaddr == -1 )
- {
+ {
/* no start or only start so dump function */
if ( saddr == -1 )
{
printf("Dump of assembler code for function %s:\n",func->sym->name);
printAsmLine(func,func->mod,-1,-1);
printf("End of assembler dump.\n");
- return 0;
+ return 0;
}
else
{
printf("Dump of assembler code:\n");
printAsmLine(NULL,modul,saddr,eaddr);
printf("End of assembler dump.\n");
- return 0;
+ return 0;
}
}
}
{
if ( args > 1 )
printf("End of assembler dump.\n");
- return 0;
+ return 0;
}
-
+
}
fprintf(stderr,"No function contains specified address.\n");
if( saddr >= 0 )
waitForSim(1000, NULL);
fputs(simResponse(),stdout);
}
- return 0;
+ return 0;
}
/*-----------------------------------------------------------------*/
/* cmdDisasm1 - disassemble one asm instruction */
{
char *bp ;
function *func = NULL;
-
+
/* user break point location specification can be of the following
forms
a) <nothing> - break point at current location
c) filename:lineno - line number of the given file
e) filename:function- function X in file Y (useful for static functions)
f) function - function entry point
- g) *addr - break point at address
+ g) *addr - break point at address
*/
if (!cctxt) {
}
/* white space skip */
while (*s && isspace(*s)) s++;
-
+
/* null terminate it after stripping trailing blanks*/
bp = s + strlen(s);
while (bp != s && isspace(*bp)) bp--;
else
setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
cctxt->func->mod->asm_name, cctxt->asmline);
-
+
}
else
fprintf(stderr,"No default breakpoint address now.\n");
-
+
goto ret ;
}
/* case g) *addr */
module *modul;
if (!applyToSet(modules,moduleLineWithAddr,braddr,&modul,&line))
{
- fprintf(stderr,"Address 0x%08x not exists in code.\n",braddr);
+ fprintf(stderr,"Address 0x%08x not exists in code.\n",braddr);
}
else
{
}
/* if current context not present then we must get the module
which has main & set the break point @ line number provided
- of that module : if current context known then set the bp
- at the line number given for the current module
+ of that module : if current context known then set the bp
+ at the line number given for the current module
*/
if (cctxt->func) {
if (!cctxt->func->mod) {
if (!applyToSet(functions,funcWithName,"main"))
fprintf(stderr,"Function \"main\" not defined.\n");
- else
+ else
setBPatModLine(func->mod,line, bpType);
- } else
+ } else
setBPatModLine(cctxt->func->mod,line, bpType);
} else {
if (list_mod) {
fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
}
}
-
+
goto ret;
}
if ((bp = strchr(s,':'))) {
-
+
module *mod = NULL;
*bp = '\0';
-
+
if (srcMode == SRC_CMODE) {
if (!applyToSet(modules,moduleWithCName,s,&mod)) {
fprintf (stderr,"No source file named %s.\n",s);
goto ret;
}
}
-
+
/* case c) filename:lineno */
- if (isdigit(*(bp +1))) {
+ if (isdigit(*(bp +1))) {
Dprintf(D_break, ("commonSetUserBp: c) line:%d \n",atoi(bp+1)));
- setBPatModLine (mod,atoi(bp+1)-1,bpType);
+ setBPatModLine (mod,atoi(bp+1)-1,bpType);
goto ret;
-
+
}
/* case d) filename:function */
- if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
- fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
- else
+ if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
+ fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
+ else
Dprintf(D_break, ("commonSetUserBp: d) \n"));
setBPatModLine (mod,
- (srcMode == SRC_CMODE ?
+ (srcMode == SRC_CMODE ?
func->entryline :
func->aentryline),bpType);
-
+
goto ret;
}
-
+
/* case e) function */
Dprintf(D_break, ("commonSetUserBp: e) \n"));
if (!applyToSet(functions,funcWithName,s,&func))
- fprintf(stderr,"Function \"%s\" not defined.\n",s);
+ fprintf(stderr,"Function \"%s\" not defined.\n",s);
else
setBPatModLine(func->mod,
(srcMode == SRC_CMODE ?
func->entryline :
func->aentryline),bpType);
- ret:
+ ret:
return 0;
}
{
char *bp ;
function *func = NULL;
- if (STACK_EMPTY(callStack))
+ if (STACK_EMPTY(callStack))
{
fprintf(stdout,"The program is not running.\n");
return 0;
- }
+ }
/* white space skip */
while (*s && isspace(*s)) s++;
-
+
/* null terminate it after stripping trailing blanks*/
bp = s + strlen(s);
while (bp != s && isspace(*bp)) bp--;
*bp = '\0';
- if (! *s )
+ if (! *s )
{
fprintf(stdout,"No argument: need line or *addr.\n");
return 0;
simSetPC(addr);
return 0;
}
- if (isdigit(*s))
+ if (isdigit(*s))
{
/* get the lineno */
int line = atoi(s) -1;
- if (!cctxt || !cctxt->func || !cctxt->func->mod)
+ if (!cctxt || !cctxt->func || !cctxt->func->mod)
{
fprintf(stderr,"Function not defined.\n");
return 0;
simSetPC(cctxt->func->mod->cLines[line]->addr);
return 0;
}
- if ((bp = strchr(s,':')))
+ if ((bp = strchr(s,':')))
{
int line;
module *mod = NULL;
*bp++ = '\0';
- if (!applyToSet(modules,moduleWithCName,s,&mod))
+ if (!applyToSet(modules,moduleWithCName,s,&mod))
{
fprintf (stderr,"No source file named %s.\n",s);
return 0;
- }
- if (!isdigit(*bp))
- {
+ }
+ if (!isdigit(*bp))
+ {
fprintf (stderr,"No line number.\n");
- return 0;
+ return 0;
}
line = atoi(bp) -1;
if (line >= mod->ncLines )
{
fprintf(stdout,"Warning line %d outside actual function.\n",
line+1);
- }
+ }
simSetPC(mod->cLines[line]->addr);
}
return 0;
/*-----------------------------------------------------------------*/
int cmdListAsm (char *s, context *cctxt)
{
- if ( cctxt && cctxt->func)
+ if ( cctxt && cctxt->func)
{
/* actual line */
if ( cctxt->addr != INT_MAX )
{
if (printAsmLine(cctxt->func,cctxt->func->mod,
(long)cctxt->addr,(long)cctxt->addr))
- return 0;
+ return 0;
}
}
return 0;
srcMode = SRC_AMODE;
else
srcMode = SRC_CMODE;
- fprintf(stderr,"source mode set to '%s'\n",
+ fprintf(stderr,"source mode set to '%s'\n",
(srcMode == SRC_CMODE ? "C" : "asm"));
return 0;
}
- if (strncmp(s,"listsize ",9) == 0)
+ if (strncmp(s,"listsize ",9) == 0)
{
listlines = strtol(s+9,0,0);
if ( listlines < LISTLINES )
}
#ifdef SDCDB_DEBUG
- if (strncmp(s,"debug ",6) == 0)
+ if (strncmp(s,"debug ",6) == 0)
{
sdcdbDebug = strtol(s+6,0,0);
return 0;
}
#endif
- if (strncmp(s,"variable ",9) == 0)
+ if (strncmp(s,"variable ",9) == 0)
{
symbol *sym ;
int fmt;
}
else
fprintf(stdout,"No new value for \"%s\".\n",s);
- return 0;
+ return 0;
}
-
+
fprintf(stderr,"'set %s' command not yet implemented\n",s);
return 0;
}
/* cmdIgnore - set ignorecount for breakpoint */
/*-----------------------------------------------------------------*/
int cmdIgnore (char *s, context *cctxt)
-{
+{
int bpnum, cnt ;
while (isspace(*s)) s++;
- if (!*s )
+ if (!*s )
{
fprintf(stdout,"Argument required (breakpoint number).\n");
return 0;
}
bpnum = strtol(s,&s,10);
while (isspace(*s)) s++;
- if (!*s )
+ if (!*s )
{
fprintf(stdout,"Second argument (specified ignore-count) is missing.");
return 0;
/* cmdCondition - set condition for breakpoint */
/*-----------------------------------------------------------------*/
int cmdCondition (char *s, context *cctxt)
-{
+{
int bpnum ;
while (isspace(*s)) s++;
- if (!*s )
+ if (!*s )
{
fprintf(stdout,"Argument required (breakpoint number).\n");
return 0;
/* cmdCommands - set commands for breakpoint */
/*-----------------------------------------------------------------*/
int cmdCommands (char *s, context *cctxt)
-{
+{
int bpnum ;
char *cmds,*line;
while (isspace(*s)) s++;
-
- if (!*s )
+
+ if (!*s )
bpnum = getLastBreakptNumber();
else
bpnum = strtol(s,0,10);
{
int bpnum ;
while (isspace(*s)) s++;
-
+
if (!*s ) {
if (userBpPresent) {
char buffer[10];
fflush(stdout);
fgets(buffer,sizeof(buffer),stdin);
if (toupper(buffer[0]) == 'Y')
- deleteUSERbp(-1);
+ deleteUSERbp(-1);
}
return 0;
}
-
+
/* determine the break point number */
if (sscanf(s,"%d",&bpnum) == 1)
deleteUSERbp(bpnum);
if (0 /*STACK_EMPTY(callStack)*/)
fprintf(stdout,"The program is not being run.\n");
- else
+ else
{
doingSteps = 2;
- simGo(2);
+ simGo(2);
doingSteps = 0;
showfull = 1;
}
if ((func = STACK_PEEK(callStack))) {
if (srcMode == SRC_CMODE)
applyToSet (func->cfpoints,setStepEPBp,STEP,
- func->mod->c_name);
+ func->mod->c_name);
else
applyToSet (func->afpoints,setStepEPBp,STEP,
func->mod->asm_name);
/* set breakpoints at all function entry points
and all exepoints of this functions & for
all functions one up in the call stack */
-
+
/* all function entry points */
- applyToSet(functions,setStepBp);
-
+ applyToSet(functions,setStepBp);
+
if (srcMode == SRC_CMODE) {
/* for all execution points in this function */
applyToSet(cctxt->func->cfpoints,setStepEPBp,STEP,
cctxt->func->mod->c_name);
-
+
/* set a break point @ the current function's
exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
- stepBpCB, cctxt->func->mod->c_name,
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+ stepBpCB, cctxt->func->mod->c_name,
cctxt->func->exitline);
-
+
/* now break point @ callers execution points */
if ((func = STACK_PPEEK(callStack))) {
applyToSet (func->cfpoints,setStepEPBp,STEP,
- func->mod->c_name);
+ func->mod->c_name);
/* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, STEP ,
- stepBpCB, func->mod->c_name,
+ setBreakPoint (func->sym->eaddr, CODE, STEP ,
+ stepBpCB, func->mod->c_name,
func->exitline);
}
} else {
/* for all execution points in this function */
applyToSet(cctxt->func->afpoints,setStepEPBp,STEP,
cctxt->func->mod->asm_name);
-
+
/* set a break point @ the current function's
exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
- stepBpCB, cctxt->func->mod->asm_name,
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+ stepBpCB, cctxt->func->mod->asm_name,
cctxt->func->aexitline);
-
+
/* now break point @ callers execution points */
if ((func = STACK_PPEEK(callStack))) {
-
+
applyToSet (func->afpoints,setStepEPBp,STEP,
- func->mod->asm_name);
-
+ func->mod->asm_name);
+
/* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, STEP ,
- stepBpCB, func->mod->asm_name,
+ setBreakPoint (func->sym->eaddr, CODE, STEP ,
+ stepBpCB, func->mod->asm_name,
func->aexitline);
}
}
{
if (STACK_EMPTY(callStack))
fprintf(stdout,"The program is not being run.\n");
- else
+ else
{
doingSteps = 2;
- simGo(1);
+ simGo(1);
doingSteps = 0;
showfull = 1;
- }
+ }
return 0;
}
if ((func = STACK_PEEK(callStack))) {
if (srcMode == SRC_CMODE)
applyToSet (func->cfpoints,setStepEPBp,NEXT,
- func->mod->c_name);
+ func->mod->c_name);
else
applyToSet (func->afpoints,setStepEPBp,NEXT,
func->mod->asm_name);
cctxt->func->mod->c_name);
/* set a break point @ the current function's
exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
- nextBpCB, cctxt->func->mod->c_name,
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
+ nextBpCB, cctxt->func->mod->c_name,
cctxt->func->exitline);
-
- /* now break point @ callers execution points */
+
+ /* now break point @ callers execution points */
if ((func = STACK_PPEEK(callStack))) {
applyToSet (func->cfpoints,setNextEPBp,NEXT ,
- func->mod->c_name);
+ func->mod->c_name);
/* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, NEXT ,
- stepBpCB, func->mod->c_name,
+ setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+ stepBpCB, func->mod->c_name,
func->exitline);
}
} else {
cctxt->func->mod->asm_name);
/* set a break point @ the current function's
exit */
- setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
- nextBpCB, cctxt->func->mod->asm_name,
+ setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
+ nextBpCB, cctxt->func->mod->asm_name,
cctxt->func->aexitline);
-
- /* now break point @ callers execution points */
+
+ /* now break point @ callers execution points */
if ((func = STACK_PPEEK(callStack))) {
applyToSet (func->cfpoints,setNextEPBp,NEXT ,
- func->mod->asm_name);
+ func->mod->asm_name);
/* set bp @ callers exit point */
- setBreakPoint (func->sym->eaddr, CODE, NEXT ,
- stepBpCB, func->mod->asm_name,
+ setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+ stepBpCB, func->mod->asm_name,
func->aexitline);
}
}
}
doingSteps = 1;
- simGo(1);
+ simGo(1);
doingSteps = 0;
showfull = 1;
- }
+ }
return 0;
}
resetHitCount();
simGo(0);
} else {
-
+
fprintf(stdout,
"The program being debugged has been started already.\n");
fprintf(stdout,"Start it from the beginning? (y or n) ");
sy->name, sy->size, sy->level, sy->block);
printf(" isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
sy->isonstack, sy->isfunc, sy->offset, sy->addr);
- printf(" eaddr:%d, addr_type:%c, type:%x etype:%x\n",
+ printf(" eaddr:%d, addr_type:%c, type:%p etype:%p\n",
sy->eaddr, sy->addr_type, sy->type, sy->etype);
printf(" scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
sy->scopetype, sy->sname, sy->rname, sy->addrspace);
- printf(" next:%x\n", sy->next);
+ printf(" next:%p\n", sy->next);
}
++i;
sy = setNextItem(symbols);
if (f == NULL)
break;
if (our_verbose) {
- printf(" %d) sym:%x, fname:%s, modName:%s, mod:%x\n", i,
+ printf(" %d) sym:%p, fname:%s, modName:%s, mod:%p\n", i,
f->sym, f->sym->name, f->modName, f->mod);
printf(" entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
f->entryline, f->aentryline, f->exitline, f->aexitline);
- printf(" cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
+ printf(" cfpoints:%p, afpoints:%p, laddr:%x, lline:%d\n",
f->cfpoints, f->afpoints, f->laddr, f->lline);
}
else {
m->cfullname, m->afullname, m->name);
printf(" c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
m->c_name, m->asm_name, m->ncLines, m->nasmLines);
- printf(" cLines:%x, asmLines:%x\n",
+ printf(" cLines:%p, asmLines:%p\n",
m->cLines, m->asmLines);
}
if (our_verbose >= 2) {
{
int our_verbose = 0;
- printf("[context:%x] func:%x modName:%s addr:%x\n",
+ printf("[context:%p] func:%p modName:%s addr:%x\n",
ctxt, ctxt->func, ctxt->modName, ctxt->addr);
printf(" cline:%d asmline:%d block:%d level:%d\n",
- ctxt->cline, ctxt->asmline, ctxt->level);
+ ctxt->cline, ctxt->asmline, ctxt->block, ctxt->level);
- printf("[globals] currCtxt:%x, modules:%x, functions:%x symbols:%x\n",
+ printf("[globals] currCtxt:%p, modules:%p, functions:%p symbols:%p\n",
currCtxt, modules, functions, symbols);
- printf(" nStructs:%d, structs:%x, ssdirl:%s\n",
+ printf(" nStructs:%d, structs:%p, ssdirl:%s\n",
nStructs, structs, ssdirl);
/**************** modules *******************/
m->cfullname, m->afullname, m->name);
printf(" c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
m->c_name, m->asm_name, m->ncLines, m->nasmLines);
- printf(" cLines:%x, asmLines:%x\n",
+ printf(" cLines:%p, asmLines:%p\n",
m->cLines, m->asmLines);
i = 0;
if (m->cLines) {
if (f == NULL)
break;
if (our_verbose) {
- printf(" %d) sym:%x, modName:%s, mod:%x\n", i,
+ printf(" %d) sym:%p, modName:%s, mod:%p\n", i,
f->sym, f->modName, f->mod);
printf(" entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
f->entryline, f->aentryline, f->exitline, f->aexitline);
- printf(" cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
+ printf(" cfpoints:%p, afpoints:%p, laddr:%x, lline:%d\n",
f->cfpoints, f->afpoints, f->laddr, f->lline);
}
++i;
s->name, s->size, s->level, s->block);
printf(" isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
s->isonstack, s->isfunc, s->offset, s->addr);
- printf(" eaddr:%d, addr_type:%c, type:%x etype:%x\n",
+ printf(" eaddr:%d, addr_type:%c, type:%p etype:%p\n",
s->eaddr, s->addr_type, s->type, s->etype);
printf(" scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
s->scopetype, s->sname, s->rname, s->addrspace);
- printf(" next:%x\n", s->next);
+ printf(" next:%p\n", s->next);
}
++i;
s = setNextItem(symbols);
/*-----------------------------------------------------------------*/
static void infoRegisters( int all, context *ctxt)
{
- static unsigned int regaddrs[] = {0x81,0x82,0x83,0xb8,0xd0,0xe0,0xf0,0};
+ static int regaddrs[] = {0x81,0x82,0x83,0xb8,0xd0,0xe0,0xf0,0};
unsigned long val;
int i,j,*r;
- i = simGetValue (0xd0,'I',1);
+ i = simGetValue (0xd0,'I',1);
fprintf(stdout,"IP : 0x%04X RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
for ( j = 0; j < 8 ; j++ )
{
- val = simGetValue (j ,'R',1);
+ val = simGetValue (j,'R',1);
fprintf(stdout," 0x%02X",val);
}
fprintf(stdout,"\n");
cmdListSrc (s+4,cctxt);
return 0;
}
- if (strncmp(s,"source",6) == 0)
+ if (strncmp(s,"source",6) == 0)
{
module *m;
if ( s[6] == 's' )
fprintf(stdout,"Source files for which symbols have been read in:\n\n");
for (m = setFirstItem(modules); m ; m = setNextItem(modules))
{
- fprintf(stdout,"%s%s, %s",k ? ", ":"",m->cfullname, m->afullname);
+ fprintf(stdout,"%s%s, %s",k ? ", ":"",m->cfullname, m->afullname);
k = 1;
}
- fprintf(stdout,"\n");
+ fprintf(stdout,"\n");
}
else
{
- if (!cctxt || !cctxt->func || !cctxt->func->mod)
+ if (!cctxt || !cctxt->func || !cctxt->func->mod)
{
fprintf(stdout,"No source file loaded\n");
return 0;
}
return 0;
}
- if (strncmp(s,"functions",7) == 0)
+ if (strncmp(s,"functions",7) == 0)
{
function *f;
module *m = NULL;
}
/* info stack display call stack */
- if (strcmp(s,"all-registers") == 0)
+ if (strcmp(s,"all-registers") == 0)
{
infoRegisters(1,cctxt);
return 0;
/* cmdQuit - quit debugging */
/*-----------------------------------------------------------------*/
int cmdQuit (char *s, context *cctxt)
-{
+{
if (simactive)
closeSimulator();
return 1;
/* cmdListSrc - list src */
/*-----------------------------------------------------------------*/
int cmdListSrc (char *s, context *cctxt)
-{
+{
static int currline = 0;
int i =0 ;
int pline = 0;
while (*s && isspace(*s)) s++;
-
+
/* if the user has spcified line numer then the line number
can be of the following formats
LINE - just line number
else
list_mod = cctxt->func->mod;
pline = strtol(s,&s,10) - 1;
- if (s && (s = strchr(s,',')))
+ if (s && (s = strchr(s,',')))
{
/* LINE,LASTLINE */
- llines = strtol(s+1,0,10);
+ llines = strtol(s+1,0,10);
if ( llines > 0 )
llines -= pline+1;
else
}
else {
char *bp;
-
+
/* if ':' present then FILE:LINE || FILE:FUNCTION */
if ((bp = strchr(s,':'))) {
*bp = '\0';
}
}
pline = strtol(bp,&bp,10) - 1;
- if (bp && (bp = strchr(bp,',')))
+ if (bp && (bp = strchr(bp,',')))
{
/* FILE:LINE,LASTLINE */
- llines = strtol(bp+1,0,10);
+ llines = strtol(bp+1,0,10);
if ( llines > 0 )
llines -= pline+1;
else
}
else {
/* FUNCTION */
- if (*s == '\'')
+ if (*s == '\'')
{
/* 'FUNCTION' */
s++ ;
- if ((bp = strrchr(s,'\'')))
+ if ((bp = strrchr(s,'\'')))
{
*bp = '\0';
}
-
+
}
if (!applyToSet(functions,funcWithName,s,&func)) {
- fprintf(stderr,"Function \"%s\" not defined.\n",s);
+ fprintf(stderr,"Function \"%s\" not defined.\n",s);
return 0;
}
else {
list_mod = func->mod;
if (srcMode == SRC_CMODE) {
pline = func->entryline;
- llines = func->exitline - func->entryline + 1;
+ llines = func->exitline - func->entryline + 1;
} else {
pline = func->aentryline;
- llines = func->aexitline - func->aentryline + 1;
+ llines = func->aexitline - func->aentryline + 1;
}
}
}
return 0;
if ( infomode )
{
- int firstaddr , lastaddr ;
+ unsigned firstaddr , lastaddr ;
if ( pline >= list_mod->ncLines )
pline = cctxt->cline;
firstaddr = lastaddr = list_mod->cLines[pline]->addr;
if (!func && cctxt && cctxt->func )
func = cctxt->func;
- fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x <%s+%d>",
+ fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x <%s+%d>",
pline+1,
list_mod->c_name, lastaddr,
func ? func->sym->name : "?",
break;
}
}
- fprintf(stdout," and ends at 0x%08x <%s+%d>.\n",
+ fprintf(stdout," and ends at 0x%08x <%s+%d>.\n",
lastaddr,
func ? func->sym->name : "?",
func ? lastaddr -func->sym->addr : 0);
static unsigned long getValBasic(symbol *sym, link *type, char *val)
{
char *s;
- union
- {
- float f;
+ union
+ {
+ float f;
unsigned long val;
long sval;
struct {
unsigned char b[4];
}v;
- if (IS_FLOAT(type))
- v.f = strtod(val,NULL);
+ if (IS_FLOAT(type))
+ v.f = strtod(val,NULL);
else
if (IS_PTR(type))
v.val = strtol(val,NULL,0);
else
{
- if (IS_INTEGRAL(type))
+ if (IS_INTEGRAL(type))
{
link *etype;
if ( type->next )
{
if ( s[1] == '\\' )
v.b[0] = strtol(s+2,NULL,8);
- else
+ else
v.b[0] = s[1];
}
else
}
}
else
- if (IS_INT(etype))
+ if (IS_INT(etype))
if (IS_LONG(etype))
v.val = strtol(val,NULL,0);
else
v.i.lo = strtol(val,NULL,0);
else
v.val = strtol(val,NULL,0);
- }
+ }
else
v.val = strtol(val,NULL,0);
}
/*-----------------------------------------------------------------*/
/* printFmtInteger - print value in bin,oct,dez or hex */
/*-----------------------------------------------------------------*/
-static void printFmtInteger(char *deffmt,int fmt, long val,
+static void printFmtInteger(char *deffmt,int fmt, long val,
int sign, int size)
{
- static char digits[] =
+ static char digits[] =
{
'0' , '1' , '2' , '3' , '4' , '5' ,
'6' , '7' , '8' , '9' , 'a' , 'b' ,
- 'c' , 'd' , 'e' , 'f' , 'g' , 'h'
+ 'c' , 'd' , 'e' , 'f' , 'g' , 'h'
};
static int radixOfFormat[] = { 0 , 2, 8 ,10, 16 };
static int olenOfSize[] = { 0 , 3, 6 , 8, 11 };
val = -val;
buf[39] = '\0';
- while (val <= -radix)
+ while (val <= -radix)
{
buf[charPos--] = digits[-(val % radix)];
val = val / radix;
while (charPos > 39 - radix )
{
buf[--charPos] = '0';
- }
+ }
switch ( fmt )
{
case FMT_OCT:
static void printValBasic(symbol *sym, link *type,
char mem, unsigned addr,int size, int fmt)
{
- union {
- float f;
- unsigned long val;
- long sval;
- struct {
- unsigned short lo;
- unsigned short hi;
- } i;
- unsigned char b[4];
- }v;
union {
- unsigned char b[4];
- }v1;
-
+ float f;
+ unsigned long val;
+ long sval;
+ struct {
+ unsigned short lo;
+ unsigned short hi;
+ } i;
+ unsigned char b[4];
+ }v;
+
v.val = simGetValue(addr,mem,size);
/* if this a floating point number then */
- if (IS_FLOAT(type))
- fprintf(stdout,"%f",v.f);
+ if (IS_FLOAT(type))
+ fprintf(stdout,"%f",v.f);
else
if (IS_PTR(type))
fprintf(stdout,"0x%*x",size<<1,v.val);
else
- if (IS_INTEGRAL(type))
+ if (IS_INTEGRAL(type))
{
link *etype;
if ( type->next )
else
etype = type;
if (IS_CHAR(etype))
- {
+ {
if ( isprint(v.val))
printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
fmt,(long)v.val,0,size);
}
else
{
- if (IS_INT(etype))
+ if (IS_INT(etype))
if (IS_LONG(etype))
if (SPEC_USIGN(etype))
printFmtInteger("%u",fmt,(long)v.val,0,size);
}
}
} else
- fprintf(stdout,"0x%0*x",size<<1,v.val);
+ fprintf(stdout,"0x%0*x",size<<1,v.val);
}
/*-----------------------------------------------------------------*/
{
link *elem_type = type->next;
int i;
-
+
fprintf(stdout,"{");
- for (i = 0 ; i < DCL_ELEM(type) ; i++) {
+ for (i = 0 ; i < DCL_ELEM(type) ; i++) {
if (IS_AGGREGATE(elem_type)) {
- printValAggregates(sym,elem_type,space,addr,fmt);
+ printValAggregates(sym,elem_type,space,addr,fmt);
} else {
printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
}
fprintf(stdout,",");
}
- fprintf(stdout,"}");
+ fprintf(stdout,"}");
}
/*-----------------------------------------------------------------*/
/* printStructValue - prints structures elements */
/*-----------------------------------------------------------------*/
-static void printStructValue (symbol *sym, link *type,
- char space, unsigned int addr, int fmt)
+static void printStructValue (symbol *sym, link *type,
+ char space, unsigned int addr, int fmt)
{
symbol *fields = SPEC_STRUCT(type)->fields;
int first = 1;
return ;
}
- if (IS_STRUCT(type)) {
- printStructValue(sym, type, space, addr, fmt);
- return;
- }
+ if (IS_STRUCT(type)) {
+ printStructValue(sym, type, space, addr, fmt);
+ return;
+ }
}
/*-----------------------------------------------------------------*/
/* printOrSetSymValue - print or set value of a symbol */
/*-----------------------------------------------------------------*/
-static int printOrSetSymValue (symbol *sym, context *cctxt,
- int flg, int dnum, int fmt, char *rs,
+static int printOrSetSymValue (symbol *sym, context *cctxt,
+ int flg, int dnum, int fmt, char *rs,
char *val, char cmp )
{
static char fmtChar[] = " todx ";
static int stack = 1;
symbol *fields;
link *type;
- unsigned int addr;
+ unsigned int addr;
int size, n;
char *s, *s2;
char save_ch, save_ch2;
/* if it is on stack then compute address & fall thru */
- if (sym->isonstack)
+ if (sym->isonstack)
{
symbol *bp = symLookup("bp",cctxt);
- if (!bp)
+ if (!bp)
{
fprintf(stdout,"cannot determine stack frame\n");
return 1;
}
sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
- + sym->offset ;
+ + sym->offset ;
}
-
+
/* get the value from the simulator and
print it */
switch (flg)
{
- case 0:
+ case 0:
default:
break;
- case 1:
+ case 1:
fprintf(stdout,"$%d = ",stack++);
break;
- case 2:
+ case 2:
fprintf(stdout,"%d: ", dnum);
if ( fmt != FMT_NON )
fprintf(stdout,"/%c ",fmtChar[fmt]);
if ( ! fields )
{
fprintf(stdout,"Unknown variable \"%s\" for index.\n", s);
- return 1;
+ return 1;
}
/* arrays & structures first */
if (! IS_INTEGRAL(fields->type))
{
fprintf(stdout,"Wrong type of variable \"%s\" for index \n", s);
- return 1;
+ return 1;
}
n = simGetValue(fields->addr,fields->addrspace,getSize(fields->type));
}
if ( n < 0 || n >= DCL_ELEM(type))
{
fprintf(stdout,"Wrong index %d.\n", n);
- return 1;
+ return 1;
}
type = type->next;
size = getSize(type);
save_ch = *rs;
if ( *rs )
*rs = '\0';
- for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next)
+ for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next)
{
if (!(strcmp(s,fields->name)))
break;
if ( ! fields )
{
fprintf(stdout,"Unknown field \"%s\" of structure\n", s);
- return 1;
+ return 1;
}
type = fields->type;
size = getSize(type);
return 1;
}
else
- {
+ {
if ( val )
{
unsigned long newval;
{
/* Symbol with address of IP */
if ( cctxt ) cctxt->addr = newval;
- simSetPC(cctxt->addr);
+ simSetPC(cctxt->addr);
}
else
- simSetValue(addr,sym->addrspace,size,newval);
+ simSetValue(addr,sym->addrspace,size,newval);
return 1;
}
}
{
symbol *field = sdef->fields ;
int i = 0 ;
-
+
while (field) {
i += field->offset;
field = field->next;
printTypeInfo (p->next);
fprintf(stdout,"[%d]",DCL_ELEM(p));
break;
-
+
case IPOINTER:
case PPOINTER:
case POINTER:
printTypeInfo( p->next);
fprintf(stdout,"(_code *)");
break;
-
+
case GPOINTER:
printTypeInfo( p->next);
fprintf(stdout,"(_generic *)");
- break;
+ break;
}
} else {
switch (SPEC_NOUN(p)) { /* depending on the specifier type */
case V_INT:
- (IS_LONG(p) ? fputs("long ",stdout) :
- ( IS_SHORT(p) ? fputs("short ",stdout) :
+ (IS_LONG(p) ? fputs("long ",stdout) :
+ ( IS_SHORT(p) ? fputs("short ",stdout) :
fputs("int ",stdout))) ;
break;
case V_FLOAT:
break;
case V_BIT:
- fprintf(stdout,": %d" ,SPEC_BLEN(p));
+ fprintf(stdout,": %d" ,SPEC_BLEN(p));
break;
}
}
/* conditionIsTrue - compare variable with constant value */
/*-----------------------------------------------------------------*/
int conditionIsTrue( char *s, context *cctxt)
-{
+{
symbol *sym = NULL;
int fmt;
char *rs, *dup, cmp_char;
fmt = 1;
else
{
- cmp_char = *s;
+ cmp_char = *s;
*s++ = '\0';
if ( *s == '=' )
{
- /* if <= or >= an other char is used
- * == or != not checked in switch
+ /* if <= or >= an other char is used
+ * == or != not checked in switch
*/
switch( cmp_char )
{
/* cmdPrint - print value of variable */
/*-----------------------------------------------------------------*/
int cmdPrint (char *s, context *cctxt)
-{
+{
symbol *sym ;
int fmt;
char *rs;
if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
return 0;
- if ( sym )
+ if ( sym )
{
printOrSetSymValue(sym,cctxt,1,0,fmt,rs,NULL,'\0');
- }
+ }
return 0;
}
/* cmdOutput - print value of variable without number and newline */
/*-----------------------------------------------------------------*/
int cmdOutput (char *s, context *cctxt)
-{
+{
symbol *sym ;
int fmt;
char *rs;
if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
return 0;
- if ( sym )
+ if ( sym )
{
printOrSetSymValue(sym,cctxt,0,0,fmt,rs,NULL,'\0');
- }
+ }
return 0;
}
return;
for (dsym = setFirstItem(dispsymbols);
dsym ;
- dsym = setNextItem(dispsymbols))
+ dsym = setNextItem(dispsymbols))
{
if ( (sym = symLookup(dsym->name,cctxt)))
printOrSetSymValue(sym,cctxt,2,dsym->dnum,dsym->fmt,
/* cmdDisplay - display value of variable */
/*-----------------------------------------------------------------*/
int cmdDisplay (char *s, context *cctxt)
-{
+{
static int dnum = 1;
symbol *sym ;
int fmt;
return 0;
}
- if ( sym )
+ if ( sym )
{
dsymbol *dsym = (dsymbol *)Safe_calloc(1,sizeof(dsymbol));
dsym->dnum = dnum++ ;
/* cmdUnDisplay - undisplay value of variable */
/*-----------------------------------------------------------------*/
int cmdUnDisplay (char *s, context *cctxt)
-{
+{
dsymbol *dsym;
int dnum;
dsym = setNextItem(dispsymbols))
{
Safe_free(dsym->rs);
- Safe_free(dsym);
+ Safe_free(dsym);
}
deleteSet(&dispsymbols);
return 0;
while ( s && *s )
{
dnum = strtol(s,&s,10);
- if (applyToSetFTrue(dispsymbols,dsymWithNumber,dnum,&dsym))
+ if (applyToSetFTrue(dispsymbols,dsymWithNumber,dnum,&dsym))
{
deleteSetItem(&dispsymbols,dsym);
Safe_free(dsym->rs);
- Safe_free(dsym);
- }
+ Safe_free(dsym);
+ }
else
{
- fprintf(stdout,"Arguments must be display numbers.\n");
+ fprintf(stdout,"Arguments must be display numbers.\n");
}
}
return 0;
/* cmdPrintType - print type of a variable */
/*-----------------------------------------------------------------*/
int cmdPrintType (char *s, context *cctxt)
-{
+{
symbol *sym ;
char *bp = s+strlen(s) -1;
"No symbol \"%s\" in current context.\n",
s);
}
- return 0;
+ return 0;
}
/*-----------------------------------------------------------------*/
/* cmdClrUserBp - clear user break point */
/*-----------------------------------------------------------------*/
int cmdClrUserBp (char *s, context *cctxt)
-{
- char *bp ;
+{
+ char *bp ;
function *func = NULL;
-
+
/* clear break point location specification can be of the following
forms
a) <nothing> - break point at current location
/* white space skip */
while (*s && isspace(*s)) s++;
-
+
/* null terminate it after stripping trailing blanks*/
bp = s + strlen(s);
while (bp != s && isspace(*bp)) bp--;
if (! *s ) {
/* if current context is known */
- if (cctxt->func)
+ if (cctxt->func)
/* clear the break point @ current location */
clearUSERbp (cctxt->addr);
else
fprintf(stderr,"No default breakpoint address now.\n");
-
+
goto ret ;
}
/* if current context not present then we must get the module
which has main & set the break point @ line number provided
- of that module : if current context known then set the bp
- at the line number given for the current module
+ of that module : if current context known then set the bp
+ at the line number given for the current module
*/
if (cctxt->func) {
if (!cctxt->func->mod) {
if (!applyToSet(functions,funcWithName,"main"))
fprintf(stderr,"Function \"main\" not defined.\n");
- else
+ else
clearBPatModLine(func->mod,line);
- } else
- clearBPatModLine(cctxt->func->mod,line);
+ } else
+ clearBPatModLine(cctxt->func->mod,line);
}
-
+
goto ret;
}
if ((bp = strchr(s,':'))) {
-
+
module *mod = NULL;
*bp = '\0';
-
+
if (!applyToSet(modules,moduleWithCName,s,&mod)) {
fprintf (stderr,"No source file named %s.\n",s);
goto ret;
}
/* case c) filename:lineno */
- if (isdigit(*(bp +1))) {
-
- clearBPatModLine (mod,atoi(bp+1));
+ if (isdigit(*(bp +1))) {
+
+ clearBPatModLine (mod,atoi(bp+1));
goto ret;
-
+
}
/* case d) filename:function */
- if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
- fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
+ if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
+ fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
else
clearBPatModLine (mod,func->entryline);
-
+
goto ret;
}
-
+
/* case e) function */
if (!applyToSet(functions,funcWithName,s,&func))
- fprintf(stderr,"Function \"%s\" not defined.\n",s);
+ fprintf(stderr,"Function \"%s\" not defined.\n",s);
else
clearBPatModLine(func->mod,func->entryline);
- ret:
- return 0;
+ ret:
+ return 0;
}
/*-----------------------------------------------------------------*/
/* cmdSimulator - send command to simulator */
/*-----------------------------------------------------------------*/
int cmdSimulator (char *s, context *cctxt)
-{
+{
char tmpstr[82];
if (strlen(s) > 80) {
void setMainContext()
{
function *func = NULL;
- currentFrame = 0;
+ currentFrame = 0;
if (!applyToSet(functions,funcWithName,"_main",&func) &&
!applyToSet(functions,funcWithName,"main",&func))
return;
}
return NULL;
}
-
+
static void printFrame()
{
int i;
/* cmdFrame - Frame command */
/*-----------------------------------------------------------------*/
int cmdFrame (char *s, context *cctxt)
-{
+{
function *func = NULL;
- int i, framenr = 0;
+ int framenr = 0;
while (isspace(*s)) s++;
if ( *s )
}
if (srcMode == SRC_CMODE) {
- setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
- stepBpCB, ctxt->func->mod->c_name,
+ setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
+ stepBpCB, ctxt->func->mod->c_name,
ctxt->func->exitline);
} else {
- setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
- stepBpCB, ctxt->func->mod->asm_name,
+ setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
+ stepBpCB, ctxt->func->mod->asm_name,
ctxt->func->aexitline);
}
simGo(-1);
showfull = 1;
return 0;
-
+
}
fputs(copying,stdout);
return 0;
}
-
+
if (strcmp(s,"warranty") == 0) {
fputs(warranty,stdout);
return 0;
AOP_TYPE(x) == AOP_R0))
#define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY || \
- AOP_TYPE(x) == AOP_DPTR || AOP(x)->paged))
+ AOP_TYPE(x) == AOP_DPTR || \
+ AOP(x)->paged))
#define AOP_INPREG(x) (x && (x->type == AOP_REG && \
(x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) )))
-
#define SYM_BP(sym) (SPEC_OCLS (sym->etype)->paged ? "_bpx" : "_bp")
#define R0INB _G.bu.bs.r0InB
"b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7"
};
-extern int mcs51_ptrRegReq;
-extern int mcs51_nRegs;
extern FILE *codeOutFile;
static void saveRBank (int, iCode *, bool);
if (inst && *inst)
{
if (fmt && *fmt)
+ {
SNPRINTF (lb, sizeof(lb), "%s\t", inst);
+ }
else
+ {
SNPRINTF (lb, sizeof(lb), "%s", inst);
+ }
+
tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap);
}
else
+ {
tvsprintf (lb, sizeof(lb), fmt, ap);
+ }
while (isspace ((unsigned char)*lbp))
+ {
lbp++;
+ }
if (lbp && *lbp)
+ {
lineCurr = (lineCurr ?
connectLine (lineCurr, newLineNode (lb)) :
(lineHead = newLineNode (lb)));
+ }
+
lineCurr->isInline = _G.inLine;
lineCurr->isDebug = _G.debugLine;
lineCurr->ic = _G.current_iCode;
if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4))
return;
- emitcode("mov","a,%s", x);
+ emitcode("mov", "a,%s", x);
}
/*-----------------------------------------------------------------*/
{
asmop *aop;
memmap *space;
+ bool accuse = leftRightUseAcc (ic) || _G.accInUse;
wassertl (ic != NULL, "Got a null iCode");
wassertl (sym != NULL, "Got a null symbol");
/* if already has one */
if (sym->aop)
{
- sym->aop->allocated++;
+ sym->aop->allocated++;
return sym->aop;
}
the pointer register */
if (aop->type != AOP_STK)
{
-
if (sym->onStack)
{
char offset = ((sym->stack < 0) ?
((char) (sym->stack - _G.nRegsSaved)) :
((char) sym->stack)) & 0xff;
- if ((offset >= -3) && (offset <= 3))
+ if ((abs(offset) <= 3) ||
+ (accuse && (abs(offset) <= 7)))
{
emitcode ("mov", "%s,%s",
aop->aopu.aop_ptr->name, SYM_BP (sym));
}
else
{
- if (_G.accInUse || leftRightUseAcc (ic))
+ if (accuse)
emitcode ("push", "acc");
emitcode ("mov", "a,%s", SYM_BP (sym));
emitcode ("add", "a,#0x%02x", offset);
- emitcode ("mov", "%s,a",
- aop->aopu.aop_ptr->name);
- if (_G.accInUse || leftRightUseAcc (ic))
+ emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
+ if (accuse)
emitcode ("pop", "acc");
}
}
else
- emitcode ("mov", "%s,#%s",
- aop->aopu.aop_ptr->name,
- sym->rname);
+ {
+ emitcode ("mov", "%s,#%s",
+ aop->aopu.aop_ptr->name,
+ sym->rname);
+ }
aop->paged = space->paged;
}
else
if (IS_FUNC (sym->type))
{
sym->aop = aop = newAsmop (AOP_IMMD);
- aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname);
+ aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);
aop->size = getSize (sym->type);
return aop;
}
}
if (val)
- sprintf (buffer, "(%s %c 0x%04x)",
- OP_SYMBOL (IC_LEFT (ic))->rname,
- val >= 0 ? '+' : '-',
- abs (val) & 0xffff);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s %c 0x%04x)",
+ OP_SYMBOL (IC_LEFT (ic))->rname,
+ val >= 0 ? '+' : '-',
+ abs (val) & 0xffff);
+ }
else
- strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
+ {
+ strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
+ }
- aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+ aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer);
/* set immd2 field if required */
- if (aop->aopu.aop_immd.from_cast_remat) {
- sprintf(buffer,"#0x%02x",ptr_type);
- aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
- strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
- }
+ if (aop->aopu.aop_immd.from_cast_remat)
+ {
+ sprintf(buffer,"#0x%02x",ptr_type);
+ aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer);
+ }
return aop;
}
/* if already has a asmop then continue */
if (op->aop)
{
- op->aop->allocated++;
+ op->aop->allocated++;
return;
}
if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
{
op->aop = OP_SYMBOL (op)->aop;
- op->aop->allocated++;
+ op->aop->allocated++;
return;
}
_G.r0Pushed--;
}
}
+ break;
}
dealloc:
}
}
-/*-----------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop */
-/*-----------------------------------------------------------------*/
+/*-------------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop */
+/*-------------------------------------------------------------------*/
static char *
aopGet (operand * oper, int offset, bool bit16, bool dname)
{
- char *s = buffer;
- char *rs;
asmop * aop = AOP (oper);
/* offset is greater than
emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
return (dname ? "acc" : "a");
}
- sprintf (s, "@%s", aop->aopu.aop_ptr->name);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name);
+ return Safe_strdup(buffer);
+
case AOP_DPTR:
if (aop->code && aop->coff==0 && offset>=1) {
}
return (dname ? "acc" : "a");
-
case AOP_IMMD:
- if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) {
- sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2);
- } else if (bit16)
- sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1);
+ if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1)))
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "%s",aop->aopu.aop_immd.aop_immd2);
+ }
+ else if (bit16)
+ {
+ SNPRINTF(buffer, sizeof(buffer),
+ "#%s", aop->aopu.aop_immd.aop_immd1);
+ }
else if (offset)
- sprintf (s, "#(%s >> %d)",
- aop->aopu.aop_immd.aop_immd1,
- offset * 8);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#(%s >> %d)",
+ aop->aopu.aop_immd.aop_immd1,
+ offset * 8);
+ }
else
- sprintf (s, "#%s",
- aop->aopu.aop_immd.aop_immd1);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "#%s", aop->aopu.aop_immd.aop_immd1);
+ }
+ return Safe_strdup(buffer);
case AOP_DIR:
if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)
- sprintf (s, "(%s >> %d)",
- aop->aopu.aop_dir, offset * 8);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s >> %d)",
+ aop->aopu.aop_dir, offset * 8);
+ }
else if (offset)
- sprintf (s, "(%s + %d)",
- aop->aopu.aop_dir,
- offset);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s + %d)",
+ aop->aopu.aop_dir,
+ offset);
+ }
else
- sprintf (s, "%s", aop->aopu.aop_dir);
- rs = Safe_calloc (1, strlen (s) + 1);
- strcpy (rs, s);
- return rs;
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "%s", aop->aopu.aop_dir);
+ }
+
+ return Safe_strdup(buffer);
case AOP_REG:
if (dname)
/* aopPut - puts a string for a aop and indicates if acc is in use */
/*-----------------------------------------------------------------*/
static bool
-aopPut (operand * result, const char *s, int offset, bool bvolatile)
+aopPut (operand * result, const char *s, int offset)
{
- char *d = buffer;
+ bool bvolatile = isOperandVolatile (result, FALSE);
bool accuse = FALSE;
asmop * aop = AOP (result);
case AOP_DIR:
if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset)
- sprintf (d, "(%s >> %d)", aop->aopu.aop_dir, offset * 8);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s >> %d)",
+ aop->aopu.aop_dir, offset * 8);
+ }
else if (offset)
- sprintf (d, "(%s + %d)", aop->aopu.aop_dir, offset);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "(%s + %d)",
+ aop->aopu.aop_dir, offset);
+ }
else
- sprintf (d, "%s", aop->aopu.aop_dir);
+ {
+ SNPRINTF (buffer, sizeof(buffer),
+ "%s", aop->aopu.aop_dir);
+ }
- if (strcmp (d, s) || bvolatile)
- emitcode ("mov", "%s,%s", d, s);
- if (!strcmp (d, "acc"))
+ if (strcmp (buffer, s) || bvolatile)
+ {
+ emitcode ("mov", "%s,%s", buffer, s);
+ }
+ if (!strcmp (buffer, "acc"))
+ {
accuse = TRUE;
-
+ }
break;
case AOP_REG:
strcmp (s, "r5") == 0 ||
strcmp (s, "r6") == 0 ||
strcmp (s, "r7") == 0)
- emitcode ("mov", "%s,%s",
- aop->aopu.aop_reg[offset]->dname, s);
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_reg[offset]->dname, s);
+ }
else
- emitcode ("mov", "%s,%s",
- aop->aopu.aop_reg[offset]->name, s);
+ {
+ emitcode ("mov", "%s,%s",
+ aop->aopu.aop_reg[offset]->name, s);
+ }
}
break;
strcmp (s, "r7") == 0)
{
char buffer[10];
- sprintf (buffer, "a%s", s);
+ SNPRINTF (buffer, sizeof(buffer), "a%s", s);
emitcode ("mov", "@%s,%s",
aop->aopu.aop_ptr->name, buffer);
}
else
- emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
-
+ {
+ emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
+ }
break;
case AOP_STK:
case AOP_STR:
aop->coff = offset;
- if (strcmp (aop->aopu.aop_str[offset], s) ||
- bvolatile)
+ if (strcmp (aop->aopu.aop_str[offset], s) || bvolatile)
emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
break;
case AOP_ACC:
accuse = TRUE;
aop->coff = offset;
- if (!offset && (strcmp (s, "acc") == 0) &&
- !bvolatile)
+ if (!offset && (strcmp (s, "acc") == 0) && !bvolatile)
break;
- if (strcmp (aop->aopu.aop_str[offset], s) &&
- !bvolatile)
+ if (strcmp (aop->aopu.aop_str[offset], s) && !bvolatile)
emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
break;
static void
reAdjustPreg (asmop * aop)
{
- if ((aop->coff==0) || aop->size <= 1)
+ if ((aop->coff==0) || (aop->size <= 1))
return;
switch (aop->type)
size = getDataSize (result);
if (size)
{
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
size--;
offset = 1;
/* unsigned or positive */
while (size--)
{
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
}
}
{
/* if the result is bit */
if (AOP_TYPE (result) == AOP_CRY)
- aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+ {
+ aopPut (result, "c", 0);
+ }
else
{
emitcode ("clr", "a");
{
symbol *tlbl;
- D(emitcode ("; genNot",""));
+ D (emitcode (";", "genNot"));
/* assign asmOps to operand & result */
aopOp (IC_LEFT (ic), ic, FALSE);
char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
MOVA (l);
emitcode ("cpl", "a");
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
int size, offset = 0;
char *l;
- D(emitcode ("; genUminusFloat",""));
+ D (emitcode (";", "genUminusFloat"));
/* for this we just copy and then flip the bit */
{
aopPut (result,
aopGet (op, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
offset++;
}
l = aopGet (op, offset, FALSE, FALSE);
-
MOVA (l);
emitcode ("cpl", "acc.7");
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
/*-----------------------------------------------------------------*/
genUminus (iCode * ic)
{
int offset, size;
- sym_link *optype, *rtype;
+ sym_link *optype;
-
- D(emitcode ("; genUminus",""));
+ D (emitcode (";", "genUminus"));
/* assign asmops */
aopOp (IC_LEFT (ic), ic, FALSE);
}
optype = operandType (IC_LEFT (ic));
- rtype = operandType (IC_RESULT (ic));
/* if float then do float stuff */
if (IS_FLOAT (optype))
/* otherwise subtract from zero */
size = AOP_SIZE (IC_LEFT (ic));
offset = 0;
- //CLRC ;
while (size--)
{
char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
emitcode ("clr", "a");
emitcode ("subb", "a,%s", l);
}
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
/* if any remaining bytes in the result */
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
release:
ic->regsSaved = 1;
if (options.useXstack)
{
+ bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+ int nBits = bitVectnBitsOn (rsavebits);
int count = bitVectnBitsOn (rsave);
+ if (nBits != 0)
+ {
+ count = count - nBits + 1;
+ /* remove all but the first bits as they are pushed all at once */
+ rsave = bitVectCplAnd (rsave, rsavebits);
+ rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+ }
+
if (count == 1)
{
regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
}
else if (count != 0)
{
- bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
- int nBits = bitVectnBitsOn (rsavebits);
-
- if (nBits != 0)
- {
- count = count - nBits + 1;
- /* remove all but the first bits as they are pushed all at once */
- rsave = bitVectCplAnd (rsave, rsavebits);
- rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
- }
-
if (bitVectBitValue (rsave, R0_IDX))
{
emitcode ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname);
if (options.useXstack)
{
+ bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+ int nBits = bitVectnBitsOn (rsavebits);
int count = bitVectnBitsOn (rsave);
+ if (nBits != 0)
+ {
+ count = count - nBits + 1;
+ /* remove all but the first bits as they are popped all at once */
+ rsave = bitVectCplAnd (rsave, rsavebits);
+ rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+ }
+
if (count == 1)
{
regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
}
else if (count != 0)
{
- bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
- int nBits = bitVectnBitsOn (rsavebits);
-
- if (nBits != 0)
- {
- count = count - nBits + 1;
- /* remove all but the first bits as they are popped all at once */
- rsave = bitVectCplAnd (rsave, rsavebits);
- rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
- }
-
emitcode ("mov", "r0,%s", spname);
for (i = mcs51_nRegs; i >= 0; i--)
{
{
if ((offset == 3) && pushedA)
emitcode ("pop", "acc");
- accuse |= aopPut (oper, fReturn[offset], offset, isOperandVolatile (oper, FALSE));
+ accuse |= aopPut (oper, fReturn[offset], offset);
offset++;
}
return accuse;
regs *r;
int size, offset = 0;
- D(emitcode ("; genXpush",""));
+ D (emitcode (";", "genXpush"));
aopOp (IC_LEFT (ic), ic, FALSE);
r = getFreePtr (ic, &aop, FALSE);
char *l;
char *prev = "";
- D(emitcode ("; genIpush",""));
+ D (emitcode (";", "genIpush"));
/* if this is not a parm push : ie. it is spill push
and spill push is always done on the local stack */
{
l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG &&
- AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
- strcmp (l, "a"))
+ AOP_TYPE (IC_LEFT (ic)) != AOP_DIR)
{
if (strcmp (l, prev) || *l == '@')
MOVA (l);
{
int size, offset;
- D(emitcode ("; genIpop",""));
+ D (emitcode (";", "genIpop"));
/* if the temp was not pushed then */
if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
size = AOP_SIZE (IC_LEFT (ic));
offset = (size - 1);
while (size--)
- emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
- FALSE, TRUE));
+ {
+ emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
+ FALSE, TRUE));
+ }
freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
}
{
emitcode ("mov", "a,psw");
emitcode ("movx", "@%s,a", r->name);
-
}
else
{
bool resultInF0 = FALSE;
bool assignResultGenerated = FALSE;
- D(emitcode("; genCall",""));
+ D (emitcode (";", "genCall"));
dtype = operandType (IC_LEFT (ic));
etype = getSpec(dtype);
} else {
genSend(_G.sendSet);
}
-
_G.sendSet = NULL;
}
}
/*-----------------------------------------------------------------*/
-/* -10l - generates a call by pointer statement */
+/* genPcall - generates a call by pointer statement */
/*-----------------------------------------------------------------*/
static void
genPcall (iCode * ic)
bool swapBanks = FALSE;
bool resultInF0 = FALSE;
- D(emitcode("; genPCall",""));
+ D (emitcode (";", "genPcall"));
dtype = operandType (IC_LEFT (ic))->next;
etype = getSpec(dtype);
save acc, b, dpl, dph */
if (IFFUNC_ISISR (sym->type))
{
-
if (!inExcludeList ("acc"))
emitcode ("push", "acc");
if (!inExcludeList ("b"))
registers :-) */
if (!FUNC_REGBANK (sym->type))
{
+ int i;
/* if this function does not call any other
function then we can be economical and
save only those registers that are used */
if (!IFFUNC_HASFCALL(sym->type))
{
- int i;
-
/* if any registers used */
if (sym->regsUsed)
{
}
else
{
-
/* this function has a function call. We cannot
- determines register usage so we will have to push the
+ determine register usage so we will have to push the
entire bank */
saveRBank (0, ic, FALSE);
if (options.parms_in_bank1) {
- int i;
for (i=0; i < 8 ; i++ ) {
emitcode ("push","%s",rb1regs[i]);
}
registers :-) */
if (!FUNC_REGBANK (sym->type))
{
+ int i;
/* if this function does not call any other
function then we can be economical and
save only those registers that are used */
if (!IFFUNC_HASFCALL(sym->type))
{
- int i;
-
/* if any registers used */
if (sym->regsUsed)
{
else
{
if (options.parms_in_bank1) {
- int i;
for (i = 7 ; i >= 0 ; i-- ) {
emitcode ("pop","%s",rb1regs[i]);
}
{
int size, offset = 0, pushed = 0;
- D(emitcode ("; genRet",""));
+ D (emitcode (";", "genRet"));
/* if we have no return value then
just generate the "ret" */
aopOp (IC_LEFT (ic), ic, FALSE);
size = AOP_SIZE (IC_LEFT (ic));
-
if (IS_BIT(_G.currentFunc->etype))
{
movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
if ((AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) && (icount > 5))
return FALSE;
- aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0, FALSE);
- aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1, FALSE);
+ aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0);
+ aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1);
while (icount--)
emitcode ("inc", "dptr");
{
MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
- aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0);
}
else
{
/* if the result is a bit */
if (AOP_TYPE (result) == AOP_CRY)
{
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
}
else
{
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
aopPut (IC_RESULT (ic),
aopGet (IC_LEFT (ic)), 2, FALSE, FALSE),
- 2,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ 2);
if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
AOP_SIZE (IC_RIGHT (ic)) == 3 &&
!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
aopPut (IC_RESULT (ic),
aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),
- 2,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ 2);
if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
AOP_SIZE (IC_LEFT (ic)) < 3 &&
{
char buffer[5];
sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
- aopPut (IC_RESULT (ic), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), buffer, 2);
}
}
#else
{
aopPut (IC_RESULT (ic),
aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ GPTRSIZE - 1);
}
if (opIsGptr (IC_RESULT (ic)) &&
{
aopPut (IC_RESULT (ic),
aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),
- GPTRSIZE - 1,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ GPTRSIZE - 1);
}
if (opIsGptr (IC_RESULT (ic)) &&
{
char buffer[5];
sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
- aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);
}
}
#endif
operand *t = IC_RIGHT (ic);
IC_RIGHT (ic) = IC_LEFT (ic);
IC_LEFT (ic) = t;
- swappedLR = TRUE;
+ swappedLR = TRUE;
}
/* if both left & right are in bit
{
MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
emitcode ("addc", "a,#00");
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
}
goto release;
D(emitcode ("; genPlus aligned array",""));
aopPut (IC_RESULT (ic),
aopGet (rightOp, 0, FALSE, FALSE),
- 0,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ 0);
if( 1 == getDataSize (IC_RIGHT (ic)) )
{
aopPut (IC_RESULT (ic),
aopGet (leftOp, 1, FALSE, FALSE),
- 1,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ 1);
}
else
{
MOVA (aopGet (IC_LEFT (ic), 1, FALSE, FALSE));
emitcode ("add", "a,%s", aopGet (rightOp, 1, FALSE, FALSE));
- aopPut (IC_RESULT (ic), "a", 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 1);
}
goto release;
}
MOVA (aopGet (rightOp, offset, FALSE, TRUE));
emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE));
}
- aopPut (IC_RESULT (ic), "a", offset, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset);
add = "addc"; /* further adds must propagate carry */
}
else
/* just move */
aopPut (IC_RESULT (ic),
aopGet (leftOp, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ offset);
}
}
offset++;
emitcode ("dec", "%s", l);
if (AOP_NEEDSACC (IC_RESULT (ic)))
- aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0);
return TRUE;
}
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
else
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
}
emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
emitcode ("inc", "a");
emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0);
addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
}
}
emitcode ("addc", "a,#0x%02x",
(unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
}
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
else
{
if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
{
aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), offset, FALSE, FALSE),
- offset, isOperandVolatile (IC_RESULT (ic), FALSE));
+ offset);
}
offset++;
}
aopGet(rightOp, offset, FALSE, TRUE));
}
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
}
-
adjustArithmeticResult (ic);
release:
}
emitcode ("mul", "ab");
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
if (size == 2)
- aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 1);
popB (pushedB);
return;
else /* ! literal */
{
if (rUnsigned) /* emitcode (";", "signed"); */
-
emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
else
{
}
emitcode ("", "%05d$:", (lbl->key + 100));
}
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
if (size == 2)
- aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 1);
popB (pushedB);
}
popB (pushedB);
- aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0);
}
/*-----------------------------------------------------------------*/
emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("div", "ab");
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
popB (pushedB);
return;
emitcode ("inc", "a");
emitcode ("", "%05d$:", (lbl->key + 100));
- accuse = aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ accuse = aopPut (result, "a", 0);
if (size > 0)
{
/* msb is 0x00 or 0xff depending on the sign */
emitcode ("mov", "c,F0");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
else /* compiletimeSign */
{
pushedA = TRUE;
}
while (size--)
- aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offset++);
}
}
}
else
{
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
if (pushedA)
popB (pushedB);
- aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0);
}
/*-----------------------------------------------------------------*/
int size2 = size;
int offs2 = offset;
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
while (size2--)
- aopPut (result, "#0xff", offs2++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offs2++);
lbl2 = newiTempLabel (NULL);
emitcode ("sjmp", "%05d$", (lbl2->key + 100));
}
emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
if (lbl2)
{
emitcode ("", "%05d$:", (lbl2->key + 100));
emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("div", "ab");
- aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 0);
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
popB (pushedB);
return;
emitcode ("inc", "a");
emitcode ("", "%05d$:", (lbl->key + 100));
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
if (size > 0)
{
/* msb is 0x00 or 0xff depending on the sign */
emitcode ("mov", "c,F0");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
else /* compiletimeSign */
while (size--)
- aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xff", offset++);
}
}
else
{
- aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", 0);
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
popB (pushedB);
operand *t = IC_RIGHT (ic);
IC_RIGHT (ic) = IC_LEFT (ic);
IC_LEFT (ic) = t;
- swappedLR = TRUE;
+ swappedLR = TRUE;
}
if (ifx && !AOP_SIZE (result))
gencjne (left, right, newiTempLabel (NULL));
if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
{
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
if (ifx)
}
else if (bytelit == 0)
{
- aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset);
}
else if (IS_AOP_PREG (result))
{
MOVA (aopGet (left, offset, FALSE, TRUE));
emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
emitcode ("anl", "%s,%s",
emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("anl", "a,b");
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else if (aopGetUsesAcc (left, offset))
{
MOVA (aopGet (left, offset, FALSE, FALSE));
emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
if (IS_AOP_PREG (result))
{
emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, TRUE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
emitcode ("anl", "%s,a",
{
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
continue;
}
else if (bytelit == 0)
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
MOVA (aopGet (left, offset, FALSE, FALSE));
- aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset);
continue;
}
else if (AOP_TYPE (left) == AOP_ACC)
if (!offset)
{
emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
continue;
}
else
{
emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "b", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "b", offset);
continue;
}
}
MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
}
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
}
}
}
else if (bytelit == 0x0FF)
{
- aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xFF", offset);
}
else if (IS_AOP_PREG (left))
{
MOVA (aopGet (left, offset, FALSE, TRUE));
emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("orl", "a,b");
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else if (aopGetUsesAcc (left, offset))
{
MOVA (aopGet (left, offset, FALSE, FALSE));
emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
if (IS_AOP_PREG (left))
{
emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, TRUE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
{
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
continue;
}
else if (bytelit == 0x0FF)
/* dummy read of volatile operand */
if (isOperandVolatile (left, FALSE))
MOVA (aopGet (left, offset, FALSE, FALSE));
- aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "#0xFF", offset);
continue;
}
}
MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE));
}
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
}
}
{
MOVA (aopGet (left, offset, FALSE, TRUE));
emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("xrl", "a,b");
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else if (aopGetUsesAcc (left, offset))
{
MOVA (aopGet (left, offset, FALSE, FALSE));
emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
if (IS_AOP_PREG (left))
{
emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
emitcode ("xrl", "%s,a",
{
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
continue;
}
}
MOVA (aopGet (right, offset, FALSE, FALSE));
emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
}
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
}
}
{
char *buffer, *bp, *bp1;
- D(emitcode ("; genInline",""));
+ D (emitcode (";", "genInline"));
_G.inLine += (!options.asmpeep);
- buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
- strcpy (buffer, IC_INLINE (ic));
+ buffer = bp = bp1 = Safe_strdup(IC_INLINE(ic));
/* emit each line as a code */
while (*bp)
MOVA (l);
emitcode ("rrc", "a");
if (AOP_SIZE (result) > 1)
- aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset--);
}
/* now we need to put the carry into the
highest order byte of the result */
}
emitcode ("mov", "acc.7,c");
release:
- aopPut (result, "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", AOP_SIZE (result) - 1);
freeAsmop (result, NULL, ic, TRUE);
freeAsmop (left, NULL, ic, TRUE);
}
}
emitcode("rlc","a"); /* bit0 will be written later */
if (AOP_SIZE (result) > 1)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
while (size--)
{
l = aopGet (left, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rlc", "a");
if (AOP_SIZE (result) > 1)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
}
/* now we need to put the carry into the
}
emitcode ("mov", "acc.0,c");
release:
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
freeAsmop (result, NULL, ic, TRUE);
freeAsmop (left, NULL, ic, TRUE);
}
offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
- 0,
- isOperandVolatile (result, FALSE));
+ 0);
freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
aopPut (result,
aopGet (left, offset, FALSE, FALSE),
- 0,
- isOperandVolatile (result, FALSE));
+ 0);
aopPut (result,
aopGet (left, offset+1, FALSE, FALSE),
- 1,
- isOperandVolatile (result, FALSE));
+ 1);
freeAsmop (result, NULL, ic, TRUE);
freeAsmop (right, NULL, ic, TRUE);
case 1: /* swap nibbles in byte */
MOVA (aopGet (left, 0, FALSE, FALSE));
emitcode ("swap", "a");
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
break;
case 2: /* swap bytes in word */
if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result)))
{
MOVA (aopGet (left, 0, FALSE, FALSE));
- aopPut (result, aopGet (left, 1, FALSE, FALSE),
- 0, isOperandVolatile (result, FALSE));
- aopPut (result, "a", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+ aopPut (result, "a", 1);
}
else if (operandsEqu (left, result))
{
reg = "b";
leftInB = TRUE;
}
- aopPut (result, aopGet (left, 1, FALSE, FALSE),
- 0, isOperandVolatile (result, FALSE));
- aopPut (result, reg, 1, isOperandVolatile (result, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+ aopPut (result, reg, 1);
if (leftInB)
popB (pushedB);
}
else
{
- aopPut (result, aopGet (left, 1, FALSE, FALSE),
- 0, isOperandVolatile (result, FALSE));
- aopPut (result, aopGet (left, 0, FALSE, FALSE),
- 1, isOperandVolatile (result, FALSE));
+ aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+ aopPut (result, aopGet (left, 0, FALSE, FALSE), 1);
}
break;
default:
freeAsmop (left, NULL, ic, TRUE);
}
-
/*-----------------------------------------------------------------*/
/* AccRol - rotate left accumulator by known count */
/*-----------------------------------------------------------------*/
AccSRsh (shCount);
else
AccRsh (shCount);
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
/*-----------------------------------------------------------------*/
MOVA (l);
/* shift left accumulator */
AccLsh (shCount);
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
/*-----------------------------------------------------------------*/
if (*l == '@' && (IS_AOP_PREG (result)))
{
emitcode ("mov", "a,%s", l);
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
else
{
if (!sign)
- aopPut (result, l, offr, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offr);
else
{
/* MSB sign in acc.7 ! */
if (getDataSize (left) == offl + 1)
{
MOVA (l);
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
}
}
if (usedB)
{
emitcode ("xch", "a,b");
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
- aopPut (result, "b", offr + MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
+ aopPut (result, "b", offr + MSB16);
popB (pushedB);
}
else
{
- aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr + MSB16);
}
}
if (usedB)
{
emitcode ("xch", "a,b");
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
emitcode ("xch", "a,b");
popB (pushedB);
}
if (getDataSize (result) > 1)
- aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr + MSB16);
}
/*-----------------------------------------------------------------*/
emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
}
/* back to result */
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
/*-----------------------------------------------------------------*/
/* or with result */
emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
/* back to result */
- aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offr);
}
/*-----------------------------------------------------------------*/
else
movLeft2Result (left, LSB, result, MSB16, 0);
}
- aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
}
/* 1 <= shCount <= 7 */
emitcode ("xch", "a,%s",
aopGet (left, LSB + offr, FALSE, FALSE));
else
- aopPut (result, "a", LSB + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", LSB + offr);
}
if (size >= MSB16 + offr)
emitcode ("xch", "a,%s",
aopGet (left, MSB16 + offr, FALSE, FALSE));
else
- aopPut (result, "a", MSB16 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB16 + offr);
}
if (size >= MSB24 + offr)
emitcode ("xch", "a,%s",
aopGet (left, MSB24 + offr, FALSE, FALSE));
else
- aopPut (result, "a", MSB24 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB24 + offr);
}
if (size > MSB32 + offr)
MOVA (l);
}
emitcode ("rlc", "a");
- aopPut (result, "a", MSB32 + offr, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB32 + offr);
}
if (offr != LSB)
- aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
}
/*-----------------------------------------------------------------*/
shiftL1Left2Result (left, LSB, result, MSB32, shCount);
else
movLeft2Result (left, LSB, result, MSB32, 0);
- aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
- aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
- aopPut (result, zero, MSB24, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
+ aopPut (result, zero, MSB16);
+ aopPut (result, zero, MSB24);
return;
}
movLeft2Result (left, MSB16, result, MSB32, 0);
movLeft2Result (left, LSB, result, MSB24, 0);
}
- aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
- aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, MSB16);
+ aopPut (result, zero, LSB);
return;
}
movLeft2Result (left, MSB24, result, MSB32, 0);
movLeft2Result (left, MSB16, result, MSB24, 0);
movLeft2Result (left, LSB, result, MSB16, 0);
- aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
}
else if (shCount == 1)
shiftLLong (left, result, MSB16);
shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
shiftL1Left2Result (left, LSB, result, MSB16, shCount);
shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);
- aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, LSB);
}
}
}
else if (shCount >= (size * 8))
while (size--)
- aopPut (result, zero, size, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, size);
else
{
switch (size)
{
emitcode ("mov", "a,%s", l);
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
- aopPut (result, l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset);
offset++;
}
}
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("add", "a,acc");
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
while (--size)
{
l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rlc", "a");
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
reAdjustPreg (AOP (result));
{
// shift is > 8
if (sign)
- {
+ {
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
if (useSameRegs && sameReg (AOP (left), MSB32, AOP (result), MSB32))
- {
+ {
emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));
- }
+ }
else
- {
- aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE));
+ {
+ aopPut (result, "a", MSB32);
MOVA (aopGet (left, MSB32, FALSE, FALSE));
- }
- }
- else
- {
- aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE));
- }
+ }
+ }
+ else
+ {
+ aopPut (result, zero, MSB32);
+ }
}
if (!sign)
}
else
{
- aopPut (result, "a", MSB32-offl, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB32-offl);
MOVA (aopGet (left, MSB24, FALSE, FALSE));
}
}
else
{
- aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB24-offl);
MOVA (aopGet (left, MSB16, FALSE, FALSE));
}
emitcode ("rrc", "a");
if (offl != LSB)
{
- aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB16 - offl);
}
else
{
}
else
{
- aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", MSB16 - offl);
MOVA (aopGet (left, LSB, FALSE, FALSE));
- }
+ }
emitcode ("rrc", "a");
- aopPut (result, "a", LSB, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", LSB);
}
}
{
emitcode ("mov", "a,%s", l);
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
- aopPut (result, l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset);
offset++;
}
}
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rrc", "a");
- aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset--);
}
reAdjustPreg (AOP (result));
emitcode ("", "%05d$:", tlbl1->key + 100);
{
emitcode ("mov", "a,%s", l);
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
- aopPut (result, l, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, l, offset);
offset++;
}
}
emitcode ("", "%05d$:", tlbl1->key + 100);
emitcode ("djnz", "b,%05d$", tlbl->key + 100);
popB (pushedB);
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
l = aopGet (result, offset, FALSE, FALSE);
MOVA (l);
emitcode ("rrc", "a");
- aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset--);
}
reAdjustPreg (AOP (result));
emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << blen));
emitcode ("", "%05d$:", tlbl->key + 100);
}
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
goto finish;
}
for (rlen=blen;rlen>=8;rlen-=8)
{
emitPtrByteGet (rname, ptype, FALSE);
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
if (rlen>8)
emitcode ("inc", "%s", rname);
}
emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << rlen));
emitcode ("", "%05d$:", tlbl->key + 100);
}
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
finish:
}
rsize -= offset;
while (rsize--)
- aopPut (result, source, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, source, offset++);
}
}
sprintf (buffer, "(%s + %d)", l + 1, offset);
else
sprintf (buffer, "%s", l + 1);
- aopPut (result, buffer, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, buffer, offset++);
}
freeAsmop (result, NULL, ic, TRUE);
emitcode ("mov", "a,@%s", rname);
if (!ifx)
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
}
else
{
sprintf (buffer, "@%s", rname);
- aopPut (result, buffer, offset, isOperandVolatile (result, FALSE));
+ aopPut (result, buffer, offset);
}
offset++;
if (size || pi)
if (aop) /* we had to allocate for this iCode */
{
if (pi) { /* post increment present */
- aopPut (left, rname, 0, isOperandVolatile (left, FALSE));
+ aopPut (left, rname, 0);
}
freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
}
emitcode ("movx", "a,@%s", rname);
if (!ifx)
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
offset++;
/* now some housekeeping stuff */
if (aop) /* we had to allocate for this iCode */
{
- if (pi) aopPut (left, rname, 0, isOperandVolatile (left, FALSE));
+ if (pi)
+ aopPut (left, rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
{
emitcode ("movx", "a,@dptr");
if (!ifx)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
if (size || pi)
emitcode ("inc", "dptr");
}
if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
{
- aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
- aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
- pi->generated = 1;
- }
+ aopPut (left, "dpl", 0);
+ aopPut (left, "dph", 1);
+ pi->generated = 1;
+ }
if (ifx && !ifx->generated)
{
}
/*-----------------------------------------------------------------*/
-/* genCodePointerGet - gget value from code space */
+/* genCodePointerGet - get value from code space */
/*-----------------------------------------------------------------*/
static void
genCodePointerGet (operand * left,
emitcode ("clr", "a");
emitcode ("movc", "a,@a+dptr");
if (!ifx)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
if (size || pi)
emitcode ("inc", "dptr");
}
if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
{
- aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
- aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
- pi->generated = 1;
- }
+ aopPut (left, "dpl", 0);
+ aopPut (left, "dph", 1);
+ pi->generated = 1;
+ }
if (ifx && !ifx->generated)
{
}
/*-----------------------------------------------------------------*/
-/* genGenPointerGet - gget value from generic pointer space */
+/* genGenPointerGet - get value from generic pointer space */
/*-----------------------------------------------------------------*/
static void
genGenPointerGet (operand * left,
{
emitcode ("lcall", "__gptrget");
if (!ifx)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
if (size || pi)
emitcode ("inc", "dptr");
}
if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
{
- aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
- aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
- pi->generated = 1;
- }
+ aopPut (left, "dpl", 0);
+ aopPut (left, "dph", 1);
+ pi->generated = 1;
+ }
if (ifx && !ifx->generated)
{
if (aop) /* we had to allocate for this iCode */
{
if (pi)
- aopPut (result, rname, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
if (aop) /* we had to allocate for this iCode */
{
if (pi)
- aopPut (result, rname, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, rname, 0);
freeAsmop (NULL, aop, ic, TRUE);
}
else
}
}
if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
- aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE));
- aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "dpl", 0);
+ aopPut (result, "dph", 1);
pi->generated=1;
}
freeAsmop (result, NULL, ic, TRUE);
}
if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
- aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE));
- aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
+ aopPut (result, "dpl", 0);
+ aopPut (result, "dph", 1);
pi->generated=1;
}
freeAsmop (result, NULL, ic, TRUE);
emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
((char) (sym->stack - _G.nRegsSaved)) :
((char) sym->stack)) & 0xff);
- aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", 0);
}
else
{
/* we can just move _bp */
- aopPut (IC_RESULT (ic), SYM_BP (sym), 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), SYM_BP (sym), 0);
}
/* fill the result with zero */
size = AOP_SIZE (IC_RESULT (ic)) - 1;
offset = 1;
while (size--)
{
- aopPut (IC_RESULT (ic), zero, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), zero, offset++);
}
goto release;
offset * 8);
else
sprintf (s, "#%s", sym->rname);
- aopPut (IC_RESULT (ic), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), s, offset++);
}
release:
while (size--)
{
emitcode ("pop", "acc");
- aopPut (result, "a", --offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", --offset);
}
freeAsmop (result, NULL, ic, FALSE);
}
if (AOP_TYPE (right) == AOP_LIT)
{
if (((int) operandLitValue (right)))
- aopPut (result, one, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, one, 0);
else
- aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, 0);
goto release;
}
if (AOP_TYPE (right) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0);
goto release;
}
/* we need to or */
toBoolean (right);
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
{
aopPut (result,
aopGet (right, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
lit >>= 8;
offset++;
size--;
emitcode ("clr", "a");
while (size--)
{
- aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset);
offset++;
}
}
{
aopPut (result,
aopGet (right, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
offset++;
}
}
if (AOP_TYPE (right) == AOP_LIT)
{
if (((int) operandLitValue (right)))
- aopPut (result, one, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, one, 0);
else
- aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, 0);
goto release;
}
if (AOP_TYPE (right) == AOP_CRY)
{
emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
- aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "c", 0);
goto release;
}
/* we need to or */
toBoolean (right);
- aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", 0);
goto release;
}
-
/* if they are the same size : or less */
if (AOP_SIZE (result) <= AOP_SIZE (right))
{
{
aopPut (result,
aopGet (right, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
offset++;
}
goto release;
}
-
/* if the result is of type pointer */
if (IS_PTR (ctype))
{
{
aopPut (result,
aopGet (right, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
offset++;
}
/* the last byte depending on type */
}
sprintf(gpValStr, "#0x%x", gpVal);
- aopPut (result, gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
+ aopPut (result, gpValStr, GPTRSIZE - 1);
}
goto release;
}
{
aopPut (result,
aopGet (right, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
offset++;
}
goto release;
{
aopPut (result,
aopGet (right, offset, FALSE, FALSE),
- offset,
- isOperandVolatile (result, FALSE));
+ offset);
offset++;
}
if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
{
while (size--)
- aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, zero, offset++);
}
else
{
emitcode ("rlc", "a");
emitcode ("subb", "a,acc");
while (size--)
- aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+ aopPut (result, "a", offset++);
}
/* we are done hurray !!!! */
return 0;
}
emitcode ("dec", "%s", rByte);
- aopPut (IC_RESULT (ic), rByte, 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), rByte, 0);
emitcode ("jnz", "%05d$", lbl->key + 100);
}
else if (IS_AOP_PREG (IC_RESULT (ic)))
_G.accInUse++;
aopOp (IC_RESULT (ic), ic, FALSE);
_G.accInUse--;
- aopPut (IC_RESULT (ic), "a", offset,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset);
for (offset = 1; offset<size; offset++)
- aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset);
goto release;
}
}
emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]);
aopOp (IC_RESULT (ic), ic, FALSE);
for (offset = 0; offset<size; offset++)
- aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset,
- isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset);
goto release;
}
}
while (size--)
{
emitcode ("pop", "acc");
- aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), "a", offset++);
}
}
else
rb1off = ic->argreg;
while (size--)
{
- aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+ aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++);
}
}
if (IC_RESULT (ic))
{
aopOp (IC_RESULT (ic), ic, TRUE);
- aopPut (IC_RESULT (ic), one, 0, 0);
+ aopPut (IC_RESULT (ic), one, 0);
emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
- aopPut (IC_RESULT (ic), zero, 0, 0);
+ aopPut (IC_RESULT (ic), zero, 0);
emitcode ("", "%05d$:", (tlbl->key + 100));
freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
}
projects / fw / sdcc / commitdiff