and - Jean-Louis VERN.jlvern@writeme.com (1999)
Bug Fixes - Wojciech Stryjewski wstryj1@tiger.lsu.edu (1999 v2.1.9a)
PIC port - Scott Dattalo scott@dattalo.com (2000)
- cont'd - Raphael Neider rneider@web.de (2005)
+ cont'd - Raphael Neider <rneider AT web.de> (2005)
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
#include <string.h>
#include <ctype.h>
#include "SDCCglobl.h"
-#include "newalloc.h"
+#include "newalloc.h"
#include "common.h"
#include "SDCCpeeph.h"
#include "ralloc.h"
#include "pcode.h"
#include "gen.h"
-
-/* When changing these, you must also update the assembler template
- * in device/lib/libsdcc/macros.inc */
-#define GPTRTAG_DATA 0x00
-#define GPTRTAG_CODE 0x80
+#include "glue.h"
/* The PIC port(s) need not differentiate between POINTER and FPOINTER. */
#define PIC_IS_DATA_PTR(x) (IS_DATA_PTR(x) || IS_FARPTR(x))
static int labelOffset=0;
extern int debug_verbose;
+extern int pic14_hasInterrupt;
//static int optimized_for_speed = 0;
/* max_key keeps track of the largest label number used in
*/
static int max_key=0;
static int GpsuedoStkPtr=0;
+static int pic14_inISR = 0;
pCodeOp *popGetImmd(char *name, unsigned int offset, int index,int is_func);
extern char *get_op( pCodeOp *pcop,char *buff,size_t buf_size);
-unsigned int pic14aopLiteral (value *val, int offset);
const char *AopType(short type);
#define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0x00ff)
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 char *zero = "0x00";
+static char *one = "0x01";
static char *spname = "sp";
char *fReturnpic14[] = {"temp1","temp2","temp3","temp4" };
extern int pic14_ptrRegReq ;
extern int pic14_nRegs;
-extern FILE *codeOutFile;
+extern struct dbuf_s *codeOutBuf;
static void saverbank (int, iCode *,bool);
static lineNode *lineHead = NULL;
{
va_list ap;
char lb[INITIAL_INLINEASM];
- unsigned char *lbp = lb;
+ unsigned char *lbp = (unsigned char *)lb;
if(!debug_verbose && !options.debug)
return;
{
if(pcop)
addpCode2pBlock(pb,newpCode(poc,pcop));
- else
+ else {
+ static int has_warned = 0;
+
DEBUGpic14_emitcode(";","%s ignoring NULL pcop",__FUNCTION__);
+ if (!has_warned) {
+ has_warned = 1;
+ fprintf( stderr, "WARNING: encountered NULL pcop--this is probably a compiler bug...\n" );
+ }
+ }
}
void emitpcodeNULLop(PIC_OPCODE poc)
{
va_list ap;
char lb[INITIAL_INLINEASM];
- unsigned char *lbp = lb;
+ char *lbp = lb;
va_start(ap,fmt);
(lineHead = newLineNode(lb)));
lineCurr->isInline = _G.inLine;
lineCurr->isDebug = _G.debugLine;
+ lineCurr->isLabel = (lbp[strlen (lbp) - 1] == ':');
if(debug_verbose)
addpCode2pBlock(pb,newpCodeCharP(lb));
if (sym->aop)
return sym->aop;
-#if 0
- /* 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;
- }
-#endif
-
//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);
/* else spill location */
if (sym->usl.spillLoc)
{
+ asmop *oldAsmOp = NULL;
+
if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
{
/* force a new aop if sizes differ */
+ oldAsmOp = sym->usl.spillLoc->aop;
sym->usl.spillLoc->aop = NULL;
}
DEBUGpic14_emitcode(";","%s %d %s sym->rname = %s, offset %d",
sym->rname, sym->usl.spillLoc->offset);
sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
+ if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
+ {
+ /* Don't reuse the new aop, go with the last one */
+ sym->usl.spillLoc->aop = oldAsmOp;
+ }
//aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname,
getSize(sym->type),
//DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
/* offset is greater than
size then zero */
+ assert(aop);
if (offset > (aop->size - 1) &&
aop->type != AOP_LIT)
return zero;
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);
+ sprintf(s, "0x%02x", pic14aopLiteral (aop->aopu.aop_lit, offset));
+ rs = Safe_strdup(s);
return rs;
case AOP_STR:
pCodeOp *pcop = aop->aopu.pcop;
DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
if(pcop->name) {
+ if (pcop->type == PO_IMMEDIATE) {
+ offset += PCOI(pcop)->index;
+ }
if (offset) {
DEBUGpic14_emitcode(";","%s offset %d",pcop->name,offset);
sprintf(s,"(%s+%d)", pcop->name,offset);
assert (aop);
+
/* XXX: still needed for BIT operands (AOP_CRY) */
if (offset > (aop->size - 1) &&
- aop->type != AOP_LIT)
+ aop->type != AOP_LIT &&
+ aop->type != AOP_PCODE)
+ {
+ printf( "%s: (offset[%d] > AOP_SIZE(op)[%d]-1) && AOP_TYPE(op) != AOP_LIT)\n", __FUNCTION__, offset, aop->size);
return NULL; //zero;
+ }
/* depending on type */
switch (aop->type) {
{
sym_link *dtype;
symbol *sym;
- unsigned char *name;
+ char *name;
int isExtern;
FENTRY;
/* make the call */
sym = OP_SYMBOL(IC_LEFT(ic));
name = sym->rname[0] ? sym->rname : sym->name;
- isExtern = IS_EXTERN(sym->etype);
+ isExtern = IS_EXTERN(sym->etype) || pic14_inISR;
if (isExtern) {
- emitpcode(POC_PAGESEL,popGetWithString(name,1)); /* Extern functions maybe on another page - must call pagesel */
+ /* Extern functions and ISRs maybe on a different page;
+ * must call pagesel */
+ emitpcode(POC_PAGESEL,popGetWithString(name,1));
}
emitpcode(POC_CALL,popGetWithString(name,isExtern));
if (isExtern) {
- emitpcode(POC_PAGESEL,popGetWithString("$",0)); /* May have returned from another page - must call pagesel to restore PCLATH before next goto or call instruction */
+ /* May have returned from a different page;
+ * must use pagesel to restore PCLATH before next
+ * goto or call instruction */
+ emitpcode(POC_PAGESEL,popGetWithString("$",0));
}
GpsuedoStkPtr=0;
/* if we need assign a result value */
*/
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_PAGESEL,pcop); /* Must restore PCLATH before goto, without destroying W */
emitpcode(POC_GOTO,pcop);
emitpLabel(albl->key);
return 0;
}
-#if defined(__BORLANDC__) || defined(_MSC_VER)
-#define STRCASECMP stricmp
-#else
-#define STRCASECMP strcasecmp
-#endif
-
#if 0
/*-----------------------------------------------------------------*/
/* inExcludeList - return 1 if the string is in exclude Reg list */
pic14_emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
pic14_emitcode(";","-----------------------------------------");
+ /* prevent this symbol from being emitted as 'extern' */
+ pic14_stringInSet(sym->rname, &pic14_localFunctions, 1);
+
pic14_emitcode("","%s:",sym->rname);
addpCode2pBlock(pb,newpCodeFunction(NULL,sym->rname,!IS_STATIC (sym->etype)));
#endif
/* if this is an interrupt service routine */
+ pic14_inISR = 0;
if (IFFUNC_ISISR(sym->type)) {
+ pic14_inISR = 1;
/* already done in pic14createInterruptVect() - delete me
addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("END_OF_INTERRUPT+1",PO_STR)));
emitpcodeNULLop(POC_NOP);
emitpcode(POC_CLRF, popCopyReg(&pc_pclath));/* during an interrupt PCLATH must be cleared before a goto or call statement */
pBlockConvert2ISR(pb);
+ pic14_hasInterrupt = 1;
#if 0
if (!inExcludeList("acc"))
pic14_emitcode ("push","acc");
operand *result)
{
int size;
+ int sign;
FENTRY;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- assert (AOP_SIZE(result) == 1);
assert (AOP_SIZE(right) == 1);
assert (AOP_SIZE(left) == 1);
size = min(AOP_SIZE(result),AOP_SIZE(left));
+ sign = !(SPEC_USIGN(operandType(left))
+ && SPEC_USIGN(operandType(right)));
if (AOP_TYPE(right) == AOP_LIT)
{
/* XXX: might add specialized code */
}
- if (SPEC_USIGN(operandType(left)) && SPEC_USIGN(operandType(right)))
+ if (!sign)
{
/* unsigned division */
#if 1
}
/* now performed the signed/unsigned division -- extend result */
- addSign(result, 1, !SPEC_USIGN(operandType(result)));
+ addSign(result, 1, sign);
}
/*-----------------------------------------------------------------*/
freeAsmop(result,NULL,ic,TRUE);
}
-/*-----------------------------------------------------------------*/
-/* genModbits :- modulus of bits */
-/*-----------------------------------------------------------------*/
-static void genModbits (operand *left,
- operand *right,
- operand *result)
-{
-
- char *l;
-
- FENTRY;
- /* 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 */
/*-----------------------------------------------------------------*/
operand *result)
{
int size;
+ int sign;
FENTRY;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
- assert (AOP_SIZE(result) == 1);
assert (AOP_SIZE(right) == 1);
assert (AOP_SIZE(left) == 1);
size = min(AOP_SIZE(result),AOP_SIZE(left));
+ sign = !(SPEC_USIGN(operandType(left))
+ && SPEC_USIGN(operandType(right)));
if (AOP_TYPE(right) == AOP_LIT)
{
/* XXX: might add specialized code */
}
- if (SPEC_USIGN(operandType(left)) && SPEC_USIGN(operandType(right)))
+ if (!sign)
{
/* unsigned division */
#if 1
}
/* now we performed the signed/unsigned modulus -- extend result */
- addSign(result, 1, !SPEC_USIGN(operandType(result)));
+ addSign(result, 1, sign);
}
/*-----------------------------------------------------------------*/
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 ) {
FENTRY;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(IC_TRUE(ic))
- pic14_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
+ {
+ // Why +100?!?
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key+100));
+ pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+ }
ic->generated = 1;
}
FENTRY;
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(!IC_TRUE(ic))
+ {
+ // Why +100?!?
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key+100));
pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+ }
ic->generated = 1;
}
pic14_emitcode("setb","c");
while(sizel--){
if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
- MOVA( aopGet(AOP(left),offset,FALSE,FALSE));
+ mov2w( AOP(left), offset);
// byte == 2^n ?
- if((posbit = isLiteralBit(bytelit)) != 0)
+ if((posbit = isLiteralBit(bytelit)) != 0) {
+ emitpcode(rIfx.condition ? POC_BTFSC : POC_BTFSS, // XXX: or the other way round?
+ newpCodeOpBit(aopGet(AOP(left),offset,FALSE,FALSE),posbit - 1, 0));
pic14_emitcode("jb","acc.%d,%05d_DS_",(posbit-1)&0x07,tlbl->key+100);
+ }
else{
+ emitpcode(POC_ANDLW, newpCodeOpLit(bytelit & 0x0ff));
+ if (rIfx.condition) emitSKPZ;
+ else emitSKPNZ;
+
if(bytelit != 0x0FFL)
+ {
pic14_emitcode("anl","a,%s",
aopGet(AOP(right),offset,FALSE,TRUE));
+ }
pic14_emitcode("jnz","%05d_DS_",tlbl->key+100);
}
+
+ emitpcode(POC_GOTO, popGetLabel(rIfx.lbl->key));
+ ifx->generated = 1;
+
}
offset++;
}
assert( !"bitfields larger than 8 bits or crossing byte boundaries are not yet supported" );
}
-unsigned long
-bitpatternFromVal (value *val)
-{
- union {
- float d;
- unsigned long l;
- } float_long;
-
- assert (sizeof (float) == sizeof (long));
-
- //fprintf (stderr, "%s:%u(%s): val=%lf, type: %d, etype: %d\n", __FILE__, __LINE__, __FUNCTION__, floatFromVal(val), SPEC_NOUN(val->type), SPEC_NOUN(val->etype));
-
- switch (SPEC_NOUN(val->type))
- {
- case V_INT:
- case V_CHAR:
- return (unsigned long)floatFromVal (val);
-
- case V_FLOAT:
- case V_DOUBLE:
- float_long.d = floatFromVal (val);
- return float_long.l;
-
- default:
- assert( !"unhandled value type" );
- break;
- }
-
- float_long.d = floatFromVal (val);
- return float_long.l;
-}
-
/*-----------------------------------------------------------------*/
/* genDataPointerSet - remat pointer to data space */
/*-----------------------------------------------------------------*/
assert (IS_SYMOP(result));
assert (IS_PTR(OP_SYM_TYPE(result)));
- size = AOP_SIZE(right);
+ if (AOP_TYPE(right) == AOP_LIT)
+ size = 4;
+ else
+ size = AOP_SIZE(right);
ressize = getSize(OP_SYM_ETYPE(result));
if (size > ressize) size = ressize;
//fprintf (stderr, "%s:%u: size(right): %d, size(result): %d\n", __FUNCTION__,__LINE__, AOP_SIZE(right), ressize);
// tsd, was l+1 - the underline `_' prefix was being stripped
while (size--) {
- emitpComment ("%s:%u: size=%d/%d, offset=%i", __FILE__,__LINE__, size, ressize, offset);
+ emitpComment ("%s:%u: size=%d/%d, offset=%d, AOP_TYPE(res)=%d", __FILE__,__LINE__, size, ressize, offset, AOP_TYPE(result));
if (AOP_TYPE(right) == AOP_LIT) {
- /* XXX: might be float... */
- unsigned int lit = bitpatternFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
- lit = lit >> (8*offset);
+ unsigned int lit = pic14aopLiteral(AOP(IC_RIGHT(ic))->aopu.aop_lit, offset);
//fprintf (stderr, "%s:%u: lit %d 0x%x\n", __FUNCTION__,__LINE__, lit, lit);
if(lit&0xff) {
emitpcode(POC_MOVLW, popGetLit(lit&0xff));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result), offset));
} else {
- emitpcode(POC_CLRF, popGet(AOP(result),offset));
+ emitpcode(POC_CLRF, popGet(AOP(result), offset));
}
} else {
//fprintf (stderr, "%s:%u: no lit\n", __FUNCTION__,__LINE__);
- emitpcode(POC_MOVFW, popGet(AOP(right),offset));
- emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+ emitpcode(POC_MOVFW, popGet(AOP(right), offset));
+ emitpcode(POC_MOVWF, popGet(AOP(result), offset));
}
offset++;
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)
if (isbit)
{
- assert (!"genIfx not implemented for bit variables...");
+ /* This assumes that CARRY is set iff cond is true */
+ if (IC_TRUE(ic))
+ {
+ assert (!IC_FALSE(ic));
+ emitpcode(POC_BTFSC, popGet(AOP(cond), 0));
+ //emitSKPNC;
+ emitpcode(POC_GOTO, popGetLabel(IC_TRUE(ic)->key));
+ } else {
+ assert (IC_FALSE(ic));
+ emitpcode(POC_BTFSS, popGet(AOP(cond), 0));
+ //emitSKPC;
+ emitpcode(POC_GOTO, popGetLabel(IC_FALSE(ic)->key));
+ }
+ if (0)
+ {
+ static int hasWarned = 0;
+ if (!hasWarned)
+ {
+ fprintf (stderr, "WARNING: using untested code for %s:%u -- please check the .asm output and report bugs.\n", ic->filename, ic->lineno);
+ hasWarned = 1;
+ }
+ }
}
else
{
- /* now Z if set iff !cond */
+ /* now Z is set iff !cond */
if (IC_TRUE(ic))
{
assert (!IC_FALSE(ic));
ic->generated = 1;
+ /* the result is now in the accumulator */
+ freeAsmop(cond,NULL,ic,TRUE);
}
/*-----------------------------------------------------------------*/
/* 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) {
know_W=-1;
while (size--) {
+
DEBUGpic14_emitcode ("; ***","%s %d",__FUNCTION__,__LINE__);
if(AOP_TYPE(right) == AOP_LIT) {
+ lit = (unsigned long)pic14aopLiteral(AOP(right)->aopu.aop_lit, offset) & 0x0ff;
if(lit&0xff) {
if(know_W != (int)(lit&0xff))
emitpcode(POC_MOVLW,popGetLit(lit&0xff));
} 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) {
_G.accInUse++;
aopOp(IC_RESULT(ic),ic,FALSE);
_G.accInUse--;
+ GpsuedoStkPtr = ic->parmBytes; // address used arg on stack
assignResultValue(IC_RESULT(ic));
}
}
if (options.iCodeInAsm) {
+ char *iLine = printILine(ic);
emitpComment ("[ICODE] %s:%d: %s", ic->filename, ic->lineno, printILine (ic));
+ dbuf_free(iLine);
}
/* if the result is marked as
spilt and rematerializable or code for
peepHole (&lineHead);
}
/* now do the actual printing */
- printLine (lineHead,codeOutFile);
+ printLine (lineHead,codeOutBuf);
#ifdef PCODE_DEBUG
DFPRINTF((stderr,"printing pBlock\n\n"));
if (IS_PTR(OP_SYM_TYPE(op)) && AOP_TYPE(op) == AOP_PCODE && AOP(op)->aopu.pcop->type == PO_IMMEDIATE) return 1;
return 0;
}
+
projects / fw / sdcc / blobdiff