X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCglue.c;h=e8922ec841debb17375afbee0f9e0123c1fdff7f;hb=0f13c644cfaea92c44ee33764cce21da520676f1;hp=4352a468388b973e5111c9ad8e4cf95bb9682641;hpb=8a613badb96477cc4002f624a2ead683bdd4d033;p=fw%2Fsdcc

diff --git a/src/SDCCglue.c b/src/SDCCglue.c
index 4352a468..e8922ec8 100644
--- a/src/SDCCglue.c
+++ b/src/SDCCglue.c
@@ -70,7 +70,7 @@ DEFSETFUNC (rmTmpFiles)
   if (name)
     {
       unlink (name);
-      free (name);
+      Safe_free (name);
     }
   return 0;
 }
@@ -154,9 +154,11 @@ aopLiteral (value * val, int offset)
 static void 
 emitRegularMap (memmap * map, bool addPublics, bool arFlag)
 {
-  symbol *sym, *symIval;
+  symbol *sym;
   ast *ival = NULL;
-  memmap *segment;
+
+  if (!map)
+    return;
 
   if (addPublics)
     {
@@ -170,34 +172,41 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag)
       else
 	tfprintf (map->oFile, "\t!area\n", map->sname);
     }
-
-  /* print the area name */
+ 
   for (sym = setFirstItem (map->syms); sym;
        sym = setNextItem (map->syms))
     {
+      symbol *newSym=NULL;
 
       /* if extern then add it into the extern list */
       if (IS_EXTERN (sym->etype))
 	{
-	  addSetHead (&externs, sym);
+          addSetHead (&externs, sym);
 	  continue;
 	}
 
       /* if allocation required check is needed
          then check if the symbol really requires
          allocation only for local variables */
+
       if (arFlag && !IS_AGGREGATE (sym->type) &&
 	  !(sym->_isparm && !IS_REGPARM (sym->etype)) &&
 	  !sym->allocreq && sym->level)
 	continue;
 
+      /* for bitvar locals and parameters */
+      if (!arFlag && !sym->allocreq && sym->level 
+	  && !SPEC_ABSA (sym->etype)) {
+	continue;
+      }
+
       /* if global variable & not static or extern
          and addPublics allowed then add it to the public set */
       if ((sym->level == 0 ||
 	   (sym->_isparm && !IS_REGPARM (sym->etype))) &&
 	  addPublics &&
 	  !IS_STATIC (sym->etype) &&
-          (IS_FUNC(sym->type) ? (sym->used || sym->fbody) : 1))
+          (IS_FUNC(sym->type) ? (sym->used || IFFUNC_HASBODY(sym->type)) : 1))
 	{
 	  addSetHead (&publics, sym);
 	}
@@ -221,61 +230,86 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag)
 	fprintf (map->oFile, "%s$%d$%d", sym->name, sym->level, sym->block);
       }
       
