X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCmem.c;h=35b0d9e1f3bb4198bbc694b081484b8bd1a3c80a;hb=116a1bfc169e441ed10267f1b0fe8a2336b6dc78;hp=ba185d241e3da2d5a2e5e95dcc43c705040ada54;hpb=9dbf0cbcc2c7048a0b2649a9d06183f61d26e791;p=fw%2Fsdcc diff --git a/src/SDCCmem.c b/src/SDCCmem.c index ba185d24..35b0d9e1 100644 --- a/src/SDCCmem.c +++ b/src/SDCCmem.c @@ -5,45 +5,46 @@ #include "common.h" /* memory segments */ -memmap *xstack = NULL; /* xternal stack data */ -memmap *istack = NULL; /* internal stack */ -memmap *code = NULL; /* code segment */ -memmap *data = NULL; /* internal data upto 128 */ -memmap *xdata = NULL; /* external data */ +memmap *xstack = NULL; /* xternal stack data */ +memmap *istack = NULL; /* internal stack */ +memmap *code = NULL; /* code segment */ +memmap *data = NULL; /* internal data upto 128 */ +memmap *pdata = NULL; /* paged external data */ +memmap *xdata = NULL; /* external data */ memmap *xidata = NULL; /* the initialized xdata */ memmap *xinit = NULL; /* the initializers for xidata */ -memmap *idata = NULL; /* internal data upto 256 */ -memmap *bit = NULL; /* bit addressable space */ -memmap *statsg = NULL; /* the constant data segment */ -memmap *sfr = NULL; /* register space */ -memmap *reg = NULL; /* register space */ -memmap *sfrbit = NULL; /* sfr bit space */ -memmap *generic = NULL; /* is a generic pointer */ -memmap *overlay = NULL; /* overlay segment */ -memmap *eeprom = NULL; /* eeprom location */ -memmap *home = NULL; /* Unswitchable code bank */ +memmap *idata = NULL; /* internal data upto 256 */ +memmap *bit = NULL; /* bit addressable space */ +memmap *statsg = NULL; /* the constant data segment */ +memmap *sfr = NULL; /* register space */ +memmap *reg = NULL; /* register space */ +memmap *sfrbit = NULL; /* sfr bit space */ +memmap *generic = NULL; /* is a generic pointer */ +memmap *overlay = NULL; /* overlay segment */ +memmap *eeprom = NULL; /* eeprom location */ +memmap *home = NULL; /* Unswitchable code bank */ /* this is a set of sets each set containing symbols in a single overlay */ set *ovrSetSets = NULL; int maxRegBank = 0; -int fatalError = 0; /* fatal error flag */ +int fatalError = 0; /* fatal error flag */ /*-----------------------------------------------------------------*/ /* allocMap - allocates a memory map */ /*-----------------------------------------------------------------*/ memmap * -allocMap (char rspace, /* sfr space */ - char farmap, /* far or near segment */ - char paged, /* can this segment be paged */ - char direct, /* directly addressable */ - char bitaddr, /* bit addressable space */ - char codemap, /* this is code space */ - unsigned sloc, /* starting location */ - const char *name, /* 2 character name */ - char dbName, /* debug name */ - int ptrType /* pointer type for this space */ +allocMap (char rspace, /* sfr space */ + char farmap, /* far or near segment */ + char paged, /* can this segment be paged */ + char direct, /* directly addressable */ + char bitaddr, /* bit addressable space */ + char codemap, /* this is code space */ + unsigned sloc, /* starting location */ + const char *name, /* 2 character name */ + char dbName, /* debug name */ + int ptrType /* pointer type for this space */ ) { memmap *map; @@ -78,58 +79,58 @@ allocMap (char rspace, /* sfr space */ /*-----------------------------------------------------------------*/ /* initMem - allocates and initializes all the segments */ /*-----------------------------------------------------------------*/ -void +void initMem () { /* allocate all the segments */ - /* xternal stack segment ; + /* xternal stack segment ; SFRSPACE - NO FAR-SPACE - YES PAGED - YES DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'A' POINTER-TYPE - FPOINTER */ xstack = allocMap (0, 1, 1, 0, 0, 0, options.xstack_loc, XSTACK_NAME, 'A', PPOINTER); - /* internal stack segment ; + /* internal stack segment ; SFRSPACE - NO FAR-SPACE - NO PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'B' POINTER-TYPE - POINTER */ if (ISTACK_NAME) { - istack = allocMap (0, 0, 0, 0, 0, 0, options.stack_loc, - ISTACK_NAME, 'B', POINTER); + istack = allocMap (0, 0, 0, 0, 0, 0, options.stack_loc, + ISTACK_NAME, 'B', POINTER); } else { istack=NULL; } - /* code segment ; + /* code segment ; SFRSPACE - NO FAR-SPACE - YES PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - YES + CODE-ACCESS - YES DEBUG-NAME - 'C' POINTER-TYPE - CPOINTER */ code = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER); - /* home segment ; + /* home segment ; SFRSPACE - NO FAR-SPACE - YES PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - YES + CODE-ACCESS - YES DEBUG-NAME - 'C' POINTER-TYPE - CPOINTER */ @@ -141,7 +142,7 @@ initMem () PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - YES + CODE-ACCESS - YES DEBUG-NAME - 'D' POINTER-TYPE - CPOINTER */ @@ -153,7 +154,7 @@ initMem () PAGED - NO DIRECT-ACCESS - YES BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'E' POINTER-TYPE - POINTER */ @@ -165,7 +166,7 @@ initMem () PAGED - NO DIRECT-ACCESS - YES BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'E' POINTER-TYPE - POINTER */ @@ -175,13 +176,29 @@ initMem () overlay = NULL; } - /* Xternal Data segment - + /* Xternal paged segment ; + SFRSPACE - NO + FAR-SPACE - NO + PAGED - YES + DIRECT-ACCESS - NO + BIT-ACCESS - NO + CODE-ACCESS - NO + DEBUG-NAME - 'P' + POINTER-TYPE - PPOINTER + */ + if (PDATA_NAME) { + pdata = allocMap (0, 0, 1, 0, 0, 0, options.xstack_loc, PDATA_NAME, 'P', PPOINTER); + } else { + pdata = NULL; + } + + /* Xternal Data segment - SFRSPACE - NO FAR-SPACE - YES PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'F' POINTER-TYPE - FPOINTER */ @@ -189,30 +206,30 @@ initMem () xidata = allocMap (0, 1, 0, 0, 0, 0, 0, XIDATA_NAME, 'F', FPOINTER); xinit = allocMap (0, 1, 0, 0, 0, 1, 0, XINIT_NAME, 'C', CPOINTER); - /* Inderectly addressed internal data segment + /* Indirectly addressed internal data segment SFRSPACE - NO FAR-SPACE - NO PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'G' POINTER-TYPE - IPOINTER */ if (IDATA_NAME) { - idata = allocMap (0, 0, 0, 0, 0, 0, options.idata_loc, - IDATA_NAME, 'G', IPOINTER); + idata = allocMap (0, 0, 0, 0, 0, 0, options.idata_loc, + IDATA_NAME, 'G', IPOINTER); } else { idata=NULL; } - /* Static segment (code for variables ); + /* Bit space ; SFRSPACE - NO FAR-SPACE - NO PAGED - NO DIRECT-ACCESS - YES BIT-ACCESS - YES - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'H' POINTER-TYPE - _NONE_ */ @@ -224,7 +241,7 @@ initMem () PAGED - NO DIRECT-ACCESS - YES BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'I' POINTER-TYPE - _NONE_ */ @@ -236,31 +253,31 @@ initMem () PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - ' ' POINTER-TYPE - _NONE_ */ reg = allocMap (1, 0, 0, 0, 0, 0, 0, REG_NAME, ' ', 0); - /* SFR bit space + /* SFR bit space SFRSPACE - YES FAR-SPACE - NO PAGED - NO DIRECT-ACCESS - YES BIT-ACCESS - YES - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'J' POINTER-TYPE - _NONE_ */ sfrbit = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, 'J', 0); - /* EEPROM bit space + /* EEPROM space SFRSPACE - NO FAR-SPACE - YES PAGED - NO DIRECT-ACCESS - NO BIT-ACCESS - NO - CODE-ACESS - NO + CODE-ACCESS - NO DEBUG-NAME - 'K' POINTER-TYPE - EEPPOINTER */ @@ -274,7 +291,7 @@ initMem () /*-----------------------------------------------------------------*/ /* allocIntoSeg - puts a symbol into a memory segment */ /*-----------------------------------------------------------------*/ -void +void allocIntoSeg (symbol * sym) { memmap *segment = SPEC_OCLS (sym->etype); @@ -283,28 +300,80 @@ allocIntoSeg (symbol * sym) /*-----------------------------------------------------------------*/ /* deleteFromSeg - deletes a symbol from segment used when a var */ -/* firest declared as "extern" then no extern */ +/* first declared as "extern" then no extern */ /*-----------------------------------------------------------------*/ void deleteFromSeg(symbol *sym) { if (SPEC_OCLS(sym->etype)) { - memmap *segment = SPEC_OCLS (sym->etype); - deleteSetItem(&segment->syms,sym); + memmap *segment = SPEC_OCLS (sym->etype); + deleteSetItem(&segment->syms,sym); } } +/*-----------------------------------------------------------------*/ +/* allocDefault - assigns the output segment based on SCLASS */ +/*-----------------------------------------------------------------*/ +bool +allocDefault (symbol * sym) +{ + switch (SPEC_SCLS (sym->etype)) + { + case S_SFR: + SPEC_OCLS (sym->etype) = sfr; + break; + case S_SBIT: + SPEC_OCLS (sym->etype) = sfrbit; + break; + case S_CODE: + if (sym->_isparm) + return FALSE; + /* if code change to constant */ + SPEC_OCLS (sym->etype) = statsg; + break; + case S_XDATA: + // should we move this to the initialized data segment? + if (port->genXINIT && + sym->ival && (sym->level==0) && !SPEC_ABSA(sym->etype)) { + SPEC_OCLS(sym->etype) = xidata; + } else { + SPEC_OCLS (sym->etype) = xdata; + } + break; + case S_DATA: + SPEC_OCLS (sym->etype) = data; + break; + case S_IDATA: + SPEC_OCLS (sym->etype) = idata; + sym->iaccess = 1; + break; + case S_PDATA: + SPEC_OCLS (sym->etype) = pdata; + sym->iaccess = 1; + break; + case S_BIT: + SPEC_OCLS (sym->etype) = bit; + break; + case S_EEPROM: + SPEC_OCLS (sym->etype) = eeprom; + break; + default: + return FALSE; + } + allocIntoSeg (sym); + return TRUE; +} /*-----------------------------------------------------------------*/ /* allocGlobal - assigns the output segment to a global var */ /*-----------------------------------------------------------------*/ -void +void allocGlobal (symbol * sym) { /* symbol name is internal name */ - if (!sym->level) /* local statics can come here */ - SNPRINTF (sym->rname, sizeof(sym->rname), - "%s%s", port->fun_prefix, sym->name); + if (!sym->level) /* local statics can come here */ + SNPRINTF (sym->rname, sizeof(sym->rname), + "%s%s", port->fun_prefix, sym->name); /* add it to the operandKey reset */ if (!isinSet (operKeyReset, sym)) { @@ -327,71 +396,43 @@ allocGlobal (symbol * sym) then put it in the interrupt service array */ if (FUNC_ISISR (sym->type) && !options.noiv && (FUNC_INTNO (sym->type) != INTNO_UNSPEC)) - { - if (interrupts[FUNC_INTNO (sym->type)]) - werror (E_INT_DEFINED, - FUNC_INTNO (sym->type), - interrupts[FUNC_INTNO (sym->type)]->name); - else - interrupts[FUNC_INTNO (sym->type)] = sym; - - /* automagically extend the maximum interrupts */ - if (FUNC_INTNO (sym->type) >= maxInterrupts) - maxInterrupts = FUNC_INTNO (sym->type) + 1; - } + { + if (interrupts[FUNC_INTNO (sym->type)]) + werror (E_INT_DEFINED, + FUNC_INTNO (sym->type), + interrupts[FUNC_INTNO (sym->type)]->name); + else + interrupts[FUNC_INTNO (sym->type)] = sym; + + /* automagically extend the maximum interrupts */ + if (FUNC_INTNO (sym->type) >= maxInterrupts) + maxInterrupts = FUNC_INTNO (sym->type) + 1; + } /* if it is not compiler defined */ if (!sym->cdef) - allocIntoSeg (sym); + allocIntoSeg (sym); return; } - /* if this is a SFR or SBIT */ - if (SPEC_SCLS (sym->etype) == S_SFR || - SPEC_SCLS (sym->etype) == S_SBIT) - { - - SPEC_OCLS (sym->etype) = - (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit); - - allocIntoSeg (sym); - return; - } - /* if this is a bit variable and no storage class */ - if (SPEC_NOUN (sym->etype) == V_BIT - && SPEC_SCLS (sym->etype) == S_BIT) - { - SPEC_OCLS (sym->etype) = bit; - allocIntoSeg (sym); - return; - } - - /* if bit storage class */ - if (SPEC_SCLS (sym->etype) == S_SBIT) + if (IS_SPEC(sym->type) && SPEC_NOUN (sym->type) == V_BIT) + /*&& SPEC_SCLS (sym->etype) == S_BIT*/ { - SPEC_OCLS (sym->etype) = bit; + SPEC_OCLS (sym->type) = bit; allocIntoSeg (sym); return; } + if(!TARGET_IS_PIC16 || (TARGET_IS_PIC16 && sym->level)) /* register storage class ignored changed to FIXED */ if (SPEC_SCLS (sym->etype) == S_REGISTER) SPEC_SCLS (sym->etype) = S_FIXED; - /* if data specified then */ - if (SPEC_SCLS (sym->etype) == S_DATA) - { - /* set the output class */ - SPEC_OCLS (sym->etype) = data; - /* generate the symbol */ - allocIntoSeg (sym); - return; - } - /* if it is fixed, then allocate depending on the */ /* current memory model, same for automatics */ if (SPEC_SCLS (sym->etype) == S_FIXED || + (TARGET_IS_PIC16 && (SPEC_SCLS (sym->etype) == S_REGISTER) && (sym->level==0)) || SPEC_SCLS (sym->etype) == S_AUTO) { if (port->mem.default_globl_map != xdata) { /* set the output class */ @@ -404,48 +445,14 @@ allocGlobal (symbol * sym) } } - /* if code change to constant */ - if (SPEC_SCLS (sym->etype) == S_CODE) { - SPEC_OCLS (sym->etype) = statsg; - allocIntoSeg (sym); - return; - } - - if (SPEC_SCLS (sym->etype) == S_XDATA) - { - // should we move this to the initialized data segment? - if (port->genXINIT && - sym->ival && (sym->level==0) && !SPEC_ABSA(sym->etype)) { - SPEC_OCLS(sym->etype)=xidata; - } else { - SPEC_OCLS (sym->etype) = xdata; - } - allocIntoSeg (sym); - return; - } - - if (SPEC_SCLS (sym->etype) == S_IDATA) - { - SPEC_OCLS (sym->etype) = idata; - sym->iaccess = 1; - allocIntoSeg (sym); - return; - } - - if (SPEC_SCLS (sym->etype) == S_EEPROM) - { - SPEC_OCLS (sym->etype) = eeprom; - allocIntoSeg (sym); - return; - } - + allocDefault (sym); return; } /*-----------------------------------------------------------------*/ /* allocParms - parameters are always passed on stack */ /*-----------------------------------------------------------------*/ -void +void allocParms (value * val) { value *lval; @@ -461,7 +468,7 @@ allocParms (value * val) it as a local variable by adding it to the first block we see in the body */ if (IS_REGPARM (lval->etype)) - continue; + continue; /* mark it as my parameter */ lval->sym->ismyparm = 1; @@ -470,74 +477,77 @@ allocParms (value * val) /* if automatic variables r 2b stacked */ if (options.stackAuto || IFFUNC_ISREENT (currFunc->type)) - { - - if (lval->sym) - lval->sym->onStack = 1; - - /* choose which stack 2 use */ - /* use xternal stack */ - if (options.useXstack) - { - /* PENDING: stack direction support */ - SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack; - SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack = - xstackPtr - getSize (lval->type); - xstackPtr -= getSize (lval->type); - } - else - { /* use internal stack */ - SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack; - if (port->stack.direction > 0) - { - SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack = - stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) - - getSize (lval->type) - - (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0); - stackPtr -= getSize (lval->type); - } - else - { - /* This looks like the wrong order but it turns out OK... */ - /* PENDING: isr, bank overhead, ... */ - SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack = - stackPtr + - ((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) + - (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) + - 0; - stackPtr += getSize (lval->type); - } - } - allocIntoSeg (lval->sym); - } + { + + if (lval->sym) + lval->sym->onStack = 1; + + /* choose which stack 2 use */ + /* use xternal stack */ + if (options.useXstack) + { + /* PENDING: stack direction support */ + SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack; + SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack = + xstackPtr - getSize (lval->type); + xstackPtr -= getSize (lval->type); + } + else + { /* use internal stack */ + SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack; + if (port->stack.direction > 0) + { + SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack = + stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) - + getSize (lval->type) - + (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0); + stackPtr -= getSize (lval->type); + } + else + { + /* This looks like the wrong order but it turns out OK... */ + /* PENDING: isr, bank overhead, ... */ + SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack = + stackPtr + + ((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) + + (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) + + 0; + stackPtr += getSize (lval->type); + } + } + allocIntoSeg (lval->sym); + } else - { /* allocate them in the automatic space */ - /* generate a unique name */ - SNPRINTF (lval->sym->rname, sizeof(lval->sym->rname), - "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum); - strncpyz (lval->name, lval->sym->rname, sizeof(lval->name)); - - /* if declared in external storage */ - if (SPEC_SCLS (lval->etype) == S_XDATA) - SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata; - else - /* other wise depending on the memory model - note here that we put it into the overlay segment - first, we will remove it from the overlay segment - after the overlay determination has been done */ - if (options.model == MODEL_SMALL) - { - SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = - (options.noOverlay ? port->mem.default_local_map - : overlay); - } - else - { - SPEC_SCLS (lval->etype) = S_XDATA; - SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata; - } - allocIntoSeg (lval->sym); - } + { /* allocate them in the automatic space */ + /* generate a unique name */ + SNPRINTF (lval->sym->rname, sizeof(lval->sym->rname), + "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum); + strncpyz (lval->name, lval->sym->rname, sizeof(lval->name)); + + /* if declared in specific storage */ + if (allocDefault (lval->sym)) + { + SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype); + continue; + } + + /* otherwise depending on the memory model + note here that we put it into the overlay segment + first, we will remove it from the overlay segment + after the overlay determination has been done */ + if (options.model == MODEL_SMALL) + { + SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = + (options.noOverlay ? port->mem.default_local_map + : overlay); + } + else + { + SPEC_SCLS (lval->etype) = S_XDATA; + SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata; + } + allocIntoSeg (lval->sym); + } } return; @@ -546,7 +556,7 @@ allocParms (value * val) /*-----------------------------------------------------------------*/ /* deallocParms - parameters are always passed on stack */ /*-----------------------------------------------------------------*/ -void +void deallocParms (value * val) { value *lval; @@ -561,30 +571,30 @@ deallocParms (value * val) deleteSym (SymbolTab, lval->sym, lval->sym->name); if (!lval->sym->isref) - { - lval->sym->allocreq = 0; - werror (W_NO_REFERENCE, - currFunc ? currFunc->name : "(unknown)", - "function argument", lval->sym->name); - } + { + lval->sym->allocreq = 0; + werror (W_NO_REFERENCE, + currFunc ? currFunc->name : "(unknown)", + "function argument", lval->sym->name); + } /* move the rname if any to the name for both val & sym */ /* and leave a copy of it in the symbol table */ if (lval->sym->rname[0]) - { - char buffer[SDCC_NAME_MAX]; - strncpyz (buffer, lval->sym->rname, sizeof(buffer)); - lval->sym = copySymbol (lval->sym); - strncpyz (lval->sym->rname, buffer, sizeof(lval->sym->rname)); - strncpyz (lval->sym->name, buffer, sizeof(lval->sym->name)); - strncpyz (lval->name, buffer, sizeof(lval->name)); - addSym (SymbolTab, lval->sym, lval->sym->name, - lval->sym->level, lval->sym->block, 1); - lval->sym->_isparm = 1; - if (!isinSet (operKeyReset, lval->sym)) { - addSet(&operKeyReset, lval->sym); - } - } + { + char buffer[SDCC_NAME_MAX]; + strncpyz (buffer, lval->sym->rname, sizeof(buffer)); + lval->sym = copySymbol (lval->sym); + strncpyz (lval->sym->rname, buffer, sizeof(lval->sym->rname)); + strncpyz (lval->sym->name, buffer, sizeof(lval->sym->name)); + strncpyz (lval->name, buffer, sizeof(lval->name)); + addSym (SymbolTab, lval->sym, lval->sym->name, + lval->sym->level, lval->sym->block, 1); + lval->sym->_isparm = 1; + if (!isinSet (operKeyReset, lval->sym)) { + addSet(&operKeyReset, lval->sym); + } + } } @@ -594,15 +604,15 @@ deallocParms (value * val) /*-----------------------------------------------------------------*/ /* allocLocal - allocate local variables */ /*-----------------------------------------------------------------*/ -void +void allocLocal (symbol * sym) { /* generate an unique name */ - SNPRINTF (sym->rname, sizeof(sym->rname), - "%s%s_%s_%d_%d", - port->fun_prefix, - currFunc->name, sym->name, sym->level, sym->block); + SNPRINTF (sym->rname, sizeof(sym->rname), + "%s%s_%s_%d_%d", + port->fun_prefix, + currFunc->name, sym->name, sym->level, sym->block); sym->islocal = 1; sym->localof = currFunc; @@ -621,7 +631,7 @@ allocLocal (symbol * sym) /* this is automatic */ - /* if it to be placed on the stack */ + /* if it's to be placed on the stack */ if (options.stackAuto || reentrant) { sym->onStack = 1; if (options.useXstack) { @@ -632,38 +642,18 @@ allocLocal (symbol * sym) } else { SPEC_OCLS (sym->etype) = istack; if (port->stack.direction > 0) { - SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1); - stackPtr += getSize (sym->type); + SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1); + stackPtr += getSize (sym->type); } else { - stackPtr -= getSize (sym->type); - SPEC_STAK (sym->etype) = sym->stack = stackPtr; + stackPtr -= getSize (sym->type); + SPEC_STAK (sym->etype) = sym->stack = stackPtr; } } allocIntoSeg (sym); return; } - - /* else depending on the storage class specified */ - if (SPEC_SCLS (sym->etype) == S_XDATA) - { - SPEC_OCLS (sym->etype) = xdata; - allocIntoSeg (sym); - return; - } - if (SPEC_SCLS (sym->etype) == S_CODE && !sym->_isparm) { - SPEC_OCLS (sym->etype) = statsg; - allocIntoSeg (sym); - return; - } - - if (SPEC_SCLS (sym->etype) == S_IDATA) - { - SPEC_OCLS (sym->etype) = idata; - sym->iaccess = 1; - allocIntoSeg (sym); - return; - } + /* else depending on the storage class specified */ /* if this is a function then assign code space */ if (IS_FUNC (sym->type)) @@ -672,22 +662,11 @@ allocLocal (symbol * sym) return; } - /* if this is a SFR or SBIT */ - if (SPEC_SCLS (sym->etype) == S_SFR || - SPEC_SCLS (sym->etype) == S_SBIT) - { - SPEC_OCLS (sym->etype) = - (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit); - - allocIntoSeg (sym); - return; - } - /* if this is a bit variable and no storage class */ - if (SPEC_NOUN (sym->etype) == V_BIT - && (SPEC_SCLS (sym->etype) == S_BIT)) + if (IS_SPEC(sym->type) && SPEC_NOUN (sym->type) == V_BIT) { - SPEC_OCLS (sym->etype) = bit; + SPEC_SCLS (sym->type) = S_BIT; + SPEC_OCLS (sym->type) = bit; allocIntoSeg (sym); return; } @@ -699,20 +678,18 @@ allocLocal (symbol * sym) return; } - if (SPEC_SCLS (sym->etype) == S_EEPROM) + if (allocDefault (sym)) { - SPEC_OCLS (sym->etype) = eeprom; - allocIntoSeg (sym); return; } /* again note that we have put it into the overlay segment - will remove and put into the 'data' segment if required after + will remove and put into the 'data' segment if required after overlay analysis has been done */ if (options.model == MODEL_SMALL) { - SPEC_OCLS (sym->etype) = - (options.noOverlay ? port->mem.default_local_map - : overlay); + SPEC_OCLS (sym->etype) = + (options.noOverlay ? port->mem.default_local_map + : overlay); } else { SPEC_OCLS (sym->etype) = port->mem.default_local_map; } @@ -722,29 +699,29 @@ allocLocal (symbol * sym) /*-----------------------------------------------------------------*/ /* deallocLocal - deallocates the local variables */ /*-----------------------------------------------------------------*/ -void +void deallocLocal (symbol * csym) { symbol *sym; for (sym = csym; sym; sym = sym->next) { - if (sym->_isparm) - continue; + if (sym->_isparm) + continue; /* if it is on the stack */ if (sym->onStack) - { - if (options.useXstack) - xstackPtr -= getSize (sym->type); - else - stackPtr -= getSize (sym->type); - } + { + if (options.useXstack) + xstackPtr -= getSize (sym->type); + else + stackPtr -= getSize (sym->type); + } /* if not used give a warning */ if (!sym->isref && !IS_STATIC (sym->etype)) - werror (W_NO_REFERENCE, - currFunc ? currFunc->name : "(unknown)", - "local variable", sym->name); + werror (W_NO_REFERENCE, + currFunc ? currFunc->name : "(unknown)", + "local variable", sym->name); /* now delete it from the symbol table */ deleteSym (SymbolTab, sym, sym->name); } @@ -753,7 +730,7 @@ deallocLocal (symbol * csym) /*-----------------------------------------------------------------*/ /* overlay2data - moves declarations from the overlay seg to data */ /*-----------------------------------------------------------------*/ -void +void overlay2data () { symbol *sym; @@ -774,7 +751,7 @@ overlay2data () /* overlay2Set - will add all symbols from the overlay segment to */ /* the set of sets containing the overlable symbols */ /*-----------------------------------------------------------------*/ -void +void overlay2Set () { symbol *sym; @@ -795,7 +772,7 @@ overlay2Set () /*-----------------------------------------------------------------*/ /* allocVariables - creates decl & assign storage class for a v */ /*-----------------------------------------------------------------*/ -int +int allocVariables (symbol * symChain) { symbol *sym; @@ -810,19 +787,20 @@ allocVariables (symbol * symChain) /* if this is a typedef then add it */ /* to the typedef table */ if (IS_TYPEDEF (sym->etype)) - { - /* check if the typedef already exists */ - csym = findSym (TypedefTab, NULL, sym->name); - if (csym && csym->level == sym->level) - werror (E_DUPLICATE_TYPEDEF, sym->name); - - addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0); - continue; /* go to the next one */ - } + { + /* check if the typedef already exists */ + csym = findSym (TypedefTab, NULL, sym->name); + if (csym && csym->level == sym->level) + werror (E_DUPLICATE_TYPEDEF, sym->name); + + SPEC_EXTR (sym->etype) = 0; + addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0); + continue; /* go to the next one */ + } /* make sure it already exist */ csym = findSymWithLevel (SymbolTab, sym); if (!csym || (csym && csym->level != sym->level)) - csym = sym; + csym = sym; /* check the declaration */ checkDecl (csym,0); @@ -830,42 +808,42 @@ allocVariables (symbol * symChain) /* if this is a function or a pointer to function */ /* then args processing */ if (funcInChain (csym->type)) - { - processFuncArgs (csym); + { + processFuncArgs (csym); - /* if register bank specified then update maxRegBank */ - if (maxRegBank < FUNC_REGBANK (csym->type)) - maxRegBank = FUNC_REGBANK (csym->type); - /*JCF: Mark the register bank as used*/ - RegBankUsed[FUNC_REGBANK(csym->type)]=1; - } + /* if register bank specified then update maxRegBank */ + if (maxRegBank < FUNC_REGBANK (csym->type)) + maxRegBank = FUNC_REGBANK (csym->type); + /*JCF: Mark the register bank as used*/ + RegBankUsed[FUNC_REGBANK(csym->type)]=1; + } /* if this is a extern variable then change the */ /* level to zero temporarily */ if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type)) - { - saveLevel = csym->level; - csym->level = 0; - } + { + saveLevel = csym->level; + csym->level = 0; + } /* if this is a literal then it is an enumerated */ /* type so need not allocate it space for it */ if (IS_LITERAL (sym->etype)) - continue; + continue; /* generate the actual declaration */ if (csym->level) - { - allocLocal (csym); - if (csym->onStack) - stack += getSize (csym->type); - } + { + allocLocal (csym); + if (csym->onStack) + stack += getSize (csym->type); + } else - allocGlobal (csym); + allocGlobal (csym); /* restore the level */ if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type)) - csym->level = saveLevel; + csym->level = saveLevel; } return stack; @@ -874,7 +852,7 @@ allocVariables (symbol * symChain) /*-----------------------------------------------------------------*/ /* redoStackOffsets :- will reassign the values for stack offsets */ /*-----------------------------------------------------------------*/ -void +void redoStackOffsets (void) { symbol *sym; @@ -893,42 +871,42 @@ redoStackOffsets (void) int size = getSize (sym->type); /* nothing to do with parameters so continue */ if ((sym->_isparm && !IS_REGPARM (sym->etype))) - continue; + continue; if (IS_AGGREGATE (sym->type)) - { - if (port->stack.direction > 0) - { - SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1); - sPtr += size; - } - else - { - sPtr -= size; - SPEC_STAK (sym->etype) = sym->stack = sPtr; - } - continue; - } + { + if (port->stack.direction > 0) + { + SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1); + sPtr += size; + } + else + { + sPtr -= size; + SPEC_STAK (sym->etype) = sym->stack = sPtr; + } + continue; + } /* if allocation not required then subtract size from overall stack size & continue */ if (!sym->allocreq) - { - currFunc->stack -= size; - SPEC_STAK (currFunc->etype) -= size; - continue; - } + { + currFunc->stack -= size; + SPEC_STAK (currFunc->etype) -= size; + continue; + } if (port->stack.direction > 0) - { - SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1); - sPtr += size; - } + { + SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1); + sPtr += size; + } else - { - sPtr -= size; - SPEC_STAK (sym->etype) = sym->stack = sPtr; - } + { + sPtr -= size; + SPEC_STAK (sym->etype) = sym->stack = sPtr; + } } /* do the same for the external stack */ @@ -940,23 +918,23 @@ redoStackOffsets (void) int size = getSize (sym->type); /* nothing to do with parameters so continue */ if ((sym->_isparm && !IS_REGPARM (sym->etype))) - continue; + continue; if (IS_AGGREGATE (sym->type)) - { - SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1); - xsPtr += size; - continue; - } + { + SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1); + xsPtr += size; + continue; + } /* if allocation not required then subtract size from overall stack size & continue */ if (!sym->allocreq) - { - currFunc->xstack -= size; - SPEC_STAK (currFunc->etype) -= size; - continue; - } + { + currFunc->xstack -= size; + SPEC_STAK (currFunc->etype) -= size; + continue; + } SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1); xsPtr += size; @@ -967,7 +945,7 @@ redoStackOffsets (void) /*-----------------------------------------------------------------*/ /* printAllocInfoSeg- print the allocation for a given section */ /*-----------------------------------------------------------------*/ -static void +static void printAllocInfoSeg (memmap * map, symbol * func, FILE * of) { symbol *sym; @@ -976,37 +954,44 @@ printAllocInfoSeg (memmap * map, symbol * func, FILE * of) return; if (!map->syms) return; - + for (sym = setFirstItem (map->syms); sym; sym = setNextItem (map->syms)) { if (sym->level == 0) - continue; + continue; if (sym->localof != func) - continue; - + continue; + fprintf (of, ";%-25s Allocated ", sym->name); /* if assigned to registers */ if (!sym->allocreq && sym->reqv) - { - int i; - - sym = OP_SYMBOL (sym->reqv); - fprintf (of, "to registers "); - for (i = 0; i < 4 && sym->regs[i]; i++) - fprintf (of, "%s ", port->getRegName (sym->regs[i])); - fprintf (of, "\n"); - continue; - } + { + int i; + + sym = OP_SYMBOL (sym->reqv); + if (!sym->isspilt || sym->remat) + { + fprintf (of, "to registers "); + for (i = 0; i < 4 && sym->regs[i]; i++) + fprintf (of, "%s ", port->getRegName (sym->regs[i])); + fprintf (of, "\n"); + continue; + } + else + { + sym = sym->usl.spillLoc; + } + } /* if on stack */ if (sym->onStack) - { - fprintf (of, "to stack - offset %d\n", sym->stack); - continue; - } + { + fprintf (of, "to stack - offset %d\n", sym->stack); + continue; + } /* otherwise give rname */ fprintf (of, "with name '%s'\n", sym->rname); @@ -1016,7 +1001,7 @@ printAllocInfoSeg (memmap * map, symbol * func, FILE * of) /*-----------------------------------------------------------------*/ /* canOverlayLocals - returns true if the local variables can overlayed */ /*-----------------------------------------------------------------*/ -static bool +static bool canOverlayLocals (eBBlock ** ebbs, int count) { int i; @@ -1027,7 +1012,7 @@ canOverlayLocals (eBBlock ** ebbs, int count) options.stackAuto || (currFunc && (IFFUNC_ISREENT (currFunc->type) || - FUNC_ISISR (currFunc->type))) || + FUNC_ISISR (currFunc->type))) || elementsInSet (overlay->syms) == 0) return FALSE; @@ -1042,13 +1027,13 @@ canOverlayLocals (eBBlock ** ebbs, int count) iCode *ic; for (ic = ebbs[i]->sch; ic; ic = ic->next) - if (ic) { - if (ic->op == CALL) { - sym_link *ftype = operandType(IC_LEFT(ic)); - /* builtins only can use overlays */ - if (!IFFUNC_ISBUILTIN(ftype)) return FALSE; - } else if (ic->op == PCALL) return FALSE; - } + if (ic) { + if (ic->op == CALL) { + sym_link *ftype = operandType(IC_LEFT(ic)); + /* builtins only can use overlays */ + if (!IFFUNC_ISBUILTIN(ftype)) return FALSE; + } else if (ic->op == PCALL) return FALSE; + } } /* no function calls found return TRUE */ @@ -1058,7 +1043,7 @@ canOverlayLocals (eBBlock ** ebbs, int count) /*-----------------------------------------------------------------*/ /* doOverlays - move the overlay segment to appropriate location */ /*-----------------------------------------------------------------*/ -void +void doOverlays (eBBlock ** ebbs, int count) { if (!overlay) { @@ -1083,12 +1068,12 @@ doOverlays (eBBlock ** ebbs, int count) /*-----------------------------------------------------------------*/ /* printAllocInfo - prints allocation information for a function */ /*-----------------------------------------------------------------*/ -void +void printAllocInfo (symbol * func, FILE * of) { if (!func) - return; - + return; + if (!of) of = stdout; @@ -1105,11 +1090,11 @@ printAllocInfo (symbol * func, FILE * of) printAllocInfoSeg (idata, func, of); printAllocInfoSeg (sfr, func, of); printAllocInfoSeg (sfrbit, func, of); - + { set *ovrset; set *tempOverlaySyms = overlay->syms; - + /* search the set of overlay sets for local variables/parameters */ for (ovrset = setFirstItem (ovrSetSets); ovrset; ovrset = setNextItem (ovrSetSets)) @@ -1119,6 +1104,6 @@ printAllocInfo (symbol * func, FILE * of) } overlay->syms = tempOverlaySyms; } - + fprintf (of, ";------------------------------------------------------------\n"); }