* src/SDCCmain.c (linkEdit): Added runtime path detection to the mcs51 port.

[fw/sdcc] / src / SDCCmem.c

diff --git a/src/SDCCmem.c b/src/SDCCmem.c
index a84bceffa89ce0b86145f8492f4894986bfaa057..8b95850638c54e44eb944a71e3201b9b3b27aa75 100644 (file)
--- a/src/SDCCmem.c
+++ b/src/SDCCmem.c
@@ -46,7 +46,7 @@ allocMap (char rspace,                /* sfr space            */
 {
   memmap *map;
 
-  if (!(map = calloc (sizeof (memmap), 1)))
+  if (!(map = Safe_alloc (sizeof (memmap))))
     {
       werror (E_OUT_OF_MEM, __FILE__, sizeof (memmap));
       exit (1);
@@ -291,19 +291,19 @@ allocGlobal (symbol * sym)
       SPEC_OCLS (sym->etype) = code;
       /* if this is an interrupt service routine
          then put it in the interrupt service array */
-      if (IS_ISR (sym->etype))
+      if (FUNC_ISISR (sym->type))
        {
 
-         if (interrupts[SPEC_INTN (sym->etype)])
+         if (interrupts[FUNC_INTNO (sym->type)])
            werror (E_INT_DEFINED,
-                   SPEC_INTN (sym->etype),
-                   interrupts[SPEC_INTN (sym->etype)]->name);
+                   FUNC_INTNO (sym->type),
+                   interrupts[FUNC_INTNO (sym->type)]->name);
          else
-           interrupts[SPEC_INTN (sym->etype)] = sym;
+           interrupts[FUNC_INTNO (sym->type)] = sym;
 
          /* automagically extend the maximum interrupts */
-         if (SPEC_INTN (sym->etype) >= maxInterrupts)
-           maxInterrupts = SPEC_INTN (sym->etype) + 1;
+         if (FUNC_INTNO (sym->type) >= maxInterrupts)
+           maxInterrupts = FUNC_INTNO (sym->type) + 1;
        }
       /* if it is not compiler defined */
       if (!sym->cdef)
@@ -370,6 +370,7 @@ allocGlobal (symbol * sym)
     {
       /* set the output class */
       SPEC_OCLS (sym->etype) = port->mem.default_globl_map;
+      // jwk: we need to set SPEC_SCLS now !!!!
       /* generate the symbol  */
       allocIntoSeg (sym);
       return;
@@ -420,7 +421,7 @@ allocParms (value * val)
     {
 
       /* check the declaration */
-      checkDecl (lval->sym);
+      checkDecl (lval->sym, 0);
 
       /* if this a register parm then allocate
          it as a local variable by adding it
@@ -434,7 +435,7 @@ allocParms (value * val)
 
 
       /* if automatic variables r 2b stacked */
-      if (options.stackAuto || IS_RENT (currFunc->etype))
+      if (options.stackAuto || IFFUNC_ISREENT (currFunc->type))
        {
 
          if (lval->sym)
@@ -456,9 +457,9 @@ allocParms (value * val)
              if (port->stack.direction > 0)
                {
                  SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
-                   stackPtr - (SPEC_BANK (currFunc->etype) ? port->stack.bank_overhead : 0) -
+                   stackPtr - (FUNC_REGBANK (currFunc->type) ? port->stack.bank_overhead : 0) -
                    getSize (lval->type) -
-                   (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0);
+                   (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0);
                  stackPtr -= getSize (lval->type);
                }
              else
@@ -467,8 +468,8 @@ allocParms (value * val)
                  /* PENDING: isr, bank overhead, ... */
                  SPEC_STAK (lval->etype) = SPEC_STAK (lval->sym->etype) = lval->sym->stack =
                    stackPtr +
-                   (IS_BANKEDCALL (currFunc->etype) ? port->stack.banked_overhead : 0) +
-                   (IS_ISR (currFunc->etype) ? port->stack.isr_overhead : 0) +
+                   ((IFFUNC_ISBANKEDCALL (currFunc->type) && !SPEC_STAT(getSpec(currFunc->etype)))? port->stack.banked_overhead : 0) +
+                   (FUNC_ISISR (currFunc->type) ? port->stack.isr_overhead : 0) +
                    0;
                  stackPtr += getSize (lval->type);
                }
@@ -582,35 +583,27 @@ allocLocal (symbol * sym)
   /* this is automatic           */
 
   /* if it to be placed on the stack */
-  if (options.stackAuto || reentrant)
-    {
-
-      sym->onStack = 1;
-      if (options.useXstack)
-       {
-         /* PENDING: stack direction for xstack */
-         SPEC_OCLS (sym->etype) = xstack;
-         SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
-         xstackPtr += getSize (sym->type);
-       }
-      else
-       {
-         SPEC_OCLS (sym->etype) = istack;
-         if (port->stack.direction > 0)
-           {
-             SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
-             stackPtr += getSize (sym->type);
-           }
-         else
-           {
-             stackPtr -= getSize (sym->type);
-             SPEC_STAK (sym->etype) = sym->stack = stackPtr;
-           }
-       }
-      allocIntoSeg (sym);
-      return;
+  if (options.stackAuto || reentrant) {
+    sym->onStack = 1;
+    if (options.useXstack) {
+      /* PENDING: stack direction for xstack */
+      SPEC_OCLS (sym->etype) = xstack;
+      SPEC_STAK (sym->etype) = sym->stack = (xstackPtr + 1);
+      xstackPtr += getSize (sym->type);
+    } else {
+      SPEC_OCLS (sym->etype) = istack;
+      if (port->stack.direction > 0) {
+       SPEC_STAK (sym->etype) = sym->stack = (stackPtr + 1);
+       stackPtr += getSize (sym->type);
+      } else {
+       stackPtr -= getSize (sym->type);
+       SPEC_STAK (sym->etype) = sym->stack = stackPtr;
+      }
     }
-
+    allocIntoSeg (sym);
+    return;
+  }
+  
   /* else depending on the storage class specified */
   if (SPEC_SCLS (sym->etype) == S_XDATA)
     {
@@ -801,7 +794,7 @@ allocVariables (symbol * symChain)
        csym = sym;
 
       /* check the declaration */
-      checkDecl (csym);
+      checkDecl (csym,0);
 
       /* if this is a function or a pointer to function */
       /* then args  processing  */
@@ -810,8 +803,8 @@ allocVariables (symbol * symChain)
 
          processFuncArgs (csym, 1);
          /* if register bank specified then update maxRegBank */
-         if (maxRegBank < SPEC_BANK (csym->etype))
-           maxRegBank = SPEC_BANK (csym->etype);
+         if (maxRegBank < FUNC_REGBANK (csym->type))
+           maxRegBank = FUNC_REGBANK (csym->type);
        }
 
       /* if this is a extern variable then change the */
@@ -938,7 +931,7 @@ redoStackOffsets (void)
 
   /* if the debug option is set then output the
      symbols to the map file */
-  if (options.debug && !options.nodebug)
+  if (options.debug)
     {
       for (sym = setFirstItem (istack->syms); sym;
           sym = setNextItem (istack->syms))
@@ -1010,8 +1003,8 @@ canOverlayLocals (eBBlock ** ebbs, int count)
   if (options.noOverlay ||
       options.stackAuto ||
       (currFunc &&
-       (IS_RENT (currFunc->etype) ||
-       IS_ISR (currFunc->etype))) ||
+       (IFFUNC_ISREENT (currFunc->type) ||
+       FUNC_ISISR (currFunc->type))) ||
       elementsInSet (overlay->syms) == 0)
 
     return FALSE;