-      /* if is has an absolute address then generate
-         an equate for this no need to allocate space */
-      if (SPEC_ABSA (sym->etype))
-	{
-	  if (options.debug) {
-	    fprintf (map->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
-	  }
-	  fprintf (map->oFile, "%s\t=\t0x%04x\n",
-		   sym->rname,
-		   SPEC_ADDR (sym->etype));
-	}
-      else
-	{
-	  /* allocate space */
-	  if (options.debug) {
-	    fprintf (map->oFile, "==.\n");
-	  }
-	  if (IS_STATIC (sym->etype))
-	    tfprintf (map->oFile, "!slabeldef\n", sym->rname);
-	  else
-	    tfprintf (map->oFile, "!labeldef\n", sym->rname);
-	  tfprintf (map->oFile, "\t!ds\n", 
-		    (unsigned int) getSize (sym->type) & 0xffff);
-	}
-
       /* if it has an initial value then do it only if
          it is a global variable */
-      if (sym->ival && sym->level == 0)
-	{
+      if (sym->ival && sym->level == 0) {
+	if (SPEC_OCLS(sym->etype)==xidata) {
+	  // create a new "XINIT (CODE)" symbol, that will be emitted later
+	  newSym=copySymbol (sym);
+	  SPEC_OCLS(newSym->etype)=xinit;
+	  sprintf (newSym->name, "__xinit_%s", sym->name);
+	  sprintf (newSym->rname,"__xinit_%s", sym->rname);
+	  SPEC_CONST(newSym->etype)=1;
+	  SPEC_STAT(newSym->etype)=1;
+	  resolveIvalSym(newSym->ival);
+
+	  // add it to the "XINIT (CODE)" segment
+	  addSet(&xinit->syms, newSym);
+	  sym->ival=NULL;
+	} else {
 	  if (IS_AGGREGATE (sym->type)) {
 	    ival = initAggregates (sym, sym->ival, NULL);
 	  } else {
+	    if (getNelements(sym->type, sym->ival)>1) {
+	      werror (W_EXCESS_INITIALIZERS, "scalar", 
+		      sym->name, sym->lineDef);
+	    }
 	    ival = newNode ('=', newAst_VALUE (symbolVal (sym)),
-		     decorateType (resolveSymbols (list2expr (sym->ival))));
+			    decorateType (resolveSymbols (list2expr (sym->ival))));
 	  }
 	  codeOutFile = statsg->oFile;
-	  allocInfo = 0;
-
-	  // set ival's lineno to where the symbol was defined
-	  if (ival) ival->lineno=sym->lineDef;
-	  eBBlockFromiCode (iCodeFromAst (ival));
-	  allocInfo = 1;
-
-	  /* if the ival is a symbol assigned to an aggregate,
-	     (bug #458099 -> #462479)
-	     we don't need it anymore, so delete it from its segment */
-	  if (IS_AST_SYM_VALUE(sym->ival->init.node) &&
-	      IS_AGGREGATE (sym->type) ) {
-	    symIval=AST_SYMBOL(sym->ival->init.node);
-	    segment = SPEC_OCLS (symIval->etype);
-	    deleteSetItem (&segment->syms, symIval);
+
+	  if (ival) {
+	    // set ival's lineno to where the symbol was defined
+	    setAstLineno (ival, lineno=sym->lineDef);
+	    // check if this is not a constant expression
+	    if (!constExprTree(ival)) {
+	      werror (E_CONST_EXPECTED, "found expression");
+	      // but try to do it anyway
+	    }
+	    allocInfo = 0;
+	    eBBlockFromiCode (iCodeFromAst (ival));
+	    allocInfo = 1;
 	  }
+	}	  
+	sym->ival = NULL;
+      }
 
-	  sym->ival = NULL;
+      /* if is has an absolute address then generate
+         an equate for this no need to allocate space */
+      if (SPEC_ABSA (sym->etype))
+	{
+	  char *equ="=";
+	  if (options.debug) {
+	    fprintf (map->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype));
+	  }
+	  if (TARGET_IS_XA51) {
+	    if (map==sfr) {
+	      equ="sfr";
+	    } else if (map==bit || map==sfrbit) {
+	      equ="bit";
+	    }
+	  }
+	  fprintf (map->oFile, "%s\t%s\t0x%04x\n",
+		   sym->rname, equ,
+		   SPEC_ADDR (sym->etype));
 	}
+      else {
+	int size = getSize (sym->type);
+	if (size==0) {
+	  werror(E_UNKNOWN_SIZE,sym->name);
+	}
+	/* allocate space */
+	if (options.debug) {
+	  fprintf (map->oFile, "==.\n");
+	}
+	if (IS_STATIC (sym->etype))
+	  tfprintf (map->oFile, "!slabeldef\n", sym->rname);
+	else
+	  tfprintf (map->oFile, "!labeldef\n", sym->rname);	      
+	tfprintf (map->oFile, "\t!ds\n", 
+		  (unsigned int)  size & 0xffff);
+      }
     }
 }
 
