1 /*-----------------------------------------------------------------*/
2 /* SDCCmem.c - 8051 memory management routines */
3 /*-----------------------------------------------------------------*/
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 */
24 /* this is a set of sets each set containing
25 symbols in a single overlay */
26 set *ovrSetSets = NULL;
29 int fatalError = 0; /* fatal error flag */
31 /*-----------------------------------------------------------------*/
32 /* allocMap - allocates a memory map */
33 /*-----------------------------------------------------------------*/
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 */
49 if (!(map = Safe_alloc (sizeof (memmap))))
51 werror (E_OUT_OF_MEM, __FILE__, sizeof (memmap));
55 memset (map, ZERO, sizeof (memmap));
61 map->codesp = codemap;
65 map->ptrType = ptrType;
66 if (!(map->oFile = tempfile ()))
68 werror (E_TMPFILE_FAILED);
71 addSetHead (&tmpfileSet, map->oFile);
76 /*-----------------------------------------------------------------*/
77 /* initMem - allocates and initializes all the segments */
78 /*-----------------------------------------------------------------*/
82 /* allocate all the segments */
83 /* xternal stack segment ;
91 POINTER-TYPE - FPOINTER
93 xstack = allocMap (0, 1, 1, 0, 0, 0, options.xstack_loc, XSTACK_NAME, 'A', PPOINTER);
95 /* internal stack segment ;
103 POINTER-TYPE - POINTER
105 istack = allocMap (0, 0, 0, 0, 0, 0, options.stack_loc, ISTACK_NAME, 'B', POINTER);
115 POINTER-TYPE - CPOINTER
117 code = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER);
127 POINTER-TYPE - CPOINTER
129 home = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER);
131 /* Static segment (code for variables );
139 POINTER-TYPE - CPOINTER
141 statsg = allocMap (0, 1, 0, 0, 0, 1, 0, STATIC_NAME, 'D', CPOINTER);
143 /* Data segment - internal storage segment ;
151 POINTER-TYPE - POINTER
153 data = allocMap (0, 0, 0, 1, 0, 0, options.data_loc, DATA_NAME, 'E', POINTER);
155 /* overlay segment - same as internal storage segment ;
163 POINTER-TYPE - POINTER
165 overlay = allocMap (0, 0, 0, 1, 0, 0, options.data_loc, DATA_NAME, 'E', POINTER);
167 /* Xternal Data segment -
175 POINTER-TYPE - FPOINTER
177 xdata = allocMap (0, 1, 0, 0, 0, 0, options.xdata_loc, XDATA_NAME, 'F', FPOINTER);
179 /* Inderectly addressed internal data segment
187 POINTER-TYPE - IPOINTER
189 idata = allocMap (0, 0, 0, 0, 0, 0, options.idata_loc, IDATA_NAME, 'G', IPOINTER);
191 /* Static segment (code for variables );
199 POINTER-TYPE - _NONE_
201 bit = allocMap (0, 0, 0, 1, 1, 0, 0, BIT_NAME, 'H', 0);
203 /* Special function register space :-
211 POINTER-TYPE - _NONE_
213 sfr = allocMap (1, 0, 0, 1, 0, 0, 0, REG_NAME, 'I', 0);
223 POINTER-TYPE - _NONE_
225 reg = allocMap (1, 0, 0, 0, 0, 0, 0, REG_NAME, ' ', 0);
235 POINTER-TYPE - _NONE_
237 sfrbit = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, 'J', 0);
247 POINTER-TYPE - EEPPOINTER
249 eeprom = allocMap (0, 1, 0, 0, 0, 0, 0, REG_NAME, 'K', EEPPOINTER);
251 /* the unknown map */
252 generic = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, ' ', GPOINTER);
256 /*-----------------------------------------------------------------*/
257 /* allocIntoSeg - puts a symbol into a memory segment */
258 /*-----------------------------------------------------------------*/
260 allocIntoSeg (symbol * sym)
262 memmap *segment = SPEC_OCLS (sym->etype);
263 addSet (&segment->syms, sym);
266 /*-----------------------------------------------------------------*/
267 /* allocGlobal - aassigns the output segment to a global var */
268 /*-----------------------------------------------------------------*/
270 allocGlobal (symbol * sym)
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);
277 /* add it to the operandKey reset */
278 addSet (&operKeyReset, sym);
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))
284 SPEC_OCLS (sym->etype) = data;
288 /* if this is a function then assign code space */
289 if (IS_FUNC (sym->type))
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 (FUNC_ISISR (sym->type))
297 if (interrupts[FUNC_INTNO (sym->type)])
298 werror (E_INT_DEFINED,
299 FUNC_INTNO (sym->type),
300 interrupts[FUNC_INTNO (sym->type)]->name);
302 interrupts[FUNC_INTNO (sym->type)] = sym;
304 /* automagically extend the maximum interrupts */
305 if (FUNC_INTNO (sym->type) >= maxInterrupts)
306 maxInterrupts = FUNC_INTNO (sym->type) + 1;
308 /* if it is not compiler defined */
315 /* if this is a SFR or SBIT */
316 if (SPEC_SCLS (sym->etype) == S_SFR ||
317 SPEC_SCLS (sym->etype) == S_SBIT)
320 /* if both absolute address & initial */
321 /* value specified then error */
322 if (IS_ABSOLUTE (sym->etype) && sym->ival)
324 werror (E_SFR_INIT, sym->name);
328 SPEC_OCLS (sym->etype) =
329 (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
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)
339 SPEC_OCLS (sym->etype) = bit;
344 /* if bit storage class */
345 if (SPEC_SCLS (sym->etype) == S_SBIT)
347 SPEC_OCLS (sym->etype) = bit;
352 /* register storage class ignored changed to FIXED */
353 if (SPEC_SCLS (sym->etype) == S_REGISTER)
354 SPEC_SCLS (sym->etype) = S_FIXED;
356 /* if data specified then */
357 if (SPEC_SCLS (sym->etype) == S_DATA)
359 /* set the output class */
360 SPEC_OCLS (sym->etype) = data;
361 /* generate the symbol */
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)
371 /* set the output class */
372 SPEC_OCLS (sym->etype) = port->mem.default_globl_map;
373 // jwk: we need to set SPEC_SCLS now !!!!
374 /* generate the symbol */
379 /* if code change to constant */
380 if (SPEC_SCLS (sym->etype) == S_CODE) {
381 SPEC_OCLS (sym->etype) = statsg;
386 if (SPEC_SCLS (sym->etype) == S_XDATA)
388 SPEC_OCLS (sym->etype) = xdata;
393 if (SPEC_SCLS (sym->etype) == S_IDATA)
395 SPEC_OCLS (sym->etype) = idata;
401 if (SPEC_SCLS (sym->etype) == S_EEPROM)
403 SPEC_OCLS (sym->etype) = eeprom;
411 /*-----------------------------------------------------------------*/
412 /* allocParms - parameters are always passed on stack */
413 /*-----------------------------------------------------------------*/
415 allocParms (value * val)
420 for (lval = val; lval; lval = lval->next, pNum++)
423 /* check the declaration */
424 checkDecl (lval->sym, 0);
426 /* if this a register parm then allocate
427 it as a local variable by adding it
428 to the first block we see in the body */
429 if (IS_REGPARM (lval->etype))
432 /* mark it as my parameter */
433 lval->sym->ismyparm = 1;
434 lval->sym->localof = currFunc;
437 /* if automatic variables r 2b stacked */
438 if (options.stackAuto || IFFUNC_ISREENT (currFunc->type))
442 lval->sym->onStack = 1;
444 /* choose which stack 2 use */
445 /* use xternal stack */
446 if (options.useXstack)
448 /* PENDING: stack direction support */
449 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack;
450 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
451 xstackPtr - getSize (lval->type);
452 xstackPtr -= getSize (lval->type);
455 { /* use internal stack */
456 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
457 if (port->stack.direction > 0)
459 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
460 stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) -
461 getSize (lval->type) -
462 (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0);
463 stackPtr -= getSize (lval->type);
467 /* This looks like the wrong order but it turns out OK... */
468 /* PENDING: isr, bank overhead, ... */
469 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
471 ((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) +
472 (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) +
474 stackPtr += getSize (lval->type);
477 allocIntoSeg (lval->sym);
480 { /* allocate them in the automatic space */
481 /* generate a unique name */
482 sprintf (lval->sym->rname, "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum);
483 strcpy (lval->name, lval->sym->rname);
485 /* if declared in external storage */
486 if (SPEC_SCLS (lval->etype) == S_XDATA)
487 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
489 /* other wise depending on the memory model
490 note here that we put it into the overlay segment
491 first, we will remove it from the overlay segment
492 after the overlay determination has been done */
493 if (options.model == MODEL_SMALL)
495 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
496 (options.noOverlay ? port->mem.default_local_map
501 SPEC_SCLS (lval->etype) = S_XDATA;
502 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
504 allocIntoSeg (lval->sym);
511 /*-----------------------------------------------------------------*/
512 /* deallocParms - parameters are always passed on stack */
513 /*-----------------------------------------------------------------*/
515 deallocParms (value * val)
519 for (lval = val; lval; lval = lval->next)
522 /* unmark is myparm */
523 lval->sym->ismyparm = 0;
524 /* if on stack then depending on which stack */
526 /* delete it from the symbol table */
527 deleteSym (SymbolTab, lval->sym, lval->sym->name);
529 if (!lval->sym->isref)
531 lval->sym->allocreq = 1;
532 werror (W_NO_REFERENCE, currFunc->name,
533 "function argument", lval->sym->name);
536 /* move the rname if any to the name for both val & sym */
537 /* and leave a copy of it in the symbol table */
538 if (lval->sym->rname[0])
540 char buffer[SDCC_NAME_MAX];
541 strcpy (buffer, lval->sym->rname);
542 lval->sym = copySymbol (lval->sym);
543 strcpy (lval->sym->rname, buffer);
544 strcpy (lval->name, strcpy (lval->sym->name, lval->sym->rname));
545 addSym (SymbolTab, lval->sym, lval->sym->name,
546 lval->sym->level, lval->sym->block, 1);
547 lval->sym->_isparm = 1;
548 addSet (&operKeyReset, lval->sym);
556 /*-----------------------------------------------------------------*/
557 /* allocLocal - allocate local variables */
558 /*-----------------------------------------------------------------*/
560 allocLocal (symbol * sym)
563 /* generate an unique name */
564 sprintf (sym->rname, "%s%s_%s_%d_%d",
566 currFunc->name, sym->name, sym->level, sym->block);
569 sym->localof = currFunc;
571 /* if this is a static variable */
572 if (IS_STATIC (sym->etype))
579 /* if volatile then */
580 if (IS_VOLATILE (sym->etype))
583 /* this is automatic */
585 /* if it to be placed on the stack */
586 if (options.stackAuto || reentrant) {
588 if (options.useXstack) {
589 /* PENDING: stack direction for xstack */
590 SPEC_OCLS (sym->etype) = xstack;
591 SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
592 xstackPtr += getSize (sym->type);
594 SPEC_OCLS (sym->etype) = istack;
595 if (port->stack.direction > 0) {
596 SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
597 stackPtr += getSize (sym->type);
599 stackPtr -= getSize (sym->type);
600 SPEC_STAK (sym->etype) = sym->stack = stackPtr;
607 /* else depending on the storage class specified */
608 if (SPEC_SCLS (sym->etype) == S_XDATA)
610 SPEC_OCLS (sym->etype) = xdata;
615 if (SPEC_SCLS (sym->etype) == S_CODE && !sym->_isparm) {
616 SPEC_OCLS (sym->etype) = statsg;
621 if (SPEC_SCLS (sym->etype) == S_IDATA)
623 SPEC_OCLS (sym->etype) = idata;
629 /* if this is a function then assign code space */
630 if (IS_FUNC (sym->type))
632 SPEC_OCLS (sym->etype) = code;
636 /* if this is a SFR or SBIT */
637 if (SPEC_SCLS (sym->etype) == S_SFR ||
638 SPEC_SCLS (sym->etype) == S_SBIT)
641 /* if both absolute address & initial */
642 /* value specified then error */
643 if (IS_ABSOLUTE (sym->etype) && sym->ival)
645 werror (E_SFR_INIT, sym->name);
649 SPEC_OCLS (sym->etype) =
650 (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
656 /* if this is a bit variable and no storage class */
657 if (SPEC_NOUN (sym->etype) == V_BIT
658 && (SPEC_SCLS (sym->etype) == S_BIT))
660 SPEC_OCLS (sym->etype) = bit;
665 if (SPEC_SCLS (sym->etype) == S_DATA)
667 SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
672 if (SPEC_SCLS (sym->etype) == S_EEPROM)
674 SPEC_OCLS (sym->etype) = eeprom;
679 /* again note that we have put it into the overlay segment
680 will remove and put into the 'data' segment if required after
681 overlay analysis has been done */
682 if (options.model == MODEL_SMALL) {
683 SPEC_OCLS (sym->etype) =
684 (options.noOverlay ? port->mem.default_local_map
687 SPEC_OCLS (sym->etype) = port->mem.default_local_map;
692 /*-----------------------------------------------------------------*/
693 /* deallocLocal - deallocates the local variables */
694 /*-----------------------------------------------------------------*/
696 deallocLocal (symbol * csym)
700 for (sym = csym; sym; sym = sym->next)
705 /* if it is on the stack */
708 if (options.useXstack)
709 xstackPtr -= getSize (sym->type);
711 stackPtr -= getSize (sym->type);
713 /* if not used give a warning */
714 if (!sym->isref && !IS_STATIC (sym->etype))
715 werror (W_NO_REFERENCE, currFunc->name,
716 "local variable", sym->name);
717 /* now delete it from the symbol table */
718 deleteSym (SymbolTab, sym, sym->name);
722 /*-----------------------------------------------------------------*/
723 /* overlay2data - moves declarations from the overlay seg to data */
724 /*-----------------------------------------------------------------*/
730 for (sym = setFirstItem (overlay->syms); sym;
731 sym = setNextItem (overlay->syms))
734 SPEC_OCLS (sym->etype) = data;
738 setToNull ((void **) &overlay->syms);
742 /*-----------------------------------------------------------------*/
743 /* overlay2Set - will add all symbols from the overlay segment to */
744 /* the set of sets containing the overlable symbols */
745 /*-----------------------------------------------------------------*/
752 for (sym = setFirstItem (overlay->syms); sym;
753 sym = setNextItem (overlay->syms))
759 setToNull ((void **) &overlay->syms);
760 addSet (&ovrSetSets, oset);
764 /*-----------------------------------------------------------------*/
765 /* allocVariables - creates decl & assign storage class for a v */
766 /*-----------------------------------------------------------------*/
768 allocVariables (symbol * symChain)
775 /* go thru the symbol chain */
776 for (sym = symChain; sym; sym = sym->next)
779 /* if this is a typedef then add it */
780 /* to the typedef table */
781 if (IS_TYPEDEF (sym->etype))
783 /* check if the typedef already exists */
784 csym = findSym (TypedefTab, NULL, sym->name);
785 if (csym && csym->level == sym->level)
786 werror (E_DUPLICATE_TYPEDEF, sym->name);
788 addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
789 continue; /* go to the next one */
791 /* make sure it already exist */
792 csym = findSymWithLevel (SymbolTab, sym);
793 if (!csym || (csym && csym->level != sym->level))
796 /* check the declaration */
799 /* if this is a function or a pointer to function */
800 /* then args processing */
801 if (funcInChain (csym->type))
804 processFuncArgs (csym, 1);
805 /* if register bank specified then update maxRegBank */
806 if (maxRegBank < FUNC_REGBANK (csym->type))
807 maxRegBank = FUNC_REGBANK (csym->type);
810 /* if this is a extern variable then change the */
811 /* level to zero temporarily */
812 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
814 saveLevel = csym->level;
818 /* if this is a literal then it is an enumerated */
819 /* type so need not allocate it space for it */
820 if (IS_LITERAL (sym->etype))
823 /* generate the actual declaration */
828 stack += getSize (csym->type);
833 /* restore the level */
834 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
835 csym->level = saveLevel;
841 /*-----------------------------------------------------------------*/
842 /* redoStackOffsets :- will reassign the values for stack offsets */
843 /*-----------------------------------------------------------------*/
845 redoStackOffsets (void)
851 /* after register allocation is complete we know
852 which variables will need to be assigned space
853 on the stack. We will eliminate those variables
854 which do not have the allocReq flag thus reducing
856 for (sym = setFirstItem (istack->syms); sym;
857 sym = setNextItem (istack->syms))
860 int size = getSize (sym->type);
861 /* nothing to do with parameters so continue */
862 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
865 if (IS_AGGREGATE (sym->type))
867 if (port->stack.direction > 0)
869 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
875 SPEC_STAK (sym->etype) = sym->stack = sPtr;
880 /* if allocation not required then subtract
881 size from overall stack size & continue */
884 currFunc->stack -= size;
885 SPEC_STAK (currFunc->etype) -= size;
889 if (port->stack.direction > 0)
891 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
897 SPEC_STAK (sym->etype) = sym->stack = sPtr;
901 /* do the same for the external stack */
903 for (sym = setFirstItem (xstack->syms); sym;
904 sym = setNextItem (xstack->syms))
907 int size = getSize (sym->type);
908 /* nothing to do with parameters so continue */
909 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
912 if (IS_AGGREGATE (sym->type))
914 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
919 /* if allocation not required then subtract
920 size from overall stack size & continue */
923 currFunc->xstack -= size;
924 SPEC_STAK (currFunc->etype) -= size;
928 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
932 /* if the debug option is set then output the
933 symbols to the map file */
936 for (sym = setFirstItem (istack->syms); sym;
937 sym = setNextItem (istack->syms))
938 cdbSymbol (sym, cdbFile, FALSE, FALSE);
940 for (sym = setFirstItem (xstack->syms); sym;
941 sym = setNextItem (xstack->syms))
942 cdbSymbol (sym, cdbFile, FALSE, FALSE);
946 /*-----------------------------------------------------------------*/
947 /* printAllocInfoSeg- print the allocation for a given section */
948 /*-----------------------------------------------------------------*/
950 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
959 for (sym = setFirstItem (map->syms); sym;
960 sym = setNextItem (map->syms))
965 if (sym->localof != func)
967 fprintf (of, ";%-25s Allocated to ", sym->name);
969 /* if assigned to registers */
970 if (!sym->allocreq && sym->reqv)
973 sym = OP_SYMBOL (sym->reqv);
974 fprintf (of, "registers ");
975 for (i = 0; i < 4 && sym->regs[i]; i++)
976 fprintf (of, "%s ", port->getRegName (sym->regs[i]));
984 fprintf (of, "stack - offset %d\n", sym->stack);
988 /* otherwise give rname */
989 fprintf (of, "in memory with name '%s'\n", sym->rname);
993 /*-----------------------------------------------------------------*/
994 /* canOverlayLocals - returns true if the local variables can overlayed */
995 /*-----------------------------------------------------------------*/
997 canOverlayLocals (eBBlock ** ebbs, int count)
1000 /* if staticAuto is in effect or the current function
1001 being compiled is reentrant or the overlay segment
1002 is empty or no overlay option is in effect then */
1003 if (options.noOverlay ||
1004 options.stackAuto ||
1006 (IFFUNC_ISREENT (currFunc->type) ||
1007 FUNC_ISISR (currFunc->type))) ||
1008 elementsInSet (overlay->syms) == 0)
1012 /* otherwise do thru the blocks and see if there
1013 any function calls if found then return false */
1014 for (i = 0; i < count; i++)
1018 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1019 if (ic && (ic->op == CALL || ic->op == PCALL))
1023 /* no function calls found return TRUE */
1027 /*-----------------------------------------------------------------*/
1028 /* doOverlays - move the overlay segment to appropriate location */
1029 /*-----------------------------------------------------------------*/
1031 doOverlays (eBBlock ** ebbs, int count)
1033 /* check if the parameters and local variables
1034 of this function can be put in the overlay segment
1035 This check is essentially to see if the function
1036 calls any other functions if yes then we cannot
1038 if (canOverlayLocals (ebbs, count))
1039 /* if we can then put the parameters &
1040 local variables in the overlay set */
1043 /* otherwise put them into data where
1048 /*-----------------------------------------------------------------*/
1049 /* printAllocInfo - prints allocation information for a function */
1050 /*-----------------------------------------------------------------*/
1052 printAllocInfo (symbol * func, FILE * of)
1057 /* must be called after register allocation is complete */
1058 fprintf (of, ";------------------------------------------------------------\n");
1059 fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1060 fprintf (of, ";------------------------------------------------------------\n");
1062 printAllocInfoSeg (xstack, func, of);
1063 printAllocInfoSeg (istack, func, of);
1064 printAllocInfoSeg (code, func, of);
1065 printAllocInfoSeg (data, func, of);
1066 printAllocInfoSeg (xdata, func, of);
1067 printAllocInfoSeg (idata, func, of);
1068 printAllocInfoSeg (sfr, func, of);
1069 printAllocInfoSeg (sfrbit, func, of);