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_OCLS (sym->etype) = statsg;
385 if (SPEC_SCLS (sym->etype) == S_XDATA)
387 SPEC_OCLS (sym->etype) = xdata;
392 if (SPEC_SCLS (sym->etype) == S_IDATA)
394 SPEC_OCLS (sym->etype) = idata;
400 if (SPEC_SCLS (sym->etype) == S_EEPROM)
402 SPEC_OCLS (sym->etype) = eeprom;
410 /*-----------------------------------------------------------------*/
411 /* allocParms - parameters are always passed on stack */
412 /*-----------------------------------------------------------------*/
414 allocParms (value * val)
419 for (lval = val; lval; lval = lval->next, pNum++)
422 /* check the declaration */
423 checkDecl (lval->sym, 0);
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))
431 /* mark it as my parameter */
432 lval->sym->ismyparm = 1;
433 lval->sym->localof = currFunc;
436 /* if automatic variables r 2b stacked */
437 if (options.stackAuto || IS_RENT (currFunc->etype))
441 lval->sym->onStack = 1;
443 /* choose which stack 2 use */
444 /* use xternal stack */
445 if (options.useXstack)
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);
454 { /* use internal stack */
455 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
456 if (port->stack.direction > 0)
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);
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 =
470 (IS_BANKEDCALL (currFunc->etype) ? port->stack.banked_overhead : 0) +
471 (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0) +
473 stackPtr += getSize (lval->type);
476 allocIntoSeg (lval->sym);
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);
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;
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)
494 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
495 (options.noOverlay ? port->mem.default_local_map
500 SPEC_SCLS (lval->etype) = S_XDATA;
501 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
503 allocIntoSeg (lval->sym);
510 /*-----------------------------------------------------------------*/
511 /* deallocParms - parameters are always passed on stack */
512 /*-----------------------------------------------------------------*/
514 deallocParms (value * val)
518 for (lval = val; lval; lval = lval->next)
521 /* unmark is myparm */
522 lval->sym->ismyparm = 0;
523 /* if on stack then depending on which stack */
525 /* delete it from the symbol table */
526 deleteSym (SymbolTab, lval->sym, lval->sym->name);
528 if (!lval->sym->isref)
530 lval->sym->allocreq = 1;
531 werror (W_NO_REFERENCE, currFunc->name,
532 "function argument", lval->sym->name);
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])
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);
555 /*-----------------------------------------------------------------*/
556 /* allocLocal - allocate local variables */
557 /*-----------------------------------------------------------------*/
559 allocLocal (symbol * sym)
562 /* generate an unique name */
563 sprintf (sym->rname, "%s%s_%s_%d_%d",
565 currFunc->name, sym->name, sym->level, sym->block);
568 sym->localof = currFunc;
570 /* if this is a static variable */
571 if (IS_STATIC (sym->etype))
578 /* if volatile then */
579 if (IS_VOLATILE (sym->etype))
582 /* this is automatic */
585 if (!IS_SPEC(sym->type) && SPEC_OCLS(sym->etype)) {
591 /* if it to be placed on the stack */
592 if (options.stackAuto || reentrant) {
594 if (options.useXstack) {
595 /* PENDING: stack direction for xstack */
596 SPEC_OCLS (sym->etype) = xstack;
597 SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
598 xstackPtr += getSize (sym->type);
600 SPEC_OCLS (sym->etype) = istack;
601 if (port->stack.direction > 0) {
602 SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
603 stackPtr += getSize (sym->type);
605 stackPtr -= getSize (sym->type);
606 SPEC_STAK (sym->etype) = sym->stack = stackPtr;
613 /* else depending on the storage class specified */
614 if (SPEC_SCLS (sym->etype) == S_XDATA)
616 SPEC_OCLS (sym->etype) = xdata;
621 if (SPEC_SCLS (sym->etype) == S_CODE && !sym->_isparm) {
622 SPEC_OCLS (sym->etype) = statsg;
627 if (SPEC_SCLS (sym->etype) == S_IDATA)
629 SPEC_OCLS (sym->etype) = idata;
635 /* if this is a function then assign code space */
636 if (IS_FUNC (sym->type))
638 SPEC_OCLS (sym->etype) = code;
642 /* if this is a SFR or SBIT */
643 if (SPEC_SCLS (sym->etype) == S_SFR ||
644 SPEC_SCLS (sym->etype) == S_SBIT)
647 /* if both absolute address & initial */
648 /* value specified then error */
649 if (IS_ABSOLUTE (sym->etype) && sym->ival)
651 werror (E_SFR_INIT, sym->name);
655 SPEC_OCLS (sym->etype) =
656 (SPEC_SCLS (sym->etype) == S_SFR ? sfr : sfrbit);
662 /* if this is a bit variable and no storage class */
663 if (SPEC_NOUN (sym->etype) == V_BIT
664 && (SPEC_SCLS (sym->etype) == S_BIT))
666 SPEC_OCLS (sym->etype) = bit;
671 if (SPEC_SCLS (sym->etype) == S_DATA)
673 SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
678 if (SPEC_SCLS (sym->etype) == S_EEPROM)
680 SPEC_OCLS (sym->etype) = eeprom;
685 /* again note that we have put it into the overlay segment
686 will remove and put into the 'data' segment if required after
687 overlay analysis has been done */
688 if (options.model == MODEL_SMALL) {
689 SPEC_OCLS (sym->etype) =
690 (options.noOverlay ? port->mem.default_local_map
693 SPEC_OCLS (sym->etype) = port->mem.default_local_map;
698 /*-----------------------------------------------------------------*/
699 /* deallocLocal - deallocates the local variables */
700 /*-----------------------------------------------------------------*/
702 deallocLocal (symbol * csym)
706 for (sym = csym; sym; sym = sym->next)
711 /* if it is on the stack */
714 if (options.useXstack)
715 xstackPtr -= getSize (sym->type);
717 stackPtr -= getSize (sym->type);
719 /* if not used give a warning */
720 if (!sym->isref && !IS_STATIC (sym->etype))
721 werror (W_NO_REFERENCE, currFunc->name,
722 "local variable", sym->name);
723 /* now delete it from the symbol table */
724 deleteSym (SymbolTab, sym, sym->name);
728 /*-----------------------------------------------------------------*/
729 /* overlay2data - moves declarations from the overlay seg to data */
730 /*-----------------------------------------------------------------*/
736 for (sym = setFirstItem (overlay->syms); sym;
737 sym = setNextItem (overlay->syms))
740 SPEC_OCLS (sym->etype) = data;
744 setToNull ((void **) &overlay->syms);
748 /*-----------------------------------------------------------------*/
749 /* overlay2Set - will add all symbols from the overlay segment to */
750 /* the set of sets containing the overlable symbols */
751 /*-----------------------------------------------------------------*/
758 for (sym = setFirstItem (overlay->syms); sym;
759 sym = setNextItem (overlay->syms))
765 setToNull ((void **) &overlay->syms);
766 addSet (&ovrSetSets, oset);
770 /*-----------------------------------------------------------------*/
771 /* allocVariables - creates decl & assign storage class for a v */
772 /*-----------------------------------------------------------------*/
774 allocVariables (symbol * symChain)
781 /* go thru the symbol chain */
782 for (sym = symChain; sym; sym = sym->next)
785 /* if this is a typedef then add it */
786 /* to the typedef table */
787 if (IS_TYPEDEF (sym->etype))
789 /* check if the typedef already exists */
790 csym = findSym (TypedefTab, NULL, sym->name);
791 if (csym && csym->level == sym->level)
792 werror (E_DUPLICATE_TYPEDEF, sym->name);
794 addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
795 continue; /* go to the next one */
797 /* make sure it already exist */
798 csym = findSymWithLevel (SymbolTab, sym);
799 if (!csym || (csym && csym->level != sym->level))
802 /* check the declaration */
805 /* if this is a function or a pointer to function */
806 /* then args processing */
807 if (funcInChain (csym->type))
810 processFuncArgs (csym, 1);
811 /* if register bank specified then update maxRegBank */
812 if (maxRegBank < SPEC_BANK (csym->etype))
813 maxRegBank = SPEC_BANK (csym->etype);
816 /* if this is a extern variable then change the */
817 /* level to zero temporarily */
818 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
820 saveLevel = csym->level;
824 /* if this is a literal then it is an enumerated */
825 /* type so need not allocate it space for it */
826 if (IS_LITERAL (sym->etype))
829 /* generate the actual declaration */
834 stack += getSize (csym->type);
839 /* restore the level */
840 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
841 csym->level = saveLevel;
847 /*-----------------------------------------------------------------*/
848 /* redoStackOffsets :- will reassign the values for stack offsets */
849 /*-----------------------------------------------------------------*/
851 redoStackOffsets (void)
857 /* after register allocation is complete we know
858 which variables will need to be assigned space
859 on the stack. We will eliminate those variables
860 which do not have the allocReq flag thus reducing
862 for (sym = setFirstItem (istack->syms); sym;
863 sym = setNextItem (istack->syms))
866 int size = getSize (sym->type);
867 /* nothing to do with parameters so continue */
868 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
871 if (IS_AGGREGATE (sym->type))
873 if (port->stack.direction > 0)
875 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
881 SPEC_STAK (sym->etype) = sym->stack = sPtr;
886 /* if allocation not required then subtract
887 size from overall stack size & continue */
890 currFunc->stack -= size;
891 SPEC_STAK (currFunc->etype) -= size;
895 if (port->stack.direction > 0)
897 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
903 SPEC_STAK (sym->etype) = sym->stack = sPtr;
907 /* do the same for the external stack */
909 for (sym = setFirstItem (xstack->syms); sym;
910 sym = setNextItem (xstack->syms))
913 int size = getSize (sym->type);
914 /* nothing to do with parameters so continue */
915 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
918 if (IS_AGGREGATE (sym->type))
920 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
925 /* if allocation not required then subtract
926 size from overall stack size & continue */
929 currFunc->xstack -= size;
930 SPEC_STAK (currFunc->etype) -= size;
934 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
938 /* if the debug option is set then output the
939 symbols to the map file */
942 for (sym = setFirstItem (istack->syms); sym;
943 sym = setNextItem (istack->syms))
944 cdbSymbol (sym, cdbFile, FALSE, FALSE);
946 for (sym = setFirstItem (xstack->syms); sym;
947 sym = setNextItem (xstack->syms))
948 cdbSymbol (sym, cdbFile, FALSE, FALSE);
952 /*-----------------------------------------------------------------*/
953 /* printAllocInfoSeg- print the allocation for a given section */
954 /*-----------------------------------------------------------------*/
956 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
965 for (sym = setFirstItem (map->syms); sym;
966 sym = setNextItem (map->syms))
971 if (sym->localof != func)
973 fprintf (of, ";%-25s Allocated to ", sym->name);
975 /* if assigned to registers */
976 if (!sym->allocreq && sym->reqv)
979 sym = OP_SYMBOL (sym->reqv);
980 fprintf (of, "registers ");
981 for (i = 0; i < 4 && sym->regs[i]; i++)
982 fprintf (of, "%s ", port->getRegName (sym->regs[i]));
990 fprintf (of, "stack - offset %d\n", sym->stack);
994 /* otherwise give rname */
995 fprintf (of, "in memory with name '%s'\n", sym->rname);
999 /*-----------------------------------------------------------------*/
1000 /* canOverlayLocals - returns true if the local variables can overlayed */
1001 /*-----------------------------------------------------------------*/
1003 canOverlayLocals (eBBlock ** ebbs, int count)
1006 /* if staticAuto is in effect or the current function
1007 being compiled is reentrant or the overlay segment
1008 is empty or no overlay option is in effect then */
1009 if (options.noOverlay ||
1010 options.stackAuto ||
1012 (IS_RENT (currFunc->etype) ||
1013 IS_ISR (currFunc->etype))) ||
1014 elementsInSet (overlay->syms) == 0)
1018 /* otherwise do thru the blocks and see if there
1019 any function calls if found then return false */
1020 for (i = 0; i < count; i++)
1024 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1025 if (ic && (ic->op == CALL || ic->op == PCALL))
1029 /* no function calls found return TRUE */
1033 /*-----------------------------------------------------------------*/
1034 /* doOverlays - move the overlay segment to appropriate location */
1035 /*-----------------------------------------------------------------*/
1037 doOverlays (eBBlock ** ebbs, int count)
1039 /* check if the parameters and local variables
1040 of this function can be put in the overlay segment
1041 This check is essentially to see if the function
1042 calls any other functions if yes then we cannot
1044 if (canOverlayLocals (ebbs, count))
1045 /* if we can then put the parameters &
1046 local variables in the overlay set */
1049 /* otherwise put them into data where
1054 /*-----------------------------------------------------------------*/
1055 /* printAllocInfo - prints allocation information for a function */
1056 /*-----------------------------------------------------------------*/
1058 printAllocInfo (symbol * func, FILE * of)
1063 /* must be called after register allocation is complete */
1064 fprintf (of, ";------------------------------------------------------------\n");
1065 fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1066 fprintf (of, ";------------------------------------------------------------\n");
1068 printAllocInfoSeg (xstack, func, of);
1069 printAllocInfoSeg (istack, func, of);
1070 printAllocInfoSeg (code, func, of);
1071 printAllocInfoSeg (data, func, of);
1072 printAllocInfoSeg (xdata, func, of);
1073 printAllocInfoSeg (idata, func, of);
1074 printAllocInfoSeg (sfr, func, of);
1075 printAllocInfoSeg (sfrbit, func, of);