@@ -283,7 +317,7 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag)
 /* initPointer - pointer initialization code massaging             */
 /*-----------------------------------------------------------------*/
 value *
-initPointer (initList * ilist)
+initPointer (initList * ilist, sym_link *toType)
 {
 	value *val;
 	ast *expr = list2expr (ilist);
@@ -295,6 +329,17 @@ initPointer (initList * ilist)
 	if ((val = constExprValue (expr, FALSE)))
 		return val;
 	
+	/* (char *)&a */
+	if (IS_AST_OP(expr) && expr->opval.op==CAST &&
+	    IS_AST_OP(expr->right) && expr->right->opval.op=='&') {
+	  if (compareType(toType, expr->left->ftype)!=1) {
+	    werror (W_INIT_WRONG);
+	    printFromToType(expr->left->ftype, toType);
+	  }
+	  // skip the cast ???
+	  expr=expr->right;
+	}
+
 	/* no then we have to do these cludgy checks */
 	/* pointers can be initialized with address of
 	   a variable or address of an array element */
@@ -338,10 +383,10 @@ initPointer (initList * ilist)
 		   (&some_struct)->element */
 		if (IS_AST_OP (expr->left) &&
 		    expr->left->opval.op == PTR_OP &&
-		    IS_ADDRESS_OF_OP (expr->left->left))
-			return valForStructElem (expr->left->left->left,
-						 expr->left->right);
-
+		    IS_ADDRESS_OF_OP (expr->left->left)) {
+		  return valForStructElem (expr->left->left->left,
+					   expr->left->right);
+		}
 	}
 	/* case 3. (((char *) &a) +/- constant) */
 	if (IS_AST_OP (expr) &&
@@ -511,7 +556,7 @@ printGPointerType (FILE * oFile, const char *iname, const char *oname,
 /* printIvalType - generates ival for int/char                     */
 /*-----------------------------------------------------------------*/
 void 
-printIvalType (sym_link * type, initList * ilist, FILE * oFile)
+printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile)
 {
 	value *val;
 
@@ -519,7 +564,19 @@ printIvalType (sym_link * type, initList * ilist, FILE * oFile)
 	if (ilist->type == INIT_DEEP)
 		ilist = ilist->init.deep;
 
-	val = list2val (ilist);
+	if (!IS_AGGREGATE(sym->type) && getNelements(type, ilist)>1) {
+	  werror (W_EXCESS_INITIALIZERS, "scalar", sym->name, sym->lineDef);
+	}
+
+	if (!(val = list2val (ilist))) {
+	  // assuming a warning has been thrown
+	  val=constVal("0");
+	}
+
+	if (val->type != type) {
+	  val = valCastLiteral(type, floatFromVal(val));
+	}
+	
 	switch (getSize (type)) {
 	case 1:
 		if (!val)
@@ -621,9 +678,12 @@ printIvalStruct (symbol * sym, sym_link * type,
 		if (IS_BITFIELD(sflds->type)) {
 			printIvalBitFields(&sflds,&iloop,oFile);
 		} else {
-			printIval (sflds, sflds->type, iloop, oFile);
+			printIval (sym, sflds->type, iloop, oFile);
 		}
 	}
+	if (iloop) {
+	  werror (W_EXCESS_INITIALIZERS, "struct", sym->name, sym->lineDef);
+	}
 	return;
 }
 
@@ -675,12 +735,16 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist,
   /* take care of the special   case  */
   /* array of characters can be init  */
   /* by a string                      */
-  if (IS_CHAR (type->next))
+  if (IS_CHAR (type->next)) {
+    if (!IS_LITERAL(list2val(ilist)->etype)) {
+      werror (W_INIT_WRONG);
+      return;
+    }
     if (printIvalChar (type,
 		       (ilist->type == INIT_DEEP ? ilist->init.deep : ilist),
 		       oFile, SPEC_CVAL (sym->etype).v_char))
       return;
-
+  }
   /* not the special case             */
   if (ilist->type != INIT_DEEP)
     {
@@ -708,7 +772,7 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist,
       if (!--lcnt) {
 	/* if initializers left */
 	if (iloop) {
-	  werror (W_EXESS_ARRAY_INITIALIZERS, sym->name, sym->lineDef);
+	  werror (W_EXCESS_INITIALIZERS, "array", sym->name, sym->lineDef);
 	}
 	break;
       }
@@ -731,6 +795,16 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile)
   int dLvl = 0;
 
   val = list2val (ilist);
+
+  if (IS_LITERAL(val->etype)) {
+    if (compareType(type,val->etype)==0) {
+      werror (E_INCOMPAT_TYPES);
+      printFromToType (val->type, type);
+    }
+    printIvalCharPtr (NULL, type, val, oFile);
+    return;
+  }
+
   /* check the types   */
   if ((dLvl = compareType (val->type, type->next)) <= 0)
     {
@@ -816,7 +890,7 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile)
     }
   else
     {
-      /* What is this case? Are these pointers? */
+      // these are literals assigned to pointers
       switch (size)
 	{
 	case 1:
@@ -830,9 +904,25 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile)
 		      aopLiteral (val, 0), aopLiteral (val, 1));
 	  break;
 	case 3:
-	  /* PENDING: 0x02 or 0x%02x, CDATA? */
-	  fprintf (oFile, "\t.byte %s,%s,#0x02\n",
-		   aopLiteral (val, 0), aopLiteral (val, 1));
+	  if (IS_GENPTR(type) && floatFromVal(val)!=0) {
+	    // non-zero mcs51 generic pointer
+	    werror (E_LITERAL_GENERIC);
+	  }
+	  fprintf (oFile, "\t.byte %s,%s,%s\n",
+		   aopLiteral (val, 0), 
+		   aopLiteral (val, 1),
+		   aopLiteral (val, 2));
+	  break;
+	case 4:
+	  if (IS_GENPTR(type) && floatFromVal(val)!=0) {
+	    // non-zero ds390 generic pointer
+	    werror (E_LITERAL_GENERIC);
+	  }
+	  fprintf (oFile, "\t.byte %s,%s,%s,%s\n",
+		   aopLiteral (val, 0), 
+		   aopLiteral (val, 1), 
+		   aopLiteral (val, 2),
+		   aopLiteral (val, 3));
 	  break;
 	default:
 	  assert (0);
@@ -866,7 +956,7 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile)
       return;
     }
 
