git.gag.com Git - fw/sdcc/blob - src/SDCCmem.c

   1 /*-----------------------------------------------------------------*/
   2 /* SDCCmem.c - 8051 memory management routines                     */
   3 /*-----------------------------------------------------------------*/
   4
   5 #include "common.h"
   6
   7 /* memory segments */
   8 memmap *xstack = NULL;          /* xternal stack data         */
   9 memmap *istack = NULL;          /* internal stack             */
  10 memmap *code = NULL;            /* code segment               */
  11 memmap *data = NULL;            /* internal data upto 128     */
  12 memmap *xdata = NULL;           /* external data              */
  13 memmap *idata = NULL;           /* internal data upto 256     */
  14 memmap *bit = NULL;             /* bit addressable space      */
  15 memmap *statsg = NULL;          /* the constant data segment  */
  16 memmap *sfr = NULL;             /* register space              */
  17 memmap *reg = NULL;             /* register space              */
  18 memmap *sfrbit = NULL;          /* sfr bit space               */
  19 memmap *generic = NULL;         /* is a generic pointer        */
  20 memmap *overlay = NULL;         /* overlay segment             */
  21 memmap *eeprom = NULL;          /* eeprom location             */
  22 memmap *home = NULL;            /* Unswitchable code bank      */
  23
  24 /* this is a set of sets each set containing
  25    symbols in a single overlay */
  26 set *ovrSetSets = NULL;
  27
  28 int maxRegBank = 0;
  29 int fatalError = 0;             /* fatal error flag                   */
  30
  31 /*-----------------------------------------------------------------*/
  32 /* allocMap - allocates a memory map                               */
  33 /*-----------------------------------------------------------------*/
  34 memmap *
  35 allocMap (char rspace,          /* sfr space            */
  36           char farmap,          /* far or near segment  */
  37           char paged,           /* can this segment be paged  */
  38           char direct,          /* directly addressable */
  39           char bitaddr,         /* bit addressable space */
  40           char codemap,         /* this is code space   */
  41           unsigned sloc,        /* starting location    */
  42           const char *name,     /* 2 character name     */
  43           char dbName,          /* debug name                 */
  44           int ptrType           /* pointer type for this space */
  45 )
  46 {
  47   memmap *map;
  48
  49   if (!(map = calloc (sizeof (memmap), 1)))
  50     {
  51       werror (E_OUT_OF_MEM, __FILE__, sizeof (memmap));
  52       exit (1);
  53     }
  54
  55   memset (map, ZERO, sizeof (memmap));
  56   map->regsp = rspace;
  57   map->fmap = farmap;
  58   map->paged = paged;
  59   map->direct = direct;
  60   map->bitsp = bitaddr;
  61   map->codesp = codemap;
  62   map->sloc = sloc;
  63   map->sname = name;
  64   map->dbName = dbName;
  65   map->ptrType = ptrType;
  66   if (!(map->oFile = tempfile ()))
  67     {
  68       werror (E_TMPFILE_FAILED);
  69       exit (1);
  70     }
  71   addSetHead (&tmpfileSet, map->oFile);
  72   map->syms = NULL;
  73   return map;
  74 }
  75
  76 /*-----------------------------------------------------------------*/
  77 /* initMem - allocates and initializes all the segments            */
  78 /*-----------------------------------------------------------------*/
  79 void
  80 initMem ()
  81 {
  82   /* allocate all the segments */
  83   /* xternal stack segment ;
  84      SFRSPACE       -   NO
  85      FAR-SPACE      -   YES
  86      PAGED          -   YES
  87      DIRECT-ACCESS  -   NO
  88      BIT-ACCESS     -   NO
  89      CODE-ACESS     -   NO
  90      DEBUG-NAME     -   'A'
  91      POINTER-TYPE   -   FPOINTER
  92    */
  93   xstack = allocMap (0, 1, 1, 0, 0, 0, options.xstack_loc, XSTACK_NAME, 'A', PPOINTER);
  94
  95   /* internal stack segment ;
  96      SFRSPACE       -   NO
  97      FAR-SPACE      -   NO
  98      PAGED          -   NO
  99      DIRECT-ACCESS  -   NO
 100      BIT-ACCESS     -   NO
 101      CODE-ACESS     -   NO
 102      DEBUG-NAME     -   'B'
 103      POINTER-TYPE   -   POINTER
 104    */
 105   istack = allocMap (0, 0, 0, 0, 0, 0, options.stack_loc, ISTACK_NAME, 'B', POINTER);
 106
 107   /* code  segment ;
 108      SFRSPACE       -   NO
 109      FAR-SPACE      -   YES
 110      PAGED          -   NO
 111      DIRECT-ACCESS  -   NO
 112      BIT-ACCESS     -   NO
 113      CODE-ACESS     -   YES
 114      DEBUG-NAME     -   'C'
 115      POINTER-TYPE   -   CPOINTER
 116    */
 117   code = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER);
 118
 119   /* home  segment ;
 120      SFRSPACE       -   NO
 121      FAR-SPACE      -   YES
 122      PAGED          -   NO
 123      DIRECT-ACCESS  -   NO
 124      BIT-ACCESS     -   NO
 125      CODE-ACESS     -   YES
 126      DEBUG-NAME     -   'C'
 127      POINTER-TYPE   -   CPOINTER
 128    */
 129   home = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER);
 130
 131   /* Static segment (code for variables );
 132      SFRSPACE       -   NO
 133      FAR-SPACE      -   YES
 134      PAGED          -   NO
 135      DIRECT-ACCESS  -   NO
 136      BIT-ACCESS     -   NO
 137      CODE-ACESS     -   YES
 138      DEBUG-NAME     -   'D'
 139      POINTER-TYPE   -   CPOINTER
 140    */
 141   statsg = allocMap (0, 1, 0, 0, 0, 1, 0, STATIC_NAME, 'D', CPOINTER);
 142
 143   /* Data segment - internal storage segment ;
 144      SFRSPACE       -   NO
 145      FAR-SPACE      -   NO
 146      PAGED          -   NO
 147      DIRECT-ACCESS  -   YES
 148      BIT-ACCESS     -   NO
 149      CODE-ACESS     -   NO
 150      DEBUG-NAME     -   'E'
 151      POINTER-TYPE   -   POINTER
 152    */
 153   data = allocMap (0, 0, 0, 1, 0, 0, options.data_loc, DATA_NAME, 'E', POINTER);
 154
 155   /* overlay segment - same as internal storage segment ;
 156      SFRSPACE       -   NO
 157      FAR-SPACE      -   NO
 158      PAGED          -   NO
 159      DIRECT-ACCESS  -   YES
 160      BIT-ACCESS     -   NO
 161      CODE-ACESS     -   NO
 162      DEBUG-NAME     -   'E'
 163      POINTER-TYPE   -   POINTER
 164    */
 165   overlay = allocMap (0, 0, 0, 1, 0, 0, options.data_loc, DATA_NAME, 'E', POINTER);
 166
 167   /* Xternal Data segment -
 168      SFRSPACE       -   NO
 169      FAR-SPACE      -   YES
 170      PAGED          -   NO
 171      DIRECT-ACCESS  -   NO
 172      BIT-ACCESS     -   NO
 173      CODE-ACESS     -   NO
 174      DEBUG-NAME     -   'F'
 175      POINTER-TYPE   -   FPOINTER
 176    */
 177   xdata = allocMap (0, 1, 0, 0, 0, 0, options.xdata_loc, XDATA_NAME, 'F', FPOINTER);
 178
 179   /* Inderectly addressed internal data segment
 180      SFRSPACE       -   NO
 181      FAR-SPACE      -   NO
 182      PAGED          -   NO
 183      DIRECT-ACCESS  -   NO
 184      BIT-ACCESS     -   NO
 185      CODE-ACESS     -   NO
 186      DEBUG-NAME     -   'G'
 187      POINTER-TYPE   -   IPOINTER
 188    */
 189   idata = allocMap (0, 0, 0, 0, 0, 0, options.idata_loc, IDATA_NAME, 'G', IPOINTER);
 190
 191   /* Static segment (code for variables );
 192      SFRSPACE       -   NO
 193      FAR-SPACE      -   NO
 194      PAGED          -   NO
 195      DIRECT-ACCESS  -   YES
 196      BIT-ACCESS     -   YES
 197      CODE-ACESS     -   NO
 198      DEBUG-NAME     -   'H'
 199      POINTER-TYPE   -  _NONE_
 200    */
 201   bit = allocMap (0, 0, 0, 1, 1, 0, 0, BIT_NAME, 'H', 0);
 202
 203   /* Special function register space :-
 204      SFRSPACE       -   YES
 205      FAR-SPACE      -   NO
 206      PAGED          -   NO
 207      DIRECT-ACCESS  -   YES
 208      BIT-ACCESS     -   NO
 209      CODE-ACESS     -   NO
 210      DEBUG-NAME     -   'I'
 211      POINTER-TYPE   -   _NONE_
 212    */
 213   sfr = allocMap (1, 0, 0, 1, 0, 0, 0, REG_NAME, 'I', 0);
 214
 215   /* Register space ;
 216      SFRSPACE       -   YES
 217      FAR-SPACE      -   NO
 218      PAGED          -   NO
 219      DIRECT-ACCESS  -   NO
 220      BIT-ACCESS     -   NO
 221      CODE-ACESS     -   NO
 222      DEBUG-NAME     -   ' '
 223      POINTER-TYPE   -   _NONE_
 224    */
 225   reg = allocMap (1, 0, 0, 0, 0, 0, 0, REG_NAME, ' ', 0);
 226
 227   /* SFR bit space
 228      SFRSPACE       -   YES
 229      FAR-SPACE      -   NO
 230      PAGED          -   NO
 231      DIRECT-ACCESS  -   YES
 232      BIT-ACCESS     -   YES
 233      CODE-ACESS     -   NO
 234      DEBUG-NAME     -   'J'
 235      POINTER-TYPE   -   _NONE_
 236    */
 237   sfrbit = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, 'J', 0);
 238
 239   /* EEPROM bit space
 240      SFRSPACE       -   NO
 241      FAR-SPACE      -   YES
 242      PAGED          -   NO
 243      DIRECT-ACCESS  -   NO
 244      BIT-ACCESS     -   NO
 245      CODE-ACESS     -   NO
 246      DEBUG-NAME     -   'K'
 247      POINTER-TYPE   -   EEPPOINTER
 248    */
 249   eeprom = allocMap (0, 1, 0, 0, 0, 0, 0, REG_NAME, 'K', EEPPOINTER);
 250
 251   /* the unknown map */
 252   generic = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, ' ', GPOINTER);
 253
 254 }
 255
 256 /*-----------------------------------------------------------------*/
 257 /* allocIntoSeg - puts a symbol into a memory segment              */
 258 /*-----------------------------------------------------------------*/
 259 void
 260 allocIntoSeg (symbol * sym)
 261 {
 262   memmap *segment = SPEC_OCLS (sym->etype);
 263   addSet (&segment->syms, sym);
 264 }
 265
 266 /*-----------------------------------------------------------------*/
 267 /* allocGlobal - aassigns the output segment to a global var       */
 268 /*-----------------------------------------------------------------*/
 269 void
 270 allocGlobal (symbol * sym)
 271 {
 272
 273   /* symbol name is internal name  */
 274   if (!sym->level)              /* local statics can come here */
 275     sprintf (sym->rname, "%s%s", port->fun_prefix, sym->name);
 276
 277   /* add it to the operandKey reset */
 278   addSet (&operKeyReset, sym);
 279
 280   /* if this is a literal e.g. enumerated type */
 281   /* put it in the data segment & do nothing   */
 282   if (IS_LITERAL (sym->etype))
 283     {
 284       SPEC_OCLS (sym->etype) = data;
 285       return;
 286     }
 287
 288   /* if this is a function then assign code space    */
 289   if (IS_FUNC (sym->type))
 290     {
 291       SPEC_OCLS (sym->etype) = code;
 292       /* if this is an interrupt service routine
 293          then put it in the interrupt service array */
 294       if (IS_ISR (sym->etype))
 295         {
 296
 297           if (interrupts[SPEC_INTN (sym->etype)])
 298             werror (E_INT_DEFINED,
 299                     SPEC_INTN (sym->etype),
 300                     interrupts[SPEC_INTN (sym->etype)]->name);
 301           else
 302             interrupts[SPEC_INTN (sym->etype)] = sym;
 303
 304           /* automagically extend the maximum interrupts */
 305           if (SPEC_INTN (sym->etype) >= maxInterrupts)
 306             maxInterrupts = SPEC_INTN (sym->etype) + 1;
 307         }
 308       /* if it is not compiler defined */
 309       if (!sym->cdef)
 310         allocIntoSeg (sym);
 311
 312       return;
 313     }
 314
 315   /* if this is a  SFR or SBIT */
 316   if (SPEC_SCLS (sym->etype) == S_SFR ||
 317       SPEC_SCLS (sym->etype) == S_SBIT)
 318     {
 319
 320       /* if both absolute address & initial  */
 321       /* value specified then error        */
 322       if (IS_ABSOLUTE (sym->etype) && sym->ival)
 323         {
 324           werror (E_SFR_INIT, sym->name);
 325           sym->ival = NULL;
 326         }
 327
 328       SPEC_OCLS (sym->etype) =
 329         (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
 330
 331       allocIntoSeg (sym);
 332       return;
 333     }
 334
 335   /* if this is a bit variable and no storage class */
 336   if (SPEC_NOUN (sym->etype) == V_BIT
 337       && SPEC_SCLS (sym->etype) == S_BIT)
 338     {
 339       SPEC_OCLS (sym->etype) = bit;
 340       allocIntoSeg (sym);
 341       return;
 342     }
 343
 344   /* if bit storage class */
 345   if (SPEC_SCLS (sym->etype) == S_SBIT)
 346     {
 347       SPEC_OCLS (sym->etype) = bit;
 348       allocIntoSeg (sym);
 349       return;
 350     }
 351
 352   /* register storage class ignored changed to FIXED */
 353   if (SPEC_SCLS (sym->etype) == S_REGISTER)
 354     SPEC_SCLS (sym->etype) = S_FIXED;
 355
 356   /* if data specified then  */
 357   if (SPEC_SCLS (sym->etype) == S_DATA)
 358     {
 359       /* set the output class */
 360       SPEC_OCLS (sym->etype) = data;
 361       /* generate the symbol  */
 362       allocIntoSeg (sym);
 363       return;
 364     }
 365
 366   /* if it is fixed, then allocate depending on the  */
 367   /* current memory model,same for automatics        */
 368   if (SPEC_SCLS (sym->etype) == S_FIXED ||
 369       SPEC_SCLS (sym->etype) == S_AUTO)
 370     {
 371       /* set the output class */
 372       SPEC_OCLS (sym->etype) = port->mem.default_globl_map;
 373       /* generate the symbol  */
 374       allocIntoSeg (sym);
 375       return;
 376     }
 377
 378   /* if code change to constant */
 379   if (SPEC_SCLS (sym->etype) == S_CODE) {
 380     SPEC_OCLS (sym->etype) = statsg;
 381     allocIntoSeg (sym);
 382     return;
 383   }
 384
 385   if (SPEC_SCLS (sym->etype) == S_XDATA)
 386     {
 387       SPEC_OCLS (sym->etype) = xdata;
 388       allocIntoSeg (sym);
 389       return;
 390     }
 391
 392   if (SPEC_SCLS (sym->etype) == S_IDATA)
 393     {
 394       SPEC_OCLS (sym->etype) = idata;
 395       sym->iaccess = 1;
 396       allocIntoSeg (sym);
 397       return;
 398     }
 399
 400   if (SPEC_SCLS (sym->etype) == S_EEPROM)
 401     {
 402       SPEC_OCLS (sym->etype) = eeprom;
 403       allocIntoSeg (sym);
 404       return;
 405     }
 406
 407   return;
 408 }
 409
 410 /*-----------------------------------------------------------------*/
 411 /* allocParms - parameters are always passed on stack              */
 412 /*-----------------------------------------------------------------*/
 413 void
 414 allocParms (value * val)
 415 {
 416   value *lval;
 417   int pNum = 1;
 418
 419   for (lval = val; lval; lval = lval->next, pNum++)
 420     {
 421
 422       /* check the declaration */
 423       checkDecl (lval->sym);
 424
 425       /* if this a register parm then allocate
 426          it as a local variable by adding it
 427          to the first block we see in the body */
 428       if (IS_REGPARM (lval->etype))
 429         continue;
 430
 431       /* mark it as my parameter */
 432       lval->sym->ismyparm = 1;
 433       lval->sym->localof = currFunc;
 434
 435
 436       /* if automatic variables r 2b stacked */
 437       if (options.stackAuto || IS_RENT (currFunc->etype))
 438         {
 439
 440           if (lval->sym)
 441             lval->sym->onStack = 1;
 442
 443           /* choose which stack 2 use   */
 444           /*  use xternal stack */
 445           if (options.useXstack)
 446             {
 447               /* PENDING: stack direction support */
 448               SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack;
 449               SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
 450                 xstackPtr - getSize (lval->type);
 451               xstackPtr -= getSize (lval->type);
 452             }
 453           else
 454             {                   /* use internal stack   */
 455               SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
 456               if (port->stack.direction > 0)
 457                 {
 458                   SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
 459                     stackPtr - (SPEC_BANK (currFunc->etype) ? port->stack.bank_overhead : 0) -
 460                     getSize (lval->type) -
 461                     (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0);
 462                   stackPtr -= getSize (lval->type);
 463                 }
 464               else
 465                 {
 466                   /* This looks like the wrong order but it turns out OK... */
 467                   /* PENDING: isr, bank overhead, ... */
 468                   SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
 469                     stackPtr +
 470                     (IS_BANKEDCALL (currFunc->etype) ? port->stack.banked_overhead : 0) +
 471                     (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0) +
 472                     0;
 473                   stackPtr += getSize (lval->type);
 474                 }
 475             }
 476           allocIntoSeg (lval->sym);
 477         }
 478       else
 479         { /* allocate them in the automatic space */
 480           /* generate a unique name  */
 481           sprintf (lval->sym->rname, "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum);
 482           strcpy (lval->name, lval->sym->rname);
 483
 484           /* if declared in external storage */
 485           if (SPEC_SCLS (lval->etype) == S_XDATA)
 486             SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
 487           else
 488             /* other wise depending on the memory model
 489                note here that we put it into the overlay segment
 490                first, we will remove it from the overlay segment
 491                after the overlay determination has been done */
 492             if (options.model == MODEL_SMALL)
 493               {
 494                 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
 495                   (options.noOverlay ? port->mem.default_local_map
 496                    : overlay);
 497               }
 498             else
 499               {
 500                 SPEC_SCLS (lval->etype) = S_XDATA;
 501                 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
 502               }
 503           allocIntoSeg (lval->sym);
 504         }
 505     }
 506
 507   return;
 508 }
 509
 510 /*-----------------------------------------------------------------*/
 511 /* deallocParms - parameters are always passed on stack                */
 512 /*-----------------------------------------------------------------*/
 513 void
 514 deallocParms (value * val)
 515 {
 516   value *lval;
 517
 518   for (lval = val; lval; lval = lval->next)
 519     {
 520
 521       /* unmark is myparm */
 522       lval->sym->ismyparm = 0;
 523       /* if on stack then depending on which stack */
 524
 525       /* delete it from the symbol table  */
 526       deleteSym (SymbolTab, lval->sym, lval->sym->name);
 527
 528       if (!lval->sym->isref)
 529         {
 530           lval->sym->allocreq = 1;
 531           werror (W_NO_REFERENCE, currFunc->name,
 532                   "function argument", lval->sym->name);
 533         }
 534
 535       /* move the rname if any to the name for both val & sym */
 536       /* and leave a copy of it in the symbol table           */
 537       if (lval->sym->rname[0])
 538         {
 539           char buffer[SDCC_NAME_MAX];
 540           strcpy (buffer, lval->sym->rname);
 541           lval->sym = copySymbol (lval->sym);
 542           strcpy (lval->sym->rname, buffer);
 543           strcpy (lval->name, strcpy (lval->sym->name, lval->sym->rname));
 544           addSym (SymbolTab, lval->sym, lval->sym->name,
 545                   lval->sym->level, lval->sym->block, 1);
 546           lval->sym->_isparm = 1;
 547           addSet (&operKeyReset, lval->sym);
 548         }
 549
 550     }
 551
 552   return;
 553 }
 554
 555 /*-----------------------------------------------------------------*/
 556 /* allocLocal - allocate local variables                           */
 557 /*-----------------------------------------------------------------*/
 558 void
 559 allocLocal (symbol * sym)
 560 {
 561
 562   /* generate an unique name */
 563   sprintf (sym->rname, "%s%s_%s_%d_%d",
 564            port->fun_prefix,
 565            currFunc->name, sym->name, sym->level, sym->block);
 566
 567   sym->islocal = 1;
 568   sym->localof = currFunc;
 569
 570   /* if this is a static variable */
 571   if (IS_STATIC (sym->etype))
 572     {
 573       allocGlobal (sym);
 574       sym->allocreq = 1;
 575       return;
 576     }
 577
 578   /* if volatile then */
 579   if (IS_VOLATILE (sym->etype))
 580     sym->allocreq = 1;
 581
 582   /* this is automatic           */
 583
 584   /* if it to be placed on the stack */
 585   if (options.stackAuto || reentrant)
 586     {
 587
 588       sym->onStack = 1;
 589       if (options.useXstack)
 590         {
 591           /* PENDING: stack direction for xstack */
 592           SPEC_OCLS (sym->etype) = xstack;
 593           SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
 594           xstackPtr += getSize (sym->type);
 595         }
 596       else
 597         {
 598           SPEC_OCLS (sym->etype) = istack;
 599           if (port->stack.direction > 0)
 600             {
 601               SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
 602               stackPtr += getSize (sym->type);
 603             }
 604           else
 605             {
 606               stackPtr -= getSize (sym->type);
 607               SPEC_STAK (sym->etype) = sym->stack = stackPtr;
 608             }
 609         }
 610       allocIntoSeg (sym);
 611       return;
 612     }
 613
 614   /* else depending on the storage class specified */
 615   if (SPEC_SCLS (sym->etype) == S_XDATA)
 616     {
 617       SPEC_OCLS (sym->etype) = xdata;
 618       allocIntoSeg (sym);
 619       return;
 620     }
 621
 622   if (SPEC_SCLS (sym->etype) == S_CODE && !sym->_isparm) {
 623     SPEC_OCLS (sym->etype) = statsg;
 624     allocIntoSeg (sym);
 625     return;
 626   }
 627
 628   if (SPEC_SCLS (sym->etype) == S_IDATA)
 629     {
 630       SPEC_OCLS (sym->etype) = idata;
 631       sym->iaccess = 1;
 632       allocIntoSeg (sym);
 633       return;
 634     }
 635
 636   /* if this is a function then assign code space    */
 637   if (IS_FUNC (sym->type))
 638     {
 639       SPEC_OCLS (sym->etype) = code;
 640       return;
 641     }
 642
 643   /* if this is a  SFR or SBIT */
 644   if (SPEC_SCLS (sym->etype) == S_SFR ||
 645       SPEC_SCLS (sym->etype) == S_SBIT)
 646     {
 647
 648       /* if both absolute address & initial  */
 649       /* value specified then error        */
 650       if (IS_ABSOLUTE (sym->etype) && sym->ival)
 651         {
 652           werror (E_SFR_INIT, sym->name);
 653           sym->ival = NULL;
 654         }
 655
 656       SPEC_OCLS (sym->etype) =
 657         (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
 658
 659       allocIntoSeg (sym);
 660       return;
 661     }
 662
 663   /* if this is a bit variable and no storage class */
 664   if (SPEC_NOUN (sym->etype) == V_BIT
 665       && (SPEC_SCLS (sym->etype) == S_BIT))
 666     {
 667       SPEC_OCLS (sym->etype) = bit;
 668       allocIntoSeg (sym);
 669       return;
 670     }
 671
 672   if (SPEC_SCLS (sym->etype) == S_DATA)
 673     {
 674       SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
 675       allocIntoSeg (sym);
 676       return;
 677     }
 678
 679   if (SPEC_SCLS (sym->etype) == S_EEPROM)
 680     {
 681       SPEC_OCLS (sym->etype) = eeprom;
 682       allocIntoSeg (sym);
 683       return;
 684     }
 685
 686   /* again note that we have put it into the overlay segment
 687      will remove and put into the 'data' segment if required after
 688      overlay  analysis has been done */
 689   if (options.model == MODEL_SMALL) {
 690     SPEC_OCLS (sym->etype) =
 691       (options.noOverlay ? port->mem.default_local_map
 692        : overlay);
 693   } else {
 694     SPEC_OCLS (sym->etype) = port->mem.default_local_map;
 695   }
 696   allocIntoSeg (sym);
 697 }
 698
 699 /*-----------------------------------------------------------------*/
 700 /* deallocLocal - deallocates the local variables                  */
 701 /*-----------------------------------------------------------------*/
 702 void
 703 deallocLocal (symbol * csym)
 704 {
 705   symbol *sym;
 706
 707   for (sym = csym; sym; sym = sym->next)
 708     {
 709       if (sym->_isparm)
 710         continue;
 711
 712       /* if it is on the stack */
 713       if (sym->onStack)
 714         {
 715           if (options.useXstack)
 716             xstackPtr -= getSize (sym->type);
 717           else
 718             stackPtr -= getSize (sym->type);
 719         }
 720       /* if not used give a warning */
 721       if (!sym->isref && !IS_STATIC (sym->etype))
 722         werror (W_NO_REFERENCE, currFunc->name,
 723                 "local variable", sym->name);
 724       /* now delete it from the symbol table */
 725       deleteSym (SymbolTab, sym, sym->name);
 726     }
 727 }
 728
 729 /*-----------------------------------------------------------------*/
 730 /* overlay2data - moves declarations from the overlay seg to data  */
 731 /*-----------------------------------------------------------------*/
 732 void
 733 overlay2data ()
 734 {
 735   symbol *sym;
 736
 737   for (sym = setFirstItem (overlay->syms); sym;
 738        sym = setNextItem (overlay->syms))
 739     {
 740
 741       SPEC_OCLS (sym->etype) = data;
 742       allocIntoSeg (sym);
 743     }
 744
 745   setToNull ((void **) &overlay->syms);
 746
 747 }
 748
 749 /*-----------------------------------------------------------------*/
 750 /* overlay2Set - will add all symbols from the overlay segment to  */
 751 /*               the set of sets containing the overlable symbols  */
 752 /*-----------------------------------------------------------------*/
 753 void
 754 overlay2Set ()
 755 {
 756   symbol *sym;
 757   set *oset = NULL;
 758
 759   for (sym = setFirstItem (overlay->syms); sym;
 760        sym = setNextItem (overlay->syms))
 761     {
 762
 763       addSet (&oset, sym);
 764     }
 765
 766   setToNull ((void **) &overlay->syms);
 767   addSet (&ovrSetSets, oset);
 768
 769 }
 770
 771 /*-----------------------------------------------------------------*/
 772 /* allocVariables - creates decl & assign storage class for a v    */
 773 /*-----------------------------------------------------------------*/
 774 int
 775 allocVariables (symbol * symChain)
 776 {
 777   symbol *sym;
 778   symbol *csym;
 779   int stack = 0;
 780   int saveLevel = 0;
 781
 782   /* go thru the symbol chain   */
 783   for (sym = symChain; sym; sym = sym->next)
 784     {
 785
 786       /* if this is a typedef then add it */
 787       /* to the typedef table             */
 788       if (IS_TYPEDEF (sym->etype))
 789         {
 790           /* check if the typedef already exists    */
 791           csym = findSym (TypedefTab, NULL, sym->name);
 792           if (csym && csym->level == sym->level)
 793             werror (E_DUPLICATE_TYPEDEF, sym->name);
 794
 795           addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
 796           continue;             /* go to the next one         */
 797         }
 798       /* make sure it already exist */
 799       csym = findSymWithLevel (SymbolTab, sym);
 800       if (!csym || (csym && csym->level != sym->level))
 801         csym = sym;
 802
 803       /* check the declaration */
 804       checkDecl (csym);
 805
 806       /* if this is a function or a pointer to function */
 807       /* then args  processing  */
 808       if (funcInChain (csym->type))
 809         {
 810
 811           processFuncArgs (csym, 1);
 812           /* if register bank specified then update maxRegBank */
 813           if (maxRegBank < SPEC_BANK (csym->etype))
 814             maxRegBank = SPEC_BANK (csym->etype);
 815         }
 816
 817       /* if this is a extern variable then change the */
 818       /* level to zero temporarily                                    */
 819       if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
 820         {
 821           saveLevel = csym->level;
 822           csym->level = 0;
 823         }
 824
 825       /* if this is a literal then it is an enumerated */
 826       /* type so need not allocate it space for it     */
 827       if (IS_LITERAL (sym->etype))
 828         continue;
 829
 830       /* generate the actual declaration  */
 831       if (csym->level)
 832         {
 833           allocLocal (csym);
 834           if (csym->onStack)
 835             stack += getSize (csym->type);
 836         }
 837       else
 838         allocGlobal (csym);
 839
 840       /* restore the level */
 841       if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
 842         csym->level = saveLevel;
 843     }
 844
 845   return stack;
 846 }
 847
 848 /*-----------------------------------------------------------------*/
 849 /* redoStackOffsets :- will reassign the values for stack offsets  */
 850 /*-----------------------------------------------------------------*/
 851 void
 852 redoStackOffsets (void)
 853 {
 854   symbol *sym;
 855   int sPtr = 0;
 856   int xsPtr = -1;
 857
 858   /* after register allocation is complete we know
 859      which variables will need to be assigned space
 860      on the stack. We will eliminate those variables
 861      which do not have the allocReq flag thus reducing
 862      the stack space */
 863   for (sym = setFirstItem (istack->syms); sym;
 864        sym = setNextItem (istack->syms))
 865     {
 866
 867       int size = getSize (sym->type);
 868       /* nothing to do with parameters so continue */
 869       if ((sym->_isparm && !IS_REGPARM (sym->etype)))
 870         continue;
 871
 872       if (IS_AGGREGATE (sym->type))
 873         {
 874           if (port->stack.direction > 0)
 875             {
 876               SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
 877               sPtr += size;
 878             }
 879           else
 880             {
 881               sPtr -= size;
 882               SPEC_STAK (sym->etype) = sym->stack = sPtr;
 883             }
 884           continue;
 885         }
 886
 887       /* if allocation not required then subtract
 888          size from overall stack size & continue */
 889       if (!sym->allocreq)
 890         {
 891           currFunc->stack -= size;
 892           SPEC_STAK (currFunc->etype) -= size;
 893           continue;
 894         }
 895
 896       if (port->stack.direction > 0)
 897         {
 898           SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
 899           sPtr += size;
 900         }
 901       else
 902         {
 903           sPtr -= size;
 904           SPEC_STAK (sym->etype) = sym->stack = sPtr;
 905         }
 906     }
 907
 908   /* do the same for the external stack */
 909
 910   for (sym = setFirstItem (xstack->syms); sym;
 911        sym = setNextItem (xstack->syms))
 912     {
 913
 914       int size = getSize (sym->type);
 915       /* nothing to do with parameters so continue */
 916       if ((sym->_isparm && !IS_REGPARM (sym->etype)))
 917         continue;
 918
 919       if (IS_AGGREGATE (sym->type))
 920         {
 921           SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
 922           xsPtr += size;
 923           continue;
 924         }
 925
 926       /* if allocation not required then subtract
 927          size from overall stack size & continue */
 928       if (!sym->allocreq)
 929         {
 930           currFunc->xstack -= size;
 931           SPEC_STAK (currFunc->etype) -= size;
 932           continue;
 933         }
 934
 935       SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
 936       xsPtr += size;
 937     }
 938
 939   /* if the debug option is set then output the
 940      symbols to the map file */
 941   if (options.debug && !options.nodebug)
 942     {
 943       for (sym = setFirstItem (istack->syms); sym;
 944            sym = setNextItem (istack->syms))
 945         cdbSymbol (sym, cdbFile, FALSE, FALSE);
 946
 947       for (sym = setFirstItem (xstack->syms); sym;
 948            sym = setNextItem (xstack->syms))
 949         cdbSymbol (sym, cdbFile, FALSE, FALSE);
 950     }
 951 }
 952
 953 /*-----------------------------------------------------------------*/
 954 /* printAllocInfoSeg- print the allocation for a given section     */
 955 /*-----------------------------------------------------------------*/
 956 static void
 957 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
 958 {
 959   symbol *sym;
 960
 961   if (!map)
 962     return;
 963   if (!map->syms)
 964     return;
 965
 966   for (sym = setFirstItem (map->syms); sym;
 967        sym = setNextItem (map->syms))
 968     {
 969
 970       if (sym->level == 0)
 971         continue;
 972       if (sym->localof != func)
 973         continue;
 974       fprintf (of, ";%-25s Allocated to ", sym->name);
 975
 976       /* if assigned to registers */
 977       if (!sym->allocreq && sym->reqv)
 978         {
 979           int i;
 980           sym = OP_SYMBOL (sym->reqv);
 981           fprintf (of, "registers ");
 982           for (i = 0; i < 4 && sym->regs[i]; i++)
 983             fprintf (of, "%s ", port->getRegName (sym->regs[i]));
 984           fprintf (of, "\n");
 985           continue;
 986         }
 987
 988       /* if on stack */
 989       if (sym->onStack)
 990         {
 991           fprintf (of, "stack - offset %d\n", sym->stack);
 992           continue;
 993         }
 994
 995       /* otherwise give rname */
 996       fprintf (of, "in memory with name '%s'\n", sym->rname);
 997     }
 998 }
 999
1000 /*-----------------------------------------------------------------*/
1001 /* canOverlayLocals - returns true if the local variables can overlayed */
1002 /*-----------------------------------------------------------------*/
1003 static bool
1004 canOverlayLocals (eBBlock ** ebbs, int count)
1005 {
1006   int i;
1007   /* if staticAuto is in effect or the current function
1008      being compiled is reentrant or the overlay segment
1009      is empty or no overlay option is in effect then */
1010   if (options.noOverlay ||
1011       options.stackAuto ||
1012       (currFunc &&
1013        (IS_RENT (currFunc->etype) ||
1014         IS_ISR (currFunc->etype))) ||
1015       elementsInSet (overlay->syms) == 0)
1016
1017     return FALSE;
1018
1019   /* otherwise do thru the blocks and see if there
1020      any function calls if found then return false */
1021   for (i = 0; i < count; i++)
1022     {
1023       iCode *ic;
1024
1025       for (ic = ebbs[i]->sch; ic; ic = ic->next)
1026         if (ic && (ic->op == CALL || ic->op == PCALL))
1027           return FALSE;
1028     }
1029
1030   /* no function calls found return TRUE */
1031   return TRUE;
1032 }
1033
1034 /*-----------------------------------------------------------------*/
1035 /* doOverlays - move the overlay segment to appropriate location   */
1036 /*-----------------------------------------------------------------*/
1037 void
1038 doOverlays (eBBlock ** ebbs, int count)
1039 {
1040   /* check if the parameters and local variables
1041      of this function can be put in the overlay segment
1042      This check is essentially to see if the function
1043      calls any other functions if yes then we cannot
1044      overlay */
1045   if (canOverlayLocals (ebbs, count))
1046     /* if we can then put the parameters &
1047        local variables in the overlay set */
1048     overlay2Set ();
1049   else
1050     /* otherwise put them into data where
1051        they belong */
1052     overlay2data ();
1053 }
1054
1055 /*-----------------------------------------------------------------*/
1056 /* printAllocInfo - prints allocation information for a function   */
1057 /*-----------------------------------------------------------------*/
1058 void
1059 printAllocInfo (symbol * func, FILE * of)
1060 {
1061   if (!of)
1062     of = stdout;
1063
1064   /* must be called after register allocation is complete */
1065   fprintf (of, ";------------------------------------------------------------\n");
1066   fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1067   fprintf (of, ";------------------------------------------------------------\n");
1068
1069   printAllocInfoSeg (xstack, func, of);
1070   printAllocInfoSeg (istack, func, of);
1071   printAllocInfoSeg (code, func, of);
1072   printAllocInfoSeg (data, func, of);
1073   printAllocInfoSeg (xdata, func, of);
1074   printAllocInfoSeg (idata, func, of);
1075   printAllocInfoSeg (sfr, func, of);
1076   printAllocInfoSeg (sfrbit, func, of);
1077 }