#endif
static PIC_device Pics[] = {
- {
- {"p16f627", "16f627", "pic16f627", "f627"}, /* processor name */
- (memRange *)NULL,
- (memRange *)NULL,
- 0, /* max ram address (calculated) */
- 0x80, /* Bank Mask */
- },
-
- {
- {"p16f628", "16f628", "pic16f628", "f628"},
- (memRange *)NULL,
- (memRange *)NULL,
- 0,
- 0x80,
- },
-
- {
- {"p16f84", "16f84", "pic16f84", "f84"},
- (memRange *)NULL,
- (memRange *)NULL,
- 0,
- 0x80,
- },
-
- {
- {"p16f873", "16f873", "pic16f873", "f873"},
- (memRange *)NULL,
- (memRange *)NULL,
- 0,
- 0x180,
- },
-
- {
- {"p16f877", "16f877", "pic16f877", "f877"},
- (memRange *)NULL,
- (memRange *)NULL,
- 0,
- 0x180,
- },
-
- {
- {"p16f819", "16f819", "pic16f819", "f819"},
- (memRange *)NULL,
- (memRange *)NULL,
- 0,
- 0x80,
- },
+ {
+ {"p16f627", "16f627", "pic16f627", "f627"}, /* processor name */
+ (memRange *)NULL,
+ (memRange *)NULL,
+ 0, /* max ram address (calculated) */
+ 0x80, /* Bank Mask */
+ },
+
+ {
+ {"p16f628", "16f628", "pic16f628", "f628"},
+ (memRange *)NULL,
+ (memRange *)NULL,
+ 0,
+ 0x80,
+ },
+
+ {
+ {"p16f84", "16f84", "pic16f84", "f84"},
+ (memRange *)NULL,
+ (memRange *)NULL,
+ 0,
+ 0x80,
+ },
+
+ {
+ {"p16f873", "16f873", "pic16f873", "f873"},
+ (memRange *)NULL,
+ (memRange *)NULL,
+ 0,
+ 0x180,
+ },
+
+ {
+ {"p16f877", "16f877", "pic16f877", "f877"},
+ (memRange *)NULL,
+ (memRange *)NULL,
+ 0,
+ 0x180,
+ },
+
+ {
+ {"p16f819", "16f819", "pic16f819", "f819"},
+ (memRange *)NULL,
+ (memRange *)NULL,
+ 0,
+ 0x80,
+ },
};
void addMemRange(memRange *r, int type)
{
- int i;
- int alias = r->alias;
-
- if (pic->maxRAMaddress < 0) {
- fprintf(stderr, "missing \"#pragma maxram\" setting\n");
- return;
- }
-
- do {
- for (i=r->start_address; i<= r->end_address; i++) {
- if ((i|alias) <= pic->maxRAMaddress) {
- finalMapping[i | alias].isValid = 1;
- finalMapping[i | alias].alias = r->alias;
- finalMapping[i | alias].bank = r->bank;
- if(type) {
- /* hack for now */
- finalMapping[i | alias].isSFR = 1;
- } else {
- finalMapping[i | alias].isSFR = 0;
+ int i;
+ int alias = r->alias;
+
+ if (pic->maxRAMaddress < 0) {
+ fprintf(stderr, "missing \"#pragma maxram\" setting\n");
+ return;
}
- } else {
- fprintf(stderr, "WARNING: %s:%s memory at 0x%x is beyond max ram = 0x%x\n",
- __FILE__,__FUNCTION__,(i|alias), pic->maxRAMaddress);
- }
- }
-
- /* Decrement alias */
- if (alias) {
- alias -= ((alias & (alias - 1)) ^ alias);
- } else {
- alias--;
- }
-
- } while (alias >= 0);
+
+ do {
+ for (i=r->start_address; i<= r->end_address; i++) {
+ if ((i|alias) <= pic->maxRAMaddress) {
+ finalMapping[i | alias].isValid = 1;
+ finalMapping[i | alias].alias = r->alias;
+ finalMapping[i | alias].bank = r->bank;
+ if(type) {
+ /* hack for now */
+ finalMapping[i | alias].isSFR = 1;
+ } else {
+ finalMapping[i | alias].isSFR = 0;
+ }
+ } else {
+ fprintf(stderr, "WARNING: %s:%s memory at 0x%x is beyond max ram = 0x%x\n",
+ __FILE__,__FUNCTION__,(i|alias), pic->maxRAMaddress);
+ }
+ }
+
+ /* Decrement alias */
+ if (alias) {
+ alias -= ((alias & (alias - 1)) ^ alias);
+ } else {
+ alias--;
+ }
+
+ } while (alias >= 0);
}
void setMaxRAM(int size)
{
- int i;
- pic->maxRAMaddress = size;
-
- if (pic->maxRAMaddress < 0) {
- fprintf(stderr, "invalid \"#pragma maxram 0x%x\" setting\n",
- pic->maxRAMaddress);
- return;
- }
-
- finalMapping = Safe_calloc(1+pic->maxRAMaddress,
- sizeof(AssignedMemory));
-
- /* Now initialize the finalMapping array */
-
- for(i=0; i<=pic->maxRAMaddress; i++) {
- finalMapping[i].reg = NULL;
- finalMapping[i].isValid = 0;
- }
+ int i;
+ pic->maxRAMaddress = size;
+
+ if (pic->maxRAMaddress < 0) {
+ fprintf(stderr, "invalid \"#pragma maxram 0x%x\" setting\n",
+ pic->maxRAMaddress);
+ return;
+ }
+
+ finalMapping = Safe_calloc(1+pic->maxRAMaddress,
+ sizeof(AssignedMemory));
+
+ /* Now initialize the finalMapping array */
+
+ for(i=0; i<=pic->maxRAMaddress; i++) {
+ finalMapping[i].reg = NULL;
+ finalMapping[i].isValid = 0;
+ }
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
int isREGinBank(regs *reg, int bank)
{
-
- if(!reg || !pic)
- return 0;
-
- if((int)((reg->address | reg->alias) & pic->bankMask & bank) == bank)
- return 1;
-
- return 0;
+
+ if(!reg || !pic)
+ return 0;
+
+ if((int)((reg->address | reg->alias) & pic->bankMask & bank) == bank)
+ return 1;
+
+ return 0;
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
int REGallBanks(regs *reg)
{
-
- if(!reg || !pic)
- return 0;
-
- return ((reg->address | reg->alias) & pic->bankMask);
-
+
+ if(!reg || !pic)
+ return 0;
+
+ return ((reg->address | reg->alias) & pic->bankMask);
+
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
/*
- * dump_map -- debug stuff
- */
+* dump_map -- debug stuff
+*/
void dump_map(void)
{
- int i;
-
- for(i=0; i<=pic->maxRAMaddress; i++) {
- //fprintf(stdout , "addr 0x%02x is %s\n", i, ((finalMapping[i].isValid) ? "valid":"invalid"));
-
- if(finalMapping[i].isValid) {
- fprintf(stderr,"addr: 0x%02x",i);
- if(finalMapping[i].isSFR)
- fprintf(stderr," isSFR");
- if(finalMapping[i].reg)
- fprintf( stderr, " reg %s", finalMapping[i].reg->name);
- fprintf(stderr, "\n");
- }
- }
-
+ int i;
+
+ for(i=0; i<=pic->maxRAMaddress; i++) {
+ //fprintf(stdout , "addr 0x%02x is %s\n", i, ((finalMapping[i].isValid) ? "valid":"invalid"));
+
+ if(finalMapping[i].isValid) {
+ fprintf(stderr,"addr: 0x%02x",i);
+ if(finalMapping[i].isSFR)
+ fprintf(stderr," isSFR");
+ if(finalMapping[i].reg)
+ fprintf( stderr, " reg %s", finalMapping[i].reg->name);
+ fprintf(stderr, "\n");
+ }
+ }
+
}
void dump_sfr(FILE *of)
{
-
- int start=-1;
- int addr=0;
- int bank_base;
- static int udata_flag=0;
-
- //dump_map(); /* display the register map */
- //fprintf(stdout,";dump_sfr \n");
- if (pic->maxRAMaddress < 0) {
- fprintf(stderr, "missing \"#pragma maxram\" setting\n");
- return;
- }
-
- do {
-
- if(finalMapping[addr].reg && !finalMapping[addr].reg->isEmitted) {
-
- if(start<0)
- start = addr;
- } else {
- if(start>=0) {
-
- /* clear the lower 7-bits of the start address of the first
- * variable declared in this bank. The upper bits for the mid
- * range pics are the bank select bits.
- */
-
- bank_base = start & 0xfff8;
-
- /* The bank number printed in the cblock comment tacitly
- * assumes that the first register in the contiguous group
- * of registers represents the bank for the whole group */
-
- if ( (start != addr) && (!udata_flag) ) {
- udata_flag = 1;
- //fprintf(of,"\tudata\n");
+
+ int start=-1;
+ int addr=0;
+ int bank_base;
+ static int udata_flag=0;
+
+ //dump_map(); /* display the register map */
+ //fprintf(stdout,";dump_sfr \n");
+ if (pic->maxRAMaddress < 0) {
+ fprintf(stderr, "missing \"#pragma maxram\" setting\n");
+ return;
}
-
- for( ; start < addr; start++) {
- if((finalMapping[start].reg) &&
- (!finalMapping[start].reg->isEmitted) &&
- (!finalMapping[start].instance) &&
- (!finalMapping[start].isSFR)) {
-
- if (finalMapping[start].reg->isFixed) {
- unsigned i;
- for (i=0; i<finalMapping[start].reg->size; i++) {
- fprintf(of,"%s\tEQU\t0x%04x\n",
- finalMapping[start].reg->name,
- finalMapping[start].reg->address+i);
- }
- } else {
- fprintf(of,"%s\tres\t%i\n",
- finalMapping[start].reg->name,
- finalMapping[start].reg->size);
- }
- finalMapping[start].reg->isEmitted = 1;
- }
- }
-
- start = -1;
- }
-
- }
-
- addr++;
-
- } while(addr <= pic->maxRAMaddress);
-
-
+
+ do {
+
+ if(finalMapping[addr].reg && !finalMapping[addr].reg->isEmitted) {
+
+ if(start<0)
+ start = addr;
+ } else {
+ if(start>=0) {
+
+ /* clear the lower 7-bits of the start address of the first
+ * variable declared in this bank. The upper bits for the mid
+ * range pics are the bank select bits.
+ */
+
+ bank_base = start & 0xfff8;
+
+ /* The bank number printed in the cblock comment tacitly
+ * assumes that the first register in the contiguous group
+ * of registers represents the bank for the whole group */
+
+ if ( (start != addr) && (!udata_flag) ) {
+ udata_flag = 1;
+ //fprintf(of,"\tudata\n");
+ }
+
+ for( ; start < addr; start++) {
+ if((finalMapping[start].reg) &&
+ (!finalMapping[start].reg->isEmitted) &&
+ (!finalMapping[start].instance) &&
+ (!finalMapping[start].isSFR)) {
+
+ if (finalMapping[start].reg->isFixed) {
+ unsigned i;
+ for (i=0; i<finalMapping[start].reg->size; i++) {
+ fprintf(of,"%s\tEQU\t0x%04x\n",
+ finalMapping[start].reg->name,
+ finalMapping[start].reg->address+i);
+ }
+ } else {
+ fprintf(of,"%s\tres\t%i\n",
+ finalMapping[start].reg->name,
+ finalMapping[start].reg->size);
+ }
+ finalMapping[start].reg->isEmitted = 1;
+ }
+ }
+
+ start = -1;
+ }
+
+ }
+
+ addr++;
+
+ } while(addr <= pic->maxRAMaddress);
+
+
}
/*-----------------------------------------------------------------*
- * void list_valid_pics(int ncols, int list_alias)
- *
- * Print out a formatted list of valid PIC devices
- *
- * ncols - number of columns in the list.
- *
- * list_alias - if non-zero, print all of the supported aliases
- * for a device (e.g. F84, 16F84, etc...)
- *-----------------------------------------------------------------*/
+* void list_valid_pics(int ncols, int list_alias)
+*
+* Print out a formatted list of valid PIC devices
+*
+* ncols - number of columns in the list.
+*
+* list_alias - if non-zero, print all of the supported aliases
+* for a device (e.g. F84, 16F84, etc...)
+*-----------------------------------------------------------------*/
void list_valid_pics(int ncols, int list_alias)
{
- int col,longest;
- int i,j,k,l;
-
- if(list_alias)
- list_alias = sizeof(Pics[0].name) / sizeof(Pics[0].name[0]);
-
- /* decrement the column number if it's greater than zero */
- ncols = (ncols > 1) ? ncols-1 : 4;
-
- /* Find the device with the longest name */
- for(i=0,longest=0; i<num_of_supported_PICS; i++) {
- for(j=0; j<=list_alias; j++) {
- k = strlen(Pics[i].name[j]);
- if(k>longest)
- longest = k;
- }
- }
-
- col = 0;
-
- for(i=0; i < num_of_supported_PICS; i++) {
- j = 0;
- do {
-
- fprintf(stderr,"%s", Pics[i].name[j]);
- if(col<ncols) {
- l = longest + 2 - strlen(Pics[i].name[j]);
- for(k=0; k<l; k++)
- fputc(' ',stderr);
-
- col++;
-
- } else {
- fputc('\n',stderr);
+ int col,longest;
+ int i,j,k,l;
+
+ if(list_alias)
+ list_alias = sizeof(Pics[0].name) / sizeof(Pics[0].name[0]);
+
+ /* decrement the column number if it's greater than zero */
+ ncols = (ncols > 1) ? ncols-1 : 4;
+
+ /* Find the device with the longest name */
+ for(i=0,longest=0; i<num_of_supported_PICS; i++) {
+ for(j=0; j<=list_alias; j++) {
+ k = strlen(Pics[i].name[j]);
+ if(k>longest)
+ longest = k;
+ }
+ }
+
col = 0;
- }
-
- } while(++j<list_alias);
-
- }
- if(col != ncols)
- fputc('\n',stderr);
-
+
+ for(i=0; i < num_of_supported_PICS; i++) {
+ j = 0;
+ do {
+
+ fprintf(stderr,"%s", Pics[i].name[j]);
+ if(col<ncols) {
+ l = longest + 2 - strlen(Pics[i].name[j]);
+ for(k=0; k<l; k++)
+ fputc(' ',stderr);
+
+ col++;
+
+ } else {
+ fputc('\n',stderr);
+ col = 0;
+ }
+
+ } while(++j<list_alias);
+
+ }
+ if(col != ncols)
+ fputc('\n',stderr);
+
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
PIC_device *find_device(char *name)
{
-
- int i,j;
-
- if(!name)
- return NULL;
-
- for(i = 0; i<num_of_supported_PICS; i++) {
-
- for(j=0; j<PROCESSOR_NAMES; j++)
- if(!STRCASECMP(Pics[i].name[j], name) )
- return &Pics[i];
- }
-
- /* not found */
- return NULL;
+
+ int i,j;
+
+ if(!name)
+ return NULL;
+
+ for(i = 0; i<num_of_supported_PICS; i++) {
+
+ for(j=0; j<PROCESSOR_NAMES; j++)
+ if(!STRCASECMP(Pics[i].name[j], name) )
+ return &Pics[i];
+ }
+
+ /* not found */
+ return NULL;
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
void init_pic(char *pic_type)
{
- pic = find_device(pic_type);
-
- if(!pic) {
- if(pic_type)
- fprintf(stderr, "'%s' was not found.\n", pic_type);
- else
- fprintf(stderr, "No processor has been specified (use -pPROCESSOR_NAME)\n");
-
- fprintf(stderr,"Valid devices are:\n");
-
- list_valid_pics(4,0);
- exit(1);
- }
-
- pic->maxRAMaddress = -1;
+ pic = find_device(pic_type);
+
+ if(!pic) {
+ if(pic_type)
+ fprintf(stderr, "'%s' was not found.\n", pic_type);
+ else
+ fprintf(stderr, "No processor has been specified (use -pPROCESSOR_NAME)\n");
+
+ fprintf(stderr,"Valid devices are:\n");
+
+ list_valid_pics(4,0);
+ exit(1);
+ }
+
+ pic->maxRAMaddress = -1;
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
int picIsInitialized(void)
{
- if(pic && pic->maxRAMaddress > 0)
- return 1;
-
- return 0;
-
+ if(pic && pic->maxRAMaddress > 0)
+ return 1;
+
+ return 0;
+
}
/*-----------------------------------------------------------------*
- * char *processor_base_name(void) - Include file is derived from this.
- *-----------------------------------------------------------------*/
+* char *processor_base_name(void) - Include file is derived from this.
+*-----------------------------------------------------------------*/
char *processor_base_name(void)
{
-
- if(!pic)
- return NULL;
-
- return pic->name[0];
+
+ if(!pic)
+ return NULL;
+
+ return pic->name[0];
}
int isSFR(int address)
{
-
- if( (address > pic->maxRAMaddress) || !finalMapping[address].isSFR)
- return 0;
-
- return 1;
-
+
+ if( (address > pic->maxRAMaddress) || !finalMapping[address].isSFR)
+ return 0;
+
+ return 1;
+
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
int validAddress(int address, int reg_size)
{
- int i;
-
- if (pic->maxRAMaddress < 0) {
- fprintf(stderr, "missing \"#pragma maxram\" setting\n");
- return 0;
- }
- // fprintf(stderr, "validAddress: Checking 0x%04x\n",address);
- if(address > pic->maxRAMaddress)
- return 0;
-
- for (i=0; i<reg_size; i++)
- if(!finalMapping[address + i].isValid ||
- finalMapping[address+i].reg ||
- finalMapping[address+i].isSFR )
- return 0;
-
- return 1;
+ int i;
+
+ if (pic->maxRAMaddress < 0) {
+ fprintf(stderr, "missing \"#pragma maxram\" setting\n");
+ return 0;
+ }
+ // fprintf(stderr, "validAddress: Checking 0x%04x\n",address);
+ if(address > pic->maxRAMaddress)
+ return 0;
+
+ for (i=0; i<reg_size; i++)
+ if(!finalMapping[address + i].isValid ||
+ finalMapping[address+i].reg ||
+ finalMapping[address+i].isSFR )
+ return 0;
+
+ return 1;
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
void mapRegister(regs *reg)
{
-
- unsigned i;
- int alias;
-
- if(!reg || !reg->size) {
- fprintf(stderr,"WARNING: %s:%s:%d Bad register\n",__FILE__,__FUNCTION__,__LINE__);
- return;
- }
-
- if (pic->maxRAMaddress < 0) {
- fprintf(stderr, "missing \"#pragma maxram\" setting\n");
- return;
- }
-
- for(i=0; i<reg->size; i++) {
-
- alias = finalMapping[reg->address].alias;
- reg->alias = alias;
-
- do {
-
- //fprintf(stdout,"mapping %s to address 0x%02x, reg size = %d\n",reg->name, (reg->address+alias+i),reg->size);
-
- finalMapping[reg->address + alias + i].reg = reg;
- finalMapping[reg->address + alias + i].instance = i;
-
- /* Decrement alias */
- if(alias)
- alias -= ((alias & (alias - 1)) ^ alias);
- else
- alias--;
-
- } while (alias>=0);
- }
-
- //fprintf(stderr,"%s - %s addr = 0x%03x, size %d\n",__FUNCTION__,reg->name, reg->address,reg->size);
-
- reg->isMapped = 1;
-
+
+ unsigned i;
+ int alias;
+
+ if(!reg || !reg->size) {
+ fprintf(stderr,"WARNING: %s:%s:%d Bad register\n",__FILE__,__FUNCTION__,__LINE__);
+ return;
+ }
+
+ if (pic->maxRAMaddress < 0) {
+ fprintf(stderr, "missing \"#pragma maxram\" setting\n");
+ return;
+ }
+
+ for(i=0; i<reg->size; i++) {
+
+ alias = finalMapping[reg->address].alias;
+ reg->alias = alias;
+
+ do {
+
+ //fprintf(stdout,"mapping %s to address 0x%02x, reg size = %d\n",reg->name, (reg->address+alias+i),reg->size);
+
+ finalMapping[reg->address + alias + i].reg = reg;
+ finalMapping[reg->address + alias + i].instance = i;
+
+ /* Decrement alias */
+ if(alias)
+ alias -= ((alias & (alias - 1)) ^ alias);
+ else
+ alias--;
+
+ } while (alias>=0);
+ }
+
+ //fprintf(stderr,"%s - %s addr = 0x%03x, size %d\n",__FUNCTION__,reg->name, reg->address,reg->size);
+
+ reg->isMapped = 1;
+
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
int assignRegister(regs *reg, int start_address)
{
- int i;
-
- //fprintf(stderr,"%s - %s start_address = 0x%03x\n",__FUNCTION__,reg->name, start_address);
- if(reg->isFixed) {
-
- if (validAddress(reg->address,reg->size)) {
- //fprintf(stderr,"%s - %s address = 0x%03x\n",__FUNCTION__,reg->name, reg->address);
- mapRegister(reg);
- return reg->address;
- }
-
- if( isSFR(reg->address)) {
- mapRegister(reg);
- return reg->address;
- }
-
- //fprintf(stderr, "WARNING: Ignoring Out of Range register assignment at fixed address %d, %s\n",
- // reg->address, reg->name);
-
- } else {
-
- /* This register does not have a fixed address requirement
- * so we'll search through all availble ram address and
- * assign the first one */
-
- for (i=start_address; i<=pic->maxRAMaddress; i++) {
-
- if (validAddress(i,reg->size)) {
- reg->address = i;
- mapRegister(reg);
- return i;
- }
- }
-
- fprintf(stderr, "WARNING: No more RAM available for %s\n",reg->name);
-
- }
-
- return -1;
+ int i;
+
+ //fprintf(stderr,"%s - %s start_address = 0x%03x\n",__FUNCTION__,reg->name, start_address);
+ if(reg->isFixed) {
+
+ if (validAddress(reg->address,reg->size)) {
+ //fprintf(stderr,"%s - %s address = 0x%03x\n",__FUNCTION__,reg->name, reg->address);
+ mapRegister(reg);
+ return reg->address;
+ }
+
+ if( isSFR(reg->address)) {
+ mapRegister(reg);
+ return reg->address;
+ }
+
+ //fprintf(stderr, "WARNING: Ignoring Out of Range register assignment at fixed address %d, %s\n",
+ // reg->address, reg->name);
+
+ } else {
+
+ /* This register does not have a fixed address requirement
+ * so we'll search through all availble ram address and
+ * assign the first one */
+
+ for (i=start_address; i<=pic->maxRAMaddress; i++) {
+
+ if (validAddress(i,reg->size)) {
+ reg->address = i;
+ mapRegister(reg);
+ return i;
+ }
+ }
+
+ fprintf(stderr, "WARNING: No more RAM available for %s\n",reg->name);
+
+ }
+
+ return -1;
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
void assignFixedRegisters(set *regset)
{
- regs *reg;
-
- for (reg = setFirstItem(regset) ; reg ;
- reg = setNextItem(regset)) {
-
- if(reg->isFixed)
- assignRegister(reg,0);
- }
-
+ regs *reg;
+
+ for (reg = setFirstItem(regset) ; reg ;
+ reg = setNextItem(regset)) {
+
+ if(reg->isFixed)
+ assignRegister(reg,0);
+ }
+
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
void assignRelocatableRegisters(set *regset, int used)
{
-
- regs *reg;
- int address = 0;
-
- for (reg = setFirstItem(regset) ; reg ;
- reg = setNextItem(regset)) {
-
- //fprintf(stdout,"assigning %s isFixed=%d, wasUsed=%d\n",reg->name,reg->isFixed,reg->wasUsed);
-
- if((!reg->isFixed) && ( used || reg->wasUsed)) {
- /* If register have been reused then shall not print it a second time. */
- set *s;
- int done = 0;
- for (s = regset; s; s = s->next) {
- regs *r;
- r = s->item;
- if (r == reg)
- break;
- if((!r->isFixed) && ( used || r->wasUsed)) {
- if (r->rIdx == reg->rIdx) {
- reg->address = r->address;
- done = 1;
- break;
- }
- }
- }
- if (!done)
- address = assignRegister(reg,address);
- }
- }
-
+
+ regs *reg;
+ int address = 0;
+
+ for (reg = setFirstItem(regset) ; reg ;
+ reg = setNextItem(regset)) {
+
+ //fprintf(stdout,"assigning %s isFixed=%d, wasUsed=%d\n",reg->name,reg->isFixed,reg->wasUsed);
+
+ if((!reg->isFixed) && ( used || reg->wasUsed)) {
+ /* If register have been reused then shall not print it a second time. */
+ set *s;
+ int done = 0;
+ for (s = regset; s; s = s->next) {
+ regs *r;
+ r = s->item;
+ if (r == reg)
+ break;
+ if((!r->isFixed) && ( used || r->wasUsed)) {
+ if (r->rIdx == reg->rIdx) {
+ reg->address = r->address;
+ done = 1;
+ break;
+ }
+ }
+ }
+ if (!done)
+ address = assignRegister(reg,address);
+ }
+ }
+
}
/*-----------------------------------------------------------------*
- * void assignConfigWordValue(int address, int value)
- *
- * All midrange PICs have one config word at address 0x2007.
- * This routine will assign a value to that address.
- *
- *-----------------------------------------------------------------*/
+* void assignConfigWordValue(int address, int value)
+*
+* All midrange PICs have one config word at address 0x2007.
+* This routine will assign a value to that address.
+*
+*-----------------------------------------------------------------*/
void assignConfigWordValue(int address, int value)
{
- if(CONFIG_WORD_ADDRESS == address)
- config_word = value;
-
- //fprintf(stderr,"setting config word to 0x%x\n",value);
-
+ if(CONFIG_WORD_ADDRESS == address)
+ config_word = value;
+
+ //fprintf(stderr,"setting config word to 0x%x\n",value);
+
}
/*-----------------------------------------------------------------*
- * int getConfigWord(int address)
- *
- * Get the current value of the config word.
- *
- *-----------------------------------------------------------------*/
+* int getConfigWord(int address)
+*
+* Get the current value of the config word.
+*
+*-----------------------------------------------------------------*/
int getConfigWord(int address)
{
- if(CONFIG_WORD_ADDRESS == address)
- return config_word;
-
- else
- return 0;
-
+ if(CONFIG_WORD_ADDRESS == address)
+ return config_word;
+
+ else
+ return 0;
+
}
*/
typedef struct memRange {
- int start_address; /* first address in range */
- int end_address; /* last */
- int alias; /* bit mask defining how/if memory range is aliased
- * e.g. alias = 0x80 means start_address is identical
- * to the memory location at (0x80 | start_address) */
- int bank; /* PIC memory bank this range occupies */
+ int start_address; /* first address in range */
+ int end_address; /* last */
+ int alias; /* bit mask defining how/if memory range is aliased
+ * e.g. alias = 0x80 means start_address is identical
+ * to the memory location at (0x80 | start_address) */
+ int bank; /* PIC memory bank this range occupies */
} memRange;
*/
typedef struct AssignedMemory {
- regs *reg; /* Pointer to the register (NULL if this is an invalid address) */
- int instance; /* the i'th byte of a multibyte register */
- int alias; /* Bit mapping of aliased addresses (see memRange) */
- int bank; /* Memory bank of this register */
- int isValid:1; /* True if the address is legal */
- int isSFR:1; /* True if the address is that of a Special Function reg */
- int isEmitted:1; /* True if the register has been written to a cBlock */
+ regs *reg; /* Pointer to the register (NULL if this is an invalid address) */
+ int instance; /* the i'th byte of a multibyte register */
+ int alias; /* Bit mapping of aliased addresses (see memRange) */
+ int bank; /* Memory bank of this register */
+ int isValid:1; /* True if the address is legal */
+ int isSFR:1; /* True if the address is that of a Special Function reg */
+ int isEmitted:1; /* True if the register has been written to a cBlock */
} AssignedMemory;
#define PROCESSOR_NAMES 4
/* Processor unique attributes */
typedef struct PIC_device {
- char *name[PROCESSOR_NAMES];/* aliases for the processor name */
+ char *name[PROCESSOR_NAMES];/* aliases for the processor name */
- memRange *ram; /* RAM memory map */
- memRange *sfr; /* SFR memory map */
+ memRange *ram; /* RAM memory map */
+ memRange *sfr; /* SFR memory map */
- int maxRAMaddress; /* maximum value for a data address */
- int bankMask; /* Bitmask that is ANDed with address to extract banking bits */
- // int hasAliasedRAM:1; /* True if there are bank independent registers */
+ int maxRAMaddress; /* maximum value for a data address */
+ int bankMask; /* Bitmask that is ANDed with address to extract banking bits */
+ // int hasAliasedRAM:1; /* True if there are bank independent registers */
} PIC_device;
static int optimized_for_speed = 0;
/* max_key keeps track of the largest label number used in
- a function. This is then used to adjust the label offset
- for the next function.
+a function. This is then used to adjust the label offset
+for the next function.
*/
static int max_key=0;
static int GpsuedoStkPtr=0;
#define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0xff)
/* this is the down and dirty file with all kinds of
- kludgy & hacky stuff. This is what it is all about
- CODE GENERATION for a specific MCU . some of the
- routines may be reusable, will have to see */
+kludgy & hacky stuff. This is what it is all about
+CODE GENERATION for a specific MCU . some of the
+routines may be reusable, will have to see */
static char *zero = "#0x00";
static char *one = "#0x01";
//static short rbank = -1;
static struct {
- short r0Pushed;
- short r1Pushed;
- short accInUse;
- short inLine;
- short debugLine;
- short nRegsSaved;
- set *sendSet;
+ short r0Pushed;
+ short r1Pushed;
+ short accInUse;
+ short inLine;
+ short debugLine;
+ short nRegsSaved;
+ set *sendSet;
} _G;
/* Resolved ifx structure. This structure stores information
- about an iCode ifx that makes it easier to generate code.
+about an iCode ifx that makes it easier to generate code.
*/
typedef struct resolvedIfx {
- symbol *lbl; /* pointer to a label */
- int condition; /* true or false ifx */
- int generated; /* set true when the code associated with the ifx
- * is generated */
+ symbol *lbl; /* pointer to a label */
+ int condition; /* true or false ifx */
+ int generated; /* set true when the code associated with the ifx
+ * is generated */
} resolvedIfx;
extern int pic14_ptrRegReq ;
/*-----------------------------------------------------------------*/
static int my_powof2 (unsigned long num)
{
- if(num) {
- if( (num & (num-1)) == 0) {
- int nshifts = -1;
- while(num) {
- num>>=1;
- nshifts++;
- }
- return nshifts;
- }
- }
-
- return -1;
+ if(num) {
+ if( (num & (num-1)) == 0) {
+ int nshifts = -1;
+ while(num) {
+ num>>=1;
+ nshifts++;
+ }
+ return nshifts;
+ }
+ }
+
+ return -1;
}
void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *result)
{
-
- DEBUGpic14_emitcode ("; ","line = %d result %s=%s, left %s=%s, right %s=%s, size = %d",
- line_no,
- ((result) ? AopType(AOP_TYPE(result)) : "-"),
- ((result) ? aopGet(AOP(result),0,TRUE,FALSE) : "-"),
- ((left) ? AopType(AOP_TYPE(left)) : "-"),
- ((left) ? aopGet(AOP(left),0,TRUE,FALSE) : "-"),
- ((right) ? AopType(AOP_TYPE(right)) : "-"),
- ((right) ? aopGet(AOP(right),0,FALSE,FALSE) : "-"),
- ((result) ? AOP_SIZE(result) : 0));
-
+
+ DEBUGpic14_emitcode ("; ","line = %d result %s=%s, left %s=%s, right %s=%s, size = %d",
+ line_no,
+ ((result) ? AopType(AOP_TYPE(result)) : "-"),
+ ((result) ? aopGet(AOP(result),0,TRUE,FALSE) : "-"),
+ ((left) ? AopType(AOP_TYPE(left)) : "-"),
+ ((left) ? aopGet(AOP(left),0,TRUE,FALSE) : "-"),
+ ((right) ? AopType(AOP_TYPE(right)) : "-"),
+ ((right) ? aopGet(AOP(right),0,FALSE,FALSE) : "-"),
+ ((result) ? AOP_SIZE(result) : 0));
+
}
void DEBUGpic14_AopTypeSign(int line_no, operand *left, operand *right, operand *result)
{
-
- DEBUGpic14_emitcode ("; ","line = %d, signs: result %s=%c, left %s=%c, right %s=%c",
- line_no,
- ((result) ? AopType(AOP_TYPE(result)) : "-"),
- ((result) ? (SPEC_USIGN(operandType(result)) ? 'u' : 's') : '-'),
- ((left) ? AopType(AOP_TYPE(left)) : "-"),
- ((left) ? (SPEC_USIGN(operandType(left)) ? 'u' : 's') : '-'),
- ((right) ? AopType(AOP_TYPE(right)) : "-"),
- ((right) ? (SPEC_USIGN(operandType(right)) ? 'u' : 's') : '-'));
-
+
+ DEBUGpic14_emitcode ("; ","line = %d, signs: result %s=%c, left %s=%c, right %s=%c",
+ line_no,
+ ((result) ? AopType(AOP_TYPE(result)) : "-"),
+ ((result) ? (SPEC_USIGN(operandType(result)) ? 'u' : 's') : '-'),
+ ((left) ? AopType(AOP_TYPE(left)) : "-"),
+ ((left) ? (SPEC_USIGN(operandType(left)) ? 'u' : 's') : '-'),
+ ((right) ? AopType(AOP_TYPE(right)) : "-"),
+ ((right) ? (SPEC_USIGN(operandType(right)) ? 'u' : 's') : '-'));
+
}
void DEBUGpic14_emitcode (char *inst,char *fmt, ...)
{
- va_list ap;
- char lb[INITIAL_INLINEASM];
- char *lbp = lb;
-
- if(!debug_verbose)
- return;
-
- va_start(ap,fmt);
-
- if (inst && *inst) {
- if (fmt && *fmt)
- sprintf(lb,"%s\t",inst);
- else
- sprintf(lb,"%s",inst);
- vsprintf(lb+(strlen(lb)),fmt,ap);
- } else
- vsprintf(lb,fmt,ap);
-
- while (isspace(*lbp)) lbp++;
-
- if (lbp && *lbp)
- lineCurr = (lineCurr ?
- connectLine(lineCurr,newLineNode(lb)) :
- (lineHead = newLineNode(lb)));
- lineCurr->isInline = _G.inLine;
- lineCurr->isDebug = _G.debugLine;
-
- addpCode2pBlock(pb,newpCodeCharP(lb));
-
- va_end(ap);
+ va_list ap;
+ char lb[INITIAL_INLINEASM];
+ char *lbp = lb;
+
+ if(!debug_verbose)
+ return;
+
+ va_start(ap,fmt);
+
+ if (inst && *inst) {
+ if (fmt && *fmt)
+ sprintf(lb,"%s\t",inst);
+ else
+ sprintf(lb,"%s",inst);
+ vsprintf(lb+(strlen(lb)),fmt,ap);
+ } else
+ vsprintf(lb,fmt,ap);
+
+ while (isspace(*lbp)) lbp++;
+
+ if (lbp && *lbp)
+ lineCurr = (lineCurr ?
+ connectLine(lineCurr,newLineNode(lb)) :
+ (lineHead = newLineNode(lb)));
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+
+ addpCode2pBlock(pb,newpCodeCharP(lb));
+
+ va_end(ap);
}
void emitpLabel(int key)
{
- addpCode2pBlock(pb,newpCodeLabel(NULL,key+100+labelOffset));
+ addpCode2pBlock(pb,newpCodeLabel(NULL,key+100+labelOffset));
}
void emitpcode(PIC_OPCODE poc, pCodeOp *pcop)
{
- if(pcop)
- addpCode2pBlock(pb,newpCode(poc,pcop));
- else
- DEBUGpic14_emitcode(";","%s ignoring NULL pcop",__FUNCTION__);
+ if(pcop)
+ addpCode2pBlock(pb,newpCode(poc,pcop));
+ else
+ DEBUGpic14_emitcode(";","%s ignoring NULL pcop",__FUNCTION__);
}
void emitpcodeNULLop(PIC_OPCODE poc)
{
-
- addpCode2pBlock(pb,newpCode(poc,NULL));
-
+
+ addpCode2pBlock(pb,newpCode(poc,NULL));
+
}
/*-----------------------------------------------------------------*/
void pic14_emitcode (char *inst,char *fmt, ...)
{
- va_list ap;
- char lb[INITIAL_INLINEASM];
- char *lbp = lb;
-
- va_start(ap,fmt);
-
- if (inst && *inst) {
- if (fmt && *fmt)
- sprintf(lb,"%s\t",inst);
- else
- sprintf(lb,"%s",inst);
- vsprintf(lb+(strlen(lb)),fmt,ap);
- } else
- vsprintf(lb,fmt,ap);
-
- while (isspace(*lbp)) lbp++;
-
- if (lbp && *lbp)
- lineCurr = (lineCurr ?
- connectLine(lineCurr,newLineNode(lb)) :
- (lineHead = newLineNode(lb)));
- lineCurr->isInline = _G.inLine;
- lineCurr->isDebug = _G.debugLine;
-
- if(debug_verbose)
- addpCode2pBlock(pb,newpCodeCharP(lb));
-
- va_end(ap);
+ va_list ap;
+ char lb[INITIAL_INLINEASM];
+ char *lbp = lb;
+
+ va_start(ap,fmt);
+
+ if (inst && *inst) {
+ if (fmt && *fmt)
+ sprintf(lb,"%s\t",inst);
+ else
+ sprintf(lb,"%s",inst);
+ vsprintf(lb+(strlen(lb)),fmt,ap);
+ } else
+ vsprintf(lb,fmt,ap);
+
+ while (isspace(*lbp)) lbp++;
+
+ if (lbp && *lbp)
+ lineCurr = (lineCurr ?
+ connectLine(lineCurr,newLineNode(lb)) :
+ (lineHead = newLineNode(lb)));
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+
+ if(debug_verbose)
+ addpCode2pBlock(pb,newpCodeCharP(lb));
+
+ va_end(ap);
}
/*-----------------------------------------------------------------*/
static regs *getFreePtr (iCode *ic, asmop **aopp, bool result)
{
- bool r0iu = FALSE , r1iu = FALSE;
- bool r0ou = FALSE , r1ou = FALSE;
-
- /* the logic: if r0 & r1 used in the instruction
- then we are in trouble otherwise */
-
- /* first check if r0 & r1 are used by this
- instruction, in which case we are in trouble */
- if ((r0iu = bitVectBitValue(ic->rUsed,R0_IDX)) &&
- (r1iu = bitVectBitValue(ic->rUsed,R1_IDX)))
- {
- goto endOfWorld;
- }
-
- r0ou = bitVectBitValue(ic->rMask,R0_IDX);
- r1ou = bitVectBitValue(ic->rMask,R1_IDX);
-
- /* if no usage of r0 then return it */
- if (!r0iu && !r0ou) {
- ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
- (*aopp)->type = AOP_R0;
-
- return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
- }
-
- /* if no usage of r1 then return it */
- if (!r1iu && !r1ou) {
- ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
- (*aopp)->type = AOP_R1;
-
- return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R1_IDX);
- }
-
- /* now we know they both have usage */
- /* if r0 not used in this instruction */
- if (!r0iu) {
- /* push it if not already pushed */
- if (!_G.r0Pushed) {
- //pic14_emitcode ("push","%s",
- // pic14_regWithIdx(R0_IDX)->dname);
- _G.r0Pushed++ ;
- }
-
- ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
- (*aopp)->type = AOP_R0;
-
- return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
- }
-
- /* if r1 not used then */
-
- if (!r1iu) {
- /* push it if not already pushed */
- if (!_G.r1Pushed) {
- //pic14_emitcode ("push","%s",
- // pic14_regWithIdx(R1_IDX)->dname);
- _G.r1Pushed++ ;
- }
-
- ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
- (*aopp)->type = AOP_R1;
- return pic14_regWithIdx(R1_IDX);
- }
-
+ bool r0iu = FALSE , r1iu = FALSE;
+ bool r0ou = FALSE , r1ou = FALSE;
+
+ /* the logic: if r0 & r1 used in the instruction
+ then we are in trouble otherwise */
+
+ /* first check if r0 & r1 are used by this
+ instruction, in which case we are in trouble */
+ if ((r0iu = bitVectBitValue(ic->rUsed,R0_IDX)) &&
+ (r1iu = bitVectBitValue(ic->rUsed,R1_IDX)))
+ {
+ goto endOfWorld;
+ }
+
+ r0ou = bitVectBitValue(ic->rMask,R0_IDX);
+ r1ou = bitVectBitValue(ic->rMask,R1_IDX);
+
+ /* if no usage of r0 then return it */
+ if (!r0iu && !r0ou) {
+ ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
+ (*aopp)->type = AOP_R0;
+
+ return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
+ }
+
+ /* if no usage of r1 then return it */
+ if (!r1iu && !r1ou) {
+ ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
+ (*aopp)->type = AOP_R1;
+
+ return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R1_IDX);
+ }
+
+ /* now we know they both have usage */
+ /* if r0 not used in this instruction */
+ if (!r0iu) {
+ /* push it if not already pushed */
+ if (!_G.r0Pushed) {
+ //pic14_emitcode ("push","%s",
+ // pic14_regWithIdx(R0_IDX)->dname);
+ _G.r0Pushed++ ;
+ }
+
+ ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
+ (*aopp)->type = AOP_R0;
+
+ return (*aopp)->aopu.aop_ptr = pic14_regWithIdx(R0_IDX);
+ }
+
+ /* if r1 not used then */
+
+ if (!r1iu) {
+ /* push it if not already pushed */
+ if (!_G.r1Pushed) {
+ //pic14_emitcode ("push","%s",
+ // pic14_regWithIdx(R1_IDX)->dname);
+ _G.r1Pushed++ ;
+ }
+
+ ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
+ (*aopp)->type = AOP_R1;
+ return pic14_regWithIdx(R1_IDX);
+ }
+
endOfWorld :
- /* I said end of world but not quite end of world yet */
- /* if this is a result then we can push it on the stack*/
- if (result) {
- (*aopp)->type = AOP_STK;
- return NULL;
- }
-
- /* other wise this is true end of the world */
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "getFreePtr should never reach here");
- exit(0);
+ /* I said end of world but not quite end of world yet */
+ /* if this is a result then we can push it on the stack*/
+ if (result) {
+ (*aopp)->type = AOP_STK;
+ return NULL;
+ }
+
+ /* other wise this is true end of the world */
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "getFreePtr should never reach here");
+ exit(0);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
asmop *newAsmop (short type)
{
- asmop *aop;
-
- aop = Safe_calloc(1,sizeof(asmop));
- aop->type = type;
- return aop;
+ asmop *aop;
+
+ aop = Safe_calloc(1,sizeof(asmop));
+ aop->type = type;
+ return aop;
}
static void genSetDPTR(int n)
{
- if (!n)
- {
- pic14_emitcode(";", "Select standard DPTR");
- pic14_emitcode("mov", "dps, #0x00");
- }
- else
- {
- pic14_emitcode(";", "Select alternate DPTR");
- pic14_emitcode("mov", "dps, #0x01");
- }
+ if (!n)
+ {
+ pic14_emitcode(";", "Select standard DPTR");
+ pic14_emitcode("mov", "dps, #0x00");
+ }
+ else
+ {
+ pic14_emitcode(";", "Select alternate DPTR");
+ pic14_emitcode("mov", "dps, #0x01");
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
{
- if(!resIfx)
- return;
-
- // DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
-
- resIfx->condition = 1; /* assume that the ifx is true */
- resIfx->generated = 0; /* indicate that the ifx has not been used */
-
- if(!ifx) {
- resIfx->lbl = newiTempLabel(NULL); /* oops, there is no ifx. so create a label */
-/*
- DEBUGpic14_emitcode("; ***","%s %d null ifx creating new label key =%d",
- __FUNCTION__,__LINE__,resIfx->lbl->key);
-*/
- } else {
- if(IC_TRUE(ifx)) {
- resIfx->lbl = IC_TRUE(ifx);
- } else {
- resIfx->lbl = IC_FALSE(ifx);
- resIfx->condition = 0;
- }
-/*
- if(IC_TRUE(ifx))
- DEBUGpic14_emitcode("; ***","ifx true is non-null");
- if(IC_FALSE(ifx))
- DEBUGpic14_emitcode("; ***","ifx false is non-null");
-*/
- }
-
- // DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
-
+ if(!resIfx)
+ return;
+
+ // DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ resIfx->condition = 1; /* assume that the ifx is true */
+ resIfx->generated = 0; /* indicate that the ifx has not been used */
+
+ if(!ifx) {
+ resIfx->lbl = newiTempLabel(NULL); /* oops, there is no ifx. so create a label */
+ /*
+ DEBUGpic14_emitcode("; ***","%s %d null ifx creating new label key =%d",
+ __FUNCTION__,__LINE__,resIfx->lbl->key);
+ */
+ } else {
+ if(IC_TRUE(ifx)) {
+ resIfx->lbl = IC_TRUE(ifx);
+ } else {
+ resIfx->lbl = IC_FALSE(ifx);
+ resIfx->condition = 0;
+ }
+ /*
+ if(IC_TRUE(ifx))
+ DEBUGpic14_emitcode("; ***","ifx true is non-null");
+ if(IC_FALSE(ifx))
+ DEBUGpic14_emitcode("; ***","ifx false is non-null");
+ */
+ }
+
+ // DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
+
}
/*-----------------------------------------------------------------*/
/* pointerCode - returns the code for a pointer type */
/*-----------------------------------------------------------------*/
static int pointerCode (sym_link *etype)
{
-
- return PTR_TYPE(SPEC_OCLS(etype));
-
+
+ return PTR_TYPE(SPEC_OCLS(etype));
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static asmop *aopForSym (iCode *ic,symbol *sym,bool result)
{
- asmop *aop;
- memmap *space= SPEC_OCLS(sym->etype);
-
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if already has one */
- if (sym->aop)
- return sym->aop;
-
- /* assign depending on the storage class */
- /* if it is on the stack or indirectly addressable */
- /* space we need to assign either r0 or r1 to it */
- if ((sym->onStack && !options.stack10bit) || sym->iaccess) {
- sym->aop = aop = newAsmop(0);
- aop->aopu.aop_ptr = getFreePtr(ic,&aop,result);
- aop->size = getSize(sym->type);
-
- /* now assign the address of the variable to
- the pointer register */
- if (aop->type != AOP_STK) {
-
- if (sym->onStack) {
- if ( _G.accInUse )
- pic14_emitcode("push","acc");
-
- pic14_emitcode("mov","a,_bp");
- pic14_emitcode("add","a,#0x%02x",
- ((sym->stack < 0) ?
- ((char)(sym->stack - _G.nRegsSaved )) :
- ((char)sym->stack)) & 0xff);
- pic14_emitcode("mov","%s,a",
- aop->aopu.aop_ptr->name);
-
- if ( _G.accInUse )
- pic14_emitcode("pop","acc");
- } else
- pic14_emitcode("mov","%s,#%s",
- aop->aopu.aop_ptr->name,
- sym->rname);
- aop->paged = space->paged;
- } else
- aop->aopu.aop_stk = sym->stack;
- return aop;
- }
-
- if (sym->onStack && options.stack10bit)
- {
- /* It's on the 10 bit stack, which is located in
- * far data space.
- */
-
- //DEBUGpic14_emitcode(";","%d",__LINE__);
-
- if ( _G.accInUse )
- pic14_emitcode("push","acc");
-
- pic14_emitcode("mov","a,_bp");
- pic14_emitcode("add","a,#0x%02x",
- ((sym->stack < 0) ?
- ((char)(sym->stack - _G.nRegsSaved )) :
- ((char)sym->stack)) & 0xff);
-
- genSetDPTR(1);
- pic14_emitcode ("mov","dpx1,#0x40");
- pic14_emitcode ("mov","dph1,#0x00");
- pic14_emitcode ("mov","dpl1, a");
- genSetDPTR(0);
-
- if ( _G.accInUse )
- pic14_emitcode("pop","acc");
-
- sym->aop = aop = newAsmop(AOP_DPTR2);
- aop->size = getSize(sym->type);
- return aop;
- }
-
- //DEBUGpic14_emitcode(";","%d",__LINE__);
- /* if in bit space */
- if (IN_BITSPACE(space)) {
- sym->aop = aop = newAsmop (AOP_CRY);
- aop->aopu.aop_dir = sym->rname ;
- aop->size = getSize(sym->type);
- //DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
- return aop;
- }
- /* if it is in direct space */
- if (IN_DIRSPACE(space)) {
- sym->aop = aop = newAsmop (AOP_DIR);
- aop->aopu.aop_dir = sym->rname ;
- aop->size = getSize(sym->type);
- DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
- return aop;
- }
-
- /* special case for a function */
- if (IS_FUNC(sym->type)) {
-
- sym->aop = aop = newAsmop(AOP_PCODE);
- aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
- PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
- PCOI(aop->aopu.pcop)->_function = 1;
- PCOI(aop->aopu.pcop)->index = 0;
- aop->size = FPTRSIZE;
- /*
- sym->aop = aop = newAsmop(AOP_IMMD);
- aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
- strcpy(aop->aopu.aop_immd,sym->rname);
- aop->size = FPTRSIZE;
- */
+ asmop *aop;
+ memmap *space= SPEC_OCLS(sym->etype);
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if already has one */
+ if (sym->aop)
+ return sym->aop;
+
+ /* assign depending on the storage class */
+ /* if it is on the stack or indirectly addressable */
+ /* space we need to assign either r0 or r1 to it */
+ if ((sym->onStack && !options.stack10bit) || sym->iaccess) {
+ sym->aop = aop = newAsmop(0);
+ aop->aopu.aop_ptr = getFreePtr(ic,&aop,result);
+ aop->size = getSize(sym->type);
+
+ /* now assign the address of the variable to
+ the pointer register */
+ if (aop->type != AOP_STK) {
+
+ if (sym->onStack) {
+ if ( _G.accInUse )
+ pic14_emitcode("push","acc");
+
+ pic14_emitcode("mov","a,_bp");
+ pic14_emitcode("add","a,#0x%02x",
+ ((sym->stack < 0) ?
+ ((char)(sym->stack - _G.nRegsSaved )) :
+ ((char)sym->stack)) & 0xff);
+ pic14_emitcode("mov","%s,a",
+ aop->aopu.aop_ptr->name);
+
+ if ( _G.accInUse )
+ pic14_emitcode("pop","acc");
+ } else
+ pic14_emitcode("mov","%s,#%s",
+ aop->aopu.aop_ptr->name,
+ sym->rname);
+ aop->paged = space->paged;
+ } else
+ aop->aopu.aop_stk = sym->stack;
+ return aop;
+ }
+
+ if (sym->onStack && options.stack10bit)
+ {
+ /* It's on the 10 bit stack, which is located in
+ * far data space.
+ */
+
+ //DEBUGpic14_emitcode(";","%d",__LINE__);
+
+ if ( _G.accInUse )
+ pic14_emitcode("push","acc");
+
+ pic14_emitcode("mov","a,_bp");
+ pic14_emitcode("add","a,#0x%02x",
+ ((sym->stack < 0) ?
+ ((char)(sym->stack - _G.nRegsSaved )) :
+ ((char)sym->stack)) & 0xff);
+
+ genSetDPTR(1);
+ pic14_emitcode ("mov","dpx1,#0x40");
+ pic14_emitcode ("mov","dph1,#0x00");
+ pic14_emitcode ("mov","dpl1, a");
+ genSetDPTR(0);
+
+ if ( _G.accInUse )
+ pic14_emitcode("pop","acc");
+
+ sym->aop = aop = newAsmop(AOP_DPTR2);
+ aop->size = getSize(sym->type);
+ return aop;
+ }
+
+ //DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* if in bit space */
+ if (IN_BITSPACE(space)) {
+ sym->aop = aop = newAsmop (AOP_CRY);
+ aop->aopu.aop_dir = sym->rname ;
+ aop->size = getSize(sym->type);
+ //DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
+ return aop;
+ }
+ /* if it is in direct space */
+ if (IN_DIRSPACE(space)) {
+ sym->aop = aop = newAsmop (AOP_DIR);
+ aop->aopu.aop_dir = sym->rname ;
+ aop->size = getSize(sym->type);
+ DEBUGpic14_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
+ return aop;
+ }
+
+ /* special case for a function */
+ if (IS_FUNC(sym->type)) {
+
+ sym->aop = aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,1);
+ PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+ PCOI(aop->aopu.pcop)->_function = 1;
+ PCOI(aop->aopu.pcop)->index = 0;
+ aop->size = FPTRSIZE;
+ /*
+ sym->aop = aop = newAsmop(AOP_IMMD);
+ aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
+ strcpy(aop->aopu.aop_immd,sym->rname);
+ aop->size = FPTRSIZE;
+ */
+ DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
+ return aop;
+ }
+
+
+ /* only remaining is far space */
+ /* in which case DPTR gets the address */
+ sym->aop = aop = newAsmop(AOP_PCODE);
+
+ aop->aopu.pcop = popGetImmd(sym->rname,0,0,0);
+ PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+ PCOI(aop->aopu.pcop)->index = 0;
+
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+
+ allocDirReg (IC_LEFT(ic));
+
+ aop->size = FPTRSIZE;
+ /*
DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
- return aop;
- }
-
-
- /* only remaining is far space */
- /* in which case DPTR gets the address */
- sym->aop = aop = newAsmop(AOP_PCODE);
-
- aop->aopu.pcop = popGetImmd(sym->rname,0,0,0);
- PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
- PCOI(aop->aopu.pcop)->index = 0;
-
- DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
- __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
-
- allocDirReg (IC_LEFT(ic));
-
- aop->size = FPTRSIZE;
-/*
- DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
- sym->aop = aop = newAsmop(AOP_DPTR);
- pic14_emitcode ("mov","dptr,#%s", sym->rname);
- aop->size = getSize(sym->type);
-
- DEBUGpic14_emitcode(";","%d size = %d",__LINE__,aop->size);
-*/
-
- /* if it is in code space */
- if (IN_CODESPACE(space))
- aop->code = 1;
-
- return aop;
+ sym->aop = aop = newAsmop(AOP_DPTR);
+ pic14_emitcode ("mov","dptr,#%s", sym->rname);
+ aop->size = getSize(sym->type);
+
+ DEBUGpic14_emitcode(";","%d size = %d",__LINE__,aop->size);
+ */
+
+ /* if it is in code space */
+ if (IN_CODESPACE(space))
+ aop->code = 1;
+
+ return aop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static asmop *aopForRemat (operand *op) // x symbol *sym)
{
- symbol *sym = OP_SYMBOL(op);
- iCode *ic = NULL;
- asmop *aop = newAsmop(AOP_PCODE);
- int val = 0;
- int offset = 0;
-
- ic = sym->rematiCode;
-
- DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
- if(IS_OP_POINTER(op)) {
- DEBUGpic14_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
- }
- for (;;) {
- if (ic->op == '+') {
- val += (int) operandLitValue(IC_RIGHT(ic));
- } else if (ic->op == '-') {
- val -= (int) operandLitValue(IC_RIGHT(ic));
- } else
- break;
-
- ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
- }
-
- offset = OP_SYMBOL(IC_LEFT(ic))->offset;
- aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val,0);
- PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
- PCOI(aop->aopu.pcop)->index = val;
-
- DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
- __LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
- val, IS_PTR_CONST(operandType(op)));
-
- // DEBUGpic14_emitcode(";","aop type %s",AopType(AOP_TYPE(IC_LEFT(ic))));
-
- allocDirReg (IC_LEFT(ic));
-
- return aop;
+ symbol *sym = OP_SYMBOL(op);
+ iCode *ic = NULL;
+ asmop *aop = newAsmop(AOP_PCODE);
+ int val = 0;
+ int offset = 0;
+
+ ic = sym->rematiCode;
+
+ DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
+ if(IS_OP_POINTER(op)) {
+ DEBUGpic14_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
+ }
+ for (;;) {
+ if (ic->op == '+') {
+ val += (int) operandLitValue(IC_RIGHT(ic));
+ } else if (ic->op == '-') {
+ val -= (int) operandLitValue(IC_RIGHT(ic));
+ } else
+ break;
+
+ ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
+ }
+
+ offset = OP_SYMBOL(IC_LEFT(ic))->offset;
+ aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val,0);
+ PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
+ PCOI(aop->aopu.pcop)->index = val;
+
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
+ val, IS_PTR_CONST(operandType(op)));
+
+ // DEBUGpic14_emitcode(";","aop type %s",AopType(AOP_TYPE(IC_LEFT(ic))));
+
+ allocDirReg (IC_LEFT(ic));
+
+ return aop;
}
int aopIdx (asmop *aop, int offset)
{
- if(!aop)
- return -1;
-
- if(aop->type != AOP_REG)
- return -2;
+ if(!aop)
+ return -1;
+
+ if(aop->type != AOP_REG)
+ return -2;
+
+ return aop->aopu.aop_reg[offset]->rIdx;
- return aop->aopu.aop_reg[offset]->rIdx;
-
}
/*-----------------------------------------------------------------*/
/* regsInCommon - two operands have some registers in common */
/*-----------------------------------------------------------------*/
static bool regsInCommon (operand *op1, operand *op2)
{
- symbol *sym1, *sym2;
- int i;
-
- /* if they have registers in common */
- if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
- return FALSE ;
-
- sym1 = OP_SYMBOL(op1);
- sym2 = OP_SYMBOL(op2);
-
- if (sym1->nRegs == 0 || sym2->nRegs == 0)
- return FALSE ;
-
- for (i = 0 ; i < sym1->nRegs ; i++) {
- int j;
- if (!sym1->regs[i])
- continue ;
-
- for (j = 0 ; j < sym2->nRegs ;j++ ) {
- if (!sym2->regs[j])
- continue ;
-
- if (sym2->regs[j] == sym1->regs[i])
- return TRUE ;
- }
- }
-
- return FALSE ;
+ symbol *sym1, *sym2;
+ int i;
+
+ /* if they have registers in common */
+ if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
+ return FALSE ;
+
+ sym1 = OP_SYMBOL(op1);
+ sym2 = OP_SYMBOL(op2);
+
+ if (sym1->nRegs == 0 || sym2->nRegs == 0)
+ return FALSE ;
+
+ for (i = 0 ; i < sym1->nRegs ; i++) {
+ int j;
+ if (!sym1->regs[i])
+ continue ;
+
+ for (j = 0 ; j < sym2->nRegs ;j++ ) {
+ if (!sym2->regs[j])
+ continue ;
+
+ if (sym2->regs[j] == sym1->regs[i])
+ return TRUE ;
+ }
+ }
+
+ return FALSE ;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static bool operandsEqu ( operand *op1, operand *op2)
{
- symbol *sym1, *sym2;
-
- /* if they not symbols */
- if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
- return FALSE;
-
- sym1 = OP_SYMBOL(op1);
- sym2 = OP_SYMBOL(op2);
-
- /* if both are itemps & one is spilt
- and the other is not then false */
- if (IS_ITEMP(op1) && IS_ITEMP(op2) &&
- sym1->isspilt != sym2->isspilt )
+ symbol *sym1, *sym2;
+
+ /* if they not symbols */
+ if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
+ return FALSE;
+
+ sym1 = OP_SYMBOL(op1);
+ sym2 = OP_SYMBOL(op2);
+
+ /* if both are itemps & one is spilt
+ and the other is not then false */
+ if (IS_ITEMP(op1) && IS_ITEMP(op2) &&
+ sym1->isspilt != sym2->isspilt )
+ return FALSE ;
+
+ /* if they are the same */
+ if (sym1 == sym2)
+ return TRUE ;
+
+ if (strcmp(sym1->rname,sym2->rname) == 0)
+ return TRUE;
+
+
+ /* if left is a tmp & right is not */
+ if (IS_ITEMP(op1) &&
+ !IS_ITEMP(op2) &&
+ sym1->isspilt &&
+ (sym1->usl.spillLoc == sym2))
+ return TRUE;
+
+ if (IS_ITEMP(op2) &&
+ !IS_ITEMP(op1) &&
+ sym2->isspilt &&
+ sym1->level > 0 &&
+ (sym2->usl.spillLoc == sym1))
+ return TRUE ;
+
return FALSE ;
-
- /* if they are the same */
- if (sym1 == sym2)
- return TRUE ;
-
- if (strcmp(sym1->rname,sym2->rname) == 0)
- return TRUE;
-
-
- /* if left is a tmp & right is not */
- if (IS_ITEMP(op1) &&
- !IS_ITEMP(op2) &&
- sym1->isspilt &&
- (sym1->usl.spillLoc == sym2))
- return TRUE;
-
- if (IS_ITEMP(op2) &&
- !IS_ITEMP(op1) &&
- sym2->isspilt &&
- sym1->level > 0 &&
- (sym2->usl.spillLoc == sym1))
- return TRUE ;
-
- return FALSE ;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
bool pic14_sameRegs (asmop *aop1, asmop *aop2 )
{
- int i;
-
- if (aop1 == aop2)
- return TRUE ;
-
- if (aop1->type != AOP_REG ||
- aop2->type != AOP_REG )
- return FALSE ;
-
- if (aop1->size != aop2->size )
- return FALSE ;
-
- for (i = 0 ; i < aop1->size ; i++ )
- if (aop1->aopu.aop_reg[i] !=
- aop2->aopu.aop_reg[i] )
- return FALSE ;
-
- return TRUE ;
+ int i;
+
+ if (aop1 == aop2)
+ return TRUE ;
+
+ if (aop1->type != AOP_REG ||
+ aop2->type != AOP_REG )
+ return FALSE ;
+
+ if (aop1->size != aop2->size )
+ return FALSE ;
+
+ for (i = 0 ; i < aop1->size ; i++ )
+ if (aop1->aopu.aop_reg[i] !=
+ aop2->aopu.aop_reg[i] )
+ return FALSE ;
+
+ return TRUE ;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void aopOp (operand *op, iCode *ic, bool result)
{
- asmop *aop;
- symbol *sym;
- int i;
-
- if (!op)
- return ;
-
- // DEBUGpic14_emitcode(";","%d",__LINE__);
- /* if this a literal */
- if (IS_OP_LITERAL(op)) {
- op->aop = aop = newAsmop(AOP_LIT);
- aop->aopu.aop_lit = op->operand.valOperand;
- aop->size = getSize(operandType(op));
- return;
- }
-
- {
- sym_link *type = operandType(op);
- if(IS_PTR_CONST(type))
- DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
- }
-
- /* if already has a asmop then continue */
- if (op->aop)
- return ;
-
- /* if the underlying symbol has a aop */
- if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
- DEBUGpic14_emitcode(";","%d",__LINE__);
- op->aop = OP_SYMBOL(op)->aop;
- return;
- }
-
- /* if this is a true symbol */
- if (IS_TRUE_SYMOP(op)) {
- //DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
- op->aop = aopForSym(ic,OP_SYMBOL(op),result);
- return ;
- }
-
- /* this is a temporary : this has
- only four choices :
- a) register
- b) spillocation
- c) rematerialize
- d) conditional
- e) can be a return use only */
-
- sym = OP_SYMBOL(op);
-
-
- /* if the type is a conditional */
- if (sym->regType == REG_CND) {
- aop = op->aop = sym->aop = newAsmop(AOP_CRY);
- aop->size = 0;
- return;
- }
-
- /* if it is spilt then two situations
- a) is rematerialize
- b) has a spill location */
- if (sym->isspilt || sym->nRegs == 0) {
-
- DEBUGpic14_emitcode(";","%d",__LINE__);
- /* rematerialize it NOW */
- if (sym->remat) {
-
- sym->aop = op->aop = aop =
- aopForRemat (op);
- aop->size = getSize(sym->type);
- //DEBUGpic14_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
- return;
- }
-
- if (sym->accuse) {
- int i;
- aop = op->aop = sym->aop = newAsmop(AOP_ACC);
- aop->size = getSize(sym->type);
- for ( i = 0 ; i < 2 ; i++ )
- aop->aopu.aop_str[i] = accUse[i];
- DEBUGpic14_emitcode(";","%d size=%d",__LINE__,aop->size);
- return;
- }
-
- if (sym->ruonly ) {
- if(sym->isptr) { // && sym->uptr
- aop = op->aop = sym->aop = newAsmop(AOP_PCODE);
- aop->aopu.pcop = newpCodeOp(NULL,PO_GPR_POINTER); //popCopyReg(&pc_fsr);
-
- //PCOI(aop->aopu.pcop)->_const = 0;
- //PCOI(aop->aopu.pcop)->index = 0;
- /*
- DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
- __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
- */
- //allocDirReg (IC_LEFT(ic));
-
- aop->size = getSize(sym->type);
- DEBUGpic14_emitcode(";","%d",__LINE__);
- return;
-
- } else {
-
- unsigned i;
-
- aop = op->aop = sym->aop = newAsmop(AOP_STR);
- aop->size = getSize(sym->type);
- for ( i = 0 ; i < fReturnSizePic ; i++ )
- aop->aopu.aop_str[i] = fReturn[i];
-
- DEBUGpic14_emitcode(";","%d",__LINE__);
- return;
- }
- }
-
- /* else spill location */
- if (sym->usl.spillLoc && getSize(sym->type) != getSize(sym->usl.spillLoc->type)) {
- /* force a new aop if sizes differ */
- sym->usl.spillLoc->aop = NULL;
+ asmop *aop;
+ symbol *sym;
+ int i;
+
+ if (!op)
+ return ;
+
+ // DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* if this a literal */
+ if (IS_OP_LITERAL(op)) {
+ op->aop = aop = newAsmop(AOP_LIT);
+ aop->aopu.aop_lit = op->operand.valOperand;
+ aop->size = getSize(operandType(op));
+ return;
}
- DEBUGpic14_emitcode(";","%s %d %s sym->rname = %s, offset %d",
- __FUNCTION__,__LINE__,
- sym->usl.spillLoc->rname,
- sym->rname, sym->usl.spillLoc->offset);
-
- sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
- //aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
- aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
- getSize(sym->type),
- sym->usl.spillLoc->offset);
- aop->size = getSize(sym->type);
-
- return;
- }
-
- {
- sym_link *type = operandType(op);
- if(IS_PTR_CONST(type))
- DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
- }
-
- /* must be in a register */
- DEBUGpic14_emitcode(";","%d register type nRegs=%d",__LINE__,sym->nRegs);
- sym->aop = op->aop = aop = newAsmop(AOP_REG);
- aop->size = sym->nRegs;
- for ( i = 0 ; i < sym->nRegs ;i++)
- aop->aopu.aop_reg[i] = sym->regs[i];
-}
-
-/*-----------------------------------------------------------------*/
-/* freeAsmop - free up the asmop given to an operand */
-/*----------------------------------------------------------------*/
-void freeAsmop (operand *op, asmop *aaop, iCode *ic, bool pop)
-{
- asmop *aop ;
-
- if (!op)
- aop = aaop;
- else
- aop = op->aop;
-
- if (!aop)
- return ;
-
- if (aop->freed)
- goto dealloc;
-
- aop->freed = 1;
-
- /* depending on the asmop type only three cases need work AOP_RO
- , AOP_R1 && AOP_STK */
-#if 0
- switch (aop->type) {
- case AOP_R0 :
- if (_G.r0Pushed ) {
- if (pop) {
- pic14_emitcode ("pop","ar0");
- _G.r0Pushed--;
- }
- }
- bitVectUnSetBit(ic->rUsed,R0_IDX);
- break;
-
- case AOP_R1 :
- if (_G.r1Pushed ) {
- if (pop) {
- pic14_emitcode ("pop","ar1");
- _G.r1Pushed--;
- }
- }
- bitVectUnSetBit(ic->rUsed,R1_IDX);
- break;
-
- case AOP_STK :
- {
- int sz = aop->size;
- int stk = aop->aopu.aop_stk + aop->size;
- bitVectUnSetBit(ic->rUsed,R0_IDX);
- bitVectUnSetBit(ic->rUsed,R1_IDX);
-
- getFreePtr(ic,&aop,FALSE);
-
- if (options.stack10bit)
- {
- /* I'm not sure what to do here yet... */
- /* #STUB */
- fprintf(stderr,
- "*** Warning: probably generating bad code for "
- "10 bit stack mode.\n");
- }
-
- if (stk) {
- pic14_emitcode ("mov","a,_bp");
- pic14_emitcode ("add","a,#0x%02x",((char)stk) & 0xff);
- pic14_emitcode ("mov","%s,a",aop->aopu.aop_ptr->name);
- } else {
- pic14_emitcode ("mov","%s,_bp",aop->aopu.aop_ptr->name);
- }
-
- while (sz--) {
- pic14_emitcode("pop","acc");
- pic14_emitcode("mov","@%s,a",aop->aopu.aop_ptr->name);
- if (!sz) break;
- pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
- }
- op->aop = aop;
- freeAsmop(op,NULL,ic,TRUE);
- if (_G.r0Pushed) {
- pic14_emitcode("pop","ar0");
- _G.r0Pushed--;
- }
-
- if (_G.r1Pushed) {
- pic14_emitcode("pop","ar1");
- _G.r1Pushed--;
- }
- }
- }
-#endif
-
-dealloc:
- /* all other cases just dealloc */
- if (op ) {
- op->aop = NULL;
- if (IS_SYMOP(op)) {
- OP_SYMBOL(op)->aop = NULL;
- /* if the symbol has a spill */
- if (SPIL_LOC(op))
- SPIL_LOC(op)->aop = NULL;
- }
- }
-}
-
-/*-----------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop */
-/*-----------------------------------------------------------------*/
-char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
-{
- char *s = buffer ;
- char *rs;
-
- //DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* offset is greater than
- size then zero */
- if (offset > (aop->size - 1) &&
- aop->type != AOP_LIT)
- return zero;
-
- /* depending on type */
- switch (aop->type) {
- case AOP_R0:
- case AOP_R1:
- DEBUGpic14_emitcode(";","%d",__LINE__);
- /* if we need to increment it */
- while (offset > aop->coff) {
- pic14_emitcode ("inc","%s",aop->aopu.aop_ptr->name);
- aop->coff++;
+ {
+ sym_link *type = operandType(op);
+ if(IS_PTR_CONST(type))
+ DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
}
- while (offset < aop->coff) {
- pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
- aop->coff--;
+ /* if already has a asmop then continue */
+ if (op->aop)
+ return ;
+
+ /* if the underlying symbol has a aop */
+ if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ op->aop = OP_SYMBOL(op)->aop;
+ return;
}
- aop->coff = offset ;
- if (aop->paged) {
- pic14_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;
-
- case AOP_DPTR:
- case AOP_DPTR2:
- DEBUGpic14_emitcode(";","%d",__LINE__);
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(1);
- }
-
- while (offset > aop->coff) {
- pic14_emitcode ("inc","dptr");
- aop->coff++;
- }
-
- while (offset < aop->coff) {
- pic14_emitcode("lcall","__decdptr");
- aop->coff--;
- }
-
- aop->coff = offset;
- if (aop->code) {
- pic14_emitcode("clr","a");
- pic14_emitcode("movc","a,@a+dptr");
- }
- else {
- pic14_emitcode("movx","a,@dptr");
- }
-
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(0);
- }
-
- return (dname ? "acc" : "a");
-
-
- case AOP_IMMD:
- if (bit16)
- sprintf (s,"%s",aop->aopu.aop_immd);
- else
- if (offset)
- sprintf(s,"(%s >> %d)",
- aop->aopu.aop_immd,
- offset*8);
- else
- sprintf(s,"%s",
- aop->aopu.aop_immd);
- DEBUGpic14_emitcode(";","%d immd %s",__LINE__,s);
- rs = Safe_calloc(1,strlen(s)+1);
- strcpy(rs,s);
- return rs;
-
- case AOP_DIR:
- if (offset) {
- sprintf(s,"(%s + %d)",
- aop->aopu.aop_dir,
- offset);
- DEBUGpic14_emitcode(";","oops AOP_DIR did this %s\n",s);
- } else
- sprintf(s,"%s",aop->aopu.aop_dir);
- rs = Safe_calloc(1,strlen(s)+1);
- strcpy(rs,s);
- return rs;
-
- case AOP_REG:
- //if (dname)
- // return aop->aopu.aop_reg[offset]->dname;
- //else
- return aop->aopu.aop_reg[offset]->name;
-
- case AOP_CRY:
- //pic14_emitcode(";","%d",__LINE__);
- return aop->aopu.aop_dir;
-
- case AOP_ACC:
- DEBUGpic14_emitcode(";Warning -pic port ignoring get(AOP_ACC)","%d",__LINE__);
- return "AOP_accumulator_bug";
-
- case AOP_LIT:
- sprintf(s,"0x%02x", pic14aopLiteral (aop->aopu.aop_lit,offset));
- rs = Safe_calloc(1,strlen(s)+1);
- strcpy(rs,s);
- return rs;
-
- case AOP_STR:
- aop->coff = offset ;
- if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
- dname)
- return "acc";
- DEBUGpic14_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
-
- return aop->aopu.aop_str[offset];
-
- case AOP_PCODE:
- {
- pCodeOp *pcop = aop->aopu.pcop;
- DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
- if(pcop->name) {
- DEBUGpic14_emitcode(";","%s offset %d",pcop->name,PCOI(pcop)->offset);
- //sprintf(s,"(%s+0x%02x)", pcop->name,PCOI(aop->aopu.pcop)->offset);
- sprintf(s,"%s", pcop->name);
- } else
- sprintf(s,"0x%02x", PCOI(aop->aopu.pcop)->offset);
-
- }
- rs = Safe_calloc(1,strlen(s)+1);
- strcpy(rs,s);
- return rs;
+ /* if this is a true symbol */
+ if (IS_TRUE_SYMOP(op)) {
+ //DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
+ op->aop = aopForSym(ic,OP_SYMBOL(op),result);
+ return ;
+ }
+
+ /* this is a temporary : this has
+ only four choices :
+ a) register
+ b) spillocation
+ c) rematerialize
+ d) conditional
+ e) can be a return use only */
+
+ sym = OP_SYMBOL(op);
+
+
+ /* if the type is a conditional */
+ if (sym->regType == REG_CND) {
+ aop = op->aop = sym->aop = newAsmop(AOP_CRY);
+ aop->size = 0;
+ return;
+ }
+
+ /* if it is spilt then two situations
+ a) is rematerialize
+ b) has a spill location */
+ if (sym->isspilt || sym->nRegs == 0) {
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* rematerialize it NOW */
+ if (sym->remat) {
+
+ sym->aop = op->aop = aop =
+ aopForRemat (op);
+ aop->size = getSize(sym->type);
+ //DEBUGpic14_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
+ return;
+ }
+
+ if (sym->accuse) {
+ int i;
+ aop = op->aop = sym->aop = newAsmop(AOP_ACC);
+ aop->size = getSize(sym->type);
+ for ( i = 0 ; i < 2 ; i++ )
+ aop->aopu.aop_str[i] = accUse[i];
+ DEBUGpic14_emitcode(";","%d size=%d",__LINE__,aop->size);
+ return;
+ }
+
+ if (sym->ruonly ) {
+ if(sym->isptr) { // && sym->uptr
+ aop = op->aop = sym->aop = newAsmop(AOP_PCODE);
+ aop->aopu.pcop = newpCodeOp(NULL,PO_GPR_POINTER); //popCopyReg(&pc_fsr);
+
+ //PCOI(aop->aopu.pcop)->_const = 0;
+ //PCOI(aop->aopu.pcop)->index = 0;
+ /*
+ DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+ __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+ */
+ //allocDirReg (IC_LEFT(ic));
+
+ aop->size = getSize(sym->type);
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return;
+
+ } else {
+
+ unsigned i;
+
+ aop = op->aop = sym->aop = newAsmop(AOP_STR);
+ aop->size = getSize(sym->type);
+ for ( i = 0 ; i < fReturnSizePic ; i++ )
+ aop->aopu.aop_str[i] = fReturn[i];
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return;
+ }
+ }
+
+ /* else spill location */
+ if (sym->usl.spillLoc && getSize(sym->type) != getSize(sym->usl.spillLoc->type)) {
+ /* force a new aop if sizes differ */
+ sym->usl.spillLoc->aop = NULL;
+ }
+ DEBUGpic14_emitcode(";","%s %d %s sym->rname = %s, offset %d",
+ __FUNCTION__,__LINE__,
+ sym->usl.spillLoc->rname,
+ sym->rname, sym->usl.spillLoc->offset);
+
+ sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
+ //aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
+ aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
+ getSize(sym->type),
+ sym->usl.spillLoc->offset);
+ aop->size = getSize(sym->type);
+
+ return;
+ }
+
+ {
+ sym_link *type = operandType(op);
+ if(IS_PTR_CONST(type))
+ DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
+ }
+
+ /* must be in a register */
+ DEBUGpic14_emitcode(";","%d register type nRegs=%d",__LINE__,sym->nRegs);
+ sym->aop = op->aop = aop = newAsmop(AOP_REG);
+ aop->size = sym->nRegs;
+ for ( i = 0 ; i < sym->nRegs ;i++)
+ aop->aopu.aop_reg[i] = sym->regs[i];
+}
- }
+/*-----------------------------------------------------------------*/
+/* freeAsmop - free up the asmop given to an operand */
+/*----------------------------------------------------------------*/
+void freeAsmop (operand *op, asmop *aaop, iCode *ic, bool pop)
+{
+ asmop *aop ;
+
+ if (!op)
+ aop = aaop;
+ else
+ aop = op->aop;
+
+ if (!aop)
+ return ;
+
+ if (aop->freed)
+ goto dealloc;
+
+ aop->freed = 1;
+
+ /* depending on the asmop type only three cases need work AOP_RO
+ , AOP_R1 && AOP_STK */
+#if 0
+ switch (aop->type) {
+ case AOP_R0 :
+ if (_G.r0Pushed ) {
+ if (pop) {
+ pic14_emitcode ("pop","ar0");
+ _G.r0Pushed--;
+ }
+ }
+ bitVectUnSetBit(ic->rUsed,R0_IDX);
+ break;
+
+ case AOP_R1 :
+ if (_G.r1Pushed ) {
+ if (pop) {
+ pic14_emitcode ("pop","ar1");
+ _G.r1Pushed--;
+ }
+ }
+ bitVectUnSetBit(ic->rUsed,R1_IDX);
+ break;
+
+ case AOP_STK :
+ {
+ int sz = aop->size;
+ int stk = aop->aopu.aop_stk + aop->size;
+ bitVectUnSetBit(ic->rUsed,R0_IDX);
+ bitVectUnSetBit(ic->rUsed,R1_IDX);
+
+ getFreePtr(ic,&aop,FALSE);
+
+ if (options.stack10bit)
+ {
+ /* I'm not sure what to do here yet... */
+ /* #STUB */
+ fprintf(stderr,
+ "*** Warning: probably generating bad code for "
+ "10 bit stack mode.\n");
+ }
+
+ if (stk) {
+ pic14_emitcode ("mov","a,_bp");
+ pic14_emitcode ("add","a,#0x%02x",((char)stk) & 0xff);
+ pic14_emitcode ("mov","%s,a",aop->aopu.aop_ptr->name);
+ } else {
+ pic14_emitcode ("mov","%s,_bp",aop->aopu.aop_ptr->name);
+ }
+
+ while (sz--) {
+ pic14_emitcode("pop","acc");
+ pic14_emitcode("mov","@%s,a",aop->aopu.aop_ptr->name);
+ if (!sz) break;
+ pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
+ }
+ op->aop = aop;
+ freeAsmop(op,NULL,ic,TRUE);
+ if (_G.r0Pushed) {
+ pic14_emitcode("pop","ar0");
+ _G.r0Pushed--;
+ }
+
+ if (_G.r1Pushed) {
+ pic14_emitcode("pop","ar1");
+ _G.r1Pushed--;
+ }
+ }
+ }
+#endif
+
+dealloc:
+ /* all other cases just dealloc */
+ if (op ) {
+ op->aop = NULL;
+ if (IS_SYMOP(op)) {
+ OP_SYMBOL(op)->aop = NULL;
+ /* if the symbol has a spill */
+ if (SPIL_LOC(op))
+ SPIL_LOC(op)->aop = NULL;
+ }
+ }
+}
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "aopget got unsupported aop->type");
- exit(0);
+/*-----------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop */
+/*-----------------------------------------------------------------*/
+char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
+{
+ char *s = buffer ;
+ char *rs;
+
+ //DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* offset is greater than
+ size then zero */
+ if (offset > (aop->size - 1) &&
+ aop->type != AOP_LIT)
+ return zero;
+
+ /* depending on type */
+ switch (aop->type) {
+
+ case AOP_R0:
+ case AOP_R1:
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ /* if we need to increment it */
+ while (offset > aop->coff) {
+ pic14_emitcode ("inc","%s",aop->aopu.aop_ptr->name);
+ aop->coff++;
+ }
+
+ while (offset < aop->coff) {
+ pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
+ aop->coff--;
+ }
+
+ aop->coff = offset ;
+ if (aop->paged) {
+ pic14_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;
+
+ case AOP_DPTR:
+ case AOP_DPTR2:
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(1);
+ }
+
+ while (offset > aop->coff) {
+ pic14_emitcode ("inc","dptr");
+ aop->coff++;
+ }
+
+ while (offset < aop->coff) {
+ pic14_emitcode("lcall","__decdptr");
+ aop->coff--;
+ }
+
+ aop->coff = offset;
+ if (aop->code) {
+ pic14_emitcode("clr","a");
+ pic14_emitcode("movc","a,@a+dptr");
+ }
+ else {
+ pic14_emitcode("movx","a,@dptr");
+ }
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(0);
+ }
+
+ return (dname ? "acc" : "a");
+
+
+ case AOP_IMMD:
+ if (bit16)
+ sprintf (s,"%s",aop->aopu.aop_immd);
+ else
+ if (offset)
+ sprintf(s,"(%s >> %d)",
+ aop->aopu.aop_immd,
+ offset*8);
+ else
+ sprintf(s,"%s",
+ aop->aopu.aop_immd);
+ DEBUGpic14_emitcode(";","%d immd %s",__LINE__,s);
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ case AOP_DIR:
+ if (offset) {
+ sprintf(s,"(%s + %d)",
+ aop->aopu.aop_dir,
+ offset);
+ DEBUGpic14_emitcode(";","oops AOP_DIR did this %s\n",s);
+ } else
+ sprintf(s,"%s",aop->aopu.aop_dir);
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ case AOP_REG:
+ //if (dname)
+ // return aop->aopu.aop_reg[offset]->dname;
+ //else
+ return aop->aopu.aop_reg[offset]->name;
+
+ case AOP_CRY:
+ //pic14_emitcode(";","%d",__LINE__);
+ return aop->aopu.aop_dir;
+
+ case AOP_ACC:
+ DEBUGpic14_emitcode(";Warning -pic port ignoring get(AOP_ACC)","%d",__LINE__);
+ return "AOP_accumulator_bug";
+
+ case AOP_LIT:
+ sprintf(s,"0x%02x", pic14aopLiteral (aop->aopu.aop_lit,offset));
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ case AOP_STR:
+ aop->coff = offset ;
+ if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
+ dname)
+ return "acc";
+ DEBUGpic14_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
+
+ return aop->aopu.aop_str[offset];
+
+ case AOP_PCODE:
+ {
+ pCodeOp *pcop = aop->aopu.pcop;
+ DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
+ if(pcop->name) {
+ DEBUGpic14_emitcode(";","%s offset %d",pcop->name,PCOI(pcop)->offset);
+ //sprintf(s,"(%s+0x%02x)", pcop->name,PCOI(aop->aopu.pcop)->offset);
+ sprintf(s,"%s", pcop->name);
+ } else
+ sprintf(s,"0x%02x", PCOI(aop->aopu.pcop)->offset);
+
+ }
+ rs = Safe_calloc(1,strlen(s)+1);
+ strcpy(rs,s);
+ return rs;
+
+ }
+
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopget got unsupported aop->type");
+ exit(0);
}
/*-----------------------------------------------------------------*/
pCodeOp *popGetTempReg(void)
{
-
- pCodeOp *pcop;
-
- pcop = newpCodeOp(NULL, PO_GPR_TEMP);
- if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
- PCOR(pcop)->r->wasUsed=1;
- PCOR(pcop)->r->isFree=0;
- }
-
- return pcop;
+
+ pCodeOp *pcop;
+
+ pcop = newpCodeOp(NULL, PO_GPR_TEMP);
+ if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
+ PCOR(pcop)->r->wasUsed=1;
+ PCOR(pcop)->r->isFree=0;
+ }
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void popReleaseTempReg(pCodeOp *pcop)
{
-
- if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r)
- PCOR(pcop)->r->isFree = 1;
-
+
+ if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r)
+ PCOR(pcop)->r->isFree = 1;
+
}
/*-----------------------------------------------------------------*/
/* popGetLabel - create a new pCodeOp of type PO_LABEL */
/*-----------------------------------------------------------------*/
pCodeOp *popGetLabel(unsigned int key)
{
-
- DEBUGpic14_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, labelOffset);
-
- if(key>(unsigned int)max_key)
- max_key = key;
-
- return newpCodeOpLabel(NULL,key+100+labelOffset);
+
+ DEBUGpic14_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, labelOffset);
+
+ if(key>(unsigned int)max_key)
+ max_key = key;
+
+ return newpCodeOpLabel(NULL,key+100+labelOffset);
}
/*-------------------------------------------------------------------*/
/*-------------------------------------------------------------------*/
pCodeOp *popGetHighLabel(unsigned int key)
{
- pCodeOp *pcop;
- pcop = popGetLabel(key);
- PCOLAB(pcop)->offset = 1;
- return pcop;
+ pCodeOp *pcop;
+ pcop = popGetLabel(key);
+ PCOLAB(pcop)->offset = 1;
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *popGetLit(unsigned int lit)
{
-
- return newpCodeOpLit(lit);
+
+ return newpCodeOpLit(lit);
}
/*-----------------------------------------------------------------*/
pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func)
{
-
- return newpCodeOpImmd(name, offset,index, 0, is_func);
+
+ return newpCodeOpImmd(name, offset,index, 0, is_func);
}
/*-----------------------------------------------------------------*/
pCodeOp *popGetWithString(char *str, int isExtern)
{
- pCodeOp *pcop;
-
-
- if(!str) {
- fprintf(stderr,"NULL string %s %d\n",__FILE__,__LINE__);
- exit (1);
- }
-
- pcop = newpCodeOp(str,PO_STR);
- PCOS(pcop)->isPublic = isExtern ? 1 : 0;
-
- return pcop;
+ pCodeOp *pcop;
+
+
+ if(!str) {
+ fprintf(stderr,"NULL string %s %d\n",__FILE__,__LINE__);
+ exit (1);
+ }
+
+ pcop = newpCodeOp(str,PO_STR);
+ PCOS(pcop)->isPublic = isExtern ? 1 : 0;
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *popRegFromString(char *str, int size, int offset)
{
-
- pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- pcop->type = PO_DIR;
-
- DEBUGpic14_emitcode(";","%d",__LINE__);
-
- if(!str)
- str = "BAD_STRING";
-
- pcop->name = Safe_calloc(1,strlen(str)+1);
- strcpy(pcop->name,str);
-
- //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
-
- PCOR(pcop)->r = dirregWithName(pcop->name);
- if(PCOR(pcop)->r == NULL) {
- //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
- PCOR(pcop)->r = allocRegByName (pcop->name,size);
- DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
- } else {
- DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
- }
- PCOR(pcop)->instance = offset;
-
- return pcop;
+
+ pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop->type = PO_DIR;
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+
+ if(!str)
+ str = "BAD_STRING";
+
+ pcop->name = Safe_calloc(1,strlen(str)+1);
+ strcpy(pcop->name,str);
+
+ //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+ PCOR(pcop)->r = dirregWithName(pcop->name);
+ if(PCOR(pcop)->r == NULL) {
+ //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+ PCOR(pcop)->r = allocRegByName (pcop->name,size);
+ DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ }
+ PCOR(pcop)->instance = offset;
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *popRegFromIdx(int rIdx)
{
- pCodeOp *pcop;
-
- DEBUGpic14_emitcode ("; ***","%s,%d , rIdx=0x%x",
- __FUNCTION__,__LINE__,rIdx);
-
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
-
- PCOR(pcop)->rIdx = rIdx;
- PCOR(pcop)->r = typeRegWithIdx(rIdx,REG_STK,1);
- PCOR(pcop)->r->isFree = 0;
- PCOR(pcop)->r->wasUsed = 1;
-
- pcop->type = PCOR(pcop)->r->pc_type;
-
-
- return pcop;
+ pCodeOp *pcop;
+
+ DEBUGpic14_emitcode ("; ***","%s,%d , rIdx=0x%x",
+ __FUNCTION__,__LINE__,rIdx);
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = typeRegWithIdx(rIdx,REG_STK,1);
+ PCOR(pcop)->r->isFree = 0;
+ PCOR(pcop)->r->wasUsed = 1;
+
+ pcop->type = PCOR(pcop)->r->pc_type;
+
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
{
- //char *s = buffer ;
- //char *rs;
-
- pCodeOp *pcop;
-
- //DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* offset is greater than
- size then zero */
-
- if (offset > (aop->size - 1) &&
- aop->type != AOP_LIT)
- return NULL; //zero;
-
- /* depending on type */
- switch (aop->type) {
+ //char *s = buffer ;
+ //char *rs;
- case AOP_R0:
- case AOP_R1:
- case AOP_DPTR:
- case AOP_DPTR2:
- case AOP_ACC:
- DEBUGpic14_emitcode(";8051 legacy","%d type = %s",__LINE__,AopType(aop->type));
- return NULL;
+ pCodeOp *pcop;
- case AOP_IMMD:
- DEBUGpic14_emitcode(";","%d",__LINE__);
- return popGetImmd(aop->aopu.aop_immd,offset,0,0);
-
- case AOP_DIR:
- return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
+ //DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* offset is greater than
+ size then zero */
+
+ if (offset > (aop->size - 1) &&
+ aop->type != AOP_LIT)
+ return NULL; //zero;
+
+ /* depending on type */
+ switch (aop->type) {
+
+ case AOP_R0:
+ case AOP_R1:
+ case AOP_DPTR:
+ case AOP_DPTR2:
+ case AOP_ACC:
+ DEBUGpic14_emitcode(";8051 legacy","%d type = %s",__LINE__,AopType(aop->type));
+ return NULL;
+
+ case AOP_IMMD:
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ return popGetImmd(aop->aopu.aop_immd,offset,0,0);
+
+ case AOP_DIR:
+ return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
#if 0
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- pcop->type = PO_DIR;
-
- /*
- if (offset)
- sprintf(s,"(%s + %d)",
- aop->aopu.aop_dir,
- offset);
- else
- sprintf(s,"%s",aop->aopu.aop_dir);
- pcop->name = Safe_calloc(1,strlen(s)+1);
- strcpy(pcop->name,s);
- */
- pcop->name = Safe_calloc(1,strlen(aop->aopu.aop_dir)+1);
- strcpy(pcop->name,aop->aopu.aop_dir);
- PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
- if(PCOR(pcop)->r == NULL) {
- //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
- PCOR(pcop)->r = allocRegByName (aop->aopu.aop_dir,aop->size);
- DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
- } else {
- DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
- }
- PCOR(pcop)->instance = offset;
-
- return pcop;
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop->type = PO_DIR;
+
+ /*
+ if (offset)
+ sprintf(s,"(%s + %d)",
+ aop->aopu.aop_dir,
+ offset);
+ else
+ sprintf(s,"%s",aop->aopu.aop_dir);
+ pcop->name = Safe_calloc(1,strlen(s)+1);
+ strcpy(pcop->name,s);
+ */
+ pcop->name = Safe_calloc(1,strlen(aop->aopu.aop_dir)+1);
+ strcpy(pcop->name,aop->aopu.aop_dir);
+ PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
+ if(PCOR(pcop)->r == NULL) {
+ //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+ PCOR(pcop)->r = allocRegByName (aop->aopu.aop_dir,aop->size);
+ DEBUGpic14_emitcode(";","%d %s offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+ } else {
+ DEBUGpic14_emitcode(";","%d %s offset=%d",__LINE__,pcop->name,offset);
+ }
+ PCOR(pcop)->instance = offset;
+
+ return pcop;
#endif
+
+ case AOP_REG:
+ {
+ int rIdx = aop->aopu.aop_reg[offset]->rIdx;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+ PCOR(pcop)->r->wasUsed=1;
+ PCOR(pcop)->r->isFree=0;
+
+ PCOR(pcop)->instance = offset;
+ pcop->type = PCOR(pcop)->r->pc_type;
+ //rs = aop->aopu.aop_reg[offset]->name;
+ DEBUGpic14_emitcode(";","%d regiser idx = %d ",__LINE__,rIdx);
+ return pcop;
+ }
+
+ case AOP_CRY:
+ pcop = newpCodeOpBit(aop->aopu.aop_dir,-1,1);
+ PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
+ //if(PCOR(pcop)->r == NULL)
+ //fprintf(stderr,"%d - couldn't find %s in allocated registers\n",__LINE__,aop->aopu.aop_dir);
+ return pcop;
+
+ case AOP_LIT:
+ return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
+
+ case AOP_STR:
+ DEBUGpic14_emitcode(";","%d %s",__LINE__,aop->aopu.aop_str[offset]);
+ return newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
+ /*
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcop)->r = allocRegByName(aop->aopu.aop_str[offset]);
+ PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
+ pcop->type = PCOR(pcop)->r->pc_type;
+ pcop->name = PCOR(pcop)->r->name;
+
+ return pcop;
+ */
+
+ case AOP_PCODE:
+ DEBUGpic14_emitcode(";","popGet AOP_PCODE (%s) %d %s",pCodeOpType(aop->aopu.pcop),
+ __LINE__,
+ ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"));
+ pcop = pCodeOpCopy(aop->aopu.pcop);
+ PCOI(pcop)->offset = offset;
+ return pcop;
+ }
- case AOP_REG:
- {
- int rIdx = aop->aopu.aop_reg[offset]->rIdx;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcop)->rIdx = rIdx;
- PCOR(pcop)->r = pic14_regWithIdx(rIdx);
- PCOR(pcop)->r->wasUsed=1;
- PCOR(pcop)->r->isFree=0;
-
- PCOR(pcop)->instance = offset;
- pcop->type = PCOR(pcop)->r->pc_type;
- //rs = aop->aopu.aop_reg[offset]->name;
- DEBUGpic14_emitcode(";","%d regiser idx = %d ",__LINE__,rIdx);
- return pcop;
- }
-
- case AOP_CRY:
- pcop = newpCodeOpBit(aop->aopu.aop_dir,-1,1);
- PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
- //if(PCOR(pcop)->r == NULL)
- //fprintf(stderr,"%d - couldn't find %s in allocated registers\n",__LINE__,aop->aopu.aop_dir);
- return pcop;
-
- case AOP_LIT:
- return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
-
- case AOP_STR:
- DEBUGpic14_emitcode(";","%d %s",__LINE__,aop->aopu.aop_str[offset]);
- return newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
- /*
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcop)->r = allocRegByName(aop->aopu.aop_str[offset]);
- PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
- pcop->type = PCOR(pcop)->r->pc_type;
- pcop->name = PCOR(pcop)->r->name;
-
- return pcop;
- */
-
- case AOP_PCODE:
- DEBUGpic14_emitcode(";","popGet AOP_PCODE (%s) %d %s",pCodeOpType(aop->aopu.pcop),
- __LINE__,
- ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"));
- pcop = pCodeOpCopy(aop->aopu.pcop);
- PCOI(pcop)->offset = offset;
- return pcop;
- }
-
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "popGet got unsupported aop->type");
- exit(0);
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "popGet got unsupported aop->type");
+ exit(0);
}
/*-----------------------------------------------------------------*/
/* aopPut - puts a string for a aop */
/*-----------------------------------------------------------------*/
void aopPut (asmop *aop, char *s, int offset)
{
- char *d = buffer ;
- symbol *lbl ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if (aop->size && offset > ( aop->size - 1)) {
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "aopPut got offset > aop->size");
- exit(0);
- }
-
- /* will assign value to value */
- /* depending on where it is ofcourse */
- switch (aop->type) {
- case AOP_DIR:
- if (offset) {
- sprintf(d,"(%s + %d)",
- aop->aopu.aop_dir,offset);
- fprintf(stderr,"oops aopPut:AOP_DIR did this %s\n",s);
-
- } else
- sprintf(d,"%s",aop->aopu.aop_dir);
-
- if (strcmp(d,s)) {
- DEBUGpic14_emitcode(";","%d",__LINE__);
- if(strcmp(s,"W"))
- pic14_emitcode("movf","%s,w",s);
- pic14_emitcode("movwf","%s",d);
-
- if(strcmp(s,"W")) {
- pic14_emitcode(";BUG!? should have this:movf","%s,w %d",s,__LINE__);
- if(offset >= aop->size) {
- emitpcode(POC_CLRF,popGet(aop,offset));
- break;
- } else
- emitpcode(POC_MOVLW,popGetImmd(s,offset,0,0));
- }
-
- emitpcode(POC_MOVWF,popGet(aop,offset));
-
-
- }
- break;
-
- case AOP_REG:
- if (strcmp(aop->aopu.aop_reg[offset]->name,s) != 0) { // &&
- //strcmp(aop->aopu.aop_reg[offset]->dname,s)!= 0){
- /*
- if (*s == '@' ||
- strcmp(s,"r0") == 0 ||
- strcmp(s,"r1") == 0 ||
- strcmp(s,"r2") == 0 ||
- strcmp(s,"r3") == 0 ||
- strcmp(s,"r4") == 0 ||
- strcmp(s,"r5") == 0 ||
- strcmp(s,"r6") == 0 ||
- strcmp(s,"r7") == 0 )
- pic14_emitcode("mov","%s,%s ; %d",
- aop->aopu.aop_reg[offset]->dname,s,__LINE__);
- else
- */
-
- if(strcmp(s,"W")==0 )
- pic14_emitcode("movf","%s,w ; %d",s,__LINE__);
-
- pic14_emitcode("movwf","%s",
- aop->aopu.aop_reg[offset]->name);
-
- if(strcmp(s,zero)==0) {
- emitpcode(POC_CLRF,popGet(aop,offset));
-
- } else if(strcmp(s,"W")==0) {
- pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- pcop->type = PO_GPR_REGISTER;
-
- PCOR(pcop)->rIdx = -1;
- PCOR(pcop)->r = NULL;
-
- DEBUGpic14_emitcode(";","%d",__LINE__);
- pcop->name = Safe_strdup(s);
- emitpcode(POC_MOVFW,pcop);
- emitpcode(POC_MOVWF,popGet(aop,offset));
- } else if(strcmp(s,one)==0) {
- emitpcode(POC_CLRF,popGet(aop,offset));
- emitpcode(POC_INCF,popGet(aop,offset));
- } else {
- emitpcode(POC_MOVWF,popGet(aop,offset));
- }
- }
- break;
-
- case AOP_DPTR:
- case AOP_DPTR2:
-
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(1);
- }
-
- if (aop->code) {
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "aopPut writting to code space");
- exit(0);
- }
-
- while (offset > aop->coff) {
- aop->coff++;
- pic14_emitcode ("inc","dptr");
- }
-
- while (offset < aop->coff) {
- aop->coff-- ;
- pic14_emitcode("lcall","__decdptr");
- }
-
- aop->coff = offset;
-
- /* if not in accumulater */
- MOVA(s);
-
- pic14_emitcode ("movx","@dptr,a");
+ char *d = buffer ;
+ symbol *lbl ;
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(0);
- }
- break;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- case AOP_R0:
- case AOP_R1:
- while (offset > aop->coff) {
- aop->coff++;
- pic14_emitcode("inc","%s",aop->aopu.aop_ptr->name);
- }
- while (offset < aop->coff) {
- aop->coff-- ;
- pic14_emitcode ("dec","%s",aop->aopu.aop_ptr->name);
+ if (aop->size && offset > ( aop->size - 1)) {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopPut got offset > aop->size");
+ exit(0);
}
- aop->coff = offset;
- if (aop->paged) {
- MOVA(s);
- pic14_emitcode("movx","@%s,a",aop->aopu.aop_ptr->name);
-
- } else
- if (*s == '@') {
- MOVA(s);
- pic14_emitcode("mov","@%s,a ; %d",aop->aopu.aop_ptr->name,__LINE__);
- } else
- if (strcmp(s,"r0") == 0 ||
- strcmp(s,"r1") == 0 ||
- strcmp(s,"r2") == 0 ||
- strcmp(s,"r3") == 0 ||
- strcmp(s,"r4") == 0 ||
- strcmp(s,"r5") == 0 ||
- strcmp(s,"r6") == 0 ||
- strcmp(s,"r7") == 0 ) {
- char buffer[10];
- sprintf(buffer,"a%s",s);
- pic14_emitcode("mov","@%s,%s",
- aop->aopu.aop_ptr->name,buffer);
+ /* will assign value to value */
+ /* depending on where it is ofcourse */
+ switch (aop->type) {
+ case AOP_DIR:
+ if (offset) {
+ sprintf(d,"(%s + %d)",
+ aop->aopu.aop_dir,offset);
+ fprintf(stderr,"oops aopPut:AOP_DIR did this %s\n",s);
+
} else
- pic14_emitcode("mov","@%s,%s",aop->aopu.aop_ptr->name,s);
-
- break;
-
- case AOP_STK:
- if (strcmp(s,"a") == 0)
- pic14_emitcode("push","acc");
- else
- pic14_emitcode("push","%s",s);
-
- break;
-
- case AOP_CRY:
- /* if bit variable */
- if (!aop->aopu.aop_dir) {
- pic14_emitcode("clr","a");
- pic14_emitcode("rlc","a");
- } else {
- if (s == zero)
- pic14_emitcode("clr","%s",aop->aopu.aop_dir);
- else
- if (s == one)
- pic14_emitcode("setb","%s",aop->aopu.aop_dir);
- else
- if (!strcmp(s,"c"))
- pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
- else {
- lbl = newiTempLabel(NULL);
+ sprintf(d,"%s",aop->aopu.aop_dir);
+
+ if (strcmp(d,s)) {
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ if(strcmp(s,"W"))
+ pic14_emitcode("movf","%s,w",s);
+ pic14_emitcode("movwf","%s",d);
- if (strcmp(s,"a")) {
- MOVA(s);
+ if(strcmp(s,"W")) {
+ pic14_emitcode(";BUG!? should have this:movf","%s,w %d",s,__LINE__);
+ if(offset >= aop->size) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+ break;
+ } else
+ emitpcode(POC_MOVLW,popGetImmd(s,offset,0,0));
}
- pic14_emitcode("clr","c");
- pic14_emitcode("jz","%05d_DS_",lbl->key+100);
- pic14_emitcode("cpl","c");
- pic14_emitcode("","%05d_DS_:",lbl->key+100);
- pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
- }
- }
- break;
-
- case AOP_STR:
- aop->coff = offset;
- if (strcmp(aop->aopu.aop_str[offset],s))
- pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s,__LINE__);
- break;
-
- case AOP_ACC:
- aop->coff = offset;
- if (!offset && (strcmp(s,"acc") == 0))
- break;
+
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+
+
+ }
+ break;
+
+ case AOP_REG:
+ if (strcmp(aop->aopu.aop_reg[offset]->name,s) != 0) { // &&
+ //strcmp(aop->aopu.aop_reg[offset]->dname,s)!= 0){
+ /*
+ if (*s == '@' ||
+ strcmp(s,"r0") == 0 ||
+ strcmp(s,"r1") == 0 ||
+ strcmp(s,"r2") == 0 ||
+ strcmp(s,"r3") == 0 ||
+ strcmp(s,"r4") == 0 ||
+ strcmp(s,"r5") == 0 ||
+ strcmp(s,"r6") == 0 ||
+ strcmp(s,"r7") == 0 )
+ pic14_emitcode("mov","%s,%s ; %d",
+ aop->aopu.aop_reg[offset]->dname,s,__LINE__);
+ else
+ */
+
+ if(strcmp(s,"W")==0 )
+ pic14_emitcode("movf","%s,w ; %d",s,__LINE__);
+
+ pic14_emitcode("movwf","%s",
+ aop->aopu.aop_reg[offset]->name);
+
+ if(strcmp(s,zero)==0) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+
+ } else if(strcmp(s,"W")==0) {
+ pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcop->type = PO_GPR_REGISTER;
+
+ PCOR(pcop)->rIdx = -1;
+ PCOR(pcop)->r = NULL;
+
+ DEBUGpic14_emitcode(";","%d",__LINE__);
+ pcop->name = Safe_strdup(s);
+ emitpcode(POC_MOVFW,pcop);
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+ } else if(strcmp(s,one)==0) {
+ emitpcode(POC_CLRF,popGet(aop,offset));
+ emitpcode(POC_INCF,popGet(aop,offset));
+ } else {
+ emitpcode(POC_MOVWF,popGet(aop,offset));
+ }
+ }
+ break;
+
+ case AOP_DPTR:
+ case AOP_DPTR2:
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(1);
+ }
+
+ if (aop->code) {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopPut writting to code space");
+ exit(0);
+ }
+
+ while (offset > aop->coff) {
+ aop->coff++;
+ pic14_emitcode ("inc","dptr");
+ }
+
+ while (offset < aop->coff) {
+ aop->coff-- ;
+ pic14_emitcode("lcall","__decdptr");
+ }
+
+ aop->coff = offset;
+
+ /* if not in accumulater */
+ MOVA(s);
+
+ pic14_emitcode ("movx","@dptr,a");
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(0);
+ }
+ break;
+
+ case AOP_R0:
+ case AOP_R1:
+ while (offset > aop->coff) {
+ aop->coff++;
+ pic14_emitcode("inc","%s",aop->aopu.aop_ptr->name);
+ }
+ while (offset < aop->coff) {
+ aop->coff-- ;
+ pic14_emitcode ("dec","%s",aop->aopu.aop_ptr->name);
+ }
+ aop->coff = offset;
+
+ if (aop->paged) {
+ MOVA(s);
+ pic14_emitcode("movx","@%s,a",aop->aopu.aop_ptr->name);
+
+ } else
+ if (*s == '@') {
+ MOVA(s);
+ pic14_emitcode("mov","@%s,a ; %d",aop->aopu.aop_ptr->name,__LINE__);
+ } else
+ if (strcmp(s,"r0") == 0 ||
+ strcmp(s,"r1") == 0 ||
+ strcmp(s,"r2") == 0 ||
+ strcmp(s,"r3") == 0 ||
+ strcmp(s,"r4") == 0 ||
+ strcmp(s,"r5") == 0 ||
+ strcmp(s,"r6") == 0 ||
+ strcmp(s,"r7") == 0 ) {
+ char buffer[10];
+ sprintf(buffer,"a%s",s);
+ pic14_emitcode("mov","@%s,%s",
+ aop->aopu.aop_ptr->name,buffer);
+ } else
+ pic14_emitcode("mov","@%s,%s",aop->aopu.aop_ptr->name,s);
+
+ break;
+
+ case AOP_STK:
+ if (strcmp(s,"a") == 0)
+ pic14_emitcode("push","acc");
+ else
+ pic14_emitcode("push","%s",s);
+
+ break;
+
+ case AOP_CRY:
+ /* if bit variable */
+ if (!aop->aopu.aop_dir) {
+ pic14_emitcode("clr","a");
+ pic14_emitcode("rlc","a");
+ } else {
+ if (s == zero)
+ pic14_emitcode("clr","%s",aop->aopu.aop_dir);
+ else
+ if (s == one)
+ pic14_emitcode("setb","%s",aop->aopu.aop_dir);
+ else
+ if (!strcmp(s,"c"))
+ pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
+ else {
+ lbl = newiTempLabel(NULL);
+
+ if (strcmp(s,"a")) {
+ MOVA(s);
+ }
+ pic14_emitcode("clr","c");
+ pic14_emitcode("jz","%05d_DS_",lbl->key+100);
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",lbl->key+100);
+ pic14_emitcode("mov","%s,c",aop->aopu.aop_dir);
+ }
+ }
+ break;
+
+ case AOP_STR:
+ aop->coff = offset;
+ if (strcmp(aop->aopu.aop_str[offset],s))
+ pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s,__LINE__);
+ break;
+
+ case AOP_ACC:
+ aop->coff = offset;
+ if (!offset && (strcmp(s,"acc") == 0))
+ break;
+
+ if (strcmp(aop->aopu.aop_str[offset],s))
+ pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s, __LINE__);
+ break;
+
+ default :
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "aopPut got unsupported aop->type");
+ exit(0);
+ }
- if (strcmp(aop->aopu.aop_str[offset],s))
- pic14_emitcode ("mov","%s,%s ; %d",aop->aopu.aop_str[offset],s, __LINE__);
- break;
-
- default :
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "aopPut got unsupported aop->type");
- exit(0);
- }
-
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void mov2w (asmop *aop, int offset)
{
-
- if(!aop)
- return;
-
- DEBUGpic14_emitcode ("; ***","%s %d offset=%d",__FUNCTION__,__LINE__,offset);
-
- if ( aop->type == AOP_PCODE ||
- aop->type == AOP_LIT ||
- aop->type == AOP_IMMD )
- emitpcode(POC_MOVLW,popGet(aop,offset));
- else
- emitpcode(POC_MOVFW,popGet(aop,offset));
-
+
+ if(!aop)
+ return;
+
+ DEBUGpic14_emitcode ("; ***","%s %d offset=%d",__FUNCTION__,__LINE__,offset);
+
+ if ( aop->type == AOP_PCODE ||
+ aop->type == AOP_LIT ||
+ aop->type == AOP_IMMD )
+ emitpcode(POC_MOVLW,popGet(aop,offset));
+ else
+ emitpcode(POC_MOVFW,popGet(aop,offset));
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void reAdjustPreg (asmop *aop)
{
- int size ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aop->coff = 0;
- if ((size = aop->size) <= 1)
- return ;
- size-- ;
- switch (aop->type) {
- case AOP_R0 :
- case AOP_R1 :
- while (size--)
- pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
- break;
- case AOP_DPTR :
- case AOP_DPTR2:
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(1);
- }
- while (size--)
- {
- pic14_emitcode("lcall","__decdptr");
- }
-
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(0);
- }
- break;
-
- }
-
+ int size ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aop->coff = 0;
+ if ((size = aop->size) <= 1)
+ return ;
+ size-- ;
+ switch (aop->type) {
+ case AOP_R0 :
+ case AOP_R1 :
+ while (size--)
+ pic14_emitcode("dec","%s",aop->aopu.aop_ptr->name);
+ break;
+ case AOP_DPTR :
+ case AOP_DPTR2:
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(1);
+ }
+ while (size--)
+ {
+ pic14_emitcode("lcall","__decdptr");
+ }
+
+ if (aop->type == AOP_DPTR2)
+ {
+ genSetDPTR(0);
+ }
+ break;
+
+ }
+
}
/*-----------------------------------------------------------------*/
static int opIsGptr(operand *op)
{
- sym_link *type = operandType(op);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type))
- {
- return 1;
- }
- return 0;
+ sym_link *type = operandType(op);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type))
+ {
+ return 1;
+ }
+ return 0;
}
#endif
/*-----------------------------------------------------------------*/
int pic14_getDataSize(operand *op)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
-
- return AOP_SIZE(op);
-
- // tsd- in the pic port, the genptr size is 1, so this code here
- // fails. ( in the 8051 port, the size was 4).
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ return AOP_SIZE(op);
+
+ // tsd- in the pic port, the genptr size is 1, so this code here
+ // fails. ( in the 8051 port, the size was 4).
#if 0
- int size;
- size = AOP_SIZE(op);
- if (size == GPTRSIZE)
- {
- sym_link *type = operandType(op);
- if (IS_GENPTR(type))
- {
- /* generic pointer; arithmetic operations
- * should ignore the high byte (pointer type).
- */
- size--;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- }
- }
- return size;
+ int size;
+ size = AOP_SIZE(op);
+ if (size == GPTRSIZE)
+ {
+ sym_link *type = operandType(op);
+ if (IS_GENPTR(type))
+ {
+ /* generic pointer; arithmetic operations
+ * should ignore the high byte (pointer type).
+ */
+ size--;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ }
+ }
+ return size;
#endif
}
/*-----------------------------------------------------------------*/
void pic14_outAcc(operand *result)
{
- int size,offset;
- DEBUGpic14_emitcode ("; ***","%s %d - ",__FUNCTION__,__LINE__);
- DEBUGpic14_AopType(__LINE__,NULL,NULL,result);
-
-
- size = pic14_getDataSize(result);
- if(size){
- emitpcode(POC_MOVWF,popGet(AOP(result),0));
- size--;
- offset = 1;
- /* unsigned or positive */
- while(size--)
- emitpcode(POC_CLRF,popGet(AOP(result),offset++));
- }
-
+ int size,offset;
+ DEBUGpic14_emitcode ("; ***","%s %d - ",__FUNCTION__,__LINE__);
+ DEBUGpic14_AopType(__LINE__,NULL,NULL,result);
+
+
+ size = pic14_getDataSize(result);
+ if(size){
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+ size--;
+ offset = 1;
+ /* unsigned or positive */
+ while(size--)
+ emitpcode(POC_CLRF,popGet(AOP(result),offset++));
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pic14_outBitC(operand *result)
{
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if the result is bit */
- if (AOP_TYPE(result) == AOP_CRY)
- aopPut(AOP(result),"c",0);
- else {
- pic14_emitcode("clr","a ; %d", __LINE__);
- pic14_emitcode("rlc","a");
- pic14_outAcc(result);
- }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if the result is bit */
+ if (AOP_TYPE(result) == AOP_CRY)
+ aopPut(AOP(result),"c",0);
+ else {
+ pic14_emitcode("clr","a ; %d", __LINE__);
+ pic14_emitcode("rlc","a");
+ pic14_outAcc(result);
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pic14_toBoolean(operand *oper)
{
- int size = AOP_SIZE(oper) - 1;
- int offset = 1;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if ( AOP_TYPE(oper) != AOP_ACC) {
- emitpcode(POC_MOVFW,popGet(AOP(oper),0));
- }
- while (size--) {
- emitpcode(POC_IORFW, popGet(AOP(oper),offset++));
- }
+ int size = AOP_SIZE(oper) - 1;
+ int offset = 1;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if ( AOP_TYPE(oper) != AOP_ACC) {
+ emitpcode(POC_MOVFW,popGet(AOP(oper),0));
+ }
+ while (size--) {
+ emitpcode(POC_IORFW, popGet(AOP(oper),offset++));
+ }
}
/*-----------------------------------------------------------------*/
static void genNot (iCode *ic)
{
- symbol *tlbl;
- int size;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* assign asmOps to operand & result */
- aopOp (IC_LEFT(ic),ic,FALSE);
- aopOp (IC_RESULT(ic),ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),NULL,IC_RESULT(ic));
- /* if in bit space then a special case */
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
- if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
- emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_XORWF,popGet(AOP(IC_RESULT(ic)),0));
- } else {
- emitpcode(POC_CLRF,popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_BTFSS,popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_INCF,popGet(AOP(IC_RESULT(ic)),0));
- }
- goto release;
- }
-
- size = AOP_SIZE(IC_LEFT(ic));
- if(size == 1) {
- emitpcode(POC_COMFW,popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_ANDLW,popGetLit(1));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
- goto release;
- }
- pic14_toBoolean(IC_LEFT(ic));
-
- tlbl = newiTempLabel(NULL);
- pic14_emitcode("cjne","a,#0x01,%05d_DS_",tlbl->key+100);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_outBitC(IC_RESULT(ic));
-
- release:
- /* release the aops */
- freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ symbol *tlbl;
+ int size;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign asmOps to operand & result */
+ aopOp (IC_LEFT(ic),ic,FALSE);
+ aopOp (IC_RESULT(ic),ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),NULL,IC_RESULT(ic));
+ /* if in bit space then a special case */
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
+ if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+ emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORWF,popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+ emitpcode(POC_CLRF,popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSS,popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_INCF,popGet(AOP(IC_RESULT(ic)),0));
+ }
+ goto release;
+ }
+
+ size = AOP_SIZE(IC_LEFT(ic));
+ if(size == 1) {
+ emitpcode(POC_COMFW,popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_ANDLW,popGetLit(1));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ goto release;
+ }
+ pic14_toBoolean(IC_LEFT(ic));
+
+ tlbl = newiTempLabel(NULL);
+ pic14_emitcode("cjne","a,#0x01,%05d_DS_",tlbl->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(IC_RESULT(ic));
+
+release:
+ /* release the aops */
+ freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
static void genCpl (iCode *ic)
{
- operand *left, *result;
- int size, offset=0;
-
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp((left = IC_LEFT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,TRUE);
-
- /* if both are in bit space then
- a special case */
- if (AOP_TYPE(result) == AOP_CRY &&
- AOP_TYPE(left) == AOP_CRY ) {
-
- pic14_emitcode("mov","c,%s",left->aop->aopu.aop_dir);
- pic14_emitcode("cpl","c");
- pic14_emitcode("mov","%s,c",result->aop->aopu.aop_dir);
- goto release;
- }
-
- size = AOP_SIZE(result);
- while (size--) {
-
- if(AOP_TYPE(left) == AOP_ACC)
- emitpcode(POC_XORLW, popGetLit(0xff));
- else
- emitpcode(POC_COMFW,popGet(AOP(left),offset));
-
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
-
- }
-
-
+ operand *left, *result;
+ int size, offset=0;
+
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ /* if both are in bit space then
+ a special case */
+ if (AOP_TYPE(result) == AOP_CRY &&
+ AOP_TYPE(left) == AOP_CRY ) {
+
+ pic14_emitcode("mov","c,%s",left->aop->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("mov","%s,c",result->aop->aopu.aop_dir);
+ goto release;
+ }
+
+ size = AOP_SIZE(result);
+ while (size--) {
+
+ if(AOP_TYPE(left) == AOP_ACC)
+ emitpcode(POC_XORLW, popGetLit(0xff));
+ else
+ emitpcode(POC_COMFW,popGet(AOP(left),offset));
+
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+
+ }
+
+
release:
- /* release the aops */
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
- freeAsmop(result,NULL,ic,TRUE);
+ /* release the aops */
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genUminusFloat(operand *op,operand *result)
{
- int size ,offset =0 ;
- char *l;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* for this we just need to flip the
- first it then copy the rest in place */
- size = AOP_SIZE(op) - 1;
- l = aopGet(AOP(op),3,FALSE,FALSE);
-
- MOVA(l);
-
- pic14_emitcode("cpl","acc.7");
- aopPut(AOP(result),"a",3);
-
- while(size--) {
- aopPut(AOP(result),
- aopGet(AOP(op),offset,FALSE,FALSE),
- offset);
- offset++;
- }
+ int size ,offset =0 ;
+ char *l;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* for this we just need to flip the
+ first it then copy the rest in place */
+ size = AOP_SIZE(op) - 1;
+ l = aopGet(AOP(op),3,FALSE,FALSE);
+
+ MOVA(l);
+
+ pic14_emitcode("cpl","acc.7");
+ aopPut(AOP(result),"a",3);
+
+ while(size--) {
+ aopPut(AOP(result),
+ aopGet(AOP(op),offset,FALSE,FALSE),
+ offset);
+ offset++;
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genUminus (iCode *ic)
{
- int size, i;
- sym_link *optype, *rtype;
-
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* assign asmops */
- aopOp(IC_LEFT(ic),ic,FALSE);
- aopOp(IC_RESULT(ic),ic,TRUE);
-
- /* if both in bit space then special
- case */
- if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
- AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
-
- emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_BTFSS, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
-
- goto release;
- }
-
- optype = operandType(IC_LEFT(ic));
- rtype = operandType(IC_RESULT(ic));
-
- /* if float then do float stuff */
- if (IS_FLOAT(optype)) {
- genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
- goto release;
- }
-
- /* otherwise subtract from zero by taking the 2's complement */
- size = AOP_SIZE(IC_LEFT(ic));
-
- for(i=0; i<size; i++) {
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_COMF, popGet(AOP(IC_LEFT(ic)),i));
- else {
- emitpcode(POC_COMFW, popGet(AOP(IC_LEFT(ic)),i));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),i));
- }
- }
-
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
- for(i=1; i<size; i++) {
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),i));
- }
-
- release:
- /* release the aops */
- freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ int size, i;
+ sym_link *optype, *rtype;
+
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign asmops */
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ aopOp(IC_RESULT(ic),ic,TRUE);
+
+ /* if both in bit space then special
+ case */
+ if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
+ AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
+
+ emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSS, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
+
+ goto release;
+ }
+
+ optype = operandType(IC_LEFT(ic));
+ rtype = operandType(IC_RESULT(ic));
+
+ /* if float then do float stuff */
+ if (IS_FLOAT(optype)) {
+ genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
+ goto release;
+ }
+
+ /* otherwise subtract from zero by taking the 2's complement */
+ size = AOP_SIZE(IC_LEFT(ic));
+
+ for(i=0; i<size; i++) {
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
+ emitpcode(POC_COMF, popGet(AOP(IC_LEFT(ic)),i));
+ else {
+ emitpcode(POC_COMFW, popGet(AOP(IC_LEFT(ic)),i));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),i));
+ }
+ }
+
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
+ for(i=1; i<size; i++) {
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),i));
+ }
+
+release:
+ /* release the aops */
+ freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void saveRegisters(iCode *lic)
{
- int i;
- iCode *ic;
- bitVect *rsave;
- sym_link *dtype;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* look for call */
- for (ic = lic ; ic ; ic = ic->next)
- if (ic->op == CALL || ic->op == PCALL)
- break;
-
- if (!ic) {
- fprintf(stderr,"found parameter push with no function call\n");
- return ;
- }
-
- /* if the registers have been saved already then
- do nothing */
- if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type))
- return ;
-
- /* find the registers in use at this time
- and push them away to safety */
- rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
- ic->rUsed);
-
- ic->regsSaved = 1;
- if (options.useXstack) {
- if (bitVectBitValue(rsave,R0_IDX))
- pic14_emitcode("mov","b,r0");
- pic14_emitcode("mov","r0,%s",spname);
- for (i = 0 ; i < pic14_nRegs ; i++) {
- if (bitVectBitValue(rsave,i)) {
- if (i == R0_IDX)
- pic14_emitcode("mov","a,b");
- else
- pic14_emitcode("mov","a,%s",pic14_regWithIdx(i)->name);
- pic14_emitcode("movx","@r0,a");
- pic14_emitcode("inc","r0");
- }
- }
- pic14_emitcode("mov","%s,r0",spname);
- if (bitVectBitValue(rsave,R0_IDX))
- pic14_emitcode("mov","r0,b");
- }// else
- //for (i = 0 ; i < pic14_nRegs ; i++) {
- // if (bitVectBitValue(rsave,i))
- // pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
- //}
-
- dtype = operandType(IC_LEFT(ic));
- if (currFunc && dtype &&
- (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
- IFFUNC_ISISR(currFunc->type) &&
- !ic->bankSaved)
-
- saverbank(FUNC_REGBANK(dtype),ic,TRUE);
-
+ int i;
+ iCode *ic;
+ bitVect *rsave;
+ sym_link *dtype;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* look for call */
+ for (ic = lic ; ic ; ic = ic->next)
+ if (ic->op == CALL || ic->op == PCALL)
+ break;
+
+ if (!ic) {
+ fprintf(stderr,"found parameter push with no function call\n");
+ return ;
+ }
+
+ /* if the registers have been saved already then
+ do nothing */
+ if (ic->regsSaved || IFFUNC_CALLEESAVES(OP_SYMBOL(IC_LEFT(ic))->type))
+ return ;
+
+ /* find the registers in use at this time
+ and push them away to safety */
+ rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
+ ic->rUsed);
+
+ ic->regsSaved = 1;
+ if (options.useXstack) {
+ if (bitVectBitValue(rsave,R0_IDX))
+ pic14_emitcode("mov","b,r0");
+ pic14_emitcode("mov","r0,%s",spname);
+ for (i = 0 ; i < pic14_nRegs ; i++) {
+ if (bitVectBitValue(rsave,i)) {
+ if (i == R0_IDX)
+ pic14_emitcode("mov","a,b");
+ else
+ pic14_emitcode("mov","a,%s",pic14_regWithIdx(i)->name);
+ pic14_emitcode("movx","@r0,a");
+ pic14_emitcode("inc","r0");
+ }
+ }
+ pic14_emitcode("mov","%s,r0",spname);
+ if (bitVectBitValue(rsave,R0_IDX))
+ pic14_emitcode("mov","r0,b");
+ }// else
+ //for (i = 0 ; i < pic14_nRegs ; i++) {
+ // if (bitVectBitValue(rsave,i))
+ // pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+ //}
+
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
+ IFFUNC_ISISR(currFunc->type) &&
+ !ic->bankSaved)
+
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
}
/*-----------------------------------------------------------------*/
/* unsaveRegisters - pop the pushed registers */
/*-----------------------------------------------------------------*/
static void unsaveRegisters (iCode *ic)
{
- int i;
- bitVect *rsave;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* find the registers in use at this time
- and push them away to safety */
- rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
- ic->rUsed);
-
- if (options.useXstack) {
- pic14_emitcode("mov","r0,%s",spname);
- for (i = pic14_nRegs ; i >= 0 ; i--) {
- if (bitVectBitValue(rsave,i)) {
- pic14_emitcode("dec","r0");
- pic14_emitcode("movx","a,@r0");
- if (i == R0_IDX)
- pic14_emitcode("mov","b,a");
- else
- pic14_emitcode("mov","%s,a",pic14_regWithIdx(i)->name);
- }
-
- }
- pic14_emitcode("mov","%s,r0",spname);
- if (bitVectBitValue(rsave,R0_IDX))
- pic14_emitcode("mov","r0,b");
- } //else
- //for (i = pic14_nRegs ; i >= 0 ; i--) {
- // if (bitVectBitValue(rsave,i))
- // pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
- //}
-
+ int i;
+ bitVect *rsave;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* find the registers in use at this time
+ and push them away to safety */
+ rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
+ ic->rUsed);
+
+ if (options.useXstack) {
+ pic14_emitcode("mov","r0,%s",spname);
+ for (i = pic14_nRegs ; i >= 0 ; i--) {
+ if (bitVectBitValue(rsave,i)) {
+ pic14_emitcode("dec","r0");
+ pic14_emitcode("movx","a,@r0");
+ if (i == R0_IDX)
+ pic14_emitcode("mov","b,a");
+ else
+ pic14_emitcode("mov","%s,a",pic14_regWithIdx(i)->name);
+ }
+
+ }
+ pic14_emitcode("mov","%s,r0",spname);
+ if (bitVectBitValue(rsave,R0_IDX))
+ pic14_emitcode("mov","r0,b");
+ } //else
+ //for (i = pic14_nRegs ; i >= 0 ; i--) {
+ // if (bitVectBitValue(rsave,i))
+ // pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
+ //}
+
}
{
#if 0
int offset = 0;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
while (size--) {
char *l = aopGet(AOP(oper),offset++,FALSE,TRUE);
if (AOP_TYPE(oper) != AOP_REG &&
- AOP_TYPE(oper) != AOP_DIR &&
- strcmp(l,"a") ) {
+ AOP_TYPE(oper) != AOP_DIR &&
+ strcmp(l,"a") ) {
pic14_emitcode("mov","a,%s",l);
pic14_emitcode("push","acc");
} else
/*-----------------------------------------------------------------*/
static void assignResultValue(operand * oper)
{
- int size = AOP_SIZE(oper);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- DEBUGpic14_AopType(__LINE__,oper,NULL,NULL);
-
- while (size--) {
- if (GpsuedoStkPtr++)
- emitpcode(POC_MOVFW,popRegFromIdx(Gstack_base_addr+2-GpsuedoStkPtr));
- emitpcode(POC_MOVWF, popGet(AOP(oper),size));
- }
+ int size = AOP_SIZE(oper);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ DEBUGpic14_AopType(__LINE__,oper,NULL,NULL);
+
+ while (size--) {
+ if (GpsuedoStkPtr++)
+ emitpcode(POC_MOVFW,popRegFromIdx(Gstack_base_addr+2-GpsuedoStkPtr));
+ emitpcode(POC_MOVWF, popGet(AOP(oper),size));
+ }
}
/*-----------------------------------------------------------------*/
static void genIpush (iCode *ic)
{
-
- DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
#if 0
- int size, offset = 0 ;
- char *l;
-
-
- /* if this is not a parm push : ie. it is spill push
- and spill push is always done on the local stack */
- if (!ic->parmPush) {
-
- /* and the item is spilt then do nothing */
- if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
- return ;
-
- aopOp(IC_LEFT(ic),ic,FALSE);
- size = AOP_SIZE(IC_LEFT(ic));
- /* push it on the stack */
- while(size--) {
- l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
- if (*l == '#') {
- MOVA(l);
- l = "acc";
- }
- pic14_emitcode("push","%s",l);
- }
- return ;
- }
-
- /* this is a paramter push: in this case we call
- the routine to find the call and save those
- registers that need to be saved */
- saveRegisters(ic);
-
- /* then do the push */
- aopOp(IC_LEFT(ic),ic,FALSE);
-
-
- // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
- size = AOP_SIZE(IC_LEFT(ic));
-
- while (size--) {
- l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
- if (AOP_TYPE(IC_LEFT(ic)) != AOP_REG &&
- AOP_TYPE(IC_LEFT(ic)) != AOP_DIR &&
- strcmp(l,"a") ) {
- pic14_emitcode("mov","a,%s",l);
- pic14_emitcode("push","acc");
- } else
- pic14_emitcode("push","%s",l);
- }
-
- freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
-#endif
-}
-
-/*-----------------------------------------------------------------*/
-/* genIpop - recover the registers: can happen only for spilling */
+ int size, offset = 0 ;
+ char *l;
+
+
+ /* if this is not a parm push : ie. it is spill push
+ and spill push is always done on the local stack */
+ if (!ic->parmPush) {
+
+ /* and the item is spilt then do nothing */
+ if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
+ return ;
+
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_LEFT(ic));
+ /* push it on the stack */
+ while(size--) {
+ l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
+ if (*l == '#') {
+ MOVA(l);
+ l = "acc";
+ }
+ pic14_emitcode("push","%s",l);
+ }
+ return ;
+ }
+
+ /* this is a paramter push: in this case we call
+ the routine to find the call and save those
+ registers that need to be saved */
+ saveRegisters(ic);
+
+ /* then do the push */
+ aopOp(IC_LEFT(ic),ic,FALSE);
+
+
+ // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
+ size = AOP_SIZE(IC_LEFT(ic));
+
+ while (size--) {
+ l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE);
+ if (AOP_TYPE(IC_LEFT(ic)) != AOP_REG &&
+ AOP_TYPE(IC_LEFT(ic)) != AOP_DIR &&
+ strcmp(l,"a") ) {
+ pic14_emitcode("mov","a,%s",l);
+ pic14_emitcode("push","acc");
+ } else
+ pic14_emitcode("push","%s",l);
+ }
+
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* genIpop - recover the registers: can happen only for spilling */
/*-----------------------------------------------------------------*/
static void genIpop (iCode *ic)
{
- DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
#if 0
- int size,offset ;
-
-
- /* if the temp was not pushed then */
- if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
- return ;
-
- aopOp(IC_LEFT(ic),ic,FALSE);
- size = AOP_SIZE(IC_LEFT(ic));
- offset = (size-1);
- while (size--)
- pic14_emitcode("pop","%s",aopGet(AOP(IC_LEFT(ic)),offset--,
- FALSE,TRUE));
-
- freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
+ int size,offset ;
+
+
+ /* if the temp was not pushed then */
+ if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
+ return ;
+
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_LEFT(ic));
+ offset = (size-1);
+ while (size--)
+ pic14_emitcode("pop","%s",aopGet(AOP(IC_LEFT(ic)),offset--,
+ FALSE,TRUE));
+
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
#endif
}
/*-----------------------------------------------------------------*/
static void unsaverbank (int bank,iCode *ic,bool popPsw)
{
- DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
#if 0
- int i;
- asmop *aop ;
- regs *r = NULL;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (popPsw) {
+ int i;
+ asmop *aop ;
+ regs *r = NULL;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (popPsw) {
+ if (options.useXstack) {
+ aop = newAsmop(0);
+ r = getFreePtr(ic,&aop,FALSE);
+
+
+ pic14_emitcode("mov","%s,_spx",r->name);
+ pic14_emitcode("movx","a,@%s",r->name);
+ pic14_emitcode("mov","psw,a");
+ pic14_emitcode("dec","%s",r->name);
+
+ }else
+ pic14_emitcode ("pop","psw");
+ }
+
+ for (i = (pic14_nRegs - 1) ; i >= 0 ;i--) {
+ if (options.useXstack) {
+ pic14_emitcode("movx","a,@%s",r->name);
+ //pic14_emitcode("mov","(%s+%d),a",
+ // regspic14[i].base,8*bank+regspic14[i].offset);
+ pic14_emitcode("dec","%s",r->name);
+
+ } else
+ pic14_emitcode("pop",""); //"(%s+%d)",
+ //regspic14[i].base,8*bank); //+regspic14[i].offset);
+ }
+
if (options.useXstack) {
- aop = newAsmop(0);
- r = getFreePtr(ic,&aop,FALSE);
-
-
- pic14_emitcode("mov","%s,_spx",r->name);
- pic14_emitcode("movx","a,@%s",r->name);
- pic14_emitcode("mov","psw,a");
- pic14_emitcode("dec","%s",r->name);
-
- }else
- pic14_emitcode ("pop","psw");
- }
-
- for (i = (pic14_nRegs - 1) ; i >= 0 ;i--) {
- if (options.useXstack) {
- pic14_emitcode("movx","a,@%s",r->name);
- //pic14_emitcode("mov","(%s+%d),a",
- // regspic14[i].base,8*bank+regspic14[i].offset);
- pic14_emitcode("dec","%s",r->name);
-
- } else
- pic14_emitcode("pop",""); //"(%s+%d)",
- //regspic14[i].base,8*bank); //+regspic14[i].offset);
- }
-
- if (options.useXstack) {
-
- pic14_emitcode("mov","_spx,%s",r->name);
- freeAsmop(NULL,aop,ic,TRUE);
-
- }
+
+ pic14_emitcode("mov","_spx,%s",r->name);
+ freeAsmop(NULL,aop,ic,TRUE);
+
+ }
#endif
}
/*-----------------------------------------------------------------*/
static void saverbank (int bank, iCode *ic, bool pushPsw)
{
- DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
#if 0
- int i;
- asmop *aop ;
- regs *r = NULL;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (options.useXstack) {
-
- aop = newAsmop(0);
- r = getFreePtr(ic,&aop,FALSE);
- pic14_emitcode("mov","%s,_spx",r->name);
-
- }
-
- for (i = 0 ; i < pic14_nRegs ;i++) {
- if (options.useXstack) {
- pic14_emitcode("inc","%s",r->name);
- //pic14_emitcode("mov","a,(%s+%d)",
- // regspic14[i].base,8*bank+regspic14[i].offset);
- pic14_emitcode("movx","@%s,a",r->name);
- } else
- pic14_emitcode("push","");// "(%s+%d)",
- //regspic14[i].base,8*bank+regspic14[i].offset);
- }
-
- if (pushPsw) {
+ int i;
+ asmop *aop ;
+ regs *r = NULL;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if (options.useXstack) {
- pic14_emitcode("mov","a,psw");
- pic14_emitcode("movx","@%s,a",r->name);
- pic14_emitcode("inc","%s",r->name);
- pic14_emitcode("mov","_spx,%s",r->name);
- freeAsmop (NULL,aop,ic,TRUE);
-
- } else
- pic14_emitcode("push","psw");
+
+ aop = newAsmop(0);
+ r = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,_spx",r->name);
+
+ }
+
+ for (i = 0 ; i < pic14_nRegs ;i++) {
+ if (options.useXstack) {
+ pic14_emitcode("inc","%s",r->name);
+ //pic14_emitcode("mov","a,(%s+%d)",
+ // regspic14[i].base,8*bank+regspic14[i].offset);
+ pic14_emitcode("movx","@%s,a",r->name);
+ } else
+ pic14_emitcode("push","");// "(%s+%d)",
+ //regspic14[i].base,8*bank+regspic14[i].offset);
+ }
- pic14_emitcode("mov","psw,#0x%02x",(bank << 3)&0x00ff);
- }
- ic->bankSaved = 1;
+ if (pushPsw) {
+ if (options.useXstack) {
+ pic14_emitcode("mov","a,psw");
+ pic14_emitcode("movx","@%s,a",r->name);
+ pic14_emitcode("inc","%s",r->name);
+ pic14_emitcode("mov","_spx,%s",r->name);
+ freeAsmop (NULL,aop,ic,TRUE);
+
+ } else
+ pic14_emitcode("push","psw");
+
+ pic14_emitcode("mov","psw,#0x%02x",(bank << 3)&0x00ff);
+ }
+ ic->bankSaved = 1;
#endif
}
/*-----------------------------------------------------------------*/
static void genCall (iCode *ic)
{
- sym_link *dtype;
- symbol *sym;
- unsigned char *name;
- int isExtern;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- /* if caller saves & we have not saved then */
- if (!ic->regsSaved)
- saveRegisters(ic);
-
- /* if we are calling a function that is not using
- the same register bank then we need to save the
- destination registers on the stack */
- dtype = operandType(IC_LEFT(ic));
- if (currFunc && dtype &&
- (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
- IFFUNC_ISISR(currFunc->type) &&
- !ic->bankSaved)
-
- saverbank(FUNC_REGBANK(dtype),ic,TRUE);
-
- /* if send set is not empty the assign */
- if (_G.sendSet) {
- iCode *sic;
- /* For the Pic port, there is no data stack.
- * So parameters passed to functions are stored
- * in registers. (The pCode optimizer will get
- * rid of most of these :).
- */
- int psuedoStkPtr=-1;
- int firstTimeThruLoop = 1;
-
- _G.sendSet = reverseSet(_G.sendSet);
-
- /* First figure how many parameters are getting passed */
- for (sic = setFirstItem(_G.sendSet) ; sic ;
- sic = setNextItem(_G.sendSet)) {
-
- aopOp(IC_LEFT(sic),sic,FALSE);
- psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
- freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
- }
-
- for (sic = setFirstItem(_G.sendSet) ; sic ;
- sic = setNextItem(_G.sendSet)) {
- int size, offset = 0;
-
- aopOp(IC_LEFT(sic),sic,FALSE);
- size = AOP_SIZE(IC_LEFT(sic));
-
- while (size--) {
- DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
- AopType(AOP_TYPE(IC_LEFT(sic))));
-
- if(!firstTimeThruLoop) {
- /* If this is not the first time we've been through the loop
- * then we need to save the parameter in a temporary
- * register. The last byte of the last parameter is
- * passed in W. */
- emitpcode(POC_MOVWF,popRegFromIdx(Gstack_base_addr - --psuedoStkPtr));
-
- }
- firstTimeThruLoop=0;
-
- mov2w (AOP(IC_LEFT(sic)), offset);
- offset++;
- }
- freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
- }
- _G.sendSet = NULL;
- }
- /* make the call */
- sym = OP_SYMBOL(IC_LEFT(ic));
- name = sym->rname[0] ? sym->rname : sym->name;
- isExtern = IS_EXTERN(sym->etype);
- if (isExtern) {
- emitpcode(POC_PAGESEL,popGetWithString(name,1)); /* Extern functions maybe on another page - must call pagesel */
- }
- emitpcode(POC_CALL,popGetWithString(name,isExtern));
- if (isExtern) {
- emitpcode(POC_PAGESEL,popGetWithString("$",0)); /* May have returned from another page - must call pagesel */
- }
- GpsuedoStkPtr=0;
- /* if we need assign a result value */
- if ((IS_ITEMP(IC_RESULT(ic)) &&
- (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
- OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
- IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
-
- _G.accInUse++;
- aopOp(IC_RESULT(ic),ic,FALSE);
- _G.accInUse--;
-
- assignResultValue(IC_RESULT(ic));
-
- DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
- AopType(AOP_TYPE(IC_RESULT(ic))));
+ sym_link *dtype;
+ symbol *sym;
+ unsigned char *name;
+ int isExtern;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* if caller saves & we have not saved then */
+ if (!ic->regsSaved)
+ saveRegisters(ic);
+
+ /* if we are calling a function that is not using
+ the same register bank then we need to save the
+ destination registers on the stack */
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)) &&
+ IFFUNC_ISISR(currFunc->type) &&
+ !ic->bankSaved)
- freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
- }
-
- /* adjust the stack for parameters if
- required */
- if (ic->parmBytes) {
- int i;
- if (ic->parmBytes > 3) {
- pic14_emitcode("mov","a,%s",spname);
- pic14_emitcode("add","a,#0x%02x", (- ic->parmBytes) & 0xff);
- pic14_emitcode("mov","%s,a",spname);
- } else
- for ( i = 0 ; i < ic->parmBytes ;i++)
- pic14_emitcode("dec","%s",spname);
-
- }
-
- /* if register bank was saved then pop them */
- if (ic->bankSaved)
- unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
-
- /* if we hade saved some registers then unsave them */
- if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
- unsaveRegisters (ic);
-
-
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ /* if send set is not empty the assign */
+ if (_G.sendSet) {
+ iCode *sic;
+ /* For the Pic port, there is no data stack.
+ * So parameters passed to functions are stored
+ * in registers. (The pCode optimizer will get
+ * rid of most of these :).
+ */
+ int psuedoStkPtr=-1;
+ int firstTimeThruLoop = 1;
+
+ _G.sendSet = reverseSet(_G.sendSet);
+
+ /* First figure how many parameters are getting passed */
+ for (sic = setFirstItem(_G.sendSet) ; sic ;
+ sic = setNextItem(_G.sendSet)) {
+
+ aopOp(IC_LEFT(sic),sic,FALSE);
+ psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
+ freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
+ }
+
+ for (sic = setFirstItem(_G.sendSet) ; sic ;
+ sic = setNextItem(_G.sendSet)) {
+ int size, offset = 0;
+
+ aopOp(IC_LEFT(sic),sic,FALSE);
+ size = AOP_SIZE(IC_LEFT(sic));
+
+ while (size--) {
+ DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
+ AopType(AOP_TYPE(IC_LEFT(sic))));
+
+ if(!firstTimeThruLoop) {
+ /* If this is not the first time we've been through the loop
+ * then we need to save the parameter in a temporary
+ * register. The last byte of the last parameter is
+ * passed in W. */
+ emitpcode(POC_MOVWF,popRegFromIdx(Gstack_base_addr - --psuedoStkPtr));
+
+ }
+ firstTimeThruLoop=0;
+
+ mov2w (AOP(IC_LEFT(sic)), offset);
+ offset++;
+ }
+ freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
+ }
+ _G.sendSet = NULL;
+ }
+ /* make the call */
+ sym = OP_SYMBOL(IC_LEFT(ic));
+ name = sym->rname[0] ? sym->rname : sym->name;
+ isExtern = IS_EXTERN(sym->etype);
+ if (isExtern) {
+ emitpcode(POC_PAGESEL,popGetWithString(name,1)); /* Extern functions maybe on another page - must call pagesel */
+ }
+ emitpcode(POC_CALL,popGetWithString(name,isExtern));
+ if (isExtern) {
+ emitpcode(POC_PAGESEL,popGetWithString("$",0)); /* May have returned from another page - must call pagesel */
+ }
+ GpsuedoStkPtr=0;
+ /* if we need assign a result value */
+ if ((IS_ITEMP(IC_RESULT(ic)) &&
+ (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
+ OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
+ IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
+
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+
+ assignResultValue(IC_RESULT(ic));
+
+ DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
+ AopType(AOP_TYPE(IC_RESULT(ic))));
+
+ freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
+ }
+
+ /* adjust the stack for parameters if
+ required */
+ if (ic->parmBytes) {
+ int i;
+ if (ic->parmBytes > 3) {
+ pic14_emitcode("mov","a,%s",spname);
+ pic14_emitcode("add","a,#0x%02x", (- ic->parmBytes) & 0xff);
+ pic14_emitcode("mov","%s,a",spname);
+ } else
+ for ( i = 0 ; i < ic->parmBytes ;i++)
+ pic14_emitcode("dec","%s",spname);
+
+ }
+
+ /* if register bank was saved then pop them */
+ if (ic->bankSaved)
+ unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ /* if we hade saved some registers then unsave them */
+ if (ic->regsSaved && !IFFUNC_CALLEESAVES(dtype))
+ unsaveRegisters (ic);
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genPcall (iCode *ic)
{
- sym_link *dtype;
- symbol *albl = newiTempLabel(NULL);
- symbol *blbl = newiTempLabel(NULL);
- PIC_OPCODE poc;
+ sym_link *dtype;
+ symbol *albl = newiTempLabel(NULL);
+ symbol *blbl = newiTempLabel(NULL);
+ PIC_OPCODE poc;
pCodeOp *pcop;
- operand *left;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if caller saves & we have not saved then */
- if (!ic->regsSaved)
- saveRegisters(ic);
-
- /* if we are calling a function that is not using
- the same register bank then we need to save the
- destination registers on the stack */
- dtype = operandType(IC_LEFT(ic));
- if (currFunc && dtype &&
- IFFUNC_ISISR(currFunc->type) &&
- (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
- saverbank(FUNC_REGBANK(dtype),ic,TRUE);
-
- left = IC_LEFT(ic);
- aopOp(left,ic,FALSE);
- DEBUGpic14_AopType(__LINE__,left,NULL,NULL);
-
- pushSide(IC_LEFT(ic), FPTRSIZE);
-
- /* if send set is not empty, assign parameters */
- if (_G.sendSet) {
-
- DEBUGpic14_emitcode ("; ***","%s %d - WARNING arg-passing to indirect call not supported",__FUNCTION__,__LINE__);
- /* no way to pass args - W always gets used to make the call */
- }
-/* first idea - factor out a common helper function and call it.
- But don't know how to get it generated only once in its own block
-
- if(AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) {
- char *rname;
- char *buffer;
- rname = IC_LEFT(ic)->aop->aopu.aop_dir;
- DEBUGpic14_emitcode ("; ***","%s %d AOP_DIR %s",__FUNCTION__,__LINE__,rname);
- buffer = Safe_calloc(1,strlen(rname)+16);
- sprintf(buffer, "%s_goto_helper", rname);
- addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp(buffer,PO_STR)));
- free(buffer);
- }
-*/
- emitpcode(POC_CALL,popGetLabel(albl->key));
+ operand *left;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if caller saves & we have not saved then */
+ if (!ic->regsSaved)
+ saveRegisters(ic);
+
+ /* if we are calling a function that is not using
+ the same register bank then we need to save the
+ destination registers on the stack */
+ dtype = operandType(IC_LEFT(ic));
+ if (currFunc && dtype &&
+ IFFUNC_ISISR(currFunc->type) &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
+ saverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ left = IC_LEFT(ic);
+ aopOp(left,ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,left,NULL,NULL);
+
+ pushSide(IC_LEFT(ic), FPTRSIZE);
+
+ /* if send set is not empty, assign parameters */
+ if (_G.sendSet) {
+
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING arg-passing to indirect call not supported",__FUNCTION__,__LINE__);
+ /* no way to pass args - W always gets used to make the call */
+ }
+ /* first idea - factor out a common helper function and call it.
+ But don't know how to get it generated only once in its own block
+
+ if(AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) {
+ char *rname;
+ char *buffer;
+ rname = IC_LEFT(ic)->aop->aopu.aop_dir;
+ DEBUGpic14_emitcode ("; ***","%s %d AOP_DIR %s",__FUNCTION__,__LINE__,rname);
+ buffer = Safe_calloc(1,strlen(rname)+16);
+ sprintf(buffer, "%s_goto_helper", rname);
+ addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp(buffer,PO_STR)));
+ free(buffer);
+ }
+ */
+ emitpcode(POC_CALL,popGetLabel(albl->key));
pcop = popGetLabel(blbl->key);
emitpcode(POC_PAGESEL,popGetWithString(pcop->name,0)); /* Must restore PCLATH before goto, without destroying W */
- emitpcode(POC_GOTO,pcop);
- emitpLabel(albl->key);
-
- poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
-
- emitpcode(poc,popGet(AOP(left),1));
- emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
- emitpcode(poc,popGet(AOP(left),0));
- emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
-
- emitpLabel(blbl->key);
-
- freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
-
- /* if we need to assign a result value */
- if ((IS_ITEMP(IC_RESULT(ic)) &&
- (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
- OP_SYMBOL(IC_RESULT(ic))->spildir)) ||
- IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
-
- _G.accInUse++;
- aopOp(IC_RESULT(ic),ic,FALSE);
- _G.accInUse--;
+ emitpcode(POC_GOTO,pcop);
+ emitpLabel(albl->key);
+
+ poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
+
+ emitpcode(poc,popGet(AOP(left),1));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
+ emitpcode(poc,popGet(AOP(left),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
+
+ emitpLabel(blbl->key);
+
+ freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
+
+ /* if we need to assign a result value */
+ if ((IS_ITEMP(IC_RESULT(ic)) &&
+ (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
+ OP_SYMBOL(IC_RESULT(ic))->spildir)) ||
+ IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
+
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+
+ assignResultValue(IC_RESULT(ic));
+
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ }
+
+ /* if register bank was saved then unsave them */
+ if (currFunc && dtype &&
+ (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
+ unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
+
+ /* if we hade saved some registers then
+ unsave them */
+ if (ic->regsSaved)
+ unsaveRegisters (ic);
- assignResultValue(IC_RESULT(ic));
-
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
- }
-
- /* if register bank was saved then unsave them */
- if (currFunc && dtype &&
- (FUNC_REGBANK(currFunc->type) != FUNC_REGBANK(dtype)))
- unsaverbank(FUNC_REGBANK(dtype),ic,TRUE);
-
- /* if we hade saved some registers then
- unsave them */
- if (ic->regsSaved)
- unsaveRegisters (ic);
-
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static int resultRemat (iCode *ic)
{
- // DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (SKIP_IC(ic) || ic->op == IFX)
- return 0;
-
- if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
- symbol *sym = OP_SYMBOL(IC_RESULT(ic));
- if (sym->remat && !POINTER_SET(ic))
- return 1;
- }
-
- return 0;
+ // DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (SKIP_IC(ic) || ic->op == IFX)
+ return 0;
+
+ if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
+ symbol *sym = OP_SYMBOL(IC_RESULT(ic));
+ if (sym->remat && !POINTER_SET(ic))
+ return 1;
+ }
+
+ return 0;
}
#if defined(__BORLANDC__) || defined(_MSC_VER)
/*-----------------------------------------------------------------*/
static bool inExcludeList(char *s)
{
- DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
- int i =0;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (options.excludeRegs[i] &&
- STRCASECMP(options.excludeRegs[i],"none") == 0)
- return FALSE ;
-
- for ( i = 0 ; options.excludeRegs[i]; i++) {
+ DEBUGpic14_emitcode ("; ***","%s %d - WARNING no code generated",__FUNCTION__,__LINE__);
+ int i =0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if (options.excludeRegs[i] &&
- STRCASECMP(s,options.excludeRegs[i]) == 0)
- return TRUE;
- }
- return FALSE ;
+ STRCASECMP(options.excludeRegs[i],"none") == 0)
+ return FALSE ;
+
+ for ( i = 0 ; options.excludeRegs[i]; i++) {
+ if (options.excludeRegs[i] &&
+ STRCASECMP(s,options.excludeRegs[i]) == 0)
+ return TRUE;
+ }
+ return FALSE ;
}
#endif
/*-----------------------------------------------------------------*/
static void genFunction (iCode *ic)
{
- symbol *sym;
- sym_link *ftype;
-
- DEBUGpic14_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
-
- labelOffset += (max_key+4);
- max_key=0;
- GpsuedoStkPtr=0;
- _G.nRegsSaved = 0;
- /* create the function header */
- pic14_emitcode(";","-----------------------------------------");
- pic14_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
- pic14_emitcode(";","-----------------------------------------");
-
- pic14_emitcode("","%s:",sym->rname);
- addpCode2pBlock(pb,newpCodeFunction(NULL,sym->rname,!IS_STATIC (sym->etype)));
-
- ftype = operandType(IC_LEFT(ic));
-
- /* if critical function then turn interrupts off */
- if (IFFUNC_ISCRITICAL(ftype))
- pic14_emitcode("clr","ea");
-
- /* here we need to generate the equates for the
- register bank if required */
+ symbol *sym;
+ sym_link *ftype;
+
+ DEBUGpic14_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
+
+ labelOffset += (max_key+4);
+ max_key=0;
+ GpsuedoStkPtr=0;
+ _G.nRegsSaved = 0;
+ /* create the function header */
+ pic14_emitcode(";","-----------------------------------------");
+ pic14_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
+ pic14_emitcode(";","-----------------------------------------");
+
+ pic14_emitcode("","%s:",sym->rname);
+ addpCode2pBlock(pb,newpCodeFunction(NULL,sym->rname,!IS_STATIC (sym->etype)));
+
+ ftype = operandType(IC_LEFT(ic));
+
+ /* if critical function then turn interrupts off */
+ if (IFFUNC_ISCRITICAL(ftype))
+ pic14_emitcode("clr","ea");
+
+ /* here we need to generate the equates for the
+ register bank if required */
#if 0
- if (FUNC_REGBANK(ftype) != rbank) {
- int i ;
-
- rbank = FUNC_REGBANK(ftype);
- for ( i = 0 ; i < pic14_nRegs ; i++ ) {
- if (strcmp(regspic14[i].base,"0") == 0)
- pic14_emitcode("","%s = 0x%02x",
- regspic14[i].dname,
- 8*rbank+regspic14[i].offset);
- else
- pic14_emitcode ("","%s = %s + 0x%02x",
- regspic14[i].dname,
- regspic14[i].base,
- 8*rbank+regspic14[i].offset);
- }
- }
+ if (FUNC_REGBANK(ftype) != rbank) {
+ int i ;
+
+ rbank = FUNC_REGBANK(ftype);
+ for ( i = 0 ; i < pic14_nRegs ; i++ ) {
+ if (strcmp(regspic14[i].base,"0") == 0)
+ pic14_emitcode("","%s = 0x%02x",
+ regspic14[i].dname,
+ 8*rbank+regspic14[i].offset);
+ else
+ pic14_emitcode ("","%s = %s + 0x%02x",
+ regspic14[i].dname,
+ regspic14[i].base,
+ 8*rbank+regspic14[i].offset);
+ }
+ }
#endif
-
- /* if this is an interrupt service routine */
- if (IFFUNC_ISISR(sym->type)) {
-/* already done in pic14createInterruptVect() - delete me
- addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("END_OF_INTERRUPT+1",PO_STR)));
- emitpcodeNULLop(POC_NOP);
- emitpcodeNULLop(POC_NOP);
- emitpcodeNULLop(POC_NOP);
-*/
- emitpcode(POC_MOVWF, popCopyReg(&pc_wsave));
- emitpcode(POC_SWAPFW, popCopyReg(&pc_status));
- emitpcode(POC_CLRF, popCopyReg(&pc_status));
- emitpcode(POC_MOVWF, popCopyReg(&pc_ssave));
- emitpcode(POC_MOVFW, popCopyReg(&pc_pclath));
- emitpcode(POC_MOVWF, popCopyReg(&pc_psave));
- emitpcode(POC_CLRF, popCopyReg(&pc_pclath));/* during an interrupt PCLATH must be cleared before a goto or call statement */
-
- pBlockConvert2ISR(pb);
+
+ /* if this is an interrupt service routine */
+ if (IFFUNC_ISISR(sym->type)) {
+ /* already done in pic14createInterruptVect() - delete me
+ addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("END_OF_INTERRUPT+1",PO_STR)));
+ emitpcodeNULLop(POC_NOP);
+ emitpcodeNULLop(POC_NOP);
+ emitpcodeNULLop(POC_NOP);
+ */
+ emitpcode(POC_MOVWF, popCopyReg(&pc_wsave));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_status));
+ emitpcode(POC_CLRF, popCopyReg(&pc_status));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_ssave));
+ emitpcode(POC_MOVFW, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_psave));
+ emitpcode(POC_CLRF, popCopyReg(&pc_pclath));/* during an interrupt PCLATH must be cleared before a goto or call statement */
+
+ pBlockConvert2ISR(pb);
#if 0
- if (!inExcludeList("acc"))
- pic14_emitcode ("push","acc");
- if (!inExcludeList("b"))
- pic14_emitcode ("push","b");
- if (!inExcludeList("dpl"))
- pic14_emitcode ("push","dpl");
- if (!inExcludeList("dph"))
- pic14_emitcode ("push","dph");
- if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
- {
- pic14_emitcode ("push", "dpx");
- /* Make sure we're using standard DPTR */
- pic14_emitcode ("push", "dps");
- pic14_emitcode ("mov", "dps, #0x00");
- if (options.stack10bit)
- {
- /* This ISR could conceivably use DPTR2. Better save it. */
- pic14_emitcode ("push", "dpl1");
- pic14_emitcode ("push", "dph1");
- pic14_emitcode ("push", "dpx1");
- }
- }
- /* if this isr has no bank i.e. is going to
- run with bank 0 , then we need to save more
- registers :-) */
- if (!FUNC_REGBANK(sym->type)) {
-
- /* 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) {
- /* save the registers used */
- for ( i = 0 ; i < sym->regsUsed->size ; i++) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
- pic14_emitcode("push","junk");//"%s",pic14_regWithIdx(i)->dname);
- }
+ if (!inExcludeList("acc"))
+ pic14_emitcode ("push","acc");
+ if (!inExcludeList("b"))
+ pic14_emitcode ("push","b");
+ if (!inExcludeList("dpl"))
+ pic14_emitcode ("push","dpl");
+ if (!inExcludeList("dph"))
+ pic14_emitcode ("push","dph");
+ if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
+ {
+ pic14_emitcode ("push", "dpx");
+ /* Make sure we're using standard DPTR */
+ pic14_emitcode ("push", "dps");
+ pic14_emitcode ("mov", "dps, #0x00");
+ if (options.stack10bit)
+ {
+ /* This ISR could conceivably use DPTR2. Better save it. */
+ pic14_emitcode ("push", "dpl1");
+ pic14_emitcode ("push", "dph1");
+ pic14_emitcode ("push", "dpx1");
+ }
+ }
+ /* if this isr has no bank i.e. is going to
+ run with bank 0 , then we need to save more
+registers :-) */
+ if (!FUNC_REGBANK(sym->type)) {
+
+ /* 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) {
+ /* save the registers used */
+ for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic14_emitcode("push","junk");//"%s",pic14_regWithIdx(i)->dname);
+ }
+ }
+
+ } else {
+ /* this function has a function call cannot
+ determines register usage so we will have the
+ entire bank */
+ saverbank(0,ic,FALSE);
+ }
}
-
- } else {
- /* this function has a function call cannot
- determines register usage so we will have the
- entire bank */
- saverbank(0,ic,FALSE);
- }
- }
#endif
- } else {
+ } else {
/* if callee-save to be used for this function
- then save the registers being used in this function */
- if (IFFUNC_CALLEESAVES(sym->type)) {
- int i;
-
- /* if any registers used */
- if (sym->regsUsed) {
- /* save the registers used */
- for ( i = 0 ; i < sym->regsUsed->size ; i++) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
- //pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
- _G.nRegsSaved++;
- }
- }
- }
- }
- }
-
- /* set the register bank to the desired value */
- if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type)) {
- pic14_emitcode("push","psw");
- pic14_emitcode("mov","psw,#0x%02x",(FUNC_REGBANK(sym->type) << 3)&0x00ff);
- }
-
- if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
-
- if (options.useXstack) {
- pic14_emitcode("mov","r0,%s",spname);
- pic14_emitcode("mov","a,_bp");
- pic14_emitcode("movx","@r0,a");
- pic14_emitcode("inc","%s",spname);
+ then save the registers being used in this function */
+ if (IFFUNC_CALLEESAVES(sym->type)) {
+ int i;
+
+ /* if any registers used */
+ if (sym->regsUsed) {
+ /* save the registers used */
+ for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
+ //pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+ _G.nRegsSaved++;
+ }
+ }
+ }
+ }
}
- else
- {
- /* set up the stack */
- pic14_emitcode ("push","_bp"); /* save the callers stack */
+
+ /* set the register bank to the desired value */
+ if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type)) {
+ pic14_emitcode("push","psw");
+ pic14_emitcode("mov","psw,#0x%02x",(FUNC_REGBANK(sym->type) << 3)&0x00ff);
}
- pic14_emitcode ("mov","_bp,%s",spname);
- }
-
- /* adjust the stack for the function */
- if (sym->stack) {
-
- int i = sym->stack;
- if (i > 256 )
- werror(W_STACK_OVERFLOW,sym->name);
-
- if (i > 3 && sym->recvSize < 4) {
-
- pic14_emitcode ("mov","a,sp");
- pic14_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
- pic14_emitcode ("mov","sp,a");
-
+
+ if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
+
+ if (options.useXstack) {
+ pic14_emitcode("mov","r0,%s",spname);
+ pic14_emitcode("mov","a,_bp");
+ pic14_emitcode("movx","@r0,a");
+ pic14_emitcode("inc","%s",spname);
+ }
+ else
+ {
+ /* set up the stack */
+ pic14_emitcode ("push","_bp"); /* save the callers stack */
+ }
+ pic14_emitcode ("mov","_bp,%s",spname);
}
- else
- while(i--)
- pic14_emitcode("inc","sp");
- }
-
- if (sym->xstack) {
-
- pic14_emitcode ("mov","a,_spx");
- pic14_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
- pic14_emitcode ("mov","_spx,a");
- }
-
+
+ /* adjust the stack for the function */
+ if (sym->stack) {
+
+ int i = sym->stack;
+ if (i > 256 )
+ werror(W_STACK_OVERFLOW,sym->name);
+
+ if (i > 3 && sym->recvSize < 4) {
+
+ pic14_emitcode ("mov","a,sp");
+ pic14_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
+ pic14_emitcode ("mov","sp,a");
+
+ }
+ else
+ while(i--)
+ pic14_emitcode("inc","sp");
+ }
+
+ if (sym->xstack) {
+
+ pic14_emitcode ("mov","a,_spx");
+ pic14_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
+ pic14_emitcode ("mov","_spx,a");
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genEndFunction (iCode *ic)
{
- symbol *sym = OP_SYMBOL(IC_LEFT(ic));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if (IFFUNC_ISREENT(sym->type) || options.stackAuto)
- {
- pic14_emitcode ("mov","%s,_bp",spname);
- }
-
- /* if use external stack but some variables were
- added to the local stack then decrement the
- local stack */
- if (options.useXstack && sym->stack) {
- pic14_emitcode("mov","a,sp");
- pic14_emitcode("add","a,#0x%02x",((char)-sym->stack) & 0xff);
- pic14_emitcode("mov","sp,a");
- }
-
-
- if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) {
- if (options.useXstack) {
- pic14_emitcode("mov","r0,%s",spname);
- pic14_emitcode("movx","a,@r0");
- pic14_emitcode("mov","_bp,a");
- pic14_emitcode("dec","%s",spname);
- }
- else
+ symbol *sym = OP_SYMBOL(IC_LEFT(ic));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (IFFUNC_ISREENT(sym->type) || options.stackAuto)
{
- pic14_emitcode ("pop","_bp");
- }
- }
-
- /* restore the register bank */
- if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type))
- pic14_emitcode ("pop","psw");
-
- if (IFFUNC_ISISR(sym->type)) {
-
- /* now we need to restore the registers */
- /* if this isr has no bank i.e. is going to
- run with bank 0 , then we need to save more
- registers :-) */
- if (!FUNC_REGBANK(sym->type)) {
-
- /* 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) {
- /* save the registers used */
- for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
- pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
- }
+ pic14_emitcode ("mov","%s,_bp",spname);
+ }
+
+ /* if use external stack but some variables were
+ added to the local stack then decrement the
+ local stack */
+ if (options.useXstack && sym->stack) {
+ pic14_emitcode("mov","a,sp");
+ pic14_emitcode("add","a,#0x%02x",((char)-sym->stack) & 0xff);
+ pic14_emitcode("mov","sp,a");
+ }
+
+
+ if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) {
+ if (options.useXstack) {
+ pic14_emitcode("mov","r0,%s",spname);
+ pic14_emitcode("movx","a,@r0");
+ pic14_emitcode("mov","_bp,a");
+ pic14_emitcode("dec","%s",spname);
+ }
+ else
+ {
+ pic14_emitcode ("pop","_bp");
}
-
- } else {
- /* this function has a function call cannot
- determines register usage so we will have the
- entire bank */
- unsaverbank(0,ic,FALSE);
- }
}
+
+ /* restore the register bank */
+ if (FUNC_REGBANK(sym->type) || FUNC_ISISR(sym->type))
+ pic14_emitcode ("pop","psw");
+
+ if (IFFUNC_ISISR(sym->type)) {
+
+ /* now we need to restore the registers */
+ /* if this isr has no bank i.e. is going to
+ run with bank 0 , then we need to save more
+registers :-) */
+ if (!FUNC_REGBANK(sym->type)) {
+
+ /* 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) {
+ /* save the registers used */
+ for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
+ }
+ }
+
+ } else {
+ /* this function has a function call cannot
+ determines register usage so we will have the
+ entire bank */
+ unsaverbank(0,ic,FALSE);
+ }
+ }
#if 0
- if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
- {
- if (options.stack10bit)
- {
- pic14_emitcode ("pop", "dpx1");
- pic14_emitcode ("pop", "dph1");
- pic14_emitcode ("pop", "dpl1");
- }
- pic14_emitcode ("pop", "dps");
- pic14_emitcode ("pop", "dpx");
- }
- if (!inExcludeList("dph"))
- pic14_emitcode ("pop","dph");
- if (!inExcludeList("dpl"))
- pic14_emitcode ("pop","dpl");
- if (!inExcludeList("b"))
- pic14_emitcode ("pop","b");
- if (!inExcludeList("acc"))
- pic14_emitcode ("pop","acc");
-
- if (IFFUNC_ISCRITICAL(sym->type))
- pic14_emitcode("setb","ea");
+ if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
+ {
+ if (options.stack10bit)
+ {
+ pic14_emitcode ("pop", "dpx1");
+ pic14_emitcode ("pop", "dph1");
+ pic14_emitcode ("pop", "dpl1");
+ }
+ pic14_emitcode ("pop", "dps");
+ pic14_emitcode ("pop", "dpx");
+ }
+ if (!inExcludeList("dph"))
+ pic14_emitcode ("pop","dph");
+ if (!inExcludeList("dpl"))
+ pic14_emitcode ("pop","dpl");
+ if (!inExcludeList("b"))
+ pic14_emitcode ("pop","b");
+ if (!inExcludeList("acc"))
+ pic14_emitcode ("pop","acc");
+
+ if (IFFUNC_ISCRITICAL(sym->type))
+ pic14_emitcode("setb","ea");
#endif
-
- /* if debug then send end of function */
-/* if (options.debug && currFunc) { */
- if (currFunc) {
- _G.debugLine = 1;
- pic14_emitcode(";","C$%s$%d$%d$%d ==.",
- FileBaseName(ic->filename),currFunc->lastLine,
- ic->level,ic->block);
- if (IS_STATIC(currFunc->etype))
- pic14_emitcode(";","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
- else
- pic14_emitcode(";","XG$%s$0$0 ==.",currFunc->name);
- _G.debugLine = 0;
- }
-
- pic14_emitcode ("reti","");
- emitpcode(POC_MOVFW, popCopyReg(&pc_psave));
- emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
- emitpcode(POC_CLRF, popCopyReg(&pc_status));
- emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
- emitpcode(POC_MOVWF, popCopyReg(&pc_status));
- emitpcode(POC_SWAPF, popCopyReg(&pc_wsave));
- emitpcode(POC_SWAPFW, popCopyReg(&pc_wsave));
- addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
- emitpcodeNULLop(POC_RETFIE);
- }
- else {
- if (IFFUNC_ISCRITICAL(sym->type))
- pic14_emitcode("setb","ea");
-
- if (IFFUNC_CALLEESAVES(sym->type)) {
- int i;
-
- /* if any registers used */
- if (sym->regsUsed) {
- /* save the registers used */
- for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
- if (bitVectBitValue(sym->regsUsed,i) ||
- (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
- pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
- }
- }
-
- }
-
- /* if debug then send end of function */
- if (currFunc) {
- _G.debugLine = 1;
- pic14_emitcode(";","C$%s$%d$%d$%d ==.",
- FileBaseName(ic->filename),currFunc->lastLine,
- ic->level,ic->block);
- if (IS_STATIC(currFunc->etype))
- pic14_emitcode(";","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
- else
- pic14_emitcode(";","XG$%s$0$0 ==.",currFunc->name);
- _G.debugLine = 0;
- }
-
- pic14_emitcode ("return","");
- emitpcodeNULLop(POC_RETURN);
-
- /* Mark the end of a function */
- addpCode2pBlock(pb,newpCodeFunction(NULL,NULL,0));
- }
-
-}
+
+ /* if debug then send end of function */
+ /* if (options.debug && currFunc) { */
+ if (currFunc) {
+ _G.debugLine = 1;
+ pic14_emitcode(";","C$%s$%d$%d$%d ==.",
+ FileBaseName(ic->filename),currFunc->lastLine,
+ ic->level,ic->block);
+ if (IS_STATIC(currFunc->etype))
+ pic14_emitcode(";","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
+ else
+ pic14_emitcode(";","XG$%s$0$0 ==.",currFunc->name);
+ _G.debugLine = 0;
+ }
+
+ pic14_emitcode ("reti","");
+ emitpcode(POC_MOVFW, popCopyReg(&pc_psave));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
+ emitpcode(POC_CLRF, popCopyReg(&pc_status));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_status));
+ emitpcode(POC_SWAPF, popCopyReg(&pc_wsave));
+ emitpcode(POC_SWAPFW, popCopyReg(&pc_wsave));
+ addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
+ emitpcodeNULLop(POC_RETFIE);
+ }
+ else {
+ if (IFFUNC_ISCRITICAL(sym->type))
+ pic14_emitcode("setb","ea");
+
+ if (IFFUNC_CALLEESAVES(sym->type)) {
+ int i;
+
+ /* if any registers used */
+ if (sym->regsUsed) {
+ /* save the registers used */
+ for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
+ if (bitVectBitValue(sym->regsUsed,i) ||
+ (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
+ pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
+ }
+ }
+
+ }
+
+ /* if debug then send end of function */
+ if (currFunc) {
+ _G.debugLine = 1;
+ pic14_emitcode(";","C$%s$%d$%d$%d ==.",
+ FileBaseName(ic->filename),currFunc->lastLine,
+ ic->level,ic->block);
+ if (IS_STATIC(currFunc->etype))
+ pic14_emitcode(";","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
+ else
+ pic14_emitcode(";","XG$%s$0$0 ==.",currFunc->name);
+ _G.debugLine = 0;
+ }
+
+ pic14_emitcode ("return","");
+ emitpcodeNULLop(POC_RETURN);
+
+ /* Mark the end of a function */
+ addpCode2pBlock(pb,newpCodeFunction(NULL,NULL,0));
+ }
+
+}
/*-----------------------------------------------------------------*/
/* genRet - generate code for return statement */
/*-----------------------------------------------------------------*/
static void genRet (iCode *ic)
{
- int size,offset = 0 , pushed = 0;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if we have no return value then
- just generate the "ret" */
- if (!IC_LEFT(ic))
- goto jumpret;
-
- /* we have something to return then
- move the return value into place */
- aopOp(IC_LEFT(ic),ic,FALSE);
- size = AOP_SIZE(IC_LEFT(ic));
-
- while (size--) {
- char *l ;
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) {
- /* #NOCHANGE */
- l = aopGet(AOP(IC_LEFT(ic)),offset++,
- FALSE,TRUE);
- pic14_emitcode("push","%s",l);
- pushed++;
- } else {
- l = aopGet(AOP(IC_LEFT(ic)),offset,
- FALSE,FALSE);
- if (strcmp(fReturn[offset],l)) {
- if ((((AOP(IC_LEFT(ic))->type) == AOP_PCODE) &&
- AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE) ||
- ( (AOP(IC_LEFT(ic))->type) == AOP_IMMD) ||
- ( (AOP(IC_LEFT(ic))->type) == AOP_LIT) ) {
- emitpcode(POC_MOVLW, popGet(AOP(IC_LEFT(ic)),offset));
- }else {
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
- }
- if(size) {
- emitpcode(POC_MOVWF,popRegFromIdx(Gstack_base_addr+1-size));
- }
- offset++;
- }
- }
- }
-
- if (pushed) {
- while(pushed) {
- pushed--;
- if (strcmp(fReturn[pushed],"a"))
- pic14_emitcode("pop",fReturn[pushed]);
- else
- pic14_emitcode("pop","acc");
- }
- }
- freeAsmop (IC_LEFT(ic),NULL,ic,TRUE);
-
- jumpret:
- /* generate a jump to the return label
- if the next is not the return statement */
- if (!(ic->next && ic->next->op == LABEL &&
- IC_LABEL(ic->next) == returnLabel)) {
-
- emitpcode(POC_GOTO,popGetLabel(returnLabel->key));
- pic14_emitcode("goto","_%05d_DS_",returnLabel->key+100 + labelOffset);
- }
-
+ int size,offset = 0 , pushed = 0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if we have no return value then
+ just generate the "ret" */
+ if (!IC_LEFT(ic))
+ goto jumpret;
+
+ /* we have something to return then
+ move the return value into place */
+ aopOp(IC_LEFT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_LEFT(ic));
+
+ while (size--) {
+ char *l ;
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) {
+ /* #NOCHANGE */
+ l = aopGet(AOP(IC_LEFT(ic)),offset++,
+ FALSE,TRUE);
+ pic14_emitcode("push","%s",l);
+ pushed++;
+ } else {
+ l = aopGet(AOP(IC_LEFT(ic)),offset,
+ FALSE,FALSE);
+ if (strcmp(fReturn[offset],l)) {
+ if ((((AOP(IC_LEFT(ic))->type) == AOP_PCODE) &&
+ AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE) ||
+ ( (AOP(IC_LEFT(ic))->type) == AOP_IMMD) ||
+ ( (AOP(IC_LEFT(ic))->type) == AOP_LIT) ) {
+ emitpcode(POC_MOVLW, popGet(AOP(IC_LEFT(ic)),offset));
+ }else {
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
+ }
+ if(size) {
+ emitpcode(POC_MOVWF,popRegFromIdx(Gstack_base_addr+1-size));
+ }
+ offset++;
+ }
+ }
+ }
+
+ if (pushed) {
+ while(pushed) {
+ pushed--;
+ if (strcmp(fReturn[pushed],"a"))
+ pic14_emitcode("pop",fReturn[pushed]);
+ else
+ pic14_emitcode("pop","acc");
+ }
+ }
+ freeAsmop (IC_LEFT(ic),NULL,ic,TRUE);
+
+jumpret:
+/* generate a jump to the return label
+ if the next is not the return statement */
+ if (!(ic->next && ic->next->op == LABEL &&
+ IC_LABEL(ic->next) == returnLabel)) {
+
+ emitpcode(POC_GOTO,popGetLabel(returnLabel->key));
+ pic14_emitcode("goto","_%05d_DS_",returnLabel->key+100 + labelOffset);
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genLabel (iCode *ic)
{
- /* special case never generate */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (IC_LABEL(ic) == entryLabel)
- return ;
-
- emitpLabel(IC_LABEL(ic)->key);
- pic14_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + labelOffset));
+ /* special case never generate */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (IC_LABEL(ic) == entryLabel)
+ return ;
+
+ emitpLabel(IC_LABEL(ic)->key);
+ pic14_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + labelOffset));
}
/*-----------------------------------------------------------------*/
//tsd
static void genGoto (iCode *ic)
{
- emitpcode(POC_GOTO,popGetLabel(IC_LABEL(ic)->key));
- pic14_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+labelOffset);
+ emitpcode(POC_GOTO,popGetLabel(IC_LABEL(ic)->key));
+ pic14_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+labelOffset);
}
/* genMultbits :- multiplication of bits */
/*-----------------------------------------------------------------*/
static void genMultbits (operand *left,
- operand *right,
- operand *result)
+ operand *right,
+ operand *result)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if(!pic14_sameRegs(AOP(result),AOP(right)))
- emitpcode(POC_BSF, popGet(AOP(result),0));
-
- emitpcode(POC_BTFSC,popGet(AOP(right),0));
- emitpcode(POC_BTFSS,popGet(AOP(left),0));
- emitpcode(POC_BCF, popGet(AOP(result),0));
-
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(!pic14_sameRegs(AOP(result),AOP(right)))
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ emitpcode(POC_BTFSC,popGet(AOP(right),0));
+ emitpcode(POC_BTFSS,popGet(AOP(left),0));
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+
}
/* genMultOneByte : 8 bit multiplication & division */
/*-----------------------------------------------------------------*/
static void genMultOneByte (operand *left,
- operand *right,
- operand *result)
+ operand *right,
+ operand *result)
{
- sym_link *opetype = operandType(result);
-
- // symbol *lbl ;
- int size,offset;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- DEBUGpic14_AopType(__LINE__,left,right,result);
- DEBUGpic14_AopTypeSign(__LINE__,left,right,result);
-
- /* (if two literals, the value is computed before) */
- /* if one literal, literal on the right */
- if (AOP_TYPE(left) == AOP_LIT){
- operand *t = right;
- right = left;
- left = t;
- }
-
- size = AOP_SIZE(result);
- if(size == 1) {
-
- if (AOP_TYPE(right) == AOP_LIT){
- pic14_emitcode("multiply ","lit val:%s by variable %s and store in %s",
- aopGet(AOP(right),0,FALSE,FALSE),
- aopGet(AOP(left),0,FALSE,FALSE),
- aopGet(AOP(result),0,FALSE,FALSE));
- pic14_emitcode("call","genMultLit");
- } else {
- pic14_emitcode("multiply ","variable :%s by variable %s and store in %s",
- aopGet(AOP(right),0,FALSE,FALSE),
- aopGet(AOP(left),0,FALSE,FALSE),
- aopGet(AOP(result),0,FALSE,FALSE));
- pic14_emitcode("call","genMult8X8_8");
-
- }
- genMult8X8_8 (left, right,result);
-
-
- /* signed or unsigned */
- //pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
- //l = aopGet(AOP(left),0,FALSE,FALSE);
- //MOVA(l);
- //pic14_emitcode("mul","ab");
- /* if result size = 1, mul signed = mul unsigned */
- //aopPut(AOP(result),"a",0);
-
- } else { // (size > 1)
-
- pic14_emitcode("multiply (size>1) ","variable :%s by variable %s and store in %s",
- aopGet(AOP(right),0,FALSE,FALSE),
- aopGet(AOP(left),0,FALSE,FALSE),
- aopGet(AOP(result),0,FALSE,FALSE));
-
- if (SPEC_USIGN(opetype)){
- pic14_emitcode("multiply ","unsigned result. size = %d",AOP_SIZE(result));
- genUMult8X8_16 (left, right, result, NULL);
-
- if (size > 2) {
- /* for filling the MSBs */
- emitpcode(POC_CLRF, popGet(AOP(result),2));
- emitpcode(POC_CLRF, popGet(AOP(result),3));
- }
- }
- else{
- pic14_emitcode("multiply ","signed result. size = %d",AOP_SIZE(result));
-
- pic14_emitcode("mov","a,b");
-
- /* adjust the MSB if left or right neg */
-
- /* if one literal */
- if (AOP_TYPE(right) == AOP_LIT){
- pic14_emitcode("multiply ","right is a lit");
- /* AND literal negative */
- if((int) floatFromVal (AOP(right)->aopu.aop_lit) < 0){
- /* adjust MSB (c==0 after mul) */
- pic14_emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE));
- }
- }
- else{
- genSMult8X8_16 (left, right, result, NULL);
- }
-
- if(size > 2){
- pic14_emitcode("multiply ","size is greater than 2, so propogate sign");
- /* get the sign */
- pic14_emitcode("rlc","a");
- pic14_emitcode("subb","a,acc");
- }
- }
-
- size -= 2;
- offset = 2;
- if (size > 0)
- while (size--)
- pic14_emitcode("multiply ","size is way greater than 2, so propogate sign");
- //aopPut(AOP(result),"a",offset++);
- }
+ sym_link *opetype = operandType(result);
+
+ // symbol *lbl ;
+ int size,offset;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+ DEBUGpic14_AopTypeSign(__LINE__,left,right,result);
+
+ /* (if two literals, the value is computed before) */
+ /* if one literal, literal on the right */
+ if (AOP_TYPE(left) == AOP_LIT){
+ operand *t = right;
+ right = left;
+ left = t;
+ }
+
+ size = AOP_SIZE(result);
+ if(size == 1) {
+
+ if (AOP_TYPE(right) == AOP_LIT){
+ pic14_emitcode("multiply ","lit val:%s by variable %s and store in %s",
+ aopGet(AOP(right),0,FALSE,FALSE),
+ aopGet(AOP(left),0,FALSE,FALSE),
+ aopGet(AOP(result),0,FALSE,FALSE));
+ pic14_emitcode("call","genMultLit");
+ } else {
+ pic14_emitcode("multiply ","variable :%s by variable %s and store in %s",
+ aopGet(AOP(right),0,FALSE,FALSE),
+ aopGet(AOP(left),0,FALSE,FALSE),
+ aopGet(AOP(result),0,FALSE,FALSE));
+ pic14_emitcode("call","genMult8X8_8");
+
+ }
+ genMult8X8_8 (left, right,result);
+
+
+ /* signed or unsigned */
+ //pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
+ //l = aopGet(AOP(left),0,FALSE,FALSE);
+ //MOVA(l);
+ //pic14_emitcode("mul","ab");
+ /* if result size = 1, mul signed = mul unsigned */
+ //aopPut(AOP(result),"a",0);
+
+ } else { // (size > 1)
+
+ pic14_emitcode("multiply (size>1) ","variable :%s by variable %s and store in %s",
+ aopGet(AOP(right),0,FALSE,FALSE),
+ aopGet(AOP(left),0,FALSE,FALSE),
+ aopGet(AOP(result),0,FALSE,FALSE));
+
+ if (SPEC_USIGN(opetype)){
+ pic14_emitcode("multiply ","unsigned result. size = %d",AOP_SIZE(result));
+ genUMult8X8_16 (left, right, result, NULL);
+
+ if (size > 2) {
+ /* for filling the MSBs */
+ emitpcode(POC_CLRF, popGet(AOP(result),2));
+ emitpcode(POC_CLRF, popGet(AOP(result),3));
+ }
+ }
+ else{
+ pic14_emitcode("multiply ","signed result. size = %d",AOP_SIZE(result));
+
+ pic14_emitcode("mov","a,b");
+
+ /* adjust the MSB if left or right neg */
+
+ /* if one literal */
+ if (AOP_TYPE(right) == AOP_LIT){
+ pic14_emitcode("multiply ","right is a lit");
+ /* AND literal negative */
+ if((int) floatFromVal (AOP(right)->aopu.aop_lit) < 0){
+ /* adjust MSB (c==0 after mul) */
+ pic14_emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE));
+ }
+ }
+ else{
+ genSMult8X8_16 (left, right, result, NULL);
+ }
+
+ if(size > 2){
+ pic14_emitcode("multiply ","size is greater than 2, so propogate sign");
+ /* get the sign */
+ pic14_emitcode("rlc","a");
+ pic14_emitcode("subb","a,acc");
+ }
+ }
+
+ size -= 2;
+ offset = 2;
+ if (size > 0)
+ while (size--)
+ pic14_emitcode("multiply ","size is way greater than 2, so propogate sign");
+ //aopPut(AOP(result),"a",offset++);
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genMult (iCode *ic)
{
- operand *left = IC_LEFT(ic);
- operand *right = IC_RIGHT(ic);
- operand *result= IC_RESULT(ic);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* assign the amsops */
- aopOp (left,ic,FALSE);
- aopOp (right,ic,FALSE);
- aopOp (result,ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- /* special cases first */
- /* both are bits */
- if (AOP_TYPE(left) == AOP_CRY &&
- AOP_TYPE(right)== AOP_CRY) {
- genMultbits(left,right,result);
- goto release ;
- }
-
- /* if both are of size == 1 */
- if (AOP_SIZE(left) == 1 &&
- AOP_SIZE(right) == 1 ) {
- genMultOneByte(left,right,result);
- goto release ;
- }
-
- pic14_emitcode("multiply ","sizes are greater than 2... need to insert proper algor.");
-
- /* should have been converted to function call */
- //assert(0) ;
-
+ operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ operand *result= IC_RESULT(ic);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ /* special cases first */
+ /* both are bits */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right)== AOP_CRY) {
+ genMultbits(left,right,result);
+ goto release ;
+ }
+
+ /* if both are of size == 1 */
+ if (AOP_SIZE(left) == 1 &&
+ AOP_SIZE(right) == 1 ) {
+ genMultOneByte(left,right,result);
+ goto release ;
+ }
+
+ pic14_emitcode("multiply ","sizes are greater than 2... need to insert proper algor.");
+
+ /* should have been converted to function call */
+ //assert(0) ;
+
release :
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* genDivbits :- division of bits */
/*-----------------------------------------------------------------*/
static void genDivbits (operand *left,
- operand *right,
- operand *result)
+ operand *right,
+ operand *result)
{
-
- char *l;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* the result must be bit */
- pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
- l = aopGet(AOP(left),0,FALSE,FALSE);
-
- MOVA(l);
-
- pic14_emitcode("div","ab");
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"c",0);
+
+ char *l;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* the result must be bit */
+ pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+
+ MOVA(l);
+
+ pic14_emitcode("div","ab");
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"c",0);
}
/*-----------------------------------------------------------------*/
/* genDivOneByte : 8 bit division */
/*-----------------------------------------------------------------*/
static void genDivOneByte (operand *left,
- operand *right,
- operand *result)
-{
- sym_link *opetype = operandType(result);
- char *l ;
- symbol *lbl ;
- int size,offset;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- size = AOP_SIZE(result) - 1;
- offset = 1;
- /* signed or unsigned */
- if (SPEC_USIGN(opetype)) {
- /* unsigned is easy */
- pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("div","ab");
- aopPut(AOP(result),"a",0);
- while (size--)
- aopPut(AOP(result),zero,offset++);
- return ;
- }
-
- /* signed is a little bit more difficult */
-
- /* save the signs of the operands */
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("xrl","a,%s",aopGet(AOP(right),0,FALSE,TRUE));
- pic14_emitcode("push","acc"); /* save it on the stack */
-
- /* now sign adjust for both left & right */
- l = aopGet(AOP(right),0,FALSE,FALSE);
- MOVA(l);
- lbl = newiTempLabel(NULL);
- pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
- pic14_emitcode("cpl","a");
- pic14_emitcode("inc","a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
- pic14_emitcode("mov","b,a");
-
- /* sign adjust left side */
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
-
- lbl = newiTempLabel(NULL);
- pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
- pic14_emitcode("cpl","a");
- pic14_emitcode("inc","a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-
- /* now the division */
- pic14_emitcode("div","ab");
- /* we are interested in the lower order
- only */
- pic14_emitcode("mov","b,a");
- lbl = newiTempLabel(NULL);
- pic14_emitcode("pop","acc");
- /* if there was an over flow we don't
- adjust the sign of the result */
- pic14_emitcode("jb","ov,%05d_DS_",(lbl->key+100));
- pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
- CLRC;
- pic14_emitcode("clr","a");
- pic14_emitcode("subb","a,b");
- pic14_emitcode("mov","b,a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-
- /* now we are done */
- aopPut(AOP(result),"b",0);
- if(size > 0){
- pic14_emitcode("mov","c,b.7");
- pic14_emitcode("subb","a,acc");
- }
- while (size--)
- aopPut(AOP(result),"a",offset++);
-
+ operand *right,
+ operand *result)
+{
+ sym_link *opetype = operandType(result);
+ char *l ;
+ symbol *lbl ;
+ int size,offset;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ size = AOP_SIZE(result) - 1;
+ offset = 1;
+ /* signed or unsigned */
+ if (SPEC_USIGN(opetype)) {
+ /* unsigned is easy */
+ pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("div","ab");
+ aopPut(AOP(result),"a",0);
+ while (size--)
+ aopPut(AOP(result),zero,offset++);
+ return ;
+ }
+
+ /* signed is a little bit more difficult */
+
+ /* save the signs of the operands */
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(right),0,FALSE,TRUE));
+ pic14_emitcode("push","acc"); /* save it on the stack */
+
+ /* now sign adjust for both left & right */
+ l = aopGet(AOP(right),0,FALSE,FALSE);
+ MOVA(l);
+ lbl = newiTempLabel(NULL);
+ pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
+ pic14_emitcode("cpl","a");
+ pic14_emitcode("inc","a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+ pic14_emitcode("mov","b,a");
+
+ /* sign adjust left side */
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+
+ lbl = newiTempLabel(NULL);
+ pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
+ pic14_emitcode("cpl","a");
+ pic14_emitcode("inc","a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+
+ /* now the division */
+ pic14_emitcode("div","ab");
+ /* we are interested in the lower order
+ only */
+ pic14_emitcode("mov","b,a");
+ lbl = newiTempLabel(NULL);
+ pic14_emitcode("pop","acc");
+ /* if there was an over flow we don't
+ adjust the sign of the result */
+ pic14_emitcode("jb","ov,%05d_DS_",(lbl->key+100));
+ pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
+ CLRC;
+ pic14_emitcode("clr","a");
+ pic14_emitcode("subb","a,b");
+ pic14_emitcode("mov","b,a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+
+ /* now we are done */
+ aopPut(AOP(result),"b",0);
+ if(size > 0){
+ pic14_emitcode("mov","c,b.7");
+ pic14_emitcode("subb","a,acc");
+ }
+ while (size--)
+ aopPut(AOP(result),"a",offset++);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genDiv (iCode *ic)
{
- operand *left = IC_LEFT(ic);
- operand *right = IC_RIGHT(ic);
- operand *result= IC_RESULT(ic);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* assign the amsops */
- aopOp (left,ic,FALSE);
- aopOp (right,ic,FALSE);
- aopOp (result,ic,TRUE);
-
- /* special cases first */
- /* both are bits */
- if (AOP_TYPE(left) == AOP_CRY &&
- AOP_TYPE(right)== AOP_CRY) {
- genDivbits(left,right,result);
- goto release ;
- }
-
- /* if both are of size == 1 */
- if (AOP_SIZE(left) == 1 &&
- AOP_SIZE(right) == 1 ) {
- genDivOneByte(left,right,result);
- goto release ;
- }
-
- /* should have been converted to function call */
- assert(0);
+ operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ operand *result= IC_RESULT(ic);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ /* special cases first */
+ /* both are bits */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right)== AOP_CRY) {
+ genDivbits(left,right,result);
+ goto release ;
+ }
+
+ /* if both are of size == 1 */
+ if (AOP_SIZE(left) == 1 &&
+ AOP_SIZE(right) == 1 ) {
+ genDivOneByte(left,right,result);
+ goto release ;
+ }
+
+ /* should have been converted to function call */
+ assert(0);
release :
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* genModbits :- modulus of bits */
/*-----------------------------------------------------------------*/
static void genModbits (operand *left,
- operand *right,
- operand *result)
+ operand *right,
+ operand *result)
{
-
- char *l;
-
- /* the result must be bit */
- pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
- l = aopGet(AOP(left),0,FALSE,FALSE);
-
- MOVA(l);
-
- pic14_emitcode("div","ab");
- pic14_emitcode("mov","a,b");
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"c",0);
+
+ char *l;
+
+ /* the result must be bit */
+ pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+
+ MOVA(l);
+
+ pic14_emitcode("div","ab");
+ pic14_emitcode("mov","a,b");
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"c",0);
}
/*-----------------------------------------------------------------*/
/* genModOneByte : 8 bit modulus */
/*-----------------------------------------------------------------*/
static void genModOneByte (operand *left,
- operand *right,
- operand *result)
-{
- sym_link *opetype = operandType(result);
- char *l ;
- symbol *lbl ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* signed or unsigned */
- if (SPEC_USIGN(opetype)) {
- /* unsigned is easy */
- pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("div","ab");
- aopPut(AOP(result),"b",0);
- return ;
- }
-
- /* signed is a little bit more difficult */
-
- /* save the signs of the operands */
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
-
- pic14_emitcode("xrl","a,%s",aopGet(AOP(right),0,FALSE,FALSE));
- pic14_emitcode("push","acc"); /* save it on the stack */
-
- /* now sign adjust for both left & right */
- l = aopGet(AOP(right),0,FALSE,FALSE);
- MOVA(l);
-
- lbl = newiTempLabel(NULL);
- pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
- pic14_emitcode("cpl","a");
- pic14_emitcode("inc","a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
- pic14_emitcode("mov","b,a");
-
- /* sign adjust left side */
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
-
- lbl = newiTempLabel(NULL);
- pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
- pic14_emitcode("cpl","a");
- pic14_emitcode("inc","a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-
- /* now the multiplication */
- pic14_emitcode("div","ab");
- /* we are interested in the lower order
- only */
- lbl = newiTempLabel(NULL);
- pic14_emitcode("pop","acc");
- /* if there was an over flow we don't
- adjust the sign of the result */
- pic14_emitcode("jb","ov,%05d_DS_",(lbl->key+100));
- pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
- CLRC ;
- pic14_emitcode("clr","a");
- pic14_emitcode("subb","a,b");
- pic14_emitcode("mov","b,a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-
- /* now we are done */
- aopPut(AOP(result),"b",0);
-
+ operand *right,
+ operand *result)
+{
+ sym_link *opetype = operandType(result);
+ char *l ;
+ symbol *lbl ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* signed or unsigned */
+ if (SPEC_USIGN(opetype)) {
+ /* unsigned is easy */
+ pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("div","ab");
+ aopPut(AOP(result),"b",0);
+ return ;
+ }
+
+ /* signed is a little bit more difficult */
+
+ /* save the signs of the operands */
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ pic14_emitcode("push","acc"); /* save it on the stack */
+
+ /* now sign adjust for both left & right */
+ l = aopGet(AOP(right),0,FALSE,FALSE);
+ MOVA(l);
+
+ lbl = newiTempLabel(NULL);
+ pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
+ pic14_emitcode("cpl","a");
+ pic14_emitcode("inc","a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+ pic14_emitcode("mov","b,a");
+
+ /* sign adjust left side */
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+
+ lbl = newiTempLabel(NULL);
+ pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
+ pic14_emitcode("cpl","a");
+ pic14_emitcode("inc","a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+
+ /* now the multiplication */
+ pic14_emitcode("div","ab");
+ /* we are interested in the lower order
+ only */
+ lbl = newiTempLabel(NULL);
+ pic14_emitcode("pop","acc");
+ /* if there was an over flow we don't
+ adjust the sign of the result */
+ pic14_emitcode("jb","ov,%05d_DS_",(lbl->key+100));
+ pic14_emitcode("jnb","acc.7,%05d_DS_",(lbl->key+100));
+ CLRC ;
+ pic14_emitcode("clr","a");
+ pic14_emitcode("subb","a,b");
+ pic14_emitcode("mov","b,a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+
+ /* now we are done */
+ aopPut(AOP(result),"b",0);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genMod (iCode *ic)
{
- operand *left = IC_LEFT(ic);
- operand *right = IC_RIGHT(ic);
- operand *result= IC_RESULT(ic);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* assign the amsops */
- aopOp (left,ic,FALSE);
- aopOp (right,ic,FALSE);
- aopOp (result,ic,TRUE);
-
- /* special cases first */
- /* both are bits */
- if (AOP_TYPE(left) == AOP_CRY &&
- AOP_TYPE(right)== AOP_CRY) {
- genModbits(left,right,result);
- goto release ;
- }
-
- /* if both are of size == 1 */
- if (AOP_SIZE(left) == 1 &&
- AOP_SIZE(right) == 1 ) {
- genModOneByte(left,right,result);
- goto release ;
- }
-
- /* should have been converted to function call */
- assert(0);
-
+ operand *left = IC_LEFT(ic);
+ operand *right = IC_RIGHT(ic);
+ operand *result= IC_RESULT(ic);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ /* special cases first */
+ /* both are bits */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right)== AOP_CRY) {
+ genModbits(left,right,result);
+ goto release ;
+ }
+
+ /* if both are of size == 1 */
+ if (AOP_SIZE(left) == 1 &&
+ AOP_SIZE(right) == 1 ) {
+ genModOneByte(left,right,result);
+ goto release ;
+ }
+
+ /* should have been converted to function call */
+ assert(0);
+
release :
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* genIfxJump :- will create a jump depending on the ifx */
/*-----------------------------------------------------------------*/
/*
- note: May need to add parameter to indicate when a variable is in bit space.
+note: May need to add parameter to indicate when a variable is in bit space.
*/
static void genIfxJump (iCode *ic, char *jval)
{
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if true label then we jump if condition
- supplied is true */
- if ( IC_TRUE(ic) ) {
-
- if(strcmp(jval,"a") == 0)
- emitSKPZ;
- else if (strcmp(jval,"c") == 0)
- emitSKPC;
- else {
- DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
- emitpcode(POC_BTFSC, newpCodeOpBit(jval,-1,1));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if true label then we jump if condition
+ supplied is true */
+ if ( IC_TRUE(ic) ) {
+
+ if(strcmp(jval,"a") == 0)
+ emitSKPZ;
+ else if (strcmp(jval,"c") == 0)
+ emitSKPC;
+ else {
+ DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
+ emitpcode(POC_BTFSC, newpCodeOpBit(jval,-1,1));
+ }
+
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ic)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + labelOffset);
+
}
-
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ic)->key));
- pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + labelOffset);
-
- }
- else {
- /* false label is present */
- if(strcmp(jval,"a") == 0)
- emitSKPNZ;
- else if (strcmp(jval,"c") == 0)
- emitSKPNC;
else {
- DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
- emitpcode(POC_BTFSS, newpCodeOpBit(jval,-1,1));
+ /* false label is present */
+ if(strcmp(jval,"a") == 0)
+ emitSKPNZ;
+ else if (strcmp(jval,"c") == 0)
+ emitSKPNC;
+ else {
+ DEBUGpic14_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
+ emitpcode(POC_BTFSS, newpCodeOpBit(jval,-1,1));
+ }
+
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ic)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + labelOffset);
+
}
-
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ic)->key));
- pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + labelOffset);
-
- }
-
-
- /* mark the icode as generated */
- ic->generated = 1;
+
+
+ /* mark the icode as generated */
+ ic->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genSkip(iCode *ifx,int status_bit)
{
- if(!ifx)
- return;
-
- if ( IC_TRUE(ifx) ) {
- switch(status_bit) {
- case 'z':
- emitSKPNZ;
- break;
-
- case 'c':
- emitSKPNC;
- break;
-
- case 'd':
- emitSKPDC;
- break;
-
- }
-
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
- pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
-
- } else {
-
- switch(status_bit) {
-
- case 'z':
- emitSKPZ;
- break;
-
- case 'c':
- emitSKPC;
- break;
-
- case 'd':
- emitSKPDC;
- break;
- }
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
- pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
-
- }
-
+ if(!ifx)
+ return;
+
+ if ( IC_TRUE(ifx) ) {
+ switch(status_bit) {
+ case 'z':
+ emitSKPNZ;
+ break;
+
+ case 'c':
+ emitSKPNC;
+ break;
+
+ case 'd':
+ emitSKPDC;
+ break;
+
+ }
+
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+
+ } else {
+
+ switch(status_bit) {
+
+ case 'z':
+ emitSKPZ;
+ break;
+
+ case 'c':
+ emitSKPC;
+ break;
+
+ case 'd':
+ emitSKPDC;
+ break;
+ }
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genSkipc(resolvedIfx *rifx)
{
- if(!rifx)
- return;
-
- if(rifx->condition)
- emitSKPC;
- else
- emitSKPNC;
-
- emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
- rifx->generated = 1;
+ if(!rifx)
+ return;
+
+ if(rifx->condition)
+ emitSKPC;
+ else
+ emitSKPNC;
+
+ emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
+ rifx->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genSkipz2(resolvedIfx *rifx, int invert_condition)
{
- if(!rifx)
- return;
-
- if( (rifx->condition ^ invert_condition) & 1)
- emitSKPZ;
- else
- emitSKPNZ;
-
- emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
- rifx->generated = 1;
+ if(!rifx)
+ return;
+
+ if( (rifx->condition ^ invert_condition) & 1)
+ emitSKPZ;
+ else
+ emitSKPNZ;
+
+ emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
+ rifx->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genSkipz(iCode *ifx, int condition)
{
- if(!ifx)
- return;
-
- if(condition)
- emitSKPNZ;
- else
- emitSKPZ;
-
- if ( IC_TRUE(ifx) )
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
- else
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
-
- if ( IC_TRUE(ifx) )
- pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
- else
- pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
-
+ if(!ifx)
+ return;
+
+ if(condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+
+ if ( IC_TRUE(ifx) )
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ else
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+
+ if ( IC_TRUE(ifx) )
+ pic14_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ else
+ pic14_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+
}
/*-----------------------------------------------------------------*/
/* genSkipCond */
/*-----------------------------------------------------------------*/
static void genSkipCond(resolvedIfx *rifx,operand *op, int offset, int bit)
{
- if(!rifx)
- return;
-
- if(rifx->condition)
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
- else
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
-
-
- emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
- rifx->generated = 1;
+ if(!rifx)
+ return;
+
+ if(rifx->condition)
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
+ else
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
+
+
+ emitpcode(POC_GOTO,popGetLabel(rifx->lbl->key));
+ rifx->generated = 1;
}
#if 0
/*-----------------------------------------------------------------*/
static int genChkZeroes(operand *op, int lit, int size)
{
-
- int i;
- int flag =1;
-
- while(size--) {
- i = (lit >> (size*8)) & 0xff;
-
- if(i==0) {
- if(flag)
- emitpcode(POC_MOVFW, popGet(AOP(op),size));
- else
- emitpcode(POC_IORFW, popGet(AOP(op),size));
- flag = 0;
- }
- }
-
- return (flag==0);
+
+ int i;
+ int flag =1;
+
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
+
+ if(i==0) {
+ if(flag)
+ emitpcode(POC_MOVFW, popGet(AOP(op),size));
+ else
+ emitpcode(POC_IORFW, popGet(AOP(op),size));
+ flag = 0;
+ }
+ }
+
+ return (flag==0);
}
#endif
/* genCmp :- greater or less than comparison */
/*-----------------------------------------------------------------*/
static void genCmp (operand *left,operand *right,
- operand *result, iCode *ifx, int sign)
-{
- int size; //, offset = 0 ;
- unsigned long lit = 0L,i = 0;
- resolvedIfx rFalseIfx;
- // resolvedIfx rTrueIfx;
- symbol *truelbl;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-/*
- if(ifx) {
- DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
- DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
- }
-*/
-
- resolveIfx(&rFalseIfx,ifx);
- truelbl = newiTempLabel(NULL);
- size = max(AOP_SIZE(left),AOP_SIZE(right));
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
+ operand *result, iCode *ifx, int sign)
+{
+ int size; //, offset = 0 ;
+ unsigned long lit = 0L,i = 0;
+ resolvedIfx rFalseIfx;
+ // resolvedIfx rTrueIfx;
+ symbol *truelbl;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /*
+ if(ifx) {
+ DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
+ DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
+ }
+ */
+
+ resolveIfx(&rFalseIfx,ifx);
+ truelbl = newiTempLabel(NULL);
+ size = max(AOP_SIZE(left),AOP_SIZE(right));
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
#define _swapp
-
- /* if literal is on the right then swap with left */
- if ((AOP_TYPE(right) == AOP_LIT)) {
- operand *tmp = right ;
- unsigned long mask = (0x100 << (8*(size-1))) - 1;
- lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ /* if literal is on the right then swap with left */
+ if ((AOP_TYPE(right) == AOP_LIT)) {
+ operand *tmp = right ;
+ unsigned long mask = (0x100 << (8*(size-1))) - 1;
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
#ifdef _swapp
-
- lit = (lit - 1) & mask;
- right = left;
- left = tmp;
- rFalseIfx.condition ^= 1;
+
+ lit = (lit - 1) & mask;
+ right = left;
+ left = tmp;
+ rFalseIfx.condition ^= 1;
#endif
-
- } else if ((AOP_TYPE(left) == AOP_LIT)) {
- lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
- }
-
-
- //if(IC_TRUE(ifx) == NULL)
- /* if left & right are bit variables */
- if (AOP_TYPE(left) == AOP_CRY &&
- AOP_TYPE(right) == AOP_CRY ) {
- pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
- pic14_emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
- } else {
- /* subtract right from left if at the
- end the carry flag is set then we know that
- left is greater than right */
-
- // {
-
- symbol *lbl = newiTempLabel(NULL);
-
-#ifndef _swapp
- if(AOP_TYPE(right) == AOP_LIT) {
-
- //lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
-
- DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
-
- /* special cases */
-
- if(lit == 0) {
-
- if(sign != 0)
- genSkipCond(&rFalseIfx,left,size-1,7);
- else
- /* no need to compare to 0...*/
- /* NOTE: this is a de-generate compare that most certainly
- * creates some dead code. */
- emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
-
- if(ifx) ifx->generated = 1;
- return;
-
- }
- size--;
-
- if(size == 0) {
- //i = (lit >> (size*8)) & 0xff;
- DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+
+ } else if ((AOP_TYPE(left) == AOP_LIT)) {
+ lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
+ }
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
-
- i = ((0-lit) & 0xff);
- if(sign) {
- if( i == 0x81) {
- /* lit is 0x7f, all signed chars are less than
- * this except for 0x7f itself */
- emitpcode(POC_XORLW, popGetLit(0x7f));
- genSkipz2(&rFalseIfx,0);
- } else {
- emitpcode(POC_ADDLW, popGetLit(0x80));
- emitpcode(POC_ADDLW, popGetLit(i^0x80));
- genSkipc(&rFalseIfx);
- }
-
+
+ //if(IC_TRUE(ifx) == NULL)
+ /* if left & right are bit variables */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right) == AOP_CRY ) {
+ pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+ pic14_emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
} else {
- if(lit == 1) {
- genSkipz2(&rFalseIfx,1);
- } else {
- emitpcode(POC_ADDLW, popGetLit(i));
- genSkipc(&rFalseIfx);
+ /* subtract right from left if at the
+ end the carry flag is set then we know that
+ left is greater than right */
+
+ // {
+
+ symbol *lbl = newiTempLabel(NULL);
+
+#ifndef _swapp
+ if(AOP_TYPE(right) == AOP_LIT) {
+
+ //lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
+
+ /* special cases */
+
+ if(lit == 0) {
+
+ if(sign != 0)
+ genSkipCond(&rFalseIfx,left,size-1,7);
+ else
+ /* no need to compare to 0...*/
+ /* NOTE: this is a de-generate compare that most certainly
+ * creates some dead code. */
+ emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+ size--;
+
+ if(size == 0) {
+ //i = (lit >> (size*8)) & 0xff;
+ DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+
+ i = ((0-lit) & 0xff);
+ if(sign) {
+ if( i == 0x81) {
+ /* lit is 0x7f, all signed chars are less than
+ * this except for 0x7f itself */
+ emitpcode(POC_XORLW, popGetLit(0x7f));
+ genSkipz2(&rFalseIfx,0);
+ } else {
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+ emitpcode(POC_ADDLW, popGetLit(i^0x80));
+ genSkipc(&rFalseIfx);
+ }
+
+ } else {
+ if(lit == 1) {
+ genSkipz2(&rFalseIfx,1);
+ } else {
+ emitpcode(POC_ADDLW, popGetLit(i));
+ genSkipc(&rFalseIfx);
+ }
+ }
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ /* chars are out of the way. now do ints and longs */
+
+
+ DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+
+ /* special cases */
+
+ if(sign) {
+
+ if(lit == 0) {
+ genSkipCond(&rFalseIfx,left,size,7);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(lit <0x100) {
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,left,size,7);
+ //rFalseIfx.condition ^= 1;
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ emitpcode(POC_MOVLW, popGetLit(0x100-lit));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),1));
+
+ while(size > 1)
+ emitpcode(POC_IORFW, popGet(AOP(left),size--));
+
+ if(rFalseIfx.condition) {
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ } else {
+ emitSKPNZ;
+ }
+
+ genSkipc(&rFalseIfx);
+ emitpLabel(truelbl->key);
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+
+ if(size == 1) {
+
+ if( (lit & 0xff) == 0) {
+ /* lower byte is zero */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ i = ((lit >> 8) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ genSkipc(&rFalseIfx);
+
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+ } else {
+ /* Special cases for signed longs */
+ if( (lit & 0xffffff) == 0) {
+ /* lower byte is zero */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ i = ((lit >> 8*3) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ genSkipc(&rFalseIfx);
+
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+ }
+
+ }
+
+
+ if(lit & (0x80 << (size*8))) {
+ /* lit is negative */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+
+ //genSkipCond(&rFalseIfx,left,size,7);
+
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+
+
+ } else {
+ /* lit is positive */
+ DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ }
+
+ /* There are no more special cases, so perform a general compare */
+
+ emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+
+ while(size--) {
+
+ emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ }
+ //rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+
+ emitpLabel(truelbl->key);
+
+ if(ifx) ifx->generated = 1;
+ return;
+
+
}
- }
-
- if(ifx) ifx->generated = 1;
- return;
- }
-
- /* chars are out of the way. now do ints and longs */
-
-
- DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
-
- /* special cases */
-
- if(sign) {
-
- if(lit == 0) {
- genSkipCond(&rFalseIfx,left,size,7);
- if(ifx) ifx->generated = 1;
- return;
- }
-
- if(lit <0x100) {
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
-
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,left,size,7);
- //rFalseIfx.condition ^= 1;
-
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
- emitpcode(POC_MOVLW, popGetLit(0x100-lit));
- emitpcode(POC_ADDFW, popGet(AOP(left),0));
- emitpcode(POC_MOVFW, popGet(AOP(left),1));
-
- while(size > 1)
- emitpcode(POC_IORFW, popGet(AOP(left),size--));
-
- if(rFalseIfx.condition) {
- emitSKPZ;
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
- } else {
- emitSKPNZ;
+
+
+ /* sign is out of the way. So now do an unsigned compare */
+ DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
+
+
+ /* General case - compare to an unsigned literal on the right.*/
+
+ i = (lit >> (size*8)) & 0xff;
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
+
+ if(i) {
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+ } else {
+ /* this byte of the lit is zero,
+ *if it's not the last then OR in the variable */
+ if(size)
+ emitpcode(POC_IORFW, popGet(AOP(left),size));
+ }
}
-
+
+
+ emitpLabel(lbl->key);
+ //if(emitFinalCheck)
genSkipc(&rFalseIfx);
- emitpLabel(truelbl->key);
+ if(sign)
+ emitpLabel(truelbl->key);
+
if(ifx) ifx->generated = 1;
return;
-
- }
-
- if(size == 1) {
-
- if( (lit & 0xff) == 0) {
- /* lower byte is zero */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- i = ((lit >> 8) & 0xff) ^0x80;
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
- emitpcode(POC_ADDLW, popGetLit( 0x80));
- emitpcode(POC_ADDLW, popGetLit(0x100-i));
- genSkipc(&rFalseIfx);
-
-
- if(ifx) ifx->generated = 1;
- return;
-
- }
- } else {
- /* Special cases for signed longs */
- if( (lit & 0xffffff) == 0) {
- /* lower byte is zero */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- i = ((lit >> 8*3) & 0xff) ^0x80;
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
- emitpcode(POC_ADDLW, popGetLit( 0x80));
- emitpcode(POC_ADDLW, popGetLit(0x100-i));
- genSkipc(&rFalseIfx);
-
-
- if(ifx) ifx->generated = 1;
- return;
-
- }
-
+
+
}
-
-
- if(lit & (0x80 << (size*8))) {
- /* lit is negative */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
-
- //genSkipCond(&rFalseIfx,left,size,7);
-
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
-
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
-
-
+#endif // _swapp
+
+ if(AOP_TYPE(left) == AOP_LIT) {
+ //symbol *lbl = newiTempLabel(NULL);
+
+ //EXPERIMENTAL lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
+
+
+ DEBUGpic14_emitcode(";left lit","lit = 0x%x,sign=%d",lit,sign);
+
+ /* Special cases */
+ if((lit == 0) && (sign == 0)){
+
+ size--;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size)
+ emitpcode(POC_IORFW, popGet(AOP(right),--size));
+
+ genSkipz2(&rFalseIfx,0);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(size==1) {
+ /* Special cases */
+ lit &= 0xff;
+ if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
+ /* degenerate compare can never be true */
+ if(rFalseIfx.condition == 0)
+ emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(sign) {
+ /* signed comparisons to a literal byte */
+
+ int lp1 = (lit+1) & 0xff;
+
+ DEBUGpic14_emitcode(";left lit","line = %d lit = 0x%x",__LINE__,lit);
+ switch (lp1) {
+ case 0:
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,0,7);
+ break;
+ case 0x7f:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_XORLW, popGetLit(0x7f));
+ genSkipz2(&rFalseIfx,1);
+ break;
+ default:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+ emitpcode(POC_ADDLW, popGetLit(((-(lit+1)) & 0xff) ^ 0x80));
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+ break;
+ }
+ if(ifx) ifx->generated = 1;
+ } else {
+ /* unsigned comparisons to a literal byte */
+
+ switch(lit & 0xff ) {
+ case 0:
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ genSkipz2(&rFalseIfx,0);
+ if(ifx) ifx->generated = 1;
+ break;
+ case 0x7f:
+ genSkipCond(&rFalseIfx,right,0,7);
+ if(ifx) ifx->generated = 1;
+ break;
+
+ default:
+ emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ rFalseIfx.condition ^= 1;
+ if (AOP_TYPE(result) == AOP_CRY) {
+ genSkipc(&rFalseIfx);
+ if(ifx) ifx->generated = 1;
+ } else {
+ DEBUGpic14_emitcode ("; ***","%s %d RFIfx.cond=%d",__FUNCTION__,__LINE__, rFalseIfx.condition);
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW, popGetLit(0x01));
+ emitpcode(POC_XORWF, popGet(AOP(result),0));
+ }
+ break;
+ }
+ }
+
+ //goto check_carry;
+ return;
+
+ } else {
+
+ /* Size is greater than 1 */
+
+ if(sign) {
+ int lp1 = lit+1;
+
+ size--;
+
+ if(lp1 == 0) {
+ /* this means lit = 0xffffffff, or -1 */
+
+
+ DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,size,7);
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(lit == 0) {
+ int s = size;
+
+ if(rFalseIfx.condition) {
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ }
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size--)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+
+
+ emitSKPZ;
+ if(rFalseIfx.condition) {
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ emitpLabel(truelbl->key);
+ }else {
+ rFalseIfx.condition ^= 1;
+ genSkipCond(&rFalseIfx,right,s,7);
+ }
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if((size == 1) && (0 == (lp1&0xff))) {
+ /* lower byte of signed word is zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x+1 low byte is zero",__LINE__,lit);
+ i = ((lp1 >> 8) & 0xff) ^0x80;
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_ADDLW, popGetLit( 0x80));
+ emitpcode(POC_ADDLW, popGetLit(0x100-i));
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+ if(lit & (0x80 << (size*8))) {
+ /* Lit is less than zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x is less than 0",__LINE__,lit);
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,left,size,7);
+ //rFalseIfx.condition ^= 1;
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ //emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+
+ } else {
+ /* Lit is greater than or equal to zero */
+ DEBUGpic14_emitcode(";left lit","line = %d 0x%x is greater than 0",__LINE__,lit);
+ //rFalseIfx.condition ^= 1;
+ //genSkipCond(&rFalseIfx,right,size,7);
+ //rFalseIfx.condition ^= 1;
+
+ //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ //emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+
+ }
+
+
+ emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+ while(size--) {
+
+ emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ }
+ rFalseIfx.condition ^= 1;
+ //rFalseIfx.condition = 1;
+ genSkipc(&rFalseIfx);
+
+ emitpLabel(truelbl->key);
+
+ if(ifx) ifx->generated = 1;
+ return;
+ // end of if (sign)
} else {
- /* lit is positive */
- DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
- }
-
- /* There are no more special cases, so perform a general compare */
-
- emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
-
- while(size--) {
-
- emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
+
+ /* compare word or long to an unsigned literal on the right.*/
+
+
+ size--;
+ if(lit < 0xff) {
+ DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x < 0xff",__FUNCTION__,__LINE__,lit);
+ switch (lit) {
+ case 0:
+ break; /* handled above */
+ /*
+ case 0xff:
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(size--)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+ genSkipz2(&rFalseIfx,0);
+ break;
+ */
+ default:
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ while(--size)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+
+ emitSKPZ;
+ if(rFalseIfx.condition)
+ emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
+ else
+ emitpcode(POC_GOTO, popGetLabel(truelbl->key));
+
+
+ emitpcode(POC_MOVLW, popGetLit(lit+1));
+ emitpcode(POC_SUBFW, popGet(AOP(right),0));
+
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
+ }
+
+ emitpLabel(truelbl->key);
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
+
+ lit++;
+ DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x",__FUNCTION__,__LINE__,lit);
+ i = (lit >> (size*8)) & 0xff;
+
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+ while(size--) {
+ i = (lit >> (size*8)) & 0xff;
+
+ if(i) {
+ emitpcode(POC_MOVLW, popGetLit(i));
+ emitSKPNZ;
+ emitpcode(POC_SUBFW, popGet(AOP(right),size));
+ } else {
+ /* this byte of the lit is zero,
+ *if it's not the last then OR in the variable */
+ if(size)
+ emitpcode(POC_IORFW, popGet(AOP(right),size));
+ }
+ }
+
+
+ emitpLabel(lbl->key);
+
+ rFalseIfx.condition ^= 1;
+ genSkipc(&rFalseIfx);
}
- //rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
-
- emitpLabel(truelbl->key);
-
+
+ if(sign)
+ emitpLabel(truelbl->key);
if(ifx) ifx->generated = 1;
return;
-
-
- }
-
-
- /* sign is out of the way. So now do an unsigned compare */
- DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
-
-
- /* General case - compare to an unsigned literal on the right.*/
-
- i = (lit >> (size*8)) & 0xff;
- emitpcode(POC_MOVLW, popGetLit(i));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- while(size--) {
- i = (lit >> (size*8)) & 0xff;
-
- if(i) {
- emitpcode(POC_MOVLW, popGetLit(i));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- } else {
- /* this byte of the lit is zero,
- *if it's not the last then OR in the variable */
- if(size)
- emitpcode(POC_IORFW, popGet(AOP(left),size));
+ }
}
- }
-
-
- emitpLabel(lbl->key);
- //if(emitFinalCheck)
- genSkipc(&rFalseIfx);
- if(sign)
- emitpLabel(truelbl->key);
-
- if(ifx) ifx->generated = 1;
- return;
-
-
- }
-#endif // _swapp
-
- if(AOP_TYPE(left) == AOP_LIT) {
- //symbol *lbl = newiTempLabel(NULL);
-
- //EXPERIMENTAL lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
-
-
- DEBUGpic14_emitcode(";left lit","lit = 0x%x,sign=%d",lit,sign);
-
- /* Special cases */
- if((lit == 0) && (sign == 0)){
-
+ /* Compare two variables */
+
+ DEBUGpic14_emitcode(";sign","%d",sign);
+
size--;
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- while(size)
- emitpcode(POC_IORFW, popGet(AOP(right),--size));
-
- genSkipz2(&rFalseIfx,0);
- if(ifx) ifx->generated = 1;
- return;
- }
-
- if(size==1) {
- /* Special cases */
- lit &= 0xff;
- if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
- /* degenerate compare can never be true */
- if(rFalseIfx.condition == 0)
- emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
-
- if(ifx) ifx->generated = 1;
- return;
- }
-
if(sign) {
- /* signed comparisons to a literal byte */
-
- int lp1 = (lit+1) & 0xff;
-
- DEBUGpic14_emitcode(";left lit","line = %d lit = 0x%x",__LINE__,lit);
- switch (lp1) {
- case 0:
- rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,0,7);
- break;
- case 0x7f:
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_XORLW, popGetLit(0x7f));
- genSkipz2(&rFalseIfx,1);
- break;
- default:
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_ADDLW, popGetLit(0x80));
- emitpcode(POC_ADDLW, popGetLit(((-(lit+1)) & 0xff) ^ 0x80));
- rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
- break;
- }
- if(ifx) ifx->generated = 1;
+ /* Sigh. thus sucks... */
+ if(size) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),size));
+ emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+ emitpcode(POC_MOVLW, popGetLit(0x80));
+ emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
+ emitpcode(POC_XORFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
+ } else {
+ /* Signed char comparison */
+ /* Special thanks to Nikolai Golovchenko for this snippet */
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_SUBFW, popGet(AOP(left),0));
+ emitpcode(POC_RRFW, popGet(AOP(left),0)); /* could be any register */
+ emitpcode(POC_XORFW, popGet(AOP(left),0));
+ emitpcode(POC_XORFW, popGet(AOP(right),0));
+ emitpcode(POC_ADDLW, popGetLit(0x80));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ genSkipc(&rFalseIfx);
+
+ if(ifx) ifx->generated = 1;
+ return;
+ }
+
} else {
- /* unsigned comparisons to a literal byte */
-
- switch(lit & 0xff ) {
- case 0:
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- genSkipz2(&rFalseIfx,0);
- if(ifx) ifx->generated = 1;
- break;
- case 0x7f:
- rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,0,7);
- if(ifx) ifx->generated = 1;
- break;
-
- default:
- emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
- emitpcode(POC_SUBFW, popGet(AOP(right),0));
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- rFalseIfx.condition ^= 1;
- if (AOP_TYPE(result) == AOP_CRY) {
- genSkipc(&rFalseIfx);
- if(ifx) ifx->generated = 1;
- } else {
- DEBUGpic14_emitcode ("; ***","%s %d RFIfx.cond=%d",__FUNCTION__,__LINE__, rFalseIfx.condition);
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- emitpcode(POC_RLF, popGet(AOP(result),0));
- emitpcode(POC_MOVLW, popGetLit(0x01));
- emitpcode(POC_XORWF, popGet(AOP(result),0));
- }
- break;
- }
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
}
-
- //goto check_carry;
- return;
-
- } else {
-
- /* Size is greater than 1 */
-
- if(sign) {
- int lp1 = lit+1;
-
- size--;
-
- if(lp1 == 0) {
- /* this means lit = 0xffffffff, or -1 */
-
-
- DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
- rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,size,7);
- if(ifx) ifx->generated = 1;
- return;
- }
-
- if(lit == 0) {
- int s = size;
-
- if(rFalseIfx.condition) {
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- }
-
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- while(size--)
- emitpcode(POC_IORFW, popGet(AOP(right),size));
-
-
- emitSKPZ;
- if(rFalseIfx.condition) {
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- emitpLabel(truelbl->key);
- }else {
- rFalseIfx.condition ^= 1;
- genSkipCond(&rFalseIfx,right,s,7);
- }
-
- if(ifx) ifx->generated = 1;
- return;
- }
-
- if((size == 1) && (0 == (lp1&0xff))) {
- /* lower byte of signed word is zero */
- DEBUGpic14_emitcode(";left lit","line = %d 0x%x+1 low byte is zero",__LINE__,lit);
- i = ((lp1 >> 8) & 0xff) ^0x80;
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- emitpcode(POC_ADDLW, popGetLit( 0x80));
- emitpcode(POC_ADDLW, popGetLit(0x100-i));
- rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
-
-
- if(ifx) ifx->generated = 1;
- return;
- }
-
- if(lit & (0x80 << (size*8))) {
- /* Lit is less than zero */
- DEBUGpic14_emitcode(";left lit","line = %d 0x%x is less than 0",__LINE__,lit);
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,left,size,7);
- //rFalseIfx.condition ^= 1;
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- //emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
-
- } else {
- /* Lit is greater than or equal to zero */
- DEBUGpic14_emitcode(";left lit","line = %d 0x%x is greater than 0",__LINE__,lit);
- //rFalseIfx.condition ^= 1;
- //genSkipCond(&rFalseIfx,right,size,7);
- //rFalseIfx.condition ^= 1;
-
- //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- //emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
-
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
-
- }
-
-
- emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
-
- while(size--) {
-
- emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
- }
- rFalseIfx.condition ^= 1;
- //rFalseIfx.condition = 1;
- genSkipc(&rFalseIfx);
-
- emitpLabel(truelbl->key);
-
- if(ifx) ifx->generated = 1;
- return;
- // end of if (sign)
- } else {
-
- /* compare word or long to an unsigned literal on the right.*/
-
-
- size--;
- if(lit < 0xff) {
- DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x < 0xff",__FUNCTION__,__LINE__,lit);
- switch (lit) {
- case 0:
- break; /* handled above */
-/*
- case 0xff:
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- while(size--)
- emitpcode(POC_IORFW, popGet(AOP(right),size));
- genSkipz2(&rFalseIfx,0);
- break;
-*/
- default:
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- while(--size)
- emitpcode(POC_IORFW, popGet(AOP(right),size));
-
- emitSKPZ;
- if(rFalseIfx.condition)
- emitpcode(POC_GOTO, popGetLabel(rFalseIfx.lbl->key));
- else
- emitpcode(POC_GOTO, popGetLabel(truelbl->key));
-
-
- emitpcode(POC_MOVLW, popGetLit(lit+1));
- emitpcode(POC_SUBFW, popGet(AOP(right),0));
-
- rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
- }
-
- emitpLabel(truelbl->key);
-
- if(ifx) ifx->generated = 1;
- return;
- }
-
-
- lit++;
- DEBUGpic14_emitcode ("; ***","%s %d lit =0x%x",__FUNCTION__,__LINE__,lit);
- i = (lit >> (size*8)) & 0xff;
-
- emitpcode(POC_MOVLW, popGetLit(i));
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
-
- while(size--) {
- i = (lit >> (size*8)) & 0xff;
-
- if(i) {
- emitpcode(POC_MOVLW, popGetLit(i));
- emitSKPNZ;
- emitpcode(POC_SUBFW, popGet(AOP(right),size));
- } else {
- /* this byte of the lit is zero,
- *if it's not the last then OR in the variable */
- if(size)
- emitpcode(POC_IORFW, popGet(AOP(right),size));
- }
- }
-
-
- emitpLabel(lbl->key);
-
- rFalseIfx.condition ^= 1;
- genSkipc(&rFalseIfx);
+
+
+ /* The rest of the bytes of a multi-byte compare */
+ while (size) {
+
+ emitSKPZ;
+ emitpcode(POC_GOTO, popGetLabel(lbl->key));
+ size--;
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),size));
+ emitpcode(POC_SUBFW, popGet(AOP(left),size));
+
+
}
-
- if(sign)
- emitpLabel(truelbl->key);
- if(ifx) ifx->generated = 1;
- return;
- }
- }
- /* Compare two variables */
-
- DEBUGpic14_emitcode(";sign","%d",sign);
-
- size--;
- if(sign) {
- /* Sigh. thus sucks... */
- if(size) {
- emitpcode(POC_MOVFW, popGet(AOP(left),size));
- emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
- emitpcode(POC_MOVLW, popGetLit(0x80));
- emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
- emitpcode(POC_XORFW, popGet(AOP(right),size));
- emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
- } else {
- /* Signed char comparison */
- /* Special thanks to Nikolai Golovchenko for this snippet */
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_SUBFW, popGet(AOP(left),0));
- emitpcode(POC_RRFW, popGet(AOP(left),0)); /* could be any register */
- emitpcode(POC_XORFW, popGet(AOP(left),0));
- emitpcode(POC_XORFW, popGet(AOP(right),0));
- emitpcode(POC_ADDLW, popGetLit(0x80));
-
+
+ emitpLabel(lbl->key);
+
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- genSkipc(&rFalseIfx);
-
+ if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) ||
+ (AOP_TYPE(result) == AOP_REG)) {
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ } else {
+ genSkipc(&rFalseIfx);
+ }
+ //genSkipc(&rFalseIfx);
if(ifx) ifx->generated = 1;
+
return;
- }
-
- } else {
-
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
- }
-
-
- /* The rest of the bytes of a multi-byte compare */
- while (size) {
-
- emitSKPZ;
- emitpcode(POC_GOTO, popGetLabel(lbl->key));
- size--;
-
- emitpcode(POC_MOVFW, popGet(AOP(right),size));
- emitpcode(POC_SUBFW, popGet(AOP(left),size));
-
-
- }
-
- emitpLabel(lbl->key);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) ||
- (AOP_TYPE(result) == AOP_REG)) {
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- emitpcode(POC_RLF, popGet(AOP(result),0));
- } else {
- genSkipc(&rFalseIfx);
- }
- //genSkipc(&rFalseIfx);
- if(ifx) ifx->generated = 1;
-
- return;
-
+
}
-
+
// check_carry:
if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- pic14_outBitC(result);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ pic14_outBitC(result);
} else {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if the result is used in the next
- ifx conditional branch then generate
- code a little differently */
- if (ifx )
- genIfxJump (ifx,"c");
- else
- pic14_outBitC(result);
- /* leave the result in acc */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if the result is used in the next
+ ifx conditional branch then generate
+ code a little differently */
+ if (ifx )
+ genIfxJump (ifx,"c");
+ else
+ pic14_outBitC(result);
+ /* leave the result in acc */
}
-
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genCmpGt (iCode *ic, iCode *ifx)
{
- operand *left, *right, *result;
- sym_link *letype , *retype;
- int sign ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- left = IC_LEFT(ic);
- right= IC_RIGHT(ic);
- result = IC_RESULT(ic);
-
- letype = getSpec(operandType(left));
- retype =getSpec(operandType(right));
- sign = !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
- /* assign the amsops */
- aopOp (left,ic,FALSE);
- aopOp (right,ic,FALSE);
- aopOp (result,ic,TRUE);
-
- genCmp(right, left, result, ifx, sign);
-
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left, *right, *result;
+ sym_link *letype , *retype;
+ int sign ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ left = IC_LEFT(ic);
+ right= IC_RIGHT(ic);
+ result = IC_RESULT(ic);
+
+ letype = getSpec(operandType(left));
+ retype =getSpec(operandType(right));
+ sign = !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ genCmp(right, left, result, ifx, sign);
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genCmpLt (iCode *ic, iCode *ifx)
{
- operand *left, *right, *result;
- sym_link *letype , *retype;
- int sign ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- left = IC_LEFT(ic);
- right= IC_RIGHT(ic);
- result = IC_RESULT(ic);
-
- letype = getSpec(operandType(left));
- retype =getSpec(operandType(right));
- sign = !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
-
- /* assign the amsops */
- aopOp (left,ic,FALSE);
- aopOp (right,ic,FALSE);
- aopOp (result,ic,TRUE);
-
- genCmp(left, right, result, ifx, sign);
-
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left, *right, *result;
+ sym_link *letype , *retype;
+ int sign ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ left = IC_LEFT(ic);
+ right= IC_RIGHT(ic);
+ result = IC_RESULT(ic);
+
+ letype = getSpec(operandType(left));
+ retype =getSpec(operandType(right));
+ sign = !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
+
+ /* assign the amsops */
+ aopOp (left,ic,FALSE);
+ aopOp (right,ic,FALSE);
+ aopOp (result,ic,TRUE);
+
+ genCmp(left, right, result, ifx, sign);
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genc16bit2lit(operand *op, int lit, int offset)
{
- int i;
-
- DEBUGpic14_emitcode ("; ***","%s %d, lit = %d",__FUNCTION__,__LINE__,lit);
- if( (lit&0xff) == 0)
- i=1;
- else
- i=0;
-
- switch( BYTEofLONG(lit,i)) {
- case 0:
- emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
- break;
- case 1:
- emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
- break;
- case 0xff:
- emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
- break;
- default:
- emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
- emitpcode(POC_XORLW,popGetLit(BYTEofLONG(lit,i)));
- }
-
- i ^= 1;
-
- switch( BYTEofLONG(lit,i)) {
- case 0:
- emitpcode(POC_IORFW,popGet(AOP(op),offset+i));
- break;
- case 1:
- emitSKPNZ;
- emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
- break;
- case 0xff:
- emitSKPNZ;
- emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
- break;
- default:
- emitpcode(POC_MOVLW,popGetLit(BYTEofLONG(lit,i)));
- emitSKPNZ;
- emitpcode(POC_XORFW,popGet(AOP(op),offset+i));
-
- }
-
+ int i;
+
+ DEBUGpic14_emitcode ("; ***","%s %d, lit = %d",__FUNCTION__,__LINE__,lit);
+ if( (lit&0xff) == 0)
+ i=1;
+ else
+ i=0;
+
+ switch( BYTEofLONG(lit,i)) {
+ case 0:
+ emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
+ break;
+ case 1:
+ emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
+ break;
+ case 0xff:
+ emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
+ break;
+ default:
+ emitpcode(POC_MOVFW,popGet(AOP(op),offset+i));
+ emitpcode(POC_XORLW,popGetLit(BYTEofLONG(lit,i)));
+ }
+
+ i ^= 1;
+
+ switch( BYTEofLONG(lit,i)) {
+ case 0:
+ emitpcode(POC_IORFW,popGet(AOP(op),offset+i));
+ break;
+ case 1:
+ emitSKPNZ;
+ emitpcode(POC_DECFW,popGet(AOP(op),offset+i));
+ break;
+ case 0xff:
+ emitSKPNZ;
+ emitpcode(POC_INCFW,popGet(AOP(op),offset+i));
+ break;
+ default:
+ emitpcode(POC_MOVLW,popGetLit(BYTEofLONG(lit,i)));
+ emitSKPNZ;
+ emitpcode(POC_XORFW,popGet(AOP(op),offset+i));
+
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
{
- int size = max(AOP_SIZE(left),AOP_SIZE(right));
- int offset = 0;
- int res_offset = 0; /* the result may be a different size then left or right */
- int res_size = AOP_SIZE(result);
- resolvedIfx rIfx;
- symbol *lbl;
-
- unsigned long lit = 0L;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- DEBUGpic14_AopType(__LINE__,left,right,result);
- if(result)
- DEBUGpic14_emitcode ("; ***","%s %d result is not null",__FUNCTION__,__LINE__);
- resolveIfx(&rIfx,ifx);
- lbl = newiTempLabel(NULL);
-
-
- /* if the left side is a literal or
- if the right is in a pointer register and left
- is not */
- if ((AOP_TYPE(left) == AOP_LIT) ||
- (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
- operand *t = right;
- right = left;
- left = t;
- }
- if(AOP_TYPE(right) == AOP_LIT)
- lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
-
- /* if the right side is a literal then anything goes */
- if (AOP_TYPE(right) == AOP_LIT &&
- AOP_TYPE(left) != AOP_DIR ) {
- switch(size) {
- case 2:
- genc16bit2lit(left, lit, 0);
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(lbl->key));
- break;
- default:
- while (size--) {
- if(lit & 0xff) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORLW,popGetLit(lit & 0xff));
- } else {
- emitpcode(POC_MOVF,popGet(AOP(left),offset));
+ int size = max(AOP_SIZE(left),AOP_SIZE(right));
+ int offset = 0;
+ int res_offset = 0; /* the result may be a different size then left or right */
+ int res_size = AOP_SIZE(result);
+ resolvedIfx rIfx;
+ symbol *lbl;
+
+ unsigned long lit = 0L;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+ if(result)
+ DEBUGpic14_emitcode ("; ***","%s %d result is not null",__FUNCTION__,__LINE__);
+ resolveIfx(&rIfx,ifx);
+ lbl = newiTempLabel(NULL);
+
+
+ /* if the left side is a literal or
+ if the right is in a pointer register and left
+ is not */
+ if ((AOP_TYPE(left) == AOP_LIT) ||
+ (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
+ operand *t = right;
+ right = left;
+ left = t;
}
-
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(lbl->key));
- offset++;
- if(res_offset < res_size-1)
- res_offset++;
- lit >>= 8;
- }
- break;
- }
- }
-
- /* if the right side is in a register or in direct space or
- if the left is a pointer register & right is not */
- else if (AOP_TYPE(right) == AOP_REG ||
- AOP_TYPE(right) == AOP_DIR ||
- (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
- (IS_AOP_PREG(left) && !IS_AOP_PREG(right))) {
- //int lbl_key = (rIfx.condition) ? rIfx.lbl->key : lbl->key;
- int lbl_key = lbl->key;
-
- if(result) {
- emitpcode(POC_CLRF,popGet(AOP(result),res_offset));
- //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
- }else {
- DEBUGpic14_emitcode ("; ***","%s %d -- ERROR",__FUNCTION__,__LINE__);
- fprintf(stderr, "%s %d error - expecting result to be non_null\n",
- __FUNCTION__,__LINE__);
- return;
- }
-
-/* switch(size) { */
-/* case 2: */
-/* genc16bit2lit(left, lit, 0); */
-/* emitSKPNZ; */
-/* emitpcode(POC_GOTO,popGetLabel(lbl->key)); */
-/* break; */
-/* default: */
- while (size--) {
- int emit_skip=1;
- if((AOP_TYPE(left) == AOP_DIR) &&
- ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
-
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORFW,popGet(AOP(right),offset));
-
- } else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
-
- switch (lit & 0xff) {
- case 0:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- break;
- case 1:
- emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
- emitpcode(POC_INCF,popGet(AOP(result),res_offset));
- //emitpcode(POC_GOTO,popGetLabel(lbl->key));
- emit_skip=0;
- break;
- case 0xff:
- emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
- //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
- //emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
- emitpcode(POC_GOTO,popGetLabel(lbl_key));
- emit_skip=0;
- break;
- default:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORLW,popGetLit(lit & 0xff));
- }
- lit >>= 8;
-
- } else {
- emitpcode(POC_MOVF,popGet(AOP(left),offset));
- }
- if(emit_skip) {
- if(AOP_TYPE(result) == AOP_CRY) {
- pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
- if(rIfx.condition)
- emitSKPNZ;
- else
- emitSKPZ;
- emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
- } else {
- /* fix me. probably need to check result size too */
- //emitpcode(POC_CLRF,popGet(AOP(result),0));
- if(rIfx.condition)
- emitSKPZ;
- else
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(lbl_key));
- //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ /* if the right side is a literal then anything goes */
+ if (AOP_TYPE(right) == AOP_LIT &&
+ AOP_TYPE(left) != AOP_DIR ) {
+ switch(size) {
+ case 2:
+ genc16bit2lit(left, lit, 0);
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ break;
+ default:
+ while (size--) {
+ if(lit & 0xff) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+ } else {
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
+ }
+
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ offset++;
+ if(res_offset < res_size-1)
+ res_offset++;
+ lit >>= 8;
+ }
+ break;
+ }
}
+
+ /* if the right side is in a register or in direct space or
+ if the left is a pointer register & right is not */
+ else if (AOP_TYPE(right) == AOP_REG ||
+ AOP_TYPE(right) == AOP_DIR ||
+ (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
+ (IS_AOP_PREG(left) && !IS_AOP_PREG(right))) {
+ //int lbl_key = (rIfx.condition) ? rIfx.lbl->key : lbl->key;
+ int lbl_key = lbl->key;
+
+ if(result) {
+ emitpcode(POC_CLRF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ }else {
+ DEBUGpic14_emitcode ("; ***","%s %d -- ERROR",__FUNCTION__,__LINE__);
+ fprintf(stderr, "%s %d error - expecting result to be non_null\n",
+ __FUNCTION__,__LINE__);
+ return;
+ }
+
+ /* switch(size) { */
+ /* case 2: */
+ /* genc16bit2lit(left, lit, 0); */
+ /* emitSKPNZ; */
+ /* emitpcode(POC_GOTO,popGetLabel(lbl->key)); */
+ /* break; */
+ /* default: */
+ while (size--) {
+ int emit_skip=1;
+ if((AOP_TYPE(left) == AOP_DIR) &&
+ ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+
+ } else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
+
+ switch (lit & 0xff) {
+ case 0:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ break;
+ case 1:
+ emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_GOTO,popGetLabel(lbl->key));
+ emit_skip=0;
+ break;
+ case 0xff:
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ //emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_GOTO,popGetLabel(lbl_key));
+ emit_skip=0;
+ break;
+ default:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+ }
+ lit >>= 8;
+
+ } else {
+ emitpcode(POC_MOVF,popGet(AOP(left),offset));
+ }
+ if(emit_skip) {
+ if(AOP_TYPE(result) == AOP_CRY) {
+ pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
+ if(rIfx.condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+ } else {
+ /* fix me. probably need to check result size too */
+ //emitpcode(POC_CLRF,popGet(AOP(result),0));
+ if(rIfx.condition)
+ emitSKPZ;
+ else
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(lbl_key));
+ //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ }
+ if(ifx)
+ ifx->generated=1;
+ }
+ emit_skip++;
+ offset++;
+ if(res_offset < res_size-1)
+ res_offset++;
+ }
+ /* break; */
+ /* } */
+ } else if(AOP_TYPE(right) == AOP_REG &&
+ AOP_TYPE(left) != AOP_DIR){
+
+ while(size--) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+ pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
+ if(rIfx.condition)
+ emitSKPNZ;
+ else
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+ offset++;
+ if(res_offset < res_size-1)
+ res_offset++;
+ }
+
+ }else{
+ /* right is a pointer reg need both a & b */
+ while(size--) {
+ char *l = aopGet(AOP(left),offset,FALSE,FALSE);
+ if(strcmp(l,"b"))
+ pic14_emitcode("mov","b,%s",l);
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("cjne","a,b,%05d_DS_",lbl->key+100);
+ offset++;
+ }
+ }
+
+ emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+ if(!rIfx.condition)
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+
+ emitpLabel(lbl->key);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
if(ifx)
- ifx->generated=1;
- }
- emit_skip++;
- offset++;
- if(res_offset < res_size-1)
- res_offset++;
- }
-/* break; */
-/* } */
- } else if(AOP_TYPE(right) == AOP_REG &&
- AOP_TYPE(left) != AOP_DIR){
-
- while(size--) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORFW,popGet(AOP(right),offset));
- pic14_emitcode(";***","%s %d",__FUNCTION__,__LINE__);
- if(rIfx.condition)
- emitSKPNZ;
- else
- emitSKPZ;
- emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
- offset++;
- if(res_offset < res_size-1)
- res_offset++;
- }
-
- }else{
- /* right is a pointer reg need both a & b */
- while(size--) {
- char *l = aopGet(AOP(left),offset,FALSE,FALSE);
- if(strcmp(l,"b"))
- pic14_emitcode("mov","b,%s",l);
- MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("cjne","a,b,%05d_DS_",lbl->key+100);
- offset++;
- }
- }
-
- emitpcode(POC_INCF,popGet(AOP(result),res_offset));
- if(!rIfx.condition)
- emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
-
- emitpLabel(lbl->key);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if(ifx)
- ifx->generated = 1;
+ ifx->generated = 1;
}
#if 0
/*-----------------------------------------------------------------*/
static void gencjne(operand *left, operand *right, iCode *ifx)
{
- symbol *tlbl = newiTempLabel(NULL);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- gencjneshort(left, right, lbl);
-
- pic14_emitcode("mov","a,%s",one);
- pic14_emitcode("sjmp","%05d_DS_",tlbl->key+100);
- pic14_emitcode("","%05d_DS_:",lbl->key+100);
- pic14_emitcode("clr","a");
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
-
- emitpLabel(lbl->key);
- emitpLabel(tlbl->key);
-
+ symbol *tlbl = newiTempLabel(NULL);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ gencjneshort(left, right, lbl);
+
+ pic14_emitcode("mov","a,%s",one);
+ pic14_emitcode("sjmp","%05d_DS_",tlbl->key+100);
+ pic14_emitcode("","%05d_DS_:",lbl->key+100);
+ pic14_emitcode("clr","a");
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+
+ emitpLabel(lbl->key);
+ emitpLabel(tlbl->key);
+
}
#endif
/*-----------------------------------------------------------------*/
static void genCmpEq (iCode *ic, iCode *ifx)
{
- operand *left, *right, *result;
- unsigned long lit = 0L;
- int size,offset=0;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if(ifx)
- DEBUGpic14_emitcode ("; ifx is non-null","");
- else
- DEBUGpic14_emitcode ("; ifx is null","");
-
- aopOp((left=IC_LEFT(ic)),ic,FALSE);
- aopOp((right=IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,TRUE);
-
- size = max(AOP_SIZE(left),AOP_SIZE(right));
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- /* if literal, literal on the right or
- if the right is in a pointer register and left
- is not */
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ||
- (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
-
- if(ifx && !AOP_SIZE(result)){
- symbol *tlbl;
- /* if they are both bit variables */
- if (AOP_TYPE(left) == AOP_CRY &&
- ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
- if(AOP_TYPE(right) == AOP_LIT){
- unsigned long lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
- if(lit == 0L){
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- pic14_emitcode("cpl","c");
- } else if(lit == 1L) {
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- } else {
- pic14_emitcode("clr","c");
- }
- /* AOP_TYPE(right) == AOP_CRY */
- } else {
- symbol *lbl = newiTempLabel(NULL);
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- pic14_emitcode("jb","%s,%05d_DS_",AOP(right)->aopu.aop_dir,(lbl->key+100));
- pic14_emitcode("cpl","c");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
- }
- /* if true label then we jump if condition
- supplied is true */
- tlbl = newiTempLabel(NULL);
- if ( IC_TRUE(ifx) ) {
- pic14_emitcode("jnc","%05d_DS_",tlbl->key+100);
- pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100);
- } else {
- pic14_emitcode("jc","%05d_DS_",tlbl->key+100);
- pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ifx)->key+100);
- }
- pic14_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
-
- {
- /* left and right are both bit variables, result is carry */
- resolvedIfx rIfx;
-
- resolveIfx(&rIfx,ifx);
-
- emitpcode(POC_MOVLW,popGet(AOP(left),0));
- emitpcode(POC_ANDFW,popGet(AOP(left),0));
- emitpcode(POC_BTFSC,popGet(AOP(right),0));
- emitpcode(POC_ANDLW,popGet(AOP(left),0));
- genSkipz2(&rIfx,0);
- }
- } else {
-
- /* They're not both bit variables. Is the right a literal? */
- if(AOP_TYPE(right) == AOP_LIT) {
- lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
-
- switch(size) {
-
- case 1:
- switch(lit & 0xff) {
- case 1:
- if ( IC_TRUE(ifx) ) {
- emitpcode(POC_DECFW,popGet(AOP(left),offset));
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ operand *left, *right, *result;
+ unsigned long lit = 0L;
+ int size,offset=0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(ifx)
+ DEBUGpic14_emitcode ("; ifx is non-null","");
+ else
+ DEBUGpic14_emitcode ("; ifx is null","");
+
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ size = max(AOP_SIZE(left),AOP_SIZE(right));
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ /* if literal, literal on the right or
+ if the right is in a pointer register and left
+ is not */
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ||
+ (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+
+ if(ifx && !AOP_SIZE(result)){
+ symbol *tlbl;
+ /* if they are both bit variables */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ unsigned long lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+ if(lit == 0L){
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ } else if(lit == 1L) {
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ } else {
+ pic14_emitcode("clr","c");
+ }
+ /* AOP_TYPE(right) == AOP_CRY */
+ } else {
+ symbol *lbl = newiTempLabel(NULL);
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ pic14_emitcode("jb","%s,%05d_DS_",AOP(right)->aopu.aop_dir,(lbl->key+100));
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+ }
+ /* if true label then we jump if condition
+ supplied is true */
+ tlbl = newiTempLabel(NULL);
+ if ( IC_TRUE(ifx) ) {
+ pic14_emitcode("jnc","%05d_DS_",tlbl->key+100);
+ pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100);
+ } else {
+ pic14_emitcode("jc","%05d_DS_",tlbl->key+100);
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ifx)->key+100);
+ }
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
+
+ {
+ /* left and right are both bit variables, result is carry */
+ resolvedIfx rIfx;
+
+ resolveIfx(&rIfx,ifx);
+
+ emitpcode(POC_MOVLW,popGet(AOP(left),0));
+ emitpcode(POC_ANDFW,popGet(AOP(left),0));
+ emitpcode(POC_BTFSC,popGet(AOP(right),0));
+ emitpcode(POC_ANDLW,popGet(AOP(left),0));
+ genSkipz2(&rIfx,0);
+ }
} else {
- emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+
+ /* They're not both bit variables. Is the right a literal? */
+ if(AOP_TYPE(right) == AOP_LIT) {
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ switch(size) {
+
+ case 1:
+ switch(lit & 0xff) {
+ case 1:
+ if ( IC_TRUE(ifx) ) {
+ emitpcode(POC_DECFW,popGet(AOP(left),offset));
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ } else {
+ emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ }
+ break;
+ case 0xff:
+ if ( IC_TRUE(ifx) ) {
+ emitpcode(POC_INCFW,popGet(AOP(left),offset));
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ } else {
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ }
+ break;
+ default:
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ if(lit)
+ emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+ genSkip(ifx,'z');
+ }
+
+
+ /* end of size == 1 */
+ break;
+
+ case 2:
+ genc16bit2lit(left,lit,offset);
+ genSkip(ifx,'z');
+ break;
+ /* end of size == 2 */
+
+ default:
+ /* size is 4 */
+ if(lit==0) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_IORFW,popGet(AOP(left),1));
+ emitpcode(POC_IORFW,popGet(AOP(left),2));
+ emitpcode(POC_IORFW,popGet(AOP(left),3));
+
+ } else {
+
+ /* search for patterns that can be optimized */
+
+ genc16bit2lit(left,lit,0);
+ lit >>= 16;
+ if(lit) {
+ genSkipz(ifx,IC_TRUE(ifx) == NULL);
+ //genSkip(ifx,'z');
+ genc16bit2lit(left,lit,2);
+ } else {
+ emitpcode(POC_IORFW,popGet(AOP(left),2));
+ emitpcode(POC_IORFW,popGet(AOP(left),3));
+
+ }
+
+ }
+
+ genSkip(ifx,'z');
+ }
+
+ ifx->generated = 1;
+ goto release ;
+
+
+ } else if(AOP_TYPE(right) == AOP_CRY ) {
+ /* we know the left is not a bit, but that the right is */
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode( ( (IC_TRUE(ifx)) ? POC_BTFSC : POC_BTFSS),
+ popGet(AOP(right),offset));
+ emitpcode(POC_XORLW,popGetLit(1));
+
+ /* if the two are equal, then W will be 0 and the Z bit is set
+ * we could test Z now, or go ahead and check the high order bytes if
+ * the variable we're comparing is larger than a byte. */
+
+ while(--size)
+ emitpcode(POC_IORFW,popGet(AOP(left),offset));
+
+ if ( IC_TRUE(ifx) ) {
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ } else {
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ }
+
+ } else {
+ /* They're both variables that are larger than bits */
+ int s = size;
+
+ tlbl = newiTempLabel(NULL);
+
+ while(size--) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+
+ if ( IC_TRUE(ifx) ) {
+ if(size) {
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ pic14_emitcode(" goto","_%05d_DS_",tlbl->key+100+labelOffset);
+ } else {
+ emitSKPNZ;
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ }
+ } else {
+ emitSKPZ;
+ emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ }
+ offset++;
+ }
+ if(s>1 && IC_TRUE(ifx)) {
+ emitpLabel(tlbl->key);
+ pic14_emitcode("","_%05d_DS_:",tlbl->key+100+labelOffset);
+ }
+ }
}
- break;
- case 0xff:
- if ( IC_TRUE(ifx) ) {
- emitpcode(POC_INCFW,popGet(AOP(left),offset));
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+ /* mark the icode as generated */
+ ifx->generated = 1;
+ goto release ;
+ }
+
+ /* if they are both bit variables */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ unsigned long lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+ if(lit == 0L){
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ } else if(lit == 1L) {
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ } else {
+ pic14_emitcode("clr","c");
+ }
+ /* AOP_TYPE(right) == AOP_CRY */
} else {
- emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
+ symbol *lbl = newiTempLabel(NULL);
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ pic14_emitcode("jb","%s,%05d_DS_",AOP(right)->aopu.aop_dir,(lbl->key+100));
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
}
- break;
- default:
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- if(lit)
- emitpcode(POC_XORLW,popGetLit(lit & 0xff));
- genSkip(ifx,'z');
- }
-
-
- /* end of size == 1 */
- break;
-
- case 2:
- genc16bit2lit(left,lit,offset);
- genSkip(ifx,'z');
- break;
- /* end of size == 2 */
-
- default:
- /* size is 4 */
- if(lit==0) {
- emitpcode(POC_MOVFW,popGet(AOP(left),0));
- emitpcode(POC_IORFW,popGet(AOP(left),1));
- emitpcode(POC_IORFW,popGet(AOP(left),2));
- emitpcode(POC_IORFW,popGet(AOP(left),3));
-
- } else {
-
- /* search for patterns that can be optimized */
-
- genc16bit2lit(left,lit,0);
- lit >>= 16;
- if(lit) {
- genSkipz(ifx,IC_TRUE(ifx) == NULL);
- //genSkip(ifx,'z');
- genc16bit2lit(left,lit,2);
- } else {
- emitpcode(POC_IORFW,popGet(AOP(left),2));
- emitpcode(POC_IORFW,popGet(AOP(left),3));
-
+ /* c = 1 if egal */
+ if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)){
+ pic14_outBitC(result);
+ goto release ;
}
+ if (ifx) {
+ genIfxJump (ifx,"c");
+ goto release ;
+ }
+ /* if the result is used in an arithmetic operation
+ then put the result in place */
+ pic14_outBitC(result);
+ } else {
- }
-
- genSkip(ifx,'z');
- }
-
- ifx->generated = 1;
- goto release ;
-
-
- } else if(AOP_TYPE(right) == AOP_CRY ) {
- /* we know the left is not a bit, but that the right is */
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode( ( (IC_TRUE(ifx)) ? POC_BTFSC : POC_BTFSS),
- popGet(AOP(right),offset));
- emitpcode(POC_XORLW,popGetLit(1));
-
- /* if the two are equal, then W will be 0 and the Z bit is set
- * we could test Z now, or go ahead and check the high order bytes if
- * the variable we're comparing is larger than a byte. */
-
- while(--size)
- emitpcode(POC_IORFW,popGet(AOP(left),offset));
-
- if ( IC_TRUE(ifx) ) {
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
- pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
- } else {
- emitSKPZ;
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
- pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
- }
-
- } else {
- /* They're both variables that are larger than bits */
- int s = size;
-
- tlbl = newiTempLabel(NULL);
-
- while(size--) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- emitpcode(POC_XORFW,popGet(AOP(right),offset));
-
- if ( IC_TRUE(ifx) ) {
- if(size) {
- emitSKPZ;
- emitpcode(POC_GOTO,popGetLabel(tlbl->key));
- pic14_emitcode(" goto","_%05d_DS_",tlbl->key+100+labelOffset);
- } else {
- emitSKPNZ;
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
- pic14_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ gencjne(left,right,result,ifx);
+ /*
+ if(ifx)
+ gencjne(left,right,newiTempLabel(NULL));
+ else {
+ if(IC_TRUE(ifx)->key)
+ gencjne(left,right,IC_TRUE(ifx)->key);
+ else
+ gencjne(left,right,IC_FALSE(ifx)->key);
+ ifx->generated = 1;
+ goto release ;
}
- } else {
- emitSKPZ;
- emitpcode(POC_GOTO,popGetLabel(IC_FALSE(ifx)->key));
- pic14_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
- }
- offset++;
- }
- if(s>1 && IC_TRUE(ifx)) {
- emitpLabel(tlbl->key);
- pic14_emitcode("","_%05d_DS_:",tlbl->key+100+labelOffset);
- }
- }
- }
- /* mark the icode as generated */
- ifx->generated = 1;
- goto release ;
- }
-
- /* if they are both bit variables */
- if (AOP_TYPE(left) == AOP_CRY &&
- ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
- if(AOP_TYPE(right) == AOP_LIT){
- unsigned long lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
- if(lit == 0L){
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- pic14_emitcode("cpl","c");
- } else if(lit == 1L) {
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- } else {
- pic14_emitcode("clr","c");
- }
- /* AOP_TYPE(right) == AOP_CRY */
- } else {
- symbol *lbl = newiTempLabel(NULL);
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- pic14_emitcode("jb","%s,%05d_DS_",AOP(right)->aopu.aop_dir,(lbl->key+100));
- pic14_emitcode("cpl","c");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
- }
- /* c = 1 if egal */
- if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)){
- pic14_outBitC(result);
- goto release ;
- }
- if (ifx) {
- genIfxJump (ifx,"c");
- goto release ;
- }
- /* if the result is used in an arithmetic operation
- then put the result in place */
- pic14_outBitC(result);
- } else {
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- gencjne(left,right,result,ifx);
-/*
- if(ifx)
- gencjne(left,right,newiTempLabel(NULL));
- else {
- if(IC_TRUE(ifx)->key)
- gencjne(left,right,IC_TRUE(ifx)->key);
- else
- gencjne(left,right,IC_FALSE(ifx)->key);
- ifx->generated = 1;
- goto release ;
- }
- if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
- aopPut(AOP(result),"a",0);
- goto release ;
- }
-
- if (ifx) {
- genIfxJump (ifx,"a");
- goto release ;
- }
-*/
- /* if the result is used in an arithmetic operation
- then put the result in place */
-/*
- if (AOP_TYPE(result) != AOP_CRY)
- pic14_outAcc(result);
-*/
- /* leave the result in acc */
- }
-
+ if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
+ aopPut(AOP(result),"a",0);
+ goto release ;
+ }
+
+ if (ifx) {
+ genIfxJump (ifx,"a");
+ goto release ;
+ }
+ */
+ /* if the result is used in an arithmetic operation
+ then put the result in place */
+ /*
+ if (AOP_TYPE(result) != AOP_CRY)
+ pic14_outAcc(result);
+ */
+ /* leave the result in acc */
+ }
+
release:
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static iCode *ifxForOp ( operand *op, iCode *ic )
{
- /* if true symbol then needs to be assigned */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (IS_TRUE_SYMOP(op))
- return NULL ;
-
- /* if this has register type condition and
- the next instruction is ifx with the same operand
- and live to of the operand is upto the ifx only then */
- if (ic->next &&
- ic->next->op == IFX &&
- IC_COND(ic->next)->key == op->key &&
- OP_SYMBOL(op)->liveTo <= ic->next->seq )
- return ic->next;
-
- if (ic->next &&
- ic->next->op == IFX &&
- IC_COND(ic->next)->key == op->key) {
- DEBUGpic14_emitcode ("; WARNING ","%d IGNORING liveTo range in %s",__LINE__,__FUNCTION__);
- return ic->next;
- }
-
- DEBUGpic14_emitcode ("; NULL :(","%d",__LINE__);
- if (ic->next &&
- ic->next->op == IFX)
- DEBUGpic14_emitcode ("; ic-next"," is an IFX");
-
- if (ic->next &&
- ic->next->op == IFX &&
- IC_COND(ic->next)->key == op->key) {
- DEBUGpic14_emitcode ("; "," key is okay");
- DEBUGpic14_emitcode ("; "," key liveTo %d, next->seq = %d",
- OP_SYMBOL(op)->liveTo,
- ic->next->seq);
- }
-
-
- return NULL;
+ /* if true symbol then needs to be assigned */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (IS_TRUE_SYMOP(op))
+ return NULL ;
+
+ /* if this has register type condition and
+ the next instruction is ifx with the same operand
+ and live to of the operand is upto the ifx only then */
+ if (ic->next &&
+ ic->next->op == IFX &&
+ IC_COND(ic->next)->key == op->key &&
+ OP_SYMBOL(op)->liveTo <= ic->next->seq )
+ return ic->next;
+
+ if (ic->next &&
+ ic->next->op == IFX &&
+ IC_COND(ic->next)->key == op->key) {
+ DEBUGpic14_emitcode ("; WARNING ","%d IGNORING liveTo range in %s",__LINE__,__FUNCTION__);
+ return ic->next;
+ }
+
+ DEBUGpic14_emitcode ("; NULL :(","%d",__LINE__);
+ if (ic->next &&
+ ic->next->op == IFX)
+ DEBUGpic14_emitcode ("; ic-next"," is an IFX");
+
+ if (ic->next &&
+ ic->next->op == IFX &&
+ IC_COND(ic->next)->key == op->key) {
+ DEBUGpic14_emitcode ("; "," key is okay");
+ DEBUGpic14_emitcode ("; "," key liveTo %d, next->seq = %d",
+ OP_SYMBOL(op)->liveTo,
+ ic->next->seq);
+ }
+
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/* genAndOp - for && operation */
/*-----------------------------------------------------------------*/
static void genAndOp (iCode *ic)
{
- operand *left,*right, *result;
-/* symbol *tlbl; */
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* note here that && operations that are in an
- if statement are taken away by backPatchLabels
- only those used in arthmetic operations remain */
- aopOp((left=IC_LEFT(ic)),ic,FALSE);
- aopOp((right=IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,FALSE);
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- emitpcode(POC_MOVFW,popGet(AOP(left),0));
- emitpcode(POC_ANDFW,popGet(AOP(right),0));
- emitpcode(POC_MOVWF,popGet(AOP(result),0));
-
- /* if both are bit variables */
-/* if (AOP_TYPE(left) == AOP_CRY && */
-/* AOP_TYPE(right) == AOP_CRY ) { */
-/* pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
-/* pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
-/* pic14_outBitC(result); */
-/* } else { */
-/* tlbl = newiTempLabel(NULL); */
-/* pic14_toBoolean(left); */
-/* pic14_emitcode("jz","%05d_DS_",tlbl->key+100); */
-/* pic14_toBoolean(right); */
-/* pic14_emitcode("","%05d_DS_:",tlbl->key+100); */
-/* pic14_outBitAcc(result); */
-/* } */
-
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left,*right, *result;
+ /* symbol *tlbl; */
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* note here that && operations that are in an
+ if statement are taken away by backPatchLabels
+ only those used in arthmetic operations remain */
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_ANDFW,popGet(AOP(right),0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+
+ /* if both are bit variables */
+ /* if (AOP_TYPE(left) == AOP_CRY && */
+ /* AOP_TYPE(right) == AOP_CRY ) { */
+ /* pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
+ /* pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
+ /* pic14_outBitC(result); */
+ /* } else { */
+ /* tlbl = newiTempLabel(NULL); */
+ /* pic14_toBoolean(left); */
+ /* pic14_emitcode("jz","%05d_DS_",tlbl->key+100); */
+ /* pic14_toBoolean(right); */
+ /* pic14_emitcode("","%05d_DS_:",tlbl->key+100); */
+ /* pic14_outBitAcc(result); */
+ /* } */
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/* genOrOp - for || operation */
/*-----------------------------------------------------------------*/
/*
- tsd pic port -
- modified this code, but it doesn't appear to ever get called
+tsd pic port -
+modified this code, but it doesn't appear to ever get called
*/
static void genOrOp (iCode *ic)
{
- operand *left,*right, *result;
- symbol *tlbl;
-
- /* note here that || operations that are in an
- if statement are taken away by backPatchLabels
- only those used in arthmetic operations remain */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp((left=IC_LEFT(ic)),ic,FALSE);
- aopOp((right=IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,FALSE);
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- /* if both are bit variables */
- if (AOP_TYPE(left) == AOP_CRY &&
- AOP_TYPE(right) == AOP_CRY ) {
- pic14_emitcode("clrc","");
- pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
- AOP(left)->aopu.aop_dir,
- AOP(left)->aopu.aop_dir);
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- pic14_emitcode("setc","");
-
- } else {
- tlbl = newiTempLabel(NULL);
- pic14_toBoolean(left);
- emitSKPZ;
- pic14_emitcode("goto","%05d_DS_",tlbl->key+100+labelOffset);
- pic14_toBoolean(right);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
-
- pic14_outBitAcc(result);
- }
-
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left,*right, *result;
+ symbol *tlbl;
+
+ /* note here that || operations that are in an
+ if statement are taken away by backPatchLabels
+ only those used in arthmetic operations remain */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ /* if both are bit variables */
+ if (AOP_TYPE(left) == AOP_CRY &&
+ AOP_TYPE(right) == AOP_CRY ) {
+ pic14_emitcode("clrc","");
+ pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
+ AOP(left)->aopu.aop_dir,
+ AOP(left)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("setc","");
+
+ } else {
+ tlbl = newiTempLabel(NULL);
+ pic14_toBoolean(left);
+ emitSKPZ;
+ pic14_emitcode("goto","%05d_DS_",tlbl->key+100+labelOffset);
+ pic14_toBoolean(right);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
+
+ pic14_outBitAcc(result);
+ }
+
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static int isLiteralBit(unsigned long lit)
{
- unsigned long pw[32] = {1L,2L,4L,8L,16L,32L,64L,128L,
- 0x100L,0x200L,0x400L,0x800L,
- 0x1000L,0x2000L,0x4000L,0x8000L,
- 0x10000L,0x20000L,0x40000L,0x80000L,
- 0x100000L,0x200000L,0x400000L,0x800000L,
- 0x1000000L,0x2000000L,0x4000000L,0x8000000L,
- 0x10000000L,0x20000000L,0x40000000L,0x80000000L};
- int idx;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- for(idx = 0; idx < 32; idx++)
- if(lit == pw[idx])
- return idx+1;
- return 0;
+ unsigned long pw[32] = {1L,2L,4L,8L,16L,32L,64L,128L,
+ 0x100L,0x200L,0x400L,0x800L,
+ 0x1000L,0x2000L,0x4000L,0x8000L,
+ 0x10000L,0x20000L,0x40000L,0x80000L,
+ 0x100000L,0x200000L,0x400000L,0x800000L,
+ 0x1000000L,0x2000000L,0x4000000L,0x8000000L,
+ 0x10000000L,0x20000000L,0x40000000L,0x80000000L};
+ int idx;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ for(idx = 0; idx < 32; idx++)
+ if(lit == pw[idx])
+ return idx+1;
+ return 0;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void continueIfTrue (iCode *ic)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(IC_TRUE(ic))
- pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
- ic->generated = 1;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(IC_TRUE(ic))
+ pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
+ ic->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void jumpIfTrue (iCode *ic)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(!IC_TRUE(ic))
- pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
- ic->generated = 1;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(!IC_TRUE(ic))
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+ ic->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void jmpTrueOrFalse (iCode *ic, symbol *tlbl)
{
- // ugly but optimized by peephole
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(IC_TRUE(ic)){
- symbol *nlbl = newiTempLabel(NULL);
- pic14_emitcode("sjmp","%05d_DS_",nlbl->key+100);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
- pic14_emitcode("","%05d_DS_:",nlbl->key+100);
- }
- else{
- pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- }
- ic->generated = 1;
+ // ugly but optimized by peephole
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(IC_TRUE(ic)){
+ symbol *nlbl = newiTempLabel(NULL);
+ pic14_emitcode("sjmp","%05d_DS_",nlbl->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
+ pic14_emitcode("","%05d_DS_:",nlbl->key+100);
+ }
+ else{
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ ic->generated = 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genAnd (iCode *ic, iCode *ifx)
{
- operand *left, *right, *result;
- int size, offset=0;
- unsigned long lit = 0L;
- int bytelit = 0;
- resolvedIfx rIfx;
-
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp((left = IC_LEFT(ic)),ic,FALSE);
- aopOp((right= IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,TRUE);
-
- resolveIfx(&rIfx,ifx);
-
- /* if left is a literal & right is not then exchange them */
- if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
- AOP_NEEDSACC(left)) {
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- /* if result = right then exchange them */
- if(pic14_sameRegs(AOP(result),AOP(right))){
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- /* if right is bit then exchange them */
- if (AOP_TYPE(right) == AOP_CRY &&
- AOP_TYPE(left) != AOP_CRY){
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
- if(AOP_TYPE(right) == AOP_LIT)
- lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
-
- size = AOP_SIZE(result);
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- // if(bit & yy)
- // result = bit & yy;
- if (AOP_TYPE(left) == AOP_CRY){
- // c = bit & literal;
- if(AOP_TYPE(right) == AOP_LIT){
- if(lit & 1) {
- if(size && pic14_sameRegs(AOP(result),AOP(left)))
- // no change
- goto release;
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- } else {
- // bit(result) = 0;
- if(size && (AOP_TYPE(result) == AOP_CRY)){
- pic14_emitcode("clr","%s",AOP(result)->aopu.aop_dir);
- goto release;
- }
- if((AOP_TYPE(result) == AOP_CRY) && ifx){
- jumpIfTrue(ifx);
- goto release;
- }
- pic14_emitcode("clr","c");
- }
- } else {
- if (AOP_TYPE(right) == AOP_CRY){
- // c = bit & bit;
- pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
- pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
- } else {
- // c = bit & val;
- MOVA(aopGet(AOP(right),0,FALSE,FALSE));
- // c = lsb
- pic14_emitcode("rrc","a");
- pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
- }
- }
- // bit = c
- // val = c
- if(size)
- pic14_outBitC(result);
- // if(bit & ...)
- else if((AOP_TYPE(result) == AOP_CRY) && ifx)
- genIfxJump(ifx, "c");
- goto release ;
- }
-
- // if(val & 0xZZ) - size = 0, ifx != FALSE -
- // bit = val & 0xZZ - size = 1, ifx = FALSE -
- if((AOP_TYPE(right) == AOP_LIT) &&
- (AOP_TYPE(result) == AOP_CRY) &&
- (AOP_TYPE(left) != AOP_CRY)){
- int posbit = isLiteralBit(lit);
- /* left & 2^n */
- if(posbit){
- posbit--;
- //MOVA(aopGet(AOP(left),posbit>>3,FALSE,FALSE));
- // bit = left & 2^n
- if(size)
- pic14_emitcode("mov","c,acc.%d",posbit&0x07);
- // if(left & 2^n)
- else{
- if(ifx){
- int offset = 0;
- while (posbit > 7) {
- posbit -= 8;
- offset++;
- }
- emitpcode(((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
- newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit,0));
- emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
-
- ifx->generated = 1;
- }
- goto release;
- }
- } else {
- symbol *tlbl = newiTempLabel(NULL);
- int sizel = AOP_SIZE(left);
- if(size)
- pic14_emitcode("setb","c");
- while(sizel--){
- if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
- MOVA( aopGet(AOP(left),offset,FALSE,FALSE));
- // byte == 2^n ?
- if((posbit = isLiteralBit(bytelit)) != 0)
- pic14_emitcode("jb","acc.%d,%05d_DS_",(posbit-1)&0x07,tlbl->key+100);
- else{
- if(bytelit != 0x0FFL)
- pic14_emitcode("anl","a,%s",
- aopGet(AOP(right),offset,FALSE,TRUE));
- pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
- }
+ operand *left, *right, *result;
+ int size, offset=0;
+ unsigned long lit = 0L;
+ int bytelit = 0;
+ resolvedIfx rIfx;
+
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((right= IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ resolveIfx(&rIfx,ifx);
+
+ /* if left is a literal & right is not then exchange them */
+ if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
+ AOP_NEEDSACC(left)) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
}
- offset++;
- }
- // bit = left & literal
- if(size){
- pic14_emitcode("clr","c");
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- }
- // if(left & literal)
- else{
- if(ifx)
- jmpTrueOrFalse(ifx, tlbl);
- goto release ;
- }
- }
- pic14_outBitC(result);
- goto release ;
- }
-
- /* if left is same as result */
- if(pic14_sameRegs(AOP(result),AOP(left))){
- int know_W = -1;
- for(;size--; offset++,lit>>=8) {
- if(AOP_TYPE(right) == AOP_LIT){
- switch(lit & 0xff) {
- case 0x00:
- /* and'ing with 0 has clears the result */
- pic14_emitcode("clrf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_CLRF,popGet(AOP(result),offset));
- break;
- case 0xff:
- /* and'ing with 0xff is a nop when the result and left are the same */
- break;
-
- default:
- {
- int p = my_powof2( (~lit) & 0xff );
- if(p>=0) {
- /* only one bit is set in the literal, so use a bcf instruction */
- pic14_emitcode("bcf","%s,%d",aopGet(AOP(left),offset,FALSE,TRUE),p);
- emitpcode(POC_BCF,newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
-
- } else {
- pic14_emitcode("movlw","0x%x", (lit & 0xff));
- pic14_emitcode("andwf","%s,f",aopGet(AOP(left),offset,FALSE,TRUE));
- if(know_W != (int)(lit&0xff))
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- know_W = lit &0xff;
- emitpcode(POC_ANDWF,popGet(AOP(left),offset));
- }
- }
- }
- } else {
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_ANDFW,popGet(AOP(right),offset));
- } else {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset));
- emitpcode(POC_ANDWF,popGet(AOP(left),offset));
-
- }
- }
- }
-
- } else {
- // left & result in different registers
- if(AOP_TYPE(result) == AOP_CRY){
- // result = bit
- // if(size), result in bit
- // if(!size && ifx), conditional oper: if(left & right)
- symbol *tlbl = newiTempLabel(NULL);
- int sizer = min(AOP_SIZE(left),AOP_SIZE(right));
- if(size)
- pic14_emitcode("setb","c");
- while(sizer--){
- MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("anl","a,%s",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
- offset++;
- }
- if(size){
- CLRC;
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_outBitC(result);
- } else if(ifx)
- jmpTrueOrFalse(ifx, tlbl);
- } else {
- for(;(size--);offset++) {
- // normal case
- // result = left & right
- if(AOP_TYPE(right) == AOP_LIT){
- int t = (lit >> (offset*8)) & 0x0FFL;
- switch(t) {
- case 0x00:
- pic14_emitcode("clrf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_CLRF,popGet(AOP(result),offset));
- break;
- case 0xff:
- if(AOP_TYPE(left) != AOP_ACC) {
- pic14_emitcode("movf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- break;
- default:
- if(AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_ANDLW, popGetLit(t));
- } else {
- pic14_emitcode("movlw","0x%x",t);
- pic14_emitcode("andwf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
-
- emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_ANDFW,popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- }
- continue;
+
+ /* if result = right then exchange them */
+ if(pic14_sameRegs(AOP(result),AOP(right))){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
}
-
- if (AOP_TYPE(left) == AOP_ACC) {
- pic14_emitcode("andwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- emitpcode(POC_ANDFW,popGet(AOP(right),offset));
+
+ /* if right is bit then exchange them */
+ if (AOP_TYPE(right) == AOP_CRY &&
+ AOP_TYPE(left) != AOP_CRY){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ // if(bit & yy)
+ // result = bit & yy;
+ if (AOP_TYPE(left) == AOP_CRY){
+ // c = bit & literal;
+ if(AOP_TYPE(right) == AOP_LIT){
+ if(lit & 1) {
+ if(size && pic14_sameRegs(AOP(result),AOP(left)))
+ // no change
+ goto release;
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ } else {
+ // bit(result) = 0;
+ if(size && (AOP_TYPE(result) == AOP_CRY)){
+ pic14_emitcode("clr","%s",AOP(result)->aopu.aop_dir);
+ goto release;
+ }
+ if((AOP_TYPE(result) == AOP_CRY) && ifx){
+ jumpIfTrue(ifx);
+ goto release;
+ }
+ pic14_emitcode("clr","c");
+ }
+ } else {
+ if (AOP_TYPE(right) == AOP_CRY){
+ // c = bit & bit;
+ pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+ pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
+ } else {
+ // c = bit & val;
+ MOVA(aopGet(AOP(right),0,FALSE,FALSE));
+ // c = lsb
+ pic14_emitcode("rrc","a");
+ pic14_emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
+ }
+ }
+ // bit = c
+ // val = c
+ if(size)
+ pic14_outBitC(result);
+ // if(bit & ...)
+ else if((AOP_TYPE(result) == AOP_CRY) && ifx)
+ genIfxJump(ifx, "c");
+ goto release ;
+ }
+
+ // if(val & 0xZZ) - size = 0, ifx != FALSE -
+ // bit = val & 0xZZ - size = 1, ifx = FALSE -
+ if((AOP_TYPE(right) == AOP_LIT) &&
+ (AOP_TYPE(result) == AOP_CRY) &&
+ (AOP_TYPE(left) != AOP_CRY)){
+ int posbit = isLiteralBit(lit);
+ /* left & 2^n */
+ if(posbit){
+ posbit--;
+ //MOVA(aopGet(AOP(left),posbit>>3,FALSE,FALSE));
+ // bit = left & 2^n
+ if(size)
+ pic14_emitcode("mov","c,acc.%d",posbit&0x07);
+ // if(left & 2^n)
+ else{
+ if(ifx){
+ int offset = 0;
+ while (posbit > 7) {
+ posbit -= 8;
+ offset++;
+ }
+ emitpcode(((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
+ newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit,0));
+ emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+
+ ifx->generated = 1;
+ }
+ goto release;
+ }
+ } else {
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizel = AOP_SIZE(left);
+ if(size)
+ pic14_emitcode("setb","c");
+ while(sizel--){
+ if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
+ MOVA( aopGet(AOP(left),offset,FALSE,FALSE));
+ // byte == 2^n ?
+ if((posbit = isLiteralBit(bytelit)) != 0)
+ pic14_emitcode("jb","acc.%d,%05d_DS_",(posbit-1)&0x07,tlbl->key+100);
+ else{
+ if(bytelit != 0x0FFL)
+ pic14_emitcode("anl","a,%s",
+ aopGet(AOP(right),offset,FALSE,TRUE));
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ }
+ }
+ offset++;
+ }
+ // bit = left & literal
+ if(size){
+ pic14_emitcode("clr","c");
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ // if(left & literal)
+ else{
+ if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ goto release ;
+ }
+ }
+ pic14_outBitC(result);
+ goto release ;
+ }
+
+ /* if left is same as result */
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ int know_W = -1;
+ for(;size--; offset++,lit>>=8) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ switch(lit & 0xff) {
+ case 0x00:
+ /* and'ing with 0 has clears the result */
+ pic14_emitcode("clrf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
+ break;
+ case 0xff:
+ /* and'ing with 0xff is a nop when the result and left are the same */
+ break;
+
+ default:
+ {
+ int p = my_powof2( (~lit) & 0xff );
+ if(p>=0) {
+ /* only one bit is set in the literal, so use a bcf instruction */
+ pic14_emitcode("bcf","%s,%d",aopGet(AOP(left),offset,FALSE,TRUE),p);
+ emitpcode(POC_BCF,newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
+
+ } else {
+ pic14_emitcode("movlw","0x%x", (lit & 0xff));
+ pic14_emitcode("andwf","%s,f",aopGet(AOP(left),offset,FALSE,TRUE));
+ if(know_W != (int)(lit&0xff))
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ know_W = lit &0xff;
+ emitpcode(POC_ANDWF,popGet(AOP(left),offset));
+ }
+ }
+ }
+ } else {
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_ANDFW,popGet(AOP(right),offset));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_ANDWF,popGet(AOP(left),offset));
+
+ }
+ }
+ }
+
} else {
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("andwf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- emitpcode(POC_MOVFW,popGet(AOP(right),offset));
- emitpcode(POC_ANDFW,popGet(AOP(left),offset));
- }
- pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- }
- }
- }
-
- release :
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ // left & result in different registers
+ if(AOP_TYPE(result) == AOP_CRY){
+ // result = bit
+ // if(size), result in bit
+ // if(!size && ifx), conditional oper: if(left & right)
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizer = min(AOP_SIZE(left),AOP_SIZE(right));
+ if(size)
+ pic14_emitcode("setb","c");
+ while(sizer--){
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("anl","a,%s",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ offset++;
+ }
+ if(size){
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(result);
+ } else if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ } else {
+ for(;(size--);offset++) {
+ // normal case
+ // result = left & right
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ switch(t) {
+ case 0x00:
+ pic14_emitcode("clrf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
+ break;
+ case 0xff:
+ if(AOP_TYPE(left) != AOP_ACC) {
+ pic14_emitcode("movf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ break;
+ default:
+ if(AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_ANDLW, popGetLit(t));
+ } else {
+ pic14_emitcode("movlw","0x%x",t);
+ pic14_emitcode("andwf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ }
+ continue;
+ }
+
+ if (AOP_TYPE(left) == AOP_ACC) {
+ pic14_emitcode("andwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ emitpcode(POC_ANDFW,popGet(AOP(right),offset));
+ } else {
+ pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("andwf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+ }
+ pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ }
+ }
+ }
+
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genOr (iCode *ic, iCode *ifx)
{
- operand *left, *right, *result;
- int size, offset=0;
- unsigned long lit = 0L;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp((left = IC_LEFT(ic)),ic,FALSE);
- aopOp((right= IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- /* if left is a literal & right is not then exchange them */
- if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
- AOP_NEEDSACC(left)) {
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- /* if result = right then exchange them */
- if(pic14_sameRegs(AOP(result),AOP(right))){
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- /* if right is bit then exchange them */
- if (AOP_TYPE(right) == AOP_CRY &&
- AOP_TYPE(left) != AOP_CRY){
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- if(AOP_TYPE(right) == AOP_LIT)
- lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
-
- size = AOP_SIZE(result);
-
- // if(bit | yy)
- // xx = bit | yy;
- if (AOP_TYPE(left) == AOP_CRY){
- if(AOP_TYPE(right) == AOP_LIT){
- // c = bit & literal;
- if(lit){
- // lit != 0 => result = 1
- if(AOP_TYPE(result) == AOP_CRY){
- if(size)
- emitpcode(POC_BSF, popGet(AOP(result),0));
- //pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
- // AOP(result)->aopu.aop_dir,
- // AOP(result)->aopu.aop_dir);
- else if(ifx)
- continueIfTrue(ifx);
- goto release;
- }
- } else {
- // lit == 0 => result = left
- if(size && pic14_sameRegs(AOP(result),AOP(left)))
- goto release;
- pic14_emitcode(";XXX mov","c,%s %s,%d",AOP(left)->aopu.aop_dir,__FILE__,__LINE__);
- }
- } else {
- if (AOP_TYPE(right) == AOP_CRY){
- if(pic14_sameRegs(AOP(result),AOP(left))){
- // c = bit | bit;
- emitpcode(POC_BCF, popGet(AOP(result),0));
- emitpcode(POC_BTFSC, popGet(AOP(right),0));
- emitpcode(POC_BSF, popGet(AOP(result),0));
-
- pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- } else {
- if( AOP_TYPE(result) == AOP_ACC) {
- emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSS, popGet(AOP(right),0));
- emitpcode(POC_BTFSC, popGet(AOP(left),0));
- emitpcode(POC_MOVLW, popGetLit(1));
-
+ operand *left, *right, *result;
+ int size, offset=0;
+ unsigned long lit = 0L;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((right= IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ /* if left is a literal & right is not then exchange them */
+ if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
+ AOP_NEEDSACC(left)) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if result = right then exchange them */
+ if(pic14_sameRegs(AOP(result),AOP(right))){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if right is bit then exchange them */
+ if (AOP_TYPE(right) == AOP_CRY &&
+ AOP_TYPE(left) != AOP_CRY){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ // if(bit | yy)
+ // xx = bit | yy;
+ if (AOP_TYPE(left) == AOP_CRY){
+ if(AOP_TYPE(right) == AOP_LIT){
+ // c = bit & literal;
+ if(lit){
+ // lit != 0 => result = 1
+ if(AOP_TYPE(result) == AOP_CRY){
+ if(size)
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ //pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ // AOP(result)->aopu.aop_dir,
+ // AOP(result)->aopu.aop_dir);
+ else if(ifx)
+ continueIfTrue(ifx);
+ goto release;
+ }
+ } else {
+ // lit == 0 => result = left
+ if(size && pic14_sameRegs(AOP(result),AOP(left)))
+ goto release;
+ pic14_emitcode(";XXX mov","c,%s %s,%d",AOP(left)->aopu.aop_dir,__FILE__,__LINE__);
+ }
} else {
-
- emitpcode(POC_BCF, popGet(AOP(result),0));
- emitpcode(POC_BTFSS, popGet(AOP(right),0));
- emitpcode(POC_BTFSC, popGet(AOP(left),0));
- emitpcode(POC_BSF, popGet(AOP(result),0));
-
- pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(left)->aopu.aop_dir,
- AOP(left)->aopu.aop_dir);
- pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- }
- }
- } else {
- // c = bit | val;
- symbol *tlbl = newiTempLabel(NULL);
- pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
-
-
- emitpcode(POC_BCF, popGet(AOP(result),0));
- if( AOP_TYPE(right) == AOP_ACC) {
- emitpcode(POC_IORLW, popGetLit(0));
- emitSKPNZ;
- emitpcode(POC_BTFSC, popGet(AOP(left),0));
- emitpcode(POC_BSF, popGet(AOP(result),0));
- }
-
-
-
- if(!((AOP_TYPE(result) == AOP_CRY) && ifx))
- pic14_emitcode(";XXX setb","c");
- pic14_emitcode(";XXX jb","%s,%05d_DS_",
- AOP(left)->aopu.aop_dir,tlbl->key+100);
- pic14_toBoolean(right);
- pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
- if((AOP_TYPE(result) == AOP_CRY) && ifx){
- jmpTrueOrFalse(ifx, tlbl);
- goto release;
- } else {
- CLRC;
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- }
- }
- }
- // bit = c
- // val = c
- if(size)
- pic14_outBitC(result);
- // if(bit | ...)
- else if((AOP_TYPE(result) == AOP_CRY) && ifx)
- genIfxJump(ifx, "c");
- goto release ;
- }
-
- // if(val | 0xZZ) - size = 0, ifx != FALSE -
- // bit = val | 0xZZ - size = 1, ifx = FALSE -
- if((AOP_TYPE(right) == AOP_LIT) &&
- (AOP_TYPE(result) == AOP_CRY) &&
- (AOP_TYPE(left) != AOP_CRY)){
- if(lit){
- pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
- // result = 1
- if(size)
- pic14_emitcode(";XXX setb","%s",AOP(result)->aopu.aop_dir);
- else
- continueIfTrue(ifx);
- goto release;
- } else {
- pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
- // lit = 0, result = boolean(left)
- if(size)
- pic14_emitcode(";XXX setb","c");
- pic14_toBoolean(right);
- if(size){
- symbol *tlbl = newiTempLabel(NULL);
- pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
- CLRC;
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- } else {
- genIfxJump (ifx,"a");
- goto release;
- }
- }
- pic14_outBitC(result);
- goto release ;
- }
-
- /* if left is same as result */
- if(pic14_sameRegs(AOP(result),AOP(left))){
- int know_W = -1;
- for(;size--; offset++,lit>>=8) {
- if(AOP_TYPE(right) == AOP_LIT){
- if((lit & 0xff) == 0)
- /* or'ing with 0 has no effect */
- continue;
- else {
- int p = my_powof2(lit & 0xff);
- if(p>=0) {
- /* only one bit is set in the literal, so use a bsf instruction */
- emitpcode(POC_BSF,
- newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
- } else {
- if(know_W != (int)(lit & 0xff))
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- know_W = lit & 0xff;
- emitpcode(POC_IORWF, popGet(AOP(left),offset));
- }
-
- }
- } else {
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_IORFW, popGet(AOP(right),offset));
- pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- emitpcode(POC_IORWF, popGet(AOP(left),offset));
-
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("iorwf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
-
- }
+ if (AOP_TYPE(right) == AOP_CRY){
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ // c = bit | bit;
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ } else {
+ if( AOP_TYPE(result) == AOP_ACC) {
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_MOVLW, popGetLit(1));
+
+ } else {
+
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ pic14_emitcode("btfss","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(left)->aopu.aop_dir,
+ AOP(left)->aopu.aop_dir);
+ pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ }
+ }
+ } else {
+ // c = bit | val;
+ symbol *tlbl = newiTempLabel(NULL);
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+
+
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ if( AOP_TYPE(right) == AOP_ACC) {
+ emitpcode(POC_IORLW, popGetLit(0));
+ emitSKPNZ;
+ emitpcode(POC_BTFSC, popGet(AOP(left),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ }
+
+
+
+ if(!((AOP_TYPE(result) == AOP_CRY) && ifx))
+ pic14_emitcode(";XXX setb","c");
+ pic14_emitcode(";XXX jb","%s,%05d_DS_",
+ AOP(left)->aopu.aop_dir,tlbl->key+100);
+ pic14_toBoolean(right);
+ pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
+ if((AOP_TYPE(result) == AOP_CRY) && ifx){
+ jmpTrueOrFalse(ifx, tlbl);
+ goto release;
+ } else {
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ }
+ }
+ // bit = c
+ // val = c
+ if(size)
+ pic14_outBitC(result);
+ // if(bit | ...)
+ else if((AOP_TYPE(result) == AOP_CRY) && ifx)
+ genIfxJump(ifx, "c");
+ goto release ;
}
- }
- } else {
- // left & result in different registers
- if(AOP_TYPE(result) == AOP_CRY){
- // result = bit
- // if(size), result in bit
- // if(!size && ifx), conditional oper: if(left | right)
- symbol *tlbl = newiTempLabel(NULL);
- int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
- pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
-
-
- if(size)
- pic14_emitcode(";XXX setb","c");
- while(sizer--){
- MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode(";XXX orl","a,%s",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
- offset++;
- }
- if(size){
- CLRC;
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_outBitC(result);
- } else if(ifx)
- jmpTrueOrFalse(ifx, tlbl);
- } else for(;(size--);offset++){
- // normal case
- // result = left & right
- if(AOP_TYPE(right) == AOP_LIT){
- int t = (lit >> (offset*8)) & 0x0FFL;
- switch(t) {
- case 0x00:
- if (AOP_TYPE(left) != AOP_ACC) {
- emitpcode(POC_MOVFW, popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
-
- break;
- default:
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_IORLW, popGetLit(t));
- } else {
- emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_IORFW, popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- }
- continue;
- }
-
- // faster than result <- left, anl result,right
- // and better if result is SFR
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_IORWF, popGet(AOP(right),offset));
- pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- emitpcode(POC_IORFW, popGet(AOP(left),offset));
-
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("iorwf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- }
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
+
+ // if(val | 0xZZ) - size = 0, ifx != FALSE -
+ // bit = val | 0xZZ - size = 1, ifx = FALSE -
+ if((AOP_TYPE(right) == AOP_LIT) &&
+ (AOP_TYPE(result) == AOP_CRY) &&
+ (AOP_TYPE(left) != AOP_CRY)){
+ if(lit){
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+ // result = 1
+ if(size)
+ pic14_emitcode(";XXX setb","%s",AOP(result)->aopu.aop_dir);
+ else
+ continueIfTrue(ifx);
+ goto release;
+ } else {
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+ // lit = 0, result = boolean(left)
+ if(size)
+ pic14_emitcode(";XXX setb","c");
+ pic14_toBoolean(right);
+ if(size){
+ symbol *tlbl = newiTempLabel(NULL);
+ pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ } else {
+ genIfxJump (ifx,"a");
+ goto release;
+ }
+ }
+ pic14_outBitC(result);
+ goto release ;
}
- }
-
+
+ /* if left is same as result */
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ int know_W = -1;
+ for(;size--; offset++,lit>>=8) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ if((lit & 0xff) == 0)
+ /* or'ing with 0 has no effect */
+ continue;
+ else {
+ int p = my_powof2(lit & 0xff);
+ if(p>=0) {
+ /* only one bit is set in the literal, so use a bsf instruction */
+ emitpcode(POC_BSF,
+ newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),p,0));
+ } else {
+ if(know_W != (int)(lit & 0xff))
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ know_W = lit & 0xff;
+ emitpcode(POC_IORWF, popGet(AOP(left),offset));
+ }
+
+ }
+ } else {
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORFW, popGet(AOP(right),offset));
+ pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_IORWF, popGet(AOP(left),offset));
+
+ pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("iorwf","%s,f",aopGet(AOP(left),offset,FALSE,FALSE));
+
+ }
+ }
+ }
+ } else {
+ // left & result in different registers
+ if(AOP_TYPE(result) == AOP_CRY){
+ // result = bit
+ // if(size), result in bit
+ // if(!size && ifx), conditional oper: if(left | right)
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
+ pic14_emitcode(";XXX "," %s,%d",__FILE__,__LINE__);
+
+
+ if(size)
+ pic14_emitcode(";XXX setb","c");
+ while(sizer--){
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode(";XXX orl","a,%s",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode(";XXX jnz","%05d_DS_",tlbl->key+100);
+ offset++;
+ }
+ if(size){
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(result);
+ } else if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ } else for(;(size--);offset++){
+ // normal case
+ // result = left & right
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ switch(t) {
+ case 0x00:
+ if (AOP_TYPE(left) != AOP_ACC) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+ break;
+ default:
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_IORFW, popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+ continue;
+ }
+
+ // faster than result <- left, anl result,right
+ // and better if result is SFR
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_IORWF, popGet(AOP(right),offset));
+ pic14_emitcode("iorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_IORFW, popGet(AOP(left),offset));
+
+ pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("iorwf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ }
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
+ }
+ }
+
release :
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genXor (iCode *ic, iCode *ifx)
{
- operand *left, *right, *result;
- int size, offset=0;
- unsigned long lit = 0L;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp((left = IC_LEFT(ic)),ic,FALSE);
- aopOp((right= IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,TRUE);
-
- /* if left is a literal & right is not ||
- if left needs acc & right does not */
- if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
- (AOP_NEEDSACC(left) && !AOP_NEEDSACC(right))) {
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- /* if result = right then exchange them */
- if(pic14_sameRegs(AOP(result),AOP(right))){
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
-
- /* if right is bit then exchange them */
- if (AOP_TYPE(right) == AOP_CRY &&
- AOP_TYPE(left) != AOP_CRY){
- operand *tmp = right ;
- right = left;
- left = tmp;
- }
- if(AOP_TYPE(right) == AOP_LIT)
- lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
-
- size = AOP_SIZE(result);
-
- // if(bit ^ yy)
- // xx = bit ^ yy;
- if (AOP_TYPE(left) == AOP_CRY){
- if(AOP_TYPE(right) == AOP_LIT){
- // c = bit & literal;
- if(lit>>1){
- // lit>>1 != 0 => result = 1
- if(AOP_TYPE(result) == AOP_CRY){
- if(size)
- {emitpcode(POC_BSF, popGet(AOP(result),offset));
- pic14_emitcode("setb","%s",AOP(result)->aopu.aop_dir);}
- else if(ifx)
- continueIfTrue(ifx);
- goto release;
- }
- pic14_emitcode("setb","c");
- } else{
- // lit == (0 or 1)
- if(lit == 0){
- // lit == 0, result = left
- if(size && pic14_sameRegs(AOP(result),AOP(left)))
- goto release;
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- } else{
- // lit == 1, result = not(left)
- if(size && pic14_sameRegs(AOP(result),AOP(left))){
- emitpcode(POC_MOVLW, popGet(AOP(result),offset));
- emitpcode(POC_XORWF, popGet(AOP(result),offset));
- pic14_emitcode("cpl","%s",AOP(result)->aopu.aop_dir);
- goto release;
- } else {
- pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
- pic14_emitcode("cpl","c");
- }
+ operand *left, *right, *result;
+ int size, offset=0;
+ unsigned long lit = 0L;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp((left = IC_LEFT(ic)),ic,FALSE);
+ aopOp((right= IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+
+ /* if left is a literal & right is not ||
+ if left needs acc & right does not */
+ if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
+ (AOP_NEEDSACC(left) && !AOP_NEEDSACC(right))) {
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
}
- }
-
- } else {
- // right != literal
- symbol *tlbl = newiTempLabel(NULL);
- if (AOP_TYPE(right) == AOP_CRY){
- // c = bit ^ bit;
- pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
- }
- else{
- int sizer = AOP_SIZE(right);
- // c = bit ^ val
- // if val>>1 != 0, result = 1
- pic14_emitcode("setb","c");
- while(sizer){
- MOVA(aopGet(AOP(right),sizer-1,FALSE,FALSE));
- if(sizer == 1)
- // test the msb of the lsb
- pic14_emitcode("anl","a,#0xfe");
- pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
- sizer--;
- }
- // val = (0,1)
- pic14_emitcode("rrc","a");
- }
- pic14_emitcode("jnb","%s,%05d_DS_",AOP(left)->aopu.aop_dir,(tlbl->key+100));
- pic14_emitcode("cpl","c");
- pic14_emitcode("","%05d_DS_:",(tlbl->key+100));
- }
- // bit = c
- // val = c
- if(size)
- pic14_outBitC(result);
- // if(bit | ...)
- else if((AOP_TYPE(result) == AOP_CRY) && ifx)
- genIfxJump(ifx, "c");
- goto release ;
- }
-
- if(pic14_sameRegs(AOP(result),AOP(left))){
- /* if left is same as result */
- for(;size--; offset++) {
- if(AOP_TYPE(right) == AOP_LIT){
- int t = (lit >> (offset*8)) & 0x0FFL;
- if(t == 0x00L)
- continue;
- else
- if (IS_AOP_PREG(left)) {
- MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
- aopPut(AOP(result),"a",offset);
- } else {
- emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_XORWF,popGet(AOP(left),offset));
- pic14_emitcode("xrl","%s,%s",
- aopGet(AOP(left),offset,FALSE,TRUE),
- aopGet(AOP(right),offset,FALSE,FALSE));
- }
- } else {
- if (AOP_TYPE(left) == AOP_ACC)
- pic14_emitcode("xrl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE));
- else {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset));
- emitpcode(POC_XORWF,popGet(AOP(left),offset));
-/*
- if (IS_AOP_PREG(left)) {
- pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
- aopPut(AOP(result),"a",offset);
- } else
- pic14_emitcode("xrl","%s,a",
- aopGet(AOP(left),offset,FALSE,TRUE));
-*/
+
+ /* if result = right then exchange them */
+ if(pic14_sameRegs(AOP(result),AOP(right))){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+
+ /* if right is bit then exchange them */
+ if (AOP_TYPE(right) == AOP_CRY &&
+ AOP_TYPE(left) != AOP_CRY){
+ operand *tmp = right ;
+ right = left;
+ left = tmp;
+ }
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
+
+ size = AOP_SIZE(result);
+
+ // if(bit ^ yy)
+ // xx = bit ^ yy;
+ if (AOP_TYPE(left) == AOP_CRY){
+ if(AOP_TYPE(right) == AOP_LIT){
+ // c = bit & literal;
+ if(lit>>1){
+ // lit>>1 != 0 => result = 1
+ if(AOP_TYPE(result) == AOP_CRY){
+ if(size)
+ {emitpcode(POC_BSF, popGet(AOP(result),offset));
+ pic14_emitcode("setb","%s",AOP(result)->aopu.aop_dir);}
+ else if(ifx)
+ continueIfTrue(ifx);
+ goto release;
+ }
+ pic14_emitcode("setb","c");
+ } else{
+ // lit == (0 or 1)
+ if(lit == 0){
+ // lit == 0, result = left
+ if(size && pic14_sameRegs(AOP(result),AOP(left)))
+ goto release;
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ } else{
+ // lit == 1, result = not(left)
+ if(size && pic14_sameRegs(AOP(result),AOP(left))){
+ emitpcode(POC_MOVLW, popGet(AOP(result),offset));
+ emitpcode(POC_XORWF, popGet(AOP(result),offset));
+ pic14_emitcode("cpl","%s",AOP(result)->aopu.aop_dir);
+ goto release;
+ } else {
+ pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
+ pic14_emitcode("cpl","c");
+ }
+ }
+ }
+
+ } else {
+ // right != literal
+ symbol *tlbl = newiTempLabel(NULL);
+ if (AOP_TYPE(right) == AOP_CRY){
+ // c = bit ^ bit;
+ pic14_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+ }
+ else{
+ int sizer = AOP_SIZE(right);
+ // c = bit ^ val
+ // if val>>1 != 0, result = 1
+ pic14_emitcode("setb","c");
+ while(sizer){
+ MOVA(aopGet(AOP(right),sizer-1,FALSE,FALSE));
+ if(sizer == 1)
+ // test the msb of the lsb
+ pic14_emitcode("anl","a,#0xfe");
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ sizer--;
+ }
+ // val = (0,1)
+ pic14_emitcode("rrc","a");
+ }
+ pic14_emitcode("jnb","%s,%05d_DS_",AOP(left)->aopu.aop_dir,(tlbl->key+100));
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",(tlbl->key+100));
+ }
+ // bit = c
+ // val = c
+ if(size)
+ pic14_outBitC(result);
+ // if(bit | ...)
+ else if((AOP_TYPE(result) == AOP_CRY) && ifx)
+ genIfxJump(ifx, "c");
+ goto release ;
+ }
+
+ if(pic14_sameRegs(AOP(result),AOP(left))){
+ /* if left is same as result */
+ for(;size--; offset++) {
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ if(t == 0x00L)
+ continue;
+ else
+ if (IS_AOP_PREG(left)) {
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
+ aopPut(AOP(result),"a",offset);
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_XORWF,popGet(AOP(left),offset));
+ pic14_emitcode("xrl","%s,%s",
+ aopGet(AOP(left),offset,FALSE,TRUE),
+ aopGet(AOP(right),offset,FALSE,FALSE));
+ }
+ } else {
+ if (AOP_TYPE(left) == AOP_ACC)
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE));
+ else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_XORWF,popGet(AOP(left),offset));
+ /*
+ if (IS_AOP_PREG(left)) {
+ pic14_emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE));
+ aopPut(AOP(result),"a",offset);
+ } else
+ pic14_emitcode("xrl","%s,a",
+ aopGet(AOP(left),offset,FALSE,TRUE));
+ */
+ }
+ }
+ }
+ } else {
+ // left & result in different registers
+ if(AOP_TYPE(result) == AOP_CRY){
+ // result = bit
+ // if(size), result in bit
+ // if(!size && ifx), conditional oper: if(left ^ right)
+ symbol *tlbl = newiTempLabel(NULL);
+ int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
+ if(size)
+ pic14_emitcode("setb","c");
+ while(sizer--){
+ if((AOP_TYPE(right) == AOP_LIT) &&
+ (((lit >> (offset*8)) & 0x0FFL) == 0x00L)){
+ MOVA(aopGet(AOP(left),offset,FALSE,FALSE));
+ } else {
+ MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("xrl","a,%s",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ }
+ pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
+ offset++;
+ }
+ if(size){
+ CLRC;
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outBitC(result);
+ } else if(ifx)
+ jmpTrueOrFalse(ifx, tlbl);
+ } else for(;(size--);offset++){
+ // normal case
+ // result = left & right
+ if(AOP_TYPE(right) == AOP_LIT){
+ int t = (lit >> (offset*8)) & 0x0FFL;
+ switch(t) {
+ case 0x00:
+ if (AOP_TYPE(left) != AOP_ACC) {
+ emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ pic14_emitcode("movf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+ break;
+ case 0xff:
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_COMFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ break;
+ default:
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORLW, popGetLit(t));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(t));
+ emitpcode(POC_XORFW,popGet(AOP(left),offset));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ pic14_emitcode("movlw","0x%x",t);
+ pic14_emitcode("xorwf","%s,w",
+ aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",
+ aopGet(AOP(result),offset,FALSE,FALSE));
+
+ }
+ continue;
+ }
+
+ // faster than result <- left, anl result,right
+ // and better if result is SFR
+ if (AOP_TYPE(left) == AOP_ACC) {
+ emitpcode(POC_XORFW,popGet(AOP(right),offset));
+ pic14_emitcode("xorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ } else {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset));
+ emitpcode(POC_XORFW,popGet(AOP(left),offset));
+ pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("xorwf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
+ }
+ if ( AOP_TYPE(result) != AOP_ACC){
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+ pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
+ }
+ }
}
- }
- }
- } else {
- // left & result in different registers
- if(AOP_TYPE(result) == AOP_CRY){
- // result = bit
- // if(size), result in bit
- // if(!size && ifx), conditional oper: if(left ^ right)
- symbol *tlbl = newiTempLabel(NULL);
- int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
- if(size)
- pic14_emitcode("setb","c");
- while(sizer--){
- if((AOP_TYPE(right) == AOP_LIT) &&
- (((lit >> (offset*8)) & 0x0FFL) == 0x00L)){
- MOVA(aopGet(AOP(left),offset,FALSE,FALSE));
- } else {
- MOVA(aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("xrl","a,%s",
- aopGet(AOP(left),offset,FALSE,FALSE));
- }
- pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
- offset++;
- }
- if(size){
- CLRC;
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_outBitC(result);
- } else if(ifx)
- jmpTrueOrFalse(ifx, tlbl);
- } else for(;(size--);offset++){
- // normal case
- // result = left & right
- if(AOP_TYPE(right) == AOP_LIT){
- int t = (lit >> (offset*8)) & 0x0FFL;
- switch(t) {
- case 0x00:
- if (AOP_TYPE(left) != AOP_ACC) {
- emitpcode(POC_MOVFW,popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- pic14_emitcode("movf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
- break;
- case 0xff:
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_XORLW, popGetLit(t));
- } else {
- emitpcode(POC_COMFW,popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- break;
- default:
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_XORLW, popGetLit(t));
- } else {
- emitpcode(POC_MOVLW, popGetLit(t));
- emitpcode(POC_XORFW,popGet(AOP(left),offset));
- }
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- pic14_emitcode("movlw","0x%x",t);
- pic14_emitcode("xorwf","%s,w",
- aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",
- aopGet(AOP(result),offset,FALSE,FALSE));
-
- }
- continue;
- }
-
- // faster than result <- left, anl result,right
- // and better if result is SFR
- if (AOP_TYPE(left) == AOP_ACC) {
- emitpcode(POC_XORFW,popGet(AOP(right),offset));
- pic14_emitcode("xorwf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- } else {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset));
- emitpcode(POC_XORFW,popGet(AOP(left),offset));
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("xorwf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));
- }
- if ( AOP_TYPE(result) != AOP_ACC){
- emitpcode(POC_MOVWF,popGet(AOP(result),offset));
- pic14_emitcode("movwf","%s",aopGet(AOP(result),offset,FALSE,FALSE));
- }
- }
- }
-
- release :
- freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(result,NULL,ic,TRUE);
+
+release :
+ freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genInline (iCode *ic)
{
- char *buffer, *bp, *bp1;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- _G.inLine += (!options.asmpeep);
-
- buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
- strcpy(buffer,IC_INLINE(ic));
-
- /* emit each line as a code */
- while (*bp) {
- if (*bp == '\n') {
- *bp++ = '\0';
-
- if(*bp1)
- addpCode2pBlock(pb,AssembleLine(bp1));
- bp1 = bp;
- } else {
- if (*bp == ':') {
- bp++;
- *bp = '\0';
- bp++;
- pic14_emitcode(bp1,"");
- bp1 = bp;
- } else
- bp++;
- }
- }
- if ((bp1 != bp) && *bp1)
- addpCode2pBlock(pb,AssembleLine(bp1));
-
- Safe_free(buffer);
-
- _G.inLine -= (!options.asmpeep);
+ char *buffer, *bp, *bp1;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ _G.inLine += (!options.asmpeep);
+
+ buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
+ strcpy(buffer,IC_INLINE(ic));
+
+ /* emit each line as a code */
+ while (*bp) {
+ if (*bp == '\n') {
+ *bp++ = '\0';
+
+ if(*bp1)
+ addpCode2pBlock(pb,AssembleLine(bp1));
+ bp1 = bp;
+ } else {
+ if (*bp == ':') {
+ bp++;
+ *bp = '\0';
+ bp++;
+ pic14_emitcode(bp1,"");
+ bp1 = bp;
+ } else
+ bp++;
+ }
+ }
+ if ((bp1 != bp) && *bp1)
+ addpCode2pBlock(pb,AssembleLine(bp1));
+
+ Safe_free(buffer);
+
+ _G.inLine -= (!options.asmpeep);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genRRC (iCode *ic)
{
- operand *left , *result ;
- int size, offset = 0, same;
-
- /* rotate right with carry */
- left = IC_LEFT(ic);
- result=IC_RESULT(ic);
- aopOp (left,ic,FALSE);
- aopOp (result,ic,FALSE);
-
- DEBUGpic14_AopType(__LINE__,left,NULL,result);
-
- same = pic14_sameRegs(AOP(result),AOP(left));
-
- size = AOP_SIZE(result);
-
- /* get the lsb and put it into the carry */
- emitpcode(POC_RRFW, popGet(AOP(left),size-1));
-
- offset = 0 ;
-
- while(size--) {
-
- if(same) {
- emitpcode(POC_RRF, popGet(AOP(left),offset));
- } else {
- emitpcode(POC_RRFW, popGet(AOP(left),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- }
-
- offset++;
- }
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left , *result ;
+ int size, offset = 0, same;
+
+ /* rotate right with carry */
+ left = IC_LEFT(ic);
+ result=IC_RESULT(ic);
+ aopOp (left,ic,FALSE);
+ aopOp (result,ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ same = pic14_sameRegs(AOP(result),AOP(left));
+
+ size = AOP_SIZE(result);
+
+ /* get the lsb and put it into the carry */
+ emitpcode(POC_RRFW, popGet(AOP(left),size-1));
+
+ offset = 0 ;
+
+ while(size--) {
+
+ if(same) {
+ emitpcode(POC_RRF, popGet(AOP(left),offset));
+ } else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+
+ offset++;
+ }
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genRLC (iCode *ic)
{
- operand *left , *result ;
- int size, offset = 0;
- int same;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* rotate right with carry */
- left = IC_LEFT(ic);
- result=IC_RESULT(ic);
- aopOp (left,ic,FALSE);
- aopOp (result,ic,FALSE);
-
- DEBUGpic14_AopType(__LINE__,left,NULL,result);
-
- same = pic14_sameRegs(AOP(result),AOP(left));
-
- /* move it to the result */
- size = AOP_SIZE(result);
-
- /* get the msb and put it into the carry */
- emitpcode(POC_RLFW, popGet(AOP(left),size-1));
-
- offset = 0 ;
-
- while(size--) {
-
- if(same) {
- emitpcode(POC_RLF, popGet(AOP(left),offset));
- } else {
- emitpcode(POC_RLFW, popGet(AOP(left),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- }
-
- offset++;
- }
-
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left , *result ;
+ int size, offset = 0;
+ int same;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* rotate right with carry */
+ left = IC_LEFT(ic);
+ result=IC_RESULT(ic);
+ aopOp (left,ic,FALSE);
+ aopOp (result,ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ same = pic14_sameRegs(AOP(result),AOP(left));
+
+ /* move it to the result */
+ size = AOP_SIZE(result);
+
+ /* get the msb and put it into the carry */
+ emitpcode(POC_RLFW, popGet(AOP(left),size-1));
+
+ offset = 0 ;
+
+ while(size--) {
+
+ if(same) {
+ emitpcode(POC_RLF, popGet(AOP(left),offset));
+ } else {
+ emitpcode(POC_RLFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+
+ offset++;
+ }
+
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genGetHbit (iCode *ic)
{
- operand *left, *result;
- left = IC_LEFT(ic);
- result=IC_RESULT(ic);
- aopOp (left,ic,FALSE);
- aopOp (result,ic,FALSE);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* get the highest order byte into a */
- MOVA(aopGet(AOP(left),AOP_SIZE(left) - 1,FALSE,FALSE));
- if(AOP_TYPE(result) == AOP_CRY){
- pic14_emitcode("rlc","a");
- pic14_outBitC(result);
- }
- else{
- pic14_emitcode("rl","a");
- pic14_emitcode("anl","a,#0x01");
- pic14_outAcc(result);
- }
-
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left, *result;
+ left = IC_LEFT(ic);
+ result=IC_RESULT(ic);
+ aopOp (left,ic,FALSE);
+ aopOp (result,ic,FALSE);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* get the highest order byte into a */
+ MOVA(aopGet(AOP(left),AOP_SIZE(left) - 1,FALSE,FALSE));
+ if(AOP_TYPE(result) == AOP_CRY){
+ pic14_emitcode("rlc","a");
+ pic14_outBitC(result);
+ }
+ else{
+ pic14_emitcode("rl","a");
+ pic14_emitcode("anl","a,#0x01");
+ pic14_outAcc(result);
+ }
+
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void AccRol (int shCount)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- shCount &= 0x0007; // shCount : 0..7
- switch(shCount){
- case 0 :
- break;
- case 1 :
- pic14_emitcode("rl","a");
- break;
- case 2 :
- pic14_emitcode("rl","a");
- pic14_emitcode("rl","a");
- break;
- case 3 :
- pic14_emitcode("swap","a");
- pic14_emitcode("rr","a");
- break;
- case 4 :
- pic14_emitcode("swap","a");
- break;
- case 5 :
- pic14_emitcode("swap","a");
- pic14_emitcode("rl","a");
- break;
- case 6 :
- pic14_emitcode("rr","a");
- pic14_emitcode("rr","a");
- break;
- case 7 :
- pic14_emitcode("rr","a");
- break;
- }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shCount &= 0x0007; // shCount : 0..7
+ switch(shCount){
+ case 0 :
+ break;
+ case 1 :
+ pic14_emitcode("rl","a");
+ break;
+ case 2 :
+ pic14_emitcode("rl","a");
+ pic14_emitcode("rl","a");
+ break;
+ case 3 :
+ pic14_emitcode("swap","a");
+ pic14_emitcode("rr","a");
+ break;
+ case 4 :
+ pic14_emitcode("swap","a");
+ break;
+ case 5 :
+ pic14_emitcode("swap","a");
+ pic14_emitcode("rl","a");
+ break;
+ case 6 :
+ pic14_emitcode("rr","a");
+ pic14_emitcode("rr","a");
+ break;
+ case 7 :
+ pic14_emitcode("rr","a");
+ break;
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void AccLsh (int shCount)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(shCount != 0){
- if(shCount == 1)
- pic14_emitcode("add","a,acc");
- else
- if(shCount == 2) {
- pic14_emitcode("add","a,acc");
- pic14_emitcode("add","a,acc");
- } else {
- /* rotate left accumulator */
- AccRol(shCount);
- /* and kill the lower order bits */
- pic14_emitcode("anl","a,#0x%02x", SLMask[shCount]);
- }
- }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(shCount != 0){
+ if(shCount == 1)
+ pic14_emitcode("add","a,acc");
+ else
+ if(shCount == 2) {
+ pic14_emitcode("add","a,acc");
+ pic14_emitcode("add","a,acc");
+ } else {
+ /* rotate left accumulator */
+ AccRol(shCount);
+ /* and kill the lower order bits */
+ pic14_emitcode("anl","a,#0x%02x", SLMask[shCount]);
+ }
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void AccRsh (int shCount)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(shCount != 0){
- if(shCount == 1){
- CLRC;
- pic14_emitcode("rrc","a");
- } else {
- /* rotate right accumulator */
- AccRol(8 - shCount);
- /* and kill the higher order bits */
- pic14_emitcode("anl","a,#0x%02x", SRMask[shCount]);
- }
- }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(shCount != 0){
+ if(shCount == 1){
+ CLRC;
+ pic14_emitcode("rrc","a");
+ } else {
+ /* rotate right accumulator */
+ AccRol(8 - shCount);
+ /* and kill the higher order bits */
+ pic14_emitcode("anl","a,#0x%02x", SRMask[shCount]);
+ }
+ }
}
#if 0
/*-----------------------------------------------------------------*/
static void AccSRsh (int shCount)
{
- symbol *tlbl ;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(shCount != 0){
- if(shCount == 1){
- pic14_emitcode("mov","c,acc.7");
- pic14_emitcode("rrc","a");
- } else if(shCount == 2){
- pic14_emitcode("mov","c,acc.7");
- pic14_emitcode("rrc","a");
- pic14_emitcode("mov","c,acc.7");
- pic14_emitcode("rrc","a");
- } else {
- tlbl = newiTempLabel(NULL);
- /* rotate right accumulator */
- AccRol(8 - shCount);
- /* and kill the higher order bits */
- pic14_emitcode("anl","a,#0x%02x", SRMask[shCount]);
- pic14_emitcode("jnb","acc.%d,%05d_DS_",7-shCount,tlbl->key+100);
- pic14_emitcode("orl","a,#0x%02x",
- (unsigned char)~SRMask[shCount]);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- }
- }
+ symbol *tlbl ;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(shCount != 0){
+ if(shCount == 1){
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ } else if(shCount == 2){
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ } else {
+ tlbl = newiTempLabel(NULL);
+ /* rotate right accumulator */
+ AccRol(8 - shCount);
+ /* and kill the higher order bits */
+ pic14_emitcode("anl","a,#0x%02x", SRMask[shCount]);
+ pic14_emitcode("jnb","acc.%d,%05d_DS_",7-shCount,tlbl->key+100);
+ pic14_emitcode("orl","a,#0x%02x",
+ (unsigned char)~SRMask[shCount]);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ }
+ }
}
#endif
/*-----------------------------------------------------------------*/
/* shiftR1Left2Result - shift right one byte from left to result */
/*-----------------------------------------------------------------*/
static void shiftR1Left2ResultSigned (operand *left, int offl,
- operand *result, int offr,
- int shCount)
-{
- int same;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
-
- switch(shCount) {
- case 1:
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- if(same)
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
-
- break;
- case 2:
-
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- if(same)
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
- emitpcode(POC_RLFW, popGet(AOP(result),offr));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
-
- break;
-
- case 3:
- if(same)
- emitpcode(POC_SWAPF, popGet(AOP(result),offr));
- else {
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
-
- emitpcode(POC_RLFW, popGet(AOP(result),offr));
- emitpcode(POC_RLFW, popGet(AOP(result),offr));
- emitpcode(POC_ANDLW, popGetLit(0x1f));
-
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
- emitpcode(POC_IORLW, popGetLit(0xe0));
-
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- break;
-
- case 4:
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
- emitpcode(POC_IORLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- break;
- case 5:
- if(same) {
- emitpcode(POC_SWAPF, popGet(AOP(result),offr));
- } else {
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
- emitpcode(POC_RRFW, popGet(AOP(result),offr));
- emitpcode(POC_ANDLW, popGetLit(0x07));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
- emitpcode(POC_IORLW, popGetLit(0xf8));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- break;
-
- case 6:
- if(same) {
- emitpcode(POC_MOVLW, popGetLit(0x00));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
- emitpcode(POC_MOVLW, popGetLit(0xfe));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
- emitpcode(POC_IORLW, popGetLit(0x01));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- } else {
- emitpcode(POC_CLRF, popGet(AOP(result),offr));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(result),offr));
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
- emitpcode(POC_BCF, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),0,0));
- }
- break;
-
- case 7:
- if(same) {
- emitpcode(POC_MOVLW, popGetLit(0x00));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
- emitpcode(POC_MOVLW, popGetLit(0xff));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- } else {
- emitpcode(POC_CLRF, popGet(AOP(result),offr));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(result),offr));
- }
-
- default:
- break;
- }
+ operand *result, int offr,
+ int shCount)
+{
+ int same;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+ switch(shCount) {
+ case 1:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ if(same)
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+
+ break;
+ case 2:
+
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ if(same)
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+ break;
+
+ case 3:
+ if(same)
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0x1f));
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+ emitpcode(POC_IORLW, popGetLit(0xe0));
+
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 4:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_IORLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+ case 5:
+ if(same) {
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ emitpcode(POC_RRFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0x07));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+ emitpcode(POC_IORLW, popGetLit(0xf8));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 6:
+ if(same) {
+ emitpcode(POC_MOVLW, popGetLit(0x00));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xfe));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+ emitpcode(POC_IORLW, popGetLit(0x01));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),offr));
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+ emitpcode(POC_BCF, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),0,0));
+ }
+ break;
+
+ case 7:
+ if(same) {
+ emitpcode(POC_MOVLW, popGetLit(0x00));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),offr));
+ }
+
+ default:
+ break;
+ }
}
/*-----------------------------------------------------------------*/
/* shiftR1Left2Result - shift right one byte from left to result */
/*-----------------------------------------------------------------*/
static void shiftR1Left2Result (operand *left, int offl,
- operand *result, int offr,
- int shCount, int sign)
+ operand *result, int offr,
+ int shCount, int sign)
{
- int same;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
-
- /* Copy the msb into the carry if signed. */
- if(sign) {
- shiftR1Left2ResultSigned(left,offl,result,offr,shCount);
- return;
- }
-
-
-
- switch(shCount) {
- case 1:
- emitCLRC;
- if(same)
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
- break;
- case 2:
- emitCLRC;
- if(same) {
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- } else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
- emitCLRC;
- emitpcode(POC_RRF, popGet(AOP(result),offr));
-
- break;
- case 3:
- if(same)
- emitpcode(POC_SWAPF, popGet(AOP(result),offr));
- else {
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
-
- emitpcode(POC_RLFW, popGet(AOP(result),offr));
- emitpcode(POC_RLFW, popGet(AOP(result),offr));
- emitpcode(POC_ANDLW, popGetLit(0x1f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- break;
-
- case 4:
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- break;
-
- case 5:
- emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- emitCLRC;
- emitpcode(POC_RRF, popGet(AOP(result),offr));
-
- break;
- case 6:
-
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0x80));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- break;
-
- case 7:
-
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- emitpcode(POC_CLRF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
-
- break;
-
- default:
- break;
- }
+ int same;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+ /* Copy the msb into the carry if signed. */
+ if(sign) {
+ shiftR1Left2ResultSigned(left,offl,result,offr,shCount);
+ return;
+ }
+
+
+
+ switch(shCount) {
+ case 1:
+ emitCLRC;
+ if(same)
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ break;
+ case 2:
+ emitCLRC;
+ if(same) {
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ emitCLRC;
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+ break;
+ case 3:
+ if(same)
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ else {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0x1f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 4:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ break;
+
+ case 5:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitCLRC;
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+ break;
+ case 6:
+
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x80));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ break;
+
+ case 7:
+
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+
+ break;
+
+ default:
+ break;
+ }
}
/*-----------------------------------------------------------------*/
/* shiftL1Left2Result - shift left one byte from left to result */
/*-----------------------------------------------------------------*/
static void shiftL1Left2Result (operand *left, int offl,
- operand *result, int offr, int shCount)
-{
- int same;
-
- // char *l;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- same = ((left == result) || (AOP(left) == AOP(result))) && (offl==offr);
- DEBUGpic14_emitcode ("; ***","same = %d",same);
- // l = aopGet(AOP(left),offl,FALSE,FALSE);
- // MOVA(l);
- /* shift left accumulator */
- //AccLsh(shCount); // don't comment out just yet...
- // aopPut(AOP(result),"a",offr);
-
- switch(shCount) {
- case 1:
- /* Shift left 1 bit position */
- emitpcode(POC_MOVFW, popGet(AOP(left),offl));
- if(same) {
- emitpcode(POC_ADDWF, popGet(AOP(left),offl));
- } else {
- emitpcode(POC_ADDFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
- break;
- case 2:
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- emitpcode(POC_ANDLW,popGetLit(0x7e));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr));
- break;
- case 3:
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- emitpcode(POC_ANDLW,popGetLit(0x3e));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- break;
- case 4:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- break;
- case 5:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr));
- break;
- case 6:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0x30));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- break;
- case 7:
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_CLRF, popGet(AOP(result),offr));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- break;
-
- default:
- DEBUGpic14_emitcode ("; ***","%s %d, shift count is %d",__FUNCTION__,__LINE__,shCount);
- }
-
+ operand *result, int offr, int shCount)
+{
+ int same;
+
+ // char *l;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ same = ((left == result) || (AOP(left) == AOP(result))) && (offl==offr);
+ DEBUGpic14_emitcode ("; ***","same = %d",same);
+ // l = aopGet(AOP(left),offl,FALSE,FALSE);
+ // MOVA(l);
+ /* shift left accumulator */
+ //AccLsh(shCount); // don't comment out just yet...
+ // aopPut(AOP(result),"a",offr);
+
+ switch(shCount) {
+ case 1:
+ /* Shift left 1 bit position */
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ if(same) {
+ emitpcode(POC_ADDWF, popGet(AOP(left),offl));
+ } else {
+ emitpcode(POC_ADDFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ break;
+ case 2:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW,popGetLit(0x7e));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ break;
+ case 3:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW,popGetLit(0x3e));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ break;
+ case 4:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ break;
+ case 5:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ break;
+ case 6:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x30));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ break;
+ case 7:
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ break;
+
+ default:
+ DEBUGpic14_emitcode ("; ***","%s %d, shift count is %d",__FUNCTION__,__LINE__,shCount);
+ }
+
}
/*-----------------------------------------------------------------*/
/* movLeft2Result - move byte from left to result */
/*-----------------------------------------------------------------*/
static void movLeft2Result (operand *left, int offl,
- operand *result, int offr)
-{
- char *l;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(!pic14_sameRegs(AOP(left),AOP(result)) || (offl != offr)){
- l = aopGet(AOP(left),offl,FALSE,FALSE);
-
- if (*l == '@' && (IS_AOP_PREG(result))) {
- pic14_emitcode("mov","a,%s",l);
- aopPut(AOP(result),"a",offr);
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- }
- }
+ operand *result, int offr)
+{
+ char *l;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(!pic14_sameRegs(AOP(left),AOP(result)) || (offl != offr)){
+ l = aopGet(AOP(left),offl,FALSE,FALSE);
+
+ if (*l == '@' && (IS_AOP_PREG(result))) {
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offr);
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ }
+ }
}
/*-----------------------------------------------------------------*/
/* shiftL2Left2Result - shift left two bytes from left to result */
/*-----------------------------------------------------------------*/
static void shiftL2Left2Result (operand *left, int offl,
- operand *result, int offr, int shCount)
+ operand *result, int offr, int shCount)
{
-
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if(pic14_sameRegs(AOP(result), AOP(left))) {
- switch(shCount) {
- case 0:
- break;
- case 1:
- case 2:
- case 3:
-
- emitpcode(POC_MOVFW,popGet(AOP(result),offr));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
-
- while(--shCount) {
- emitCLRC;
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- }
-
- break;
- case 4:
- case 5:
- emitpcode(POC_MOVLW, popGetLit(0x0f));
- emitpcode(POC_ANDWF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr));
- emitpcode(POC_ANDFW, popGet(AOP(result),offr));
- emitpcode(POC_XORWF, popGet(AOP(result),offr));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
- if(shCount >=5) {
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- }
- break;
- case 6:
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ANDLW,popGetLit(0xc0));
- emitpcode(POC_XORFW,popGet(AOP(result),offr));
- emitpcode(POC_XORWF,popGet(AOP(result),offr));
- emitpcode(POC_XORFW,popGet(AOP(result),offr));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- break;
- case 7:
- emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRFW, popGet(AOP(result),offr));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_CLRF, popGet(AOP(result),offr));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- }
-
- } else {
- switch(shCount) {
- case 0:
- break;
- case 1:
- case 2:
- case 3:
- /* note, use a mov/add for the shift since the mov has a
- chance of getting optimized out */
- emitpcode(POC_MOVFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr));
- emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
-
- while(--shCount) {
- emitCLRC;
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- }
- break;
-
- case 4:
- case 5:
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
- emitpcode(POC_ANDLW, popGetLit(0xF0));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
- emitpcode(POC_ANDLW, popGetLit(0xF0));
- emitpcode(POC_XORWF, popGet(AOP(result),offr));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
-
-
- if(shCount == 5) {
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- }
- break;
- case 6:
- emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRFW, popGet(AOP(result),offl));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
-
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ANDLW,popGetLit(0xc0));
- emitpcode(POC_XORFW,popGet(AOP(result),offr));
- emitpcode(POC_XORWF,popGet(AOP(result),offr));
- emitpcode(POC_XORFW,popGet(AOP(result),offr));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- break;
- case 7:
- emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_CLRF, popGet(AOP(result),offr));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- }
- }
-
+
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(pic14_sameRegs(AOP(result), AOP(left))) {
+ switch(shCount) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 3:
+
+ emitpcode(POC_MOVFW,popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+
+ while(--shCount) {
+ emitCLRC;
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+
+ break;
+ case 4:
+ case 5:
+ emitpcode(POC_MOVLW, popGetLit(0x0f));
+ emitpcode(POC_ANDWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+ emitpcode(POC_ANDFW, popGet(AOP(result),offr));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+ if(shCount >=5) {
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+ break;
+ case 6:
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW,popGetLit(0xc0));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ break;
+ case 7:
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ }
+
+ } else {
+ switch(shCount) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 3:
+ /* note, use a mov/add for the shift since the mov has a
+ chance of getting optimized out */
+ emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+
+ while(--shCount) {
+ emitCLRC;
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+ break;
+
+ case 4:
+ case 5:
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_ANDLW, popGetLit(0xF0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW, popGetLit(0xF0));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+
+
+ if(shCount == 5) {
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ }
+ break;
+ case 6:
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(result),offl));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW,popGetLit(0xc0));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ break;
+ case 7:
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ }
+ }
+
}
/*-----------------------------------------------------------------*/
/* shiftR2Left2Result - shift right two bytes from left to result */
/*-----------------------------------------------------------------*/
static void shiftR2Left2Result (operand *left, int offl,
- operand *result, int offr,
- int shCount, int sign)
+ operand *result, int offr,
+ int shCount, int sign)
{
- int same=0;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- same = pic14_sameRegs(AOP(result), AOP(left));
-
- if(same && ((offl + MSB16) == offr)){
- same=1;
- /* don't crash result[offr] */
- MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
- pic14_emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
- }
-/* else {
- movLeft2Result(left,offl, result, offr);
- MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
- }
-*/
- /* a:x >> shCount (x = lsb(result))*/
-/*
- if(sign)
- AccAXRshS( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
- else {
- AccAXRsh( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
-*/
- switch(shCount) {
- case 0:
- break;
- case 1:
- case 2:
- case 3:
- if(sign)
- emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
- else
- emitCLRC;
-
- if(same) {
- emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRF,popGet(AOP(result),offr));
- } else {
- emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- }
-
- while(--shCount) {
- if(sign)
- emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
- else
- emitCLRC;
- emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRF,popGet(AOP(result),offr));
- }
- break;
- case 4:
- case 5:
- if(same) {
-
- emitpcode(POC_MOVLW, popGetLit(0xf0));
- emitpcode(POC_ANDWF, popGet(AOP(result),offr));
- emitpcode(POC_SWAPF, popGet(AOP(result),offr));
-
- emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ANDFW, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr));
- } else {
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
- emitpcode(POC_ANDLW, popGetLit(0x0f));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr));
-
- emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
- emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr));
- }
-
- if(shCount >=5) {
- emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RRF, popGet(AOP(result),offr));
- }
-
- if(sign) {
- emitpcode(POC_MOVLW, popGetLit(0xf0 + (shCount-4)*8 ));
- emitpcode(POC_BTFSC,
- newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0));
- emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
- }
-
- break;
-
- case 6:
- if(same) {
-
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
-
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RLFW, popGet(AOP(result),offr));
- emitpcode(POC_ANDLW,popGetLit(0x03));
- if(sign) {
- emitpcode(POC_BTFSC,
- newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0));
- emitpcode(POC_IORLW,popGetLit(0xfc));
- }
- emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- } else {
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_RLF, popGet(AOP(result),offr));
- emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
- emitpcode(POC_ANDLW,popGetLit(0x03));
- if(sign) {
- emitpcode(POC_BTFSC,
- newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
- emitpcode(POC_IORLW,popGetLit(0xfc));
- }
- emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
- //emitpcode(POC_RLF, popGet(AOP(result),offr));
-
-
- }
-
- break;
- case 7:
- emitpcode(POC_RLFW, popGet(AOP(left),offl));
- emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
- emitpcode(POC_MOVWF,popGet(AOP(result),offr));
- emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16));
- if(sign) {
- emitSKPNC;
- emitpcode(POC_DECF, popGet(AOP(result),offr+MSB16));
- } else
- emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ int same=0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ same = pic14_sameRegs(AOP(result), AOP(left));
+
+ if(same && ((offl + MSB16) == offr)){
+ same=1;
+ /* don't crash result[offr] */
+ MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
+ pic14_emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
+ }
+ /* else {
+ movLeft2Result(left,offl, result, offr);
+ MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
+ }
+ */
+ /* a:x >> shCount (x = lsb(result))*/
+ /*
+ if(sign)
+ AccAXRshS( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
+ else {
+ AccAXRsh( aopGet(AOP(result),offr,FALSE,FALSE) , shCount);
+ */
+ switch(shCount) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 3:
+ if(sign)
+ emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
+ else
+ emitCLRC;
+
+ if(same) {
+ emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF,popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ }
+
+ while(--shCount) {
+ if(sign)
+ emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
+ else
+ emitCLRC;
+ emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF,popGet(AOP(result),offr));
+ }
+ break;
+ case 4:
+ case 5:
+ if(same) {
+
+ emitpcode(POC_MOVLW, popGetLit(0xf0));
+ emitpcode(POC_ANDWF, popGet(AOP(result),offr));
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+
+ emitpcode(POC_SWAPF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
+ emitpcode(POC_ANDLW, popGetLit(0x0f));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+
+ emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr));
+ }
+
+ if(shCount >=5) {
+ emitpcode(POC_RRF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RRF, popGet(AOP(result),offr));
+ }
+
+ if(sign) {
+ emitpcode(POC_MOVLW, popGetLit(0xf0 + (shCount-4)*8 ));
+ emitpcode(POC_BTFSC,
+ newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+ }
+
+ break;
+
+ case 6:
+ if(same) {
+
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr));
+ emitpcode(POC_ANDLW,popGetLit(0x03));
+ if(sign) {
+ emitpcode(POC_BTFSC,
+ newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0));
+ emitpcode(POC_IORLW,popGetLit(0xfc));
+ }
+ emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ } else {
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_RLF, popGet(AOP(result),offr));
+ emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
+ emitpcode(POC_ANDLW,popGetLit(0x03));
+ if(sign) {
+ emitpcode(POC_BTFSC,
+ newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
+ emitpcode(POC_IORLW,popGetLit(0xfc));
+ }
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+ //emitpcode(POC_RLF, popGet(AOP(result),offr));
+
+
+ }
+
+ break;
+ case 7:
+ emitpcode(POC_RLFW, popGet(AOP(left),offl));
+ emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+ emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16));
+ if(sign) {
+ emitSKPNC;
+ emitpcode(POC_DECF, popGet(AOP(result),offr+MSB16));
+ } else
+ emitpcode(POC_RLF, popGet(AOP(result),offr+MSB16));
}
}
/* shiftLLeftOrResult - shift left one byte from left, or to result*/
/*-----------------------------------------------------------------*/
static void shiftLLeftOrResult (operand *left, int offl,
- operand *result, int offr, int shCount)
+ operand *result, int offr, int shCount)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
- /* shift left accumulator */
- AccLsh(shCount);
- /* or with result */
- pic14_emitcode("orl","a,%s", aopGet(AOP(result),offr,FALSE,FALSE));
- /* back to result */
- aopPut(AOP(result),"a",offr);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
+ /* shift left accumulator */
+ AccLsh(shCount);
+ /* or with result */
+ pic14_emitcode("orl","a,%s", aopGet(AOP(result),offr,FALSE,FALSE));
+ /* back to result */
+ aopPut(AOP(result),"a",offr);
}
/*-----------------------------------------------------------------*/
/* shiftRLeftOrResult - shift right one byte from left,or to result*/
/*-----------------------------------------------------------------*/
static void shiftRLeftOrResult (operand *left, int offl,
- operand *result, int offr, int shCount)
+ operand *result, int offr, int shCount)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
- /* shift right accumulator */
- AccRsh(shCount);
- /* or with result */
- pic14_emitcode("orl","a,%s", aopGet(AOP(result),offr,FALSE,FALSE));
- /* back to result */
- aopPut(AOP(result),"a",offr);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
+ /* shift right accumulator */
+ AccRsh(shCount);
+ /* or with result */
+ pic14_emitcode("orl","a,%s", aopGet(AOP(result),offr,FALSE,FALSE));
+ /* back to result */
+ aopPut(AOP(result),"a",offr);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genlshOne (operand *result, operand *left, int shCount)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- shiftL1Left2Result(left, LSB, result, LSB, shCount);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shiftL1Left2Result(left, LSB, result, LSB, shCount);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genlshTwo (operand *result,operand *left, int shCount)
{
- int size;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- size = pic14_getDataSize(result);
-
- /* if shCount >= 8 */
- if (shCount >= 8) {
- shCount -= 8 ;
-
- if (size > 1){
- if (shCount)
- shiftL1Left2Result(left, LSB, result, MSB16, shCount);
- else
- movLeft2Result(left, LSB, result, MSB16);
- }
- emitpcode(POC_CLRF,popGet(AOP(result),LSB));
- }
-
- /* 1 <= shCount <= 7 */
- else {
- if(size == 1)
- shiftL1Left2Result(left, LSB, result, LSB, shCount);
- else
- shiftL2Left2Result(left, LSB, result, LSB, shCount);
- }
+ int size;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ size = pic14_getDataSize(result);
+
+ /* if shCount >= 8 */
+ if (shCount >= 8) {
+ shCount -= 8 ;
+
+ if (size > 1){
+ if (shCount)
+ shiftL1Left2Result(left, LSB, result, MSB16, shCount);
+ else
+ movLeft2Result(left, LSB, result, MSB16);
+ }
+ emitpcode(POC_CLRF,popGet(AOP(result),LSB));
+ }
+
+ /* 1 <= shCount <= 7 */
+ else {
+ if(size == 1)
+ shiftL1Left2Result(left, LSB, result, LSB, shCount);
+ else
+ shiftL2Left2Result(left, LSB, result, LSB, shCount);
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void shiftLLong (operand *left, operand *result, int offr )
{
- char *l;
- int size = AOP_SIZE(result);
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(size >= LSB+offr){
- l = aopGet(AOP(left),LSB,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("add","a,acc");
- if (pic14_sameRegs(AOP(left),AOP(result)) &&
- size >= MSB16+offr && offr != LSB )
- pic14_emitcode("xch","a,%s",
- aopGet(AOP(left),LSB+offr,FALSE,FALSE));
- else
- aopPut(AOP(result),"a",LSB+offr);
- }
-
- if(size >= MSB16+offr){
- if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) {
- l = aopGet(AOP(left),MSB16,FALSE,FALSE);
- MOVA(l);
- }
- pic14_emitcode("rlc","a");
- if (pic14_sameRegs(AOP(left),AOP(result)) &&
- size >= MSB24+offr && offr != LSB)
- pic14_emitcode("xch","a,%s",
- aopGet(AOP(left),MSB16+offr,FALSE,FALSE));
- else
- aopPut(AOP(result),"a",MSB16+offr);
- }
-
- if(size >= MSB24+offr){
- if (!(pic14_sameRegs(AOP(left),AOP(left)) && size >= MSB24+offr && offr != LSB)) {
- l = aopGet(AOP(left),MSB24,FALSE,FALSE);
- MOVA(l);
- }
- pic14_emitcode("rlc","a");
- if (pic14_sameRegs(AOP(left),AOP(result)) &&
- size >= MSB32+offr && offr != LSB )
- pic14_emitcode("xch","a,%s",
- aopGet(AOP(left),MSB24+offr,FALSE,FALSE));
- else
- aopPut(AOP(result),"a",MSB24+offr);
- }
-
- if(size > MSB32+offr){
- if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB32+offr && offr != LSB)) {
- l = aopGet(AOP(left),MSB32,FALSE,FALSE);
- MOVA(l);
- }
- pic14_emitcode("rlc","a");
- aopPut(AOP(result),"a",MSB32+offr);
- }
- if(offr != LSB)
- aopPut(AOP(result),zero,LSB);
+ char *l;
+ int size = AOP_SIZE(result);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(size >= LSB+offr){
+ l = aopGet(AOP(left),LSB,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("add","a,acc");
+ if (pic14_sameRegs(AOP(left),AOP(result)) &&
+ size >= MSB16+offr && offr != LSB )
+ pic14_emitcode("xch","a,%s",
+ aopGet(AOP(left),LSB+offr,FALSE,FALSE));
+ else
+ aopPut(AOP(result),"a",LSB+offr);
+ }
+
+ if(size >= MSB16+offr){
+ if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) {
+ l = aopGet(AOP(left),MSB16,FALSE,FALSE);
+ MOVA(l);
+ }
+ pic14_emitcode("rlc","a");
+ if (pic14_sameRegs(AOP(left),AOP(result)) &&
+ size >= MSB24+offr && offr != LSB)
+ pic14_emitcode("xch","a,%s",
+ aopGet(AOP(left),MSB16+offr,FALSE,FALSE));
+ else
+ aopPut(AOP(result),"a",MSB16+offr);
+ }
+
+ if(size >= MSB24+offr){
+ if (!(pic14_sameRegs(AOP(left),AOP(left)) && size >= MSB24+offr && offr != LSB)) {
+ l = aopGet(AOP(left),MSB24,FALSE,FALSE);
+ MOVA(l);
+ }
+ pic14_emitcode("rlc","a");
+ if (pic14_sameRegs(AOP(left),AOP(result)) &&
+ size >= MSB32+offr && offr != LSB )
+ pic14_emitcode("xch","a,%s",
+ aopGet(AOP(left),MSB24+offr,FALSE,FALSE));
+ else
+ aopPut(AOP(result),"a",MSB24+offr);
+ }
+
+ if(size > MSB32+offr){
+ if (!(pic14_sameRegs(AOP(result),AOP(left)) && size >= MSB32+offr && offr != LSB)) {
+ l = aopGet(AOP(left),MSB32,FALSE,FALSE);
+ MOVA(l);
+ }
+ pic14_emitcode("rlc","a");
+ aopPut(AOP(result),"a",MSB32+offr);
+ }
+ if(offr != LSB)
+ aopPut(AOP(result),zero,LSB);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genlshFour (operand *result, operand *left, int shCount)
{
- int size;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- size = AOP_SIZE(result);
-
- /* if shifting more that 3 bytes */
- if (shCount >= 24 ) {
- shCount -= 24;
- if (shCount)
- /* lowest order of left goes to the highest
- order of the destination */
- shiftL1Left2Result(left, LSB, result, MSB32, shCount);
- else
- movLeft2Result(left, LSB, result, MSB32);
- aopPut(AOP(result),zero,LSB);
- aopPut(AOP(result),zero,MSB16);
- aopPut(AOP(result),zero,MSB32);
- return;
- }
-
- /* more than two bytes */
- else if ( shCount >= 16 ) {
- /* lower order two bytes goes to higher order two bytes */
- shCount -= 16;
- /* if some more remaining */
- if (shCount)
- shiftL2Left2Result(left, LSB, result, MSB24, shCount);
- else {
- movLeft2Result(left, MSB16, result, MSB32);
- movLeft2Result(left, LSB, result, MSB24);
- }
- aopPut(AOP(result),zero,MSB16);
- aopPut(AOP(result),zero,LSB);
- return;
- }
-
- /* if more than 1 byte */
- else if ( shCount >= 8 ) {
- /* lower order three bytes goes to higher order three bytes */
- shCount -= 8;
- if(size == 2){
- if(shCount)
- shiftL1Left2Result(left, LSB, result, MSB16, shCount);
- else
- movLeft2Result(left, LSB, result, MSB16);
- }
- else{ /* size = 4 */
- if(shCount == 0){
- movLeft2Result(left, MSB24, result, MSB32);
- movLeft2Result(left, MSB16, result, MSB24);
- movLeft2Result(left, LSB, result, MSB16);
- aopPut(AOP(result),zero,LSB);
- }
- else if(shCount == 1)
- shiftLLong(left, result, MSB16);
- else{
- shiftL2Left2Result(left, MSB16, result, MSB24, shCount);
- shiftL1Left2Result(left, LSB, result, MSB16, shCount);
- shiftRLeftOrResult(left, LSB, result, MSB24, 8 - shCount);
- aopPut(AOP(result),zero,LSB);
- }
- }
- }
-
- /* 1 <= shCount <= 7 */
- else if(shCount <= 2){
- shiftLLong(left, result, LSB);
- if(shCount == 2)
- shiftLLong(result, result, LSB);
- }
- /* 3 <= shCount <= 7, optimize */
- else{
- shiftL2Left2Result(left, MSB24, result, MSB24, shCount);
- shiftRLeftOrResult(left, MSB16, result, MSB24, 8 - shCount);
- shiftL2Left2Result(left, LSB, result, LSB, shCount);
- }
+ int size;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ size = AOP_SIZE(result);
+
+ /* if shifting more that 3 bytes */
+ if (shCount >= 24 ) {
+ shCount -= 24;
+ if (shCount)
+ /* lowest order of left goes to the highest
+ order of the destination */
+ shiftL1Left2Result(left, LSB, result, MSB32, shCount);
+ else
+ movLeft2Result(left, LSB, result, MSB32);
+ aopPut(AOP(result),zero,LSB);
+ aopPut(AOP(result),zero,MSB16);
+ aopPut(AOP(result),zero,MSB32);
+ return;
+ }
+
+ /* more than two bytes */
+ else if ( shCount >= 16 ) {
+ /* lower order two bytes goes to higher order two bytes */
+ shCount -= 16;
+ /* if some more remaining */
+ if (shCount)
+ shiftL2Left2Result(left, LSB, result, MSB24, shCount);
+ else {
+ movLeft2Result(left, MSB16, result, MSB32);
+ movLeft2Result(left, LSB, result, MSB24);
+ }
+ aopPut(AOP(result),zero,MSB16);
+ aopPut(AOP(result),zero,LSB);
+ return;
+ }
+
+ /* if more than 1 byte */
+ else if ( shCount >= 8 ) {
+ /* lower order three bytes goes to higher order three bytes */
+ shCount -= 8;
+ if(size == 2){
+ if(shCount)
+ shiftL1Left2Result(left, LSB, result, MSB16, shCount);
+ else
+ movLeft2Result(left, LSB, result, MSB16);
+ }
+ else{ /* size = 4 */
+ if(shCount == 0){
+ movLeft2Result(left, MSB24, result, MSB32);
+ movLeft2Result(left, MSB16, result, MSB24);
+ movLeft2Result(left, LSB, result, MSB16);
+ aopPut(AOP(result),zero,LSB);
+ }
+ else if(shCount == 1)
+ shiftLLong(left, result, MSB16);
+ else{
+ shiftL2Left2Result(left, MSB16, result, MSB24, shCount);
+ shiftL1Left2Result(left, LSB, result, MSB16, shCount);
+ shiftRLeftOrResult(left, LSB, result, MSB24, 8 - shCount);
+ aopPut(AOP(result),zero,LSB);
+ }
+ }
+ }
+
+ /* 1 <= shCount <= 7 */
+ else if(shCount <= 2){
+ shiftLLong(left, result, LSB);
+ if(shCount == 2)
+ shiftLLong(result, result, LSB);
+ }
+ /* 3 <= shCount <= 7, optimize */
+ else{
+ shiftL2Left2Result(left, MSB24, result, MSB24, shCount);
+ shiftRLeftOrResult(left, MSB16, result, MSB24, 8 - shCount);
+ shiftL2Left2Result(left, LSB, result, LSB, shCount);
+ }
}
/*-----------------------------------------------------------------*/
/* genLeftShiftLiteral - left shifting by known count */
/*-----------------------------------------------------------------*/
static void genLeftShiftLiteral (operand *left,
- operand *right,
- operand *result,
- iCode *ic)
+ operand *right,
+ operand *result,
+ iCode *ic)
{
- int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
- int size;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- freeAsmop(right,NULL,ic,TRUE);
-
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
- size = getSize(operandType(result));
-
+ int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+ int size;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ freeAsmop(right,NULL,ic,TRUE);
+
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ size = getSize(operandType(result));
+
#if VIEW_SIZE
- pic14_emitcode("; shift left ","result %d, left %d",size,
- AOP_SIZE(left));
+ pic14_emitcode("; shift left ","result %d, left %d",size,
+ AOP_SIZE(left));
#endif
-
- /* I suppose that the left size >= result size */
- if(shCount == 0){
- while(size--){
- movLeft2Result(left, size, result, size);
- }
- }
-
- else if(shCount >= (size * 8))
- while(size--)
- aopPut(AOP(result),zero,size);
- else{
- switch (size) {
- case 1:
- genlshOne (result,left,shCount);
- break;
-
- case 2:
- case 3:
- genlshTwo (result,left,shCount);
- break;
-
- case 4:
- genlshFour (result,left,shCount);
- break;
- }
- }
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+
+ /* I suppose that the left size >= result size */
+ if(shCount == 0){
+ while(size--){
+ movLeft2Result(left, size, result, size);
+ }
+ }
+
+ else if(shCount >= (size * 8))
+ while(size--)
+ aopPut(AOP(result),zero,size);
+ else{
+ switch (size) {
+ case 1:
+ genlshOne (result,left,shCount);
+ break;
+
+ case 2:
+ case 3:
+ genlshTwo (result,left,shCount);
+ break;
+
+ case 4:
+ genlshFour (result,left,shCount);
+ break;
+ }
+ }
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*
- * genMultiAsm - repeat assembly instruction for size of register.
- * if endian == 1, then the high byte (i.e base address + size of
- * register) is used first else the low byte is used first;
- *-----------------------------------------------------------------*/
+* genMultiAsm - repeat assembly instruction for size of register.
+* if endian == 1, then the high byte (i.e base address + size of
+* register) is used first else the low byte is used first;
+*-----------------------------------------------------------------*/
static void genMultiAsm( PIC_OPCODE poc, operand *reg, int size, int endian)
{
-
- int offset = 0;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if(!reg)
- return;
-
- if(!endian) {
- endian = 1;
- } else {
- endian = -1;
- offset = size-1;
- }
-
- while(size--) {
- emitpcode(poc, popGet(AOP(reg),offset));
- offset += endian;
- }
-
+
+ int offset = 0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(!reg)
+ return;
+
+ if(!endian) {
+ endian = 1;
+ } else {
+ endian = -1;
+ offset = size-1;
+ }
+
+ while(size--) {
+ emitpcode(poc, popGet(AOP(reg),offset));
+ offset += endian;
+ }
+
}
/*-----------------------------------------------------------------*/
/* genLeftShift - generates code for left shifting */
/*-----------------------------------------------------------------*/
static void genLeftShift (iCode *ic)
{
- operand *left,*right, *result;
- int size, offset;
- char *l;
- symbol *tlbl , *tlbl1;
- pCodeOp *pctemp;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- right = IC_RIGHT(ic);
- left = IC_LEFT(ic);
- result = IC_RESULT(ic);
-
- aopOp(right,ic,FALSE);
-
- /* if the shift count is known then do it
- as efficiently as possible */
- if (AOP_TYPE(right) == AOP_LIT) {
- genLeftShiftLiteral (left,right,result,ic);
- return ;
- }
-
- /* shift count is unknown then we have to form
- a loop get the loop count in B : Note: we take
- only the lower order byte since shifting
- more that 32 bits make no sense anyway, ( the
- largest size of an object can be only 32 bits ) */
-
-
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
- /* now move the left to the result if they are not the
- same */
- if (!pic14_sameRegs(AOP(left),AOP(result)) &&
- AOP_SIZE(result) > 1) {
-
- size = AOP_SIZE(result);
- offset=0;
- while (size--) {
- l = aopGet(AOP(left),offset,FALSE,TRUE);
- if (*l == '@' && (IS_AOP_PREG(result))) {
-
- pic14_emitcode("mov","a,%s",l);
- aopPut(AOP(result),"a",offset);
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(left),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- //aopPut(AOP(result),l,offset);
- }
- offset++;
- }
- }
-
- size = AOP_SIZE(result);
-
- /* if it is only one byte then */
- if (size == 1) {
- if(optimized_for_speed) {
- emitpcode(POC_SWAPFW, popGet(AOP(left),0));
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
- emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
- emitpcode(POC_ADDWF, popGet(AOP(result),0));
- emitpcode(POC_RLFW, popGet(AOP(result),0));
- emitpcode(POC_ANDLW, popGetLit(0xfe));
- emitpcode(POC_ADDFW, popGet(AOP(result),0));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
- emitpcode(POC_ADDWF, popGet(AOP(result),0));
- } else {
-
- tlbl = newiTempLabel(NULL);
- if (!pic14_sameRegs(AOP(left),AOP(result))) {
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
- }
-
- emitpcode(POC_COMFW, popGet(AOP(right),0));
- emitpcode(POC_RRF, popGet(AOP(result),0));
- emitpLabel(tlbl->key);
- emitpcode(POC_RLF, popGet(AOP(result),0));
- emitpcode(POC_ADDLW, popGetLit(1));
- emitSKPC;
- emitpcode(POC_GOTO,popGetLabel(tlbl->key));
- }
- goto release ;
- }
-
- if (pic14_sameRegs(AOP(left),AOP(result))) {
-
- tlbl = newiTempLabel(NULL);
- emitpcode(POC_COMFW, popGet(AOP(right),0));
- genMultiAsm(POC_RRF, result, size,1);
- emitpLabel(tlbl->key);
- genMultiAsm(POC_RLF, result, size,0);
- emitpcode(POC_ADDLW, popGetLit(1));
- emitSKPC;
- emitpcode(POC_GOTO,popGetLabel(tlbl->key));
- goto release;
- }
-
- //tlbl = newiTempLabel(NULL);
- //offset = 0 ;
- //tlbl1 = newiTempLabel(NULL);
-
- //reAdjustPreg(AOP(result));
-
- //pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
- //pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- //l = aopGet(AOP(result),offset,FALSE,FALSE);
- //MOVA(l);
- //pic14_emitcode("add","a,acc");
- //aopPut(AOP(result),"a",offset++);
- //while (--size) {
- // l = aopGet(AOP(result),offset,FALSE,FALSE);
- // MOVA(l);
- // pic14_emitcode("rlc","a");
- // aopPut(AOP(result),"a",offset++);
- //}
- //reAdjustPreg(AOP(result));
-
- //pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
- //pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
-
-
- tlbl = newiTempLabel(NULL);
- tlbl1= newiTempLabel(NULL);
-
- size = AOP_SIZE(result);
- offset = 1;
-
- pctemp = popGetTempReg(); /* grab a temporary working register. */
-
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
-
- /* offset should be 0, 1 or 3 */
- emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
- emitSKPNZ;
- emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
-
- emitpcode(POC_MOVWF, pctemp);
-
-
- emitpLabel(tlbl->key);
-
- emitCLRC;
- emitpcode(POC_RLF, popGet(AOP(result),0));
- while(--size)
- emitpcode(POC_RLF, popGet(AOP(result),offset++));
-
- emitpcode(POC_DECFSZ, pctemp);
- emitpcode(POC_GOTO,popGetLabel(tlbl->key));
- emitpLabel(tlbl1->key);
-
- popReleaseTempReg(pctemp);
-
-
- release:
- freeAsmop (right,NULL,ic,TRUE);
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+ operand *left,*right, *result;
+ int size, offset;
+ char *l;
+ symbol *tlbl , *tlbl1;
+ pCodeOp *pctemp;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ right = IC_RIGHT(ic);
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+
+ aopOp(right,ic,FALSE);
+
+ /* if the shift count is known then do it
+ as efficiently as possible */
+ if (AOP_TYPE(right) == AOP_LIT) {
+ genLeftShiftLiteral (left,right,result,ic);
+ return ;
+ }
+
+ /* shift count is unknown then we have to form
+ a loop get the loop count in B : Note: we take
+ only the lower order byte since shifting
+ more that 32 bits make no sense anyway, ( the
+ largest size of an object can be only 32 bits ) */
+
+
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ /* now move the left to the result if they are not the
+ same */
+ if (!pic14_sameRegs(AOP(left),AOP(result)) &&
+ AOP_SIZE(result) > 1) {
+
+ size = AOP_SIZE(result);
+ offset=0;
+ while (size--) {
+ l = aopGet(AOP(left),offset,FALSE,TRUE);
+ if (*l == '@' && (IS_AOP_PREG(result))) {
+
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offset);
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ //aopPut(AOP(result),l,offset);
+ }
+ offset++;
+ }
+ }
+
+ size = AOP_SIZE(result);
+
+ /* if it is only one byte then */
+ if (size == 1) {
+ if(optimized_for_speed) {
+ emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ emitpcode(POC_RLFW, popGet(AOP(result),0));
+ emitpcode(POC_ANDLW, popGetLit(0xfe));
+ emitpcode(POC_ADDFW, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ } else {
+
+ tlbl = newiTempLabel(NULL);
+ if (!pic14_sameRegs(AOP(left),AOP(result))) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ }
+
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+ emitpLabel(tlbl->key);
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ emitpcode(POC_ADDLW, popGetLit(1));
+ emitSKPC;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ }
+ goto release ;
+ }
+
+ if (pic14_sameRegs(AOP(left),AOP(result))) {
+
+ tlbl = newiTempLabel(NULL);
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ genMultiAsm(POC_RRF, result, size,1);
+ emitpLabel(tlbl->key);
+ genMultiAsm(POC_RLF, result, size,0);
+ emitpcode(POC_ADDLW, popGetLit(1));
+ emitSKPC;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ goto release;
+ }
+
+ //tlbl = newiTempLabel(NULL);
+ //offset = 0 ;
+ //tlbl1 = newiTempLabel(NULL);
+
+ //reAdjustPreg(AOP(result));
+
+ //pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ //pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ //l = aopGet(AOP(result),offset,FALSE,FALSE);
+ //MOVA(l);
+ //pic14_emitcode("add","a,acc");
+ //aopPut(AOP(result),"a",offset++);
+ //while (--size) {
+ // l = aopGet(AOP(result),offset,FALSE,FALSE);
+ // MOVA(l);
+ // pic14_emitcode("rlc","a");
+ // aopPut(AOP(result),"a",offset++);
+ //}
+ //reAdjustPreg(AOP(result));
+
+ //pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ //pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
+
+ tlbl = newiTempLabel(NULL);
+ tlbl1= newiTempLabel(NULL);
+
+ size = AOP_SIZE(result);
+ offset = 1;
+
+ pctemp = popGetTempReg(); /* grab a temporary working register. */
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+ /* offset should be 0, 1 or 3 */
+ emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
+ emitSKPNZ;
+ emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
+
+ emitpcode(POC_MOVWF, pctemp);
+
+
+ emitpLabel(tlbl->key);
+
+ emitCLRC;
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ while(--size)
+ emitpcode(POC_RLF, popGet(AOP(result),offset++));
+
+ emitpcode(POC_DECFSZ, pctemp);
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ emitpLabel(tlbl1->key);
+
+ popReleaseTempReg(pctemp);
+
+
+release:
+ freeAsmop (right,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* genrshOne - right shift a one byte quantity by known count */
/*-----------------------------------------------------------------*/
static void genrshOne (operand *result, operand *left,
- int shCount, int sign)
+ int shCount, int sign)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- shiftR1Left2Result(left, LSB, result, LSB, shCount, sign);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ shiftR1Left2Result(left, LSB, result, LSB, shCount, sign);
}
/*-----------------------------------------------------------------*/
/* genrshTwo - right shift two bytes by known amount != 0 */
/*-----------------------------------------------------------------*/
static void genrshTwo (operand *result,operand *left,
- int shCount, int sign)
-{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if shCount >= 8 */
- if (shCount >= 8) {
- shCount -= 8 ;
- if (shCount)
- shiftR1Left2Result(left, MSB16, result, LSB,
- shCount, sign);
- else
- movLeft2Result(left, MSB16, result, LSB);
-
- emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
-
- if(sign) {
- emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(result),MSB16));
- }
- }
-
- /* 1 <= shCount <= 7 */
- else
- shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
+ int shCount, int sign)
+{
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if shCount >= 8 */
+ if (shCount >= 8) {
+ shCount -= 8 ;
+ if (shCount)
+ shiftR1Left2Result(left, MSB16, result, LSB,
+ shCount, sign);
+ else
+ movLeft2Result(left, MSB16, result, LSB);
+
+ emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
+
+ if(sign) {
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
+ }
+ }
+
+ /* 1 <= shCount <= 7 */
+ else
+ shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
}
/*-----------------------------------------------------------------*/
/* offl = LSB or MSB16 */
/*-----------------------------------------------------------------*/
static void shiftRLong (operand *left, int offl,
- operand *result, int sign)
+ operand *result, int sign)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(!sign)
- pic14_emitcode("clr","c");
- MOVA(aopGet(AOP(left),MSB32,FALSE,FALSE));
- if(sign)
- pic14_emitcode("mov","c,acc.7");
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"a",MSB32-offl);
- if(offl == MSB16)
- /* add sign of "a" */
- addSign(result, MSB32, sign);
-
- MOVA(aopGet(AOP(left),MSB24,FALSE,FALSE));
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"a",MSB24-offl);
-
- MOVA(aopGet(AOP(left),MSB16,FALSE,FALSE));
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"a",MSB16-offl);
-
- if(offl == LSB){
- MOVA(aopGet(AOP(left),LSB,FALSE,FALSE));
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"a",LSB);
- }
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(!sign)
+ pic14_emitcode("clr","c");
+ MOVA(aopGet(AOP(left),MSB32,FALSE,FALSE));
+ if(sign)
+ pic14_emitcode("mov","c,acc.7");
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",MSB32-offl);
+ if(offl == MSB16)
+ /* add sign of "a" */
+ addSign(result, MSB32, sign);
+
+ MOVA(aopGet(AOP(left),MSB24,FALSE,FALSE));
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",MSB24-offl);
+
+ MOVA(aopGet(AOP(left),MSB16,FALSE,FALSE));
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",MSB16-offl);
+
+ if(offl == LSB){
+ MOVA(aopGet(AOP(left),LSB,FALSE,FALSE));
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",LSB);
+ }
}
/*-----------------------------------------------------------------*/
/* genrshFour - shift four byte by a known amount != 0 */
/*-----------------------------------------------------------------*/
static void genrshFour (operand *result, operand *left,
- int shCount, int sign)
-{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if shifting more that 3 bytes */
- if(shCount >= 24 ) {
- shCount -= 24;
- if(shCount)
- shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
- else
- movLeft2Result(left, MSB32, result, LSB);
-
- addSign(result, MSB16, sign);
- }
- else if(shCount >= 16){
- shCount -= 16;
- if(shCount)
- shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
- else{
- movLeft2Result(left, MSB24, result, LSB);
- movLeft2Result(left, MSB32, result, MSB16);
- }
- addSign(result, MSB24, sign);
- }
- else if(shCount >= 8){
- shCount -= 8;
- if(shCount == 1)
- shiftRLong(left, MSB16, result, sign);
- else if(shCount == 0){
- movLeft2Result(left, MSB16, result, LSB);
- movLeft2Result(left, MSB24, result, MSB16);
- movLeft2Result(left, MSB32, result, MSB24);
- addSign(result, MSB32, sign);
- }
- else{
- shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0);
- shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount);
- /* the last shift is signed */
- shiftR1Left2Result(left, MSB32, result, MSB24, shCount, sign);
- addSign(result, MSB32, sign);
- }
- }
- else{ /* 1 <= shCount <= 7 */
- if(shCount <= 2){
- shiftRLong(left, LSB, result, sign);
- if(shCount == 2)
- shiftRLong(result, LSB, result, sign);
- }
- else{
- shiftR2Left2Result(left, LSB, result, LSB, shCount, 0);
- shiftLLeftOrResult(left, MSB24, result, MSB16, 8 - shCount);
- shiftR2Left2Result(left, MSB24, result, MSB24, shCount, sign);
- }
- }
+ int shCount, int sign)
+{
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if shifting more that 3 bytes */
+ if(shCount >= 24 ) {
+ shCount -= 24;
+ if(shCount)
+ shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
+ else
+ movLeft2Result(left, MSB32, result, LSB);
+
+ addSign(result, MSB16, sign);
+ }
+ else if(shCount >= 16){
+ shCount -= 16;
+ if(shCount)
+ shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
+ else{
+ movLeft2Result(left, MSB24, result, LSB);
+ movLeft2Result(left, MSB32, result, MSB16);
+ }
+ addSign(result, MSB24, sign);
+ }
+ else if(shCount >= 8){
+ shCount -= 8;
+ if(shCount == 1)
+ shiftRLong(left, MSB16, result, sign);
+ else if(shCount == 0){
+ movLeft2Result(left, MSB16, result, LSB);
+ movLeft2Result(left, MSB24, result, MSB16);
+ movLeft2Result(left, MSB32, result, MSB24);
+ addSign(result, MSB32, sign);
+ }
+ else{
+ shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0);
+ shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount);
+ /* the last shift is signed */
+ shiftR1Left2Result(left, MSB32, result, MSB24, shCount, sign);
+ addSign(result, MSB32, sign);
+ }
+ }
+ else{ /* 1 <= shCount <= 7 */
+ if(shCount <= 2){
+ shiftRLong(left, LSB, result, sign);
+ if(shCount == 2)
+ shiftRLong(result, LSB, result, sign);
+ }
+ else{
+ shiftR2Left2Result(left, LSB, result, LSB, shCount, 0);
+ shiftLLeftOrResult(left, MSB24, result, MSB16, 8 - shCount);
+ shiftR2Left2Result(left, MSB24, result, MSB24, shCount, sign);
+ }
+ }
}
/*-----------------------------------------------------------------*/
/* genRightShiftLiteral - right shifting by known count */
/*-----------------------------------------------------------------*/
static void genRightShiftLiteral (operand *left,
- operand *right,
- operand *result,
- iCode *ic,
- int sign)
+ operand *right,
+ operand *result,
+ iCode *ic,
+ int sign)
{
- int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
- int lsize,res_size;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- freeAsmop(right,NULL,ic,TRUE);
-
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
+ int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+ int lsize,res_size;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ freeAsmop(right,NULL,ic,TRUE);
+
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
#if VIEW_SIZE
- pic14_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
- AOP_SIZE(left));
+ pic14_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
+ AOP_SIZE(left));
#endif
-
- lsize = pic14_getDataSize(left);
- res_size = pic14_getDataSize(result);
- /* test the LEFT size !!! */
-
- /* I suppose that the left size >= result size */
- if(shCount == 0){
- while(res_size--)
- movLeft2Result(left, lsize, result, res_size);
- }
-
- else if(shCount >= (lsize * 8)){
-
- if(res_size == 1) {
- emitpcode(POC_CLRF, popGet(AOP(result),LSB));
- if(sign) {
- emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(result),LSB));
- }
- } else {
-
- if(sign) {
- emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
- emitpcode(POC_MOVLW, popGetLit(0xff));
- while(res_size--)
- emitpcode(POC_MOVWF, popGet(AOP(result),res_size));
-
- } else {
-
- while(res_size--)
- emitpcode(POC_CLRF, popGet(AOP(result),res_size));
- }
- }
- } else {
-
- switch (res_size) {
- case 1:
- genrshOne (result,left,shCount,sign);
- break;
-
- case 2:
- genrshTwo (result,left,shCount,sign);
- break;
-
- case 4:
- genrshFour (result,left,shCount,sign);
- break;
- default :
- break;
- }
-
- }
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+
+ lsize = pic14_getDataSize(left);
+ res_size = pic14_getDataSize(result);
+ /* test the LEFT size !!! */
+
+ /* I suppose that the left size >= result size */
+ if(shCount == 0){
+ while(res_size--)
+ movLeft2Result(left, lsize, result, res_size);
+ }
+
+ else if(shCount >= (lsize * 8)){
+
+ if(res_size == 1) {
+ emitpcode(POC_CLRF, popGet(AOP(result),LSB));
+ if(sign) {
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),LSB));
+ }
+ } else {
+
+ if(sign) {
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ while(res_size--)
+ emitpcode(POC_MOVWF, popGet(AOP(result),res_size));
+
+ } else {
+
+ while(res_size--)
+ emitpcode(POC_CLRF, popGet(AOP(result),res_size));
+ }
+ }
+ } else {
+
+ switch (res_size) {
+ case 1:
+ genrshOne (result,left,shCount,sign);
+ break;
+
+ case 2:
+ genrshTwo (result,left,shCount,sign);
+ break;
+
+ case 4:
+ genrshFour (result,left,shCount,sign);
+ break;
+ default :
+ break;
+ }
+
+ }
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genSignedRightShift (iCode *ic)
{
- operand *right, *left, *result;
- int size, offset;
- // char *l;
- symbol *tlbl, *tlbl1 ;
- pCodeOp *pctemp;
-
- //same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
-
- /* we do it the hard way put the shift count in b
- and loop thru preserving the sign */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- right = IC_RIGHT(ic);
- left = IC_LEFT(ic);
- result = IC_RESULT(ic);
-
- aopOp(right,ic,FALSE);
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
-
- if ( AOP_TYPE(right) == AOP_LIT) {
- genRightShiftLiteral (left,right,result,ic,1);
- return ;
- }
- /* shift count is unknown then we have to form
- a loop get the loop count in B : Note: we take
- only the lower order byte since shifting
- more that 32 bits make no sense anyway, ( the
- largest size of an object can be only 32 bits ) */
-
- //pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
- //pic14_emitcode("inc","b");
- //freeAsmop (right,NULL,ic,TRUE);
- //aopOp(left,ic,FALSE);
- //aopOp(result,ic,FALSE);
-
- /* now move the left to the result if they are not the
- same */
- if (!pic14_sameRegs(AOP(left),AOP(result)) &&
- AOP_SIZE(result) > 1) {
-
- size = AOP_SIZE(result);
- offset=0;
- while (size--) {
- /*
- l = aopGet(AOP(left),offset,FALSE,TRUE);
- if (*l == '@' && IS_AOP_PREG(result)) {
-
- pic14_emitcode("mov","a,%s",l);
- aopPut(AOP(result),"a",offset);
- } else
- aopPut(AOP(result),l,offset);
- */
- emitpcode(POC_MOVFW, popGet(AOP(left),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
-
- offset++;
- }
- }
-
- /* mov the highest order bit to OVR */
- tlbl = newiTempLabel(NULL);
- tlbl1= newiTempLabel(NULL);
-
- size = AOP_SIZE(result);
- offset = size - 1;
-
- pctemp = popGetTempReg(); /* grab a temporary working register. */
-
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
-
- /* offset should be 0, 1 or 3 */
- emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
- emitSKPNZ;
- emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
-
- emitpcode(POC_MOVWF, pctemp);
-
-
- emitpLabel(tlbl->key);
-
- emitpcode(POC_RLFW, popGet(AOP(result),offset));
- emitpcode(POC_RRF, popGet(AOP(result),offset));
-
- while(--size) {
- emitpcode(POC_RRF, popGet(AOP(result),--offset));
- }
-
- emitpcode(POC_DECFSZ, pctemp);
- emitpcode(POC_GOTO,popGetLabel(tlbl->key));
- emitpLabel(tlbl1->key);
-
- popReleaseTempReg(pctemp);
+ operand *right, *left, *result;
+ int size, offset;
+ // char *l;
+ symbol *tlbl, *tlbl1 ;
+ pCodeOp *pctemp;
+
+ //same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+ /* we do it the hard way put the shift count in b
+ and loop thru preserving the sign */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ right = IC_RIGHT(ic);
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+
+ aopOp(right,ic,FALSE);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+
+ if ( AOP_TYPE(right) == AOP_LIT) {
+ genRightShiftLiteral (left,right,result,ic,1);
+ return ;
+ }
+ /* shift count is unknown then we have to form
+ a loop get the loop count in B : Note: we take
+ only the lower order byte since shifting
+ more that 32 bits make no sense anyway, ( the
+ largest size of an object can be only 32 bits ) */
+
+ //pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ //pic14_emitcode("inc","b");
+ //freeAsmop (right,NULL,ic,TRUE);
+ //aopOp(left,ic,FALSE);
+ //aopOp(result,ic,FALSE);
+
+ /* now move the left to the result if they are not the
+ same */
+ if (!pic14_sameRegs(AOP(left),AOP(result)) &&
+ AOP_SIZE(result) > 1) {
+
+ size = AOP_SIZE(result);
+ offset=0;
+ while (size--) {
+ /*
+ l = aopGet(AOP(left),offset,FALSE,TRUE);
+ if (*l == '@' && IS_AOP_PREG(result)) {
+
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offset);
+ } else
+ aopPut(AOP(result),l,offset);
+ */
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+ offset++;
+ }
+ }
+
+ /* mov the highest order bit to OVR */
+ tlbl = newiTempLabel(NULL);
+ tlbl1= newiTempLabel(NULL);
+
+ size = AOP_SIZE(result);
+ offset = size - 1;
+
+ pctemp = popGetTempReg(); /* grab a temporary working register. */
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+ /* offset should be 0, 1 or 3 */
+ emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
+ emitSKPNZ;
+ emitpcode(POC_GOTO, popGetLabel(tlbl1->key));
+
+ emitpcode(POC_MOVWF, pctemp);
+
+
+ emitpLabel(tlbl->key);
+
+ emitpcode(POC_RLFW, popGet(AOP(result),offset));
+ emitpcode(POC_RRF, popGet(AOP(result),offset));
+
+ while(--size) {
+ emitpcode(POC_RRF, popGet(AOP(result),--offset));
+ }
+
+ emitpcode(POC_DECFSZ, pctemp);
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+ emitpLabel(tlbl1->key);
+
+ popReleaseTempReg(pctemp);
#if 0
- size = AOP_SIZE(result);
- offset = size - 1;
- pic14_emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE));
- pic14_emitcode("rlc","a");
- pic14_emitcode("mov","ov,c");
- /* if it is only one byte then */
- if (size == 1) {
- l = aopGet(AOP(left),0,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_emitcode("mov","c,ov");
- pic14_emitcode("rrc","a");
- pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
- pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
- aopPut(AOP(result),"a",0);
- goto release ;
- }
-
- reAdjustPreg(AOP(result));
- pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_emitcode("mov","c,ov");
- while (size--) {
- l = aopGet(AOP(result),offset,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"a",offset--);
- }
- reAdjustPreg(AOP(result));
- pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
- pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
-
- release:
+ size = AOP_SIZE(result);
+ offset = size - 1;
+ pic14_emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE));
+ pic14_emitcode("rlc","a");
+ pic14_emitcode("mov","ov,c");
+ /* if it is only one byte then */
+ if (size == 1) {
+ l = aopGet(AOP(left),0,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_emitcode("mov","c,ov");
+ pic14_emitcode("rrc","a");
+ pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+ aopPut(AOP(result),"a",0);
+ goto release ;
+ }
+
+ reAdjustPreg(AOP(result));
+ pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_emitcode("mov","c,ov");
+ while (size--) {
+ l = aopGet(AOP(result),offset,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",offset--);
+ }
+ reAdjustPreg(AOP(result));
+ pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
+release:
#endif
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
- freeAsmop(right,NULL,ic,TRUE);
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(right,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genRightShift (iCode *ic)
{
- operand *right, *left, *result;
- sym_link *retype ;
- int size, offset;
- char *l;
- symbol *tlbl, *tlbl1 ;
-
- /* if signed then we do it the hard way preserve the
- sign bit moving it inwards */
- retype = getSpec(operandType(IC_RESULT(ic)));
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if (!SPEC_USIGN(retype)) {
- genSignedRightShift (ic);
- return ;
- }
-
- /* signed & unsigned types are treated the same : i.e. the
- signed is NOT propagated inwards : quoting from the
- ANSI - standard : "for E1 >> E2, is equivalent to division
- by 2**E2 if unsigned or if it has a non-negative value,
- otherwise the result is implementation defined ", MY definition
- is that the sign does not get propagated */
-
- right = IC_RIGHT(ic);
- left = IC_LEFT(ic);
- result = IC_RESULT(ic);
-
- aopOp(right,ic,FALSE);
-
- /* if the shift count is known then do it
- as efficiently as possible */
- if (AOP_TYPE(right) == AOP_LIT) {
- genRightShiftLiteral (left,right,result,ic, 0);
- return ;
- }
-
- /* shift count is unknown then we have to form
- a loop get the loop count in B : Note: we take
- only the lower order byte since shifting
- more that 32 bits make no sense anyway, ( the
- largest size of an object can be only 32 bits ) */
-
- pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
- pic14_emitcode("inc","b");
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
- /* now move the left to the result if they are not the
- same */
- if (!pic14_sameRegs(AOP(left),AOP(result)) &&
- AOP_SIZE(result) > 1) {
-
- size = AOP_SIZE(result);
- offset=0;
- while (size--) {
- l = aopGet(AOP(left),offset,FALSE,TRUE);
- if (*l == '@' && IS_AOP_PREG(result)) {
-
- pic14_emitcode("mov","a,%s",l);
- aopPut(AOP(result),"a",offset);
- } else
- aopPut(AOP(result),l,offset);
- offset++;
- }
- }
-
- tlbl = newiTempLabel(NULL);
- tlbl1= newiTempLabel(NULL);
- size = AOP_SIZE(result);
- offset = size - 1;
-
- /* if it is only one byte then */
- if (size == 1) {
-
- tlbl = newiTempLabel(NULL);
- if (!pic14_sameRegs(AOP(left),AOP(result))) {
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
- }
-
- emitpcode(POC_COMFW, popGet(AOP(right),0));
- emitpcode(POC_RLF, popGet(AOP(result),0));
- emitpLabel(tlbl->key);
- emitpcode(POC_RRF, popGet(AOP(result),0));
- emitpcode(POC_ADDLW, popGetLit(1));
- emitSKPC;
- emitpcode(POC_GOTO,popGetLabel(tlbl->key));
-
- goto release ;
- }
-
- reAdjustPreg(AOP(result));
- pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- CLRC;
- while (size--) {
- l = aopGet(AOP(result),offset,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("rrc","a");
- aopPut(AOP(result),"a",offset--);
- }
- reAdjustPreg(AOP(result));
-
- pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
- pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
-
+ operand *right, *left, *result;
+ sym_link *retype ;
+ int size, offset;
+ char *l;
+ symbol *tlbl, *tlbl1 ;
+
+ /* if signed then we do it the hard way preserve the
+ sign bit moving it inwards */
+ retype = getSpec(operandType(IC_RESULT(ic)));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (!SPEC_USIGN(retype)) {
+ genSignedRightShift (ic);
+ return ;
+ }
+
+ /* signed & unsigned types are treated the same : i.e. the
+ signed is NOT propagated inwards : quoting from the
+ ANSI - standard : "for E1 >> E2, is equivalent to division
+ by 2**E2 if unsigned or if it has a non-negative value,
+ otherwise the result is implementation defined ", MY definition
+ is that the sign does not get propagated */
+
+ right = IC_RIGHT(ic);
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+
+ aopOp(right,ic,FALSE);
+
+ /* if the shift count is known then do it
+ as efficiently as possible */
+ if (AOP_TYPE(right) == AOP_LIT) {
+ genRightShiftLiteral (left,right,result,ic, 0);
+ return ;
+ }
+
+ /* shift count is unknown then we have to form
+ a loop get the loop count in B : Note: we take
+ only the lower order byte since shifting
+ more that 32 bits make no sense anyway, ( the
+ largest size of an object can be only 32 bits ) */
+
+ pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+ pic14_emitcode("inc","b");
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+ /* now move the left to the result if they are not the
+ same */
+ if (!pic14_sameRegs(AOP(left),AOP(result)) &&
+ AOP_SIZE(result) > 1) {
+
+ size = AOP_SIZE(result);
+ offset=0;
+ while (size--) {
+ l = aopGet(AOP(left),offset,FALSE,TRUE);
+ if (*l == '@' && IS_AOP_PREG(result)) {
+
+ pic14_emitcode("mov","a,%s",l);
+ aopPut(AOP(result),"a",offset);
+ } else
+ aopPut(AOP(result),l,offset);
+ offset++;
+ }
+ }
+
+ tlbl = newiTempLabel(NULL);
+ tlbl1= newiTempLabel(NULL);
+ size = AOP_SIZE(result);
+ offset = size - 1;
+
+ /* if it is only one byte then */
+ if (size == 1) {
+
+ tlbl = newiTempLabel(NULL);
+ if (!pic14_sameRegs(AOP(left),AOP(result))) {
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ }
+
+ emitpcode(POC_COMFW, popGet(AOP(right),0));
+ emitpcode(POC_RLF, popGet(AOP(result),0));
+ emitpLabel(tlbl->key);
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+ emitpcode(POC_ADDLW, popGetLit(1));
+ emitSKPC;
+ emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+
+ goto release ;
+ }
+
+ reAdjustPreg(AOP(result));
+ pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ CLRC;
+ while (size--) {
+ l = aopGet(AOP(result),offset,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("rrc","a");
+ aopPut(AOP(result),"a",offset--);
+ }
+ reAdjustPreg(AOP(result));
+
+ pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+ pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
release:
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop (right,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop (right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genUnpackBits (operand *result, char *rname, int ptype)
{
- int shCnt ;
- int rlen = 0 ;
- sym_link *etype;
- int offset = 0 ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- etype = getSpec(operandType(result));
-
- /* read the first byte */
- switch (ptype) {
-
- case POINTER:
- case IPOINTER:
- pic14_emitcode("mov","a,@%s",rname);
- break;
+ int shCnt ;
+ int rlen = 0 ;
+ sym_link *etype;
+ int offset = 0 ;
- case PPOINTER:
- pic14_emitcode("movx","a,@%s",rname);
- break;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ etype = getSpec(operandType(result));
- case FPOINTER:
- pic14_emitcode("movx","a,@dptr");
- break;
-
- case CPOINTER:
- pic14_emitcode("clr","a");
- pic14_emitcode("movc","a","@a+dptr");
- break;
-
- case GPOINTER:
- pic14_emitcode("lcall","__gptrget");
- break;
- }
-
- /* if we have bitdisplacement then it fits */
- /* into this byte completely or if length is */
- /* less than a byte */
- if ((shCnt = SPEC_BSTR(etype)) ||
- (SPEC_BLEN(etype) <= 8)) {
-
- /* shift right acc */
- AccRsh(shCnt);
-
- pic14_emitcode("anl","a,#0x%02x",
- ((unsigned char) -1)>>(8 - SPEC_BLEN(etype)));
- aopPut(AOP(result),"a",offset);
- return ;
- }
-
- /* bit field did not fit in a byte */
- rlen = SPEC_BLEN(etype) - 8;
- aopPut(AOP(result),"a",offset++);
-
- while (1) {
-
+ /* read the first byte */
switch (ptype) {
+
case POINTER:
case IPOINTER:
- pic14_emitcode("inc","%s",rname);
- pic14_emitcode("mov","a,@%s",rname);
- break;
-
+ pic14_emitcode("mov","a,@%s",rname);
+ break;
+
case PPOINTER:
- pic14_emitcode("inc","%s",rname);
- pic14_emitcode("movx","a,@%s",rname);
- break;
-
+ pic14_emitcode("movx","a,@%s",rname);
+ break;
+
case FPOINTER:
- pic14_emitcode("inc","dptr");
- pic14_emitcode("movx","a,@dptr");
- break;
-
+ pic14_emitcode("movx","a,@dptr");
+ break;
+
case CPOINTER:
- pic14_emitcode("clr","a");
- pic14_emitcode("inc","dptr");
- pic14_emitcode("movc","a","@a+dptr");
- break;
-
+ pic14_emitcode("clr","a");
+ pic14_emitcode("movc","a","@a+dptr");
+ break;
+
case GPOINTER:
- pic14_emitcode("inc","dptr");
- pic14_emitcode("lcall","__gptrget");
- break;
- }
-
- rlen -= 8;
- /* if we are done */
- if ( rlen <= 0 )
- break ;
+ pic14_emitcode("lcall","__gptrget");
+ break;
+ }
+
+ /* if we have bitdisplacement then it fits */
+ /* into this byte completely or if length is */
+ /* less than a byte */
+ if ((shCnt = SPEC_BSTR(etype)) ||
+ (SPEC_BLEN(etype) <= 8)) {
+
+ /* shift right acc */
+ AccRsh(shCnt);
+
+ pic14_emitcode("anl","a,#0x%02x",
+ ((unsigned char) -1)>>(8 - SPEC_BLEN(etype)));
+ aopPut(AOP(result),"a",offset);
+ return ;
+ }
+ /* bit field did not fit in a byte */
+ rlen = SPEC_BLEN(etype) - 8;
aopPut(AOP(result),"a",offset++);
-
- }
-
- if (rlen) {
- pic14_emitcode("anl","a,#0x%02x",((unsigned char)-1)>>(-rlen));
- aopPut(AOP(result),"a",offset);
- }
-
- return ;
+
+ while (1) {
+
+ switch (ptype) {
+ case POINTER:
+ case IPOINTER:
+ pic14_emitcode("inc","%s",rname);
+ pic14_emitcode("mov","a,@%s",rname);
+ break;
+
+ case PPOINTER:
+ pic14_emitcode("inc","%s",rname);
+ pic14_emitcode("movx","a,@%s",rname);
+ break;
+
+ case FPOINTER:
+ pic14_emitcode("inc","dptr");
+ pic14_emitcode("movx","a,@dptr");
+ break;
+
+ case CPOINTER:
+ pic14_emitcode("clr","a");
+ pic14_emitcode("inc","dptr");
+ pic14_emitcode("movc","a","@a+dptr");
+ break;
+
+ case GPOINTER:
+ pic14_emitcode("inc","dptr");
+ pic14_emitcode("lcall","__gptrget");
+ break;
+ }
+
+ rlen -= 8;
+ /* if we are done */
+ if ( rlen <= 0 )
+ break ;
+
+ aopPut(AOP(result),"a",offset++);
+
+ }
+
+ if (rlen) {
+ pic14_emitcode("anl","a,#0x%02x",((unsigned char)-1)>>(-rlen));
+ aopPut(AOP(result),"a",offset);
+ }
+
+ return ;
}
#if 0
/* genDataPointerGet - generates code when ptr offset is known */
/*-----------------------------------------------------------------*/
static void genDataPointerGet (operand *left,
- operand *result,
- iCode *ic)
+ operand *result,
+ iCode *ic)
{
- int size , offset = 0;
-
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
-
- /* optimization - most of the time, left and result are the same
- * address, but different types. for the pic code, we could omit
- * the following
- */
-
- aopOp(result,ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,left,NULL,result);
-
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
-
- size = AOP_SIZE(result);
-
- while (size--) {
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- offset++;
- }
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+ int size , offset = 0;
+
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ /* optimization - most of the time, left and result are the same
+ * address, but different types. for the pic code, we could omit
+ * the following
+ */
+
+ aopOp(result,ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+
+ size = AOP_SIZE(result);
+
+ while (size--) {
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ offset++;
+ }
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
#endif
/*-----------------------------------------------------------------*/
/* genNearPointerGet - pic14_emitcode for near pointer fetch */
/*-----------------------------------------------------------------*/
static void genNearPointerGet (operand *left,
- operand *result,
- iCode *ic)
-{
- asmop *aop = NULL;
- //regs *preg = NULL ;
- char *rname ;
- sym_link *rtype, *retype;
- sym_link *ltype = operandType(left);
- //char buffer[80];
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- rtype = operandType(result);
- retype= getSpec(rtype);
-
- aopOp(left,ic,FALSE);
-
- /* if left is rematerialisable and
- result is not bit variable type and
- the left is pointer to data space i.e
- lower 128 bytes of space */
- if (AOP_TYPE(left) == AOP_PCODE && //AOP_TYPE(left) == AOP_IMMD &&
- !IS_BITVAR(retype) &&
- DCL_TYPE(ltype) == POINTER) {
- //genDataPointerGet (left,result,ic);
- return ;
- }
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ //regs *preg = NULL ;
+ char *rname ;
+ sym_link *rtype, *retype;
+ sym_link *ltype = operandType(left);
+ //char buffer[80];
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ rtype = operandType(result);
+ retype= getSpec(rtype);
+
+ aopOp(left,ic,FALSE);
+
+ /* if left is rematerialisable and
+ result is not bit variable type and
+ the left is pointer to data space i.e
+ lower 128 bytes of space */
+ if (AOP_TYPE(left) == AOP_PCODE && //AOP_TYPE(left) == AOP_IMMD &&
+ !IS_BITVAR(retype) &&
+ DCL_TYPE(ltype) == POINTER) {
+ //genDataPointerGet (left,result,ic);
+ return ;
+ }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
/* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG(AOP(left))) {
- /* otherwise get a free pointer register */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-/*
- aop = newAsmop(0);
- preg = getFreePtr(ic,&aop,FALSE);
- pic14_emitcode("mov","%s,%s",
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(left))) {
+ /* otherwise get a free pointer register */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /*
+ aop = newAsmop(0);
+ preg = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,%s",
preg->name,
aopGet(AOP(left),0,FALSE,TRUE));
- rname = preg->name ;
-*/
- rname ="BAD";
- } else
- rname = aopGet(AOP(left),0,FALSE,FALSE);
-
- aopOp (result,ic,FALSE);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR(retype))
- genUnpackBits (result,rname,POINTER);
- else {
- /* we have can just get the values */
- int size = AOP_SIZE(result);
- int offset = 0 ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- emitpcode(POC_MOVFW,popGet(AOP(left),0));
- emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
- while(size--) {
- emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
- if(size)
- emitpcode(POC_INCF,popCopyReg(&pc_fsr));
- }
-/*
- while (size--) {
- if (IS_AOP_PREG(result) || AOP_TYPE(result) == AOP_STK ) {
-
- pic14_emitcode("mov","a,@%s",rname);
- aopPut(AOP(result),"a",offset);
- } else {
- sprintf(buffer,"@%s",rname);
- aopPut(AOP(result),buffer,offset);
- }
- offset++ ;
- if (size)
- pic14_emitcode("inc","%s",rname);
+ rname = preg->name ;
+ */
+ rname ="BAD";
+ } else
+ rname = aopGet(AOP(left),0,FALSE,FALSE);
+
+ aopOp (result,ic,FALSE);
+
+ /* if bitfield then unpack the bits */
+ if (IS_BITVAR(retype))
+ genUnpackBits (result,rname,POINTER);
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(result);
+ int offset = 0 ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+ while(size--) {
+ emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
+ if(size)
+ emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ }
+ /*
+ while (size--) {
+ if (IS_AOP_PREG(result) || AOP_TYPE(result) == AOP_STK ) {
+
+ pic14_emitcode("mov","a,@%s",rname);
+ aopPut(AOP(result),"a",offset);
+ } else {
+ sprintf(buffer,"@%s",rname);
+ aopPut(AOP(result),buffer,offset);
+ }
+ offset++ ;
+ if (size)
+ pic14_emitcode("inc","%s",rname);
+ }
+ */
}
-*/
- }
-
- /* now some housekeeping stuff */
- if (aop) {
- /* we had to allocate for this iCode */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- freeAsmop(NULL,aop,ic,TRUE);
- } else {
+
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
/* we did not allocate which means left
already in a pointer register, then
if size > 0 && this could be used again
we have to point it back to where it
- belongs */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_SIZE(result) > 1 &&
- !OP_SYMBOL(left)->remat &&
- ( OP_SYMBOL(left)->liveTo > ic->seq ||
- ic->depth )) {
- int size = AOP_SIZE(result) - 1;
- while (size--)
- pic14_emitcode("dec","%s",rname);
+ belongs */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (AOP_SIZE(result) > 1 &&
+ !OP_SYMBOL(left)->remat &&
+ ( OP_SYMBOL(left)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(result) - 1;
+ while (size--)
+ pic14_emitcode("dec","%s",rname);
+ }
+ }
+
+ /* done */
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genPagedPointerGet - pic14_emitcode for paged pointer fetch */
+/*-----------------------------------------------------------------*/
+static void genPagedPointerGet (operand *left,
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ regs *preg = NULL ;
+ char *rname ;
+ sym_link *rtype, *retype;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ rtype = operandType(result);
+ retype= getSpec(rtype);
+
+ aopOp(left,ic,FALSE);
+
+ /* if the value is already in a pointer register
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(left))) {
+ /* otherwise get a free pointer register */
+ aop = newAsmop(0);
+ preg = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,%s",
+ preg->name,
+ aopGet(AOP(left),0,FALSE,TRUE));
+ rname = preg->name ;
+ } else
+ rname = aopGet(AOP(left),0,FALSE,FALSE);
+
+ freeAsmop(left,NULL,ic,TRUE);
+ aopOp (result,ic,FALSE);
+
+ /* if bitfield then unpack the bits */
+ if (IS_BITVAR(retype))
+ genUnpackBits (result,rname,PPOINTER);
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(result);
+ int offset = 0 ;
+
+ while (size--) {
+
+ pic14_emitcode("movx","a,@%s",rname);
+ aopPut(AOP(result),"a",offset);
+
+ offset++ ;
+
+ if (size)
+ pic14_emitcode("inc","%s",rname);
+ }
}
- }
-
- /* done */
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
-
-}
-
-/*-----------------------------------------------------------------*/
-/* genPagedPointerGet - pic14_emitcode for paged pointer fetch */
-/*-----------------------------------------------------------------*/
-static void genPagedPointerGet (operand *left,
- operand *result,
- iCode *ic)
-{
- asmop *aop = NULL;
- regs *preg = NULL ;
- char *rname ;
- sym_link *rtype, *retype;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- rtype = operandType(result);
- retype= getSpec(rtype);
-
- aopOp(left,ic,FALSE);
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG(AOP(left))) {
- /* otherwise get a free pointer register */
- aop = newAsmop(0);
- preg = getFreePtr(ic,&aop,FALSE);
- pic14_emitcode("mov","%s,%s",
- preg->name,
- aopGet(AOP(left),0,FALSE,TRUE));
- rname = preg->name ;
- } else
- rname = aopGet(AOP(left),0,FALSE,FALSE);
-
- freeAsmop(left,NULL,ic,TRUE);
- aopOp (result,ic,FALSE);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR(retype))
- genUnpackBits (result,rname,PPOINTER);
- else {
- /* we have can just get the values */
- int size = AOP_SIZE(result);
- int offset = 0 ;
- while (size--) {
-
- pic14_emitcode("movx","a,@%s",rname);
- aopPut(AOP(result),"a",offset);
-
- offset++ ;
-
- if (size)
- pic14_emitcode("inc","%s",rname);
- }
- }
-
- /* now some housekeeping stuff */
- if (aop) {
- /* we had to allocate for this iCode */
- freeAsmop(NULL,aop,ic,TRUE);
- } else {
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
/* we did not allocate which means left
already in a pointer register, then
if size > 0 && this could be used again
we have to point it back to where it
- belongs */
- if (AOP_SIZE(result) > 1 &&
- !OP_SYMBOL(left)->remat &&
- ( OP_SYMBOL(left)->liveTo > ic->seq ||
- ic->depth )) {
- int size = AOP_SIZE(result) - 1;
- while (size--)
- pic14_emitcode("dec","%s",rname);
+ belongs */
+ if (AOP_SIZE(result) > 1 &&
+ !OP_SYMBOL(left)->remat &&
+ ( OP_SYMBOL(left)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(result) - 1;
+ while (size--)
+ pic14_emitcode("dec","%s",rname);
+ }
}
- }
-
- /* done */
- freeAsmop(result,NULL,ic,TRUE);
-
+
+ /* done */
+ freeAsmop(result,NULL,ic,TRUE);
+
}
/* genFarPointerGet - gget value from far space */
/*-----------------------------------------------------------------*/
static void genFarPointerGet (operand *left,
- operand *result, iCode *ic)
-{
- int size, offset ;
- sym_link *retype = getSpec(operandType(result));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp(left,ic,FALSE);
-
- /* if the operand is already in dptr
- then we do nothing else we move the value to dptr */
- if (AOP_TYPE(left) != AOP_STR) {
- /* if this is remateriazable */
- if (AOP_TYPE(left) == AOP_IMMD)
- pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
- else { /* we need to get it byte by byte */
- pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
- pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
- if (options.model == MODEL_FLAT24)
- {
- pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
- }
- }
- }
- /* so dptr know contains the address */
- freeAsmop(left,NULL,ic,TRUE);
- aopOp(result,ic,FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR(retype))
- genUnpackBits(result,"dptr",FPOINTER);
- else {
- size = AOP_SIZE(result);
- offset = 0 ;
-
- while (size--) {
- pic14_emitcode("movx","a,@dptr");
- aopPut(AOP(result),"a",offset++);
- if (size)
- pic14_emitcode("inc","dptr");
- }
- }
-
- freeAsmop(result,NULL,ic,TRUE);
+ operand *result, iCode *ic)
+{
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(result));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(left,ic,FALSE);
+
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE(left) != AOP_STR) {
+ /* if this is remateriazable */
+ if (AOP_TYPE(left) == AOP_IMMD)
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
+ else { /* we need to get it byte by byte */
+ pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
+ pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
+ if (options.model == MODEL_FLAT24)
+ {
+ pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
+ }
+ }
+ }
+ /* so dptr know contains the address */
+ freeAsmop(left,NULL,ic,TRUE);
+ aopOp(result,ic,FALSE);
+
+ /* if bit then unpack */
+ if (IS_BITVAR(retype))
+ genUnpackBits(result,"dptr",FPOINTER);
+ else {
+ size = AOP_SIZE(result);
+ offset = 0 ;
+
+ while (size--) {
+ pic14_emitcode("movx","a,@dptr");
+ aopPut(AOP(result),"a",offset++);
+ if (size)
+ pic14_emitcode("inc","dptr");
+ }
+ }
+
+ freeAsmop(result,NULL,ic,TRUE);
}
#if 0
/*-----------------------------------------------------------------*/
/* genCodePointerGet - get value from code space */
/*-----------------------------------------------------------------*/
static void genCodePointerGet (operand *left,
- operand *result, iCode *ic)
-{
- int size, offset ;
- sym_link *retype = getSpec(operandType(result));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp(left,ic,FALSE);
-
- /* if the operand is already in dptr
- then we do nothing else we move the value to dptr */
- if (AOP_TYPE(left) != AOP_STR) {
- /* if this is remateriazable */
- if (AOP_TYPE(left) == AOP_IMMD)
- pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
- else { /* we need to get it byte by byte */
- pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
- pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
- if (options.model == MODEL_FLAT24)
- {
- pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
- }
- }
- }
- /* so dptr know contains the address */
- freeAsmop(left,NULL,ic,TRUE);
- aopOp(result,ic,FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR(retype))
- genUnpackBits(result,"dptr",CPOINTER);
- else {
- size = AOP_SIZE(result);
- offset = 0 ;
-
- while (size--) {
- pic14_emitcode("clr","a");
- pic14_emitcode("movc","a,@a+dptr");
- aopPut(AOP(result),"a",offset++);
- if (size)
- pic14_emitcode("inc","dptr");
- }
- }
-
- freeAsmop(result,NULL,ic,TRUE);
+ operand *result, iCode *ic)
+{
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(result));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(left,ic,FALSE);
+
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE(left) != AOP_STR) {
+ /* if this is remateriazable */
+ if (AOP_TYPE(left) == AOP_IMMD)
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
+ else { /* we need to get it byte by byte */
+ pic14_emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE));
+ pic14_emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE));
+ if (options.model == MODEL_FLAT24)
+ {
+ pic14_emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE));
+ }
+ }
+ }
+ /* so dptr know contains the address */
+ freeAsmop(left,NULL,ic,TRUE);
+ aopOp(result,ic,FALSE);
+
+ /* if bit then unpack */
+ if (IS_BITVAR(retype))
+ genUnpackBits(result,"dptr",CPOINTER);
+ else {
+ size = AOP_SIZE(result);
+ offset = 0 ;
+
+ while (size--) {
+ pic14_emitcode("clr","a");
+ pic14_emitcode("movc","a,@a+dptr");
+ aopPut(AOP(result),"a",offset++);
+ if (size)
+ pic14_emitcode("inc","dptr");
+ }
+ }
+
+ freeAsmop(result,NULL,ic,TRUE);
}
#endif
/*-----------------------------------------------------------------*/
/* genGenPointerGet - gget value from generic pointer space */
/*-----------------------------------------------------------------*/
static void genGenPointerGet (operand *left,
- operand *result, iCode *ic)
+ operand *result, iCode *ic)
{
- int size, offset ;
- sym_link *retype = getSpec(operandType(result));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
-
- DEBUGpic14_AopType(__LINE__,left,NULL,result);
-
- /* if the operand is already in dptr
- then we do nothing else we move the value to dptr */
- // if (AOP_TYPE(left) != AOP_STR) {
- /* if this is remateriazable */
- if (AOP_TYPE(left) == AOP_IMMD) {
- pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
- pic14_emitcode("mov","b,#%d",pointerCode(retype));
- }
- else { /* we need to get it byte by byte */
-
- emitpcode(POC_MOVFW,popGet(AOP(left),0));
- emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
-
- size = AOP_SIZE(result);
- offset = 0 ;
-
- while(size--) {
- emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
- emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
- if(size)
- emitpcode(POC_INCF,popCopyReg(&pc_fsr));
- }
- goto release;
- }
- //}
- /* so dptr know contains the address */
-
- /* if bit then unpack */
- //if (IS_BITVAR(retype))
- // genUnpackBits(result,"dptr",GPOINTER);
-
- release:
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
-
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(result));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ // if (AOP_TYPE(left) != AOP_STR) {
+ /* if this is remateriazable */
+ if (AOP_TYPE(left) == AOP_IMMD) {
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
+ pic14_emitcode("mov","b,#%d",pointerCode(retype));
+ }
+ else { /* we need to get it byte by byte */
+
+ emitpcode(POC_MOVFW,popGet(AOP(left),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+
+ size = AOP_SIZE(result);
+ offset = 0 ;
+
+ while(size--) {
+ emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
+ emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
+ if(size)
+ emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ }
+ goto release;
+ }
+ //}
+ /* so dptr know contains the address */
+
+ /* if bit then unpack */
+ //if (IS_BITVAR(retype))
+ // genUnpackBits(result,"dptr",GPOINTER);
+
+release:
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
}
/*-----------------------------------------------------------------*/
/* genConstPointerGet - get value from const generic pointer space */
/*-----------------------------------------------------------------*/
static void genConstPointerGet (operand *left,
- operand *result, iCode *ic)
+ operand *result, iCode *ic)
{
- //sym_link *retype = getSpec(operandType(result));
- symbol *albl = newiTempLabel(NULL);
- symbol *blbl = newiTempLabel(NULL);
- PIC_OPCODE poc;
- pCodeOp *pcop;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp(left,ic,FALSE);
- aopOp(result,ic,FALSE);
-
-
- DEBUGpic14_AopType(__LINE__,left,NULL,result);
-
- DEBUGpic14_emitcode ("; "," %d getting const pointer",__LINE__);
-
- emitpcode(POC_CALL,popGetLabel(albl->key));
- pcop = popGetLabel(blbl->key);
- emitpcode(POC_PAGESEL,popGetWithString(pcop->name,0)); /* Must restore PCLATH before goto, without destroying W */
- emitpcode(POC_GOTO,pcop);
- emitpLabel(albl->key);
-
- poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
-
- emitpcode(poc,popGet(AOP(left),1));
- emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
- emitpcode(poc,popGet(AOP(left),0));
- emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
-
- emitpLabel(blbl->key);
-
- emitpcode(POC_MOVWF,popGet(AOP(result),0));
-
-
- freeAsmop(left,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
-
+ //sym_link *retype = getSpec(operandType(result));
+ symbol *albl = newiTempLabel(NULL);
+ symbol *blbl = newiTempLabel(NULL);
+ PIC_OPCODE poc;
+ pCodeOp *pcop;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(left,ic,FALSE);
+ aopOp(result,ic,FALSE);
+
+
+ DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+ DEBUGpic14_emitcode ("; "," %d getting const pointer",__LINE__);
+
+ emitpcode(POC_CALL,popGetLabel(albl->key));
+ pcop = popGetLabel(blbl->key);
+ emitpcode(POC_PAGESEL,popGetWithString(pcop->name,0)); /* Must restore PCLATH before goto, without destroying W */
+ emitpcode(POC_GOTO,pcop);
+ emitpLabel(albl->key);
+
+ poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
+
+ emitpcode(poc,popGet(AOP(left),1));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
+ emitpcode(poc,popGet(AOP(left),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
+
+ emitpLabel(blbl->key);
+
+ emitpcode(POC_MOVWF,popGet(AOP(result),0));
+
+
+ freeAsmop(left,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
}
/*-----------------------------------------------------------------*/
/* genPointerGet - generate code for pointer get */
/*-----------------------------------------------------------------*/
static void genPointerGet (iCode *ic)
{
- operand *left, *result ;
- sym_link *type, *etype;
- int p_type;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- left = IC_LEFT(ic);
- result = IC_RESULT(ic) ;
-
- /* depending on the type of pointer we need to
- move it to the correct pointer register */
- type = operandType(left);
- etype = getSpec(type);
-
- if (IS_PTR_CONST(type))
- DEBUGpic14_emitcode ("; ***","%d - const pointer",__LINE__);
-
- /* if left is of type of pointer then it is simple */
- if (IS_PTR(type) && !IS_FUNC(type->next))
- p_type = DCL_TYPE(type);
- else {
- /* we have to go by the storage class */
- p_type = PTR_TYPE(SPEC_OCLS(etype));
-
- DEBUGpic14_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
-
- if (SPEC_OCLS(etype)->codesp ) {
- DEBUGpic14_emitcode ("; ***","%d - cpointer",__LINE__);
- //p_type = CPOINTER ;
+ operand *left, *result ;
+ sym_link *type, *etype;
+ int p_type;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic) ;
+
+ /* depending on the type of pointer we need to
+ move it to the correct pointer register */
+ type = operandType(left);
+ etype = getSpec(type);
+
+ if (IS_PTR_CONST(type))
+ DEBUGpic14_emitcode ("; ***","%d - const pointer",__LINE__);
+
+ /* if left is of type of pointer then it is simple */
+ if (IS_PTR(type) && !IS_FUNC(type->next))
+ p_type = DCL_TYPE(type);
+ else {
+ /* we have to go by the storage class */
+ p_type = PTR_TYPE(SPEC_OCLS(etype));
+
+ DEBUGpic14_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
+
+ if (SPEC_OCLS(etype)->codesp ) {
+ DEBUGpic14_emitcode ("; ***","%d - cpointer",__LINE__);
+ //p_type = CPOINTER ;
+ }
+ else
+ if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged)
+ DEBUGpic14_emitcode ("; ***","%d - fpointer",__LINE__);
+ /*p_type = FPOINTER ;*/
+ else
+ if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged)
+ DEBUGpic14_emitcode ("; ***","%d - ppointer",__LINE__);
+ /* p_type = PPOINTER; */
+ else
+ if (SPEC_OCLS(etype) == idata )
+ DEBUGpic14_emitcode ("; ***","%d - ipointer",__LINE__);
+ /* p_type = IPOINTER; */
+ else
+ DEBUGpic14_emitcode ("; ***","%d - pointer",__LINE__);
+ /* p_type = POINTER ; */
}
- else
- if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged)
- DEBUGpic14_emitcode ("; ***","%d - fpointer",__LINE__);
- /*p_type = FPOINTER ;*/
- else
- if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged)
- DEBUGpic14_emitcode ("; ***","%d - ppointer",__LINE__);
-/* p_type = PPOINTER; */
+
+ /* now that we have the pointer type we assign
+ the pointer values */
+ switch (p_type) {
+
+ case POINTER:
+ case IPOINTER:
+ genNearPointerGet (left,result,ic);
+ break;
+
+ case PPOINTER:
+ genPagedPointerGet(left,result,ic);
+ break;
+
+ case FPOINTER:
+ genFarPointerGet (left,result,ic);
+ break;
+
+ case CPOINTER:
+ genConstPointerGet (left,result,ic);
+ //pic14_emitcodePointerGet (left,result,ic);
+ break;
+
+ case GPOINTER:
+ if (IS_PTR_CONST(type))
+ genConstPointerGet (left,result,ic);
else
- if (SPEC_OCLS(etype) == idata )
- DEBUGpic14_emitcode ("; ***","%d - ipointer",__LINE__);
-/* p_type = IPOINTER; */
- else
- DEBUGpic14_emitcode ("; ***","%d - pointer",__LINE__);
-/* p_type = POINTER ; */
- }
-
- /* now that we have the pointer type we assign
- the pointer values */
- switch (p_type) {
-
- case POINTER:
- case IPOINTER:
- genNearPointerGet (left,result,ic);
- break;
-
- case PPOINTER:
- genPagedPointerGet(left,result,ic);
- break;
-
- case FPOINTER:
- genFarPointerGet (left,result,ic);
- break;
-
- case CPOINTER:
- genConstPointerGet (left,result,ic);
- //pic14_emitcodePointerGet (left,result,ic);
- break;
-
- case GPOINTER:
- if (IS_PTR_CONST(type))
- genConstPointerGet (left,result,ic);
- else
- genGenPointerGet (left,result,ic);
- break;
- }
-
+ genGenPointerGet (left,result,ic);
+ break;
+ }
+
}
/*-----------------------------------------------------------------*/
/* genPackBits - generates code for packed bit storage */
/*-----------------------------------------------------------------*/
static void genPackBits (sym_link *etype ,
- operand *right ,
- char *rname, int p_type)
-{
- int shCount = 0 ;
- int offset = 0 ;
- int rLen = 0 ;
- int blen, bstr ;
- char *l ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- blen = SPEC_BLEN(etype);
- bstr = SPEC_BSTR(etype);
-
- l = aopGet(AOP(right),offset++,FALSE,FALSE);
- MOVA(l);
-
- /* if the bit lenth is less than or */
- /* it exactly fits a byte then */
- if (SPEC_BLEN(etype) <= 8 ) {
- shCount = SPEC_BSTR(etype) ;
-
- /* shift left acc */
- AccLsh(shCount);
-
- if (SPEC_BLEN(etype) < 8 ) { /* if smaller than a byte */
-
-
- switch (p_type) {
- case POINTER:
- pic14_emitcode ("mov","b,a");
- pic14_emitcode("mov","a,@%s",rname);
- break;
-
- case FPOINTER:
- pic14_emitcode ("mov","b,a");
- pic14_emitcode("movx","a,@dptr");
- break;
-
- case GPOINTER:
- pic14_emitcode ("push","b");
- pic14_emitcode ("push","acc");
- pic14_emitcode ("lcall","__gptrget");
- pic14_emitcode ("pop","b");
- break;
- }
-
- pic14_emitcode ("anl","a,#0x%02x",(unsigned char)
- ((unsigned char)(0xFF << (blen+bstr)) |
- (unsigned char)(0xFF >> (8-bstr)) ) );
- pic14_emitcode ("orl","a,b");
- if (p_type == GPOINTER)
- pic14_emitcode("pop","b");
- }
- }
-
- switch (p_type) {
- case POINTER:
- pic14_emitcode("mov","@%s,a",rname);
- break;
-
- case FPOINTER:
- pic14_emitcode("movx","@dptr,a");
- break;
-
- case GPOINTER:
- DEBUGpic14_emitcode(";lcall","__gptrput");
- break;
- }
-
- /* if we r done */
- if ( SPEC_BLEN(etype) <= 8 )
- return ;
-
- pic14_emitcode("inc","%s",rname);
- rLen = SPEC_BLEN(etype) ;
-
- /* now generate for lengths greater than one byte */
- while (1) {
-
- l = aopGet(AOP(right),offset++,FALSE,TRUE);
-
- rLen -= 8 ;
- if (rLen <= 0 )
- break ;
-
- switch (p_type) {
- case POINTER:
- if (*l == '@') {
- MOVA(l);
- pic14_emitcode("mov","@%s,a",rname);
- } else
- pic14_emitcode("mov","@%s,%s",rname,l);
- break;
-
- case FPOINTER:
- MOVA(l);
- pic14_emitcode("movx","@dptr,a");
- break;
-
- case GPOINTER:
- MOVA(l);
- DEBUGpic14_emitcode(";lcall","__gptrput");
- break;
- }
- pic14_emitcode ("inc","%s",rname);
- }
-
- MOVA(l);
-
- /* last last was not complete */
- if (rLen) {
- /* save the byte & read byte */
- switch (p_type) {
- case POINTER:
- pic14_emitcode ("mov","b,a");
- pic14_emitcode("mov","a,@%s",rname);
- break;
-
- case FPOINTER:
- pic14_emitcode ("mov","b,a");
- pic14_emitcode("movx","a,@dptr");
- break;
-
- case GPOINTER:
- pic14_emitcode ("push","b");
- pic14_emitcode ("push","acc");
- pic14_emitcode ("lcall","__gptrget");
- pic14_emitcode ("pop","b");
- break;
- }
-
- pic14_emitcode ("anl","a,#0x%02x",((unsigned char)-1 << -rLen) );
- pic14_emitcode ("orl","a,b");
- }
-
- if (p_type == GPOINTER)
- pic14_emitcode("pop","b");
-
- switch (p_type) {
-
- case POINTER:
- pic14_emitcode("mov","@%s,a",rname);
- break;
-
- case FPOINTER:
- pic14_emitcode("movx","@dptr,a");
- break;
-
- case GPOINTER:
- DEBUGpic14_emitcode(";lcall","__gptrput");
- break;
- }
+ operand *right ,
+ char *rname, int p_type)
+{
+ int shCount = 0 ;
+ int offset = 0 ;
+ int rLen = 0 ;
+ int blen, bstr ;
+ char *l ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ blen = SPEC_BLEN(etype);
+ bstr = SPEC_BSTR(etype);
+
+ l = aopGet(AOP(right),offset++,FALSE,FALSE);
+ MOVA(l);
+
+ /* if the bit lenth is less than or */
+ /* it exactly fits a byte then */
+ if (SPEC_BLEN(etype) <= 8 ) {
+ shCount = SPEC_BSTR(etype) ;
+
+ /* shift left acc */
+ AccLsh(shCount);
+
+ if (SPEC_BLEN(etype) < 8 ) { /* if smaller than a byte */
+
+
+ switch (p_type) {
+ case POINTER:
+ pic14_emitcode ("mov","b,a");
+ pic14_emitcode("mov","a,@%s",rname);
+ break;
+
+ case FPOINTER:
+ pic14_emitcode ("mov","b,a");
+ pic14_emitcode("movx","a,@dptr");
+ break;
+
+ case GPOINTER:
+ pic14_emitcode ("push","b");
+ pic14_emitcode ("push","acc");
+ pic14_emitcode ("lcall","__gptrget");
+ pic14_emitcode ("pop","b");
+ break;
+ }
+
+ pic14_emitcode ("anl","a,#0x%02x",(unsigned char)
+ ((unsigned char)(0xFF << (blen+bstr)) |
+ (unsigned char)(0xFF >> (8-bstr)) ) );
+ pic14_emitcode ("orl","a,b");
+ if (p_type == GPOINTER)
+ pic14_emitcode("pop","b");
+ }
+ }
+
+ switch (p_type) {
+ case POINTER:
+ pic14_emitcode("mov","@%s,a",rname);
+ break;
+
+ case FPOINTER:
+ pic14_emitcode("movx","@dptr,a");
+ break;
+
+ case GPOINTER:
+ DEBUGpic14_emitcode(";lcall","__gptrput");
+ break;
+ }
+
+ /* if we r done */
+ if ( SPEC_BLEN(etype) <= 8 )
+ return ;
+
+ pic14_emitcode("inc","%s",rname);
+ rLen = SPEC_BLEN(etype) ;
+
+ /* now generate for lengths greater than one byte */
+ while (1) {
+
+ l = aopGet(AOP(right),offset++,FALSE,TRUE);
+
+ rLen -= 8 ;
+ if (rLen <= 0 )
+ break ;
+
+ switch (p_type) {
+ case POINTER:
+ if (*l == '@') {
+ MOVA(l);
+ pic14_emitcode("mov","@%s,a",rname);
+ } else
+ pic14_emitcode("mov","@%s,%s",rname,l);
+ break;
+
+ case FPOINTER:
+ MOVA(l);
+ pic14_emitcode("movx","@dptr,a");
+ break;
+
+ case GPOINTER:
+ MOVA(l);
+ DEBUGpic14_emitcode(";lcall","__gptrput");
+ break;
+ }
+ pic14_emitcode ("inc","%s",rname);
+ }
+
+ MOVA(l);
+
+ /* last last was not complete */
+ if (rLen) {
+ /* save the byte & read byte */
+ switch (p_type) {
+ case POINTER:
+ pic14_emitcode ("mov","b,a");
+ pic14_emitcode("mov","a,@%s",rname);
+ break;
+
+ case FPOINTER:
+ pic14_emitcode ("mov","b,a");
+ pic14_emitcode("movx","a,@dptr");
+ break;
+
+ case GPOINTER:
+ pic14_emitcode ("push","b");
+ pic14_emitcode ("push","acc");
+ pic14_emitcode ("lcall","__gptrget");
+ pic14_emitcode ("pop","b");
+ break;
+ }
+
+ pic14_emitcode ("anl","a,#0x%02x",((unsigned char)-1 << -rLen) );
+ pic14_emitcode ("orl","a,b");
+ }
+
+ if (p_type == GPOINTER)
+ pic14_emitcode("pop","b");
+
+ switch (p_type) {
+
+ case POINTER:
+ pic14_emitcode("mov","@%s,a",rname);
+ break;
+
+ case FPOINTER:
+ pic14_emitcode("movx","@dptr,a");
+ break;
+
+ case GPOINTER:
+ DEBUGpic14_emitcode(";lcall","__gptrput");
+ break;
+ }
}
/*-----------------------------------------------------------------*/
/* genDataPointerSet - remat pointer to data space */
/*-----------------------------------------------------------------*/
static void genDataPointerSet(operand *right,
- operand *result,
- iCode *ic)
+ operand *result,
+ iCode *ic)
{
- int size, offset = 0 ;
- char *l, buffer[256];
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp(right,ic,FALSE);
-
- l = aopGet(AOP(result),0,FALSE,TRUE);
- size = AOP_SIZE(right);
-/*
- if ( AOP_TYPE(result) == AOP_PCODE) {
- fprintf(stderr,"genDataPointerSet %s, %d\n",
- AOP(result)->aopu.pcop->name,
- PCOI(AOP(result)->aopu.pcop)->offset);
- }
-*/
-
- // tsd, was l+1 - the underline `_' prefix was being stripped
- while (size--) {
- if (offset) {
- sprintf(buffer,"(%s + %d)",l,offset);
- fprintf(stderr,"oops %s\n",buffer);
- } else
- sprintf(buffer,"%s",l);
-
- if (AOP_TYPE(right) == AOP_LIT) {
- unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
- lit = lit >> (8*offset);
- if(lit&0xff) {
- pic14_emitcode("movlw","%d",lit);
- pic14_emitcode("movwf","%s",buffer);
-
- emitpcode(POC_MOVLW, popGetLit(lit&0xff));
- //emitpcode(POC_MOVWF, popRegFromString(buffer));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
-
- } else {
- pic14_emitcode("clrf","%s",buffer);
- //emitpcode(POC_CLRF, popRegFromString(buffer));
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- }
- }else {
- pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s",buffer);
-
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- //emitpcode(POC_MOVWF, popRegFromString(buffer));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ int size, offset = 0 ;
+ char *l, buffer[256];
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(right,ic,FALSE);
+
+ l = aopGet(AOP(result),0,FALSE,TRUE);
+ size = AOP_SIZE(right);
+ /*
+ if ( AOP_TYPE(result) == AOP_PCODE) {
+ fprintf(stderr,"genDataPointerSet %s, %d\n",
+ AOP(result)->aopu.pcop->name,
+ PCOI(AOP(result)->aopu.pcop)->offset);
+ }
+ */
+
+ // tsd, was l+1 - the underline `_' prefix was being stripped
+ while (size--) {
+ if (offset) {
+ sprintf(buffer,"(%s + %d)",l,offset);
+ fprintf(stderr,"oops %s\n",buffer);
+ } else
+ sprintf(buffer,"%s",l);
+
+ if (AOP_TYPE(right) == AOP_LIT) {
+ unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
+ lit = lit >> (8*offset);
+ if(lit&0xff) {
+ pic14_emitcode("movlw","%d",lit);
+ pic14_emitcode("movwf","%s",buffer);
+
+ emitpcode(POC_MOVLW, popGetLit(lit&0xff));
+ //emitpcode(POC_MOVWF, popRegFromString(buffer));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+
+ } else {
+ pic14_emitcode("clrf","%s",buffer);
+ //emitpcode(POC_CLRF, popRegFromString(buffer));
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ }
+ }else {
+ pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",buffer);
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ //emitpcode(POC_MOVWF, popRegFromString(buffer));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+
+ }
+
+ offset++;
+ }
+
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+}
+/*-----------------------------------------------------------------*/
+/* genNearPointerSet - pic14_emitcode for near pointer put */
+/*-----------------------------------------------------------------*/
+static void genNearPointerSet (operand *right,
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ char *l;
+ sym_link *retype;
+ sym_link *ptype = operandType(result);
+
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ retype= getSpec(operandType(right));
+
+ aopOp(result,ic,FALSE);
+
+
+ /* if the result is rematerializable &
+ in data space & not a bit variable */
+ //if (AOP_TYPE(result) == AOP_IMMD &&
+ if (AOP_TYPE(result) == AOP_PCODE && //AOP_TYPE(result) == AOP_IMMD &&
+ DCL_TYPE(ptype) == POINTER &&
+ !IS_BITVAR(retype)) {
+ genDataPointerSet (right,result,ic);
+ freeAsmop(result,NULL,ic,TRUE);
+ return;
+ }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(right,ic,FALSE);
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* if the value is already in a pointer register
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(result))) {
+ /* otherwise get a free pointer register */
+ //aop = newAsmop(0);
+ //preg = getFreePtr(ic,&aop,FALSE);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ //pic14_emitcode("mov","%s,%s",
+ // preg->name,
+ // aopGet(AOP(result),0,FALSE,TRUE));
+ //rname = preg->name ;
+ //pic14_emitcode("movwf","fsr");
+ emitpcode(POC_MOVFW, popGet(AOP(result),0));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_fsr));
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_indf));
+ goto release;
+
+ }// else
+ // rname = aopGet(AOP(result),0,FALSE,FALSE);
+
+
+ /* if bitfield then unpack the bits */
+ if (IS_BITVAR(retype)) {
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "The programmer is obviously confused");
+ //genPackBits (retype,right,rname,POINTER);
+ exit(1);
+ }
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(right);
+ int offset = 0 ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ while (size--) {
+ l = aopGet(AOP(right),offset,FALSE,TRUE);
+ if (*l == '@' ) {
+ //MOVA(l);
+ //pic14_emitcode("mov","@%s,a",rname);
+ pic14_emitcode("movf","indf,w ;1");
+ } else {
+
+ if (AOP_TYPE(right) == AOP_LIT) {
+ unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
+ if(lit) {
+ pic14_emitcode("movlw","%s",l);
+ pic14_emitcode("movwf","indf ;2");
+ } else
+ pic14_emitcode("clrf","indf");
+ }else {
+ pic14_emitcode("movf","%s,w",l);
+ pic14_emitcode("movwf","indf ;2");
+ }
+ //pic14_emitcode("mov","@%s,%s",rname,l);
+ }
+ if (size)
+ pic14_emitcode("incf","fsr,f ;3");
+ //pic14_emitcode("inc","%s",rname);
+ offset++;
+ }
+ }
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
+ /* we did not allocate which means left
+ already in a pointer register, then
+ if size > 0 && this could be used again
+ we have to point it back to where it
+ belongs */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (AOP_SIZE(right) > 1 &&
+ !OP_SYMBOL(result)->remat &&
+ ( OP_SYMBOL(result)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(right) - 1;
+ while (size--)
+ pic14_emitcode("decf","fsr,f");
+ //pic14_emitcode("dec","%s",rname);
+ }
}
-
- offset++;
- }
-
- freeAsmop(right,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
-}
-
-/*-----------------------------------------------------------------*/
-/* genNearPointerSet - pic14_emitcode for near pointer put */
-/*-----------------------------------------------------------------*/
-static void genNearPointerSet (operand *right,
- operand *result,
- iCode *ic)
-{
- asmop *aop = NULL;
- char *l;
- sym_link *retype;
- sym_link *ptype = operandType(result);
-
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- retype= getSpec(operandType(right));
-
- aopOp(result,ic,FALSE);
-
-
- /* if the result is rematerializable &
- in data space & not a bit variable */
- //if (AOP_TYPE(result) == AOP_IMMD &&
- if (AOP_TYPE(result) == AOP_PCODE && //AOP_TYPE(result) == AOP_IMMD &&
- DCL_TYPE(ptype) == POINTER &&
- !IS_BITVAR(retype)) {
- genDataPointerSet (right,result,ic);
- freeAsmop(result,NULL,ic,TRUE);
- return;
- }
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp(right,ic,FALSE);
- DEBUGpic14_AopType(__LINE__,NULL,right,result);
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG(AOP(result))) {
- /* otherwise get a free pointer register */
- //aop = newAsmop(0);
- //preg = getFreePtr(ic,&aop,FALSE);
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- //pic14_emitcode("mov","%s,%s",
- // preg->name,
- // aopGet(AOP(result),0,FALSE,TRUE));
- //rname = preg->name ;
- //pic14_emitcode("movwf","fsr");
- emitpcode(POC_MOVFW, popGet(AOP(result),0));
- emitpcode(POC_MOVWF, popCopyReg(&pc_fsr));
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_MOVWF, popCopyReg(&pc_indf));
- goto release;
-
- }// else
- // rname = aopGet(AOP(result),0,FALSE,FALSE);
-
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR(retype)) {
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "The programmer is obviously confused");
- //genPackBits (retype,right,rname,POINTER);
- exit(1);
- }
- else {
- /* we have can just get the values */
- int size = AOP_SIZE(right);
- int offset = 0 ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- while (size--) {
- l = aopGet(AOP(right),offset,FALSE,TRUE);
- if (*l == '@' ) {
- //MOVA(l);
- //pic14_emitcode("mov","@%s,a",rname);
- pic14_emitcode("movf","indf,w ;1");
- } else {
-
- if (AOP_TYPE(right) == AOP_LIT) {
- unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
- if(lit) {
- pic14_emitcode("movlw","%s",l);
- pic14_emitcode("movwf","indf ;2");
- } else
- pic14_emitcode("clrf","indf");
- }else {
- pic14_emitcode("movf","%s,w",l);
- pic14_emitcode("movwf","indf ;2");
- }
- //pic14_emitcode("mov","@%s,%s",rname,l);
- }
- if (size)
- pic14_emitcode("incf","fsr,f ;3");
- //pic14_emitcode("inc","%s",rname);
- offset++;
- }
- }
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* now some housekeeping stuff */
- if (aop) {
- /* we had to allocate for this iCode */
- freeAsmop(NULL,aop,ic,TRUE);
- } else {
- /* we did not allocate which means left
- already in a pointer register, then
- if size > 0 && this could be used again
- we have to point it back to where it
- belongs */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_SIZE(right) > 1 &&
- !OP_SYMBOL(result)->remat &&
- ( OP_SYMBOL(result)->liveTo > ic->seq ||
- ic->depth )) {
- int size = AOP_SIZE(right) - 1;
- while (size--)
- pic14_emitcode("decf","fsr,f");
- //pic14_emitcode("dec","%s",rname);
- }
- }
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* done */
- release:
- freeAsmop(right,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* done */
+release:
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* genPagedPointerSet - pic14_emitcode for Paged pointer put */
/*-----------------------------------------------------------------*/
static void genPagedPointerSet (operand *right,
- operand *result,
- iCode *ic)
-{
- asmop *aop = NULL;
- regs *preg = NULL ;
- char *rname , *l;
- sym_link *retype;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- retype= getSpec(operandType(right));
-
- aopOp(result,ic,FALSE);
-
- /* if the value is already in a pointer register
- then don't need anything more */
- if (!AOP_INPREG(AOP(result))) {
- /* otherwise get a free pointer register */
- aop = newAsmop(0);
- preg = getFreePtr(ic,&aop,FALSE);
- pic14_emitcode("mov","%s,%s",
- preg->name,
- aopGet(AOP(result),0,FALSE,TRUE));
- rname = preg->name ;
- } else
- rname = aopGet(AOP(result),0,FALSE,FALSE);
-
- freeAsmop(result,NULL,ic,TRUE);
- aopOp (right,ic,FALSE);
-
- /* if bitfield then unpack the bits */
- if (IS_BITVAR(retype))
- genPackBits (retype,right,rname,PPOINTER);
- else {
- /* we have can just get the values */
- int size = AOP_SIZE(right);
- int offset = 0 ;
+ operand *result,
+ iCode *ic)
+{
+ asmop *aop = NULL;
+ regs *preg = NULL ;
+ char *rname , *l;
+ sym_link *retype;
- while (size--) {
- l = aopGet(AOP(right),offset,FALSE,TRUE);
-
- MOVA(l);
- pic14_emitcode("movx","@%s,a",rname);
-
- if (size)
- pic14_emitcode("inc","%s",rname);
-
- offset++;
- }
- }
-
- /* now some housekeeping stuff */
- if (aop) {
- /* we had to allocate for this iCode */
- freeAsmop(NULL,aop,ic,TRUE);
- } else {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ retype= getSpec(operandType(right));
+
+ aopOp(result,ic,FALSE);
+
+ /* if the value is already in a pointer register
+ then don't need anything more */
+ if (!AOP_INPREG(AOP(result))) {
+ /* otherwise get a free pointer register */
+ aop = newAsmop(0);
+ preg = getFreePtr(ic,&aop,FALSE);
+ pic14_emitcode("mov","%s,%s",
+ preg->name,
+ aopGet(AOP(result),0,FALSE,TRUE));
+ rname = preg->name ;
+ } else
+ rname = aopGet(AOP(result),0,FALSE,FALSE);
+
+ freeAsmop(result,NULL,ic,TRUE);
+ aopOp (right,ic,FALSE);
+
+ /* if bitfield then unpack the bits */
+ if (IS_BITVAR(retype))
+ genPackBits (retype,right,rname,PPOINTER);
+ else {
+ /* we have can just get the values */
+ int size = AOP_SIZE(right);
+ int offset = 0 ;
+
+ while (size--) {
+ l = aopGet(AOP(right),offset,FALSE,TRUE);
+
+ MOVA(l);
+ pic14_emitcode("movx","@%s,a",rname);
+
+ if (size)
+ pic14_emitcode("inc","%s",rname);
+
+ offset++;
+ }
+ }
+
+ /* now some housekeeping stuff */
+ if (aop) {
+ /* we had to allocate for this iCode */
+ freeAsmop(NULL,aop,ic,TRUE);
+ } else {
/* we did not allocate which means left
already in a pointer register, then
if size > 0 && this could be used again
we have to point it back to where it
- belongs */
- if (AOP_SIZE(right) > 1 &&
- !OP_SYMBOL(result)->remat &&
- ( OP_SYMBOL(result)->liveTo > ic->seq ||
- ic->depth )) {
- int size = AOP_SIZE(right) - 1;
- while (size--)
- pic14_emitcode("dec","%s",rname);
+ belongs */
+ if (AOP_SIZE(right) > 1 &&
+ !OP_SYMBOL(result)->remat &&
+ ( OP_SYMBOL(result)->liveTo > ic->seq ||
+ ic->depth )) {
+ int size = AOP_SIZE(right) - 1;
+ while (size--)
+ pic14_emitcode("dec","%s",rname);
+ }
}
- }
-
- /* done */
- freeAsmop(right,NULL,ic,TRUE);
-
+
+ /* done */
+ freeAsmop(right,NULL,ic,TRUE);
+
}
/* genFarPointerSet - set value from far space */
/*-----------------------------------------------------------------*/
static void genFarPointerSet (operand *right,
- operand *result, iCode *ic)
-{
- int size, offset ;
- sym_link *retype = getSpec(operandType(right));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp(result,ic,FALSE);
-
- /* if the operand is already in dptr
- then we do nothing else we move the value to dptr */
- if (AOP_TYPE(result) != AOP_STR) {
- /* if this is remateriazable */
- if (AOP_TYPE(result) == AOP_IMMD)
- pic14_emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE));
- else { /* we need to get it byte by byte */
- pic14_emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE));
- pic14_emitcode("mov","dph,%s",aopGet(AOP(result),1,FALSE,FALSE));
- if (options.model == MODEL_FLAT24)
- {
- pic14_emitcode("mov", "dpx,%s",aopGet(AOP(result),2,FALSE,FALSE));
- }
- }
- }
- /* so dptr know contains the address */
- freeAsmop(result,NULL,ic,TRUE);
- aopOp(right,ic,FALSE);
-
- /* if bit then unpack */
- if (IS_BITVAR(retype))
- genPackBits(retype,right,"dptr",FPOINTER);
- else {
- size = AOP_SIZE(right);
- offset = 0 ;
-
- while (size--) {
- char *l = aopGet(AOP(right),offset++,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode("movx","@dptr,a");
- if (size)
- pic14_emitcode("inc","dptr");
- }
- }
-
- freeAsmop(right,NULL,ic,TRUE);
+ operand *result, iCode *ic)
+{
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(right));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp(result,ic,FALSE);
+
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE(result) != AOP_STR) {
+ /* if this is remateriazable */
+ if (AOP_TYPE(result) == AOP_IMMD)
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE));
+ else { /* we need to get it byte by byte */
+ pic14_emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE));
+ pic14_emitcode("mov","dph,%s",aopGet(AOP(result),1,FALSE,FALSE));
+ if (options.model == MODEL_FLAT24)
+ {
+ pic14_emitcode("mov", "dpx,%s",aopGet(AOP(result),2,FALSE,FALSE));
+ }
+ }
+ }
+ /* so dptr know contains the address */
+ freeAsmop(result,NULL,ic,TRUE);
+ aopOp(right,ic,FALSE);
+
+ /* if bit then unpack */
+ if (IS_BITVAR(retype))
+ genPackBits(retype,right,"dptr",FPOINTER);
+ else {
+ size = AOP_SIZE(right);
+ offset = 0 ;
+
+ while (size--) {
+ char *l = aopGet(AOP(right),offset++,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode("movx","@dptr,a");
+ if (size)
+ pic14_emitcode("inc","dptr");
+ }
+ }
+
+ freeAsmop(right,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* genGenPointerSet - set value from generic pointer space */
/*-----------------------------------------------------------------*/
static void genGenPointerSet (operand *right,
- operand *result, iCode *ic)
+ operand *result, iCode *ic)
{
- int size, offset ;
- sym_link *retype = getSpec(operandType(right));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp(result,ic,FALSE);
- aopOp(right,ic,FALSE);
- size = AOP_SIZE(right);
-
- DEBUGpic14_AopType(__LINE__,NULL,right,result);
-
- /* if the operand is already in dptr
- then we do nothing else we move the value to dptr */
- if (AOP_TYPE(result) != AOP_STR) {
- /* if this is remateriazable */
- if (AOP_TYPE(result) == AOP_IMMD) {
- pic14_emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE));
- pic14_emitcode("mov","b,%s + 1",aopGet(AOP(result),0,TRUE,FALSE));
- }
- else { /* we need to get it byte by byte */
- //char *l = aopGet(AOP(result),0,FALSE,FALSE);
- size = AOP_SIZE(right);
- offset = 0 ;
-
- /* hack hack! see if this the FSR. If so don't load W */
- if(AOP_TYPE(right) != AOP_ACC) {
-
-
- emitpcode(POC_MOVFW,popGet(AOP(result),0));
- emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
-
- if(AOP_SIZE(result) > 1) {
- emitpcode(POC_BCF, popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
- emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),1,FALSE,FALSE),0,0));
- emitpcode(POC_BSF, popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
-
+ int size, offset ;
+ sym_link *retype = getSpec(operandType(right));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(result,ic,FALSE);
+ aopOp(right,ic,FALSE);
+ size = AOP_SIZE(right);
+
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* if the operand is already in dptr
+ then we do nothing else we move the value to dptr */
+ if (AOP_TYPE(result) != AOP_STR) {
+ /* if this is remateriazable */
+ if (AOP_TYPE(result) == AOP_IMMD) {
+ pic14_emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE));
+ pic14_emitcode("mov","b,%s + 1",aopGet(AOP(result),0,TRUE,FALSE));
+ }
+ else { /* we need to get it byte by byte */
+ //char *l = aopGet(AOP(result),0,FALSE,FALSE);
+ size = AOP_SIZE(right);
+ offset = 0 ;
+
+ /* hack hack! see if this the FSR. If so don't load W */
+ if(AOP_TYPE(right) != AOP_ACC) {
+
+
+ emitpcode(POC_MOVFW,popGet(AOP(result),0));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+
+ if(AOP_SIZE(result) > 1) {
+ emitpcode(POC_BCF, popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),1,FALSE,FALSE),0,0));
+ emitpcode(POC_BSF, popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
+
+ }
+
+ //if(size==2)
+ //emitpcode(POC_DECF,popCopyReg(&pc_fsr));
+ //if(size==4) {
+ // emitpcode(POC_MOVLW,popGetLit(0xfd));
+ // emitpcode(POC_ADDWF,popCopyReg(&pc_fsr));
+ //}
+
+ while(size--) {
+ emitpcode(POC_MOVFW,popGet(AOP(right),offset++));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+
+ if(size)
+ emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ }
+
+
+ goto release;
+ }
+
+ if(aopIdx(AOP(result),0) != 4) {
+
+ emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+ goto release;
+ }
+
+ emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+ goto release;
+
+ }
}
-
- //if(size==2)
- //emitpcode(POC_DECF,popCopyReg(&pc_fsr));
- //if(size==4) {
- // emitpcode(POC_MOVLW,popGetLit(0xfd));
- // emitpcode(POC_ADDWF,popCopyReg(&pc_fsr));
- //}
-
- while(size--) {
- emitpcode(POC_MOVFW,popGet(AOP(right),offset++));
- emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
-
- if(size)
- emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+ /* so dptr know contains the address */
+
+
+ /* if bit then unpack */
+ if (IS_BITVAR(retype))
+ genPackBits(retype,right,"dptr",GPOINTER);
+ else {
+ size = AOP_SIZE(right);
+ offset = 0 ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d size=%d",__FUNCTION__,__LINE__,size);
+
+ while (size--) {
+
+ emitpcode(POC_MOVFW,popGet(AOP(result),offset));
+ emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+
+ if (AOP_TYPE(right) == AOP_LIT)
+ emitpcode(POC_MOVLW, popGet(AOP(right),offset));
+ else
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+
+ emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+
+ offset++;
+ }
}
-
-
- goto release;
- }
-
- if(aopIdx(AOP(result),0) != 4) {
-
- emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
- goto release;
- }
-
- emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
- goto release;
-
- }
- }
- /* so dptr know contains the address */
-
-
- /* if bit then unpack */
- if (IS_BITVAR(retype))
- genPackBits(retype,right,"dptr",GPOINTER);
- else {
- size = AOP_SIZE(right);
- offset = 0 ;
-
- DEBUGpic14_emitcode ("; ***","%s %d size=%d",__FUNCTION__,__LINE__,size);
-
- while (size--) {
-
- emitpcode(POC_MOVFW,popGet(AOP(result),offset));
- emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
-
- if (AOP_TYPE(right) == AOP_LIT)
- emitpcode(POC_MOVLW, popGet(AOP(right),offset));
- else
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
-
- emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
-
- offset++;
- }
- }
-
- release:
- freeAsmop(right,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
+
+release:
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genPointerSet (iCode *ic)
{
- operand *right, *result ;
- sym_link *type, *etype;
- int p_type;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- right = IC_RIGHT(ic);
- result = IC_RESULT(ic) ;
-
- /* depending on the type of pointer we need to
- move it to the correct pointer register */
- type = operandType(result);
- etype = getSpec(type);
- /* if left is of type of pointer then it is simple */
- if (IS_PTR(type) && !IS_FUNC(type->next)) {
- p_type = DCL_TYPE(type);
- }
- else {
- /* we have to go by the storage class */
- p_type = PTR_TYPE(SPEC_OCLS(etype));
-
-/* if (SPEC_OCLS(etype)->codesp ) { */
-/* p_type = CPOINTER ; */
-/* } */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/* p_type = FPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
-/* p_type = PPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype) == idata ) */
-/* p_type = IPOINTER ; */
-/* else */
-/* p_type = POINTER ; */
- }
-
- /* now that we have the pointer type we assign
- the pointer values */
- switch (p_type) {
-
- case POINTER:
- case IPOINTER:
- genNearPointerSet (right,result,ic);
- break;
-
- case PPOINTER:
- genPagedPointerSet (right,result,ic);
- break;
-
- case FPOINTER:
- genFarPointerSet (right,result,ic);
- break;
-
- case GPOINTER:
- genGenPointerSet (right,result,ic);
- break;
-
- default:
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "genPointerSet: illegal pointer type");
- }
+ operand *right, *result ;
+ sym_link *type, *etype;
+ int p_type;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ right = IC_RIGHT(ic);
+ result = IC_RESULT(ic) ;
+
+ /* depending on the type of pointer we need to
+ move it to the correct pointer register */
+ type = operandType(result);
+ etype = getSpec(type);
+ /* if left is of type of pointer then it is simple */
+ if (IS_PTR(type) && !IS_FUNC(type->next)) {
+ p_type = DCL_TYPE(type);
+ }
+ else {
+ /* we have to go by the storage class */
+ p_type = PTR_TYPE(SPEC_OCLS(etype));
+
+ /* if (SPEC_OCLS(etype)->codesp ) { */
+ /* p_type = CPOINTER ; */
+ /* } */
+ /* else */
+ /* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
+ /* p_type = FPOINTER ; */
+ /* else */
+ /* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
+ /* p_type = PPOINTER ; */
+ /* else */
+ /* if (SPEC_OCLS(etype) == idata ) */
+ /* p_type = IPOINTER ; */
+ /* else */
+ /* p_type = POINTER ; */
+ }
+
+ /* now that we have the pointer type we assign
+ the pointer values */
+ switch (p_type) {
+
+ case POINTER:
+ case IPOINTER:
+ genNearPointerSet (right,result,ic);
+ break;
+
+ case PPOINTER:
+ genPagedPointerSet (right,result,ic);
+ break;
+
+ case FPOINTER:
+ genFarPointerSet (right,result,ic);
+ break;
+
+ case GPOINTER:
+ genGenPointerSet (right,result,ic);
+ break;
+
+ default:
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "genPointerSet: illegal pointer type");
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genIfx (iCode *ic, iCode *popIc)
{
- operand *cond = IC_COND(ic);
- int isbit =0;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp(cond,ic,FALSE);
-
- /* get the value into acc */
- if (AOP_TYPE(cond) != AOP_CRY)
- pic14_toBoolean(cond);
- else
- isbit = 1;
- /* the result is now in the accumulator */
- freeAsmop(cond,NULL,ic,TRUE);
-
- /* if there was something to be popped then do it */
- if (popIc)
- genIpop(popIc);
-
- /* if the condition is a bit variable */
- if (isbit && IS_ITEMP(cond) &&
- SPIL_LOC(cond)) {
- genIfxJump(ic,SPIL_LOC(cond)->rname);
- DEBUGpic14_emitcode ("; isbit SPIL_LOC","%s",SPIL_LOC(cond)->rname);
- }
- else {
- if (isbit && !IS_ITEMP(cond))
- genIfxJump(ic,OP_SYMBOL(cond)->rname);
- else
- genIfxJump(ic,"a");
- }
- ic->generated = 1;
-
+ operand *cond = IC_COND(ic);
+ int isbit =0;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(cond,ic,FALSE);
+
+ /* get the value into acc */
+ if (AOP_TYPE(cond) != AOP_CRY)
+ pic14_toBoolean(cond);
+ else
+ isbit = 1;
+ /* the result is now in the accumulator */
+ freeAsmop(cond,NULL,ic,TRUE);
+
+ /* if there was something to be popped then do it */
+ if (popIc)
+ genIpop(popIc);
+
+ /* if the condition is a bit variable */
+ if (isbit && IS_ITEMP(cond) &&
+ SPIL_LOC(cond)) {
+ genIfxJump(ic,SPIL_LOC(cond)->rname);
+ DEBUGpic14_emitcode ("; isbit SPIL_LOC","%s",SPIL_LOC(cond)->rname);
+ }
+ else {
+ if (isbit && !IS_ITEMP(cond))
+ genIfxJump(ic,OP_SYMBOL(cond)->rname);
+ else
+ genIfxJump(ic,"a");
+ }
+ ic->generated = 1;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genAddrOf (iCode *ic)
{
- operand *right, *result, *left;
- int size, offset ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
-
- //aopOp(IC_RESULT(ic),ic,FALSE);
-
- aopOp((left=IC_LEFT(ic)),ic,FALSE);
- aopOp((right=IC_RIGHT(ic)),ic,FALSE);
- aopOp((result=IC_RESULT(ic)),ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,left,right,result);
-
- size = AOP_SIZE(IC_RESULT(ic));
- offset = 0;
-
- while (size--) {
- /* fixing bug #863624, reported from (errolv) */
- emitpcode(POC_MOVLW, popGetImmd(OP_SYMBOL(left)->rname, offset, 0, IS_FUNC(OP_SYM_TYPE(left))));
- emitpcode(POC_MOVWF, popGet(AOP(result), offset));
+ operand *right, *result, *left;
+ int size, offset ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ //aopOp(IC_RESULT(ic),ic,FALSE);
+
+ aopOp((left=IC_LEFT(ic)),ic,FALSE);
+ aopOp((right=IC_RIGHT(ic)),ic,FALSE);
+ aopOp((result=IC_RESULT(ic)),ic,TRUE);
+ DEBUGpic14_AopType(__LINE__,left,right,result);
+
+ size = AOP_SIZE(IC_RESULT(ic));
+ offset = 0;
+
+ while (size--) {
+ /* fixing bug #863624, reported from (errolv) */
+ emitpcode(POC_MOVLW, popGetImmd(OP_SYMBOL(left)->rname, offset, 0, IS_FUNC(OP_SYM_TYPE(left))));
+ emitpcode(POC_MOVWF, popGet(AOP(result), offset));
+
#if 0
- emitpcode(POC_MOVLW, popGet(AOP(left),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ emitpcode(POC_MOVLW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
#endif
- offset++;
- }
-
- freeAsmop(left,NULL,ic,FALSE);
- freeAsmop(result,NULL,ic,TRUE);
-
+ offset++;
+ }
+
+ freeAsmop(left,NULL,ic,FALSE);
+ freeAsmop(result,NULL,ic,TRUE);
+
}
#if 0
/*-----------------------------------------------------------------*/
static void genFarFarAssign (operand *result, operand *right, iCode *ic)
{
- int size = AOP_SIZE(right);
- int offset = 0;
- char *l ;
- /* first push the right side on to the stack */
- while (size--) {
- l = aopGet(AOP(right),offset++,FALSE,FALSE);
- MOVA(l);
- pic14_emitcode ("push","acc");
- }
-
- freeAsmop(right,NULL,ic,FALSE);
- /* now assign DPTR to result */
- aopOp(result,ic,FALSE);
- size = AOP_SIZE(result);
- while (size--) {
- pic14_emitcode ("pop","acc");
- aopPut(AOP(result),"a",--offset);
- }
- freeAsmop(result,NULL,ic,FALSE);
+ int size = AOP_SIZE(right);
+ int offset = 0;
+ char *l ;
+ /* first push the right side on to the stack */
+ while (size--) {
+ l = aopGet(AOP(right),offset++,FALSE,FALSE);
+ MOVA(l);
+ pic14_emitcode ("push","acc");
+ }
+
+ freeAsmop(right,NULL,ic,FALSE);
+ /* now assign DPTR to result */
+ aopOp(result,ic,FALSE);
+ size = AOP_SIZE(result);
+ while (size--) {
+ pic14_emitcode ("pop","acc");
+ aopPut(AOP(result),"a",--offset);
+ }
+ freeAsmop(result,NULL,ic,FALSE);
}
#endif
/*-----------------------------------------------------------------*/
static void genAssign (iCode *ic)
{
- operand *result, *right;
- int size, offset,know_W;
- unsigned long lit = 0L;
-
- result = IC_RESULT(ic);
- right = IC_RIGHT(ic) ;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- /* if they are the same */
- if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
- return ;
-
- aopOp(right,ic,FALSE);
- aopOp(result,ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,NULL,right,result);
-
- /* if they are the same registers */
- if (pic14_sameRegs(AOP(right),AOP(result)))
- goto release;
-
- /* if the result is a bit */
- if (AOP_TYPE(result) == AOP_CRY) {
-
- /* if the right size is a literal then
- we know what the value is */
- if (AOP_TYPE(right) == AOP_LIT) {
-
- emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
- popGet(AOP(result),0));
-
- if (((int) operandLitValue(right)))
- pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- else
- pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- goto release;
- }
-
- /* the right is also a bit variable */
- if (AOP_TYPE(right) == AOP_CRY) {
- emitpcode(POC_BCF, popGet(AOP(result),0));
- emitpcode(POC_BTFSC, popGet(AOP(right),0));
- emitpcode(POC_BSF, popGet(AOP(result),0));
-
- pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- pic14_emitcode("btfsc","(%s >> 3),(%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- goto release ;
- }
-
- /* we need to or */
- emitpcode(POC_BCF, popGet(AOP(result),0));
- pic14_toBoolean(right);
- emitSKPZ;
- emitpcode(POC_BSF, popGet(AOP(result),0));
- //aopPut(AOP(result),"a",0);
- goto release ;
- }
-
- /* bit variables done */
- /* general case */
- size = AOP_SIZE(result);
- offset = 0 ;
- if(AOP_TYPE(right) == AOP_LIT)
- lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
-
- if( AOP_TYPE(right) == AOP_DIR && (AOP_TYPE(result) == AOP_REG) && size==1) {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(aopIdx(AOP(result),0) == 4) {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- goto release;
- } else
- DEBUGpic14_emitcode ("; WARNING","%s %d ignoring register storage",__FUNCTION__,__LINE__);
- }
-
- know_W=-1;
- while (size--) {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(AOP_TYPE(right) == AOP_LIT) {
- if(lit&0xff) {
- if(know_W != (int)(lit&0xff))
- emitpcode(POC_MOVLW,popGetLit(lit&0xff));
- know_W = lit&0xff;
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- } else
- emitpcode(POC_CLRF, popGet(AOP(result),offset));
-
- lit >>= 8;
-
- } else if (AOP_TYPE(right) == AOP_CRY) {
- emitpcode(POC_CLRF, popGet(AOP(result),offset));
- if(offset == 0) {
- emitpcode(POC_BTFSS, popGet(AOP(right),0));
- emitpcode(POC_INCF, popGet(AOP(result),0));
- }
- } else {
- mov2w (AOP(right), offset);
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- }
-
- offset++;
- }
-
-
- release:
- freeAsmop (right,NULL,ic,FALSE);
- freeAsmop (result,NULL,ic,TRUE);
+ operand *result, *right;
+ int size, offset,know_W;
+ unsigned long lit = 0L;
+
+ result = IC_RESULT(ic);
+ right = IC_RIGHT(ic) ;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* if they are the same */
+ if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
+ return ;
+
+ aopOp(right,ic,FALSE);
+ aopOp(result,ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* if they are the same registers */
+ if (pic14_sameRegs(AOP(right),AOP(result)))
+ goto release;
+
+ /* if the result is a bit */
+ if (AOP_TYPE(result) == AOP_CRY) {
+
+ /* if the right size is a literal then
+ we know what the value is */
+ if (AOP_TYPE(right) == AOP_LIT) {
+
+ emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
+ popGet(AOP(result),0));
+
+ if (((int) operandLitValue(right)))
+ pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ else
+ pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ goto release;
+ }
+
+ /* the right is also a bit variable */
+ if (AOP_TYPE(right) == AOP_CRY) {
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+
+ pic14_emitcode("bcf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3),(%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ pic14_emitcode("bsf","(%s >> 3),(%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ goto release ;
+ }
+
+ /* we need to or */
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ pic14_toBoolean(right);
+ emitSKPZ;
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ //aopPut(AOP(result),"a",0);
+ goto release ;
+ }
+
+ /* bit variables done */
+ /* general case */
+ size = AOP_SIZE(result);
+ offset = 0 ;
+ if(AOP_TYPE(right) == AOP_LIT)
+ lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+
+ if( AOP_TYPE(right) == AOP_DIR && (AOP_TYPE(result) == AOP_REG) && size==1) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(aopIdx(AOP(result),0) == 4) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ goto release;
+ } else
+ DEBUGpic14_emitcode ("; WARNING","%s %d ignoring register storage",__FUNCTION__,__LINE__);
+ }
+
+ know_W=-1;
+ while (size--) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(AOP_TYPE(right) == AOP_LIT) {
+ if(lit&0xff) {
+ if(know_W != (int)(lit&0xff))
+ emitpcode(POC_MOVLW,popGetLit(lit&0xff));
+ know_W = lit&0xff;
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ } else
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+
+ lit >>= 8;
+
+ } else if (AOP_TYPE(right) == AOP_CRY) {
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+ if(offset == 0) {
+ emitpcode(POC_BTFSS, popGet(AOP(right),0));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+ }
+ } else {
+ mov2w (AOP(right), offset);
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ }
+
+ offset++;
+ }
+
+
+release:
+ freeAsmop (right,NULL,ic,FALSE);
+ freeAsmop (result,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genJumpTab (iCode *ic)
{
- symbol *jtab;
- char *l;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp(IC_JTCOND(ic),ic,FALSE);
- /* get the condition into accumulator */
- l = aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE);
- MOVA(l);
- /* multiply by three */
- pic14_emitcode("add","a,acc");
- pic14_emitcode("add","a,%s",aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE));
-
- jtab = newiTempLabel(NULL);
- pic14_emitcode("mov","dptr,#%05d_DS_",jtab->key+100);
- pic14_emitcode("jmp","@a+dptr");
- pic14_emitcode("","%05d_DS_:",jtab->key+100);
-
- emitpcode(POC_MOVLW, popGetHighLabel(jtab->key));
- emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
- emitpcode(POC_MOVLW, popGetLabel(jtab->key));
- emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0));
- emitSKPNC;
- emitpcode(POC_INCF, popCopyReg(&pc_pclath));
- emitpcode(POC_MOVWF, popCopyReg(&pc_pcl));
- emitpLabel(jtab->key);
-
- freeAsmop(IC_JTCOND(ic),NULL,ic,TRUE);
-
- /* now generate the jump labels */
- for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
- jtab = setNextItem(IC_JTLABELS(ic))) {
- pic14_emitcode("ljmp","%05d_DS_",jtab->key+100);
- emitpcode(POC_GOTO,popGetLabel(jtab->key));
+ symbol *jtab;
+ char *l;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp(IC_JTCOND(ic),ic,FALSE);
+ /* get the condition into accumulator */
+ l = aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE);
+ MOVA(l);
+ /* multiply by three */
+ pic14_emitcode("add","a,acc");
+ pic14_emitcode("add","a,%s",aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE));
+
+ jtab = newiTempLabel(NULL);
+ pic14_emitcode("mov","dptr,#%05d_DS_",jtab->key+100);
+ pic14_emitcode("jmp","@a+dptr");
+ pic14_emitcode("","%05d_DS_:",jtab->key+100);
+
+ emitpcode(POC_MOVLW, popGetHighLabel(jtab->key));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVLW, popGetLabel(jtab->key));
+ emitpcode(POC_ADDFW, popGet(AOP(IC_JTCOND(ic)),0));
+ emitSKPNC;
+ emitpcode(POC_INCF, popCopyReg(&pc_pclath));
+ emitpcode(POC_MOVWF, popCopyReg(&pc_pcl));
+ emitpLabel(jtab->key);
+
+ freeAsmop(IC_JTCOND(ic),NULL,ic,TRUE);
+
+ /* now generate the jump labels */
+ for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
+ jtab = setNextItem(IC_JTLABELS(ic))) {
+ pic14_emitcode("ljmp","%05d_DS_",jtab->key+100);
+ emitpcode(POC_GOTO,popGetLabel(jtab->key));
+
+ }
- }
-
}
/*-----------------------------------------------------------------*/
/* genMixedOperation - gen code for operators between mixed types */
/*-----------------------------------------------------------------*/
/*
- TSD - Written for the PIC port - but this unfortunately is buggy.
- This routine is good in that it is able to efficiently promote
- types to different (larger) sizes. Unfortunately, the temporary
- variables that are optimized out by this routine are sometimes
- used in other places. So until I know how to really parse the
- iCode tree, I'm going to not be using this routine :(.
+TSD - Written for the PIC port - but this unfortunately is buggy.
+This routine is good in that it is able to efficiently promote
+types to different (larger) sizes. Unfortunately, the temporary
+variables that are optimized out by this routine are sometimes
+used in other places. So until I know how to really parse the
+iCode tree, I'm going to not be using this routine :(.
*/
static int genMixedOperation (iCode *ic)
{
#if 0
- operand *result = IC_RESULT(ic);
- sym_link *ctype = operandType(IC_LEFT(ic));
- operand *right = IC_RIGHT(ic);
- int ret = 0;
- int big,small;
- int offset;
-
- iCode *nextic;
- operand *nextright=NULL,*nextleft=NULL,*nextresult=NULL;
-
- pic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
-
- nextic = ic->next;
- if(!nextic)
- return 0;
-
- nextright = IC_RIGHT(nextic);
- nextleft = IC_LEFT(nextic);
- nextresult = IC_RESULT(nextic);
-
- aopOp(right,ic,FALSE);
- aopOp(result,ic,FALSE);
- aopOp(nextright, nextic, FALSE);
- aopOp(nextleft, nextic, FALSE);
- aopOp(nextresult, nextic, FALSE);
-
- if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_RIGHT(nextic)))) {
-
- operand *t = right;
- right = nextright;
- nextright = t;
-
- pic14_emitcode(";remove right +","");
-
- } else if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_LEFT(nextic)))) {
-/*
- operand *t = right;
- right = nextleft;
- nextleft = t;
-*/
- pic14_emitcode(";remove left +","");
- } else
- return 0;
-
- big = AOP_SIZE(nextleft);
- small = AOP_SIZE(nextright);
-
- switch(nextic->op) {
-
- case '+':
- pic14_emitcode(";optimize a +","");
- /* if unsigned or not an integral type */
- if (AOP_TYPE(IC_LEFT(nextic)) == AOP_CRY) {
- pic14_emitcode(";add a bit to something","");
- } else {
-
- pic14_emitcode("movf","%s,w",AOP(nextright)->aopu.aop_dir);
-
- if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ) {
- pic14_emitcode("addwf","%s,w",AOP(nextleft)->aopu.aop_dir);
- pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(nextic)),0,FALSE,FALSE));
- } else
- pic14_emitcode("addwf","%s,f",AOP(nextleft)->aopu.aop_dir);
-
- offset = 0;
- while(--big) {
-
- offset++;
-
- if(--small) {
- if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
- pic14_emitcode("movf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
- }
-
- pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
- emitSKPNC;
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(nextic))->aopu.aop_dir,
- AOP(IC_RIGHT(nextic))->aopu.aop_dir);
- pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE));
-
- } else {
- pic14_emitcode("rlf","known_zero,w");
-
- /*
- if right is signed
- btfsc right,7
- addlw ff
- */
- if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
- pic14_emitcode("addwf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
- pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
- } else {
- pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
- }
+ operand *result = IC_RESULT(ic);
+ sym_link *ctype = operandType(IC_LEFT(ic));
+ operand *right = IC_RIGHT(ic);
+ int ret = 0;
+ int big,small;
+ int offset;
+
+ iCode *nextic;
+ operand *nextright=NULL,*nextleft=NULL,*nextresult=NULL;
+
+ pic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ nextic = ic->next;
+ if(!nextic)
+ return 0;
+
+ nextright = IC_RIGHT(nextic);
+ nextleft = IC_LEFT(nextic);
+ nextresult = IC_RESULT(nextic);
+
+ aopOp(right,ic,FALSE);
+ aopOp(result,ic,FALSE);
+ aopOp(nextright, nextic, FALSE);
+ aopOp(nextleft, nextic, FALSE);
+ aopOp(nextresult, nextic, FALSE);
+
+ if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_RIGHT(nextic)))) {
+
+ operand *t = right;
+ right = nextright;
+ nextright = t;
+
+ pic14_emitcode(";remove right +","");
+
+ } else if (pic14_sameRegs(AOP(IC_RESULT(ic)), AOP(IC_LEFT(nextic)))) {
+ /*
+ operand *t = right;
+ right = nextleft;
+ nextleft = t;
+ */
+ pic14_emitcode(";remove left +","");
+ } else
+ return 0;
+
+ big = AOP_SIZE(nextleft);
+ small = AOP_SIZE(nextright);
+
+ switch(nextic->op) {
+
+ case '+':
+ pic14_emitcode(";optimize a +","");
+ /* if unsigned or not an integral type */
+ if (AOP_TYPE(IC_LEFT(nextic)) == AOP_CRY) {
+ pic14_emitcode(";add a bit to something","");
+ } else {
+
+ pic14_emitcode("movf","%s,w",AOP(nextright)->aopu.aop_dir);
+
+ if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ) {
+ pic14_emitcode("addwf","%s,w",AOP(nextleft)->aopu.aop_dir);
+ pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(nextic)),0,FALSE,FALSE));
+ } else
+ pic14_emitcode("addwf","%s,f",AOP(nextleft)->aopu.aop_dir);
+
+ offset = 0;
+ while(--big) {
+
+ offset++;
+
+ if(--small) {
+ if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
+ pic14_emitcode("movf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
+ }
+
+ pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ emitSKPNC;
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(nextic))->aopu.aop_dir,
+ AOP(IC_RIGHT(nextic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE));
+
+ } else {
+ pic14_emitcode("rlf","known_zero,w");
+
+ /*
+ if right is signed
+ btfsc right,7
+ addlw ff
+ */
+ if (!pic14_sameRegs(AOP(IC_LEFT(nextic)), AOP(IC_RESULT(nextic))) ){
+ pic14_emitcode("addwf","%s,w",aopGet(AOP(IC_LEFT(nextic)),offset,FALSE,FALSE));
+ pic14_emitcode("movwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
+ } else {
+ pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(nextic)),offset,FALSE,FALSE) );
+ }
+ }
+ }
+ ret = 1;
+ }
}
- }
- ret = 1;
- }
- }
- ret = 1;
-
+ ret = 1;
+
release:
- freeAsmop(right,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
- freeAsmop(nextright,NULL,ic,TRUE);
- freeAsmop(nextleft,NULL,ic,TRUE);
- if(ret)
- nextic->generated = 1;
-
- return ret;
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+ freeAsmop(nextright,NULL,ic,TRUE);
+ freeAsmop(nextleft,NULL,ic,TRUE);
+ if(ret)
+ nextic->generated = 1;
+
+ return ret;
#else
- return 0;
+ return 0;
#endif
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genCast (iCode *ic)
{
- operand *result = IC_RESULT(ic);
- sym_link *ctype = operandType(IC_LEFT(ic));
- sym_link *rtype = operandType(IC_RIGHT(ic));
- operand *right = IC_RIGHT(ic);
- int size, offset ;
-
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- /* if they are equivalent then do nothing */
- if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
- return ;
-
- aopOp(right,ic,FALSE) ;
- aopOp(result,ic,FALSE);
-
- DEBUGpic14_AopType(__LINE__,NULL,right,result);
-
- /* if the result is a bit */
- if (AOP_TYPE(result) == AOP_CRY) {
- /* if the right size is a literal then
- we know what the value is */
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_TYPE(right) == AOP_LIT) {
-
- emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
- popGet(AOP(result),0));
-
- if (((int) operandLitValue(right)))
- pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
- else
- pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
- AOP(result)->aopu.aop_dir,
- AOP(result)->aopu.aop_dir);
-
- goto release;
- }
-
- /* the right is also a bit variable */
- if (AOP_TYPE(right) == AOP_CRY) {
-
- emitCLRC;
- emitpcode(POC_BTFSC, popGet(AOP(right),0));
-
- pic14_emitcode("clrc","");
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(right)->aopu.aop_dir,
- AOP(right)->aopu.aop_dir);
- aopPut(AOP(result),"c",0);
- goto release ;
- }
-
- /* we need to or */
- if (AOP_TYPE(right) == AOP_REG) {
- emitpcode(POC_BCF, popGet(AOP(result),0));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
- emitpcode(POC_BSF, popGet(AOP(result),0));
- }
- pic14_toBoolean(right);
- aopPut(AOP(result),"a",0);
- goto release ;
- }
-
- if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) {
- int offset = 1;
- size = AOP_SIZE(result);
-
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
-
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- emitpcode(POC_BTFSC, popGet(AOP(right),0));
- emitpcode(POC_INCF, popGet(AOP(result),0));
-
- while (size--)
- emitpcode(POC_CLRF, popGet(AOP(result),offset++));
-
- goto release;
- }
-
- /* if they are the same size : or less */
- if (AOP_SIZE(result) <= AOP_SIZE(right)) {
-
- /* if they are in the same place */
- if (pic14_sameRegs(AOP(right),AOP(result)))
- goto release;
-
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
- if (IS_PTR_CONST(rtype))
- DEBUGpic14_emitcode ("; ***","%d - right is const pointer",__LINE__);
- if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
- DEBUGpic14_emitcode ("; ***","%d - result is const pointer",__LINE__);
-
- if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
- emitpcode(POC_MOVLW, popGet(AOP(right),0));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
- emitpcode(POC_MOVLW, popGet(AOP(right),1));
- emitpcode(POC_MOVWF, popGet(AOP(result),1));
- if(AOP_SIZE(result) <2)
- fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
-
- } else {
-
- /* if they in different places then copy */
- size = AOP_SIZE(result);
- offset = 0 ;
- while (size--) {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
-
- //aopPut(AOP(result),
- // aopGet(AOP(right),offset,FALSE,FALSE),
- // offset);
-
- offset++;
- }
- }
- goto release;
- }
-
-
- /* if the result is of type pointer */
- if (IS_PTR(ctype)) {
-
- int p_type;
- sym_link *type = operandType(right);
- sym_link *etype = getSpec(type);
- DEBUGpic14_emitcode("; ***","%s %d - pointer cast",__FUNCTION__,__LINE__);
-
- /* pointer to generic pointer */
- if (IS_GENPTR(ctype)) {
- char *l = zero;
-
- if (IS_PTR(type))
- p_type = DCL_TYPE(type);
- else {
- /* we have to go by the storage class */
- p_type = PTR_TYPE(SPEC_OCLS(etype));
-
-/* if (SPEC_OCLS(etype)->codesp ) */
-/* p_type = CPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/* p_type = FPOINTER ; */
-/* else */
-/* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
-/* p_type = PPOINTER; */
-/* else */
-/* if (SPEC_OCLS(etype) == idata ) */
-/* p_type = IPOINTER ; */
-/* else */
-/* p_type = POINTER ; */
- }
-
- /* the first two bytes are known */
- DEBUGpic14_emitcode("; ***","%s %d - pointer cast2",__FUNCTION__,__LINE__);
- size = GPTRSIZE - 1;
- offset = 0 ;
- while (size--) {
- if(offset < AOP_SIZE(right)) {
- DEBUGpic14_emitcode("; ***","%s %d - pointer cast3",__FUNCTION__,__LINE__);
- if ((AOP_TYPE(right) == AOP_PCODE) &&
- AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
- emitpcode(POC_MOVLW, popGet(AOP(right),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- } else {
- aopPut(AOP(result),
- aopGet(AOP(right),offset,FALSE,FALSE),
- offset);
- }
- } else
- emitpcode(POC_CLRF,popGet(AOP(result),offset));
- offset++;
- }
- /* the last byte depending on type */
- switch (p_type) {
- case IPOINTER:
- case POINTER:
- emitpcode(POC_CLRF,popGet(AOP(result),GPTRSIZE - 1));
- break;
- case FPOINTER:
- pic14_emitcode(";BUG!? ","%d",__LINE__);
- l = one;
- break;
- case CPOINTER:
- pic14_emitcode(";BUG!? ","%d",__LINE__);
- l = "#0x02";
- break;
- case PPOINTER:
- pic14_emitcode(";BUG!? ","%d",__LINE__);
- l = "#0x03";
- break;
+ operand *result = IC_RESULT(ic);
+ sym_link *ctype = operandType(IC_LEFT(ic));
+ sym_link *rtype = operandType(IC_RIGHT(ic));
+ operand *right = IC_RIGHT(ic);
+ int size, offset ;
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* if they are equivalent then do nothing */
+ if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
+ return ;
+
+ aopOp(right,ic,FALSE) ;
+ aopOp(result,ic,FALSE);
+
+ DEBUGpic14_AopType(__LINE__,NULL,right,result);
+
+ /* if the result is a bit */
+ if (AOP_TYPE(result) == AOP_CRY) {
+ /* if the right size is a literal then
+ we know what the value is */
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (AOP_TYPE(right) == AOP_LIT) {
+
+ emitpcode( ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
+ popGet(AOP(result),0));
+
+ if (((int) operandLitValue(right)))
+ pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+ else
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(result)->aopu.aop_dir,
+ AOP(result)->aopu.aop_dir);
+
+ goto release;
+ }
- default:
- /* this should never happen */
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "got unknown pointer type");
- exit(1);
- }
- //aopPut(AOP(result),l, GPTRSIZE - 1);
- goto release ;
+ /* the right is also a bit variable */
+ if (AOP_TYPE(right) == AOP_CRY) {
+
+ emitCLRC;
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+
+ pic14_emitcode("clrc","");
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(right)->aopu.aop_dir,
+ AOP(right)->aopu.aop_dir);
+ aopPut(AOP(result),"c",0);
+ goto release ;
+ }
+
+ /* we need to or */
+ if (AOP_TYPE(right) == AOP_REG) {
+ emitpcode(POC_BCF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ emitpcode(POC_BSF, popGet(AOP(result),0));
+ }
+ pic14_toBoolean(right);
+ aopPut(AOP(result),"a",0);
+ goto release ;
}
- /* just copy the pointers */
- size = AOP_SIZE(result);
+ if ((AOP_TYPE(right) == AOP_CRY) && (AOP_TYPE(result) == AOP_REG)) {
+ int offset = 1;
+ size = AOP_SIZE(result);
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_BTFSC, popGet(AOP(right),0));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+
+ while (size--)
+ emitpcode(POC_CLRF, popGet(AOP(result),offset++));
+
+ goto release;
+ }
+
+ /* if they are the same size : or less */
+ if (AOP_SIZE(result) <= AOP_SIZE(right)) {
+
+ /* if they are in the same place */
+ if (pic14_sameRegs(AOP(right),AOP(result)))
+ goto release;
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (IS_PTR_CONST(rtype))
+ DEBUGpic14_emitcode ("; ***","%d - right is const pointer",__LINE__);
+ if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
+ DEBUGpic14_emitcode ("; ***","%d - result is const pointer",__LINE__);
+
+ if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+ emitpcode(POC_MOVLW, popGet(AOP(right),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW, popGet(AOP(right),1));
+ emitpcode(POC_MOVWF, popGet(AOP(result),1));
+ if(AOP_SIZE(result) <2)
+ fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
+
+ } else {
+
+ /* if they in different places then copy */
+ size = AOP_SIZE(result);
+ offset = 0 ;
+ while (size--) {
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+ //aopPut(AOP(result),
+ // aopGet(AOP(right),offset,FALSE,FALSE),
+ // offset);
+
+ offset++;
+ }
+ }
+ goto release;
+ }
+
+
+ /* if the result is of type pointer */
+ if (IS_PTR(ctype)) {
+
+ int p_type;
+ sym_link *type = operandType(right);
+ sym_link *etype = getSpec(type);
+ DEBUGpic14_emitcode("; ***","%s %d - pointer cast",__FUNCTION__,__LINE__);
+
+ /* pointer to generic pointer */
+ if (IS_GENPTR(ctype)) {
+ char *l = zero;
+
+ if (IS_PTR(type))
+ p_type = DCL_TYPE(type);
+ else {
+ /* we have to go by the storage class */
+ p_type = PTR_TYPE(SPEC_OCLS(etype));
+
+ /* if (SPEC_OCLS(etype)->codesp ) */
+ /* p_type = CPOINTER ; */
+ /* else */
+ /* if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
+ /* p_type = FPOINTER ; */
+ /* else */
+ /* if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
+ /* p_type = PPOINTER; */
+ /* else */
+ /* if (SPEC_OCLS(etype) == idata ) */
+ /* p_type = IPOINTER ; */
+ /* else */
+ /* p_type = POINTER ; */
+ }
+
+ /* the first two bytes are known */
+ DEBUGpic14_emitcode("; ***","%s %d - pointer cast2",__FUNCTION__,__LINE__);
+ size = GPTRSIZE - 1;
+ offset = 0 ;
+ while (size--) {
+ if(offset < AOP_SIZE(right)) {
+ DEBUGpic14_emitcode("; ***","%s %d - pointer cast3",__FUNCTION__,__LINE__);
+ if ((AOP_TYPE(right) == AOP_PCODE) &&
+ AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+ emitpcode(POC_MOVLW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ } else {
+ aopPut(AOP(result),
+ aopGet(AOP(right),offset,FALSE,FALSE),
+ offset);
+ }
+ } else
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
+ offset++;
+ }
+ /* the last byte depending on type */
+ switch (p_type) {
+ case IPOINTER:
+ case POINTER:
+ emitpcode(POC_CLRF,popGet(AOP(result),GPTRSIZE - 1));
+ break;
+ case FPOINTER:
+ pic14_emitcode(";BUG!? ","%d",__LINE__);
+ l = one;
+ break;
+ case CPOINTER:
+ pic14_emitcode(";BUG!? ","%d",__LINE__);
+ l = "#0x02";
+ break;
+ case PPOINTER:
+ pic14_emitcode(";BUG!? ","%d",__LINE__);
+ l = "#0x03";
+ break;
+
+ default:
+ /* this should never happen */
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "got unknown pointer type");
+ exit(1);
+ }
+ //aopPut(AOP(result),l, GPTRSIZE - 1);
+ goto release ;
+ }
+
+ /* just copy the pointers */
+ size = AOP_SIZE(result);
+ offset = 0 ;
+ while (size--) {
+ aopPut(AOP(result),
+ aopGet(AOP(right),offset,FALSE,FALSE),
+ offset);
+ offset++;
+ }
+ goto release ;
+ }
+
+
+
+ /* so we now know that the size of destination is greater
+ than the size of the source.
+ Now, if the next iCode is an operator then we might be
+ able to optimize the operation without performing a cast.
+ */
+ if(genMixedOperation(ic))
+ goto release;
+
+ DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* we move to result for the size of source */
+ size = AOP_SIZE(right);
offset = 0 ;
while (size--) {
- aopPut(AOP(result),
- aopGet(AOP(right),offset,FALSE,FALSE),
- offset);
- offset++;
- }
- goto release ;
- }
-
-
-
- /* so we now know that the size of destination is greater
- than the size of the source.
- Now, if the next iCode is an operator then we might be
- able to optimize the operation without performing a cast.
- */
- if(genMixedOperation(ic))
- goto release;
-
- DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
-
- /* we move to result for the size of source */
- size = AOP_SIZE(right);
- offset = 0 ;
- while (size--) {
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
- offset++;
- }
-
- /* now depending on the sign of the destination */
- size = AOP_SIZE(result) - AOP_SIZE(right);
- /* if unsigned or not an integral type */
- if (SPEC_USIGN(rtype) || !IS_SPEC(rtype)) {
- while (size--)
- emitpcode(POC_CLRF, popGet(AOP(result),offset++));
- } else {
- /* we need to extend the sign :{ */
-
- if(size == 1) {
- /* Save one instruction of casting char to int */
- emitpcode(POC_CLRF, popGet(AOP(result),offset));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),offset-1,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(result),offset));
- } else {
- emitpcodeNULLop(POC_CLRW);
-
- if(offset)
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),offset-1,FALSE,FALSE),7,0));
- else
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),offset,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ offset++;
+ }
+
+ /* now depending on the sign of the destination */
+ size = AOP_SIZE(result) - AOP_SIZE(right);
+ /* if unsigned or not an integral type */
+ if (SPEC_USIGN(rtype) || !IS_SPEC(rtype)) {
+ while (size--)
+ emitpcode(POC_CLRF, popGet(AOP(result),offset++));
+ } else {
+ /* we need to extend the sign :{ */
+
+ if(size == 1) {
+ /* Save one instruction of casting char to int */
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),offset-1,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),offset));
+ } else {
+ emitpcodeNULLop(POC_CLRW);
+
+ if(offset)
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),offset-1,FALSE,FALSE),7,0));
+ else
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),offset,FALSE,FALSE),7,0));
+
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+
+ while (size--)
+ emitpcode(POC_MOVWF, popGet(AOP(result),offset++));
+ }
+ }
- emitpcode(POC_MOVLW, popGetLit(0xff));
-
- while (size--)
- emitpcode(POC_MOVWF, popGet(AOP(result),offset++));
- }
- }
-
release:
- freeAsmop(right,NULL,ic,TRUE);
- freeAsmop(result,NULL,ic,TRUE);
-
+ freeAsmop(right,NULL,ic,TRUE);
+ freeAsmop(result,NULL,ic,TRUE);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static int genDjnz (iCode *ic, iCode *ifx)
{
- symbol *lbl, *lbl1;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if (!ifx)
- return 0;
-
- /* if the if condition has a false label
- then we cannot save */
- if (IC_FALSE(ifx))
- return 0;
-
- /* if the minus is not of the form
- a = a - 1 */
- if (!isOperandEqual(IC_RESULT(ic),IC_LEFT(ic)) ||
- !IS_OP_LITERAL(IC_RIGHT(ic)))
- return 0;
-
- if (operandLitValue(IC_RIGHT(ic)) != 1)
- return 0;
-
- /* if the size of this greater than one then no
- saving */
- if (getSize(operandType(IC_RESULT(ic))) > 1)
- return 0;
-
- /* otherwise we can save BIG */
- lbl = newiTempLabel(NULL);
- lbl1= newiTempLabel(NULL);
-
- aopOp(IC_RESULT(ic),ic,FALSE);
-
- if (IS_AOP_PREG(IC_RESULT(ic))) {
- pic14_emitcode("dec","%s",
- aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- pic14_emitcode("mov","a,%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- pic14_emitcode("jnz","%05d_DS_",lbl->key+100);
- } else {
-
-
- emitpcode(POC_DECFSZ,popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
-
- pic14_emitcode("decfsz","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- pic14_emitcode ("goto","_%05d_DS_",IC_TRUE(ifx)->key+100 + labelOffset);
-
- }
-/* pic14_emitcode ("sjmp","%05d_DS_",lbl1->key+100); */
-/* pic14_emitcode ("","%05d_DS_:",lbl->key+100); */
-/* pic14_emitcode ("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100); */
-/* pic14_emitcode ("","%05d_DS_:",lbl1->key+100); */
-
-
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
- ifx->generated = 1;
- return 1;
+ symbol *lbl, *lbl1;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (!ifx)
+ return 0;
+
+ /* if the if condition has a false label
+ then we cannot save */
+ if (IC_FALSE(ifx))
+ return 0;
+
+ /* if the minus is not of the form
+ a = a - 1 */
+ if (!isOperandEqual(IC_RESULT(ic),IC_LEFT(ic)) ||
+ !IS_OP_LITERAL(IC_RIGHT(ic)))
+ return 0;
+
+ if (operandLitValue(IC_RIGHT(ic)) != 1)
+ return 0;
+
+ /* if the size of this greater than one then no
+ saving */
+ if (getSize(operandType(IC_RESULT(ic))) > 1)
+ return 0;
+
+ /* otherwise we can save BIG */
+ lbl = newiTempLabel(NULL);
+ lbl1= newiTempLabel(NULL);
+
+ aopOp(IC_RESULT(ic),ic,FALSE);
+
+ if (IS_AOP_PREG(IC_RESULT(ic))) {
+ pic14_emitcode("dec","%s",
+ aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("mov","a,%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("jnz","%05d_DS_",lbl->key+100);
+ } else {
+
+
+ emitpcode(POC_DECFSZ,popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_GOTO,popGetLabel(IC_TRUE(ifx)->key));
+
+ pic14_emitcode("decfsz","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ pic14_emitcode ("goto","_%05d_DS_",IC_TRUE(ifx)->key+100 + labelOffset);
+
+ }
+ /* pic14_emitcode ("sjmp","%05d_DS_",lbl1->key+100); */
+ /* pic14_emitcode ("","%05d_DS_:",lbl->key+100); */
+ /* pic14_emitcode ("ljmp","%05d_DS_",IC_TRUE(ifx)->key+100); */
+ /* pic14_emitcode ("","%05d_DS_:",lbl1->key+100); */
+
+
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ ifx->generated = 1;
+ return 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genReceive (iCode *ic)
{
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if (isOperandInFarSpace(IC_RESULT(ic)) &&
- ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
- IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
-
- int size = getSize(operandType(IC_RESULT(ic)));
- int offset = fReturnSizePic - size;
- while (size--) {
- pic14_emitcode ("push","%s", (strcmp(fReturn[fReturnSizePic - offset - 1],"a") ?
- fReturn[fReturnSizePic - offset - 1] : "acc"));
- offset++;
- }
- aopOp(IC_RESULT(ic),ic,FALSE);
- size = AOP_SIZE(IC_RESULT(ic));
- offset = 0;
- while (size--) {
- pic14_emitcode ("pop","acc");
- aopPut (AOP(IC_RESULT(ic)),"a",offset++);
- }
-
- } else {
- _G.accInUse++;
- aopOp(IC_RESULT(ic),ic,FALSE);
- _G.accInUse--;
- assignResultValue(IC_RESULT(ic));
- }
-
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (isOperandInFarSpace(IC_RESULT(ic)) &&
+ ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
+ IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
+
+ int size = getSize(operandType(IC_RESULT(ic)));
+ int offset = fReturnSizePic - size;
+ while (size--) {
+ pic14_emitcode ("push","%s", (strcmp(fReturn[fReturnSizePic - offset - 1],"a") ?
+ fReturn[fReturnSizePic - offset - 1] : "acc"));
+ offset++;
+ }
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ size = AOP_SIZE(IC_RESULT(ic));
+ offset = 0;
+ while (size--) {
+ pic14_emitcode ("pop","acc");
+ aopPut (AOP(IC_RESULT(ic)),"a",offset++);
+ }
+
+ } else {
+ _G.accInUse++;
+ aopOp(IC_RESULT(ic),ic,FALSE);
+ _G.accInUse--;
+ assignResultValue(IC_RESULT(ic));
+ }
+
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
static void
genDummyRead (iCode * ic)
{
- pic14_emitcode ("; genDummyRead","");
- pic14_emitcode ("; not implemented","");
-
- ic = ic;
+ pic14_emitcode ("; genDummyRead","");
+ pic14_emitcode ("; not implemented","");
+
+ ic = ic;
}
/*-----------------------------------------------------------------*/
/* genpic14Code - generate code for pic14 based controllers */
/*-----------------------------------------------------------------*/
/*
- * At this point, ralloc.c has gone through the iCode and attempted
- * to optimize in a way suitable for a PIC. Now we've got to generate
- * PIC instructions that correspond to the iCode.
- *
- * Once the instructions are generated, we'll pass through both the
- * peep hole optimizer and the pCode optimizer.
- *-----------------------------------------------------------------*/
+* At this point, ralloc.c has gone through the iCode and attempted
+* to optimize in a way suitable for a PIC. Now we've got to generate
+* PIC instructions that correspond to the iCode.
+*
+* Once the instructions are generated, we'll pass through both the
+* peep hole optimizer and the pCode optimizer.
+*-----------------------------------------------------------------*/
void genpic14Code (iCode *lic)
{
- iCode *ic;
- int cln = 0;
-
- lineHead = lineCurr = NULL;
-
- pb = newpCodeChain(GcurMemmap,0,newpCodeCharP("; Starting pCode block"));
- addpBlock(pb);
-
- /* if debug information required */
- if (options.debug && currFunc) {
- if (currFunc) {
- debugFile->writeFunction(currFunc);
- _G.debugLine = 1;
- if (IS_STATIC(currFunc->etype)) {
- pic14_emitcode("",";F%s$%s$0$0 %d",moduleName,currFunc->name,__LINE__);
- //addpCode2pBlock(pb,newpCodeLabel(moduleName,currFunc->name));
- } else {
- pic14_emitcode("",";G$%s$0$0 %d",currFunc->name,__LINE__);
- //addpCode2pBlock(pb,newpCodeLabel(NULL,currFunc->name));
- }
- _G.debugLine = 0;
- }
- }
-
-
- for (ic = lic ; ic ; ic = ic->next ) {
-
- DEBUGpic14_emitcode(";ic","");
- if ( cln != ic->lineno ) {
- if ( options.debug ) {
- _G.debugLine = 1;
- pic14_emitcode("",";C$%s$%d$%d$%d ==.",
- FileBaseName(ic->filename),ic->lineno,
- ic->level,ic->block);
- _G.debugLine = 0;
- }
- /*
- pic14_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
- pic14_emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
- printCLine(ic->filename, ic->lineno));
- */
- if (!options.noCcodeInAsm) {
- addpCode2pBlock(pb,
- newpCodeCSource(ic->lineno,
- ic->filename,
- printCLine(ic->filename, ic->lineno)));
- }
-
- cln = ic->lineno ;
- }
-
- // if you want printILine too, look at ../mcs51/gen.c, i don't understand this :)
-
- /* if the result is marked as
- spilt and rematerializable or code for
- this has already been generated then
- do nothing */
- if (resultRemat(ic) || ic->generated )
- continue ;
-
- /* depending on the operation */
- switch (ic->op) {
- case '!' :
- genNot(ic);
- break;
-
- case '~' :
- genCpl(ic);
- break;
-
- case UNARYMINUS:
- genUminus (ic);
- break;
-
- case IPUSH:
- genIpush (ic);
- break;
-
- case IPOP:
- /* IPOP happens only when trying to restore a
- spilt live range, if there is an ifx statement
- following this pop then the if statement might
- be using some of the registers being popped which
- would destory the contents of the register so
- we need to check for this condition and handle it */
- if (ic->next &&
- ic->next->op == IFX &&
- regsInCommon(IC_LEFT(ic),IC_COND(ic->next)))
- genIfx (ic->next,ic);
- else
- genIpop (ic);
- break;
-
- case CALL:
- genCall (ic);
- break;
-
- case PCALL:
- genPcall (ic);
- break;
-
- case FUNCTION:
- genFunction (ic);
- break;
-
- case ENDFUNCTION:
- genEndFunction (ic);
- break;
-
- case RETURN:
- genRet (ic);
- break;
-
- case LABEL:
- genLabel (ic);
- break;
-
- case GOTO:
- genGoto (ic);
- break;
-
- case '+' :
- genPlus (ic) ;
- break;
-
- case '-' :
- if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
- genMinus (ic);
- break;
-
- case '*' :
- genMult (ic);
- break;
-
- case '/' :
- genDiv (ic) ;
- break;
-
- case '%' :
- genMod (ic);
- break;
-
- case '>' :
- genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));
- break;
-
- case '<' :
- genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
- break;
-
- case LE_OP:
- case GE_OP:
- case NE_OP:
-
- /* note these two are xlated by algebraic equivalence
- during parsing SDCC.y */
- werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
- "got '>=' or '<=' shouldn't have come here");
- break;
-
- case EQ_OP:
- genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
- break;
-
- case AND_OP:
- genAndOp (ic);
- break;
-
- case OR_OP:
- genOrOp (ic);
- break;
-
- case '^' :
- genXor (ic,ifxForOp(IC_RESULT(ic),ic));
- break;
-
- case '|' :
- genOr (ic,ifxForOp(IC_RESULT(ic),ic));
- break;
-
- case BITWISEAND:
- genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
- break;
-
- case INLINEASM:
- genInline (ic);
- break;
-
- case RRC:
- genRRC (ic);
- break;
-
- case RLC:
- genRLC (ic);
- break;
-
- case GETHBIT:
- genGetHbit (ic);
- break;
-
- case LEFT_OP:
- genLeftShift (ic);
- break;
-
- case RIGHT_OP:
- genRightShift (ic);
- break;
-
- case GET_VALUE_AT_ADDRESS:
- genPointerGet(ic);
- break;
-
- case '=' :
- if (POINTER_SET(ic))
- genPointerSet(ic);
- else
- genAssign(ic);
- break;
-
- case IFX:
- genIfx (ic,NULL);
- break;
-
- case ADDRESS_OF:
- genAddrOf (ic);
- break;
-
- case JUMPTABLE:
- genJumpTab (ic);
- break;
-
- case CAST:
- genCast (ic);
- break;
-
- case RECEIVE:
- genReceive(ic);
- break;
-
- case SEND:
- addSet(&_G.sendSet,ic);
- break;
-
- case DUMMY_READ_VOLATILE:
- genDummyRead (ic);
- break;
-
- default :
- ic = ic;
- }
- }
-
-
- /* now we are ready to call the
- peep hole optimizer */
- if (!options.nopeep) {
- peepHole (&lineHead);
- }
- /* now do the actual printing */
- printLine (lineHead,codeOutFile);
-
+ iCode *ic;
+ int cln = 0;
+
+ lineHead = lineCurr = NULL;
+
+ pb = newpCodeChain(GcurMemmap,0,newpCodeCharP("; Starting pCode block"));
+ addpBlock(pb);
+
+ /* if debug information required */
+ if (options.debug && currFunc) {
+ if (currFunc) {
+ debugFile->writeFunction(currFunc);
+ _G.debugLine = 1;
+ if (IS_STATIC(currFunc->etype)) {
+ pic14_emitcode("",";F%s$%s$0$0 %d",moduleName,currFunc->name,__LINE__);
+ //addpCode2pBlock(pb,newpCodeLabel(moduleName,currFunc->name));
+ } else {
+ pic14_emitcode("",";G$%s$0$0 %d",currFunc->name,__LINE__);
+ //addpCode2pBlock(pb,newpCodeLabel(NULL,currFunc->name));
+ }
+ _G.debugLine = 0;
+ }
+ }
+
+
+ for (ic = lic ; ic ; ic = ic->next ) {
+
+ DEBUGpic14_emitcode(";ic","");
+ if ( cln != ic->lineno ) {
+ if ( options.debug ) {
+ _G.debugLine = 1;
+ pic14_emitcode("",";C$%s$%d$%d$%d ==.",
+ FileBaseName(ic->filename),ic->lineno,
+ ic->level,ic->block);
+ _G.debugLine = 0;
+ }
+ /*
+ pic14_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
+ pic14_emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno,
+ printCLine(ic->filename, ic->lineno));
+ */
+ if (!options.noCcodeInAsm) {
+ addpCode2pBlock(pb,
+ newpCodeCSource(ic->lineno,
+ ic->filename,
+ printCLine(ic->filename, ic->lineno)));
+ }
+
+ cln = ic->lineno ;
+ }
+
+ // if you want printILine too, look at ../mcs51/gen.c, i don't understand this :)
+
+ /* if the result is marked as
+ spilt and rematerializable or code for
+ this has already been generated then
+ do nothing */
+ if (resultRemat(ic) || ic->generated )
+ continue ;
+
+ /* depending on the operation */
+ switch (ic->op) {
+ case '!' :
+ genNot(ic);
+ break;
+
+ case '~' :
+ genCpl(ic);
+ break;
+
+ case UNARYMINUS:
+ genUminus (ic);
+ break;
+
+ case IPUSH:
+ genIpush (ic);
+ break;
+
+ case IPOP:
+ /* IPOP happens only when trying to restore a
+ spilt live range, if there is an ifx statement
+ following this pop then the if statement might
+ be using some of the registers being popped which
+ would destory the contents of the register so
+ we need to check for this condition and handle it */
+ if (ic->next &&
+ ic->next->op == IFX &&
+ regsInCommon(IC_LEFT(ic),IC_COND(ic->next)))
+ genIfx (ic->next,ic);
+ else
+ genIpop (ic);
+ break;
+
+ case CALL:
+ genCall (ic);
+ break;
+
+ case PCALL:
+ genPcall (ic);
+ break;
+
+ case FUNCTION:
+ genFunction (ic);
+ break;
+
+ case ENDFUNCTION:
+ genEndFunction (ic);
+ break;
+
+ case RETURN:
+ genRet (ic);
+ break;
+
+ case LABEL:
+ genLabel (ic);
+ break;
+
+ case GOTO:
+ genGoto (ic);
+ break;
+
+ case '+' :
+ genPlus (ic) ;
+ break;
+
+ case '-' :
+ if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
+ genMinus (ic);
+ break;
+
+ case '*' :
+ genMult (ic);
+ break;
+
+ case '/' :
+ genDiv (ic) ;
+ break;
+
+ case '%' :
+ genMod (ic);
+ break;
+
+ case '>' :
+ genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case '<' :
+ genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case LE_OP:
+ case GE_OP:
+ case NE_OP:
+
+ /* note these two are xlated by algebraic equivalence
+ during parsing SDCC.y */
+ werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+ "got '>=' or '<=' shouldn't have come here");
+ break;
+
+ case EQ_OP:
+ genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case AND_OP:
+ genAndOp (ic);
+ break;
+
+ case OR_OP:
+ genOrOp (ic);
+ break;
+
+ case '^' :
+ genXor (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case '|' :
+ genOr (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case BITWISEAND:
+ genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
+ break;
+
+ case INLINEASM:
+ genInline (ic);
+ break;
+
+ case RRC:
+ genRRC (ic);
+ break;
+
+ case RLC:
+ genRLC (ic);
+ break;
+
+ case GETHBIT:
+ genGetHbit (ic);
+ break;
+
+ case LEFT_OP:
+ genLeftShift (ic);
+ break;
+
+ case RIGHT_OP:
+ genRightShift (ic);
+ break;
+
+ case GET_VALUE_AT_ADDRESS:
+ genPointerGet(ic);
+ break;
+
+ case '=' :
+ if (POINTER_SET(ic))
+ genPointerSet(ic);
+ else
+ genAssign(ic);
+ break;
+
+ case IFX:
+ genIfx (ic,NULL);
+ break;
+
+ case ADDRESS_OF:
+ genAddrOf (ic);
+ break;
+
+ case JUMPTABLE:
+ genJumpTab (ic);
+ break;
+
+ case CAST:
+ genCast (ic);
+ break;
+
+ case RECEIVE:
+ genReceive(ic);
+ break;
+
+ case SEND:
+ addSet(&_G.sendSet,ic);
+ break;
+
+ case DUMMY_READ_VOLATILE:
+ genDummyRead (ic);
+ break;
+
+ default :
+ ic = ic;
+ }
+ }
+
+
+ /* now we are ready to call the
+ peep hole optimizer */
+ if (!options.nopeep) {
+ peepHole (&lineHead);
+ }
+ /* now do the actual printing */
+ printLine (lineHead,codeOutFile);
+
#ifdef PCODE_DEBUG
- DFPRINTF((stderr,"printing pBlock\n\n"));
- printpBlock(stdout,pb);
+ DFPRINTF((stderr,"printing pBlock\n\n"));
+ printpBlock(stdout,pb);
#endif
-
- return;
+
+ return;
}
struct pCodeOp;
enum
- {
- AOP_LIT = 1,
- AOP_REG, AOP_DIR,
- AOP_DPTR, AOP_DPTR2, AOP_R0, AOP_R1,
- AOP_STK, AOP_IMMD, AOP_STR,
- AOP_CRY, AOP_ACC,
- AOP_PCODE
+{
+ AOP_LIT = 1,
+ AOP_REG, AOP_DIR,
+ AOP_DPTR, AOP_DPTR2, AOP_R0, AOP_R1,
+ AOP_STK, AOP_IMMD, AOP_STR,
+ AOP_CRY, AOP_ACC,
+ AOP_PCODE
- };
+};
/* type asmop : a homogenised type for
all the different spaces an operand can be
in */
typedef struct asmop
- {
-
- short type; /* can have values
- AOP_LIT - operand is a literal value
- AOP_REG - is in registers
- AOP_DIR - direct just a name
- AOP_DPTR - dptr contains address of operand
- AOP_DPTR2 - dptr2 contains address of operand (DS80C390 only).
- AOP_R0/R1 - r0/r1 contains address of operand
- AOP_STK - should be pushed on stack this
- can happen only for the result
- AOP_IMMD - immediate value for eg. remateriazable
- AOP_CRY - carry contains the value of this
- AOP_STR - array of strings
- AOP_ACC - result is in the acc:b pair
- */
- short coff; /* current offset */
- short size; /* total size */
- unsigned code:1; /* is in Code space */
- unsigned paged:1; /* in paged memory */
- unsigned freed:1; /* already freed */
- union
- {
- value *aop_lit; /* if literal */
- regs *aop_reg[4]; /* array of registers */
- char *aop_dir; /* if direct */
- regs *aop_ptr; /* either -> to r0 or r1 */
- char *aop_immd; /* if immediate others are implied */
- int aop_stk; /* stack offset when AOP_STK */
- char *aop_str[4]; /* just a string array containing the location */
-/* regs *aop_alloc_reg; * points to a dynamically allocated register */
- pCodeOp *pcop;
- }
- aopu;
- }
+{
+
+ short type; /* can have values
+ AOP_LIT - operand is a literal value
+ AOP_REG - is in registers
+ AOP_DIR - direct just a name
+ AOP_DPTR - dptr contains address of operand
+ AOP_DPTR2 - dptr2 contains address of operand (DS80C390 only).
+ AOP_R0/R1 - r0/r1 contains address of operand
+ AOP_STK - should be pushed on stack this
+ can happen only for the result
+ AOP_IMMD - immediate value for eg. remateriazable
+ AOP_CRY - carry contains the value of this
+ AOP_STR - array of strings
+ AOP_ACC - result is in the acc:b pair
+ */
+ short coff; /* current offset */
+ short size; /* total size */
+ unsigned code:1; /* is in Code space */
+ unsigned paged:1; /* in paged memory */
+ unsigned freed:1; /* already freed */
+ union
+ {
+ value *aop_lit; /* if literal */
+ regs *aop_reg[4]; /* array of registers */
+ char *aop_dir; /* if direct */
+ regs *aop_ptr; /* either -> to r0 or r1 */
+ char *aop_immd; /* if immediate others are implied */
+ int aop_stk; /* stack offset when AOP_STK */
+ char *aop_str[4]; /* just a string array containing the location */
+/* regs *aop_alloc_reg; * points to a dynamically allocated register */
+ pCodeOp *pcop;
+ }
+ aopu;
+}
asmop;
void genpic14Code (iCode *);
const char *AopType(short type)
{
- switch(type) {
- case AOP_LIT:
- return "AOP_LIT";
- break;
- case AOP_REG:
- return "AOP_REG";
- break;
- case AOP_DIR:
- return "AOP_DIR";
- break;
- case AOP_DPTR:
- return "AOP_DPTR";
- break;
- case AOP_DPTR2:
- return "AOP_DPTR2";
- break;
- case AOP_R0:
- return "AOP_R0";
- break;
- case AOP_R1:
- return "AOP_R1";
- break;
- case AOP_STK:
- return "AOP_STK";
- break;
- case AOP_IMMD:
- return "AOP_IMMD";
- break;
- case AOP_STR:
- return "AOP_STR";
- break;
- case AOP_CRY:
- return "AOP_CRY";
- break;
- case AOP_ACC:
- return "AOP_ACC";
- break;
- case AOP_PCODE:
- return "AOP_PCODE";
- break;
- }
-
- return "BAD TYPE";
+ switch(type) {
+ case AOP_LIT:
+ return "AOP_LIT";
+ break;
+ case AOP_REG:
+ return "AOP_REG";
+ break;
+ case AOP_DIR:
+ return "AOP_DIR";
+ break;
+ case AOP_DPTR:
+ return "AOP_DPTR";
+ break;
+ case AOP_DPTR2:
+ return "AOP_DPTR2";
+ break;
+ case AOP_R0:
+ return "AOP_R0";
+ break;
+ case AOP_R1:
+ return "AOP_R1";
+ break;
+ case AOP_STK:
+ return "AOP_STK";
+ break;
+ case AOP_IMMD:
+ return "AOP_IMMD";
+ break;
+ case AOP_STR:
+ return "AOP_STR";
+ break;
+ case AOP_CRY:
+ return "AOP_CRY";
+ break;
+ case AOP_ACC:
+ return "AOP_ACC";
+ break;
+ case AOP_PCODE:
+ return "AOP_PCODE";
+ break;
+ }
+
+ return "BAD TYPE";
}
const char *pCodeOpType( pCodeOp *pcop)
{
-
- if(pcop) {
-
- switch(pcop->type) {
-
- case PO_NONE:
- return "PO_NONE";
- case PO_W:
- return "PO_W";
- case PO_STATUS:
- return "PO_STATUS";
- case PO_FSR:
- return "PO_FSR";
- case PO_INDF:
- return "PO_INDF";
- case PO_INTCON:
- return "PO_INTCON";
- case PO_GPR_REGISTER:
- return "PO_GPR_REGISTER";
- case PO_GPR_POINTER:
- return "PO_GPR_POINTER";
- case PO_GPR_BIT:
- return "PO_GPR_BIT";
- case PO_GPR_TEMP:
- return "PO_GPR_TEMP";
- case PO_SFR_REGISTER:
- return "PO_SFR_REGISTER";
- case PO_PCL:
- return "PO_PCL";
- case PO_PCLATH:
- return "PO_PCLATH";
- case PO_LITERAL:
- return "PO_LITERAL";
- case PO_IMMEDIATE:
- return "PO_IMMEDIATE";
- case PO_DIR:
- return "PO_DIR";
- case PO_CRY:
- return "PO_CRY";
- case PO_BIT:
- return "PO_BIT";
- case PO_STR:
- return "PO_STR";
- case PO_LABEL:
- return "PO_LABEL";
- case PO_WILD:
- return "PO_WILD";
- }
- }
-
- return "BAD PO_TYPE";
+
+ if(pcop) {
+
+ switch(pcop->type) {
+
+ case PO_NONE:
+ return "PO_NONE";
+ case PO_W:
+ return "PO_W";
+ case PO_STATUS:
+ return "PO_STATUS";
+ case PO_FSR:
+ return "PO_FSR";
+ case PO_INDF:
+ return "PO_INDF";
+ case PO_INTCON:
+ return "PO_INTCON";
+ case PO_GPR_REGISTER:
+ return "PO_GPR_REGISTER";
+ case PO_GPR_POINTER:
+ return "PO_GPR_POINTER";
+ case PO_GPR_BIT:
+ return "PO_GPR_BIT";
+ case PO_GPR_TEMP:
+ return "PO_GPR_TEMP";
+ case PO_SFR_REGISTER:
+ return "PO_SFR_REGISTER";
+ case PO_PCL:
+ return "PO_PCL";
+ case PO_PCLATH:
+ return "PO_PCLATH";
+ case PO_LITERAL:
+ return "PO_LITERAL";
+ case PO_IMMEDIATE:
+ return "PO_IMMEDIATE";
+ case PO_DIR:
+ return "PO_DIR";
+ case PO_CRY:
+ return "PO_CRY";
+ case PO_BIT:
+ return "PO_BIT";
+ case PO_STR:
+ return "PO_STR";
+ case PO_LABEL:
+ return "PO_LABEL";
+ case PO_WILD:
+ return "PO_WILD";
+ }
+ }
+
+ return "BAD PO_TYPE";
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
bool genPlusIncr (iCode *ic)
{
- unsigned int icount ;
- unsigned int size = pic14_getDataSize(IC_RESULT(ic));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_LEFT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))));
-
- /* will try to generate an increment */
- /* if the right side is not a literal
- we cannot */
- if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
- return FALSE ;
-
- DEBUGpic14_emitcode ("; ","%s %d",__FUNCTION__,__LINE__);
- /* if the literal value of the right hand side
- is greater than 1 then it is faster to add */
- if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
- return FALSE ;
-
- /* if increment 16 bits in register */
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
- (icount == 1)) {
-
- int offset = MSB16;
-
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB));
- //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
-
- while(--size) {
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
- //pic14_emitcode(" incf","%s,f",aopGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
- }
-
- return TRUE;
- }
-
- DEBUGpic14_emitcode ("; ","%s %d",__FUNCTION__,__LINE__);
- /* if left is in accumulator - probably a bit operation*/
- if( strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") &&
- (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) ) {
-
- emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
- pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
- AOP(IC_RESULT(ic))->aopu.aop_dir,
- AOP(IC_RESULT(ic))->aopu.aop_dir);
- if(icount)
- emitpcode(POC_XORLW,popGetLit(1));
- //pic14_emitcode("xorlw","1");
- else
- emitpcode(POC_ANDLW,popGetLit(1));
- //pic14_emitcode("andlw","1");
-
- emitSKPZ;
- emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
- pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
- AOP(IC_RESULT(ic))->aopu.aop_dir,
- AOP(IC_RESULT(ic))->aopu.aop_dir);
-
- return TRUE;
- }
-
-
-
- /* if the sizes are greater than 1 then we cannot */
- if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
- AOP_SIZE(IC_LEFT(ic)) > 1 )
- return FALSE ;
-
- /* If we are incrementing the same register by two: */
-
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+ unsigned int icount ;
+ unsigned int size = pic14_getDataSize(IC_RESULT(ic));
- while (icount--)
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
- //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
+ AopType(AOP_TYPE(IC_RESULT(ic))),
+ AopType(AOP_TYPE(IC_LEFT(ic))),
+ AopType(AOP_TYPE(IC_RIGHT(ic))));
- return TRUE ;
- }
-
- DEBUGpic14_emitcode ("; ","couldn't increment ");
-
- return FALSE ;
+ /* will try to generate an increment */
+ /* if the right side is not a literal
+ we cannot */
+ if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
+ return FALSE ;
+
+ DEBUGpic14_emitcode ("; ","%s %d",__FUNCTION__,__LINE__);
+ /* if the literal value of the right hand side
+ is greater than 1 then it is faster to add */
+ if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
+ return FALSE ;
+
+ /* if increment 16 bits in register */
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
+ (icount == 1)) {
+
+ int offset = MSB16;
+
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB));
+ //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+
+ while(--size) {
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
+ //pic14_emitcode(" incf","%s,f",aopGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
+ }
+
+ return TRUE;
+ }
+
+ DEBUGpic14_emitcode ("; ","%s %d",__FUNCTION__,__LINE__);
+ /* if left is in accumulator - probably a bit operation*/
+ if( strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") &&
+ (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) ) {
+
+ emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(IC_RESULT(ic))->aopu.aop_dir,
+ AOP(IC_RESULT(ic))->aopu.aop_dir);
+ if(icount)
+ emitpcode(POC_XORLW,popGetLit(1));
+ //pic14_emitcode("xorlw","1");
+ else
+ emitpcode(POC_ANDLW,popGetLit(1));
+ //pic14_emitcode("andlw","1");
+
+ emitSKPZ;
+ emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
+ pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+ AOP(IC_RESULT(ic))->aopu.aop_dir,
+ AOP(IC_RESULT(ic))->aopu.aop_dir);
+
+ return TRUE;
+ }
+
+
+
+ /* if the sizes are greater than 1 then we cannot */
+ if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
+ AOP_SIZE(IC_LEFT(ic)) > 1 )
+ return FALSE ;
+
+ /* If we are incrementing the same register by two: */
+
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+
+ while (icount--)
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
+ //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ return TRUE ;
+ }
+
+ DEBUGpic14_emitcode ("; ","couldn't increment ");
+
+ return FALSE ;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pic14_outBitAcc(operand *result)
{
- symbol *tlbl = newiTempLabel(NULL);
- /* if the result is a bit */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if (AOP_TYPE(result) == AOP_CRY){
- aopPut(AOP(result),"a",0);
- }
- else {
- pic14_emitcode("jz","%05d_DS_",tlbl->key+100);
- pic14_emitcode("mov","a,#01");
- pic14_emitcode("","%05d_DS_:",tlbl->key+100);
- pic14_outAcc(result);
- }
+ symbol *tlbl = newiTempLabel(NULL);
+ /* if the result is a bit */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if (AOP_TYPE(result) == AOP_CRY){
+ aopPut(AOP(result),"a",0);
+ }
+ else {
+ pic14_emitcode("jz","%05d_DS_",tlbl->key+100);
+ pic14_emitcode("mov","a,#01");
+ pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+ pic14_outAcc(result);
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void genPlusBits (iCode *ic)
{
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_LEFT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))));
- /*
- The following block of code will add two bits.
- Note that it'll even work if the destination is
- the carry (C in the status register).
- It won't work if the 'Z' bit is a source or destination.
- */
-
- /* If the result is stored in the accumulator (w) */
- //if(strcmp(aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),"a") == 0 ) {
- switch(AOP_TYPE(IC_RESULT(ic))) {
- case AOP_ACC:
- emitpcode(POC_CLRW, NULL);
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_XORLW, popGetLit(1));
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_XORLW, popGetLit(1));
-
- pic14_emitcode("clrw","");
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode("xorlw","1");
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_LEFT(ic))->aopu.aop_dir,
- AOP(IC_LEFT(ic))->aopu.aop_dir);
- pic14_emitcode("xorlw","1");
- break;
- case AOP_REG:
- emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_XORLW, popGetLit(1));
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_XORLW, popGetLit(1));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
- break;
- default:
- emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
-
- pic14_emitcode("movlw","(1 << (%s & 7))",
- AOP(IC_RESULT(ic))->aopu.aop_dir,
- AOP(IC_RESULT(ic))->aopu.aop_dir);
- pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
- AOP(IC_RESULT(ic))->aopu.aop_dir,
- AOP(IC_RESULT(ic))->aopu.aop_dir);
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode("xorwf","(%s >>3),f",
- AOP(IC_RESULT(ic))->aopu.aop_dir);
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_LEFT(ic))->aopu.aop_dir,
- AOP(IC_LEFT(ic))->aopu.aop_dir);
- pic14_emitcode("xorwf","(%s>>3),f",
- AOP(IC_RESULT(ic))->aopu.aop_dir);
- break;
- }
-
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
+ AopType(AOP_TYPE(IC_RESULT(ic))),
+ AopType(AOP_TYPE(IC_LEFT(ic))),
+ AopType(AOP_TYPE(IC_RIGHT(ic))));
+ /*
+ The following block of code will add two bits.
+ Note that it'll even work if the destination is
+ the carry (C in the status register).
+ It won't work if the 'Z' bit is a source or destination.
+ */
+
+ /* If the result is stored in the accumulator (w) */
+ //if(strcmp(aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),"a") == 0 ) {
+ switch(AOP_TYPE(IC_RESULT(ic))) {
+ case AOP_ACC:
+ emitpcode(POC_CLRW, NULL);
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORLW, popGetLit(1));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORLW, popGetLit(1));
+
+ pic14_emitcode("clrw","");
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode("xorlw","1");
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_LEFT(ic))->aopu.aop_dir,
+ AOP(IC_LEFT(ic))->aopu.aop_dir);
+ pic14_emitcode("xorlw","1");
+ break;
+ case AOP_REG:
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORLW, popGetLit(1));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORLW, popGetLit(1));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
+ break;
+ default:
+ emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
+
+ pic14_emitcode("movlw","(1 << (%s & 7))",
+ AOP(IC_RESULT(ic))->aopu.aop_dir,
+ AOP(IC_RESULT(ic))->aopu.aop_dir);
+ pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+ AOP(IC_RESULT(ic))->aopu.aop_dir,
+ AOP(IC_RESULT(ic))->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode("xorwf","(%s >>3),f",
+ AOP(IC_RESULT(ic))->aopu.aop_dir);
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_LEFT(ic))->aopu.aop_dir,
+ AOP(IC_LEFT(ic))->aopu.aop_dir);
+ pic14_emitcode("xorwf","(%s>>3),f",
+ AOP(IC_RESULT(ic))->aopu.aop_dir);
+ break;
+ }
+
}
#if 0
/* This is the original version of this code.
- *
- * This is being kept around for reference,
- * because I am not entirely sure I got it right...
- */
+*
+* This is being kept around for reference,
+* because I am not entirely sure I got it right...
+*/
static void adjustArithmeticResult(iCode *ic)
{
- if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
- AOP_SIZE(IC_LEFT(ic)) == 3 &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
- aopPut(AOP(IC_RESULT(ic)),
- aopGet(AOP(IC_LEFT(ic)),2,FALSE,FALSE),
- 2);
-
- if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
- AOP_SIZE(IC_RIGHT(ic)) == 3 &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
- aopPut(AOP(IC_RESULT(ic)),
- aopGet(AOP(IC_RIGHT(ic)),2,FALSE,FALSE),
- 2);
-
- if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
- AOP_SIZE(IC_LEFT(ic)) < 3 &&
- AOP_SIZE(IC_RIGHT(ic)) < 3 &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
- char buffer[5];
- sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
- aopPut(AOP(IC_RESULT(ic)),buffer,2);
- }
+ if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
+ AOP_SIZE(IC_LEFT(ic)) == 3 &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
+ aopPut(AOP(IC_RESULT(ic)),
+ aopGet(AOP(IC_LEFT(ic)),2,FALSE,FALSE),
+ 2);
+
+ if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
+ AOP_SIZE(IC_RIGHT(ic)) == 3 &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
+ aopPut(AOP(IC_RESULT(ic)),
+ aopGet(AOP(IC_RIGHT(ic)),2,FALSE,FALSE),
+ 2);
+
+ if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
+ AOP_SIZE(IC_LEFT(ic)) < 3 &&
+ AOP_SIZE(IC_RIGHT(ic)) < 3 &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
+ char buffer[5];
+ sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
+ aopPut(AOP(IC_RESULT(ic)),buffer,2);
+ }
}
//#else
/* This is the pure and virtuous version of this code.
- * I'm pretty certain it's right, but not enough to toss the old
- * code just yet...
- */
+* I'm pretty certain it's right, but not enough to toss the old
+* code just yet...
+*/
static void adjustArithmeticResult(iCode *ic)
{
- if (opIsGptr(IC_RESULT(ic)) &&
- opIsGptr(IC_LEFT(ic)) &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
- {
- aopPut(AOP(IC_RESULT(ic)),
- aopGet(AOP(IC_LEFT(ic)), GPTRSIZE - 1,FALSE,FALSE),
- GPTRSIZE - 1);
- }
-
- if (opIsGptr(IC_RESULT(ic)) &&
- opIsGptr(IC_RIGHT(ic)) &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
- {
- aopPut(AOP(IC_RESULT(ic)),
- aopGet(AOP(IC_RIGHT(ic)),GPTRSIZE - 1,FALSE,FALSE),
- GPTRSIZE - 1);
- }
-
- if (opIsGptr(IC_RESULT(ic)) &&
- AOP_SIZE(IC_LEFT(ic)) < GPTRSIZE &&
- AOP_SIZE(IC_RIGHT(ic)) < GPTRSIZE &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
- !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
- char buffer[5];
- sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
- aopPut(AOP(IC_RESULT(ic)),buffer,GPTRSIZE - 1);
- }
+ if (opIsGptr(IC_RESULT(ic)) &&
+ opIsGptr(IC_LEFT(ic)) &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
+ {
+ aopPut(AOP(IC_RESULT(ic)),
+ aopGet(AOP(IC_LEFT(ic)), GPTRSIZE - 1,FALSE,FALSE),
+ GPTRSIZE - 1);
+ }
+
+ if (opIsGptr(IC_RESULT(ic)) &&
+ opIsGptr(IC_RIGHT(ic)) &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
+ {
+ aopPut(AOP(IC_RESULT(ic)),
+ aopGet(AOP(IC_RIGHT(ic)),GPTRSIZE - 1,FALSE,FALSE),
+ GPTRSIZE - 1);
+ }
+
+ if (opIsGptr(IC_RESULT(ic)) &&
+ AOP_SIZE(IC_LEFT(ic)) < GPTRSIZE &&
+ AOP_SIZE(IC_RIGHT(ic)) < GPTRSIZE &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
+ !pic14_sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
+ char buffer[5];
+ sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
+ aopPut(AOP(IC_RESULT(ic)),buffer,GPTRSIZE - 1);
+ }
}
#endif
/*-----------------------------------------------------------------*/
static void genAddLit2byte (operand *result, int offr, int lit)
{
-
- switch(lit & 0xff) {
- case 0:
- break;
- case 1:
- emitpcode(POC_INCF, popGet(AOP(result),offr));
- break;
- case 0xff:
- emitpcode(POC_DECF, popGet(AOP(result),offr));
- break;
- default:
- emitpcode(POC_MOVLW,popGetLit(lit&0xff));
- emitpcode(POC_ADDWF,popGet(AOP(result),offr));
- }
-
-}
-
-static void emitMOVWF(operand *reg, int offset)
-{
- if(!reg)
- return;
-
- if (AOP_TYPE(reg) == AOP_ACC) {
- DEBUGpic14_emitcode ("; ***","%s %d ignoring mov into W",__FUNCTION__,__LINE__);
- return;
- }
-
- emitpcode(POC_MOVWF, popGet(AOP(reg),offset));
-
-}
-
-static void genAddLit (iCode *ic, int lit)
-{
-
- int size,same;
- int lo;
-
- operand *result;
- operand *left;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
-
- left = IC_LEFT(ic);
- result = IC_RESULT(ic);
- same = pic14_sameRegs(AOP(left), AOP(result));
- size = pic14_getDataSize(result);
-
- if(same) {
-
- /* Handle special cases first */
- if(size == 1)
- genAddLit2byte (result, 0, lit);
-
- else if(size == 2) {
- int hi = 0xff & (lit >> 8);
- lo = lit & 0xff;
-
- switch(hi) {
- case 0:
-
- /* lit = 0x00LL */
- DEBUGpic14_emitcode ("; hi = 0","%s %d",__FUNCTION__,__LINE__);
- switch(lo) {
+
+ switch(lit & 0xff) {
case 0:
- break;
+ break;
case 1:
- emitpcode(POC_INCF, popGet(AOP(result),0));
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
- break;
+ emitpcode(POC_INCF, popGet(AOP(result),offr));
+ break;
case 0xff:
- emitpcode(POC_DECF, popGet(AOP(result),0));
- emitpcode(POC_INCFSZW, popGet(AOP(result),0));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
-
- break;
+ emitpcode(POC_DECF, popGet(AOP(result),offr));
+ break;
default:
- emitpcode(POC_MOVLW,popGetLit(lit&0xff));
- emitpcode(POC_ADDWF,popGet(AOP(result),0));
- emitSKPNC;
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
-
-
- }
- break;
-
- case 1:
- /* lit = 0x01LL */
- DEBUGpic14_emitcode ("; hi = 1","%s %d",__FUNCTION__,__LINE__);
- switch(lo) {
- case 0: /* 0x0100 */
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
- break;
- case 1: /* 0x0101 */
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
- emitpcode(POC_INCF, popGet(AOP(result),0));
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
- break;
- case 0xff: /* 0x01ff */
- emitpcode(POC_DECF, popGet(AOP(result),0));
- emitpcode(POC_INCFSZW, popGet(AOP(result),0));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16));
- }
- break;
-
- case 0xff:
- DEBUGpic14_emitcode ("; hi = ff","%s %d",__FUNCTION__,__LINE__);
- /* lit = 0xffLL */
- switch(lo) {
- case 0: /* 0xff00 */
- emitpcode(POC_DECF, popGet(AOP(result),MSB16));
- break;
- case 1: /*0xff01 */
- emitpcode(POC_INCFSZ, popGet(AOP(result),0));
- emitpcode(POC_DECF, popGet(AOP(result),MSB16));
- break;
-/* case 0xff: * 0xffff *
- emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
- emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
- break;
-*/
- default:
- emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF,popGet(AOP(result),0));
- emitSKPC;
- emitpcode(POC_DECF, popGet(AOP(result),MSB16));
-
+ emitpcode(POC_MOVLW,popGetLit(lit&0xff));
+ emitpcode(POC_ADDWF,popGet(AOP(result),offr));
}
-
- break;
- default:
- DEBUGpic14_emitcode ("; hi is generic","%d %s %d",hi,__FUNCTION__,__LINE__);
+}
- /* lit = 0xHHLL */
- switch(lo) {
- case 0: /* 0xHH00 */
- genAddLit2byte (result, MSB16, hi);
- break;
- case 1: /* 0xHH01 */
- emitpcode(POC_MOVLW,popGetLit((hi+1)&0xff));
- emitpcode(POC_INCFSZ, popGet(AOP(result),0));
- emitpcode(POC_MOVLW,popGetLit(hi));
- emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
- break;
-/* case 0xff: * 0xHHff *
- emitpcode(POC_MOVFW, popGet(AOP(result),0,FALSE,FALSE));
- emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
- emitpcode(POC_MOVLW,popGetLit(hi));
- emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
- break;
-*/ default: /* 0xHHLL */
- emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF, popGet(AOP(result),0));
- emitpcode(POC_MOVLW,popGetLit(hi));
- emitSKPNC;
- emitpcode(POC_MOVLW,popGetLit((hi+1) & 0xff));
- emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
- break;
+static void emitMOVWF(operand *reg, int offset)
+{
+ if(!reg)
+ return;
+
+ if (AOP_TYPE(reg) == AOP_ACC) {
+ DEBUGpic14_emitcode ("; ***","%s %d ignoring mov into W",__FUNCTION__,__LINE__);
+ return;
}
+
+ emitpcode(POC_MOVWF, popGet(AOP(reg),offset));
+
+}
- }
- } else {
- int carry_info = 0;
- int offset = 0;
- /* size > 2 */
- DEBUGpic14_emitcode ("; add lit to long","%s %d",__FUNCTION__,__LINE__);
-
- while(size--) {
- lo = BYTEofLONG(lit,0);
-
- if(carry_info) {
- switch(lo) {
- case 0:
- switch(carry_info) {
- case 1:
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),offset));
- break;
- case 2:
- emitpcode(POC_RLFW, popGet(AOP(result),offset));
- emitpcode(POC_ANDLW,popGetLit(1));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset));
- break;
- default: /* carry_info = 3 */
- emitSKPNC;
- emitpcode(POC_INCF, popGet(AOP(result),offset));
- carry_info = 1;
- break;
- }
- break;
- case 0xff:
- emitpcode(POC_MOVLW,popGetLit(lo));
- if(carry_info==1)
- emitSKPZ;
- else
- emitSKPC;
- emitpcode(POC_ADDWF, popGet(AOP(result),offset));
- break;
- default:
- emitpcode(POC_MOVLW,popGetLit(lo));
- if(carry_info==1)
- emitSKPNZ;
- else
- emitSKPNC;
- emitpcode(POC_MOVLW,popGetLit(lo+1));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset));
- carry_info=2;
- break;
- }
- }else {
- /* no carry info from previous step */
- /* this means this is the first time to add */
- switch(lo) {
- case 0:
- break;
- case 1:
- emitpcode(POC_INCF, popGet(AOP(result),offset));
- carry_info=1;
- break;
- default:
- emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset));
- if(lit <0x100)
- carry_info = 3; /* Were adding only one byte and propogating the carry */
- else
- carry_info = 2;
- break;
+static void genAddLit (iCode *ic, int lit)
+{
+
+ int size,same;
+ int lo;
+
+ operand *result;
+ operand *left;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+
+ left = IC_LEFT(ic);
+ result = IC_RESULT(ic);
+ same = pic14_sameRegs(AOP(left), AOP(result));
+ size = pic14_getDataSize(result);
+
+ if(same) {
+
+ /* Handle special cases first */
+ if(size == 1)
+ genAddLit2byte (result, 0, lit);
+
+ else if(size == 2) {
+ int hi = 0xff & (lit >> 8);
+ lo = lit & 0xff;
+
+ switch(hi) {
+ case 0:
+
+ /* lit = 0x00LL */
+ DEBUGpic14_emitcode ("; hi = 0","%s %d",__FUNCTION__,__LINE__);
+ switch(lo) {
+ case 0:
+ break;
+ case 1:
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ break;
+ case 0xff:
+ emitpcode(POC_DECF, popGet(AOP(result),0));
+ emitpcode(POC_INCFSZW, popGet(AOP(result),0));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+
+ break;
+ default:
+ emitpcode(POC_MOVLW,popGetLit(lit&0xff));
+ emitpcode(POC_ADDWF,popGet(AOP(result),0));
+ emitSKPNC;
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+
+
+ }
+ break;
+
+ case 1:
+ /* lit = 0x01LL */
+ DEBUGpic14_emitcode ("; hi = 1","%s %d",__FUNCTION__,__LINE__);
+ switch(lo) {
+ case 0: /* 0x0100 */
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ break;
+ case 1: /* 0x0101 */
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ emitpcode(POC_INCF, popGet(AOP(result),0));
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ break;
+ case 0xff: /* 0x01ff */
+ emitpcode(POC_DECF, popGet(AOP(result),0));
+ emitpcode(POC_INCFSZW, popGet(AOP(result),0));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+ }
+ break;
+
+ case 0xff:
+ DEBUGpic14_emitcode ("; hi = ff","%s %d",__FUNCTION__,__LINE__);
+ /* lit = 0xffLL */
+ switch(lo) {
+ case 0: /* 0xff00 */
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
+ break;
+ case 1: /*0xff01 */
+ emitpcode(POC_INCFSZ, popGet(AOP(result),0));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
+ break;
+ /* case 0xff: * 0xffff *
+ emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
+ break;
+ */
+ default:
+ emitpcode(POC_MOVLW,popGetLit(lo));
+ emitpcode(POC_ADDWF,popGet(AOP(result),0));
+ emitSKPC;
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16));
+
+ }
+
+ break;
+
+ default:
+ DEBUGpic14_emitcode ("; hi is generic","%d %s %d",hi,__FUNCTION__,__LINE__);
+
+ /* lit = 0xHHLL */
+ switch(lo) {
+ case 0: /* 0xHH00 */
+ genAddLit2byte (result, MSB16, hi);
+ break;
+ case 1: /* 0xHH01 */
+ emitpcode(POC_MOVLW,popGetLit((hi+1)&0xff));
+ emitpcode(POC_INCFSZ, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW,popGetLit(hi));
+ emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
+ break;
+ /* case 0xff: * 0xHHff *
+ emitpcode(POC_MOVFW, popGet(AOP(result),0,FALSE,FALSE));
+ emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+ emitpcode(POC_MOVLW,popGetLit(hi));
+ emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+ break;
+ */ default: /* 0xHHLL */
+ emitpcode(POC_MOVLW,popGetLit(lo));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ emitpcode(POC_MOVLW,popGetLit(hi));
+ emitSKPNC;
+ emitpcode(POC_MOVLW,popGetLit((hi+1) & 0xff));
+ emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
+ break;
+ }
+
}
+ } else {
+ int carry_info = 0;
+ int offset = 0;
+ /* size > 2 */
+ DEBUGpic14_emitcode ("; add lit to long","%s %d",__FUNCTION__,__LINE__);
+
+ while(size--) {
+ lo = BYTEofLONG(lit,0);
+
+ if(carry_info) {
+ switch(lo) {
+ case 0:
+ switch(carry_info) {
+ case 1:
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(result),offset));
+ break;
+ case 2:
+ emitpcode(POC_RLFW, popGet(AOP(result),offset));
+ emitpcode(POC_ANDLW,popGetLit(1));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ break;
+ default: /* carry_info = 3 */
+ emitSKPNC;
+ emitpcode(POC_INCF, popGet(AOP(result),offset));
+ carry_info = 1;
+ break;
+ }
+ break;
+ case 0xff:
+ emitpcode(POC_MOVLW,popGetLit(lo));
+ if(carry_info==1)
+ emitSKPZ;
+ else
+ emitSKPC;
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ break;
+ default:
+ emitpcode(POC_MOVLW,popGetLit(lo));
+ if(carry_info==1)
+ emitSKPNZ;
+ else
+ emitSKPNC;
+ emitpcode(POC_MOVLW,popGetLit(lo+1));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ carry_info=2;
+ break;
+ }
+ }else {
+ /* no carry info from previous step */
+ /* this means this is the first time to add */
+ switch(lo) {
+ case 0:
+ break;
+ case 1:
+ emitpcode(POC_INCF, popGet(AOP(result),offset));
+ carry_info=1;
+ break;
+ default:
+ emitpcode(POC_MOVLW,popGetLit(lo));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ if(lit <0x100)
+ carry_info = 3; /* Were adding only one byte and propogating the carry */
+ else
+ carry_info = 2;
+ break;
+ }
+ }
+ offset++;
+ lit >>= 8;
+ }
+
+ /*
+ lo = BYTEofLONG(lit,0);
+
+ if(lit < 0x100) {
+ if(lo) {
+ if(lo == 1) {
+ emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+ emitSKPNZ;
+ } else {
+ emitpcode(POC_MOVLW,popGetLit(lo));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitSKPNC;
+ }
+ emitpcode(POC_INCF, popGet(AOP(result),1,FALSE,FALSE));
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(result),2,FALSE,FALSE));
+ emitSKPNZ;
+ emitpcode(POC_INCF, popGet(AOP(result),3,FALSE,FALSE));
+
+ }
+ }
+ }
+
+ */
}
- offset++;
- lit >>= 8;
- }
-
-/*
- lo = BYTEofLONG(lit,0);
-
- if(lit < 0x100) {
- if(lo) {
- if(lo == 1) {
- emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
- emitSKPNZ;
- } else {
- emitpcode(POC_MOVLW,popGetLit(lo));
- emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
- emitSKPNC;
- }
- emitpcode(POC_INCF, popGet(AOP(result),1,FALSE,FALSE));
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),2,FALSE,FALSE));
- emitSKPNZ;
- emitpcode(POC_INCF, popGet(AOP(result),3,FALSE,FALSE));
-
- }
- }
- }
-
-*/
- }
} else {
- int offset = 1;
- DEBUGpic14_emitcode ("; left and result aren't same","%s %d",__FUNCTION__,__LINE__);
-
- if(size == 1) {
-
- if(AOP_TYPE(left) == AOP_ACC) {
- /* left addend is already in accumulator */
- switch(lit & 0xff) {
- case 0:
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- break;
- default:
- emitpcode(POC_ADDLW, popGetLit(lit & 0xff));
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- }
- } else {
- /* left addend is in a register */
- switch(lit & 0xff) {
- case 0:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitMOVWF(result, 0);
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- break;
- case 1:
- emitpcode(POC_INCFW, popGet(AOP(left),0));
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- break;
- case 0xff:
- emitpcode(POC_DECFW, popGet(AOP(left),0));
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- break;
- default:
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDFW, popGet(AOP(left),0));
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- }
- }
-
- } else {
- int clear_carry=0;
-
- /* left is not the accumulator */
- if(lit & 0xff) {
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDFW, popGet(AOP(left),0));
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- /* We don't know the state of the carry bit at this point */
- clear_carry = 1;
- }
- //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
- emitMOVWF(result,0);
- while(--size) {
-
- lit >>= 8;
- if(lit & 0xff) {
- if(clear_carry) {
- /* The ls byte of the lit must've been zero - that
- means we don't have to deal with carry */
-
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDFW, popGet(AOP(left),offset));
- emitpcode(POC_MOVWF, popGet(AOP(left),offset));
-
- clear_carry = 0;
-
+ int offset = 1;
+ DEBUGpic14_emitcode ("; left and result aren't same","%s %d",__FUNCTION__,__LINE__);
+
+ if(size == 1) {
+
+ if(AOP_TYPE(left) == AOP_ACC) {
+ /* left addend is already in accumulator */
+ switch(lit & 0xff) {
+ case 0:
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ break;
+ default:
+ emitpcode(POC_ADDLW, popGetLit(lit & 0xff));
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ }
+ } else {
+ /* left addend is in a register */
+ switch(lit & 0xff) {
+ case 0:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitMOVWF(result, 0);
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ break;
+ case 1:
+ emitpcode(POC_INCFW, popGet(AOP(left),0));
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ break;
+ case 0xff:
+ emitpcode(POC_DECFW, popGet(AOP(left),0));
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ break;
+ default:
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ }
+ }
+
} else {
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- //emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
- emitMOVWF(result,offset);
- emitpcode(POC_MOVFW, popGet(AOP(left),offset));
- emitSKPNC;
- emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ int clear_carry=0;
+
+ /* left is not the accumulator */
+ if(lit & 0xff) {
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0));
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ /* We don't know the state of the carry bit at this point */
+ clear_carry = 1;
+ }
+ //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+ emitMOVWF(result,0);
+ while(--size) {
+
+ lit >>= 8;
+ if(lit & 0xff) {
+ if(clear_carry) {
+ /* The ls byte of the lit must've been zero - that
+ means we don't have to deal with carry */
+
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitpcode(POC_ADDFW, popGet(AOP(left),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(left),offset));
+
+ clear_carry = 0;
+
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ //emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+ emitMOVWF(result,offset);
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitSKPNC;
+ emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ }
+
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(result),offset));
+ emitpcode(POC_RLF, popGet(AOP(result),offset));
+ emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+ }
+ offset++;
+ }
}
-
- } else {
- emitpcode(POC_CLRF, popGet(AOP(result),offset));
- emitpcode(POC_RLF, popGet(AOP(result),offset));
- emitpcode(POC_MOVFW, popGet(AOP(left),offset));
- emitpcode(POC_ADDWF, popGet(AOP(result),offset));
- }
- offset++;
- }
- }
}
}
/*-----------------------------------------------------------------*/
void genPlus (iCode *ic)
{
- int size, offset = 0;
-
- /* special cases :- */
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- aopOp (IC_LEFT(ic),ic,FALSE);
- aopOp (IC_RIGHT(ic),ic,FALSE);
- aopOp (IC_RESULT(ic),ic,TRUE);
-
- DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),IC_RIGHT(ic),IC_RESULT(ic));
-
- /* if literal, literal on the right or
- if left requires ACC or right is already
- in ACC */
-
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) {
- operand *t = IC_RIGHT(ic);
- IC_RIGHT(ic) = IC_LEFT(ic);
- IC_LEFT(ic) = t;
- }
-
- /* if both left & right are in bit space */
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
- AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
- genPlusBits (ic);
- goto release ;
- }
-
- /* if left in bit space & right literal */
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
- AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
- /* if result in bit space */
- if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
- if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
- emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
- if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
- }
- } else {
- size = pic14_getDataSize(IC_RESULT(ic));
- while (size--) {
- MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
- pic14_emitcode("addc","a,#00 ;%d",__LINE__);
- aopPut(AOP(IC_RESULT(ic)),"a",offset++);
- }
- }
- goto release ;
- }
-
- /* if I can do an increment instead
- of add then GOOD for ME */
- if (genPlusIncr (ic) == TRUE)
- goto release;
-
- size = pic14_getDataSize(IC_RESULT(ic));
-
- if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
- /* Add a literal to something else */
- //bool know_W=0;
- unsigned lit = (unsigned) floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
- // unsigned l1=0;
-
- // offset = 0;
- DEBUGpic14_emitcode(";","adding lit to something. size %d",size);
-
- genAddLit (ic, lit);
- goto release;
-
- } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
-
- pic14_emitcode(";bitadd","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- pic14_emitcode(";bitadd","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- pic14_emitcode(";bitadd","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
- /* here we are adding a bit to a char or int */
- if(size == 1) {
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
-
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_INCF , popGet(AOP(IC_RESULT(ic)),0));
-
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- } else {
-
- if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_XORLW , popGetLit(1));
-
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode(" xorlw","1");
- } else {
- emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0));
-
- pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ int size, offset = 0;
+
+ /* special cases :- */
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ aopOp (IC_LEFT(ic),ic,FALSE);
+ aopOp (IC_RIGHT(ic),ic,FALSE);
+ aopOp (IC_RESULT(ic),ic,TRUE);
+
+ DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),IC_RIGHT(ic),IC_RESULT(ic));
+
+ /* if literal, literal on the right or
+ if left requires ACC or right is already
+ in ACC */
+
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) {
+ operand *t = IC_RIGHT(ic);
+ IC_RIGHT(ic) = IC_LEFT(ic);
+ IC_LEFT(ic) = t;
}
-
- if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
-
- if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
- emitpcode(POC_ANDLW , popGetLit(1));
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
- emitSKPZ;
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
- } else {
- emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
- pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- }
+
+ /* if both left & right are in bit space */
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
+ AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
+ genPlusBits (ic);
+ goto release ;
}
- }
-
- } else {
- int offset = 1;
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitCLRZ;
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
-
- pic14_emitcode("clrz","");
-
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
- } else {
-
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0));
- //emitpcode(POC_MOVWF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- emitMOVWF(IC_RIGHT(ic),0);
-
- pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
- }
-
- while(--size){
- emitSKPZ;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
- //pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
- }
-
- }
-
- } else {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- /* Add the first bytes */
-
- if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
- emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
- } else {
-
- if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
- if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
- } else {
-
- emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
-
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
- else {
- PIC_OPCODE poc = POC_ADDFW;
-
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
- poc = POC_ADDLW;
- emitpcode(poc, popGet(AOP(IC_LEFT(ic)),0));
- if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+
+ /* if left in bit space & right literal */
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
+ AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
+ /* if result in bit space */
+ if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
+ if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
+ emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
+ if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
+ emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
+ }
+ } else {
+ size = pic14_getDataSize(IC_RESULT(ic));
+ while (size--) {
+ MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+ pic14_emitcode("addc","a,#00 ;%d",__LINE__);
+ aopPut(AOP(IC_RESULT(ic)),"a",offset++);
+ }
+ }
+ goto release ;
}
- }
- }
-
- size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
- offset = 1;
-
-
- if(size){
- if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)))) {
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE))) {
- while(size--){
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPNC;
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- }
- } else {
- while(size--){
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
- emitSKPNC;
- emitpcode(POC_INCFSZW, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- }
- }
- } else {
- PIC_OPCODE poc = POC_MOVFW;
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
- poc = POC_MOVLW;
- while(size--){
- if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(poc, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- }
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPNC;
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- }
- }
- }
- }
-
- if (AOP_SIZE(IC_RESULT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
- int sign = !(SPEC_USIGN(getSpec(operandType(IC_LEFT(ic)))) |
- SPEC_USIGN(getSpec(operandType(IC_RIGHT(ic)))) );
-
-
- /* Need to extend result to higher bytes */
- size = AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_RIGHT(ic)) - 1;
-
- /* First grab the carry from the lower bytes */
- if (AOP_SIZE(IC_LEFT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
- int leftsize = AOP_SIZE(IC_LEFT(ic)) - AOP_SIZE(IC_RIGHT(ic));
- PIC_OPCODE poc = POC_MOVFW;
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
- poc = POC_MOVLW;
- while(leftsize-- > 0) {
- emitpcode(poc, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- emitSKPNC;
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- if (size)
- size--;
- else
- break;
- }
- } else {
- emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
- emitpcode(POC_RLF, popGet(AOP(IC_RESULT(ic)),offset));
- }
-
-
- if(sign) {
- /* Now this is really horrid. Gotta check the sign of the addends and propogate
- * to the result */
-
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_LEFT(ic)),offset-1,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RIGHT(ic)),offset-1,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
-
- /* if chars or ints or being signed extended to longs: */
- if(size) {
- emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE),7,0));
- emitpcode(POC_MOVLW, popGetLit(0xff));
- }
- }
-
- offset++;
- while(size--) {
-
- if(sign)
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- else
- emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
-
- offset++;
- }
- }
-
-
- //adjustArithmeticResult(ic);
-
- release:
- freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+
+ /* if I can do an increment instead
+ of add then GOOD for ME */
+ if (genPlusIncr (ic) == TRUE)
+ goto release;
+
+ size = pic14_getDataSize(IC_RESULT(ic));
+
+ if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
+ /* Add a literal to something else */
+ //bool know_W=0;
+ unsigned lit = (unsigned) floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
+ // unsigned l1=0;
+
+ // offset = 0;
+ DEBUGpic14_emitcode(";","adding lit to something. size %d",size);
+
+ genAddLit (ic, lit);
+ goto release;
+
+ } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
+
+ pic14_emitcode(";bitadd","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ pic14_emitcode(";bitadd","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ pic14_emitcode(";bitadd","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ /* here we are adding a bit to a char or int */
+ if(size == 1) {
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCF , popGet(AOP(IC_RESULT(ic)),0));
+
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ } else {
+
+ if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORLW , popGetLit(1));
+
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode(" xorlw","1");
+ } else {
+ emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0));
+
+ pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ }
+
+ if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
+
+ if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+ emitpcode(POC_ANDLW , popGetLit(1));
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
+ emitSKPZ;
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+ emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
+ pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ }
+ }
+ }
+
+ } else {
+ int offset = 1;
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+ emitCLRZ;
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
+
+ pic14_emitcode("clrz","");
+
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ } else {
+
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0));
+ //emitpcode(POC_MOVWF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ emitMOVWF(IC_RIGHT(ic),0);
+
+ pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ }
+
+ while(--size){
+ emitSKPZ;
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
+ //pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
+ }
+
+ }
+
+ } else {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ /* Add the first bytes */
+
+ if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
+ emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+
+ if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
+ emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
+ if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+
+ emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
+
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
+ else {
+ PIC_OPCODE poc = POC_ADDFW;
+
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
+ poc = POC_ADDLW;
+ emitpcode(poc, popGet(AOP(IC_LEFT(ic)),0));
+ if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ }
+ }
+ }
+
+ size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
+ offset = 1;
+
+
+ if(size){
+ if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)))) {
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE))) {
+ while(size--){
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPNC;
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ }
+ } else {
+ while(size--){
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitSKPNC;
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ }
+ }
+ } else {
+ PIC_OPCODE poc = POC_MOVFW;
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
+ poc = POC_MOVLW;
+ while(size--){
+ if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+ emitpcode(poc, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ }
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPNC;
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ }
+ }
+ }
+ }
+
+ if (AOP_SIZE(IC_RESULT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
+ int sign = !(SPEC_USIGN(getSpec(operandType(IC_LEFT(ic)))) |
+ SPEC_USIGN(getSpec(operandType(IC_RIGHT(ic)))) );
+
+
+ /* Need to extend result to higher bytes */
+ size = AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_RIGHT(ic)) - 1;
+
+ /* First grab the carry from the lower bytes */
+ if (AOP_SIZE(IC_LEFT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
+ int leftsize = AOP_SIZE(IC_LEFT(ic)) - AOP_SIZE(IC_RIGHT(ic));
+ PIC_OPCODE poc = POC_MOVFW;
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
+ poc = POC_MOVLW;
+ while(leftsize-- > 0) {
+ emitpcode(poc, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ emitSKPNC;
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ if (size)
+ size--;
+ else
+ break;
+ }
+ } else {
+ emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
+ emitpcode(POC_RLF, popGet(AOP(IC_RESULT(ic)),offset));
+ }
+
+
+ if(sign) {
+ /* Now this is really horrid. Gotta check the sign of the addends and propogate
+ * to the result */
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_LEFT(ic)),offset-1,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RIGHT(ic)),offset-1,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
+
+ /* if chars or ints or being signed extended to longs: */
+ if(size) {
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ }
+ }
+
+ offset++;
+ while(size--) {
+
+ if(sign)
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ else
+ emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
+
+ offset++;
+ }
+ }
+
+
+ //adjustArithmeticResult(ic);
+
+release:
+ freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
bool genMinusDec (iCode *ic)
{
- unsigned int icount ;
- unsigned int size = pic14_getDataSize(IC_RESULT(ic));
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- /* will try to generate an increment */
- /* if the right side is not a literal
- we cannot */
- if ((AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT) ||
- (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) ||
- (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) )
- return FALSE ;
-
- DEBUGpic14_emitcode ("; lit val","%d",(unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit));
-
- /* if the literal value of the right hand side
- is greater than 4 then it is not worth it */
- if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
- return FALSE ;
-
- /* if decrement 16 bits in register */
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
- (size > 1) &&
- (icount == 1)) {
-
- if(size == 2) {
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),LSB));
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB));
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),MSB16));
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),MSB16));
-
- pic14_emitcode("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
- pic14_emitcode("incfsz","%s,w",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
- pic14_emitcode(" decf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
- } else {
- /* size is 3 or 4 */
- emitpcode(POC_MOVLW, popGetLit(0xff));
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),LSB));
- emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB16));
- emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB24));
-
- pic14_emitcode("movlw","0xff");
- pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
-
- emitSKPNC;
- pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
- emitSKPNC;
- pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE));
-
- if(size > 3) {
- emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB32));
-
- pic14_emitcode("skpnc","");
- emitSKPNC;
- pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE));
+ unsigned int icount ;
+ unsigned int size = pic14_getDataSize(IC_RESULT(ic));
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ /* will try to generate an increment */
+ /* if the right side is not a literal
+ we cannot */
+ if ((AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT) ||
+ (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) ||
+ (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) )
+ return FALSE ;
+
+ DEBUGpic14_emitcode ("; lit val","%d",(unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit));
+
+ /* if the literal value of the right hand side
+ is greater than 4 then it is not worth it */
+ if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
+ return FALSE ;
+
+ /* if decrement 16 bits in register */
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
+ (size > 1) &&
+ (icount == 1)) {
+
+ if(size == 2) {
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),LSB));
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),MSB16));
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),MSB16));
+
+ pic14_emitcode("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+ pic14_emitcode("incfsz","%s,w",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+ pic14_emitcode(" decf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
+ } else {
+ /* size is 3 or 4 */
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),LSB));
+ emitSKPNC;
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB16));
+ emitSKPNC;
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB24));
+
+ pic14_emitcode("movlw","0xff");
+ pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+
+ emitSKPNC;
+ pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
+ emitSKPNC;
+ pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE));
+
+ if(size > 3) {
+ emitSKPNC;
+ emitpcode(POC_ADDWF, popGet(AOP(IC_RESULT(ic)),MSB32));
+
+ pic14_emitcode("skpnc","");
+ emitSKPNC;
+ pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE));
+ }
+
+ }
+
+ return TRUE;
+
}
-
- }
-
- return TRUE;
-
- }
-
- /* if the sizes are greater than 1 then we cannot */
- if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
- AOP_SIZE(IC_LEFT(ic)) > 1 )
- return FALSE ;
-
- /* we can if the aops of the left & result match or
- if they are in registers and the registers are the
- same */
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
-
- while (icount--)
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0));
-
- //pic14_emitcode ("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
- return TRUE ;
- }
-
- DEBUGpic14_emitcode ("; returning"," result=%s, left=%s",
- aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),
- aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- if(size==1) {
-
- pic14_emitcode("decf","%s,w",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
- emitpcode(POC_DECFW, popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
-
- return TRUE;
- }
-
- return FALSE ;
+
+ /* if the sizes are greater than 1 then we cannot */
+ if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
+ AOP_SIZE(IC_LEFT(ic)) > 1 )
+ return FALSE ;
+
+ /* we can if the aops of the left & result match or
+ if they are in registers and the registers are the
+ same */
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
+
+ while (icount--)
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0));
+
+ //pic14_emitcode ("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ return TRUE ;
+ }
+
+ DEBUGpic14_emitcode ("; returning"," result=%s, left=%s",
+ aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),
+ aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ if(size==1) {
+
+ pic14_emitcode("decf","%s,w",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ emitpcode(POC_DECFW, popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
+
+ return TRUE;
+ }
+
+ return FALSE ;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void addSign(operand *result, int offset, int sign)
{
- int size = (pic14_getDataSize(result) - offset);
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
-
- if(size > 0){
- if(sign && offset) {
-
- if(size == 1) {
- emitpcode(POC_CLRF,popGet(AOP(result),offset));
- emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
- emitpcode(POC_DECF, popGet(AOP(result),offset));
- } else {
-
- emitpcode(POC_MOVLW, popGetLit(0));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
- emitpcode(POC_MOVLW, popGetLit(0xff));
- while(size--)
- emitpcode(POC_MOVWF, popGet(AOP(result),size));
-
- }
- } else
- while(size--)
- emitpcode(POC_CLRF,popGet(AOP(result),offset++));
- }
+ int size = (pic14_getDataSize(result) - offset);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+
+ if(size > 0){
+ if(sign && offset) {
+
+ if(size == 1) {
+ emitpcode(POC_CLRF,popGet(AOP(result),offset));
+ emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
+ emitpcode(POC_DECF, popGet(AOP(result),offset));
+ } else {
+
+ emitpcode(POC_MOVLW, popGetLit(0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ while(size--)
+ emitpcode(POC_MOVWF, popGet(AOP(result),size));
+
+ }
+ } else
+ while(size--)
+ emitpcode(POC_CLRF,popGet(AOP(result),offset++));
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void genMinusBits (iCode *ic)
{
- symbol *lbl = newiTempLabel(NULL);
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
- pic14_emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
- pic14_emitcode("jnb","%s,%05d_DS_",AOP(IC_RIGHT(ic))->aopu.aop_dir,(lbl->key+100));
- pic14_emitcode("cpl","c");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
- pic14_outBitC(IC_RESULT(ic));
- }
- else{
- pic14_emitcode("mov","c,%s",AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode("subb","a,acc");
- pic14_emitcode("jnb","%s,%05d_DS_",AOP(IC_LEFT(ic))->aopu.aop_dir,(lbl->key+100));
- pic14_emitcode("inc","a");
- pic14_emitcode("","%05d_DS_:",(lbl->key+100));
- aopPut(AOP(IC_RESULT(ic)),"a",0);
- addSign(IC_RESULT(ic), MSB16, SPEC_USIGN(getSpec(operandType(IC_RESULT(ic)))));
- }
+ symbol *lbl = newiTempLabel(NULL);
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
+ pic14_emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
+ pic14_emitcode("jnb","%s,%05d_DS_",AOP(IC_RIGHT(ic))->aopu.aop_dir,(lbl->key+100));
+ pic14_emitcode("cpl","c");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+ pic14_outBitC(IC_RESULT(ic));
+ }
+ else{
+ pic14_emitcode("mov","c,%s",AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode("subb","a,acc");
+ pic14_emitcode("jnb","%s,%05d_DS_",AOP(IC_LEFT(ic))->aopu.aop_dir,(lbl->key+100));
+ pic14_emitcode("inc","a");
+ pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+ aopPut(AOP(IC_RESULT(ic)),"a",0);
+ addSign(IC_RESULT(ic), MSB16, SPEC_USIGN(getSpec(operandType(IC_RESULT(ic)))));
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void genMinus (iCode *ic)
{
- int size, offset = 0, same=0;
- unsigned long lit = 0L;
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- aopOp (IC_LEFT(ic),ic,FALSE);
- aopOp (IC_RIGHT(ic),ic,FALSE);
- aopOp (IC_RESULT(ic),ic,TRUE);
-
- if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
- AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
- operand *t = IC_RIGHT(ic);
- IC_RIGHT(ic) = IC_LEFT(ic);
- IC_LEFT(ic) = t;
- }
-
- DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_LEFT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))));
-
- /* special cases :- */
- /* if both left & right are in bit space */
- if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
- AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
- genPlusBits (ic);
- goto release ;
- }
-
- /* if I can do an decrement instead
- of subtract then GOOD for ME */
- // if (genMinusDec (ic) == TRUE)
- // goto release;
-
- size = pic14_getDataSize(IC_RESULT(ic));
- same = pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)));
-
- if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
- /* Add a literal to something else */
-
- lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
- lit = - (long)lit;
-
- genAddLit ( ic, lit);
-
-#if 0
- /* add the first byte: */
- pic14_emitcode("movlw","0x%x", lit & 0xff);
- pic14_emitcode("addwf","%s,f", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
-
-
- offset = 1;
- size--;
-
- while(size-- > 0) {
-
- lit >>= 8;
-
- if(lit & 0xff) {
-
- if((lit & 0xff) == 0xff) {
- emitpcode(POC_MOVLW, popGetLit(0xff));
- emitSKPC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
- } else {
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitSKPNC;
- emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
- }
-
- } else {
- /* do the rlf known zero trick here */
- emitpcode(POC_MOVLW, popGetLit(1));
- emitSKPNC;
- emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
- }
- offset++;
- }
-#endif
- } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
- // bit subtraction
-
- pic14_emitcode(";bitsub","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
- pic14_emitcode(";bitsub","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
- pic14_emitcode(";bitsub","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
- /* here we are subtracting a bit from a char or int */
- if(size == 1) {
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
-
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_DECF , popGet(AOP(IC_RESULT(ic)),0));
-
- pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
- AOP(IC_RIGHT(ic))->aopu.aop_dir,
- AOP(IC_RIGHT(ic))->aopu.aop_dir);
- pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- } else {
-
- if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_XORLW , popGetLit(1));
- }else if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
- (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
-
- lit = (unsigned long)floatFromVal(AOP(IC_LEFT(ic))->aopu.aop_lit);
-
- if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
- if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
- if(lit & 1) {
- emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0));
- }
- }else{
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
- if(lit & 1)
- emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0));
- else
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
- }
- goto release;
- } else {
- emitpcode(POC_MOVLW , popGetLit(lit & 0xff));
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_MOVLW , popGetLit((lit-1) & 0xff));
- emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
-
- }
-
- } else {
- emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
- emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0));
- }
-
- if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
-
- emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
-
- } else {
- emitpcode(POC_ANDLW , popGetLit(1));
-/*
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- emitSKPZ;
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-*/
+ int size, offset = 0, same=0;
+ unsigned long lit = 0L;
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ aopOp (IC_LEFT(ic),ic,FALSE);
+ aopOp (IC_RIGHT(ic),ic,FALSE);
+ aopOp (IC_RESULT(ic),ic,TRUE);
+
+ if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
+ AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
+ operand *t = IC_RIGHT(ic);
+ IC_RIGHT(ic) = IC_LEFT(ic);
+ IC_LEFT(ic) = t;
}
-
- }
-
- }
- } else if(// (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
- (AOP(IC_LEFT(ic))->type == AOP_LIT) &&
- (AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)) {
-
- lit = (unsigned long)floatFromVal(AOP(IC_LEFT(ic))->aopu.aop_lit);
- DEBUGpic14_emitcode ("; left is lit","line %d result %s, left %s, right %s",__LINE__,
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_LEFT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))));
-
-
- if( (size == 1) && ((lit & 0xff) == 0) ) {
- /* res = 0 - right */
- if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_COMF, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_INCF, popGet(AOP(IC_RIGHT(ic)),0));
- } else {
- emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
- emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
- }
- goto release;
- }
-
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
-
-
- offset = 1;
- while(--size) {
- lit >>= 8;
-
- if(size == 1) {
- /* This is the last byte in a multibyte subtraction
- * There are a couple of tricks we can do by not worrying about
- * propogating the carry */
- if(lit == 0xff) {
- /* 0xff - x == ~x */
- if(same) {
- emitpcode(POC_COMF, popGet(AOP(IC_RESULT(ic)),offset));
- emitSKPC;
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
- } else {
- emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- emitSKPC;
- emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
- }
- } else {
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPC;
- emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+
+ DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
+ AopType(AOP_TYPE(IC_RESULT(ic))),
+ AopType(AOP_TYPE(IC_LEFT(ic))),
+ AopType(AOP_TYPE(IC_RIGHT(ic))));
+
+ /* special cases :- */
+ /* if both left & right are in bit space */
+ if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
+ AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
+ genPlusBits (ic);
+ goto release ;
}
-
- goto release;
- }
-
- if(same) {
-
- if(lit & 0xff) {
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitSKPC;
- emitpcode(POC_MOVLW, popGetLit((lit & 0xff)-1));
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
+
+ /* if I can do an decrement instead
+ of subtract then GOOD for ME */
+ // if (genMinusDec (ic) == TRUE)
+ // goto release;
+
+ size = pic14_getDataSize(IC_RESULT(ic));
+ same = pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)));
+
+ if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
+ /* Add a literal to something else */
+
+ lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
+ lit = - (long)lit;
+
+ genAddLit ( ic, lit);
+
+#if 0
+ /* add the first byte: */
+ pic14_emitcode("movlw","0x%x", lit & 0xff);
+ pic14_emitcode("addwf","%s,f", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
+
+
+ offset = 1;
+ size--;
+
+ while(size-- > 0) {
+
+ lit >>= 8;
+
+ if(lit & 0xff) {
+
+ if((lit & 0xff) == 0xff) {
+ emitpcode(POC_MOVLW, popGetLit(0xff));
+ emitSKPC;
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
+ } else {
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitSKPNC;
+ emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
+ }
+
+ } else {
+ /* do the rlf known zero trick here */
+ emitpcode(POC_MOVLW, popGetLit(1));
+ emitSKPNC;
+ emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset));
+ }
+ offset++;
+ }
+#endif
+ } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
+ // bit subtraction
+
+ pic14_emitcode(";bitsub","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+ pic14_emitcode(";bitsub","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+ pic14_emitcode(";bitsub","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+ /* here we are subtracting a bit from a char or int */
+ if(size == 1) {
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_DECF , popGet(AOP(IC_RESULT(ic)),0));
+
+ pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+ AOP(IC_RIGHT(ic))->aopu.aop_dir,
+ AOP(IC_RIGHT(ic))->aopu.aop_dir);
+ pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ } else {
+
+ if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORLW , popGetLit(1));
+ }else if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
+ (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
+
+ lit = (unsigned long)floatFromVal(AOP(IC_LEFT(ic))->aopu.aop_lit);
+
+ if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+ if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
+ if(lit & 1) {
+ emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0));
+ }
+ }else{
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
+ if(lit & 1)
+ emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0));
+ else
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
+ }
+ goto release;
+ } else {
+ emitpcode(POC_MOVLW , popGetLit(lit & 0xff));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_MOVLW , popGetLit((lit-1) & 0xff));
+ emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
+
+ }
+
+ } else {
+ emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
+ emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0));
+ }
+
+ if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
+
+ emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
+
+ } else {
+ emitpcode(POC_ANDLW , popGetLit(1));
+ /*
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ emitSKPZ;
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+ */
+ }
+
+ }
+
+ }
+ } else if(// (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
+ (AOP(IC_LEFT(ic))->type == AOP_LIT) &&
+ (AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)) {
+
+ lit = (unsigned long)floatFromVal(AOP(IC_LEFT(ic))->aopu.aop_lit);
+ DEBUGpic14_emitcode ("; left is lit","line %d result %s, left %s, right %s",__LINE__,
+ AopType(AOP_TYPE(IC_RESULT(ic))),
+ AopType(AOP_TYPE(IC_LEFT(ic))),
+ AopType(AOP_TYPE(IC_RIGHT(ic))));
+
+
+ if( (size == 1) && ((lit & 0xff) == 0) ) {
+ /* res = 0 - right */
+ if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
+ emitpcode(POC_COMF, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_INCF, popGet(AOP(IC_RIGHT(ic)),0));
+ } else {
+ emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
+ emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
+ }
+ goto release;
+ }
+
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+
+
+ offset = 1;
+ while(--size) {
+ lit >>= 8;
+
+ if(size == 1) {
+ /* This is the last byte in a multibyte subtraction
+ * There are a couple of tricks we can do by not worrying about
+ * propogating the carry */
+ if(lit == 0xff) {
+ /* 0xff - x == ~x */
+ if(same) {
+ emitpcode(POC_COMF, popGet(AOP(IC_RESULT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
+ } else {
+ emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),offset));
+ }
+ } else {
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ }
+
+ goto release;
+ }
+
+ if(same) {
+
+ if(lit & 0xff) {
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitSKPC;
+ emitpcode(POC_MOVLW, popGetLit((lit & 0xff)-1));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
+ } else {
+ emitSKPNC;
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
+
+ }
+ } else {
+
+ if(lit & 0xff) {
+ emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ } else
+ emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
+
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
+ }
+ }
+
+
} else {
- emitSKPNC;
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
-
- }
- } else {
-
- if(lit & 0xff) {
- emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- } else
- emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
-
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPC;
- emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
- }
- }
-
-
- } else {
-
- DEBUGpic14_emitcode ("; ","line %d result %s, left %s, right %s",__LINE__,
- AopType(AOP_TYPE(IC_RESULT(ic))),
- AopType(AOP_TYPE(IC_LEFT(ic))),
- AopType(AOP_TYPE(IC_RIGHT(ic))));
-
- if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_SUBLW, popGetLit(0));
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
- } else {
-
- if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
- emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
- emitpcode(POC_SUBLW, popGetLit(0));
- if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
- } else {
-
- DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- if(AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)
- emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
-
- if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
- emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0));
- else {
- if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
- (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
- emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0));
- } else {
- emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0));
- }
- if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
- if ( AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
- emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
- emitSKPZ;
- emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
- }else
- emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
- }
+
+ DEBUGpic14_emitcode ("; ","line %d result %s, left %s, right %s",__LINE__,
+ AopType(AOP_TYPE(IC_RESULT(ic))),
+ AopType(AOP_TYPE(IC_LEFT(ic))),
+ AopType(AOP_TYPE(IC_RIGHT(ic))));
+
+ if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_SUBLW, popGetLit(0));
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+
+ if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
+ emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
+ emitpcode(POC_SUBLW, popGetLit(0));
+ if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ } else {
+
+ DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+ if(AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC)
+ emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
+
+ if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
+ emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0));
+ else {
+ if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
+ (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
+ emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0));
+ } else {
+ emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0));
+ }
+ if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
+ if ( AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+ emitpcode(POC_BCF , popGet(AOP(IC_RESULT(ic)),0));
+ emitSKPZ;
+ emitpcode(POC_BSF , popGet(AOP(IC_RESULT(ic)),0));
+ }else
+ emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
+ }
+ }
+ }
+ }
+
+ size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
+ offset = 1;
+
+ if(size){
+ if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)))) {
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE))) {
+ while(size--){
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ }
+ } else {
+ while(size--){
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ }
+ }
+ } else {
+ PIC_OPCODE poc = POC_MOVFW;
+ if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
+ (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
+ poc = POC_MOVLW;
+ while(size--){
+ if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+ emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+ }
+ emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
+ emitSKPC;
+ emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
+ emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
+ offset++;
+ }
+ }
+ }
}
- }
- }
-
- size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
- offset = 1;
-
- if(size){
- if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)))) {
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE))) {
- while(size--){
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPC;
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- }
- } else {
- while(size--){
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPC;
- emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- }
- }
- } else {
- PIC_OPCODE poc = POC_MOVFW;
- if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && (
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL) ||
- (AOP(IC_LEFT(ic))->aopu.pcop->type == PO_IMMEDIATE)))
- poc = POC_MOVLW;
- while(size--){
- if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
- emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
- emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
- }
- emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
- emitSKPC;
- emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
- emitpcode(POC_SUBWF, popGet(AOP(IC_RESULT(ic)),offset));
- offset++;
- }
- }
- }
- }
-
- // adjustArithmeticResult(ic);
-
- release:
- freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
- freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+
+ // adjustArithmeticResult(ic);
+
+release:
+ freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+ freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*
- * genUMult8XLit_16 - unsigned multiplication of two 8-bit numbers.
- *
- *
- *-----------------------------------------------------------------*/
+* genUMult8XLit_16 - unsigned multiplication of two 8-bit numbers.
+*
+*
+*-----------------------------------------------------------------*/
void genUMult8XLit_16 (operand *left,
- operand *right,
- operand *result,
- pCodeOpReg *result_hi)
-
+ operand *right,
+ operand *result,
+ pCodeOpReg *result_hi)
+
{
-
- unsigned int lit;
- unsigned int i,have_first_bit;
- int same;
- pCodeOp *temp;
-
- if (AOP_TYPE(right) != AOP_LIT){
- fprintf(stderr,"%s %d - right operand is not a literal\n",__FILE__,__LINE__);
- exit(1);
- }
-
-
- if(!result_hi) {
- result_hi = PCOR(popGet(AOP(result),1));
- }
-
- lit = (unsigned int)floatFromVal(AOP(right)->aopu.aop_lit);
- lit &= 0xff;
- pic14_emitcode(";","Unrolled 8 X 8 multiplication");
-
- same = pic14_sameRegs(AOP(left), AOP(result));
-
- if(same) {
- switch(lit) {
- case 0:
- emitpcode(POC_CLRF, popGet(AOP(left),0));
- return;
- case 2:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 3:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 4:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 5:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 5*F
- return;
- case 6:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 7:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 5*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 7*F
- return;
- case 8:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 8*F
- return;
- case 9:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 10:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 5*F
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 11:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 8*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 11*F
- return;
- case 12:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 13:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 8*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 13*F
- return;
- case 14:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 8*F
- emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 11*F
- emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 14*F
- return;
- case 15:
- temp = popGetTempReg();
- if(!temp) {
- fprintf(stderr,"ERROR: unable to allocate register. %s:%d\n",__FUNCTION__,__LINE__);
- exit(1);
- }
- emitpcode(POC_SWAPFW, popGet(AOP(left),0));
- emitpcode(POC_MOVWF, temp);
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF, popGet(AOP(left),0));
- emitpcode(POC_SWAPFW, temp);
- emitpcode(POC_SUBWF, popGet(AOP(left),0));
- popReleaseTempReg(temp);
- return;
- case 16:
- emitpcode(POC_SWAPFW, popGet(AOP(left),0));
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_MOVWF, popGet(AOP(left),0));
- return;
- case 17:
- emitpcode(POC_SWAPFW, popGet(AOP(left),0));
- emitpcode(POC_ANDLW, popGetLit(0xf0));
- emitpcode(POC_ADDWF, popGet(AOP(left),0));
- return;
- case 32:
- emitpcode(POC_SWAPF, popGet(AOP(left),0));
- emitpcode(POC_RLFW, popGet(AOP(left),0));
- emitpcode(POC_ANDLW, popGetLit(0xe0));
- emitpcode(POC_MOVWF, popGet(AOP(left),0));
- return;
- case 64:
- emitpcode(POC_SWAPF, popGet(AOP(left),0));
- emitpcode(POC_RLF, popGet(AOP(left),0));
- emitpcode(POC_RLFW, popGet(AOP(left),0));
- emitpcode(POC_ANDLW, popGetLit(0xc0));
- emitpcode(POC_MOVWF, popGet(AOP(left),0));
- return;
- case 128:
- emitpcode(POC_RRFW, popGet(AOP(left),0));
- emitpcode(POC_CLRF, popGet(AOP(left),0));
- emitpcode(POC_RRF, popGet(AOP(left),0));
- return;
-
- }
+
+ unsigned int lit;
+ unsigned int i,have_first_bit;
+ int same;
+ pCodeOp *temp;
+
+ if (AOP_TYPE(right) != AOP_LIT){
+ fprintf(stderr,"%s %d - right operand is not a literal\n",__FILE__,__LINE__);
+ exit(1);
+ }
+
+
+ if(!result_hi) {
+ result_hi = PCOR(popGet(AOP(result),1));
+ }
+
+ lit = (unsigned int)floatFromVal(AOP(right)->aopu.aop_lit);
+ lit &= 0xff;
+ pic14_emitcode(";","Unrolled 8 X 8 multiplication");
+
+ same = pic14_sameRegs(AOP(left), AOP(result));
+
+ if(same) {
+ switch(lit) {
+ case 0:
+ emitpcode(POC_CLRF, popGet(AOP(left),0));
+ return;
+ case 2:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 3:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 4:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 5:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 5*F
+ return;
+ case 6:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 7:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 5*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 7*F
+ return;
+ case 8:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 8*F
+ return;
+ case 9:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 10:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 5*F
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 11:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 8*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 11*F
+ return;
+ case 12:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 13:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 8*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 13*F
+ return;
+ case 14:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 2*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 3*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 5*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 8*F
+ emitpcode(POC_ADDFW, popGet(AOP(left),0)); // W = 11*F
+ emitpcode(POC_ADDWF, popGet(AOP(left),0)); // F = 14*F
+ return;
+ case 15:
+ temp = popGetTempReg();
+ if(!temp) {
+ fprintf(stderr,"ERROR: unable to allocate register. %s:%d\n",__FUNCTION__,__LINE__);
+ exit(1);
+ }
+ emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, temp);
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF, popGet(AOP(left),0));
+ emitpcode(POC_SWAPFW, temp);
+ emitpcode(POC_SUBWF, popGet(AOP(left),0));
+ popReleaseTempReg(temp);
+ return;
+ case 16:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_MOVWF, popGet(AOP(left),0));
+ return;
+ case 17:
+ emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+ emitpcode(POC_ANDLW, popGetLit(0xf0));
+ emitpcode(POC_ADDWF, popGet(AOP(left),0));
+ return;
+ case 32:
+ emitpcode(POC_SWAPF, popGet(AOP(left),0));
+ emitpcode(POC_RLFW, popGet(AOP(left),0));
+ emitpcode(POC_ANDLW, popGetLit(0xe0));
+ emitpcode(POC_MOVWF, popGet(AOP(left),0));
+ return;
+ case 64:
+ emitpcode(POC_SWAPF, popGet(AOP(left),0));
+ emitpcode(POC_RLF, popGet(AOP(left),0));
+ emitpcode(POC_RLFW, popGet(AOP(left),0));
+ emitpcode(POC_ANDLW, popGetLit(0xc0));
+ emitpcode(POC_MOVWF, popGet(AOP(left),0));
+ return;
+ case 128:
+ emitpcode(POC_RRFW, popGet(AOP(left),0));
+ emitpcode(POC_CLRF, popGet(AOP(left),0));
+ emitpcode(POC_RRF, popGet(AOP(left),0));
+ return;
+
+ }
} else {
-
- switch(lit) {
- case 0:
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- emitpcode(POC_CLRF, popCopyReg(result_hi));
- return;
- case 2:
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
- emitpcode(POC_ADDWF, popGet(AOP(result),0));
- emitpcode(POC_CLRF, popCopyReg(result_hi));
- emitpcode(POC_RLF, popCopyReg(result_hi));
- return;
- }
-
+
+ switch(lit) {
+ case 0:
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_CLRF, popCopyReg(result_hi));
+ return;
+ case 2:
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ emitpcode(POC_ADDWF, popGet(AOP(result),0));
+ emitpcode(POC_CLRF, popCopyReg(result_hi));
+ emitpcode(POC_RLF, popCopyReg(result_hi));
+ return;
+ }
+
}
-
+
emitpcode(POC_MOVFW, popGet(AOP(left),0));
emitpcode(POC_CLRF, popGet(AOP(result),0));
emitpcode(POC_CLRF, popCopyReg(result_hi));
-
+
have_first_bit = 0;
for(i=0; i<8; i++) {
-
- if(lit & 1) {
- emitpcode(POC_ADDWF, popCopyReg(result_hi));
- have_first_bit = 1;
- }
-
- if(have_first_bit) {
- emitpcode(POC_RRF, popCopyReg(result_hi));
- emitpcode(POC_RRF, popGet(AOP(result),0));
- }
-
- lit >>= 1;
+
+ if(lit & 1) {
+ emitpcode(POC_ADDWF, popCopyReg(result_hi));
+ have_first_bit = 1;
+ }
+
+ if(have_first_bit) {
+ emitpcode(POC_RRF, popCopyReg(result_hi));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+ }
+
+ lit >>= 1;
}
-
+
}
/*-----------------------------------------------------------------*
- * genUMult8X8_16 - unsigned multiplication of two 8-bit numbers.
- *
- *
- *-----------------------------------------------------------------*/
+* genUMult8X8_16 - unsigned multiplication of two 8-bit numbers.
+*
+*
+*-----------------------------------------------------------------*/
void genUMult8X8_16 (operand *left,
- operand *right,
- operand *result,
- pCodeOpReg *result_hi)
-
+ operand *right,
+ operand *result,
+ pCodeOpReg *result_hi)
+
{
-
- int i;
- int looped = 1;
-
- if(!result_hi) {
- result_hi = PCOR(popGet(AOP(result),1));
- }
-
- if (AOP_TYPE(right) == AOP_LIT) {
- genUMult8XLit_16(left,right,result,result_hi);
- return;
- }
-
- if(!looped) {
- pic14_emitcode(";","Unrolled 8 X 8 multiplication");
-
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- emitpcode(POC_CLRF, popCopyReg(result_hi));
- emitCLRC;
-
- for(i=0; i<8; i++) {
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),i,0));
- emitpcode(POC_ADDWF, popCopyReg(result_hi));
- emitpcode(POC_RRF, popCopyReg(result_hi));
- emitpcode(POC_RRF, popGet(AOP(result),0));
- }
-
-
- /*
- Here's another version that does the same thing and takes the
- same number of instructions. The one above is slightly better
- because the entry instructions have a higher probability of
- being optimized out.
- */
- /*
- emitpcode(POC_CLRF, popCopyReg(result_hi));
- emitpcode(POC_RRFW, popGet(AOP(left),0));
- emitpcode(POC_MOVWF, popGet(AOP(result),0));
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
-
- for(i=0; i<8; i++) {
- emitSKPNC;
- emitpcode(POC_ADDWF, popCopyReg(result_hi));
- emitpcode(POC_RRF, popCopyReg(result_hi));
- emitpcode(POC_RRF, popGet(AOP(result),0));
- }
- */
-
- } else {
- symbol *tlbl = newiTempLabel(NULL);
- pCodeOp *temp;
-
-
- pic14_emitcode(";","Looped 8 X 8 multiplication");
-
- emitpcode(POC_CLRF, popGet(AOP(result),0));
- emitpcode(POC_CLRF, popCopyReg(result_hi));
-
- emitpcode(POC_BSF, newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE),7,0));
-
- emitpcode(POC_MOVFW, popGet(AOP(right),0));
-
- temp = popGetTempReg();
- emitpcode(POC_MOVWF, popCopyReg(PCOR(temp)));
-
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
-
- emitpLabel(tlbl->key);
-
- emitpcode(POC_RRF, popCopyReg(PCOR(temp)));
- emitSKPNC;
- emitpcode(POC_ADDWF, popCopyReg(result_hi));
-
- emitpcode(POC_RRF, popCopyReg(result_hi));
- emitpcode(POC_RRF, popGet(AOP(result),0));
-
- emitSKPC;
- emitpcode(POC_GOTO, popGetLabel(tlbl->key));
-
- popReleaseTempReg(temp);
-
- }
+
+ int i;
+ int looped = 1;
+
+ if(!result_hi) {
+ result_hi = PCOR(popGet(AOP(result),1));
+ }
+
+ if (AOP_TYPE(right) == AOP_LIT) {
+ genUMult8XLit_16(left,right,result,result_hi);
+ return;
+ }
+
+ if(!looped) {
+ pic14_emitcode(";","Unrolled 8 X 8 multiplication");
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_CLRF, popCopyReg(result_hi));
+ emitCLRC;
+
+ for(i=0; i<8; i++) {
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),i,0));
+ emitpcode(POC_ADDWF, popCopyReg(result_hi));
+ emitpcode(POC_RRF, popCopyReg(result_hi));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+ }
+
+
+ /*
+ Here's another version that does the same thing and takes the
+ same number of instructions. The one above is slightly better
+ because the entry instructions have a higher probability of
+ being optimized out.
+ */
+ /*
+ emitpcode(POC_CLRF, popCopyReg(result_hi));
+ emitpcode(POC_RRFW, popGet(AOP(left),0));
+ emitpcode(POC_MOVWF, popGet(AOP(result),0));
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+ for(i=0; i<8; i++) {
+ emitSKPNC;
+ emitpcode(POC_ADDWF, popCopyReg(result_hi));
+ emitpcode(POC_RRF, popCopyReg(result_hi));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+ }
+ */
+
+ } else {
+ symbol *tlbl = newiTempLabel(NULL);
+ pCodeOp *temp;
+
+
+ pic14_emitcode(";","Looped 8 X 8 multiplication");
+
+ emitpcode(POC_CLRF, popGet(AOP(result),0));
+ emitpcode(POC_CLRF, popCopyReg(result_hi));
+
+ emitpcode(POC_BSF, newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE),7,0));
+
+ emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+ temp = popGetTempReg();
+ emitpcode(POC_MOVWF, popCopyReg(PCOR(temp)));
+
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+
+ emitpLabel(tlbl->key);
+
+ emitpcode(POC_RRF, popCopyReg(PCOR(temp)));
+ emitSKPNC;
+ emitpcode(POC_ADDWF, popCopyReg(result_hi));
+
+ emitpcode(POC_RRF, popCopyReg(result_hi));
+ emitpcode(POC_RRF, popGet(AOP(result),0));
+
+ emitSKPC;
+ emitpcode(POC_GOTO, popGetLabel(tlbl->key));
+
+ popReleaseTempReg(temp);
+
+ }
}
/*-----------------------------------------------------------------*
- * genSMult8X8_16 - signed multiplication of two 8-bit numbers
- *
- * this routine will call the unsigned multiply routine and then
- * post-fix the sign bit.
- *-----------------------------------------------------------------*/
+* genSMult8X8_16 - signed multiplication of two 8-bit numbers
+*
+* this routine will call the unsigned multiply routine and then
+* post-fix the sign bit.
+*-----------------------------------------------------------------*/
void genSMult8X8_16 (operand *left,
- operand *right,
- operand *result,
- pCodeOpReg *result_hi)
+ operand *right,
+ operand *result,
+ pCodeOpReg *result_hi)
{
-
- if(!result_hi) {
- result_hi = PCOR(popGet(AOP(result),1));
- }
-
- genUMult8X8_16(left,right,result,result_hi);
-
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),7,0));
- emitpcode(POC_SUBWF, popCopyReg(result_hi));
- emitpcode(POC_MOVFW, popGet(AOP(left),0));
- emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),7,0));
- emitpcode(POC_SUBWF, popGet(AOP(result),1));
-
+
+ if(!result_hi) {
+ result_hi = PCOR(popGet(AOP(result),1));
+ }
+
+ genUMult8X8_16(left,right,result,result_hi);
+
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),7,0));
+ emitpcode(POC_SUBWF, popCopyReg(result_hi));
+ emitpcode(POC_MOVFW, popGet(AOP(left),0));
+ emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),7,0));
+ emitpcode(POC_SUBWF, popGet(AOP(result),1));
+
}
/*-----------------------------------------------------------------*
- * genMult8X8_8 - multiplication of two 8-bit numbers
- *
- * this routine will call the unsigned multiply 8X8=>16 routine and
- * then throw away the high byte of the result.
- *
- *-----------------------------------------------------------------*/
+* genMult8X8_8 - multiplication of two 8-bit numbers
+*
+* this routine will call the unsigned multiply 8X8=>16 routine and
+* then throw away the high byte of the result.
+*
+*-----------------------------------------------------------------*/
void genMult8X8_8 (operand *left,
- operand *right,
- operand *result)
+ operand *right,
+ operand *result)
{
- pCodeOp *result_hi = popGetTempReg();
-
- if (AOP_TYPE(right) == AOP_LIT)
- genUMult8XLit_16(left,right,result,PCOR(result_hi));
- else
- genUMult8X8_16(left,right,result,PCOR(result_hi));
-
- popReleaseTempReg(result_hi);
+ pCodeOp *result_hi = popGetTempReg();
+
+ if (AOP_TYPE(right) == AOP_LIT)
+ genUMult8XLit_16(left,right,result,PCOR(result_hi));
+ else
+ genUMult8X8_16(left,right,result,PCOR(result_hi));
+
+ popReleaseTempReg(result_hi);
}
#if 0
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void genMultConst(unsigned C)
{
-
- unsigned lit;
- unsigned sr3; // Shift right 3
- unsigned mask;
-
- int size = 1;
-
- /*
- Convert a string of 3 binary 1's in the lit into
- 0111 = 1000 - 1;
- */
-
- mask = 7 << ( (size*8) - 3);
- lit = C;
- sr3 = 0;
-
- while(mask < (1<<size*8)) {
-
- if( (mask & lit) == lit) {
- unsigned lsb;
-
- /* We found 3 (or more) consecutive 1's */
-
- lsb = mask & ~(mask & (mask-1)); // lsb of mask.
-
- consecutive_bits = ((lit + lsb) & lit) ^ lit;
-
- lit ^= consecutive_bits;
-
- mask <<= 3;
-
- sr3 |= (consecutive + lsb);
-
- }
-
- mask >>= 1;
-
- }
-
+
+ unsigned lit;
+ unsigned sr3; // Shift right 3
+ unsigned mask;
+
+ int size = 1;
+
+ /*
+ Convert a string of 3 binary 1's in the lit into
+ 0111 = 1000 - 1;
+ */
+
+ mask = 7 << ( (size*8) - 3);
+ lit = C;
+ sr3 = 0;
+
+ while(mask < (1<<size*8)) {
+
+ if( (mask & lit) == lit) {
+ unsigned lsb;
+
+ /* We found 3 (or more) consecutive 1's */
+
+ lsb = mask & ~(mask & (mask-1)); // lsb of mask.
+
+ consecutive_bits = ((lit + lsb) & lit) ^ lit;
+
+ lit ^= consecutive_bits;
+
+ mask <<= 3;
+
+ sr3 |= (consecutive + lsb);
+
+ }
+
+ mask >>= 1;
+
+ }
+
}
#endif
#ifdef WORDS_BIGENDIAN
- #define _ENDIAN(x) (3-x)
+#define _ENDIAN(x) (3-x)
#else
- #define _ENDIAN(x) (x)
+#define _ENDIAN(x) (x)
#endif
#define BYTE_IN_LONG(x,b) ((x>>(8*_ENDIAN(b)))&0xff)
/*-----------------------------------------------------------------*/
int pic14aopLiteral (value *val, int offset)
{
- union {
- float f;
- unsigned char c[4];
- } fl;
-
- /* if it is a float then it gets tricky */
- /* otherwise it is fairly simple */
- if (!IS_FLOAT(val->type)) {
- unsigned long v = (unsigned long) floatFromVal(val);
-
- return ( (v >> (offset * 8)) & 0xff);
- }
-
- /* it is type float */
- fl.f = (float) floatFromVal(val);
+ union {
+ float f;
+ unsigned char c[4];
+ } fl;
+
+ /* if it is a float then it gets tricky */
+ /* otherwise it is fairly simple */
+ if (!IS_FLOAT(val->type)) {
+ unsigned long v = (unsigned long) floatFromVal(val);
+
+ return ( (v >> (offset * 8)) & 0xff);
+ }
+
+ /* it is type float */
+ fl.f = (float) floatFromVal(val);
#ifdef WORDS_BIGENDIAN
- return fl.c[3-offset];
+ return fl.c[3-offset];
#else
- return fl.c[offset];
+ return fl.c[offset];
#endif
-
+
}
static void
pic14emitRegularMap (memmap * map, bool addPublics, bool arFlag)
{
- symbol *sym;
- int bitvars = 0;;
-
- /* print the area name */
- if (addPublics)
- fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
-
- for (sym = setFirstItem (map->syms); sym;
- sym = setNextItem (map->syms)) {
-
- //printf("%s\n",sym->name);
-
- /* if extern then add it into the extern list */
- if (IS_EXTERN (sym->etype)) {
- addSetHead (&externs, sym);
- continue;
- }
-
- /* if allocation required check is needed
- then check if the symbol really requires
- allocation only for local variables */
- if (arFlag && !IS_AGGREGATE (sym->type) &&
- !(sym->_isparm && !IS_REGPARM (sym->etype)) &&
- !sym->allocreq && sym->level)
- continue;
-
- /* if global variable & not static or extern
- and addPublics allowed then add it to the public set */
- if ((sym->level == 0 ||
- (sym->_isparm && !IS_REGPARM (sym->etype))) &&
- addPublics &&
- !IS_STATIC (sym->etype))
- addSetHead (&publics, sym);
-
- // PIC code allocates its own registers - so ignore parameter variable generated by processFuncArgs()
- if (sym->_isparm)
- continue;
- /* if extern then do nothing or is a function
- then do nothing */
- if (IS_FUNC (sym->type))
- continue;
+ symbol *sym;
+ int bitvars = 0;;
+
+ /* print the area name */
+ if (addPublics)
+ fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
+
+ for (sym = setFirstItem (map->syms); sym;
+ sym = setNextItem (map->syms)) {
+
+ //printf("%s\n",sym->name);
+
+ /* if extern then add it into the extern list */
+ if (IS_EXTERN (sym->etype)) {
+ addSetHead (&externs, sym);
+ continue;
+ }
+
+ /* if allocation required check is needed
+ then check if the symbol really requires
+ allocation only for local variables */
+ if (arFlag && !IS_AGGREGATE (sym->type) &&
+ !(sym->_isparm && !IS_REGPARM (sym->etype)) &&
+ !sym->allocreq && sym->level)
+ continue;
+
+ /* if global variable & not static or extern
+ and addPublics allowed then add it to the public set */
+ if ((sym->level == 0 ||
+ (sym->_isparm && !IS_REGPARM (sym->etype))) &&
+ addPublics &&
+ !IS_STATIC (sym->etype))
+ addSetHead (&publics, sym);
+
+ // PIC code allocates its own registers - so ignore parameter variable generated by processFuncArgs()
+ if (sym->_isparm)
+ continue;
+ /* if extern then do nothing or is a function
+ then do nothing */
+ if (IS_FUNC (sym->type))
+ continue;
#if 0
- /* print extra debug info if required */
- if (options.debug || sym->level == 0)
- {
- if (!sym->level) /* global */
- if (IS_STATIC (sym->etype))
- fprintf (map->oFile, "F%s_", moduleName); /* scope is file */
- else
- fprintf (map->oFile, "G_"); /* scope is global */
- else
- /* symbol is local */
- fprintf (map->oFile, "L%s_", (sym->localof ? sym->localof->name : "-null-"));
- fprintf (map->oFile, "%s_%d_%d", sym->name, sym->level, sym->block);
- }
+ /* print extra debug info if required */
+ if (options.debug || sym->level == 0)
+ {
+ if (!sym->level) /* global */
+ if (IS_STATIC (sym->etype))
+ fprintf (map->oFile, "F%s_", moduleName); /* scope is file */
+ else
+ fprintf (map->oFile, "G_"); /* scope is global */
+ else
+ /* symbol is local */
+ fprintf (map->oFile, "L%s_", (sym->localof ? sym->localof->name : "-null-"));
+ fprintf (map->oFile, "%s_%d_%d", sym->name, sym->level, sym->block);
+ }
#endif
-
- /* if it has an absolute address then generate
- an equate for this no need to allocate space */
- if (SPEC_ABSA (sym->etype))
- {
- //if (options.debug || sym->level == 0)
- //fprintf (map->oFile,"; == 0x%04x\n",SPEC_ADDR (sym->etype));
-
- fprintf (map->oFile, "%s\tEQU\t0x%04x\n",
- sym->rname,
- SPEC_ADDR (sym->etype));
- }
- else
- {
- /* allocate space */
-
- /* If this is a bit variable, then allocate storage after 8 bits have been declared */
- /* unlike the 8051, the pic does not have a separate bit area. So we emulate bit ram */
- /* by grouping the bits together into groups of 8 and storing them in the normal ram. */
- if (IS_BITVAR (sym->etype))
- {
- bitvars++;
- }
- else
- {
- fprintf (map->oFile, "%s\tres\t%d\n", sym->rname,getSize (sym->type) & 0xffff);
- /*
- {
- int i, size;
-
- if ((size = (unsigned int) getSize (sym->type) & 0xffff) > 1)
- {
- for (i = 1; i < size; i++)
- fprintf (map->oFile, "\t%s_%d\n", sym->rname, i);
- }
- }
- */
- }
- //fprintf (map->oFile, "\t.ds\t0x%04x\n", (unsigned int)getSize (sym->type) & 0xffff);
- }
-
- /* if it has a initial value then do it only if
- it is a global variable */
- if (sym->ival && sym->level == 0) {
- ast *ival = NULL;
-
- if (IS_AGGREGATE (sym->type))
- ival = initAggregates (sym, sym->ival, NULL);
- else
- ival = newNode ('=', newAst_VALUE(symbolVal (sym)),
- decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_CHECK));
- codeOutFile = statsg->oFile;
- GcurMemmap = statsg;
- eBBlockFromiCode (iCodeFromAst (ival));
- sym->ival = NULL;
- }
- }
+
+ /* if it has an absolute address then generate
+ an equate for this no need to allocate space */
+ if (SPEC_ABSA (sym->etype))
+ {
+ //if (options.debug || sym->level == 0)
+ //fprintf (map->oFile,"; == 0x%04x\n",SPEC_ADDR (sym->etype));
+
+ fprintf (map->oFile, "%s\tEQU\t0x%04x\n",
+ sym->rname,
+ SPEC_ADDR (sym->etype));
+ }
+ else
+ {
+ /* allocate space */
+
+ /* If this is a bit variable, then allocate storage after 8 bits have been declared */
+ /* unlike the 8051, the pic does not have a separate bit area. So we emulate bit ram */
+ /* by grouping the bits together into groups of 8 and storing them in the normal ram. */
+ if (IS_BITVAR (sym->etype))
+ {
+ bitvars++;
+ }
+ else
+ {
+ fprintf (map->oFile, "%s\tres\t%d\n", sym->rname,getSize (sym->type) & 0xffff);
+ /*
+ {
+ int i, size;
+
+ if ((size = (unsigned int) getSize (sym->type) & 0xffff) > 1)
+ {
+ for (i = 1; i < size; i++)
+ fprintf (map->oFile, "\t%s_%d\n", sym->rname, i);
+ }
+ }
+ */
+ }
+ //fprintf (map->oFile, "\t.ds\t0x%04x\n", (unsigned int)getSize (sym->type) & 0xffff);
+ }
+
+ /* if it has a initial value then do it only if
+ it is a global variable */
+ if (sym->ival && sym->level == 0) {
+ ast *ival = NULL;
+
+ if (IS_AGGREGATE (sym->type))
+ ival = initAggregates (sym, sym->ival, NULL);
+ else
+ ival = newNode ('=', newAst_VALUE(symbolVal (sym)),
+ decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_CHECK));
+ codeOutFile = statsg->oFile;
+ GcurMemmap = statsg;
+ eBBlockFromiCode (iCodeFromAst (ival));
+ sym->ival = NULL;
+ }
+ }
}
static void
printIvalType (symbol *sym, sym_link * type, initList * ilist, pBlock *pb)
{
- value *val;
- unsigned long ulval;
-
- //fprintf(stderr, "%s\n",__FUNCTION__);
-
- /* if initList is deep */
- if (ilist->type == INIT_DEEP)
- ilist = ilist->init.deep;
-
- if (!IS_AGGREGATE(sym->type) && getNelements(type, ilist)>1) {
- werror (W_EXCESS_INITIALIZERS, "scalar", sym->name, sym->lineDef);
- }
-
- if (!(val = list2val (ilist))) {
- // assuming a warning has been thrown
- val=constVal("0");
- }
-
- if (val->type != type) {
- val = valCastLiteral(type, floatFromVal(val));
- }
-
- if(val)
- ulval = (unsigned long) floatFromVal (val);
- else
- ulval =0;
-
- switch (getSize (type)) {
- case 1:
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
- break;
-
- case 2:
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1))));
- break;
-
- case 4:
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1))));
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,2))));
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,3))));
- break;
- }
+ value *val;
+ unsigned long ulval;
+
+ //fprintf(stderr, "%s\n",__FUNCTION__);
+
+ /* if initList is deep */
+ if (ilist->type == INIT_DEEP)
+ ilist = ilist->init.deep;
+
+ if (!IS_AGGREGATE(sym->type) && getNelements(type, ilist)>1) {
+ werror (W_EXCESS_INITIALIZERS, "scalar", sym->name, sym->lineDef);
+ }
+
+ if (!(val = list2val (ilist))) {
+ // assuming a warning has been thrown
+ val=constVal("0");
+ }
+
+ if (val->type != type) {
+ val = valCastLiteral(type, floatFromVal(val));
+ }
+
+ if(val)
+ ulval = (unsigned long) floatFromVal (val);
+ else
+ ulval =0;
+
+ switch (getSize (type)) {
+ case 1:
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
+ break;
+
+ case 2:
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1))));
+ break;
+
+ case 4:
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,0))));
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,1))));
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,2))));
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(BYTE_IN_LONG(ulval,3))));
+ break;
+ }
}
/*-----------------------------------------------------------------*/
static int
printIvalChar (sym_link * type, initList * ilist, pBlock *pb, char *s)
{
- value *val;
- int remain;
-
- if(!pb)
- return 0;
-
- //fprintf(stderr, "%s\n",__FUNCTION__);
- if (!s)
- {
-
- val = list2val (ilist);
- /* if the value is a character string */
- if (IS_ARRAY (val->type) && IS_CHAR (val->etype))
+ value *val;
+ int remain;
+
+ if(!pb)
+ return 0;
+
+ //fprintf(stderr, "%s\n",__FUNCTION__);
+ if (!s)
{
- if (!DCL_ELEM (type))
- DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1;
-
- //printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type));
- //fprintf(stderr, "%s omitting call to printChar\n",__FUNCTION__);
- addpCode2pBlock(pb,newpCodeCharP(";omitting call to printChar"));
-
- if ((remain = (DCL_ELEM (type) - strlen (SPEC_CVAL (val->etype).v_char) - 1)) > 0)
- while (remain--)
- //tfprintf (oFile, "\t!db !constbyte\n", 0);
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(0)));
- return 1;
+
+ val = list2val (ilist);
+ /* if the value is a character string */
+ if (IS_ARRAY (val->type) && IS_CHAR (val->etype))
+ {
+ if (!DCL_ELEM (type))
+ DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1;
+
+ //printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type));
+ //fprintf(stderr, "%s omitting call to printChar\n",__FUNCTION__);
+ addpCode2pBlock(pb,newpCodeCharP(";omitting call to printChar"));
+
+ if ((remain = (DCL_ELEM (type) - strlen (SPEC_CVAL (val->etype).v_char) - 1)) > 0)
+ while (remain--)
+ //tfprintf (oFile, "\t!db !constbyte\n", 0);
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(0)));
+ return 1;
+ }
+ else
+ return 0;
+ }
+ else {
+ //printChar (oFile, s, strlen (s) + 1);
+
+ for(remain=0; remain<(int)strlen(s); remain++) {
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(s[remain])));
+ //fprintf(stderr,"0x%02x ",s[remain]);
+ }
+ //fprintf(stderr,"\n");
}
- else
- return 0;
- }
- else {
- //printChar (oFile, s, strlen (s) + 1);
-
- for(remain=0; remain<(int)strlen(s); remain++) {
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(s[remain])));
- //fprintf(stderr,"0x%02x ",s[remain]);
- }
- //fprintf(stderr,"\n");
- }
- return 1;
+ return 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void
printIvalArray (symbol * sym, sym_link * type, initList * ilist,
- pBlock *pb)
+ pBlock *pb)
{
- initList *iloop;
- int lcnt = 0, size = 0;
-
- if(!pb)
- return;
-
- /* take care of the special case */
- /* array of characters can be init */
- /* by a string */
- if (IS_CHAR (type->next)) {
- //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__);
- if (!IS_LITERAL(list2val(ilist)->etype)) {
- werror (W_INIT_WRONG);
- return;
- }
- if (printIvalChar (type,
- (ilist->type == INIT_DEEP ? ilist->init.deep : ilist),
- pb, SPEC_CVAL (sym->etype).v_char))
- return;
- }
- /* not the special case */
- if (ilist->type != INIT_DEEP)
- {
- werror (E_INIT_STRUCT, sym->name);
- return;
- }
-
- iloop = ilist->init.deep;
- lcnt = DCL_ELEM (type);
-
- for (;;)
- {
- //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__);
- size++;
- printIval (sym, type->next, iloop, pb);
- iloop = (iloop ? iloop->next : NULL);
-
-
- /* if not array limits given & we */
- /* are out of initialisers then */
- if (!DCL_ELEM (type) && !iloop)
- break;
-
- /* no of elements given and we */
- /* have generated for all of them */
- if (!--lcnt) {
- /* if initializers left */
- if (iloop) {
- werror (W_EXCESS_INITIALIZERS, "array", sym->name, sym->lineDef);
+ initList *iloop;
+ int lcnt = 0, size = 0;
+
+ if(!pb)
+ return;
+
+ /* take care of the special case */
+ /* array of characters can be init */
+ /* by a string */
+ if (IS_CHAR (type->next)) {
+ //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__);
+ if (!IS_LITERAL(list2val(ilist)->etype)) {
+ werror (W_INIT_WRONG);
+ return;
+ }
+ if (printIvalChar (type,
+ (ilist->type == INIT_DEEP ? ilist->init.deep : ilist),
+ pb, SPEC_CVAL (sym->etype).v_char))
+ return;
}
- break;
- }
- }
-
- /* if we have not been given a size */
- if (!DCL_ELEM (type))
- DCL_ELEM (type) = size;
-
- return;
+ /* not the special case */
+ if (ilist->type != INIT_DEEP)
+ {
+ werror (E_INIT_STRUCT, sym->name);
+ return;
+ }
+
+ iloop = ilist->init.deep;
+ lcnt = DCL_ELEM (type);
+
+ for (;;)
+ {
+ //fprintf(stderr,"%s:%d - is_char\n",__FUNCTION__,__LINE__);
+ size++;
+ printIval (sym, type->next, iloop, pb);
+ iloop = (iloop ? iloop->next : NULL);
+
+
+ /* if not array limits given & we */
+ /* are out of initialisers then */
+ if (!DCL_ELEM (type) && !iloop)
+ break;
+
+ /* no of elements given and we */
+ /* have generated for all of them */
+ if (!--lcnt) {
+ /* if initializers left */
+ if (iloop) {
+ werror (W_EXCESS_INITIALIZERS, "array", sym->name, sym->lineDef);
+ }
+ break;
+ }
+ }
+
+ /* if we have not been given a size */
+ if (!DCL_ELEM (type))
+ DCL_ELEM (type) = size;
+
+ return;
}
/*-----------------------------------------------------------------*/
static void
printIval (symbol * sym, sym_link * type, initList * ilist, pBlock *pb)
{
- if (!ilist || !pb)
- return;
-
- /* if structure then */
- if (IS_STRUCT (type))
- {
- //fprintf(stderr,"%s struct\n",__FUNCTION__);
- //printIvalStruct (sym, type, ilist, oFile);
- return;
- }
-
- /* if this is a pointer */
- if (IS_PTR (type))
- {
- //fprintf(stderr,"%s pointer\n",__FUNCTION__);
- //printIvalPtr (sym, type, ilist, oFile);
- return;
- }
-
- /* if this is an array */
- if (IS_ARRAY (type))
- {
- //fprintf(stderr,"%s array\n",__FUNCTION__);
- printIvalArray (sym, type, ilist, pb);
- return;
- }
-
- /* if type is SPECIFIER */
- if (IS_SPEC (type))
- {
- //fprintf(stderr,"%s spec\n",__FUNCTION__);
- printIvalType (sym, type, ilist, pb);
- return;
- }
+ if (!ilist || !pb)
+ return;
+
+ /* if structure then */
+ if (IS_STRUCT (type))
+ {
+ //fprintf(stderr,"%s struct\n",__FUNCTION__);
+ //printIvalStruct (sym, type, ilist, oFile);
+ return;
+ }
+
+ /* if this is a pointer */
+ if (IS_PTR (type))
+ {
+ //fprintf(stderr,"%s pointer\n",__FUNCTION__);
+ //printIvalPtr (sym, type, ilist, oFile);
+ return;
+ }
+
+ /* if this is an array */
+ if (IS_ARRAY (type))
+ {
+ //fprintf(stderr,"%s array\n",__FUNCTION__);
+ printIvalArray (sym, type, ilist, pb);
+ return;
+ }
+
+ /* if type is SPECIFIER */
+ if (IS_SPEC (type))
+ {
+ //fprintf(stderr,"%s spec\n",__FUNCTION__);
+ printIvalType (sym, type, ilist, pb);
+ return;
+ }
}
extern void pCodeConstString(char *name, char *value);
static void
pic14emitStaticSeg (memmap * map)
{
- symbol *sym;
-
- fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
-
- //fprintf(stderr, "%s\n",__FUNCTION__);
-
- /* for all variables in this segment do */
- for (sym = setFirstItem (map->syms); sym;
- sym = setNextItem (map->syms))
- {
- /* if extern then add it into the extern list */
- if (IS_EXTERN (sym->etype)) {
- addSetHead (&externs, sym);
- continue;
- }
-
- /* if it is not static add it to the public
- table */
- if (!IS_STATIC (sym->etype))
- addSetHead (&publics, sym);
-
- /* print extra debug info if required */
- if (options.debug || sym->level == 0)
+ symbol *sym;
+
+ fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
+
+ //fprintf(stderr, "%s\n",__FUNCTION__);
+
+ /* for all variables in this segment do */
+ for (sym = setFirstItem (map->syms); sym;
+ sym = setNextItem (map->syms))
{
- if (!sym->level)
- { /* global */
- if (IS_STATIC (sym->etype))
- fprintf (code->oFile, "F%s_", moduleName); /* scope is file */
- else
- fprintf (code->oFile, "G_"); /* scope is global */
- }
- else
- /* symbol is local */
- fprintf (code->oFile, "L%s_",
- (sym->localof ? sym->localof->name : "-null-"));
- fprintf (code->oFile, "%s_%d_%d", sym->name, sym->level, sym->block);
-
- }
-
- /* if it has an absolute address */
- if (SPEC_ABSA (sym->etype))
- {
- if (options.debug || sym->level == 0)
- fprintf (code->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
-
- fprintf (code->oFile, "%s\t=\t0x%04x\n",
- sym->rname,
- SPEC_ADDR (sym->etype));
- }
- else
- {
- if (options.debug || sym->level == 0)
- fprintf (code->oFile, " == .\n");
-
- /* if it has an initial value */
- if (sym->ival)
- {
- pBlock *pb;
-
- fprintf (code->oFile, "%s:\n", sym->rname);
- noAlloc++;
- resolveIvalSym (sym->ival, sym->type);
- //printIval (sym, sym->type, sym->ival, code->oFile);
- pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block for Ival"));
- addpBlock(pb);
- addpCode2pBlock(pb,newpCodeLabel(sym->rname,-1));
-
- printIval (sym, sym->type, sym->ival, pb);
- noAlloc--;
- }
- else
- {
-
- /* allocate space */
- fprintf (code->oFile, "%s:\n", sym->rname);
- /* special case for character strings */
- if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
- SPEC_CVAL (sym->etype).v_char)
- pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
- /*printChar (code->oFile,
- SPEC_CVAL (sym->etype).v_char,
- strlen (SPEC_CVAL (sym->etype).v_char) + 1);*/
- else
- fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
- }
+ /* if extern then add it into the extern list */
+ if (IS_EXTERN (sym->etype)) {
+ addSetHead (&externs, sym);
+ continue;
+ }
+
+ /* if it is not static add it to the public
+ table */
+ if (!IS_STATIC (sym->etype))
+ addSetHead (&publics, sym);
+
+ /* print extra debug info if required */
+ if (options.debug || sym->level == 0)
+ {
+ if (!sym->level)
+ { /* global */
+ if (IS_STATIC (sym->etype))
+ fprintf (code->oFile, "F%s_", moduleName); /* scope is file */
+ else
+ fprintf (code->oFile, "G_"); /* scope is global */
+ }
+ else
+ /* symbol is local */
+ fprintf (code->oFile, "L%s_",
+ (sym->localof ? sym->localof->name : "-null-"));
+ fprintf (code->oFile, "%s_%d_%d", sym->name, sym->level, sym->block);
+
+ }
+
+ /* if it has an absolute address */
+ if (SPEC_ABSA (sym->etype))
+ {
+ if (options.debug || sym->level == 0)
+ fprintf (code->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
+
+ fprintf (code->oFile, "%s\t=\t0x%04x\n",
+ sym->rname,
+ SPEC_ADDR (sym->etype));
+ }
+ else
+ {
+ if (options.debug || sym->level == 0)
+ fprintf (code->oFile, " == .\n");
+
+ /* if it has an initial value */
+ if (sym->ival)
+ {
+ pBlock *pb;
+
+ fprintf (code->oFile, "%s:\n", sym->rname);
+ noAlloc++;
+ resolveIvalSym (sym->ival, sym->type);
+ //printIval (sym, sym->type, sym->ival, code->oFile);
+ pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block for Ival"));
+ addpBlock(pb);
+ addpCode2pBlock(pb,newpCodeLabel(sym->rname,-1));
+
+ printIval (sym, sym->type, sym->ival, pb);
+ noAlloc--;
+ }
+ else
+ {
+
+ /* allocate space */
+ fprintf (code->oFile, "%s:\n", sym->rname);
+ /* special case for character strings */
+ if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
+ SPEC_CVAL (sym->etype).v_char)
+ pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
+ /*printChar (code->oFile,
+ SPEC_CVAL (sym->etype).v_char,
+ strlen (SPEC_CVAL (sym->etype).v_char) + 1);*/
+ else
+ fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
+ }
+ }
}
- }
-
+
}
static void
pic14emitMaps ()
{
- /* no special considerations for the following
- data, idata & bit & xdata */
- pic14emitRegularMap (data, TRUE, TRUE);
- pic14emitRegularMap (idata, TRUE, TRUE);
- pic14emitRegularMap (bit, TRUE, FALSE);
- pic14emitRegularMap (xdata, TRUE, TRUE);
- pic14emitRegularMap (sfr, FALSE, FALSE);
- pic14emitRegularMap (sfrbit, FALSE, FALSE);
- pic14emitRegularMap (code, TRUE, FALSE);
- pic14emitStaticSeg (statsg);
+/* no special considerations for the following
+ data, idata & bit & xdata */
+ pic14emitRegularMap (data, TRUE, TRUE);
+ pic14emitRegularMap (idata, TRUE, TRUE);
+ pic14emitRegularMap (bit, TRUE, FALSE);
+ pic14emitRegularMap (xdata, TRUE, TRUE);
+ pic14emitRegularMap (sfr, FALSE, FALSE);
+ pic14emitRegularMap (sfrbit, FALSE, FALSE);
+ pic14emitRegularMap (code, TRUE, FALSE);
+ pic14emitStaticSeg (statsg);
}
/*-----------------------------------------------------------------*/
static void
pic14createInterruptVect (FILE * vFile)
{
- mainf = newSymbol ("main", 0);
- mainf->block = 0;
-
- /* only if the main function exists */
- if (!(mainf = findSymWithLevel (SymbolTab, mainf)))
- {
- if (!options.cc_only)
-// werror (E_NO_MAIN);
- fprintf(stderr,"WARNING: function 'main' undefined\n");
- return;
- }
-
- /* if the main is only a prototype ie. no body then do nothing */
- if (!IFFUNC_HASBODY(mainf->type))
- {
- /* if ! compile only then main function should be present */
- if (!options.cc_only)
-// werror (E_NO_MAIN);
- fprintf(stderr,"WARNING: function 'main' undefined\n");
- return;
- }
-
- fprintf (vFile, "%s", iComments2);
- fprintf (vFile, "; config word \n");
- fprintf (vFile, "%s", iComments2);
- fprintf (vFile, "\t__config 0x%x\n", getConfigWord(0x2007));
-
- fprintf (vFile, "%s", iComments2);
- fprintf (vFile, "; reset vector \n");
- fprintf (vFile, "%s", iComments2);
- fprintf (vFile, "STARTUP\t%s\n", CODE_NAME); // Lkr file should place section STARTUP at address 0x0
- fprintf (vFile, "\tnop\n"); /* first location for used by incircuit debugger */
- fprintf (vFile, "\tgoto\t__sdcc_gsinit_startup\n");
+ mainf = newSymbol ("main", 0);
+ mainf->block = 0;
+
+ /* only if the main function exists */
+ if (!(mainf = findSymWithLevel (SymbolTab, mainf)))
+ {
+ if (!options.cc_only)
+ // werror (E_NO_MAIN);
+ fprintf(stderr,"WARNING: function 'main' undefined\n");
+ return;
+ }
+
+ /* if the main is only a prototype ie. no body then do nothing */
+ if (!IFFUNC_HASBODY(mainf->type))
+ {
+ /* if ! compile only then main function should be present */
+ if (!options.cc_only)
+ // werror (E_NO_MAIN);
+ fprintf(stderr,"WARNING: function 'main' undefined\n");
+ return;
+ }
+
+ fprintf (vFile, "%s", iComments2);
+ fprintf (vFile, "; config word \n");
+ fprintf (vFile, "%s", iComments2);
+ fprintf (vFile, "\t__config 0x%x\n", getConfigWord(0x2007));
+
+ fprintf (vFile, "%s", iComments2);
+ fprintf (vFile, "; reset vector \n");
+ fprintf (vFile, "%s", iComments2);
+ fprintf (vFile, "STARTUP\t%s\n", CODE_NAME); // Lkr file should place section STARTUP at address 0x0
+ fprintf (vFile, "\tnop\n"); /* first location for used by incircuit debugger */
+ fprintf (vFile, "\tgoto\t__sdcc_gsinit_startup\n");
}
static void
pic14initialComments (FILE * afile)
{
- initialComments (afile);
- fprintf (afile, "; PIC port for the 14-bit core\n");
- fprintf (afile, iComments2);
-
+ initialComments (afile);
+ fprintf (afile, "; PIC port for the 14-bit core\n");
+ fprintf (afile, iComments2);
+
}
/*-----------------------------------------------------------------*/
static void
pic14printExterns (FILE * afile)
{
- symbol *sym;
-
- fprintf (afile, "%s", iComments2);
- fprintf (afile, "; extern variables in this module\n");
- fprintf (afile, "%s", iComments2);
-
- for (sym = setFirstItem (externs); sym;
- sym = setNextItem (externs))
- fprintf (afile, "\textern %s\n", sym->rname);
+ symbol *sym;
+
+ fprintf (afile, "%s", iComments2);
+ fprintf (afile, "; extern variables in this module\n");
+ fprintf (afile, "%s", iComments2);
+
+ for (sym = setFirstItem (externs); sym;
+ sym = setNextItem (externs))
+ fprintf (afile, "\textern %s\n", sym->rname);
}
/*-----------------------------------------------------------------*/
static void
pic14printPublics (FILE * afile)
{
- symbol *sym;
-
- fprintf (afile, "%s", iComments2);
- fprintf (afile, "; publics variables in this module\n");
- fprintf (afile, "%s", iComments2);
-
- for (sym = setFirstItem (publics); sym;
- sym = setNextItem (publics)) {
-
- if(!IS_BITFIELD(sym->type) && ((IS_FUNC(sym->type) || sym->allocreq))) {
- if (!IS_BITVAR(sym->type))
- fprintf (afile, "\tglobal %s\n", sym->rname);
- } else {
- /* Absolute variables are defines in the asm file as equates and thus can not be made global. */
- if (!SPEC_ABSA (sym->etype))
- fprintf (afile, "\tglobal %s\n", sym->rname);
+ symbol *sym;
+
+ fprintf (afile, "%s", iComments2);
+ fprintf (afile, "; publics variables in this module\n");
+ fprintf (afile, "%s", iComments2);
+
+ for (sym = setFirstItem (publics); sym;
+ sym = setNextItem (publics)) {
+
+ if(!IS_BITFIELD(sym->type) && ((IS_FUNC(sym->type) || sym->allocreq))) {
+ if (!IS_BITVAR(sym->type))
+ fprintf (afile, "\tglobal %s\n", sym->rname);
+ } else {
+ /* Absolute variables are defines in the asm file as equates and thus can not be made global. */
+ if (!SPEC_ABSA (sym->etype))
+ fprintf (afile, "\tglobal %s\n", sym->rname);
+ }
}
- }
}
/*-----------------------------------------------------------------*/
static void
pic14emitOverlay (FILE * afile)
{
- set *ovrset;
-
-/* if (!elementsInSet (ovrSetSets))*/
-
- /* the hack below, fixes translates for devices which
- * only have udata_shr memory */
- fprintf (afile, "%s\t%s\n",
- (elementsInSet(ovrSetSets)?"":";"),
- port->mem.overlay_name);
-
- /* for each of the sets in the overlay segment do */
- for (ovrset = setFirstItem (ovrSetSets); ovrset;
- ovrset = setNextItem (ovrSetSets))
- {
-
- symbol *sym;
-
- if (elementsInSet (ovrset))
+ set *ovrset;
+
+ /* if (!elementsInSet (ovrSetSets))*/
+
+ /* the hack below, fixes translates for devices which
+ * only have udata_shr memory */
+ fprintf (afile, "%s\t%s\n",
+ (elementsInSet(ovrSetSets)?"":";"),
+ port->mem.overlay_name);
+
+ /* for each of the sets in the overlay segment do */
+ for (ovrset = setFirstItem (ovrSetSets); ovrset;
+ ovrset = setNextItem (ovrSetSets))
{
- /* this dummy area is used to fool the assembler
- otherwise the assembler will append each of these
- declarations into one chunk and will not overlay
- sad but true */
-
- /* I don't think this applies to us. We are using gpasm. CRF */
-
- fprintf (afile, ";\t.area _DUMMY\n");
- /* output the area informtion */
- fprintf (afile, ";\t.area\t%s\n", port->mem.overlay_name); /* MOF */
- }
-
- for (sym = setFirstItem (ovrset); sym;
- sym = setNextItem (ovrset))
- {
-
- /* if extern then do nothing */
- if (IS_EXTERN (sym->etype))
- continue;
-
- /* if allocation required check is needed
- then check if the symbol really requires
- allocation only for local variables */
- if (!IS_AGGREGATE (sym->type) &&
- !(sym->_isparm && !IS_REGPARM (sym->etype))
- && !sym->allocreq && sym->level)
- continue;
-
- /* if global variable & not static or extern
- and addPublics allowed then add it to the public set */
- if ((sym->_isparm && !IS_REGPARM (sym->etype))
- && !IS_STATIC (sym->etype))
- addSetHead (&publics, sym);
-
- /* if extern then do nothing or is a function
- then do nothing */
- if (IS_FUNC (sym->type))
- continue;
-
- /* print extra debug info if required */
- if (options.debug || sym->level == 0)
- {
- if (!sym->level)
- { /* global */
- if (IS_STATIC (sym->etype))
- fprintf (afile, "F%s_", moduleName); /* scope is file */
- else
- fprintf (afile, "G_"); /* scope is global */
+
+ symbol *sym;
+
+ if (elementsInSet (ovrset))
+ {
+ /* this dummy area is used to fool the assembler
+ otherwise the assembler will append each of these
+ declarations into one chunk and will not overlay
+ sad but true */
+
+ /* I don't think this applies to us. We are using gpasm. CRF */
+
+ fprintf (afile, ";\t.area _DUMMY\n");
+ /* output the area informtion */
+ fprintf (afile, ";\t.area\t%s\n", port->mem.overlay_name); /* MOF */
+ }
+
+ for (sym = setFirstItem (ovrset); sym;
+ sym = setNextItem (ovrset))
+ {
+
+ /* if extern then do nothing */
+ if (IS_EXTERN (sym->etype))
+ continue;
+
+ /* if allocation required check is needed
+ then check if the symbol really requires
+ allocation only for local variables */
+ if (!IS_AGGREGATE (sym->type) &&
+ !(sym->_isparm && !IS_REGPARM (sym->etype))
+ && !sym->allocreq && sym->level)
+ continue;
+
+ /* if global variable & not static or extern
+ and addPublics allowed then add it to the public set */
+ if ((sym->_isparm && !IS_REGPARM (sym->etype))
+ && !IS_STATIC (sym->etype))
+ addSetHead (&publics, sym);
+
+ /* if extern then do nothing or is a function
+ then do nothing */
+ if (IS_FUNC (sym->type))
+ continue;
+
+ /* print extra debug info if required */
+ if (options.debug || sym->level == 0)
+ {
+ if (!sym->level)
+ { /* global */
+ if (IS_STATIC (sym->etype))
+ fprintf (afile, "F%s_", moduleName); /* scope is file */
+ else
+ fprintf (afile, "G_"); /* scope is global */
+ }
+ else
+ /* symbol is local */
+ fprintf (afile, "L%s_",
+ (sym->localof ? sym->localof->name : "-null-"));
+ fprintf (afile, "%s_%d_%d", sym->name, sym->level, sym->block);
+ }
+
+ /* if is has an absolute address then generate
+ an equate for this no need to allocate space */
+ if (SPEC_ABSA (sym->etype))
+ {
+
+ if (options.debug || sym->level == 0)
+ fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
+
+ fprintf (afile, "%s\t=\t0x%04x\n",
+ sym->rname,
+ SPEC_ADDR (sym->etype));
+ }
+ else
+ {
+ if (options.debug || sym->level == 0)
+ fprintf (afile, "==.\n");
+
+ /* allocate space */
+ fprintf (afile, "%s:\n", sym->rname);
+ fprintf (afile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
+ }
+
}
- else
- /* symbol is local */
- fprintf (afile, "L%s_",
- (sym->localof ? sym->localof->name : "-null-"));
- fprintf (afile, "%s_%d_%d", sym->name, sym->level, sym->block);
- }
-
- /* if is has an absolute address then generate
- an equate for this no need to allocate space */
- if (SPEC_ABSA (sym->etype))
- {
-
- if (options.debug || sym->level == 0)
- fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
-
- fprintf (afile, "%s\t=\t0x%04x\n",
- sym->rname,
- SPEC_ADDR (sym->etype));
- }
- else
- {
- if (options.debug || sym->level == 0)
- fprintf (afile, "==.\n");
-
- /* allocate space */
- fprintf (afile, "%s:\n", sym->rname);
- fprintf (afile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
- }
-
}
- }
}
void
picglue ()
{
- char udata_name[80];
- FILE *vFile;
- FILE *asmFile;
- FILE *ovrFile = tempfile();
-
- addSetHead(&tmpfileSet,ovrFile);
- pCodeInitRegisters();
-
- if (mainf && IFFUNC_HASBODY(mainf->type)) {
-
- pBlock *pb = newpCodeChain(NULL,'X',newpCodeCharP("; Starting pCode block"));
- addpBlock(pb);
-
- /* entry point @ start of CSEG */
- addpCode2pBlock(pb,newpCodeLabel("__sdcc_program_startup",-1));
- /* put in the call to main */
- addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp("_main",PO_STR)));
-
- if (options.mainreturn) {
-
- addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will return to caller\n"));
- addpCode2pBlock(pb,newpCode(POC_RETURN,NULL));
-
- } else {
-
- addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will lock up\n"));
- addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("$",PO_STR)));
-
- }
- }
-
-
- /* At this point we've got all the code in the form of pCode structures */
- /* Now it needs to be rearranged into the order it should be placed in the */
- /* code space */
-
- movepBlock2Head('P'); // Last
- movepBlock2Head(code->dbName);
- movepBlock2Head('X');
- movepBlock2Head(statsg->dbName); // First
-
-
- /* print the global struct definitions */
- if (options.debug)
- cdbStructBlock (0);
-
- vFile = tempfile();
-
- addSetHead(&tmpfileSet,vFile);
-
- /* emit code for the all the variables declared */
- pic14emitMaps ();
- /* do the overlay segments */
- pic14emitOverlay(ovrFile);
-
- /* PENDING: this isnt the best place but it will do */
- if (port->general.glue_up_main) {
- /* create the interrupt vector table */
- pic14createInterruptVect (vFile);
- }
-
- AnalyzepCode('*');
-
- ReuseReg(); // ReuseReg where call tree permits
-
- InlinepCode();
-
- AnalyzepCode('*');
-
- pcode_test();
-
-
- /* now put it all together into the assembler file */
- /* create the assembler file name */
-
- if ((noAssemble || options.c1mode) && fullDstFileName)
- {
- sprintf (buffer, fullDstFileName);
- }
- else
- {
- sprintf (buffer, dstFileName);
- strcat (buffer, ".asm");
- }
-
- if (!(asmFile = fopen (buffer, "w"))) {
- werror (E_FILE_OPEN_ERR, buffer);
- exit (1);
- }
-
- /* initial comments */
- pic14initialComments (asmFile);
-
- /* print module name */
- fprintf (asmFile, ";\t.module %s\n", moduleName);
-
- /* Let the port generate any global directives, etc. */
- if (port->genAssemblerPreamble)
- {
- port->genAssemblerPreamble(asmFile);
- }
-
- /* print the extern variables in this module */
- pic14printExterns (asmFile);
-
- /* print the global variables in this module */
- pic14printPublics (asmFile);
-
- /* copy the sfr segment */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; special function registers\n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, sfr->oFile);
-
-
- if (udata_section_name) {
- sprintf(udata_name,"%s",udata_section_name);
- } else {
- sprintf(udata_name,"data_%s",moduleName);
- }
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; udata\n");
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "%s\tudata\n", udata_name);
- copyFile (asmFile, data->oFile);
-
- /* Put all variables into a cblock */
- AnalyzeBanking();
- writeUsedRegs(asmFile);
-
- /* create the overlay segments */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; overlayable items in internal ram \n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, ovrFile);
-
+ char udata_name[80];
+ FILE *vFile;
+ FILE *asmFile;
+ FILE *ovrFile = tempfile();
+
+ addSetHead(&tmpfileSet,ovrFile);
+ pCodeInitRegisters();
+
+ if (mainf && IFFUNC_HASBODY(mainf->type)) {
+
+ pBlock *pb = newpCodeChain(NULL,'X',newpCodeCharP("; Starting pCode block"));
+ addpBlock(pb);
+
+ /* entry point @ start of CSEG */
+ addpCode2pBlock(pb,newpCodeLabel("__sdcc_program_startup",-1));
+ /* put in the call to main */
+ addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp("_main",PO_STR)));
+
+ if (options.mainreturn) {
+
+ addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will return to caller\n"));
+ addpCode2pBlock(pb,newpCode(POC_RETURN,NULL));
+
+ } else {
+
+ addpCode2pBlock(pb,newpCodeCharP(";\treturn from main will lock up\n"));
+ addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("$",PO_STR)));
+
+ }
+ }
+
+
+ /* At this point we've got all the code in the form of pCode structures */
+ /* Now it needs to be rearranged into the order it should be placed in the */
+ /* code space */
+
+ movepBlock2Head('P'); // Last
+ movepBlock2Head(code->dbName);
+ movepBlock2Head('X');
+ movepBlock2Head(statsg->dbName); // First
+
+
+ /* print the global struct definitions */
+ if (options.debug)
+ cdbStructBlock (0);
+
+ vFile = tempfile();
+
+ addSetHead(&tmpfileSet,vFile);
+
+ /* emit code for the all the variables declared */
+ pic14emitMaps ();
+ /* do the overlay segments */
+ pic14emitOverlay(ovrFile);
+
+ /* PENDING: this isnt the best place but it will do */
+ if (port->general.glue_up_main) {
+ /* create the interrupt vector table */
+ pic14createInterruptVect (vFile);
+ }
+
+ AnalyzepCode('*');
+
+ ReuseReg(); // ReuseReg where call tree permits
+
+ InlinepCode();
+
+ AnalyzepCode('*');
+
+ pcode_test();
+
+
+ /* now put it all together into the assembler file */
+ /* create the assembler file name */
+
+ if ((noAssemble || options.c1mode) && fullDstFileName)
+ {
+ sprintf (buffer, fullDstFileName);
+ }
+ else
+ {
+ sprintf (buffer, dstFileName);
+ strcat (buffer, ".asm");
+ }
+
+ if (!(asmFile = fopen (buffer, "w"))) {
+ werror (E_FILE_OPEN_ERR, buffer);
+ exit (1);
+ }
+
+ /* initial comments */
+ pic14initialComments (asmFile);
+
+ /* print module name */
+ fprintf (asmFile, ";\t.module %s\n", moduleName);
+
+ /* Let the port generate any global directives, etc. */
+ if (port->genAssemblerPreamble)
+ {
+ port->genAssemblerPreamble(asmFile);
+ }
+
+ /* print the extern variables in this module */
+ pic14printExterns (asmFile);
+
+ /* print the global variables in this module */
+ pic14printPublics (asmFile);
+
+ /* copy the sfr segment */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; special function registers\n");
+ fprintf (asmFile, "%s", iComments2);
+ copyFile (asmFile, sfr->oFile);
+
+
+ if (udata_section_name) {
+ sprintf(udata_name,"%s",udata_section_name);
+ } else {
+ sprintf(udata_name,"data_%s",moduleName);
+ }
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; udata\n");
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "%s\tudata\n", udata_name);
+ copyFile (asmFile, data->oFile);
+
+ /* Put all variables into a cblock */
+ AnalyzeBanking();
+ writeUsedRegs(asmFile);
+
+ /* create the overlay segments */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; overlayable items in internal ram \n");
+ fprintf (asmFile, "%s", iComments2);
+ copyFile (asmFile, ovrFile);
+
#if 0
-
- /* create the stack segment MOF */
- if (mainf && IFFUNC_HASBODY(mainf->type)) {
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; Stack segment in internal ram \n");
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, ";\t.area\tSSEG\t(DATA)\n"
- ";__start__stack:\n;\t.ds\t1\n\n");
- }
-
- /* create the idata segment */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; indirectly addressable internal ram data\n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, idata->oFile);
-
- /* if external stack then reserve space of it */
- if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack ) {
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; external stack \n");
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile,";\t.area XSEG (XDATA)\n"); /* MOF */
- fprintf (asmFile,";\t.ds 256\n");
- }
-
- /* copy xtern ram data */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; external ram data\n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, xdata->oFile);
-
+
+ /* create the stack segment MOF */
+ if (mainf && IFFUNC_HASBODY(mainf->type)) {
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; Stack segment in internal ram \n");
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, ";\t.area\tSSEG\t(DATA)\n"
+ ";__start__stack:\n;\t.ds\t1\n\n");
+ }
+
+ /* create the idata segment */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; indirectly addressable internal ram data\n");
+ fprintf (asmFile, "%s", iComments2);
+ copyFile (asmFile, idata->oFile);
+
+ /* if external stack then reserve space of it */
+ if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack ) {
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; external stack \n");
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile,";\t.area XSEG (XDATA)\n"); /* MOF */
+ fprintf (asmFile,";\t.ds 256\n");
+ }
+
+ /* copy xtern ram data */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; external ram data\n");
+ fprintf (asmFile, "%s", iComments2);
+ copyFile (asmFile, xdata->oFile);
+
#endif
-
- /* copy the bit segment */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; bit data\n");
- fprintf (asmFile, "%s", iComments2);
- copyFile (asmFile, bit->oFile);
-
- /* copy the interrupt vector table */
- if (mainf && IFFUNC_HASBODY(mainf->type)) {
- copyFile (asmFile, vFile);
-
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; interrupt and initialization code\n");
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "code_init\t%s\t0x4\n", CODE_NAME); // Note - for mplink may have to enlarge section vectors in .lnk file
-
- /* interrupt service routine */
- fprintf (asmFile, "__sdcc_interrupt:\n");
- copypCode(asmFile, 'I');
-
- /* initialize data memory */
- fprintf (asmFile,"__sdcc_gsinit_startup:\n");
- /* FIXME: This is temporary. The idata section should be used. If
- not, we could add a special feature to the linker. This will
- work in the mean time. Put all initalized data in main.c */
- copypCode(asmFile, statsg->dbName);
- fprintf (asmFile,"\tpagesel _main\n");
- fprintf (asmFile,"\tgoto _main\n");
- }
-
+
+ /* copy the bit segment */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; bit data\n");
+ fprintf (asmFile, "%s", iComments2);
+ copyFile (asmFile, bit->oFile);
+
+ /* copy the interrupt vector table */
+ if (mainf && IFFUNC_HASBODY(mainf->type)) {
+ copyFile (asmFile, vFile);
+
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; interrupt and initialization code\n");
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "code_init\t%s\t0x4\n", CODE_NAME); // Note - for mplink may have to enlarge section vectors in .lnk file
+
+ /* interrupt service routine */
+ fprintf (asmFile, "__sdcc_interrupt:\n");
+ copypCode(asmFile, 'I');
+
+ /* initialize data memory */
+ fprintf (asmFile,"__sdcc_gsinit_startup:\n");
+ /* FIXME: This is temporary. The idata section should be used. If
+ not, we could add a special feature to the linker. This will
+ work in the mean time. Put all initalized data in main.c */
+ copypCode(asmFile, statsg->dbName);
+ fprintf (asmFile,"\tpagesel _main\n");
+ fprintf (asmFile,"\tgoto _main\n");
+ }
+
#if 0
-
- /* copy global & static initialisations */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; global & static initialisations\n");
- fprintf (asmFile, "%s", iComments2);
- copypCode(asmFile, statsg->dbName);
-
+
+ /* copy global & static initialisations */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; global & static initialisations\n");
+ fprintf (asmFile, "%s", iComments2);
+ copypCode(asmFile, statsg->dbName);
+
#endif
-
- /* copy over code */
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "; code\n");
- fprintf (asmFile, "%s", iComments2);
- fprintf (asmFile, "code_%s\t%s\n", moduleName, port->mem.code_name);
-
- /* unknown */
- copypCode(asmFile, 'X');
-
- /* _main function */
- copypCode(asmFile, 'M');
-
- /* other functions */
- copypCode(asmFile, code->dbName);
-
- /* unknown */
- copypCode(asmFile, 'P');
-
- fprintf (asmFile,"\tend\n");
-
- fclose (asmFile);
-
- rm_tmpfiles();
+
+ /* copy over code */
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "; code\n");
+ fprintf (asmFile, "%s", iComments2);
+ fprintf (asmFile, "code_%s\t%s\n", moduleName, port->mem.code_name);
+
+ /* unknown */
+ copypCode(asmFile, 'X');
+
+ /* _main function */
+ copypCode(asmFile, 'M');
+
+ /* other functions */
+ copypCode(asmFile, code->dbName);
+
+ /* unknown */
+ copypCode(asmFile, 'P');
+
+ fprintf (asmFile,"\tend\n");
+
+ fclose (asmFile);
+
+ rm_tmpfiles();
}
/*-------------------------------------------------------------------------
- SDCCglue.h - glues everything we have done together into one file.
+ SDCCglue.h - glues everything we have done together into one file.
Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
-
+
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
/* list of key words used by msc51 */
static char *_pic14_keywords[] =
{
- "at",
- "bit",
- "code",
- "critical",
- "data",
- "far",
- "idata",
- "interrupt",
- "near",
- "pdata",
- "reentrant",
- "sfr",
- "sbit",
- "using",
- "xdata",
- "_data",
- "_code",
- "_generic",
- "_near",
- "_xdata",
- "_pdata",
- "_idata",
- NULL
+ "at",
+ "bit",
+ "code",
+ "critical",
+ "data",
+ "far",
+ "idata",
+ "interrupt",
+ "near",
+ "pdata",
+ "reentrant",
+ "sfr",
+ "sbit",
+ "using",
+ "xdata",
+ "_data",
+ "_code",
+ "_generic",
+ "_near",
+ "_xdata",
+ "_pdata",
+ "_idata",
+ NULL
};
void pCodeInitRegisters(void);
static void
_pic14_init (void)
{
- asm_addTree (&asm_asxxxx_mapping);
- pCodeInitRegisters();
+ asm_addTree (&asm_asxxxx_mapping);
+ pCodeInitRegisters();
}
static void
_pic14_reset_regparm ()
{
- regParmFlg = 0;
+ regParmFlg = 0;
}
static int
_pic14_regparm (sym_link * l)
{
- /* for this processor it is simple
- can pass only the first parameter in a register */
- //if (regParmFlg)
- // return 0;
-
- regParmFlg++;// = 1;
- return 1;
+/* for this processor it is simple
+ can pass only the first parameter in a register */
+ //if (regParmFlg)
+ // return 0;
+
+ regParmFlg++;// = 1;
+ return 1;
}
static int
_process_pragma(const char *sz)
{
- static const char *WHITE = " \t";
- char *ptr = strtok((char *)sz, WHITE);
-
- if (startsWith (ptr, "memmap"))
- {
- char *start;
- char *end;
- char *type;
- char *alias;
-
- start = strtok((char *)NULL, WHITE);
- end = strtok((char *)NULL, WHITE);
- type = strtok((char *)NULL, WHITE);
- alias = strtok((char *)NULL, WHITE);
-
- if (start != (char *)NULL
- && end != (char *)NULL
- && type != (char *)NULL) {
- value *startVal = constVal(start);
- value *endVal = constVal(end);
- value *aliasVal;
- memRange r;
-
- if (alias == (char *)NULL) {
- aliasVal = constVal(0);
- } else {
- aliasVal = constVal(alias);
- }
-
- r.start_address = (int)floatFromVal(startVal);
- r.end_address = (int)floatFromVal(endVal);
- r.alias = (int)floatFromVal(aliasVal);
- r.bank = (r.start_address >> 7) & 3;
-
- if (strcmp(type, "RAM") == 0) {
- addMemRange(&r, 0);
- } else if (strcmp(type, "SFR") == 0) {
- addMemRange(&r, 1);
- } else {
- return 1;
- }
- }
-
- return 0;
- } else if (startsWith (ptr, "maxram")) {
- char *maxRAM = strtok((char *)NULL, WHITE);
-
- if (maxRAM != (char *)NULL) {
- int maxRAMaddress;
- value *maxRAMVal;
-
- maxRAMVal = constVal(maxRAM);
- maxRAMaddress = (int)floatFromVal(maxRAMVal);
- setMaxRAM(maxRAMaddress);
- }
+ static const char *WHITE = " \t";
+ char *ptr = strtok((char *)sz, WHITE);
- return 0;
- }
- return 1;
+ if (startsWith (ptr, "memmap"))
+ {
+ char *start;
+ char *end;
+ char *type;
+ char *alias;
+
+ start = strtok((char *)NULL, WHITE);
+ end = strtok((char *)NULL, WHITE);
+ type = strtok((char *)NULL, WHITE);
+ alias = strtok((char *)NULL, WHITE);
+
+ if (start != (char *)NULL
+ && end != (char *)NULL
+ && type != (char *)NULL) {
+ value *startVal = constVal(start);
+ value *endVal = constVal(end);
+ value *aliasVal;
+ memRange r;
+
+ if (alias == (char *)NULL) {
+ aliasVal = constVal(0);
+ } else {
+ aliasVal = constVal(alias);
+ }
+
+ r.start_address = (int)floatFromVal(startVal);
+ r.end_address = (int)floatFromVal(endVal);
+ r.alias = (int)floatFromVal(aliasVal);
+ r.bank = (r.start_address >> 7) & 3;
+
+ if (strcmp(type, "RAM") == 0) {
+ addMemRange(&r, 0);
+ } else if (strcmp(type, "SFR") == 0) {
+ addMemRange(&r, 1);
+ } else {
+ return 1;
+ }
+ }
+
+ return 0;
+ } else if (startsWith (ptr, "maxram")) {
+ char *maxRAM = strtok((char *)NULL, WHITE);
+
+ if (maxRAM != (char *)NULL) {
+ int maxRAMaddress;
+ value *maxRAMVal;
+
+ maxRAMVal = constVal(maxRAM);
+ maxRAMaddress = (int)floatFromVal(maxRAMVal);
+ setMaxRAM(maxRAMaddress);
+ }
+
+ return 0;
+ }
+ return 1;
}
extern char *udata_section_name;
static bool
_pic14_parseOptions (int *pargc, char **argv, int *i)
{
- char buf[128];
-
- /* TODO: allow port-specific command line options to specify
- * segment names here.
- */
-
+ char buf[128];
+
+ /* TODO: allow port-specific command line options to specify
+ * segment names here.
+ */
+
/* This is a temporary hack, to solve problems with some processors
- * that do not have udata section. It will be changed when a more
- * robust solution is figured out -- VR 27-11-2003 FIXME
- */
+ * that do not have udata section. It will be changed when a more
+ * robust solution is figured out -- VR 27-11-2003 FIXME
+ */
strcpy(buf, "--udata-section-name");
if(!strncmp(buf, argv[ *i ], strlen(buf))) {
if(strlen(argv[ *i ]) <= strlen(buf)+1) {
}
return 1;
}
-
- return FALSE;
+
+ return FALSE;
}
static void
_pic14_finaliseOptions (void)
{
-
- port->mem.default_local_map = data;
- port->mem.default_globl_map = data;
+
+ port->mem.default_local_map = data;
+ port->mem.default_globl_map = data;
#if 0
- /* Hack-o-matic: if we are using the flat24 model,
- * adjust pointer sizes.
- */
- if (options.model == MODEL_FLAT24)
- {
-
- fprintf (stderr, "*** WARNING: you should use the '-mds390' option "
- "for DS80C390 support. This code generator is "
- "badly out of date and probably broken.\n");
-
- port->s.fptr_size = 3;
- port->s.gptr_size = 4;
- port->stack.isr_overhead++; /* Will save dpx on ISR entry. */
+ /* Hack-o-matic: if we are using the flat24 model,
+ * adjust pointer sizes.
+ */
+ if (options.model == MODEL_FLAT24)
+ {
+
+ fprintf (stderr, "*** WARNING: you should use the '-mds390' option "
+ "for DS80C390 support. This code generator is "
+ "badly out of date and probably broken.\n");
+
+ port->s.fptr_size = 3;
+ port->s.gptr_size = 4;
+ port->stack.isr_overhead++; /* Will save dpx on ISR entry. */
#if 1
- port->stack.call_overhead++; /* This acounts for the extra byte
- * of return addres on the stack.
- * but is ugly. There must be a
- * better way.
- */
+ port->stack.call_overhead++; /* This acounts for the extra byte
+ * of return addres on the stack.
+ * but is ugly. There must be a
+ * better way.
+ */
#endif
- fReturn = fReturn390;
- fReturnSize = 5;
- }
-
- if (options.model == MODEL_LARGE)
- {
- port->mem.default_local_map = xdata;
- port->mem.default_globl_map = xdata;
- }
- else
- {
- port->mem.default_local_map = data;
- port->mem.default_globl_map = data;
- }
-
- if (options.stack10bit)
- {
- if (options.model != MODEL_FLAT24)
+ fReturn = fReturn390;
+ fReturnSize = 5;
+ }
+
+ if (options.model == MODEL_LARGE)
{
- fprintf (stderr,
- "*** warning: 10 bit stack mode is only supported in flat24 model.\n");
- fprintf (stderr, "\t10 bit stack mode disabled.\n");
- options.stack10bit = 0;
+ port->mem.default_local_map = xdata;
+ port->mem.default_globl_map = xdata;
}
- else
+ else
{
- /* Fixup the memory map for the stack; it is now in
- * far space and requires a FPOINTER to access it.
- */
- istack->fmap = 1;
- istack->ptrType = FPOINTER;
+ port->mem.default_local_map = data;
+ port->mem.default_globl_map = data;
+ }
+
+ if (options.stack10bit)
+ {
+ if (options.model != MODEL_FLAT24)
+ {
+ fprintf (stderr,
+ "*** warning: 10 bit stack mode is only supported in flat24 model.\n");
+ fprintf (stderr, "\t10 bit stack mode disabled.\n");
+ options.stack10bit = 0;
+ }
+ else
+ {
+ /* Fixup the memory map for the stack; it is now in
+ * far space and requires a FPOINTER to access it.
+ */
+ istack->fmap = 1;
+ istack->ptrType = FPOINTER;
+ }
}
- }
#endif
}
static const char *
_pic14_getRegName (struct regs *reg)
{
- if (reg)
- return reg->name;
- return "err";
+ if (reg)
+ return reg->name;
+ return "err";
}
extern char *processor_base_name(void);
static void
_pic14_genAssemblerPreamble (FILE * of)
{
- char * name = processor_base_name();
-
- if(!name) {
-
- name = "p16f877";
- fprintf(stderr,"WARNING: No Pic has been selected, defaulting to %s\n",name);
- }
-
- fprintf (of, "\tlist\tp=%s\n",&name[1]);
- fprintf (of, "\tradix dec\n");
- fprintf (of, "\tinclude \"%s.inc\"\n",name);
+ char * name = processor_base_name();
+
+ if(!name) {
+
+ name = "p16f877";
+ fprintf(stderr,"WARNING: No Pic has been selected, defaulting to %s\n",name);
+ }
+
+ fprintf (of, "\tlist\tp=%s\n",&name[1]);
+ fprintf (of, "\tradix dec\n");
+ fprintf (of, "\tinclude \"%s.inc\"\n",name);
}
/* Generate interrupt vector table. */
static int
_pic14_genIVT (FILE * of, symbol ** interrupts, int maxInterrupts)
{
- int i;
-
- if (options.model != MODEL_FLAT24)
- {
- /* Let the default code handle it. */
- return FALSE;
- }
-
- fprintf (of, "\t;ajmp\t__sdcc_gsinit_startup\n");
-
- /* now for the other interrupts */
- for (i = 0; i < maxInterrupts; i++)
- {
- if (interrupts[i])
+ int i;
+
+ if (options.model != MODEL_FLAT24)
{
- fprintf (of, "\t;ljmp\t%s\n\t.ds\t4\n", interrupts[i]->rname);
+ /* Let the default code handle it. */
+ return FALSE;
}
- else
+
+ fprintf (of, "\t;ajmp\t__sdcc_gsinit_startup\n");
+
+ /* now for the other interrupts */
+ for (i = 0; i < maxInterrupts; i++)
{
- fprintf (of, "\t;reti\n\t.ds\t7\n");
+ if (interrupts[i])
+ {
+ fprintf (of, "\t;ljmp\t%s\n\t.ds\t4\n", interrupts[i]->rname);
+ }
+ else
+ {
+ fprintf (of, "\t;reti\n\t.ds\t7\n");
+ }
}
- }
-
- return TRUE;
+
+ return TRUE;
}
static bool
_hasNativeMulFor (iCode *ic, sym_link *left, sym_link *right)
{
/*
- sym_link *test = NULL;
- value *val;
-*/
-
- fprintf(stderr,"checking for native mult\n");
-
- if ( ic->op != '*')
- {
- return FALSE;
- }
-
- return TRUE;
-/*
- if ( IS_LITERAL (left))
- {
- fprintf(stderr,"left is lit\n");
- test = left;
- val = OP_VALUE (IC_LEFT (ic));
- }
- else if ( IS_LITERAL (right))
- {
- fprintf(stderr,"right is lit\n");
- test = left;
- val = OP_VALUE (IC_RIGHT (ic));
- }
- else
- {
- fprintf(stderr,"oops, neither is lit so no\n");
- return FALSE;
- }
-
- if ( getSize (test) <= 2)
- {
- fprintf(stderr,"yep\n");
- return TRUE;
- }
- fprintf(stderr,"nope\n");
-
- return FALSE;
-*/
+sym_link *test = NULL;
+value *val;
+ */
+
+ fprintf(stderr,"checking for native mult\n");
+
+ if ( ic->op != '*')
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+ /*
+ if ( IS_LITERAL (left))
+ {
+ fprintf(stderr,"left is lit\n");
+ test = left;
+ val = OP_VALUE (IC_LEFT (ic));
+ }
+ else if ( IS_LITERAL (right))
+ {
+ fprintf(stderr,"right is lit\n");
+ test = left;
+ val = OP_VALUE (IC_RIGHT (ic));
+ }
+ else
+ {
+ fprintf(stderr,"oops, neither is lit so no\n");
+ return FALSE;
+ }
+
+ if ( getSize (test) <= 2)
+ {
+ fprintf(stderr,"yep\n");
+ return TRUE;
+ }
+ fprintf(stderr,"nope\n");
+
+ return FALSE;
+ */
}
/* Indicate which extended bit operations this port supports */
static bool
hasExtBitOp (int op, int size)
{
- if (op == RRC
- || op == RLC
- /* || op == GETHBIT */ /* GETHBIT doesn't look complete for PIC */
- )
- return TRUE;
- else
- return FALSE;
+ if (op == RRC
+ || op == RLC
+ /* || op == GETHBIT */ /* GETHBIT doesn't look complete for PIC */
+ )
+ return TRUE;
+ else
+ return FALSE;
}
/* Indicate the expense of an access to an output storage class */
static int
oclsExpense (struct memmap *oclass)
{
- /* The IN_FARSPACE test is compatible with historical behaviour, */
- /* but I don't think it is applicable to PIC. If so, please feel */
- /* free to remove this test -- EEP */
- if (IN_FARSPACE(oclass))
- return 1;
-
- return 0;
+ /* The IN_FARSPACE test is compatible with historical behaviour, */
+ /* but I don't think it is applicable to PIC. If so, please feel */
+ /* free to remove this test -- EEP */
+ if (IN_FARSPACE(oclass))
+ return 1;
+
+ return 0;
}
/** $1 is always the basename.
- $2 is always the output file.
- $3 varies
- $l is the list of extra options that should be there somewhere...
- MUST be terminated with a NULL.
+$2 is always the output file.
+$3 varies
+$l is the list of extra options that should be there somewhere...
+MUST be terminated with a NULL.
*/
static const char *_linkCmd[] =
{
- "gplink", "-o $2", "\"$1.o\"", "$l", NULL
+ "gplink", "-o $2", "\"$1.o\"", "$l", NULL
};
static const char *_asmCmd[] =
{
- "gpasm", "$l", "-c", "\"$1.asm\"", NULL
-
+ "gpasm", "$l", "-c", "\"$1.asm\"", NULL
+
};
/* Globals */
PORT pic_port =
{
- TARGET_ID_PIC,
- "pic14",
- "MCU pic", /* Target name */
- "", /* Processor */
- {
- picglue,
- TRUE, /* Emit glue around main */
- MODEL_SMALL | MODEL_LARGE | MODEL_FLAT24,
- MODEL_SMALL
- },
- {
- _asmCmd,
- NULL,
- NULL,
- NULL,
- //"-plosgffc", /* Options with debug */
- //"-plosgff", /* Options without debug */
- 0,
- ".asm",
- NULL /* no do_assemble function */
- },
- {
- _linkCmd,
- NULL,
- NULL,
- ".o",
- 0
- },
- {
- _defaultRules
- },
- {
- /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
- 1, 2, 2, 4, 2, 2, 2, 1, 4, 4
- /* TSD - I changed the size of gptr from 3 to 1. However, it should be
- 2 so that we can accomodate the PIC's with 4 register banks (like the
- 16f877)
- */
- },
- {
- "XSEG (XDATA)",
- "STACK (DATA)",
- "code",
- "DSEG (DATA)",
- "ISEG (DATA)",
- "XSEG (XDATA)",
- "BSEG (BIT)",
- "RSEG (DATA)",
- "GSINIT (CODE)",
- "udata_ovr",
- "GSFINAL (CODE)",
- "HOME (CODE)",
- NULL, // xidata
- NULL, // xinit
- NULL,
- NULL,
- 1 // code is read only
- },
- { NULL, NULL },
- {
- +1, 1, 4, 1, 1, 0
- },
- /* pic14 has an 8 bit mul */
- {
- 1, -1
- },
- "_",
- _pic14_init,
- _pic14_parseOptions,
- NULL,
- _pic14_finaliseOptions,
- _pic14_setDefaultOptions,
- pic14_assignRegisters,
- _pic14_getRegName,
- _pic14_keywords,
- _pic14_genAssemblerPreamble,
- NULL, /* no genAssemblerEnd */
- _pic14_genIVT,
- NULL, // _pic14_genXINIT
- _pic14_reset_regparm,
- _pic14_regparm,
- _process_pragma, /* process a pragma */
- NULL,
- _hasNativeMulFor,
- hasExtBitOp, /* hasExtBitOp */
- oclsExpense, /* oclsExpense */
- FALSE,
-// TRUE, /* little endian */
- FALSE, /* little endian - PIC code enumlates big endian */
- 0, /* leave lt */
- 0, /* leave gt */
- 1, /* transform <= to ! > */
- 1, /* transform >= to ! < */
- 1, /* transform != to !(a == b) */
- 0, /* leave == */
- FALSE, /* No array initializer support. */
- 0, /* no CSE cost estimation yet */
- NULL, /* no builtin functions */
- GPOINTER, /* treat unqualified pointers as "generic" pointers */
- 1, /* reset labelKey to 1 */
- 1, /* globals & local static allowed */
- PORT_MAGIC
+ TARGET_ID_PIC,
+ "pic14",
+ "MCU pic", /* Target name */
+ "", /* Processor */
+ {
+ picglue,
+ TRUE, /* Emit glue around main */
+ MODEL_SMALL | MODEL_LARGE | MODEL_FLAT24,
+ MODEL_SMALL
+ },
+ {
+ _asmCmd,
+ NULL,
+ NULL,
+ NULL,
+ //"-plosgffc", /* Options with debug */
+ //"-plosgff", /* Options without debug */
+ 0,
+ ".asm",
+ NULL /* no do_assemble function */
+ },
+ {
+ _linkCmd,
+ NULL,
+ NULL,
+ ".o",
+ 0
+ },
+ {
+ _defaultRules
+ },
+ {
+ /* Sizes: char, short, int, long, ptr, fptr, gptr, bit, float, max */
+ 1, 2, 2, 4, 2, 2, 2, 1, 4, 4
+ /* TSD - I changed the size of gptr from 3 to 1. However, it should be
+ 2 so that we can accomodate the PIC's with 4 register banks (like the
+ 16f877)
+ */
+ },
+ {
+ "XSEG (XDATA)",
+ "STACK (DATA)",
+ "code",
+ "DSEG (DATA)",
+ "ISEG (DATA)",
+ "XSEG (XDATA)",
+ "BSEG (BIT)",
+ "RSEG (DATA)",
+ "GSINIT (CODE)",
+ "udata_ovr",
+ "GSFINAL (CODE)",
+ "HOME (CODE)",
+ NULL, // xidata
+ NULL, // xinit
+ NULL,
+ NULL,
+ 1 // code is read only
+ },
+ { NULL, NULL },
+ {
+ +1, 1, 4, 1, 1, 0
+ },
+ /* pic14 has an 8 bit mul */
+ {
+ 1, -1
+ },
+ "_",
+ _pic14_init,
+ _pic14_parseOptions,
+ NULL,
+ _pic14_finaliseOptions,
+ _pic14_setDefaultOptions,
+ pic14_assignRegisters,
+ _pic14_getRegName,
+ _pic14_keywords,
+ _pic14_genAssemblerPreamble,
+ NULL, /* no genAssemblerEnd */
+ _pic14_genIVT,
+ NULL, // _pic14_genXINIT
+ _pic14_reset_regparm,
+ _pic14_regparm,
+ _process_pragma, /* process a pragma */
+ NULL,
+ _hasNativeMulFor,
+ hasExtBitOp, /* hasExtBitOp */
+ oclsExpense, /* oclsExpense */
+ FALSE,
+// TRUE, /* little endian */
+ FALSE, /* little endian - PIC code enumlates big endian */
+ 0, /* leave lt */
+ 0, /* leave gt */
+ 1, /* transform <= to ! > */
+ 1, /* transform >= to ! < */
+ 1, /* transform != to !(a == b) */
+ 0, /* leave == */
+ FALSE, /* No array initializer support. */
+ 0, /* no CSE cost estimation yet */
+ NULL, /* no builtin functions */
+ GPOINTER, /* treat unqualified pointers as "generic" pointers */
+ 1, /* reset labelKey to 1 */
+ 1, /* globals & local static allowed */
+ PORT_MAGIC
};
/****************************************************************/
peepCommand peepCommands[] = {
-
- {NOTBITSKIP, "_NOTBITSKIP_"},
- {BITSKIP, "_BITSKIP_"},
- {INVERTBITSKIP, "_INVERTBITSKIP_"},
-
- {-1, NULL}
+
+ {NOTBITSKIP, "_NOTBITSKIP_"},
+ {BITSKIP, "_BITSKIP_"},
+ {INVERTBITSKIP, "_INVERTBITSKIP_"},
+
+ {-1, NULL}
};
/****************************************************************/
pCodeInstruction pciADDWF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_ADDWF,
- "ADDWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ADDWF,
+ "ADDWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
};
pCodeInstruction pciADDFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_ADDFW,
- "ADDWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ADDFW,
+ "ADDWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciADDLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_ADDLW,
- "ADDLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- (PCC_W | PCC_LITERAL), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ADDLW,
+ "ADDLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciANDLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_ANDLW,
- "ANDLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- (PCC_W | PCC_LITERAL), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ANDLW,
+ "ANDLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciANDWF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_ANDWF,
- "ANDWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ANDWF,
+ "ANDWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
};
pCodeInstruction pciANDFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_ANDFW,
- "ANDWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_ANDFW,
+ "ANDWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciBCF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_BCF,
- "BCF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,1, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_BSF,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_BCF,
+ "BCF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,1, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_BSF,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciBSF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_BSF,
- "BSF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,1, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_BCF,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_BSF,
+ "BSF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,1, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_BCF,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
};
pCodeInstruction pciBTFSC = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
- genericDestruct,
- genericPrint},
- POC_BTFSC,
- "BTFSC",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,1, // dest, bit instruction
- 1,1, // branch, skip
- 0, // literal operand
- POC_BTFSS,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- PCC_EXAMINE_PCOP // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_BTFSC,
+ "BTFSC",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,1, // dest, bit instruction
+ 1,1, // branch, skip
+ 0, // literal operand
+ POC_BTFSS,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ PCC_EXAMINE_PCOP // outCond
};
pCodeInstruction pciBTFSS = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
- genericDestruct,
- genericPrint},
- POC_BTFSS,
- "BTFSS",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,1, // dest, bit instruction
- 1,1, // branch, skip
- 0, // literal operand
- POC_BTFSC,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- PCC_EXAMINE_PCOP // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_BTFSS,
+ "BTFSS",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,1, // dest, bit instruction
+ 1,1, // branch, skip
+ 0, // literal operand
+ POC_BTFSC,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ PCC_EXAMINE_PCOP // outCond
};
pCodeInstruction pciCALL = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_CALL,
- "CALL",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 1,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CALL,
+ "CALL",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
};
pCodeInstruction pciCOMF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_COMF,
- "COMF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_COMF,
+ "COMF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciCOMFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_COMFW,
- "COMF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_COMFW,
+ "COMF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciCLRF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_CLRF,
- "CLRF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CLRF,
+ "CLRF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciCLRW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_CLRW,
- "CLRW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 0, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CLRW,
+ "CLRW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciCLRWDT = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_CLRWDT,
- "CLRWDT",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 0, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CLRWDT,
+ "CLRWDT",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
};
pCodeInstruction pciDECF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_DECF,
- "DECF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_DECF,
+ "DECF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciDECFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_DECFW,
- "DECF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_DECFW,
+ "DECF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciDECFSZ = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
- genericDestruct,
- genericPrint},
- POC_DECFSZ,
- "DECFSZ",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 1,1, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_DECFSZ,
+ "DECFSZ",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciDECFSZW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
- genericDestruct,
- genericPrint},
- POC_DECFSZW,
- "DECFSZ",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 1,1, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_DECFSZW,
+ "DECFSZ",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciGOTO = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeGOTO,
- genericDestruct,
- genericPrint},
- POC_GOTO,
- "GOTO",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 1,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeGOTO,
+ genericDestruct,
+ genericPrint},
+ POC_GOTO,
+ "GOTO",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
};
pCodeInstruction pciINCF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_INCF,
- "INCF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_INCF,
+ "INCF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciINCFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_INCFW,
- "INCF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_INCFW,
+ "INCF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciINCFSZ = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
- genericDestruct,
- genericPrint},
- POC_INCFSZ,
- "INCFSZ",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 1,1, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_INCFSZ,
+ "INCFSZ",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciINCFSZW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
- genericDestruct,
- genericPrint},
- POC_INCFSZW,
- "INCFSZ",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 1,1, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeSKIP,
+ genericDestruct,
+ genericPrint},
+ POC_INCFSZW,
+ "INCFSZ",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciIORWF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_IORWF,
- "IORWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_IORWF,
+ "IORWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
};
pCodeInstruction pciIORFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_IORFW,
- "IORWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_IORFW,
+ "IORWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciIORLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_IORLW,
- "IORLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- (PCC_W | PCC_LITERAL), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_IORLW,
+ "IORLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciMOVF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_MOVF,
- "MOVF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_Z // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVF,
+ "MOVF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ PCC_Z // outCond
};
pCodeInstruction pciMOVFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_MOVFW,
- "MOVF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVFW,
+ "MOVF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_REGISTER, // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciMOVWF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_MOVWF,
- "MOVWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_W, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_MOVWF,
+ "MOVWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_W, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciMOVLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- genericDestruct,
- genericPrint},
- POC_MOVLW,
- "MOVLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- (PCC_NONE | PCC_LITERAL), // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ genericDestruct,
+ genericPrint},
+ POC_MOVLW,
+ "MOVLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ (PCC_NONE | PCC_LITERAL), // inCond
+ PCC_W // outCond
};
pCodeInstruction pciNOP = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- genericDestruct,
- genericPrint},
- POC_NOP,
- "NOP",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 0, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ genericDestruct,
+ genericPrint},
+ POC_NOP,
+ "NOP",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
};
pCodeInstruction pciRETFIE = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeRETURN,
- genericDestruct,
- genericPrint},
- POC_RETFIE,
- "RETFIE",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 0, // num ops
- 0,0, // dest, bit instruction
- 1,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond (not true... affects the GIE bit too)
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeRETURN,
+ genericDestruct,
+ genericPrint},
+ POC_RETFIE,
+ "RETFIE",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ 1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond (not true... affects the GIE bit too)
};
pCodeInstruction pciRETLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeRETURN,
- genericDestruct,
- genericPrint},
- POC_RETLW,
- "RETLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 1,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- PCC_LITERAL, // inCond
- PCC_W // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeRETURN,
+ genericDestruct,
+ genericPrint},
+ POC_RETLW,
+ "RETLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 1,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ PCC_LITERAL, // inCond
+ PCC_W // outCond
};
pCodeInstruction pciRETURN = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeRETURN,
- genericDestruct,
- genericPrint},
- POC_RETURN,
- "RETURN",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 0, // num ops
- 0,0, // dest, bit instruction
- 1,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // AnalyzeRETURN,
+ genericDestruct,
+ genericPrint},
+ POC_RETURN,
+ "RETURN",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ 1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
};
pCodeInstruction pciRLF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_RLF,
- "RLF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_C | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_RLF,
+ "RLF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_C | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciRLFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_RLFW,
- "RLF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_C | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_RLFW,
+ "RLF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_C | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciRRF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_RRF,
- "RRF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_C | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_RRF,
+ "RRF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_C | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciRRFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_RRFW,
- "RRF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_C | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_RRFW,
+ "RRF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_C | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciSUBWF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_SUBWF,
- "SUBWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SUBWF,
+ "SUBWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
};
pCodeInstruction pciSUBFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_SUBFW,
- "SUBWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SUBFW,
+ "SUBWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciSUBLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_SUBLW,
- "SUBLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- (PCC_W | PCC_LITERAL), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SUBLW,
+ "SUBLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciSWAPF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_SWAPF,
- "SWAPF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_REGISTER), // inCond
- (PCC_REGISTER) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SWAPF,
+ "SWAPF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_REGISTER), // inCond
+ (PCC_REGISTER) // outCond
};
pCodeInstruction pciSWAPFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_SWAPFW,
- "SWAPF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_REGISTER), // inCond
- (PCC_W) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_SWAPFW,
+ "SWAPF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_REGISTER), // inCond
+ (PCC_W) // outCond
};
pCodeInstruction pciTRIS = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_TRIS,
- "TRIS",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_TRIS,
+ "TRIS",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciXORWF = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_XORWF,
- "XORWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 1,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_XORWF,
+ "XORWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 1,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_REGISTER | PCC_Z) // outCond
};
pCodeInstruction pciXORFW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_XORFW,
- "XORWF",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 2, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- (PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_XORFW,
+ "XORWF",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 2, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_REGISTER), // inCond
+ (PCC_W | PCC_Z) // outCond
};
pCodeInstruction pciXORLW = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_XORLW,
- "XORLW",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 1, // literal operand
- POC_NOP,
- (PCC_W | PCC_LITERAL), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_XORLW,
+ "XORLW",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
+ (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
pCodeInstruction pciBANKSEL = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_BANKSEL,
- "BANKSEL",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_BANKSEL,
+ "BANKSEL",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction pciPAGESEL = {
- {PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
- genericDestruct,
- genericPrint},
- POC_PAGESEL,
- "PAGESEL",
- NULL, // from branch
- NULL, // to branch
- NULL, // label
- NULL, // operand
- NULL, // flow block
- NULL, // C source
- 1, // num ops
- 0,0, // dest, bit instruction
- 0,0, // branch, skip
- 0, // literal operand
- POC_NOP,
- PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ {PC_OPCODE, NULL, NULL, 0, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_PAGESEL,
+ "PAGESEL",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 1, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_REGISTER // outCond
};
pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS];
/* return a unique ID number to assist pCodes debuging */
/*-----------------------------------------------------------------*/
unsigned PCodeID(void) {
- static unsigned int pcodeId = 1; /* unique ID number to be assigned to all pCodes */
-/*
- static unsigned int stop;
- if (pcodeId == 5801)
- stop++;
- if ((pcodeId >= 855)&&(pcodeId <= 856))
- stop++;
-*/
- return pcodeId++;
+ static unsigned int pcodeId = 1; /* unique ID number to be assigned to all pCodes */
+ /*
+ static unsigned int stop;
+ if (pcodeId == 5801)
+ stop++;
+ if ((pcodeId >= 855)&&(pcodeId <= 856))
+ stop++;
+ */
+ return pcodeId++;
}
#ifdef HAVE_VSNPRINTF
- // Alas, vsnprintf is not ANSI standard, and does not exist
- // on Solaris (and probably other non-Gnu flavored Unixes).
+// Alas, vsnprintf is not ANSI standard, and does not exist
+// on Solaris (and probably other non-Gnu flavored Unixes).
/*-----------------------------------------------------------------*/
/* SAFE_snprintf - like snprintf except the string pointer is */
/*-----------------------------------------------------------------*/
void SAFE_snprintf(char **str, size_t *size, const char *format, ...)
{
- va_list val;
- int len;
-
- if(!str || !*str)
- return;
-
- va_start(val, format);
-
- vsnprintf(*str, *size, format, val);
-
- va_end (val);
-
- len = strlen(*str);
- if((size_t)len > *size) {
- fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
- fprintf(stderr,"len = %d is > str size %d\n",len,(int)*size);
- }
-
- *str += len;
- *size -= len;
-
+ va_list val;
+ int len;
+
+ if(!str || !*str)
+ return;
+
+ va_start(val, format);
+
+ vsnprintf(*str, *size, format, val);
+
+ va_end (val);
+
+ len = strlen(*str);
+ if((size_t)len > *size) {
+ fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
+ fprintf(stderr,"len = %d is > str size %d\n",len,(int)*size);
+ }
+
+ *str += len;
+ *size -= len;
+
}
#else // HAVE_VSNPRINTF
void SAFE_snprintf(char **str, size_t *size, const char *format, ...)
{
- va_list val;
- int len;
- static char buffer[1024]; /* grossly conservative, but still not inherently safe */
-
- if(!str || !*str)
- return;
-
- va_start(val, format);
-
- vsprintf(buffer, format, val);
- va_end (val);
-
- len = strlen(buffer);
- if(len > *size) {
- fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
- fprintf(stderr,"len = %d is > str size %d\n",len,*size);
- }
-
- strcpy(*str, buffer);
- *str += len;
- *size -= len;
-
+ va_list val;
+ int len;
+ static char buffer[1024]; /* grossly conservative, but still not inherently safe */
+
+ if(!str || !*str)
+ return;
+
+ va_start(val, format);
+
+ vsprintf(buffer, format, val);
+ va_end (val);
+
+ len = strlen(buffer);
+ if(len > *size) {
+ fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
+ fprintf(stderr,"len = %d is > str size %d\n",len,*size);
+ }
+
+ strcpy(*str, buffer);
+ *str += len;
+ *size -= len;
+
}
#endif // HAVE_VSNPRINTF
-
+
extern void initStack(int base_address, int size);
extern regs *allocProcessorRegister(int rIdx, char * name, short po_type, int alias);
void pCodeInitRegisters(void)
{
- static int initialized=0;
- int shareBankAddress,stkSize;
-
- if(initialized)
- return;
- initialized = 1;
-
- shareBankAddress = 0x7f; /* FIXME - some PIC ICs like 16C7X which do not have a shared bank need a different approach. */
- stkSize = 8; // Set pseudo stack size to 8
- initStack(shareBankAddress, stkSize); // Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters
- init_pic(port->processor);
-
- pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x180);
- pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80);
- pc_pclath.r = allocProcessorRegister(IDX_PCLATH,"PCLATH", PO_PCLATH, 0x180);
- pc_fsr.r = allocProcessorRegister(IDX_FSR,"FSR", PO_FSR, 0x180);
- pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x80);
- pc_intcon.r = allocProcessorRegister(IDX_INTCON,"INTCON", PO_INTCON, 0x180);
-
- pc_status.rIdx = IDX_STATUS;
- pc_fsr.rIdx = IDX_FSR;
- pc_indf.rIdx = IDX_INDF;
- pc_intcon.rIdx = IDX_INTCON;
- pc_pcl.rIdx = IDX_PCL;
- pc_pclath.rIdx = IDX_PCLATH;
-
- pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0x180); /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */
- pc_ssave.r = allocInternalRegister(IDX_SSAVE,"SSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for status register. */
- pc_psave.r = allocInternalRegister(IDX_PSAVE,"PSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for pclath register. */
-
- pc_wsave.rIdx = pc_wsave.r->rIdx;
- pc_ssave.rIdx = pc_ssave.r->rIdx;
- pc_psave.rIdx = pc_psave.r->rIdx;
-
- pc_wsave.r->isFixed = 1; /* Some PIC ICs do not have a sharebank - this register needs to be reserved across all banks. */
- pc_wsave.r->address = shareBankAddress-stkSize;
- pc_ssave.r->isFixed = 1; /* This register must be in the first bank. */
- pc_ssave.r->address = shareBankAddress-stkSize-1;
- pc_psave.r->isFixed = 1; /* This register must be in the first bank. */
- pc_psave.r->address = shareBankAddress-stkSize-2;
-
- /* probably should put this in a separate initialization routine */
- pb_dead_pcodes = newpBlock();
-
+ static int initialized=0;
+ int shareBankAddress,stkSize;
+
+ if(initialized)
+ return;
+ initialized = 1;
+
+ shareBankAddress = 0x7f; /* FIXME - some PIC ICs like 16C7X which do not have a shared bank need a different approach. */
+ stkSize = 8; // Set pseudo stack size to 8
+ initStack(shareBankAddress, stkSize); // Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters
+ init_pic(port->processor);
+
+ pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x180);
+ pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80);
+ pc_pclath.r = allocProcessorRegister(IDX_PCLATH,"PCLATH", PO_PCLATH, 0x180);
+ pc_fsr.r = allocProcessorRegister(IDX_FSR,"FSR", PO_FSR, 0x180);
+ pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x80);
+ pc_intcon.r = allocProcessorRegister(IDX_INTCON,"INTCON", PO_INTCON, 0x180);
+
+ pc_status.rIdx = IDX_STATUS;
+ pc_fsr.rIdx = IDX_FSR;
+ pc_indf.rIdx = IDX_INDF;
+ pc_intcon.rIdx = IDX_INTCON;
+ pc_pcl.rIdx = IDX_PCL;
+ pc_pclath.rIdx = IDX_PCLATH;
+
+ pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0x180); /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */
+ pc_ssave.r = allocInternalRegister(IDX_SSAVE,"SSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for status register. */
+ pc_psave.r = allocInternalRegister(IDX_PSAVE,"PSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for pclath register. */
+
+ pc_wsave.rIdx = pc_wsave.r->rIdx;
+ pc_ssave.rIdx = pc_ssave.r->rIdx;
+ pc_psave.rIdx = pc_psave.r->rIdx;
+
+ pc_wsave.r->isFixed = 1; /* Some PIC ICs do not have a sharebank - this register needs to be reserved across all banks. */
+ pc_wsave.r->address = shareBankAddress-stkSize;
+ pc_ssave.r->isFixed = 1; /* This register must be in the first bank. */
+ pc_ssave.r->address = shareBankAddress-stkSize-1;
+ pc_psave.r->isFixed = 1; /* This register must be in the first bank. */
+ pc_psave.r->address = shareBankAddress-stkSize-2;
+
+ /* probably should put this in a separate initialization routine */
+ pb_dead_pcodes = newpBlock();
+
}
/*-----------------------------------------------------------------*/
int mnem2key(char const *mnem)
{
- int key = 0;
-
- if(!mnem)
- return 0;
-
- while(*mnem) {
-
- key += toupper(*mnem++) +1;
-
- }
-
- return (key & 0x1f);
-
+ int key = 0;
+
+ if(!mnem)
+ return 0;
+
+ while(*mnem) {
+
+ key += toupper(*mnem++) +1;
+
+ }
+
+ return (key & 0x1f);
+
}
void pic14initMnemonics(void)
{
- int i = 0;
- int key;
- // char *str;
- pCodeInstruction *pci;
-
- if(mnemonics_initialized)
- return;
-
-//FIXME - probably should NULL out the array before making the assignments
-//since we check the array contents below this initialization.
-
- pic14Mnemonics[POC_ADDLW] = &pciADDLW;
- pic14Mnemonics[POC_ADDWF] = &pciADDWF;
- pic14Mnemonics[POC_ADDFW] = &pciADDFW;
- pic14Mnemonics[POC_ANDLW] = &pciANDLW;
- pic14Mnemonics[POC_ANDWF] = &pciANDWF;
- pic14Mnemonics[POC_ANDFW] = &pciANDFW;
- pic14Mnemonics[POC_BCF] = &pciBCF;
- pic14Mnemonics[POC_BSF] = &pciBSF;
- pic14Mnemonics[POC_BTFSC] = &pciBTFSC;
- pic14Mnemonics[POC_BTFSS] = &pciBTFSS;
- pic14Mnemonics[POC_CALL] = &pciCALL;
- pic14Mnemonics[POC_COMF] = &pciCOMF;
- pic14Mnemonics[POC_COMFW] = &pciCOMFW;
- pic14Mnemonics[POC_CLRF] = &pciCLRF;
- pic14Mnemonics[POC_CLRW] = &pciCLRW;
- pic14Mnemonics[POC_CLRWDT] = &pciCLRWDT;
- pic14Mnemonics[POC_DECF] = &pciDECF;
- pic14Mnemonics[POC_DECFW] = &pciDECFW;
- pic14Mnemonics[POC_DECFSZ] = &pciDECFSZ;
- pic14Mnemonics[POC_DECFSZW] = &pciDECFSZW;
- pic14Mnemonics[POC_GOTO] = &pciGOTO;
- pic14Mnemonics[POC_INCF] = &pciINCF;
- pic14Mnemonics[POC_INCFW] = &pciINCFW;
- pic14Mnemonics[POC_INCFSZ] = &pciINCFSZ;
- pic14Mnemonics[POC_INCFSZW] = &pciINCFSZW;
- pic14Mnemonics[POC_IORLW] = &pciIORLW;
- pic14Mnemonics[POC_IORWF] = &pciIORWF;
- pic14Mnemonics[POC_IORFW] = &pciIORFW;
- pic14Mnemonics[POC_MOVF] = &pciMOVF;
- pic14Mnemonics[POC_MOVFW] = &pciMOVFW;
- pic14Mnemonics[POC_MOVLW] = &pciMOVLW;
- pic14Mnemonics[POC_MOVWF] = &pciMOVWF;
- pic14Mnemonics[POC_NOP] = &pciNOP;
- pic14Mnemonics[POC_RETFIE] = &pciRETFIE;
- pic14Mnemonics[POC_RETLW] = &pciRETLW;
- pic14Mnemonics[POC_RETURN] = &pciRETURN;
- pic14Mnemonics[POC_RLF] = &pciRLF;
- pic14Mnemonics[POC_RLFW] = &pciRLFW;
- pic14Mnemonics[POC_RRF] = &pciRRF;
- pic14Mnemonics[POC_RRFW] = &pciRRFW;
- pic14Mnemonics[POC_SUBLW] = &pciSUBLW;
- pic14Mnemonics[POC_SUBWF] = &pciSUBWF;
- pic14Mnemonics[POC_SUBFW] = &pciSUBFW;
- pic14Mnemonics[POC_SWAPF] = &pciSWAPF;
- pic14Mnemonics[POC_SWAPFW] = &pciSWAPFW;
- pic14Mnemonics[POC_TRIS] = &pciTRIS;
- pic14Mnemonics[POC_XORLW] = &pciXORLW;
- pic14Mnemonics[POC_XORWF] = &pciXORWF;
- pic14Mnemonics[POC_XORFW] = &pciXORFW;
- pic14Mnemonics[POC_BANKSEL] = &pciBANKSEL;
- pic14Mnemonics[POC_PAGESEL] = &pciPAGESEL;
-
- for(i=0; i<MAX_PIC14MNEMONICS; i++)
- if(pic14Mnemonics[i])
- hTabAddItem(&pic14MnemonicsHash, mnem2key(pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]);
- pci = hTabFirstItem(pic14MnemonicsHash, &key);
-
- while(pci) {
- DFPRINTF((stderr, "element %d key %d, mnem %s\n",i++,key,pci->mnemonic));
- pci = hTabNextItem(pic14MnemonicsHash, &key);
- }
-
- mnemonics_initialized = 1;
+ int i = 0;
+ int key;
+ // char *str;
+ pCodeInstruction *pci;
+
+ if(mnemonics_initialized)
+ return;
+
+ //FIXME - probably should NULL out the array before making the assignments
+ //since we check the array contents below this initialization.
+
+ pic14Mnemonics[POC_ADDLW] = &pciADDLW;
+ pic14Mnemonics[POC_ADDWF] = &pciADDWF;
+ pic14Mnemonics[POC_ADDFW] = &pciADDFW;
+ pic14Mnemonics[POC_ANDLW] = &pciANDLW;
+ pic14Mnemonics[POC_ANDWF] = &pciANDWF;
+ pic14Mnemonics[POC_ANDFW] = &pciANDFW;
+ pic14Mnemonics[POC_BCF] = &pciBCF;
+ pic14Mnemonics[POC_BSF] = &pciBSF;
+ pic14Mnemonics[POC_BTFSC] = &pciBTFSC;
+ pic14Mnemonics[POC_BTFSS] = &pciBTFSS;
+ pic14Mnemonics[POC_CALL] = &pciCALL;
+ pic14Mnemonics[POC_COMF] = &pciCOMF;
+ pic14Mnemonics[POC_COMFW] = &pciCOMFW;
+ pic14Mnemonics[POC_CLRF] = &pciCLRF;
+ pic14Mnemonics[POC_CLRW] = &pciCLRW;
+ pic14Mnemonics[POC_CLRWDT] = &pciCLRWDT;
+ pic14Mnemonics[POC_DECF] = &pciDECF;
+ pic14Mnemonics[POC_DECFW] = &pciDECFW;
+ pic14Mnemonics[POC_DECFSZ] = &pciDECFSZ;
+ pic14Mnemonics[POC_DECFSZW] = &pciDECFSZW;
+ pic14Mnemonics[POC_GOTO] = &pciGOTO;
+ pic14Mnemonics[POC_INCF] = &pciINCF;
+ pic14Mnemonics[POC_INCFW] = &pciINCFW;
+ pic14Mnemonics[POC_INCFSZ] = &pciINCFSZ;
+ pic14Mnemonics[POC_INCFSZW] = &pciINCFSZW;
+ pic14Mnemonics[POC_IORLW] = &pciIORLW;
+ pic14Mnemonics[POC_IORWF] = &pciIORWF;
+ pic14Mnemonics[POC_IORFW] = &pciIORFW;
+ pic14Mnemonics[POC_MOVF] = &pciMOVF;
+ pic14Mnemonics[POC_MOVFW] = &pciMOVFW;
+ pic14Mnemonics[POC_MOVLW] = &pciMOVLW;
+ pic14Mnemonics[POC_MOVWF] = &pciMOVWF;
+ pic14Mnemonics[POC_NOP] = &pciNOP;
+ pic14Mnemonics[POC_RETFIE] = &pciRETFIE;
+ pic14Mnemonics[POC_RETLW] = &pciRETLW;
+ pic14Mnemonics[POC_RETURN] = &pciRETURN;
+ pic14Mnemonics[POC_RLF] = &pciRLF;
+ pic14Mnemonics[POC_RLFW] = &pciRLFW;
+ pic14Mnemonics[POC_RRF] = &pciRRF;
+ pic14Mnemonics[POC_RRFW] = &pciRRFW;
+ pic14Mnemonics[POC_SUBLW] = &pciSUBLW;
+ pic14Mnemonics[POC_SUBWF] = &pciSUBWF;
+ pic14Mnemonics[POC_SUBFW] = &pciSUBFW;
+ pic14Mnemonics[POC_SWAPF] = &pciSWAPF;
+ pic14Mnemonics[POC_SWAPFW] = &pciSWAPFW;
+ pic14Mnemonics[POC_TRIS] = &pciTRIS;
+ pic14Mnemonics[POC_XORLW] = &pciXORLW;
+ pic14Mnemonics[POC_XORWF] = &pciXORWF;
+ pic14Mnemonics[POC_XORFW] = &pciXORFW;
+ pic14Mnemonics[POC_BANKSEL] = &pciBANKSEL;
+ pic14Mnemonics[POC_PAGESEL] = &pciPAGESEL;
+
+ for(i=0; i<MAX_PIC14MNEMONICS; i++)
+ if(pic14Mnemonics[i])
+ hTabAddItem(&pic14MnemonicsHash, mnem2key(pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]);
+ pci = hTabFirstItem(pic14MnemonicsHash, &key);
+
+ while(pci) {
+ DFPRINTF((stderr, "element %d key %d, mnem %s\n",i++,key,pci->mnemonic));
+ pci = hTabNextItem(pic14MnemonicsHash, &key);
+ }
+
+ mnemonics_initialized = 1;
}
int getpCodePeepCommand(char *cmd);
int getpCode(char *mnem,unsigned dest)
{
-
- pCodeInstruction *pci;
- int key = mnem2key(mnem);
-
- if(!mnemonics_initialized)
- pic14initMnemonics();
-
- pci = hTabFirstItemWK(pic14MnemonicsHash, key);
-
- while(pci) {
-
- if(STRCASECMP(pci->mnemonic, mnem) == 0) {
- if((pci->num_ops <= 1) || (pci->isModReg == dest) || (pci->isBitInst))
- return(pci->op);
- }
-
- pci = hTabNextItemWK (pic14MnemonicsHash);
-
- }
-
- return -1;
+
+ pCodeInstruction *pci;
+ int key = mnem2key(mnem);
+
+ if(!mnemonics_initialized)
+ pic14initMnemonics();
+
+ pci = hTabFirstItemWK(pic14MnemonicsHash, key);
+
+ while(pci) {
+
+ if(STRCASECMP(pci->mnemonic, mnem) == 0) {
+ if((pci->num_ops <= 1) || (pci->isModReg == dest) || (pci->isBitInst))
+ return(pci->op);
+ }
+
+ pci = hTabNextItemWK (pic14MnemonicsHash);
+
+ }
+
+ return -1;
}
/*-----------------------------------------------------------------*
- * pic14initpCodePeepCommands
- *
- *-----------------------------------------------------------------*/
+* pic14initpCodePeepCommands
+*
+*-----------------------------------------------------------------*/
void pic14initpCodePeepCommands(void)
{
-
- int key, i;
- peepCommand *pcmd;
-
- i = 0;
- do {
- hTabAddItem(&pic14pCodePeepCommandsHash,
- mnem2key(peepCommands[i].cmd), &peepCommands[i]);
- i++;
- } while (peepCommands[i].cmd);
-
- pcmd = hTabFirstItem(pic14pCodePeepCommandsHash, &key);
-
- while(pcmd) {
- //fprintf(stderr, "peep command %s key %d\n",pcmd->cmd,pcmd->id);
- pcmd = hTabNextItem(pic14pCodePeepCommandsHash, &key);
- }
-
+
+ int key, i;
+ peepCommand *pcmd;
+
+ i = 0;
+ do {
+ hTabAddItem(&pic14pCodePeepCommandsHash,
+ mnem2key(peepCommands[i].cmd), &peepCommands[i]);
+ i++;
+ } while (peepCommands[i].cmd);
+
+ pcmd = hTabFirstItem(pic14pCodePeepCommandsHash, &key);
+
+ while(pcmd) {
+ //fprintf(stderr, "peep command %s key %d\n",pcmd->cmd,pcmd->id);
+ pcmd = hTabNextItem(pic14pCodePeepCommandsHash, &key);
+ }
+
}
/*-----------------------------------------------------------------
- *
- *
- *-----------------------------------------------------------------*/
+*
+*
+*-----------------------------------------------------------------*/
int getpCodePeepCommand(char *cmd)
{
-
- peepCommand *pcmd;
- int key = mnem2key(cmd);
-
-
- pcmd = hTabFirstItemWK(pic14pCodePeepCommandsHash, key);
-
- while(pcmd) {
- // fprintf(stderr," comparing %s to %s\n",pcmd->cmd,cmd);
- if(STRCASECMP(pcmd->cmd, cmd) == 0) {
- return pcmd->id;
- }
-
- pcmd = hTabNextItemWK (pic14pCodePeepCommandsHash);
-
- }
-
- return -1;
+
+ peepCommand *pcmd;
+ int key = mnem2key(cmd);
+
+
+ pcmd = hTabFirstItemWK(pic14pCodePeepCommandsHash, key);
+
+ while(pcmd) {
+ // fprintf(stderr," comparing %s to %s\n",pcmd->cmd,cmd);
+ if(STRCASECMP(pcmd->cmd, cmd) == 0) {
+ return pcmd->id;
+ }
+
+ pcmd = hTabNextItemWK (pic14pCodePeepCommandsHash);
+
+ }
+
+ return -1;
}
char getpBlock_dbName(pBlock *pb)
{
- if(!pb)
- return 0;
-
- if(pb->cmemmap)
- return pb->cmemmap->dbName;
-
- return pb->dbName;
+ if(!pb)
+ return 0;
+
+ if(pb->cmemmap)
+ return pb->cmemmap->dbName;
+
+ return pb->dbName;
}
void pBlockConvert2ISR(pBlock *pb)
{
- if(!pb)
- return;
-
- if(pb->cmemmap)
- pb->cmemmap = NULL;
-
- pb->dbName = 'I';
+ if(!pb)
+ return;
+
+ if(pb->cmemmap)
+ pb->cmemmap = NULL;
+
+ pb->dbName = 'I';
}
/*-----------------------------------------------------------------*/
void movepBlock2Head(char dbName)
{
- pBlock *pb;
-
- pb = the_pFile->pbHead;
-
- while(pb) {
-
- if(getpBlock_dbName(pb) == dbName) {
- pBlock *pbn = pb->next;
- pb->next = the_pFile->pbHead;
- the_pFile->pbHead->prev = pb;
- the_pFile->pbHead = pb;
-
- if(pb->prev)
- pb->prev->next = pbn;
-
- // If the pBlock that we just moved was the last
- // one in the link of all of the pBlocks, then we
- // need to point the tail to the block just before
- // the one we moved.
- // Note: if pb->next is NULL, then pb must have
- // been the last pBlock in the chain.
-
- if(pbn)
- pbn->prev = pb->prev;
- else
- the_pFile->pbTail = pb->prev;
-
- pb = pbn;
-
- } else
- pb = pb->next;
-
- }
-
+ pBlock *pb;
+
+ pb = the_pFile->pbHead;
+
+ while(pb) {
+
+ if(getpBlock_dbName(pb) == dbName) {
+ pBlock *pbn = pb->next;
+ pb->next = the_pFile->pbHead;
+ the_pFile->pbHead->prev = pb;
+ the_pFile->pbHead = pb;
+
+ if(pb->prev)
+ pb->prev->next = pbn;
+
+ // If the pBlock that we just moved was the last
+ // one in the link of all of the pBlocks, then we
+ // need to point the tail to the block just before
+ // the one we moved.
+ // Note: if pb->next is NULL, then pb must have
+ // been the last pBlock in the chain.
+
+ if(pbn)
+ pbn->prev = pb->prev;
+ else
+ the_pFile->pbTail = pb->prev;
+
+ pb = pbn;
+
+ } else
+ pb = pb->next;
+
+ }
+
}
void copypCode(FILE *of, char dbName)
{
- pBlock *pb;
-
- if(!of || !the_pFile)
- return;
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if(getpBlock_dbName(pb) == dbName) {
- pBlockStats(of,pb);
- printpBlock(of,pb);
- fprintf (of, "\n");
- }
- }
-
+ pBlock *pb;
+
+ if(!of || !the_pFile)
+ return;
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ if(getpBlock_dbName(pb) == dbName) {
+ pBlockStats(of,pb);
+ printpBlock(of,pb);
+ fprintf (of, "\n");
+ }
+ }
+
}
void pcode_test(void)
{
-
- DFPRINTF((stderr,"pcode is alive!\n"));
-
- //initMnemonics();
-
- if(the_pFile) {
-
- pBlock *pb;
- FILE *pFile;
- char buffer[100];
-
- /* create the file name */
- strcpy(buffer,dstFileName);
- strcat(buffer,".p");
-
- if( !(pFile = fopen(buffer, "w" ))) {
- werror(E_FILE_OPEN_ERR,buffer);
- exit(1);
- }
-
- fprintf(pFile,"pcode dump\n\n");
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- fprintf(pFile,"\n\tNew pBlock\n\n");
- if(pb->cmemmap)
- fprintf(pFile,"%s",pb->cmemmap->sname);
- else
- fprintf(pFile,"internal pblock");
-
- fprintf(pFile,", dbName =%c\n",getpBlock_dbName(pb));
- printpBlock(pFile,pb);
- }
- }
+
+ DFPRINTF((stderr,"pcode is alive!\n"));
+
+ //initMnemonics();
+
+ if(the_pFile) {
+
+ pBlock *pb;
+ FILE *pFile;
+ char buffer[100];
+
+ /* create the file name */
+ strcpy(buffer,dstFileName);
+ strcat(buffer,".p");
+
+ if( !(pFile = fopen(buffer, "w" ))) {
+ werror(E_FILE_OPEN_ERR,buffer);
+ exit(1);
+ }
+
+ fprintf(pFile,"pcode dump\n\n");
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ fprintf(pFile,"\n\tNew pBlock\n\n");
+ if(pb->cmemmap)
+ fprintf(pFile,"%s",pb->cmemmap->sname);
+ else
+ fprintf(pFile,"internal pblock");
+
+ fprintf(pFile,", dbName =%c\n",getpBlock_dbName(pb));
+ printpBlock(pFile,pb);
+ }
+ }
}
/*-----------------------------------------------------------------*/
/* int RegCond(pCodeOp *pcop) - if pcop points to the STATUS reg- */
static int RegCond(pCodeOp *pcop)
{
-
- if(!pcop)
- return 0;
-
- if (pcop->type == PO_GPR_BIT) {
- char *name = pcop->name;
- if (!name)
- name = PCOR(pcop)->r->name;
-// if (strcmp(name, pc_status.pcop.name) != 0) { <<< This breaks the peep 2 optimisation
- switch(PCORB(pcop)->bit) {
- case PIC_C_BIT:
- return PCC_C;
- case PIC_DC_BIT:
- return PCC_DC;
- case PIC_Z_BIT:
- return PCC_Z;
- }
-// }
- }
-
- return 0;
+
+ if(!pcop)
+ return 0;
+
+ if (pcop->type == PO_GPR_BIT) {
+ char *name = pcop->name;
+ if (!name)
+ name = PCOR(pcop)->r->name;
+ // if (strcmp(name, pc_status.pcop.name) != 0) { <<< This breaks the peep 2 optimisation
+ switch(PCORB(pcop)->bit) {
+ case PIC_C_BIT:
+ return PCC_C;
+ case PIC_DC_BIT:
+ return PCC_DC;
+ case PIC_Z_BIT:
+ return PCC_Z;
+ }
+ // }
+ }
+
+ return 0;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop)
{
- pCodeInstruction *pci ;
-
- if(!mnemonics_initialized)
- pic14initMnemonics();
-
- pci = Safe_calloc(1, sizeof(pCodeInstruction));
-
- if((op>=0) && (op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) {
- memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction));
- pci->pc.id = PCodeID();
- pci->pcop = pcop;
-
- if(pci->inCond & PCC_EXAMINE_PCOP)
- pci->inCond |= RegCond(pcop);
-
- if(pci->outCond & PCC_EXAMINE_PCOP)
- pci->outCond |= RegCond(pcop);
-
- pci->pc.prev = pci->pc.next = NULL;
- return (pCode *)pci;
- }
-
- fprintf(stderr, "pCode mnemonic error %s,%d\n",__FUNCTION__,__LINE__);
- exit(1);
+ pCodeInstruction *pci ;
+
+ if(!mnemonics_initialized)
+ pic14initMnemonics();
- return NULL;
+ pci = Safe_calloc(1, sizeof(pCodeInstruction));
+
+ if((op>=0) && (op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) {
+ memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction));
+ pci->pc.id = PCodeID();
+ pci->pcop = pcop;
+
+ if(pci->inCond & PCC_EXAMINE_PCOP)
+ pci->inCond |= RegCond(pcop);
+
+ if(pci->outCond & PCC_EXAMINE_PCOP)
+ pci->outCond |= RegCond(pcop);
+
+ pci->pc.prev = pci->pc.next = NULL;
+ return (pCode *)pci;
+ }
+
+ fprintf(stderr, "pCode mnemonic error %s,%d\n",__FUNCTION__,__LINE__);
+ exit(1);
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label)
{
+
+ pCodeWild *pcw;
- pCodeWild *pcw;
-
- pcw = Safe_calloc(1,sizeof(pCodeWild));
-
- pcw->pci.pc.type = PC_WILD;
- pcw->pci.pc.prev = pcw->pci.pc.next = NULL;
- pcw->id = PCodeID();
- pcw->pci.from = pcw->pci.to = pcw->pci.label = NULL;
- pcw->pci.pc.pb = NULL;
-
- // pcw->pci.pc.analyze = genericAnalyze;
- pcw->pci.pc.destruct = genericDestruct;
- pcw->pci.pc.print = genericPrint;
-
- pcw->id = pCodeID; // this is the 'n' in %n
- pcw->operand = optional_operand;
- pcw->label = optional_label;
-
- pcw->mustBeBitSkipInst = 0;
- pcw->mustNotBeBitSkipInst = 0;
- pcw->invertBitSkipInst = 0;
-
- return ( (pCode *)pcw);
-
+ pcw = Safe_calloc(1,sizeof(pCodeWild));
+
+ pcw->pci.pc.type = PC_WILD;
+ pcw->pci.pc.prev = pcw->pci.pc.next = NULL;
+ pcw->id = PCodeID();
+ pcw->pci.from = pcw->pci.to = pcw->pci.label = NULL;
+ pcw->pci.pc.pb = NULL;
+
+ // pcw->pci.pc.analyze = genericAnalyze;
+ pcw->pci.pc.destruct = genericDestruct;
+ pcw->pci.pc.print = genericPrint;
+
+ pcw->id = pCodeID; // this is the 'n' in %n
+ pcw->operand = optional_operand;
+ pcw->label = optional_label;
+
+ pcw->mustBeBitSkipInst = 0;
+ pcw->mustNotBeBitSkipInst = 0;
+ pcw->invertBitSkipInst = 0;
+
+ return ( (pCode *)pcw);
+
}
- /*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
/* newPcodeInlineP - create a new pCode from a char string */
/*-----------------------------------------------------------------*/
pCode *newpCodeInlineP(char *cP)
{
+
+ pCodeComment *pcc ;
- pCodeComment *pcc ;
-
- pcc = Safe_calloc(1,sizeof(pCodeComment));
-
- pcc->pc.type = PC_INLINE;
- pcc->pc.prev = pcc->pc.next = NULL;
- pcc->pc.id = PCodeID();
- //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
- pcc->pc.pb = NULL;
-
- // pcc->pc.analyze = genericAnalyze;
- pcc->pc.destruct = genericDestruct;
- pcc->pc.print = genericPrint;
-
- if(cP)
- pcc->comment = Safe_strdup(cP);
- else
- pcc->comment = NULL;
-
- return ( (pCode *)pcc);
-
+ pcc = Safe_calloc(1,sizeof(pCodeComment));
+
+ pcc->pc.type = PC_INLINE;
+ pcc->pc.prev = pcc->pc.next = NULL;
+ pcc->pc.id = PCodeID();
+ //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
+ pcc->pc.pb = NULL;
+
+ // pcc->pc.analyze = genericAnalyze;
+ pcc->pc.destruct = genericDestruct;
+ pcc->pc.print = genericPrint;
+
+ if(cP)
+ pcc->comment = Safe_strdup(cP);
+ else
+ pcc->comment = NULL;
+
+ return ( (pCode *)pcc);
+
}
/*-----------------------------------------------------------------*/
pCode *newpCodeCharP(char *cP)
{
+
+ pCodeComment *pcc ;
- pCodeComment *pcc ;
-
- pcc = Safe_calloc(1,sizeof(pCodeComment));
-
- pcc->pc.type = PC_COMMENT;
- pcc->pc.prev = pcc->pc.next = NULL;
- pcc->pc.id = PCodeID();
- //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
- pcc->pc.pb = NULL;
-
- // pcc->pc.analyze = genericAnalyze;
- pcc->pc.destruct = genericDestruct;
- pcc->pc.print = genericPrint;
-
- if(cP)
- pcc->comment = Safe_strdup(cP);
- else
- pcc->comment = NULL;
-
- return ( (pCode *)pcc);
-
+ pcc = Safe_calloc(1,sizeof(pCodeComment));
+
+ pcc->pc.type = PC_COMMENT;
+ pcc->pc.prev = pcc->pc.next = NULL;
+ pcc->pc.id = PCodeID();
+ //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
+ pcc->pc.pb = NULL;
+
+ // pcc->pc.analyze = genericAnalyze;
+ pcc->pc.destruct = genericDestruct;
+ pcc->pc.print = genericPrint;
+
+ if(cP)
+ pcc->comment = Safe_strdup(cP);
+ else
+ pcc->comment = NULL;
+
+ return ( (pCode *)pcc);
+
}
/*-----------------------------------------------------------------*/
pCode *newpCodeFunction(char *mod,char *f,int isPublic)
{
- pCodeFunction *pcf;
-
- pcf = Safe_calloc(1,sizeof(pCodeFunction));
- //_ALLOC(pcf,sizeof(pCodeFunction));
-
- pcf->pc.type = PC_FUNCTION;
- pcf->pc.prev = pcf->pc.next = NULL;
- pcf->pc.id = PCodeID();
- //pcf->pc.from = pcf->pc.to = pcf->pc.label = NULL;
- pcf->pc.pb = NULL;
-
- // pcf->pc.analyze = genericAnalyze;
- pcf->pc.destruct = genericDestruct;
- pcf->pc.print = pCodePrintFunction;
-
- pcf->ncalled = 0;
-
- if(mod) {
- //_ALLOC_ATOMIC(pcf->modname,strlen(mod)+1);
- pcf->modname = Safe_calloc(1,strlen(mod)+1);
- strcpy(pcf->modname,mod);
- } else
- pcf->modname = NULL;
-
- if(f) {
- //_ALLOC_ATOMIC(pcf->fname,strlen(f)+1);
- pcf->fname = Safe_calloc(1,strlen(f)+1);
- strcpy(pcf->fname,f);
- } else
- pcf->fname = NULL;
-
- pcf->isPublic = (unsigned)isPublic;
-
- return ( (pCode *)pcf);
-
+ pCodeFunction *pcf;
+
+ pcf = Safe_calloc(1,sizeof(pCodeFunction));
+ //_ALLOC(pcf,sizeof(pCodeFunction));
+
+ pcf->pc.type = PC_FUNCTION;
+ pcf->pc.prev = pcf->pc.next = NULL;
+ pcf->pc.id = PCodeID();
+ //pcf->pc.from = pcf->pc.to = pcf->pc.label = NULL;
+ pcf->pc.pb = NULL;
+
+ // pcf->pc.analyze = genericAnalyze;
+ pcf->pc.destruct = genericDestruct;
+ pcf->pc.print = pCodePrintFunction;
+
+ pcf->ncalled = 0;
+
+ if(mod) {
+ //_ALLOC_ATOMIC(pcf->modname,strlen(mod)+1);
+ pcf->modname = Safe_calloc(1,strlen(mod)+1);
+ strcpy(pcf->modname,mod);
+ } else
+ pcf->modname = NULL;
+
+ if(f) {
+ //_ALLOC_ATOMIC(pcf->fname,strlen(f)+1);
+ pcf->fname = Safe_calloc(1,strlen(f)+1);
+ strcpy(pcf->fname,f);
+ } else
+ pcf->fname = NULL;
+
+ pcf->isPublic = (unsigned)isPublic;
+
+ return ( (pCode *)pcf);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void destructpCodeFlow(pCode *pc)
{
- if(!pc || !isPCFL(pc))
- return;
-
-/*
- if(PCFL(pc)->from)
- if(PCFL(pc)->to)
-*/
- unlinkpCode(pc);
-
- deleteSet(&PCFL(pc)->registers);
- deleteSet(&PCFL(pc)->from);
- deleteSet(&PCFL(pc)->to);
- free(pc);
-
+ if(!pc || !isPCFL(pc))
+ return;
+
+ /*
+ if(PCFL(pc)->from)
+ if(PCFL(pc)->to)
+ */
+ unlinkpCode(pc);
+
+ deleteSet(&PCFL(pc)->registers);
+ deleteSet(&PCFL(pc)->from);
+ deleteSet(&PCFL(pc)->to);
+ free(pc);
+
}
pCode *newpCodeFlow(void )
{
- pCodeFlow *pcflow;
-
- //_ALLOC(pcflow,sizeof(pCodeFlow));
- pcflow = Safe_calloc(1,sizeof(pCodeFlow));
-
- pcflow->pc.type = PC_FLOW;
- pcflow->pc.prev = pcflow->pc.next = NULL;
- pcflow->pc.pb = NULL;
-
- // pcflow->pc.analyze = genericAnalyze;
- pcflow->pc.destruct = destructpCodeFlow;
- pcflow->pc.print = genericPrint;
-
- pcflow->pc.seq = GpcFlowSeq++;
-
- pcflow->from = pcflow->to = NULL;
-
- pcflow->inCond = PCC_NONE;
- pcflow->outCond = PCC_NONE;
-
- pcflow->firstBank = 'U'; /* Undetermined */
- pcflow->lastBank = 'U'; /* Undetermined */
-
- pcflow->FromConflicts = 0;
- pcflow->ToConflicts = 0;
-
- pcflow->end = NULL;
-
- pcflow->registers = newSet();
-
- return ( (pCode *)pcflow);
-
+ pCodeFlow *pcflow;
+
+ //_ALLOC(pcflow,sizeof(pCodeFlow));
+ pcflow = Safe_calloc(1,sizeof(pCodeFlow));
+
+ pcflow->pc.type = PC_FLOW;
+ pcflow->pc.prev = pcflow->pc.next = NULL;
+ pcflow->pc.pb = NULL;
+
+ // pcflow->pc.analyze = genericAnalyze;
+ pcflow->pc.destruct = destructpCodeFlow;
+ pcflow->pc.print = genericPrint;
+
+ pcflow->pc.seq = GpcFlowSeq++;
+
+ pcflow->from = pcflow->to = NULL;
+
+ pcflow->inCond = PCC_NONE;
+ pcflow->outCond = PCC_NONE;
+
+ pcflow->firstBank = 'U'; /* Undetermined */
+ pcflow->lastBank = 'U'; /* Undetermined */
+
+ pcflow->FromConflicts = 0;
+ pcflow->ToConflicts = 0;
+
+ pcflow->end = NULL;
+
+ pcflow->registers = newSet();
+
+ return ( (pCode *)pcflow);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow)
{
- pCodeFlowLink *pcflowLink;
-
- pcflowLink = Safe_calloc(1,sizeof(pCodeFlowLink));
-
- pcflowLink->pcflow = pcflow;
- pcflowLink->bank_conflict = 0;
-
- return pcflowLink;
-}
+ pCodeFlowLink *pcflowLink;
+
+ pcflowLink = Safe_calloc(1,sizeof(pCodeFlowLink));
+
+ pcflowLink->pcflow = pcflow;
+ pcflowLink->bank_conflict = 0;
+
+ return pcflowLink;
+}
/*-----------------------------------------------------------------*/
/* newpCodeCSource - create a new pCode Source Symbol */
pCode *newpCodeCSource(int ln, char *f, char *l)
{
+
+ pCodeCSource *pccs;
- pCodeCSource *pccs;
-
- pccs = Safe_calloc(1,sizeof(pCodeCSource));
-
- pccs->pc.type = PC_CSOURCE;
- pccs->pc.prev = pccs->pc.next = NULL;
- pccs->pc.id = PCodeID();
- pccs->pc.pb = NULL;
-
- pccs->pc.destruct = genericDestruct;
- pccs->pc.print = genericPrint;
-
- pccs->line_number = ln;
- if(l)
- pccs->line = Safe_strdup(l);
- else
- pccs->line = NULL;
-
- if(f)
- pccs->file_name = Safe_strdup(f);
- else
- pccs->file_name = NULL;
-
- return ( (pCode *)pccs);
-
+ pccs = Safe_calloc(1,sizeof(pCodeCSource));
+
+ pccs->pc.type = PC_CSOURCE;
+ pccs->pc.prev = pccs->pc.next = NULL;
+ pccs->pc.id = PCodeID();
+ pccs->pc.pb = NULL;
+
+ pccs->pc.destruct = genericDestruct;
+ pccs->pc.print = genericPrint;
+
+ pccs->line_number = ln;
+ if(l)
+ pccs->line = Safe_strdup(l);
+ else
+ pccs->line = NULL;
+
+ if(f)
+ pccs->file_name = Safe_strdup(f);
+ else
+ pccs->file_name = NULL;
+
+ return ( (pCode *)pccs);
+
}
/*-----------------------------------------------------------------*/
/* pCodeLabelDestruct - free memory used by a label. */
/*-----------------------------------------------------------------*/
static void pCodeLabelDestruct(pCode *pc)
{
-
- if(!pc)
- return;
-
- if((pc->type == PC_LABEL) && PCL(pc)->label)
- free(PCL(pc)->label);
-
- free(pc);
-
+
+ if(!pc)
+ return;
+
+ if((pc->type == PC_LABEL) && PCL(pc)->label)
+ free(PCL(pc)->label);
+
+ free(pc);
+
}
pCode *newpCodeLabel(char *name, int key)
{
+
+ char *s = buffer;
+ pCodeLabel *pcl;
- char *s = buffer;
- pCodeLabel *pcl;
-
- pcl = Safe_calloc(1,sizeof(pCodeLabel) );
-
- pcl->pc.type = PC_LABEL;
- pcl->pc.prev = pcl->pc.next = NULL;
- pcl->pc.id = PCodeID();
- //pcl->pc.from = pcl->pc.to = pcl->pc.label = NULL;
- pcl->pc.pb = NULL;
-
- // pcl->pc.analyze = genericAnalyze;
- pcl->pc.destruct = pCodeLabelDestruct;
- pcl->pc.print = pCodePrintLabel;
-
- pcl->key = key;
-
- pcl->label = NULL;
- if(key>0) {
- sprintf(s,"_%05d_DS_",key);
- } else
- s = name;
-
- if(s)
- pcl->label = Safe_strdup(s);
-
- //fprintf(stderr,"newpCodeLabel: key=%d, name=%s\n",key, ((s)?s:""));
- return ( (pCode *)pcl);
-
+ pcl = Safe_calloc(1,sizeof(pCodeLabel) );
+
+ pcl->pc.type = PC_LABEL;
+ pcl->pc.prev = pcl->pc.next = NULL;
+ pcl->pc.id = PCodeID();
+ //pcl->pc.from = pcl->pc.to = pcl->pc.label = NULL;
+ pcl->pc.pb = NULL;
+
+ // pcl->pc.analyze = genericAnalyze;
+ pcl->pc.destruct = pCodeLabelDestruct;
+ pcl->pc.print = pCodePrintLabel;
+
+ pcl->key = key;
+
+ pcl->label = NULL;
+ if(key>0) {
+ sprintf(s,"_%05d_DS_",key);
+ } else
+ s = name;
+
+ if(s)
+ pcl->label = Safe_strdup(s);
+
+ //fprintf(stderr,"newpCodeLabel: key=%d, name=%s\n",key, ((s)?s:""));
+ return ( (pCode *)pcl);
+
}
/*-----------------------------------------------------------------*/
pBlock *newpBlock(void)
{
-
- pBlock *PpB;
-
- PpB = Safe_calloc(1,sizeof(pBlock) );
- PpB->next = PpB->prev = NULL;
-
- PpB->function_entries = PpB->function_exits = PpB->function_calls = NULL;
- PpB->tregisters = NULL;
- PpB->visited = 0;
- PpB->FlowTree = NULL;
-
- return PpB;
-
+
+ pBlock *PpB;
+
+ PpB = Safe_calloc(1,sizeof(pBlock) );
+ PpB->next = PpB->prev = NULL;
+
+ PpB->function_entries = PpB->function_exits = PpB->function_calls = NULL;
+ PpB->tregisters = NULL;
+ PpB->visited = 0;
+ PpB->FlowTree = NULL;
+
+ return PpB;
+
}
/*-----------------------------------------------------------------*/
/* newpCodeChain - create a new chain of pCodes */
/*-----------------------------------------------------------------*
- *
- * This function will create a new pBlock and the pointer to the
- * pCode that is passed in will be the first pCode in the block.
- *-----------------------------------------------------------------*/
+*
+* This function will create a new pBlock and the pointer to the
+* pCode that is passed in will be the first pCode in the block.
+*-----------------------------------------------------------------*/
pBlock *newpCodeChain(memmap *cm,char c, pCode *pc)
{
-
- pBlock *pB = newpBlock();
-
- pB->pcHead = pB->pcTail = pc;
- pB->cmemmap = cm;
- pB->dbName = c;
-
- return pB;
+
+ pBlock *pB = newpBlock();
+
+ pB->pcHead = pB->pcTail = pc;
+ pB->cmemmap = cm;
+ pB->dbName = c;
+
+ return pB;
}
/*-----------------------------------------------------------------*/
pCodeOp *newpCodeOpLabel(char *name, int key)
{
- char *s=NULL;
- static int label_key=-1;
-
- pCodeOp *pcop;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpLabel) );
- pcop->type = PO_LABEL;
-
- pcop->name = NULL;
-
- if(key>0)
- sprintf(s=buffer,"_%05d_DS_",key);
- else
- s = name, key = label_key--;
-
- PCOLAB(pcop)->offset = 0;
- if(s)
- pcop->name = Safe_strdup(s);
-
- ((pCodeOpLabel *)pcop)->key = key;
-
- //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
- return pcop;
+ char *s=NULL;
+ static int label_key=-1;
+
+ pCodeOp *pcop;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpLabel) );
+ pcop->type = PO_LABEL;
+
+ pcop->name = NULL;
+
+ if(key>0)
+ sprintf(s=buffer,"_%05d_DS_",key);
+ else
+ s = name, key = label_key--;
+
+ PCOLAB(pcop)->offset = 0;
+ if(s)
+ pcop->name = Safe_strdup(s);
+
+ ((pCodeOpLabel *)pcop)->key = key;
+
+ //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *newpCodeOpLit(int lit)
{
- char *s = buffer;
- pCodeOp *pcop;
-
-
- pcop = Safe_calloc(1,sizeof(pCodeOpLit) );
- pcop->type = PO_LITERAL;
-
- pcop->name = NULL;
- if(lit>=0) {
- sprintf(s,"0x%02x",lit);
- if(s)
- pcop->name = Safe_strdup(s);
- }
-
- ((pCodeOpLit *)pcop)->lit = lit;
-
- return pcop;
+ char *s = buffer;
+ pCodeOp *pcop;
+
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpLit) );
+ pcop->type = PO_LITERAL;
+
+ pcop->name = NULL;
+ if(lit>=0) {
+ sprintf(s,"0x%02x",lit);
+ if(s)
+ pcop->name = Safe_strdup(s);
+ }
+
+ ((pCodeOpLit *)pcop)->lit = lit;
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space, int is_func)
{
- pCodeOp *pcop;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpImmd) );
- pcop->type = PO_IMMEDIATE;
- if(name) {
- regs *r = NULL;
- pcop->name = Safe_strdup(name);
-
- if(!is_func)
- r = dirregWithName(name);
-
- PCOI(pcop)->r = r;
- if(r) {
- //fprintf(stderr, " newpCodeOpImmd reg %s exists\n",name);
- PCOI(pcop)->rIdx = r->rIdx;
- } else {
- //fprintf(stderr, " newpCodeOpImmd reg %s doesn't exist\n",name);
- PCOI(pcop)->rIdx = -1;
- }
- //fprintf(stderr,"%s %s %d\n",__FUNCTION__,name,offset);
- } else {
- pcop->name = NULL;
- }
-
- PCOI(pcop)->index = index;
- PCOI(pcop)->offset = offset;
- PCOI(pcop)->_const = code_space;
- PCOI(pcop)->_function = is_func;
-
- return pcop;
+ pCodeOp *pcop;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpImmd) );
+ pcop->type = PO_IMMEDIATE;
+ if(name) {
+ regs *r = NULL;
+ pcop->name = Safe_strdup(name);
+
+ if(!is_func)
+ r = dirregWithName(name);
+
+ PCOI(pcop)->r = r;
+ if(r) {
+ //fprintf(stderr, " newpCodeOpImmd reg %s exists\n",name);
+ PCOI(pcop)->rIdx = r->rIdx;
+ } else {
+ //fprintf(stderr, " newpCodeOpImmd reg %s doesn't exist\n",name);
+ PCOI(pcop)->rIdx = -1;
+ }
+ //fprintf(stderr,"%s %s %d\n",__FUNCTION__,name,offset);
+ } else {
+ pcop->name = NULL;
+ }
+
+ PCOI(pcop)->index = index;
+ PCOI(pcop)->offset = offset;
+ PCOI(pcop)->_const = code_space;
+ PCOI(pcop)->_function = is_func;
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *newpCodeOpWild(int id, pCodeWildBlock *pcwb, pCodeOp *subtype)
{
- char *s = buffer;
- pCodeOp *pcop;
-
-
- if(!pcwb || !subtype) {
- fprintf(stderr, "Wild opcode declaration error: %s-%d\n",__FILE__,__LINE__);
- exit(1);
- }
-
- pcop = Safe_calloc(1,sizeof(pCodeOpWild));
- pcop->type = PO_WILD;
- sprintf(s,"%%%d",id);
- pcop->name = Safe_strdup(s);
-
- PCOW(pcop)->id = id;
- PCOW(pcop)->pcwb = pcwb;
- PCOW(pcop)->subtype = subtype;
- PCOW(pcop)->matched = NULL;
-
- return pcop;
+ char *s = buffer;
+ pCodeOp *pcop;
+
+
+ if(!pcwb || !subtype) {
+ fprintf(stderr, "Wild opcode declaration error: %s-%d\n",__FILE__,__LINE__);
+ exit(1);
+ }
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpWild));
+ pcop->type = PO_WILD;
+ sprintf(s,"%%%d",id);
+ pcop->name = Safe_strdup(s);
+
+ PCOW(pcop)->id = id;
+ PCOW(pcop)->pcwb = pcwb;
+ PCOW(pcop)->subtype = subtype;
+ PCOW(pcop)->matched = NULL;
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/* Find a symbol with matching name */
/*-----------------------------------------------------------------*/
static symbol *symFindWithName(memmap * map, const char *name)
{
- symbol *sym;
-
- for (sym = setFirstItem(map->syms); sym; sym = setNextItem (map->syms)) {
- if (sym->rname && (strcmp(sym->rname,name)==0))
- return sym;
- }
- return 0;
+ symbol *sym;
+
+ for (sym = setFirstItem(map->syms); sym; sym = setNextItem (map->syms)) {
+ if (sym->rname && (strcmp(sym->rname,name)==0))
+ return sym;
+ }
+ return 0;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *newpCodeOpBit(char *name, int ibit, int inBitSpace)
{
- pCodeOp *pcop;
- struct regs *r = 0;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) );
- pcop->type = PO_GPR_BIT;
-
- PCORB(pcop)->bit = ibit;
- PCORB(pcop)->inBitSpace = inBitSpace;
-
- if (name) r = regFindWithName(name);
- if (!r) {
- // Register has not been allocated - check for symbol information
- symbol *sym;
- sym = symFindWithName(bit, name);
- if (!sym) sym = symFindWithName(sfrbit, name);
- if (!sym) sym = symFindWithName(sfr, name);
- if (sym) {
- r = allocNewDirReg(sym->etype,name);
- }
- }
- if (r) {
- pcop->name = NULL;
- PCOR(pcop)->r = r;
- PCOR(pcop)->rIdx = r->rIdx;
- } else {
- pcop->name = Safe_strdup(name);
- PCOR(pcop)->r = NULL;
- PCOR(pcop)->rIdx = 0;
- }
- return pcop;
+ pCodeOp *pcop;
+ struct regs *r = 0;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) );
+ pcop->type = PO_GPR_BIT;
+
+ PCORB(pcop)->bit = ibit;
+ PCORB(pcop)->inBitSpace = inBitSpace;
+
+ if (name) r = regFindWithName(name);
+ if (!r) {
+ // Register has not been allocated - check for symbol information
+ symbol *sym;
+ sym = symFindWithName(bit, name);
+ if (!sym) sym = symFindWithName(sfrbit, name);
+ if (!sym) sym = symFindWithName(sfr, name);
+ if (sym) {
+ r = allocNewDirReg(sym->etype,name);
+ }
+ }
+ if (r) {
+ pcop->name = NULL;
+ PCOR(pcop)->r = r;
+ PCOR(pcop)->rIdx = r->rIdx;
+ } else {
+ pcop->name = Safe_strdup(name);
+ PCOR(pcop)->r = NULL;
+ PCOR(pcop)->rIdx = 0;
+ }
+ return pcop;
}
/*-----------------------------------------------------------------*
- * pCodeOp *newpCodeOpReg(int rIdx) - allocate a new register
- *
- * If rIdx >=0 then a specific register from the set of registers
- * will be selected. If rIdx <0, then a new register will be searched
- * for.
- *-----------------------------------------------------------------*/
+* pCodeOp *newpCodeOpReg(int rIdx) - allocate a new register
+*
+* If rIdx >=0 then a specific register from the set of registers
+* will be selected. If rIdx <0, then a new register will be searched
+* for.
+*-----------------------------------------------------------------*/
pCodeOp *newpCodeOpReg(int rIdx)
{
- pCodeOp *pcop;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
-
- pcop->name = NULL;
-
- if(rIdx >= 0) {
- PCOR(pcop)->rIdx = rIdx;
- PCOR(pcop)->r = pic14_regWithIdx(rIdx);
- } else {
- PCOR(pcop)->r = pic14_findFreeReg(REG_GPR);
-
- if(PCOR(pcop)->r)
- PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
- }
-
- if(PCOR(pcop)->r)
- pcop->type = PCOR(pcop)->r->pc_type;
-
- return pcop;
+ pCodeOp *pcop;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+
+ pcop->name = NULL;
+
+ if(rIdx >= 0) {
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+ } else {
+ PCOR(pcop)->r = pic14_findFreeReg(REG_GPR);
+
+ if(PCOR(pcop)->r)
+ PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
+ }
+
+ if(PCOR(pcop)->r)
+ pcop->type = PCOR(pcop)->r->pc_type;
+
+ return pcop;
}
pCodeOp *newpCodeOpRegFromStr(char *name)
{
- pCodeOp *pcop;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcop)->r = allocRegByName(name, 1);
- PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
- pcop->type = PCOR(pcop)->r->pc_type;
- pcop->name = PCOR(pcop)->r->name;
-
- return pcop;
+ pCodeOp *pcop;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcop)->r = allocRegByName(name, 1);
+ PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
+ pcop->type = PCOR(pcop)->r->pc_type;
+ pcop->name = PCOR(pcop)->r->name;
+
+ return pcop;
}
pCodeOp *newpCodeOpStr(char *name)
{
- pCodeOp *pcop;
-
- pcop = Safe_calloc(1,sizeof(pCodeOpStr));
- pcop->type = PO_STR;
- pcop->name = Safe_strdup(name);
-
- PCOS(pcop)->isPublic = 0;
-
- return pcop;
+ pCodeOp *pcop;
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpStr));
+ pcop->type = PO_STR;
+ pcop->name = Safe_strdup(name);
+
+ PCOS(pcop)->isPublic = 0;
+
+ return pcop;
}
pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type)
{
- pCodeOp *pcop;
-
- switch(type) {
- case PO_BIT:
- case PO_GPR_BIT:
- pcop = newpCodeOpBit(name, -1,0);
- break;
-
- case PO_LITERAL:
- pcop = newpCodeOpLit(-1);
- break;
-
- case PO_LABEL:
- pcop = newpCodeOpLabel(NULL,-1);
- break;
-
- case PO_GPR_TEMP:
- pcop = newpCodeOpReg(-1);
- break;
-
- case PO_GPR_POINTER:
- case PO_GPR_REGISTER:
- if(name)
- pcop = newpCodeOpRegFromStr(name);
- else
- pcop = newpCodeOpReg(-1);
- break;
-
- case PO_STR:
- pcop = newpCodeOpStr(name);
- break;
-
- default:
- pcop = Safe_calloc(1,sizeof(pCodeOp) );
- pcop->type = type;
- if(name)
- pcop->name = Safe_strdup(name);
- else
- pcop->name = NULL;
- }
-
- return pcop;
+ pCodeOp *pcop;
+
+ switch(type) {
+ case PO_BIT:
+ case PO_GPR_BIT:
+ pcop = newpCodeOpBit(name, -1,0);
+ break;
+
+ case PO_LITERAL:
+ pcop = newpCodeOpLit(-1);
+ break;
+
+ case PO_LABEL:
+ pcop = newpCodeOpLabel(NULL,-1);
+ break;
+
+ case PO_GPR_TEMP:
+ pcop = newpCodeOpReg(-1);
+ break;
+
+ case PO_GPR_POINTER:
+ case PO_GPR_REGISTER:
+ if(name)
+ pcop = newpCodeOpRegFromStr(name);
+ else
+ pcop = newpCodeOpReg(-1);
+ break;
+
+ case PO_STR:
+ pcop = newpCodeOpStr(name);
+ break;
+
+ default:
+ pcop = Safe_calloc(1,sizeof(pCodeOp) );
+ pcop->type = type;
+ if(name)
+ pcop->name = Safe_strdup(name);
+ else
+ pcop->name = NULL;
+ }
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pCodeConstString(char *name, char *value)
{
- pBlock *pb;
-
- // fprintf(stderr, " %s %s %s\n",__FUNCTION__,name,value);
-
- if(!name || !value)
- return;
-
- pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
-
- addpBlock(pb);
-
- sprintf(buffer,"; %s = %s",name,value);
-
- addpCode2pBlock(pb,newpCodeCharP(buffer));
- addpCode2pBlock(pb,newpCodeLabel(name,-1));
-
- do {
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(*value)));
- }while (*value++);
-
-
+ pBlock *pb;
+
+ // fprintf(stderr, " %s %s %s\n",__FUNCTION__,name,value);
+
+ if(!name || !value)
+ return;
+
+ pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
+
+ addpBlock(pb);
+
+ sprintf(buffer,"; %s = %s",name,value);
+
+ addpCode2pBlock(pb,newpCodeCharP(buffer));
+ addpCode2pBlock(pb,newpCodeLabel(name,-1));
+
+ do {
+ addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(*value)));
+ }while (*value++);
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pCodeReadCodeTable(void)
{
- pBlock *pb;
-
- fprintf(stderr, " %s\n",__FUNCTION__);
-
- pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
-
- addpBlock(pb);
-
- addpCode2pBlock(pb,newpCodeCharP("; ReadCodeTable - built in function"));
- addpCode2pBlock(pb,newpCodeCharP("; Inputs: temp1,temp2 = code pointer"));
- addpCode2pBlock(pb,newpCodeCharP("; Outpus: W (from RETLW at temp2:temp1)"));
- addpCode2pBlock(pb,newpCodeLabel("ReadCodeTable:",-1));
-
- addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp2")));
- addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCLATH")));
- addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp1")));
- addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCL")));
-
-
+ pBlock *pb;
+
+ fprintf(stderr, " %s\n",__FUNCTION__);
+
+ pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
+
+ addpBlock(pb);
+
+ addpCode2pBlock(pb,newpCodeCharP("; ReadCodeTable - built in function"));
+ addpCode2pBlock(pb,newpCodeCharP("; Inputs: temp1,temp2 = code pointer"));
+ addpCode2pBlock(pb,newpCodeCharP("; Outpus: W (from RETLW at temp2:temp1)"));
+ addpCode2pBlock(pb,newpCodeLabel("ReadCodeTable:",-1));
+
+ addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp2")));
+ addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCLATH")));
+ addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp1")));
+ addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCL")));
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void addpCode2pBlock(pBlock *pb, pCode *pc)
{
-
- if(!pc)
- return;
-
- if(!pb->pcHead) {
- /* If this is the first pcode to be added to a block that
- * was initialized with a NULL pcode, then go ahead and
- * make this pcode the head and tail */
- pb->pcHead = pb->pcTail = pc;
- } else {
- // if(pb->pcTail)
- pb->pcTail->next = pc;
-
- pc->prev = pb->pcTail;
- pc->pb = pb;
-
- pb->pcTail = pc;
- }
+
+ if(!pc)
+ return;
+
+ if(!pb->pcHead) {
+ /* If this is the first pcode to be added to a block that
+ * was initialized with a NULL pcode, then go ahead and
+ * make this pcode the head and tail */
+ pb->pcHead = pb->pcTail = pc;
+ } else {
+ // if(pb->pcTail)
+ pb->pcTail->next = pc;
+
+ pc->prev = pb->pcTail;
+ pc->pb = pb;
+
+ pb->pcTail = pc;
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void addpBlock(pBlock *pb)
{
- // fprintf(stderr," Adding pBlock: dbName =%c\n",getpBlock_dbName(pb));
-
- if(!the_pFile) {
- /* First time called, we'll pass through here. */
- //_ALLOC(the_pFile,sizeof(pFile));
- the_pFile = Safe_calloc(1,sizeof(pFile));
- the_pFile->pbHead = the_pFile->pbTail = pb;
- the_pFile->functions = NULL;
- return;
- }
-
- the_pFile->pbTail->next = pb;
- pb->prev = the_pFile->pbTail;
- pb->next = NULL;
- the_pFile->pbTail = pb;
+ // fprintf(stderr," Adding pBlock: dbName =%c\n",getpBlock_dbName(pb));
+
+ if(!the_pFile) {
+ /* First time called, we'll pass through here. */
+ //_ALLOC(the_pFile,sizeof(pFile));
+ the_pFile = Safe_calloc(1,sizeof(pFile));
+ the_pFile->pbHead = the_pFile->pbTail = pb;
+ the_pFile->functions = NULL;
+ return;
+ }
+
+ the_pFile->pbTail->next = pb;
+ pb->prev = the_pFile->pbTail;
+ pb->next = NULL;
+ the_pFile->pbTail = pb;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void removepBlock(pBlock *pb)
{
- pBlock *pbs;
-
- if(!the_pFile)
- return;
-
-
- //fprintf(stderr," Removing pBlock: dbName =%c\n",getpBlock_dbName(pb));
-
- for(pbs = the_pFile->pbHead; pbs; pbs = pbs->next) {
- if(pbs == pb) {
-
- if(pbs == the_pFile->pbHead)
- the_pFile->pbHead = pbs->next;
-
- if (pbs == the_pFile->pbTail)
- the_pFile->pbTail = pbs->prev;
-
- if(pbs->next)
- pbs->next->prev = pbs->prev;
-
- if(pbs->prev)
- pbs->prev->next = pbs->next;
-
- return;
-
- }
- }
-
- fprintf(stderr, "Warning: call to %s:%s didn't find pBlock\n",__FILE__,__FUNCTION__);
-
+ pBlock *pbs;
+
+ if(!the_pFile)
+ return;
+
+
+ //fprintf(stderr," Removing pBlock: dbName =%c\n",getpBlock_dbName(pb));
+
+ for(pbs = the_pFile->pbHead; pbs; pbs = pbs->next) {
+ if(pbs == pb) {
+
+ if(pbs == the_pFile->pbHead)
+ the_pFile->pbHead = pbs->next;
+
+ if (pbs == the_pFile->pbTail)
+ the_pFile->pbTail = pbs->prev;
+
+ if(pbs->next)
+ pbs->next->prev = pbs->prev;
+
+ if(pbs->prev)
+ pbs->prev->next = pbs->next;
+
+ return;
+
+ }
+ }
+
+ fprintf(stderr, "Warning: call to %s:%s didn't find pBlock\n",__FILE__,__FUNCTION__);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void printpCode(FILE *of, pCode *pc)
{
-
- if(!pc || !of)
- return;
-
- if(pc->print) {
- pc->print(of,pc);
- return;
- }
-
- fprintf(of,"warning - unable to print pCode\n");
+
+ if(!pc || !of)
+ return;
+
+ if(pc->print) {
+ pc->print(of,pc);
+ return;
+ }
+
+ fprintf(of,"warning - unable to print pCode\n");
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void printpBlock(FILE *of, pBlock *pb)
{
- pCode *pc;
-
- if(!pb)
- return;
-
- if(!of)
- of = stderr;
-
- for(pc = pb->pcHead; pc; pc = pc->next)
- printpCode(of,pc);
-
+ pCode *pc;
+
+ if(!pb)
+ return;
+
+ if(!of)
+ of = stderr;
+
+ for(pc = pb->pcHead; pc; pc = pc->next)
+ printpCode(of,pc);
+
}
/*-----------------------------------------------------------------*/
void unlinkpCode(pCode *pc)
{
-
-
- if(pc) {
+
+
+ if(pc) {
#ifdef PCODE_DEBUG
- fprintf(stderr,"Unlinking: ");
- printpCode(stderr, pc);
+ fprintf(stderr,"Unlinking: ");
+ printpCode(stderr, pc);
#endif
- if(pc->prev)
- pc->prev->next = pc->next;
- if(pc->next)
- pc->next->prev = pc->prev;
-
- pc->prev = pc->next = NULL;
- }
+ if(pc->prev)
+ pc->prev->next = pc->next;
+ if(pc->next)
+ pc->next->prev = pc->prev;
+
+ pc->prev = pc->next = NULL;
+ }
}
/*-----------------------------------------------------------------*/
static void genericDestruct(pCode *pc)
{
-
- unlinkpCode(pc);
-
- if(isPCI(pc)) {
- /* For instructions, tell the register (if there's one used)
- * that it's no longer needed */
- regs *reg = getRegFromInstruction(pc);
- if(reg)
- deleteSetItem (&(reg->reglives.usedpCodes),pc);
- }
-
- /* Instead of deleting the memory used by this pCode, mark
- * the object as bad so that if there's a pointer to this pCode
- * dangling around somewhere then (hopefully) when the type is
- * checked we'll catch it.
- */
-
- pc->type = PC_BAD;
-
- addpCode2pBlock(pb_dead_pcodes, pc);
-
- //free(pc);
-
+
+ unlinkpCode(pc);
+
+ if(isPCI(pc)) {
+ /* For instructions, tell the register (if there's one used)
+ * that it's no longer needed */
+ regs *reg = getRegFromInstruction(pc);
+ if(reg)
+ deleteSetItem (&(reg->reglives.usedpCodes),pc);
+ }
+
+ /* Instead of deleting the memory used by this pCode, mark
+ * the object as bad so that if there's a pointer to this pCode
+ * dangling around somewhere then (hopefully) when the type is
+ * checked we'll catch it.
+ */
+
+ pc->type = PC_BAD;
+
+ addpCode2pBlock(pb_dead_pcodes, pc);
+
+ //free(pc);
+
}
/* Copies the pCodeInstruction flow pointer from source pCode */
/*-----------------------------------------------------------------*/
static void CopyFlow(pCodeInstruction *pcd, pCode *pcs) {
- pCode *p;
- pCodeFlow *pcflow = 0;
- for (p=pcs; p; p=p->prev) {
- if (isPCI(p)) {
- pcflow = PCI(p)->pcflow;
- break;
- }
- if (isPCF(p)) {
- pcflow = (pCodeFlow*)p;
- break;
- }
- }
- PCI(pcd)->pcflow = pcflow;
+ pCode *p;
+ pCodeFlow *pcflow = 0;
+ for (p=pcs; p; p=p->prev) {
+ if (isPCI(p)) {
+ pcflow = PCI(p)->pcflow;
+ break;
+ }
+ if (isPCF(p)) {
+ pcflow = (pCodeFlow*)p;
+ break;
+ }
+ }
+ PCI(pcd)->pcflow = pcflow;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pCodeInsertAfter(pCode *pc1, pCode *pc2)
{
-
- if(!pc1 || !pc2)
- return;
-
- pc2->next = pc1->next;
- if(pc1->next)
- pc1->next->prev = pc2;
-
- pc2->pb = pc1->pb;
- pc2->prev = pc1;
- pc1->next = pc2;
-
- /* If this is an instrution type propogate the flow */
- if (isPCI(pc2))
- CopyFlow(PCI(pc2),pc1);
+
+ if(!pc1 || !pc2)
+ return;
+
+ pc2->next = pc1->next;
+ if(pc1->next)
+ pc1->next->prev = pc2;
+
+ pc2->pb = pc1->pb;
+ pc2->prev = pc1;
+ pc1->next = pc2;
+
+ /* If this is an instrution type propogate the flow */
+ if (isPCI(pc2))
+ CopyFlow(PCI(pc2),pc1);
}
/*------------------------------------------------------------------*/
/*------------------------------------------------------------------*/
void pCodeInsertBefore(pCode *pc1, pCode *pc2)
{
-
- if(!pc1 || !pc2)
- return;
-
- pc2->prev = pc1->prev;
- if(pc1->prev)
- pc1->prev->next = pc2;
-
- pc2->pb = pc1->pb;
- pc2->next = pc1;
- pc1->prev = pc2;
-
- /* If this is an instrution type propogate the flow */
- if (isPCI(pc2))
- CopyFlow(PCI(pc2),pc1);
+
+ if(!pc1 || !pc2)
+ return;
+
+ pc2->prev = pc1->prev;
+ if(pc1->prev)
+ pc1->prev->next = pc2;
+
+ pc2->pb = pc1->pb;
+ pc2->next = pc1;
+ pc1->prev = pc2;
+
+ /* If this is an instrution type propogate the flow */
+ if (isPCI(pc2))
+ CopyFlow(PCI(pc2),pc1);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *pCodeOpCopy(pCodeOp *pcop)
{
- pCodeOp *pcopnew=NULL;
-
- if(!pcop)
- return NULL;
-
- switch(pcop->type) {
- case PO_CRY:
- case PO_BIT:
- //DFPRINTF((stderr,"pCodeOpCopy bit\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpRegBit) );
- PCORB(pcopnew)->bit = PCORB(pcop)->bit;
- PCORB(pcopnew)->inBitSpace = PCORB(pcop)->inBitSpace;
-
- break;
-
- case PO_WILD:
- /* Here we expand the wild card into the appropriate type: */
- /* By recursively calling pCodeOpCopy */
- //DFPRINTF((stderr,"pCodeOpCopy wild\n"));
- if(PCOW(pcop)->matched)
- pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
- else {
- // Probably a label
- pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
- pcopnew->name = Safe_strdup(PCOW(pcop)->pcwb->vars[PCOW(pcop)->id]);
- //DFPRINTF((stderr,"copied a wild op named %s\n",pcopnew->name));
- }
-
- return pcopnew;
- break;
-
- case PO_LABEL:
- //DFPRINTF((stderr,"pCodeOpCopy label\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
- PCOLAB(pcopnew)->key = PCOLAB(pcop)->key;
- break;
-
- case PO_IMMEDIATE:
- pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) );
- PCOI(pcopnew)->index = PCOI(pcop)->index;
- PCOI(pcopnew)->offset = PCOI(pcop)->offset;
- PCOI(pcopnew)->_const = PCOI(pcop)->_const;
- PCOI(pcopnew)->_function = PCOI(pcop)->_function;
- break;
-
- case PO_LITERAL:
- //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
- PCOL(pcopnew)->lit = PCOL(pcop)->lit;
- break;
-
- case PO_GPR_BIT:
-
- pcopnew = newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace);
- PCOR(pcopnew)->r = PCOR(pcop)->r;
- PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- DFPRINTF((stderr," pCodeOpCopy Bit -register index\n"));
- return pcopnew;
- break;
-
- case PO_GPR_POINTER:
- case PO_GPR_REGISTER:
- case PO_GPR_TEMP:
- case PO_FSR:
- case PO_INDF:
- //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcopnew)->r = PCOR(pcop)->r;
- PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- PCOR(pcopnew)->instance = PCOR(pcop)->instance;
- DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
- break;
-
- case PO_DIR:
- //fprintf(stderr,"pCodeOpCopy PO_DIR\n");
- pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcopnew)->r = PCOR(pcop)->r;
- PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- PCOR(pcopnew)->instance = PCOR(pcop)->instance;
- break;
- case PO_STATUS:
- DFPRINTF((stderr,"pCodeOpCopy PO_STATUS\n"));
- case PO_SFR_REGISTER:
- case PO_STR:
- case PO_NONE:
- case PO_W:
- case PO_INTCON:
- case PO_PCL:
- case PO_PCLATH:
-
- //DFPRINTF((stderr,"pCodeOpCopy register type %d\n", pcop->type));
- pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
-
- }
-
- pcopnew->type = pcop->type;
- if(pcop->name)
- pcopnew->name = Safe_strdup(pcop->name);
- else
- pcopnew->name = NULL;
-
- return pcopnew;
+ pCodeOp *pcopnew=NULL;
+
+ if(!pcop)
+ return NULL;
+
+ switch(pcop->type) {
+ case PO_CRY:
+ case PO_BIT:
+ //DFPRINTF((stderr,"pCodeOpCopy bit\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpRegBit) );
+ PCORB(pcopnew)->bit = PCORB(pcop)->bit;
+ PCORB(pcopnew)->inBitSpace = PCORB(pcop)->inBitSpace;
+
+ break;
+
+ case PO_WILD:
+ /* Here we expand the wild card into the appropriate type: */
+ /* By recursively calling pCodeOpCopy */
+ //DFPRINTF((stderr,"pCodeOpCopy wild\n"));
+ if(PCOW(pcop)->matched)
+ pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
+ else {
+ // Probably a label
+ pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
+ pcopnew->name = Safe_strdup(PCOW(pcop)->pcwb->vars[PCOW(pcop)->id]);
+ //DFPRINTF((stderr,"copied a wild op named %s\n",pcopnew->name));
+ }
+
+ return pcopnew;
+ break;
+
+ case PO_LABEL:
+ //DFPRINTF((stderr,"pCodeOpCopy label\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
+ PCOLAB(pcopnew)->key = PCOLAB(pcop)->key;
+ break;
+
+ case PO_IMMEDIATE:
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) );
+ PCOI(pcopnew)->index = PCOI(pcop)->index;
+ PCOI(pcopnew)->offset = PCOI(pcop)->offset;
+ PCOI(pcopnew)->_const = PCOI(pcop)->_const;
+ PCOI(pcopnew)->_function = PCOI(pcop)->_function;
+ break;
+
+ case PO_LITERAL:
+ //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
+ PCOL(pcopnew)->lit = PCOL(pcop)->lit;
+ break;
+
+ case PO_GPR_BIT:
+
+ pcopnew = newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace);
+ PCOR(pcopnew)->r = PCOR(pcop)->r;
+ PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
+ DFPRINTF((stderr," pCodeOpCopy Bit -register index\n"));
+ return pcopnew;
+ break;
+
+ case PO_GPR_POINTER:
+ case PO_GPR_REGISTER:
+ case PO_GPR_TEMP:
+ case PO_FSR:
+ case PO_INDF:
+ //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcopnew)->r = PCOR(pcop)->r;
+ PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
+ PCOR(pcopnew)->instance = PCOR(pcop)->instance;
+ DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
+ break;
+
+ case PO_DIR:
+ //fprintf(stderr,"pCodeOpCopy PO_DIR\n");
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
+ PCOR(pcopnew)->r = PCOR(pcop)->r;
+ PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
+ PCOR(pcopnew)->instance = PCOR(pcop)->instance;
+ break;
+ case PO_STATUS:
+ DFPRINTF((stderr,"pCodeOpCopy PO_STATUS\n"));
+ case PO_SFR_REGISTER:
+ case PO_STR:
+ case PO_NONE:
+ case PO_W:
+ case PO_INTCON:
+ case PO_PCL:
+ case PO_PCLATH:
+
+ //DFPRINTF((stderr,"pCodeOpCopy register type %d\n", pcop->type));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
+
+ }
+
+ pcopnew->type = pcop->type;
+ if(pcop->name)
+ pcopnew->name = Safe_strdup(pcop->name);
+ else
+ pcopnew->name = NULL;
+
+ return pcopnew;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCodeOp *popCopyReg(pCodeOpReg *pc)
{
- pCodeOpReg *pcor;
-
- pcor = Safe_calloc(1,sizeof(pCodeOpReg) );
- pcor->pcop.type = pc->pcop.type;
- if(pc->pcop.name) {
- if(!(pcor->pcop.name = Safe_strdup(pc->pcop.name)))
- fprintf(stderr,"oops %s %d",__FILE__,__LINE__);
- } else
- pcor->pcop.name = NULL;
-
- pcor->r = pc->r;
- pcor->rIdx = pc->rIdx;
- pcor->r->wasUsed=1;
-
- //DEBUGpic14_emitcode ("; ***","%s , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
-
- return PCOP(pcor);
+ pCodeOpReg *pcor;
+
+ pcor = Safe_calloc(1,sizeof(pCodeOpReg) );
+ pcor->pcop.type = pc->pcop.type;
+ if(pc->pcop.name) {
+ if(!(pcor->pcop.name = Safe_strdup(pc->pcop.name)))
+ fprintf(stderr,"oops %s %d",__FILE__,__LINE__);
+ } else
+ pcor->pcop.name = NULL;
+
+ pcor->r = pc->r;
+ pcor->rIdx = pc->rIdx;
+ pcor->r->wasUsed=1;
+
+ //DEBUGpic14_emitcode ("; ***","%s , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
+
+ return PCOP(pcor);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode *pCodeInstructionCopy(pCodeInstruction *pci,int invert)
{
- pCodeInstruction *new_pci;
-
- if(invert)
- new_pci = PCI(newpCode(pci->inverted_op,pci->pcop));
- else
- new_pci = PCI(newpCode(pci->op,pci->pcop));
-
- new_pci->pc.pb = pci->pc.pb;
- new_pci->from = pci->from;
- new_pci->to = pci->to;
- new_pci->label = pci->label;
- new_pci->pcflow = pci->pcflow;
-
- return PCODE(new_pci);
+ pCodeInstruction *new_pci;
+
+ if(invert)
+ new_pci = PCI(newpCode(pci->inverted_op,pci->pcop));
+ else
+ new_pci = PCI(newpCode(pci->op,pci->pcop));
+
+ new_pci->pc.pb = pci->pc.pb;
+ new_pci->from = pci->from;
+ new_pci->to = pci->to;
+ new_pci->label = pci->label;
+ new_pci->pcflow = pci->pcflow;
+
+ return PCODE(new_pci);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pCodeDeleteChain(pCode *f,pCode *t)
{
- pCode *pc;
-
- while(f && f!=t) {
- DFPRINTF((stderr,"delete pCode:\n"));
- pc = f->next;
- //f->print(stderr,f);
- //f->delete(f); this dumps core...
- f = pc;
- }
+ pCode *pc;
+
+ while(f && f!=t) {
+ DFPRINTF((stderr,"delete pCode:\n"));
+ pc = f->next;
+ //f->print(stderr,f);
+ //f->delete(f); this dumps core...
+ f = pc;
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pBlockRegs(FILE *of, pBlock *pb)
{
-
- regs *r;
-
- r = setFirstItem(pb->tregisters);
- while (r) {
- r = setNextItem(pb->tregisters);
- }
+
+ regs *r;
+
+ r = setFirstItem(pb->tregisters);
+ while (r) {
+ r = setNextItem(pb->tregisters);
+ }
}
/*-----------------------------------------------------------------*/
char *get_op(pCodeOp *pcop,char *buffer, size_t size)
{
- regs *r;
- static char b[50];
- char *s;
- int use_buffer = 1; // copy the string to the passed buffer pointer
-
- if(!buffer) {
- buffer = b;
- size = sizeof(b);
- use_buffer = 0; // Don't bother copying the string to the buffer.
- }
-
- if(pcop) {
- switch(pcop->type) {
- case PO_INDF:
- case PO_FSR:
- if(use_buffer) {
- SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
- return buffer;
- }
- //return PCOR(pcop)->r->name;
- return pcop->name;
- break;
- case PO_GPR_TEMP:
- if (PCOR(pcop)->r->type == REG_STK)
- r = typeRegWithIdx(PCOR(pcop)->r->rIdx,REG_STK,1);
- else
- r = pic14_regWithIdx(PCOR(pcop)->r->rIdx);
-
- if(use_buffer) {
- SAFE_snprintf(&buffer,&size,"%s",r->name);
- return buffer;
- }
-
- return r->name;
-
-
- case PO_IMMEDIATE:
- s = buffer;
-
- if(PCOI(pcop)->_const) {
-
- if( PCOI(pcop)->offset && PCOI(pcop)->offset<4) {
- switch(PCOI(pcop)->offset) {
- case 0:
- SAFE_snprintf(&s,&size,"low %s",pcop->name);
- break;
- case 1:
- SAFE_snprintf(&s,&size,"high %s",pcop->name);
- break;
- default:
- SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)",
- pcop->name,
- PCOI(pcop)->index,
- 8 * PCOI(pcop)->offset );
- }
- } else
- SAFE_snprintf(&s,&size,"LOW(%s+%d)",pcop->name,PCOI(pcop)->index);
- } else {
-
- if( PCOI(pcop)->index) { // && PCOI(pcc->pcop)->offset<4) {
- SAFE_snprintf(&s,&size,"(%s + %d)",
- pcop->name,
- PCOI(pcop)->index );
- } else {
- switch(PCOI(pcop)->offset) {
- case 0:
- SAFE_snprintf(&s,&size,"%s",pcop->name);
- break;
- case 1:
- SAFE_snprintf(&s,&size,"high %s",pcop->name);
- break;
- default:
- SAFE_snprintf(&s,&size,"(%s >> %d)&0xff",pcop->name, 8*PCOI(pcop)->offset);
- }
- }
- }
-
- return buffer;
-
- case PO_DIR:
- s = buffer;
- //size = sizeof(buffer);
- if( PCOR(pcop)->instance) {
- SAFE_snprintf(&s,&size,"(%s + %d)",
- pcop->name,
- PCOR(pcop)->instance );
- //fprintf(stderr,"PO_DIR %s\n",buffer);
- } else
- SAFE_snprintf(&s,&size,"%s",pcop->name);
- return buffer;
-
- case PO_LABEL:
- s = buffer;
- if (pcop->name) {
- if(PCOLAB(pcop)->offset == 1)
- SAFE_snprintf(&s,&size,"HIGH(%s)",pcop->name);
- else
- SAFE_snprintf(&s,&size,"%s",pcop->name);
- }
- return buffer;
-
- default:
- if (pcop->name) {
- if(use_buffer) {
- SAFE_snprintf(&buffer,&size,"%s",pcop->name);
- return buffer;
+ regs *r;
+ static char b[50];
+ char *s;
+ int use_buffer = 1; // copy the string to the passed buffer pointer
+
+ if(!buffer) {
+ buffer = b;
+ size = sizeof(b);
+ use_buffer = 0; // Don't bother copying the string to the buffer.
+ }
+
+ if(pcop) {
+ switch(pcop->type) {
+ case PO_INDF:
+ case PO_FSR:
+ if(use_buffer) {
+ SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
+ return buffer;
+ }
+ //return PCOR(pcop)->r->name;
+ return pcop->name;
+ break;
+ case PO_GPR_TEMP:
+ if (PCOR(pcop)->r->type == REG_STK)
+ r = typeRegWithIdx(PCOR(pcop)->r->rIdx,REG_STK,1);
+ else
+ r = pic14_regWithIdx(PCOR(pcop)->r->rIdx);
+
+ if(use_buffer) {
+ SAFE_snprintf(&buffer,&size,"%s",r->name);
+ return buffer;
+ }
+
+ return r->name;
+
+
+ case PO_IMMEDIATE:
+ s = buffer;
+
+ if(PCOI(pcop)->_const) {
+
+ if( PCOI(pcop)->offset && PCOI(pcop)->offset<4) {
+ switch(PCOI(pcop)->offset) {
+ case 0:
+ SAFE_snprintf(&s,&size,"low %s",pcop->name);
+ break;
+ case 1:
+ SAFE_snprintf(&s,&size,"high %s",pcop->name);
+ break;
+ default:
+ SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)",
+ pcop->name,
+ PCOI(pcop)->index,
+ 8 * PCOI(pcop)->offset );
+ }
+ } else
+ SAFE_snprintf(&s,&size,"LOW(%s+%d)",pcop->name,PCOI(pcop)->index);
+ } else {
+
+ if( PCOI(pcop)->index) { // && PCOI(pcc->pcop)->offset<4) {
+ SAFE_snprintf(&s,&size,"(%s + %d)",
+ pcop->name,
+ PCOI(pcop)->index );
+ } else {
+ switch(PCOI(pcop)->offset) {
+ case 0:
+ SAFE_snprintf(&s,&size,"%s",pcop->name);
+ break;
+ case 1:
+ SAFE_snprintf(&s,&size,"high %s",pcop->name);
+ break;
+ default:
+ SAFE_snprintf(&s,&size,"(%s >> %d)&0xff",pcop->name, 8*PCOI(pcop)->offset);
+ }
+ }
+ }
+
+ return buffer;
+
+ case PO_DIR:
+ s = buffer;
+ //size = sizeof(buffer);
+ if( PCOR(pcop)->instance) {
+ SAFE_snprintf(&s,&size,"(%s + %d)",
+ pcop->name,
+ PCOR(pcop)->instance );
+ //fprintf(stderr,"PO_DIR %s\n",buffer);
+ } else
+ SAFE_snprintf(&s,&size,"%s",pcop->name);
+ return buffer;
+
+ case PO_LABEL:
+ s = buffer;
+ if (pcop->name) {
+ if(PCOLAB(pcop)->offset == 1)
+ SAFE_snprintf(&s,&size,"HIGH(%s)",pcop->name);
+ else
+ SAFE_snprintf(&s,&size,"%s",pcop->name);
+ }
+ return buffer;
+
+ default:
+ if (pcop->name) {
+ if(use_buffer) {
+ SAFE_snprintf(&buffer,&size,"%s",pcop->name);
+ return buffer;
+ }
+ return pcop->name;
+ }
+
+ }
}
- return pcop->name;
- }
-
- }
- }
-
- return "NO operand";
-
+
+ return "NO operand";
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static char *get_op_from_instruction( pCodeInstruction *pcc)
{
-
- if(pcc )
- return get_op(pcc->pcop,NULL,0);
-
- /* gcc 3.2: warning: concatenation of string literals with __FUNCTION__ is deprecated
- return ("ERROR Null: "__FUNCTION__);
- */
- return ("ERROR Null: get_op_from_instruction");
-
+
+ if(pcc )
+ return get_op(pcc->pcop,NULL,0);
+
+ /* gcc 3.2: warning: concatenation of string literals with __FUNCTION__ is deprecated
+ return ("ERROR Null: "__FUNCTION__);
+ */
+ return ("ERROR Null: get_op_from_instruction");
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void pCodeOpPrint(FILE *of, pCodeOp *pcop)
{
-
- fprintf(of,"pcodeopprint- not implemented\n");
+
+ fprintf(of,"pcodeopprint- not implemented\n");
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
char *pCode2str(char *str, size_t size, pCode *pc)
{
- char *s = str;
-
- switch(pc->type) {
-
- case PC_OPCODE:
-
- SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic);
-
- if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) {
-
- if(PCI(pc)->isBitInst) {
- if(PCI(pc)->pcop->type == PO_GPR_BIT) {
- char *name = PCI(pc)->pcop->name;
- if (!name)
- name = PCOR(PCI(pc)->pcop)->r->name;
- if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
- SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name);
- else
- SAFE_snprintf(&s,&size,"%s,%d", name,
- (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
- } else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
- SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
- }else
- SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
- //PCI(pc)->pcop->t.bit );
- } else {
-
- if(PCI(pc)->pcop->type == PO_GPR_BIT) {
- if( PCI(pc)->num_ops == 2)
- SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
- else
- SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
-
- }else {
- SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc)));
-
- if( PCI(pc)->num_ops == 2)
- SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W'));
+ char *s = str;
+
+ switch(pc->type) {
+
+ case PC_OPCODE:
+
+ SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic);
+
+ if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) {
+
+ if(PCI(pc)->isBitInst) {
+ if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+ char *name = PCI(pc)->pcop->name;
+ if (!name)
+ name = PCOR(PCI(pc)->pcop)->r->name;
+ if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
+ SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name);
+ else
+ SAFE_snprintf(&s,&size,"%s,%d", name,
+ (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
+ } else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+ SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
+ }else
+ SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
+ //PCI(pc)->pcop->t.bit );
+ } else {
+
+ if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+ if( PCI(pc)->num_ops == 2)
+ SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
+ else
+ SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
+
+ }else {
+ SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc)));
+
+ if( PCI(pc)->num_ops == 2)
+ SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W'));
+ }
+ }
+
+ }
+ break;
+
+ case PC_COMMENT:
+ /* assuming that comment ends with a \n */
+ SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment);
+ break;
+
+ case PC_INLINE:
+ /* assuming that inline code ends with a \n */
+ SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment);
+ break;
+
+ case PC_LABEL:
+ SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
+ break;
+ case PC_FUNCTION:
+ SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
+ break;
+ case PC_WILD:
+ SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id);
+ break;
+ case PC_FLOW:
+ SAFE_snprintf(&s,&size,";\t--FLOW change\n");
+ break;
+ case PC_CSOURCE:
+ SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
+ break;
+
+ case PC_BAD:
+ SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
}
- }
-
- }
- break;
-
- case PC_COMMENT:
- /* assuming that comment ends with a \n */
- SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment);
- break;
-
- case PC_INLINE:
- /* assuming that inline code ends with a \n */
- SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment);
- break;
-
- case PC_LABEL:
- SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
- break;
- case PC_FUNCTION:
- SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
- break;
- case PC_WILD:
- SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id);
- break;
- case PC_FLOW:
- SAFE_snprintf(&s,&size,";\t--FLOW change\n");
- break;
- case PC_CSOURCE:
- SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
- break;
-
- case PC_BAD:
- SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
- }
-
- return str;
-
+
+ return str;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void genericPrint(FILE *of, pCode *pc)
{
-
- if(!pc || !of)
- return;
-
- switch(pc->type) {
- case PC_COMMENT:
- fprintf(of,";%s\n", ((pCodeComment *)pc)->comment);
- break;
-
- case PC_INLINE:
- fprintf(of,"%s\n", ((pCodeComment *)pc)->comment);
- break;
-
- case PC_OPCODE:
- // If the opcode has a label, print that first
- {
- pBranch *pbl = PCI(pc)->label;
- while(pbl && pbl->pc) {
- if(pbl->pc->type == PC_LABEL)
- pCodePrintLabel(of, pbl->pc);
- pbl = pbl->next;
- }
- }
-
- if(PCI(pc)->cline)
- genericPrint(of,PCODE(PCI(pc)->cline));
-
- {
- char str[256];
-
- pCode2str(str, 256, pc);
-
- fprintf(of,"%s",str);
-
- /* Debug */
- if(debug_verbose) {
- fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq);
- if(PCI(pc)->pcflow)
- fprintf(of,",flow seq=%03x",PCI(pc)->pcflow->pc.seq);
- }
- }
-#if 0
- {
- pBranch *dpb = pc->to; // debug
- while(dpb) {
- switch ( dpb->pc->type) {
- case PC_OPCODE:
- fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic);
- break;
- case PC_LABEL:
- fprintf(of, "\t;label %d", PCL(dpb->pc)->key);
- break;
- case PC_FUNCTION:
- fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]"));
- break;
- case PC_FLOW:
- fprintf(of, "\t;flow");
- break;
+
+ if(!pc || !of)
+ return;
+
+ switch(pc->type) {
case PC_COMMENT:
+ fprintf(of,";%s\n", ((pCodeComment *)pc)->comment);
+ break;
+
+ case PC_INLINE:
+ fprintf(of,"%s\n", ((pCodeComment *)pc)->comment);
+ break;
+
+ case PC_OPCODE:
+ // If the opcode has a label, print that first
+ {
+ pBranch *pbl = PCI(pc)->label;
+ while(pbl && pbl->pc) {
+ if(pbl->pc->type == PC_LABEL)
+ pCodePrintLabel(of, pbl->pc);
+ pbl = pbl->next;
+ }
+ }
+
+ if(PCI(pc)->cline)
+ genericPrint(of,PCODE(PCI(pc)->cline));
+
+ {
+ char str[256];
+
+ pCode2str(str, 256, pc);
+
+ fprintf(of,"%s",str);
+
+ /* Debug */
+ if(debug_verbose) {
+ fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq);
+ if(PCI(pc)->pcflow)
+ fprintf(of,",flow seq=%03x",PCI(pc)->pcflow->pc.seq);
+ }
+ }
+#if 0
+ {
+ pBranch *dpb = pc->to; // debug
+ while(dpb) {
+ switch ( dpb->pc->type) {
+ case PC_OPCODE:
+ fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic);
+ break;
+ case PC_LABEL:
+ fprintf(of, "\t;label %d", PCL(dpb->pc)->key);
+ break;
+ case PC_FUNCTION:
+ fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]"));
+ break;
+ case PC_FLOW:
+ fprintf(of, "\t;flow");
+ break;
+ case PC_COMMENT:
+ case PC_WILD:
+ break;
+ }
+ dpb = dpb->next;
+ }
+ }
+#endif
+ fprintf(of,"\n");
+ break;
+
case PC_WILD:
- break;
+ fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id);
+ if(PCW(pc)->pci.label)
+ pCodePrintLabel(of, PCW(pc)->pci.label->pc);
+
+ if(PCW(pc)->operand) {
+ fprintf(of,";\toperand ");
+ pCodeOpPrint(of,PCW(pc)->operand );
+ }
+ break;
+
+ case PC_FLOW:
+ if(debug_verbose) {
+ fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq);
+ if(PCFL(pc)->ancestor)
+ fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
+ fprintf(of,"\n");
+
+ }
+ break;
+
+ case PC_CSOURCE:
+ fprintf(of,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
+ break;
+ case PC_LABEL:
+ default:
+ fprintf(of,"unknown pCode type %d\n",pc->type);
}
- dpb = dpb->next;
- }
- }
-#endif
- fprintf(of,"\n");
- break;
-
- case PC_WILD:
- fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id);
- if(PCW(pc)->pci.label)
- pCodePrintLabel(of, PCW(pc)->pci.label->pc);
-
- if(PCW(pc)->operand) {
- fprintf(of,";\toperand ");
- pCodeOpPrint(of,PCW(pc)->operand );
- }
- break;
-
- case PC_FLOW:
- if(debug_verbose) {
- fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq);
- if(PCFL(pc)->ancestor)
- fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
- fprintf(of,"\n");
-
- }
- break;
-
- case PC_CSOURCE:
- fprintf(of,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
- break;
- case PC_LABEL:
- default:
- fprintf(of,"unknown pCode type %d\n",pc->type);
- }
-
+
}
/*-----------------------------------------------------------------*/
static void pCodePrintFunction(FILE *of, pCode *pc)
{
-
- if(!pc || !of)
- return;
-
- if( ((pCodeFunction *)pc)->modname)
- fprintf(of,"F_%s",((pCodeFunction *)pc)->modname);
-
- if(PCF(pc)->fname) {
- pBranch *exits = PCF(pc)->to;
- int i=0;
- fprintf(of,"%s\t;Function start\n",PCF(pc)->fname);
- while(exits) {
- i++;
- exits = exits->next;
- }
- //if(i) i--;
- fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s'));
-
- }else {
- if((PCF(pc)->from &&
- PCF(pc)->from->pc->type == PC_FUNCTION &&
- PCF(PCF(pc)->from->pc)->fname) )
- fprintf(of,"; exit point of %s\n",PCF(PCF(pc)->from->pc)->fname);
- else
- fprintf(of,"; exit point [can't find entry point]\n");
- }
+
+ if(!pc || !of)
+ return;
+
+ if( ((pCodeFunction *)pc)->modname)
+ fprintf(of,"F_%s",((pCodeFunction *)pc)->modname);
+
+ if(PCF(pc)->fname) {
+ pBranch *exits = PCF(pc)->to;
+ int i=0;
+ fprintf(of,"%s\t;Function start\n",PCF(pc)->fname);
+ while(exits) {
+ i++;
+ exits = exits->next;
+ }
+ //if(i) i--;
+ fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s'));
+
+ }else {
+ if((PCF(pc)->from &&
+ PCF(pc)->from->pc->type == PC_FUNCTION &&
+ PCF(PCF(pc)->from->pc)->fname) )
+ fprintf(of,"; exit point of %s\n",PCF(PCF(pc)->from->pc)->fname);
+ else
+ fprintf(of,"; exit point [can't find entry point]\n");
+ }
}
/*-----------------------------------------------------------------*/
/* pCodePrintLabel - prints label */
static void pCodePrintLabel(FILE *of, pCode *pc)
{
-
- if(!pc || !of)
- return;
-
- if(PCL(pc)->label)
- fprintf(of,"%s\n",PCL(pc)->label);
- else if (PCL(pc)->key >=0)
- fprintf(of,"_%05d_DS_:\n",PCL(pc)->key);
- else
- fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key);
-
+
+ if(!pc || !of)
+ return;
+
+ if(PCL(pc)->label)
+ fprintf(of,"%s\n",PCL(pc)->label);
+ else if (PCL(pc)->key >=0)
+ fprintf(of,"_%05d_DS_:\n",PCL(pc)->key);
+ else
+ fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key);
+
}
/*-----------------------------------------------------------------*/
/* unlinkpCodeFromBranch - Search for a label in a pBranch and */
/*-----------------------------------------------------------------*/
static void unlinkpCodeFromBranch(pCode *pcl , pCode *pc)
{
- pBranch *b, *bprev;
-
-
- bprev = NULL;
-
- if(pcl->type == PC_OPCODE)
- b = PCI(pcl)->label;
- else {
- fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__);
- exit(1);
-
- }
-
- //fprintf (stderr, "%s \n",__FUNCTION__);
- //pcl->print(stderr,pcl);
- //pc->print(stderr,pc);
- while(b) {
- if(b->pc == pc) {
- //fprintf (stderr, "found label\n");
-
- /* Found a label */
- if(bprev) {
- bprev->next = b->next; /* Not first pCode in chain */
- free(b);
- } else {
- pc->destruct(pc);
- PCI(pcl)->label = b->next; /* First pCode in chain */
- free(b);
- }
- return; /* A label can't occur more than once */
- }
- bprev = b;
- b = b->next;
- }
-
+ pBranch *b, *bprev;
+
+
+ bprev = NULL;
+
+ if(pcl->type == PC_OPCODE)
+ b = PCI(pcl)->label;
+ else {
+ fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__);
+ exit(1);
+
+ }
+
+ //fprintf (stderr, "%s \n",__FUNCTION__);
+ //pcl->print(stderr,pcl);
+ //pc->print(stderr,pc);
+ while(b) {
+ if(b->pc == pc) {
+ //fprintf (stderr, "found label\n");
+
+ /* Found a label */
+ if(bprev) {
+ bprev->next = b->next; /* Not first pCode in chain */
+ free(b);
+ } else {
+ pc->destruct(pc);
+ PCI(pcl)->label = b->next; /* First pCode in chain */
+ free(b);
+ }
+ return; /* A label can't occur more than once */
+ }
+ bprev = b;
+ b = b->next;
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pBranch * pBranchAppend(pBranch *h, pBranch *n)
{
- pBranch *b;
-
- if(!h)
- return n;
-
- if(h == n)
- return n;
-
- b = h;
- while(b->next)
- b = b->next;
-
- b->next = n;
-
- return h;
-
+ pBranch *b;
+
+ if(!h)
+ return n;
+
+ if(h == n)
+ return n;
+
+ b = h;
+ while(b->next)
+ b = b->next;
+
+ b->next = n;
+
+ return h;
+
}
/*-----------------------------------------------------------------*/
/* pBranchLink - given two pcodes, this function will link them */
/*-----------------------------------------------------------------*/
static void pBranchLink(pCodeFunction *f, pCodeFunction *t)
{
- pBranch *b;
-
- // Declare a new branch object for the 'from' pCode.
-
- //_ALLOC(b,sizeof(pBranch));
- b = Safe_calloc(1,sizeof(pBranch));
- b->pc = PCODE(t); // The link to the 'to' pCode.
- b->next = NULL;
-
- f->to = pBranchAppend(f->to,b);
-
- // Now do the same for the 'to' pCode.
-
- //_ALLOC(b,sizeof(pBranch));
- b = Safe_calloc(1,sizeof(pBranch));
- b->pc = PCODE(f);
- b->next = NULL;
-
- t->from = pBranchAppend(t->from,b);
-
+ pBranch *b;
+
+ // Declare a new branch object for the 'from' pCode.
+
+ //_ALLOC(b,sizeof(pBranch));
+ b = Safe_calloc(1,sizeof(pBranch));
+ b->pc = PCODE(t); // The link to the 'to' pCode.
+ b->next = NULL;
+
+ f->to = pBranchAppend(f->to,b);
+
+ // Now do the same for the 'to' pCode.
+
+ //_ALLOC(b,sizeof(pBranch));
+ b = Safe_calloc(1,sizeof(pBranch));
+ b->pc = PCODE(f);
+ b->next = NULL;
+
+ t->from = pBranchAppend(t->from,b);
+
}
#if 0
/*-----------------------------------------------------------------*/
static pBranch *pBranchFind(pBranch *pb,pCode *pc)
{
- while(pb) {
-
- if(pb->pc == pc)
- return pb;
-
- pb = pb->next;
- }
-
- return NULL;
+ while(pb) {
+
+ if(pb->pc == pc)
+ return pb;
+
+ pb = pb->next;
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void pCodeUnlink(pCode *pc)
{
- pBranch *pb1,*pb2;
- pCode *pc1;
-
- if(!pc->prev || !pc->next) {
- fprintf(stderr,"unlinking bad pCode in %s:%d\n",__FILE__,__LINE__);
- exit(1);
- }
-
- /* first remove the pCode from the chain */
- pc->prev->next = pc->next;
- pc->next->prev = pc->prev;
-
- /* Now for the hard part... */
-
- /* Remove the branches */
-
- pb1 = pc->from;
- while(pb1) {
- pc1 = pb1->pc; /* Get the pCode that branches to the
- * one we're unlinking */
-
- /* search for the link back to this pCode (the one we're
- * unlinking) */
- if(pb2 = pBranchFind(pc1->to,pc)) {
- pb2->pc = pc->to->pc; // make the replacement
-
- /* if the pCode we're unlinking contains multiple 'to'
- * branches (e.g. this a skip instruction) then we need
- * to copy these extra branches to the chain. */
- if(pc->to->next)
- pBranchAppend(pb2, pc->to->next);
- }
-
- pb1 = pb1->next;
- }
-
+ pBranch *pb1,*pb2;
+ pCode *pc1;
+
+ if(!pc->prev || !pc->next) {
+ fprintf(stderr,"unlinking bad pCode in %s:%d\n",__FILE__,__LINE__);
+ exit(1);
+ }
+
+ /* first remove the pCode from the chain */
+ pc->prev->next = pc->next;
+ pc->next->prev = pc->prev;
+
+ /* Now for the hard part... */
+
+ /* Remove the branches */
+
+ pb1 = pc->from;
+ while(pb1) {
+ pc1 = pb1->pc; /* Get the pCode that branches to the
+ * one we're unlinking */
+
+ /* search for the link back to this pCode (the one we're
+ * unlinking) */
+ if(pb2 = pBranchFind(pc1->to,pc)) {
+ pb2->pc = pc->to->pc; // make the replacement
+
+ /* if the pCode we're unlinking contains multiple 'to'
+ * branches (e.g. this a skip instruction) then we need
+ * to copy these extra branches to the chain. */
+ if(pc->to->next)
+ pBranchAppend(pb2, pc->to->next);
+ }
+ pb1 = pb1->next;
+ }
+
+
}
#endif
/*-----------------------------------------------------------------*/
#if 0
static void genericAnalyze(pCode *pc)
{
- switch(pc->type) {
- case PC_WILD:
- case PC_COMMENT:
- return;
- case PC_LABEL:
- case PC_FUNCTION:
- case PC_OPCODE:
- {
- // Go through the pCodes that are in pCode chain and link
- // them together through the pBranches. Note, the pCodes
- // are linked together as a contiguous stream like the
- // assembly source code lines. The linking here mimics this
- // except that comments are not linked in.
- //
- pCode *npc = pc->next;
- while(npc) {
- if(npc->type == PC_OPCODE || npc->type == PC_LABEL) {
- pBranchLink(pc,npc);
- return;
- } else
- npc = npc->next;
- }
- /* reached the end of the pcode chain without finding
- * an instruction we could link to. */
- }
- break;
- case PC_FLOW:
- fprintf(stderr,"analyze PC_FLOW\n");
-
- return;
- case PC_BAD:
- fprintf(stderr,";A bad pCode is being used\n");
-
- }
+ switch(pc->type) {
+ case PC_WILD:
+ case PC_COMMENT:
+ return;
+ case PC_LABEL:
+ case PC_FUNCTION:
+ case PC_OPCODE:
+ {
+ // Go through the pCodes that are in pCode chain and link
+ // them together through the pBranches. Note, the pCodes
+ // are linked together as a contiguous stream like the
+ // assembly source code lines. The linking here mimics this
+ // except that comments are not linked in.
+ //
+ pCode *npc = pc->next;
+ while(npc) {
+ if(npc->type == PC_OPCODE || npc->type == PC_LABEL) {
+ pBranchLink(pc,npc);
+ return;
+ } else
+ npc = npc->next;
+ }
+ /* reached the end of the pcode chain without finding
+ * an instruction we could link to. */
+ }
+ break;
+ case PC_FLOW:
+ fprintf(stderr,"analyze PC_FLOW\n");
+
+ return;
+ case PC_BAD:
+ fprintf(stderr,";A bad pCode is being used\n");
+
+ }
}
#endif
/*-----------------------------------------------------------------*/
int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
{
- pBranch *pbr;
-
- if(pc->type == PC_LABEL) {
- if( ((pCodeLabel *)pc)->key == pcop_label->key)
- return TRUE;
- }
- if(pc->type == PC_OPCODE) {
- pbr = PCI(pc)->label;
- while(pbr) {
- if(pbr->pc->type == PC_LABEL) {
- if( ((pCodeLabel *)(pbr->pc))->key == pcop_label->key)
- return TRUE;
- }
- pbr = pbr->next;
- }
- }
-
- return FALSE;
+ pBranch *pbr;
+
+ if(pc->type == PC_LABEL) {
+ if( ((pCodeLabel *)pc)->key == pcop_label->key)
+ return TRUE;
+ }
+ if(pc->type == PC_OPCODE) {
+ pbr = PCI(pc)->label;
+ while(pbr) {
+ if(pbr->pc->type == PC_LABEL) {
+ if( ((pCodeLabel *)(pbr->pc))->key == pcop_label->key)
+ return TRUE;
+ }
+ pbr = pbr->next;
+ }
+ }
+
+ return FALSE;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int checkLabel(pCode *pc)
{
- pBranch *pbr;
-
- if(pc && isPCI(pc)) {
- pbr = PCI(pc)->label;
- while(pbr) {
- if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
- return TRUE;
-
- pbr = pbr->next;
- }
- }
-
- return FALSE;
+ pBranch *pbr;
+
+ if(pc && isPCI(pc)) {
+ pbr = PCI(pc)->label;
+ while(pbr) {
+ if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
+ return TRUE;
+
+ pbr = pbr->next;
+ }
+ }
+
+ return FALSE;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findLabelinpBlock(pBlock *pb,pCodeOpLabel *pcop_label)
{
- pCode *pc;
-
- if(!pb)
- return NULL;
-
- for(pc = pb->pcHead; pc; pc = pc->next)
- if(compareLabel(pc,pcop_label))
- return pc;
-
- return NULL;
+ pCode *pc;
+
+ if(!pb)
+ return NULL;
+
+ for(pc = pb->pcHead; pc; pc = pc->next)
+ if(compareLabel(pc,pcop_label))
+ return pc;
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findLabel(pCodeOpLabel *pcop_label)
{
- pBlock *pb;
- pCode *pc;
-
- if(!the_pFile)
- return NULL;
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if( (pc = findLabelinpBlock(pb,pcop_label)) != NULL)
- return pc;
- }
-
- fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name);
- return NULL;
+ pBlock *pb;
+ pCode *pc;
+
+ if(!the_pFile)
+ return NULL;
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ if( (pc = findLabelinpBlock(pb,pcop_label)) != NULL)
+ return pc;
+ }
+
+ fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name);
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findNextpCode(pCode *pc, PC_TYPE pct)
{
-
- while(pc) {
- if(pc->type == pct)
- return pc;
-
- pc = pc->next;
- }
-
- return NULL;
+
+ while(pc) {
+ if(pc->type == pct)
+ return pc;
+
+ pc = pc->next;
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findPrevpCode(pCode *pc, PC_TYPE pct)
{
-
- while(pc) {
- if(pc->type == pct)
- return pc;
-
- pc = pc->prev;
- }
-
- return NULL;
+
+ while(pc) {
+ if(pc->type == pct)
+ return pc;
+
+ pc = pc->prev;
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/* findNextInstruction - given a pCode, find the next instruction */
/*-----------------------------------------------------------------*/
pCode * findNextInstruction(pCode *pci)
{
- pCode *pc = pci;
-
- while(pc) {
- if((pc->type == PC_OPCODE) || (pc->type == PC_WILD))
- return pc;
-
+ pCode *pc = pci;
+
+ while(pc) {
+ if((pc->type == PC_OPCODE) || (pc->type == PC_WILD))
+ return pc;
+
#ifdef PCODE_DEBUG
- fprintf(stderr,"findNextInstruction: ");
- printpCode(stderr, pc);
+ fprintf(stderr,"findNextInstruction: ");
+ printpCode(stderr, pc);
#endif
- pc = pc->next;
- }
-
- //fprintf(stderr,"Couldn't find instruction\n");
- return NULL;
+ pc = pc->next;
+ }
+
+ //fprintf(stderr,"Couldn't find instruction\n");
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findPrevInstruction(pCode *pci)
{
- return findPrevpCode(pci, PC_OPCODE);
+ return findPrevpCode(pci, PC_OPCODE);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findFunctionEnd(pCode *pc)
{
-
- while(pc) {
- if(pc->type == PC_FUNCTION && !(PCF(pc)->fname))
- return pc;
-
- pc = pc->next;
- }
-
- fprintf(stderr,"Couldn't find function end\n");
- return NULL;
+
+ while(pc) {
+ if(pc->type == PC_FUNCTION && !(PCF(pc)->fname))
+ return pc;
+
+ pc = pc->next;
+ }
+
+ fprintf(stderr,"Couldn't find function end\n");
+ return NULL;
}
#if 0
/*-----------------------------------------------------------------*/
static void AnalyzeLabel(pCode *pc)
{
-
- pCodeUnlink(pc);
-
+
+ pCodeUnlink(pc);
+
}
#endif
#if 0
static void AnalyzeGOTO(pCode *pc)
{
-
- pBranchLink(pc,findLabel( (pCodeOpLabel *) (PCI(pc)->pcop) ));
-
+
+ pBranchLink(pc,findLabel( (pCodeOpLabel *) (PCI(pc)->pcop) ));
+
}
static void AnalyzeSKIP(pCode *pc)
{
-
- pBranchLink(pc,findNextInstruction(pc->next));
- pBranchLink(pc,findNextInstruction(pc->next->next));
-
+
+ pBranchLink(pc,findNextInstruction(pc->next));
+ pBranchLink(pc,findNextInstruction(pc->next->next));
+
}
static void AnalyzeRETURN(pCode *pc)
{
-
- // branch_link(pc,findFunctionEnd(pc->next));
-
+
+ // branch_link(pc,findFunctionEnd(pc->next));
+
}
#endif
/*-----------------------------------------------------------------*/
regs * getRegFromInstruction(pCode *pc)
{
+
+ if(!pc ||
+ !isPCI(pc) ||
+ !PCI(pc)->pcop ||
+ PCI(pc)->num_ops == 0 )
+ return NULL;
+
+ switch(PCI(pc)->pcop->type) {
+ case PO_INDF:
+ case PO_FSR:
+ return PCOR(PCI(pc)->pcop)->r;
+
+ // return typeRegWithIdx (PCOR(PCI(pc)->pcop)->rIdx, REG_SFR, 0);
+
+ case PO_BIT:
+ case PO_GPR_TEMP:
+ //fprintf(stderr, "getRegFromInstruction - bit or temp\n");
+ return PCOR(PCI(pc)->pcop)->r;
+
+ case PO_IMMEDIATE:
+ if(PCOI(PCI(pc)->pcop)->r)
+ return (PCOI(PCI(pc)->pcop)->r);
+
+ //fprintf(stderr, "getRegFromInstruction - immediate\n");
+ return dirregWithName(PCI(pc)->pcop->name);
+ //return NULL; // PCOR(PCI(pc)->pcop)->r;
+
+ case PO_GPR_BIT:
+ return PCOR(PCI(pc)->pcop)->r;
+
+ case PO_GPR_REGISTER:
+ case PO_DIR:
+ //fprintf(stderr, "getRegFromInstruction - dir\n");
+ return PCOR(PCI(pc)->pcop)->r;
+ case PO_LITERAL:
+ //fprintf(stderr, "getRegFromInstruction - literal\n");
+ break;
+
+ default:
+ //fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
+ //genericPrint(stderr, pc);
+ break;
+ }
+
+ return NULL;
+
+}
- if(!pc ||
- !isPCI(pc) ||
- !PCI(pc)->pcop ||
- PCI(pc)->num_ops == 0 )
- return NULL;
-
- switch(PCI(pc)->pcop->type) {
- case PO_INDF:
- case PO_FSR:
- return PCOR(PCI(pc)->pcop)->r;
-
- // return typeRegWithIdx (PCOR(PCI(pc)->pcop)->rIdx, REG_SFR, 0);
-
- case PO_BIT:
- case PO_GPR_TEMP:
- //fprintf(stderr, "getRegFromInstruction - bit or temp\n");
- return PCOR(PCI(pc)->pcop)->r;
-
- case PO_IMMEDIATE:
- if(PCOI(PCI(pc)->pcop)->r)
- return (PCOI(PCI(pc)->pcop)->r);
-
- //fprintf(stderr, "getRegFromInstruction - immediate\n");
- return dirregWithName(PCI(pc)->pcop->name);
- //return NULL; // PCOR(PCI(pc)->pcop)->r;
-
- case PO_GPR_BIT:
- return PCOR(PCI(pc)->pcop)->r;
-
- case PO_GPR_REGISTER:
- case PO_DIR:
- //fprintf(stderr, "getRegFromInstruction - dir\n");
- return PCOR(PCI(pc)->pcop)->r;
- case PO_LITERAL:
- //fprintf(stderr, "getRegFromInstruction - literal\n");
- break;
-
- default:
- //fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
- //genericPrint(stderr, pc);
- break;
- }
-
- return NULL;
-
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
void AnalyzepBlock(pBlock *pb)
{
- pCode *pc;
-
- if(!pb)
- return;
-
- /* Find all of the registers used in this pBlock
- * by looking at each instruction and examining it's
- * operands
- */
- for(pc = pb->pcHead; pc; pc = pc->next) {
-
- /* Is this an instruction with operands? */
- if(pc->type == PC_OPCODE && PCI(pc)->pcop) {
-
- if((PCI(pc)->pcop->type == PO_GPR_TEMP)
- || ((PCI(pc)->pcop->type == PO_GPR_BIT) && PCOR(PCI(pc)->pcop)->r && (PCOR(PCI(pc)->pcop)->r->pc_type == PO_GPR_TEMP))) {
-
- /* Loop through all of the registers declared so far in
- this block and see if we find this one there */
-
- regs *r = setFirstItem(pb->tregisters);
-
- while(r) {
- if((r->rIdx == PCOR(PCI(pc)->pcop)->r->rIdx) && (r->type == PCOR(PCI(pc)->pcop)->r->type)) {
- PCOR(PCI(pc)->pcop)->r = r;
- break;
- }
- r = setNextItem(pb->tregisters);
- }
-
- if(!r) {
- /* register wasn't found */
- //r = Safe_calloc(1, sizeof(regs));
- //memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs));
- //addSet(&pb->tregisters, r);
- addSet(&pb->tregisters, PCOR(PCI(pc)->pcop)->r);
- //PCOR(PCI(pc)->pcop)->r = r;
- //fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx);
- }/* else
- fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx);
- */
- }
- if(PCI(pc)->pcop->type == PO_GPR_REGISTER) {
- if(PCOR(PCI(pc)->pcop)->r) {
- pic14_allocWithIdx (PCOR(PCI(pc)->pcop)->r->rIdx);
- DFPRINTF((stderr,"found register in pblock: reg 0x%x\n",PCOR(PCI(pc)->pcop)->r->rIdx));
- } else {
- if(PCI(pc)->pcop->name)
- fprintf(stderr,"ERROR: %s is a NULL register\n",PCI(pc)->pcop->name );
- else
- fprintf(stderr,"ERROR: NULL register\n");
+ pCode *pc;
+
+ if(!pb)
+ return;
+
+ /* Find all of the registers used in this pBlock
+ * by looking at each instruction and examining it's
+ * operands
+ */
+ for(pc = pb->pcHead; pc; pc = pc->next) {
+
+ /* Is this an instruction with operands? */
+ if(pc->type == PC_OPCODE && PCI(pc)->pcop) {
+
+ if((PCI(pc)->pcop->type == PO_GPR_TEMP)
+ || ((PCI(pc)->pcop->type == PO_GPR_BIT) && PCOR(PCI(pc)->pcop)->r && (PCOR(PCI(pc)->pcop)->r->pc_type == PO_GPR_TEMP))) {
+
+ /* Loop through all of the registers declared so far in
+ this block and see if we find this one there */
+
+ regs *r = setFirstItem(pb->tregisters);
+
+ while(r) {
+ if((r->rIdx == PCOR(PCI(pc)->pcop)->r->rIdx) && (r->type == PCOR(PCI(pc)->pcop)->r->type)) {
+ PCOR(PCI(pc)->pcop)->r = r;
+ break;
+ }
+ r = setNextItem(pb->tregisters);
+ }
+
+ if(!r) {
+ /* register wasn't found */
+ //r = Safe_calloc(1, sizeof(regs));
+ //memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs));
+ //addSet(&pb->tregisters, r);
+ addSet(&pb->tregisters, PCOR(PCI(pc)->pcop)->r);
+ //PCOR(PCI(pc)->pcop)->r = r;
+ //fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx);
+ }/* else
+ fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx);
+ */
+ }
+ if(PCI(pc)->pcop->type == PO_GPR_REGISTER) {
+ if(PCOR(PCI(pc)->pcop)->r) {
+ pic14_allocWithIdx (PCOR(PCI(pc)->pcop)->r->rIdx);
+ DFPRINTF((stderr,"found register in pblock: reg 0x%x\n",PCOR(PCI(pc)->pcop)->r->rIdx));
+ } else {
+ if(PCI(pc)->pcop->name)
+ fprintf(stderr,"ERROR: %s is a NULL register\n",PCI(pc)->pcop->name );
+ else
+ fprintf(stderr,"ERROR: NULL register\n");
+ }
+ }
+ }
+
+
}
- }
- }
-
-
- }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void InsertpFlow(pCode *pc, pCode **pflow)
{
- if(*pflow)
- PCFL(*pflow)->end = pc;
-
- if(!pc || !pc->next)
- return;
-
- *pflow = newpCodeFlow();
- pCodeInsertAfter(pc, *pflow);
+ if(*pflow)
+ PCFL(*pflow)->end = pc;
+
+ if(!pc || !pc->next)
+ return;
+
+ *pflow = newpCodeFlow();
+ pCodeInsertAfter(pc, *pflow);
}
/*-----------------------------------------------------------------*/
/* BuildFlow(pBlock *pb) - examine the code in a pBlock and build */
/* the flow blocks. */
/*
- * BuildFlow inserts pCodeFlow objects into the pCode chain at each
- * point the instruction flow changes.
- */
+* BuildFlow inserts pCodeFlow objects into the pCode chain at each
+* point the instruction flow changes.
+*/
/*-----------------------------------------------------------------*/
void BuildFlow(pBlock *pb)
{
- pCode *pc;
- pCode *last_pci=NULL;
- pCode *pflow=NULL;
- int seq = 0;
-
- if(!pb)
- return;
-
- //fprintf (stderr,"build flow start seq %d ",GpcFlowSeq);
- /* Insert a pCodeFlow object at the beginning of a pBlock */
-
- InsertpFlow(pb->pcHead, &pflow);
-
- //pflow = newpCodeFlow(); /* Create a new Flow object */
- //pflow->next = pb->pcHead; /* Make the current head the next object */
- //pb->pcHead->prev = pflow; /* let the current head point back to the flow object */
- //pb->pcHead = pflow; /* Make the Flow object the head */
- //pflow->pb = pb;
-
- for( pc = findNextInstruction(pb->pcHead);
- pc != NULL;
- pc=findNextInstruction(pc)) {
-
- pc->seq = seq++;
- PCI(pc)->pcflow = PCFL(pflow);
-
- //fprintf(stderr," build: ");
- //pflow->print(stderr,pflow);
-
- if( PCI(pc)->isSkip) {
-
- /* The two instructions immediately following this one
- * mark the beginning of a new flow segment */
-
- while(pc && PCI(pc)->isSkip) {
-
- PCI(pc)->pcflow = PCFL(pflow);
- pc->seq = seq-1;
- seq = 1;
-
- InsertpFlow(pc, &pflow);
- pc=findNextInstruction(pc->next);
- }
-
- seq = 0;
-
- if(!pc)
- break;
-
- PCI(pc)->pcflow = PCFL(pflow);
- pc->seq = 0;
- InsertpFlow(pc, &pflow);
-
- } else if ( PCI(pc)->isBranch && !checkLabel(findNextInstruction(pc->next))) {
-
- InsertpFlow(pc, &pflow);
- seq = 0;
-
- } else if (checkLabel(pc)) {
-
- /* This instruction marks the beginning of a
- * new flow segment */
-
- pc->seq = 0;
- seq = 1;
-
- /* If the previous pCode is not a flow object, then
- * insert a new flow object. (This check prevents
- * two consecutive flow objects from being insert in
- * the case where a skip instruction preceeds an
- * instruction containing a label.) */
-
- if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow)))
- InsertpFlow(findPrevInstruction(pc->prev), &pflow);
-
- PCI(pc)->pcflow = PCFL(pflow);
-
- }
- last_pci = pc;
- pc = pc->next;
- }
-
- //fprintf (stderr,",end seq %d",GpcFlowSeq);
- if(pflow)
- PCFL(pflow)->end = pb->pcTail;
+ pCode *pc;
+ pCode *last_pci=NULL;
+ pCode *pflow=NULL;
+ int seq = 0;
+
+ if(!pb)
+ return;
+
+ //fprintf (stderr,"build flow start seq %d ",GpcFlowSeq);
+ /* Insert a pCodeFlow object at the beginning of a pBlock */
+
+ InsertpFlow(pb->pcHead, &pflow);
+
+ //pflow = newpCodeFlow(); /* Create a new Flow object */
+ //pflow->next = pb->pcHead; /* Make the current head the next object */
+ //pb->pcHead->prev = pflow; /* let the current head point back to the flow object */
+ //pb->pcHead = pflow; /* Make the Flow object the head */
+ //pflow->pb = pb;
+
+ for( pc = findNextInstruction(pb->pcHead);
+ pc != NULL;
+ pc=findNextInstruction(pc)) {
+
+ pc->seq = seq++;
+ PCI(pc)->pcflow = PCFL(pflow);
+
+ //fprintf(stderr," build: ");
+ //pflow->print(stderr,pflow);
+
+ if( PCI(pc)->isSkip) {
+
+ /* The two instructions immediately following this one
+ * mark the beginning of a new flow segment */
+
+ while(pc && PCI(pc)->isSkip) {
+
+ PCI(pc)->pcflow = PCFL(pflow);
+ pc->seq = seq-1;
+ seq = 1;
+
+ InsertpFlow(pc, &pflow);
+ pc=findNextInstruction(pc->next);
+ }
+
+ seq = 0;
+
+ if(!pc)
+ break;
+
+ PCI(pc)->pcflow = PCFL(pflow);
+ pc->seq = 0;
+ InsertpFlow(pc, &pflow);
+
+ } else if ( PCI(pc)->isBranch && !checkLabel(findNextInstruction(pc->next))) {
+
+ InsertpFlow(pc, &pflow);
+ seq = 0;
+
+ } else if (checkLabel(pc)) {
+
+ /* This instruction marks the beginning of a
+ * new flow segment */
+
+ pc->seq = 0;
+ seq = 1;
+
+ /* If the previous pCode is not a flow object, then
+ * insert a new flow object. (This check prevents
+ * two consecutive flow objects from being insert in
+ * the case where a skip instruction preceeds an
+ * instruction containing a label.) */
+
+ if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow)))
+ InsertpFlow(findPrevInstruction(pc->prev), &pflow);
+
+ PCI(pc)->pcflow = PCFL(pflow);
+
+ }
+ last_pci = pc;
+ pc = pc->next;
+ }
+
+ //fprintf (stderr,",end seq %d",GpcFlowSeq);
+ if(pflow)
+ PCFL(pflow)->end = pb->pcTail;
}
/*-------------------------------------------------------------------*/
/* unBuildFlow(pBlock *pb) - examine the code in a pBlock and build */
/* the flow blocks. */
/*
- * unBuildFlow removes pCodeFlow objects from a pCode chain
- */
+* unBuildFlow removes pCodeFlow objects from a pCode chain
+*/
/*-----------------------------------------------------------------*/
void unBuildFlow(pBlock *pb)
{
- pCode *pc,*pcnext;
-
- if(!pb)
- return;
-
- pc = pb->pcHead;
-
- while(pc) {
- pcnext = pc->next;
-
- if(isPCI(pc)) {
-
- pc->seq = 0;
- if(PCI(pc)->pcflow) {
- //free(PCI(pc)->pcflow);
- PCI(pc)->pcflow = NULL;
- }
-
- } else if(isPCFL(pc) )
- pc->destruct(pc);
-
- pc = pcnext;
- }
-
-
+ pCode *pc,*pcnext;
+
+ if(!pb)
+ return;
+
+ pc = pb->pcHead;
+
+ while(pc) {
+ pcnext = pc->next;
+
+ if(isPCI(pc)) {
+
+ pc->seq = 0;
+ if(PCI(pc)->pcflow) {
+ //free(PCI(pc)->pcflow);
+ PCI(pc)->pcflow = NULL;
+ }
+
+ } else if(isPCFL(pc) )
+ pc->destruct(pc);
+
+ pc = pcnext;
+ }
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void dumpCond(int cond)
{
-
- static char *pcc_str[] = {
- //"PCC_NONE",
- "PCC_REGISTER",
- "PCC_C",
- "PCC_Z",
- "PCC_DC",
- "PCC_W",
- "PCC_EXAMINE_PCOP",
- "PCC_REG_BANK0",
- "PCC_REG_BANK1",
- "PCC_REG_BANK2",
- "PCC_REG_BANK3"
- };
-
- int ncond = sizeof(pcc_str) / sizeof(char *);
- int i,j;
-
- fprintf(stderr, "0x%04X\n",cond);
-
- for(i=0,j=1; i<ncond; i++, j<<=1)
- if(cond & j)
- fprintf(stderr, " %s\n",pcc_str[i]);
-
+
+ static char *pcc_str[] = {
+ //"PCC_NONE",
+ "PCC_REGISTER",
+ "PCC_C",
+ "PCC_Z",
+ "PCC_DC",
+ "PCC_W",
+ "PCC_EXAMINE_PCOP",
+ "PCC_REG_BANK0",
+ "PCC_REG_BANK1",
+ "PCC_REG_BANK2",
+ "PCC_REG_BANK3"
+ };
+
+ int ncond = sizeof(pcc_str) / sizeof(char *);
+ int i,j;
+
+ fprintf(stderr, "0x%04X\n",cond);
+
+ for(i=0,j=1; i<ncond; i++, j<<=1)
+ if(cond & j)
+ fprintf(stderr, " %s\n",pcc_str[i]);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void FlowStats(pCodeFlow *pcflow)
{
-
- pCode *pc;
-
- if(!isPCFL(pcflow))
- return;
-
- fprintf(stderr, " FlowStats - flow block (seq=%d)\n", pcflow->pc.seq);
-
- pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
-
- if(!pc) {
- fprintf(stderr, " FlowStats - empty flow (seq=%d)\n", pcflow->pc.seq);
- return;
- }
-
-
- fprintf(stderr, " FlowStats inCond: ");
- dumpCond(pcflow->inCond);
- fprintf(stderr, " FlowStats outCond: ");
- dumpCond(pcflow->outCond);
-
+
+ pCode *pc;
+
+ if(!isPCFL(pcflow))
+ return;
+
+ fprintf(stderr, " FlowStats - flow block (seq=%d)\n", pcflow->pc.seq);
+
+ pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
+
+ if(!pc) {
+ fprintf(stderr, " FlowStats - empty flow (seq=%d)\n", pcflow->pc.seq);
+ return;
+ }
+
+
+ fprintf(stderr, " FlowStats inCond: ");
+ dumpCond(pcflow->inCond);
+ fprintf(stderr, " FlowStats outCond: ");
+ dumpCond(pcflow->outCond);
+
}
/*-----------------------------------------------------------------*
- * int isBankInstruction(pCode *pc) - examine the pCode *pc to determine
- * if it affects the banking bits.
- *
- * return: -1 == Banking bits are unaffected by this pCode.
- *
- * return: > 0 == Banking bits are affected.
- *
- * If the banking bits are affected, then the returned value describes
- * which bits are affected and how they're affected. The lower half
- * of the integer maps to the bits that are affected, the upper half
- * to whether they're set or cleared.
- *
- *-----------------------------------------------------------------*/
+* int isBankInstruction(pCode *pc) - examine the pCode *pc to determine
+* if it affects the banking bits.
+*
+* return: -1 == Banking bits are unaffected by this pCode.
+*
+* return: > 0 == Banking bits are affected.
+*
+* If the banking bits are affected, then the returned value describes
+* which bits are affected and how they're affected. The lower half
+* of the integer maps to the bits that are affected, the upper half
+* to whether they're set or cleared.
+*
+*-----------------------------------------------------------------*/
/*
#define SET_BANK_BIT (1 << 16)
#define CLR_BANK_BIT 0
static int isBankInstruction(pCode *pc)
{
- regs *reg;
- int bank = -1;
-
- if(!isPCI(pc))
- return -1;
-
- if( ( (reg = getRegFromInstruction(pc)) != NULL) && isSTATUS_REG(reg)) {
-
- // Check to see if the register banks are changing
- if(PCI(pc)->isModReg) {
-
- pCodeOp *pcop = PCI(pc)->pcop;
- switch(PCI(pc)->op) {
-
- case POC_BSF:
- if(PCORB(pcop)->bit == PIC_RP0_BIT) {
- //fprintf(stderr, " isBankInstruction - Set RP0\n");
- return SET_BANK_BIT | PIC_RP0_BIT;
- }
-
- if(PCORB(pcop)->bit == PIC_RP1_BIT) {
- //fprintf(stderr, " isBankInstruction - Set RP1\n");
- return CLR_BANK_BIT | PIC_RP0_BIT;
- }
- break;
-
- case POC_BCF:
- if(PCORB(pcop)->bit == PIC_RP0_BIT) {
- //fprintf(stderr, " isBankInstruction - Clr RP0\n");
- return CLR_BANK_BIT | PIC_RP1_BIT;
- }
- if(PCORB(pcop)->bit == PIC_RP1_BIT) {
- //fprintf(stderr, " isBankInstruction - Clr RP1\n");
- return CLR_BANK_BIT | PIC_RP1_BIT;
+ regs *reg;
+ int bank = -1;
+
+ if(!isPCI(pc))
+ return -1;
+
+ if( ( (reg = getRegFromInstruction(pc)) != NULL) && isSTATUS_REG(reg)) {
+
+ // Check to see if the register banks are changing
+ if(PCI(pc)->isModReg) {
+
+ pCodeOp *pcop = PCI(pc)->pcop;
+ switch(PCI(pc)->op) {
+
+ case POC_BSF:
+ if(PCORB(pcop)->bit == PIC_RP0_BIT) {
+ //fprintf(stderr, " isBankInstruction - Set RP0\n");
+ return SET_BANK_BIT | PIC_RP0_BIT;
+ }
+
+ if(PCORB(pcop)->bit == PIC_RP1_BIT) {
+ //fprintf(stderr, " isBankInstruction - Set RP1\n");
+ return CLR_BANK_BIT | PIC_RP0_BIT;
+ }
+ break;
+
+ case POC_BCF:
+ if(PCORB(pcop)->bit == PIC_RP0_BIT) {
+ //fprintf(stderr, " isBankInstruction - Clr RP0\n");
+ return CLR_BANK_BIT | PIC_RP1_BIT;
+ }
+ if(PCORB(pcop)->bit == PIC_RP1_BIT) {
+ //fprintf(stderr, " isBankInstruction - Clr RP1\n");
+ return CLR_BANK_BIT | PIC_RP1_BIT;
+ }
+ break;
+ default:
+ //fprintf(stderr, " isBankInstruction - Status register is getting Modified by:\n");
+ //genericPrint(stderr, pc);
+ ;
+ }
+ }
+
}
- break;
- default:
- //fprintf(stderr, " isBankInstruction - Status register is getting Modified by:\n");
- //genericPrint(stderr, pc);
- ;
- }
- }
-
- }
-
- return bank;
+
+ return bank;
}
*/
/*
static void FillFlow(pCodeFlow *pcflow)
{
- pCode *pc;
- int cur_bank;
-
- if(!isPCFL(pcflow))
- return;
-
- // fprintf(stderr, " FillFlow - flow block (seq=%d)\n", pcflow->pc.seq);
-
- pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
-
- if(!pc) {
- //fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq);
- return;
- }
-
- cur_bank = -1;
-
- do {
- isBankInstruction(pc);
- pc = pc->next;
- } while (pc && (pc != pcflow->end) && !isPCFL(pc));
-/ *
- if(!pc ) {
- fprintf(stderr, " FillFlow - Bad end of flow\n");
- } else {
- fprintf(stderr, " FillFlow - Ending flow with\n ");
- pc->print(stderr,pc);
- }
+ pCode *pc;
+ int cur_bank;
+
+ if(!isPCFL(pcflow))
+ return;
+
+ // fprintf(stderr, " FillFlow - flow block (seq=%d)\n", pcflow->pc.seq);
+
+ pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
+
+ if(!pc) {
+ //fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq);
+ return;
+ }
+
+ cur_bank = -1;
+
+ do {
+ isBankInstruction(pc);
+ pc = pc->next;
+ } while (pc && (pc != pcflow->end) && !isPCFL(pc));
+ / *
+ if(!pc ) {
+ fprintf(stderr, " FillFlow - Bad end of flow\n");
+ } else {
+ fprintf(stderr, " FillFlow - Ending flow with\n ");
+ pc->print(stderr,pc);
+ }
- fprintf(stderr, " FillFlow inCond: ");
- dumpCond(pcflow->inCond);
- fprintf(stderr, " FillFlow outCond: ");
- dumpCond(pcflow->outCond);
-* /
+ fprintf(stderr, " FillFlow inCond: ");
+ dumpCond(pcflow->inCond);
+ fprintf(stderr, " FillFlow outCond: ");
+ dumpCond(pcflow->outCond);
+ * /
}
*/
/*-----------------------------------------------------------------*/
void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
{
- pCodeFlowLink *fromLink, *toLink;
-
- if(!from || !to || !to->pcflow || !from->pcflow)
- return;
-
- fromLink = newpCodeFlowLink(from->pcflow);
- toLink = newpCodeFlowLink(to->pcflow);
-
- addSetIfnotP(&(from->pcflow->to), toLink); //to->pcflow);
- addSetIfnotP(&(to->pcflow->from), fromLink); //from->pcflow);
-
+ pCodeFlowLink *fromLink, *toLink;
+
+ if(!from || !to || !to->pcflow || !from->pcflow)
+ return;
+
+ fromLink = newpCodeFlowLink(from->pcflow);
+ toLink = newpCodeFlowLink(to->pcflow);
+
+ addSetIfnotP(&(from->pcflow->to), toLink); //to->pcflow);
+ addSetIfnotP(&(to->pcflow->from), fromLink); //from->pcflow);
+
}
/*-----------------------------------------------------------------*
- * void LinkFlow(pBlock *pb)
- *
- * In BuildFlow, the PIC code has been partitioned into contiguous
- * non-branching segments. In LinkFlow, we determine the execution
- * order of these segments. For example, if one of the segments ends
- * with a skip, then we know that there are two possible flow segments
- * to which control may be passed.
- *-----------------------------------------------------------------*/
+* void LinkFlow(pBlock *pb)
+*
+* In BuildFlow, the PIC code has been partitioned into contiguous
+* non-branching segments. In LinkFlow, we determine the execution
+* order of these segments. For example, if one of the segments ends
+* with a skip, then we know that there are two possible flow segments
+* to which control may be passed.
+*-----------------------------------------------------------------*/
void LinkFlow(pBlock *pb)
{
- pCode *pc=NULL;
- pCode *pcflow;
- pCode *pct;
-
- //fprintf(stderr,"linkflow \n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow))
- fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
-
- //fprintf(stderr," link: ");
- //pcflow->print(stderr,pcflow);
-
- //FillFlow(PCFL(pcflow));
-
- pc = PCFL(pcflow)->end;
-
- //fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq);
- if(isPCI_SKIP(pc)) {
- //fprintf(stderr, "ends with skip\n");
- //pc->print(stderr,pc);
- pct=findNextInstruction(pc->next);
- LinkFlow_pCode(PCI(pc),PCI(pct));
- pct=findNextInstruction(pct->next);
- LinkFlow_pCode(PCI(pc),PCI(pct));
- continue;
- }
-
- if(isPCI_BRANCH(pc)) {
- pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
-
- //fprintf(stderr, "ends with branch\n ");
- //pc->print(stderr,pc);
-
- if(!(pcol && isPCOLAB(pcol))) {
- if((PCI(pc)->op != POC_RETLW) && (PCI(pc)->op != POC_RETURN) && (PCI(pc)->op != POC_CALL) && (PCI(pc)->op != POC_RETFIE) ) {
- pc->print(stderr,pc);
- fprintf(stderr, "ERROR: %s, branch instruction doesn't have label\n",__FUNCTION__);
+ pCode *pc=NULL;
+ pCode *pcflow;
+ pCode *pct;
+
+ //fprintf(stderr,"linkflow \n");
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ if(!isPCFL(pcflow))
+ fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
+
+ //fprintf(stderr," link: ");
+ //pcflow->print(stderr,pcflow);
+
+ //FillFlow(PCFL(pcflow));
+
+ pc = PCFL(pcflow)->end;
+
+ //fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq);
+ if(isPCI_SKIP(pc)) {
+ //fprintf(stderr, "ends with skip\n");
+ //pc->print(stderr,pc);
+ pct=findNextInstruction(pc->next);
+ LinkFlow_pCode(PCI(pc),PCI(pct));
+ pct=findNextInstruction(pct->next);
+ LinkFlow_pCode(PCI(pc),PCI(pct));
+ continue;
+ }
+
+ if(isPCI_BRANCH(pc)) {
+ pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
+
+ //fprintf(stderr, "ends with branch\n ");
+ //pc->print(stderr,pc);
+
+ if(!(pcol && isPCOLAB(pcol))) {
+ if((PCI(pc)->op != POC_RETLW) && (PCI(pc)->op != POC_RETURN) && (PCI(pc)->op != POC_CALL) && (PCI(pc)->op != POC_RETFIE) ) {
+ pc->print(stderr,pc);
+ fprintf(stderr, "ERROR: %s, branch instruction doesn't have label\n",__FUNCTION__);
+ }
+ continue;
+ }
+
+ if( (pct = findLabelinpBlock(pb,pcol)) != NULL)
+ LinkFlow_pCode(PCI(pc),PCI(pct));
+ else
+ fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n",
+ __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-"));
+ //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
+
+ continue;
+ }
+
+ if(isPCI(pc)) {
+ //fprintf(stderr, "ends with non-branching instruction:\n");
+ //pc->print(stderr,pc);
+
+ LinkFlow_pCode(PCI(pc),PCI(findNextInstruction(pc->next)));
+
+ continue;
+ }
+
+ if(pc) {
+ //fprintf(stderr, "ends with unknown\n");
+ //pc->print(stderr,pc);
+ continue;
+ }
+
+ //fprintf(stderr, "ends with nothing: ERROR\n");
+
}
- continue;
- }
-
- if( (pct = findLabelinpBlock(pb,pcol)) != NULL)
- LinkFlow_pCode(PCI(pc),PCI(pct));
- else
- fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n",
- __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-"));
- //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
-
- continue;
- }
-
- if(isPCI(pc)) {
- //fprintf(stderr, "ends with non-branching instruction:\n");
- //pc->print(stderr,pc);
-
- LinkFlow_pCode(PCI(pc),PCI(findNextInstruction(pc->next)));
-
- continue;
- }
-
- if(pc) {
- //fprintf(stderr, "ends with unknown\n");
- //pc->print(stderr,pc);
- continue;
- }
-
- //fprintf(stderr, "ends with nothing: ERROR\n");
-
- }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int isPCinFlow(pCode *pc, pCode *pcflow)
{
-
- if(!pc || !pcflow)
- return 0;
-
- if(!isPCI(pc) || !PCI(pc)->pcflow || !isPCFL(pcflow) )
- return 0;
-
- if( PCI(pc)->pcflow->pc.seq == pcflow->seq)
- return 1;
-
- return 0;
+
+ if(!pc || !pcflow)
+ return 0;
+
+ if(!isPCI(pc) || !PCI(pc)->pcflow || !isPCFL(pcflow) )
+ return 0;
+
+ if( PCI(pc)->pcflow->pc.seq == pcflow->seq)
+ return 1;
+
+ return 0;
}
/*-----------------------------------------------------------------*/
/*
static void BanksUsedFlow2(pCode *pcflow)
{
- pCode *pc=NULL;
-
- int bank = -1;
- bool RegUsed = 0;
-
- regs *reg;
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "BanksUsed - pcflow is not a flow object ");
- return;
- }
-
- pc = findNextInstruction(pcflow->next);
-
- PCFL(pcflow)->lastBank = -1;
-
- while(isPCinFlow(pc,pcflow)) {
-
- int bank_selected = isBankInstruction(pc);
-
- //if(PCI(pc)->pcflow)
- //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq);
-
- if(bank_selected > 0) {
- //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected);
-
- // This instruction is modifying banking bits before accessing registers
- if(!RegUsed)
- PCFL(pcflow)->firstBank = -1;
-
- if(PCFL(pcflow)->lastBank == -1)
- PCFL(pcflow)->lastBank = 0;
-
- bank = (1 << (bank_selected & (PIC_RP0_BIT | PIC_RP1_BIT)));
- if(bank_selected & SET_BANK_BIT)
- PCFL(pcflow)->lastBank |= bank;
-
-
- } else {
- reg = getRegFromInstruction(pc);
-
- if(reg && !isREGinBank(reg, bank)) {
- int allbanks = REGallBanks(reg);
- if(bank == -1)
- PCFL(pcflow)->firstBank = allbanks;
-
- PCFL(pcflow)->lastBank = allbanks;
-
- bank = allbanks;
- }
- RegUsed = 1;
- }
-
- pc = findNextInstruction(pc->next);
- }
-
-// fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n",
-// pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank);
+ pCode *pc=NULL;
+
+ int bank = -1;
+ bool RegUsed = 0;
+
+ regs *reg;
+
+ if(!isPCFL(pcflow)) {
+ fprintf(stderr, "BanksUsed - pcflow is not a flow object ");
+ return;
+ }
+
+ pc = findNextInstruction(pcflow->next);
+
+ PCFL(pcflow)->lastBank = -1;
+
+ while(isPCinFlow(pc,pcflow)) {
+
+ int bank_selected = isBankInstruction(pc);
+
+ //if(PCI(pc)->pcflow)
+ //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq);
+
+ if(bank_selected > 0) {
+ //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected);
+
+ // This instruction is modifying banking bits before accessing registers
+ if(!RegUsed)
+ PCFL(pcflow)->firstBank = -1;
+
+ if(PCFL(pcflow)->lastBank == -1)
+ PCFL(pcflow)->lastBank = 0;
+
+ bank = (1 << (bank_selected & (PIC_RP0_BIT | PIC_RP1_BIT)));
+ if(bank_selected & SET_BANK_BIT)
+ PCFL(pcflow)->lastBank |= bank;
+
+
+ } else {
+ reg = getRegFromInstruction(pc);
+
+ if(reg && !isREGinBank(reg, bank)) {
+ int allbanks = REGallBanks(reg);
+ if(bank == -1)
+ PCFL(pcflow)->firstBank = allbanks;
+
+ PCFL(pcflow)->lastBank = allbanks;
+
+ bank = allbanks;
+ }
+ RegUsed = 1;
+ }
+
+ pc = findNextInstruction(pc->next);
+ }
+
+ // fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n",
+ // pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank);
}
*/
/*-----------------------------------------------------------------*/
/*
static void BanksUsedFlow(pBlock *pb)
{
- pCode *pcflow;
+pCode *pcflow;
- //pb->pcHead->print(stderr, pb->pcHead);
-
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- //pcflow->print(stderr,pcflow);
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- BanksUsedFlow2(pcflow);
- }
+ //pb->pcHead->print(stderr, pb->pcHead);
+
+ pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ //pcflow->print(stderr,pcflow);
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ BanksUsedFlow2(pcflow);
+ }
}
*/
/*-----------------------------------------------------------------*/
static void pCodeInstructionInsertAfter(pCodeInstruction *pci, pCodeInstruction *new_pci)
{
-
- pCodeInsertAfter(pci->pc.prev, &new_pci->pc);
-
- /* Move the label, if there is one */
-
- if(pci->label) {
- new_pci->label = pci->label;
- pci->label = NULL;
- }
-
- /* Move the C code comment, if there is one */
-
- if(pci->cline) {
- new_pci->cline = pci->cline;
- pci->cline = NULL;
- }
-
- /* The new instruction has the same pcflow block */
- new_pci->pcflow = pci->pcflow;
-
+
+ pCodeInsertAfter(pci->pc.prev, &new_pci->pc);
+
+ /* Move the label, if there is one */
+
+ if(pci->label) {
+ new_pci->label = pci->label;
+ pci->label = NULL;
+ }
+
+ /* Move the C code comment, if there is one */
+
+ if(pci->cline) {
+ new_pci->cline = pci->cline;
+ pci->cline = NULL;
+ }
+
+ /* The new instruction has the same pcflow block */
+ new_pci->pcflow = pci->pcflow;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBit)
{
- pCode *new_pc;
-
- new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
-
- pCodeInstructionInsertAfter(pci, PCI(new_pc));
+ pCode *new_pc;
+
+ new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
+
+ pCodeInstructionInsertAfter(pci, PCI(new_pc));
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void insertBankSel(pCodeInstruction *pci, const char *name)
{
- pCode *new_pc;
-
- pCodeOp *pcop = popCopyReg(PCOR(pci->pcop));
- pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it
- if (pcop->name == 0)
- pcop->name = strdup(name);
- new_pc = newpCode(POC_BANKSEL, pcop);
-
- pCodeInstructionInsertAfter(pci, PCI(new_pc));
+ pCode *new_pc;
+
+ pCodeOp *pcop = popCopyReg(PCOR(pci->pcop));
+ pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it
+ if (pcop->name == 0)
+ pcop->name = strdup(name);
+ new_pc = newpCode(POC_BANKSEL, pcop);
+
+ pCodeInstructionInsertAfter(pci, PCI(new_pc));
}
/*-----------------------------------------------------------------*/
static int LastRegIdx; /* If the previous register is the same one again then no need to change bank. */
static int BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg)
{
- int bank;
- int a = reg->alias>>7;
- if ((a&3) == 3) {
- return cur_bank; // This register is available in all banks
- } else if ((a&1)&&((cur_bank==0)||(cur_bank==1))) {
- return cur_bank; // This register is available in banks 0 & 1
- } else if (a&2) {
- if (reg->address&0x80) {
- if ((cur_bank==1)||(cur_bank==3)) {
- return cur_bank; // This register is available in banks 1 & 3
- }
- } else {
- if ((cur_bank==0)||(cur_bank==1)) {
- return cur_bank; // This register is available in banks 0 & 2
- }
- }
- }
-
- if (LastRegIdx == reg->rIdx) // If this is the same register as last time then it is in same bank
- return cur_bank;
- LastRegIdx = reg->rIdx;
-
- if (reg->isFixed) {
- bank = REG_BANK(reg);
- } else if (reg->isExtern) {
- bank = 'E'; // Unfixed extern registers are allocated by the linker therefore its bank is unknown
- } else {
- bank = 'L'; // Unfixed local registers are allocated by the linker therefore its bank is unknown
- }
- if ((cur_bank == 'L')&&(bank == 'L')) { // If current bank and new bank are both allocated locally by the linker, then assume it is in same bank.
- return 'L'; // Local registers are presumed to be in same linker assigned bank
- } else if ((bank == 'L')&&(cur_bank != 'L')) { // Reg is now local and linker to assign bank
- insertBankSel(pci, reg->name); // Let linker choose the bank selection
- } else if (bank == 'E') { // Reg is now extern and linker to assign bank
- insertBankSel(pci, reg->name); // Let linker choose the bank selection
- } else if ((cur_bank == -1)||(cur_bank == 'L')||(cur_bank == 'E')) { // Current bank unknown and new register bank is known then can set bank bits
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- } else { // Current bank and new register banks known - can set bank bits
- switch((cur_bank^bank) & 3) {
- case 0:
- break;
- case 1:
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- break;
- case 2:
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- break;
- case 3:
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- break;
- }
- }
-
- return bank;
+ int bank;
+ int a = reg->alias>>7;
+ if ((a&3) == 3) {
+ return cur_bank; // This register is available in all banks
+ } else if ((a&1)&&((cur_bank==0)||(cur_bank==1))) {
+ return cur_bank; // This register is available in banks 0 & 1
+ } else if (a&2) {
+ if (reg->address&0x80) {
+ if ((cur_bank==1)||(cur_bank==3)) {
+ return cur_bank; // This register is available in banks 1 & 3
+ }
+ } else {
+ if ((cur_bank==0)||(cur_bank==1)) {
+ return cur_bank; // This register is available in banks 0 & 2
+ }
+ }
+ }
+
+ if (LastRegIdx == reg->rIdx) // If this is the same register as last time then it is in same bank
+ return cur_bank;
+ LastRegIdx = reg->rIdx;
+
+ if (reg->isFixed) {
+ bank = REG_BANK(reg);
+ } else if (reg->isExtern) {
+ bank = 'E'; // Unfixed extern registers are allocated by the linker therefore its bank is unknown
+ } else {
+ bank = 'L'; // Unfixed local registers are allocated by the linker therefore its bank is unknown
+ }
+ if ((cur_bank == 'L')&&(bank == 'L')) { // If current bank and new bank are both allocated locally by the linker, then assume it is in same bank.
+ return 'L'; // Local registers are presumed to be in same linker assigned bank
+ } else if ((bank == 'L')&&(cur_bank != 'L')) { // Reg is now local and linker to assign bank
+ insertBankSel(pci, reg->name); // Let linker choose the bank selection
+ } else if (bank == 'E') { // Reg is now extern and linker to assign bank
+ insertBankSel(pci, reg->name); // Let linker choose the bank selection
+ } else if ((cur_bank == -1)||(cur_bank == 'L')||(cur_bank == 'E')) { // Current bank unknown and new register bank is known then can set bank bits
+ insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
+ insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
+ } else { // Current bank and new register banks known - can set bank bits
+ switch((cur_bank^bank) & 3) {
+ case 0:
+ break;
+ case 1:
+ insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
+ break;
+ case 2:
+ insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
+ break;
+ case 3:
+ insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
+ insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
+ break;
+ }
+ }
+
+ return bank;
}
/*-----------------------------------------------------------------*/
/* cur_bank to match. */
/*-----------------------------------------------------------------*/
static int IsBankChange(pCode *pc, regs *reg, int *cur_bank) {
-
- if (isSTATUS_REG(reg)) {
-
- if (PCI(pc)->op == POC_BCF) {
- int old_bank = *cur_bank;
- if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
- /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0;
- else
- *cur_bank = *cur_bank&0x2;
- LastRegIdx = reg->rIdx;
- } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
- /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0;
- else
- *cur_bank = *cur_bank&0x1;
- LastRegIdx = reg->rIdx;
- }
- return old_bank != *cur_bank;
- }
-
- if (PCI(pc)->op == POC_BSF) {
- int old_bank = *cur_bank;
- if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
- /* If current bank is unknown or linker assigned then set to bit else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0x1;
- else
- *cur_bank = (*cur_bank&0x2) | 0x1;
- LastRegIdx = reg->rIdx;
- } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
- /* If current bank is unknown or linker assigned then set to bit else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0x2;
- else
- *cur_bank = (*cur_bank&0x1) | 0x2;
- LastRegIdx = reg->rIdx;
- }
- return old_bank != *cur_bank;
- }
-
- } else if (PCI(pc)->op == POC_BANKSEL) {
- int old_bank = *cur_bank;
- *cur_bank = (PCOR(PCI(pc)->pcop)->r->isExtern) ? 'E' : 'L';
- LastRegIdx = reg->rIdx;
- return old_bank != *cur_bank;
- }
-
- return 0;
+
+ if (isSTATUS_REG(reg)) {
+
+ if (PCI(pc)->op == POC_BCF) {
+ int old_bank = *cur_bank;
+ if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
+ /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
+ if (*cur_bank & ~(0x3))
+ *cur_bank = 0;
+ else
+ *cur_bank = *cur_bank&0x2;
+ LastRegIdx = reg->rIdx;
+ } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
+ /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
+ if (*cur_bank & ~(0x3))
+ *cur_bank = 0;
+ else
+ *cur_bank = *cur_bank&0x1;
+ LastRegIdx = reg->rIdx;
+ }
+ return old_bank != *cur_bank;
+ }
+
+ if (PCI(pc)->op == POC_BSF) {
+ int old_bank = *cur_bank;
+ if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
+ /* If current bank is unknown or linker assigned then set to bit else just change the bit */
+ if (*cur_bank & ~(0x3))
+ *cur_bank = 0x1;
+ else
+ *cur_bank = (*cur_bank&0x2) | 0x1;
+ LastRegIdx = reg->rIdx;
+ } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
+ /* If current bank is unknown or linker assigned then set to bit else just change the bit */
+ if (*cur_bank & ~(0x3))
+ *cur_bank = 0x2;
+ else
+ *cur_bank = (*cur_bank&0x1) | 0x2;
+ LastRegIdx = reg->rIdx;
+ }
+ return old_bank != *cur_bank;
+ }
+
+ } else if (PCI(pc)->op == POC_BANKSEL) {
+ int old_bank = *cur_bank;
+ *cur_bank = (PCOR(PCI(pc)->pcop)->r->isExtern) ? 'E' : 'L';
+ LastRegIdx = reg->rIdx;
+ return old_bank != *cur_bank;
+ }
+
+ return 0;
}
/*-----------------------------------------------------------------*/
/* Set bank selection if necessary */
/*-----------------------------------------------------------------*/
static int DoBankSelect(pCode *pc, int cur_bank) {
- pCode *pcprev;
- regs *reg;
-
- if(!isPCI(pc))
- return cur_bank;
-
- if (isCALL(pc)) {
- pCode *pcf = findFunction(get_op_from_instruction(PCI(pc)));
- if (pcf && isPCF(pcf)) {
- pCode *pcfr;
- int rbank = 'U'; // Undetermined
- FixRegisterBanking(pcf->pb,cur_bank); // Ensure this block has had its banks selection done
- // Check all the returns to work out what bank is selected
- for (pcfr=pcf->pb->pcHead; pcfr; pcfr=pcfr->next) {
- if (isPCI(pcfr)) {
- if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) {
- if (rbank == 'U')
- rbank = PCFL(pcfr)->lastBank;
- else
- if (rbank != PCFL(pcfr)->lastBank)
- return -1; // Unknown bank - multiple returns with different banks
- }
- }
- }
- if (rbank == 'U')
- return -1; // Unknown bank
- return rbank;
- } else if (isPCOS(PCI(pc)->pcop) && PCOS(PCI(pc)->pcop)->isPublic) {
- /* Extern functions may use registers in different bank - must call banksel */
- return -1; /* Unknown bank */
- }
- }
-
- if ((isPCI(pc)) && (PCI(pc)->op == POC_BANKSEL)) {
- return -1; /* New bank unknown - linkers choice. */
- }
-
- reg = getRegFromInstruction(pc);
- if (reg) {
-
- if (IsBankChange(pc,reg,&cur_bank))
- return cur_bank;
-
- if (!isPCI_LIT(pc)) {
-
- /* Examine the instruction before this one to make sure it is
- * not a skip type instruction */
- pcprev = findPrevpCode(pc->prev, PC_OPCODE);
-
- if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
- cur_bank = BankSelect(PCI(pc),cur_bank,reg);
- } else {
- cur_bank = BankSelect(PCI(pcprev),cur_bank,reg);
- }
- if (!PCI(pc)->pcflow)
- fprintf(stderr,"PCI ID=%d missing flow pointer ???\n",pc->id);
- else
- PCI(pc)->pcflow->lastBank = cur_bank; /* Maintain pCodeFlow lastBank state */
- }
- }
- return cur_bank;
+ pCode *pcprev;
+ regs *reg;
+
+ if(!isPCI(pc))
+ return cur_bank;
+
+ if (isCALL(pc)) {
+ pCode *pcf = findFunction(get_op_from_instruction(PCI(pc)));
+ if (pcf && isPCF(pcf)) {
+ pCode *pcfr;
+ int rbank = 'U'; // Undetermined
+ FixRegisterBanking(pcf->pb,cur_bank); // Ensure this block has had its banks selection done
+ // Check all the returns to work out what bank is selected
+ for (pcfr=pcf->pb->pcHead; pcfr; pcfr=pcfr->next) {
+ if (isPCI(pcfr)) {
+ if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) {
+ if (rbank == 'U')
+ rbank = PCFL(pcfr)->lastBank;
+ else
+ if (rbank != PCFL(pcfr)->lastBank)
+ return -1; // Unknown bank - multiple returns with different banks
+ }
+ }
+ }
+ if (rbank == 'U')
+ return -1; // Unknown bank
+ return rbank;
+ } else if (isPCOS(PCI(pc)->pcop) && PCOS(PCI(pc)->pcop)->isPublic) {
+ /* Extern functions may use registers in different bank - must call banksel */
+ return -1; /* Unknown bank */
+ }
+ }
+
+ if ((isPCI(pc)) && (PCI(pc)->op == POC_BANKSEL)) {
+ return -1; /* New bank unknown - linkers choice. */
+ }
+
+ reg = getRegFromInstruction(pc);
+ if (reg) {
+
+ if (IsBankChange(pc,reg,&cur_bank))
+ return cur_bank;
+
+ if (!isPCI_LIT(pc)) {
+
+ /* Examine the instruction before this one to make sure it is
+ * not a skip type instruction */
+ pcprev = findPrevpCode(pc->prev, PC_OPCODE);
+
+ if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
+ cur_bank = BankSelect(PCI(pc),cur_bank,reg);
+ } else {
+ cur_bank = BankSelect(PCI(pcprev),cur_bank,reg);
+ }
+ if (!PCI(pc)->pcflow)
+ fprintf(stderr,"PCI ID=%d missing flow pointer ???\n",pc->id);
+ else
+ PCI(pc)->pcflow->lastBank = cur_bank; /* Maintain pCodeFlow lastBank state */
+ }
+ }
+ return cur_bank;
}
/*-----------------------------------------------------------------*/
/*
static void FixRegisterBankingInFlow(pCodeFlow *pcfl, int cur_bank)
{
- pCode *pc=NULL;
- pCode *pcprev=NULL;
+ pCode *pc=NULL;
+ pCode *pcprev=NULL;
- if(!pcfl)
- return;
+ if(!pcfl)
+ return;
- pc = findNextInstruction(pcfl->pc.next);
-
- while(isPCinFlow(pc,PCODE(pcfl))) {
-
- cur_bank = DoBankSelect(pc,cur_bank);
- pcprev = pc;
- pc = findNextInstruction(pc->next);
+ pc = findNextInstruction(pcfl->pc.next);
+
+ while(isPCinFlow(pc,PCODE(pcfl))) {
- }
+ cur_bank = DoBankSelect(pc,cur_bank);
+ pcprev = pc;
+ pc = findNextInstruction(pc->next);
+
+ }
- if(pcprev && cur_bank) {
- // Set bank state to unknown at the end of each flow block
- cur_bank = -1;
- }
+ if(pcprev && cur_bank) {
+ // Set bank state to unknown at the end of each flow block
+ cur_bank = -1;
+ }
}
*/
/*
int compareBankFlow(pCodeFlow *pcflow, pCodeFlowLink *pcflowLink, int toORfrom)
{
-
- if(!pcflow || !pcflowLink || !pcflowLink->pcflow)
- return 0;
-
- if(!isPCFL(pcflow) || !isPCFL(pcflowLink->pcflow))
- return 0;
-
- if(pcflow->firstBank == -1)
- return 0;
-
-
- if(pcflowLink->pcflow->firstBank == -1) {
- pCodeFlowLink *pctl = setFirstItem( toORfrom ?
- pcflowLink->pcflow->to :
- pcflowLink->pcflow->from);
- return compareBankFlow(pcflow, pctl, toORfrom);
- }
-
- if(toORfrom) {
- if(pcflow->lastBank == pcflowLink->pcflow->firstBank)
- return 0;
-
- pcflowLink->bank_conflict++;
- pcflowLink->pcflow->FromConflicts++;
- pcflow->ToConflicts++;
- } else {
-
- if(pcflow->firstBank == pcflowLink->pcflow->lastBank)
- return 0;
-
- pcflowLink->bank_conflict++;
- pcflowLink->pcflow->ToConflicts++;
- pcflow->FromConflicts++;
-
- }
- / *
- fprintf(stderr,"compare flow found conflict: seq %d from conflicts %d, to conflicts %d\n",
- pcflowLink->pcflow->pc.seq,
- pcflowLink->pcflow->FromConflicts,
- pcflowLink->pcflow->ToConflicts);
- * /
- return 1;
-
+
+ if(!pcflow || !pcflowLink || !pcflowLink->pcflow)
+ return 0;
+
+ if(!isPCFL(pcflow) || !isPCFL(pcflowLink->pcflow))
+ return 0;
+
+ if(pcflow->firstBank == -1)
+ return 0;
+
+
+ if(pcflowLink->pcflow->firstBank == -1) {
+ pCodeFlowLink *pctl = setFirstItem( toORfrom ?
+ pcflowLink->pcflow->to :
+ pcflowLink->pcflow->from);
+ return compareBankFlow(pcflow, pctl, toORfrom);
+ }
+
+ if(toORfrom) {
+ if(pcflow->lastBank == pcflowLink->pcflow->firstBank)
+ return 0;
+
+ pcflowLink->bank_conflict++;
+ pcflowLink->pcflow->FromConflicts++;
+ pcflow->ToConflicts++;
+ } else {
+
+ if(pcflow->firstBank == pcflowLink->pcflow->lastBank)
+ return 0;
+
+ pcflowLink->bank_conflict++;
+ pcflowLink->pcflow->ToConflicts++;
+ pcflow->FromConflicts++;
+
+ }
+ / *
+ fprintf(stderr,"compare flow found conflict: seq %d from conflicts %d, to conflicts %d\n",
+ pcflowLink->pcflow->pc.seq,
+ pcflowLink->pcflow->FromConflicts,
+ pcflowLink->pcflow->ToConflicts);
+ * /
+ return 1;
+
}
*/
/*-----------------------------------------------------------------*/
/*
void FixBankFlow(pBlock *pb)
{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
- pCode *pcflow_max_To=NULL;
- pCode *pcflow_max_From=NULL;
- int max_ToConflicts=0;
- int max_FromConflicts=0;
-
- //fprintf(stderr,"Fix Bank flow \n");
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
-
-
- / *
- First loop through all of the flow objects in this pcode block
- and fix the ones that have banking conflicts between the
- entry and exit.
- * /
-
- //fprintf(stderr, "FixBankFlow - Phase 1\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
- continue;
- }
-
- if(PCFL(pcflow)->firstBank != PCFL(pcflow)->lastBank &&
- PCFL(pcflow)->firstBank >= 0 &&
- PCFL(pcflow)->lastBank >= 0 ) {
-
- int cur_bank = (PCFL(pcflow)->firstBank < PCFL(pcflow)->lastBank) ?
- PCFL(pcflow)->firstBank : PCFL(pcflow)->lastBank;
-
- FixRegisterBankingInFlow(PCFL(pcflow),cur_bank);
- BanksUsedFlow2(pcflow);
-
- }
- }
-
- //fprintf(stderr, "FixBankFlow - Phase 2\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+ pCode *pc=NULL;
+ pCode *pcflow;
+ pCodeFlowLink *pcfl;
+
+ pCode *pcflow_max_To=NULL;
+ pCode *pcflow_max_From=NULL;
+ int max_ToConflicts=0;
+ int max_FromConflicts=0;
+
+ //fprintf(stderr,"Fix Bank flow \n");
+ pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+
+
+ / *
+ First loop through all of the flow objects in this pcode block
+ and fix the ones that have banking conflicts between the
+ entry and exit.
+ * /
- int nFlows;
- int nConflicts;
+ //fprintf(stderr, "FixBankFlow - Phase 1\n");
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ if(!isPCFL(pcflow)) {
+ fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
+ continue;
+ }
+
+ if(PCFL(pcflow)->firstBank != PCFL(pcflow)->lastBank &&
+ PCFL(pcflow)->firstBank >= 0 &&
+ PCFL(pcflow)->lastBank >= 0 ) {
+
+ int cur_bank = (PCFL(pcflow)->firstBank < PCFL(pcflow)->lastBank) ?
+ PCFL(pcflow)->firstBank : PCFL(pcflow)->lastBank;
+
+ FixRegisterBankingInFlow(PCFL(pcflow),cur_bank);
+ BanksUsedFlow2(pcflow);
+
+ }
+ }
+
+ //fprintf(stderr, "FixBankFlow - Phase 2\n");
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
- continue;
- }
+ int nFlows;
+ int nConflicts;
- PCFL(pcflow)->FromConflicts = 0;
- PCFL(pcflow)->ToConflicts = 0;
+ if(!isPCFL(pcflow)) {
+ fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
+ continue;
+ }
- nFlows = 0;
- nConflicts = 0;
+ PCFL(pcflow)->FromConflicts = 0;
+ PCFL(pcflow)->ToConflicts = 0;
- //fprintf(stderr, " FixBankFlow flow seq %d\n",pcflow->seq);
- pcfl = setFirstItem(PCFL(pcflow)->from);
- while (pcfl) {
+ nFlows = 0;
+ nConflicts = 0;
- pc = PCODE(pcfl->pcflow);
+ //fprintf(stderr, " FixBankFlow flow seq %d\n",pcflow->seq);
+ pcfl = setFirstItem(PCFL(pcflow)->from);
+ while (pcfl) {
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
+ pc = PCODE(pcfl->pcflow);
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 0);
- nFlows++;
+ if(!isPCFL(pc)) {
+ fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
+ pc->print(stderr,pc);
+ }
- pcfl=setNextItem(PCFL(pcflow)->from);
- }
+ nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 0);
+ nFlows++;
- if((nFlows >= 2) && nConflicts && (PCFL(pcflow)->firstBank>0)) {
- //fprintf(stderr, " From conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
+ pcfl=setNextItem(PCFL(pcflow)->from);
+ }
- FixRegisterBankingInFlow(PCFL(pcflow),-1);
- BanksUsedFlow2(pcflow);
+ if((nFlows >= 2) && nConflicts && (PCFL(pcflow)->firstBank>0)) {
+ //fprintf(stderr, " From conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
- continue; / * Don't need to check the flow from here - it's already been fixed * /
+ FixRegisterBankingInFlow(PCFL(pcflow),-1);
+ BanksUsedFlow2(pcflow);
- }
+ continue; / * Don't need to check the flow from here - it's already been fixed * /
- nFlows = 0;
- nConflicts = 0;
+ }
- pcfl = setFirstItem(PCFL(pcflow)->to);
- while (pcfl) {
+ nFlows = 0;
+ nConflicts = 0;
- pc = PCODE(pcfl->pcflow);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
+ pcfl = setFirstItem(PCFL(pcflow)->to);
+ while (pcfl) {
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1);
- nFlows++;
+ pc = PCODE(pcfl->pcflow);
+ if(!isPCFL(pc)) {
+ fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
+ pc->print(stderr,pc);
+ }
- pcfl=setNextItem(PCFL(pcflow)->to);
- }
+ nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1);
+ nFlows++;
- if((nFlows >= 2) && nConflicts &&(nConflicts != nFlows) && (PCFL(pcflow)->lastBank>0)) {
- //fprintf(stderr, " To conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
+ pcfl=setNextItem(PCFL(pcflow)->to);
+ }
- FixRegisterBankingInFlow(PCFL(pcflow),-1);
- BanksUsedFlow2(pcflow);
- }
- }
+ if((nFlows >= 2) && nConflicts &&(nConflicts != nFlows) && (PCFL(pcflow)->lastBank>0)) {
+ //fprintf(stderr, " To conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
- / *
- Loop through the flow objects again and find the ones with the
- maximum conflicts
- * /
+ FixRegisterBankingInFlow(PCFL(pcflow),-1);
+ BanksUsedFlow2(pcflow);
+ }
+ }
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+ / *
+ Loop through the flow objects again and find the ones with the
+ maximum conflicts
+ * /
- if(PCFL(pcflow)->ToConflicts > max_ToConflicts)
- pcflow_max_To = pcflow;
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
- if(PCFL(pcflow)->FromConflicts > max_FromConflicts)
- pcflow_max_From = pcflow;
- }
-/ *
- if(pcflow_max_To)
- fprintf(stderr,"compare flow Max To conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_To)->pc.seq,
- PCFL(pcflow_max_To)->ToConflicts);
+ if(PCFL(pcflow)->ToConflicts > max_ToConflicts)
+ pcflow_max_To = pcflow;
- if(pcflow_max_From)
- fprintf(stderr,"compare flow Max From conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_From)->pc.seq,
- PCFL(pcflow_max_From)->FromConflicts);
-* /
+ if(PCFL(pcflow)->FromConflicts > max_FromConflicts)
+ pcflow_max_From = pcflow;
+ }
+ / *
+ if(pcflow_max_To)
+ fprintf(stderr,"compare flow Max To conflicts: seq %d conflicts %d\n",
+ PCFL(pcflow_max_To)->pc.seq,
+ PCFL(pcflow_max_To)->ToConflicts);
+
+ if(pcflow_max_From)
+ fprintf(stderr,"compare flow Max From conflicts: seq %d conflicts %d\n",
+ PCFL(pcflow_max_From)->pc.seq,
+ PCFL(pcflow_max_From)->FromConflicts);
+ * /
}
*/
/*-----------------------------------------------------------------*/
void DumpFlow(pBlock *pb)
{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
-
- fprintf(stderr,"Dump flow \n");
- pb->pcHead->print(stderr, pb->pcHead);
-
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow->print(stderr,pcflow);
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "DumpFlow - pcflow is not a flow object ");
- continue;
- }
- fprintf(stderr,"dumping: ");
- pcflow->print(stderr,pcflow);
- FlowStats(PCFL(pcflow));
-
- for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
-
- pc = PCODE(pcfl->pcflow);
-
- fprintf(stderr, " from seq %d:\n",pc->seq);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - from is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- }
-
- for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
-
- pc = PCODE(pcfl->pcflow);
-
- fprintf(stderr, " to seq %d:\n",pc->seq);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- }
-
- }
-
+ pCode *pc=NULL;
+ pCode *pcflow;
+ pCodeFlowLink *pcfl;
+
+
+ fprintf(stderr,"Dump flow \n");
+ pb->pcHead->print(stderr, pb->pcHead);
+
+ pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow->print(stderr,pcflow);
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ if(!isPCFL(pcflow)) {
+ fprintf(stderr, "DumpFlow - pcflow is not a flow object ");
+ continue;
+ }
+ fprintf(stderr,"dumping: ");
+ pcflow->print(stderr,pcflow);
+ FlowStats(PCFL(pcflow));
+
+ for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
+
+ pc = PCODE(pcfl->pcflow);
+
+ fprintf(stderr, " from seq %d:\n",pc->seq);
+ if(!isPCFL(pc)) {
+ fprintf(stderr,"oops dumpflow - from is not a pcflow\n");
+ pc->print(stderr,pc);
+ }
+
+ }
+
+ for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
+
+ pc = PCODE(pcfl->pcflow);
+
+ fprintf(stderr, " to seq %d:\n",pc->seq);
+ if(!isPCFL(pc)) {
+ fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
+ pc->print(stderr,pc);
+ }
+
+ }
+
+ }
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int OptimizepBlock(pBlock *pb)
{
- pCode *pc, *pcprev;
- int matches =0;
-
- if(!pb || !peepOptimizing)
- return 0;
-
- DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
-/*
- for(pc = pb->pcHead; pc; pc = pc->next)
- matches += pCodePeepMatchRule(pc);
-*/
-
- pc = findNextInstruction(pb->pcHead);
- if(!pc)
- return 0;
-
- pcprev = pc->prev;
- do {
-
-
- if(pCodePeepMatchRule(pc)) {
-
- matches++;
-
- if(pcprev)
- pc = findNextInstruction(pcprev->next);
- else
+ pCode *pc, *pcprev;
+ int matches =0;
+
+ if(!pb || !peepOptimizing)
+ return 0;
+
+ DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
+ /*
+ for(pc = pb->pcHead; pc; pc = pc->next)
+ matches += pCodePeepMatchRule(pc);
+ */
+
pc = findNextInstruction(pb->pcHead);
- } else
- pc = findNextInstruction(pc->next);
- } while(pc);
-
- if(matches)
- DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches));
- return matches;
-
+ if(!pc)
+ return 0;
+
+ pcprev = pc->prev;
+ do {
+
+
+ if(pCodePeepMatchRule(pc)) {
+
+ matches++;
+
+ if(pcprev)
+ pc = findNextInstruction(pcprev->next);
+ else
+ pc = findNextInstruction(pb->pcHead);
+ } else
+ pc = findNextInstruction(pc->next);
+ } while(pc);
+
+ if(matches)
+ DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches));
+ return matches;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
{
- pCode *pc;
-
- for(pc = pcs; pc; pc = pc->next) {
-
- if((pc->type == PC_OPCODE) &&
- (PCI(pc)->pcop) &&
- (PCI(pc)->pcop->type == PO_LABEL) &&
- (PCOLAB(PCI(pc)->pcop)->key == pcl->key))
- return pc;
- }
-
-
- return NULL;
+ pCode *pc;
+
+ for(pc = pcs; pc; pc = pc->next) {
+
+ if((pc->type == PC_OPCODE) &&
+ (PCI(pc)->pcop) &&
+ (PCI(pc)->pcop->type == PO_LABEL) &&
+ (PCOLAB(PCI(pc)->pcop)->key == pcl->key))
+ return pc;
+ }
+
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void exchangeLabels(pCodeLabel *pcl, pCode *pc)
{
-
- char *s=NULL;
-
- if(isPCI(pc) &&
- (PCI(pc)->pcop) &&
- (PCI(pc)->pcop->type == PO_LABEL)) {
-
- pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
-
- //fprintf(stderr,"changing label key from %d to %d\n",pcol->key, pcl->key);
- if(pcol->pcop.name)
- free(pcol->pcop.name);
-
- /* If the key is negative, then we (probably) have a label to
- * a function and the name is already defined */
-
- if(pcl->key>0)
- sprintf(s=buffer,"_%05d_DS_",pcl->key);
- else
- s = pcl->label;
-
- //sprintf(buffer,"_%05d_DS_",pcl->key);
- if(!s) {
- fprintf(stderr, "ERROR %s:%d function label is null\n",__FUNCTION__,__LINE__);
- }
- pcol->pcop.name = Safe_strdup(s);
- pcol->key = pcl->key;
- //pc->print(stderr,pc);
-
- }
-
-
+
+ char *s=NULL;
+
+ if(isPCI(pc) &&
+ (PCI(pc)->pcop) &&
+ (PCI(pc)->pcop->type == PO_LABEL)) {
+
+ pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
+
+ //fprintf(stderr,"changing label key from %d to %d\n",pcol->key, pcl->key);
+ if(pcol->pcop.name)
+ free(pcol->pcop.name);
+
+ /* If the key is negative, then we (probably) have a label to
+ * a function and the name is already defined */
+
+ if(pcl->key>0)
+ sprintf(s=buffer,"_%05d_DS_",pcl->key);
+ else
+ s = pcl->label;
+
+ //sprintf(buffer,"_%05d_DS_",pcl->key);
+ if(!s) {
+ fprintf(stderr, "ERROR %s:%d function label is null\n",__FUNCTION__,__LINE__);
+ }
+ pcol->pcop.name = Safe_strdup(s);
+ pcol->key = pcl->key;
+ //pc->print(stderr,pc);
+
+ }
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pBlockRemoveUnusedLabels(pBlock *pb)
{
- pCode *pc; pCodeLabel *pcl;
-
- if(!pb)
- return;
-
- for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
-
- pBranch *pbr = PCI(pc)->label;
- if(pbr && pbr->next) {
- pCode *pcd = pb->pcHead;
-
- //fprintf(stderr, "multiple labels\n");
- //pc->print(stderr,pc);
-
- pbr = pbr->next;
- while(pbr) {
-
- while ( (pcd = findInstructionUsingLabel(PCL(PCI(pc)->label->pc), pcd)) != NULL) {
- //fprintf(stderr,"Used by:\n");
- //pcd->print(stderr,pcd);
-
- exchangeLabels(PCL(pbr->pc),pcd);
-
- pcd = pcd->next;
+ pCode *pc; pCodeLabel *pcl;
+
+ if(!pb)
+ return;
+
+ for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
+
+ pBranch *pbr = PCI(pc)->label;
+ if(pbr && pbr->next) {
+ pCode *pcd = pb->pcHead;
+
+ //fprintf(stderr, "multiple labels\n");
+ //pc->print(stderr,pc);
+
+ pbr = pbr->next;
+ while(pbr) {
+
+ while ( (pcd = findInstructionUsingLabel(PCL(PCI(pc)->label->pc), pcd)) != NULL) {
+ //fprintf(stderr,"Used by:\n");
+ //pcd->print(stderr,pcd);
+
+ exchangeLabels(PCL(pbr->pc),pcd);
+
+ pcd = pcd->next;
+ }
+ pbr = pbr->next;
+ }
+ }
}
- pbr = pbr->next;
- }
- }
- }
-
- for(pc = pb->pcHead; pc; pc = pc->next) {
-
- if(isPCL(pc)) // Label pcode
- pcl = PCL(pc);
- else if (isPCI(pc) && PCI(pc)->label) // pcode instruction with a label
- pcl = PCL(PCI(pc)->label->pc);
- else continue;
-
- //fprintf(stderr," found A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
-
- /* This pCode is a label, so search the pBlock to see if anyone
- * refers to it */
-
- if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
- //if( !findInstructionUsingLabel(pcl, pb->pcHead)) {
- /* Couldn't find an instruction that refers to this label
- * So, unlink the pCode label from it's pCode chain
- * and destroy the label */
- //fprintf(stderr," removed A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
-
- DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d, %s\n", pcl->key,pcl->label));
- if(pc->type == PC_LABEL) {
- unlinkpCode(pc);
- pCodeLabelDestruct(pc);
- } else {
- unlinkpCodeFromBranch(pc, PCODE(pcl));
- /*if(pc->label->next == NULL && pc->label->pc == NULL) {
- free(pc->label);
- }*/
- }
-
- }
- }
-
+
+ for(pc = pb->pcHead; pc; pc = pc->next) {
+
+ if(isPCL(pc)) // Label pcode
+ pcl = PCL(pc);
+ else if (isPCI(pc) && PCI(pc)->label) // pcode instruction with a label
+ pcl = PCL(PCI(pc)->label->pc);
+ else continue;
+
+ //fprintf(stderr," found A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
+
+ /* This pCode is a label, so search the pBlock to see if anyone
+ * refers to it */
+
+ if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
+ //if( !findInstructionUsingLabel(pcl, pb->pcHead)) {
+ /* Couldn't find an instruction that refers to this label
+ * So, unlink the pCode label from it's pCode chain
+ * and destroy the label */
+ //fprintf(stderr," removed A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
+
+ DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d, %s\n", pcl->key,pcl->label));
+ if(pc->type == PC_LABEL) {
+ unlinkpCode(pc);
+ pCodeLabelDestruct(pc);
+ } else {
+ unlinkpCodeFromBranch(pc, PCODE(pcl));
+ /*if(pc->label->next == NULL && pc->label->pc == NULL) {
+ free(pc->label);
+ }*/
+ }
+
+ }
+ }
+
}
/*-----------------------------------------------------------------*/
void pBlockMergeLabels(pBlock *pb)
{
- pBranch *pbr;
- pCode *pc, *pcnext=NULL;
-
- if(!pb)
- return;
-
- /* First, Try to remove any unused labels */
- //pBlockRemoveUnusedLabels(pb);
-
- /* Now loop through the pBlock and merge the labels with the opcodes */
-
- pc = pb->pcHead;
- // for(pc = pb->pcHead; pc; pc = pc->next) {
-
- while(pc) {
- pCode *pcn = pc->next;
-
- if(pc->type == PC_LABEL) {
-
- //fprintf(stderr," checking merging label %s\n",PCL(pc)->label);
- //fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key);
- if((pcnext = findNextInstruction(pc) )) {
-
- // Unlink the pCode label from it's pCode chain
- unlinkpCode(pc);
+ pBranch *pbr;
+ pCode *pc, *pcnext=NULL;
+
+ if(!pb)
+ return;
+
+ /* First, Try to remove any unused labels */
+ //pBlockRemoveUnusedLabels(pb);
+
+ /* Now loop through the pBlock and merge the labels with the opcodes */
+
+ pc = pb->pcHead;
+ // for(pc = pb->pcHead; pc; pc = pc->next) {
+
+ while(pc) {
+ pCode *pcn = pc->next;
+
+ if(pc->type == PC_LABEL) {
+
+ //fprintf(stderr," checking merging label %s\n",PCL(pc)->label);
+ //fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key);
+ if((pcnext = findNextInstruction(pc) )) {
+
+ // Unlink the pCode label from it's pCode chain
+ unlinkpCode(pc);
+
+ //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key);
+ // And link it into the instruction's pBranch labels. (Note, since
+ // it's possible to have multiple labels associated with one instruction
+ // we must provide a means to accomodate the additional labels. Thus
+ // the labels are placed into the singly-linked list "label" as
+ // opposed to being a single member of the pCodeInstruction.)
+
+ //_ALLOC(pbr,sizeof(pBranch));
+ pbr = Safe_calloc(1,sizeof(pBranch));
+ pbr->pc = pc;
+ pbr->next = NULL;
+
+ PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
+
+ } else {
+ fprintf(stderr, "WARNING: couldn't associate label %s with an instruction\n",PCL(pc)->label);
+ }
+ } else if(pc->type == PC_CSOURCE) {
+
+ /* merge the source line symbolic info into the next instruction */
+ if((pcnext = findNextInstruction(pc) )) {
+
+ // Unlink the pCode label from it's pCode chain
+ unlinkpCode(pc);
+ PCI(pcnext)->cline = PCCS(pc);
+ //fprintf(stderr, "merging CSRC\n");
+ //genericPrint(stderr,pcnext);
+ }
+
+ }
+ pc = pcn;
+ }
+ pBlockRemoveUnusedLabels(pb);
- //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key);
- // And link it into the instruction's pBranch labels. (Note, since
- // it's possible to have multiple labels associated with one instruction
- // we must provide a means to accomodate the additional labels. Thus
- // the labels are placed into the singly-linked list "label" as
- // opposed to being a single member of the pCodeInstruction.)
-
- //_ALLOC(pbr,sizeof(pBranch));
- pbr = Safe_calloc(1,sizeof(pBranch));
- pbr->pc = pc;
- pbr->next = NULL;
-
- PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
-
- } else {
- fprintf(stderr, "WARNING: couldn't associate label %s with an instruction\n",PCL(pc)->label);
- }
- } else if(pc->type == PC_CSOURCE) {
-
- /* merge the source line symbolic info into the next instruction */
- if((pcnext = findNextInstruction(pc) )) {
-
- // Unlink the pCode label from it's pCode chain
- unlinkpCode(pc);
- PCI(pcnext)->cline = PCCS(pc);
- //fprintf(stderr, "merging CSRC\n");
- //genericPrint(stderr,pcnext);
- }
-
- }
- pc = pcn;
- }
- pBlockRemoveUnusedLabels(pb);
-
}
/*-----------------------------------------------------------------*/
int OptimizepCode(char dbName)
{
#define MAX_PASSES 4
-
- int matches = 0;
- int passes = 0;
- pBlock *pb;
-
- if(!the_pFile)
- return 0;
-
- DFPRINTF((stderr," Optimizing pCode\n"));
-
- do {
- matches = 0;
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if('*' == dbName || getpBlock_dbName(pb) == dbName)
- matches += OptimizepBlock(pb);
- }
- }
- while(matches && ++passes < MAX_PASSES);
-
- return matches;
+
+ int matches = 0;
+ int passes = 0;
+ pBlock *pb;
+
+ if(!the_pFile)
+ return 0;
+
+ DFPRINTF((stderr," Optimizing pCode\n"));
+
+ do {
+ matches = 0;
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ if('*' == dbName || getpBlock_dbName(pb) == dbName)
+ matches += OptimizepBlock(pb);
+ }
+ }
+ while(matches && ++passes < MAX_PASSES);
+
+ return matches;
}
/*-----------------------------------------------------------------*/
pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval)
{
- pCodeOp *pcop;
-
- pcop = newpCodeOpBit(pc->name, bitval, 0);
-
- if( !( (pcop->type == PO_LABEL) ||
- (pcop->type == PO_LITERAL) ||
- (pcop->type == PO_STR) ))
- PCOR(pcop)->r = PCOR(pc)->r; /* This is dangerous... */
-
- return pcop;
+ pCodeOp *pcop;
+
+ pcop = newpCodeOpBit(pc->name, bitval, 0);
+
+ if( !( (pcop->type == PO_LABEL) ||
+ (pcop->type == PO_LITERAL) ||
+ (pcop->type == PO_STR) ))
+ PCOR(pcop)->r = PCOR(pc)->r; /* This is dangerous... */
+
+ return pcop;
}
/*-----------------------------------------------------------------*/
static void FixRegisterBanking(pBlock *pb,int cur_bank)
{
- pCode *pc;
- int firstBank = 'U';
-
- if(!pb)
- return;
-
- for (pc=pb->pcHead; pc; pc=pc->next) {
- if (isPCFL(pc)) {
- firstBank = PCFL(pc)->firstBank;
- break;
- }
- }
- if (firstBank != 'U') {
- /* This block has already been done */
- if (firstBank != cur_bank) {
- /* This block has started with a different bank - must adjust it */
- if ((firstBank != -1)&&(firstBank != 'E')) { /* The first bank start off unknown or extern then need not worry as banksel will be called */
- while (pc) {
- if (isPCI(pc)) {
- regs *reg = getRegFromInstruction(pc);
- if (reg) {
- DoBankSelect(pc,cur_bank);
- }
- }
- pc = pc->next;
- }
- }
- }
- return;
- }
-
- /* loop through all of the pCodes within this pblock setting the bank selection, ignoring any branching */
- LastRegIdx = -1;
- cur_bank = -1;
- for (pc=pb->pcHead; pc; pc=pc->next) {
- if (isPCFL(pc)) {
- PCFL(pc)->firstBank = cur_bank;
- continue;
- }
- cur_bank = DoBankSelect(pc,cur_bank);
- }
-
- /* Trace through branches and set the bank selection as required. */
- LastRegIdx = -1;
- cur_bank = -1;
- for (pc=pb->pcHead; pc; pc=pc->next) {
- if (isPCFL(pc)) {
- PCFL(pc)->firstBank = cur_bank;
- continue;
- }
- if (isPCI(pc)) {
- if (PCI(pc)->op == POC_GOTO) {
- int lastRegIdx = LastRegIdx;
- pCode *pcb = pc;
- /* Trace through branch */
- pCode *pcl = findLabel(PCOLAB(PCI(pcb)->pcop));
- while (pcl) {
- if (isPCI(pcl)) {
- regs *reg = getRegFromInstruction(pcl);
- if (reg) {
- int bankUnknown = -1;
- if (IsBankChange(pcl,reg,&bankUnknown)) /* Look for any bank change */
- break;
- if (cur_bank != DoBankSelect(pcl,cur_bank)) /* Set bank selection if necessary */
- break;
- }
- }
- pcl = pcl->next;
- }
- LastRegIdx = lastRegIdx;
- } else {
- /* Keep track out current bank */
- regs *reg = getRegFromInstruction(pc);
- if (reg)
- IsBankChange(pc,reg,&cur_bank);
- }
- }
- }
+ pCode *pc;
+ int firstBank = 'U';
+
+ if(!pb)
+ return;
+
+ for (pc=pb->pcHead; pc; pc=pc->next) {
+ if (isPCFL(pc)) {
+ firstBank = PCFL(pc)->firstBank;
+ break;
+ }
+ }
+ if (firstBank != 'U') {
+ /* This block has already been done */
+ if (firstBank != cur_bank) {
+ /* This block has started with a different bank - must adjust it */
+ if ((firstBank != -1)&&(firstBank != 'E')) { /* The first bank start off unknown or extern then need not worry as banksel will be called */
+ while (pc) {
+ if (isPCI(pc)) {
+ regs *reg = getRegFromInstruction(pc);
+ if (reg) {
+ DoBankSelect(pc,cur_bank);
+ }
+ }
+ pc = pc->next;
+ }
+ }
+ }
+ return;
+ }
+
+ /* loop through all of the pCodes within this pblock setting the bank selection, ignoring any branching */
+ LastRegIdx = -1;
+ cur_bank = -1;
+ for (pc=pb->pcHead; pc; pc=pc->next) {
+ if (isPCFL(pc)) {
+ PCFL(pc)->firstBank = cur_bank;
+ continue;
+ }
+ cur_bank = DoBankSelect(pc,cur_bank);
+ }
+
+ /* Trace through branches and set the bank selection as required. */
+ LastRegIdx = -1;
+ cur_bank = -1;
+ for (pc=pb->pcHead; pc; pc=pc->next) {
+ if (isPCFL(pc)) {
+ PCFL(pc)->firstBank = cur_bank;
+ continue;
+ }
+ if (isPCI(pc)) {
+ if (PCI(pc)->op == POC_GOTO) {
+ int lastRegIdx = LastRegIdx;
+ pCode *pcb = pc;
+ /* Trace through branch */
+ pCode *pcl = findLabel(PCOLAB(PCI(pcb)->pcop));
+ while (pcl) {
+ if (isPCI(pcl)) {
+ regs *reg = getRegFromInstruction(pcl);
+ if (reg) {
+ int bankUnknown = -1;
+ if (IsBankChange(pcl,reg,&bankUnknown)) /* Look for any bank change */
+ break;
+ if (cur_bank != DoBankSelect(pcl,cur_bank)) /* Set bank selection if necessary */
+ break;
+ }
+ }
+ pcl = pcl->next;
+ }
+ LastRegIdx = lastRegIdx;
+ } else {
+ /* Keep track out current bank */
+ regs *reg = getRegFromInstruction(pc);
+ if (reg)
+ IsBankChange(pc,reg,&cur_bank);
+ }
+ }
+ }
}
/*-----------------------------------------------------------------*/
void pBlockDestruct(pBlock *pb)
{
-
- if(!pb)
- return;
-
-
- free(pb);
-
+
+ if(!pb)
+ return;
+
+
+ free(pb);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void mergepBlocks(char dbName)
{
+
+ pBlock *pb, *pbmerged = NULL,*pbn;
+
+ pb = the_pFile->pbHead;
+
+ //fprintf(stderr," merging blocks named %c\n",dbName);
+ while(pb) {
+
+ pbn = pb->next;
+ //fprintf(stderr,"looking at %c\n",getpBlock_dbName(pb));
+ if( getpBlock_dbName(pb) == dbName) {
+
+ //fprintf(stderr," merged block %c\n",dbName);
+
+ if(!pbmerged) {
+ pbmerged = pb;
+ } else {
+ addpCode2pBlock(pbmerged, pb->pcHead);
+ /* addpCode2pBlock doesn't handle the tail: */
+ pbmerged->pcTail = pb->pcTail;
+
+ pb->prev->next = pbn;
+ if(pbn)
+ pbn->prev = pb->prev;
+
+
+ pBlockDestruct(pb);
+ }
+ //printpBlock(stderr, pbmerged);
+ }
+ pb = pbn;
+ }
+
+}
- pBlock *pb, *pbmerged = NULL,*pbn;
-
- pb = the_pFile->pbHead;
-
- //fprintf(stderr," merging blocks named %c\n",dbName);
- while(pb) {
-
- pbn = pb->next;
- //fprintf(stderr,"looking at %c\n",getpBlock_dbName(pb));
- if( getpBlock_dbName(pb) == dbName) {
-
- //fprintf(stderr," merged block %c\n",dbName);
-
- if(!pbmerged) {
- pbmerged = pb;
- } else {
- addpCode2pBlock(pbmerged, pb->pcHead);
- /* addpCode2pBlock doesn't handle the tail: */
- pbmerged->pcTail = pb->pcTail;
-
- pb->prev->next = pbn;
- if(pbn)
- pbn->prev = pb->prev;
-
-
- pBlockDestruct(pb);
- }
- //printpBlock(stderr, pbmerged);
- }
- pb = pbn;
- }
-
-}
-
-/*-----------------------------------------------------------------*/
-/* AnalyzeFlow - Examine the flow of the code and optimize */
-/* */
-/* level 0 == minimal optimization */
-/* optimize registers that are used only by two instructions */
-/* level 1 == maximal optimization */
-/* optimize by looking at pairs of instructions that use the */
-/* register. */
-/*-----------------------------------------------------------------*/
-
-void AnalyzeFlow(int level)
-{
- static int times_called=0;
-
- pBlock *pb;
-
- if(!the_pFile)
- return;
-
-
- /* if this is not the first time this function has been called,
- then clean up old flow information */
- if(times_called++) {
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- unBuildFlow(pb);
-
- RegsUnMapLiveRanges();
-
- }
-
- GpcFlowSeq = 1;
-
- /* Phase 2 - Flow Analysis - Register Banking
- *
- * In this phase, the individual flow blocks are examined
- * and register banking is fixed.
- */
-
- //for(pb = the_pFile->pbHead; pb; pb = pb->next)
- //FixRegisterBanking(pb);
-
- /* Phase 2 - Flow Analysis
- *
- * In this phase, the pCode is partition into pCodeFlow
- * blocks. The flow blocks mark the points where a continuous
- * stream of instructions changes flow (e.g. because of
- * a call or goto or whatever).
- */
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- BuildFlow(pb);
-
-
- /* Phase 2 - Flow Analysis - linking flow blocks
- *
- * In this phase, the individual flow blocks are examined
- * to determine their order of excution.
- */
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- LinkFlow(pb);
-
- /* Phase 3 - Flow Analysis - Flow Tree
- *
- * In this phase, the individual flow blocks are examined
- * to determine their order of excution.
- */
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- BuildFlowTree(pb);
-
-
- /* Phase x - Flow Analysis - Used Banks
- *
- * In this phase, the individual flow blocks are examined
- * to determine the Register Banks they use
- */
-
-// for(pb = the_pFile->pbHead; pb; pb = pb->next)
-// FixBankFlow(pb);
-
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- pCodeRegMapLiveRanges(pb);
-
- RemoveUnusedRegisters();
-
- // for(pb = the_pFile->pbHead; pb; pb = pb->next)
- pCodeRegOptimizeRegUsage(level);
-
- OptimizepCode('*');
-
+/*-----------------------------------------------------------------*/
+/* AnalyzeFlow - Examine the flow of the code and optimize */
+/* */
+/* level 0 == minimal optimization */
+/* optimize registers that are used only by two instructions */
+/* level 1 == maximal optimization */
+/* optimize by looking at pairs of instructions that use the */
+/* register. */
+/*-----------------------------------------------------------------*/
-/*
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- DumpFlow(pb);
-*/
- /* debug stuff */
-/*
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- pCode *pcflow;
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
- pcflow = pcflow->next) {
-
- FillFlow(PCFL(pcflow));
- }
- }
-*/
-/*
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- pCode *pcflow;
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
- pcflow = pcflow->next) {
-
- FlowStats(PCFL(pcflow));
- }
- }
-*/
+void AnalyzeFlow(int level)
+{
+ static int times_called=0;
+
+ pBlock *pb;
+
+ if(!the_pFile)
+ return;
+
+
+ /* if this is not the first time this function has been called,
+ then clean up old flow information */
+ if(times_called++) {
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ unBuildFlow(pb);
+
+ RegsUnMapLiveRanges();
+
+ }
+
+ GpcFlowSeq = 1;
+
+ /* Phase 2 - Flow Analysis - Register Banking
+ *
+ * In this phase, the individual flow blocks are examined
+ * and register banking is fixed.
+ */
+
+ //for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ //FixRegisterBanking(pb);
+
+ /* Phase 2 - Flow Analysis
+ *
+ * In this phase, the pCode is partition into pCodeFlow
+ * blocks. The flow blocks mark the points where a continuous
+ * stream of instructions changes flow (e.g. because of
+ * a call or goto or whatever).
+ */
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ BuildFlow(pb);
+
+
+ /* Phase 2 - Flow Analysis - linking flow blocks
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine their order of excution.
+ */
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ LinkFlow(pb);
+
+ /* Phase 3 - Flow Analysis - Flow Tree
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine their order of excution.
+ */
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ BuildFlowTree(pb);
+
+
+ /* Phase x - Flow Analysis - Used Banks
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine the Register Banks they use
+ */
+
+ // for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ // FixBankFlow(pb);
+
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ pCodeRegMapLiveRanges(pb);
+
+ RemoveUnusedRegisters();
+
+ // for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ pCodeRegOptimizeRegUsage(level);
+
+ OptimizepCode('*');
+
+
+ /*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ DumpFlow(pb);
+ */
+ /* debug stuff */
+ /*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ pCode *pcflow;
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
+ pcflow = pcflow->next) {
+
+ FillFlow(PCFL(pcflow));
+ }
+ }
+ */
+ /*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ pCode *pcflow;
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
+ pcflow = pcflow->next) {
+
+ FlowStats(PCFL(pcflow));
+ }
+ }
+ */
}
/*-----------------------------------------------------------------*/
void AnalyzeBanking(void)
{
- pBlock *pb;
-
- if(!picIsInitialized()) {
- fprintf(stderr,"Temporary ERROR: at the moment you have to use\n");
- fprintf(stderr,"an include file create by inc2h.pl. See SDCC source:\n");
- fprintf(stderr,"support/scripts/inc2h.pl\n");
- fprintf(stderr,"this is a nuisance bug that will be fixed shortly\n");
-
- exit(1);
- }
-
- /* Phase x - Flow Analysis - Used Banks
- *
- * In this phase, the individual flow blocks are examined
- * to determine the Register Banks they use
- */
-
- AnalyzeFlow(0);
- AnalyzeFlow(1);
-
-// for(pb = the_pFile->pbHead; pb; pb = pb->next)
-// BanksUsedFlow(pb);
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- FixRegisterBanking(pb,-1); // cur_bank is unknown
-
+ pBlock *pb;
+
+ if(!picIsInitialized()) {
+ fprintf(stderr,"Temporary ERROR: at the moment you have to use\n");
+ fprintf(stderr,"an include file create by inc2h.pl. See SDCC source:\n");
+ fprintf(stderr,"support/scripts/inc2h.pl\n");
+ fprintf(stderr,"this is a nuisance bug that will be fixed shortly\n");
+
+ exit(1);
+ }
+
+ /* Phase x - Flow Analysis - Used Banks
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine the Register Banks they use
+ */
+
+ AnalyzeFlow(0);
+ AnalyzeFlow(1);
+
+ // for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ // BanksUsedFlow(pb);
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ FixRegisterBanking(pb,-1); // cur_bank is unknown
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
DEFSETFUNC (resetrIdx)
{
- if (!((regs *)item)->isFixed)
- ((regs *)item)->rIdx = 0;
-
- return 0;
+ if (!((regs *)item)->isFixed)
+ ((regs *)item)->rIdx = 0;
+
+ return 0;
}
/*-----------------------------------------------------------------*/
void InitReuseReg(void)
{
- /* Find end of statically allocated variables for start idx */
- unsigned maxIdx = 0x20; /* Start from begining of GPR. Note may not be 0x20 on some PICs */
- regs *r;
- for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) {
- if (r->type != REG_SFR) {
- maxIdx += r->size; /* Increment for all statically allocated variables */
- }
- }
- peakIdx = maxIdx;
- applyToSet(dynAllocRegs,resetrIdx); /* Reset all rIdx to zero. */
+ /* Find end of statically allocated variables for start idx */
+ unsigned maxIdx = 0x20; /* Start from begining of GPR. Note may not be 0x20 on some PICs */
+ regs *r;
+ for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) {
+ if (r->type != REG_SFR) {
+ maxIdx += r->size; /* Increment for all statically allocated variables */
+ }
+ }
+ peakIdx = maxIdx;
+ applyToSet(dynAllocRegs,resetrIdx); /* Reset all rIdx to zero. */
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static unsigned register_reassign(pBlock *pb, unsigned idx)
{
- pCode *pc;
-
- /* check recursion */
- pc = setFirstItem(pb->function_entries);
- if(!pc)
- return idx;
-
- pb->visited = 1;
-
- DFPRINTF((stderr," reassigning registers for function \"%s\"\n",PCF(pc)->fname));
-
- if (pb->tregisters) {
- regs *r;
- for (r = setFirstItem(pb->tregisters); r; r = setNextItem(pb->tregisters)) {
- if (r->type == REG_GPR) {
- if (!r->isFixed) {
- if (r->rIdx < (int)idx) {
- char s[20];
- r->rIdx = idx++;
- if (peakIdx < idx) peakIdx = idx;
- sprintf(s,"r0x%02X", r->rIdx);
- DFPRINTF((stderr," reassigning register \"%s\" to \"%s\"\n",r->name,s));
- free(r->name);
- r->name = Safe_strdup(s);
- }
- }
- }
- }
- }
- for(pc = setFirstItem(pb->function_calls); pc; pc = setNextItem(pb->function_calls)) {
-
- if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- char *dest = get_op_from_instruction(PCI(pc));
-
- pCode *pcn = findFunction(dest);
- if(pcn) {
- register_reassign(pcn->pb,idx);
- }
- }
-
- }
-
- return idx;
+ pCode *pc;
+
+ /* check recursion */
+ pc = setFirstItem(pb->function_entries);
+ if(!pc)
+ return idx;
+
+ pb->visited = 1;
+
+ DFPRINTF((stderr," reassigning registers for function \"%s\"\n",PCF(pc)->fname));
+
+ if (pb->tregisters) {
+ regs *r;
+ for (r = setFirstItem(pb->tregisters); r; r = setNextItem(pb->tregisters)) {
+ if (r->type == REG_GPR) {
+ if (!r->isFixed) {
+ if (r->rIdx < (int)idx) {
+ char s[20];
+ r->rIdx = idx++;
+ if (peakIdx < idx) peakIdx = idx;
+ sprintf(s,"r0x%02X", r->rIdx);
+ DFPRINTF((stderr," reassigning register \"%s\" to \"%s\"\n",r->name,s));
+ free(r->name);
+ r->name = Safe_strdup(s);
+ }
+ }
+ }
+ }
+ }
+ for(pc = setFirstItem(pb->function_calls); pc; pc = setNextItem(pb->function_calls)) {
+
+ if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
+ char *dest = get_op_from_instruction(PCI(pc));
+
+ pCode *pcn = findFunction(dest);
+ if(pcn) {
+ register_reassign(pcn->pb,idx);
+ }
+ }
+
+ }
+
+ return idx;
}
/*------------------------------------------------------------------*/
/*------------------------------------------------------------------*/
void ReuseReg(void)
{
- pBlock *pb;
- InitReuseReg();
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- /* Non static functions can be called from other modules so their registers must reassign */
- if (pb->function_entries&&(PCF(setFirstItem(pb->function_entries))->isPublic||!pb->visited))
- register_reassign(pb,peakIdx);
- }
+ pBlock *pb;
+ InitReuseReg();
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ /* Non static functions can be called from other modules so their registers must reassign */
+ if (pb->function_entries&&(PCF(setFirstItem(pb->function_entries))->isPublic||!pb->visited))
+ register_reassign(pb,peakIdx);
+ }
}
/*-----------------------------------------------------------------*/
void buildCallTree(void )
{
- pBranch *pbr;
- pBlock *pb;
- pCode *pc;
-
- if(!the_pFile)
- return;
-
- /* Now build the call tree.
- First we examine all of the pCodes for functions.
- Keep in mind that the function boundaries coincide
- with pBlock boundaries.
-
- The algorithm goes something like this:
- We have two nested loops. The outer loop iterates
- through all of the pBlocks/functions. The inner
- loop iterates through all of the pCodes for
- a given pBlock. When we begin iterating through
- a pBlock, the variable pc_fstart, pCode of the start
- of a function, is cleared. We then search for pCodes
- of type PC_FUNCTION. When one is encountered, we
- initialize pc_fstart to this and at the same time
- associate a new pBranch object that signifies a
- branch entry. If a return is found, then this signifies
- a function exit point. We'll link the pCodes of these
- returns to the matching pc_fstart.
-
- When we're done, a doubly linked list of pBranches
- will exist. The head of this list is stored in
- `the_pFile', which is the meta structure for all
- of the pCode. Look at the printCallTree function
- on how the pBranches are linked together.
-
- */
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- pCode *pc_fstart=NULL;
- for(pc = pb->pcHead; pc; pc = pc->next) {
- if(isPCF(pc)) {
- pCodeFunction *pcf = PCF(pc);
- if (pcf->fname) {
-
- if(STRCASECMP(pcf->fname, "_main") == 0) {
- //fprintf(stderr," found main \n");
- pb->cmemmap = NULL; /* FIXME do we need to free ? */
- pb->dbName = 'M';
- }
-
- pbr = Safe_calloc(1,sizeof(pBranch));
- pbr->pc = pc_fstart = pc;
- pbr->next = NULL;
-
- the_pFile->functions = pBranchAppend(the_pFile->functions,pbr);
-
- // Here's a better way of doing the same:
- addSet(&pb->function_entries, pc);
-
- } else {
- // Found an exit point in a function, e.g. return
- // (Note, there may be more than one return per function)
- if(pc_fstart)
- pBranchLink(PCF(pc_fstart), pcf);
-
- addSet(&pb->function_exits, pc);
- }
- } else if(isCALL(pc)) {
- addSet(&pb->function_calls,pc);
- }
- }
- }
+ pBranch *pbr;
+ pBlock *pb;
+ pCode *pc;
+
+ if(!the_pFile)
+ return;
+
+ /* Now build the call tree.
+ First we examine all of the pCodes for functions.
+ Keep in mind that the function boundaries coincide
+ with pBlock boundaries.
+
+ The algorithm goes something like this:
+ We have two nested loops. The outer loop iterates
+ through all of the pBlocks/functions. The inner
+ loop iterates through all of the pCodes for
+ a given pBlock. When we begin iterating through
+ a pBlock, the variable pc_fstart, pCode of the start
+ of a function, is cleared. We then search for pCodes
+ of type PC_FUNCTION. When one is encountered, we
+ initialize pc_fstart to this and at the same time
+ associate a new pBranch object that signifies a
+ branch entry. If a return is found, then this signifies
+ a function exit point. We'll link the pCodes of these
+ returns to the matching pc_fstart.
+
+ When we're done, a doubly linked list of pBranches
+ will exist. The head of this list is stored in
+ `the_pFile', which is the meta structure for all
+ of the pCode. Look at the printCallTree function
+ on how the pBranches are linked together.
+
+ */
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ pCode *pc_fstart=NULL;
+ for(pc = pb->pcHead; pc; pc = pc->next) {
+ if(isPCF(pc)) {
+ pCodeFunction *pcf = PCF(pc);
+ if (pcf->fname) {
+
+ if(STRCASECMP(pcf->fname, "_main") == 0) {
+ //fprintf(stderr," found main \n");
+ pb->cmemmap = NULL; /* FIXME do we need to free ? */
+ pb->dbName = 'M';
+ }
+
+ pbr = Safe_calloc(1,sizeof(pBranch));
+ pbr->pc = pc_fstart = pc;
+ pbr->next = NULL;
+
+ the_pFile->functions = pBranchAppend(the_pFile->functions,pbr);
+
+ // Here's a better way of doing the same:
+ addSet(&pb->function_entries, pc);
+
+ } else {
+ // Found an exit point in a function, e.g. return
+ // (Note, there may be more than one return per function)
+ if(pc_fstart)
+ pBranchLink(PCF(pc_fstart), pcf);
+
+ addSet(&pb->function_exits, pc);
+ }
+ } else if(isCALL(pc)) {
+ addSet(&pb->function_calls,pc);
+ }
+ }
+ }
}
/*-----------------------------------------------------------------*/
void AnalyzepCode(char dbName)
{
- pBlock *pb;
- int i,changes;
-
- if(!the_pFile)
- return;
-
- mergepBlocks('D');
-
-
- /* Phase 1 - Register allocation and peep hole optimization
- *
- * The first part of the analysis is to determine the registers
- * that are used in the pCode. Once that is done, the peep rules
- * are applied to the code. We continue to loop until no more
- * peep rule optimizations are found (or until we exceed the
- * MAX_PASSES threshold).
- *
- * When done, the required registers will be determined.
- *
- */
- i = 0;
- do {
-
- DFPRINTF((stderr," Analyzing pCode: PASS #%d\n",i+1));
-
- /* First, merge the labels with the instructions */
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if('*' == dbName || getpBlock_dbName(pb) == dbName) {
-
- DFPRINTF((stderr," analyze and merging block %c\n",dbName));
- pBlockMergeLabels(pb);
- AnalyzepBlock(pb);
- } else {
- DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName));
- }
- }
-
- changes = OptimizepCode(dbName);
-
- } while(changes && (i++ < MAX_PASSES));
-
- buildCallTree();
+ pBlock *pb;
+ int i,changes;
+
+ if(!the_pFile)
+ return;
+
+ mergepBlocks('D');
+
+
+ /* Phase 1 - Register allocation and peep hole optimization
+ *
+ * The first part of the analysis is to determine the registers
+ * that are used in the pCode. Once that is done, the peep rules
+ * are applied to the code. We continue to loop until no more
+ * peep rule optimizations are found (or until we exceed the
+ * MAX_PASSES threshold).
+ *
+ * When done, the required registers will be determined.
+ *
+ */
+ i = 0;
+ do {
+
+ DFPRINTF((stderr," Analyzing pCode: PASS #%d\n",i+1));
+
+ /* First, merge the labels with the instructions */
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ if('*' == dbName || getpBlock_dbName(pb) == dbName) {
+
+ DFPRINTF((stderr," analyze and merging block %c\n",dbName));
+ pBlockMergeLabels(pb);
+ AnalyzepBlock(pb);
+ } else {
+ DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName));
+ }
+ }
+
+ changes = OptimizepCode(dbName);
+
+ } while(changes && (i++ < MAX_PASSES));
+
+ buildCallTree();
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
bool ispCodeFunction(pCode *pc)
{
-
- if(pc && pc->type == PC_FUNCTION && PCF(pc)->fname)
- return 1;
-
- return 0;
+
+ if(pc && pc->type == PC_FUNCTION && PCF(pc)->fname)
+ return 1;
+
+ return 0;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode *findFunction(char *fname)
{
- pBlock *pb;
- pCode *pc;
- if(!fname)
- return NULL;
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
-
- pc = setFirstItem(pb->function_entries);
- while(pc) {
-
- if((pc->type == PC_FUNCTION) &&
- (PCF(pc)->fname) &&
- (strcmp(fname, PCF(pc)->fname)==0))
- return pc;
-
- pc = setNextItem(pb->function_entries);
-
- }
-
- }
- return NULL;
+ pBlock *pb;
+ pCode *pc;
+ if(!fname)
+ return NULL;
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+
+ pc = setFirstItem(pb->function_entries);
+ while(pc) {
+
+ if((pc->type == PC_FUNCTION) &&
+ (PCF(pc)->fname) &&
+ (strcmp(fname, PCF(pc)->fname)==0))
+ return pc;
+
+ pc = setNextItem(pb->function_entries);
+
+ }
+
+ }
+ return NULL;
}
void MarkUsedRegisters(set *regset)
{
-
- regs *r1,*r2;
-
- for(r1=setFirstItem(regset); r1; r1=setNextItem(regset)) {
- r2 = pic14_regWithIdx(r1->rIdx);
- if (r2) {
- r2->isFree = 0;
- r2->wasUsed = 1;
- }
- }
+
+ regs *r1,*r2;
+
+ for(r1=setFirstItem(regset); r1; r1=setNextItem(regset)) {
+ r2 = pic14_regWithIdx(r1->rIdx);
+ if (r2) {
+ r2->isFree = 0;
+ r2->wasUsed = 1;
+ }
+ }
}
void pBlockStats(FILE *of, pBlock *pb)
{
-
- pCode *pc;
- regs *r;
-
- fprintf(of,";***\n; pBlock Stats: dbName = %c\n;***\n",getpBlock_dbName(pb));
-
- // for now just print the first element of each set
- pc = setFirstItem(pb->function_entries);
- if(pc) {
- fprintf(of,";entry: ");
- pc->print(of,pc);
- }
- pc = setFirstItem(pb->function_exits);
- if(pc) {
- fprintf(of,";has an exit\n");
- //pc->print(of,pc);
- }
-
- pc = setFirstItem(pb->function_calls);
- if(pc) {
- fprintf(of,";functions called:\n");
-
- while(pc) {
- if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- fprintf(of,"; %s\n",get_op_from_instruction(PCI(pc)));
- }
- pc = setNextItem(pb->function_calls);
- }
- }
-
- r = setFirstItem(pb->tregisters);
- if(r) {
- int n = elementsInSet(pb->tregisters);
-
- fprintf(of,";%d compiler assigned register%c:\n",n, ( (n!=1) ? 's' : ' '));
-
- while (r) {
- fprintf(of,"; %s\n",r->name);
- r = setNextItem(pb->tregisters);
- }
- }
+
+ pCode *pc;
+ regs *r;
+
+ fprintf(of,";***\n; pBlock Stats: dbName = %c\n;***\n",getpBlock_dbName(pb));
+
+ // for now just print the first element of each set
+ pc = setFirstItem(pb->function_entries);
+ if(pc) {
+ fprintf(of,";entry: ");
+ pc->print(of,pc);
+ }
+ pc = setFirstItem(pb->function_exits);
+ if(pc) {
+ fprintf(of,";has an exit\n");
+ //pc->print(of,pc);
+ }
+
+ pc = setFirstItem(pb->function_calls);
+ if(pc) {
+ fprintf(of,";functions called:\n");
+
+ while(pc) {
+ if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
+ fprintf(of,"; %s\n",get_op_from_instruction(PCI(pc)));
+ }
+ pc = setNextItem(pb->function_calls);
+ }
+ }
+
+ r = setFirstItem(pb->tregisters);
+ if(r) {
+ int n = elementsInSet(pb->tregisters);
+
+ fprintf(of,";%d compiler assigned register%c:\n",n, ( (n!=1) ? 's' : ' '));
+
+ while (r) {
+ fprintf(of,"; %s\n",r->name);
+ r = setNextItem(pb->tregisters);
+ }
+ }
}
/*-----------------------------------------------------------------*/
#if 0
static void sequencepCode(void)
{
- pBlock *pb;
- pCode *pc;
-
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
-
- pb->seq = GpCodeSequenceNumber+1;
-
- for( pc = pb->pcHead; pc; pc = pc->next)
- pc->seq = ++GpCodeSequenceNumber;
- }
-
+ pBlock *pb;
+ pCode *pc;
+
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+
+ pb->seq = GpCodeSequenceNumber+1;
+
+ for( pc = pb->pcHead; pc; pc = pc->next)
+ pc->seq = ++GpCodeSequenceNumber;
+ }
+
}
#endif
/*
set *register_usage(pBlock *pb)
{
- pCode *pc,*pcn;
- set *registers=NULL;
- set *registersInCallPath = NULL;
-
- / * check recursion * /
-
- pc = setFirstItem(pb->function_entries);
-
- if(!pc)
- return registers;
-
- pb->visited = 1;
+ pCode *pc,*pcn;
+ set *registers=NULL;
+ set *registersInCallPath = NULL;
+
+ / * check recursion * /
- if(pc->type != PC_FUNCTION)
- fprintf(stderr,"%s, first pc is not a function???\n",__FUNCTION__);
+ pc = setFirstItem(pb->function_entries);
+
+ if(!pc)
+ return registers;
+
+ pb->visited = 1;
+
+ if(pc->type != PC_FUNCTION)
+ fprintf(stderr,"%s, first pc is not a function???\n",__FUNCTION__);
- pc = setFirstItem(pb->function_calls);
- for( ; pc; pc = setNextItem(pb->function_calls)) {
+ pc = setFirstItem(pb->function_calls);
+ for( ; pc; pc = setNextItem(pb->function_calls)) {
- if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- char *dest = get_op_from_instruction(PCI(pc));
+ if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
+ char *dest = get_op_from_instruction(PCI(pc));
- pcn = findFunction(dest);
- if(pcn)
- registersInCallPath = register_usage(pcn->pb);
- } else
- fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
+ pcn = findFunction(dest);
+ if(pcn)
+ registersInCallPath = register_usage(pcn->pb);
+ } else
+ fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
- }
+ }
#ifdef PCODE_DEBUG
- pBlockStats(stderr,pb); // debug
+ pBlockStats(stderr,pb); // debug
#endif
- // Mark the registers in this block as used.
+ // Mark the registers in this block as used.
- MarkUsedRegisters(pb->tregisters);
- if(registersInCallPath) {
- / * registers were used in the functions this pBlock has called * /
- / * so now, we need to see if these collide with the ones we are * /
- / * using here * /
+ MarkUsedRegisters(pb->tregisters);
+ if(registersInCallPath) {
+ / * registers were used in the functions this pBlock has called * /
+ / * so now, we need to see if these collide with the ones we are * /
+ / * using here * /
- regs *r1,*r2, *newreg;
+ regs *r1,*r2, *newreg;
- DFPRINTF((stderr,"comparing registers\n"));
+ DFPRINTF((stderr,"comparing registers\n"));
- r1 = setFirstItem(registersInCallPath);
- while(r1) {
- if (r1->type != REG_STK) {
- r2 = setFirstItem(pb->tregisters);
+ r1 = setFirstItem(registersInCallPath);
+ while(r1) {
+ if (r1->type != REG_STK) {
+ r2 = setFirstItem(pb->tregisters);
- while(r2 && (r2->type != REG_STK)) {
+ while(r2 && (r2->type != REG_STK)) {
- if(r2->rIdx == r1->rIdx) {
- newreg = pic14_findFreeReg(REG_GPR);
+ if(r2->rIdx == r1->rIdx) {
+ newreg = pic14_findFreeReg(REG_GPR);
- if(!newreg) {
- DFPRINTF((stderr,"Bummer, no more registers.\n"));
- exit(1);
- }
+ if(!newreg) {
+ DFPRINTF((stderr,"Bummer, no more registers.\n"));
+ exit(1);
+ }
- DFPRINTF((stderr,"Cool found register collision nIdx=%d moving to %d\n",
- r1->rIdx, newreg->rIdx));
- r2->rIdx = newreg->rIdx;
- if(newreg->name)
- r2->name = Safe_strdup(newreg->name);
- else
- r2->name = NULL;
- newreg->isFree = 0;
- newreg->wasUsed = 1;
- }
- r2 = setNextItem(pb->tregisters);
- }
- }
+ DFPRINTF((stderr,"Cool found register collision nIdx=%d moving to %d\n",
+ r1->rIdx, newreg->rIdx));
+ r2->rIdx = newreg->rIdx;
+ if(newreg->name)
+ r2->name = Safe_strdup(newreg->name);
+ else
+ r2->name = NULL;
+ newreg->isFree = 0;
+ newreg->wasUsed = 1;
+ }
+ r2 = setNextItem(pb->tregisters);
+ }
+ }
- r1 = setNextItem(registersInCallPath);
- }
+ r1 = setNextItem(registersInCallPath);
+ }
- / * Collisions have been resolved. Now free the registers in the call path * /
- r1 = setFirstItem(registersInCallPath);
- while(r1) {
- newreg = pic14_regWithIdx(r1->rIdx);
- if (newreg) newreg->isFree = 1;
- r1 = setNextItem(registersInCallPath);
- }
+ / * Collisions have been resolved. Now free the registers in the call path * /
+ r1 = setFirstItem(registersInCallPath);
+ while(r1) {
+ newreg = pic14_regWithIdx(r1->rIdx);
+ if (newreg) newreg->isFree = 1;
+ r1 = setNextItem(registersInCallPath);
+ }
- }// else
- // MarkUsedRegisters(pb->registers);
+ }// else
+ // MarkUsedRegisters(pb->registers);
- registers = unionSets(pb->tregisters, registersInCallPath, THROW_NONE);
+ registers = unionSets(pb->tregisters, registersInCallPath, THROW_NONE);
#ifdef PCODE_DEBUG
- if(registers)
- DFPRINTF((stderr,"returning regs\n"));
- else
- DFPRINTF((stderr,"not returning regs\n"));
+ if(registers)
+ DFPRINTF((stderr,"returning regs\n"));
+ else
+ DFPRINTF((stderr,"not returning regs\n"));
- DFPRINTF((stderr,"pBlock after register optim.\n"));
- pBlockStats(stderr,pb); // debug
+ DFPRINTF((stderr,"pBlock after register optim.\n"));
+ pBlockStats(stderr,pb); // debug
#endif
- return registers;
+ return registers;
}
*/
/*-----------------------------------------------------------------*/
void pct2(FILE *of,pBlock *pb,int indent)
{
- pCode *pc,*pcn;
- int i;
- // set *registersInCallPath = NULL;
-
- if(!of)
- return;
-
- if(indent > 10)
- return; //recursion ?
-
- pc = setFirstItem(pb->function_entries);
-
- if(!pc)
- return;
-
- pb->visited = 0;
-
- for(i=0;i<indent;i++) // Indentation
- fputc(' ',of);
-
- if(pc->type == PC_FUNCTION)
- fprintf(of,"%s\n",PCF(pc)->fname);
- else
- return; // ???
-
-
- pc = setFirstItem(pb->function_calls);
- for( ; pc; pc = setNextItem(pb->function_calls)) {
-
- if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- char *dest = get_op_from_instruction(PCI(pc));
-
- pcn = findFunction(dest);
- if(pcn)
- pct2(of,pcn->pb,indent+1);
- } else
- fprintf(of,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
-
- }
-
-
+ pCode *pc,*pcn;
+ int i;
+ // set *registersInCallPath = NULL;
+
+ if(!of)
+ return;
+
+ if(indent > 10)
+ return; //recursion ?
+
+ pc = setFirstItem(pb->function_entries);
+
+ if(!pc)
+ return;
+
+ pb->visited = 0;
+
+ for(i=0;i<indent;i++) // Indentation
+ fputc(' ',of);
+
+ if(pc->type == PC_FUNCTION)
+ fprintf(of,"%s\n",PCF(pc)->fname);
+ else
+ return; // ???
+
+
+ pc = setFirstItem(pb->function_calls);
+ for( ; pc; pc = setNextItem(pb->function_calls)) {
+
+ if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
+ char *dest = get_op_from_instruction(PCI(pc));
+
+ pcn = findFunction(dest);
+ if(pcn)
+ pct2(of,pcn->pb,indent+1);
+ } else
+ fprintf(of,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
+
+ }
+
+
}
void printCallTree(FILE *of)
{
- pBranch *pbr;
- pBlock *pb;
- pCode *pc;
-
- if(!the_pFile)
- return;
-
- if(!of)
- of = stderr;
-
- fprintf(of, "\npBlock statistics\n");
- for(pb = the_pFile->pbHead; pb; pb = pb->next )
- pBlockStats(of,pb);
-
-
-
- fprintf(of,"Call Tree\n");
- pbr = the_pFile->functions;
- while(pbr) {
- if(pbr->pc) {
- pc = pbr->pc;
- if(!ispCodeFunction(pc))
- fprintf(of,"bug in call tree");
-
-
- fprintf(of,"Function: %s\n", PCF(pc)->fname);
-
- while(pc->next && !ispCodeFunction(pc->next)) {
- pc = pc->next;
- if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL)
- fprintf(of,"\t%s\n",get_op_from_instruction(PCI(pc)));
- }
- }
-
- pbr = pbr->next;
- }
-
-
- fprintf(of,"\n**************\n\na better call tree\n");
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if(pb->visited)
- pct2(of,pb,0);
- }
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- fprintf(of,"block dbname: %c\n", getpBlock_dbName(pb));
- }
+ pBranch *pbr;
+ pBlock *pb;
+ pCode *pc;
+
+ if(!the_pFile)
+ return;
+
+ if(!of)
+ of = stderr;
+
+ fprintf(of, "\npBlock statistics\n");
+ for(pb = the_pFile->pbHead; pb; pb = pb->next )
+ pBlockStats(of,pb);
+
+
+
+ fprintf(of,"Call Tree\n");
+ pbr = the_pFile->functions;
+ while(pbr) {
+ if(pbr->pc) {
+ pc = pbr->pc;
+ if(!ispCodeFunction(pc))
+ fprintf(of,"bug in call tree");
+
+
+ fprintf(of,"Function: %s\n", PCF(pc)->fname);
+
+ while(pc->next && !ispCodeFunction(pc->next)) {
+ pc = pc->next;
+ if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL)
+ fprintf(of,"\t%s\n",get_op_from_instruction(PCI(pc)));
+ }
+ }
+
+ pbr = pbr->next;
+ }
+
+
+ fprintf(of,"\n**************\n\na better call tree\n");
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ if(pb->visited)
+ pct2(of,pb,0);
+ }
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ fprintf(of,"block dbname: %c\n", getpBlock_dbName(pb));
+ }
}
void InlineFunction(pBlock *pb)
{
- pCode *pc;
- pCode *pc_call;
-
- if(!pb)
- return;
-
- pc = setFirstItem(pb->function_calls);
-
- for( ; pc; pc = setNextItem(pb->function_calls)) {
-
- if(isCALL(pc)) {
- pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
- pCode *pcp = pc->prev;
- pCode *pct;
- pCode *pce;
-
- pBranch *pbr;
-
- if(pcn && isPCF(pcn) && (PCF(pcn)->ncalled == 1) && !PCF(pcn)->isPublic && (pcp && (isPCI_BITSKIP(pcp)||!isPCI_SKIP(pcp)))) { /* Bit skips can be inverted other skips can not */
-
- InlineFunction(pcn->pb);
-
- /*
- At this point, *pc points to a CALL mnemonic, and
- *pcn points to the function that is being called.
-
- To in-line this call, we need to remove the CALL
- and RETURN(s), and link the function pCode in with
- the CALLee pCode.
-
- */
-
- pc_call = pc;
-
- /* Check if previous instruction was a bit skip */
- if (isPCI_BITSKIP(pcp)) {
- pCodeLabel *pcl;
- /* Invert skip instruction and add a goto */
- PCI(pcp)->op = (PCI(pcp)->op == POC_BTFSS) ? POC_BTFSC : POC_BTFSS;
-
- if(isPCL(pc_call->next)) { // Label pcode
- pcl = PCL(pc_call->next);
- } else if (isPCI(pc_call->next) && PCI(pc_call->next)->label) { // pcode instruction with a label
- pcl = PCL(PCI(pc_call->next)->label->pc);
- } else {
- pcl = PCL(newpCodeLabel(NULL, newiTempLabel(NULL)->key+100));
- PCI(pc_call->next)->label->pc = (struct pCode*)pcl;
- }
- pCodeInsertAfter(pcp, newpCode(POC_GOTO, newpCodeOp(pcl->label,PO_STR)));
- }
-
- /* remove callee pBlock from the pBlock linked list */
- removepBlock(pcn->pb);
-
- pce = pcn;
- while(pce) {
- pce->pb = pb;
- pce = pce->next;
- }
-
- /* Remove the Function pCode */
- pct = findNextInstruction(pcn->next);
-
- /* Link the function with the callee */
- if (pcp) pcp->next = pcn->next;
- pcn->next->prev = pcp;
-
- /* Convert the function name into a label */
-
- pbr = Safe_calloc(1,sizeof(pBranch));
- pbr->pc = newpCodeLabel(PCF(pcn)->fname, -1);
- pbr->next = NULL;
- PCI(pct)->label = pBranchAppend(PCI(pct)->label,pbr);
- PCI(pct)->label = pBranchAppend(PCI(pct)->label,PCI(pc_call)->label);
-
- /* turn all of the return's except the last into goto's */
- /* check case for 2 instruction pBlocks */
- pce = findNextInstruction(pcn->next);
- while(pce) {
- pCode *pce_next = findNextInstruction(pce->next);
-
- if(pce_next == NULL) {
- /* found the last return */
- pCode *pc_call_next = findNextInstruction(pc_call->next);
-
- //fprintf(stderr,"found last return\n");
- //pce->print(stderr,pce);
- pce->prev->next = pc_call->next;
- pc_call->next->prev = pce->prev;
- PCI(pc_call_next)->label = pBranchAppend(PCI(pc_call_next)->label,
- PCI(pce)->label);
- }
-
- pce = pce_next;
- }
-
- }
- } else
- fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
-
- }
-
+ pCode *pc;
+ pCode *pc_call;
+
+ if(!pb)
+ return;
+
+ pc = setFirstItem(pb->function_calls);
+
+ for( ; pc; pc = setNextItem(pb->function_calls)) {
+
+ if(isCALL(pc)) {
+ pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
+ pCode *pcp = pc->prev;
+ pCode *pct;
+ pCode *pce;
+
+ pBranch *pbr;
+
+ if(pcn && isPCF(pcn) && (PCF(pcn)->ncalled == 1) && !PCF(pcn)->isPublic && (pcp && (isPCI_BITSKIP(pcp)||!isPCI_SKIP(pcp)))) { /* Bit skips can be inverted other skips can not */
+
+ InlineFunction(pcn->pb);
+
+ /*
+ At this point, *pc points to a CALL mnemonic, and
+ *pcn points to the function that is being called.
+
+ To in-line this call, we need to remove the CALL
+ and RETURN(s), and link the function pCode in with
+ the CALLee pCode.
+
+ */
+
+ pc_call = pc;
+
+ /* Check if previous instruction was a bit skip */
+ if (isPCI_BITSKIP(pcp)) {
+ pCodeLabel *pcl;
+ /* Invert skip instruction and add a goto */
+ PCI(pcp)->op = (PCI(pcp)->op == POC_BTFSS) ? POC_BTFSC : POC_BTFSS;
+
+ if(isPCL(pc_call->next)) { // Label pcode
+ pcl = PCL(pc_call->next);
+ } else if (isPCI(pc_call->next) && PCI(pc_call->next)->label) { // pcode instruction with a label
+ pcl = PCL(PCI(pc_call->next)->label->pc);
+ } else {
+ pcl = PCL(newpCodeLabel(NULL, newiTempLabel(NULL)->key+100));
+ PCI(pc_call->next)->label->pc = (struct pCode*)pcl;
+ }
+ pCodeInsertAfter(pcp, newpCode(POC_GOTO, newpCodeOp(pcl->label,PO_STR)));
+ }
+
+ /* remove callee pBlock from the pBlock linked list */
+ removepBlock(pcn->pb);
+
+ pce = pcn;
+ while(pce) {
+ pce->pb = pb;
+ pce = pce->next;
+ }
+
+ /* Remove the Function pCode */
+ pct = findNextInstruction(pcn->next);
+
+ /* Link the function with the callee */
+ if (pcp) pcp->next = pcn->next;
+ pcn->next->prev = pcp;
+
+ /* Convert the function name into a label */
+
+ pbr = Safe_calloc(1,sizeof(pBranch));
+ pbr->pc = newpCodeLabel(PCF(pcn)->fname, -1);
+ pbr->next = NULL;
+ PCI(pct)->label = pBranchAppend(PCI(pct)->label,pbr);
+ PCI(pct)->label = pBranchAppend(PCI(pct)->label,PCI(pc_call)->label);
+
+ /* turn all of the return's except the last into goto's */
+ /* check case for 2 instruction pBlocks */
+ pce = findNextInstruction(pcn->next);
+ while(pce) {
+ pCode *pce_next = findNextInstruction(pce->next);
+
+ if(pce_next == NULL) {
+ /* found the last return */
+ pCode *pc_call_next = findNextInstruction(pc_call->next);
+
+ //fprintf(stderr,"found last return\n");
+ //pce->print(stderr,pce);
+ pce->prev->next = pc_call->next;
+ pc_call->next->prev = pce->prev;
+ PCI(pc_call_next)->label = pBranchAppend(PCI(pc_call_next)->label,
+ PCI(pce)->label);
+ }
+
+ pce = pce_next;
+ }
+
+ }
+ } else
+ fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
+
+ }
+
}
/*-----------------------------------------------------------------*/
void InlinepCode(void)
{
-
- pBlock *pb;
- pCode *pc;
-
- if(!the_pFile)
- return;
-
- if(!functionInlining)
- return;
-
- /* Loop through all of the function definitions and count the
- * number of times each one is called */
- //fprintf(stderr,"inlining %d\n",__LINE__);
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
-
- pc = setFirstItem(pb->function_calls);
-
- for( ; pc; pc = setNextItem(pb->function_calls)) {
-
- if(isCALL(pc)) {
- pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
- if(pcn && isPCF(pcn)) {
- PCF(pcn)->ncalled++;
+
+ pBlock *pb;
+ pCode *pc;
+
+ if(!the_pFile)
+ return;
+
+ if(!functionInlining)
+ return;
+
+ /* Loop through all of the function definitions and count the
+ * number of times each one is called */
+ //fprintf(stderr,"inlining %d\n",__LINE__);
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+
+ pc = setFirstItem(pb->function_calls);
+
+ for( ; pc; pc = setNextItem(pb->function_calls)) {
+
+ if(isCALL(pc)) {
+ pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
+ if(pcn && isPCF(pcn)) {
+ PCF(pcn)->ncalled++;
+ }
+ } else
+ fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
+
+ }
}
- } else
- fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
-
- }
- }
-
- //fprintf(stderr,"inlining %d\n",__LINE__);
-
- /* Now, Loop through the function definitions again, but this
- * time inline those functions that have only been called once. */
-
- InlineFunction(the_pFile->pbHead);
- //fprintf(stderr,"inlining %d\n",__LINE__);
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- unBuildFlow(pb);
-
+
+ //fprintf(stderr,"inlining %d\n",__LINE__);
+
+ /* Now, Loop through the function definitions again, but this
+ * time inline those functions that have only been called once. */
+
+ InlineFunction(the_pFile->pbHead);
+ //fprintf(stderr,"inlining %d\n",__LINE__);
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ unBuildFlow(pb);
+
}
typedef enum
{
- PO_NONE=0, // No operand e.g. NOP
- PO_W, // The 'W' register
- PO_STATUS, // The 'STATUS' register
- PO_FSR, // The "file select register" (in 18c it's one of three)
- PO_INDF, // The Indirect register
- PO_INTCON, // Interrupt Control register
- PO_GPR_REGISTER, // A general purpose register
- PO_GPR_BIT, // A bit of a general purpose register
- PO_GPR_TEMP, // A general purpose temporary register
- PO_GPR_POINTER, // A general purpose pointer
- PO_SFR_REGISTER, // A special function register (e.g. PORTA)
- PO_PCL, // Program counter Low register
- PO_PCLATH, // Program counter Latch high register
- PO_LITERAL, // A constant
- PO_IMMEDIATE, // (8051 legacy)
- PO_DIR, // Direct memory (8051 legacy)
- PO_CRY, // bit memory (8051 legacy)
- PO_BIT, // bit operand.
- PO_STR, // (8051 legacy)
- PO_LABEL,
- PO_WILD // Wild card operand in peep optimizer
+ PO_NONE=0, // No operand e.g. NOP
+ PO_W, // The 'W' register
+ PO_STATUS, // The 'STATUS' register
+ PO_FSR, // The "file select register" (in 18c it's one of three)
+ PO_INDF, // The Indirect register
+ PO_INTCON, // Interrupt Control register
+ PO_GPR_REGISTER, // A general purpose register
+ PO_GPR_BIT, // A bit of a general purpose register
+ PO_GPR_TEMP, // A general purpose temporary register
+ PO_GPR_POINTER, // A general purpose pointer
+ PO_SFR_REGISTER, // A special function register (e.g. PORTA)
+ PO_PCL, // Program counter Low register
+ PO_PCLATH, // Program counter Latch high register
+ PO_LITERAL, // A constant
+ PO_IMMEDIATE, // (8051 legacy)
+ PO_DIR, // Direct memory (8051 legacy)
+ PO_CRY, // bit memory (8051 legacy)
+ PO_BIT, // bit operand.
+ PO_STR, // (8051 legacy)
+ PO_LABEL,
+ PO_WILD // Wild card operand in peep optimizer
} PIC_OPTYPE;
typedef enum
{
- POC_WILD=-1, /* Wild card - used in the pCode peep hole optimizer
- * to represent ANY pic opcode */
- POC_ADDLW=0,
- POC_ADDWF,
- POC_ADDFW,
- POC_ANDLW,
- POC_ANDWF,
- POC_ANDFW,
- POC_BCF,
- POC_BSF,
- POC_BTFSC,
- POC_BTFSS,
- POC_CALL,
- POC_COMF,
- POC_COMFW,
- POC_CLRF,
- POC_CLRW,
- POC_CLRWDT,
- POC_DECF,
- POC_DECFW,
- POC_DECFSZ,
- POC_DECFSZW,
- POC_GOTO,
- POC_INCF,
- POC_INCFW,
- POC_INCFSZ,
- POC_INCFSZW,
- POC_IORLW,
- POC_IORWF,
- POC_IORFW,
- POC_MOVF,
- POC_MOVFW,
- POC_MOVLW,
- POC_MOVWF,
- POC_NOP,
- POC_RETLW,
- POC_RETURN,
- POC_RETFIE,
- POC_RLF,
- POC_RLFW,
- POC_RRF,
- POC_RRFW,
- POC_SUBLW,
- POC_SUBWF,
- POC_SUBFW,
- POC_SWAPF,
- POC_SWAPFW,
- POC_TRIS,
- POC_XORLW,
- POC_XORWF,
- POC_XORFW,
- POC_BANKSEL,
- POC_PAGESEL,
-
- MAX_PIC14MNEMONICS
+ POC_WILD=-1, /* Wild card - used in the pCode peep hole optimizer
+ * to represent ANY pic opcode */
+ POC_ADDLW=0,
+ POC_ADDWF,
+ POC_ADDFW,
+ POC_ANDLW,
+ POC_ANDWF,
+ POC_ANDFW,
+ POC_BCF,
+ POC_BSF,
+ POC_BTFSC,
+ POC_BTFSS,
+ POC_CALL,
+ POC_COMF,
+ POC_COMFW,
+ POC_CLRF,
+ POC_CLRW,
+ POC_CLRWDT,
+ POC_DECF,
+ POC_DECFW,
+ POC_DECFSZ,
+ POC_DECFSZW,
+ POC_GOTO,
+ POC_INCF,
+ POC_INCFW,
+ POC_INCFSZ,
+ POC_INCFSZW,
+ POC_IORLW,
+ POC_IORWF,
+ POC_IORFW,
+ POC_MOVF,
+ POC_MOVFW,
+ POC_MOVLW,
+ POC_MOVWF,
+ POC_NOP,
+ POC_RETLW,
+ POC_RETURN,
+ POC_RETFIE,
+ POC_RLF,
+ POC_RLFW,
+ POC_RRF,
+ POC_RRFW,
+ POC_SUBLW,
+ POC_SUBWF,
+ POC_SUBFW,
+ POC_SWAPF,
+ POC_SWAPFW,
+ POC_TRIS,
+ POC_XORLW,
+ POC_XORWF,
+ POC_XORFW,
+ POC_BANKSEL,
+ POC_PAGESEL,
+
+ MAX_PIC14MNEMONICS
} PIC_OPCODE;
typedef enum
{
- PC_COMMENT=0, /* pCode is a comment */
- PC_INLINE, /* user's inline code */
- PC_OPCODE, /* PORT dependent opcode */
- PC_LABEL, /* assembly label */
- PC_FLOW, /* flow analysis */
- PC_FUNCTION, /* Function start or end */
- PC_WILD, /* wildcard - an opcode place holder used
- * in the pCode peep hole optimizer */
- PC_CSOURCE, /* C-Source Line */
- PC_BAD /* Mark the pCode object as being bad */
+ PC_COMMENT=0, /* pCode is a comment */
+ PC_INLINE, /* user's inline code */
+ PC_OPCODE, /* PORT dependent opcode */
+ PC_LABEL, /* assembly label */
+ PC_FLOW, /* flow analysis */
+ PC_FUNCTION, /* Function start or end */
+ PC_WILD, /* wildcard - an opcode place holder used
+ * in the pCode peep hole optimizer */
+ PC_CSOURCE, /* C-Source Line */
+ PC_BAD /* Mark the pCode object as being bad */
} PC_TYPE;
/************************************************/
typedef struct pBranch
{
- struct pCode *pc; // Next pCode in a branch
- struct pBranch *next; /* If more than one branch
- * the next one is here */
+ struct pCode *pc; // Next pCode in a branch
+ struct pBranch *next; /* If more than one branch
+ * the next one is here */
} pBranch;
typedef struct pCodeOp
{
- PIC_OPTYPE type;
- char *name;
-
+ PIC_OPTYPE type;
+ char *name;
+
} pCodeOp;
#if 0
typedef struct pCodeOpBit
{
- pCodeOp pcop;
- int bit;
- unsigned int inBitSpace: 1; /* True if in bit space, else
- just a bit of a register */
+ pCodeOp pcop;
+ int bit;
+ unsigned int inBitSpace: 1; /* True if in bit space, else
+ just a bit of a register */
} pCodeOpBit;
#endif
typedef struct pCodeOpLit
{
- pCodeOp pcop;
- int lit;
+ pCodeOp pcop;
+ int lit;
} pCodeOpLit;
typedef struct pCodeOpImmd
{
- pCodeOp pcop;
- int offset; /* low,med, or high byte of immediate value */
- int index; /* add this to the immediate value */
- unsigned _const:1; /* is in code space */
- unsigned _function:1; /* is a (pointer to a) function */
+ pCodeOp pcop;
+ int offset; /* low,med, or high byte of immediate value */
+ int index; /* add this to the immediate value */
+ unsigned _const:1; /* is in code space */
+ unsigned _function:1; /* is a (pointer to a) function */
- int rIdx; /* If this immd points to a register */
- struct regs *r; /* then this is the reg. */
+ int rIdx; /* If this immd points to a register */
+ struct regs *r; /* then this is the reg. */
} pCodeOpImmd;
typedef struct pCodeOpLabel
{
- pCodeOp pcop;
- int key;
- int offset; /* low or high byte of label */
+ pCodeOp pcop;
+ int key;
+ int offset; /* low or high byte of label */
} pCodeOpLabel;
typedef struct pCodeOpReg
{
- pCodeOp pcop; // Can be either GPR or SFR
- int rIdx; // Index into the register table
- struct regs *r;
- int instance; // byte # of Multi-byte registers
- struct pBlock *pb;
+ pCodeOp pcop; // Can be either GPR or SFR
+ int rIdx; // Index into the register table
+ struct regs *r;
+ int instance; // byte # of Multi-byte registers
+ struct pBlock *pb;
} pCodeOpReg;
typedef struct pCodeOpRegBit
{
- pCodeOpReg pcor; // The Register containing this bit
- int bit; // 0-7 bit number.
- PIC_OPTYPE subtype; // The type of this register.
- unsigned int inBitSpace: 1; /* True if in bit space, else
- just a bit of a register */
+ pCodeOpReg pcor; // The Register containing this bit
+ int bit; // 0-7 bit number.
+ PIC_OPTYPE subtype; // The type of this register.
+ unsigned int inBitSpace: 1; /* True if in bit space, else
+ just a bit of a register */
} pCodeOpRegBit;
typedef struct pCodeOpRegPtr
{
- pCodeOpReg pcor; // The Register containing this bit
+ pCodeOpReg pcor; // The Register containing this bit
- // PIC_OPTYPE subtype; // The type of this register.
- // unsigned int inBitSpace: 1; /* True if in bit space, else
+ // PIC_OPTYPE subtype; // The type of this register.
+ // unsigned int inBitSpace: 1; /* True if in bit space, else
} pCodeOpRegPtr;
typedef struct pCodeOpStr /* Only used here for the name of fn being called or jumped to */
{
- pCodeOp pcop;
- unsigned isPublic: 1; /* True if not static ie extern */
+ pCodeOp pcop;
+ unsigned isPublic: 1; /* True if not static ie extern */
} pCodeOpStr;
typedef struct pCodeOpWild
{
- pCodeOp pcop;
+ pCodeOp pcop;
- struct pCodeWildBlock *pcwb;
+ struct pCodeWildBlock *pcwb;
- int id; /* index into an array of char *'s that will match
- * the wild card. The array is in *pcp. */
- pCodeOp *subtype; /* Pointer to the Operand type into which this wild
- * card will be expanded */
- pCodeOp *matched; /* When a wild matches, we'll store a pointer to the
- * opcode we matched */
+ int id; /* index into an array of char *'s that will match
+ * the wild card. The array is in *pcp. */
+ pCodeOp *subtype; /* Pointer to the Operand type into which this wild
+ * card will be expanded */
+ pCodeOp *matched; /* When a wild matches, we'll store a pointer to the
+ * opcode we matched */
} pCodeOpWild;
typedef struct pCode
{
- PC_TYPE type;
+ PC_TYPE type;
- struct pCode *prev; // The pCode objects are linked together
- struct pCode *next; // in doubly linked lists.
+ struct pCode *prev; // The pCode objects are linked together
+ struct pCode *next; // in doubly linked lists.
- unsigned id; // unique ID number for all pCodes to assist in debugging
- int seq; // sequence number
+ unsigned id; // unique ID number for all pCodes to assist in debugging
+ int seq; // sequence number
- struct pBlock *pb; // The pBlock that contains this pCode.
+ struct pBlock *pb; // The pBlock that contains this pCode.
- /* "virtual functions"
- * The pCode structure is like a base class
- * in C++. The subsequent structures that "inherit"
- * the pCode structure will initialize these function
- * pointers to something useful */
- // void (*analyze) (struct pCode *_this);
- void (*destruct)(struct pCode *_this);
- void (*print) (FILE *of,struct pCode *_this);
+ /* "virtual functions"
+ * The pCode structure is like a base class
+ * in C++. The subsequent structures that "inherit"
+ * the pCode structure will initialize these function
+ * pointers to something useful */
+ // void (*analyze) (struct pCode *_this);
+ void (*destruct)(struct pCode *_this);
+ void (*print) (FILE *of,struct pCode *_this);
} pCode;
typedef struct pCodeComment
{
- pCode pc;
+ pCode pc;
- char *comment;
+ char *comment;
} pCodeComment;
typedef struct pCodeCSource
{
- pCode pc;
+ pCode pc;
- int line_number;
- char *line;
- char *file_name;
+ int line_number;
+ char *line;
+ char *file_name;
} pCodeCSource;
typedef struct pCodeFlow
{
- pCode pc;
+ pCode pc;
- pCode *end; /* Last pCode in this flow. Note that
- the first pCode is pc.next */
+ pCode *end; /* Last pCode in this flow. Note that
+ the first pCode is pc.next */
- /* set **uses; * map the pCode instruction inCond and outCond conditions
- * in this array of set's. The reason we allocate an
- * array of pointers instead of declaring each type of
- * usage is because there are port dependent usage definitions */
- //int nuses; /* number of uses sets */
+ /* set **uses; * map the pCode instruction inCond and outCond conditions
+ * in this array of set's. The reason we allocate an
+ * array of pointers instead of declaring each type of
+ * usage is because there are port dependent usage definitions */
+ //int nuses; /* number of uses sets */
- set *from; /* flow blocks that can send control to this flow block */
- set *to; /* flow blocks to which this one can send control */
- struct pCodeFlow *ancestor; /* The most immediate "single" pCodeFlow object that
- * executes prior to this one. In many cases, this
- * will be just the previous */
+ set *from; /* flow blocks that can send control to this flow block */
+ set *to; /* flow blocks to which this one can send control */
+ struct pCodeFlow *ancestor; /* The most immediate "single" pCodeFlow object that
+ * executes prior to this one. In many cases, this
+ * will be just the previous */
- int inCond; /* Input conditions - stuff assumed defined at entry */
- int outCond; /* Output conditions - stuff modified by flow block */
+ int inCond; /* Input conditions - stuff assumed defined at entry */
+ int outCond; /* Output conditions - stuff modified by flow block */
- int firstBank; /* The first and last bank flags are the first and last */
- int lastBank; /* register banks used within one flow object */
+ int firstBank; /* The first and last bank flags are the first and last */
+ int lastBank; /* register banks used within one flow object */
- int FromConflicts;
- int ToConflicts;
+ int FromConflicts;
+ int ToConflicts;
- set *registers;/* Registers used in this flow */
+ set *registers;/* Registers used in this flow */
} pCodeFlow;
*/
typedef struct pCodeFlowLink
{
- pCodeFlow *pcflow; /* pointer to linked pCodeFlow object */
+ pCodeFlow *pcflow; /* pointer to linked pCodeFlow object */
- int bank_conflict; /* records bank conflicts */
+ int bank_conflict; /* records bank conflicts */
} pCodeFlowLink;
typedef struct pCodeInstruction
{
- pCode pc;
+ pCode pc;
- PIC_OPCODE op; // The opcode of the instruction.
+ PIC_OPCODE op; // The opcode of the instruction.
- char const * const mnemonic; // Pointer to mnemonic string
+ char const * const mnemonic; // Pointer to mnemonic string
- pBranch *from; // pCodes that execute before this one
- pBranch *to; // pCodes that execute after
- pBranch *label; // pCode instructions that have labels
+ pBranch *from; // pCodes that execute before this one
+ pBranch *to; // pCodes that execute after
+ pBranch *label; // pCode instructions that have labels
- pCodeOp *pcop; /* Operand, if this instruction has one */
- pCodeFlow *pcflow; /* flow block to which this instruction belongs */
- pCodeCSource *cline; /* C Source from which this instruction was derived */
+ pCodeOp *pcop; /* Operand, if this instruction has one */
+ pCodeFlow *pcflow; /* flow block to which this instruction belongs */
+ pCodeCSource *cline; /* C Source from which this instruction was derived */
- unsigned int num_ops; /* Number of operands (0,1,2 for mid range pics) */
- unsigned int isModReg: 1; /* If destination is W or F, then 1==F */
- unsigned int isBitInst: 1; /* e.g. BCF */
- unsigned int isBranch: 1; /* True if this is a branching instruction */
- unsigned int isSkip: 1; /* True if this is a skip instruction */
- unsigned int isLit: 1; /* True if this instruction has an literal operand */
+ unsigned int num_ops; /* Number of operands (0,1,2 for mid range pics) */
+ unsigned int isModReg: 1; /* If destination is W or F, then 1==F */
+ unsigned int isBitInst: 1; /* e.g. BCF */
+ unsigned int isBranch: 1; /* True if this is a branching instruction */
+ unsigned int isSkip: 1; /* True if this is a skip instruction */
+ unsigned int isLit: 1; /* True if this instruction has an literal operand */
- PIC_OPCODE inverted_op; /* Opcode of instruction that's the opposite of this one */
- unsigned int inCond; // Input conditions for this instruction
- unsigned int outCond; // Output conditions for this instruction
+ PIC_OPCODE inverted_op; /* Opcode of instruction that's the opposite of this one */
+ unsigned int inCond; // Input conditions for this instruction
+ unsigned int outCond; // Output conditions for this instruction
} pCodeInstruction;
typedef struct pCodeLabel
{
- pCode pc;
+ pCode pc;
- char *label;
- int key;
+ char *label;
+ int key;
} pCodeLabel;
typedef struct pCodeFunction
{
- pCode pc;
+ pCode pc;
- char *modname;
- char *fname; /* If NULL, then this is the end of
- a function. Otherwise, it's the
- start and the name is contained
- here */
+ char *modname;
+ char *fname; /* If NULL, then this is the end of
+ a function. Otherwise, it's the
+ start and the name is contained
+ here */
- pBranch *from; // pCodes that execute before this one
- pBranch *to; // pCodes that execute after
- pBranch *label; // pCode instructions that have labels
+ pBranch *from; // pCodes that execute before this one
+ pBranch *to; // pCodes that execute after
+ pBranch *label; // pCode instructions that have labels
- int ncalled; /* Number of times function is called */
- unsigned isPublic:1; /* True if the fn is not static and can be called from another module (ie a another c or asm file) */
+ int ncalled; /* Number of times function is called */
+ unsigned isPublic:1; /* True if the fn is not static and can be called from another module (ie a another c or asm file) */
} pCodeFunction;
typedef struct pCodeWild
{
- pCodeInstruction pci;
+ pCodeInstruction pci;
- int id; /* Index into the wild card array of a peepBlock
- * - this wild card will get expanded into that pCode
- * that is stored at this index */
+ int id; /* Index into the wild card array of a peepBlock
+ * - this wild card will get expanded into that pCode
+ * that is stored at this index */
- /* Conditions on wild pcode instruction */
- int mustBeBitSkipInst:1;
- int mustNotBeBitSkipInst:1;
- int invertBitSkipInst:1;
+ /* Conditions on wild pcode instruction */
+ int mustBeBitSkipInst:1;
+ int mustNotBeBitSkipInst:1;
+ int invertBitSkipInst:1;
- pCodeOp *operand; // Optional operand
- pCodeOp *label; // Optional label
+ pCodeOp *operand; // Optional operand
+ pCodeOp *label; // Optional label
} pCodeWild;
typedef struct pBlock
{
- memmap *cmemmap; /* The snippet is from this memmap */
- char dbName; /* if cmemmap is NULL, then dbName will identify the block */
- pCode *pcHead; /* A pointer to the first pCode in a link list of pCodes */
- pCode *pcTail; /* A pointer to the last pCode in a link list of pCodes */
+ memmap *cmemmap; /* The snippet is from this memmap */
+ char dbName; /* if cmemmap is NULL, then dbName will identify the block */
+ pCode *pcHead; /* A pointer to the first pCode in a link list of pCodes */
+ pCode *pcTail; /* A pointer to the last pCode in a link list of pCodes */
- struct pBlock *next; /* The pBlocks will form a doubly linked list */
- struct pBlock *prev;
+ struct pBlock *next; /* The pBlocks will form a doubly linked list */
+ struct pBlock *prev;
- set *function_entries; /* dll of functions in this pblock */
- set *function_exits;
- set *function_calls;
- set *tregisters;
+ set *function_entries; /* dll of functions in this pblock */
+ set *function_exits;
+ set *function_calls;
+ set *tregisters;
- set *FlowTree;
- unsigned visited:1; /* set true if traversed in call tree */
+ set *FlowTree;
+ unsigned visited:1; /* set true if traversed in call tree */
- unsigned seq; /* sequence number of this pBlock */
+ unsigned seq; /* sequence number of this pBlock */
} pBlock;
typedef struct pFile
{
- pBlock *pbHead; /* A pointer to the first pBlock */
- pBlock *pbTail; /* A pointer to the last pBlock */
+ pBlock *pbHead; /* A pointer to the first pBlock */
+ pBlock *pbTail; /* A pointer to the last pBlock */
- pBranch *functions; /* A SLL of functions in this pFile */
+ pBranch *functions; /* A SLL of functions in this pFile */
} pFile;
a pBlock.
**************************************************/
typedef struct pCodeWildBlock {
- pBlock *pb;
- struct pCodePeep *pcp; // pointer back to ... I don't like this...
+ pBlock *pb;
+ struct pCodePeep *pcp; // pointer back to ... I don't like this...
- int nvars; // Number of wildcard registers in target.
- char **vars; // array of pointers to them
+ int nvars; // Number of wildcard registers in target.
+ char **vars; // array of pointers to them
- int nops; // Number of wildcard operands in target.
- pCodeOp **wildpCodeOps; // array of pointers to the pCodeOp's.
+ int nops; // Number of wildcard operands in target.
+ pCodeOp **wildpCodeOps; // array of pointers to the pCodeOp's.
- int nwildpCodes; // Number of wildcard pCodes in target/replace
- pCode **wildpCodes; // array of pointers to the pCode's.
+ int nwildpCodes; // Number of wildcard pCodes in target/replace
+ pCode **wildpCodes; // array of pointers to the pCode's.
} pCodeWildBlock;
pCode chain.
**************************************************/
typedef struct pCodePeep {
- pCodeWildBlock target; // code we'd like to optimize
- pCodeWildBlock replace; // and this is what we'll optimize it with.
+ pCodeWildBlock target; // code we'd like to optimize
+ pCodeWildBlock replace; // and this is what we'll optimize it with.
- //pBlock *target;
- //pBlock replace; // and this is what we'll optimize it with.
+ //pBlock *target;
+ //pBlock replace; // and this is what we'll optimize it with.
- /* (Note: a wildcard register is a place holder. Any register
- * can be replaced by the wildcard when the pcode is being
- * compared to the target. */
+ /* (Note: a wildcard register is a place holder. Any register
+ * can be replaced by the wildcard when the pcode is being
+ * compared to the target. */
- /* Post Conditions. A post condition is a condition that
- * must be either true or false before the peep rule is
- * accepted. For example, a certain rule may be accepted
- * if and only if the Z-bit is not used as an input to
- * the subsequent instructions in a pCode chain.
- */
- unsigned int postFalseCond;
- unsigned int postTrueCond;
+ /* Post Conditions. A post condition is a condition that
+ * must be either true or false before the peep rule is
+ * accepted. For example, a certain rule may be accepted
+ * if and only if the Z-bit is not used as an input to
+ * the subsequent instructions in a pCode chain.
+ */
+ unsigned int postFalseCond;
+ unsigned int postTrueCond;
} pCodePeep;
**************************************************/
enum peepCommandTypes{
- NOTBITSKIP = 0,
- BITSKIP,
- INVERTBITSKIP,
- _LAST_PEEP_COMMAND_
+ NOTBITSKIP = 0,
+ BITSKIP,
+ INVERTBITSKIP,
+ _LAST_PEEP_COMMAND_
};
/*************************************************
**************************************************/
typedef struct peepCommand {
- int id;
- char *cmd;
+ int id;
+ char *cmd;
} peepCommand;
/*************************************************
#if 0
/*
- In the section that follows, an exhaustive flow "tree" is built.
- It's not a tree that's really built, but instead every possible
- flow path is constructed.
+In the section that follows, an exhaustive flow "tree" is built.
+It's not a tree that's really built, but instead every possible
+flow path is constructed.
- This is really overkill...
+ This is really overkill...
*/
static set *FlowTree=NULL;
void dbg_dumpFlowTree(set *FlowTree)
{
- set *segment;
- pCodeFlow *pcflow;
-
- fprintf(stderr,"Flow Tree: \n");
-
- for(segment = setFirstItem(FlowTree); segment; segment=setNextItem(FlowTree)) {
-
- fprintf(stderr,"Segment:\n");
-
- for(pcflow=PCFL(setFirstItem(segment)); pcflow; pcflow=PCFL(setNextItem(segment))) {
- fprintf(stderr, " 0x%03x",pcflow->pc.seq);
- }
- fprintf(stderr,"\n");
- }
-
+ set *segment;
+ pCodeFlow *pcflow;
+
+ fprintf(stderr,"Flow Tree: \n");
+
+ for(segment = setFirstItem(FlowTree); segment; segment=setNextItem(FlowTree)) {
+
+ fprintf(stderr,"Segment:\n");
+
+ for(pcflow=PCFL(setFirstItem(segment)); pcflow; pcflow=PCFL(setNextItem(segment))) {
+ fprintf(stderr, " 0x%03x",pcflow->pc.seq);
+ }
+ fprintf(stderr,"\n");
+ }
+
}
/*-----------------------------------------------------------------*
- * void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
- *-----------------------------------------------------------------*/
+* void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
+*-----------------------------------------------------------------*/
void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
{
-
- int nNextFlow=0;
- pCodeFlowLink *pcflowLink=NULL;
-
- /* Add this flow to the set if it's not in there already */
- if(isinSet(segment, pcflow)) {
- addSetHead(&FlowTree, segment);
- return;
- }
-
- addSetHead(&segment, pcflow);
-
- /* Continue to add contiguous flows */
-
- while( pcflow->to && ((nNextFlow = elementsInSet(pcflow->to)) == 1)) {
- pcflowLink = (pCodeFlowLink *)(setFirstItem(pcflow->to));
- pcflow = pcflowLink->pcflow;
-
- if(isinSet(segment, pcflow)) {
- addSetIfnotP(&FlowTree, segment);
- return;
- }
-
- addSetIfnotP(&segment, pcflow);
-
- }
-
- /* Branch: for each branch, duplicate the set and recursively call */
- if(pcflow->to && nNextFlow>=2) {
- pCodeFlow *pcflow_to;
-
- set *branch_segment=NULL;
-
- pcflowLink = (pCodeFlowLink *)(setFirstItem(pcflow->to));
- pcflow_to = pcflowLink->pcflow;
-
- addSetIfnotP(&segment, pcflow);
-
- pcflowLink = (pCodeFlowLink *)(setNextItem(pcflow->to));
-
- while(pcflowLink) {
-
- branch_segment = setFromSet(segment);
- BuildFlowSegment(setFromSet(segment),pcflowLink->pcflow);
- pcflowLink = (pCodeFlowLink *)(setNextItem(pcflow->to));
- }
-
- /* add the first branch to this segment */
- BuildFlowSegment(segment,pcflow_to);
-
- }
-
- addSetIfnotP(&FlowTree, segment);
-
- /* done */
+
+ int nNextFlow=0;
+ pCodeFlowLink *pcflowLink=NULL;
+
+ /* Add this flow to the set if it's not in there already */
+ if(isinSet(segment, pcflow)) {
+ addSetHead(&FlowTree, segment);
+ return;
+ }
+
+ addSetHead(&segment, pcflow);
+
+ /* Continue to add contiguous flows */
+
+ while( pcflow->to && ((nNextFlow = elementsInSet(pcflow->to)) == 1)) {
+ pcflowLink = (pCodeFlowLink *)(setFirstItem(pcflow->to));
+ pcflow = pcflowLink->pcflow;
+
+ if(isinSet(segment, pcflow)) {
+ addSetIfnotP(&FlowTree, segment);
+ return;
+ }
+
+ addSetIfnotP(&segment, pcflow);
+
+ }
+
+ /* Branch: for each branch, duplicate the set and recursively call */
+ if(pcflow->to && nNextFlow>=2) {
+ pCodeFlow *pcflow_to;
+
+ set *branch_segment=NULL;
+
+ pcflowLink = (pCodeFlowLink *)(setFirstItem(pcflow->to));
+ pcflow_to = pcflowLink->pcflow;
+
+ addSetIfnotP(&segment, pcflow);
+
+ pcflowLink = (pCodeFlowLink *)(setNextItem(pcflow->to));
+
+ while(pcflowLink) {
+
+ branch_segment = setFromSet(segment);
+ BuildFlowSegment(setFromSet(segment),pcflowLink->pcflow);
+ pcflowLink = (pCodeFlowLink *)(setNextItem(pcflow->to));
+ }
+
+ /* add the first branch to this segment */
+ BuildFlowSegment(segment,pcflow_to);
+
+ }
+
+ addSetIfnotP(&FlowTree, segment);
+
+ /* done */
}
/*-----------------------------------------------------------------*
- * void BuildFlowTree(pBlock *pb)
- *-----------------------------------------------------------------*/
+* void BuildFlowTree(pBlock *pb)
+*-----------------------------------------------------------------*/
void BuildFlowTree(pBlock *pb)
{
- pCodeFlow *pcflow;
- set *segment;
-
- FlowTree = newSet();
-
- /* Start with the first flow object of this pBlock */
-
- pcflow = PCFL(findNextpCode(pb->pcHead, PC_FLOW));
-
- segment = newSet();
- BuildFlowSegment(segment, pcflow);
-
- pb->FlowTree = FlowTree;
-
- dbg_dumpFlowTree(FlowTree);
+ pCodeFlow *pcflow;
+ set *segment;
+
+ FlowTree = newSet();
+
+ /* Start with the first flow object of this pBlock */
+
+ pcflow = PCFL(findNextpCode(pb->pcHead, PC_FLOW));
+
+ segment = newSet();
+ BuildFlowSegment(segment, pcflow);
+
+ pb->FlowTree = FlowTree;
+
+ dbg_dumpFlowTree(FlowTree);
}
#endif
void dbg_dumpFlow(pBlock *pb)
{
- pCode *pcflow;
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow))
- fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
-
- fprintf(stderr, "Flow: 0x%x",pcflow->seq);
- if(PCFL(pcflow) && PCFL(pcflow)->ancestor)
- fprintf(stderr,", ancestor 0x%x\n",
- PCFL(pcflow)->ancestor->pc.seq);
- else {
- pCodeFlowLink *from = (PCFL(pcflow)->from) ? (PCFLINK(setFirstItem(PCFL(pcflow)->from))) : NULL;
- fprintf(stderr," no ancestor");
- while(from) {
- fprintf(stderr," (0x%x)",from->pcflow->pc.seq);
- from = setNextItem(PCFL(pcflow)->from);
- }
- fprintf(stderr,"\n");
- }
- }
-
+ pCode *pcflow;
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ if(!isPCFL(pcflow))
+ fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
+
+ fprintf(stderr, "Flow: 0x%x",pcflow->seq);
+ if(PCFL(pcflow) && PCFL(pcflow)->ancestor)
+ fprintf(stderr,", ancestor 0x%x\n",
+ PCFL(pcflow)->ancestor->pc.seq);
+ else {
+ pCodeFlowLink *from = (PCFL(pcflow)->from) ? (PCFLINK(setFirstItem(PCFL(pcflow)->from))) : NULL;
+ fprintf(stderr," no ancestor");
+ while(from) {
+ fprintf(stderr," (0x%x)",from->pcflow->pc.seq);
+ from = setNextItem(PCFL(pcflow)->from);
+ }
+ fprintf(stderr,"\n");
+ }
+ }
+
}
/*-----------------------------------------------------------------*
- * void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
- *-----------------------------------------------------------------*/
+* void BuildFlowSegment(set *segment, pCodeFlow *pcflow)
+*-----------------------------------------------------------------*/
void BuildFlowSegment(pCodeFlow *pcflow)
{
- static int recursion=0;
- pCodeFlow *pcflow_other;
- set *flowset;
-
- if(!pcflow)
- return;
-
- if(recursion++ > 200) {
- fprintf(stderr, " exceeded recursion\n");
- return;
- }
-
- fprintf(stderr,"examining 0x%x\n",pcflow->pc.seq);
-
- if(pcflow->from) {
-
-
- flowset = pcflow->from;
-
- if(flowset && flowset->next == NULL) {
-
- /*
- There is a flow before this one. In fact, there's
- exactly one flow before this one (because ->next is
- NULL). That means all children of this node pass
- through both this node and the node immediately
- before this one; i.e. they have the same ancestor.
- */
-
- if( (NULL == (pcflow_other = PCFLINK(flowset->item)->pcflow)) ||
- (NULL == pcflow_other)) {
- fprintf(stderr,"2 error in flow link\n");
- exit(1);
- }
- pcflow->ancestor = pcflow_other->ancestor ;
-
- fprintf(stderr,"Assigning ancestor 0x%x from flow 0x%x\n",
- pcflow->ancestor->pc.seq, pcflow_other->pc.seq);
-
- } else {
-
- if(flowset == NULL) {
-
- /* There are no flows before this one.
- * If this is not the first flow object in the pBlock then
- * there's an error */
-
- if(!pcflow->ancestor) {
- fprintf(stderr,"error in flow link\n");
- exit(1);
-
- }
-
- } else {
-
- /* Flow passes to this flow from multiple flows. Let's
- look at just one of these. If the one we look at has
- an ancestor, then that's our ancestor too. If the one
- we look at doesn't have an ancestor, then that means
- we haven't traversed that branch of the call tree
- yet - but we will */
-
- pcflow_other = PCFLINK(flowset->item)->pcflow;
- if(pcflow_other) {
- fprintf(stderr, "coming from 0x%x\n",pcflow_other->pc.seq);
- if( pcflow_other->ancestor)
- pcflow->ancestor = pcflow_other->ancestor;
+ static int recursion=0;
+ pCodeFlow *pcflow_other;
+ set *flowset;
+
+ if(!pcflow)
+ return;
+
+ if(recursion++ > 200) {
+ fprintf(stderr, " exceeded recursion\n");
+ return;
}
- }
-
-
- }
-
- } else {
- /* there are no nodes before this one */
- if(!pcflow->ancestor)
- fprintf(stderr,"3 Error in flow link\n");
- }
-
- /* Now let's recursively expand the call tree */
-
- if(pcflow->ancestor && pcflow->to) {
- flowset = pcflow->to;
- while(flowset) {
- BuildFlowSegment(PCFLINK(flowset->item)->pcflow);
- flowset = flowset->next;
- }
- }
-
+
+ fprintf(stderr,"examining 0x%x\n",pcflow->pc.seq);
+
+ if(pcflow->from) {
+
+
+ flowset = pcflow->from;
+
+ if(flowset && flowset->next == NULL) {
+
+ /*
+ There is a flow before this one. In fact, there's
+ exactly one flow before this one (because ->next is
+ NULL). That means all children of this node pass
+ through both this node and the node immediately
+ before this one; i.e. they have the same ancestor.
+ */
+
+ if( (NULL == (pcflow_other = PCFLINK(flowset->item)->pcflow)) ||
+ (NULL == pcflow_other)) {
+ fprintf(stderr,"2 error in flow link\n");
+ exit(1);
+ }
+ pcflow->ancestor = pcflow_other->ancestor ;
+
+ fprintf(stderr,"Assigning ancestor 0x%x from flow 0x%x\n",
+ pcflow->ancestor->pc.seq, pcflow_other->pc.seq);
+
+ } else {
+
+ if(flowset == NULL) {
+
+ /* There are no flows before this one.
+ * If this is not the first flow object in the pBlock then
+ * there's an error */
+
+ if(!pcflow->ancestor) {
+ fprintf(stderr,"error in flow link\n");
+ exit(1);
+
+ }
+
+ } else {
+
+ /* Flow passes to this flow from multiple flows. Let's
+ look at just one of these. If the one we look at has
+ an ancestor, then that's our ancestor too. If the one
+ we look at doesn't have an ancestor, then that means
+ we haven't traversed that branch of the call tree
+ yet - but we will */
+
+ pcflow_other = PCFLINK(flowset->item)->pcflow;
+ if(pcflow_other) {
+ fprintf(stderr, "coming from 0x%x\n",pcflow_other->pc.seq);
+ if( pcflow_other->ancestor)
+ pcflow->ancestor = pcflow_other->ancestor;
+ }
+ }
+
+
+ }
+
+ } else {
+ /* there are no nodes before this one */
+ if(!pcflow->ancestor)
+ fprintf(stderr,"3 Error in flow link\n");
+ }
+
+ /* Now let's recursively expand the call tree */
+
+ if(pcflow->ancestor && pcflow->to) {
+ flowset = pcflow->to;
+ while(flowset) {
+ BuildFlowSegment(PCFLINK(flowset->item)->pcflow);
+ flowset = flowset->next;
+ }
+ }
+
}
void BuildFlowTree(pBlock *pb)
{
- pCodeFlow *first_pcflow, *pcflow;
-
-
- // fprintf(stderr,"BuildFlowTree \n");
-
- first_pcflow = PCFL(findNextpCode(pb->pcHead, PC_FLOW));
- if(!first_pcflow)
- return;
-
- /* The very first node is like Adam, it's its own ancestor (i.e.
- * there are no other flows in this pBlock prior to the first one).
- */
-
- first_pcflow->ancestor = first_pcflow;
-
- /* For each flow that has only one predecessor, it's easy to
- identify the ancestor */
- pcflow = PCFL(findNextpCode(first_pcflow->pc.next, PC_FLOW));
-
- while(pcflow) {
- if(elementsInSet(pcflow->from) == 1) {
- pCodeFlowLink *from = PCFLINK(setFirstItem(pcflow->from));
-
- pcflow->ancestor = from->pcflow;
- /*
- fprintf(stderr,"Assigning ancestor 0x%x to flow 0x%x\n",
- pcflow->ancestor->pc.seq, pcflow->pc.seq);
- */
- }
-
- pcflow = PCFL(findNextpCode(pcflow->pc.next, PC_FLOW));
-
- }
-
- pcflow = PCFL(findNextpCode(first_pcflow->pc.next, PC_FLOW));
-
- while(pcflow) {
- if(elementsInSet(pcflow->from) > 1) {
- pCodeFlow *min_pcflow;
- pCodeFlowLink *from = PCFLINK(setFirstItem(pcflow->from));
-
- min_pcflow = from->pcflow;
-
- while( (from = setNextItem(pcflow->from)) != NULL) {
- if(from->pcflow->pc.seq < min_pcflow->pc.seq)
- min_pcflow = from->pcflow;
- }
-
- pcflow->ancestor = min_pcflow;
- /*
- fprintf(stderr,"Assigning ancestor 0x%x to flow 0x%x from multiple\n",
- pcflow->ancestor->pc.seq, pcflow->pc.seq);
- */
-
- }
-
- pcflow = PCFL(findNextpCode(pcflow->pc.next, PC_FLOW));
-
- }
-
- // BuildFlowSegment(pcflow);
-
- //dbg_dumpFlow(pb);
-
+ pCodeFlow *first_pcflow, *pcflow;
+
+
+ // fprintf(stderr,"BuildFlowTree \n");
+
+ first_pcflow = PCFL(findNextpCode(pb->pcHead, PC_FLOW));
+ if(!first_pcflow)
+ return;
+
+ /* The very first node is like Adam, it's its own ancestor (i.e.
+ * there are no other flows in this pBlock prior to the first one).
+ */
+
+ first_pcflow->ancestor = first_pcflow;
+
+ /* For each flow that has only one predecessor, it's easy to
+ identify the ancestor */
+ pcflow = PCFL(findNextpCode(first_pcflow->pc.next, PC_FLOW));
+
+ while(pcflow) {
+ if(elementsInSet(pcflow->from) == 1) {
+ pCodeFlowLink *from = PCFLINK(setFirstItem(pcflow->from));
+
+ pcflow->ancestor = from->pcflow;
+ /*
+ fprintf(stderr,"Assigning ancestor 0x%x to flow 0x%x\n",
+ pcflow->ancestor->pc.seq, pcflow->pc.seq);
+ */
+ }
+
+ pcflow = PCFL(findNextpCode(pcflow->pc.next, PC_FLOW));
+
+ }
+
+ pcflow = PCFL(findNextpCode(first_pcflow->pc.next, PC_FLOW));
+
+ while(pcflow) {
+ if(elementsInSet(pcflow->from) > 1) {
+ pCodeFlow *min_pcflow;
+ pCodeFlowLink *from = PCFLINK(setFirstItem(pcflow->from));
+
+ min_pcflow = from->pcflow;
+
+ while( (from = setNextItem(pcflow->from)) != NULL) {
+ if(from->pcflow->pc.seq < min_pcflow->pc.seq)
+ min_pcflow = from->pcflow;
+ }
+
+ pcflow->ancestor = min_pcflow;
+ /*
+ fprintf(stderr,"Assigning ancestor 0x%x to flow 0x%x from multiple\n",
+ pcflow->ancestor->pc.seq, pcflow->pc.seq);
+ */
+
+ }
+
+ pcflow = PCFL(findNextpCode(pcflow->pc.next, PC_FLOW));
+
+ }
+
+ // BuildFlowSegment(pcflow);
+
+ //dbg_dumpFlow(pb);
+
}
/****************************************************************/
/*
- * rootRules - defined in SDCCpeep.c
- * This is a pointer to the (parsed) peephole rules that are
- * defined in peep.def.
- */
+* rootRules - defined in SDCCpeep.c
+* This is a pointer to the (parsed) peephole rules that are
+* defined in peep.def.
+*/
//extern peepRule *rootRules;
/****************************************************************/
/****************************************************************/
typedef struct _DLL {
- struct _DLL *prev;
- struct _DLL *next;
- // void *data;
+ struct _DLL *prev;
+ struct _DLL *next;
+ // void *data;
} _DLL;
typedef struct pCodePeepSnippets
{
- _DLL dll;
- pCodePeep *peep;
+ _DLL dll;
+ pCodePeep *peep;
} pCodePeepSnippets;
typedef struct pCodeToken
{
- int tt; // token type;
- union {
- char c; // character
- int n; // number
- char *s; // string
- } tok;
-
+ int tt; // token type;
+ union {
+ char c; // character
+ int n; // number
+ char *s; // string
+ } tok;
+
} pCodeToken;
pCodeToken tokArr[50];
typedef enum {
- PCT_NULL=0,
- PCT_SPACE=1,
- PCT_PERCENT,
- PCT_LESSTHAN,
- PCT_GREATERTHAN,
- PCT_COLON,
- PCT_COMMA,
- PCT_COMMENT,
- PCT_STRING,
- PCT_NUMBER
-
+ PCT_NULL=0,
+ PCT_SPACE=1,
+ PCT_PERCENT,
+ PCT_LESSTHAN,
+ PCT_GREATERTHAN,
+ PCT_COLON,
+ PCT_COMMA,
+ PCT_COMMENT,
+ PCT_STRING,
+ PCT_NUMBER
+
} pCodeTokens;
typedef struct parsedPattern {
- struct pcPattern *pcp;
- pCodeToken *pct;
+ struct pcPattern *pcp;
+ pCodeToken *pct;
} parsedPattern;
#define MAX_PARSEDPATARR 50
typedef enum {
- PCP_LABEL=1,
- PCP_NUMBER,
- PCP_STR,
- PCP_WILDVAR,
- PCP_WILDSTR,
- PCP_COMMA,
- PCP_COMMENT
+ PCP_LABEL=1,
+ PCP_NUMBER,
+ PCP_STR,
+ PCP_WILDVAR,
+ PCP_WILDSTR,
+ PCP_COMMA,
+ PCP_COMMENT
} pCodePatterns;
static char pcpat_label[] = {PCT_PERCENT, PCT_NUMBER, PCT_COLON, 0};
typedef struct pcPattern {
- char pt; // Pattern type
- char *tokens; // list of tokens that describe the pattern
- void * (*f) (void *,pCodeWildBlock *);
+ char pt; // Pattern type
+ char *tokens; // list of tokens that describe the pattern
+ void * (*f) (void *,pCodeWildBlock *);
} pcPattern;
pcPattern pcpArr[] = {
- {PCP_LABEL, pcpat_label, NULL},
- {PCP_WILDSTR, pcpat_wildString, NULL},
- {PCP_STR, pcpat_string, NULL},
- {PCP_WILDVAR, pcpat_wildVar, NULL},
- {PCP_COMMA, pcpat_comma, NULL},
- {PCP_COMMENT, pcpat_comment, NULL},
- {PCP_NUMBER, pcpat_number, NULL}
+ {PCP_LABEL, pcpat_label, NULL},
+ {PCP_WILDSTR, pcpat_wildString, NULL},
+ {PCP_STR, pcpat_string, NULL},
+ {PCP_WILDVAR, pcpat_wildVar, NULL},
+ {PCP_COMMA, pcpat_comma, NULL},
+ {PCP_COMMENT, pcpat_comment, NULL},
+ {PCP_NUMBER, pcpat_number, NULL}
};
#define PCPATTERNS (sizeof(pcpArr)/sizeof(pcPattern))
// Assembly Line Token
typedef enum {
- ALT_LABEL=1,
- ALT_COMMENT,
- ALT_MNEM0,
- ALT_MNEM0A,
- ALT_MNEM1,
- ALT_MNEM1A,
- ALT_MNEM1B,
- ALT_MNEM2,
- ALT_MNEM2A,
- ALT_MNEM3
+ ALT_LABEL=1,
+ ALT_COMMENT,
+ ALT_MNEM0,
+ ALT_MNEM0A,
+ ALT_MNEM1,
+ ALT_MNEM1A,
+ ALT_MNEM1B,
+ ALT_MNEM2,
+ ALT_MNEM2A,
+ ALT_MNEM3
} altPatterns;
static char alt_comment[] = { PCP_COMMENT, 0};
static void * cvt_altpat_mnem3(void *pp,pCodeWildBlock *pcwb);
pcPattern altArr[] = {
- {ALT_LABEL, alt_label, cvt_altpat_label},
- {ALT_COMMENT, alt_comment,cvt_altpat_comment},
- {ALT_MNEM3, alt_mnem3, cvt_altpat_mnem3},
- {ALT_MNEM2A, alt_mnem2a, cvt_altpat_mnem2a},
- {ALT_MNEM2, alt_mnem2, cvt_altpat_mnem2},
- {ALT_MNEM1B, alt_mnem1b, cvt_altpat_mnem1b},
- {ALT_MNEM1A, alt_mnem1a, cvt_altpat_mnem1a},
- {ALT_MNEM1, alt_mnem1, cvt_altpat_mnem1},
- {ALT_MNEM0A, alt_mnem0a, cvt_altpat_mnem0a},
- {ALT_MNEM0, alt_mnem0, cvt_altpat_mnem0},
-
+ {ALT_LABEL, alt_label, cvt_altpat_label},
+ {ALT_COMMENT, alt_comment,cvt_altpat_comment},
+ {ALT_MNEM3, alt_mnem3, cvt_altpat_mnem3},
+ {ALT_MNEM2A, alt_mnem2a, cvt_altpat_mnem2a},
+ {ALT_MNEM2, alt_mnem2, cvt_altpat_mnem2},
+ {ALT_MNEM1B, alt_mnem1b, cvt_altpat_mnem1b},
+ {ALT_MNEM1A, alt_mnem1a, cvt_altpat_mnem1a},
+ {ALT_MNEM1, alt_mnem1, cvt_altpat_mnem1},
+ {ALT_MNEM0A, alt_mnem0a, cvt_altpat_mnem0a},
+ {ALT_MNEM0, alt_mnem0, cvt_altpat_mnem0},
+
};
#define ALTPATTERNS (sizeof(altArr)/sizeof(pcPattern))
/*-----------------------------------------------------------------*/
static int cvt_extract_destination(parsedPattern *pp)
{
-
- if(pp->pct[0].tt == PCT_STRING) {
-
- // just check first letter for now
-
- if(toupper(*pp->pct[0].tok.s) == 'F')
- return 1;
-
- } else if (pp->pct[0].tt == PCT_NUMBER) {
-
- if(pp->pct[0].tok.n)
- return 1;
- }
-
- return 0;
-
+
+ if(pp->pct[0].tt == PCT_STRING) {
+
+ // just check first letter for now
+
+ if(toupper(*pp->pct[0].tok.s) == 'F')
+ return 1;
+
+ } else if (pp->pct[0].tt == PCT_NUMBER) {
+
+ if(pp->pct[0].tok.n)
+ return 1;
+ }
+
+ return 0;
+
}
/*-----------------------------------------------------------------*/
static pCodeOp *cvt_extract_status(char *reg, char *bit)
{
- int len;
-
- if(STRCASECMP(reg, pc_status.pcop.name))
- return NULL;
-
- len = strlen(bit);
-
- if(len == 1) {
- // check C,Z
- if(toupper(*bit) == 'C')
- return PCOP(popCopyGPR2Bit(&pc_status,PIC_C_BIT));
- if(toupper(*bit) == 'Z')
- return PCOP(popCopyGPR2Bit(&pc_status,PIC_Z_BIT));
- }
-
- // Check DC
- if(len ==2 && toupper(bit[0]) == 'D' && toupper(bit[1]) == 'C')
- return PCOP(popCopyGPR2Bit(&pc_status,PIC_DC_BIT));
-
- return NULL;
-
+ int len;
+
+ if(STRCASECMP(reg, pc_status.pcop.name))
+ return NULL;
+
+ len = strlen(bit);
+
+ if(len == 1) {
+ // check C,Z
+ if(toupper(*bit) == 'C')
+ return PCOP(popCopyGPR2Bit(&pc_status,PIC_C_BIT));
+ if(toupper(*bit) == 'Z')
+ return PCOP(popCopyGPR2Bit(&pc_status,PIC_Z_BIT));
+ }
+
+ // Check DC
+ if(len ==2 && toupper(bit[0]) == 'D' && toupper(bit[1]) == 'C')
+ return PCOP(popCopyGPR2Bit(&pc_status,PIC_DC_BIT));
+
+ return NULL;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_label(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
-
- DFPRINTF((stderr,"altpat_label with ID = %d\n",p->pct[1].tok.n));
- return newpCodeLabel(NULL,-p->pct[1].tok.n);
-
+ parsedPattern *p = pp;
+
+ DFPRINTF((stderr,"altpat_label with ID = %d\n",p->pct[1].tok.n));
+ return newpCodeLabel(NULL,-p->pct[1].tok.n);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_comment(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
-
- DFPRINTF((stderr,"altpat_comment = %s\n",p->pct[0].tok.s));
- return newpCodeCharP(p->pct[0].tok.s);
-
+ parsedPattern *p = pp;
+
+ DFPRINTF((stderr,"altpat_comment = %s\n",p->pct[0].tok.s));
+ return newpCodeCharP(p->pct[0].tok.s);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem0(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
- int opcode;
-
- pCodeInstruction *pci=NULL;
-
- DFPRINTF((stderr,"altpat_mnem0 %s\n", p->pct[0].tok.s));
-
- opcode = getpCode(p->pct[0].tok.s,0);
-
- if(opcode < 0) {
- /* look for special command strings like _NOTBITSKIP_ */
-
- //fprintf(stderr, "Bad mnemonic\n");
-
- opcode = getpCodePeepCommand(p->pct[0].tok.s);
- //if(opcode > 0)
- // fprintf(stderr," but valid peep command: %s, key = %d\n",p->pct[0].tok.s,opcode);
- return NULL;
- }
-
- pci = PCI(newpCode(opcode, NULL));
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
-
- return pci;
+ parsedPattern *p = pp;
+ int opcode;
+
+ pCodeInstruction *pci=NULL;
+
+ DFPRINTF((stderr,"altpat_mnem0 %s\n", p->pct[0].tok.s));
+
+ opcode = getpCode(p->pct[0].tok.s,0);
+
+ if(opcode < 0) {
+ /* look for special command strings like _NOTBITSKIP_ */
+
+ //fprintf(stderr, "Bad mnemonic\n");
+
+ opcode = getpCodePeepCommand(p->pct[0].tok.s);
+ //if(opcode > 0)
+ // fprintf(stderr," but valid peep command: %s, key = %d\n",p->pct[0].tok.s,opcode);
+ return NULL;
+ }
+
+ pci = PCI(newpCode(opcode, NULL));
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+
+ return pci;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem0a(void *pp, pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
-
- DFPRINTF((stderr,"altpat_mnem0a wild mnem # %d\n", p[0].pct[1].tok.n));
-
- /* Save the index of the maximum wildcard mnemonic */
-
- //if(p[0].pct[1].tok.n > sMaxWildVar)
- // sMaxWildMnem = p[0].pct[1].tok.n;
-
- if(p[0].pct[1].tok.n > pcwb->nwildpCodes)
- pcwb->nwildpCodes = p[0].pct[1].tok.n;
-
- return newpCodeWild(p[0].pct[1].tok.n,NULL,NULL);
-
+ parsedPattern *p = pp;
+
+ DFPRINTF((stderr,"altpat_mnem0a wild mnem # %d\n", p[0].pct[1].tok.n));
+
+ /* Save the index of the maximum wildcard mnemonic */
+
+ //if(p[0].pct[1].tok.n > sMaxWildVar)
+ // sMaxWildMnem = p[0].pct[1].tok.n;
+
+ if(p[0].pct[1].tok.n > pcwb->nwildpCodes)
+ pcwb->nwildpCodes = p[0].pct[1].tok.n;
+
+ return newpCodeWild(p[0].pct[1].tok.n,NULL,NULL);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem1(void *pp,pCodeWildBlock *pcwb)
{
-
- parsedPattern *p = pp;
- int opcode;
-
- pCodeInstruction *pci=NULL;
- pCodeOp *pcosubtype;
-
- DFPRINTF((stderr,"altpat_mnem1 %s var %s\n", p->pct[0].tok.s,p[1].pct[0].tok.s));
-
- opcode = getpCode(p->pct[0].tok.s,0);
- if(opcode < 0) {
- //fprintf(stderr, "Bad mnemonic\n");
- opcode = getpCodePeepCommand(p->pct[0].tok.s);
- //if(opcode > 0)
- //fprintf(stderr," but valid peep command: %s, key = %d\n",p->pct[0].tok.s,opcode);
-
- return NULL;
- }
-
- if(pic14Mnemonics[opcode]->isBitInst)
- pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_BIT);
- else
- pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
-
-
- pci = PCI(newpCode(opcode, pcosubtype));
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
-
- return pci;
+
+ parsedPattern *p = pp;
+ int opcode;
+
+ pCodeInstruction *pci=NULL;
+ pCodeOp *pcosubtype;
+
+ DFPRINTF((stderr,"altpat_mnem1 %s var %s\n", p->pct[0].tok.s,p[1].pct[0].tok.s));
+
+ opcode = getpCode(p->pct[0].tok.s,0);
+ if(opcode < 0) {
+ //fprintf(stderr, "Bad mnemonic\n");
+ opcode = getpCodePeepCommand(p->pct[0].tok.s);
+ //if(opcode > 0)
+ //fprintf(stderr," but valid peep command: %s, key = %d\n",p->pct[0].tok.s,opcode);
+
+ return NULL;
+ }
+
+ if(pic14Mnemonics[opcode]->isBitInst)
+ pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_BIT);
+ else
+ pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
+
+
+ pci = PCI(newpCode(opcode, pcosubtype));
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+
+ return pci;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem1a(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
- int opcode;
-
- pCodeInstruction *pci=NULL;
- pCodeOp *pcosubtype;
-
- DFPRINTF((stderr,"altpat_mnem1a %s var %d\n", p->pct[0].tok.s,p[1].pct[1].tok.n));
-
- opcode = getpCode(p->pct[0].tok.s,0);
- if(opcode < 0) {
- int cmd_id = getpCodePeepCommand(p->pct[0].tok.s);
- pCode *pc=NULL;
-
- if(cmd_id<0) {
- fprintf(stderr, "Bad mnemonic\n");
- return NULL;
- }
-
- if(p[0].pct[1].tok.n > pcwb->nwildpCodes)
- pcwb->nwildpCodes = p[0].pct[1].tok.n;
-
- pc = newpCodeWild(p[1].pct[1].tok.n,NULL,NULL);
-
- switch(cmd_id) {
- case NOTBITSKIP:
- PCW(pc)->mustNotBeBitSkipInst = 1;
- break;
- case BITSKIP:
- PCW(pc)->mustBeBitSkipInst = 1;
- break;
- case INVERTBITSKIP:
- PCW(pc)->invertBitSkipInst = 1;
- }
- return pc;
- }
-
- if(pic14Mnemonics[opcode]->isBitInst)
- pcosubtype = newpCodeOpBit(NULL,-1,0);
- else
- pcosubtype = newpCodeOp(NULL,PO_GPR_REGISTER);
-
-
- pci = PCI(newpCode(opcode,
- newpCodeOpWild(p[1].pct[1].tok.n, pcwb, pcosubtype)));
-
- /* Save the index of the maximum wildcard variable */
- //if(p[1].pct[1].tok.n > sMaxWildVar)
- // sMaxWildVar = p[1].pct[1].tok.n;
-
- if(p[1].pct[1].tok.n > pcwb->nvars)
- pcwb->nvars = p[1].pct[1].tok.n;
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
-
- return pci;
+ parsedPattern *p = pp;
+ int opcode;
+
+ pCodeInstruction *pci=NULL;
+ pCodeOp *pcosubtype;
+
+ DFPRINTF((stderr,"altpat_mnem1a %s var %d\n", p->pct[0].tok.s,p[1].pct[1].tok.n));
+
+ opcode = getpCode(p->pct[0].tok.s,0);
+ if(opcode < 0) {
+ int cmd_id = getpCodePeepCommand(p->pct[0].tok.s);
+ pCode *pc=NULL;
+
+ if(cmd_id<0) {
+ fprintf(stderr, "Bad mnemonic\n");
+ return NULL;
+ }
+
+ if(p[0].pct[1].tok.n > pcwb->nwildpCodes)
+ pcwb->nwildpCodes = p[0].pct[1].tok.n;
+
+ pc = newpCodeWild(p[1].pct[1].tok.n,NULL,NULL);
+
+ switch(cmd_id) {
+ case NOTBITSKIP:
+ PCW(pc)->mustNotBeBitSkipInst = 1;
+ break;
+ case BITSKIP:
+ PCW(pc)->mustBeBitSkipInst = 1;
+ break;
+ case INVERTBITSKIP:
+ PCW(pc)->invertBitSkipInst = 1;
+ }
+ return pc;
+ }
+
+ if(pic14Mnemonics[opcode]->isBitInst)
+ pcosubtype = newpCodeOpBit(NULL,-1,0);
+ else
+ pcosubtype = newpCodeOp(NULL,PO_GPR_REGISTER);
+
+
+ pci = PCI(newpCode(opcode,
+ newpCodeOpWild(p[1].pct[1].tok.n, pcwb, pcosubtype)));
+
+ /* Save the index of the maximum wildcard variable */
+ //if(p[1].pct[1].tok.n > sMaxWildVar)
+ // sMaxWildVar = p[1].pct[1].tok.n;
+
+ if(p[1].pct[1].tok.n > pcwb->nvars)
+ pcwb->nvars = p[1].pct[1].tok.n;
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+
+ return pci;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem1b(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
- int opcode;
-
- pCodeInstruction *pci=NULL;
-
- DFPRINTF((stderr,"altpat_mnem1b %s var %d\n", p->pct[0].tok.s,p[1].pct[0].tok.n));
-
- opcode = getpCode(p->pct[0].tok.s,0);
- if(opcode < 0) {
- fprintf(stderr, "Bad mnemonic\n");
- return NULL;
- }
-
- pci = PCI(newpCode(opcode, newpCodeOpLit(p[1].pct[0].tok.n) ));
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
-
- return pci;
+ parsedPattern *p = pp;
+ int opcode;
+
+ pCodeInstruction *pci=NULL;
+
+ DFPRINTF((stderr,"altpat_mnem1b %s var %d\n", p->pct[0].tok.s,p[1].pct[0].tok.n));
+
+ opcode = getpCode(p->pct[0].tok.s,0);
+ if(opcode < 0) {
+ fprintf(stderr, "Bad mnemonic\n");
+ return NULL;
+ }
+
+ pci = PCI(newpCode(opcode, newpCodeOpLit(p[1].pct[0].tok.n) ));
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+
+ return pci;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem2(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
- int opcode;
- int dest;
-
- pCodeInstruction *pci=NULL;
- pCodeOp *pcosubtype;
-
- dest = cvt_extract_destination(&p[3]);
-
- DFPRINTF((stderr,"altpat_mnem2 %s var %s destination %s(%d)\n",
- p->pct[0].tok.s,
- p[1].pct[0].tok.s,
- p[3].pct[0].tok.s,
- dest));
-
-
- opcode = getpCode(p->pct[0].tok.s,dest);
- if(opcode < 0) {
- fprintf(stderr, "Bad mnemonic\n");
- return NULL;
- }
-
- if(pic14Mnemonics[opcode]->isBitInst) {
- pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
- if(pcosubtype == NULL) {
- fprintf(stderr, "bad operand?\n");
- return NULL;
- }
-
- } else
- pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
-
-
- pci = PCI(newpCode(opcode,pcosubtype));
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
- return pci;
-
+ parsedPattern *p = pp;
+ int opcode;
+ int dest;
+
+ pCodeInstruction *pci=NULL;
+ pCodeOp *pcosubtype;
+
+ dest = cvt_extract_destination(&p[3]);
+
+ DFPRINTF((stderr,"altpat_mnem2 %s var %s destination %s(%d)\n",
+ p->pct[0].tok.s,
+ p[1].pct[0].tok.s,
+ p[3].pct[0].tok.s,
+ dest));
+
+
+ opcode = getpCode(p->pct[0].tok.s,dest);
+ if(opcode < 0) {
+ fprintf(stderr, "Bad mnemonic\n");
+ return NULL;
+ }
+
+ if(pic14Mnemonics[opcode]->isBitInst) {
+ pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
+ if(pcosubtype == NULL) {
+ fprintf(stderr, "bad operand?\n");
+ return NULL;
+ }
+
+ } else
+ pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
+
+
+ pci = PCI(newpCode(opcode,pcosubtype));
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+ return pci;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem2a(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
- int opcode;
- int dest;
-
- pCodeInstruction *pci=NULL;
- pCodeOp *pcosubtype;
-
- if(!pcwb) {
- fprintf(stderr,"ERROR %s:%d - can't assemble line\n",__FILE__,__LINE__);
- return NULL;
- }
-
- dest = cvt_extract_destination(&p[3]);
-
- DFPRINTF((stderr,"altpat_mnem2a %s var %d destination %s(%d)\n",
- p->pct[0].tok.s,
- p[1].pct[1].tok.n,
- p[3].pct[0].tok.s,
- dest));
-
-
- opcode = getpCode(p->pct[0].tok.s,dest);
- if(opcode < 0) {
- fprintf(stderr, "Bad mnemonic\n");
- return NULL;
- }
-
- if(pic14Mnemonics[opcode]->isBitInst)
- pcosubtype = newpCodeOp(NULL,PO_BIT);
- else
- pcosubtype = newpCodeOp(NULL,PO_GPR_REGISTER);
-
-
- pci = PCI(newpCode(opcode,
- newpCodeOpWild(p[1].pct[1].tok.n, pcwb, pcosubtype)));
-
- /* Save the index of the maximum wildcard variable */
- //if(p[1].pct[1].tok.n > sMaxWildVar)
- // sMaxWildVar = p[1].pct[1].tok.n;
-
- if(p[1].pct[1].tok.n > pcwb->nvars)
- pcwb->nvars = p[1].pct[1].tok.n;
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
- return pci;
-
+ parsedPattern *p = pp;
+ int opcode;
+ int dest;
+
+ pCodeInstruction *pci=NULL;
+ pCodeOp *pcosubtype;
+
+ if(!pcwb) {
+ fprintf(stderr,"ERROR %s:%d - can't assemble line\n",__FILE__,__LINE__);
+ return NULL;
+ }
+
+ dest = cvt_extract_destination(&p[3]);
+
+ DFPRINTF((stderr,"altpat_mnem2a %s var %d destination %s(%d)\n",
+ p->pct[0].tok.s,
+ p[1].pct[1].tok.n,
+ p[3].pct[0].tok.s,
+ dest));
+
+
+ opcode = getpCode(p->pct[0].tok.s,dest);
+ if(opcode < 0) {
+ fprintf(stderr, "Bad mnemonic\n");
+ return NULL;
+ }
+
+ if(pic14Mnemonics[opcode]->isBitInst)
+ pcosubtype = newpCodeOp(NULL,PO_BIT);
+ else
+ pcosubtype = newpCodeOp(NULL,PO_GPR_REGISTER);
+
+
+ pci = PCI(newpCode(opcode,
+ newpCodeOpWild(p[1].pct[1].tok.n, pcwb, pcosubtype)));
+
+ /* Save the index of the maximum wildcard variable */
+ //if(p[1].pct[1].tok.n > sMaxWildVar)
+ // sMaxWildVar = p[1].pct[1].tok.n;
+
+ if(p[1].pct[1].tok.n > pcwb->nvars)
+ pcwb->nvars = p[1].pct[1].tok.n;
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+ return pci;
+
}
/*-----------------------------------------------------------------*/
static void * cvt_altpat_mnem3(void *pp,pCodeWildBlock *pcwb)
{
- parsedPattern *p = pp;
- int opcode;
- int dest; // or could be bit position in the register
-
- pCodeInstruction *pci=NULL;
- pCodeOp *pcosubtype=NULL;
-
- dest = cvt_extract_destination(&p[3]);
-
- DFPRINTF((stderr,"altpat_mnem3 %s var %s bit (%d)\n",
- p->pct[0].tok.s,
- p[1].pct[0].tok.s,
- p[3].pct[0].tok.n));
-
-
- opcode = getpCode(p->pct[0].tok.s,0);
- if(opcode < 0) {
- fprintf(stderr, "Bad mnemonic\n");
- return NULL;
- }
-
-
- if(pic14Mnemonics[opcode]->isBitInst) {
- //pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
-
- //if(pcosubtype == NULL) {
- pcosubtype = newpCodeOpBit(p[1].pct[0].tok.s,p[3].pct[0].tok.n,0);
- //}
- } else
- pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
-
- if(pcosubtype == NULL) {
- fprintf(stderr, "Bad operand\n");
- return NULL;
- }
-
- pci = PCI(newpCode(opcode, pcosubtype));
-
- if(!pci)
- fprintf(stderr,"couldn't find mnemonic\n");
-
- return pci;
-
+ parsedPattern *p = pp;
+ int opcode;
+ int dest; // or could be bit position in the register
+
+ pCodeInstruction *pci=NULL;
+ pCodeOp *pcosubtype=NULL;
+
+ dest = cvt_extract_destination(&p[3]);
+
+ DFPRINTF((stderr,"altpat_mnem3 %s var %s bit (%d)\n",
+ p->pct[0].tok.s,
+ p[1].pct[0].tok.s,
+ p[3].pct[0].tok.n));
+
+
+ opcode = getpCode(p->pct[0].tok.s,0);
+ if(opcode < 0) {
+ fprintf(stderr, "Bad mnemonic\n");
+ return NULL;
+ }
+
+
+ if(pic14Mnemonics[opcode]->isBitInst) {
+ //pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
+
+ //if(pcosubtype == NULL) {
+ pcosubtype = newpCodeOpBit(p[1].pct[0].tok.s,p[3].pct[0].tok.n,0);
+ //}
+ } else
+ pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
+
+ if(pcosubtype == NULL) {
+ fprintf(stderr, "Bad operand\n");
+ return NULL;
+ }
+
+ pci = PCI(newpCode(opcode, pcosubtype));
+
+ if(!pci)
+ fprintf(stderr,"couldn't find mnemonic\n");
+
+ return pci;
+
}
/*-----------------------------------------------------------------*/
static void tokenizeLineNode(char *ln)
{
- char *lnstart=ln;
- tokIdx = 0; // Starting off at the beginning
- tokArr[0].tt = PCT_NULL; // and assume invalid character for first token.
-
- if(!ln || !*ln)
- return;
-
-
- while(*ln) {
-
- if(isspace(*ln)) {
- // add a SPACE token and eat the extra spaces.
- tokArr[tokIdx++].tt = PCT_SPACE;
- while (isspace (*ln))
- ln++;
- continue;
- }
-
- if(isdigit(*ln)) {
-
- tokArr[tokIdx].tt = PCT_NUMBER;
- tokArr[tokIdx++].tok.n = strtol(ln, &ln, 0);
-
- continue;
-
- }
-
- switch(*ln) {
- case '%':
- tokArr[tokIdx++].tt = PCT_PERCENT;
- break;
- case '<':
- tokArr[tokIdx++].tt = PCT_LESSTHAN;
- break;
- case '>':
- tokArr[tokIdx++].tt = PCT_GREATERTHAN;
- break;
- case ':':
- tokArr[tokIdx++].tt = PCT_COLON;
- break;
- case ';':
- tokArr[tokIdx].tok.s = Safe_strdup(ln);
- tokArr[tokIdx++].tt = PCT_COMMENT;
- tokArr[tokIdx].tt = PCT_NULL;
- return;
- case ',':
- tokArr[tokIdx++].tt = PCT_COMMA;
- break;
-
-
- default:
- if(isalpha(*ln) || (*ln == '_') ) {
- char buffer[50];
- int i=0;
-
- while( (isalpha(*ln) || isdigit(*ln) || (*ln == '_')) && i<49)
- buffer[i++] = *ln++;
-
- ln--;
- buffer[i] = 0;
-
- tokArr[tokIdx].tok.s = Safe_strdup(buffer);
- tokArr[tokIdx++].tt = PCT_STRING;
-
- } else {
- fprintf(stderr, "Error while parsing peep rules (check peeph.def)\n");
- fprintf(stderr, "Line: %s\n",lnstart);
- fprintf(stderr, "Token: '%c'\n",*ln);
- exit(1);
- }
- }
-
- /* Advance to next character in input string .
- * Note, if none of the tests passed above, then
- * we effectively ignore the `bad' character.
- * Since the line has already been parsed by SDCCpeeph,
- * chance are that there are no invalid characters... */
-
- ln++;
-
- }
-
- tokArr[tokIdx].tt = 0;
+ char *lnstart=ln;
+ tokIdx = 0; // Starting off at the beginning
+ tokArr[0].tt = PCT_NULL; // and assume invalid character for first token.
+
+ if(!ln || !*ln)
+ return;
+
+
+ while(*ln) {
+
+ if(isspace(*ln)) {
+ // add a SPACE token and eat the extra spaces.
+ tokArr[tokIdx++].tt = PCT_SPACE;
+ while (isspace (*ln))
+ ln++;
+ continue;
+ }
+
+ if(isdigit(*ln)) {
+
+ tokArr[tokIdx].tt = PCT_NUMBER;
+ tokArr[tokIdx++].tok.n = strtol(ln, &ln, 0);
+
+ continue;
+
+ }
+
+ switch(*ln) {
+ case '%':
+ tokArr[tokIdx++].tt = PCT_PERCENT;
+ break;
+ case '<':
+ tokArr[tokIdx++].tt = PCT_LESSTHAN;
+ break;
+ case '>':
+ tokArr[tokIdx++].tt = PCT_GREATERTHAN;
+ break;
+ case ':':
+ tokArr[tokIdx++].tt = PCT_COLON;
+ break;
+ case ';':
+ tokArr[tokIdx].tok.s = Safe_strdup(ln);
+ tokArr[tokIdx++].tt = PCT_COMMENT;
+ tokArr[tokIdx].tt = PCT_NULL;
+ return;
+ case ',':
+ tokArr[tokIdx++].tt = PCT_COMMA;
+ break;
+
+
+ default:
+ if(isalpha(*ln) || (*ln == '_') ) {
+ char buffer[50];
+ int i=0;
+
+ while( (isalpha(*ln) || isdigit(*ln) || (*ln == '_')) && i<49)
+ buffer[i++] = *ln++;
+
+ ln--;
+ buffer[i] = 0;
+
+ tokArr[tokIdx].tok.s = Safe_strdup(buffer);
+ tokArr[tokIdx++].tt = PCT_STRING;
+
+ } else {
+ fprintf(stderr, "Error while parsing peep rules (check peeph.def)\n");
+ fprintf(stderr, "Line: %s\n",lnstart);
+ fprintf(stderr, "Token: '%c'\n",*ln);
+ exit(1);
+ }
+ }
+
+ /* Advance to next character in input string .
+ * Note, if none of the tests passed above, then
+ * we effectively ignore the `bad' character.
+ * Since the line has already been parsed by SDCCpeeph,
+ * chance are that there are no invalid characters... */
+
+ ln++;
+
+ }
+
+ tokArr[tokIdx].tt = 0;
}
void dump1Token(pCodeTokens tt)
{
-
- switch(tt) {
- case PCT_SPACE:
- fprintf(stderr, " space ");
- break;
- case PCT_PERCENT:
- fprintf(stderr, " pct %%");
- break;
- case PCT_LESSTHAN:
- fprintf(stderr, " pct <");
- break;
- case PCT_GREATERTHAN:
- fprintf(stderr, " pct >");
- break;
- case PCT_COLON:
- fprintf(stderr, " col :");
- break;
- case PCT_COMMA:
- fprintf(stderr, " comma , ");
- break;
- case PCT_COMMENT:
- fprintf(stderr, " comment ");
- //fprintf(stderr,"%s",tokArr[i].tok.s);
- break;
- case PCT_STRING:
- fprintf(stderr, " str ");
- //fprintf(stderr,"%s",tokArr[i].tok.s);
- break;
- case PCT_NUMBER:
- fprintf(stderr, " num ");
- //fprintf(stderr,"%d",tokArr[i].tok.n);
- break;
- case PCT_NULL:
- fprintf(stderr, " null ");
-
- }
-
+
+ switch(tt) {
+ case PCT_SPACE:
+ fprintf(stderr, " space ");
+ break;
+ case PCT_PERCENT:
+ fprintf(stderr, " pct %%");
+ break;
+ case PCT_LESSTHAN:
+ fprintf(stderr, " pct <");
+ break;
+ case PCT_GREATERTHAN:
+ fprintf(stderr, " pct >");
+ break;
+ case PCT_COLON:
+ fprintf(stderr, " col :");
+ break;
+ case PCT_COMMA:
+ fprintf(stderr, " comma , ");
+ break;
+ case PCT_COMMENT:
+ fprintf(stderr, " comment ");
+ //fprintf(stderr,"%s",tokArr[i].tok.s);
+ break;
+ case PCT_STRING:
+ fprintf(stderr, " str ");
+ //fprintf(stderr,"%s",tokArr[i].tok.s);
+ break;
+ case PCT_NUMBER:
+ fprintf(stderr, " num ");
+ //fprintf(stderr,"%d",tokArr[i].tok.n);
+ break;
+ case PCT_NULL:
+ fprintf(stderr, " null ");
+
+ }
+
}
int pcComparePattern(pCodeToken *pct, char *pat, int max_tokens)
{
- int i=0;
-
- if(!pct || !pat || !*pat)
- return 0;
-
- //DFPRINTF((stderr,"comparing against:\n"));
-
- while(i < max_tokens) {
-
- if(*pat == 0){
- //DFPRINTF((stderr,"matched\n"));
- return (i+1);
- }
+ int i=0;
+
+ if(!pct || !pat || !*pat)
+ return 0;
+
+ //DFPRINTF((stderr,"comparing against:\n"));
+
+ while(i < max_tokens) {
+
+ if(*pat == 0){
+ //DFPRINTF((stderr,"matched\n"));
+ return (i+1);
+ }
+
+ //dump1Token(*pat); DFPRINTF((stderr,"\n"));
+
+ if(pct->tt != *pat)
+ return 0;
+
+
+ pct++;
+ pat++;
+ }
+
+ return 0;
+
+}
- //dump1Token(*pat); DFPRINTF((stderr,"\n"));
-
- if(pct->tt != *pat)
- return 0;
-
-
- pct++;
- pat++;
- }
-
- return 0;
-
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
int altComparePattern( char *pct, parsedPattern *pat, int max_tokens)
{
- int i=0;
-
- if(!pct || !pat || !*pct)
- return 0;
-
-
- while(i < max_tokens) {
-
- if(*pct == 0) {
- //DFPRINTF((stderr,"matched\n"));
- return i;
- }
-
- //dump1Token(*pat); DFPRINTF((stderr,"\n"));
-
- if( !pat || !pat->pcp )
- return 0;
-
- if (pat->pcp->pt != *pct)
- return 0;
-
- //DFPRINTF((stderr," pct=%d\n",*pct));
- pct++;
- pat++;
- i++;
- }
-
- return 0;
-
+ int i=0;
+
+ if(!pct || !pat || !*pct)
+ return 0;
+
+
+ while(i < max_tokens) {
+
+ if(*pct == 0) {
+ //DFPRINTF((stderr,"matched\n"));
+ return i;
+ }
+
+ //dump1Token(*pat); DFPRINTF((stderr,"\n"));
+
+ if( !pat || !pat->pcp )
+ return 0;
+
+ if (pat->pcp->pt != *pct)
+ return 0;
+
+ //DFPRINTF((stderr," pct=%d\n",*pct));
+ pct++;
+ pat++;
+ i++;
+ }
+
+ return 0;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int advTokIdx(int *v, int amt)
{
-
- if((unsigned) (*v + amt) > tokIdx)
- return 1;
-
- *v += amt;
- return 0;
-
+
+ if((unsigned) (*v + amt) > tokIdx)
+ return 1;
+
+ *v += amt;
+ return 0;
+
}
/*-----------------------------------------------------------------*/
int parseTokens(pCodeWildBlock *pcwb, pCode **pcret)
{
- pCode *pc;
- int error = 0;
-
- if(!tokIdx)
- return error;
-
+ pCode *pc;
+ int error = 0;
+
+ if(!tokIdx)
+ return error;
+
#ifdef PCODE_DEBUG
- {
- unsigned i;
- for(i=0; i<=tokIdx; i++)
- dump1Token(tokArr[i].tt);
- fputc('\n',stderr);
- }
+ {
+ unsigned i;
+ for(i=0; i<=tokIdx; i++)
+ dump1Token(tokArr[i].tt);
+ fputc('\n',stderr);
+ }
#endif
-
- {
- int lparsedPatIdx=0;
- int lpcpIdx;
- int ltokIdx =0;
- int matching = 0;
- int j=0;
- int k=0;
-
- char * cPmnem = NULL; // Pointer to non-wild mnemonic (if any)
- char * cP1stop = NULL;
- char * cP2ndop = NULL;
-
- //pCodeOp *pcl = NULL; // Storage for a label
- //pCodeOp *pco1 = NULL; // 1st operand
- //pCodeOp *pco2 = NULL; // 2nd operand
- //pCode *pc = NULL; // Mnemonic
-
- typedef enum {
- PS_START,
- PS_HAVE_LABEL,
- PS_HAVE_MNEM,
- PS_HAVE_1OPERAND,
- PS_HAVE_COMMA,
- PS_HAVE_2OPERANDS
- } ParseStates;
-
- ParseStates state = PS_START;
-
- do {
-
- lpcpIdx=0;
- matching = 0;
-
- if( ((tokArr[ltokIdx].tt == PCT_SPACE) )
- && (advTokIdx(<okIdx, 1)) ) // eat space
- break;
-
- do {
- j = pcComparePattern(&tokArr[ltokIdx], pcpArr[lpcpIdx].tokens, tokIdx +1);
- if( j ) {
-
- switch(pcpArr[lpcpIdx].pt) {
- case PCP_LABEL:
- if(state == PS_START){
- DFPRINTF((stderr," label\n"));
- state = PS_HAVE_LABEL;
- } else
- DFPRINTF((stderr," bad state (%d) for label\n",state));
- break;
-
- case PCP_STR:
- DFPRINTF((stderr," %s is",tokArr[ltokIdx].tok.s));
- switch(state) {
- case PS_START:
- case PS_HAVE_LABEL:
- DFPRINTF((stderr," mnem\n"));
- cPmnem = tokArr[ltokIdx].tok.s;
- state = PS_HAVE_MNEM;
- break;
- case PS_HAVE_MNEM:
- DFPRINTF((stderr," 1st operand\n"));
- cP1stop = tokArr[ltokIdx].tok.s;
- //pco1 = newpCodeOp(NULL,PO_GPR_REGISTER);
- state = PS_HAVE_1OPERAND;
- break;
- case PS_HAVE_1OPERAND:
- DFPRINTF((stderr," error expecting comma\n"));
- break;
- case PS_HAVE_COMMA:
- DFPRINTF((stderr," 2 operands\n"));
- cP2ndop = tokArr[ltokIdx].tok.s;
- break;
- case PS_HAVE_2OPERANDS:
- break;
- }
- break;
-
- case PCP_WILDVAR:
- switch(state) {
- case PS_START:
- case PS_HAVE_LABEL:
- DFPRINTF((stderr," wild mnem\n"));
- state = PS_HAVE_MNEM;
- break;
- case PS_HAVE_MNEM:
- DFPRINTF((stderr," 1st operand is wild\n"));
- state = PS_HAVE_1OPERAND;
- break;
- case PS_HAVE_1OPERAND:
- DFPRINTF((stderr," error expecting comma\n"));
- break;
- case PS_HAVE_COMMA:
- DFPRINTF((stderr," 2nd operand is wild\n"));
- break;
- case PS_HAVE_2OPERANDS:
- break;
- }
- break;
-
- case PCP_NUMBER:
- switch(state) {
- case PS_START:
- case PS_HAVE_LABEL:
- fprintf(stderr," ERROR number\n");
- break;
- case PS_HAVE_MNEM:
- DFPRINTF((stderr," 1st operand is a number\n"));
- state = PS_HAVE_1OPERAND;
- break;
- case PS_HAVE_1OPERAND:
- fprintf(stderr," error expecting comma\n");
- break;
- case PS_HAVE_COMMA:
- DFPRINTF((stderr," 2nd operand is a number\n"));
- break;
- case PS_HAVE_2OPERANDS:
- break;
- }
- break;
-
- case PCP_WILDSTR:
- break;
- case PCP_COMMA:
- if(state == PS_HAVE_1OPERAND){
- DFPRINTF((stderr," got a comma\n"));
- state = PS_HAVE_COMMA;
- } else
- fprintf(stderr," unexpected comma\n");
- break;
-
- }
-
- matching = 1;
- parsedPatArr[lparsedPatIdx].pcp = &pcpArr[lpcpIdx];
- parsedPatArr[lparsedPatIdx].pct = &tokArr[ltokIdx];
- lparsedPatIdx++;
-
- //dump1Token(tokArr[ltokIdx].tt);
-
- if(advTokIdx(<okIdx, strlen(pcpArr[lpcpIdx].tokens) ) ) {
- DFPRINTF((stderr," reached end \n"));
- matching = 0;
- //return;
- }
+
+ {
+ int lparsedPatIdx=0;
+ int lpcpIdx;
+ int ltokIdx =0;
+ int matching = 0;
+ int j=0;
+ int k=0;
+
+ char * cPmnem = NULL; // Pointer to non-wild mnemonic (if any)
+ char * cP1stop = NULL;
+ char * cP2ndop = NULL;
+
+ //pCodeOp *pcl = NULL; // Storage for a label
+ //pCodeOp *pco1 = NULL; // 1st operand
+ //pCodeOp *pco2 = NULL; // 2nd operand
+ //pCode *pc = NULL; // Mnemonic
+
+ typedef enum {
+ PS_START,
+ PS_HAVE_LABEL,
+ PS_HAVE_MNEM,
+ PS_HAVE_1OPERAND,
+ PS_HAVE_COMMA,
+ PS_HAVE_2OPERANDS
+ } ParseStates;
+
+ ParseStates state = PS_START;
+
+ do {
+
+ lpcpIdx=0;
+ matching = 0;
+
+ if( ((tokArr[ltokIdx].tt == PCT_SPACE) )
+ && (advTokIdx(<okIdx, 1)) ) // eat space
+ break;
+
+ do {
+ j = pcComparePattern(&tokArr[ltokIdx], pcpArr[lpcpIdx].tokens, tokIdx +1);
+ if( j ) {
+
+ switch(pcpArr[lpcpIdx].pt) {
+ case PCP_LABEL:
+ if(state == PS_START){
+ DFPRINTF((stderr," label\n"));
+ state = PS_HAVE_LABEL;
+ } else
+ DFPRINTF((stderr," bad state (%d) for label\n",state));
+ break;
+
+ case PCP_STR:
+ DFPRINTF((stderr," %s is",tokArr[ltokIdx].tok.s));
+ switch(state) {
+ case PS_START:
+ case PS_HAVE_LABEL:
+ DFPRINTF((stderr," mnem\n"));
+ cPmnem = tokArr[ltokIdx].tok.s;
+ state = PS_HAVE_MNEM;
+ break;
+ case PS_HAVE_MNEM:
+ DFPRINTF((stderr," 1st operand\n"));
+ cP1stop = tokArr[ltokIdx].tok.s;
+ //pco1 = newpCodeOp(NULL,PO_GPR_REGISTER);
+ state = PS_HAVE_1OPERAND;
+ break;
+ case PS_HAVE_1OPERAND:
+ DFPRINTF((stderr," error expecting comma\n"));
+ break;
+ case PS_HAVE_COMMA:
+ DFPRINTF((stderr," 2 operands\n"));
+ cP2ndop = tokArr[ltokIdx].tok.s;
+ break;
+ case PS_HAVE_2OPERANDS:
+ break;
+ }
+ break;
+
+ case PCP_WILDVAR:
+ switch(state) {
+ case PS_START:
+ case PS_HAVE_LABEL:
+ DFPRINTF((stderr," wild mnem\n"));
+ state = PS_HAVE_MNEM;
+ break;
+ case PS_HAVE_MNEM:
+ DFPRINTF((stderr," 1st operand is wild\n"));
+ state = PS_HAVE_1OPERAND;
+ break;
+ case PS_HAVE_1OPERAND:
+ DFPRINTF((stderr," error expecting comma\n"));
+ break;
+ case PS_HAVE_COMMA:
+ DFPRINTF((stderr," 2nd operand is wild\n"));
+ break;
+ case PS_HAVE_2OPERANDS:
+ break;
+ }
+ break;
+
+ case PCP_NUMBER:
+ switch(state) {
+ case PS_START:
+ case PS_HAVE_LABEL:
+ fprintf(stderr," ERROR number\n");
+ break;
+ case PS_HAVE_MNEM:
+ DFPRINTF((stderr," 1st operand is a number\n"));
+ state = PS_HAVE_1OPERAND;
+ break;
+ case PS_HAVE_1OPERAND:
+ fprintf(stderr," error expecting comma\n");
+ break;
+ case PS_HAVE_COMMA:
+ DFPRINTF((stderr," 2nd operand is a number\n"));
+ break;
+ case PS_HAVE_2OPERANDS:
+ break;
+ }
+ break;
+
+ case PCP_WILDSTR:
+ break;
+ case PCP_COMMA:
+ if(state == PS_HAVE_1OPERAND){
+ DFPRINTF((stderr," got a comma\n"));
+ state = PS_HAVE_COMMA;
+ } else
+ fprintf(stderr," unexpected comma\n");
+ break;
+
+ }
+
+ matching = 1;
+ parsedPatArr[lparsedPatIdx].pcp = &pcpArr[lpcpIdx];
+ parsedPatArr[lparsedPatIdx].pct = &tokArr[ltokIdx];
+ lparsedPatIdx++;
+
+ //dump1Token(tokArr[ltokIdx].tt);
+
+ if(advTokIdx(<okIdx, strlen(pcpArr[lpcpIdx].tokens) ) ) {
+ DFPRINTF((stderr," reached end \n"));
+ matching = 0;
+ //return;
+ }
}
-
-
- } while ((++lpcpIdx < PCPATTERNS) && !matching);
-
- } while (matching);
-
- parsedPatArr[lparsedPatIdx].pcp = NULL;
- parsedPatArr[lparsedPatIdx].pct = NULL;
-
- j=k=0;
- do {
- int c;
-
- if( (c=altComparePattern( altArr[k].tokens, &parsedPatArr[j],10) ) ) {
-
- if( altArr[k].f) {
- pc = altArr[k].f(&parsedPatArr[j],pcwb);
- //if(pc && pc->print)
- // pc->print(stderr,pc);
- //if(pc && pc->destruct) pc->destruct(pc); dumps core?
-
- //if(curBlock && pc)
- //addpCode2pBlock(curBlock, pc);
- if(pc) {
- if (pcret) {
- *pcret = pc;
- return 0; // Only accept one line for now.
- } else
- addpCode2pBlock(pcwb->pb, pc);
- } else
- error++;
+
+
+ } while ((++lpcpIdx < PCPATTERNS) && !matching);
+
+ } while (matching);
+
+ parsedPatArr[lparsedPatIdx].pcp = NULL;
+ parsedPatArr[lparsedPatIdx].pct = NULL;
+
+ j=k=0;
+ do {
+ int c;
+
+ if( (c=altComparePattern( altArr[k].tokens, &parsedPatArr[j],10) ) ) {
+
+ if( altArr[k].f) {
+ pc = altArr[k].f(&parsedPatArr[j],pcwb);
+ //if(pc && pc->print)
+ // pc->print(stderr,pc);
+ //if(pc && pc->destruct) pc->destruct(pc); dumps core?
+
+ //if(curBlock && pc)
+ //addpCode2pBlock(curBlock, pc);
+ if(pc) {
+ if (pcret) {
+ *pcret = pc;
+ return 0; // Only accept one line for now.
+ } else
+ addpCode2pBlock(pcwb->pb, pc);
+ } else
+ error++;
+ }
+ j += c;
+ }
+ k++;
}
- j += c;
- }
- k++;
- }
- while(j<=lparsedPatIdx && k<ALTPATTERNS);
-
-/*
- DFPRINTF((stderr,"\nConverting parsed line to pCode:\n\n"));
-
- j = 0;
- do {
- if(parsedPatArr[j].pcp && parsedPatArr[j].pcp->f )
- parsedPatArr[j].pcp->f(&parsedPatArr[j]);
- DFPRINTF((stderr," %d",parsedPatArr[j].pcp->pt));
- j++;
- }
- while(j<lparsedPatIdx);
-*/
- DFPRINTF((stderr,"\n"));
-
+ while(j<=lparsedPatIdx && k<ALTPATTERNS);
+
+ /*
+ DFPRINTF((stderr,"\nConverting parsed line to pCode:\n\n"));
+
+ j = 0;
+ do {
+ if(parsedPatArr[j].pcp && parsedPatArr[j].pcp->f )
+ parsedPatArr[j].pcp->f(&parsedPatArr[j]);
+ DFPRINTF((stderr," %d",parsedPatArr[j].pcp->pt));
+ j++;
+ }
+ while(j<lparsedPatIdx);
+ */
+ DFPRINTF((stderr,"\n"));
+
}
return error;
/*-----------------------------------------------------------------*/
void peepRuleBlock2pCodeBlock( lineNode *ln, pCodeWildBlock *pcwb)
{
-
- if(!ln)
- return;
-
- for( ; ln; ln = ln->next) {
-
- //DFPRINTF((stderr,"%s\n",ln->line));
-
- tokenizeLineNode(ln->line);
-
- if(parseTokens(pcwb,NULL)) {
- int i;
- fprintf(stderr,"ERROR assembling line:\n%s\n",ln->line);
- fprintf(stderr,"Tokens:\n");
- for(i=0; i<5; i++)
- dump1Token(tokArr[i].tt);
- fputc('\n',stderr);
- exit (1);
- }
- }
+
+ if(!ln)
+ return;
+
+ for( ; ln; ln = ln->next) {
+
+ //DFPRINTF((stderr,"%s\n",ln->line));
+
+ tokenizeLineNode(ln->line);
+
+ if(parseTokens(pcwb,NULL)) {
+ int i;
+ fprintf(stderr,"ERROR assembling line:\n%s\n",ln->line);
+ fprintf(stderr,"Tokens:\n");
+ for(i=0; i<5; i++)
+ dump1Token(tokArr[i].tt);
+ fputc('\n',stderr);
+ exit (1);
+ }
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
pCode *AssembleLine(char *line)
{
- pCode *pc=NULL;
-
- if(!line || !*line) {
- fprintf(stderr,"WARNING returning NULL in AssembleLine\n");
- return NULL;
- }
-
- tokenizeLineNode(line);
-
- if(parseTokens(NULL,&pc))
- fprintf(stderr, "WARNING: unable to assemble line:\n%s\n",line);
-
- return pc;
+ pCode *pc=NULL;
+
+ if(!line || !*line) {
+ fprintf(stderr,"WARNING returning NULL in AssembleLine\n");
+ return NULL;
+ }
+
+ tokenizeLineNode(line);
+ if(parseTokens(NULL,&pc))
+ fprintf(stderr, "WARNING: unable to assemble line:\n%s\n",line);
+
+ return pc;
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void peepRuleCondition(char *cond, pCodePeep *pcp)
{
- if(!cond || !pcp)
- return;
-
- //DFPRINTF((stderr,"\nCondition: %s\n",cond));
- /* brute force compares for now */
-
- if(STRCASECMP(cond, "NZ") == 0) {
- //DFPRINTF((stderr,"found NZ\n"));
- pcp->postFalseCond = PCC_Z;
-
- }
-
+ if(!cond || !pcp)
+ return;
+
+ //DFPRINTF((stderr,"\nCondition: %s\n",cond));
+ /* brute force compares for now */
+
+ if(STRCASECMP(cond, "NZ") == 0) {
+ //DFPRINTF((stderr,"found NZ\n"));
+ pcp->postFalseCond = PCC_Z;
+
+ }
+
}
void initpCodeWildBlock(pCodeWildBlock *pcwb)
{
-
- // pcwb = Safe_calloc(1,sizeof(pCodeWildBlock));
-
- if(!pcwb)
- return;
-
- pcwb->vars = NULL;
- pcwb->wildpCodes = NULL;
- pcwb->wildpCodeOps = NULL;
-
- pcwb->nvars = 0;
- pcwb->nwildpCodes = 0;
- pcwb->nops = 0;
-
+
+ // pcwb = Safe_calloc(1,sizeof(pCodeWildBlock));
+
+ if(!pcwb)
+ return;
+
+ pcwb->vars = NULL;
+ pcwb->wildpCodes = NULL;
+ pcwb->wildpCodeOps = NULL;
+
+ pcwb->nvars = 0;
+ pcwb->nwildpCodes = 0;
+ pcwb->nops = 0;
+
}
void postinit_pCodeWildBlock(pCodeWildBlock *pcwb)
{
-
- if(!pcwb)
- return;
-
- pcwb->nvars+=2;
- pcwb->nops = pcwb->nvars;
-
- pcwb->vars = Safe_calloc(pcwb->nvars, sizeof(char *));
- pcwb->wildpCodeOps = Safe_calloc(pcwb->nvars, sizeof(pCodeOp *));
-
- pcwb->nwildpCodes+=2;
- pcwb->wildpCodes = Safe_calloc(pcwb->nwildpCodes, sizeof(pCode *));
-
+
+ if(!pcwb)
+ return;
+
+ pcwb->nvars+=2;
+ pcwb->nops = pcwb->nvars;
+
+ pcwb->vars = Safe_calloc(pcwb->nvars, sizeof(char *));
+ pcwb->wildpCodeOps = Safe_calloc(pcwb->nvars, sizeof(pCodeOp *));
+
+ pcwb->nwildpCodes+=2;
+ pcwb->wildpCodes = Safe_calloc(pcwb->nwildpCodes, sizeof(pCode *));
+
}
void initpCodePeep(pCodePeep *pcp)
{
-
- // pcwb = Safe_calloc(1,sizeof(pCodeWildBlock));
-
- if(!pcp)
- return;
-
- initpCodeWildBlock(&pcp->target);
- pcp->target.pb = newpCodeChain(NULL, 'W', NULL);
-
- initpCodeWildBlock(&pcp->replace);
- pcp->replace.pb = newpCodeChain(NULL, 'W', NULL);
-
+
+ // pcwb = Safe_calloc(1,sizeof(pCodeWildBlock));
+
+ if(!pcp)
+ return;
+
+ initpCodeWildBlock(&pcp->target);
+ pcp->target.pb = newpCodeChain(NULL, 'W', NULL);
+
+ initpCodeWildBlock(&pcp->replace);
+ pcp->replace.pb = newpCodeChain(NULL, 'W', NULL);
+
}
/*-----------------------------------------------------------------*/
void peepRules2pCode(peepRule *rules)
{
- peepRule *pr;
-
- pCodePeep *currentRule;
- pCodePeepSnippets *pcps;
-
- pic14initpCodePeepCommands();
-
- /* The rules are in a linked-list. Each rule has two portions */
- /* There's the `target' and there's the `replace'. The target */
- /* is compared against the SDCC generated code and if it */
- /* matches, it gets replaced by the `replace' block of code. */
- /* */
- /* Here we loop through each rule and convert the target's and*/
- /* replace's into pCode target and replace blocks */
-
- for (pr = rules; pr; pr = pr->next) {
-
- //DFPRINTF((stderr,"\nRule:\n\n"));
-
- pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
- peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
-
- currentRule = pcps->peep = Safe_calloc(1,sizeof(pCodePeep));
- initpCodePeep(currentRule);
-
- /* Convert the target block */
- peepRuleBlock2pCodeBlock(pr->match, ¤tRule->target);
-
- //DFPRINTF((stderr,"finished target, here it is in pcode form:\n"));
- //printpBlock(stderr, currentRule->target.pb);
-
- //DFPRINTF((stderr,"target with labels merged:\n"));
- //pBlockMergeLabels(curBlock);
- pBlockMergeLabels(currentRule->target.pb);
- //printpBlock(stderr, currentRule->replace.pb);
-
- //#ifdef PCODE_DEBUG
- // printpBlock(stderr, curBlock);
- //#endif
- //DFPRINTF((stderr,"\nReplaced by:\n"));
-
-
- /* Convert the replace block */
- peepRuleBlock2pCodeBlock(pr->replace, ¤tRule->replace);
-
- //DFPRINTF((stderr,"finished replace block, here it is in pcode form:\n"));
- //printpBlock(stderr, curBlock);
-
- //DFPRINTF((stderr,"replace with labels merged:\n"));
-
- pBlockMergeLabels(currentRule->replace.pb);
- //printpBlock(stderr, currentRule->replace.pb);
-
- peepRuleCondition(pr->cond,currentRule);
-
- /* The rule has been converted to pCode. Now allocate
- * space for the wildcards */
-
- postinit_pCodeWildBlock(¤tRule->target);
- postinit_pCodeWildBlock(¤tRule->replace);
-
- //return; // debug ... don't want to go through all the rules yet
- }
-
- {
- pCodePeep *peepBlock;
- _DLL *peeprules;
-
- peeprules = (_DLL *)peepSnippets;
- //fprintf(stderr,"target rules\n");
- while(peeprules) {
- //fprintf(stderr," rule:\n");
- peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
- //printpBlock(stderr, peepBlock->target.pb);
- peeprules = peeprules->next;
- }
- //fprintf(stderr," ... done\n");
- }
-
+ peepRule *pr;
+
+ pCodePeep *currentRule;
+ pCodePeepSnippets *pcps;
+
+ pic14initpCodePeepCommands();
+
+ /* The rules are in a linked-list. Each rule has two portions */
+ /* There's the `target' and there's the `replace'. The target */
+ /* is compared against the SDCC generated code and if it */
+ /* matches, it gets replaced by the `replace' block of code. */
+ /* */
+ /* Here we loop through each rule and convert the target's and*/
+ /* replace's into pCode target and replace blocks */
+
+ for (pr = rules; pr; pr = pr->next) {
+
+ //DFPRINTF((stderr,"\nRule:\n\n"));
+
+ pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
+ peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
+
+ currentRule = pcps->peep = Safe_calloc(1,sizeof(pCodePeep));
+ initpCodePeep(currentRule);
+
+ /* Convert the target block */
+ peepRuleBlock2pCodeBlock(pr->match, ¤tRule->target);
+
+ //DFPRINTF((stderr,"finished target, here it is in pcode form:\n"));
+ //printpBlock(stderr, currentRule->target.pb);
+
+ //DFPRINTF((stderr,"target with labels merged:\n"));
+ //pBlockMergeLabels(curBlock);
+ pBlockMergeLabels(currentRule->target.pb);
+ //printpBlock(stderr, currentRule->replace.pb);
+
+ //#ifdef PCODE_DEBUG
+ // printpBlock(stderr, curBlock);
+ //#endif
+ //DFPRINTF((stderr,"\nReplaced by:\n"));
+
+
+ /* Convert the replace block */
+ peepRuleBlock2pCodeBlock(pr->replace, ¤tRule->replace);
+
+ //DFPRINTF((stderr,"finished replace block, here it is in pcode form:\n"));
+ //printpBlock(stderr, curBlock);
+
+ //DFPRINTF((stderr,"replace with labels merged:\n"));
+
+ pBlockMergeLabels(currentRule->replace.pb);
+ //printpBlock(stderr, currentRule->replace.pb);
+
+ peepRuleCondition(pr->cond,currentRule);
+
+ /* The rule has been converted to pCode. Now allocate
+ * space for the wildcards */
+
+ postinit_pCodeWildBlock(¤tRule->target);
+ postinit_pCodeWildBlock(¤tRule->replace);
+
+ //return; // debug ... don't want to go through all the rules yet
+ }
+
+ {
+ pCodePeep *peepBlock;
+ _DLL *peeprules;
+
+ peeprules = (_DLL *)peepSnippets;
+ //fprintf(stderr,"target rules\n");
+ while(peeprules) {
+ //fprintf(stderr," rule:\n");
+ peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
+ //printpBlock(stderr, peepBlock->target.pb);
+ peeprules = peeprules->next;
+ }
+ //fprintf(stderr," ... done\n");
+ }
+
}
void printpCodeString(FILE *of, pCode *pc, int max)
{
- int i=0;
-
- while(pc && (i++<max)) {
- pc->print(of,pc);
- pc = pc->next;
- }
+ int i=0;
+
+ while(pc && (i++<max)) {
+ pc->print(of,pc);
+ pc = pc->next;
+ }
}
/*-----------------------------------------------------------------*/
static void * DLL_append(_DLL *list, _DLL *next)
{
- _DLL *b;
-
-
- /* If there's no list, then create one: */
- if(!list) {
- next->next = next->prev = NULL;
- return next;
- }
-
-
- /* Search for the end of the list. */
- b = list;
- while(b->next)
- b = b->next;
-
- /* Now append the new DLL object */
- b->next = next;
- b->next->prev = b;
- b = b->next;
- b->next = NULL;
-
- return list;
-
+ _DLL *b;
+
+
+ /* If there's no list, then create one: */
+ if(!list) {
+ next->next = next->prev = NULL;
+ return next;
+ }
+
+
+ /* Search for the end of the list. */
+ b = list;
+ while(b->next)
+ b = b->next;
+
+ /* Now append the new DLL object */
+ b->next = next;
+ b->next->prev = b;
+ b = b->next;
+ b->next = NULL;
+
+ return list;
+
}
pCode peephole optimization
-
- The pCode "peep hole" optimization is not too unlike the peep hole
- optimization in SDCCpeeph.c. The major difference is that here we
- use pCode's whereas there we use ASCII strings. The advantage with
- pCode's is that we can ascertain flow information in the instructions
- being optimized.
-
-
-<FIX ME> - elaborate...
-
- -----------------------------------------------------------------*/
+
+ The pCode "peep hole" optimization is not too unlike the peep hole
+ optimization in SDCCpeeph.c. The major difference is that here we
+ use pCode's whereas there we use ASCII strings. The advantage with
+ pCode's is that we can ascertain flow information in the instructions
+ being optimized.
+
+
+ <FIX ME> - elaborate...
+
+-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int pCodeSearchCondition(pCode *pc, unsigned int cond, int contIfSkip)
{
- while(pc) {
-
- /* If we reach a function end (presumably an end since we most
- probably began the search in the middle of a function), then
- the condition was not found. */
- if(pc->type == PC_FUNCTION)
- return 0;
-
- if(pc->type == PC_OPCODE) {
- if(PCI(pc)->inCond & cond) {
- if (contIfSkip) {
- /* If previous instruction is a skip then continue search as condiction is not certain */
- pCode *pcp = findPrevInstruction(pc);
- if (pcp && !isPCI_SKIP(pcp)) {
- return 1;
- }
- } else {
- return 1;
- }
- }
- if(PCI(pc)->outCond & cond) {
- if (contIfSkip) {
- /* If previous instruction is a skip then continue search as condiction is not certain */
- pCode *pcp = findPrevInstruction(pc);
- if (pcp && !isPCI_SKIP(pcp)) {
- return -1;
- }
- } else {
- return -1;
- }
- }
- }
-
- pc = pc->next;
- }
-
- return 0;
+ while(pc) {
+
+ /* If we reach a function end (presumably an end since we most
+ probably began the search in the middle of a function), then
+ the condition was not found. */
+ if(pc->type == PC_FUNCTION)
+ return 0;
+
+ if(pc->type == PC_OPCODE) {
+ if(PCI(pc)->inCond & cond) {
+ if (contIfSkip) {
+ /* If previous instruction is a skip then continue search as condiction is not certain */
+ pCode *pcp = findPrevInstruction(pc);
+ if (pcp && !isPCI_SKIP(pcp)) {
+ return 1;
+ }
+ } else {
+ return 1;
+ }
+ }
+ if(PCI(pc)->outCond & cond) {
+ if (contIfSkip) {
+ /* If previous instruction is a skip then continue search as condiction is not certain */
+ pCode *pcp = findPrevInstruction(pc);
+ if (pcp && !isPCI_SKIP(pcp)) {
+ return -1;
+ }
+ } else {
+ return -1;
+ }
+ }
+ }
+
+ pc = pc->next;
+ }
+
+ return 0;
}
/*-----------------------------------------------------------------
- * int pCodeOpCompare(pCodeOp *pcops, pCodeOp *pcopd)
- *
- * Compare two pCodeOp's and return 1 if they're the same
- *-----------------------------------------------------------------*/
+* int pCodeOpCompare(pCodeOp *pcops, pCodeOp *pcopd)
+*
+* Compare two pCodeOp's and return 1 if they're the same
+*-----------------------------------------------------------------*/
int pCodeOpCompare(pCodeOp *pcops, pCodeOp *pcopd)
{
- char b[50], *n2;
-
- if(!pcops || !pcopd)
- return 0;
-/*
- fprintf(stderr," Comparing operands %s",
- get_op( pcops,NULL,0));
-
- fprintf(stderr," to %s\n",
- get_op( pcopd,NULL,0));
-*/
-
- if(pcops->type != pcopd->type) {
- //fprintf(stderr," - fail - diff types\n");
- return 0; // different types
- }
-
- if(pcops->type == PO_LITERAL) {
-
- if((PCOL(pcops)->lit >= 0) && (PCOL(pcops)->lit == PCOL(pcopd)->lit))
- return 1;
-
- return 0;
- }
-
- b[0]=0;
- get_op(pcops,b,50);
-
- n2 = get_op(pcopd,NULL,0);
-
- if( !n2 || strcmp(b,n2)) {
- //fprintf(stderr," - fail - diff names: %s, len=%d, %s, len=%d\n",b,strlen(b), n2, strlen(n2) );
- return 0; // different names
- }
-
- switch(pcops->type) {
- case PO_DIR:
- if( PCOR(pcops)->instance != PCOR(pcopd)->instance) {
- //fprintf(stderr, " - fail different instances\n");
- return 0;
- }
- break;
- default:
- break;
- }
-
- //fprintf(stderr," - pass\n");
-
- return 1;
+ char b[50], *n2;
+
+ if(!pcops || !pcopd)
+ return 0;
+ /*
+ fprintf(stderr," Comparing operands %s",
+ get_op( pcops,NULL,0));
+
+ fprintf(stderr," to %s\n",
+ get_op( pcopd,NULL,0));
+ */
+
+ if(pcops->type != pcopd->type) {
+ //fprintf(stderr," - fail - diff types\n");
+ return 0; // different types
+ }
+
+ if(pcops->type == PO_LITERAL) {
+
+ if((PCOL(pcops)->lit >= 0) && (PCOL(pcops)->lit == PCOL(pcopd)->lit))
+ return 1;
+
+ return 0;
+ }
+
+ b[0]=0;
+ get_op(pcops,b,50);
+
+ n2 = get_op(pcopd,NULL,0);
+
+ if( !n2 || strcmp(b,n2)) {
+ //fprintf(stderr," - fail - diff names: %s, len=%d, %s, len=%d\n",b,strlen(b), n2, strlen(n2) );
+ return 0; // different names
+ }
+
+ switch(pcops->type) {
+ case PO_DIR:
+ if( PCOR(pcops)->instance != PCOR(pcopd)->instance) {
+ //fprintf(stderr, " - fail different instances\n");
+ return 0;
+ }
+ break;
+ default:
+ break;
+ }
+
+ //fprintf(stderr," - pass\n");
+
+ return 1;
}
int pCodePeepMatchLabels(pCodePeep *peepBlock, pCode *pcs, pCode *pcd)
{
- int labindex;
-
- /* Check for a label associated with this wild pCode */
- // If the wild card has a label, make sure the source code does too.
- if(PCI(pcd)->label) {
- pCode *pcl = PCI(pcd)->label->pc;
-
+ int labindex;
+
+ /* Check for a label associated with this wild pCode */
+ // If the wild card has a label, make sure the source code does too.
+ if(PCI(pcd)->label) {
+ pCode *pcl = PCI(pcd)->label->pc;
+
#ifdef PCODE_DEBUG
- int li = -PCL(pcl)->key;
-
- if(peepBlock->target.vars[li] == NULL) {
- if(PCI(pcs)->label) {
- DFPRINTF((stderr,"first time for a label: %d %s\n",li,PCL(PCI(pcs)->label->pc)->label));
- }
- } else {
- // DFPRINTF((stderr,"label id = %d \n",PCL(PCI(pcd)->label->pc)->key));
- DFPRINTF((stderr," label id: %d %s\n",li,peepBlock->target.vars[li]));
- if(PCI(pcs)->label) {
- DFPRINTF((stderr," src %s\n",PCL(PCI(pcs)->label->pc)->label));
- }
- }
+ int li = -PCL(pcl)->key;
+
+ if(peepBlock->target.vars[li] == NULL) {
+ if(PCI(pcs)->label) {
+ DFPRINTF((stderr,"first time for a label: %d %s\n",li,PCL(PCI(pcs)->label->pc)->label));
+ }
+ } else {
+ // DFPRINTF((stderr,"label id = %d \n",PCL(PCI(pcd)->label->pc)->key));
+ DFPRINTF((stderr," label id: %d %s\n",li,peepBlock->target.vars[li]));
+ if(PCI(pcs)->label) {
+ DFPRINTF((stderr," src %s\n",PCL(PCI(pcs)->label->pc)->label));
+ }
+ }
#endif
+
+
+ if(!PCI(pcs)->label)
+ return 0;
+
+ labindex = -PCL(pcl)->key;
+ if(peepBlock->target.vars[labindex] == NULL) {
+ // First time to encounter this label
+ peepBlock->target.vars[labindex] = PCL(PCI(pcs)->label->pc)->label;
+ DFPRINTF((stderr,"first time for a label: %d %s\n",labindex,PCL(PCI(pcs)->label->pc)->label));
+
+ } else {
+ if(strcmp(peepBlock->target.vars[labindex],PCL(PCI(pcs)->label->pc)->label) != 0) {
+ DFPRINTF((stderr,"labels don't match dest %s != src %s\n",peepBlock->target.vars[labindex],PCL(PCI(pcs)->label->pc)->label));
+ return 0;
+ }
+ DFPRINTF((stderr,"matched a label %d %s -hey\n",labindex,peepBlock->target.vars[labindex]));
+ }
+ } else {
+ //DFPRINTF((stderr,"destination doesn't have a label\n"));
+
+ if(PCI(pcs)->label)
+ return 0;
+
+ //DFPRINTF((stderr,"neither src nor dest have labels\n"));
+
+ }
+
+ return 1;
-
- if(!PCI(pcs)->label)
- return 0;
-
- labindex = -PCL(pcl)->key;
- if(peepBlock->target.vars[labindex] == NULL) {
- // First time to encounter this label
- peepBlock->target.vars[labindex] = PCL(PCI(pcs)->label->pc)->label;
- DFPRINTF((stderr,"first time for a label: %d %s\n",labindex,PCL(PCI(pcs)->label->pc)->label));
-
- } else {
- if(strcmp(peepBlock->target.vars[labindex],PCL(PCI(pcs)->label->pc)->label) != 0) {
- DFPRINTF((stderr,"labels don't match dest %s != src %s\n",peepBlock->target.vars[labindex],PCL(PCI(pcs)->label->pc)->label));
- return 0;
- }
- DFPRINTF((stderr,"matched a label %d %s -hey\n",labindex,peepBlock->target.vars[labindex]));
- }
- } else {
- //DFPRINTF((stderr,"destination doesn't have a label\n"));
-
- if(PCI(pcs)->label)
- return 0;
-
- //DFPRINTF((stderr,"neither src nor dest have labels\n"));
-
- }
-
- return 1;
-
}
/*-----------------------------------------------------------------*/
int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd)
{
- int index; // index into wild card arrays
-
- /* one-for-one match. Here the source and destination opcodes
- * are not wild. However, there may be a label or a wild operand */
-
- if(pcs) {
- if(PCI(pcs)->label) {
- DFPRINTF((stderr,"Match line source label: %s\n",PCL(PCI(pcs)->label->pc)->label));
- }
- }
-
- if(pcs->type == pcd->type) {
-
- if(pcs->type == PC_OPCODE) {
-
- /* If the opcodes don't match then the line doesn't match */
- if(PCI(pcs)->op != PCI(pcd)->op)
- return 0;
-
+ int index; // index into wild card arrays
+
+ /* one-for-one match. Here the source and destination opcodes
+ * are not wild. However, there may be a label or a wild operand */
+
+ if(pcs) {
+ if(PCI(pcs)->label) {
+ DFPRINTF((stderr,"Match line source label: %s\n",PCL(PCI(pcs)->label->pc)->label));
+ }
+ }
+
+ if(pcs->type == pcd->type) {
+
+ if(pcs->type == PC_OPCODE) {
+
+ /* If the opcodes don't match then the line doesn't match */
+ if(PCI(pcs)->op != PCI(pcd)->op)
+ return 0;
+
#ifdef PCODE_DEBUG
- DFPRINTF((stderr,"%s comparing\n",__FUNCTION__));
- pcs->print(stderr,pcs);
- pcd->print(stderr,pcd);
+ DFPRINTF((stderr,"%s comparing\n",__FUNCTION__));
+ pcs->print(stderr,pcs);
+ pcd->print(stderr,pcd);
#endif
-
- if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
- return 0;
-
- /* Compare the operands */
- if(PCI(pcd)->pcop) {
- // Volatile types should not be deleted or modified, these include SFR, externs and publics
- // They can be used as a matched, however if a match is found then the optimiser intends
- // to change some aspect of a block of code, which is most likely a critcal one. As this
- // method of optimisation does not allow a means to distiguishing what may change, it is
- // best to just negate any match.
- if (PCI(pcs)->pcop) {
- struct regs *r;
- pCodeOp *pcop = PCI(pcs)->pcop;
- switch(pcop->type) {
- case PO_W:
- case PO_STATUS:
- case PO_FSR:
- case PO_INDF:
- case PO_INTCON:
- case PO_PCL:
- case PO_PCLATH:
- case PO_SFR_REGISTER:
- return 0; // SFR - do not modify
- case PO_DIR:
- case PO_GPR_REGISTER:
- case PO_GPR_BIT:
- case PO_GPR_TEMP:
- case PO_GPR_POINTER:
- r = PCOR(pcop)->r;
- if (r->isPublic||r->isExtern||r->isFixed) // Changes to these types of registers should not be changed as they may be used else where
- return 0;
- default:
- break;
- }
- }
- if (PCI(pcd)->pcop->type == PO_WILD) {
- char *n;
- index = PCOW(PCI(pcd)->pcop)->id;
- //DFPRINTF((stderr,"destination is wild\n"));
+
+ if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
+ return 0;
+
+ /* Compare the operands */
+ if(PCI(pcd)->pcop) {
+ // Volatile types should not be deleted or modified, these include SFR, externs and publics
+ // They can be used as a matched, however if a match is found then the optimiser intends
+ // to change some aspect of a block of code, which is most likely a critcal one. As this
+ // method of optimisation does not allow a means to distiguishing what may change, it is
+ // best to just negate any match.
+ if (PCI(pcs)->pcop) {
+ struct regs *r;
+ pCodeOp *pcop = PCI(pcs)->pcop;
+ switch(pcop->type) {
+ case PO_W:
+ case PO_STATUS:
+ case PO_FSR:
+ case PO_INDF:
+ case PO_INTCON:
+ case PO_PCL:
+ case PO_PCLATH:
+ case PO_SFR_REGISTER:
+ return 0; // SFR - do not modify
+ case PO_DIR:
+ case PO_GPR_REGISTER:
+ case PO_GPR_BIT:
+ case PO_GPR_TEMP:
+ case PO_GPR_POINTER:
+ r = PCOR(pcop)->r;
+ if (r->isPublic||r->isExtern||r->isFixed) // Changes to these types of registers should not be changed as they may be used else where
+ return 0;
+ default:
+ break;
+ }
+ }
+ if (PCI(pcd)->pcop->type == PO_WILD) {
+ char *n;
+ index = PCOW(PCI(pcd)->pcop)->id;
+ //DFPRINTF((stderr,"destination is wild\n"));
#ifdef DEBUG_PCODEPEEP
- if (index > peepBlock->nops) {
- DFPRINTF((stderr,"%s - variables exceeded\n",__FUNCTION__));
- exit(1);
- }
+ if (index > peepBlock->nops) {
+ DFPRINTF((stderr,"%s - variables exceeded\n",__FUNCTION__));
+ exit(1);
+ }
#endif
- n = PCI(pcs)->pcop->name;
- if(peepBlock->target.vars[index]) {
- if ((!n)||(strcmp(peepBlock->target.vars[index],n) != 0))
- return 0; // variable is different
- } else {
- DFPRINTF((stderr,"first time for a variable: %d, %s\n",index,n));
- peepBlock->target.vars[index] = n;
- }
-
- PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
- if(!peepBlock->target.wildpCodeOps[index]) {
- peepBlock->target.wildpCodeOps[index] = PCI(pcs)->pcop;
-
- //fprintf(stderr, "first time for wild opcode #%d\n",index);
- return 1;
-
- } else {
- /*
- pcs->print(stderr,pcs);
- pcd->print(stderr,pcd);
- fprintf(stderr, "comparing operands of these instructions, result %d\n",
- pCodeOpCompare(PCI(pcs)->pcop, peepBlock->target.wildpCodeOps[index])
- );
- */
-
- return pCodeOpCompare(PCI(pcs)->pcop, peepBlock->target.wildpCodeOps[index]);
- }
-/*
- {
- char *n;
-
- switch(PCI(pcs)->pcop->type) {
- case PO_GPR_TEMP:
- case PO_FSR:
- //case PO_INDF:
- //n = PCOR(PCI(pcs)->pcop)->r->name;
- n = PCI(pcs)->pcop->name;
-
- break;
- default:
- n = PCI(pcs)->pcop->name;
- }
-
- if(peepBlock->target.vars[index])
- return (strcmp(peepBlock->target.vars[index],n) == 0);
- else {
- DFPRINTF((stderr,"first time for a variable: %d, %s\n",index,n));
- peepBlock->target.vars[index] = n;
- return 1;
- }
- }
-*/
- } else if (PCI(pcd)->pcop->type == PO_LITERAL) {
- /*
- pcs->print(stderr,pcs);
- pcd->print(stderr,pcd);
-
- fprintf(stderr, "comparing literal operands of these instructions, result %d\n",
- pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop));
- */
- return pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop);
-
- } else {
- /* FIXME - need an else to check the case when the destination
- * isn't a wild card */
- /*
- fprintf(stderr, "Destination is not wild: operand compare =%d\n",
- pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop));
- */
- return pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop);
-
- }
- } else
- /* The pcd has no operand. Lines match if pcs has no operand either*/
- return (PCI(pcs)->pcop == NULL);
- }
- }
+ n = PCI(pcs)->pcop->name;
+ if(peepBlock->target.vars[index]) {
+ if ((!n)||(strcmp(peepBlock->target.vars[index],n) != 0))
+ return 0; // variable is different
+ } else {
+ DFPRINTF((stderr,"first time for a variable: %d, %s\n",index,n));
+ peepBlock->target.vars[index] = n;
+ }
+
+ PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
+ if(!peepBlock->target.wildpCodeOps[index]) {
+ peepBlock->target.wildpCodeOps[index] = PCI(pcs)->pcop;
+
+ //fprintf(stderr, "first time for wild opcode #%d\n",index);
+ return 1;
+
+ } else {
+ /*
+ pcs->print(stderr,pcs);
+ pcd->print(stderr,pcd);
+ fprintf(stderr, "comparing operands of these instructions, result %d\n",
+ pCodeOpCompare(PCI(pcs)->pcop, peepBlock->target.wildpCodeOps[index])
+ );
+ */
+
+ return pCodeOpCompare(PCI(pcs)->pcop, peepBlock->target.wildpCodeOps[index]);
+ }
+ /*
+ {
+ char *n;
+
+ switch(PCI(pcs)->pcop->type) {
+ case PO_GPR_TEMP:
+ case PO_FSR:
+ //case PO_INDF:
+ //n = PCOR(PCI(pcs)->pcop)->r->name;
+ n = PCI(pcs)->pcop->name;
+
+ break;
+ default:
+ n = PCI(pcs)->pcop->name;
+ }
+
+ if(peepBlock->target.vars[index])
+ return (strcmp(peepBlock->target.vars[index],n) == 0);
+ else {
+ DFPRINTF((stderr,"first time for a variable: %d, %s\n",index,n));
+ peepBlock->target.vars[index] = n;
+ return 1;
+ }
+ }
+ */
+ } else if (PCI(pcd)->pcop->type == PO_LITERAL) {
+ /*
+ pcs->print(stderr,pcs);
+ pcd->print(stderr,pcd);
+
+ fprintf(stderr, "comparing literal operands of these instructions, result %d\n",
+ pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop));
+ */
+ return pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop);
+
+ } else {
+ /* FIXME - need an else to check the case when the destination
+ * isn't a wild card */
+ /*
+ fprintf(stderr, "Destination is not wild: operand compare =%d\n",
+ pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop));
+ */
+ return pCodeOpCompare(PCI(pcs)->pcop, PCI(pcd)->pcop);
+
+ }
+ } else
+ /* The pcd has no operand. Lines match if pcs has no operand either*/
+ return (PCI(pcs)->pcop == NULL);
+ }
+ }
- /* Compare a wild instruction to a regular one. */
+ /* Compare a wild instruction to a regular one. */
- if((pcd->type == PC_WILD) && (pcs->type == PC_OPCODE)) {
+ if((pcd->type == PC_WILD) && (pcs->type == PC_OPCODE)) {
- index = PCW(pcd)->id;
+ index = PCW(pcd)->id;
#ifdef PCODE_DEBUG
- DFPRINTF((stderr,"%s comparing wild cards\n",__FUNCTION__));
- pcs->print(stderr,pcs);
- pcd->print(stderr,pcd);
+ DFPRINTF((stderr,"%s comparing wild cards\n",__FUNCTION__));
+ pcs->print(stderr,pcs);
+ pcd->print(stderr,pcd);
#endif
- peepBlock->target.wildpCodes[PCW(pcd)->id] = pcs;
-
- if(!pCodePeepMatchLabels(peepBlock, pcs, pcd)) {
- DFPRINTF((stderr," Failing because labels don't match\n"));
- return 0;
- }
-
- if(PCW(pcd)->mustBeBitSkipInst & !(PCI(pcs)->isBitInst && PCI(pcs)->isSkip)) {
- // doesn't match because the wild pcode must be a bit skip
- DFPRINTF((stderr," Failing match because bit skip is req\n"));
- //pcd->print(stderr,pcd);
- //pcs->print(stderr,pcs);
- return 0;
- }
-
- if(PCW(pcd)->mustNotBeBitSkipInst & (PCI(pcs)->isBitInst && PCI(pcs)->isSkip)) {
- // doesn't match because the wild pcode must *not* be a bit skip
- DFPRINTF((stderr," Failing match because shouldn't be bit skip\n"));
- //pcd->print(stderr,pcd);
- //pcs->print(stderr,pcs);
- return 0;
- }
-
- if(PCW(pcd)->operand) {
- PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
- if(peepBlock->target.vars[index]) {
- int i = (strcmp(peepBlock->target.vars[index],PCI(pcs)->pcop->name) == 0);
+ peepBlock->target.wildpCodes[PCW(pcd)->id] = pcs;
+
+ if(!pCodePeepMatchLabels(peepBlock, pcs, pcd)) {
+ DFPRINTF((stderr," Failing because labels don't match\n"));
+ return 0;
+ }
+
+ if(PCW(pcd)->mustBeBitSkipInst & !(PCI(pcs)->isBitInst && PCI(pcs)->isSkip)) {
+ // doesn't match because the wild pcode must be a bit skip
+ DFPRINTF((stderr," Failing match because bit skip is req\n"));
+ //pcd->print(stderr,pcd);
+ //pcs->print(stderr,pcs);
+ return 0;
+ }
+
+ if(PCW(pcd)->mustNotBeBitSkipInst & (PCI(pcs)->isBitInst && PCI(pcs)->isSkip)) {
+ // doesn't match because the wild pcode must *not* be a bit skip
+ DFPRINTF((stderr," Failing match because shouldn't be bit skip\n"));
+ //pcd->print(stderr,pcd);
+ //pcs->print(stderr,pcs);
+ return 0;
+ }
+
+ if(PCW(pcd)->operand) {
+ PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
+ if(peepBlock->target.vars[index]) {
+ int i = (strcmp(peepBlock->target.vars[index],PCI(pcs)->pcop->name) == 0);
#ifdef PCODE_DEBUG
- if(i)
- DFPRINTF((stderr," (matched)\n"));
- else {
- DFPRINTF((stderr," (no match: wild card operand mismatch\n"));
- DFPRINTF((stderr," peepblock= %s, pcodeop= %s\n",
- peepBlock->target.vars[index],
- PCI(pcs)->pcop->name));
- }
+ if(i)
+ DFPRINTF((stderr," (matched)\n"));
+ else {
+ DFPRINTF((stderr," (no match: wild card operand mismatch\n"));
+ DFPRINTF((stderr," peepblock= %s, pcodeop= %s\n",
+ peepBlock->target.vars[index],
+ PCI(pcs)->pcop->name));
+ }
#endif
- return i;
- } else {
- DFPRINTF((stderr," (matched %s\n",PCI(pcs)->pcop->name));
- peepBlock->target.vars[index] = PCI(pcs)->pcop->name;
- return 1;
- }
- }
-
- pcs = findNextInstruction(pcs->next);
- if(pcs) {
- //DFPRINTF((stderr," (next to match)\n"));
- //pcs->print(stderr,pcs);
- } else if(pcd->next) {
- /* oops, we ran out of code, but there's more to the rule */
- return 0;
- }
-
- return 1; /* wild card matches */
- }
+ return i;
+ } else {
+ DFPRINTF((stderr," (matched %s\n",PCI(pcs)->pcop->name));
+ peepBlock->target.vars[index] = PCI(pcs)->pcop->name;
+ return 1;
+ }
+ }
+
+ pcs = findNextInstruction(pcs->next);
+ if(pcs) {
+ //DFPRINTF((stderr," (next to match)\n"));
+ //pcs->print(stderr,pcs);
+ } else if(pcd->next) {
+ /* oops, we ran out of code, but there's more to the rule */
+ return 0;
+ }
+
+ return 1; /* wild card matches */
+ }
- return 0;
+ return 0;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pCodePeepClrVars(pCodePeep *pcp)
{
-
- int i;
- if(!pcp)
- return;
-/*
- DFPRINTF((stderr," Clearing peep rule vars\n"));
- DFPRINTF((stderr," %d %d %d %d %d %d\n",
- pcp->target.nvars,pcp->target.nops,pcp->target.nwildpCodes,
- pcp->replace.nvars,pcp->replace.nops,pcp->replace.nwildpCodes));
-*/
- for(i=0;i<pcp->target.nvars; i++)
- pcp->target.vars[i] = NULL;
- for(i=0;i<pcp->target.nops; i++)
- pcp->target.wildpCodeOps[i] = NULL;
- for(i=0;i<pcp->target.nwildpCodes; i++)
- pcp->target.wildpCodes[i] = NULL;
-
- for(i=0;i<pcp->replace.nvars; i++)
- pcp->replace.vars[i] = NULL;
- for(i=0;i<pcp->replace.nops; i++)
- pcp->replace.wildpCodeOps[i] = NULL;
- for(i=0;i<pcp->replace.nwildpCodes; i++)
- pcp->replace.wildpCodes[i] = NULL;
-
-
-
+
+ int i;
+ if(!pcp)
+ return;
+ /*
+ DFPRINTF((stderr," Clearing peep rule vars\n"));
+ DFPRINTF((stderr," %d %d %d %d %d %d\n",
+ pcp->target.nvars,pcp->target.nops,pcp->target.nwildpCodes,
+ pcp->replace.nvars,pcp->replace.nops,pcp->replace.nwildpCodes));
+ */
+ for(i=0;i<pcp->target.nvars; i++)
+ pcp->target.vars[i] = NULL;
+ for(i=0;i<pcp->target.nops; i++)
+ pcp->target.wildpCodeOps[i] = NULL;
+ for(i=0;i<pcp->target.nwildpCodes; i++)
+ pcp->target.wildpCodes[i] = NULL;
+
+ for(i=0;i<pcp->replace.nvars; i++)
+ pcp->replace.vars[i] = NULL;
+ for(i=0;i<pcp->replace.nops; i++)
+ pcp->replace.wildpCodeOps[i] = NULL;
+ for(i=0;i<pcp->replace.nwildpCodes; i++)
+ pcp->replace.wildpCodes[i] = NULL;
+
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int pCodePeepMatchRule(pCode *pc)
{
- pCodePeep *peepBlock;
- pCode *pct, *pcin;
- pCodeCSource *pc_cline=NULL;
- _DLL *peeprules;
- int matched;
-
- peeprules = (_DLL *)peepSnippets;
-
- while(peeprules) {
- peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
-
- if(!peepBlock || /*!peepBlock->target ||*/ !peepBlock->target.pb->pcHead) {
- fprintf(stderr, "skipping rule because target pb is NULL\n");
- goto next_rule;
- }
-
- pCodePeepClrVars(peepBlock);
-/*
- pcin = pc;
- if(IS_PCCOMMENT(pcin))
- pc = pcin = findNextInstruction(pcin->next);
-*/
- pcin = pc = findNextInstruction(pc);
-
- pct = peepBlock->target.pb->pcHead;
+ pCodePeep *peepBlock;
+ pCode *pct, *pcin;
+ pCodeCSource *pc_cline=NULL;
+ _DLL *peeprules;
+ int matched;
+
+ peeprules = (_DLL *)peepSnippets;
+
+ while(peeprules) {
+ peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
+
+ if(!peepBlock || /*!peepBlock->target ||*/ !peepBlock->target.pb->pcHead) {
+ fprintf(stderr, "skipping rule because target pb is NULL\n");
+ goto next_rule;
+ }
+
+ pCodePeepClrVars(peepBlock);
+ /*
+ pcin = pc;
+ if(IS_PCCOMMENT(pcin))
+ pc = pcin = findNextInstruction(pcin->next);
+ */
+ pcin = pc = findNextInstruction(pc);
+
+ pct = peepBlock->target.pb->pcHead;
#ifdef PCODE_DEBUG
- {
- pCode *pcr = peepBlock->replace.pb->pcHead;
- if(pcr) pct->print(stderr,pcr);
- }
+ {
+ pCode *pcr = peepBlock->replace.pb->pcHead;
+ if(pcr) pct->print(stderr,pcr);
+ }
#endif
- matched = 0;
- while(pct && pcin) {
-
- if(! (matched = pCodePeepMatchLine(peepBlock, pcin,pct)))
- break;
-
- pcin = findNextInstruction(pcin->next);
- pct = pct->next;
- //debug:
- //DFPRINTF((stderr," matched\n"));
-
- if(!pcin && pct) {
- DFPRINTF((stderr," partial match... no more code\n"));
- matched = 0;
- }
- if(!pct) {
- DFPRINTF((stderr," end of rule\n"));
- }
- }
-
- if(matched && pcin) {
-
- /* So far we matched the rule up to the point of the conditions .
- * In other words, all of the opcodes match. Now we need to see
- * if the post conditions are satisfied.
- * First we check the 'postFalseCond'. This means that we check
- * to see if any of the subsequent pCode's in the pCode chain
- * following the point just past where we have matched depend on
- * the `postFalseCond' as input then we abort the match
- */
- DFPRINTF((stderr," matched rule so far, now checking conditions\n"));
- //pcin->print(stderr,pcin);
-
- if (pcin && peepBlock->postFalseCond &&
- (pCodeSearchCondition(pcin,peepBlock->postFalseCond,0) > 0) )
- matched = 0;
-
- //fprintf(stderr," condition results = %d\n",pCodeSearchCondition(pcin,peepBlock->postFalseCond));
-
-
- //if(!matched) fprintf(stderr,"failed on conditions\n");
- }
-
- if(matched) {
-
- pCode *pcprev;
- pCode *pcr;
-
-
- /* We matched a rule! Now we have to go through and remove the
- inefficient code with the optimized version */
+ matched = 0;
+ while(pct && pcin) {
+
+ if(! (matched = pCodePeepMatchLine(peepBlock, pcin,pct)))
+ break;
+
+ pcin = findNextInstruction(pcin->next);
+ pct = pct->next;
+ //debug:
+ //DFPRINTF((stderr," matched\n"));
+
+ if(!pcin && pct) {
+ DFPRINTF((stderr," partial match... no more code\n"));
+ matched = 0;
+ }
+ if(!pct) {
+ DFPRINTF((stderr," end of rule\n"));
+ }
+ }
+
+ if(matched && pcin) {
+
+ /* So far we matched the rule up to the point of the conditions .
+ * In other words, all of the opcodes match. Now we need to see
+ * if the post conditions are satisfied.
+ * First we check the 'postFalseCond'. This means that we check
+ * to see if any of the subsequent pCode's in the pCode chain
+ * following the point just past where we have matched depend on
+ * the `postFalseCond' as input then we abort the match
+ */
+ DFPRINTF((stderr," matched rule so far, now checking conditions\n"));
+ //pcin->print(stderr,pcin);
+
+ if (pcin && peepBlock->postFalseCond &&
+ (pCodeSearchCondition(pcin,peepBlock->postFalseCond,0) > 0) )
+ matched = 0;
+
+ //fprintf(stderr," condition results = %d\n",pCodeSearchCondition(pcin,peepBlock->postFalseCond));
+
+
+ //if(!matched) fprintf(stderr,"failed on conditions\n");
+ }
+
+ if(matched) {
+
+ pCode *pcprev;
+ pCode *pcr;
+
+
+ /* We matched a rule! Now we have to go through and remove the
+ inefficient code with the optimized version */
#ifdef PCODE_DEBUG
- DFPRINTF((stderr, "Found a pcode peep match:\nRule:\n"));
- printpCodeString(stderr,peepBlock->target.pb->pcHead,10);
- DFPRINTF((stderr,"first thing matched\n"));
- pc->print(stderr,pc);
- if(pcin) {
- DFPRINTF((stderr,"last thing matched\n"));
- pcin->print(stderr,pcin);
- }
+ DFPRINTF((stderr, "Found a pcode peep match:\nRule:\n"));
+ printpCodeString(stderr,peepBlock->target.pb->pcHead,10);
+ DFPRINTF((stderr,"first thing matched\n"));
+ pc->print(stderr,pc);
+ if(pcin) {
+ DFPRINTF((stderr,"last thing matched\n"));
+ pcin->print(stderr,pcin);
+ }
#endif
-
-
- /* Unlink the original code */
- pcprev = pc->prev;
- pcprev->next = pcin;
- if(pcin)
- pcin->prev = pc->prev;
-
-
+
+
+ /* Unlink the original code */
+ pcprev = pc->prev;
+ pcprev->next = pcin;
+ if(pcin)
+ pcin->prev = pc->prev;
+
+
#if 0
- {
- /* DEBUG */
- /* Converted the deleted pCodes into comments */
-
- char buf[256];
- pCodeCSource *pc_cline2=NULL;
-
- buf[0] = ';';
- buf[1] = '#';
-
- while(pc && pc!=pcin) {
-
- if(pc->type == PC_OPCODE && PCI(pc)->cline) {
- if(pc_cline) {
- pc_cline2->pc.next = PCODE(PCI(pc)->cline);
- pc_cline2 = PCCS(pc_cline2->pc.next);
- } else {
- pc_cline = pc_cline2 = PCI(pc)->cline;
- pc_cline->pc.seq = pc->seq;
- }
- }
-
- pCode2str(&buf[2], 254, pc);
- pCodeInsertAfter(pcprev, newpCodeCharP(buf));
- pcprev = pcprev->next;
- pc = pc->next;
-
- }
- if(pc_cline2)
- pc_cline2->pc.next = NULL;
- }
+ {
+ /* DEBUG */
+ /* Converted the deleted pCodes into comments */
+
+ char buf[256];
+ pCodeCSource *pc_cline2=NULL;
+
+ buf[0] = ';';
+ buf[1] = '#';
+
+ while(pc && pc!=pcin) {
+
+ if(pc->type == PC_OPCODE && PCI(pc)->cline) {
+ if(pc_cline) {
+ pc_cline2->pc.next = PCODE(PCI(pc)->cline);
+ pc_cline2 = PCCS(pc_cline2->pc.next);
+ } else {
+ pc_cline = pc_cline2 = PCI(pc)->cline;
+ pc_cline->pc.seq = pc->seq;
+ }
+ }
+
+ pCode2str(&buf[2], 254, pc);
+ pCodeInsertAfter(pcprev, newpCodeCharP(buf));
+ pcprev = pcprev->next;
+ pc = pc->next;
+
+ }
+ if(pc_cline2)
+ pc_cline2->pc.next = NULL;
+ }
#endif
-
- if(pcin)
- pCodeDeleteChain(pc,pcin);
-
- /* Generate the replacement code */
- pc = pcprev;
- pcr = peepBlock->replace.pb->pcHead; // This is the replacement code
- while (pcr) {
- pCodeOp *pcop=NULL;
-
- /* If the replace pcode is an instruction with an operand, */
- /* then duplicate the operand (and expand wild cards in the process). */
- if(pcr->type == PC_OPCODE) {
- if(PCI(pcr)->pcop) {
- /* The replacing instruction has an operand.
- * Is it wild? */
- if(PCI(pcr)->pcop->type == PO_WILD) {
- int index = PCOW(PCI(pcr)->pcop)->id;
- //DFPRINTF((stderr,"copying wildopcode\n"));
- if(peepBlock->target.wildpCodeOps[index])
- pcop = pCodeOpCopy(peepBlock->target.wildpCodeOps[index]);
- else
- DFPRINTF((stderr,"error, wildopcode in replace but not source?\n"));
- } else
- pcop = pCodeOpCopy(PCI(pcr)->pcop);
- }
- //DFPRINTF((stderr,"inserting pCode\n"));
- pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
- } else if (pcr->type == PC_WILD) {
- if(PCW(pcr)->invertBitSkipInst)
- DFPRINTF((stderr,"We need to invert the bit skip instruction\n"));
- pCodeInsertAfter(pc,
- pCodeInstructionCopy(PCI(peepBlock->target.wildpCodes[PCW(pcr)->id]),
+
+ if(pcin)
+ pCodeDeleteChain(pc,pcin);
+
+ /* Generate the replacement code */
+ pc = pcprev;
+ pcr = peepBlock->replace.pb->pcHead; // This is the replacement code
+ while (pcr) {
+ pCodeOp *pcop=NULL;
+
+ /* If the replace pcode is an instruction with an operand, */
+ /* then duplicate the operand (and expand wild cards in the process). */
+ if(pcr->type == PC_OPCODE) {
+ if(PCI(pcr)->pcop) {
+ /* The replacing instruction has an operand.
+ * Is it wild? */
+ if(PCI(pcr)->pcop->type == PO_WILD) {
+ int index = PCOW(PCI(pcr)->pcop)->id;
+ //DFPRINTF((stderr,"copying wildopcode\n"));
+ if(peepBlock->target.wildpCodeOps[index])
+ pcop = pCodeOpCopy(peepBlock->target.wildpCodeOps[index]);
+ else
+ DFPRINTF((stderr,"error, wildopcode in replace but not source?\n"));
+ } else
+ pcop = pCodeOpCopy(PCI(pcr)->pcop);
+ }
+ //DFPRINTF((stderr,"inserting pCode\n"));
+ pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
+ } else if (pcr->type == PC_WILD) {
+ if(PCW(pcr)->invertBitSkipInst)
+ DFPRINTF((stderr,"We need to invert the bit skip instruction\n"));
+ pCodeInsertAfter(pc,
+ pCodeInstructionCopy(PCI(peepBlock->target.wildpCodes[PCW(pcr)->id]),
PCW(pcr)->invertBitSkipInst));
- } else if (pcr->type == PC_COMMENT) {
- pCodeInsertAfter(pc, newpCodeCharP( ((pCodeComment *)(pcr))->comment));
- }
-
-
- pc = pc->next;
+ } else if (pcr->type == PC_COMMENT) {
+ pCodeInsertAfter(pc, newpCodeCharP( ((pCodeComment *)(pcr))->comment));
+ }
+
+
+ pc = pc->next;
#ifdef PCODE_DEBUG
- DFPRINTF((stderr," NEW Code:"));
- if(pc) pc->print(stderr,pc);
+ DFPRINTF((stderr," NEW Code:"));
+ if(pc) pc->print(stderr,pc);
#endif
- pcr = pcr->next;
- }
-
- /* We have just replaced the inefficient code with the rule.
- * Now, we need to re-add the C-source symbols if there are any */
- pc = pcprev;
- while(pc_cline ) {
-
- pc = findNextInstruction(pc->next);
- PCI(pc)->cline = pc_cline;
- pc_cline = PCCS(pc_cline->pc.next);
-
- }
-
- return 1;
- }
- next_rule:
- peeprules = peeprules->next;
+ pcr = pcr->next;
+ }
+
+ /* We have just replaced the inefficient code with the rule.
+ * Now, we need to re-add the C-source symbols if there are any */
+ pc = pcprev;
+ while(pc_cline ) {
+
+ pc = findNextInstruction(pc->next);
+ PCI(pc)->cline = pc_cline;
+ pc_cline = PCCS(pc_cline->pc.next);
+
+ }
+
+ return 1;
+ }
+next_rule:
+ peeprules = peeprules->next;
}
DFPRINTF((stderr," no rule matched\n"));
-------------------------------------------------------------------------*/
/*
- pcoderegs.c
+pcoderegs.c
The purpose of the code in this file is to optimize the register usage.
int register_optimization=1;
/*-----------------------------------------------------------------*
- * void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
- *-----------------------------------------------------------------*/
+* void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
+*-----------------------------------------------------------------*/
/*
void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
{
- if(!reg || ! pcfl || !isPCFL(pcflow))
- return;
-
- if(!pcfl->registers)
- pcfl->registers = newSet();
+ if(!reg || ! pcfl || !isPCFL(pcflow))
+ return;
+ if(!pcfl->registers)
+ pcfl->registers = newSet();
+
}
*/
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
void dbg_regusage(set *fregs)
{
- regs *reg;
- pCode *pcfl;
- pCode *pc;
-
-
- for (reg = setFirstItem(fregs) ; reg ;
- reg = setNextItem(fregs)) {
-
- if(elementsInSet(reg->reglives.usedpCodes)) {
-
- fprintf (stderr, "%s addr=0x%03x rIdx=0x%03x",
- reg->name,
- reg->address,
- reg->rIdx);
-
- pcfl = setFirstItem(reg->reglives.usedpFlows);
- if(pcfl)
- fprintf(stderr, "\n used in seq");
-
- while(pcfl) {
- fprintf(stderr," 0x%03x",pcfl->seq);
- pcfl = setNextItem(reg->reglives.usedpFlows);
- }
-
- pcfl = setFirstItem(reg->reglives.assignedpFlows);
- if(pcfl)
- fprintf(stderr, "\n assigned in seq");
-
- while(pcfl) {
- fprintf(stderr," 0x%03x",pcfl->seq);
- pcfl = setNextItem(reg->reglives.assignedpFlows);
- }
-
- pc = setFirstItem(reg->reglives.usedpCodes);
- if(pc)
- fprintf(stderr, "\n used in instructions ");
-
- while(pc) {
- pcfl = PCODE(PCI(pc)->pcflow);
- if(pcfl)
- fprintf(stderr," 0x%03x:",pcfl->seq);
- fprintf(stderr,"0x%03x",pc->seq);
-
- pc = setNextItem(reg->reglives.usedpCodes);
- }
-
- fprintf(stderr, "\n");
- }
- }
+ regs *reg;
+ pCode *pcfl;
+ pCode *pc;
+
+
+ for (reg = setFirstItem(fregs) ; reg ;
+ reg = setNextItem(fregs)) {
+
+ if(elementsInSet(reg->reglives.usedpCodes)) {
+
+ fprintf (stderr, "%s addr=0x%03x rIdx=0x%03x",
+ reg->name,
+ reg->address,
+ reg->rIdx);
+
+ pcfl = setFirstItem(reg->reglives.usedpFlows);
+ if(pcfl)
+ fprintf(stderr, "\n used in seq");
+
+ while(pcfl) {
+ fprintf(stderr," 0x%03x",pcfl->seq);
+ pcfl = setNextItem(reg->reglives.usedpFlows);
+ }
+
+ pcfl = setFirstItem(reg->reglives.assignedpFlows);
+ if(pcfl)
+ fprintf(stderr, "\n assigned in seq");
+
+ while(pcfl) {
+ fprintf(stderr," 0x%03x",pcfl->seq);
+ pcfl = setNextItem(reg->reglives.assignedpFlows);
+ }
+
+ pc = setFirstItem(reg->reglives.usedpCodes);
+ if(pc)
+ fprintf(stderr, "\n used in instructions ");
+
+ while(pc) {
+ pcfl = PCODE(PCI(pc)->pcflow);
+ if(pcfl)
+ fprintf(stderr," 0x%03x:",pcfl->seq);
+ fprintf(stderr,"0x%03x",pc->seq);
+
+ pc = setNextItem(reg->reglives.usedpCodes);
+ }
+
+ fprintf(stderr, "\n");
+ }
+ }
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
void dbg_dumpregusage(void)
{
-
- fprintf(stderr,"*** Register Usage ***\n");
- fprintf(stderr,"InternalRegs:\n");
- dbg_regusage(dynInternalRegs);
- fprintf(stderr,"AllocRegs:\n");
- dbg_regusage(dynAllocRegs);
- fprintf(stderr,"StackRegs:\n");
- dbg_regusage(dynStackRegs);
- fprintf(stderr,"DirectRegs:\n");
- dbg_regusage(dynDirectRegs);
- fprintf(stderr,"DirectBitRegs:\n");
- dbg_regusage(dynDirectBitRegs);
- fprintf(stderr,"ProcessorRegs:\n");
- dbg_regusage(dynProcessorRegs);
-
+
+ fprintf(stderr,"*** Register Usage ***\n");
+ fprintf(stderr,"InternalRegs:\n");
+ dbg_regusage(dynInternalRegs);
+ fprintf(stderr,"AllocRegs:\n");
+ dbg_regusage(dynAllocRegs);
+ fprintf(stderr,"StackRegs:\n");
+ dbg_regusage(dynStackRegs);
+ fprintf(stderr,"DirectRegs:\n");
+ dbg_regusage(dynDirectRegs);
+ fprintf(stderr,"DirectBitRegs:\n");
+ dbg_regusage(dynDirectBitRegs);
+ fprintf(stderr,"ProcessorRegs:\n");
+ dbg_regusage(dynProcessorRegs);
+
}
/*-----------------------------------------------------------------*
- * void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
- *-----------------------------------------------------------------*/
+* void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
+*-----------------------------------------------------------------*/
void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
{
-
- pCode *pc=NULL;
- pCode *pcprev=NULL;
-
- regs *reg;
-
- if(!pcfl)
- return;
-
-
- pc = findNextInstruction(pcfl->pc.next);
-
- while(isPCinFlow(pc,PCODE(pcfl))) {
-
-
- reg = getRegFromInstruction(pc);
-
- if(reg) {
-/*
- fprintf(stderr, "flow seq %d, inst seq %d %s ",PCODE(pcfl)->seq,pc->seq,reg->name);
- fprintf(stderr, "addr = 0x%03x, type = %d rIdx=0x%03x\n",
- reg->address,reg->type,reg->rIdx);
-*/
-
- addSetIfnotP(& (PCFL(pcfl)->registers), reg);
-
- if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
- addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
-
- if(PCC_REGISTER & PCI(pc)->outCond)
- addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
-
- addSetIfnotP(& (reg->reglives.usedpCodes), pc);
- }
-
-
- pcprev = pc;
- pc = findNextInstruction(pc->next);
-
- }
-
+
+ pCode *pc=NULL;
+ pCode *pcprev=NULL;
+
+ regs *reg;
+
+ if(!pcfl)
+ return;
+
+
+ pc = findNextInstruction(pcfl->pc.next);
+
+ while(isPCinFlow(pc,PCODE(pcfl))) {
+
+
+ reg = getRegFromInstruction(pc);
+
+ if(reg) {
+ /*
+ fprintf(stderr, "flow seq %d, inst seq %d %s ",PCODE(pcfl)->seq,pc->seq,reg->name);
+ fprintf(stderr, "addr = 0x%03x, type = %d rIdx=0x%03x\n",
+ reg->address,reg->type,reg->rIdx);
+ */
+
+ addSetIfnotP(& (PCFL(pcfl)->registers), reg);
+
+ if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
+ addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
+
+ if(PCC_REGISTER & PCI(pc)->outCond)
+ addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
+
+ addSetIfnotP(& (reg->reglives.usedpCodes), pc);
+ }
+
+
+ pcprev = pc;
+ pc = findNextInstruction(pc->next);
+
+ }
+
}
/*-----------------------------------------------------------------*
- * void pCodeRegMapLiveRanges(pBlock *pb)
- *-----------------------------------------------------------------*/
+* void pCodeRegMapLiveRanges(pBlock *pb)
+*-----------------------------------------------------------------*/
void pCodeRegMapLiveRanges(pBlock *pb)
{
- pCode *pcflow;
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "pCodeRegMapLiveRanges - pcflow is not a flow object ");
- continue;
- }
- pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
- }
-
+ pCode *pcflow;
+
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ if(!isPCFL(pcflow)) {
+ fprintf(stderr, "pCodeRegMapLiveRanges - pcflow is not a flow object ");
+ continue;
+ }
+ pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
+ }
+
#if 0
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- regs *r = setFirstItem(PCFL(pcflow)->registers);
- fprintf(stderr,"flow seq %d\n", pcflow->seq);
-
- while (r) {
- fprintf(stderr, " %s\n",r->name);
- r = setNextItem(PCFL(pcflow)->registers);
-
- }
-
- }
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
+
+ regs *r = setFirstItem(PCFL(pcflow)->registers);
+ fprintf(stderr,"flow seq %d\n", pcflow->seq);
+
+ while (r) {
+ fprintf(stderr, " %s\n",r->name);
+ r = setNextItem(PCFL(pcflow)->registers);
+
+ }
+
+ }
#endif
-
-// dbg_dumpregusage();
-
+
+ // dbg_dumpregusage();
+
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
static void Remove1pcode(pCode *pc, regs *reg, int debug_code)
{
-
- pCode *pcn=NULL;
-
- if(!reg || !pc)
- return;
-
- deleteSetItem (&(reg->reglives.usedpCodes),pc);
-
- if(PCI(pc)->label) {
- pcn = findNextInstruction(pc->next);
-
- if(pcn)
- PCI(pcn)->label = pBranchAppend(PCI(pcn)->label,PCI(pc)->label);
- }
-
- if(PCI(pc)->cline) {
- if(!pcn)
- pcn = findNextInstruction(pc->next);
-
- if(pcn) {
- if(PCI(pcn)->cline) {
- //fprintf(stderr, "source line has been optimized completely out\n");
- //pc->print(stderr,pc);
- } else {
- PCI(pcn)->cline = PCI(pc)->cline;
- }
- }
- }
-
-
- if(1){
- /*
- Debug stuff. Comment out the instruction we're about to delete.
- */
-
- char buff1[256];
- size_t size = 256;
-
- char *pbuff,**ppbuff;
- pbuff = buff1;
- ppbuff = &pbuff;
-
- SAFE_snprintf(ppbuff,&size, ";%d", debug_code);
- pCode2str(*ppbuff, size, pc);
- pCodeInsertBefore(pc, newpCodeCharP(buff1));
- //fprintf(stderr,"removing instruction:\n%s\n",buff1);
- }
-
- pc->destruct(pc);
-
+
+ pCode *pcn=NULL;
+
+ if(!reg || !pc)
+ return;
+
+ deleteSetItem (&(reg->reglives.usedpCodes),pc);
+
+ if(PCI(pc)->label) {
+ pcn = findNextInstruction(pc->next);
+
+ if(pcn)
+ PCI(pcn)->label = pBranchAppend(PCI(pcn)->label,PCI(pc)->label);
+ }
+
+ if(PCI(pc)->cline) {
+ if(!pcn)
+ pcn = findNextInstruction(pc->next);
+
+ if(pcn) {
+ if(PCI(pcn)->cline) {
+ //fprintf(stderr, "source line has been optimized completely out\n");
+ //pc->print(stderr,pc);
+ } else {
+ PCI(pcn)->cline = PCI(pc)->cline;
+ }
+ }
+ }
+
+
+ if(1){
+ /*
+ Debug stuff. Comment out the instruction we're about to delete.
+ */
+
+ char buff1[256];
+ size_t size = 256;
+
+ char *pbuff,**ppbuff;
+ pbuff = buff1;
+ ppbuff = &pbuff;
+
+ SAFE_snprintf(ppbuff,&size, ";%d", debug_code);
+ pCode2str(*ppbuff, size, pc);
+ pCodeInsertBefore(pc, newpCodeCharP(buff1));
+ //fprintf(stderr,"removing instruction:\n%s\n",buff1);
+ }
+
+ pc->destruct(pc);
+
}
/*-----------------------------------------------------------------*
- * void RemoveRegsFromSet(set *regset)
- *
- *-----------------------------------------------------------------*/
+* void RemoveRegsFromSet(set *regset)
+*
+*-----------------------------------------------------------------*/
void RemoveRegsFromSet(set *regset)
{
- regs *reg;
- int used;
-
- while(regset) {
- reg = regset->item;
- regset = regset->next;
-
- used = elementsInSet(reg->reglives.usedpCodes);
-
- if(used <= 1) {
-
- //fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
- if(used == 0) {
- //fprintf(stderr," getting rid of reg %s\n",reg->name);
- reg->isFree = 1;
- reg->wasUsed = 0;
- } else {
- pCode *pc;
-
-
- pc = setFirstItem(reg->reglives.usedpCodes);
-
- if(reg->type == REG_SFR || reg->type == REG_STK || reg->isPublic || reg->isExtern) {
- //fprintf(stderr, "not removing SFR reg %s even though used only once\n",reg->name);
- continue;
- }
-
-
- if(isPCI(pc)) {
- if(PCI(pc)->label) {
- pCode *pcn = findNextInstruction(pc->next);
-
- if(pcn && PCI(pcn)->label) {
- //fprintf(stderr,"can't delete instruction with label...\n");
- //pc->print(stderr,pc);
- continue;
- }
- /* Move the label to the next instruction */
-
- PCI(pcn)->label = PCI(pc)->label;
-
- }
-
- if(isPCI_SKIP(pc)) {
- regs *r = getRegFromInstruction(pc);
- fprintf(stderr, "WARNING, a skip instruction is being optimized out\n");
- pc->print(stderr,pc);
- fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
- }
- //fprintf(stderr," removing reg %s because it is used only once\n",reg->name);
- Remove1pcode(pc, reg, 1);
- /*
- unlinkpCode(pc);
- deleteSetItem (&(reg->reglives.usedpCodes),pc);
- */
- reg->isFree = 1;
- reg->wasUsed = 0;
- total_registers_saved++; // debugging stats.
+ regs *reg;
+ int used;
+
+ while(regset) {
+ reg = regset->item;
+ regset = regset->next;
+
+ used = elementsInSet(reg->reglives.usedpCodes);
+
+ if(used <= 1) {
+
+ //fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
+ if(used == 0) {
+ //fprintf(stderr," getting rid of reg %s\n",reg->name);
+ reg->isFree = 1;
+ reg->wasUsed = 0;
+ } else {
+ pCode *pc;
+
+
+ pc = setFirstItem(reg->reglives.usedpCodes);
+
+ if(reg->type == REG_SFR || reg->type == REG_STK || reg->isPublic || reg->isExtern) {
+ //fprintf(stderr, "not removing SFR reg %s even though used only once\n",reg->name);
+ continue;
+ }
+
+
+ if(isPCI(pc)) {
+ if(PCI(pc)->label) {
+ pCode *pcn = findNextInstruction(pc->next);
+
+ if(pcn && PCI(pcn)->label) {
+ //fprintf(stderr,"can't delete instruction with label...\n");
+ //pc->print(stderr,pc);
+ continue;
+ }
+ /* Move the label to the next instruction */
+
+ PCI(pcn)->label = PCI(pc)->label;
+
+ }
+
+ if(isPCI_SKIP(pc)) {
+ regs *r = getRegFromInstruction(pc);
+ fprintf(stderr, "WARNING, a skip instruction is being optimized out\n");
+ pc->print(stderr,pc);
+ fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
+ }
+ //fprintf(stderr," removing reg %s because it is used only once\n",reg->name);
+ Remove1pcode(pc, reg, 1);
+ /*
+ unlinkpCode(pc);
+ deleteSetItem (&(reg->reglives.usedpCodes),pc);
+ */
+ reg->isFree = 1;
+ reg->wasUsed = 0;
+ total_registers_saved++; // debugging stats.
+ }
+ }
+ }
+
}
- }
- }
-
- }
}
/*-----------------------------------------------------------------*
- * void RemoveUnusedRegisters(void)
- *
- *-----------------------------------------------------------------*/
+* void RemoveUnusedRegisters(void)
+*
+*-----------------------------------------------------------------*/
void RemoveUnusedRegisters(void)
{
- /* First, get rid of registers that are used only one time */
-
- //RemoveRegsFromSet(dynInternalRegs);
- RemoveRegsFromSet(dynAllocRegs);
- RemoveRegsFromSet(dynStackRegs);
- /*
- don't do DirectRegs yet - there's a problem with arrays
- RemoveRegsFromSet(dynDirectRegs);
- */
- RemoveRegsFromSet(dynDirectBitRegs);
-
- if(total_registers_saved) DFPRINTF((stderr, " *** Saved %d registers ***\n", total_registers_saved));
+ /* First, get rid of registers that are used only one time */
+
+ //RemoveRegsFromSet(dynInternalRegs);
+ RemoveRegsFromSet(dynAllocRegs);
+ RemoveRegsFromSet(dynStackRegs);
+ /*
+ don't do DirectRegs yet - there's a problem with arrays
+ RemoveRegsFromSet(dynDirectRegs);
+ */
+ RemoveRegsFromSet(dynDirectBitRegs);
+
+ if(total_registers_saved) DFPRINTF((stderr, " *** Saved %d registers ***\n", total_registers_saved));
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int can_free)
{
- static int debug_code=99;
- if(!reg)
- return;
-
- //fprintf(stderr,"%s\n",__FUNCTION__);
- if(pc1)
- Remove1pcode(pc1, reg, debug_code++);
-
- if(pc2) {
- Remove1pcode(pc2, reg, debug_code++);
- deleteSetItem (&(PCFL(pcflow)->registers), reg);
-
- if(can_free) {
- reg->isFree = 1;
- reg->wasUsed = 0;
- }
-
- }
-
- pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
+ static int debug_code=99;
+ if(!reg)
+ return;
+
+ //fprintf(stderr,"%s\n",__FUNCTION__);
+ if(pc1)
+ Remove1pcode(pc1, reg, debug_code++);
+
+ if(pc2) {
+ Remove1pcode(pc2, reg, debug_code++);
+ deleteSetItem (&(PCFL(pcflow)->registers), reg);
+
+ if(can_free) {
+ reg->isFree = 1;
+ reg->wasUsed = 0;
+ }
+
+ }
+
+ pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
}
/*-----------------------------------------------------------------*
- *
- *-----------------------------------------------------------------*/
+*
+*-----------------------------------------------------------------*/
int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
{
- int i=0;
- regs *testreg;
-
- do {
- testreg = getRegFromInstruction(pc1);
- if(testreg && (testreg->rIdx == reg->rIdx)) {
- return 1;
- }
-
- pc1 = findNextInstruction(pc1->next);
-
- } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
-
- if(i >= 100)
- fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
-
- return 0;
+ int i=0;
+ regs *testreg;
+
+ do {
+ testreg = getRegFromInstruction(pc1);
+ if(testreg && (testreg->rIdx == reg->rIdx)) {
+ return 1;
+ }
+
+ pc1 = findNextInstruction(pc1->next);
+
+ } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
+
+ if(i >= 100)
+ fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
+
+ return 0;
}
/*-----------------------------------------------------------------*
- * void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
- *
- * ADHOC pattern checking
- * Now look for specific sequences that are easy to optimize.
- * Many of these sequences are characteristic of the compiler
- * (i.e. it'd probably be a waste of time to apply these adhoc
- * checks to hand written assembly.)
- *
- *
- *-----------------------------------------------------------------*/
+* void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
+*
+* ADHOC pattern checking
+* Now look for specific sequences that are easy to optimize.
+* Many of these sequences are characteristic of the compiler
+* (i.e. it'd probably be a waste of time to apply these adhoc
+* checks to hand written assembly.)
+*
+*
+*-----------------------------------------------------------------*/
int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free, int optimize_level)
{
- pCode *pct1, *pct2;
- regs *reg1, *reg2;
-
- int t = total_registers_saved;
-
- if(pc2->seq < pc1->seq) {
- pct1 = pc2;
- pc2 = pc1;
- pc1 = pct1;
- }
-
- //fprintf(stderr,"pCodeOptime2pCodes\n");
- //pc1->print(stderr,pc1);
- //pc2->print(stderr,pc2);
-
- if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
- pCode *newpc;
- int regUsed = 0;
- int wUsed = 0;
- int wSaved = 0;
- /*
- clrf reg ; pc1
- stuff...
- movf reg,w ; pc2
-
- can be replaced with (only if following instructions are not going to use W and reg is not used again later)
-
- stuff...
- movlw 0 or clrf reg
- */
- DFPRINTF((stderr, " optimising CLRF reg ... MOVF reg,W to ... MOVLW 0\n"));
- pct2 = findNextInstruction(pc2->next);
-
- if(pct2 && PCI(pct2)->op == POC_MOVWF) {
- wSaved = wUsed = 1; /* Maybe able to replace with clrf pc2->next->reg. */
- } else {
- wUsed = pCodeSearchCondition(pct2,PCC_W,1) > 0;
- }
- regUsed = regUsedinRange(pct2,0,reg);
- if ((regUsed&&wUsed) || (pCodeSearchCondition(pct2,PCC_Z,0) > 1)) {
- /* Do not optimise as exisiting code is required. */
- } else {
- /* Can optimise. */
- if(regUsed) {
- newpc = newpCode(POC_CLRF, PCI(pc1)->pcop);
- } else if(wSaved && !wUsed) {
- newpc = newpCode(POC_CLRF, PCI(pct2)->pcop);
- pct2->destruct(pct2);
- } else {
- newpc = newpCode(POC_MOVLW, newpCodeOpLit(0));
- }
-
- pCodeInsertAfter(pc2, newpc);
- PCI(newpc)->pcflow = PCFL(pcfl_used);
- newpc->seq = pc2->seq;
-
- Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
- total_registers_saved++; // debugging stats.
- }
- } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
- DFPRINTF((stderr, " optimising CLRF/IORFW\n"));
-
- pct2 = findNextInstruction(pc2->next);
-
- if(pCodeSearchCondition(pct2, PCC_Z,0) > 0) {
- pct2 = newpCode(POC_IORLW, newpCodeOpLit(0));
- pct2->seq = pc2->seq;
- PCI(pct2)->pcflow = PCFL(pcfl_used);
- pCodeInsertAfter(pc1,pct2);
- }
- Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
- total_registers_saved++; // debugging stats.
-
- } else if(PCI(pc1)->op == POC_MOVWF) {
- // Optimising MOVWF reg ...
-
- pct2 = findNextInstruction(pc2->next);
-
- if(PCI(pc2)->op == POC_MOVFW) {
- // Optimising MOVWF reg ... MOVF reg,W
-
- if(PCI(pct2)->op == POC_MOVWF) {
- /*
- Change:
-
- movwf reg ; pc1
- stuff...
- movf reg,w ; pc2
- movwf reg2 ; pct2
-
- To: ( as long as 'stuff' does not use reg2 or if following instructions do not use W or reg is not used later)
-
- movwf reg2
- stuff...
-
- */
- reg2 = getRegFromInstruction(pct2);
- /* Check reg2 is not used for something else before it is loaded with reg */
- if (reg2 && !regUsedinRange(pc1,pc2,reg2)) {
- pCode *pct3 = findNextInstruction(pct2->next);
- /* Check following instructions are not relying on the use of W or the Z flag condiction */
- if ((pCodeSearchCondition(pct3,PCC_Z,0) < 1) || (pCodeSearchCondition(pct3,PCC_W,0) < 1)) {
- DFPRINTF((stderr, " optimising MOVF reg ... MOVF reg,W MOVWF reg2 to MOVWF reg2 ...\n"));
- pct2->seq = pc1->seq;
- unlinkpCode(pct2);
- pCodeInsertBefore(pc1,pct2);
- if(regUsedinRange(pct2,0,reg))
- Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
- else
- Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
-
- total_registers_saved++; // debugging stats.
- return 1;
- }
- }
- }
- }
-
- pct1 = findPrevInstruction(pc1->prev);
- if(pct1 && (PCI(pct1)->pcflow == PCI(pc1)->pcflow)) {
-
- if ( (PCI(pct1)->op == POC_MOVFW) &&
- (PCI(pc2)->op == POC_MOVFW)) {
-
- reg1 = getRegFromInstruction(pct1);
- if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
- DFPRINTF((stderr, " optimising MOVF reg1,W MOVWF reg ... MOVF reg,W\n"));
- /*
- Change:
-
- movf reg1,w
- movwf reg
-
- stuff...
- movf reg,w
-
- To:
-
- stuff...
-
- movf reg1,w
-
- Or, if we're not deleting the register then the "To" is:
-
- stuff...
-
- movf reg1,w
- movwf reg
- */
- pct2 = newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
- pCodeInsertAfter(pc2, pct2);
- PCI(pct2)->pcflow = PCFL(pcfl_used);
- pct2->seq = pc2->seq;
-
- if(can_free) {
- Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
- } else {
- /* If we're not freeing the register then that means (probably)
- * the register is needed somewhere else.*/
- unlinkpCode(pc1);
- pCodeInsertAfter(pct2, pc1);
-
- Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
- }
-
- Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
- total_registers_saved++; // debugging stats.
-
- }
-/* Note this else if is same conditional as the if - DELETE ME
- } else if ( (PCI(pct1)->op == POC_MOVWF) &&
- (PCI(pc2)->op == POC_MOVFW)) {
- DFPRINTF(stderr, " optimising MOVF reg1,W MOVWF reg ... MOVF reg,W\n");
- if(optimize_level > 1 && can_free) {
- pct2 = newpCode(POC_MOVFW, PCI(pc1)->pcop);
- pCodeInsertAfter(pc2, pct2);
- Remove2pcodes(pcfl_used, pc1, pc2, reg, 1);
- total_registers_saved++; // debugging stats.
- }
-*/
- }
- }
+ pCode *pct1, *pct2;
+ regs *reg1, *reg2;
+
+ int t = total_registers_saved;
+
+ if(pc2->seq < pc1->seq) {
+ pct1 = pc2;
+ pc2 = pc1;
+ pc1 = pct1;
+ }
+
+ //fprintf(stderr,"pCodeOptime2pCodes\n");
+ //pc1->print(stderr,pc1);
+ //pc2->print(stderr,pc2);
+
+ if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
+ pCode *newpc;
+ int regUsed = 0;
+ int wUsed = 0;
+ int wSaved = 0;
+ /*
+ clrf reg ; pc1
+ stuff...
+ movf reg,w ; pc2
+
+ can be replaced with (only if following instructions are not going to use W and reg is not used again later)
+
+ stuff...
+ movlw 0 or clrf reg
+ */
+ DFPRINTF((stderr, " optimising CLRF reg ... MOVF reg,W to ... MOVLW 0\n"));
+ pct2 = findNextInstruction(pc2->next);
+
+ if(pct2 && PCI(pct2)->op == POC_MOVWF) {
+ wSaved = wUsed = 1; /* Maybe able to replace with clrf pc2->next->reg. */
+ } else {
+ wUsed = pCodeSearchCondition(pct2,PCC_W,1) > 0;
+ }
+ regUsed = regUsedinRange(pct2,0,reg);
+ if ((regUsed&&wUsed) || (pCodeSearchCondition(pct2,PCC_Z,0) > 1)) {
+ /* Do not optimise as exisiting code is required. */
+ } else {
+ /* Can optimise. */
+ if(regUsed) {
+ newpc = newpCode(POC_CLRF, PCI(pc1)->pcop);
+ } else if(wSaved && !wUsed) {
+ newpc = newpCode(POC_CLRF, PCI(pct2)->pcop);
+ pct2->destruct(pct2);
+ } else {
+ newpc = newpCode(POC_MOVLW, newpCodeOpLit(0));
+ }
+
+ pCodeInsertAfter(pc2, newpc);
+ PCI(newpc)->pcflow = PCFL(pcfl_used);
+ newpc->seq = pc2->seq;
+
+ Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
+ total_registers_saved++; // debugging stats.
+ }
+ } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
+ DFPRINTF((stderr, " optimising CLRF/IORFW\n"));
+
+ pct2 = findNextInstruction(pc2->next);
+
+ if(pCodeSearchCondition(pct2, PCC_Z,0) > 0) {
+ pct2 = newpCode(POC_IORLW, newpCodeOpLit(0));
+ pct2->seq = pc2->seq;
+ PCI(pct2)->pcflow = PCFL(pcfl_used);
+ pCodeInsertAfter(pc1,pct2);
+ }
+ Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
+ total_registers_saved++; // debugging stats.
+
+ } else if(PCI(pc1)->op == POC_MOVWF) {
+ // Optimising MOVWF reg ...
+
+ pct2 = findNextInstruction(pc2->next);
+
+ if(PCI(pc2)->op == POC_MOVFW) {
+ // Optimising MOVWF reg ... MOVF reg,W
+
+ if(PCI(pct2)->op == POC_MOVWF) {
+ /*
+ Change:
+
+ movwf reg ; pc1
+ stuff...
+ movf reg,w ; pc2
+ movwf reg2 ; pct2
+
+ To: ( as long as 'stuff' does not use reg2 or if following instructions do not use W or reg is not used later)
+
+ movwf reg2
+ stuff...
+
+ */
+ reg2 = getRegFromInstruction(pct2);
+ /* Check reg2 is not used for something else before it is loaded with reg */
+ if (reg2 && !regUsedinRange(pc1,pc2,reg2)) {
+ pCode *pct3 = findNextInstruction(pct2->next);
+ /* Check following instructions are not relying on the use of W or the Z flag condiction */
+ if ((pCodeSearchCondition(pct3,PCC_Z,0) < 1) || (pCodeSearchCondition(pct3,PCC_W,0) < 1)) {
+ DFPRINTF((stderr, " optimising MOVF reg ... MOVF reg,W MOVWF reg2 to MOVWF reg2 ...\n"));
+ pct2->seq = pc1->seq;
+ unlinkpCode(pct2);
+ pCodeInsertBefore(pc1,pct2);
+ if(regUsedinRange(pct2,0,reg))
+ Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
+ else
+ Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
+
+ total_registers_saved++; // debugging stats.
+ return 1;
+ }
+ }
+ }
+ }
+
+ pct1 = findPrevInstruction(pc1->prev);
+ if(pct1 && (PCI(pct1)->pcflow == PCI(pc1)->pcflow)) {
+
+ if ( (PCI(pct1)->op == POC_MOVFW) &&
+ (PCI(pc2)->op == POC_MOVFW)) {
+
+ reg1 = getRegFromInstruction(pct1);
+ if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
+ DFPRINTF((stderr, " optimising MOVF reg1,W MOVWF reg ... MOVF reg,W\n"));
+ /*
+ Change:
+
+ movf reg1,w
+ movwf reg
+
+ stuff...
+ movf reg,w
+
+ To:
+
+ stuff...
+
+ movf reg1,w
+
+ Or, if we're not deleting the register then the "To" is:
+
+ stuff...
+
+ movf reg1,w
+ movwf reg
+ */
+ pct2 = newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
+ pCodeInsertAfter(pc2, pct2);
+ PCI(pct2)->pcflow = PCFL(pcfl_used);
+ pct2->seq = pc2->seq;
+
+ if(can_free) {
+ Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
+ } else {
+ /* If we're not freeing the register then that means (probably)
+ * the register is needed somewhere else.*/
+ unlinkpCode(pc1);
+ pCodeInsertAfter(pct2, pc1);
+
+ Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
+ }
+
+ Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
+ total_registers_saved++; // debugging stats.
+
+ }
+ /* Note this else if is same conditional as the if - DELETE ME
+ } else if ( (PCI(pct1)->op == POC_MOVWF) &&
+ (PCI(pc2)->op == POC_MOVFW)) {
+ DFPRINTF(stderr, " optimising MOVF reg1,W MOVWF reg ... MOVF reg,W\n");
+ if(optimize_level > 1 && can_free) {
+ pct2 = newpCode(POC_MOVFW, PCI(pc1)->pcop);
+ pCodeInsertAfter(pc2, pct2);
+ Remove2pcodes(pcfl_used, pc1, pc2, reg, 1);
+ total_registers_saved++; // debugging stats.
+ }
+ */
+ }
+ }
}
return (total_registers_saved != t);
}
/*-----------------------------------------------------------------*
- * void pCodeRegOptimeRegUsage(pBlock *pb)
- *-----------------------------------------------------------------*/
+* void pCodeRegOptimeRegUsage(pBlock *pb)
+*-----------------------------------------------------------------*/
void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_level)
{
- regs *reg;
- int used;
- pCode *pc1=NULL, *pc2=NULL;
-
-
- while(fregs) {
- pCode *pcfl_used, *pcfl_assigned;
-
- /* Step through the set by directly accessing the 'next' pointer.
- * We could also step through by using the set API, but the
- * the (debug) calls to print instructions affect the state
- * of the set pointers */
-
- reg = fregs->item;
- fregs = fregs->next;
-/*
-if (strcmp(reg->name,"_SubState")==0)
- fprintf(stderr,"Reg: %s\n",reg->name);
-*/
-
- if(reg->type == REG_SFR || reg->type == REG_STK || reg->isPublic || reg->isExtern|| reg->isFixed) {
- //fprintf(stderr,"skipping SFR: %s\n",reg->name);
- continue;
- }
-
- pcfl_used = setFirstItem(reg->reglives.usedpFlows);
- pcfl_assigned = setFirstItem(reg->reglives.assignedpFlows);
-
- used = elementsInSet(reg->reglives.usedpCodes);
- if(used == 2) {
-
- /*
- * In this section, all registers that are used in only in two
- * instructions are examined. If possible, they're optimized out.
- */
-
-/*
- fprintf (stderr, "OptimizeRegUsage: %s addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
- reg->name,
- reg->address,
- reg->rIdx, reg->type, used);
-*/
- pc1 = setFirstItem(reg->reglives.usedpCodes);
- pc2 = setNextItem(reg->reglives.usedpCodes);
-
- if(pcfl_used && pcfl_assigned) {
-
- /*
- expected case - the register has been assigned a value and is
- subsequently used
- */
-
- //fprintf(stderr," used only twice\n");
- if(pcfl_used->seq == pcfl_assigned->seq) {
-
- //fprintf(stderr, " and used in same flow\n");
-
- pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
-
- } else {
- // fprintf(stderr, " and used in different flows\n");
-
- }
-
- } else if(pcfl_used) {
-
- /*
- register has been used twice without ever being assigned */
- fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
-
- } else {
- fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
- Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
- total_registers_saved++; // debugging stats.
- }
- } else {
-
- /* register has been used either once, or more than twice */
-
- if(used && !pcfl_used && pcfl_assigned) {
- pCode *pc;
-
- fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
-
- pc = setFirstItem(reg->reglives.usedpCodes);
- while(pc) {
-
- pcfl_assigned = PCODE(PCI(pc)->pcflow);
- Remove1pcode(pc, reg,2);
-
- deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
- /*
- deleteSetItem (&(reg->reglives.usedpCodes),pc);
- pc->destruct(pc);
- */
- pc = setNextItem(reg->reglives.usedpCodes);
- }
-
-
- reg->isFree = 1;
- reg->wasUsed = 0;
-
- total_registers_saved++; // debugging stats.
- } else if( (used > 2) && optimize_multi_uses) {
-
- set *rset1=NULL;
- set *rset2=NULL;
- int searching=1;
-
- pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
-
- /* examine the number of times this register is used */
-
-
- rset1 = reg->reglives.usedpCodes;
- while(rset1 && searching) {
-
- pc1 = rset1->item;
- rset2 = rset1->next;
-
- if(pc1 && isPCI(pc1) && ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
-
- //while(rset2 && searching) {
- if(rset2) {
-
- pc2 = rset2->item;
- if(pc2 && isPCI(pc2) && ( (pcfl2 = PCI(pc2)->pcflow) != NULL) ) {
- if(pcfl2 == pcfl1) {
-
- if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
- searching = 0;
+ regs *reg;
+ int used;
+ pCode *pc1=NULL, *pc2=NULL;
+
+
+ while(fregs) {
+ pCode *pcfl_used, *pcfl_assigned;
+
+ /* Step through the set by directly accessing the 'next' pointer.
+ * We could also step through by using the set API, but the
+ * the (debug) calls to print instructions affect the state
+ * of the set pointers */
+
+ reg = fregs->item;
+ fregs = fregs->next;
+ /*
+ if (strcmp(reg->name,"_SubState")==0)
+ fprintf(stderr,"Reg: %s\n",reg->name);
+ */
+
+ if(reg->type == REG_SFR || reg->type == REG_STK || reg->isPublic || reg->isExtern|| reg->isFixed) {
+ //fprintf(stderr,"skipping SFR: %s\n",reg->name);
+ continue;
}
- }
-
- //rset2 = rset2->next;
-
- }
- }
- rset1 = rset1->next;
- }
- }
- }
-
+
+ pcfl_used = setFirstItem(reg->reglives.usedpFlows);
+ pcfl_assigned = setFirstItem(reg->reglives.assignedpFlows);
+
+ used = elementsInSet(reg->reglives.usedpCodes);
+ if(used == 2) {
+
+ /*
+ * In this section, all registers that are used in only in two
+ * instructions are examined. If possible, they're optimized out.
+ */
+
+ /*
+ fprintf (stderr, "OptimizeRegUsage: %s addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
+ reg->name,
+ reg->address,
+ reg->rIdx, reg->type, used);
+ */
+ pc1 = setFirstItem(reg->reglives.usedpCodes);
+ pc2 = setNextItem(reg->reglives.usedpCodes);
+
+ if(pcfl_used && pcfl_assigned) {
+
+ /*
+ expected case - the register has been assigned a value and is
+ subsequently used
+ */
+
+ //fprintf(stderr," used only twice\n");
+ if(pcfl_used->seq == pcfl_assigned->seq) {
+
+ //fprintf(stderr, " and used in same flow\n");
+
+ pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
+
+ } else {
+ // fprintf(stderr, " and used in different flows\n");
+
+ }
+
+ } else if(pcfl_used) {
+
+ /* register has been used twice without ever being assigned */
+ fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
+
+ } else {
+ fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
+ Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
+ total_registers_saved++; // debugging stats.
+ }
+ } else {
+
+ /* register has been used either once, or more than twice */
+
+ if(used && !pcfl_used && pcfl_assigned) {
+ pCode *pc;
+
+ fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
+
+ pc = setFirstItem(reg->reglives.usedpCodes);
+ while(pc) {
+
+ pcfl_assigned = PCODE(PCI(pc)->pcflow);
+ Remove1pcode(pc, reg,2);
+
+ deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
+ /*
+ deleteSetItem (&(reg->reglives.usedpCodes),pc);
+ pc->destruct(pc);
+ */
+ pc = setNextItem(reg->reglives.usedpCodes);
+ }
+
+
+ reg->isFree = 1;
+ reg->wasUsed = 0;
+
+ total_registers_saved++; // debugging stats.
+ } else if( (used > 2) && optimize_multi_uses) {
+
+ set *rset1=NULL;
+ set *rset2=NULL;
+ int searching=1;
+
+ pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
+
+ /* examine the number of times this register is used */
+
+
+ rset1 = reg->reglives.usedpCodes;
+ while(rset1 && searching) {
+
+ pc1 = rset1->item;
+ rset2 = rset1->next;
+
+ if(pc1 && isPCI(pc1) && ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
+
+ //while(rset2 && searching) {
+ if(rset2) {
+
+ pc2 = rset2->item;
+ if(pc2 && isPCI(pc2) && ( (pcfl2 = PCI(pc2)->pcflow) != NULL) ) {
+ if(pcfl2 == pcfl1) {
+
+ if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
+ searching = 0;
+ }
+ }
+
+ //rset2 = rset2->next;
+
+ }
+ }
+ rset1 = rset1->next;
+ }
+ }
+ }
+
}
}
/*-----------------------------------------------------------------*
- * void pCodeRegOptimeRegUsage(pBlock *pb)
- *-----------------------------------------------------------------*/
+* void pCodeRegOptimeRegUsage(pBlock *pb)
+*-----------------------------------------------------------------*/
void pCodeRegOptimizeRegUsage(int level)
{
-
- int passes;
- int saved = 0;
- int t = total_registers_saved;
-
- if(!register_optimization)
- return;
+
+ int passes;
+ int saved = 0;
+ int t = total_registers_saved;
+
+ if(!register_optimization)
+ return;
#define OPT_PASSES 4
- passes = OPT_PASSES;
-
- do {
- saved = total_registers_saved;
+ passes = OPT_PASSES;
+
+ do {
+ saved = total_registers_saved;
+
+ /* Identify registers used in one flow sequence */
+ OptimizeRegUsage(dynAllocRegs,level, (OPT_PASSES-passes));
+ OptimizeRegUsage(dynStackRegs,level, (OPT_PASSES-passes));
+ OptimizeRegUsage(dynDirectRegs,0, (OPT_PASSES-passes));
+
+ if(total_registers_saved != saved)
+ DFPRINTF((stderr, " *** pass %d, Saved %d registers, total saved %d ***\n",
+ (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved));
+
+ passes--;
+
+ } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
+
+ if(total_registers_saved == t)
+ DFPRINTF((stderr, "No registers saved on this pass\n"));
- /* Identify registers used in one flow sequence */
- OptimizeRegUsage(dynAllocRegs,level, (OPT_PASSES-passes));
- OptimizeRegUsage(dynStackRegs,level, (OPT_PASSES-passes));
- OptimizeRegUsage(dynDirectRegs,0, (OPT_PASSES-passes));
- if(total_registers_saved != saved)
- DFPRINTF((stderr, " *** pass %d, Saved %d registers, total saved %d ***\n",
- (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved));
-
- passes--;
-
- } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
-
- if(total_registers_saved == t)
- DFPRINTF((stderr, "No registers saved on this pass\n"));
-
-
-/*
- fprintf(stderr,"dynamically allocated regs:\n");
- dbg_regusage(dynAllocRegs);
- fprintf(stderr,"stack regs:\n");
- dbg_regusage(dynStackRegs);
- fprintf(stderr,"direct regs:\n");
- dbg_regusage(dynDirectRegs);
-*/
+ /*
+ fprintf(stderr,"dynamically allocated regs:\n");
+ dbg_regusage(dynAllocRegs);
+ fprintf(stderr,"stack regs:\n");
+ dbg_regusage(dynStackRegs);
+ fprintf(stderr,"direct regs:\n");
+ dbg_regusage(dynDirectRegs);
+ */
}
/*-----------------------------------------------------------------*
- * void RegsUnMapLiveRanges(set *regset)
- *
- *-----------------------------------------------------------------*/
+* void RegsUnMapLiveRanges(set *regset)
+*
+*-----------------------------------------------------------------*/
void RegsSetUnMapLiveRanges(set *regset)
{
- regs *reg;
-
- while(regset) {
- reg = regset->item;
- regset = regset->next;
-
-
- deleteSet(®->reglives.usedpCodes);
- deleteSet(®->reglives.usedpFlows);
- deleteSet(®->reglives.assignedpFlows);
-
- }
-
+ regs *reg;
+
+ while(regset) {
+ reg = regset->item;
+ regset = regset->next;
+
+
+ deleteSet(®->reglives.usedpCodes);
+ deleteSet(®->reglives.usedpFlows);
+ deleteSet(®->reglives.assignedpFlows);
+
+ }
+
}
void RegsUnMapLiveRanges(void)
{
-
- RegsSetUnMapLiveRanges(dynAllocRegs);
- RegsSetUnMapLiveRanges(dynStackRegs);
- RegsSetUnMapLiveRanges(dynDirectRegs);
- RegsSetUnMapLiveRanges(dynProcessorRegs);
- RegsSetUnMapLiveRanges(dynDirectBitRegs);
- RegsSetUnMapLiveRanges(dynInternalRegs);
-
+
+ RegsSetUnMapLiveRanges(dynAllocRegs);
+ RegsSetUnMapLiveRanges(dynStackRegs);
+ RegsSetUnMapLiveRanges(dynDirectRegs);
+ RegsSetUnMapLiveRanges(dynProcessorRegs);
+ RegsSetUnMapLiveRanges(dynDirectBitRegs);
+ RegsSetUnMapLiveRanges(dynInternalRegs);
+
}
**************************************************/
typedef struct pCodeRegLives {
- set *usedpFlows; /* set of pFlow objects that use this register */
- set *assignedpFlows; /* set of pFlow objects that assign values to this register */
- set *usedpCodes; /* set of all instructions that use this register */
+ set *usedpFlows; /* set of pFlow objects that use this register */
+ set *assignedpFlows; /* set of pFlow objects that assign values to this register */
+ set *usedpCodes; /* set of all instructions that use this register */
} pCodeRegLives;
/*------------------------------------------------------------------------
SDCCralloc.c - source file for register allocation. (8051) specific
-
- Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
- Added Pic Port T.scott Dattalo scott@dattalo.com (2000)
-
- This program is free software; you can redistribute it and/or modify it
- 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!
+
+ Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
+ Added Pic Port T.scott Dattalo scott@dattalo.com (2000)
+
+ This program is free software; you can redistribute it and/or modify it
+ 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!
-------------------------------------------------------------------------*/
#include "common.h"
/* Global data */
static struct
- {
- bitVect *spiltSet;
- set *stackSpil;
- bitVect *regAssigned;
- short blockSpil;
- int slocNum;
- bitVect *funcrUsed; /* registers used in a function */
- int stackExtend;
- int dataExtend;
- }
+{
+ bitVect *spiltSet;
+ set *stackSpil;
+ bitVect *regAssigned;
+ short blockSpil;
+ int slocNum;
+ bitVect *funcrUsed; /* registers used in a function */
+ int stackExtend;
+ int dataExtend;
+}
_G;
/* Shared with gen.c */
int pic14_nRegs = 128; // = sizeof (regspic14) / sizeof (regs);
int Gstack_base_addr=0; /* The starting address of registers that
- * are used to pass and return parameters */
+* are used to pass and return parameters */
/*-----------------------------------------------------------------*/
//static void debugLog(char *inst,char *fmt, ...)
static void
-debugLog (char *fmt,...)
+ debugLog (char *fmt,...)
{
- static int append = 0; // First time through, open the file without append.
-
- char buffer[256];
- //char *bufferP=buffer;
- va_list ap;
+ static int append = 0; // First time through, open the file without append.
- if (!debug || !dstFileName)
- return;
+ char buffer[256];
+ //char *bufferP=buffer;
+ va_list ap;
+ if (!debug || !dstFileName)
+ return;
- if (!debugF)
- {
- /* create the file name */
- strcpy (buffer, dstFileName);
- strcat (buffer, ".d");
- if (!(debugF = fopen (buffer, (append ? "a+" : "w"))))
+ if (!debugF)
{
- werror (E_FILE_OPEN_ERR, buffer);
- exit (1);
- }
- append = 1; // Next time debubLog is called, we'll append the debug info
+ /* create the file name */
+ strcpy (buffer, dstFileName);
+ strcat (buffer, ".d");
+
+ if (!(debugF = fopen (buffer, (append ? "a+" : "w"))))
+ {
+ werror (E_FILE_OPEN_ERR, buffer);
+ exit (1);
+ }
+ append = 1; // Next time debubLog is called, we'll append the debug info
- }
+ }
- va_start (ap, fmt);
+ va_start (ap, fmt);
- vsprintf (buffer, fmt, ap);
+ vsprintf (buffer, fmt, ap);
- fprintf (debugF, "%s", buffer);
-/*
- while (isspace(*bufferP)) bufferP++;
+ fprintf (debugF, "%s", buffer);
+ /*
+ while (isspace(*bufferP)) bufferP++;
- if (bufferP && *bufferP)
- lineCurr = (lineCurr ?
- connectLine(lineCurr,newLineNode(lb)) :
- (lineHead = newLineNode(lb)));
- lineCurr->isInline = _G.inLine;
- lineCurr->isDebug = _G.debugLine;
- */
- va_end (ap);
+ if (bufferP && *bufferP)
+ lineCurr = (lineCurr ?
+ connectLine(lineCurr,newLineNode(lb)) :
+ (lineHead = newLineNode(lb)));
+ lineCurr->isInline = _G.inLine;
+ lineCurr->isDebug = _G.debugLine;
+ */
+ va_end (ap);
}
-
+
static void
-debugNewLine (void)
+ debugNewLine (void)
{
- if (debugF)
- fputc ('\n', debugF);
+ if (debugF)
+ fputc ('\n', debugF);
}
-/*-----------------------------------------------------------------*/
-/* debugLogClose - closes the debug log file (if opened) */
-/*-----------------------------------------------------------------*/
+ /*-----------------------------------------------------------------*/
+ /* debugLogClose - closes the debug log file (if opened) */
+ /*-----------------------------------------------------------------*/
static void
-debugLogClose (void)
+ debugLogClose (void)
{
- if (debugF)
- {
- fclose (debugF);
- debugF = NULL;
- }
+ if (debugF)
+ {
+ fclose (debugF);
+ debugF = NULL;
+ }
}
#define AOP(op) op->aop
-
+
static char *
-debugAopGet (char *str, operand * op)
+ debugAopGet (char *str, operand * op)
{
- if (str)
- debugLog (str);
+ if (str)
+ debugLog (str);
- printOperand (op, debugF);
- debugNewLine ();
+ printOperand (op, debugF);
+ debugNewLine ();
- return NULL;
+ return NULL;
}
static char *
-decodeOp (unsigned int op)
+ decodeOp (unsigned int op)
{
- if (op < 128 && op > ' ')
- {
- buffer[0] = (op & 0xff);
- buffer[1] = 0;
- return buffer;
- }
+ if (op < 128 && op > ' ')
+ {
+ buffer[0] = (op & 0xff);
+ buffer[1] = 0;
+ return buffer;
+ }
- switch (op)
- {
- case IDENTIFIER:
- return "IDENTIFIER";
- case TYPE_NAME:
- return "TYPE_NAME";
- case CONSTANT:
- return "CONSTANT";
- case STRING_LITERAL:
- return "STRING_LITERAL";
- case SIZEOF:
- return "SIZEOF";
- case PTR_OP:
- return "PTR_OP";
- case INC_OP:
- return "INC_OP";
- case DEC_OP:
- return "DEC_OP";
- case LEFT_OP:
- return "LEFT_OP";
- case RIGHT_OP:
- return "RIGHT_OP";
- case LE_OP:
- return "LE_OP";
- case GE_OP:
- return "GE_OP";
- case EQ_OP:
- return "EQ_OP";
- case NE_OP:
- return "NE_OP";
- case AND_OP:
- return "AND_OP";
- case OR_OP:
- return "OR_OP";
- case MUL_ASSIGN:
- return "MUL_ASSIGN";
- case DIV_ASSIGN:
- return "DIV_ASSIGN";
- case MOD_ASSIGN:
- return "MOD_ASSIGN";
- case ADD_ASSIGN:
- return "ADD_ASSIGN";
- case SUB_ASSIGN:
- return "SUB_ASSIGN";
- case LEFT_ASSIGN:
- return "LEFT_ASSIGN";
- case RIGHT_ASSIGN:
- return "RIGHT_ASSIGN";
- case AND_ASSIGN:
- return "AND_ASSIGN";
- case XOR_ASSIGN:
- return "XOR_ASSIGN";
- case OR_ASSIGN:
- return "OR_ASSIGN";
- case TYPEDEF:
- return "TYPEDEF";
- case EXTERN:
- return "EXTERN";
- case STATIC:
- return "STATIC";
- case AUTO:
- return "AUTO";
- case REGISTER:
- return "REGISTER";
- case CODE:
- return "CODE";
- case EEPROM:
- return "EEPROM";
- case INTERRUPT:
- return "INTERRUPT";
- case SFR:
- return "SFR";
- case AT:
- return "AT";
- case SBIT:
- return "SBIT";
- case REENTRANT:
- return "REENTRANT";
- case USING:
- return "USING";
- case XDATA:
- return "XDATA";
- case DATA:
- return "DATA";
- case IDATA:
- return "IDATA";
- case PDATA:
- return "PDATA";
- case VAR_ARGS:
- return "VAR_ARGS";
- case CRITICAL:
- return "CRITICAL";
- case NONBANKED:
- return "NONBANKED";
- case BANKED:
- return "BANKED";
- case CHAR:
- return "CHAR";
- case SHORT:
- return "SHORT";
- case INT:
- return "INT";
- case LONG:
- return "LONG";
- case SIGNED:
- return "SIGNED";
- case UNSIGNED:
- return "UNSIGNED";
- case FLOAT:
- return "FLOAT";
- case DOUBLE:
- return "DOUBLE";
- case CONST:
- return "CONST";
- case VOLATILE:
- return "VOLATILE";
- case VOID:
- return "VOID";
- case BIT:
- return "BIT";
- case STRUCT:
- return "STRUCT";
- case UNION:
- return "UNION";
- case ENUM:
- return "ENUM";
- case ELIPSIS:
- return "ELIPSIS";
- case RANGE:
- return "RANGE";
- case FAR:
- return "FAR";
- case CASE:
- return "CASE";
- case DEFAULT:
- return "DEFAULT";
- case IF:
- return "IF";
- case ELSE:
- return "ELSE";
- case SWITCH:
- return "SWITCH";
- case WHILE:
- return "WHILE";
- case DO:
- return "DO";
- case FOR:
- return "FOR";
- case GOTO:
- return "GOTO";
- case CONTINUE:
- return "CONTINUE";
- case BREAK:
- return "BREAK";
- case RETURN:
- return "RETURN";
- case INLINEASM:
- return "INLINEASM";
- case IFX:
- return "IFX";
- case ADDRESS_OF:
- return "ADDRESS_OF";
- case GET_VALUE_AT_ADDRESS:
- return "GET_VALUE_AT_ADDRESS";
- case SPIL:
- return "SPIL";
- case UNSPIL:
- return "UNSPIL";
- case GETHBIT:
- return "GETHBIT";
- case BITWISEAND:
- return "BITWISEAND";
- case UNARYMINUS:
- return "UNARYMINUS";
- case IPUSH:
- return "IPUSH";
- case IPOP:
- return "IPOP";
- case PCALL:
- return "PCALL";
- case ENDFUNCTION:
- return "ENDFUNCTION";
- case JUMPTABLE:
- return "JUMPTABLE";
- case RRC:
- return "RRC";
- case RLC:
- return "RLC";
- case CAST:
- return "CAST";
- case CALL:
- return "CALL";
- case PARAM:
- return "PARAM ";
- case NULLOP:
- return "NULLOP";
- case BLOCK:
- return "BLOCK";
- case LABEL:
- return "LABEL";
- case RECEIVE:
- return "RECEIVE";
- case SEND:
- return "SEND";
- }
- sprintf (buffer, "unknown op %d %c", op, op & 0xff);
- return buffer;
+ switch (op)
+ {
+ case IDENTIFIER:
+ return "IDENTIFIER";
+ case TYPE_NAME:
+ return "TYPE_NAME";
+ case CONSTANT:
+ return "CONSTANT";
+ case STRING_LITERAL:
+ return "STRING_LITERAL";
+ case SIZEOF:
+ return "SIZEOF";
+ case PTR_OP:
+ return "PTR_OP";
+ case INC_OP:
+ return "INC_OP";
+ case DEC_OP:
+ return "DEC_OP";
+ case LEFT_OP:
+ return "LEFT_OP";
+ case RIGHT_OP:
+ return "RIGHT_OP";
+ case LE_OP:
+ return "LE_OP";
+ case GE_OP:
+ return "GE_OP";
+ case EQ_OP:
+ return "EQ_OP";
+ case NE_OP:
+ return "NE_OP";
+ case AND_OP:
+ return "AND_OP";
+ case OR_OP:
+ return "OR_OP";
+ case MUL_ASSIGN:
+ return "MUL_ASSIGN";
+ case DIV_ASSIGN:
+ return "DIV_ASSIGN";
+ case MOD_ASSIGN:
+ return "MOD_ASSIGN";
+ case ADD_ASSIGN:
+ return "ADD_ASSIGN";
+ case SUB_ASSIGN:
+ return "SUB_ASSIGN";
+ case LEFT_ASSIGN:
+ return "LEFT_ASSIGN";
+ case RIGHT_ASSIGN:
+ return "RIGHT_ASSIGN";
+ case AND_ASSIGN:
+ return "AND_ASSIGN";
+ case XOR_ASSIGN:
+ return "XOR_ASSIGN";
+ case OR_ASSIGN:
+ return "OR_ASSIGN";
+ case TYPEDEF:
+ return "TYPEDEF";
+ case EXTERN:
+ return "EXTERN";
+ case STATIC:
+ return "STATIC";
+ case AUTO:
+ return "AUTO";
+ case REGISTER:
+ return "REGISTER";
+ case CODE:
+ return "CODE";
+ case EEPROM:
+ return "EEPROM";
+ case INTERRUPT:
+ return "INTERRUPT";
+ case SFR:
+ return "SFR";
+ case AT:
+ return "AT";
+ case SBIT:
+ return "SBIT";
+ case REENTRANT:
+ return "REENTRANT";
+ case USING:
+ return "USING";
+ case XDATA:
+ return "XDATA";
+ case DATA:
+ return "DATA";
+ case IDATA:
+ return "IDATA";
+ case PDATA:
+ return "PDATA";
+ case VAR_ARGS:
+ return "VAR_ARGS";
+ case CRITICAL:
+ return "CRITICAL";
+ case NONBANKED:
+ return "NONBANKED";
+ case BANKED:
+ return "BANKED";
+ case CHAR:
+ return "CHAR";
+ case SHORT:
+ return "SHORT";
+ case INT:
+ return "INT";
+ case LONG:
+ return "LONG";
+ case SIGNED:
+ return "SIGNED";
+ case UNSIGNED:
+ return "UNSIGNED";
+ case FLOAT:
+ return "FLOAT";
+ case DOUBLE:
+ return "DOUBLE";
+ case CONST:
+ return "CONST";
+ case VOLATILE:
+ return "VOLATILE";
+ case VOID:
+ return "VOID";
+ case BIT:
+ return "BIT";
+ case STRUCT:
+ return "STRUCT";
+ case UNION:
+ return "UNION";
+ case ENUM:
+ return "ENUM";
+ case ELIPSIS:
+ return "ELIPSIS";
+ case RANGE:
+ return "RANGE";
+ case FAR:
+ return "FAR";
+ case CASE:
+ return "CASE";
+ case DEFAULT:
+ return "DEFAULT";
+ case IF:
+ return "IF";
+ case ELSE:
+ return "ELSE";
+ case SWITCH:
+ return "SWITCH";
+ case WHILE:
+ return "WHILE";
+ case DO:
+ return "DO";
+ case FOR:
+ return "FOR";
+ case GOTO:
+ return "GOTO";
+ case CONTINUE:
+ return "CONTINUE";
+ case BREAK:
+ return "BREAK";
+ case RETURN:
+ return "RETURN";
+ case INLINEASM:
+ return "INLINEASM";
+ case IFX:
+ return "IFX";
+ case ADDRESS_OF:
+ return "ADDRESS_OF";
+ case GET_VALUE_AT_ADDRESS:
+ return "GET_VALUE_AT_ADDRESS";
+ case SPIL:
+ return "SPIL";
+ case UNSPIL:
+ return "UNSPIL";
+ case GETHBIT:
+ return "GETHBIT";
+ case BITWISEAND:
+ return "BITWISEAND";
+ case UNARYMINUS:
+ return "UNARYMINUS";
+ case IPUSH:
+ return "IPUSH";
+ case IPOP:
+ return "IPOP";
+ case PCALL:
+ return "PCALL";
+ case ENDFUNCTION:
+ return "ENDFUNCTION";
+ case JUMPTABLE:
+ return "JUMPTABLE";
+ case RRC:
+ return "RRC";
+ case RLC:
+ return "RLC";
+ case CAST:
+ return "CAST";
+ case CALL:
+ return "CALL";
+ case PARAM:
+ return "PARAM ";
+ case NULLOP:
+ return "NULLOP";
+ case BLOCK:
+ return "BLOCK";
+ case LABEL:
+ return "LABEL";
+ case RECEIVE:
+ return "RECEIVE";
+ case SEND:
+ return "SEND";
+ }
+ sprintf (buffer, "unknown op %d %c", op, op & 0xff);
+ return buffer;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static char *
debugLogRegType (short type)
{
-
- switch (type)
- {
- case REG_GPR:
- return "REG_GPR";
- case REG_PTR:
- return "REG_PTR";
- case REG_CND:
- return "REG_CND";
- }
-
- sprintf (buffer, "unknown reg type %d", type);
- return buffer;
+
+ switch (type)
+ {
+ case REG_GPR:
+ return "REG_GPR";
+ case REG_PTR:
+ return "REG_PTR";
+ case REG_CND:
+ return "REG_CND";
+ }
+
+ sprintf (buffer, "unknown reg type %d", type);
+ return buffer;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static int regname2key(char const *name)
{
- int key = 0;
-
- if(!name)
- return 0;
-
- while(*name) {
-
- key += (*name++) + 1;
-
- }
-
- return ( (key + (key >> 4) + (key>>8)) & 0x3f);
-
+ int key = 0;
+
+ if(!name)
+ return 0;
+
+ while(*name) {
+
+ key += (*name++) + 1;
+
+ }
+
+ return ( (key + (key >> 4) + (key>>8)) & 0x3f);
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alias)
{
-
- regs *dReg;
-
- dReg = Safe_calloc(1,sizeof(regs));
- dReg->type = type;
- dReg->pc_type = pc_type;
- dReg->rIdx = rIdx;
- if(name) {
- dReg->name = Safe_strdup(name);
- } else {
- sprintf(buffer,"r0x%02X", dReg->rIdx);
- dReg->name = Safe_strdup(buffer);
- }
- //fprintf(stderr,"newReg: %s, rIdx = 0x%02x\n",dReg->name,rIdx);
- dReg->isFree = 0;
- dReg->wasUsed = 1;
- if (type == REG_SFR)
- dReg->isFixed = 1;
- else
- dReg->isFixed = 0;
-
- dReg->isMapped = 0;
- dReg->isEmitted = 0;
- dReg->isPublic = 0;
- dReg->isExtern = 0;
- dReg->address = 0;
- dReg->size = size;
- dReg->alias = alias;
- dReg->reg_alias = NULL;
- dReg->reglives.usedpFlows = newSet();
- dReg->reglives.assignedpFlows = newSet();
-
- hTabAddItem(&dynDirectRegNames, regname2key(name), dReg);
-
- return dReg;
+
+ regs *dReg;
+
+ dReg = Safe_calloc(1,sizeof(regs));
+ dReg->type = type;
+ dReg->pc_type = pc_type;
+ dReg->rIdx = rIdx;
+ if(name) {
+ dReg->name = Safe_strdup(name);
+ } else {
+ sprintf(buffer,"r0x%02X", dReg->rIdx);
+ dReg->name = Safe_strdup(buffer);
+ }
+ //fprintf(stderr,"newReg: %s, rIdx = 0x%02x\n",dReg->name,rIdx);
+ dReg->isFree = 0;
+ dReg->wasUsed = 1;
+ if (type == REG_SFR)
+ dReg->isFixed = 1;
+ else
+ dReg->isFixed = 0;
+
+ dReg->isMapped = 0;
+ dReg->isEmitted = 0;
+ dReg->isPublic = 0;
+ dReg->isExtern = 0;
+ dReg->address = 0;
+ dReg->size = size;
+ dReg->alias = alias;
+ dReg->reg_alias = NULL;
+ dReg->reglives.usedpFlows = newSet();
+ dReg->reglives.assignedpFlows = newSet();
+
+ hTabAddItem(&dynDirectRegNames, regname2key(name), dReg);
+
+ return dReg;
}
/*-----------------------------------------------------------------*/
static regs *
regWithIdx (set *dRegs, int idx, int fixed)
{
- regs *dReg;
-
- for (dReg = setFirstItem(dRegs) ; dReg ;
- dReg = setNextItem(dRegs)) {
-
- if(idx == dReg->rIdx && (fixed == (int)dReg->isFixed)) {
- return dReg;
- }
- }
-
- return NULL;
+ regs *dReg;
+
+ for (dReg = setFirstItem(dRegs) ; dReg ;
+ dReg = setNextItem(dRegs)) {
+
+ if(idx == dReg->rIdx && (fixed == (int)dReg->isFixed)) {
+ return dReg;
+ }
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
static regs *
regWithName (set *dRegs, const char *name)
{
- regs *dReg;
-
- for (dReg = setFirstItem(dRegs) ; dReg ;
- dReg = setNextItem(dRegs)) {
-
- if((strcmp(name,dReg->name)==0)) {
- return dReg;
- }
- }
-
- return NULL;
+ regs *dReg;
+
+ for (dReg = setFirstItem(dRegs) ; dReg ;
+ dReg = setNextItem(dRegs)) {
+
+ if((strcmp(name,dReg->name)==0)) {
+ return dReg;
+ }
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
regs *
regFindWithName (const char *name)
{
- regs *dReg;
-
- if( (dReg = regWithName ( dynDirectRegs, name)) != NULL ) {
- debugLog ("Found a Direct Register!\n");
- return dReg;
- }
- if( (dReg = regWithName ( dynDirectBitRegs, name)) != NULL) {
- debugLog ("Found a Direct Bit Register!\n");
- return dReg;
- }
-
+ regs *dReg;
+
+ if( (dReg = regWithName ( dynDirectRegs, name)) != NULL ) {
+ debugLog ("Found a Direct Register!\n");
+ return dReg;
+ }
+ if( (dReg = regWithName ( dynDirectBitRegs, name)) != NULL) {
+ debugLog ("Found a Direct Bit Register!\n");
+ return dReg;
+ }
+
if (*name=='_') name++; // Step passed '_'
-
- if( (dReg = regWithName ( dynAllocRegs, name)) != NULL) {
- debugLog ("Found a Dynamic Register!\n");
- return dReg;
- }
- if( (dReg = regWithName ( dynProcessorRegs, name)) != NULL) {
- debugLog ("Found a Processor Register!\n");
- return dReg;
- }
- if( (dReg = regWithName ( dynInternalRegs, name)) != NULL) {
- debugLog ("Found an Internal Register!\n");
- return dReg;
- }
- if( (dReg = regWithName ( dynStackRegs, name)) != NULL) {
- debugLog ("Found an Stack Register!\n");
- return dReg;
- }
-
- return NULL;
+
+ if( (dReg = regWithName ( dynAllocRegs, name)) != NULL) {
+ debugLog ("Found a Dynamic Register!\n");
+ return dReg;
+ }
+ if( (dReg = regWithName ( dynProcessorRegs, name)) != NULL) {
+ debugLog ("Found a Processor Register!\n");
+ return dReg;
+ }
+ if( (dReg = regWithName ( dynInternalRegs, name)) != NULL) {
+ debugLog ("Found an Internal Register!\n");
+ return dReg;
+ }
+ if( (dReg = regWithName ( dynStackRegs, name)) != NULL) {
+ debugLog ("Found an Stack Register!\n");
+ return dReg;
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
static regs *
regFindFree (set *dRegs)
{
- regs *dReg;
-
- for (dReg = setFirstItem(dRegs) ; dReg ;
- dReg = setNextItem(dRegs)) {
-
- if(dReg->isFree)
- return dReg;
- }
-
- return NULL;
+ regs *dReg;
+
+ for (dReg = setFirstItem(dRegs) ; dReg ;
+ dReg = setNextItem(dRegs)) {
+
+ if(dReg->isFree)
+ return dReg;
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/* initStack - allocate registers for a psuedo stack */
/*-----------------------------------------------------------------*/
void initStack(int base_address, int size)
{
-
- int i;
-
- Gstack_base_addr = base_address;
- //fprintf(stderr,"initStack");
-
- for(i = 0; i<size; i++) {
- regs *r = newReg(REG_STK, PO_GPR_TEMP,base_address,NULL,1,0);
- r->address = base_address; // Pseudo stack needs a fixed location that can be known by all modules
- r->isFixed = 1;
- r->name[0] = 's';
- r->alias = 0x180; // Using shared memory for pseudo stack
- addSet(&dynStackRegs,r);
- base_address--;
- }
+
+ int i;
+
+ Gstack_base_addr = base_address;
+ //fprintf(stderr,"initStack");
+
+ for(i = 0; i<size; i++) {
+ regs *r = newReg(REG_STK, PO_GPR_TEMP,base_address,NULL,1,0);
+ r->address = base_address; // Pseudo stack needs a fixed location that can be known by all modules
+ r->isFixed = 1;
+ r->name[0] = 's';
+ r->alias = 0x180; // Using shared memory for pseudo stack
+ addSet(&dynStackRegs,r);
+ base_address--;
+ }
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
regs *
allocProcessorRegister(int rIdx, char * name, short po_type, int alias)
{
-
- //fprintf(stderr,"allocProcessorRegister %s addr =0x%x\n",name,rIdx);
- return addSet(&dynProcessorRegs,newReg(REG_SFR, po_type, rIdx, name,1,alias));
+
+ //fprintf(stderr,"allocProcessorRegister %s addr =0x%x\n",name,rIdx);
+ return addSet(&dynProcessorRegs,newReg(REG_SFR, po_type, rIdx, name,1,alias));
}
/*-----------------------------------------------------------------*
- *-----------------------------------------------------------------*/
+*-----------------------------------------------------------------*/
regs *
allocInternalRegister(int rIdx, char * name, short po_type, int alias)
{
- regs * reg = newReg(REG_GPR, po_type, rIdx, name,1,alias);
-
- //fprintf(stderr,"allocInternalRegister %s addr =0x%x\n",name,rIdx);
- if(reg) {
- reg->wasUsed = 0;
- return addSet(&dynInternalRegs,reg);
- }
-
- return NULL;
+ regs * reg = newReg(REG_GPR, po_type, rIdx, name,1,alias);
+
+ //fprintf(stderr,"allocInternalRegister %s addr =0x%x\n",name,rIdx);
+ if(reg) {
+ reg->wasUsed = 0;
+ return addSet(&dynInternalRegs,reg);
+ }
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
/* allocReg - allocates register of given type */
static regs *
allocReg (short type)
{
-
- debugLog ("%s of type %s\n", __FUNCTION__, debugLogRegType (type));
- //fprintf(stderr,"allocReg\n");
-
-
- return addSet(&dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0));
-
+
+ debugLog ("%s of type %s\n", __FUNCTION__, debugLogRegType (type));
+ //fprintf(stderr,"allocReg\n");
+
+
+ return addSet(&dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0));
+
}
regs *
dirregWithName (char *name)
{
- int hkey;
- regs *reg;
-
- if(!name)
- return NULL;
-
- /* hash the name to get a key */
-
- hkey = regname2key(name);
-
- reg = hTabFirstItemWK(dynDirectRegNames, hkey);
-
- while(reg) {
-
- if(STRCASECMP(reg->name, name) == 0) {
- return(reg);
- }
-
- reg = hTabNextItemWK (dynDirectRegNames);
-
- }
-
- return NULL; // name wasn't found in the hash table
+ int hkey;
+ regs *reg;
+
+ if(!name)
+ return NULL;
+
+ /* hash the name to get a key */
+
+ hkey = regname2key(name);
+
+ reg = hTabFirstItemWK(dynDirectRegNames, hkey);
+
+ while(reg) {
+
+ if(STRCASECMP(reg->name, name) == 0) {
+ return(reg);
+ }
+
+ reg = hTabNextItemWK (dynDirectRegNames);
+
+ }
+
+ return NULL; // name wasn't found in the hash table
}
int IS_CONFIG_ADDRESS(int address)
{
-
- return address == 0x2007;
+
+ return address == 0x2007;
}
/*-----------------------------------------------------------------*/
regs *
allocNewDirReg (sym_link *symlnk,const char *name)
{
- regs *reg;
- int address = 0;
-
- /* if this is at an absolute address, then get the address. */
- if (SPEC_ABSA (symlnk) ) {
- address = SPEC_ADDR (symlnk);
- //fprintf(stderr,"reg %s is at an absolute address: 0x%03x\n",name,address);
- }
-
- /* Register wasn't found in hash, so let's create
- * a new one and put it in the hash table AND in the
- * dynDirectRegNames set */
- if (IS_CONFIG_ADDRESS(address)) {
- debugLog (" -- %s is declared at address 0x2007\n",name);
- reg = 0;
- } else {
- int idx;
- if (address) {
- if (IS_BITVAR (symlnk))
- idx = address >> 3;
- else
- idx = address;
- } else {
- idx = rDirectIdx++;
- }
- reg = newReg(REG_GPR, PO_DIR, idx, (char*)name,getSize (symlnk),0 );
- debugLog (" -- added %s to hash, size = %d\n", (char*)name,reg->size);
-
- if (SPEC_ABSA (symlnk) ) {
- reg->type = REG_SFR;
- }
-
- if (IS_BITVAR (symlnk)) {
- addSet(&dynDirectBitRegs, reg);
- reg->isBitField = 1;
- } else
- addSet(&dynDirectRegs, reg);
-
- if (!IS_STATIC (symlnk)) {
- reg->isPublic = 1;
- }
- if (IS_EXTERN (symlnk)) {
- reg->isExtern = 1;
- }
-
- }
-
- if (address && reg) {
- reg->isFixed = 1;
- reg->address = address;
- debugLog (" -- and it is at a fixed address 0x%02x\n",reg->address);
- }
-
- return reg;
+ regs *reg;
+ int address = 0;
+
+ /* if this is at an absolute address, then get the address. */
+ if (SPEC_ABSA (symlnk) ) {
+ address = SPEC_ADDR (symlnk);
+ //fprintf(stderr,"reg %s is at an absolute address: 0x%03x\n",name,address);
+ }
+
+ /* Register wasn't found in hash, so let's create
+ * a new one and put it in the hash table AND in the
+ * dynDirectRegNames set */
+ if (IS_CONFIG_ADDRESS(address)) {
+ debugLog (" -- %s is declared at address 0x2007\n",name);
+ reg = 0;
+ } else {
+ int idx;
+ if (address) {
+ if (IS_BITVAR (symlnk))
+ idx = address >> 3;
+ else
+ idx = address;
+ } else {
+ idx = rDirectIdx++;
+ }
+ reg = newReg(REG_GPR, PO_DIR, idx, (char*)name,getSize (symlnk),0 );
+ debugLog (" -- added %s to hash, size = %d\n", (char*)name,reg->size);
+
+ if (SPEC_ABSA (symlnk) ) {
+ reg->type = REG_SFR;
+ }
+
+ if (IS_BITVAR (symlnk)) {
+ addSet(&dynDirectBitRegs, reg);
+ reg->isBitField = 1;
+ } else
+ addSet(&dynDirectRegs, reg);
+
+ if (!IS_STATIC (symlnk)) {
+ reg->isPublic = 1;
+ }
+ if (IS_EXTERN (symlnk)) {
+ reg->isExtern = 1;
+ }
+
+ }
+
+ if (address && reg) {
+ reg->isFixed = 1;
+ reg->address = address;
+ debugLog (" -- and it is at a fixed address 0x%02x\n",reg->address);
+ }
+
+ return reg;
}
/*-----------------------------------------------------------------*/
regs *
allocDirReg (operand *op )
{
-
- regs *reg;
- char *name;
-
- if(!IS_SYMOP(op)) {
- debugLog ("%s BAD, op is NULL\n", __FUNCTION__);
- return NULL;
- }
-
- name = OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name;
-
- /* If the symbol is at a fixed address, then remove the leading underscore
- * from the name. This is hack to allow the .asm include file named registers
- * to match the .c declared register names */
-
- //if (SPEC_ABSA ( OP_SYM_ETYPE(op)) && (*name == '_'))
- //name++;
-
- debugLog ("%s symbol name %s\n", __FUNCTION__,name);
- {
- if(SPEC_CONST ( OP_SYM_ETYPE(op)) && (IS_CHAR ( OP_SYM_ETYPE(op)) )) {
- debugLog(" %d const char\n",__LINE__);
- debugLog(" value = %s \n",SPEC_CVAL( OP_SYM_ETYPE(op)));
- }
-
- debugLog(" %d storage class %d \n",__LINE__,SPEC_SCLS( OP_SYM_ETYPE(op)));
- if (IS_CODE ( OP_SYM_ETYPE(op)) )
- debugLog(" %d code space\n",__LINE__);
-
- if (IS_INTEGRAL ( OP_SYM_ETYPE(op)) )
- debugLog(" %d integral\n",__LINE__);
- if (IS_LITERAL ( OP_SYM_ETYPE(op)) )
- debugLog(" %d literal\n",__LINE__);
- if (IS_SPEC ( OP_SYM_ETYPE(op)) )
- debugLog(" %d specifier\n",__LINE__);
- debugAopGet(NULL, op);
- }
-
- if (IS_CODE ( OP_SYM_ETYPE(op)) )
- return NULL;
-
- /* First, search the hash table to see if there is a register with this name */
- if (SPEC_ABSA ( OP_SYM_ETYPE(op)) && !(IS_BITVAR (OP_SYM_ETYPE(op))) ) {
- reg = regWithIdx (dynProcessorRegs, SPEC_ADDR ( OP_SYM_ETYPE(op)), 1);
-/*
- if(!reg)
- fprintf(stderr,"ralloc %s is at fixed address but not a processor reg, addr=0x%x\n",
- name, SPEC_ADDR ( OP_SYM_ETYPE(op)));
- else
- fprintf(stderr,"ralloc %s at fixed address has already been declared, addr=0x%x\n",
- name, SPEC_ADDR ( OP_SYM_ETYPE(op)));
-*/
- } else {
- //fprintf(stderr,"ralloc:%d %s \n", __LINE__,name);
-
- reg = dirregWithName(name);
- }
-
+
+ regs *reg;
+ char *name;
+
+ if(!IS_SYMOP(op)) {
+ debugLog ("%s BAD, op is NULL\n", __FUNCTION__);
+ return NULL;
+ }
+
+ name = OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name;
+
+ /* If the symbol is at a fixed address, then remove the leading underscore
+ * from the name. This is hack to allow the .asm include file named registers
+ * to match the .c declared register names */
+
+ //if (SPEC_ABSA ( OP_SYM_ETYPE(op)) && (*name == '_'))
+ //name++;
+
+ debugLog ("%s symbol name %s\n", __FUNCTION__,name);
+ {
+ if(SPEC_CONST ( OP_SYM_ETYPE(op)) && (IS_CHAR ( OP_SYM_ETYPE(op)) )) {
+ debugLog(" %d const char\n",__LINE__);
+ debugLog(" value = %s \n",SPEC_CVAL( OP_SYM_ETYPE(op)));
+ }
+
+ debugLog(" %d storage class %d \n",__LINE__,SPEC_SCLS( OP_SYM_ETYPE(op)));
+ if (IS_CODE ( OP_SYM_ETYPE(op)) )
+ debugLog(" %d code space\n",__LINE__);
+
+ if (IS_INTEGRAL ( OP_SYM_ETYPE(op)) )
+ debugLog(" %d integral\n",__LINE__);
+ if (IS_LITERAL ( OP_SYM_ETYPE(op)) )
+ debugLog(" %d literal\n",__LINE__);
+ if (IS_SPEC ( OP_SYM_ETYPE(op)) )
+ debugLog(" %d specifier\n",__LINE__);
+ debugAopGet(NULL, op);
+ }
+
+ if (IS_CODE ( OP_SYM_ETYPE(op)) )
+ return NULL;
+
+ /* First, search the hash table to see if there is a register with this name */
+ if (SPEC_ABSA ( OP_SYM_ETYPE(op)) && !(IS_BITVAR (OP_SYM_ETYPE(op))) ) {
+ reg = regWithIdx (dynProcessorRegs, SPEC_ADDR ( OP_SYM_ETYPE(op)), 1);
+ /*
+ if(!reg)
+ fprintf(stderr,"ralloc %s is at fixed address but not a processor reg, addr=0x%x\n",
+ name, SPEC_ADDR ( OP_SYM_ETYPE(op)));
+ else
+ fprintf(stderr,"ralloc %s at fixed address has already been declared, addr=0x%x\n",
+ name, SPEC_ADDR ( OP_SYM_ETYPE(op)));
+ */
+ } else {
+ //fprintf(stderr,"ralloc:%d %s \n", __LINE__,name);
+
+ reg = dirregWithName(name);
+ }
+
#if 0
- if(!reg) {
- int address = 0;
-
- /* if this is at an absolute address, then get the address. */
- if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
- address = SPEC_ADDR ( OP_SYM_ETYPE(op));
- //fprintf(stderr,"reg %s is at an absolute address: 0x%03x\n",name,address);
- }
-
- /* Register wasn't found in hash, so let's create
- * a new one and put it in the hash table AND in the
- * dynDirectRegNames set */
- if(!IS_CONFIG_ADDRESS(address)) {
- //fprintf(stderr,"allocating new reg %s\n",name);
-
- reg = newReg(REG_GPR, PO_DIR, rDirectIdx++, name,getSize (OP_SYMBOL (op)->type),0 );
- debugLog (" -- added %s to hash, size = %d\n", name,reg->size);
-
- //hTabAddItem(&dynDirectRegNames, regname2key(name), reg);
-
- if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
-
- //fprintf(stderr, " ralloc.c at fixed address: %s - changing to REG_SFR\n",name);
- reg->type = REG_SFR;
- }
-
- if (IS_BITVAR (OP_SYM_ETYPE(op))) {
- addSet(&dynDirectBitRegs, reg);
- reg->isBitField = 1;
- } else
- addSet(&dynDirectRegs, reg);
-
- if (!IS_STATIC (OP_SYM_ETYPE(op))) {
- reg->isPublic = 1;
- }
- if (IS_EXTERN (OP_SYM_ETYPE(op))) {
- reg->isExtern = 1;
- }
-
-
- } else {
- debugLog (" -- %s is declared at address 0x2007\n",name);
-
- }
- }
-
- if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
- reg->isFixed = 1;
- reg->address = SPEC_ADDR ( OP_SYM_ETYPE(op));
- debugLog (" -- and it is at a fixed address 0x%02x\n",reg->address);
- }
+ if(!reg) {
+ int address = 0;
+
+ /* if this is at an absolute address, then get the address. */
+ if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
+ address = SPEC_ADDR ( OP_SYM_ETYPE(op));
+ //fprintf(stderr,"reg %s is at an absolute address: 0x%03x\n",name,address);
+ }
+
+ /* Register wasn't found in hash, so let's create
+ * a new one and put it in the hash table AND in the
+ * dynDirectRegNames set */
+ if(!IS_CONFIG_ADDRESS(address)) {
+ //fprintf(stderr,"allocating new reg %s\n",name);
+
+ reg = newReg(REG_GPR, PO_DIR, rDirectIdx++, name,getSize (OP_SYMBOL (op)->type),0 );
+ debugLog (" -- added %s to hash, size = %d\n", name,reg->size);
+
+ //hTabAddItem(&dynDirectRegNames, regname2key(name), reg);
+
+ if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
+
+ //fprintf(stderr, " ralloc.c at fixed address: %s - changing to REG_SFR\n",name);
+ reg->type = REG_SFR;
+ }
+
+ if (IS_BITVAR (OP_SYM_ETYPE(op))) {
+ addSet(&dynDirectBitRegs, reg);
+ reg->isBitField = 1;
+ } else
+ addSet(&dynDirectRegs, reg);
+
+ if (!IS_STATIC (OP_SYM_ETYPE(op))) {
+ reg->isPublic = 1;
+ }
+ if (IS_EXTERN (OP_SYM_ETYPE(op))) {
+ reg->isExtern = 1;
+ }
+
+
+ } else {
+ debugLog (" -- %s is declared at address 0x2007\n",name);
+
+ }
+ }
+
+ if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
+ reg->isFixed = 1;
+ reg->address = SPEC_ADDR ( OP_SYM_ETYPE(op));
+ debugLog (" -- and it is at a fixed address 0x%02x\n",reg->address);
+ }
#endif
-
- if(reg) {
- if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
- reg->isFixed = 1;
- reg->address = SPEC_ADDR ( OP_SYM_ETYPE(op));
- debugLog (" -- and it is at a fixed address 0x%02x\n",reg->address);
- }
- } else {
- allocNewDirReg (OP_SYM_ETYPE(op),name);
- }
-
- return reg;
+
+ if(reg) {
+ if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
+ reg->isFixed = 1;
+ reg->address = SPEC_ADDR ( OP_SYM_ETYPE(op));
+ debugLog (" -- and it is at a fixed address 0x%02x\n",reg->address);
+ }
+ } else {
+ allocNewDirReg (OP_SYM_ETYPE(op),name);
+ }
+
+ return reg;
}
regs *
allocRegByName (char *name, int size)
{
-
- regs *reg;
-
- if(!name) {
- fprintf(stderr, "%s - allocating a NULL register\n",__FUNCTION__);
- exit(1);
- }
-
- /* First, search the hash table to see if there is a register with this name */
- reg = dirregWithName(name);
-
-
- if(!reg) {
- int found = 0;
- symbol *sym;
- /* Register wasn't found in hash, so let's create
- * a new one and put it in the hash table AND in the
- * dynDirectRegNames set */
- //fprintf (stderr,"%s symbol name %s\n", __FUNCTION__,name);
- reg = newReg(REG_GPR, PO_DIR, rDirectIdx++, name,size,0 );
- for (sym = setFirstItem(sfr->syms); sym; sym = setNextItem(sfr->syms)) {
- if (strcmp(reg->name+1,sym->name)==0) {
- unsigned a = SPEC_ADDR(sym->etype);
- reg->address = a;
- reg->isFixed = 1;
- reg->type = REG_SFR;
- if (!IS_STATIC (sym->etype)) {
- reg->isPublic = 1;
- }
- if (IS_EXTERN (sym->etype)) {
- reg->isExtern = 1;
- }
- if (IS_BITVAR (sym->etype))
- reg->isBitField = 1;
- found = 1;
- break;
- }
+
+ regs *reg;
+
+ if(!name) {
+ fprintf(stderr, "%s - allocating a NULL register\n",__FUNCTION__);
+ exit(1);
}
- if (!found) {
- for (sym = setFirstItem(data->syms); sym; sym = setNextItem(data->syms)) {
+
+ /* First, search the hash table to see if there is a register with this name */
+ reg = dirregWithName(name);
+
+
+ if(!reg) {
+ int found = 0;
+ symbol *sym;
+ /* Register wasn't found in hash, so let's create
+ * a new one and put it in the hash table AND in the
+ * dynDirectRegNames set */
+ //fprintf (stderr,"%s symbol name %s\n", __FUNCTION__,name);
+ reg = newReg(REG_GPR, PO_DIR, rDirectIdx++, name,size,0 );
+ for (sym = setFirstItem(sfr->syms); sym; sym = setNextItem(sfr->syms)) {
if (strcmp(reg->name+1,sym->name)==0) {
unsigned a = SPEC_ADDR(sym->etype);
reg->address = a;
+ reg->isFixed = 1;
+ reg->type = REG_SFR;
if (!IS_STATIC (sym->etype)) {
reg->isPublic = 1;
}
if (IS_EXTERN (sym->etype)) {
reg->isExtern = 1;
- }
+ }
if (IS_BITVAR (sym->etype))
reg->isBitField = 1;
found = 1;
- break;
+ break;
+ }
}
+ if (!found) {
+ for (sym = setFirstItem(data->syms); sym; sym = setNextItem(data->syms)) {
+ if (strcmp(reg->name+1,sym->name)==0) {
+ unsigned a = SPEC_ADDR(sym->etype);
+ reg->address = a;
+ if (!IS_STATIC (sym->etype)) {
+ reg->isPublic = 1;
+ }
+ if (IS_EXTERN (sym->etype)) {
+ reg->isExtern = 1;
+ }
+ if (IS_BITVAR (sym->etype))
+ reg->isBitField = 1;
+ found = 1;
+ break;
+ }
+ }
+ }
+
+ debugLog (" -- added %s to hash, size = %d\n", name,reg->size);
+
+ //hTabAddItem(&dynDirectRegNames, regname2key(name), reg);
+ if (reg->isBitField) {
+ addSet(&dynDirectBitRegs, reg);
+ } else
+ addSet(&dynDirectRegs, reg);
}
- }
-
- debugLog (" -- added %s to hash, size = %d\n", name,reg->size);
-
- //hTabAddItem(&dynDirectRegNames, regname2key(name), reg);
- if (reg->isBitField) {
- addSet(&dynDirectBitRegs, reg);
- } else
- addSet(&dynDirectRegs, reg);
- }
-
- return reg;
+
+ return reg;
}
/*-----------------------------------------------------------------*/
regs *
typeRegWithIdx (int idx, int type, int fixed)
{
-
- regs *dReg;
-
- debugLog ("%s - requesting index = 0x%x\n", __FUNCTION__,idx);
-
- switch (type) {
-
- case REG_GPR:
- if( (dReg = regWithIdx ( dynAllocRegs, idx, fixed)) != NULL) {
-
- debugLog ("Found a Dynamic Register!\n");
- return dReg;
- }
- if( (dReg = regWithIdx ( dynDirectRegs, idx, fixed)) != NULL ) {
- debugLog ("Found a Direct Register!\n");
- return dReg;
- }
-
- break;
- case REG_STK:
- if( (dReg = regWithIdx ( dynStackRegs, idx, fixed)) != NULL ) {
- debugLog ("Found a Stack Register!\n");
- return dReg;
- }
- break;
- case REG_SFR:
- if( (dReg = regWithIdx ( dynProcessorRegs, idx, fixed)) != NULL ) {
- debugLog ("Found a Processor Register!\n");
- return dReg;
- }
-
- case REG_CND:
- case REG_PTR:
- default:
- break;
- }
-
-
- return NULL;
+
+ regs *dReg;
+
+ debugLog ("%s - requesting index = 0x%x\n", __FUNCTION__,idx);
+
+ switch (type) {
+
+ case REG_GPR:
+ if( (dReg = regWithIdx ( dynAllocRegs, idx, fixed)) != NULL) {
+
+ debugLog ("Found a Dynamic Register!\n");
+ return dReg;
+ }
+ if( (dReg = regWithIdx ( dynDirectRegs, idx, fixed)) != NULL ) {
+ debugLog ("Found a Direct Register!\n");
+ return dReg;
+ }
+
+ break;
+ case REG_STK:
+ if( (dReg = regWithIdx ( dynStackRegs, idx, fixed)) != NULL ) {
+ debugLog ("Found a Stack Register!\n");
+ return dReg;
+ }
+ break;
+ case REG_SFR:
+ if( (dReg = regWithIdx ( dynProcessorRegs, idx, fixed)) != NULL ) {
+ debugLog ("Found a Processor Register!\n");
+ return dReg;
+ }
+
+ case REG_CND:
+ case REG_PTR:
+ default:
+ break;
+ }
+
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
regs *
pic14_regWithIdx (int idx)
{
- regs *dReg;
-
- if( (dReg = typeRegWithIdx(idx,REG_GPR,0)) != NULL)
- return dReg;
-
- if( (dReg = typeRegWithIdx(idx,REG_SFR,0)) != NULL)
- return dReg;
-
- return NULL;
+ regs *dReg;
+
+ if( (dReg = typeRegWithIdx(idx,REG_GPR,0)) != NULL)
+ return dReg;
+
+ if( (dReg = typeRegWithIdx(idx,REG_SFR,0)) != NULL)
+ return dReg;
+
+ return NULL;
}
/*-----------------------------------------------------------------*/
regs *
pic14_allocWithIdx (int idx)
{
-
- regs *dReg;
-
- debugLog ("%s - allocating with index = 0x%x\n", __FUNCTION__,idx);
-
- if( (dReg = regWithIdx ( dynAllocRegs, idx,0)) != NULL) {
-
- debugLog ("Found a Dynamic Register!\n");
- } else if( (dReg = regWithIdx ( dynStackRegs, idx,0)) != NULL ) {
- debugLog ("Found a Stack Register!\n");
- } else if( (dReg = regWithIdx ( dynProcessorRegs, idx,0)) != NULL ) {
- debugLog ("Found a Processor Register!\n");
- } else if( (dReg = regWithIdx ( dynInternalRegs, idx,0)) != NULL ) {
- debugLog ("Found an Internal Register!\n");
- } else if( (dReg = regWithIdx ( dynInternalRegs, idx,1)) != NULL ) {
- debugLog ("Found an Internal Register!\n");
- } else {
-
- debugLog ("Dynamic Register not found\n");
-
-
- //fprintf(stderr,"%s %d - requested register: 0x%x\n",__FUNCTION__,__LINE__,idx);
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "regWithIdx not found");
- exit (1);
-
- }
-
- dReg->wasUsed = 1;
- dReg->isFree = 0;
-
- return dReg;
+
+ regs *dReg;
+
+ debugLog ("%s - allocating with index = 0x%x\n", __FUNCTION__,idx);
+
+ if( (dReg = regWithIdx ( dynAllocRegs, idx,0)) != NULL) {
+
+ debugLog ("Found a Dynamic Register!\n");
+ } else if( (dReg = regWithIdx ( dynStackRegs, idx,0)) != NULL ) {
+ debugLog ("Found a Stack Register!\n");
+ } else if( (dReg = regWithIdx ( dynProcessorRegs, idx,0)) != NULL ) {
+ debugLog ("Found a Processor Register!\n");
+ } else if( (dReg = regWithIdx ( dynInternalRegs, idx,0)) != NULL ) {
+ debugLog ("Found an Internal Register!\n");
+ } else if( (dReg = regWithIdx ( dynInternalRegs, idx,1)) != NULL ) {
+ debugLog ("Found an Internal Register!\n");
+ } else {
+
+ debugLog ("Dynamic Register not found\n");
+
+
+ //fprintf(stderr,"%s %d - requested register: 0x%x\n",__FUNCTION__,__LINE__,idx);
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "regWithIdx not found");
+ exit (1);
+
+ }
+
+ dReg->wasUsed = 1;
+ dReg->isFree = 0;
+
+ return dReg;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
regs *
pic14_findFreeReg(short type)
{
- // int i;
- regs* dReg;
-
- switch (type) {
- case REG_GPR:
- if((dReg = regFindFree(dynAllocRegs)) != NULL)
- return dReg;
- return addSet(&dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0));
-
- case REG_STK:
-
- if((dReg = regFindFree(dynStackRegs)) != NULL)
- return dReg;
-
- return NULL;
-
- case REG_PTR:
- case REG_CND:
- case REG_SFR:
- default:
- return NULL;
- }
+ // int i;
+ regs* dReg;
+
+ switch (type) {
+ case REG_GPR:
+ if((dReg = regFindFree(dynAllocRegs)) != NULL)
+ return dReg;
+ return addSet(&dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0));
+
+ case REG_STK:
+
+ if((dReg = regFindFree(dynStackRegs)) != NULL)
+ return dReg;
+
+ return NULL;
+
+ case REG_PTR:
+ case REG_CND:
+ case REG_SFR:
+ default:
+ return NULL;
+ }
}
/*-----------------------------------------------------------------*/
/* freeReg - frees a register */
static void
freeReg (regs * reg)
{
- debugLog ("%s\n", __FUNCTION__);
- reg->isFree = 1;
+ debugLog ("%s\n", __FUNCTION__);
+ reg->isFree = 1;
}
static int
nFreeRegs (int type)
{
- /* dynamically allocate as many as we need and worry about
- * fitting them into a PIC later */
-
- return 100;
+/* dynamically allocate as many as we need and worry about
+ * fitting them into a PIC later */
+
+ return 100;
#if 0
- int i;
- int nfr = 0;
-
- debugLog ("%s\n", __FUNCTION__);
- for (i = 0; i < pic14_nRegs; i++)
- if (regspic14[i].isFree && regspic14[i].type == type)
- nfr++;
- return nfr;
+ int i;
+ int nfr = 0;
+
+ debugLog ("%s\n", __FUNCTION__);
+ for (i = 0; i < pic14_nRegs; i++)
+ if (regspic14[i].isFree && regspic14[i].type == type)
+ nfr++;
+ return nfr;
#endif
}
static int
nfreeRegsType (int type)
{
- int nfr;
- debugLog ("%s\n", __FUNCTION__);
- if (type == REG_PTR)
- {
- if ((nfr = nFreeRegs (type)) == 0)
- return nFreeRegs (REG_GPR);
- }
-
- return nFreeRegs (type);
+ int nfr;
+ debugLog ("%s\n", __FUNCTION__);
+ if (type == REG_PTR)
+ {
+ if ((nfr = nFreeRegs (type)) == 0)
+ return nFreeRegs (REG_GPR);
+ }
+
+ return nFreeRegs (type);
}
void writeSetUsedRegs(FILE *of, set *dRegs)
{
-
- regs *dReg;
-
- for (dReg = setFirstItem(dRegs) ; dReg ;
- dReg = setNextItem(dRegs)) {
-
- if(dReg->wasUsed)
- fprintf (of, "\t%s\n",dReg->name);
- }
-
+
+ regs *dReg;
+
+ for (dReg = setFirstItem(dRegs) ; dReg ;
+ dReg = setNextItem(dRegs)) {
+
+ if(dReg->wasUsed)
+ fprintf (of, "\t%s\n",dReg->name);
+ }
+
}
extern void assignFixedRegisters(set *regset);
extern void assignRelocatableRegisters(set *regset,int used);
void packBits(set *bregs)
{
- set *regset;
- regs *breg;
- regs *bitfield=NULL;
- regs *relocbitfield=NULL;
- int bit_no=0;
- int byte_no=-1;
- char buffer[20];
-
-
- for (regset = bregs ; regset ;
- regset = regset->next) {
-
- breg = regset->item;
- breg->isBitField = 1;
- //fprintf(stderr,"bit reg: %s\n",breg->name);
-
- if(breg->isFixed) {
- //fprintf(stderr,"packing bit at fixed address = 0x%03x\n",breg->address);
-
- bitfield = typeRegWithIdx (breg->address >> 3, -1 , 1);
- breg->rIdx = breg->address & 7;
- breg->address >>= 3;
-
- if(!bitfield) {
- //sprintf (buffer, "fbitfield%02x", breg->address);
- sprintf (buffer, "0x%02x", breg->address);
- //fprintf(stderr,"new bit field\n");
- bitfield = newReg(REG_SFR, PO_GPR_BIT,breg->address,buffer,1,0);
- bitfield->isBitField = 1;
- bitfield->isFixed = 1;
- bitfield->address = breg->address;
- //addSet(&dynDirectRegs,bitfield);
- addSet(&dynInternalRegs,bitfield);
- //hTabAddItem(&dynDirectRegNames, regname2key(buffer), bitfield);
- } else {
- //fprintf(stderr," which is occupied by %s (addr = %d)\n",bitfield->name,bitfield->address);
- ;
- }
- breg->reg_alias = bitfield;
- bitfield = NULL;
-
- } else {
- if(!relocbitfield || bit_no >7) {
- byte_no++;
- bit_no=0;
- sprintf (buffer, "bitfield%d", byte_no);
- //fprintf(stderr,"new relocatable bit field\n");
- relocbitfield = newReg(REG_GPR, PO_GPR_BIT,rDirectIdx++,buffer,1,0);
- relocbitfield->isBitField = 1;
- //addSet(&dynDirectRegs,relocbitfield);
- addSet(&dynInternalRegs,relocbitfield);
- //hTabAddItem(&dynDirectRegNames, regname2key(buffer), relocbitfield);
-
- }
-
- breg->reg_alias = relocbitfield;
- breg->address = rDirectIdx; /* byte_no; */
- breg->rIdx = bit_no++;
- }
- }
-
+ set *regset;
+ regs *breg;
+ regs *bitfield=NULL;
+ regs *relocbitfield=NULL;
+ int bit_no=0;
+ int byte_no=-1;
+ char buffer[20];
+
+
+ for (regset = bregs ; regset ;
+ regset = regset->next) {
+
+ breg = regset->item;
+ breg->isBitField = 1;
+ //fprintf(stderr,"bit reg: %s\n",breg->name);
+
+ if(breg->isFixed) {
+ //fprintf(stderr,"packing bit at fixed address = 0x%03x\n",breg->address);
+
+ bitfield = typeRegWithIdx (breg->address >> 3, -1 , 1);
+ breg->rIdx = breg->address & 7;
+ breg->address >>= 3;
+
+ if(!bitfield) {
+ //sprintf (buffer, "fbitfield%02x", breg->address);
+ sprintf (buffer, "0x%02x", breg->address);
+ //fprintf(stderr,"new bit field\n");
+ bitfield = newReg(REG_SFR, PO_GPR_BIT,breg->address,buffer,1,0);
+ bitfield->isBitField = 1;
+ bitfield->isFixed = 1;
+ bitfield->address = breg->address;
+ //addSet(&dynDirectRegs,bitfield);
+ addSet(&dynInternalRegs,bitfield);
+ //hTabAddItem(&dynDirectRegNames, regname2key(buffer), bitfield);
+ } else {
+ //fprintf(stderr," which is occupied by %s (addr = %d)\n",bitfield->name,bitfield->address);
+ ;
+ }
+ breg->reg_alias = bitfield;
+ bitfield = NULL;
+
+ } else {
+ if(!relocbitfield || bit_no >7) {
+ byte_no++;
+ bit_no=0;
+ sprintf (buffer, "bitfield%d", byte_no);
+ //fprintf(stderr,"new relocatable bit field\n");
+ relocbitfield = newReg(REG_GPR, PO_GPR_BIT,rDirectIdx++,buffer,1,0);
+ relocbitfield->isBitField = 1;
+ //addSet(&dynDirectRegs,relocbitfield);
+ addSet(&dynInternalRegs,relocbitfield);
+ //hTabAddItem(&dynDirectRegNames, regname2key(buffer), relocbitfield);
+
+ }
+
+ breg->reg_alias = relocbitfield;
+ breg->address = rDirectIdx; /* byte_no; */
+ breg->rIdx = bit_no++;
+ }
+ }
+
}
void bitEQUs(FILE *of, set *bregs)
{
- regs *breg,*bytereg;
- int bit_no=0;
-
- //fprintf(stderr," %s\n",__FUNCTION__);
- for (breg = setFirstItem(bregs) ; breg ;
- breg = setNextItem(bregs)) {
-
- //fprintf(stderr,"bit reg: %s\n",breg->name);
-
- bytereg = breg->reg_alias;
- if(bytereg)
- fprintf (of, "%s\tEQU\t( (%s<<3)+%d)\n",
- breg->name,
- bytereg->name,
- breg->rIdx & 0x0007);
-
- else {
- //fprintf(stderr, "bit field is not assigned to a register\n");
- fprintf (of, "%s\tEQU\t( (bitfield%d<<3)+%d)\n",
- breg->name,
- bit_no>>3,
- bit_no & 0x0007);
-
- bit_no++;
- }
- }
-
+ regs *breg,*bytereg;
+ int bit_no=0;
+
+ //fprintf(stderr," %s\n",__FUNCTION__);
+ for (breg = setFirstItem(bregs) ; breg ;
+ breg = setNextItem(bregs)) {
+
+ //fprintf(stderr,"bit reg: %s\n",breg->name);
+
+ bytereg = breg->reg_alias;
+ if(bytereg)
+ fprintf (of, "%s\tEQU\t( (%s<<3)+%d)\n",
+ breg->name,
+ bytereg->name,
+ breg->rIdx & 0x0007);
+
+ else {
+ //fprintf(stderr, "bit field is not assigned to a register\n");
+ fprintf (of, "%s\tEQU\t( (bitfield%d<<3)+%d)\n",
+ breg->name,
+ bit_no>>3,
+ bit_no & 0x0007);
+
+ bit_no++;
+ }
+ }
+
}
void aliasEQUs(FILE *of, set *fregs, int use_rIdx)
{
- regs *reg;
-
-
- for (reg = setFirstItem(fregs) ; reg ;
- reg = setNextItem(fregs)) {
-
- //if(!reg->isEmitted && reg->wasUsed) {
- if(reg->wasUsed) {
- if(use_rIdx)
- fprintf (of, "%s\tEQU\t0x%03x\n",
- reg->name,
- reg->rIdx);
- else
- fprintf (of, "%s\tEQU\t0x%03x\n",
- reg->name,
- reg->address);
- }
- }
-
+ regs *reg;
+
+
+ for (reg = setFirstItem(fregs) ; reg ;
+ reg = setNextItem(fregs)) {
+
+ //if(!reg->isEmitted && reg->wasUsed) {
+ if(reg->wasUsed) {
+ if(use_rIdx)
+ fprintf (of, "%s\tEQU\t0x%03x\n",
+ reg->name,
+ reg->rIdx);
+ else
+ fprintf (of, "%s\tEQU\t0x%03x\n",
+ reg->name,
+ reg->address);
+ }
+ }
+
}
void writeUsedRegs(FILE *of)
{
- packBits(dynDirectBitRegs);
-
- assignFixedRegisters(dynInternalRegs);
- assignFixedRegisters(dynAllocRegs);
- assignFixedRegisters(dynStackRegs);
- assignFixedRegisters(dynDirectRegs);
-
- assignRelocatableRegisters(dynInternalRegs,0);
- assignRelocatableRegisters(dynAllocRegs,0);
- assignRelocatableRegisters(dynStackRegs,0);
-
-/*
- assignRelocatableRegisters(dynDirectRegs,0);
- printf("assignRelocatableRegisters(dynDirectRegs,0);\n");
-*/
- //dump_map();
-
- dump_sfr(of);
- bitEQUs(of,dynDirectBitRegs);
-/*
- aliasEQUs(of,dynAllocRegs,0);
- aliasEQUs(of,dynDirectRegs,0);
- aliasEQUs(of,dynStackRegs,0);
- aliasEQUs(of,dynProcessorRegs,1);
-*/
+ packBits(dynDirectBitRegs);
+
+ assignFixedRegisters(dynInternalRegs);
+ assignFixedRegisters(dynAllocRegs);
+ assignFixedRegisters(dynStackRegs);
+ assignFixedRegisters(dynDirectRegs);
+
+ assignRelocatableRegisters(dynInternalRegs,0);
+ assignRelocatableRegisters(dynAllocRegs,0);
+ assignRelocatableRegisters(dynStackRegs,0);
+
+ /*
+ assignRelocatableRegisters(dynDirectRegs,0);
+ printf("assignRelocatableRegisters(dynDirectRegs,0);\n");
+ */
+ //dump_map();
+
+ dump_sfr(of);
+ bitEQUs(of,dynDirectBitRegs);
+ /*
+ aliasEQUs(of,dynAllocRegs,0);
+ aliasEQUs(of,dynDirectRegs,0);
+ aliasEQUs(of,dynStackRegs,0);
+ aliasEQUs(of,dynProcessorRegs,1);
+ */
}
#if 0
static bool
allDefsOutOfRange (bitVect * defs, int fseq, int toseq)
{
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- if (!defs)
- return TRUE;
-
- for (i = 0; i < defs->size; i++)
- {
- iCode *ic;
-
- if (bitVectBitValue (defs, i) &&
- (ic = hTabItemWithKey (iCodehTab, i)) &&
- (ic->seq >= fseq && ic->seq <= toseq))
-
- return FALSE;
-
- }
-
- return TRUE;
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ if (!defs)
+ return TRUE;
+
+ for (i = 0; i < defs->size; i++)
+ {
+ iCode *ic;
+
+ if (bitVectBitValue (defs, i) &&
+ (ic = hTabItemWithKey (iCodehTab, i)) &&
+ (ic->seq >= fseq && ic->seq <= toseq))
+
+ return FALSE;
+
+ }
+
+ return TRUE;
}
#endif
static bitVect *
computeSpillable (iCode * ic)
{
- bitVect *spillable;
-
- debugLog ("%s\n", __FUNCTION__);
- /* spillable live ranges are those that are live at this
- point . the following categories need to be subtracted
- from this set.
- a) - those that are already spilt
- b) - if being used by this one
- c) - defined by this one */
-
- spillable = bitVectCopy (ic->rlive);
- spillable =
- bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
- spillable =
- bitVectCplAnd (spillable, ic->uses); /* used in this one */
- bitVectUnSetBit (spillable, ic->defKey);
- spillable = bitVectIntersect (spillable, _G.regAssigned);
- return spillable;
-
+ bitVect *spillable;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* spillable live ranges are those that are live at this
+ point . the following categories need to be subtracted
+ from this set.
+ a) - those that are already spilt
+ b) - if being used by this one
+ c) - defined by this one */
+
+ spillable = bitVectCopy (ic->rlive);
+ spillable =
+ bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
+ spillable =
+ bitVectCplAnd (spillable, ic->uses); /* used in this one */
+ bitVectUnSetBit (spillable, ic->defKey);
+ spillable = bitVectIntersect (spillable, _G.regAssigned);
+ return spillable;
+
}
/*-----------------------------------------------------------------*/
static int
noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- return (sym->usl.spillLoc ? 0 : 1);
+ debugLog ("%s\n", __FUNCTION__);
+ return (sym->usl.spillLoc ? 0 : 1);
}
/*-----------------------------------------------------------------*/
static int
hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- return (sym->usl.spillLoc ? 1 : 0);
+ debugLog ("%s\n", __FUNCTION__);
+ return (sym->usl.spillLoc ? 1 : 0);
}
/*-----------------------------------------------------------------*/
static int
directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- if (sym->usl.spillLoc &&
- (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
- return 1;
- else
- return 0;
+ debugLog ("%s\n", __FUNCTION__);
+ if (sym->usl.spillLoc &&
+ (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
+ return 1;
+ else
+ return 0;
}
/*-----------------------------------------------------------------*/
static int
hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
+ debugLog ("%s\n", __FUNCTION__);
+ return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
}
/*-----------------------------------------------------------------*/
static int
rematable (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- return sym->remat;
+ debugLog ("%s\n", __FUNCTION__);
+ return sym->remat;
}
/*-----------------------------------------------------------------*/
static int
notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
- allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
+ debugLog ("%s\n", __FUNCTION__);
+ return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
+ allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
}
/*-----------------------------------------------------------------*/
static int
allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
{
- debugLog ("%s\n", __FUNCTION__);
- return 1;
+ debugLog ("%s\n", __FUNCTION__);
+ return 1;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static set *
liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
- eBBlock * ebp, iCode * ic)
+ eBBlock * ebp, iCode * ic)
{
- set *rset = NULL;
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- if (!lrs || !lrs->size)
- return NULL;
-
- for (i = 1; i < lrs->size; i++)
- {
- symbol *sym;
- if (!bitVectBitValue (lrs, i))
- continue;
-
- /* if we don't find it in the live range
- hash table we are in serious trouble */
- if (!(sym = hTabItemWithKey (liveRanges, i)))
+ set *rset = NULL;
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ if (!lrs || !lrs->size)
+ return NULL;
+
+ for (i = 1; i < lrs->size; i++)
{
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "liveRangesWith could not find liveRange");
- exit (1);
+ symbol *sym;
+ if (!bitVectBitValue (lrs, i))
+ continue;
+
+ /* if we don't find it in the live range
+ hash table we are in serious trouble */
+ if (!(sym = hTabItemWithKey (liveRanges, i)))
+ {
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "liveRangesWith could not find liveRange");
+ exit (1);
+ }
+
+ if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
+ addSetHead (&rset, sym);
}
-
- if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
- addSetHead (&rset, sym);
- }
-
- return rset;
+
+ return rset;
}
static symbol *
leastUsedLR (set * sset)
{
- symbol *sym = NULL, *lsym = NULL;
-
- debugLog ("%s\n", __FUNCTION__);
- sym = lsym = setFirstItem (sset);
-
- if (!lsym)
- return NULL;
-
- for (; lsym; lsym = setNextItem (sset))
- {
-
- /* if usage is the same then prefer
- the spill the smaller of the two */
- if (lsym->used == sym->used)
- if (getSize (lsym->type) < getSize (sym->type))
- sym = lsym;
-
- /* if less usage */
- if (lsym->used < sym->used)
- sym = lsym;
-
- }
-
- setToNull ((void *) &sset);
- sym->blockSpil = 0;
- return sym;
+ symbol *sym = NULL, *lsym = NULL;
+
+ debugLog ("%s\n", __FUNCTION__);
+ sym = lsym = setFirstItem (sset);
+
+ if (!lsym)
+ return NULL;
+
+ for (; lsym; lsym = setNextItem (sset))
+ {
+
+ /* if usage is the same then prefer
+ the spill the smaller of the two */
+ if (lsym->used == sym->used)
+ if (getSize (lsym->type) < getSize (sym->type))
+ sym = lsym;
+
+ /* if less usage */
+ if (lsym->used < sym->used)
+ sym = lsym;
+
+ }
+
+ setToNull ((void *) &sset);
+ sym->blockSpil = 0;
+ return sym;
}
/*-----------------------------------------------------------------*/
static int
noOverLap (set * itmpStack, symbol * fsym)
{
- symbol *sym;
- debugLog ("%s\n", __FUNCTION__);
-
-
- for (sym = setFirstItem (itmpStack); sym;
- sym = setNextItem (itmpStack))
- {
- if (sym->liveTo > fsym->liveFrom)
- return 0;
-
- }
-
- return 1;
+ symbol *sym;
+ debugLog ("%s\n", __FUNCTION__);
+
+
+ for (sym = setFirstItem (itmpStack); sym;
+ sym = setNextItem (itmpStack))
+ {
+ if (sym->liveTo > fsym->liveFrom)
+ return 0;
+
+ }
+
+ return 1;
}
/*-----------------------------------------------------------------*/
static
DEFSETFUNC (isFree)
{
- symbol *sym = item;
- V_ARG (symbol **, sloc);
- V_ARG (symbol *, fsym);
-
- debugLog ("%s\n", __FUNCTION__);
- /* if already found */
- if (*sloc)
- return 0;
-
- /* if it is free && and the itmp assigned to
- this does not have any overlapping live ranges
- with the one currently being assigned and
- the size can be accomodated */
- if (sym->isFree &&
- noOverLap (sym->usl.itmpStack, fsym) &&
- getSize (sym->type) >= getSize (fsym->type))
- {
- *sloc = sym;
- return 1;
- }
-
- return 0;
+ symbol *sym = item;
+ V_ARG (symbol **, sloc);
+ V_ARG (symbol *, fsym);
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* if already found */
+ if (*sloc)
+ return 0;
+
+ /* if it is free && and the itmp assigned to
+ this does not have any overlapping live ranges
+ with the one currently being assigned and
+ the size can be accomodated */
+ if (sym->isFree &&
+ noOverLap (sym->usl.itmpStack, fsym) &&
+ getSize (sym->type) >= getSize (fsym->type))
+ {
+ *sloc = sym;
+ return 1;
+ }
+
+ return 0;
}
/*-----------------------------------------------------------------*/
static void
spillLRWithPtrReg (symbol * forSym)
{
- symbol *lrsym;
- regs *r0, *r1;
- int k;
-
- debugLog ("%s\n", __FUNCTION__);
- if (!_G.regAssigned ||
- bitVectIsZero (_G.regAssigned))
- return;
-
- r0 = pic14_regWithIdx (R0_IDX);
- r1 = pic14_regWithIdx (R1_IDX);
-
- /* for all live ranges */
- for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
- lrsym = hTabNextItem (liveRanges, &k))
- {
- int j;
-
- /* if no registers assigned to it or
- spilt */
- /* if it does not overlap with this then
- not need to spill it */
-
- if (lrsym->isspilt || !lrsym->nRegs ||
- (lrsym->liveTo < forSym->liveFrom))
- continue;
-
- /* go thru the registers : if it is either
- r0 or r1 then spil it */
- for (j = 0; j < lrsym->nRegs; j++)
- if (lrsym->regs[j] == r0 ||
- lrsym->regs[j] == r1)
- {
- spillThis (lrsym);
- break;
- }
- }
-
+ symbol *lrsym;
+ regs *r0, *r1;
+ int k;
+
+ debugLog ("%s\n", __FUNCTION__);
+ if (!_G.regAssigned ||
+ bitVectIsZero (_G.regAssigned))
+ return;
+
+ r0 = pic14_regWithIdx (R0_IDX);
+ r1 = pic14_regWithIdx (R1_IDX);
+
+ /* for all live ranges */
+ for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
+ lrsym = hTabNextItem (liveRanges, &k))
+ {
+ int j;
+
+ /* if no registers assigned to it or
+ spilt */
+ /* if it does not overlap with this then
+ not need to spill it */
+
+ if (lrsym->isspilt || !lrsym->nRegs ||
+ (lrsym->liveTo < forSym->liveFrom))
+ continue;
+
+ /* go thru the registers : if it is either
+ r0 or r1 then spil it */
+ for (j = 0; j < lrsym->nRegs; j++)
+ if (lrsym->regs[j] == r0 ||
+ lrsym->regs[j] == r1)
+ {
+ spillThis (lrsym);
+ break;
+ }
+ }
+
}
/*-----------------------------------------------------------------*/
static symbol *
createStackSpil (symbol * sym)
{
- symbol *sloc = NULL;
- int useXstack, model, noOverlay;
-
- char slocBuffer[30];
- debugLog ("%s\n", __FUNCTION__);
-
- /* first go try and find a free one that is already
- existing on the stack */
- if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
- {
- /* found a free one : just update & return */
- sym->usl.spillLoc = sloc;
- sym->stackSpil = 1;
- sloc->isFree = 0;
- addSetHead (&sloc->usl.itmpStack, sym);
- return sym;
- }
-
- /* could not then have to create one , this is the hard part
- we need to allocate this on the stack : this is really a
- hack!! but cannot think of anything better at this time */
-
- if (sprintf (slocBuffer, "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
- {
- fprintf (stderr, "kkkInternal error: slocBuffer overflowed: %s:%d\n",
- __FILE__, __LINE__);
- exit (1);
- }
-
- sloc = newiTemp (slocBuffer);
-
- /* set the type to the spilling symbol */
- sloc->type = copyLinkChain (sym->type);
- sloc->etype = getSpec (sloc->type);
- SPEC_SCLS (sloc->etype) = S_DATA;
- SPEC_EXTR (sloc->etype) = 0;
- SPEC_STAT (sloc->etype) = 0;
-
- /* we don't allow it to be allocated`
- onto the external stack since : so we
- temporarily turn it off ; we also
- turn off memory model to prevent
- the spil from going to the external storage
- and turn off overlaying
- */
-
- useXstack = options.useXstack;
- model = options.model;
- noOverlay = options.noOverlay;
- options.noOverlay = 1;
- options.model = options.useXstack = 0;
-
- allocLocal (sloc);
-
- options.useXstack = useXstack;
- options.model = model;
- options.noOverlay = noOverlay;
- sloc->isref = 1; /* to prevent compiler warning */
-
- /* if it is on the stack then update the stack */
- if (IN_STACK (sloc->etype))
- {
- currFunc->stack += getSize (sloc->type);
- _G.stackExtend += getSize (sloc->type);
- }
- else
- _G.dataExtend += getSize (sloc->type);
-
- /* add it to the _G.stackSpil set */
- addSetHead (&_G.stackSpil, sloc);
- sym->usl.spillLoc = sloc;
- sym->stackSpil = 1;
-
- /* add it to the set of itempStack set
- of the spill location */
- addSetHead (&sloc->usl.itmpStack, sym);
- return sym;
+ symbol *sloc = NULL;
+ int useXstack, model, noOverlay;
+
+ char slocBuffer[30];
+ debugLog ("%s\n", __FUNCTION__);
+
+ /* first go try and find a free one that is already
+ existing on the stack */
+ if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
+ {
+ /* found a free one : just update & return */
+ sym->usl.spillLoc = sloc;
+ sym->stackSpil = 1;
+ sloc->isFree = 0;
+ addSetHead (&sloc->usl.itmpStack, sym);
+ return sym;
+ }
+
+ /* could not then have to create one , this is the hard part
+ we need to allocate this on the stack : this is really a
+ hack!! but cannot think of anything better at this time */
+
+ if (sprintf (slocBuffer, "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
+ {
+ fprintf (stderr, "kkkInternal error: slocBuffer overflowed: %s:%d\n",
+ __FILE__, __LINE__);
+ exit (1);
+ }
+
+ sloc = newiTemp (slocBuffer);
+
+ /* set the type to the spilling symbol */
+ sloc->type = copyLinkChain (sym->type);
+ sloc->etype = getSpec (sloc->type);
+ SPEC_SCLS (sloc->etype) = S_DATA;
+ SPEC_EXTR (sloc->etype) = 0;
+ SPEC_STAT (sloc->etype) = 0;
+
+ /* we don't allow it to be allocated`
+ onto the external stack since : so we
+ temporarily turn it off ; we also
+ turn off memory model to prevent
+ the spil from going to the external storage
+ and turn off overlaying
+ */
+
+ useXstack = options.useXstack;
+ model = options.model;
+ noOverlay = options.noOverlay;
+ options.noOverlay = 1;
+ options.model = options.useXstack = 0;
+
+ allocLocal (sloc);
+
+ options.useXstack = useXstack;
+ options.model = model;
+ options.noOverlay = noOverlay;
+ sloc->isref = 1; /* to prevent compiler warning */
+
+ /* if it is on the stack then update the stack */
+ if (IN_STACK (sloc->etype))
+ {
+ currFunc->stack += getSize (sloc->type);
+ _G.stackExtend += getSize (sloc->type);
+ }
+ else
+ _G.dataExtend += getSize (sloc->type);
+
+ /* add it to the _G.stackSpil set */
+ addSetHead (&_G.stackSpil, sloc);
+ sym->usl.spillLoc = sloc;
+ sym->stackSpil = 1;
+
+ /* add it to the set of itempStack set
+ of the spill location */
+ addSetHead (&sloc->usl.itmpStack, sym);
+ return sym;
}
/*-----------------------------------------------------------------*/
static bool
isSpiltOnStack (symbol * sym)
{
- sym_link *etype;
-
- debugLog ("%s\n", __FUNCTION__);
- if (!sym)
- return FALSE;
-
- if (!sym->isspilt)
- return FALSE;
-
-/* if (sym->_G.stackSpil) */
-/* return TRUE; */
-
- if (!sym->usl.spillLoc)
- return FALSE;
-
- etype = getSpec (sym->usl.spillLoc->type);
- if (IN_STACK (etype))
- return TRUE;
-
- return FALSE;
+ sym_link *etype;
+
+ debugLog ("%s\n", __FUNCTION__);
+ if (!sym)
+ return FALSE;
+
+ if (!sym->isspilt)
+ return FALSE;
+
+ /* if (sym->_G.stackSpil) */
+ /* return TRUE; */
+
+ if (!sym->usl.spillLoc)
+ return FALSE;
+
+ etype = getSpec (sym->usl.spillLoc->type);
+ if (IN_STACK (etype))
+ return TRUE;
+
+ return FALSE;
}
/*-----------------------------------------------------------------*/
static void
spillThis (symbol * sym)
{
- int i;
- debugLog ("%s : %s\n", __FUNCTION__, sym->rname);
-
- /* if this is rematerializable or has a spillLocation
- we are okay, else we need to create a spillLocation
- for it */
- if (!(sym->remat || sym->usl.spillLoc))
- createStackSpil (sym);
-
-
- /* mark it has spilt & put it in the spilt set */
- sym->isspilt = 1;
- _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
-
- bitVectUnSetBit (_G.regAssigned, sym->key);
-
- for (i = 0; i < sym->nRegs; i++)
-
- if (sym->regs[i])
- {
- freeReg (sym->regs[i]);
- sym->regs[i] = NULL;
- }
-
- /* if spilt on stack then free up r0 & r1
- if they could have been assigned to some
- LIVE ranges */
- if (!pic14_ptrRegReq && isSpiltOnStack (sym))
- {
- pic14_ptrRegReq++;
- spillLRWithPtrReg (sym);
- }
-
- if (sym->usl.spillLoc && !sym->remat)
- sym->usl.spillLoc->allocreq = 1;
- return;
+ int i;
+ debugLog ("%s : %s\n", __FUNCTION__, sym->rname);
+
+ /* if this is rematerializable or has a spillLocation
+ we are okay, else we need to create a spillLocation
+ for it */
+ if (!(sym->remat || sym->usl.spillLoc))
+ createStackSpil (sym);
+
+
+ /* mark it has spilt & put it in the spilt set */
+ sym->isspilt = 1;
+ _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
+
+ bitVectUnSetBit (_G.regAssigned, sym->key);
+
+ for (i = 0; i < sym->nRegs; i++)
+
+ if (sym->regs[i])
+ {
+ freeReg (sym->regs[i]);
+ sym->regs[i] = NULL;
+ }
+
+ /* if spilt on stack then free up r0 & r1
+ if they could have been assigned to some
+ LIVE ranges */
+ if (!pic14_ptrRegReq && isSpiltOnStack (sym))
+ {
+ pic14_ptrRegReq++;
+ spillLRWithPtrReg (sym);
+ }
+
+ if (sym->usl.spillLoc && !sym->remat)
+ sym->usl.spillLoc->allocreq = 1;
+ return;
}
/*-----------------------------------------------------------------*/
static symbol *
selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
{
- bitVect *lrcs = NULL;
- set *selectS;
- symbol *sym;
-
- debugLog ("%s\n", __FUNCTION__);
- /* get the spillable live ranges */
- lrcs = computeSpillable (ic);
-
- /* get all live ranges that are rematerizable */
- if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
- {
-
- /* return the least used of these */
- return leastUsedLR (selectS);
- }
-
- /* get live ranges with spillLocations in direct space */
- if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
- {
- sym = leastUsedLR (selectS);
- strcpy (sym->rname, (sym->usl.spillLoc->rname[0] ?
- sym->usl.spillLoc->rname :
- sym->usl.spillLoc->name));
- sym->spildir = 1;
- /* mark it as allocation required */
- sym->usl.spillLoc->allocreq = 1;
- return sym;
- }
-
- /* if the symbol is local to the block then */
- if (forSym->liveTo < ebp->lSeq)
- {
-
- /* check if there are any live ranges allocated
- to registers that are not used in this block */
- if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
+ bitVect *lrcs = NULL;
+ set *selectS;
+ symbol *sym;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* get the spillable live ranges */
+ lrcs = computeSpillable (ic);
+
+ /* get all live ranges that are rematerizable */
+ if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
{
- sym = leastUsedLR (selectS);
- /* if this is not rematerializable */
- if (!sym->remat)
- {
- _G.blockSpil++;
- sym->blockSpil = 1;
- }
- return sym;
+
+ /* return the least used of these */
+ return leastUsedLR (selectS);
}
-
- /* check if there are any live ranges that not
- used in the remainder of the block */
- if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
+
+ /* get live ranges with spillLocations in direct space */
+ if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
{
- sym = leastUsedLR (selectS);
- if (!sym->remat)
- {
- sym->remainSpil = 1;
- _G.blockSpil++;
- }
- return sym;
+ sym = leastUsedLR (selectS);
+ strcpy (sym->rname, (sym->usl.spillLoc->rname[0] ?
+ sym->usl.spillLoc->rname :
+ sym->usl.spillLoc->name));
+ sym->spildir = 1;
+ /* mark it as allocation required */
+ sym->usl.spillLoc->allocreq = 1;
+ return sym;
}
- }
-
- /* find live ranges with spillocation && not used as pointers */
- if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
- {
-
- sym = leastUsedLR (selectS);
- /* mark this as allocation required */
- sym->usl.spillLoc->allocreq = 1;
- return sym;
- }
-
- /* find live ranges with spillocation */
- if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
- {
-
- sym = leastUsedLR (selectS);
- sym->usl.spillLoc->allocreq = 1;
- return sym;
- }
-
- /* couldn't find then we need to create a spil
- location on the stack , for which one? the least
- used ofcourse */
- if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
- {
-
- /* return a created spil location */
- sym = createStackSpil (leastUsedLR (selectS));
- sym->usl.spillLoc->allocreq = 1;
- return sym;
- }
-
- /* this is an extreme situation we will spill
- this one : happens very rarely but it does happen */
- spillThis (forSym);
- return forSym;
-
+
+ /* if the symbol is local to the block then */
+ if (forSym->liveTo < ebp->lSeq)
+ {
+
+ /* check if there are any live ranges allocated
+ to registers that are not used in this block */
+ if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
+ {
+ sym = leastUsedLR (selectS);
+ /* if this is not rematerializable */
+ if (!sym->remat)
+ {
+ _G.blockSpil++;
+ sym->blockSpil = 1;
+ }
+ return sym;
+ }
+
+ /* check if there are any live ranges that not
+ used in the remainder of the block */
+ if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
+ {
+ sym = leastUsedLR (selectS);
+ if (!sym->remat)
+ {
+ sym->remainSpil = 1;
+ _G.blockSpil++;
+ }
+ return sym;
+ }
+ }
+
+ /* find live ranges with spillocation && not used as pointers */
+ if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
+ {
+
+ sym = leastUsedLR (selectS);
+ /* mark this as allocation required */
+ sym->usl.spillLoc->allocreq = 1;
+ return sym;
+ }
+
+ /* find live ranges with spillocation */
+ if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
+ {
+
+ sym = leastUsedLR (selectS);
+ sym->usl.spillLoc->allocreq = 1;
+ return sym;
+ }
+
+ /* couldn't find then we need to create a spil
+ location on the stack , for which one? the least
+ used ofcourse */
+ if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
+ {
+
+ /* return a created spil location */
+ sym = createStackSpil (leastUsedLR (selectS));
+ sym->usl.spillLoc->allocreq = 1;
+ return sym;
+ }
+
+ /* this is an extreme situation we will spill
+ this one : happens very rarely but it does happen */
+ spillThis (forSym);
+ return forSym;
+
}
/*-----------------------------------------------------------------*/
static bool
spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
{
- symbol *ssym;
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- /* get something we can spil */
- ssym = selectSpil (ic, ebp, forSym);
-
- /* mark it as spilt */
- ssym->isspilt = 1;
- _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
-
- /* mark it as not register assigned &
- take it away from the set */
- bitVectUnSetBit (_G.regAssigned, ssym->key);
-
- /* mark the registers as free */
- for (i = 0; i < ssym->nRegs; i++)
- if (ssym->regs[i])
- freeReg (ssym->regs[i]);
-
- /* if spilt on stack then free up r0 & r1
- if they could have been assigned to as gprs */
- if (!pic14_ptrRegReq && isSpiltOnStack (ssym))
- {
- pic14_ptrRegReq++;
- spillLRWithPtrReg (ssym);
- }
-
- /* if this was a block level spil then insert push & pop
- at the start & end of block respectively */
- if (ssym->blockSpil)
- {
- iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
- /* add push to the start of the block */
- addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
- ebp->sch->next : ebp->sch));
- nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
- /* add pop to the end of the block */
- addiCodeToeBBlock (ebp, nic, NULL);
- }
-
- /* if spilt because not used in the remainder of the
- block then add a push before this instruction and
- a pop at the end of the block */
- if (ssym->remainSpil)
- {
-
- iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
- /* add push just before this instruction */
- addiCodeToeBBlock (ebp, nic, ic);
-
- nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
- /* add pop to the end of the block */
- addiCodeToeBBlock (ebp, nic, NULL);
- }
-
- if (ssym == forSym)
- return FALSE;
- else
- return TRUE;
+ symbol *ssym;
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* get something we can spil */
+ ssym = selectSpil (ic, ebp, forSym);
+
+ /* mark it as spilt */
+ ssym->isspilt = 1;
+ _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
+
+ /* mark it as not register assigned &
+ take it away from the set */
+ bitVectUnSetBit (_G.regAssigned, ssym->key);
+
+ /* mark the registers as free */
+ for (i = 0; i < ssym->nRegs; i++)
+ if (ssym->regs[i])
+ freeReg (ssym->regs[i]);
+
+ /* if spilt on stack then free up r0 & r1
+ if they could have been assigned to as gprs */
+ if (!pic14_ptrRegReq && isSpiltOnStack (ssym))
+ {
+ pic14_ptrRegReq++;
+ spillLRWithPtrReg (ssym);
+ }
+
+ /* if this was a block level spil then insert push & pop
+ at the start & end of block respectively */
+ if (ssym->blockSpil)
+ {
+ iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
+ /* add push to the start of the block */
+ addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
+ ebp->sch->next : ebp->sch));
+ nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
+ /* add pop to the end of the block */
+ addiCodeToeBBlock (ebp, nic, NULL);
+ }
+
+ /* if spilt because not used in the remainder of the
+ block then add a push before this instruction and
+ a pop at the end of the block */
+ if (ssym->remainSpil)
+ {
+
+ iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
+ /* add push just before this instruction */
+ addiCodeToeBBlock (ebp, nic, ic);
+
+ nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
+ /* add pop to the end of the block */
+ addiCodeToeBBlock (ebp, nic, NULL);
+ }
+
+ if (ssym == forSym)
+ return FALSE;
+ else
+ return TRUE;
}
/*-----------------------------------------------------------------*/
static regs *
getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
{
- regs *reg;
- int j;
-
- debugLog ("%s\n", __FUNCTION__);
+ regs *reg;
+ int j;
+
+ debugLog ("%s\n", __FUNCTION__);
tryAgain:
- /* try for a ptr type */
- if ((reg = allocReg (REG_PTR)))
- return reg;
-
- /* try for gpr type */
- if ((reg = allocReg (REG_GPR)))
- return reg;
-
- /* we have to spil */
- if (!spilSomething (ic, ebp, sym))
- return NULL;
-
- /* make sure partially assigned registers aren't reused */
- for (j=0; j<=sym->nRegs; j++)
- if (sym->regs[j])
- sym->regs[j]->isFree = 0;
-
- /* this looks like an infinite loop but
- in really selectSpil will abort */
- goto tryAgain;
+ /* try for a ptr type */
+ if ((reg = allocReg (REG_PTR)))
+ return reg;
+
+ /* try for gpr type */
+ if ((reg = allocReg (REG_GPR)))
+ return reg;
+
+ /* we have to spil */
+ if (!spilSomething (ic, ebp, sym))
+ return NULL;
+
+ /* make sure partially assigned registers aren't reused */
+ for (j=0; j<=sym->nRegs; j++)
+ if (sym->regs[j])
+ sym->regs[j]->isFree = 0;
+
+ /* this looks like an infinite loop but
+ in really selectSpil will abort */
+ goto tryAgain;
}
/*-----------------------------------------------------------------*/
static regs *
getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
{
- regs *reg;
- int j;
-
- debugLog ("%s\n", __FUNCTION__);
+ regs *reg;
+ int j;
+
+ debugLog ("%s\n", __FUNCTION__);
tryAgain:
- /* try for gpr type */
- if ((reg = allocReg (REG_GPR)))
- return reg;
-
- if (!pic14_ptrRegReq)
- if ((reg = allocReg (REG_PTR)))
- return reg;
-
- /* we have to spil */
- if (!spilSomething (ic, ebp, sym))
- return NULL;
-
- /* make sure partially assigned registers aren't reused */
- for (j=0; j<=sym->nRegs; j++)
- if (sym->regs[j])
- sym->regs[j]->isFree = 0;
-
- /* this looks like an infinite loop but
- in really selectSpil will abort */
- goto tryAgain;
+ /* try for gpr type */
+ if ((reg = allocReg (REG_GPR)))
+ return reg;
+
+ if (!pic14_ptrRegReq)
+ if ((reg = allocReg (REG_PTR)))
+ return reg;
+
+ /* we have to spil */
+ if (!spilSomething (ic, ebp, sym))
+ return NULL;
+
+ /* make sure partially assigned registers aren't reused */
+ for (j=0; j<=sym->nRegs; j++)
+ if (sym->regs[j])
+ sym->regs[j]->isFree = 0;
+
+ /* this looks like an infinite loop but
+ in really selectSpil will abort */
+ goto tryAgain;
}
/*-----------------------------------------------------------------*/
static bool
symHasReg (symbol * sym, regs * reg)
{
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- for (i = 0; i < sym->nRegs; i++)
- if (sym->regs[i] == reg)
- return TRUE;
-
- return FALSE;
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ for (i = 0; i < sym->nRegs; i++)
+ if (sym->regs[i] == reg)
+ return TRUE;
+
+ return FALSE;
}
/*-----------------------------------------------------------------*/
static void
deassignLRs (iCode * ic, eBBlock * ebp)
{
- symbol *sym;
- int k;
- symbol *result;
-
- debugLog ("%s\n", __FUNCTION__);
- for (sym = hTabFirstItem (liveRanges, &k); sym;
- sym = hTabNextItem (liveRanges, &k))
- {
-
- symbol *psym = NULL;
- /* if it does not end here */
- if (sym->liveTo > ic->seq)
- continue;
-
- /* if it was spilt on stack then we can
- mark the stack spil location as free */
- if (sym->isspilt)
- {
- if (sym->stackSpil)
- {
- sym->usl.spillLoc->isFree = 1;
- sym->stackSpil = 0;
- }
- continue;
- }
-
- if (!bitVectBitValue (_G.regAssigned, sym->key))
- continue;
-
- /* special case check if this is an IFX &
- the privious one was a pop and the
- previous one was not spilt then keep track
- of the symbol */
- if (ic->op == IFX && ic->prev &&
- ic->prev->op == IPOP &&
- !ic->prev->parmPush &&
- !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
- psym = OP_SYMBOL (IC_LEFT (ic->prev));
-
- if (sym->nRegs)
+ symbol *sym;
+ int k;
+ symbol *result;
+
+ debugLog ("%s\n", __FUNCTION__);
+ for (sym = hTabFirstItem (liveRanges, &k); sym;
+ sym = hTabNextItem (liveRanges, &k))
{
- int i = 0;
-
- bitVectUnSetBit (_G.regAssigned, sym->key);
-
- /* if the result of this one needs registers
- and does not have it then assign it right
- away */
- if (IC_RESULT (ic) &&
- !(SKIP_IC2 (ic) || /* not a special icode */
- ic->op == JUMPTABLE ||
- ic->op == IFX ||
- ic->op == IPUSH ||
- ic->op == IPOP ||
- ic->op == RETURN ||
- POINTER_SET (ic)) &&
- (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
- result->liveTo > ic->seq && /* and will live beyond this */
- result->liveTo <= ebp->lSeq && /* does not go beyond this block */
- result->regType == sym->regType && /* same register types */
- result->nRegs && /* which needs registers */
- !result->isspilt && /* and does not already have them */
- !result->remat &&
- !bitVectBitValue (_G.regAssigned, result->key) &&
- /* the number of free regs + number of regs in this LR
- can accomodate the what result Needs */
- ((nfreeRegsType (result->regType) +
- sym->nRegs) >= result->nRegs)
- )
- {
-
- for (i = 0; i < max (sym->nRegs, result->nRegs); i++)
- if (i < sym->nRegs)
- result->regs[i] = sym->regs[i];
- else
- result->regs[i] = getRegGpr (ic, ebp, result);
-
- _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
-
- }
-
- /* free the remaining */
- for (; i < sym->nRegs; i++)
- {
- if (psym)
+
+ symbol *psym = NULL;
+ /* if it does not end here */
+ if (sym->liveTo > ic->seq)
+ continue;
+
+ /* if it was spilt on stack then we can
+ mark the stack spil location as free */
+ if (sym->isspilt)
+ {
+ if (sym->stackSpil)
+ {
+ sym->usl.spillLoc->isFree = 1;
+ sym->stackSpil = 0;
+ }
+ continue;
+ }
+
+ if (!bitVectBitValue (_G.regAssigned, sym->key))
+ continue;
+
+ /* special case check if this is an IFX &
+ the privious one was a pop and the
+ previous one was not spilt then keep track
+ of the symbol */
+ if (ic->op == IFX && ic->prev &&
+ ic->prev->op == IPOP &&
+ !ic->prev->parmPush &&
+ !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
+ psym = OP_SYMBOL (IC_LEFT (ic->prev));
+
+ if (sym->nRegs)
{
- if (!symHasReg (psym, sym->regs[i]))
- freeReg (sym->regs[i]);
+ int i = 0;
+
+ bitVectUnSetBit (_G.regAssigned, sym->key);
+
+ /* if the result of this one needs registers
+ and does not have it then assign it right
+ away */
+ if (IC_RESULT (ic) &&
+ !(SKIP_IC2 (ic) || /* not a special icode */
+ ic->op == JUMPTABLE ||
+ ic->op == IFX ||
+ ic->op == IPUSH ||
+ ic->op == IPOP ||
+ ic->op == RETURN ||
+ POINTER_SET (ic)) &&
+ (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
+ result->liveTo > ic->seq && /* and will live beyond this */
+ result->liveTo <= ebp->lSeq && /* does not go beyond this block */
+ result->regType == sym->regType && /* same register types */
+ result->nRegs && /* which needs registers */
+ !result->isspilt && /* and does not already have them */
+ !result->remat &&
+ !bitVectBitValue (_G.regAssigned, result->key) &&
+ /* the number of free regs + number of regs in this LR
+ can accomodate the what result Needs */
+ ((nfreeRegsType (result->regType) +
+ sym->nRegs) >= result->nRegs)
+ )
+ {
+
+ for (i = 0; i < max (sym->nRegs, result->nRegs); i++)
+ if (i < sym->nRegs)
+ result->regs[i] = sym->regs[i];
+ else
+ result->regs[i] = getRegGpr (ic, ebp, result);
+
+ _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
+
+ }
+
+ /* free the remaining */
+ for (; i < sym->nRegs; i++)
+ {
+ if (psym)
+ {
+ if (!symHasReg (psym, sym->regs[i]))
+ freeReg (sym->regs[i]);
+ }
+ else
+ freeReg (sym->regs[i]);
+ }
}
- else
- freeReg (sym->regs[i]);
- }
}
- }
}
static void
reassignLR (operand * op)
{
- symbol *sym = OP_SYMBOL (op);
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- /* not spilt any more */
- sym->isspilt = sym->blockSpil = sym->remainSpil = 0;
- bitVectUnSetBit (_G.spiltSet, sym->key);
-
- _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
-
- _G.blockSpil--;
-
- for (i = 0; i < sym->nRegs; i++)
- sym->regs[i]->isFree = 0;
+ symbol *sym = OP_SYMBOL (op);
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* not spilt any more */
+ sym->isspilt = sym->blockSpil = sym->remainSpil = 0;
+ bitVectUnSetBit (_G.spiltSet, sym->key);
+
+ _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
+
+ _G.blockSpil--;
+
+ for (i = 0; i < sym->nRegs; i++)
+ sym->regs[i]->isFree = 0;
}
/*-----------------------------------------------------------------*/
static int
willCauseSpill (int nr, int rt)
{
- debugLog ("%s\n", __FUNCTION__);
- /* first check if there are any avlb registers
- of te type required */
- if (rt == REG_PTR)
- {
- /* special case for pointer type
- if pointer type not avlb then
- check for type gpr */
- if (nFreeRegs (rt) >= nr)
- return 0;
- if (nFreeRegs (REG_GPR) >= nr)
- return 0;
- }
- else
- {
- if (pic14_ptrRegReq)
+ debugLog ("%s\n", __FUNCTION__);
+ /* first check if there are any avlb registers
+ of te type required */
+ if (rt == REG_PTR)
{
- if (nFreeRegs (rt) >= nr)
- return 0;
+ /* special case for pointer type
+ if pointer type not avlb then
+ check for type gpr */
+ if (nFreeRegs (rt) >= nr)
+ return 0;
+ if (nFreeRegs (REG_GPR) >= nr)
+ return 0;
}
- else
+ else
{
- if (nFreeRegs (REG_PTR) +
- nFreeRegs (REG_GPR) >= nr)
- return 0;
+ if (pic14_ptrRegReq)
+ {
+ if (nFreeRegs (rt) >= nr)
+ return 0;
+ }
+ else
+ {
+ if (nFreeRegs (REG_PTR) +
+ nFreeRegs (REG_GPR) >= nr)
+ return 0;
+ }
}
- }
-
- debugLog (" ... yep it will (cause a spill)\n");
- /* it will cause a spil */
- return 1;
+
+ debugLog (" ... yep it will (cause a spill)\n");
+ /* it will cause a spil */
+ return 1;
}
/*-----------------------------------------------------------------*/
static void
positionRegs (symbol * result, symbol * opsym, int lineno)
{
- int count = min (result->nRegs, opsym->nRegs);
- int i, j = 0, shared = 0;
-
- debugLog ("%s\n", __FUNCTION__);
- /* if the result has been spilt then cannot share */
- if (opsym->isspilt)
- return;
+ int count = min (result->nRegs, opsym->nRegs);
+ int i, j = 0, shared = 0;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* if the result has been spilt then cannot share */
+ if (opsym->isspilt)
+ return;
again:
- shared = 0;
- /* first make sure that they actually share */
- for (i = 0; i < count; i++)
- {
- for (j = 0; j < count; j++)
+ shared = 0;
+ /* first make sure that they actually share */
+ for (i = 0; i < count; i++)
{
- if (result->regs[i] == opsym->regs[j] && i != j)
- {
- shared = 1;
- goto xchgPositions;
- }
+ for (j = 0; j < count; j++)
+ {
+ if (result->regs[i] == opsym->regs[j] && i != j)
+ {
+ shared = 1;
+ goto xchgPositions;
+ }
+ }
}
- }
xchgPositions:
- if (shared)
- {
- regs *tmp = result->regs[i];
- result->regs[i] = result->regs[j];
- result->regs[j] = tmp;
- goto again;
- }
+ if (shared)
+ {
+ regs *tmp = result->regs[i];
+ result->regs[i] = result->regs[j];
+ result->regs[j] = tmp;
+ goto again;
+ }
}
/*-----------------------------------------------------------------*/
static void
serialRegAssign (eBBlock ** ebbs, int count)
{
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- /* for all blocks */
- for (i = 0; i < count; i++)
- {
-
- iCode *ic;
-
- if (ebbs[i]->noPath &&
- (ebbs[i]->entryLabel != entryLabel &&
- ebbs[i]->entryLabel != returnLabel))
- continue;
-
- /* of all instructions do */
- for (ic = ebbs[i]->sch; ic; ic = ic->next)
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* for all blocks */
+ for (i = 0; i < count; i++)
{
-
- debugLog (" op: %s\n", decodeOp (ic->op));
-
- /* if this is an ipop that means some live
- range will have to be assigned again */
- if (ic->op == IPOP)
- reassignLR (IC_LEFT (ic));
-
- /* if result is present && is a true symbol */
- if (IC_RESULT (ic) && ic->op != IFX &&
- IS_TRUE_SYMOP (IC_RESULT (ic)))
- OP_SYMBOL (IC_RESULT (ic))->allocreq = 1;
-
- /* take away registers from live
- ranges that end at this instruction */
- deassignLRs (ic, ebbs[i]);
-
- /* some don't need registers */
- if (SKIP_IC2 (ic) ||
- ic->op == JUMPTABLE ||
- ic->op == IFX ||
- ic->op == IPUSH ||
- ic->op == IPOP ||
- (IC_RESULT (ic) && POINTER_SET (ic)))
- continue;
-
- /* now we need to allocate registers
- only for the result */
- if (IC_RESULT (ic))
- {
- symbol *sym = OP_SYMBOL (IC_RESULT (ic));
- bitVect *spillable;
- int willCS;
- int j;
- int ptrRegSet = 0;
-
- /* if it does not need or is spilt
- or is already assigned to registers
- or will not live beyond this instructions */
- if (!sym->nRegs ||
- sym->isspilt ||
- bitVectBitValue (_G.regAssigned, sym->key) ||
- sym->liveTo <= ic->seq)
- continue;
-
- /* if some liverange has been spilt at the block level
- and this one live beyond this block then spil this
- to be safe */
- if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
- {
- spillThis (sym);
- continue;
- }
- /* if trying to allocate this will cause
- a spill and there is nothing to spill
- or this one is rematerializable then
- spill this one */
- willCS = willCauseSpill (sym->nRegs, sym->regType);
- spillable = computeSpillable (ic);
- if (sym->remat ||
- (willCS && bitVectIsZero (spillable)))
+
+ iCode *ic;
+
+ if (ebbs[i]->noPath &&
+ (ebbs[i]->entryLabel != entryLabel &&
+ ebbs[i]->entryLabel != returnLabel))
+ continue;
+
+ /* of all instructions do */
+ for (ic = ebbs[i]->sch; ic; ic = ic->next)
{
-
- spillThis (sym);
- continue;
-
- }
-
- /* if it has a spillocation & is used less than
- all other live ranges then spill this */
- if (willCS) {
- if (sym->usl.spillLoc) {
- symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
- allLRs, ebbs[i], ic));
- if (leastUsed && leastUsed->used > sym->used) {
- spillThis (sym);
- continue;
- }
- } else {
- /* if none of the liveRanges have a spillLocation then better
- to spill this one than anything else already assigned to registers */
- if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
- /* if this is local to this block then we might find a block spil */
- if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
- spillThis (sym);
+
+ debugLog (" op: %s\n", decodeOp (ic->op));
+
+ /* if this is an ipop that means some live
+ range will have to be assigned again */
+ if (ic->op == IPOP)
+ reassignLR (IC_LEFT (ic));
+
+ /* if result is present && is a true symbol */
+ if (IC_RESULT (ic) && ic->op != IFX &&
+ IS_TRUE_SYMOP (IC_RESULT (ic)))
+ OP_SYMBOL (IC_RESULT (ic))->allocreq = 1;
+
+ /* take away registers from live
+ ranges that end at this instruction */
+ deassignLRs (ic, ebbs[i]);
+
+ /* some don't need registers */
+ if (SKIP_IC2 (ic) ||
+ ic->op == JUMPTABLE ||
+ ic->op == IFX ||
+ ic->op == IPUSH ||
+ ic->op == IPOP ||
+ (IC_RESULT (ic) && POINTER_SET (ic)))
continue;
- }
- }
- }
- }
-
- if (ic->op == RECEIVE)
- debugLog ("When I get clever, I'll optimize the receive logic\n");
-
- /* if we need ptr regs for the right side
- then mark it */
- if (POINTER_GET (ic) && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
- <= (unsigned) PTRSIZE)
- {
- pic14_ptrRegReq++;
- ptrRegSet = 1;
- }
- /* else we assign registers to it */
- _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
-
- debugLog (" %d - \n", __LINE__);
- if(debugF)
- bitVectDebugOn(_G.regAssigned, debugF);
- for (j = 0; j < sym->nRegs; j++)
- {
- if (sym->regType == REG_PTR)
- sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
- else
- sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
-
- /* if the allocation failed which means
- this was spilt then break */
- if (!sym->regs[j])
- break;
- }
- debugLog (" %d - \n", __LINE__);
-
- /* if it shares registers with operands make sure
- that they are in the same position */
- if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
- OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=')
- positionRegs (OP_SYMBOL (IC_RESULT (ic)),
- OP_SYMBOL (IC_LEFT (ic)), ic->lineno);
- /* do the same for the right operand */
- if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
- OP_SYMBOL (IC_RIGHT (ic))->nRegs && ic->op != '=')
- positionRegs (OP_SYMBOL (IC_RESULT (ic)),
- OP_SYMBOL (IC_RIGHT (ic)), ic->lineno);
-
- debugLog (" %d - \n", __LINE__);
- if (ptrRegSet)
- {
- debugLog (" %d - \n", __LINE__);
- pic14_ptrRegReq--;
- ptrRegSet = 0;
+
+ /* now we need to allocate registers
+ only for the result */
+ if (IC_RESULT (ic))
+ {
+ symbol *sym = OP_SYMBOL (IC_RESULT (ic));
+ bitVect *spillable;
+ int willCS;
+ int j;
+ int ptrRegSet = 0;
+
+ /* if it does not need or is spilt
+ or is already assigned to registers
+ or will not live beyond this instructions */
+ if (!sym->nRegs ||
+ sym->isspilt ||
+ bitVectBitValue (_G.regAssigned, sym->key) ||
+ sym->liveTo <= ic->seq)
+ continue;
+
+ /* if some liverange has been spilt at the block level
+ and this one live beyond this block then spil this
+ to be safe */
+ if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
+ {
+ spillThis (sym);
+ continue;
+ }
+ /* if trying to allocate this will cause
+ a spill and there is nothing to spill
+ or this one is rematerializable then
+ spill this one */
+ willCS = willCauseSpill (sym->nRegs, sym->regType);
+ spillable = computeSpillable (ic);
+ if (sym->remat ||
+ (willCS && bitVectIsZero (spillable)))
+ {
+
+ spillThis (sym);
+ continue;
+
+ }
+
+ /* if it has a spillocation & is used less than
+ all other live ranges then spill this */
+ if (willCS) {
+ if (sym->usl.spillLoc) {
+ symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
+ allLRs, ebbs[i], ic));
+ if (leastUsed && leastUsed->used > sym->used) {
+ spillThis (sym);
+ continue;
+ }
+ } else {
+ /* if none of the liveRanges have a spillLocation then better
+ to spill this one than anything else already assigned to registers */
+ if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
+ /* if this is local to this block then we might find a block spil */
+ if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
+ spillThis (sym);
+ continue;
+ }
+ }
+ }
+ }
+
+ if (ic->op == RECEIVE)
+ debugLog ("When I get clever, I'll optimize the receive logic\n");
+
+ /* if we need ptr regs for the right side
+ then mark it */
+ if (POINTER_GET (ic) && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
+ <= (unsigned) PTRSIZE)
+ {
+ pic14_ptrRegReq++;
+ ptrRegSet = 1;
+ }
+ /* else we assign registers to it */
+ _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
+
+ debugLog (" %d - \n", __LINE__);
+ if(debugF)
+ bitVectDebugOn(_G.regAssigned, debugF);
+ for (j = 0; j < sym->nRegs; j++)
+ {
+ if (sym->regType == REG_PTR)
+ sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
+ else
+ sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
+
+ /* if the allocation failed which means
+ this was spilt then break */
+ if (!sym->regs[j])
+ break;
+ }
+ debugLog (" %d - \n", __LINE__);
+
+ /* if it shares registers with operands make sure
+ that they are in the same position */
+ if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
+ OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=')
+ positionRegs (OP_SYMBOL (IC_RESULT (ic)),
+ OP_SYMBOL (IC_LEFT (ic)), ic->lineno);
+ /* do the same for the right operand */
+ if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
+ OP_SYMBOL (IC_RIGHT (ic))->nRegs && ic->op != '=')
+ positionRegs (OP_SYMBOL (IC_RESULT (ic)),
+ OP_SYMBOL (IC_RIGHT (ic)), ic->lineno);
+
+ debugLog (" %d - \n", __LINE__);
+ if (ptrRegSet)
+ {
+ debugLog (" %d - \n", __LINE__);
+ pic14_ptrRegReq--;
+ ptrRegSet = 0;
+ }
+
}
-
- }
}
- }
+ }
}
/*-----------------------------------------------------------------*/
static bitVect *
rUmaskForOp (operand * op)
{
- bitVect *rumask;
- symbol *sym;
- int j;
-
- debugLog ("%s\n", __FUNCTION__);
- /* only temporaries are assigned registers */
- if (!IS_ITEMP (op))
- return NULL;
-
- sym = OP_SYMBOL (op);
-
- /* if spilt or no registers assigned to it
- then nothing */
- if (sym->isspilt || !sym->nRegs)
- return NULL;
-
- rumask = newBitVect (pic14_nRegs);
-
- for (j = 0; j < sym->nRegs; j++)
- {
- rumask = bitVectSetBit (rumask,
- sym->regs[j]->rIdx);
- }
-
- return rumask;
-}
+ bitVect *rumask;
+ symbol *sym;
+ int j;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* only temporaries are assigned registers */
+ if (!IS_ITEMP (op))
+ return NULL;
+
+ sym = OP_SYMBOL (op);
+
+ /* if spilt or no registers assigned to it
+ then nothing */
+ if (sym->isspilt || !sym->nRegs)
+ return NULL;
+
+ rumask = newBitVect (pic14_nRegs);
+
+ for (j = 0; j < sym->nRegs; j++)
+ {
+ rumask = bitVectSetBit (rumask,
+ sym->regs[j]->rIdx);
+ }
+
+ return rumask;
+}
/*-----------------------------------------------------------------*/
/* regsUsedIniCode :- returns bit vector of registers used in iCode */
static bitVect *
regsUsedIniCode (iCode * ic)
{
- bitVect *rmask = newBitVect (pic14_nRegs);
-
- debugLog ("%s\n", __FUNCTION__);
- /* do the special cases first */
- if (ic->op == IFX)
- {
- rmask = bitVectUnion (rmask,
- rUmaskForOp (IC_COND (ic)));
- goto ret;
- }
-
- /* for the jumptable */
- if (ic->op == JUMPTABLE)
- {
- rmask = bitVectUnion (rmask,
- rUmaskForOp (IC_JTCOND (ic)));
-
- goto ret;
- }
-
- /* of all other cases */
- if (IC_LEFT (ic))
- rmask = bitVectUnion (rmask,
- rUmaskForOp (IC_LEFT (ic)));
-
-
- if (IC_RIGHT (ic))
- rmask = bitVectUnion (rmask,
- rUmaskForOp (IC_RIGHT (ic)));
-
- if (IC_RESULT (ic))
- rmask = bitVectUnion (rmask,
- rUmaskForOp (IC_RESULT (ic)));
-
+ bitVect *rmask = newBitVect (pic14_nRegs);
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* do the special cases first */
+ if (ic->op == IFX)
+ {
+ rmask = bitVectUnion (rmask,
+ rUmaskForOp (IC_COND (ic)));
+ goto ret;
+ }
+
+ /* for the jumptable */
+ if (ic->op == JUMPTABLE)
+ {
+ rmask = bitVectUnion (rmask,
+ rUmaskForOp (IC_JTCOND (ic)));
+
+ goto ret;
+ }
+
+ /* of all other cases */
+ if (IC_LEFT (ic))
+ rmask = bitVectUnion (rmask,
+ rUmaskForOp (IC_LEFT (ic)));
+
+
+ if (IC_RIGHT (ic))
+ rmask = bitVectUnion (rmask,
+ rUmaskForOp (IC_RIGHT (ic)));
+
+ if (IC_RESULT (ic))
+ rmask = bitVectUnion (rmask,
+ rUmaskForOp (IC_RESULT (ic)));
+
ret:
- return rmask;
+ return rmask;
}
/*-----------------------------------------------------------------*/
static void
createRegMask (eBBlock ** ebbs, int count)
{
- int i;
-
- debugLog ("%s\n", __FUNCTION__);
- /* for all blocks */
- for (i = 0; i < count; i++)
- {
- iCode *ic;
-
- if (ebbs[i]->noPath &&
- (ebbs[i]->entryLabel != entryLabel &&
- ebbs[i]->entryLabel != returnLabel))
- continue;
-
- /* for all instructions */
- for (ic = ebbs[i]->sch; ic; ic = ic->next)
+ int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* for all blocks */
+ for (i = 0; i < count; i++)
{
-
- int j;
-
- if (SKIP_IC2 (ic) || !ic->rlive)
- continue;
-
- /* first mark the registers used in this
- instruction */
- ic->rUsed = regsUsedIniCode (ic);
- _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
-
- /* now create the register mask for those
- registers that are in use : this is a
- super set of ic->rUsed */
- ic->rMask = newBitVect (pic14_nRegs + 1);
-
- /* for all live Ranges alive at this point */
- for (j = 1; j < ic->rlive->size; j++)
- {
- symbol *sym;
- int k;
-
- /* if not alive then continue */
- if (!bitVectBitValue (ic->rlive, j))
- continue;
-
- /* find the live range we are interested in */
- if (!(sym = hTabItemWithKey (liveRanges, j)))
+ iCode *ic;
+
+ if (ebbs[i]->noPath &&
+ (ebbs[i]->entryLabel != entryLabel &&
+ ebbs[i]->entryLabel != returnLabel))
+ continue;
+
+ /* for all instructions */
+ for (ic = ebbs[i]->sch; ic; ic = ic->next)
{
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
- "createRegMask cannot find live range");
- exit (0);
+
+ int j;
+
+ if (SKIP_IC2 (ic) || !ic->rlive)
+ continue;
+
+ /* first mark the registers used in this
+ instruction */
+ ic->rUsed = regsUsedIniCode (ic);
+ _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
+
+ /* now create the register mask for those
+ registers that are in use : this is a
+ super set of ic->rUsed */
+ ic->rMask = newBitVect (pic14_nRegs + 1);
+
+ /* for all live Ranges alive at this point */
+ for (j = 1; j < ic->rlive->size; j++)
+ {
+ symbol *sym;
+ int k;
+
+ /* if not alive then continue */
+ if (!bitVectBitValue (ic->rlive, j))
+ continue;
+
+ /* find the live range we are interested in */
+ if (!(sym = hTabItemWithKey (liveRanges, j)))
+ {
+ werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+ "createRegMask cannot find live range");
+ exit (0);
+ }
+
+ /* if no register assigned to it */
+ if (!sym->nRegs || sym->isspilt)
+ continue;
+
+ /* for all the registers allocated to it */
+ for (k = 0; k < sym->nRegs; k++)
+ if (sym->regs[k])
+ ic->rMask =
+ bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
+ }
}
-
- /* if no register assigned to it */
- if (!sym->nRegs || sym->isspilt)
- continue;
-
- /* for all the registers allocated to it */
- for (k = 0; k < sym->nRegs; k++)
- if (sym->regs[k])
- ic->rMask =
- bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
- }
}
- }
}
/*-----------------------------------------------------------------*/
static symbol *
rematStr (symbol * sym)
{
- char *s = buffer;
- iCode *ic = sym->rematiCode;
- symbol *psym = NULL;
-
- debugLog ("%s\n", __FUNCTION__);
-
- //printf ("%s\n", s);
-
- /* if plus or minus print the right hand side */
-
- if (ic->op == '+' || ic->op == '-') {
+ char *s = buffer;
+ iCode *ic = sym->rematiCode;
+ symbol *psym = NULL;
- iCode *ric = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
-
- sprintf (s, "(%s %c 0x%04x)",
- OP_SYMBOL (IC_LEFT (ric))->rname,
- ic->op,
- (int) operandLitValue (IC_RIGHT (ic)));
-
-
- //fprintf(stderr, "ralloc.c:%d OOPS %s\n",__LINE__,s);
-
- psym = newSymbol (OP_SYMBOL (IC_LEFT (ric))->rname, 1);
- psym->offset = (int) operandLitValue (IC_RIGHT (ic));
-
- return psym;
- }
-
- sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
- psym = newSymbol (OP_SYMBOL (IC_LEFT (ic))->rname, 1);
-
- //printf ("ralloc.c:%d %s\n", __LINE__,buffer);
- return psym;
+ debugLog ("%s\n", __FUNCTION__);
+
+ //printf ("%s\n", s);
+
+ /* if plus or minus print the right hand side */
+
+ if (ic->op == '+' || ic->op == '-') {
+
+ iCode *ric = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
+
+ sprintf (s, "(%s %c 0x%04x)",
+ OP_SYMBOL (IC_LEFT (ric))->rname,
+ ic->op,
+ (int) operandLitValue (IC_RIGHT (ic)));
+
+
+ //fprintf(stderr, "ralloc.c:%d OOPS %s\n",__LINE__,s);
+
+ psym = newSymbol (OP_SYMBOL (IC_LEFT (ric))->rname, 1);
+ psym->offset = (int) operandLitValue (IC_RIGHT (ic));
+
+ return psym;
+ }
+
+ sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
+ psym = newSymbol (OP_SYMBOL (IC_LEFT (ic))->rname, 1);
+
+ //printf ("ralloc.c:%d %s\n", __LINE__,buffer);
+ return psym;
}
#if 0
static char *
rematStr (symbol * sym)
{
- char *s = buffer;
- iCode *ic = sym->rematiCode;
-
- debugLog ("%s\n", __FUNCTION__);
- while (1)
- {
-
- printf ("%s\n", s);
- /* if plus or minus print the right hand side */
-/*
- if (ic->op == '+' || ic->op == '-') {
- sprintf(s,"0x%04x %c ",(int) operandLitValue(IC_RIGHT(ic)),
- ic->op );
- s += strlen(s);
- ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
- continue ;
- }
- */
- if (ic->op == '+' || ic->op == '-')
+ char *s = buffer;
+ iCode *ic = sym->rematiCode;
+
+ debugLog ("%s\n", __FUNCTION__);
+ while (1)
{
- iCode *ric = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
- sprintf (s, "(%s %c 0x%04x)",
- OP_SYMBOL (IC_LEFT (ric))->rname,
- ic->op,
- (int) operandLitValue (IC_RIGHT (ic)));
-
- //s += strlen(s);
- //ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
- //continue ;
- //fprintf(stderr, "ralloc.c:%d OOPS %s\n",__LINE__,s);
- return buffer;
+
+ printf ("%s\n", s);
+ /* if plus or minus print the right hand side */
+ /*
+ if (ic->op == '+' || ic->op == '-') {
+ sprintf(s,"0x%04x %c ",(int) operandLitValue(IC_RIGHT(ic)),
+ ic->op );
+ s += strlen(s);
+ ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
+ continue ;
+ }
+ */
+ if (ic->op == '+' || ic->op == '-')
+ {
+ iCode *ric = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
+ sprintf (s, "(%s %c 0x%04x)",
+ OP_SYMBOL (IC_LEFT (ric))->rname,
+ ic->op,
+ (int) operandLitValue (IC_RIGHT (ic)));
+
+ //s += strlen(s);
+ //ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
+ //continue ;
+ //fprintf(stderr, "ralloc.c:%d OOPS %s\n",__LINE__,s);
+ return buffer;
+ }
+
+ /* we reached the end */
+ sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
+ break;
}
-
- /* we reached the end */
- sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
- break;
- }
-
- printf ("%s\n", buffer);
- return buffer;
+
+ printf ("%s\n", buffer);
+ return buffer;
}
#endif
static void
regTypeNum ()
{
- symbol *sym;
- int k;
- iCode *ic;
-
- debugLog ("%s\n", __FUNCTION__);
- /* for each live range do */
- for (sym = hTabFirstItem (liveRanges, &k); sym;
- sym = hTabNextItem (liveRanges, &k)) {
-
- debugLog (" %d - %s\n", __LINE__, sym->rname);
-
- /* if used zero times then no registers needed */
- if ((sym->liveTo - sym->liveFrom) == 0)
- continue;
-
-
- /* if the live range is a temporary */
- if (sym->isitmp) {
-
- debugLog (" %d - itemp register\n", __LINE__);
-
- /* if the type is marked as a conditional */
- if (sym->regType == REG_CND)
- continue;
-
- /* if used in return only then we don't
- need registers */
- if (sym->accuse) {
- if (IS_AGGREGATE (sym->type) || sym->isptr)
- sym->type = aggrToPtr (sym->type, FALSE);
- debugLog (" %d - no reg needed - accumulator used\n", __LINE__);
-
- continue;
- }
-
- if (sym->ruonly) {
- //if (IS_AGGREGATE (sym->type) || sym->isptr)
- // sym->type = aggrToPtr (sym->type, FALSE);
- debugLog (" %d - used as a return\n", __LINE__);
-
- //continue;
- }
-
- /* if the symbol has only one definition &
- that definition is a get_pointer and the
- pointer we are getting is rematerializable and
- in "data" space */
-
- if (bitVectnBitsOn (sym->defs) == 1 &&
- (ic = hTabItemWithKey (iCodehTab,
- bitVectFirstBit (sym->defs))) &&
- POINTER_GET (ic) &&
- !sym->noSpilLoc &&
- !IS_BITVAR (sym->etype)) {
+ symbol *sym;
+ int k;
+ iCode *ic;
-
- debugLog (" %d - \n", __LINE__);
-
- /* if remat in data space */
- if (OP_SYMBOL (IC_LEFT (ic))->remat &&
- DCL_TYPE (aggrToPtr (sym->type, FALSE)) == POINTER) {
-
- /* create a psuedo symbol & force a spil */
- //X symbol *psym = newSymbol (rematStr (OP_SYMBOL (IC_LEFT (ic))), 1);
- symbol *psym = rematStr (OP_SYMBOL (IC_LEFT (ic)));
- psym->type = sym->type;
- psym->etype = sym->etype;
- strcpy (psym->rname, psym->name);
- sym->isspilt = 1;
- sym->usl.spillLoc = psym;
- continue;
- }
-
- /* if in data space or idata space then try to
- allocate pointer register */
-
- }
-
- /* if not then we require registers */
- sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
- getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
- getSize (sym->type));
-
-
- if(IS_PTR_CONST (sym->type)) {
- debugLog (" %d const pointer type requires %d registers, changing to 2\n",__LINE__,sym->nRegs);
- sym->nRegs = 2;
- }
-
- if (sym->nRegs > 4) {
- fprintf (stderr, "allocated more than 4 or 0 registers for type ");
- printTypeChain (sym->type, stderr);
- fprintf (stderr, "\n");
- }
-
- /* determine the type of register required */
- if (sym->nRegs == 1 &&
- IS_PTR (sym->type) &&
- sym->uptr)
- sym->regType = REG_PTR;
- else
- sym->regType = REG_GPR;
-
-
- debugLog (" reg name %s, reg type %s\n", sym->rname, debugLogRegType (sym->regType));
-
- }
- else
- /* for the first run we don't provide */
- /* registers for true symbols we will */
- /* see how things go */
- sym->nRegs = 0;
+ debugLog ("%s\n", __FUNCTION__);
+ /* for each live range do */
+ for (sym = hTabFirstItem (liveRanges, &k); sym;
+ sym = hTabNextItem (liveRanges, &k)) {
+
+ debugLog (" %d - %s\n", __LINE__, sym->rname);
+
+ /* if used zero times then no registers needed */
+ if ((sym->liveTo - sym->liveFrom) == 0)
+ continue;
+
+
+ /* if the live range is a temporary */
+ if (sym->isitmp) {
+
+ debugLog (" %d - itemp register\n", __LINE__);
+
+ /* if the type is marked as a conditional */
+ if (sym->regType == REG_CND)
+ continue;
+
+ /* if used in return only then we don't
+ need registers */
+ if (sym->accuse) {
+ if (IS_AGGREGATE (sym->type) || sym->isptr)
+ sym->type = aggrToPtr (sym->type, FALSE);
+ debugLog (" %d - no reg needed - accumulator used\n", __LINE__);
+
+ continue;
+ }
+
+ if (sym->ruonly) {
+ //if (IS_AGGREGATE (sym->type) || sym->isptr)
+ // sym->type = aggrToPtr (sym->type, FALSE);
+ debugLog (" %d - used as a return\n", __LINE__);
+
+ //continue;
+ }
+
+ /* if the symbol has only one definition &
+ that definition is a get_pointer and the
+ pointer we are getting is rematerializable and
+ in "data" space */
+
+ if (bitVectnBitsOn (sym->defs) == 1 &&
+ (ic = hTabItemWithKey (iCodehTab,
+ bitVectFirstBit (sym->defs))) &&
+ POINTER_GET (ic) &&
+ !sym->noSpilLoc &&
+ !IS_BITVAR (sym->etype)) {
+
+
+ debugLog (" %d - \n", __LINE__);
+
+ /* if remat in data space */
+ if (OP_SYMBOL (IC_LEFT (ic))->remat &&
+ DCL_TYPE (aggrToPtr (sym->type, FALSE)) == POINTER) {
+
+ /* create a psuedo symbol & force a spil */
+ //X symbol *psym = newSymbol (rematStr (OP_SYMBOL (IC_LEFT (ic))), 1);
+ symbol *psym = rematStr (OP_SYMBOL (IC_LEFT (ic)));
+ psym->type = sym->type;
+ psym->etype = sym->etype;
+ strcpy (psym->rname, psym->name);
+ sym->isspilt = 1;
+ sym->usl.spillLoc = psym;
+ continue;
+ }
+
+ /* if in data space or idata space then try to
+ allocate pointer register */
+
+ }
+
+ /* if not then we require registers */
+ sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
+ getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
+ getSize (sym->type));
+
+
+ if(IS_PTR_CONST (sym->type)) {
+ debugLog (" %d const pointer type requires %d registers, changing to 2\n",__LINE__,sym->nRegs);
+ sym->nRegs = 2;
+ }
+
+ if (sym->nRegs > 4) {
+ fprintf (stderr, "allocated more than 4 or 0 registers for type ");
+ printTypeChain (sym->type, stderr);
+ fprintf (stderr, "\n");
+ }
+
+ /* determine the type of register required */
+ if (sym->nRegs == 1 &&
+ IS_PTR (sym->type) &&
+ sym->uptr)
+ sym->regType = REG_PTR;
+ else
+ sym->regType = REG_GPR;
+
+
+ debugLog (" reg name %s, reg type %s\n", sym->rname, debugLogRegType (sym->regType));
+
+ }
+ else
+ /* for the first run we don't provide */
+ /* registers for true symbols we will */
+ /* see how things go */
+ sym->nRegs = 0;
}
-
+
}
DEFSETFUNC (markRegFree)
{
- ((regs *)item)->isFree = 1;
-
- return 0;
+ ((regs *)item)->isFree = 1;
+
+ return 0;
}
DEFSETFUNC (deallocReg)
{
- fprintf(stderr,"deallocting register %s\n",((regs *)item)->name);
- ((regs *)item)->isFree = 1;
- ((regs *)item)->wasUsed = 0;
-
- return 0;
+ fprintf(stderr,"deallocting register %s\n",((regs *)item)->name);
+ ((regs *)item)->isFree = 1;
+ ((regs *)item)->wasUsed = 0;
+
+ return 0;
}
/*-----------------------------------------------------------------*/
/* freeAllRegs - mark all registers as free */
void
pic14_freeAllRegs ()
{
- // int i;
-
- debugLog ("%s\n", __FUNCTION__);
-
- applyToSet(dynAllocRegs,markRegFree);
- applyToSet(dynStackRegs,markRegFree);
-
-/*
- for (i = 0; i < pic14_nRegs; i++)
- regspic14[i].isFree = 1;
-*/
+ // int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+
+ applyToSet(dynAllocRegs,markRegFree);
+ applyToSet(dynStackRegs,markRegFree);
+
+ /*
+ for (i = 0; i < pic14_nRegs; i++)
+ regspic14[i].isFree = 1;
+ */
}
/*-----------------------------------------------------------------*/
void
pic14_deallocateAllRegs ()
{
- // int i;
-
- debugLog ("%s\n", __FUNCTION__);
-
- applyToSet(dynAllocRegs,deallocReg);
-
-/*
- for (i = 0; i < pic14_nRegs; i++) {
- if(regspic14[i].pc_type == PO_GPR_TEMP) {
- regspic14[i].isFree = 1;
- regspic14[i].wasUsed = 0;
- }
- }
-*/
+ // int i;
+
+ debugLog ("%s\n", __FUNCTION__);
+
+ applyToSet(dynAllocRegs,deallocReg);
+
+ /*
+ for (i = 0; i < pic14_nRegs; i++) {
+ if(regspic14[i].pc_type == PO_GPR_TEMP) {
+ regspic14[i].isFree = 1;
+ regspic14[i].wasUsed = 0;
+ }
+ }
+ */
}
static
DEFSETFUNC (deallocStackSpil)
{
- symbol *sym = item;
-
- debugLog ("%s\n", __FUNCTION__);
- deallocLocal (sym);
- return 0;
+ symbol *sym = item;
+
+ debugLog ("%s\n", __FUNCTION__);
+ deallocLocal (sym);
+ return 0;
}
/*-----------------------------------------------------------------*/
static iCode *
farSpacePackable (iCode * ic)
{
- iCode *dic;
-
- debugLog ("%s\n", __FUNCTION__);
- /* go thru till we find a definition for the
- symbol on the right */
- for (dic = ic->prev; dic; dic = dic->prev)
- {
-
- /* if the definition is a call then no */
- if ((dic->op == CALL || dic->op == PCALL) &&
- IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
+ iCode *dic;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* go thru till we find a definition for the
+ symbol on the right */
+ for (dic = ic->prev; dic; dic = dic->prev)
{
- return NULL;
+
+ /* if the definition is a call then no */
+ if ((dic->op == CALL || dic->op == PCALL) &&
+ IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
+ {
+ return NULL;
+ }
+
+ /* if shift by unknown amount then not */
+ if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
+ IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
+ return NULL;
+
+ /* if pointer get and size > 1 */
+ if (POINTER_GET (dic) &&
+ getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
+ return NULL;
+
+ if (POINTER_SET (dic) &&
+ getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
+ return NULL;
+
+ /* if any three is a true symbol in far space */
+ if (IC_RESULT (dic) &&
+ IS_TRUE_SYMOP (IC_RESULT (dic)) &&
+ isOperandInFarSpace (IC_RESULT (dic)))
+ return NULL;
+
+ if (IC_RIGHT (dic) &&
+ IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
+ isOperandInFarSpace (IC_RIGHT (dic)) &&
+ !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
+ return NULL;
+
+ if (IC_LEFT (dic) &&
+ IS_TRUE_SYMOP (IC_LEFT (dic)) &&
+ isOperandInFarSpace (IC_LEFT (dic)) &&
+ !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
+ return NULL;
+
+ if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
+ {
+ if ((dic->op == LEFT_OP ||
+ dic->op == RIGHT_OP ||
+ dic->op == '-') &&
+ IS_OP_LITERAL (IC_RIGHT (dic)))
+ return NULL;
+ else
+ return dic;
+ }
}
-
- /* if shift by unknown amount then not */
- if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
- IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
- return NULL;
-
- /* if pointer get and size > 1 */
- if (POINTER_GET (dic) &&
- getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
- return NULL;
-
- if (POINTER_SET (dic) &&
- getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
- return NULL;
-
- /* if any three is a true symbol in far space */
- if (IC_RESULT (dic) &&
- IS_TRUE_SYMOP (IC_RESULT (dic)) &&
- isOperandInFarSpace (IC_RESULT (dic)))
- return NULL;
-
- if (IC_RIGHT (dic) &&
- IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
- isOperandInFarSpace (IC_RIGHT (dic)) &&
- !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
- return NULL;
-
- if (IC_LEFT (dic) &&
- IS_TRUE_SYMOP (IC_LEFT (dic)) &&
- isOperandInFarSpace (IC_LEFT (dic)) &&
- !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
+
return NULL;
-
- if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
- {
- if ((dic->op == LEFT_OP ||
- dic->op == RIGHT_OP ||
- dic->op == '-') &&
- IS_OP_LITERAL (IC_RIGHT (dic)))
- return NULL;
- else
- return dic;
- }
- }
-
- return NULL;
}
/*-----------------------------------------------------------------*/
static int
packRegsForAssign (iCode * ic, eBBlock * ebp)
{
-
- iCode *dic, *sic;
-
- debugLog ("%s\n", __FUNCTION__);
-
- debugAopGet (" result:", IC_RESULT (ic));
- debugAopGet (" left:", IC_LEFT (ic));
- debugAopGet (" right:", IC_RIGHT (ic));
-
- /* if this is at an absolute address, then get the address. */
- if (SPEC_ABSA ( OP_SYM_ETYPE(IC_RESULT(ic))) ) {
- if(IS_CONFIG_ADDRESS( SPEC_ADDR ( OP_SYM_ETYPE(IC_RESULT(ic))))) {
- debugLog (" %d - found config word declaration\n", __LINE__);
- if(IS_VALOP(IC_RIGHT(ic))) {
- debugLog (" setting config word to %x\n",
- (int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
- assignConfigWordValue( SPEC_ADDR ( OP_SYM_ETYPE(IC_RESULT(ic))),
- (int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
- }
-
- /* remove the assignment from the iCode chain. */
-
- remiCodeFromeBBlock (ebp, ic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
- hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
-
- return 1;
-
- }
- }
-
- if (!IS_ITEMP (IC_RESULT (ic))) {
- allocDirReg(IC_RESULT (ic));
- debugLog (" %d - result is not temp\n", __LINE__);
- }
-/*
- if (IC_LEFT (ic) && !IS_ITEMP (IC_LEFT (ic))) {
- debugLog (" %d - left is not temp, allocating\n", __LINE__);
- allocDirReg(IC_LEFT (ic));
- }
-*/
-
- if (!IS_ITEMP (IC_RIGHT (ic))) {
- debugLog (" %d - not packing - right is not temp\n", __LINE__);
-
- /* only pack if this is not a function pointer */
- if (!IS_REF (IC_RIGHT (ic)))
- allocDirReg(IC_RIGHT (ic));
- return 0;
- }
-
- if (OP_SYMBOL (IC_RIGHT (ic))->isind ||
- OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
- {
- debugLog (" %d - not packing - right side fails \n", __LINE__);
- return 0;
- }
-
- /* if the true symbol is defined in far space or on stack
- then we should not since this will increase register pressure */
- if (isOperandInFarSpace (IC_RESULT (ic)))
- {
- if ((dic = farSpacePackable (ic)))
- goto pack;
- else
- return 0;
-
- }
- /* find the definition of iTempNN scanning backwards if we find a
- a use of the true symbol before we find the definition then
- we cannot pack */
- for (dic = ic->prev; dic; dic = dic->prev)
- {
-
- /* if there is a function call and this is
- a parameter & not my parameter then don't pack it */
- if ((dic->op == CALL || dic->op == PCALL) &&
- (OP_SYMBOL (IC_RESULT (ic))->_isparm &&
- !OP_SYMBOL (IC_RESULT (ic))->ismyparm))
+
+ iCode *dic, *sic;
+
+ debugLog ("%s\n", __FUNCTION__);
+
+ debugAopGet (" result:", IC_RESULT (ic));
+ debugAopGet (" left:", IC_LEFT (ic));
+ debugAopGet (" right:", IC_RIGHT (ic));
+
+ /* if this is at an absolute address, then get the address. */
+ if (SPEC_ABSA ( OP_SYM_ETYPE(IC_RESULT(ic))) ) {
+ if(IS_CONFIG_ADDRESS( SPEC_ADDR ( OP_SYM_ETYPE(IC_RESULT(ic))))) {
+ debugLog (" %d - found config word declaration\n", __LINE__);
+ if(IS_VALOP(IC_RIGHT(ic))) {
+ debugLog (" setting config word to %x\n",
+ (int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
+ assignConfigWordValue( SPEC_ADDR ( OP_SYM_ETYPE(IC_RESULT(ic))),
+ (int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
+ }
+
+ /* remove the assignment from the iCode chain. */
+
+ remiCodeFromeBBlock (ebp, ic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
+ hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
+
+ return 1;
+
+ }
+ }
+
+ if (!IS_ITEMP (IC_RESULT (ic))) {
+ allocDirReg(IC_RESULT (ic));
+ debugLog (" %d - result is not temp\n", __LINE__);
+ }
+ /*
+ if (IC_LEFT (ic) && !IS_ITEMP (IC_LEFT (ic))) {
+ debugLog (" %d - left is not temp, allocating\n", __LINE__);
+ allocDirReg(IC_LEFT (ic));
+ }
+ */
+
+ if (!IS_ITEMP (IC_RIGHT (ic))) {
+ debugLog (" %d - not packing - right is not temp\n", __LINE__);
+
+ /* only pack if this is not a function pointer */
+ if (!IS_REF (IC_RIGHT (ic)))
+ allocDirReg(IC_RIGHT (ic));
+ return 0;
+ }
+
+ if (OP_SYMBOL (IC_RIGHT (ic))->isind ||
+ OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
{
- debugLog (" %d - \n", __LINE__);
- dic = NULL;
- break;
+ debugLog (" %d - not packing - right side fails \n", __LINE__);
+ return 0;
}
-
- if (SKIP_IC2 (dic))
- continue;
-
- if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
- IS_OP_VOLATILE (IC_RESULT (dic)))
+
+ /* if the true symbol is defined in far space or on stack
+ then we should not since this will increase register pressure */
+ if (isOperandInFarSpace (IC_RESULT (ic)))
{
- debugLog (" %d - dic is VOLATILE \n", __LINE__);
- dic = NULL;
- break;
+ if ((dic = farSpacePackable (ic)))
+ goto pack;
+ else
+ return 0;
+
}
-
- if (IS_SYMOP (IC_RESULT (dic)) &&
- IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
+ /* find the definition of iTempNN scanning backwards if we find a
+ a use of the true symbol before we find the definition then
+ we cannot pack */
+ for (dic = ic->prev; dic; dic = dic->prev)
{
- /* A previous result was assigned to the same register - we'll our definition */
- debugLog (" %d - dic result key == ic right key -- pointer set=%c\n",
- __LINE__, ((POINTER_SET (dic)) ? 'Y' : 'N'));
- if (POINTER_SET (dic))
- dic = NULL;
-
- break;
+
+ /* if there is a function call and this is
+ a parameter & not my parameter then don't pack it */
+ if ((dic->op == CALL || dic->op == PCALL) &&
+ (OP_SYMBOL (IC_RESULT (ic))->_isparm &&
+ !OP_SYMBOL (IC_RESULT (ic))->ismyparm))
+ {
+ debugLog (" %d - \n", __LINE__);
+ dic = NULL;
+ break;
+ }
+
+ if (SKIP_IC2 (dic))
+ continue;
+
+ if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
+ IS_OP_VOLATILE (IC_RESULT (dic)))
+ {
+ debugLog (" %d - dic is VOLATILE \n", __LINE__);
+ dic = NULL;
+ break;
+ }
+
+ if (IS_SYMOP (IC_RESULT (dic)) &&
+ IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
+ {
+ /* A previous result was assigned to the same register - we'll our definition */
+ debugLog (" %d - dic result key == ic right key -- pointer set=%c\n",
+ __LINE__, ((POINTER_SET (dic)) ? 'Y' : 'N'));
+ if (POINTER_SET (dic))
+ dic = NULL;
+
+ break;
+ }
+
+ if (IS_SYMOP (IC_RIGHT (dic)) &&
+ (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
+ IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
+ {
+ debugLog (" %d - dic right key == ic rightor result key\n", __LINE__);
+ dic = NULL;
+ break;
+ }
+
+ if (IS_SYMOP (IC_LEFT (dic)) &&
+ (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
+ IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
+ {
+ debugLog (" %d - dic left key == ic rightor result key\n", __LINE__);
+ dic = NULL;
+ break;
+ }
+
+ if (POINTER_SET (dic) &&
+ IC_RESULT (dic)->key == IC_RESULT (ic)->key)
+ {
+ debugLog (" %d - dic result key == ic result key -- pointer set=Y\n",
+ __LINE__);
+ dic = NULL;
+ break;
+ }
}
-
- if (IS_SYMOP (IC_RIGHT (dic)) &&
- (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
- IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
+
+ if (!dic)
+ return 0; /* did not find */
+
+ /* if the result is on stack or iaccess then it must be
+ the same atleast one of the operands */
+ if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
+ OP_SYMBOL (IC_RESULT (ic))->iaccess)
{
- debugLog (" %d - dic right key == ic rightor result key\n", __LINE__);
- dic = NULL;
- break;
+
+ /* the operation has only one symbol
+ operator then we can pack */
+ if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
+ (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
+ goto pack;
+
+ if (!((IC_LEFT (dic) &&
+ IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
+ (IC_RIGHT (dic) &&
+ IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
+ return 0;
}
-
- if (IS_SYMOP (IC_LEFT (dic)) &&
- (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
- IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
+pack:
+ debugLog (" packing. removing %s\n", OP_SYMBOL (IC_RIGHT (ic))->rname);
+ debugLog (" replacing with %s\n", OP_SYMBOL (IC_RESULT (dic))->rname);
+ /* found the definition */
+ /* replace the result with the result of */
+ /* this assignment and remove this assignment */
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+ IC_RESULT (dic) = IC_RESULT (ic);
+
+ if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
{
- debugLog (" %d - dic left key == ic rightor result key\n", __LINE__);
- dic = NULL;
- break;
+ OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
}
-
- if (POINTER_SET (dic) &&
- IC_RESULT (dic)->key == IC_RESULT (ic)->key)
+ /* delete from liverange table also
+ delete from all the points inbetween and the new
+ one */
+ for (sic = dic; sic != ic; sic = sic->next)
{
- debugLog (" %d - dic result key == ic result key -- pointer set=Y\n",
- __LINE__);
- dic = NULL;
- break;
+ bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
+ if (IS_ITEMP (IC_RESULT (dic)))
+ bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
}
- }
-
- if (!dic)
- return 0; /* did not find */
-
- /* if the result is on stack or iaccess then it must be
- the same atleast one of the operands */
- if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
- OP_SYMBOL (IC_RESULT (ic))->iaccess)
- {
-
- /* the operation has only one symbol
- operator then we can pack */
- if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
- (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
- goto pack;
-
- if (!((IC_LEFT (dic) &&
- IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
- (IC_RIGHT (dic) &&
- IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
- return 0;
- }
-pack:
- debugLog (" packing. removing %s\n", OP_SYMBOL (IC_RIGHT (ic))->rname);
- debugLog (" replacing with %s\n", OP_SYMBOL (IC_RESULT (dic))->rname);
- /* found the definition */
- /* replace the result with the result of */
- /* this assignment and remove this assignment */
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- IC_RESULT (dic) = IC_RESULT (ic);
-
- if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
- {
- OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
- }
- /* delete from liverange table also
- delete from all the points inbetween and the new
- one */
- for (sic = dic; sic != ic; sic = sic->next)
- {
- bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
- if (IS_ITEMP (IC_RESULT (dic)))
- bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
- }
-
- remiCodeFromeBBlock (ebp, ic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
- hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
- OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
- return 1;
-
-
-}
+
+ remiCodeFromeBBlock (ebp, ic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
+ hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
+ OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+ return 1;
+
+
+}
/*-----------------------------------------------------------------*/
/* findAssignToSym : scanning backwards looks for first assig found */
static iCode *
findAssignToSym (operand * op, iCode * ic)
{
- iCode *dic;
-
- debugLog ("%s\n", __FUNCTION__);
- for (dic = ic->prev; dic; dic = dic->prev)
- {
-
- /* if definition by assignment */
- if (dic->op == '=' &&
- !POINTER_SET (dic) &&
- IC_RESULT (dic)->key == op->key
-/* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
- )
+ iCode *dic;
+
+ debugLog ("%s\n", __FUNCTION__);
+ for (dic = ic->prev; dic; dic = dic->prev)
{
-
- /* we are interested only if defined in far space */
- /* or in stack space in case of + & - */
-
- /* if assigned to a non-symbol then return
- true */
- if (!IS_SYMOP (IC_RIGHT (dic)))
- break;
-
- /* if the symbol is in far space then
- we should not */
- if (isOperandInFarSpace (IC_RIGHT (dic)))
- return NULL;
-
- /* for + & - operations make sure that
- if it is on the stack it is the same
- as one of the three operands */
- if ((ic->op == '+' || ic->op == '-') &&
- OP_SYMBOL (IC_RIGHT (dic))->onStack)
- {
-
- if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
- IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
- IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
- return NULL;
- }
-
- break;
-
+
+ /* if definition by assignment */
+ if (dic->op == '=' &&
+ !POINTER_SET (dic) &&
+ IC_RESULT (dic)->key == op->key
+ /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
+ )
+ {
+
+ /* we are interested only if defined in far space */
+ /* or in stack space in case of + & - */
+
+ /* if assigned to a non-symbol then return
+ true */
+ if (!IS_SYMOP (IC_RIGHT (dic)))
+ break;
+
+ /* if the symbol is in far space then
+ we should not */
+ if (isOperandInFarSpace (IC_RIGHT (dic)))
+ return NULL;
+
+ /* for + & - operations make sure that
+ if it is on the stack it is the same
+ as one of the three operands */
+ if ((ic->op == '+' || ic->op == '-') &&
+ OP_SYMBOL (IC_RIGHT (dic))->onStack)
+ {
+
+ if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
+ IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
+ IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
+ return NULL;
+ }
+
+ break;
+
+ }
+
+ /* if we find an usage then we cannot delete it */
+ if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
+ return NULL;
+
+ if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
+ return NULL;
+
+ if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
+ return NULL;
}
-
- /* if we find an usage then we cannot delete it */
- if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
- return NULL;
-
- if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
- return NULL;
-
- if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
- return NULL;
- }
-
- /* now make sure that the right side of dic
- is not defined between ic & dic */
- if (dic)
- {
- iCode *sic = dic->next;
-
- for (; sic != ic; sic = sic->next)
- if (IC_RESULT (sic) &&
- IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
- return NULL;
- }
-
- return dic;
-
-
+
+ /* now make sure that the right side of dic
+ is not defined between ic & dic */
+ if (dic)
+ {
+ iCode *sic = dic->next;
+
+ for (; sic != ic; sic = sic->next)
+ if (IC_RESULT (sic) &&
+ IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
+ return NULL;
+ }
+
+ return dic;
+
+
}
/*-----------------------------------------------------------------*/
static int
packRegsForSupport (iCode * ic, eBBlock * ebp)
{
- int change = 0;
-
- debugLog ("%s\n", __FUNCTION__);
- /* for the left & right operand :- look to see if the
- left was assigned a true symbol in far space in that
- case replace them */
- if (IS_ITEMP (IC_LEFT (ic)) &&
- OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
- {
- iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
- iCode *sic;
-
- if (!dic)
- goto right;
-
- debugAopGet ("removing left:", IC_LEFT (ic));
-
- /* found it we need to remove it from the
- block */
- for (sic = dic; sic != ic; sic = sic->next)
- bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
-
- IC_LEFT (ic)->operand.symOperand =
- IC_RIGHT (dic)->operand.symOperand;
- IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
- remiCodeFromeBBlock (ebp, dic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
- change++;
- }
-
- /* do the same for the right operand */
+ int change = 0;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* for the left & right operand :- look to see if the
+ left was assigned a true symbol in far space in that
+ case replace them */
+ if (IS_ITEMP (IC_LEFT (ic)) &&
+ OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
+ {
+ iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
+ iCode *sic;
+
+ if (!dic)
+ goto right;
+
+ debugAopGet ("removing left:", IC_LEFT (ic));
+
+ /* found it we need to remove it from the
+ block */
+ for (sic = dic; sic != ic; sic = sic->next)
+ bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
+
+ IC_LEFT (ic)->operand.symOperand =
+ IC_RIGHT (dic)->operand.symOperand;
+ IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
+ remiCodeFromeBBlock (ebp, dic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+ hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
+ change++;
+ }
+
+ /* do the same for the right operand */
right:
- if (!change &&
- IS_ITEMP (IC_RIGHT (ic)) &&
- OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
- {
- iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
- iCode *sic;
-
- if (!dic)
- return change;
-
- /* if this is a subtraction & the result
- is a true symbol in far space then don't pack */
- if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
+ if (!change &&
+ IS_ITEMP (IC_RIGHT (ic)) &&
+ OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
{
- sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
- if (IN_FARSPACE (SPEC_OCLS (etype)))
- return change;
+ iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
+ iCode *sic;
+
+ if (!dic)
+ return change;
+
+ /* if this is a subtraction & the result
+ is a true symbol in far space then don't pack */
+ if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
+ {
+ sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
+ if (IN_FARSPACE (SPEC_OCLS (etype)))
+ return change;
+ }
+
+ debugAopGet ("removing right:", IC_RIGHT (ic));
+
+ /* found it we need to remove it from the
+ block */
+ for (sic = dic; sic != ic; sic = sic->next)
+ bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
+
+ IC_RIGHT (ic)->operand.symOperand =
+ IC_RIGHT (dic)->operand.symOperand;
+ IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
+
+ remiCodeFromeBBlock (ebp, dic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+ hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
+ change++;
}
-
- debugAopGet ("removing right:", IC_RIGHT (ic));
-
- /* found it we need to remove it from the
- block */
- for (sic = dic; sic != ic; sic = sic->next)
- bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
-
- IC_RIGHT (ic)->operand.symOperand =
- IC_RIGHT (dic)->operand.symOperand;
- IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
-
- remiCodeFromeBBlock (ebp, dic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
- change++;
- }
-
- return change;
+
+ return change;
}
#define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
static iCode *
packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
{
- bitVect *uses;
- iCode *dic, *sic;
-
- debugLog ("%s\n", __FUNCTION__);
- /* if returning a literal then do nothing */
- if (!IS_SYMOP (op))
- return NULL;
-
- /* only upto 2 bytes since we cannot predict
- the usage of b, & acc */
- if (getSize (operandType (op)) > (fReturnSizePic - 2) &&
- ic->op != RETURN &&
- ic->op != SEND)
- return NULL;
-
- /* this routine will mark the a symbol as used in one
- instruction use only && if the definition is local
- (ie. within the basic block) && has only one definition &&
- that definition is either a return value from a
- function or does not contain any variables in
- far space */
- uses = bitVectCopy (OP_USES (op));
- bitVectUnSetBit (uses, ic->key); /* take away this iCode */
- if (!bitVectIsZero (uses)) /* has other uses */
- return NULL;
-
- /* if it has only one defintion */
- if (bitVectnBitsOn (OP_DEFS (op)) > 1)
- return NULL; /* has more than one definition */
-
- /* get that definition */
- if (!(dic =
- hTabItemWithKey (iCodehTab,
- bitVectFirstBit (OP_DEFS (op)))))
- return NULL;
-
- /* found the definition now check if it is local */
- if (dic->seq < ebp->fSeq ||
- dic->seq > ebp->lSeq)
- return NULL; /* non-local */
-
- /* now check if it is the return from
- a function call */
- if (dic->op == CALL || dic->op == PCALL)
- {
- if (ic->op != SEND && ic->op != RETURN &&
- !POINTER_SET(ic) && !POINTER_GET(ic))
+ bitVect *uses;
+ iCode *dic, *sic;
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* if returning a literal then do nothing */
+ if (!IS_SYMOP (op))
+ return NULL;
+
+ /* only upto 2 bytes since we cannot predict
+ the usage of b, & acc */
+ if (getSize (operandType (op)) > (fReturnSizePic - 2) &&
+ ic->op != RETURN &&
+ ic->op != SEND)
+ return NULL;
+
+ /* this routine will mark the a symbol as used in one
+ instruction use only && if the definition is local
+ (ie. within the basic block) && has only one definition &&
+ that definition is either a return value from a
+ function or does not contain any variables in
+ far space */
+ uses = bitVectCopy (OP_USES (op));
+ bitVectUnSetBit (uses, ic->key); /* take away this iCode */
+ if (!bitVectIsZero (uses)) /* has other uses */
+ return NULL;
+
+ /* if it has only one defintion */
+ if (bitVectnBitsOn (OP_DEFS (op)) > 1)
+ return NULL; /* has more than one definition */
+
+ /* get that definition */
+ if (!(dic =
+ hTabItemWithKey (iCodehTab,
+ bitVectFirstBit (OP_DEFS (op)))))
+ return NULL;
+
+ /* found the definition now check if it is local */
+ if (dic->seq < ebp->fSeq ||
+ dic->seq > ebp->lSeq)
+ return NULL; /* non-local */
+
+ /* now check if it is the return from
+ a function call */
+ if (dic->op == CALL || dic->op == PCALL)
{
- OP_SYMBOL (op)->ruonly = 1;
- return dic;
+ if (ic->op != SEND && ic->op != RETURN &&
+ !POINTER_SET(ic) && !POINTER_GET(ic))
+ {
+ OP_SYMBOL (op)->ruonly = 1;
+ return dic;
+ }
+ dic = dic->next;
}
- dic = dic->next;
- }
-
-
- /* otherwise check that the definition does
- not contain any symbols in far space */
- if (isOperandInFarSpace (IC_LEFT (dic)) ||
- isOperandInFarSpace (IC_RIGHT (dic)) ||
- IS_OP_RUONLY (IC_LEFT (ic)) ||
- IS_OP_RUONLY (IC_RIGHT (ic)))
- {
- return NULL;
- }
-
- /* if pointer set then make sure the pointer
- is one byte */
- if (POINTER_SET (dic) &&
- !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
- return NULL;
-
- if (POINTER_GET (dic) &&
- !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
- return NULL;
-
- sic = dic;
-
- /* also make sure the intervenening instructions
- don't have any thing in far space */
- for (dic = dic->next; dic && dic != ic; dic = dic->next)
- {
-
- /* if there is an intervening function call then no */
- if (dic->op == CALL || dic->op == PCALL)
- return NULL;
- /* if pointer set then make sure the pointer
- is one byte */
- if (POINTER_SET (dic) &&
- !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
- return NULL;
-
- if (POINTER_GET (dic) &&
- !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
- return NULL;
-
- /* if address of & the result is remat then okay */
- if (dic->op == ADDRESS_OF &&
- OP_SYMBOL (IC_RESULT (dic))->remat)
- continue;
-
- /* if operand has size of three or more & this
- operation is a '*','/' or '%' then 'b' may
- cause a problem */
- if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
- getSize (operandType (op)) >= 3)
- return NULL;
-
- /* if left or right or result is in far space */
- if (isOperandInFarSpace (IC_LEFT (dic)) ||
- isOperandInFarSpace (IC_RIGHT (dic)) ||
- isOperandInFarSpace (IC_RESULT (dic)) ||
- IS_OP_RUONLY (IC_LEFT (dic)) ||
- IS_OP_RUONLY (IC_RIGHT (dic)) ||
- IS_OP_RUONLY (IC_RESULT (dic)))
+
+
+ /* otherwise check that the definition does
+ not contain any symbols in far space */
+ if (isOperandInFarSpace (IC_LEFT (dic)) ||
+ isOperandInFarSpace (IC_RIGHT (dic)) ||
+ IS_OP_RUONLY (IC_LEFT (ic)) ||
+ IS_OP_RUONLY (IC_RIGHT (ic)))
{
- return NULL;
+ return NULL;
}
- }
-
- OP_SYMBOL (op)->ruonly = 1;
- return sic;
-
+
+ /* if pointer set then make sure the pointer
+ is one byte */
+ if (POINTER_SET (dic) &&
+ !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
+ return NULL;
+
+ if (POINTER_GET (dic) &&
+ !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
+ return NULL;
+
+ sic = dic;
+
+ /* also make sure the intervenening instructions
+ don't have any thing in far space */
+ for (dic = dic->next; dic && dic != ic; dic = dic->next)
+ {
+
+ /* if there is an intervening function call then no */
+ if (dic->op == CALL || dic->op == PCALL)
+ return NULL;
+ /* if pointer set then make sure the pointer
+ is one byte */
+ if (POINTER_SET (dic) &&
+ !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
+ return NULL;
+
+ if (POINTER_GET (dic) &&
+ !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
+ return NULL;
+
+ /* if address of & the result is remat then okay */
+ if (dic->op == ADDRESS_OF &&
+ OP_SYMBOL (IC_RESULT (dic))->remat)
+ continue;
+
+ /* if operand has size of three or more & this
+ operation is a '*','/' or '%' then 'b' may
+ cause a problem */
+ if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
+ getSize (operandType (op)) >= 3)
+ return NULL;
+
+ /* if left or right or result is in far space */
+ if (isOperandInFarSpace (IC_LEFT (dic)) ||
+ isOperandInFarSpace (IC_RIGHT (dic)) ||
+ isOperandInFarSpace (IC_RESULT (dic)) ||
+ IS_OP_RUONLY (IC_LEFT (dic)) ||
+ IS_OP_RUONLY (IC_RIGHT (dic)) ||
+ IS_OP_RUONLY (IC_RESULT (dic)))
+ {
+ return NULL;
+ }
+ }
+
+ OP_SYMBOL (op)->ruonly = 1;
+ return sic;
+
}
/*-----------------------------------------------------------------*/
static bool
isBitwiseOptimizable (iCode * ic)
{
- sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
- sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
-
- debugLog ("%s\n", __FUNCTION__);
- /* bitwise operations are considered optimizable
- under the following conditions (Jean-Louis VERN)
-
- x & lit
- bit & bit
- bit & x
- bit ^ bit
- bit ^ x
- x ^ lit
- x | lit
- bit | bit
- bit | x
- */
- if (IS_LITERAL (rtype) ||
- (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
- return TRUE;
- else
- return FALSE;
+ sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
+ sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
+
+ debugLog ("%s\n", __FUNCTION__);
+ /* bitwise operations are considered optimizable
+ under the following conditions (Jean-Louis VERN)
+
+ x & lit
+ bit & bit
+ bit & x
+ bit ^ bit
+ bit ^ x
+ x ^ lit
+ x | lit
+ bit | bit
+ bit | x
+ */
+ if (IS_LITERAL (rtype) ||
+ (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
+ return TRUE;
+ else
+ return FALSE;
}
/*-----------------------------------------------------------------*/
static void
packRegsForAccUse (iCode * ic)
{
- iCode *uic;
-
- debugLog ("%s\n", __FUNCTION__);
-
- /* if this is an aggregate, e.g. a one byte char array */
- if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
- return;
- }
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
-
- /* if + or - then it has to be one byte result */
- if ((ic->op == '+' || ic->op == '-')
- && getSize (operandType (IC_RESULT (ic))) > 1)
- return;
-
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
- /* if shift operation make sure right side is not a literal */
- if (ic->op == RIGHT_OP &&
- (isOperandLiteral (IC_RIGHT (ic)) ||
- getSize (operandType (IC_RESULT (ic))) > 1))
- return;
-
- if (ic->op == LEFT_OP &&
- (isOperandLiteral (IC_RIGHT (ic)) ||
- getSize (operandType (IC_RESULT (ic))) > 1))
- return;
-
- if (IS_BITWISE_OP (ic) &&
- getSize (operandType (IC_RESULT (ic))) > 1)
- return;
-
-
- /* has only one definition */
- if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
- return;
-
- /* has only one use */
- if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
- return;
-
- /* and the usage immediately follows this iCode */
- if (!(uic = hTabItemWithKey (iCodehTab,
- bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
- return;
-
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
- if (ic->next != uic)
- return;
-
- /* if it is a conditional branch then we definitely can */
- if (uic->op == IFX)
- goto accuse;
-
- if (uic->op == JUMPTABLE)
- return;
-
- /* if the usage is not is an assignment
- or an arithmetic / bitwise / shift operation then not */
- if (POINTER_SET (uic) &&
- getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
- return;
-
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
- if (uic->op != '=' &&
- !IS_ARITHMETIC_OP (uic) &&
- !IS_BITWISE_OP (uic) &&
- uic->op != LEFT_OP &&
- uic->op != RIGHT_OP)
- return;
-
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
- /* if used in ^ operation then make sure right is not a
- literl */
- if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
- return;
-
- /* if shift operation make sure right side is not a literal */
- if (uic->op == RIGHT_OP &&
- (isOperandLiteral (IC_RIGHT (uic)) ||
- getSize (operandType (IC_RESULT (uic))) > 1))
- return;
-
- if (uic->op == LEFT_OP &&
- (isOperandLiteral (IC_RIGHT (uic)) ||
- getSize (operandType (IC_RESULT (uic))) > 1))
- return;
-
- /* make sure that the result of this icode is not on the
- stack, since acc is used to compute stack offset */
- if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
- OP_SYMBOL (IC_RESULT (uic))->onStack)
- return;
-
- /* if either one of them in far space then we cannot */
- if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
- isOperandInFarSpace (IC_LEFT (uic))) ||
- (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
- isOperandInFarSpace (IC_RIGHT (uic))))
- return;
-
- /* if the usage has only one operand then we can */
- if (IC_LEFT (uic) == NULL ||
- IC_RIGHT (uic) == NULL)
- goto accuse;
-
- /* make sure this is on the left side if not
- a '+' since '+' is commutative */
- if (ic->op != '+' &&
- IC_LEFT (uic)->key != IC_RESULT (ic)->key)
- return;
-
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
- /* if one of them is a literal then we can */
- if ( ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
- (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic)))) &&
- (getSize (operandType (IC_RESULT (uic))) <= 1))
- {
- OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
- return;
- }
-
- debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
- /* if the other one is not on stack then we can */
- if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
- (IS_ITEMP (IC_RIGHT (uic)) ||
- (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
- !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
- goto accuse;
-
- if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
- (IS_ITEMP (IC_LEFT (uic)) ||
- (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
- !OP_SYMBOL (IC_LEFT (uic))->onStack)))
- goto accuse;
-
- return;
-
+ iCode *uic;
+
+ debugLog ("%s\n", __FUNCTION__);
+
+ /* if this is an aggregate, e.g. a one byte char array */
+ if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
+ return;
+ }
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+
+ /* if + or - then it has to be one byte result */
+ if ((ic->op == '+' || ic->op == '-')
+ && getSize (operandType (IC_RESULT (ic))) > 1)
+ return;
+
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+ /* if shift operation make sure right side is not a literal */
+ if (ic->op == RIGHT_OP &&
+ (isOperandLiteral (IC_RIGHT (ic)) ||
+ getSize (operandType (IC_RESULT (ic))) > 1))
+ return;
+
+ if (ic->op == LEFT_OP &&
+ (isOperandLiteral (IC_RIGHT (ic)) ||
+ getSize (operandType (IC_RESULT (ic))) > 1))
+ return;
+
+ if (IS_BITWISE_OP (ic) &&
+ getSize (operandType (IC_RESULT (ic))) > 1)
+ return;
+
+
+ /* has only one definition */
+ if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
+ return;
+
+ /* has only one use */
+ if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
+ return;
+
+ /* and the usage immediately follows this iCode */
+ if (!(uic = hTabItemWithKey (iCodehTab,
+ bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
+ return;
+
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+ if (ic->next != uic)
+ return;
+
+ /* if it is a conditional branch then we definitely can */
+ if (uic->op == IFX)
+ goto accuse;
+
+ if (uic->op == JUMPTABLE)
+ return;
+
+ /* if the usage is not is an assignment
+ or an arithmetic / bitwise / shift operation then not */
+ if (POINTER_SET (uic) &&
+ getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
+ return;
+
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+ if (uic->op != '=' &&
+ !IS_ARITHMETIC_OP (uic) &&
+ !IS_BITWISE_OP (uic) &&
+ uic->op != LEFT_OP &&
+ uic->op != RIGHT_OP)
+ return;
+
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+ /* if used in ^ operation then make sure right is not a
+ literl */
+ if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
+ return;
+
+ /* if shift operation make sure right side is not a literal */
+ if (uic->op == RIGHT_OP &&
+ (isOperandLiteral (IC_RIGHT (uic)) ||
+ getSize (operandType (IC_RESULT (uic))) > 1))
+ return;
+
+ if (uic->op == LEFT_OP &&
+ (isOperandLiteral (IC_RIGHT (uic)) ||
+ getSize (operandType (IC_RESULT (uic))) > 1))
+ return;
+
+ /* make sure that the result of this icode is not on the
+ stack, since acc is used to compute stack offset */
+ if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
+ OP_SYMBOL (IC_RESULT (uic))->onStack)
+ return;
+
+ /* if either one of them in far space then we cannot */
+ if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
+ isOperandInFarSpace (IC_LEFT (uic))) ||
+ (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
+ isOperandInFarSpace (IC_RIGHT (uic))))
+ return;
+
+ /* if the usage has only one operand then we can */
+ if (IC_LEFT (uic) == NULL ||
+ IC_RIGHT (uic) == NULL)
+ goto accuse;
+
+ /* make sure this is on the left side if not
+ a '+' since '+' is commutative */
+ if (ic->op != '+' &&
+ IC_LEFT (uic)->key != IC_RESULT (ic)->key)
+ return;
+
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+ /* if one of them is a literal then we can */
+ if ( ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
+ (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic)))) &&
+ (getSize (operandType (IC_RESULT (uic))) <= 1))
+ {
+ OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
+ return;
+ }
+
+ debugLog (" %s:%d\n", __FUNCTION__,__LINE__);
+ /* if the other one is not on stack then we can */
+ if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
+ (IS_ITEMP (IC_RIGHT (uic)) ||
+ (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
+ !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
+ goto accuse;
+
+ if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
+ (IS_ITEMP (IC_LEFT (uic)) ||
+ (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
+ !OP_SYMBOL (IC_LEFT (uic))->onStack)))
+ goto accuse;
+
+ return;
+
accuse:
- debugLog ("%s - Yes we are using the accumulator\n", __FUNCTION__);
- OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
-
-
+ debugLog ("%s - Yes we are using the accumulator\n", __FUNCTION__);
+ OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
+
+
}
/*-----------------------------------------------------------------*/
static void
packForReceive (iCode * ic, eBBlock * ebp)
{
- iCode *dic;
-
- debugLog ("%s\n", __FUNCTION__);
- debugAopGet (" result:", IC_RESULT (ic));
- debugAopGet (" left:", IC_LEFT (ic));
- debugAopGet (" right:", IC_RIGHT (ic));
-
- if (!ic->next)
- return;
-
- for (dic = ic->next; dic; dic = dic->next)
- {
-
-
-
- if (IC_LEFT (dic) && (IC_RESULT (ic)->key == IC_LEFT (dic)->key))
- debugLog (" used on left\n");
- if (IC_RIGHT (dic) && IC_RESULT (ic)->key == IC_RIGHT (dic)->key)
- debugLog (" used on right\n");
- if (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key)
- debugLog (" used on result\n");
-
- if ((IC_LEFT (dic) && (IC_RESULT (ic)->key == IC_LEFT (dic)->key)) ||
- (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key))
- return;
-
- }
-
- debugLog (" hey we can remove this unnecessary assign\n");
+ iCode *dic;
+
+ debugLog ("%s\n", __FUNCTION__);
+ debugAopGet (" result:", IC_RESULT (ic));
+ debugAopGet (" left:", IC_LEFT (ic));
+ debugAopGet (" right:", IC_RIGHT (ic));
+
+ if (!ic->next)
+ return;
+
+ for (dic = ic->next; dic; dic = dic->next)
+ {
+
+
+
+ if (IC_LEFT (dic) && (IC_RESULT (ic)->key == IC_LEFT (dic)->key))
+ debugLog (" used on left\n");
+ if (IC_RIGHT (dic) && IC_RESULT (ic)->key == IC_RIGHT (dic)->key)
+ debugLog (" used on right\n");
+ if (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key)
+ debugLog (" used on result\n");
+
+ if ((IC_LEFT (dic) && (IC_RESULT (ic)->key == IC_LEFT (dic)->key)) ||
+ (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key))
+ return;
+
+ }
+
+ debugLog (" hey we can remove this unnecessary assign\n");
}
/*-----------------------------------------------------------------*/
/* packForPush - hueristics to reduce iCode for pushing */
static void
packForPush (iCode * ic, eBBlock * ebp)
{
- iCode *dic;
-
- debugLog ("%s\n", __FUNCTION__);
- if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
- return;
-
- /* must have only definition & one usage */
- if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
- bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
- return;
-
- /* find the definition */
- if (!(dic = hTabItemWithKey (iCodehTab,
- bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
- return;
-
- if (dic->op != '=' || POINTER_SET (dic))
- return;
-
- /* we now we know that it has one & only one def & use
- and the that the definition is an assignment */
- IC_LEFT (ic) = IC_RIGHT (dic);
-
- remiCodeFromeBBlock (ebp, dic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
+ iCode *dic;
+
+ debugLog ("%s\n", __FUNCTION__);
+ if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
+ return;
+
+ /* must have only definition & one usage */
+ if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
+ bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
+ return;
+
+ /* find the definition */
+ if (!(dic = hTabItemWithKey (iCodehTab,
+ bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
+ return;
+
+ if (dic->op != '=' || POINTER_SET (dic))
+ return;
+
+ /* we now we know that it has one & only one def & use
+ and the that the definition is an assignment */
+ IC_LEFT (ic) = IC_RIGHT (dic);
+
+ remiCodeFromeBBlock (ebp, dic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+ hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
}
void printSymType(char * str, sym_link *sl)
{
- debugLog (" %s Symbol type: ",str);
- printTypeChain( sl, debugF);
- debugLog ("\n");
-
+ debugLog (" %s Symbol type: ",str);
+ printTypeChain( sl, debugF);
+ debugLog ("\n");
+
}
/*-----------------------------------------------------------------*/
/* some debug code to print the symbol S_TYPE. Note that
- * the function checkSClass in src/SDCCsymt.c dinks with
- * the S_TYPE in ways the PIC port doesn't fully like...*/
+* the function checkSClass in src/SDCCsymt.c dinks with
+* the S_TYPE in ways the PIC port doesn't fully like...*/
/*-----------------------------------------------------------------*/
void isData(sym_link *sl)
{
- FILE *of = stderr;
-
- if(!sl)
- return;
-
- if(debugF)
- of = debugF;
-
- for ( ; sl; sl=sl->next) {
- if(!IS_DECL(sl) ) {
- switch (SPEC_SCLS(sl)) {
-
- case S_DATA: fprintf (of, "data "); break;
- case S_XDATA: fprintf (of, "xdata "); break;
- case S_SFR: fprintf (of, "sfr "); break;
- case S_SBIT: fprintf (of, "sbit "); break;
- case S_CODE: fprintf (of, "code "); break;
- case S_IDATA: fprintf (of, "idata "); break;
- case S_PDATA: fprintf (of, "pdata "); break;
- case S_LITERAL: fprintf (of, "literal "); break;
- case S_STACK: fprintf (of, "stack "); break;
- case S_XSTACK: fprintf (of, "xstack "); break;
- case S_BIT: fprintf (of, "bit "); break;
- case S_EEPROM: fprintf (of, "eeprom "); break;
- default: break;
- }
-
- }
-
- }
-
+ FILE *of = stderr;
+
+ if(!sl)
+ return;
+
+ if(debugF)
+ of = debugF;
+
+ for ( ; sl; sl=sl->next) {
+ if(!IS_DECL(sl) ) {
+ switch (SPEC_SCLS(sl)) {
+
+ case S_DATA: fprintf (of, "data "); break;
+ case S_XDATA: fprintf (of, "xdata "); break;
+ case S_SFR: fprintf (of, "sfr "); break;
+ case S_SBIT: fprintf (of, "sbit "); break;
+ case S_CODE: fprintf (of, "code "); break;
+ case S_IDATA: fprintf (of, "idata "); break;
+ case S_PDATA: fprintf (of, "pdata "); break;
+ case S_LITERAL: fprintf (of, "literal "); break;
+ case S_STACK: fprintf (of, "stack "); break;
+ case S_XSTACK: fprintf (of, "xstack "); break;
+ case S_BIT: fprintf (of, "bit "); break;
+ case S_EEPROM: fprintf (of, "eeprom "); break;
+ default: break;
+ }
+
+ }
+
+ }
+
}
/*-----------------------------------------------------------------*/
/* packRegisters - does some transformations to reduce register */
static void
packRegisters (eBBlock * ebp)
{
- iCode *ic;
- int change = 0;
-
- debugLog ("%s\n", __FUNCTION__);
-
- while (1) {
-
- change = 0;
-
- /* look for assignments of the form */
- /* iTempNN = TRueSym (someoperation) SomeOperand */
- /* .... */
- /* TrueSym := iTempNN:1 */
- for (ic = ebp->sch; ic; ic = ic->next)
- {
-
- /* find assignment of the form TrueSym := iTempNN:1 */
- if (ic->op == '=' && !POINTER_SET (ic))
- change += packRegsForAssign (ic, ebp);
- /* debug stuff */
- if (ic->op == '=')
- {
- if (POINTER_SET (ic))
- debugLog ("pointer is set\n");
- debugAopGet (" result:", IC_RESULT (ic));
- debugAopGet (" left:", IC_LEFT (ic));
- debugAopGet (" right:", IC_RIGHT (ic));
- }
-
- }
-
- if (!change)
- break;
- }
-
- for (ic = ebp->sch; ic; ic = ic->next) {
-
- if(IS_SYMOP ( IC_LEFT(ic))) {
- sym_link *etype = getSpec (operandType (IC_LEFT (ic)));
-
- debugAopGet (" left:", IC_LEFT (ic));
- if(IS_PTR_CONST(OP_SYMBOL(IC_LEFT(ic))->type))
- debugLog (" is a pointer\n");
-
- if(IS_OP_VOLATILE(IC_LEFT(ic)))
- debugLog (" is volatile\n");
-
- isData(etype);
-
- printSymType(" ", OP_SYMBOL(IC_LEFT(ic))->type);
- }
-
- if(IS_SYMOP ( IC_RIGHT(ic))) {
- debugAopGet (" right:", IC_RIGHT (ic));
- printSymType(" ", OP_SYMBOL(IC_RIGHT(ic))->type);
- }
-
- if(IS_SYMOP ( IC_RESULT(ic))) {
- debugAopGet (" result:", IC_RESULT (ic));
- printSymType(" ", OP_SYMBOL(IC_RESULT(ic))->type);
- }
-
- if (POINTER_SET (ic))
- debugLog (" %d - Pointer set\n", __LINE__);
-
-
- /* if this is an itemp & result of a address of a true sym
- then mark this as rematerialisable */
- if (ic->op == ADDRESS_OF &&
- IS_ITEMP (IC_RESULT (ic)) &&
- IS_TRUE_SYMOP (IC_LEFT (ic)) &&
- bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
- !OP_SYMBOL (IC_LEFT (ic))->onStack)
- {
-
- debugLog (" %d - %s. result is rematerializable\n", __LINE__,__FUNCTION__);
-
- OP_SYMBOL (IC_RESULT (ic))->remat = 1;
- OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
- OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
-
- }
-
- /* if straight assignment then carry remat flag if
- this is the only definition */
- if (ic->op == '=' &&
- !POINTER_SET (ic) &&
- IS_SYMOP (IC_RIGHT (ic)) &&
- OP_SYMBOL (IC_RIGHT (ic))->remat &&
- bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
- {
- debugLog (" %d - %s. straight rematerializable\n", __LINE__,__FUNCTION__);
-
- OP_SYMBOL (IC_RESULT (ic))->remat =
- OP_SYMBOL (IC_RIGHT (ic))->remat;
- OP_SYMBOL (IC_RESULT (ic))->rematiCode =
- OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
- }
-
- /* if this is a +/- operation with a rematerizable
- then mark this as rematerializable as well */
- if ((ic->op == '+' || ic->op == '-') &&
- (IS_SYMOP (IC_LEFT (ic)) &&
- IS_ITEMP (IC_RESULT (ic)) &&
- OP_SYMBOL (IC_LEFT (ic))->remat &&
- bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
- IS_OP_LITERAL (IC_RIGHT (ic))))
- {
- debugLog (" %d - %s. rematerializable because op is +/-\n", __LINE__,__FUNCTION__);
- //int i =
- operandLitValue (IC_RIGHT (ic));
- OP_SYMBOL (IC_RESULT (ic))->remat = 1;
- OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
- OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
- }
-
- /* mark the pointer usages */
- if (POINTER_SET (ic))
- {
- OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
- debugLog (" marking as a pointer (set) =>");
- debugAopGet (" result:", IC_RESULT (ic));
- }
- if (POINTER_GET (ic))
- {
- OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
- debugLog (" marking as a pointer (get) =>");
- debugAopGet (" left:", IC_LEFT (ic));
- }
-
- if (!SKIP_IC2 (ic))
- {
- /* if we are using a symbol on the stack
- then we should say pic14_ptrRegReq */
- if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
- pic14_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ||
- OP_SYMBOL (IC_COND (ic))->iaccess) ? 1 : 0);
- else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
- pic14_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ||
- OP_SYMBOL (IC_JTCOND (ic))->iaccess) ? 1 : 0);
- else
- {
- if (IS_SYMOP (IC_LEFT (ic)))
- pic14_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ||
- OP_SYMBOL (IC_LEFT (ic))->iaccess) ? 1 : 0);
- if (IS_SYMOP (IC_RIGHT (ic)))
- pic14_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ||
- OP_SYMBOL (IC_RIGHT (ic))->iaccess) ? 1 : 0);
- if (IS_SYMOP (IC_RESULT (ic)))
- pic14_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ||
- OP_SYMBOL (IC_RESULT (ic))->iaccess) ? 1 : 0);
- }
-
- debugLog (" %d - pointer reg req = %d\n", __LINE__,pic14_ptrRegReq);
-
- }
-
- /* if the condition of an if instruction
- is defined in the previous instruction then
- mark the itemp as a conditional */
- if ((IS_CONDITIONAL (ic) ||
- ((ic->op == BITWISEAND ||
- ic->op == '|' ||
- ic->op == '^') &&
- isBitwiseOptimizable (ic))) &&
- ic->next && ic->next->op == IFX &&
- isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
- OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
- {
-
- debugLog (" %d\n", __LINE__);
- OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
- continue;
- }
-
- /* reduce for support function calls */
- if (ic->supportRtn || ic->op == '+' || ic->op == '-')
- packRegsForSupport (ic, ebp);
-
- /* if a parameter is passed, it's in W, so we may not
- need to place a copy in a register */
- if (ic->op == RECEIVE)
- packForReceive (ic, ebp);
-
- /* some cases the redundant moves can
- can be eliminated for return statements */
- if ((ic->op == RETURN || ic->op == SEND) &&
- !isOperandInFarSpace (IC_LEFT (ic)) &&
- !options.model)
- packRegsForOneuse (ic, IC_LEFT (ic), ebp);
-
- /* if pointer set & left has a size more than
- one and right is not in far space */
- if (POINTER_SET (ic) &&
- !isOperandInFarSpace (IC_RIGHT (ic)) &&
- !OP_SYMBOL (IC_RESULT (ic))->remat &&
- !IS_OP_RUONLY (IC_RIGHT (ic)) &&
- getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1)
-
- packRegsForOneuse (ic, IC_RESULT (ic), ebp);
-
- /* if pointer get */
- if (POINTER_GET (ic) &&
- !isOperandInFarSpace (IC_RESULT (ic)) &&
- !OP_SYMBOL (IC_LEFT (ic))->remat &&
- !IS_OP_RUONLY (IC_RESULT (ic)) &&
- getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1)
-
- packRegsForOneuse (ic, IC_LEFT (ic), ebp);
-
-
- /* if this is cast for intergral promotion then
- check if only use of the definition of the
- operand being casted/ if yes then replace
- the result of that arithmetic operation with
- this result and get rid of the cast */
- if (ic->op == CAST) {
-
- sym_link *fromType = operandType (IC_RIGHT (ic));
- sym_link *toType = operandType (IC_LEFT (ic));
-
- debugLog (" %d - casting\n", __LINE__);
-
- if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
- getSize (fromType) != getSize (toType)) {
-
-
- iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
- if (dic) {
-
- if (IS_ARITHMETIC_OP (dic)) {
-
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- IC_RESULT (dic) = IC_RESULT (ic);
- remiCodeFromeBBlock (ebp, ic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
- hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
- OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
- ic = ic->prev;
- } else
-
- OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
- }
- } else {
-
- /* if the type from and type to are the same
- then if this is the only use then packit */
- if (compareType (operandType (IC_RIGHT (ic)),
- operandType (IC_LEFT (ic))) == 1) {
-
- iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
- if (dic) {
-
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
- IC_RESULT (dic) = IC_RESULT (ic);
- bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
- remiCodeFromeBBlock (ebp, ic);
- hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
- OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
- ic = ic->prev;
- }
+ iCode *ic;
+ int change = 0;
+
+ debugLog ("%s\n", __FUNCTION__);
+
+ while (1) {
+
+ change = 0;
+
+ /* look for assignments of the form */
+ /* iTempNN = TRueSym (someoperation) SomeOperand */
+ /* .... */
+ /* TrueSym := iTempNN:1 */
+ for (ic = ebp->sch; ic; ic = ic->next)
+ {
+
+ /* find assignment of the form TrueSym := iTempNN:1 */
+ if (ic->op == '=' && !POINTER_SET (ic))
+ change += packRegsForAssign (ic, ebp);
+ /* debug stuff */
+ if (ic->op == '=')
+ {
+ if (POINTER_SET (ic))
+ debugLog ("pointer is set\n");
+ debugAopGet (" result:", IC_RESULT (ic));
+ debugAopGet (" left:", IC_LEFT (ic));
+ debugAopGet (" right:", IC_RIGHT (ic));
+ }
+
+ }
+
+ if (!change)
+ break;
}
- }
- }
-
- /* pack for PUSH
- iTempNN := (some variable in farspace) V1
- push iTempNN ;
- -------------
- push V1
- */
- if (ic->op == IPUSH)
- {
- packForPush (ic, ebp);
- }
-
-
- /* pack registers for accumulator use, when the
- result of an arithmetic or bit wise operation
- has only one use, that use is immediately following
- the defintion and the using iCode has only one
- operand or has two operands but one is literal &
- the result of that operation is not on stack then
- we can leave the result of this operation in acc:b
- combination */
- if ((IS_ARITHMETIC_OP (ic)
-
- || IS_BITWISE_OP (ic)
-
- || ic->op == LEFT_OP || ic->op == RIGHT_OP
-
- ) &&
- IS_ITEMP (IC_RESULT (ic)) &&
- getSize (operandType (IC_RESULT (ic))) <= 2)
-
- packRegsForAccUse (ic);
-
+
+ for (ic = ebp->sch; ic; ic = ic->next) {
+
+ if(IS_SYMOP ( IC_LEFT(ic))) {
+ sym_link *etype = getSpec (operandType (IC_LEFT (ic)));
+
+ debugAopGet (" left:", IC_LEFT (ic));
+ if(IS_PTR_CONST(OP_SYMBOL(IC_LEFT(ic))->type))
+ debugLog (" is a pointer\n");
+
+ if(IS_OP_VOLATILE(IC_LEFT(ic)))
+ debugLog (" is volatile\n");
+
+ isData(etype);
+
+ printSymType(" ", OP_SYMBOL(IC_LEFT(ic))->type);
+ }
+
+ if(IS_SYMOP ( IC_RIGHT(ic))) {
+ debugAopGet (" right:", IC_RIGHT (ic));
+ printSymType(" ", OP_SYMBOL(IC_RIGHT(ic))->type);
+ }
+
+ if(IS_SYMOP ( IC_RESULT(ic))) {
+ debugAopGet (" result:", IC_RESULT (ic));
+ printSymType(" ", OP_SYMBOL(IC_RESULT(ic))->type);
+ }
+
+ if (POINTER_SET (ic))
+ debugLog (" %d - Pointer set\n", __LINE__);
+
+
+ /* if this is an itemp & result of a address of a true sym
+ then mark this as rematerialisable */
+ if (ic->op == ADDRESS_OF &&
+ IS_ITEMP (IC_RESULT (ic)) &&
+ IS_TRUE_SYMOP (IC_LEFT (ic)) &&
+ bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
+ !OP_SYMBOL (IC_LEFT (ic))->onStack)
+ {
+
+ debugLog (" %d - %s. result is rematerializable\n", __LINE__,__FUNCTION__);
+
+ OP_SYMBOL (IC_RESULT (ic))->remat = 1;
+ OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
+ OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
+
+ }
+
+ /* if straight assignment then carry remat flag if
+ this is the only definition */
+ if (ic->op == '=' &&
+ !POINTER_SET (ic) &&
+ IS_SYMOP (IC_RIGHT (ic)) &&
+ OP_SYMBOL (IC_RIGHT (ic))->remat &&
+ bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
+ {
+ debugLog (" %d - %s. straight rematerializable\n", __LINE__,__FUNCTION__);
+
+ OP_SYMBOL (IC_RESULT (ic))->remat =
+ OP_SYMBOL (IC_RIGHT (ic))->remat;
+ OP_SYMBOL (IC_RESULT (ic))->rematiCode =
+ OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
+ }
+
+ /* if this is a +/- operation with a rematerizable
+ then mark this as rematerializable as well */
+ if ((ic->op == '+' || ic->op == '-') &&
+ (IS_SYMOP (IC_LEFT (ic)) &&
+ IS_ITEMP (IC_RESULT (ic)) &&
+ OP_SYMBOL (IC_LEFT (ic))->remat &&
+ bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
+ IS_OP_LITERAL (IC_RIGHT (ic))))
+ {
+ debugLog (" %d - %s. rematerializable because op is +/-\n", __LINE__,__FUNCTION__);
+ //int i =
+ operandLitValue (IC_RIGHT (ic));
+ OP_SYMBOL (IC_RESULT (ic))->remat = 1;
+ OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
+ OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
+ }
+
+ /* mark the pointer usages */
+ if (POINTER_SET (ic))
+ {
+ OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
+ debugLog (" marking as a pointer (set) =>");
+ debugAopGet (" result:", IC_RESULT (ic));
+ }
+ if (POINTER_GET (ic))
+ {
+ OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
+ debugLog (" marking as a pointer (get) =>");
+ debugAopGet (" left:", IC_LEFT (ic));
+ }
+
+ if (!SKIP_IC2 (ic))
+ {
+ /* if we are using a symbol on the stack
+ then we should say pic14_ptrRegReq */
+ if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
+ pic14_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ||
+ OP_SYMBOL (IC_COND (ic))->iaccess) ? 1 : 0);
+ else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
+ pic14_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ||
+ OP_SYMBOL (IC_JTCOND (ic))->iaccess) ? 1 : 0);
+ else
+ {
+ if (IS_SYMOP (IC_LEFT (ic)))
+ pic14_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ||
+ OP_SYMBOL (IC_LEFT (ic))->iaccess) ? 1 : 0);
+ if (IS_SYMOP (IC_RIGHT (ic)))
+ pic14_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ||
+ OP_SYMBOL (IC_RIGHT (ic))->iaccess) ? 1 : 0);
+ if (IS_SYMOP (IC_RESULT (ic)))
+ pic14_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ||
+ OP_SYMBOL (IC_RESULT (ic))->iaccess) ? 1 : 0);
+ }
+
+ debugLog (" %d - pointer reg req = %d\n", __LINE__,pic14_ptrRegReq);
+
+ }
+
+ /* if the condition of an if instruction
+ is defined in the previous instruction then
+ mark the itemp as a conditional */
+ if ((IS_CONDITIONAL (ic) ||
+ ((ic->op == BITWISEAND ||
+ ic->op == '|' ||
+ ic->op == '^') &&
+ isBitwiseOptimizable (ic))) &&
+ ic->next && ic->next->op == IFX &&
+ isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
+ OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
+ {
+
+ debugLog (" %d\n", __LINE__);
+ OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
+ continue;
+ }
+
+ /* reduce for support function calls */
+ if (ic->supportRtn || ic->op == '+' || ic->op == '-')
+ packRegsForSupport (ic, ebp);
+
+ /* if a parameter is passed, it's in W, so we may not
+ need to place a copy in a register */
+ if (ic->op == RECEIVE)
+ packForReceive (ic, ebp);
+
+ /* some cases the redundant moves can
+ can be eliminated for return statements */
+ if ((ic->op == RETURN || ic->op == SEND) &&
+ !isOperandInFarSpace (IC_LEFT (ic)) &&
+ !options.model)
+ packRegsForOneuse (ic, IC_LEFT (ic), ebp);
+
+ /* if pointer set & left has a size more than
+ one and right is not in far space */
+ if (POINTER_SET (ic) &&
+ !isOperandInFarSpace (IC_RIGHT (ic)) &&
+ !OP_SYMBOL (IC_RESULT (ic))->remat &&
+ !IS_OP_RUONLY (IC_RIGHT (ic)) &&
+ getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1)
+
+ packRegsForOneuse (ic, IC_RESULT (ic), ebp);
+
+ /* if pointer get */
+ if (POINTER_GET (ic) &&
+ !isOperandInFarSpace (IC_RESULT (ic)) &&
+ !OP_SYMBOL (IC_LEFT (ic))->remat &&
+ !IS_OP_RUONLY (IC_RESULT (ic)) &&
+ getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1)
+
+ packRegsForOneuse (ic, IC_LEFT (ic), ebp);
+
+
+ /* if this is cast for intergral promotion then
+ check if only use of the definition of the
+ operand being casted/ if yes then replace
+ the result of that arithmetic operation with
+ this result and get rid of the cast */
+ if (ic->op == CAST) {
+
+ sym_link *fromType = operandType (IC_RIGHT (ic));
+ sym_link *toType = operandType (IC_LEFT (ic));
+
+ debugLog (" %d - casting\n", __LINE__);
+
+ if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
+ getSize (fromType) != getSize (toType)) {
+
+
+ iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
+ if (dic) {
+
+ if (IS_ARITHMETIC_OP (dic)) {
+
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+ IC_RESULT (dic) = IC_RESULT (ic);
+ remiCodeFromeBBlock (ebp, ic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
+ hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
+ OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+ ic = ic->prev;
+ } else
+
+ OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
+ }
+ } else {
+
+ /* if the type from and type to are the same
+ then if this is the only use then packit */
+ if (compareType (operandType (IC_RIGHT (ic)),
+ operandType (IC_LEFT (ic))) == 1) {
+
+ iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
+ if (dic) {
+
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+ IC_RESULT (dic) = IC_RESULT (ic);
+ bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
+ remiCodeFromeBBlock (ebp, ic);
+ hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
+ OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+ ic = ic->prev;
+ }
+ }
+ }
+ }
+
+ /* pack for PUSH
+ iTempNN := (some variable in farspace) V1
+ push iTempNN ;
+ -------------
+ push V1
+ */
+ if (ic->op == IPUSH)
+ {
+ packForPush (ic, ebp);
+ }
+
+
+ /* pack registers for accumulator use, when the
+ result of an arithmetic or bit wise operation
+ has only one use, that use is immediately following
+ the defintion and the using iCode has only one
+ operand or has two operands but one is literal &
+ the result of that operation is not on stack then
+ we can leave the result of this operation in acc:b
+ combination */
+ if ((IS_ARITHMETIC_OP (ic)
+
+ || IS_BITWISE_OP (ic)
+
+ || ic->op == LEFT_OP || ic->op == RIGHT_OP
+
+ ) &&
+ IS_ITEMP (IC_RESULT (ic)) &&
+ getSize (operandType (IC_RESULT (ic))) <= 2)
+
+ packRegsForAccUse (ic);
+
}
}
static void
dumpEbbsToDebug (eBBlock ** ebbs, int count)
{
- int i;
-
- if (!debug || !debugF)
- return;
-
- for (i = 0; i < count; i++)
- {
- fprintf (debugF, "\n----------------------------------------------------------------\n");
- fprintf (debugF, "Basic Block %s : loop Depth = %d noPath = %d , lastinLoop = %d\n",
- ebbs[i]->entryLabel->name,
- ebbs[i]->depth,
- ebbs[i]->noPath,
- ebbs[i]->isLastInLoop);
- fprintf (debugF, "depth 1st num %d : bbnum = %d 1st iCode = %d , last iCode = %d\n",
- ebbs[i]->dfnum,
- ebbs[i]->bbnum,
- ebbs[i]->fSeq,
- ebbs[i]->lSeq);
- fprintf (debugF, "visited %d : hasFcall = %d\n",
- ebbs[i]->visited,
- ebbs[i]->hasFcall);
-
- fprintf (debugF, "\ndefines bitVector :");
- bitVectDebugOn (ebbs[i]->defSet, debugF);
- fprintf (debugF, "\nlocal defines bitVector :");
- bitVectDebugOn (ebbs[i]->ldefs, debugF);
- fprintf (debugF, "\npointers Set bitvector :");
- bitVectDebugOn (ebbs[i]->ptrsSet, debugF);
- fprintf (debugF, "\nin pointers Set bitvector :");
- bitVectDebugOn (ebbs[i]->inPtrsSet, debugF);
- fprintf (debugF, "\ninDefs Set bitvector :");
- bitVectDebugOn (ebbs[i]->inDefs, debugF);
- fprintf (debugF, "\noutDefs Set bitvector :");
- bitVectDebugOn (ebbs[i]->outDefs, debugF);
- fprintf (debugF, "\nusesDefs Set bitvector :");
- bitVectDebugOn (ebbs[i]->usesDefs, debugF);
- fprintf (debugF, "\n----------------------------------------------------------------\n");
- printiCChain (ebbs[i]->sch, debugF);
- }
+ int i;
+
+ if (!debug || !debugF)
+ return;
+
+ for (i = 0; i < count; i++)
+ {
+ fprintf (debugF, "\n----------------------------------------------------------------\n");
+ fprintf (debugF, "Basic Block %s : loop Depth = %d noPath = %d , lastinLoop = %d\n",
+ ebbs[i]->entryLabel->name,
+ ebbs[i]->depth,
+ ebbs[i]->noPath,
+ ebbs[i]->isLastInLoop);
+ fprintf (debugF, "depth 1st num %d : bbnum = %d 1st iCode = %d , last iCode = %d\n",
+ ebbs[i]->dfnum,
+ ebbs[i]->bbnum,
+ ebbs[i]->fSeq,
+ ebbs[i]->lSeq);
+ fprintf (debugF, "visited %d : hasFcall = %d\n",
+ ebbs[i]->visited,
+ ebbs[i]->hasFcall);
+
+ fprintf (debugF, "\ndefines bitVector :");
+ bitVectDebugOn (ebbs[i]->defSet, debugF);
+ fprintf (debugF, "\nlocal defines bitVector :");
+ bitVectDebugOn (ebbs[i]->ldefs, debugF);
+ fprintf (debugF, "\npointers Set bitvector :");
+ bitVectDebugOn (ebbs[i]->ptrsSet, debugF);
+ fprintf (debugF, "\nin pointers Set bitvector :");
+ bitVectDebugOn (ebbs[i]->inPtrsSet, debugF);
+ fprintf (debugF, "\ninDefs Set bitvector :");
+ bitVectDebugOn (ebbs[i]->inDefs, debugF);
+ fprintf (debugF, "\noutDefs Set bitvector :");
+ bitVectDebugOn (ebbs[i]->outDefs, debugF);
+ fprintf (debugF, "\nusesDefs Set bitvector :");
+ bitVectDebugOn (ebbs[i]->usesDefs, debugF);
+ fprintf (debugF, "\n----------------------------------------------------------------\n");
+ printiCChain (ebbs[i]->sch, debugF);
+ }
}
/*-----------------------------------------------------------------*/
/* assignRegisters - assigns registers to each live range as need */
void
pic14_assignRegisters (eBBlock ** ebbs, int count)
{
- iCode *ic;
- int i;
-
- debugLog ("<><><><><><><><><><><><><><><><><>\nstarting\t%s:%s", __FILE__, __FUNCTION__);
- debugLog ("\nebbs before optimizing:\n");
- dumpEbbsToDebug (ebbs, count);
-
- setToNull ((void *) &_G.funcrUsed);
- pic14_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
-
-
- /* change assignments this will remove some
- live ranges reducing some register pressure */
- for (i = 0; i < count; i++)
- packRegisters (ebbs[i]);
-
- {
- regs *reg;
- int hkey;
- int i=0;
-
- debugLog("dir registers allocated so far:\n");
- reg = hTabFirstItem(dynDirectRegNames, &hkey);
-
- while(reg) {
- debugLog(" -- #%d reg = %s key %d, rIdx = %d, size %d\n",i++,reg->name,hkey, reg->rIdx,reg->size);
- reg = hTabNextItem(dynDirectRegNames, &hkey);
- }
-
- }
-
- if (options.dump_pack)
- dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
-
- /* first determine for each live range the number of
- registers & the type of registers required for each */
- regTypeNum ();
-
- /* and serially allocate registers */
- serialRegAssign (ebbs, count);
-
- /* if stack was extended then tell the user */
- if (_G.stackExtend)
- {
-/* werror(W_TOOMANY_SPILS,"stack", */
-/* _G.stackExtend,currFunc->name,""); */
- _G.stackExtend = 0;
- }
-
- if (_G.dataExtend)
- {
-/* werror(W_TOOMANY_SPILS,"data space", */
-/* _G.dataExtend,currFunc->name,""); */
- _G.dataExtend = 0;
- }
-
- /* after that create the register mask
- for each of the instruction */
- createRegMask (ebbs, count);
-
- /* redo that offsets for stacked automatic variables */
- redoStackOffsets ();
-
- if (options.dump_rassgn)
- dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
-
- /* now get back the chain */
- ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
-
- debugLog ("ebbs after optimizing:\n");
- dumpEbbsToDebug (ebbs, count);
-
-
- genpic14Code (ic);
-
- /* free up any _G.stackSpil locations allocated */
- applyToSet (_G.stackSpil, deallocStackSpil);
- _G.slocNum = 0;
- setToNull ((void *) &_G.stackSpil);
- setToNull ((void *) &_G.spiltSet);
- /* mark all registers as free */
- //pic14_freeAllRegs ();
-
- debugLog ("leaving\n<><><><><><><><><><><><><><><><><>\n");
- debugLogClose ();
- return;
+ iCode *ic;
+ int i;
+
+ debugLog ("<><><><><><><><><><><><><><><><><>\nstarting\t%s:%s", __FILE__, __FUNCTION__);
+ debugLog ("\nebbs before optimizing:\n");
+ dumpEbbsToDebug (ebbs, count);
+
+ setToNull ((void *) &_G.funcrUsed);
+ pic14_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
+
+
+ /* change assignments this will remove some
+ live ranges reducing some register pressure */
+ for (i = 0; i < count; i++)
+ packRegisters (ebbs[i]);
+
+ {
+ regs *reg;
+ int hkey;
+ int i=0;
+
+ debugLog("dir registers allocated so far:\n");
+ reg = hTabFirstItem(dynDirectRegNames, &hkey);
+
+ while(reg) {
+ debugLog(" -- #%d reg = %s key %d, rIdx = %d, size %d\n",i++,reg->name,hkey, reg->rIdx,reg->size);
+ reg = hTabNextItem(dynDirectRegNames, &hkey);
+ }
+
+ }
+
+ if (options.dump_pack)
+ dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
+
+ /* first determine for each live range the number of
+ registers & the type of registers required for each */
+ regTypeNum ();
+
+ /* and serially allocate registers */
+ serialRegAssign (ebbs, count);
+
+ /* if stack was extended then tell the user */
+ if (_G.stackExtend)
+ {
+ /* werror(W_TOOMANY_SPILS,"stack", */
+ /* _G.stackExtend,currFunc->name,""); */
+ _G.stackExtend = 0;
+ }
+
+ if (_G.dataExtend)
+ {
+ /* werror(W_TOOMANY_SPILS,"data space", */
+ /* _G.dataExtend,currFunc->name,""); */
+ _G.dataExtend = 0;
+ }
+
+ /* after that create the register mask
+ for each of the instruction */
+ createRegMask (ebbs, count);
+
+ /* redo that offsets for stacked automatic variables */
+ redoStackOffsets ();
+
+ if (options.dump_rassgn)
+ dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
+
+ /* now get back the chain */
+ ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
+
+ debugLog ("ebbs after optimizing:\n");
+ dumpEbbsToDebug (ebbs, count);
+
+
+ genpic14Code (ic);
+
+ /* free up any _G.stackSpil locations allocated */
+ applyToSet (_G.stackSpil, deallocStackSpil);
+ _G.slocNum = 0;
+ setToNull ((void *) &_G.stackSpil);
+ setToNull ((void *) &_G.spiltSet);
+ /* mark all registers as free */
+ //pic14_freeAllRegs ();
+
+ debugLog ("leaving\n<><><><><><><><><><><><><><><><><>\n");
+ debugLogClose ();
+ return;
}
enum
- {
- R2_IDX = 0, R3_IDX, R4_IDX,
- R5_IDX, R6_IDX, R7_IDX,
- R0_IDX, R1_IDX, X8_IDX,
- X9_IDX, X10_IDX, X11_IDX,
- X12_IDX, CND_IDX
- };
+{
+ R2_IDX = 0, R3_IDX, R4_IDX,
+ R5_IDX, R6_IDX, R7_IDX,
+ R0_IDX, R1_IDX, X8_IDX,
+ X9_IDX, X10_IDX, X11_IDX,
+ X12_IDX, CND_IDX
+};
enum {
- REG_PTR=1,
- REG_GPR,
- REG_CND,
- REG_SFR,
- REG_STK,
- REG_TMP
+ REG_PTR=1,
+ REG_GPR,
+ REG_CND,
+ REG_SFR,
+ REG_STK,
+ REG_TMP
};
//#define REG_PTR 0x01
//#define REG_GPR 0x02
/* definition for the registers */
typedef struct regs
- {
- short type; /* can have value
- * REG_GPR, REG_PTR or REG_CND
- * This like the "meta-type" */
- short pc_type; /* pcode type */
- short rIdx; /* index into register table */
- // short otype;
- char *name; /* name */
-
- unsigned isFree:1; /* is currently unassigned */
- unsigned wasUsed:1; /* becomes true if register has been used */
- unsigned isFixed:1; /* True if address can't change */
- unsigned isMapped:1; /* The Register's address has been mapped to physical RAM */
- unsigned isBitField:1; /* True if reg is type bit OR is holder for several bits */
- unsigned isEmitted:1; /* True if the reg has been written to a .asm file */
- unsigned isPublic:1; /* True if the reg is not static and can be modified in another module (ie a another c or asm file) */
- unsigned isExtern:1; /* True if the reg is in another module */
- unsigned address; /* reg's address if isFixed | isMapped is true */
- unsigned size; /* 0 for byte, 1 for int, 4 for long */
- unsigned alias; /* Alias mask if register appears in multiple banks */
- struct regs *reg_alias; /* If more than one register share the same address
- * then they'll point to each other. (primarily for bits)*/
- pCodeRegLives reglives; /* live range mapping */
- }
+{
+ short type; /* can have value
+ * REG_GPR, REG_PTR or REG_CND
+ * This like the "meta-type" */
+ short pc_type; /* pcode type */
+ short rIdx; /* index into register table */
+ // short otype;
+ char *name; /* name */
+
+ unsigned isFree:1; /* is currently unassigned */
+ unsigned wasUsed:1; /* becomes true if register has been used */
+ unsigned isFixed:1; /* True if address can't change */
+ unsigned isMapped:1; /* The Register's address has been mapped to physical RAM */
+ unsigned isBitField:1; /* True if reg is type bit OR is holder for several bits */
+ unsigned isEmitted:1; /* True if the reg has been written to a .asm file */
+ unsigned isPublic:1; /* True if the reg is not static and can be modified in another module (ie a another c or asm file) */
+ unsigned isExtern:1; /* True if the reg is in another module */
+ unsigned address; /* reg's address if isFixed | isMapped is true */
+ unsigned size; /* 0 for byte, 1 for int, 4 for long */
+ unsigned alias; /* Alias mask if register appears in multiple banks */
+ struct regs *reg_alias; /* If more than one register share the same address
+ * then they'll point to each other. (primarily for bits)*/
+ pCodeRegLives reglives; /* live range mapping */
+}
regs;
extern regs regspic14[];
extern int pic14_nRegs;