-  if (!(val = initPointer (ilist)))
+  if (!(val = initPointer (ilist, type)))
     return;
 
   /* if character pointer */
@@ -956,7 +1046,7 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile)
   /* if type is SPECIFIER */
   if (IS_SPEC (type))
     {
-      printIvalType (type, ilist, oFile);
+      printIvalType (sym, type, ilist, oFile);
       return;
     }
 }
@@ -969,9 +1059,7 @@ emitStaticSeg (memmap * map, FILE * out)
 {
   symbol *sym;
 
-  /*     fprintf(map->oFile,"\t.area\t%s\n",map->sname); */
-  if (!out)
-    out = code->oFile;
+  /* fprintf(out, "\t.area\t%s\n", map->sname); */
 
   /* for all variables in this segment do */
   for (sym = setFirstItem (map->syms); sym;
@@ -985,7 +1073,9 @@ emitStaticSeg (memmap * map, FILE * out)
       /* if it is not static add it to the public
          table */
       if (!IS_STATIC (sym->etype))
-	addSetHead (&publics, sym);
+        {
+          addSetHead (&publics, sym);
+        }
 
       /* print extra debug info if required */
       if (options.debug) {
@@ -1028,18 +1118,22 @@ emitStaticSeg (memmap * map, FILE * out)
 	      printIval (sym, sym->type, sym->ival, out);
 	      noAlloc--;
 	    }
-	  else
-	    {
+	  else {
 	      /* allocate space */
+	      int size = getSize (sym->type);
+	      
+	      if (size==0) {
+		  werror(E_UNKNOWN_SIZE,sym->name);
+	      }
 	      fprintf (out, "%s:\n", sym->rname);
 	      /* special case for character strings */
 	      if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
 		  SPEC_CVAL (sym->etype).v_char)
-		printChar (out,
-			   SPEC_CVAL (sym->etype).v_char,
-			   strlen (SPEC_CVAL (sym->etype).v_char) + 1);
+		  printChar (out,
+			     SPEC_CVAL (sym->etype).v_char,
+			     strlen (SPEC_CVAL (sym->etype).v_char) + 1);
 	      else
-		tfprintf (out, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff);
+		  tfprintf (out, "\t!ds\n", (unsigned int) size & 0xffff);
 	    }
 	}
     }
