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);
299 if (segment == pdata)
303 /*-----------------------------------------------------------------*/
304 /* deleteFromSeg - deletes a symbol from segment used when a var */
305 /* first declared as "extern" then no extern */
306 /*-----------------------------------------------------------------*/
307 void deleteFromSeg(symbol *sym)
309 if (SPEC_OCLS(sym->etype)) {
310 memmap *segment = SPEC_OCLS (sym->etype);
311 deleteSetItem(&segment->syms,sym);
315 /*-----------------------------------------------------------------*/
316 /* allocDefault - assigns the output segment based on SCLASS */
317 /*-----------------------------------------------------------------*/
319 allocDefault (symbol * sym)
321 switch (SPEC_SCLS (sym->etype))
324 SPEC_OCLS (sym->etype) = sfr;
327 SPEC_OCLS (sym->etype) = sfrbit;
332 /* if code change to constant */
333 SPEC_OCLS (sym->etype) = statsg;
336 // should we move this to the initialized data segment?
337 if (port->genXINIT &&
338 sym->ival && (sym->level==0) && !SPEC_ABSA(sym->etype)) {
339 SPEC_OCLS(sym->etype) = xidata;
341 SPEC_OCLS (sym->etype) = xdata;
345 SPEC_OCLS (sym->etype) = data;
348 SPEC_OCLS (sym->etype) = idata;
352 SPEC_OCLS (sym->etype) = pdata;
356 SPEC_OCLS (sym->etype) = bit;
359 SPEC_OCLS (sym->etype) = eeprom;
368 /*-----------------------------------------------------------------*/
369 /* allocGlobal - assigns the output segment to a global var */
370 /*-----------------------------------------------------------------*/
372 allocGlobal (symbol * sym)
375 /* symbol name is internal name */
376 if (!sym->level) /* local statics can come here */
377 SNPRINTF (sym->rname, sizeof(sym->rname),
378 "%s%s", port->fun_prefix, sym->name);
380 /* add it to the operandKey reset */
381 if (!isinSet (operKeyReset, sym)) {
382 addSet(&operKeyReset, sym);
385 /* if this is a literal e.g. enumerated type */
386 /* put it in the data segment & do nothing */
387 if (IS_LITERAL (sym->etype))
389 SPEC_OCLS (sym->etype) = data;
393 /* if this is a function then assign code space */
394 if (IS_FUNC (sym->type))
396 SPEC_OCLS (sym->etype) = code;
397 /* if this is an interrupt service routine
398 then put it in the interrupt service array */
399 if (FUNC_ISISR (sym->type) && !options.noiv
400 && (FUNC_INTNO (sym->type) != INTNO_UNSPEC))
402 if (interrupts[FUNC_INTNO (sym->type)])
403 werror (E_INT_DEFINED,
404 FUNC_INTNO (sym->type),
405 interrupts[FUNC_INTNO (sym->type)]->name);
407 interrupts[FUNC_INTNO (sym->type)] = sym;
409 /* automagically extend the maximum interrupts */
410 if (FUNC_INTNO (sym->type) >= maxInterrupts)
411 maxInterrupts = FUNC_INTNO (sym->type) + 1;
413 /* if it is not compiler defined */
420 /* if this is a bit variable and no storage class */
421 if (IS_SPEC(sym->type) && SPEC_NOUN (sym->type) == V_BIT)
422 /*&& SPEC_SCLS (sym->etype) == S_BIT*/
424 SPEC_OCLS (sym->type) = bit;
429 if(!TARGET_IS_PIC16 || (TARGET_IS_PIC16 && sym->level))
430 /* register storage class ignored changed to FIXED */
431 if (SPEC_SCLS (sym->etype) == S_REGISTER)
432 SPEC_SCLS (sym->etype) = S_FIXED;
434 /* if it is fixed, then allocate depending on the */
435 /* current memory model, same for automatics */
436 if (SPEC_SCLS (sym->etype) == S_FIXED ||
437 (TARGET_IS_PIC16 && (SPEC_SCLS (sym->etype) == S_REGISTER) && (sym->level==0)) ||
438 SPEC_SCLS (sym->etype) == S_AUTO) {
439 if (port->mem.default_globl_map != xdata) {
440 /* set the output class */
441 SPEC_OCLS (sym->etype) = port->mem.default_globl_map;
442 /* generate the symbol */
446 SPEC_SCLS (sym->etype) = S_XDATA;
454 /*-----------------------------------------------------------------*/
455 /* allocParms - parameters are always passed on stack */
456 /*-----------------------------------------------------------------*/
458 allocParms (value * val)
463 for (lval = val; lval; lval = lval->next, pNum++)
466 /* check the declaration */
467 checkDecl (lval->sym, 0);
469 /* if this a register parm then allocate
470 it as a local variable by adding it
471 to the first block we see in the body */
472 if (IS_REGPARM (lval->etype))
475 /* mark it as my parameter */
476 lval->sym->ismyparm = 1;
477 lval->sym->localof = currFunc;
480 /* if automatic variables r 2b stacked */
481 if (options.stackAuto || IFFUNC_ISREENT (currFunc->type))
485 lval->sym->onStack = 1;
487 /* choose which stack 2 use */
488 /* use xternal stack */
489 if (options.useXstack)
491 /* PENDING: stack direction support */
492 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = xstack;
493 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
494 xstackPtr - getSize (lval->type);
495 xstackPtr -= getSize (lval->type);
498 { /* use internal stack */
499 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) = istack;
500 if (port->stack.direction > 0)
502 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
503 stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) -
504 getSize (lval->type) -
505 (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0);
506 stackPtr -= getSize (lval->type);
510 /* This looks like the wrong order but it turns out OK... */
511 /* PENDING: isr, bank overhead, ... */
512 SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
514 ((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) +
515 (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) +
517 stackPtr += getSize (lval->type);
520 allocIntoSeg (lval->sym);
523 { /* allocate them in the automatic space */
524 /* generate a unique name */
525 SNPRINTF (lval->sym->rname, sizeof(lval->sym->rname),
526 "%s%s_PARM_%d", port->fun_prefix, currFunc->name, pNum);
527 strncpyz (lval->name, lval->sym->rname, sizeof(lval->name));
529 /* if declared in specific storage */
530 if (allocDefault (lval->sym))
532 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype);
536 /* otherwise depending on the memory model */
537 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
538 port->mem.default_local_map;
539 if (options.model == MODEL_SMALL)
541 /* note here that we put it into the overlay segment
542 first, we will remove it from the overlay segment
543 after the overlay determination has been done */
544 if (!options.noOverlay)
546 SPEC_OCLS (lval->etype) = SPEC_OCLS (lval->sym->etype) =
550 else if (options.model == MODEL_MEDIUM)
552 SPEC_SCLS (lval->etype) = S_PDATA;
556 SPEC_SCLS (lval->etype) = S_XDATA;
558 allocIntoSeg (lval->sym);
565 /*-----------------------------------------------------------------*/
566 /* deallocParms - parameters are always passed on stack */
567 /*-----------------------------------------------------------------*/
569 deallocParms (value * val)
573 for (lval = val; lval; lval = lval->next)
576 /* unmark is myparm */
577 lval->sym->ismyparm = 0;
579 /* delete it from the symbol table */
580 deleteSym (SymbolTab, lval->sym, lval->sym->name);
582 if (!lval->sym->isref)
584 lval->sym->allocreq = 0;
585 werror (W_NO_REFERENCE,
586 currFunc ? currFunc->name : "(unknown)",
587 "function argument", lval->sym->name);
590 /* move the rname if any to the name for both val & sym */
591 /* and leave a copy of it in the symbol table */
592 if (lval->sym->rname[0])
594 char buffer[SDCC_NAME_MAX];
595 strncpyz (buffer, lval->sym->rname, sizeof(buffer));
596 lval->sym = copySymbol (lval->sym);
597 strncpyz (lval->sym->rname, buffer, sizeof(lval->sym->rname));
598 strncpyz (lval->sym->name, buffer, sizeof(lval->sym->name));
599 strncpyz (lval->name, buffer, sizeof(lval->name));
600 addSym (SymbolTab, lval->sym, lval->sym->name,
601 lval->sym->level, lval->sym->block, 1);
602 lval->sym->_isparm = 1;
603 if (!isinSet (operKeyReset, lval->sym)) {
604 addSet(&operKeyReset, lval->sym);
613 /*-----------------------------------------------------------------*/
614 /* allocLocal - allocate local variables */
615 /*-----------------------------------------------------------------*/
617 allocLocal (symbol * sym)
620 /* generate an unique name */
621 SNPRINTF (sym->rname, sizeof(sym->rname),
624 currFunc->name, sym->name, sym->level, sym->block);
627 sym->localof = currFunc;
629 /* if this is a static variable */
630 if (IS_STATIC (sym->etype))
637 /* if volatile then */
638 if (IS_VOLATILE (sym->etype))
641 /* this is automatic */
643 /* if it's to be placed on the stack */
644 if (options.stackAuto || reentrant) {
646 if (options.useXstack) {
647 /* PENDING: stack direction for xstack */
648 SPEC_OCLS (sym->etype) = xstack;
649 SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
650 xstackPtr += getSize (sym->type);
652 SPEC_OCLS (sym->etype) = istack;
653 if (port->stack.direction > 0) {
654 SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
655 stackPtr += getSize (sym->type);
657 stackPtr -= getSize (sym->type);
658 SPEC_STAK (sym->etype) = sym->stack = stackPtr;
665 /* else depending on the storage class specified */
667 /* if this is a function then assign code space */
668 if (IS_FUNC (sym->type))
670 SPEC_OCLS (sym->etype) = code;
674 /* if this is a bit variable and no storage class */
675 if (IS_SPEC(sym->type) && SPEC_NOUN (sym->type) == V_BIT)
677 SPEC_SCLS (sym->type) = S_BIT;
678 SPEC_OCLS (sym->type) = bit;
683 if (SPEC_SCLS (sym->etype) == S_DATA)
685 SPEC_OCLS (sym->etype) = (options.noOverlay ? data : overlay);
690 if (allocDefault (sym))
695 /* again note that we have put it into the overlay segment
696 will remove and put into the 'data' segment if required after
697 overlay analysis has been done */
698 if (options.model == MODEL_SMALL) {
699 SPEC_OCLS (sym->etype) =
700 (options.noOverlay ? port->mem.default_local_map
703 SPEC_OCLS (sym->etype) = port->mem.default_local_map;
708 /*-----------------------------------------------------------------*/
709 /* deallocLocal - deallocates the local variables */
710 /*-----------------------------------------------------------------*/
712 deallocLocal (symbol * csym)
716 for (sym = csym; sym; sym = sym->next)
721 /* if it is on the stack */
724 if (options.useXstack)
725 xstackPtr -= getSize (sym->type);
727 stackPtr -= getSize (sym->type);
729 /* if not used give a warning */
730 if (!sym->isref && !IS_STATIC (sym->etype))
731 werror (W_NO_REFERENCE,
732 currFunc ? currFunc->name : "(unknown)",
733 "local variable", sym->name);
734 /* now delete it from the symbol table */
735 deleteSym (SymbolTab, sym, sym->name);
739 /*-----------------------------------------------------------------*/
740 /* overlay2data - moves declarations from the overlay seg to data */
741 /*-----------------------------------------------------------------*/
747 for (sym = setFirstItem (overlay->syms); sym;
748 sym = setNextItem (overlay->syms))
751 SPEC_OCLS (sym->etype) = data;
755 setToNull ((void *) &overlay->syms);
759 /*-----------------------------------------------------------------*/
760 /* overlay2Set - will add all symbols from the overlay segment to */
761 /* the set of sets containing the overlable symbols */
762 /*-----------------------------------------------------------------*/
769 for (sym = setFirstItem (overlay->syms); sym;
770 sym = setNextItem (overlay->syms))
776 setToNull ((void *) &overlay->syms);
777 addSet (&ovrSetSets, oset);
781 /*-----------------------------------------------------------------*/
782 /* allocVariables - creates decl & assign storage class for a v */
783 /*-----------------------------------------------------------------*/
785 allocVariables (symbol * symChain)
792 /* go thru the symbol chain */
793 for (sym = symChain; sym; sym = sym->next)
796 /* if this is a typedef then add it */
797 /* to the typedef table */
798 if (IS_TYPEDEF (sym->etype))
800 /* check if the typedef already exists */
801 csym = findSym (TypedefTab, NULL, sym->name);
802 if (csym && csym->level == sym->level)
803 werror (E_DUPLICATE_TYPEDEF, sym->name);
805 SPEC_EXTR (sym->etype) = 0;
806 addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
807 continue; /* go to the next one */
809 /* make sure it already exist */
810 csym = findSymWithLevel (SymbolTab, sym);
811 if (!csym || (csym && csym->level != sym->level))
814 /* check the declaration */
817 /* if this is a function or a pointer to function */
818 /* then args processing */
819 if (funcInChain (csym->type))
821 processFuncArgs (csym);
823 /* if register bank specified then update maxRegBank */
824 if (maxRegBank < FUNC_REGBANK (csym->type))
825 maxRegBank = FUNC_REGBANK (csym->type);
826 /*JCF: Mark the register bank as used*/
827 RegBankUsed[FUNC_REGBANK(csym->type)]=1;
830 /* if this is a extern variable then change the */
831 /* level to zero temporarily */
832 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
834 saveLevel = csym->level;
838 /* if this is a literal then it is an enumerated */
839 /* type so need not allocate it space for it */
840 if (IS_LITERAL (sym->etype))
843 /* generate the actual declaration */
848 stack += getSize (csym->type);
853 /* restore the level */
854 if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
855 csym->level = saveLevel;
861 /*-----------------------------------------------------------------*/
862 /* redoStackOffsets :- will reassign the values for stack offsets */
863 /*-----------------------------------------------------------------*/
865 redoStackOffsets (void)
871 /* after register allocation is complete we know
872 which variables will need to be assigned space
873 on the stack. We will eliminate those variables
874 which do not have the allocReq flag thus reducing
876 for (sym = setFirstItem (istack->syms); sym;
877 sym = setNextItem (istack->syms))
880 int size = getSize (sym->type);
881 /* nothing to do with parameters so continue */
882 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
885 if (IS_AGGREGATE (sym->type))
887 if (port->stack.direction > 0)
889 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
895 SPEC_STAK (sym->etype) = sym->stack = sPtr;
900 /* if allocation not required then subtract
901 size from overall stack size & continue */
904 currFunc->stack -= size;
905 SPEC_STAK (currFunc->etype) -= size;
909 if (port->stack.direction > 0)
911 SPEC_STAK (sym->etype) = sym->stack = (sPtr + 1);
917 SPEC_STAK (sym->etype) = sym->stack = sPtr;
921 /* do the same for the external stack */
923 for (sym = setFirstItem (xstack->syms); sym;
924 sym = setNextItem (xstack->syms))
927 int size = getSize (sym->type);
928 /* nothing to do with parameters so continue */
929 if ((sym->_isparm && !IS_REGPARM (sym->etype)))
932 if (IS_AGGREGATE (sym->type))
934 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
939 /* if allocation not required then subtract
940 size from overall stack size & continue */
943 currFunc->xstack -= size;
944 SPEC_STAK (currFunc->etype) -= size;
948 SPEC_STAK (sym->etype) = sym->stack = (xsPtr + 1);
954 /*-----------------------------------------------------------------*/
955 /* printAllocInfoSeg- print the allocation for a given section */
956 /*-----------------------------------------------------------------*/
958 printAllocInfoSeg (memmap * map, symbol * func, FILE * of)
967 for (sym = setFirstItem (map->syms); sym;
968 sym = setNextItem (map->syms))
973 if (sym->localof != func)
976 fprintf (of, ";%-25s Allocated ", sym->name);
978 /* if assigned to registers */
979 if (!sym->allocreq && sym->reqv)
983 sym = OP_SYMBOL (sym->reqv);
984 if (!sym->isspilt || sym->remat)
986 fprintf (of, "to registers ");
987 for (i = 0; i < 4 && sym->regs[i]; i++)
988 fprintf (of, "%s ", port->getRegName (sym->regs[i]));
994 sym = sym->usl.spillLoc;
1001 fprintf (of, "to stack - offset %d\n", sym->stack);
1005 /* otherwise give rname */
1006 fprintf (of, "with name '%s'\n", sym->rname);
1010 /*-----------------------------------------------------------------*/
1011 /* canOverlayLocals - returns true if the local variables can overlayed */
1012 /*-----------------------------------------------------------------*/
1014 canOverlayLocals (eBBlock ** ebbs, int count)
1017 /* if staticAuto is in effect or the current function
1018 being compiled is reentrant or the overlay segment
1019 is empty or no overlay option is in effect then */
1020 if (options.noOverlay ||
1021 options.stackAuto ||
1023 (IFFUNC_ISREENT (currFunc->type) ||
1024 FUNC_ISISR (currFunc->type))) ||
1025 elementsInSet (overlay->syms) == 0)
1029 /* if this is a forces overlay */
1030 if (IFFUNC_ISOVERLAY(currFunc->type)) return TRUE;
1032 /* otherwise do thru the blocks and see if there
1033 any function calls if found then return false */
1034 for (i = 0; i < count; i++)
1038 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1040 if (ic->op == CALL) {
1041 sym_link *ftype = operandType(IC_LEFT(ic));
1042 /* builtins only can use overlays */
1043 if (!IFFUNC_ISBUILTIN(ftype)) return FALSE;
1044 } else if (ic->op == PCALL) return FALSE;
1048 /* no function calls found return TRUE */
1052 /*-----------------------------------------------------------------*/
1053 /* doOverlays - move the overlay segment to appropriate location */
1054 /*-----------------------------------------------------------------*/
1056 doOverlays (eBBlock ** ebbs, int count)
1062 /* check if the parameters and local variables
1063 of this function can be put in the overlay segment
1064 This check is essentially to see if the function
1065 calls any other functions if yes then we cannot
1067 if (canOverlayLocals (ebbs, count))
1068 /* if we can then put the parameters &
1069 local variables in the overlay set */
1072 /* otherwise put them into data where
1077 /*-----------------------------------------------------------------*/
1078 /* printAllocInfo - prints allocation information for a function */
1079 /*-----------------------------------------------------------------*/
1081 printAllocInfo (symbol * func, FILE * of)
1089 /* must be called after register allocation is complete */
1090 fprintf (of, ";------------------------------------------------------------\n");
1091 fprintf (of, ";Allocation info for local variables in function '%s'\n", func->name);
1092 fprintf (of, ";------------------------------------------------------------\n");
1094 printAllocInfoSeg (xstack, func, of);
1095 printAllocInfoSeg (istack, func, of);
1096 printAllocInfoSeg (code, func, of);
1097 printAllocInfoSeg (data, func, of);
1098 printAllocInfoSeg (xdata, func, of);
1099 printAllocInfoSeg (idata, func, of);
1100 printAllocInfoSeg (sfr, func, of);
1101 printAllocInfoSeg (sfrbit, func, of);
1105 set *tempOverlaySyms = overlay->syms;
1107 /* search the set of overlay sets for local variables/parameters */
1108 for (ovrset = setFirstItem (ovrSetSets); ovrset;
1109 ovrset = setNextItem (ovrSetSets))
1111 overlay->syms = ovrset;
1112 printAllocInfoSeg (overlay, func, of);
1114 overlay->syms = tempOverlaySyms;
1117 fprintf (of, ";------------------------------------------------------------\n");