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 *pdata = NULL; /* paged external data */
13 memmap *xdata = NULL; /* external data */
14 memmap *xidata = NULL; /* the initialized xdata */
15 memmap *xinit = NULL; /* the initializers for xidata */
16 memmap *idata = NULL; /* internal data upto 256 */
17 memmap *bit = NULL; /* bit addressable space */
18 memmap *statsg = NULL; /* the constant data segment */
19 memmap *sfr = NULL; /* register space */
20 memmap *reg = NULL; /* register space */
21 memmap *sfrbit = NULL; /* sfr bit space */
22 memmap *generic = NULL; /* is a generic pointer */
23 memmap *overlay = NULL; /* overlay segment */
24 memmap *eeprom = NULL; /* eeprom location */
25 memmap *home = NULL; /* Unswitchable code bank */
27 /* this is a set of sets each set containing
28 symbols in a single overlay */
29 set *ovrSetSets = NULL;
32 int fatalError = 0; /* fatal error flag */
34 /*-----------------------------------------------------------------*/
35 /* allocMap - allocates a memory map */
36 /*-----------------------------------------------------------------*/
38 allocMap (char rspace, /* sfr space */
39 char farmap, /* far or near segment */
40 char paged, /* can this segment be paged */
41 char direct, /* directly addressable */
42 char bitaddr, /* bit addressable space */
43 char codemap, /* this is code space */
44 unsigned sloc, /* starting location */
45 const char *name, /* 2 character name */
46 char dbName, /* debug name */
47 int ptrType /* pointer type for this space */
52 if (!(map = Safe_alloc (sizeof (memmap))))
54 werror (E_OUT_OF_MEM, __FILE__, sizeof (memmap));
58 memset (map, ZERO, sizeof (memmap));
64 map->codesp = codemap;
68 map->ptrType = ptrType;
69 if (!(map->oFile = tempfile ()))
71 werror (E_TMPFILE_FAILED);
74 addSetHead (&tmpfileSet, map->oFile);
79 /*-----------------------------------------------------------------*/
80 /* initMem - allocates and initializes all the segments */
81 /*-----------------------------------------------------------------*/
85 /* allocate all the segments */
86 /* xternal stack segment ;
94 POINTER-TYPE - FPOINTER
96 xstack = allocMap (0, 1, 1, 0, 0, 0, options.xstack_loc, XSTACK_NAME, 'A', PPOINTER);
98 /* internal stack segment ;
106 POINTER-TYPE - POINTER
109 istack = allocMap (0, 0, 0, 0, 0, 0, options.stack_loc,
110 ISTACK_NAME, 'B', POINTER);
123 POINTER-TYPE - CPOINTER
125 code = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER);
135 POINTER-TYPE - CPOINTER
137 home = allocMap (0, 1, 0, 0, 0, 1, options.code_loc, CODE_NAME, 'C', CPOINTER);
139 /* Static segment (code for variables );
147 POINTER-TYPE - CPOINTER
149 statsg = allocMap (0, 1, 0, 0, 0, 1, 0, STATIC_NAME, 'D', CPOINTER);
151 /* Data segment - internal storage segment ;
159 POINTER-TYPE - POINTER
161 data = allocMap (0, 0, 0, 1, 0, 0, options.data_loc, DATA_NAME, 'E', POINTER);
163 /* overlay segment - same as internal storage segment ;
171 POINTER-TYPE - POINTER
174 overlay = allocMap (0, 0, 0, 1, 0, 0, options.data_loc, DATA_NAME, 'E', POINTER);
179 /* Xternal paged segment ;
187 POINTER-TYPE - PPOINTER
190 pdata = allocMap (0, 0, 1, 0, 0, 0, options.xstack_loc, PDATA_NAME, 'P', PPOINTER);
195 /* Xternal Data segment -
203 POINTER-TYPE - FPOINTER
205 xdata = allocMap (0, 1, 0, 0, 0, 0, options.xdata_loc, XDATA_NAME, 'F', FPOINTER);
206 xidata = allocMap (0, 1, 0, 0, 0, 0, 0, XIDATA_NAME, 'F', FPOINTER);
207 xinit = allocMap (0, 1, 0, 0, 0, 1, 0, XINIT_NAME, 'C', CPOINTER);
209 /* Indirectly addressed internal data segment
217 POINTER-TYPE - IPOINTER
220 idata = allocMap (0, 0, 0, 0, 0, 0, options.idata_loc,
221 IDATA_NAME, 'G', IPOINTER);
234 POINTER-TYPE - _NONE_
236 bit = allocMap (0, 0, 0, 1, 1, 0, 0, BIT_NAME, 'H', 0);
238 /* Special function register space :-
246 POINTER-TYPE - _NONE_
248 sfr = allocMap (1, 0, 0, 1, 0, 0, 0, REG_NAME, 'I', 0);
258 POINTER-TYPE - _NONE_
260 reg = allocMap (1, 0, 0, 0, 0, 0, 0, REG_NAME, ' ', 0);
270 POINTER-TYPE - _NONE_
272 sfrbit = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, 'J', 0);
282 POINTER-TYPE - EEPPOINTER
284 eeprom = allocMap (0, 1, 0, 0, 0, 0, 0, REG_NAME, 'K', EEPPOINTER);
286 /* the unknown map */
287 generic = allocMap (1, 0, 0, 1, 1, 0, 0, REG_NAME, ' ', GPOINTER);
291 /*-----------------------------------------------------------------*/
292 /* allocIntoSeg - puts a symbol into a memory segment */
293 /*-----------------------------------------------------------------*/
295 allocIntoSeg (symbol * sym)
297 memmap *segment = SPEC_OCLS (sym->etype);
298 addSet (&segment->syms, sym);
301 /*-----------------------------------------------------------------*/
302 /* deleteFromSeg - deletes a symbol from segment used when a var */
303 /* first declared as "extern" then no extern */
304 /*-----------------------------------------------------------------*/
305 void deleteFromSeg(symbol *sym)
307 if (SPEC_OCLS(sym->etype)) {
308 memmap *segment = SPEC_OCLS (sym->etype);
309 deleteSetItem(&segment->syms,sym);
313 /*-----------------------------------------------------------------*/
314 /* allocDefault - assigns the output segment based on SCLASS */
315 /*-----------------------------------------------------------------*/
317 allocDefault (symbol * sym)
319 switch (SPEC_SCLS (sym->etype))
322 SPEC_OCLS (sym->etype) = sfr;
325 SPEC_OCLS (sym->etype) = sfrbit;
330 /* if code change to constant */
331 SPEC_OCLS (sym->etype) = statsg;
334 // should we move this to the initialized data segment?
335 if (port->genXINIT &&
336 sym->ival && (sym->level==0) && !SPEC_ABSA(sym->etype)) {
337 SPEC_OCLS(sym->etype) = xidata;
339 SPEC_OCLS (sym->etype) = xdata;
343 SPEC_OCLS (sym->etype) = data;
346 SPEC_OCLS (sym->etype) = idata;
350 SPEC_OCLS (sym->etype) = pdata;
354 SPEC_OCLS (sym->etype) = bit;
357 SPEC_OCLS (sym->etype) = eeprom;
366 /*-----------------------------------------------------------------*/
367 /* allocGlobal - assigns the output segment to a global var */
368 /*-----------------------------------------------------------------*/
370 allocGlobal (symbol * sym)
373 /* symbol name is internal name */
374 if (!sym->level) /* local statics can come here */
375 SNPRINTF (sym->rname, sizeof(sym->rname),
376 "%s%s", port->fun_prefix, sym->name);
378 /* add it to the operandKey reset */
379 if (!isinSet (operKeyReset, sym)) {
380 addSet(&operKeyReset, sym);
383 /* if this is a literal e.g. enumerated type */
384 /* put it in the data segment & do nothing */
385 if (IS_LITERAL (sym->etype))
387 SPEC_OCLS (sym->etype) = data;
391 /* if this is a function then assign code space */
392 if (IS_FUNC (sym->type))
394 SPEC_OCLS (sym->etype) = code;
395 /* if this is an interrupt service routine
396 then put it in the interrupt service array */
397 if (FUNC_ISISR (sym->type) && !options.noiv
398 && (FUNC_INTNO (sym->type) != INTNO_UNSPEC))
400 if (interrupts[FUNC_INTNO (sym->type)])
401 werror (E_INT_DEFINED,
402 FUNC_INTNO (sym->type),
403 interrupts[FUNC_INTNO (sym->type)]->name);
405 interrupts[FUNC_INTNO (sym->type)] = sym;
407 /* automagically extend the maximum interrupts */
408 if (FUNC_INTNO (sym->type) >= maxInterrupts)
409 maxInterrupts = FUNC_INTNO (sym->type) + 1;
411 /* if it is not compiler defined */
418 /* if this is a bit variable and no storage class */
419 if (SPEC_NOUN (sym->etype) == V_BIT
420 /*&& SPEC_SCLS (sym->etype) == S_BIT*/)
422 SPEC_OCLS (sym->etype) = bit;
427 if(!TARGET_IS_PIC16 || (TARGET_IS_PIC16 && sym->level))
428 /* register storage class ignored changed to FIXED */
429 if (SPEC_SCLS (sym->etype) == S_REGISTER)
430 SPEC_SCLS (sym->etype) = S_FIXED;
432 /* if it is fixed, then allocate depending on the */
433 /* current memory model, same for automatics */
434 if (SPEC_SCLS (sym->etype) == S_FIXED ||
435 (TARGET_IS_PIC16 && (SPEC_SCLS (sym->etype) == S_REGISTER) && (sym->level==0)) ||
436 SPEC_SCLS (sym->etype) == S_AUTO) {
437 if (port->mem.default_globl_map != xdata) {
438 /* set the output class */
439 SPEC_OCLS (sym->etype) = port->mem.default_globl_map;
440 /* generate the symbol */
444 SPEC_SCLS (sym->etype) = S_XDATA;
452 /*-----------------------------------------------------------------*/
453 /* allocParms - parameters are always passed on stack */
454 /*-----------------------------------------------------------------*/
456 allocParms (value * val)
461 for (lval = val; lval; lval = lval->next, pNum++)
464 /* check the declaration */
465 checkDecl (lval->sym, 0);
467 /* if this a register parm then allocate
468 it as a local variable by adding it
469 to the first block we see in the body */
470 if (IS_REGPARM (lval->etype))
473 /* mark it as my parameter */
474 lval->sym->ismyparm = 1;
475 lval->sym->localof = currFunc;
478 /* if automatic variables r 2b stacked */
479 if (options.stackAuto || IFFUNC_ISREENT (currFunc->type))
483 lval->sym->onStack = 1;
485 /* choose which stack 2 use */
486 /* use xternal stack */
487 if (options.useXstack)
489 /* PENDING: stack direction support */
490 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack;
491 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
492 xstackPtr - getSize (lval->type);
493 xstackPtr -= getSize (lval->type);
496 { /* use internal stack */
497 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
498 if (port->stack.direction > 0)
500 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
501 stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) -
502 getSize (lval->type) -
503 (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0);
504 stackPtr -= getSize (lval->type);
508 /* This looks like the wrong order but it turns out OK... */
509 /* PENDING: isr, bank overhead, ... */
510 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
512 ((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) +
513 (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) +
515 stackPtr += getSize (lval->type);
518 allocIntoSeg (lval->sym);
521 { /* allocate them in the automatic space */
522 /* generate a unique name */
523 SNPRINTF (lval->sym->rname, sizeof(lval->sym->rname),
524 "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum);
525 strncpyz (lval->name, lval->sym->rname, sizeof(lval->name));
527 /* if declared in specific storage */
528 if (allocDefault (lval->sym))
530 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype);
534 /* otherwise depending on the memory model
535 note here that we put it into the overlay segment
536 first, we will remove it from the overlay segment
537 after the overlay determination has been done */
538 if (options.model == MODEL_SMALL)
540 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
541 (options.noOverlay ? port->mem.default_local_map
546 SPEC_SCLS (lval->etype) = S_XDATA;
547 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xdata;
549 allocIntoSeg (lval->sym);
556 /*-----------------------------------------------------------------*/
557 /* deallocParms - parameters are always passed on stack */
558 /*-----------------------------------------------------------------*/
560 deallocParms (value * val)
564 for (lval = val; lval; lval = lval->next)
567 /* unmark is myparm */
568 lval->sym->ismyparm = 0;
570 /* delete it from the symbol table */
571 deleteSym (SymbolTab, lval->sym, lval->sym->name);
573 if (!lval->sym->isref)
575 lval->sym->allocreq = 0;
576 werror (W_NO_REFERENCE,
577 currFunc ? currFunc->name : "(unknown)",
578 "function argument", lval->sym->name);
581 /* move the rname if any to the name for both val & sym */
582 /* and leave a copy of it in the symbol table */
583 if (lval->sym->rname[0])
585 char buffer[SDCC_NAME_MAX];
586 strncpyz (buffer, lval->sym->rname, sizeof(buffer));
587 lval->sym = copySymbol (lval->sym);
588 strncpyz (lval->sym->rname, buffer, sizeof(lval->sym->rname));
589 strncpyz (lval->sym->name, buffer, sizeof(lval->sym->name));
590 strncpyz (lval->name, buffer, sizeof(lval->name));
591 addSym (SymbolTab, lval->sym, lval->sym->name,
592 lval->sym->level, lval->sym->block, 1);
593 lval->sym->_isparm = 1;
594 if (!isinSet (operKeyReset, lval->sym)) {
595 addSet(&operKeyReset, lval->sym);
604 /*-----------------------------------------------------------------*/
605 /* allocLocal - allocate local variables */
606 /*-----------------------------------------------------------------*/
608 allocLocal (symbol * sym)
611 /* generate an unique name */
612 SNPRINTF (sym->rname, sizeof(sym->rname),
615 currFunc->name, sym->name, sym->level, sym->block);
618 sym->localof = currFunc;
620 /* if this is a static variable */
621 if (IS_STATIC (sym->etype))
628 /* if volatile then */
629 if (IS_VOLATILE (sym->etype))
632 /* this is automatic */
634 /* if it's to be placed on the stack */
635 if (options.stackAuto || reentrant) {
637 if (options.useXstack) {
638 /* PENDING: stack direction for xstack */
639 SPEC_OCLS (sym->etype) = xstack;
640 SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
641 xstackPtr += getSize (sym->type);
643 SPEC_OCLS (sym->etype) = istack;
644 if (port->stack.direction > 0) {
645 SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
646 stackPtr += getSize (sym->type);
648 stackPtr -= getSize (sym->type);
649 SPEC_STAK (sym->etype) = sym->stack = stackPtr;
656 /* else depending on the storage class specified */
658 /* if this is a function then assign code space */
659 if (IS_FUNC (sym->type))
661 SPEC_OCLS (sym->etype) = code;
665 /* if this is a bit variable and no storage class */
666 if (SPEC_NOUN (sym->etype) == V_BIT
667 && (SPEC_SCLS (sym->etype) == S_BIT))
669 SPEC_OCLS (sym->etype) = bit;
674 if (SPEC_SCLS (sym->etype) == S_DATA)
676 SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
681 if (allocDefault (sym))
686 /* again note that we have put it into the overlay segment
687 will remove and put into the 'data' segment if required after
688 overlay analysis has been done */
689 if (options.model == MODEL_SMALL) {
690 SPEC_OCLS (sym->etype) =
691 (options.noOverlay ? port->mem.default_local_map
694 SPEC_OCLS (sym->etype) = port->mem.default_local_map;
699 /*-----------------------------------------------------------------*/
700 /* deallocLocal - deallocates the local variables */
701 /*-----------------------------------------------------------------*/
703 deallocLocal (symbol * csym)
707 for (sym = csym; sym; sym = sym->next)
712 /* if it is on the stack */
715 if (options.useXstack)
716 xstackPtr -= getSize (sym->type);
718 stackPtr -= getSize (sym->type);
720 /* if not used give a warning */
721 if (!sym->isref && !IS_STATIC (sym->etype))
722 werror (W_NO_REFERENCE,
723 currFunc ? currFunc->name : "(unknown)",
724 "local variable", sym->name);
725 /* now delete it from the symbol table */
726 deleteSym (SymbolTab, sym, sym->name);
730 /*-----------------------------------------------------------------*/
731 /* overlay2data - moves declarations from the overlay seg to data */
732 /*-----------------------------------------------------------------*/
738 for (sym = setFirstItem (overlay->syms); sym;
739 sym = setNextItem (overlay->syms))
742 SPEC_OCLS (sym->etype) = data;
746 setToNull ((void *) &overlay->syms);
750 /*-----------------------------------------------------------------*/
751 /* overlay2Set - will add all symbols from the overlay segment to */
752 /* the set of sets containing the overlable symbols */
753 /*-----------------------------------------------------------------*/
760 for (sym = setFirstItem (overlay->syms); sym;
761 sym = setNextItem (overlay->syms))
767 setToNull ((void *) &overlay->syms);
768 addSet (&ovrSetSets, oset);
772 /*-----------------------------------------------------------------*/
773 /* allocVariables - creates decl & assign storage class for a v */
774 /*-----------------------------------------------------------------*/
776 allocVariables (symbol * symChain)
783 /* go thru the symbol chain */
784 for (sym = symChain; sym; sym = sym->next)
787 /* if this is a typedef then add it */
788 /* to the typedef table */
789 if (IS_TYPEDEF (sym->etype))
791 /* check if the typedef already exists */
792 csym = findSym (TypedefTab, NULL, sym->name);
793 if (csym && csym->level == sym->level)
794 werror (E_DUPLICATE_TYPEDEF, sym->name);
796 SPEC_EXTR (sym->etype) = 0;
797 addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
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))
812 processFuncArgs (csym);
814 /* if register bank specified then update maxRegBank */
815 if (maxRegBank < FUNC_REGBANK (csym->type))
816 maxRegBank = FUNC_REGBANK (csym->type);
817 /*JCF: Mark the register bank as used*/
818 RegBankUsed[FUNC_REGBANK(csym->type)]=1;
821 /* if this is a extern variable then change the */
822 /* level to zero temporarily */
823 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
825 saveLevel = csym->level;
829 /* if this is a literal then it is an enumerated */
830 /* type so need not allocate it space for it */
831 if (IS_LITERAL (sym->etype))
834 /* generate the actual declaration */
839 stack += getSize (csym->type);
844 /* restore the level */
845 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
846 csym->level = saveLevel;
852 /*-----------------------------------------------------------------*/
853 /* redoStackOffsets :- will reassign the values for stack offsets */
854 /*-----------------------------------------------------------------*/
856 redoStackOffsets (void)
862 /* after register allocation is complete we know
863 which variables will need to be assigned space
864 on the stack. We will eliminate those variables
865 which do not have the allocReq flag thus reducing
867 for (sym = setFirstItem (istack->syms); sym;
868 sym = setNextItem (istack->syms))
871 int size = getSize (sym->type);
872 /* nothing to do with parameters so continue */
873 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
876 if (IS_AGGREGATE (sym->type))
878 if (port->stack.direction > 0)
880 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
886 SPEC_STAK (sym->etype) = sym->stack = sPtr;
891 /* if allocation not required then subtract
892 size from overall stack size & continue */
895 currFunc->stack -= size;
896 SPEC_STAK (currFunc->etype) -= size;
900 if (port->stack.direction > 0)
902 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
908 SPEC_STAK (sym->etype) = sym->stack = sPtr;
912 /* do the same for the external stack */
914 for (sym = setFirstItem (xstack->syms); sym;
915 sym = setNextItem (xstack->syms))
918 int size = getSize (sym->type);
919 /* nothing to do with parameters so continue */
920 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
923 if (IS_AGGREGATE (sym->type))
925 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
930 /* if allocation not required then subtract
931 size from overall stack size & continue */
934 currFunc->xstack -= size;
935 SPEC_STAK (currFunc->etype) -= size;
939 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
945 /*-----------------------------------------------------------------*/
946 /* printAllocInfoSeg- print the allocation for a given section */
947 /*-----------------------------------------------------------------*/
949 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
958 for (sym = setFirstItem (map->syms); sym;
959 sym = setNextItem (map->syms))
964 if (sym->localof != func)
967 fprintf (of, ";%-25s Allocated ", sym->name);
969 /* if assigned to registers */
970 if (!sym->allocreq && sym->reqv)
974 sym = OP_SYMBOL (sym->reqv);
975 if (!sym->isspilt || sym->remat)
977 fprintf (of, "to registers ");
978 for (i = 0; i < 4 && sym->regs[i]; i++)
979 fprintf (of, "%s ", port->getRegName (sym->regs[i]));
985 sym = sym->usl.spillLoc;
992 fprintf (of, "to stack - offset %d\n", sym->stack);
996 /* otherwise give rname */
997 fprintf (of, "with name '%s'\n", sym->rname);
1001 /*-----------------------------------------------------------------*/
1002 /* canOverlayLocals - returns true if the local variables can overlayed */
1003 /*-----------------------------------------------------------------*/
1005 canOverlayLocals (eBBlock ** ebbs, int count)
1008 /* if staticAuto is in effect or the current function
1009 being compiled is reentrant or the overlay segment
1010 is empty or no overlay option is in effect then */
1011 if (options.noOverlay ||
1012 options.stackAuto ||
1014 (IFFUNC_ISREENT (currFunc->type) ||
1015 FUNC_ISISR (currFunc->type))) ||
1016 elementsInSet (overlay->syms) == 0)
1020 /* if this is a forces overlay */
1021 if (IFFUNC_ISOVERLAY(currFunc->type)) return TRUE;
1023 /* otherwise do thru the blocks and see if there
1024 any function calls if found then return false */
1025 for (i = 0; i < count; i++)
1029 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1031 if (ic->op == CALL) {
1032 sym_link *ftype = operandType(IC_LEFT(ic));
1033 /* builtins only can use overlays */
1034 if (!IFFUNC_ISBUILTIN(ftype)) return FALSE;
1035 } else if (ic->op == PCALL) return FALSE;
1039 /* no function calls found return TRUE */
1043 /*-----------------------------------------------------------------*/
1044 /* doOverlays - move the overlay segment to appropriate location */
1045 /*-----------------------------------------------------------------*/
1047 doOverlays (eBBlock ** ebbs, int count)
1053 /* check if the parameters and local variables
1054 of this function can be put in the overlay segment
1055 This check is essentially to see if the function
1056 calls any other functions if yes then we cannot
1058 if (canOverlayLocals (ebbs, count))
1059 /* if we can then put the parameters &
1060 local variables in the overlay set */
1063 /* otherwise put them into data where
1068 /*-----------------------------------------------------------------*/
1069 /* printAllocInfo - prints allocation information for a function */
1070 /*-----------------------------------------------------------------*/
1072 printAllocInfo (symbol * func, FILE * of)
1080 /* must be called after register allocation is complete */
1081 fprintf (of, ";------------------------------------------------------------\n");
1082 fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1083 fprintf (of, ";------------------------------------------------------------\n");
1085 printAllocInfoSeg (xstack, func, of);
1086 printAllocInfoSeg (istack, func, of);
1087 printAllocInfoSeg (code, func, of);
1088 printAllocInfoSeg (data, func, of);
1089 printAllocInfoSeg (xdata, func, of);
1090 printAllocInfoSeg (idata, func, of);
1091 printAllocInfoSeg (sfr, func, of);
1092 printAllocInfoSeg (sfrbit, func, of);
1096 set *tempOverlaySyms = overlay->syms;
1098 /* search the set of overlay sets for local variables/parameters */
1099 for (ovrset = setFirstItem (ovrSetSets); ovrset;
1100 ovrset = setNextItem (ovrSetSets))
1102 overlay->syms = ovrset;
1103 printAllocInfoSeg (overlay, func, of);
1105 overlay->syms = tempOverlaySyms;
1108 fprintf (of, ";------------------------------------------------------------\n");