@@ -1058,12 +1152,19 @@ emitMaps ()
   emitRegularMap (idata, TRUE, TRUE);
   emitRegularMap (bit, TRUE, FALSE);
   emitRegularMap (xdata, TRUE, TRUE);
+  if (port->genXINIT) {
+    emitRegularMap (xidata, TRUE, TRUE);
+  }
   emitRegularMap (sfr, FALSE, FALSE);
   emitRegularMap (sfrbit, FALSE, FALSE);
   emitRegularMap (home, TRUE, FALSE);
   emitRegularMap (code, TRUE, FALSE);
 
   emitStaticSeg (statsg, code->oFile);
+  if (port->genXINIT) {
+    tfprintf (code->oFile, "\t!area\n", xinit->sname);
+    emitStaticSeg (xinit, code->oFile);
+  }
   inInitMode--;
 }
 
@@ -1097,7 +1198,7 @@ createInterruptVect (FILE * vFile)
     }
 
   /* if the main is only a prototype ie. no body then do nothing */
-  if (!mainf->fbody)
+  if (!IFFUNC_HASBODY(mainf->type))
     {
       /* if ! compile only then main function should be present */
       if (!options.cc_only && !noAssemble)
@@ -1112,7 +1213,6 @@ createInterruptVect (FILE * vFile)
   if (!port->genIVT || !(port->genIVT (vFile, interrupts, maxInterrupts)))
     {
       /* "generic" interrupt table header (if port doesn't specify one).
-
        * Look suspiciously like 8051 code to me...
        */
 
@@ -1184,7 +1284,7 @@ printExterns (FILE * afile)
 
   for (sym = setFirstItem (externs); sym;
        sym = setNextItem (externs))
-    tfprintf (afile, "\t!global\n", sym->rname);
+    tfprintf (afile, "\t!extern\n", sym->rname);
 }
 
 /*-----------------------------------------------------------------*/
@@ -1207,11 +1307,6 @@ emitOverlay (FILE * afile)
 
       if (elementsInSet (ovrset))
 	{
-	  /* this dummy area is used to fool the assembler
-	     otherwise the assembler will append each of these
-	     declarations into one chunk and will not overlay
-	     sad but true */
-	  fprintf (afile, "\t.area _DUMMY\n");
 	  /* output the area informtion */
 	  fprintf (afile, "\t.area\t%s\n", port->mem.overlay_name);	/* MOF */
 	}
@@ -1219,8 +1314,7 @@ emitOverlay (FILE * afile)
       for (sym = setFirstItem (ovrset); sym;
 	   sym = setNextItem (ovrset))
 	{
-
-	  /* if extern then add it to the publics tabledo nothing */
+	  /* if extern then it is in the publics table: do nothing */
 	  if (IS_EXTERN (sym->etype))
 	    continue;
 
@@ -1236,7 +1330,9 @@ emitOverlay (FILE * afile)
 	     and addPublics allowed then add it to the public set */
 	  if ((sym->_isparm && !IS_REGPARM (sym->etype))
 	      && !IS_STATIC (sym->etype))
-	    addSetHead (&publics, sym);
+            {
+              addSetHead (&publics, sym);
+            }
 
 	  /* if extern then do nothing or is a function
 	     then do nothing */
@@ -1274,16 +1370,20 @@ emitOverlay (FILE * afile)
 		       sym->rname,
 		       SPEC_ADDR (sym->etype));
 	    }
