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, 0);
 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     sym->onStack = 1;
 587     if (options.useXstack) {
 588       /* PENDING: stack direction for xstack */
 589       SPEC_OCLS (sym->etype) = xstack;
 590       SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
 591       xstackPtr += getSize (sym->type);
 592     } else {
 593       SPEC_OCLS (sym->etype) = istack;
 594       if (port->stack.direction > 0) {
 595         SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
 596         stackPtr += getSize (sym->type);
 597       } else {
 598         stackPtr -= getSize (sym->type);
 599         SPEC_STAK (sym->etype) = sym->stack = stackPtr;
 600       }
 601     }
 602     allocIntoSeg (sym);
 603     return;
 604   }
 605
 606   /* else depending on the storage class specified */
 607   if (SPEC_SCLS (sym->etype) == S_XDATA)
 608     {
 609       SPEC_OCLS (sym->etype) = xdata;
 610       allocIntoSeg (sym);
 611       return;
 612     }
 613
 614   if (SPEC_SCLS (sym->etype) == S_CODE && !sym->_isparm) {
 615     SPEC_OCLS (sym->etype) = statsg;
 616     allocIntoSeg (sym);
 617     return;
 618   }
 619
 620   if (SPEC_SCLS (sym->etype) == S_IDATA)
 621     {
 622       SPEC_OCLS (sym->etype) = idata;
 623       sym->iaccess = 1;
 624       allocIntoSeg (sym);
 625       return;
 626     }
 627
 628   /* if this is a function then assign code space    */
 629   if (IS_FUNC (sym->type))
 630     {
 631       SPEC_OCLS (sym->etype) = code;
 632       return;
 633     }
 634
 635   /* if this is a  SFR or SBIT */
 636   if (SPEC_SCLS (sym->etype) == S_SFR ||
 637       SPEC_SCLS (sym->etype) == S_SBIT)
 638     {
 639
 640       /* if both absolute address & initial  */
 641       /* value specified then error        */
 642       if (IS_ABSOLUTE (sym->etype) && sym->ival)
 643         {
 644           werror (E_SFR_INIT, sym->name);
 645           sym->ival = NULL;
 646         }
 647
 648       SPEC_OCLS (sym->etype) =
 649         (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
 650
 651       allocIntoSeg (sym);
 652       return;
 653     }
 654
 655   /* if this is a bit variable and no storage class */
 656   if (SPEC_NOUN (sym->etype) == V_BIT
 657       && (SPEC_SCLS (sym->etype) == S_BIT))
 658     {
 659       SPEC_OCLS (sym->etype) = bit;
 660       allocIntoSeg (sym);
 661       return;
 662     }
 663
 664   if (SPEC_SCLS (sym->etype) == S_DATA)
 665     {
 666       SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
 667       allocIntoSeg (sym);
 668       return;
 669     }
 670
 671   if (SPEC_SCLS (sym->etype) == S_EEPROM)
 672     {
 673       SPEC_OCLS (sym->etype) = eeprom;
 674       allocIntoSeg (sym);
 675       return;
 676     }
 677
 678   /* again note that we have put it into the overlay segment
 679      will remove and put into the 'data' segment if required after
 680      overlay  analysis has been done */
 681   if (options.model == MODEL_SMALL) {
 682     SPEC_OCLS (sym->etype) =
 683       (options.noOverlay ? port->mem.default_local_map
 684        : overlay);
 685   } else {
 686     SPEC_OCLS (sym->etype) = port->mem.default_local_map;
 687   }
 688   allocIntoSeg (sym);
 689 }
 690
 691 /*-----------------------------------------------------------------*/
 692 /* deallocLocal - deallocates the local variables                  */
 693 /*-----------------------------------------------------------------*/
 694 void
 695 deallocLocal (symbol * csym)
 696 {
 697   symbol *sym;
 698
 699   for (sym = csym; sym; sym = sym->next)
 700     {
 701       if (sym->_isparm)
 702         continue;
 703
 704       /* if it is on the stack */
 705       if (sym->onStack)
 706         {
 707           if (options.useXstack)
 708             xstackPtr -= getSize (sym->type);
 709           else
 710             stackPtr -= getSize (sym->type);
 711         }
 712       /* if not used give a warning */
 713       if (!sym->isref && !IS_STATIC (sym->etype))
 714         werror (W_NO_REFERENCE, currFunc->name,
 715                 "local variable", sym->name);
 716       /* now delete it from the symbol table */
 717       deleteSym (SymbolTab, sym, sym->name);
 718     }
 719 }
 720
 721 /*-----------------------------------------------------------------*/
 722 /* overlay2data - moves declarations from the overlay seg to data  */
 723 /*-----------------------------------------------------------------*/
 724 void
 725 overlay2data ()
 726 {
 727   symbol *sym;
 728
 729   for (sym = setFirstItem (overlay->syms); sym;
 730        sym = setNextItem (overlay->syms))
 731     {
 732
 733       SPEC_OCLS (sym->etype) = data;
 734       allocIntoSeg (sym);
 735     }
 736
 737   setToNull ((void **) &overlay->syms);
 738
 739 }
 740
 741 /*-----------------------------------------------------------------*/
 742 /* overlay2Set - will add all symbols from the overlay segment to  */
 743 /*               the set of sets containing the overlable symbols  */
 744 /*-----------------------------------------------------------------*/
 745 void
 746 overlay2Set ()
 747 {
 748   symbol *sym;
 749   set *oset = NULL;
 750
 751   for (sym = setFirstItem (overlay->syms); sym;
 752        sym = setNextItem (overlay->syms))
 753     {
 754
 755       addSet (&oset, sym);
 756     }
 757
 758   setToNull ((void **) &overlay->syms);
 759   addSet (&ovrSetSets, oset);
 760
 761 }
 762
 763 /*-----------------------------------------------------------------*/
 764 /* allocVariables - creates decl & assign storage class for a v    */
 765 /*-----------------------------------------------------------------*/
 766 int
 767 allocVariables (symbol * symChain)
 768 {
 769   symbol *sym;
 770   symbol *csym;
 771   int stack = 0;
 772   int saveLevel = 0;
 773
 774   /* go thru the symbol chain   */
 775   for (sym = symChain; sym; sym = sym->next)
 776     {
 777
 778       /* if this is a typedef then add it */
 779       /* to the typedef table             */
 780       if (IS_TYPEDEF (sym->etype))
 781         {
 782           /* check if the typedef already exists    */
 783           csym = findSym (TypedefTab, NULL, sym->name);
 784           if (csym && csym->level == sym->level)
 785             werror (E_DUPLICATE_TYPEDEF, sym->name);
 786
 787           addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
 788           continue;             /* go to the next one         */
 789         }
 790       /* make sure it already exist */
 791       csym = findSymWithLevel (SymbolTab, sym);
 792       if (!csym || (csym && csym->level != sym->level))
 793         csym = sym;
 794
 795       /* check the declaration */
 796       checkDecl (csym,0);
 797
 798       /* if this is a function or a pointer to function */
 799       /* then args  processing  */
 800       if (funcInChain (csym->type))
 801         {
 802
 803           processFuncArgs (csym, 1);
 804           /* if register bank specified then update maxRegBank */
 805           if (maxRegBank < SPEC_BANK (csym->etype))
 806             maxRegBank = SPEC_BANK (csym->etype);
 807         }
 808
 809       /* if this is a extern variable then change the */
 810       /* level to zero temporarily                                    */
 811       if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
 812         {
 813           saveLevel = csym->level;
 814           csym->level = 0;
 815         }
 816
 817       /* if this is a literal then it is an enumerated */
 818       /* type so need not allocate it space for it     */
 819       if (IS_LITERAL (sym->etype))
 820         continue;
 821
 822       /* generate the actual declaration  */
 823       if (csym->level)
 824         {
 825           allocLocal (csym);
 826           if (csym->onStack)
 827             stack += getSize (csym->type);
 828         }
 829       else
 830         allocGlobal (csym);
 831
 832       /* restore the level */
 833       if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
 834         csym->level = saveLevel;
 835     }
 836
 837   return stack;
 838 }
 839
 840 /*-----------------------------------------------------------------*/
 841 /* redoStackOffsets :- will reassign the values for stack offsets  */
 842 /*-----------------------------------------------------------------*/
 843 void
 844 redoStackOffsets (void)
 845 {
 846   symbol *sym;
 847   int sPtr = 0;
 848   int xsPtr = -1;
 849
 850   /* after register allocation is complete we know
 851      which variables will need to be assigned space
 852      on the stack. We will eliminate those variables
 853      which do not have the allocReq flag thus reducing
 854      the stack space */
 855   for (sym = setFirstItem (istack->syms); sym;
 856        sym = setNextItem (istack->syms))
 857     {
 858
 859       int size = getSize (sym->type);
 860       /* nothing to do with parameters so continue */
 861       if ((sym->_isparm && !IS_REGPARM (sym->etype)))
 862         continue;
 863
 864       if (IS_AGGREGATE (sym->type))
 865         {
 866           if (port->stack.direction > 0)
 867             {
 868               SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
 869               sPtr += size;
 870             }
 871           else
 872             {
 873               sPtr -= size;
 874               SPEC_STAK (sym->etype) = sym->stack = sPtr;
 875             }
 876           continue;
 877         }
 878
 879       /* if allocation not required then subtract
 880          size from overall stack size & continue */
 881       if (!sym->allocreq)
 882         {
 883           currFunc->stack -= size;
 884           SPEC_STAK (currFunc->etype) -= size;
 885           continue;
 886         }
 887
 888       if (port->stack.direction > 0)
 889         {
 890           SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
 891           sPtr += size;
 892         }
 893       else
 894         {
 895           sPtr -= size;
 896           SPEC_STAK (sym->etype) = sym->stack = sPtr;
 897         }
 898     }
 899
 900   /* do the same for the external stack */
 901
 902   for (sym = setFirstItem (xstack->syms); sym;
 903        sym = setNextItem (xstack->syms))
 904     {
 905
 906       int size = getSize (sym->type);
 907       /* nothing to do with parameters so continue */
 908       if ((sym->_isparm && !IS_REGPARM (sym->etype)))
 909         continue;
 910
 911       if (IS_AGGREGATE (sym->type))
 912         {
 913           SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
 914           xsPtr += size;
 915           continue;
 916         }
 917
 918       /* if allocation not required then subtract
 919          size from overall stack size & continue */
 920       if (!sym->allocreq)
 921         {
 922           currFunc->xstack -= size;
 923           SPEC_STAK (currFunc->etype) -= size;
 924           continue;
 925         }
 926
 927       SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
 928       xsPtr += size;
 929     }
 930
 931   /* if the debug option is set then output the
 932      symbols to the map file */
 933   if (options.debug)
 934     {
 935       for (sym = setFirstItem (istack->syms); sym;
 936            sym = setNextItem (istack->syms))
 937         cdbSymbol (sym, cdbFile, FALSE, FALSE);
 938
 939       for (sym = setFirstItem (xstack->syms); sym;
 940            sym = setNextItem (xstack->syms))
 941         cdbSymbol (sym, cdbFile, FALSE, FALSE);
 942     }
 943 }
 944
 945 /*-----------------------------------------------------------------*/
 946 /* printAllocInfoSeg- print the allocation for a given section     */
 947 /*-----------------------------------------------------------------*/
 948 static void
 949 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
 950 {
 951   symbol *sym;
 952
 953   if (!map)
 954     return;
 955   if (!map->syms)
 956     return;
 957
 958   for (sym = setFirstItem (map->syms); sym;
 959        sym = setNextItem (map->syms))
 960     {
 961
 962       if (sym->level == 0)
 963         continue;
 964       if (sym->localof != func)
 965         continue;
 966       fprintf (of, ";%-25s Allocated to ", sym->name);
 967
 968       /* if assigned to registers */
 969       if (!sym->allocreq && sym->reqv)
 970         {
 971           int i;
 972           sym = OP_SYMBOL (sym->reqv);
 973           fprintf (of, "registers ");
 974           for (i = 0; i < 4 && sym->regs[i]; i++)
 975             fprintf (of, "%s ", port->getRegName (sym->regs[i]));
 976           fprintf (of, "\n");
 977           continue;
 978         }
 979
 980       /* if on stack */
 981       if (sym->onStack)
 982         {
 983           fprintf (of, "stack - offset %d\n", sym->stack);
 984           continue;
 985         }
 986
 987       /* otherwise give rname */
 988       fprintf (of, "in memory with name '%s'\n", sym->rname);
 989     }
 990 }
 991
 992 /*-----------------------------------------------------------------*/
 993 /* canOverlayLocals - returns true if the local variables can overlayed */
 994 /*-----------------------------------------------------------------*/
 995 static bool
 996 canOverlayLocals (eBBlock ** ebbs, int count)
 997 {
 998   int i;
 999   /* if staticAuto is in effect or the current function
1000      being compiled is reentrant or the overlay segment
1001      is empty or no overlay option is in effect then */
1002   if (options.noOverlay ||
1003       options.stackAuto ||
1004       (currFunc &&
1005        (IS_RENT (currFunc->etype) ||
1006         IS_ISR (currFunc->etype))) ||
1007       elementsInSet (overlay->syms) == 0)
1008
1009     return FALSE;
1010
1011   /* otherwise do thru the blocks and see if there
1012      any function calls if found then return false */
1013   for (i = 0; i < count; i++)
1014     {
1015       iCode *ic;
1016
1017       for (ic = ebbs[i]->sch; ic; ic = ic->next)
1018         if (ic && (ic->op == CALL || ic->op == PCALL))
1019           return FALSE;
1020     }
1021
1022   /* no function calls found return TRUE */
1023   return TRUE;
1024 }
1025
1026 /*-----------------------------------------------------------------*/
1027 /* doOverlays - move the overlay segment to appropriate location   */
1028 /*-----------------------------------------------------------------*/
1029 void
1030 doOverlays (eBBlock ** ebbs, int count)
1031 {
1032   /* check if the parameters and local variables
1033      of this function can be put in the overlay segment
1034      This check is essentially to see if the function
1035      calls any other functions if yes then we cannot
1036      overlay */
1037   if (canOverlayLocals (ebbs, count))
1038     /* if we can then put the parameters &
1039        local variables in the overlay set */
1040     overlay2Set ();
1041   else
1042     /* otherwise put them into data where
1043        they belong */
1044     overlay2data ();
1045 }
1046
1047 /*-----------------------------------------------------------------*/
1048 /* printAllocInfo - prints allocation information for a function   */
1049 /*-----------------------------------------------------------------*/
1050 void
1051 printAllocInfo (symbol * func, FILE * of)
1052 {
1053   if (!of)
1054     of = stdout;
1055
1056   /* must be called after register allocation is complete */
1057   fprintf (of, ";------------------------------------------------------------\n");
1058   fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1059   fprintf (of, ";------------------------------------------------------------\n");
1060
1061   printAllocInfoSeg (xstack, func, of);
1062   printAllocInfoSeg (istack, func, of);
1063   printAllocInfoSeg (code, func, of);
1064   printAllocInfoSeg (data, func, of);
1065   printAllocInfoSeg (xdata, func, of);
1066   printAllocInfoSeg (idata, func, of);
1067   printAllocInfoSeg (sfr, func, of);
1068   printAllocInfoSeg (sfrbit, func, of);
1069 }