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 = calloc (sizeof (memmap), 1)))
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 (IS_ISR (sym->etype))
297 if (interrupts[SPEC_INTN (sym->etype)])
298 werror (E_INT_DEFINED,
299 SPEC_INTN (sym->etype),
300 interrupts[SPEC_INTN (sym->etype)]->name);
302 interrupts[SPEC_INTN (sym->etype)] = sym;
304 /* automagically extend the maximum interrupts */
305 if (SPEC_INTN (sym->etype) >= maxInterrupts)
306 maxInterrupts = SPEC_INTN (sym->etype) + 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 /* generate the symbol */
378 /* if code change to constant */
379 if (SPEC_SCLS (sym->etype) == S_CODE ||
380 SPEC_SCLS (sym->etype) == S_CONSTANT)
382 SPEC_OCLS (sym->etype) = statsg;
387 if (SPEC_SCLS (sym->etype) == S_XDATA)
389 SPEC_OCLS (sym->etype) = xdata;
394 if (SPEC_SCLS (sym->etype) == S_IDATA)
396 SPEC_OCLS (sym->etype) = idata;
402 if (SPEC_SCLS (sym->etype) == S_EEPROM)
404 SPEC_OCLS (sym->etype) = eeprom;
412 /*-----------------------------------------------------------------*/
413 /* allocParms - parameters are always passed on stack */
414 /*-----------------------------------------------------------------*/
416 allocParms (value * val)
421 for (lval = val; lval; lval = lval->next, pNum++)
424 /* check the declaration */
425 checkDecl (lval->sym);
427 /* if this a register parm then allocate
428 it as a local variable by adding it
429 to the first block we see in the body */
430 if (IS_REGPARM (lval->etype))
433 /* mark it as my parameter */
434 lval->sym->ismyparm = 1;
435 lval->sym->localof = currFunc;
438 /* if automatic variables r 2b stacked */
439 if (options.stackAuto || IS_RENT (currFunc->etype))
443 lval->sym->onStack = 1;
445 /* choose which stack 2 use */
446 /* use xternal stack */
447 if (options.useXstack)
449 /* PENDING: stack direction support */
450 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack;
451 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
452 xstackPtr - getSize (lval->type);
453 xstackPtr -= getSize (lval->type);
456 { /* use internal stack */
457 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
458 if (port->stack.direction > 0)
460 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
461 stackPtr - (SPEC_BANK (currFunc->etype) ? port->stack.bank_overhead : 0) -
462 getSize (lval->type) -
463 (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0);
464 stackPtr -= getSize (lval->type);
468 /* This looks like the wrong order but it turns out OK... */
469 /* PENDING: isr, bank overhead, ... */
470 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
472 (IS_BANKEDCALL (currFunc->etype) ? port->stack.banked_overhead : 0) +
473 (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0) +
475 stackPtr += getSize (lval->type);
478 allocIntoSeg (lval->sym);
481 { /* allocate them in the automatic space */
482 /* generate a unique name */
483 sprintf (lval->sym->rname, "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum);
484 strcpy (lval->name, lval->sym->rname);
486 /* if declared in external storage */
487 if (SPEC_SCLS (lval->etype) == S_XDATA)
488 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
490 /* other wise depending on the memory model
491 note here that we put it into the overlay segment
492 first, we will remove it from the overlay segment
493 after the overlay determination has been done */
494 if (options.model == MODEL_SMALL)
496 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
497 (options.model == MODEL_SMALL ? port->mem.default_local_map :
498 (options.noOverlay ? port->mem.default_local_map
503 SPEC_SCLS (lval->etype) = S_XDATA;
504 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
506 allocIntoSeg (lval->sym);
513 /*-----------------------------------------------------------------*/
514 /* deallocParms - parameters are always passed on stack */
515 /*-----------------------------------------------------------------*/
517 deallocParms (value * val)
521 for (lval = val; lval; lval = lval->next)
524 /* unmark is myparm */
525 lval->sym->ismyparm = 0;
526 /* if on stack then depending on which stack */
528 /* delete it from the symbol table */
529 deleteSym (SymbolTab, lval->sym, lval->sym->name);
531 if (!lval->sym->isref)
533 lval->sym->allocreq = 1;
534 werror (W_NO_REFERENCE, currFunc->name,
535 "function argument", lval->sym->name);
538 /* move the rname if any to the name for both val & sym */
539 /* and leave a copy of it in the symbol table */
540 if (lval->sym->rname[0])
542 char buffer[SDCC_NAME_MAX];
543 strcpy (buffer, lval->sym->rname);
544 lval->sym = copySymbol (lval->sym);
545 strcpy (lval->sym->rname, buffer);
546 strcpy (lval->name, strcpy (lval->sym->name, lval->sym->rname));
547 addSym (SymbolTab, lval->sym, lval->sym->name,
548 lval->sym->level, lval->sym->block);
549 lval->sym->_isparm = 1;
550 addSet (&operKeyReset, lval->sym);
558 /*-----------------------------------------------------------------*/
559 /* allocLocal - allocate local variables */
560 /*-----------------------------------------------------------------*/
562 allocLocal (symbol * sym)
565 /* generate an unique name */
566 sprintf (sym->rname, "%s%s_%s_%d_%d",
568 currFunc->name, sym->name, sym->level, sym->block);
571 sym->localof = currFunc;
573 /* if this is a static variable */
574 if (IS_STATIC (sym->etype))
581 /* if volatile then */
582 if (IS_VOLATILE (sym->etype))
585 /* this is automatic */
587 /* if it to be placed on the stack */
588 if (options.stackAuto || reentrant)
592 if (options.useXstack)
594 /* PENDING: stack direction for xstack */
595 SPEC_OCLS (sym->etype) = xstack;
596 SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
597 xstackPtr += getSize (sym->type);
601 SPEC_OCLS (sym->etype) = istack;
602 if (port->stack.direction > 0)
604 SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
605 stackPtr += getSize (sym->type);
609 stackPtr -= getSize (sym->type);
610 SPEC_STAK (sym->etype) = sym->stack = stackPtr;
617 /* else depending on the storage class specified */
618 if (SPEC_SCLS (sym->etype) == S_XDATA)
620 SPEC_OCLS (sym->etype) = xdata;
625 if ((SPEC_SCLS (sym->etype) == S_CODE ||
626 SPEC_SCLS (sym->etype) == S_CONSTANT) &&
629 SPEC_OCLS (sym->etype) = statsg;
634 if (SPEC_SCLS (sym->etype) == S_IDATA)
636 SPEC_OCLS (sym->etype) = idata;
642 /* if this is a function then assign code space */
643 if (IS_FUNC (sym->type))
645 SPEC_OCLS (sym->etype) = code;
649 /* if this is a SFR or SBIT */
650 if (SPEC_SCLS (sym->etype) == S_SFR ||
651 SPEC_SCLS (sym->etype) == S_SBIT)
654 /* if both absolute address & initial */
655 /* value specified then error */
656 if (IS_ABSOLUTE (sym->etype) && sym->ival)
658 werror (E_SFR_INIT, sym->name);
662 SPEC_OCLS (sym->etype) =
663 (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
669 /* if this is a bit variable and no storage class */
670 if (SPEC_NOUN (sym->etype) == V_BIT
671 && (SPEC_SCLS (sym->etype) == S_BIT))
673 SPEC_OCLS (sym->etype) = bit;
678 if (SPEC_SCLS (sym->etype) == S_DATA)
680 SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
685 if (SPEC_SCLS (sym->etype) == S_EEPROM)
687 SPEC_OCLS (sym->etype) = eeprom;
692 /* again note that we have put it into the overlay segment
693 will remove and put into the 'data' segment if required after
694 overlay analysis has been done */
695 SPEC_OCLS (sym->etype) = (options.model == MODEL_SMALL ? port->mem.default_local_map :
696 (options.noOverlay ? port->mem.default_local_map
701 /*-----------------------------------------------------------------*/
702 /* deallocLocal - deallocates the local variables */
703 /*-----------------------------------------------------------------*/
705 deallocLocal (symbol * csym)
709 for (sym = csym; sym; sym = sym->next)
714 /* if it is on the stack */
717 if (options.useXstack)
718 xstackPtr -= getSize (sym->type);
720 stackPtr -= getSize (sym->type);
722 /* if not used give a warning */
723 if (!sym->isref && !IS_STATIC (sym->etype))
724 werror (W_NO_REFERENCE, currFunc->name,
725 "local variable", sym->name);
726 /* now delete it from the symbol table */
727 deleteSym (SymbolTab, sym, sym->name);
731 /*-----------------------------------------------------------------*/
732 /* overlay2data - moves declarations from the overlay seg to data */
733 /*-----------------------------------------------------------------*/
739 for (sym = setFirstItem (overlay->syms); sym;
740 sym = setNextItem (overlay->syms))
743 SPEC_OCLS (sym->etype) = data;
747 setToNull ((void **) &overlay->syms);
751 /*-----------------------------------------------------------------*/
752 /* overlay2Set - will add all symbols from the overlay segment to */
753 /* the set of sets containing the overlable symbols */
754 /*-----------------------------------------------------------------*/
761 for (sym = setFirstItem (overlay->syms); sym;
762 sym = setNextItem (overlay->syms))
768 setToNull ((void **) &overlay->syms);
769 addSet (&ovrSetSets, oset);
773 /*-----------------------------------------------------------------*/
774 /* allocVariables - creates decl & assign storage class for a v */
775 /*-----------------------------------------------------------------*/
777 allocVariables (symbol * symChain)
784 /* go thru the symbol chain */
785 for (sym = symChain; sym; sym = sym->next)
788 /* if this is a typedef then add it */
789 /* to the typedef table */
790 if (IS_TYPEDEF (sym->etype))
792 /* check if the typedef already exists */
793 csym = findSym (TypedefTab, NULL, sym->name);
794 if (csym && csym->level == sym->level)
795 werror (E_DUPLICATE_TYPEDEF, sym->name);
797 addSym (TypedefTab, sym, sym->name, sym->level, sym->block);
798 continue; /* go to the next one */
800 /* make sure it already exist */
801 csym = findSymWithLevel (SymbolTab, sym);
802 if (!csym || (csym && csym->level != sym->level))
805 /* check the declaration */
808 /* if this is a function or a pointer to function */
809 /* then args processing */
810 if (funcInChain (csym->type))
813 processFuncArgs (csym, 1);
814 /* if register bank specified then update maxRegBank */
815 if (maxRegBank < SPEC_BANK (csym->etype))
816 maxRegBank = SPEC_BANK (csym->etype);
819 /* if this is a extern variable then change the */
820 /* level to zero temporarily */
821 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
823 saveLevel = csym->level;
827 /* if this is a literal then it is an enumerated */
828 /* type so need not allocate it space for it */
829 if (IS_LITERAL (sym->etype))
832 /* generate the actual declaration */
837 stack += getSize (csym->type);
842 /* restore the level */
843 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
844 csym->level = saveLevel;
850 /*-----------------------------------------------------------------*/
851 /* redoStackOffsets :- will reassign the values for stack offsets */
852 /*-----------------------------------------------------------------*/
854 redoStackOffsets (void)
860 /* after register allocation is complete we know
861 which variables will need to be assigned space
862 on the stack. We will eliminate those variables
863 which do not have the allocReq flag thus reducing
865 for (sym = setFirstItem (istack->syms); sym;
866 sym = setNextItem (istack->syms))
869 int size = getSize (sym->type);
870 /* nothing to do with parameters so continue */
871 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
874 if (IS_AGGREGATE (sym->type))
876 if (port->stack.direction > 0)
878 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
884 SPEC_STAK (sym->etype) = sym->stack = sPtr;
889 /* if allocation not required then subtract
890 size from overall stack size & continue */
893 currFunc->stack -= size;
894 SPEC_STAK (currFunc->etype) -= size;
898 if (port->stack.direction > 0)
900 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
906 SPEC_STAK (sym->etype) = sym->stack = sPtr;
910 /* do the same for the external stack */
912 for (sym = setFirstItem (xstack->syms); sym;
913 sym = setNextItem (xstack->syms))
916 int size = getSize (sym->type);
917 /* nothing to do with parameters so continue */
918 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
921 if (IS_AGGREGATE (sym->type))
923 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
928 /* if allocation not required then subtract
929 size from overall stack size & continue */
932 currFunc->xstack -= size;
933 SPEC_STAK (currFunc->etype) -= size;
937 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
941 /* if the debug option is set then output the
942 symbols to the map file */
943 if (options.debug && !options.nodebug)
945 for (sym = setFirstItem (istack->syms); sym;
946 sym = setNextItem (istack->syms))
947 cdbSymbol (sym, cdbFile, FALSE, FALSE);
949 for (sym = setFirstItem (xstack->syms); sym;
950 sym = setNextItem (xstack->syms))
951 cdbSymbol (sym, cdbFile, FALSE, FALSE);
955 /*-----------------------------------------------------------------*/
956 /* printAllocInfoSeg- print the allocation for a given section */
957 /*-----------------------------------------------------------------*/
959 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
968 for (sym = setFirstItem (map->syms); sym;
969 sym = setNextItem (map->syms))
974 if (sym->localof != func)
976 fprintf (of, ";%-25s Allocated to ", sym->name);
978 /* if assigned to registers */
979 if (!sym->allocreq && sym->reqv)
982 sym = OP_SYMBOL (sym->reqv);
983 fprintf (of, "registers ");
984 for (i = 0; i < 4 && sym->regs[i]; i++)
985 fprintf (of, "%s ", port->getRegName (sym->regs[i]));
993 fprintf (of, "stack - offset %d\n", sym->stack);
997 /* otherwise give rname */
998 fprintf (of, "in memory with name '%s'\n", sym->rname);
1002 /*-----------------------------------------------------------------*/
1003 /* canOverlayLocals - returns true if the local variables can overlayed */
1004 /*-----------------------------------------------------------------*/
1006 canOverlayLocals (eBBlock ** ebbs, int count)
1009 /* if staticAuto is in effect or the current function
1010 being compiled is reentrant or the overlay segment
1011 is empty or no overlay option is in effect then */
1012 if (options.noOverlay ||
1013 options.stackAuto ||
1015 (IS_RENT (currFunc->etype) ||
1016 IS_ISR (currFunc->etype))) ||
1017 elementsInSet (overlay->syms) == 0)
1021 /* otherwise do thru the blocks and see if there
1022 any function calls if found then return false */
1023 for (i = 0; i < count; i++)
1027 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1028 if (ic && (ic->op == CALL || ic->op == PCALL))
1032 /* no function calls found return TRUE */
1036 /*-----------------------------------------------------------------*/
1037 /* doOverlays - move the overlay segment to appropriate location */
1038 /*-----------------------------------------------------------------*/
1040 doOverlays (eBBlock ** ebbs, int count)
1042 /* check if the parameters and local variables
1043 of this function can be put in the overlay segment
1044 This check is essentially to see if the function
1045 calls any other functions if yes then we cannot
1047 if (canOverlayLocals (ebbs, count))
1048 /* if we can then put the parameters &
1049 local variables in the overlay set */
1052 /* otherwise put them into data where
1057 /*-----------------------------------------------------------------*/
1058 /* printAllocInfo - prints allocation information for a function */
1059 /*-----------------------------------------------------------------*/
1061 printAllocInfo (symbol * func, FILE * of)
1066 /* must be called after register allocation is complete */
1067 fprintf (of, ";------------------------------------------------------------\n");
1068 fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1069 fprintf (of, ";------------------------------------------------------------\n");
1071 printAllocInfoSeg (xstack, func, of);
1072 printAllocInfoSeg (istack, func, of);
1073 printAllocInfoSeg (code, func, of);
1074 printAllocInfoSeg (data, func, of);
1075 printAllocInfoSeg (xdata, func, of);
1076 printAllocInfoSeg (idata, func, of);
1077 printAllocInfoSeg (sfr, func, of);
1078 printAllocInfoSeg (sfrbit, func, of);