-	  else
-	    {
+	  else {
+	      int size = getSize(sym->type);
+
+	      if (size==0) {
+		  werror(E_UNKNOWN_SIZE,sym->name);
+	      }	      
 	      if (options.debug)
-		fprintf (afile, "==.\n");
+		  fprintf (afile, "==.\n");
 	      
 	      /* allocate space */
 	      tfprintf (afile, "!labeldef\n", sym->rname);
 	      tfprintf (afile, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff);
-	    }
-
+	  }
+	  
 	}
     }
 }
@@ -1375,13 +1475,15 @@ glue ()
 
 
   /* create the overlay segments */
-  fprintf (asmFile, "%s", iComments2);
-  fprintf (asmFile, "; overlayable items in internal ram \n");
-  fprintf (asmFile, "%s", iComments2);
-  copyFile (asmFile, ovrFile);
+  if (overlay) {
+    fprintf (asmFile, "%s", iComments2);
+    fprintf (asmFile, "; overlayable items in internal ram \n");
+    fprintf (asmFile, "%s", iComments2);
+    copyFile (asmFile, ovrFile);
+  }
 
   /* create the stack segment MOF */
-  if (mainf && mainf->fbody)
+  if (mainf && IFFUNC_HASBODY(mainf->type))
     {
       fprintf (asmFile, "%s", iComments2);
       fprintf (asmFile, "; Stack segment in internal ram \n");
@@ -1391,10 +1493,12 @@ glue ()
     }
 
   /* create the idata segment */
-  fprintf (asmFile, "%s", iComments2);
-  fprintf (asmFile, "; indirectly addressable internal ram data\n");
-  fprintf (asmFile, "%s", iComments2);
-  copyFile (asmFile, idata->oFile);
+  if (idata) {
+    fprintf (asmFile, "%s", iComments2);
+    fprintf (asmFile, "; indirectly addressable internal ram data\n");
+    fprintf (asmFile, "%s", iComments2);
+    copyFile (asmFile, idata->oFile);
+  }
 
   /* copy the bit segment */
   fprintf (asmFile, "%s", iComments2);
@@ -1403,7 +1507,7 @@ glue ()
   copyFile (asmFile, bit->oFile);
 
   /* if external stack then reserve space of it */
