+2004-06-30 Vangelis Rokas <vrokas AT otenet.gr>
+
+ * device/lib/Makefile.in: fixed bug in target objects-pic16,
+ * device/lib/pic16/Makefile: prefixed with dash (-) command under
+ target 'clean',
+ * doc/sdccman.lyx: changed version to 2.4.2 and added some port
+ specific command line arguments. Also added sample lkr script
+ for placing a variable at a specific memory bank.
+ * src/pic16/device.c (pic16_dump_gsection): NEW, to dump variables
+ at a specific memory bank,
+ * (pic16_dump_isection): fixed bug which caused string literals to
+ be omitted when dumping idata section,
+ * (pic16_groupRegistersInSection): added code to handle registers
+ in specific memory banks,
+ * src/pic16/gen.c: labelOffset is prefixed with pic16_ and made
+ public, all references are renamed too,
+ * (pic16_aopGet): removed switch cases for AOP_R0,AOP_R1,AOP_DPTR,
+ AOP_DPTR2,
+ * (pic16_storeForReturn): added case to handle when dest is WREG,
+ * src/pic16/genarith.c (pic16_pCodeOpSubType): NEW,
+ * src/pic16/glue.c (pic16emitRegularMap): when adding a register in
+ pic16_rel_udata, check to see if that register is marked as being
+ a member of a specific memory bank,
+ * (pic16_printIvalCharPtr): added code to add string literals either
+ to code or the idata sections,
+ * src/pic16/main.c (_process_pragma): added \n to WHITE constant,
+ also accept the 'udata' pragma,
+ * src/pic16/main.h: new structure types sectName and sectSym
+ * src/pic16/pcode.c: added new pCodeInstruction entry for BANKSEL
+ * (newpCodeOpBit): added PIC_OPTYPE subt in function prototype,
+ * (pic16_findPrevInstruction): fixed, it returned nothing,
+ * (insertBankSwitch): fixed to emit banksel/skip and skip/banksel
+ instruction combinations,
+ * (pic16_FixRegisterBanking): heavily reorganised,
+ * (pic16_AnalyzeBanking): if generating banksel directives is
+ disabled, then don't call FixRegisterBanking at all,
+ * src/pic16/ralloc.c (bitEQUs, aliasEQUs, allDefsOutOfRange):
+ completely removed,
+ * (pic16_writeUsedRegisters): added call to pic16_dump_gsection
+
2004-06-29 Bernhard Held <bernhard AT bernhardheld.de>
* src/SDCCglue.c (printChar): fixed bug #973350, patch provided by
fi
objects-pic16: build-dir port-specific-objects-pic16 clean_intermediate-pic16
- cd $(PORTDIR)/bin; ls *$(OEXT) > $(PORT).lib
+ cd $(PORTDIR); ls *$(OEXT) > $(PORT).lib
build-dir: $(PORTDIR)
clean: all-clean
- $(RM) -f bin/*
+ -$(RM) -f bin/*
\size normal
-SDCC 2.4.1
+SDCC 2.4.2
\size footnotesize
\newline
-preplace-udata-with=[kword] Replaces the default udata keyword for allocating
unitialized data variables with [kword].
Valid keywords are: "udata_acs", "udata_shr", "udata_ovr".
+\layout List
+\labelwidthstring 00.00.0000
+
+-
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash
+/
+\end_inset
+
+-ivt-loc <nnnn> positions the Interrupt Vector Table at location <nnnn>.
+ Useful for bootloaders.
+\layout List
+\labelwidthstring 00.00.0000
+
+-
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash
+/
+\end_inset
+
+-asm= sets the full path and name of an external assembler to call.
+\layout List
+\labelwidthstring 00.00.0000
+
+-
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash
+/
+\end_inset
+
+-link= sets the full path and name of an external linker to call.
\layout Subsubsection
Debugging Options
\newline
The stack pragma should be used only once in a project.
Multiple pragmas may result in indeterminate behaviour of the program.
-\newline
-If you omit setting the pragma the port emits a warning message before linking.
- If not initializing the stack is desired ignore the message.
\layout LyX-Code
Example:
\layout LyX-Code
#pragma stack 0x5ff
+\layout List
+\labelwidthstring 00.00.0000
+
+udata pragma udata instructs the compiler to emit code so that linker will
+ place a variable at a specific memory bank
+\layout LyX-Code
+
+Example:
+\layout LyX-Code
+
+\layout LyX-Code
+
+/* places variable foo at bank2 */
+\layout LyX-Code
+
+#pragma udata bank2 foo
+\layout LyX-Code
+
+char foo;
+\layout Standard
+
+In order for this pragma to work there are some changes that must be made
+ in the .lkr script used in link stage.
+ In the following example a sample .lkr file is shown:
+\layout LyX-Code
+
\layout LyX-Code
+// Sample linker script for the PIC18F452 processor
+\layout LyX-Code
+
+LIBPATH .
+\layout LyX-Code
+
+CODEPAGE NAME=vectors START=0x0 END=0x29 PROTECTED
+\layout LyX-Code
+
+CODEPAGE NAME=page START=0x2A END=0x7FFF
+\layout LyX-Code
+
+CODEPAGE NAME=idlocs START=0x200000 END=0x200007 PROTECTED
+\layout LyX-Code
+
+CODEPAGE NAME=config START=0x300000 END=0x30000D PROTECTED
+\layout LyX-Code
+
+CODEPAGE NAME=devid START=0x3FFFFE END=0x3FFFFF PROTECTED
+\layout LyX-Code
+
+CODEPAGE NAME=eedata START=0xF00000 END=0xF000FF PROTECTED
+\layout LyX-Code
+
+ACCESSBANK NAME=accessram START=0x0 END=0x7F
+\layout LyX-Code
+
+\layout LyX-Code
+
+DATABANK NAME=gpr0 START=0x80 END=0xFF
+\layout LyX-Code
+
+DATABANK NAME=gpr1 START=0x100 END=0x1FF
+\layout LyX-Code
+
+DATABANK NAME=gpr2 START=0x200 END=0x2FF
+\layout LyX-Code
+
+DATABANK NAME=gpr3 START=0x300 END=0x3FF
+\layout LyX-Code
+
+DATABANK NAME=gpr4 START=0x400 END=0x4FF
+\layout LyX-Code
+
+DATABANK NAME=gpr5 START=0x500 END=0x5FF
+\layout LyX-Code
+
+ACCESSBANK NAME=accesssfr START=0xF80 END=0xFFF PROTECTED
+\layout LyX-Code
+
+\layout LyX-Code
+
+SECTION NAME=CONFIG ROM=config
+\layout LyX-Code
+
+\layout LyX-Code
+
+SECTION NAME=bank0 RAM=gpr0
+\layout LyX-Code
+
+SECTION NAME=bank1 RAM=gpr1
+\layout LyX-Code
+
+SECTION NAME=bank2 RAM=gpr2
+\layout LyX-Code
+
+SECTION NAME=bank3 RAM=gpr3
+\layout LyX-Code
+
+SECTION NAME=bank4 RAM=gpr4
+\layout LyX-Code
+
+SECTION NAME=bank5 RAM=gpr5
+\layout Standard
+
+The linker will recognise the section name set in the pragma statement and
+ will position the variable at the memory bank set with the RAM field at
+ the SECTION line in the linker script file.
\layout Subsection
Header Files
FSR0 (FSR0L and FSR0H)
\layout Standard
-These registers are restored upon return from the interrupt routine
+These registers are restored upon return from the interrupt routine.
+
+\layout Standard
+
+When entering a high priority interrupt WREG, STATUS and BSR are not explicit
+ saved by software.
+ The hardware shadow registers for WREG, STATUS and BSR are used in these
+ cases.
+\layout Standard
+
+
\begin_inset Foot
collapsed false
--pcode-verbose enable verbose pcode generator messages
- port options
- --pgen-banksel enable banksel directives for the assembler
- This will be turned on by default later, but left as
- is for now
+ --pno-banksel disable banksel directives for the assembler
--pomit-config-words does not emit configuration instruction in
the translation This is useful when copmiling
multiple sources, when you do not want multiple
#include "newalloc.h"
+#include "main.h"
#include "pcode.h"
#include "ralloc.h"
#include "device.h"
{ 0xff, 0, 0xff } /* a */ , { 0xe0, 0, 0xff } /* b */ , { 0xff, 0, 0xff } /* c */ ,
{ 0x40, 0, 0xff } /* d */ }
}
- },
+ }
};
free(rlist);
}
+void pic16_dump_gsection(FILE *of, set *sections)
+{
+ regs *r;
+ sectName *sname;
+
+ for(sname = setFirstItem(sections); sname; sname = setNextItem(sections)) {
+ fprintf(of, "\n\n%s\tudata\n", sname->name);
+
+ for(r=setFirstItem(sname->regsSet); r; r=setNextItem(sname->regsSet)) {
+#if 0
+ fprintf(stderr, "%s:%d emitting variable %s for section %s (%p)\n", __FILE__, __LINE__,
+ r->name, sname->name, sname);
+#endif
+ fprintf(of, "%s\tres\t%d\n", r->name, r->size);
+ }
+ }
+}
+
/* forward declaration */
void pic16_printIval(symbol * sym, sym_link * type, initList * ilist, char ptype, void *p);
+extern void pic16_pCodeConstString(char *name, char *value);
void pic16_dump_isection(FILE *of, set *section, int fix)
{
if(!fix) {
fprintf(of, "\n\n\tidata\n");
for(s = setFirstItem(section); s; s = setNextItem(section)) {
- fprintf(of, "%s", s->rname);
- pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
- pic16_flushDB('f', (void *)of);
+
+ if(s->ival) {
+ fprintf(of, "%s", s->rname);
+ pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
+ pic16_flushDB('f', (void *)of);
+ } else {
+ if (IS_ARRAY (s->type) && IS_CHAR (s->type->next)
+ && SPEC_CVAL (s->etype).v_char) {
+
+// fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, s->rname);
+ pic16_pCodeConstString(s->rname , SPEC_CVAL (s->etype).v_char);
+ } else {
+ assert(0);
+ }
+ }
+
}
} else {
int j=0;
fprintf(of, "\nistat_%s_%02d\tidata\t0X%04X\n", moduleName, abs_isection_no++, init_addr);
}
- fprintf(of, "%s", s->rname);
- pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
- pic16_flushDB('f', (void *)of);
+ if(s->ival) {
+ fprintf(of, "%s", s->rname);
+ pic16_printIval(s, s->type, s->ival, 'f', (void *)of);
+ pic16_flushDB('f', (void *)of);
+ } else {
+ if (IS_ARRAY (s->type) && IS_CHAR (s->type->next)
+ && SPEC_CVAL (s->etype).v_char) {
+
+// fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, s->rname);
+ pic16_pCodeConstString(s->rname , SPEC_CVAL (s->etype).v_char);
+ } else {
+ assert(0);
+ }
+ }
+
sprev = s;
}
void pic16_groupRegistersInSection(set *regset)
{
regs *reg;
+ sectSym *ssym;
+ int docontinue=0;
for(reg=setFirstItem(regset); reg; reg = setNextItem(regset)) {
(reg->regop?(OP_SYMBOL(reg->regop)->ival?1:0):-1),
(reg->regop?(OP_SYMBOL(reg->regop)->level):-1) );
#endif
+
+ docontinue=0;
+ for(ssym=setFirstItem(sectSyms);ssym;ssym=setNextItem(sectSyms)) {
+ if(!strcmp(ssym->name, reg->name)) {
+// fprintf(stderr, "%s:%d section found %s (%p) with var %s\n",
+// __FILE__, __LINE__, ssym->section->name, ssym->section, ssym->name);
+ addSet(&ssym->section->regsSet, reg);
+ docontinue=1;
+ }
+ }
+
+ if(docontinue)continue;
+
+// fprintf(stderr, "%s:%d reg: %s\n", __FILE__, __LINE__, reg->name);
if(reg->alias == 0x80) {
checkAddReg(&pic16_equ_data, reg);
static void mov2w (asmop *aop, int offset);
static int aopIdx (asmop *aop, int offset);
-static int labelOffset=0;
+int pic16_labelOffset=0;
extern int pic16_debug_verbose;
static int optimized_for_speed = 0;
/*
void pic16_emitpLabel(int key)
{
- pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(NULL,key+100+labelOffset));
+ pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(NULL,key+100+pic16_labelOffset));
}
void pic16_emitpLabelFORCE(int key)
{
- pic16_addpCode2pBlock(pb,pic16_newpCodeLabelFORCE(NULL,key+100+labelOffset));
+ pic16_addpCode2pBlock(pb,pic16_newpCodeLabelFORCE(NULL,key+100+pic16_labelOffset));
}
void pic16_emitpcode(PIC_OPCODE poc, pCodeOp *pcop)
#endif
}
- DEBUGpic16_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
+ DEBUGpic16_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,pic16_labelOffset);
}
#if 0
/* if symbol was initially placed onStack then we must re-place it
* to direct memory, since pic16 does not have a specific stack */
if(sym->onStack) {
- sym->onStack = 0;
+// sym->onStack = 0;
SPEC_OCLS( sym->etype ) = data;
space = data;
}
/* depending on type */
switch (aop->type) {
- case AOP_R0:
- case AOP_R1:
- DEBUGpic16_emitcode(";","%d",__LINE__);
- /* if we need to increment it */
- while (offset > aop->coff) {
- pic16_emitcode ("inc","%s",aop->aopu.aop_ptr->name);
- aop->coff++;
- }
-
- while (offset < aop->coff) {
- pic16_emitcode("dec","%s",aop->aopu.aop_ptr->name);
- aop->coff--;
- }
-
- aop->coff = offset ;
- if (aop->paged) {
- pic16_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:
- DEBUGpic16_emitcode(";","%d",__LINE__);
- if (aop->type == AOP_DPTR2)
- {
- genSetDPTR(1);
- }
-
- while (offset > aop->coff) {
- pic16_emitcode ("inc","dptr");
- aop->coff++;
- }
-
- while (offset < aop->coff) {
- pic16_emitcode("lcall","__decdptr");
- aop->coff--;
- }
-
- aop->coff = offset;
- if (aop->code) {
- pic16_emitcode("clr","a");
- pic16_emitcode("movc","a,@a+dptr");
- }
- else {
- pic16_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);
pCodeOp *pic16_popGetLabel(unsigned int key)
{
- DEBUGpic16_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, labelOffset);
+ DEBUGpic16_emitcode ("; ***","%s key=%d, label offset %d",__FUNCTION__,key, pic16_labelOffset);
if(key>max_key)
max_key = key;
- return pic16_newpCodeOpLabel(NULL,key+100+labelOffset);
+ return pic16_newpCodeOpLabel(NULL,key+100+pic16_labelOffset);
}
/*-----------------------------------------------------------------*/
case AOP_CRY:
DEBUGpic16_emitcode(";","%d\tAOP_CRY", __LINE__);
- pcop = pic16_newpCodeOpBit(aop->aopu.aop_dir,-1,1);
+ pcop = pic16_newpCodeOpBit(aop->aopu.aop_dir,-1,1, PO_GPR_REGISTER);
PCOR(pcop)->r = pic16_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);
} else {
/* >32-bits, result on stack, and FSR0 points to beginning.
* Fix stack when done */
-
+ /* FIXME FIXME */
while (size--) {
// DEBUGpic16_emitcode("; ", "POC_MOVLW %d", GpsuedoStkPtr);
// DEBUGpic16_emitcode("; ", "POC_MOVFW PLUSW2");
symbol *sym;
sym_link *ftype;
- DEBUGpic16_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,labelOffset,max_key);
+ DEBUGpic16_emitcode ("; ***","%s %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,pic16_labelOffset,max_key);
- labelOffset += (max_key+4);
+ pic16_labelOffset += (max_key+4);
max_key=0;
GpsuedoStkPtr=0;
_G.nRegsSaved = 0;
case 2: abSym->address = 0x000018; break;
}
-
/* relocate interrupt vectors if needed */
abSym->address += pic16_options.ivt_loc;
}
}
- pic16_emitpcomment("%s: _G.nRegsSaved upon exit from function: %d\n", __FUNCTION__, _G.nRegsSaved);
+// pic16_emitpcomment("%s: _G.nRegsSaved upon exit from function: %d\n", __FUNCTION__, _G.nRegsSaved);
/* if debug then send end of function */
if (currFunc) {
debugFile->writeEndFunction (currFunc, ic, 1);
if(dest->type != PO_WREG)
pic16_emitpcode(POC_MOVWF, dest);
} else {
+ if(dest->type == PO_WREG && (offset == 0)) {
+ pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(op), offset));
+ return;
+ }
+
pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
pic16_popGet(AOP(op), offset), dest));
}
&& IC_LABEL(ic->next) == returnLabel)) {
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(returnLabel->key));
- pic16_emitcode("goto","_%05d_DS_",returnLabel->key+100 + labelOffset);
+ pic16_emitcode("goto","_%05d_DS_",returnLabel->key+100 + pic16_labelOffset);
}
}
return ;
pic16_emitpLabel(IC_LABEL(ic)->key);
- pic16_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + labelOffset));
+ pic16_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + pic16_labelOffset));
}
/*-----------------------------------------------------------------*/
static void genGoto (iCode *ic)
{
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_LABEL(ic)->key));
- pic16_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+labelOffset);
+ pic16_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+pic16_labelOffset);
}
emitSKPC;
else {
DEBUGpic16_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(jval,-1,1));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(jval,-1,1, PO_GPR_REGISTER));
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ic)->key));
- pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + labelOffset);
+ pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + pic16_labelOffset);
}
else {
emitSKPNC;
else {
DEBUGpic16_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(jval,-1,1));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(jval,-1,1, PO_GPR_REGISTER));
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ic)->key));
- pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + labelOffset);
+ pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + pic16_labelOffset);
}
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- // pic16_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ // pic16_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+pic16_labelOffset);
} else {
break;
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- // pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ // pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+pic16_labelOffset);
}
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
if ( IC_TRUE(ifx) )
- pic16_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ pic16_emitcode("goto","_%05d_DS_",IC_TRUE(ifx)->key+100+pic16_labelOffset);
else
- pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ pic16_emitcode("goto","_%05d_DS_",IC_FALSE(ifx)->key+100+pic16_labelOffset);
}
#endif
return;
if(rifx->condition)
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(op),offset,FALSE,FALSE),bit,0, PO_GPR_REGISTER));
else
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(op),offset,FALSE,FALSE),bit,0));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(op),offset,FALSE,FALSE),bit,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(rifx->lbl->key));
#if 0
fprintf(stderr, "%s:%s:%d truelbl: %d\tlbl: %d\n",
- __FILE__, __FUNCTION__, __LINE__, truelbl->key+100+labelOffset, lbl->key+100+labelOffset);
+ __FILE__, __FUNCTION__, __LINE__, truelbl->key+100+pic16_labelOffset, lbl->key+100+pic16_labelOffset);
#endif
#ifndef _swapp
//genSkipCond(&rFalseIfx,left,size,7);
//rFalseIfx.condition ^= 1;
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),size,FALSE,FALSE),7,0, PO_GPR_REGISTER));
if(rFalseIfx.condition)
pic16_emitpcode(POC_GOTO, pic16_popGetLabel(rFalseIfx.lbl->key));
else
//genSkipCond(&rFalseIfx,left,size,7);
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),size,FALSE,FALSE),7,0, PO_GPR_REGISTER));
if(rFalseIfx.condition)
pic16_emitpcode(POC_GOTO, pic16_popGetLabel(truelbl->key));
} else {
/* lit is positive */
DEBUGpic16_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),size,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),size,FALSE,FALSE),7,0, PO_GPR_REGISTER));
if(rFalseIfx.condition)
pic16_emitpcode(POC_GOTO, pic16_popGetLabel(rFalseIfx.lbl->key));
else
int s = size;
if(rFalseIfx.condition) {
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_GOTO, pic16_popGetLabel(truelbl->key));
}
//rFalseIfx.condition ^= 1;
//genSkipCond(&rFalseIfx,left,size,7);
//rFalseIfx.condition ^= 1;
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0, PO_GPR_REGISTER));
//pic16_emitpcode(POC_GOTO, pic16_popGetLabel(truelbl->key));
if(rFalseIfx.condition)
//pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0));
//pic16_emitpcode(POC_GOTO, pic16_popGetLabel(rFalseIfx.lbl->key));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size,FALSE,FALSE),7,0, PO_GPR_REGISTER));
if(rFalseIfx.condition)
pic16_emitpcode(POC_GOTO, pic16_popGetLabel(truelbl->key));
else
pic16_emitcode("jc","%05d_DS_",tlbl->key+100);
pic16_emitcode("ljmp","%05d_DS_",IC_FALSE(ifx)->key+100);
}
- pic16_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
+ pic16_emitcode("","%05d_DS_:",tlbl->key+100+pic16_labelOffset);
{
/* left and right are both bit variables, result is carry */
if ( IC_TRUE(ifx) ) {
emitSKPNZ;
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- // pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ // pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+pic16_labelOffset);
} else {
emitSKPZ;
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- // pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ // pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+pic16_labelOffset);
}
} else {
DEBUGpic16_emitcode (";","\tIC_TRUE emitSKPZ");
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(tlbl->key));
- pic16_emitcode(" goto","_%05d_DS_",tlbl->key+100+labelOffset);
+ pic16_emitcode(" goto","_%05d_DS_",tlbl->key+100+pic16_labelOffset);
} else {
emitSKPNZ;
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
- pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+labelOffset);
+ pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ifx)->key+100+pic16_labelOffset);
}
} else {
emitSKPZ;
DEBUGpic16_emitcode (";","\tnot IC_TRUE emitSKPZ");
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ifx)->key));
- pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+labelOffset);
+ pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ifx)->key+100+pic16_labelOffset);
}
offset++;
}
if(s>1 && IC_TRUE(ifx)) {
pic16_emitpLabel(tlbl->key);
- pic16_emitcode("","_%05d_DS_:",tlbl->key+100+labelOffset);
+ pic16_emitcode("","_%05d_DS_:",tlbl->key+100+pic16_labelOffset);
}
}
}
tlbl = newiTempLabel(NULL);
pic16_toBoolean(left);
emitSKPZ;
- pic16_emitcode("goto","%05d_DS_",tlbl->key+100+labelOffset);
+ pic16_emitcode("goto","%05d_DS_",tlbl->key+100+pic16_labelOffset);
pic16_toBoolean(right);
- pic16_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
+ pic16_emitcode("","%05d_DS_:",tlbl->key+100+pic16_labelOffset);
pic16_outBitAcc(result);
}
}
pic16_emitpcode(((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
- pic16_newpCodeOpBit(pic16_aopGet(AOP(left),ofs,FALSE,FALSE),bp,0));
+ pic16_newpCodeOpBit(pic16_aopGet(AOP(left),ofs,FALSE,FALSE),bp,0, PO_GPR_REGISTER));
}
/*
if(p>=0) {
/* only one bit is set in the literal, so use a bcf instruction */
// pic16_emitcode("bcf","%s,%d",pic16_aopGet(AOP(left),offset,FALSE,TRUE),p);
- pic16_emitpcode(POC_BCF,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offset,FALSE,FALSE),p,0));
+ pic16_emitpcode(POC_BCF,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offset,FALSE,FALSE),p,0, PO_GPR_REGISTER));
} else {
pic16_emitcode("movlw","0x%x", (lit & 0xff));
if(p>=0) {
/* only one bit is set in the literal, so use a bsf instruction */
pic16_emitpcode(POC_BSF,
- pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offset,FALSE,FALSE),p,0));
+ pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offset,FALSE,FALSE),p,0, PO_GPR_REGISTER));
} else {
if(know_W != (lit & 0xff))
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(lit & 0xff));
pic16_emitpcode(POC_RLCFW, pic16_popGet(AOP(result),offr));
pic16_emitpcode(POC_ANDLW, pic16_popGetLit(0x1f));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),3,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_IORLW, pic16_popGetLit(0xe0));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offr));
case 4:
pic16_emitpcode(POC_SWAPFW, pic16_popGet(AOP(left),offl));
pic16_emitpcode(POC_ANDLW, pic16_popGetLit(0x0f));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_IORLW, pic16_popGetLit(0xf0));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offr));
break;
}
pic16_emitpcode(POC_RRCFW, pic16_popGet(AOP(result),offr));
pic16_emitpcode(POC_ANDLW, pic16_popGetLit(0x07));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),3,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_IORLW, pic16_popGetLit(0xf8));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offr));
break;
case 6:
if(same) {
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x00));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xfe));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),6,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_IORLW, pic16_popGetLit(0x01));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offr));
} else {
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),6,0));
- pic16_emitpcode(POC_BCF, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),0,0));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),6,0, PO_GPR_REGISTER));
+ pic16_emitpcode(POC_BCF, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),0,0, PO_GPR_REGISTER));
}
break;
case 7:
if(same) {
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x00));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),LSB,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xff));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offr));
} else {
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offr));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),offr));
}
if(sign) {
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xf0 + (shCount-4)*8 ));
pic16_emitpcode(POC_BTFSC,
- pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0));
+ pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_ADDWF, pic16_popGet(AOP(result),offr+MSB16));
}
pic16_emitpcode(POC_ANDLW,pic16_popGetLit(0x03));
if(sign) {
pic16_emitpcode(POC_BTFSC,
- pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0));
+ pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_IORLW,pic16_popGetLit(0xfc));
}
pic16_emitpcode(POC_XORFW,pic16_popGet(AOP(result),offr+MSB16));
pic16_emitpcode(POC_ANDLW,pic16_popGetLit(0x03));
if(sign) {
pic16_emitpcode(POC_BTFSC,
- pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
+ pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_IORLW,pic16_popGetLit(0xfc));
}
pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),offr+MSB16));
if(optimized_for_speed) {
pic16_emitpcode(POC_SWAPFW, pic16_popGet(AOP(left),0));
pic16_emitpcode(POC_ANDLW, pic16_popGetLit(0xf0));
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),2,0));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),2,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),0));
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),0));
- pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),0,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_ADDWF, pic16_popGet(AOP(result),0));
pic16_emitpcode(POC_RLCFW, pic16_popGet(AOP(result),0));
pic16_emitpcode(POC_ANDLW, pic16_popGetLit(0xfe));
pic16_emitpcode(POC_ADDFW, pic16_popGet(AOP(result),0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),1,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),1,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_ADDWF, pic16_popGet(AOP(result),0));
} else {
pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),MSB16));
if(sign) {
- pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),LSB,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),MSB16));
}
}
if(res_size == 1) {
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),LSB));
if(sign) {
- pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),LSB));
}
} else {
if(sign) {
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xff));
while(res_size--)
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),res_size));
/* we need to or */
if (AOP_TYPE(right) == AOP_REG) {
pic16_emitpcode(POC_BCF, pic16_popGet(AOP(result),0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),0,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),0,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_BSF, pic16_popGet(AOP(result),0));
}
pic16_toBoolean(right);
if(size == 1) {
/* Save one instruction of casting char to int */
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),offset));
} else {
pic16_emitpcode(POC_CLRF,pic16_popCopyReg(&pic16_pc_wreg));
if(offset)
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
else
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xff));
pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ifx)->key));
pic16_emitcode("decfsz","%s,f",pic16_aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
- pic16_emitcode ("goto","_%05d_DS_",IC_TRUE(ifx)->key+100 + labelOffset);
+ pic16_emitcode ("goto","_%05d_DS_",IC_TRUE(ifx)->key+100 + pic16_labelOffset);
}
/* pic16_emitcode ("sjmp","%05d_DS_",lbl1->key+100); */
{
DEBUGpic16_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
+#if 0
+ fprintf(stderr, "%s:%d %s for symbol %s\tonStack: %d\n", __FILE__, __LINE__, __FUNCTION__,
+ OP_SYMBOL( IC_RESULT(ic) )->rname, OP_SYMBOL( IC_RESULT(ic) )->onStack);
+#endif
+// pic16_DumpOp(__FUNCTION__, IC_RESULT(ic));
+
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 = pic16_fReturnSizePic - size;
+ assert( 0 );
while (size--) {
pic16_emitcode ("push","%s", (strcmp(fReturn[pic16_fReturnSizePic - offset - 1],"a") ?
fReturn[pic16_fReturnSizePic - offset - 1] : "acc"));
return "BAD TYPE";
}
-const char *pic16_pCodeOpType( pCodeOp *pcop)
+const char *pic16_pCodeOpType(pCodeOp *pcop)
{
if(pcop) {
return "BAD PO_TYPE";
}
+const char *pic16_pCodeOpSubType(pCodeOp *pcop)
+{
+
+ if(pcop && (pcop->type == PO_GPR_BIT)) {
+
+ switch(PCORB(pcop)->subtype) {
+
+ case PO_NONE:
+ return "PO_NONE";
+ case PO_W:
+ return "PO_W";
+ case PO_WREG:
+ return "PO_WREG";
+ case PO_STATUS:
+ return "PO_STATUS";
+ case PO_BSR:
+ return "PO_BSR";
+ case PO_FSR0:
+ return "PO_FSR0";
+ case PO_INDF0:
+ return "PO_INDF0";
+ case PO_INTCON:
+ return "PO_INTCON";
+ case PO_GPR_REGISTER:
+ return "PO_GPR_REGISTER";
+ 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_PCLATU:
+ return "PO_PCLATU";
+ case PO_PRODL:
+ return "PO_PRODL";
+ case PO_PRODH:
+ return "PO_PRODH";
+ case PO_LITERAL:
+ return "PO_LITERAL";
+ case PO_REL_ADDR:
+ return "PO_REL_ADDR";
+ 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";
+}
+
/*-----------------------------------------------------------------*/
/* pic16_genPlusIncr :- does addition with increment if possible */
/*-----------------------------------------------------------------*/
// right is signed, oh dear ...
for(i=size; i< AOP_SIZE(result); i++) {
pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),i));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),size-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),size-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_COMF, pic16_popGet(AOP(result),i));
pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(left),i));
pic16_emitpcode(POC_ADDWFC, pic16_popGet(AOP(result),i));
for(i=size; i< AOP_SIZE(result); i++) {
if(size < AOP_SIZE(left)) {
pic16_emitpcode(POC_CLRF, pic16_popCopyReg(&pic16_pc_wreg));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),size-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_COMFW, pic16_popCopyReg(&pic16_pc_wreg));
if (pic16_sameRegs(AOP(left), AOP(result)))
{
/* Now this is really horrid. Gotta check the sign of the addends and propogate
* to the result */
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(IC_LEFT(ic)),offset-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(IC_LEFT(ic)),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(IC_RESULT(ic)),offset));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(IC_RIGHT(ic)),offset-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(IC_RIGHT(ic)),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(IC_RESULT(ic)),offset));
/* if chars or ints or being signed extended to longs: */
if(size) {
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xff));
}
}
if(size == 1) {
pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),offset));
- pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),offset));
} else {
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0xff));
while(size--)
pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset+size));
/* if I can do an decrement instead
of subtract then GOOD for ME */
- // if (pic16_genMinusDec (ic) == TRUE)
- // goto release;
+// if (pic16_genMinusDec (ic) == TRUE)
+// goto release;
size = pic16_getDataSize(IC_RESULT(ic));
same = pic16_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic)));
#if 0
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),0,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),0,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_SUBWF, pic16_popCopyReg(result_hi));
pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),0));
- pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),7,0));
+ pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(right),0,FALSE,FALSE),7,0, PO_GPR_REGISTER));
pic16_emitpcode(POC_SUBWF, pic16_popGet(AOP(result),1));
#endif
}
for (sym = setFirstItem (map->syms); sym; sym = setNextItem (map->syms)) {
#if 0
- fprintf(stderr, "\t%s: sym: %s\tused: %d\textern: %d\tstatic: %d\taggregate: %d\n",
+ fprintf(stderr, "%s\t%s: sym: %s\tused: %d\textern: %d\tstatic: %d\taggregate: %d\n",
+ __FUNCTION__,
map->sname, sym->name, sym->used, IS_EXTERN(sym->etype), IS_STATIC(sym->etype),
IS_AGGREGATE(sym->type));
printTypeChain( sym->type, stderr );
#endif
reg = pic16_allocDirReg( operandFromSymbol( sym ));
- checkAddReg(&pic16_rel_udata, reg);
+// addSet(&pic16_dynAllocRegs, reg);
+
+ {
+ sectSym *ssym;
+ int found=0;
+
+ for(ssym=setFirstItem(sectSyms); ssym; ssym=setNextItem(sectSyms)) {
+ if(!strcmp(ssym->name, reg->name))found=1;
+ }
+
+ if(!found)checkAddReg(&pic16_rel_udata, reg);
+ }
}
/* if extern then do nothing or is a function
} else {
reg = pic16_allocDirReg( operandFromSymbol( sym ) );
}
- if(checkAddReg(&pic16_rel_udata, reg)) {
- addSetHead(&publics, sym);
+
+ {
+ sectSym *ssym;
+ int found=0;
+
+ for(ssym=setFirstItem(sectSyms); ssym; ssym=setNextItem(sectSyms)) {
+ if(!strcmp(ssym->name, reg->name))found=1;
+ }
+
+ if(!found)
+ if(checkAddReg(&pic16_rel_udata, reg)) {
+ addSetHead(&publics, sym);
+ }
+
}
+
+
+
} else
+
addSetHead(&publics, sym);
}
{
fprintf (stderr, "*** internal error: unknown size in "
"printIvalCharPtr.\n");
+ assert(0);
}
}
else
pic16_emitDB(pic16aopLiteral(val, 0), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 1), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 2), ptype, p);
-
break;
default:
}
}
- if (val->sym && val->sym->isstrlit && !isinSet(statsg->syms, val->sym)) {
- addSet (&statsg->syms, val->sym);
+ if (val->sym && val->sym->isstrlit) { // && !isinSet(statsg->syms, val->sym)) {
+ if(ptype == 'p' && !isinSet(statsg->syms, val->sym))addSet (&statsg->syms, val->sym);
+ else if(ptype == 'f' /*&& !isinSet(rel_idataSymSet, val->sym)*/)addSet(&rel_idataSymSet, val->sym);
}
return 1;
value *val;
int size;
-
#if 0
fprintf(stderr, "%s:%d initialising pointer: %s size: %d\n", __FILE__, __LINE__,
sym->rname, getSize(sym->type));
pic16_emitDB(pic16aopLiteral(val, 0), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 1), ptype, p);
pic16_emitDB(pic16aopLiteral(val, 2), ptype, p);
+ default:
+ assert(0);
}
return;
}
pic16_printGPointerType (val->name, sym->name, (IS_PTR(type)?DCL_TYPE(type):PTR_TYPE(SPEC_OCLS(sym->etype))),
(IS_PTR (val->type) ? DCL_TYPE (val->type) :
PTR_TYPE (SPEC_OCLS (val->etype))), ptype, p);
- }
+ } else
+ assert(0);
return;
}
if (!p)
return;
-// fprintf(stderr, "%s:%d generating init for %s\n", __FILE__, __LINE__, sym->name);
-
+#if 0
+ fprintf(stderr, "%s:%d generating init for %s\n", __FILE__, __LINE__, sym->name);
+ fprintf(stderr, "%s: IS_STRUCT: %d IS_ARRAY: %d IS_PTR: %d IS_SPEC: %d\n", sym->name,
+ IS_STRUCT(type), IS_ARRAY(type), IS_PTR(type), IS_SPEC(type));
+#endif
+
/* if structure then */
if (IS_STRUCT (type))
{
{
symbol *sym;
- fprintf (map->oFile, ";\t.area\t%s\n", map->sname);
-
//fprintf(stderr, "%s\n",__FUNCTION__);
pic16_initDB();
{
#if 0
- fprintf(stderr, "\t%s: sym: %s\tused: %d\tSPEC_ABSA: %d\tSPEC_AGGREGATE: %d\tCODE: %d\n\
-CODESPACE: %d\tCONST: %d\tPTRCONST: %d\tSPEC_CONST: %d\n",
+ fprintf(stderr, "%s\t%s: sym: %s\tused: %d\tSPEC_ABSA: %d\tSPEC_AGGREGATE: %d\tCODE: %d\n\
+CODESPACE: %d\tCONST: %d\tPTRCONST: %d\tSPEC_CONST: %d\n", __FUNCTION__,
map->sname, sym->name, sym->used, SPEC_ABSA(sym->etype), IS_AGGREGATE(sym->type),
IS_CODE(sym->etype), IN_CODESPACE( SPEC_OCLS(sym->etype)), IS_CONSTANT(sym->etype),
IS_PTR_CONST(sym->etype), SPEC_CONST(sym->etype));
pic16_addpCode2pBlock(pb,pcf);
pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(sym->rname,-1));
+// fprintf(stderr, "%s:%d [1] generating init for label: %s\n", __FILE__, __LINE__, sym->rname);
pic16_printIval(sym, sym->type, sym->ival, 'p', (void *)pb);
pic16_flushDB('p', (void *)pb);
/* special case for character strings */
if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
- SPEC_CVAL (sym->etype).v_char)
+ SPEC_CVAL (sym->etype).v_char) {
+
+// fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, sym->rname);
+
pic16_pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
- else {
+ } else {
assert(0);
- fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
}
}
pb = pic16_newpCodeChain(NULL, 'P',pic16_newpCodeCharP("; Starting pCode block for Ival"));
pic16_addpBlock(pb);
- pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(sym->rname,-1));
+// fprintf(stderr, "%s:%d [2] generating init for label: %s\n", __FILE__, __LINE__, sym->rname);
+
+ pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(sym->rname,-1));
pic16_printIval(sym, sym->type, sym->ival, 'p', (void *)pb);
pic16_flushDB('p', (void *)pb);
noAlloc--;
/* symbol doesn't have absolute address and no initial value */
/* allocate space */
+// fprintf(stderr, "%s:%d [3] generating init for label: %s\n", __FILE__, __LINE__, sym->rname);
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)
+ SPEC_CVAL (sym->etype).v_char) {
+
+// fprintf(stderr, "%s:%d printing code string from %s\n", __FILE__, __LINE__, sym->rname);
+
pic16_pCodeConstString(sym->rname , SPEC_CVAL (sym->etype).v_char);
- else {
+ } else {
assert(0);
- fprintf (code->oFile, "\t.ds\t0x%04x\n", (unsigned int) getSize (sym->type) & 0xffff);
}
}
}
if((!pic16_options.omit_ivt) || (pic16_options.omit_ivt && pic16_options.leave_reset)) {
fprintf (vFile, ";\t.area\t%s\n", CODE_NAME);
fprintf(vFile, ".intvecs\tcode\t0x%06x\n", pic16_options.ivt_loc);
- fprintf (vFile, "__interrupt_vect:\n");
/* this is an overkill since WE are the port,
* and we know if we have a genIVT function! */
if(initsfpnt) {
pic16_addpCode2pBlock(pb, pic16_newpCode(POC_LFSR,
- pic16_popGetLit2(1, pic16_newpCodeOpRegFromStr("stack"))));
+ pic16_popGetLit2(1, pic16_newpCodeOpRegFromStr("_stack"))));
pic16_addpCode2pBlock(pb, pic16_newpCode(POC_LFSR,
- pic16_popGetLit2(2, pic16_newpCodeOpRegFromStr("stack"))));
+ pic16_popGetLit2(2, pic16_newpCodeOpRegFromStr("_stack"))));
}
/* put in the call to main */
* so glue() later emits code to initialize stack/frame pointers */
set *absSymSet;
+set *sectNames=NULL; /* list of section listed in pragma directives */
+set *sectSyms=NULL; /* list of symbols set in a specific section */
+
+
static int
_process_pragma(const char *sz)
{
- static const char *WHITE = " \t";
+ static const char *WHITE = " \t\n";
char *ptr = strtok((char *)sz, WHITE);
+ /* #pragma maxram [maxram] */
if (startsWith (ptr, "maxram")) {
char *maxRAM = strtok((char *)NULL, WHITE);
}
}
+ /* #pragma stack [stack-position] */
if(startsWith(ptr, "stack")) {
char *stackPosS = strtok((char *)NULL, WHITE);
value *stackPosVal;
return 0;
}
+ /* #pragma code [symbol] [location] */
if(startsWith(ptr, "code")) {
char *symname = strtok((char *)NULL, WHITE);
char *location = strtok((char *)NULL, WHITE);
__FILE__, __LINE__, symname, absS->address);
return 0;
- }
+ }
+ /* #pragma udata [section-name] [symbol] */
+ if(startsWith(ptr, "udata")) {
+ char *sectname = strtok((char *)NULL, WHITE);
+ char *symname = strtok((char *)NULL, WHITE);
+ sectSym *ssym;
+ sectName *snam;
+ int found=0;
+
+ while(symname) {
+
+ ssym = Safe_calloc(1, sizeof(sectSyms));
+ ssym->name = Safe_calloc(1, strlen(symname)+2);
+ sprintf(ssym->name, "_%s", symname);
+ ssym->reg = NULL;
+
+ addSet(§Syms, ssym);
+
+ found = 0;
+ for(snam=setFirstItem(sectNames);snam;snam=setNextItem(sectNames)) {
+ if(!strcmp(sectname, snam->name)){ found=1; break; }
+ }
+
+ if(!found) {
+ snam = Safe_calloc(1, sizeof(sectNames));
+ snam->name = Safe_strdup( sectname );
+ snam->regsSet = NULL;
+
+ addSet(§Names, snam);
+ }
+
+ ssym->section = snam;
+
+// fprintf(stderr, "%s:%d placing symbol %s at section %s (%p)\n", __FILE__, __LINE__,
+// ssym->name, snam->name, snam);
+
+ symname = strtok((char *)NULL, WHITE);
+ }
+
+ return 0;
+ }
+
return 1;
}
#ifndef MAIN_INCLUDE
#define MAIN_INCLUDE
+#include "ralloc.h"
+
bool x_parseOptions (char **argv, int *pargc);
void x_setDefaultOptions (void);
void x_finaliseOptions (void);
unsigned int address;
} absSym;
+typedef struct sectName {
+ char *name;
+ set *regsSet;
+} sectName;
+
+typedef struct sectSym {
+ sectName *section;
+ char *name;
+ regs *reg;
+} sectSym;
extern set *absSymSet;
+extern set *sectNames;
+extern set *sectSyms;
#endif
};
+pCodeInstruction pic16_pciBANKSEL = {
+ {PC_OPCODE, NULL, NULL, 0, NULL,
+ genericDestruct,
+ genericPrint},
+ POC_BANKSEL,
+ "BANKSEL",
+ 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
+ 0, // RAM access bit
+ 0, // fast call/return mode select bit
+ 0, // second memory operand
+ 0, // second literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE, // outCond
+ PCI_MAGIC
+};
+
+
#define MAX_PIC16MNEMONICS 100
pCodeInstruction *pic16Mnemonics[MAX_PIC16MNEMONICS];
pic16Mnemonics[POC_RETURN] = &pic16_pciRETURN;
pic16Mnemonics[POC_RLCF] = &pic16_pciRLCF;
pic16Mnemonics[POC_RLCFW] = &pic16_pciRLCFW;
- pic16Mnemonics[POC_RLNCF] = &pic16_pciRLNCF; // was [POC_RLCF] !!!
+ pic16Mnemonics[POC_RLNCF] = &pic16_pciRLNCF;
pic16Mnemonics[POC_RLNCFW] = &pic16_pciRLNCFW;
pic16Mnemonics[POC_RRCF] = &pic16_pciRRCF;
pic16Mnemonics[POC_RRCFW] = &pic16_pciRRCFW;
pic16Mnemonics[POC_SUBFWB_D1] = &pic16_pciSUBFWB_D1;
pic16Mnemonics[POC_SWAPF] = &pic16_pciSWAPF;
pic16Mnemonics[POC_SWAPFW] = &pic16_pciSWAPFW;
- pic16Mnemonics[POC_TBLRD] = &pic16_pciTBLRD; // patch 15
- pic16Mnemonics[POC_TBLRD_POSTINC] = &pic16_pciTBLRD_POSTINC; //
- pic16Mnemonics[POC_TBLRD_POSTDEC] = &pic16_pciTBLRD_POSTDEC; //
- pic16Mnemonics[POC_TBLRD_PREINC] = &pic16_pciTBLRD_PREINC; //
- pic16Mnemonics[POC_TBLWT] = &pic16_pciTBLWT; //
- pic16Mnemonics[POC_TBLWT_POSTINC] = &pic16_pciTBLWT_POSTINC; //
- pic16Mnemonics[POC_TBLWT_POSTDEC] = &pic16_pciTBLWT_POSTDEC; //
- pic16Mnemonics[POC_TBLWT_PREINC] = &pic16_pciTBLWT_PREINC; // patch 15
+ pic16Mnemonics[POC_TBLRD] = &pic16_pciTBLRD;
+ pic16Mnemonics[POC_TBLRD_POSTINC] = &pic16_pciTBLRD_POSTINC;
+ pic16Mnemonics[POC_TBLRD_POSTDEC] = &pic16_pciTBLRD_POSTDEC;
+ pic16Mnemonics[POC_TBLRD_PREINC] = &pic16_pciTBLRD_PREINC;
+ pic16Mnemonics[POC_TBLWT] = &pic16_pciTBLWT;
+ pic16Mnemonics[POC_TBLWT_POSTINC] = &pic16_pciTBLWT_POSTINC;
+ pic16Mnemonics[POC_TBLWT_POSTDEC] = &pic16_pciTBLWT_POSTDEC;
+ pic16Mnemonics[POC_TBLWT_PREINC] = &pic16_pciTBLWT_PREINC;
pic16Mnemonics[POC_TSTFSZ] = &pic16_pciTSTFSZ;
pic16Mnemonics[POC_XORLW] = &pic16_pciXORLW;
pic16Mnemonics[POC_XORWF] = &pic16_pciXORWF;
pic16Mnemonics[POC_XORFW] = &pic16_pciXORFW;
+ pic16Mnemonics[POC_BANKSEL] = &pic16_pciBANKSEL;
for(i=0; i<MAX_PIC16MNEMONICS; i++)
if(pic16Mnemonics[i])
return pcop;
}
+
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-pCodeOp *pic16_newpCodeOpBit(char *s, int bit, int inBitSpace)
+pCodeOp *pic16_newpCodeOpBit(char *s, int bit, int inBitSpace, PIC_OPTYPE subt)
{
pCodeOp *pcop;
-
+
pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) );
pcop->type = PO_GPR_BIT;
if(s)
PCORB(pcop)->bit = bit;
PCORB(pcop)->inBitSpace = inBitSpace;
+ PCORB(pcop)->subtype = subt;
/* pCodeOpBit is derived from pCodeOpReg. We need to init this too */
PCOR(pcop)->r = NULL;
return pcop;
}
+
/*-----------------------------------------------------------------*
* pCodeOp *pic16_newpCodeOpReg(int rIdx) - allocate a new register
*
switch(type) {
case PO_BIT:
case PO_GPR_BIT:
- pcop = pic16_newpCodeOpBit(name, -1,0);
+ pcop = pic16_newpCodeOpBit(name, -1,0, type);
break;
case PO_LITERAL:
l = strlen(DBd.buffer);
sprintf(DBd.buffer+l,"%s0x%02x", (DBd.count>0?", ":""), c & 0xff);
+// fprintf(stderr, "%s:%d DBbuffer: '%s'\n", __FILE__, __LINE__, DBd.buffer);
+
DBd.count++;
if (DBd.count>= DB_ITEMS_PER_LINE)
pic16_flushDB(ptype, p);
l = strlen(DBd.buffer);
sprintf(DBd.buffer+l,"%s%s", (DBd.count>0?", ":""), s);
+// fprintf(stderr, "%s:%d DBbuffer: '%s'\n", __FILE__, __LINE__, DBd.buffer);
+
DBd.count++; //=strlen(s);
if (DBd.count>=16)
pic16_flushDB(ptype, p);
}
/*-----------------------------------------------------------------*/
-/* pCodeUnlink - Unlink the given pCode from its pCode chain. */
+/* pic16_pCodeUnlink - Unlink the given pCode from its pCode chain. */
/*-----------------------------------------------------------------*/
-static void pCodeUnlink(pCode *pc)
+void pic16_pCodeUnlink(pCode *pc)
{
pBranch *pb1,*pb2;
pCode *pc1;
/* Remove the branches */
- pb1 = pc->from;
+ pb1 = PCI(pc)->from;
while(pb1) {
- pc1 = pb1->pc; /* Get the pCode that branches to the
+ PCI(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((pb2 = pBranchFind(PCI(pc1)->to,pc))) {
+ pb2->pc = PCI(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)
- pic16_pBranchAppend(pb2, pc->to->next);
+ if(PCI(pc)->to->next)
+ pic16_pBranchAppend(pb2, PCI(pc)->to->next);
}
pb1 = pb1->next;
}
/*-----------------------------------------------------------------*/
-/* pic16_findNextInstruction - given a pCode, find the next instruction */
+/* pic16_findPrevInstruction - given a pCode, find the next instruction */
/* in the linked list */
/*-----------------------------------------------------------------*/
pCode * pic16_findPrevInstruction(pCode *pci)
pCode *pc = pci;
while(pc) {
+ pc = pc->prev;
+
if((pc->type == PC_OPCODE)
|| (pc->type == PC_WILD)
|| (pc->type == PC_ASMDIR)
fprintf(stderr,"pic16_findPrevInstruction: ");
printpCode(stderr, pc);
#endif
- pc = pc->next;
}
//fprintf(stderr,"Couldn't find instruction\n");
static void AnalyzeLabel(pCode *pc)
{
- pCodeUnlink(pc);
+ pic16_pCodeUnlink(pc);
}
#endif
case PO_FSR0:
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, "pic16_getRegFromInstruction - bit or temp\n");
if(PCOI(PCI(pc)->pcop)->r)
return (PCOI(PCI(pc)->pcop)->r);
- //fprintf(stderr, "pic16_getRegFromInstruction - immediate\n");
- return pic16_dirregWithName(PCI(pc)->pcop->name);
- //return NULL; // PCOR(PCI(pc)->pcop)->r;
-
case PO_GPR_BIT:
return PCOR(PCI(pc)->pcop)->r;
case PO_DIR:
// fprintf(stderr, "pic16_getRegFromInstruction - dir\n");
return PCOR(PCI(pc)->pcop)->r;
+
case PO_LITERAL:
//fprintf(stderr, "pic16_getRegFromInstruction - literal\n");
break;
// fprintf(stderr, "pic16_getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
// genericPrint(stderr, pc);
// assert( 0 );
- break;
+ break;
}
return NULL;
/* */
/* position == 0: insert before */
/* position == 1: insert after pc */
-/* position == 2: 0 previous was a skip instruction */
+/* position == 2: like 0 but previous was a skip instruction */
/*-----------------------------------------------------------------*/
+pCodeOp *pic16_popGetLabel(unsigned int key);
+extern int pic16_labelOffset;
+
static void insertBankSwitch(int position, pCode *pc)
{
pCode *new_pc;
/* emit BANKSEL [symbol] */
reg = pic16_getRegFromInstruction(pc);
- if(!reg)return;
+ if(!reg) {
+ if(!(PCI(pc)->pcop && PCI(pc)->pcop->type == PO_GPR_BIT))return;
+ }
new_pc = pic16_newpCodeAsmDir("BANKSEL", "%s", pic16_get_op_from_instruction(PCI(pc)));
// position = 0; // position is always before (sanity check!)
#if 0
- fprintf(stderr, "%s:%d: inserting bank switch\tbank = %d\n", __FUNCTION__, __LINE__, bsr);
+ fprintf(stderr, "%s:%d: inserting bank switch\n", __FUNCTION__, __LINE__);
pc->print(stderr, pc);
#endif
case 1: {
/* insert the bank switch after this pc instruction */
pCode *pcnext = pic16_findNextInstruction(pc);
- pic16_pCodeInsertAfter(pc, new_pc);
- if(pcnext)pc = pcnext;
+
+ pic16_pCodeInsertAfter(pc, new_pc);
+ if(pcnext)pc = pcnext;
}; break;
case 0:
/* insert the bank switch BEFORE this pc instruction */
pic16_pCodeInsertAfter(pc->prev, new_pc);
break;
+
+ case 2: {
+ /* just like 0, but previous was a skip instruction,
+ * so some care should be taken */
+ symbol *tlbl;
+ pCode *pcnext, *pcprev, *npci;;
+ PIC_OPCODE ipci;
+
+ pic16_labelOffset += 10000;
+ tlbl = newiTempLabel(NULL);
+
+ /* invert skip instruction */
+ pcprev = pic16_findPrevInstruction(pc);
+ ipci = PCI(pcprev)->inverted_op;
+ npci = pic16_newpCode(ipci, PCI(pcprev)->pcop);
+
+#if 1
+ PCI(npci)->from = PCI(pcprev)->from;
+ PCI(npci)->to = PCI(pcprev)->to;
+ PCI(npci)->label = PCI(pcprev)->label;
+ PCI(npci)->pcflow = PCI(pcprev)->pcflow;
+ PCI(npci)->cline = PCI(pcprev)->cline;
+#endif
+
+// memmove(PCI(pcprev), PCI(npci), sizeof(pCode) + sizeof(PIC_OPCODE) + sizeof(char const * const));
+
+#if 1
+ pic16_pCodeInsertAfter(pcprev->prev, npci);
+ /* unlink the pCode */
+ pcprev->prev->next = pcprev->next;
+ pcprev->next->prev = pcprev->prev;
+#endif
+
+ pcnext = pic16_newpCode(POC_GOTO, pic16_popGetLabel(tlbl->key));
+ pic16_pCodeInsertAfter(pc->prev, pcnext);
+ pic16_pCodeInsertAfter(pc->prev, new_pc);
+
+ pcnext = pic16_newpCodeLabel(NULL,tlbl->key+100+pic16_labelOffset);
+ pic16_pCodeInsertAfter(pc, pcnext);
+ }; break;
}
/* Move the label, if there is one */
-
if(PCI(pc)->label) {
// fprintf(stderr, "%s:%d: moving label due to bank switch directive src= 0x%p dst= 0x%p\n",
// __FILE__, __LINE__, pc, new_pc);
PCAD(new_pc)->pci.label = PCI(pc)->label;
PCI(pc)->label = NULL;
}
-
-// fprintf(stderr, "BankSwitch has been inserted\n");
}
return matches;
}
+
+
+const char *pic16_pCodeOpType(pCodeOp *pcop);
+const char *pic16_pCodeOpSubType(pCodeOp *pcop);
+
+
/*-----------------------------------------------------------------*/
/* pic16_popCopyGPR2Bit - copy a pcode operator */
/*-----------------------------------------------------------------*/
{
pCodeOp *pcop;
- pcop = pic16_newpCodeOpBit(pc->name, bitval, 0);
+// fprintf(stderr, "%s:%d pc type: %s\n", __FILE__, __LINE__, pic16_pCodeOpType(pc));
+ pcop = pic16_newpCodeOpBit(pc->name, bitval, 0, pc->type);
if( !( (pcop->type == PO_LABEL) ||
(pcop->type == PO_LITERAL) ||
pCode *pc=NULL;
pCode *pcprev=NULL;
regs *reg, *prevreg;
-
+ int flag=0;
+
if(!pb)
return;
pc = pic16_findNextpCode(pb->pcHead, PC_OPCODE);
- if(!pc)
- return;
+ if(!pc)return;
/* loop through all of the flow blocks with in one pblock */
// fprintf(stderr,"%s:%d: Register banking\n", __FUNCTION__, __LINE__);
- prevreg = NULL;
- do {
- /* at this point, pc should point to a PC_FLOW object */
- /* for each flow block, determine the register banking
- requirements */
+ prevreg = NULL;
+ do {
+ /* at this point, pc should point to a PC_FLOW object */
+ /* for each flow block, determine the register banking
+ * requirements */
+
+ if(!isPCI(pc))goto loop;
- if(isPCI(pc) && !PCI(pc)->is2MemOp) {
+ if(PCI(pc)->is2MemOp)goto loop;
+
reg = pic16_getRegFromInstruction(pc);
#if 0
+ pc->print(stderr, pc);
fprintf(stderr, "reg = %p\n", reg);
+
if(reg) {
fprintf(stderr, "%s:%d: %s %d\n",__FUNCTION__, __LINE__, reg->name, reg->rIdx);
- fprintf(stderr, "addr = 0x%03x, bank = %d, bit=%d\tmapped = %d sfr=%d fix=%d\n",
- reg->address,REG_BANK(reg),reg->isBitField, reg->isMapped,
- pic16_finalMapping[ reg->address ].isSFR, reg->isFixed);
+ fprintf(stderr, "addr = 0x%03x, bit=%d\tfix=%d\n",
+ reg->address,reg->isBitField, reg->isFixed);
}
#endif
/* we can be 99% that within a pBlock, between two consequtive
* refernces to the same register, the extra banksel is needless */
+
+
+ /* now make some tests to make sure that instruction needs bank switch */
- if((reg && !isACCESS_BANK(reg) && (isBankInstruction(pc) == -1))
- && (!isPCI_LIT(pc))
- && (PCI(pc)->op != POC_CALL)
-
- && ( ((pic16_options.opt_banksel>0)
- && (!prevreg || (prevreg && !pic16_areRegsSame(reg, prevreg))))
- || (!pic16_options.opt_banksel)
- )
- )
- {
- /* Examine the instruction before this one to make sure it is
- * not a skip type instruction */
- pcprev = findPrevpCode(pc->prev, PC_OPCODE);
-
- /* FIXME: if previous is SKIP pCode, we should move the BANKSEL
- * before SKIP, but we have to check if the SKIP uses BANKSEL, etc... */
- if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
- prevreg = reg;
- if(!pic16_options.no_banksel)
- insertBankSwitch(0, pc);
- } else {
-// if(pcprev && isPCI_SKIP(pcprev))assert(0);
- }
+ /* if not no register exists, and if not a bit opcode goto loop */
+ if(!reg) {
+ if(!(PCI(pc)->pcop && PCI(pc)->pcop->type == PO_GPR_BIT))goto loop;
}
-
- pcprev = pc;
-
- }
-
- pc = pc->next;
- }while (pc);
-
-#if 0
- if(pcprev && cur_bank) {
-
- int pos = 1; /* Assume that the bank switch instruction(s)
- * are inserted after this instruction */
-
- if((PCI(pcprev)->op == POC_RETLW) ||
- (PCI(pcprev)->op == POC_RETURN) ||
- (PCI(pcprev)->op == POC_RETFIE)) {
-
- /* oops, a RETURN - we need to switch banks *before* the RETURN */
-
- pos = 0;
-
- }
-
- /* Brute force - make sure that we point to bank 0 at the
- * end of each flow block */
-
-// insertBankSwitch(pos, pcprev, 0);
-/*
- new_pc = pic16_newpCode(POC_MOVLB, pic16_newpCodeOpLit(0));
- pic16_pCodeInsertAfter(pcprev, new_pc);
-*/
- cur_bank = 0;
- //fprintf(stderr, "Brute force switch\n");
- }
-#endif
-
+
+ if(isPCI_SKIP(pc)) {
+// fprintf(stderr, "instruction is SKIP instruction\n");
+ }
+ if((reg && isACCESS_BANK(reg)) || !isBankInstruction(pc))goto loop;
+
+ if(isPCI_LIT(pc))goto loop;
+
+ if(PCI(pc)->op == POC_CALL)goto loop;
+
+ /* Examine the instruction before this one to make sure it is
+ * not a skip type instruction */
+ pcprev = findPrevpCode(pc->prev, PC_OPCODE);
+
+ /* FIXME: if previous is SKIP pCode, we should move the BANKSEL
+ * before SKIP, but we have to check if the SKIP uses BANKSEL, etc... */
+ flag = 0;
+ if(pcprev && isPCI_SKIP(pcprev))flag=2; //goto loop;
+
+ prevreg = reg;
+ insertBankSwitch(flag, pc);
+ pcprev = pc;
+
+// fprintf(stderr, "BANK SWITCH inserted\n");
+
+loop:
+ pc = pc->next;
+ } while (pc);
}
+
static void pBlockDestruct(pBlock *pb)
{
if(!the_pFile)return;
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
-// fprintf(stderr, "%s:%d: Fix register banking in pb= 0x%p\n", __FILE__, __LINE__, pb);
- pic16_FixRegisterBanking(pb);
+
+ if(!pic16_options.no_banksel) {
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+// fprintf(stderr, "%s:%d: Fix register banking in pb= 0x%p\n", __FILE__, __LINE__, pb);
+ pic16_FixRegisterBanking(pb);
+ }
}
}
POC_SUBFWB_D1,
POC_SWAPF,
POC_SWAPFW,
-// POC_TRIS , // To be removed
- POC_TBLRD, // patch 15
- POC_TBLRD_POSTINC, //
- POC_TBLRD_POSTDEC, //
- POC_TBLRD_PREINC, //
- POC_TBLWT, //
- POC_TBLWT_POSTINC, //
- POC_TBLWT_POSTDEC, //
- POC_TBLWT_PREINC, // patch 15
+ POC_TBLRD,
+ POC_TBLRD_POSTINC,
+ POC_TBLRD_POSTDEC,
+ POC_TBLRD_PREINC,
+ POC_TBLWT,
+ POC_TBLWT_POSTINC,
+ POC_TBLWT_POSTDEC,
+ POC_TBLWT_PREINC,
POC_TSTFSZ,
POC_XORLW,
POC_XORWF,
- POC_XORFW
+ POC_XORFW,
+
+ POC_BANKSEL
} PIC_OPCODE;
pCodeOp *pic16_newpCodeOpImmd(char *name, int offset, int index, int code_space);
pCodeOp *pic16_newpCodeOpLit(int lit);
pCodeOp *pic16_newpCodeOpLit2(int lit, pCodeOp *arg2);
-pCodeOp *pic16_newpCodeOpBit(char *name, int bit,int inBitSpace);
+pCodeOp *pic16_newpCodeOpBit(char *name, int bit,int inBitSpace, PIC_OPTYPE subt);
pCodeOp *pic16_newpCodeOpRegFromStr(char *name);
pCodeOp *pic16_newpCodeOp(char *name, PIC_OPTYPE p);
pCodeOp *pic16_pCodeOpCopy(pCodeOp *pcop);
}
if(pic16Mnemonics[opcode]->isBitInst)
- pcosubtype = pic16_newpCodeOpBit(NULL,-1,0);
+ pcosubtype = pic16_newpCodeOpBit(NULL,-1,0, PO_GPR_REGISTER);
else
pcosubtype = pic16_newpCodeOp(NULL,PO_GPR_REGISTER);
//pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
//if(pcosubtype == NULL) {
- pcosubtype = pic16_newpCodeOpBit(p[1].pct[0].tok.s,p[3].pct[0].tok.n,0);
+ pcosubtype = pic16_newpCodeOpBit(p[1].pct[0].tok.s,p[3].pct[0].tok.n,0, PO_GPR_REGISTER);
//}
} else
pcosubtype = pic16_newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
/* now check whether the second operand matches */
if(PCOW2(PCI(pcd)->pcop) && (PCOR2(PCI(pcd)->pcop)->pcop2->type == PO_WILD)) {
- fprintf(stderr, "%s:%d %s second operand is wild\n", __FILE__, __LINE__, __FUNCTION__);
+// fprintf(stderr, "%s:%d %s second operand is wild\n", __FILE__, __LINE__, __FUNCTION__);
index = PCOW2(PCI(pcd)->pcop)->id;
//DFPRINTF((stderr,"destination is wild\n"));
case PO_GPR_BIT:
- pcopnew = pic16_newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace);
+ pcopnew = pic16_newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace, PO_GPR_REGISTER);
PCOR(pcopnew)->r = PCOR(pcop)->r;
PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
DFPRINTF((stderr," pCodeOpCopy Bit -register index\n"));
static hTab *dynDirectRegNames= NULL;
//static hTab *regHash = NULL; /* a hash table containing ALL registers */
+extern set *sectNames;
+
set *pic16_rel_udata=NULL; /* relocatable uninitialized registers */
set *pic16_fix_udata=NULL; /* absolute uninitialized registers */
set *pic16_equ_data=NULL; /* registers used by equates */
name = OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name;
- if(!SPEC_OCLS( OP_SYM_ETYPE(op))) { // patch 13
- if(pic16_debug_verbose) //
- { //
- fprintf(stderr, "%s:%d symbol %s(r:%s) is not assigned to a memmap\n", __FILE__, __LINE__, //
- OP_SYMBOL(op)->name, OP_SYMBOL(op)->rname); //
- } //
- return NULL; //
- } // patch 13
+ if(!SPEC_OCLS( OP_SYM_ETYPE(op))) {
+ if(pic16_debug_verbose)
+ {
+ fprintf(stderr, "%s:%d symbol %s(r:%s) is not assigned to a memmap\n", __FILE__, __LINE__,
+ OP_SYMBOL(op)->name, OP_SYMBOL(op)->rname);
+ }
+ return NULL;
+ }
debugLog ("%s:%d symbol name %s\n", __FUNCTION__, __LINE__, name);
// fprintf(stderr, "%s symbol name %s\n", __FUNCTION__,name);
// if(SPEC_SCLS(OP_SYM_ETYPE(op)))regtype = REG_SFR;
if(OP_SYMBOL(op)->onStack) {
-// fprintf(stderr, "%s:%d onStack %s\n", __FILE__, __LINE__, OP_SYMBOL(op)->name);
- OP_SYMBOL(op)->onStack = 0;
+ fprintf(stderr, "%s:%d onStack %s\n", __FILE__, __LINE__, OP_SYMBOL(op)->name);
+// OP_SYMBOL(op)->onStack = 0;
SPEC_OCLS(OP_SYM_ETYPE(op)) = data;
regtype = REG_GPR;
}
extern void pic16_dump_int_registers(FILE *of, set *section);
extern void pic16_dump_idata(FILE *of, set *idataSymSet);
+extern void pic16_dump_gsection(FILE *of, set *sections);
+
static void packBits(set *bregs)
{
set *regset;
}
-
-
-#if 0
-static 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++;
- }
- }
-
-}
-
-static 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(use_rIdx) {
- if (reg->type != REG_SFR) {
- fprintf (of, "%s\tEQU\t0x%03x\n",
- reg->name,
- reg->rIdx);
- }
- }
- else
- fprintf (of, "%s\tEQU\t0x%03x\n",
- reg->name,
- reg->address);
- }
- }
-
-}
-#endif
-
void pic16_writeUsedRegs(FILE *of)
{
packBits(pic16_dynDirectBitRegs);
/* dump internal registers */
pic16_dump_int_registers(of, pic16_int_regs);
+ /* dump generic section variables */
+ pic16_dump_gsection(of, sectNames);
+
/* dump other variables */
pic16_dump_usection(of, pic16_rel_udata, 0);
pic16_dump_usection(of, pic16_fix_udata, 1);
}
-#if 0
-/*-----------------------------------------------------------------*/
-/* allDefsOutOfRange - all definitions are out of a range */
-/*-----------------------------------------------------------------*/
-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;
-}
-#endif
/*-----------------------------------------------------------------*/
/* computeSpillable - given a point find the spillable live ranges */