-  if (mainf && mainf->fbody && options.useXstack)
+  if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack)
     {
       fprintf (asmFile, "%s", iComments2);
       fprintf (asmFile, "; external stack \n");
@@ -1419,8 +1523,14 @@ glue ()
   fprintf (asmFile, "%s", iComments2);
   copyFile (asmFile, xdata->oFile);
 
+  /* copy xternal initialized ram data */
+  fprintf (asmFile, "%s", iComments2);
+  fprintf (asmFile, "; external initialized ram data\n");
+  fprintf (asmFile, "%s", iComments2);
+  copyFile (asmFile, xidata->oFile);
+
   /* copy the interrupt vector table */
-  if (mainf && mainf->fbody)
+  if (mainf && IFFUNC_HASBODY(mainf->type))
     {
       fprintf (asmFile, "%s", iComments2);
       fprintf (asmFile, "; interrupt vector \n");
@@ -1443,7 +1553,7 @@ glue ()
   tfprintf (asmFile, "\t!area\n", port->mem.post_static_name);
   tfprintf (asmFile, "\t!area\n", port->mem.static_name);
 
-  if (mainf && mainf->fbody)
+  if (mainf && IFFUNC_HASBODY(mainf->type))
     {
       fprintf (asmFile, "__sdcc_gsinit_startup:\n");
       /* if external stack is specified then the
@@ -1461,7 +1571,7 @@ glue ()
       /* initialise the stack pointer */
       /* if the user specified a value then use it */
       if (options.stack_loc)
-	fprintf (asmFile, "\tmov\tsp,#%d\n", options.stack_loc);
+	fprintf (asmFile, "\tmov\tsp,#%d\n", options.stack_loc & 0xff);
       else
 	/* no: we have to compute it */
       if (!options.stackOnData && maxRegBank <= 3)
@@ -1475,10 +1585,15 @@ glue ()
       fprintf (asmFile, "\tljmp\t__sdcc_program_startup\n");
       fprintf (asmFile, "__sdcc_init_data:\n");
 
+      // if the port can copy the XINIT segment to XISEG
+      if (port->genXINIT) {
+	port->genXINIT(asmFile);
+      }
+
     }
   copyFile (asmFile, statsg->oFile);
 
-  if (port->general.glue_up_main && mainf && mainf->fbody)
+  if (port->general.glue_up_main && mainf && IFFUNC_HASBODY(mainf->type))
     {
       /* This code is generated in the post-static area.
        * This area is guaranteed to follow the static area
@@ -1500,7 +1615,7 @@ glue ()
   fprintf (asmFile, "; code\n");
   fprintf (asmFile, "%s", iComments2);
   tfprintf (asmFile, "\t!areacode\n", CODE_NAME);
-  if (mainf && mainf->fbody)
+  if (mainf && IFFUNC_HASBODY(mainf->type))
     {
 
       /* entry point @ start of CSEG */
@@ -1524,6 +1639,9 @@ glue ()
     }
   copyFile (asmFile, code->oFile);
 
+  if (port->genAssemblerEnd) {
+      port->genAssemblerEnd(asmFile);
+  }
   fclose (asmFile);
   applyToSet (tmpfileSet, closeTmpFiles);
   applyToSet (tmpfileNameSet, rmTmpFiles);
@@ -1538,6 +1656,33 @@ rm_tmpfiles (void)
 }
 #endif
 
+/** Creates a temporary file name a'la tmpnam which avoids the bugs
+    in cygwin wrt c:\tmp.
+    Scans, in order: TMP, TEMP, TMPDIR, else uses tmpfile().
+*/
+char *
+tempfilename (void)
+{
+#if !defined(_MSC_VER)
+  const char *tmpdir = NULL;
+  if (getenv ("TMP"))
+    tmpdir = getenv ("TMP");
+  else if (getenv ("TEMP"))
+    tmpdir = getenv ("TEMP");
+  else if (getenv ("TMPDIR"))
+    tmpdir = getenv ("TMPDIR");
+  if (tmpdir)
+    {
+      char *name = tempnam (tmpdir, "sdcc");
+      if (name)
+	{
+          return name;
+        }
+    }
+#endif
+  return tmpnam (NULL);
+}
+
 /** Creates a temporary file a'la tmpfile which avoids the bugs
     in cygwin wrt c:\tmp.
     Scans, in order: TMP, TEMP, TMPDIR, else uses tmpfile().
@@ -1555,7 +1700,7 @@ tempfile (void)
     tmpdir = getenv ("TMPDIR");
   if (tmpdir)
     {
-      char *name = tempnam (tmpdir, "sdcc");
+      char *name = Safe_strdup( tempnam (tmpdir, "sdcc"));
       if (name)
 	{
 	  FILE *fp = fopen (name, "w+b");
@@ -1571,11 +1716,3 @@ tempfile (void)
   return tmpfile ();
 }
 
-char *
-gc_strdup (const char *s)
-{
-  char *ret;
-  ret = Safe_calloc (1, strlen (s) + 1);
-  strcpy (ret, s);
-  return ret;
-}