X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=20ee30adcab89f68e804eb10fa79a439d9f49173;hb=8b1f2b3651c5172eb88e2c9bca4f1f34dfd7131b;hp=c6cd281a0e6c778db6792c74ba383fa2d00ff002;hpb=8ed6a00ec3d753de14b8ed85bdcf8e2ca37ed5cb;p=fw%2Fsdcc

diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c
index c6cd281a..20ee30ad 100644
--- a/src/SDCCsymt.c
+++ b/src/SDCCsymt.c
@@ -371,7 +371,7 @@ pointerTypes (sym_link * ptr, sym_link * type)
 	  DCL_TYPE (ptr) = EEPPOINTER;
 	  break;
 	default:
-	  DCL_TYPE (ptr) = GPOINTER;
+	  DCL_TYPE (ptr) = port->unqualified_pointer;
 	  break;
 	}
       /* the storage class of type ends here */
@@ -385,7 +385,7 @@ pointerTypes (sym_link * ptr, sym_link * type)
   while (ptr)
     {
       if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
-	DCL_TYPE (ptr) = GPOINTER;
+	DCL_TYPE (ptr) = port->unqualified_pointer;
       ptr = ptr->next;
     }
 
@@ -394,7 +394,7 @@ pointerTypes (sym_link * ptr, sym_link * type)
   while (type)
     {
       if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
-	DCL_TYPE (type) = GPOINTER;
+	DCL_TYPE (type) = port->unqualified_pointer;
       type = type->next;
     }
 
@@ -621,7 +621,10 @@ mergeSpec (sym_link * dest, sym_link * src, char *name)
   SPEC_BLEN (dest) |= SPEC_BLEN (src);
   SPEC_BSTR (dest) |= SPEC_BSTR (src);
   SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
-
+  SPEC_ENUM (dest) |= SPEC_ENUM (src);
+  if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
+      SPEC_ARGREG(dest) = SPEC_ARGREG(src);
+  
   if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
     SPEC_STRUCT (dest) = SPEC_STRUCT (src);
 
@@ -633,6 +636,9 @@ mergeSpec (sym_link * dest, sym_link * src, char *name)
   FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
   FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
   FUNC_ISISR(dest) |= FUNC_ISISR(src);
+  FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
+  FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
+  FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
   FUNC_INTNO(dest) |= FUNC_INTNO(src);
   FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
 
@@ -783,7 +789,13 @@ getSize (sym_link * p)
   switch (DCL_TYPE (p))
     {
     case ARRAY:
-      return DCL_ELEM (p) * getSize (p->next);
+      if (DCL_ELEM(p)) {
+	return DCL_ELEM (p) * getSize (p->next);
+      } else {
+	  //	werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
+	  //	"can not tell the size of an array[]");
+	return 0;
+      }
     case IPOINTER:
     case PPOINTER:
     case POINTER:
@@ -980,6 +992,7 @@ addSymChain (symbol * symHead)
 	  }
 	  /* delete current entry */
 	  deleteSym (SymbolTab, csym, csym->name);
+	  deleteFromSeg(csym);
 	} else {
 	  /* not extern */
 	  werror (E_DUPLICATE, sym->name);
@@ -1018,25 +1031,27 @@ structElemType (sym_link * stype, value * id)
   sym_link *type, *etype;
   sym_link *petype = getSpec (stype);
 
-  if (!fields || !id)
-    return NULL;
+  if (fields && id) {
+    
+    /* look for the id */
+    while (fields)
+      {
+	if (strcmp (fields->rname, id->name) == 0)
+	  {
+	    type = copyLinkChain (fields->type);
+	    etype = getSpec (type);
+	    SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
+				 SPEC_SCLS (etype) : SPEC_SCLS (petype));
+	    return type;
+	  }
+	fields = fields->next;
+      }
+  }
 
-  /* look for the id */
-  while (fields)
-    {
-      if (strcmp (fields->rname, id->name) == 0)
-	{
-	  type = copyLinkChain (fields->type);
-	  etype = getSpec (type);
-	  SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
-			       SPEC_SCLS (etype) : SPEC_SCLS (petype));
-	  return type;
-	}
-      fields = fields->next;
-    }
   werror (E_NOT_MEMBER, id->name);
-
-  return NULL;
+    
+  // the show must go on
+  return newIntLink();
 }
 
 /*------------------------------------------------------------------*/
@@ -1106,13 +1121,6 @@ compStructSize (int su, structdef * sdef)
 	    sum += getSize (loop->type);
 	}
 
-#if 0 // jwk: this is done now in addDecl()
-	/* if function then do the arguments for it */
-	if (funcInChain (loop->type)) {
-	    processFuncArgs (loop);
-	}
-#endif
-
 	loop = loop->next;
 
 	/* if this is not a bitfield but the */
@@ -1165,13 +1173,22 @@ checkSClass (symbol * sym, int isProto)
     }
   
   /* if absolute address given then it mark it as
-     volatile */
-  if (IS_ABSOLUTE (sym->etype))
-    SPEC_VOLATILE (sym->etype) = 1;
+     volatile -- except in the PIC port */
+
+#if !OPT_DISABLE_PIC
+  /* The PIC port uses a different peep hole optimizer based on "pCode" */
+  if (!TARGET_IS_PIC)
+#endif
+
+    if (IS_ABSOLUTE (sym->etype))
+      SPEC_VOLATILE (sym->etype) = 1;
   
+
   /* global variables declared const put into code */
+  /* if no other storage class specified */
   if (sym->level == 0 &&
-      SPEC_CONST (sym->etype)) {
+      SPEC_CONST (sym->etype) &&
+      SPEC_SCLS(sym->etype) == S_FIXED) {
     SPEC_SCLS (sym->etype) = S_CODE;
   }
   
@@ -1293,7 +1310,7 @@ changePointer (symbol * sym)
   for (p = sym->type; p; p = p->next)
     {
       if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
-	DCL_TYPE (p) = GPOINTER;
+	DCL_TYPE (p) = port->unqualified_pointer;
       if (IS_PTR (p) && IS_FUNC (p->next))
 	DCL_TYPE (p) = CPOINTER;
     }
@@ -1410,11 +1427,11 @@ computeType (sym_link * type1, sym_link * type2)
   else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
     rType = copyLinkChain (type1);
   else
-    /* if one of them is a pointer then that
+    /* if one of them is a pointer or array then that
        prevails */
-  if (IS_PTR (type1))
+  if (IS_PTR (type1) || IS_ARRAY (type1))
     rType = copyLinkChain (type1);
-  else if (IS_PTR (type2))
+  else if (IS_PTR (type2) || IS_ARRAY (type2))
     rType = copyLinkChain (type2);
   else if (getSize (type1) > getSize (type2))
     rType = copyLinkChain (type1);
@@ -1586,14 +1603,14 @@ aggregateToPointer (value * val)
 	  } else {
 #if 1
 	    // this happens for (external) function parameters
-	    DCL_TYPE (val->type) = GPOINTER;
+	    DCL_TYPE (val->type) = port->unqualified_pointer;
 #else
 	    if (TARGET_IS_DS390) {
 	      /* The AUTO and REGISTER classes should probably
 	       * also become generic pointers, but I haven't yet
 	       * devised a test case for that.
 	       */
-	      DCL_TYPE (val->type) = GPOINTER;
+	      DCL_TYPE (val->type) = port->unqualified_pointer;
 	      break;
 	    }
 	    if (options.model==MODEL_LARGE) {
@@ -1618,7 +1635,7 @@ aggregateToPointer (value * val)
 	  DCL_TYPE (val->type) = EEPPOINTER;
 	  break;
 	default:
-	  DCL_TYPE (val->type) = GPOINTER;
+	  DCL_TYPE (val->type) = port->unqualified_pointer;
 	}
       
       /* is there is a symbol associated then */
@@ -1672,7 +1689,7 @@ checkFunction (symbol * sym, symbol *csym)
 
   /* check if this function is defined as calleeSaves
      then mark it as such */
-    FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
+  FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
 
   /* if interrupt service routine  */
   /* then it cannot have arguments */
@@ -1684,6 +1701,26 @@ checkFunction (symbol * sym, symbol *csym)
       }
     }
 
+  for (argCnt=1, acargs = FUNC_ARGS(sym->type); 
+       acargs; 
+       acargs=acargs->next, argCnt++) {
+    if (!acargs->sym) { 
+      // this can happen for reentrant functions
+      werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
+      // the show must go on: synthesize a name and symbol
+      sprintf (acargs->name, "_%s_PARM_%d", sym->name, argCnt);
+      acargs->sym = newSymbol (acargs->name, 1);
+      SPEC_OCLS (acargs->etype) = istack;
+      acargs->sym->type = copyLinkChain (acargs->type);
+      acargs->sym->etype = getSpec (acargs->sym->type);
+      acargs->sym->_isparm = 1;
+      strcpy (acargs->sym->rname, acargs->name);
+    } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) { 
+      // synthesized name
+      werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
+    }
+  }
+
   if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
     return 1;			/* not defined nothing more to check  */
 
@@ -1762,6 +1799,7 @@ checkFunction (symbol * sym, symbol *csym)
   /* replace with this defition */
   sym->cdef = csym->cdef;
   deleteSym (SymbolTab, csym, csym->name);
+  deleteFromSeg(csym);
   addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
   if (IS_EXTERN (csym->etype) && !
       IS_EXTERN (sym->etype))
@@ -1791,7 +1829,7 @@ processFuncArgs (symbol * func)
 
   /* if this function has variable argument list */
   /* then make the function a reentrant one    */
-  if (IFFUNC_HASVARARGS(funcType))
+  if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
     FUNC_ISREENT(funcType)=1;
 
   /* check if this function is defined as calleeSaves
@@ -1814,13 +1852,17 @@ processFuncArgs (symbol * func)
   /* change it to pointer to the same type */
   while (val)
     {
+	int argreg = 0;
       /* mark it as a register parameter if
          the function does not have VA_ARG
          and as port dictates */
       if (!IFFUNC_HASVARARGS(funcType) &&
-	  (*port->reg_parm) (val->type))
+	  (argreg = (*port->reg_parm) (val->type)))
 	{
 	  SPEC_REGPARM (val->etype) = 1;
+	  SPEC_ARGREG(val->etype) = argreg;
+	} else if (IFFUNC_ISREENT(funcType)) {
+	    FUNC_HASSTACKPARM(funcType) = 1;
 	}
 
       if (IS_AGGREGATE (val->type))
@@ -1855,7 +1897,6 @@ processFuncArgs (symbol * func)
       /* synthesize a variable name */
       if (!val->sym)
 	{
-
 	  sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
 	  val->sym = newSymbol (val->name, 1);
 	  SPEC_OCLS (val->etype) = port->mem.default_local_map;
@@ -1943,7 +1984,9 @@ printTypeChain (sym_link * start, FILE * of)
 	  switch (DCL_TYPE (type))
 	    {
 	    case FUNCTION:
-	      fprintf (of, "function ");
+	      fprintf (of, "function %s %s", 
+		       (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
+		       (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
 	      break;
 	    case GPOINTER:
 	      if (DCL_PTR_CONST (type))
@@ -1987,7 +2030,11 @@ printTypeChain (sym_link * start, FILE * of)
 	      fprintf (of, "unkown * ");
 	      break;
 	    case ARRAY:
-	      fprintf (of, "[] ");
+	      if (DCL_ELEM(type)) {
+		fprintf (of, "[%d] ", DCL_ELEM(type));
+	      } else {
+		fprintf (of, "[] ");
+	      }
 	      break;
 	    }
 	}
@@ -2016,7 +2063,6 @@ printTypeChain (sym_link * start, FILE * of)
 	    fprintf (of, "unsigned ");
 	  if (SPEC_CONST (type))
 	    fprintf (of, "const ");
-
 	  switch (SPEC_NOUN (type))
 	    {
 	    case V_INT:
@@ -2327,6 +2373,111 @@ _mangleFunctionName(char *in)
     }
 }
 
+/*-----------------------------------------------------------------*/
+/* typeFromStr - create a typechain from an encoded string         */
+/* basic types - 	'c' - char            			   */
+/*   			's' - short				   */
+/* 			'i' - int                                  */
+/* 			'l' - long                                 */
+/*                      'f' - float				   */
+/*                      'v' - void				   */
+/*                      '*' - pointer - default (GPOINTER)	   */
+/* modifiers -          'u' - unsigned                             */
+/* pointer modifiers -  'g' - generic                              */
+/*                      'x' - xdata                                */
+/*                      'p' - code                                 */
+/*                      'd' - data                                 */                     
+/*                      'F' - function                             */                     
+/* examples : "ig*" - generic int *				   */
+/*            "cx*" - char xdata *                                 */
+/*            "ui" -  unsigned int                                 */
+/*-----------------------------------------------------------------*/
+sym_link *typeFromStr (char *s)
+{
+    sym_link *r = newLink();
+    int usign = 0;
+
+    do {
+	sym_link *nr;
+	switch (*s) {
+	case 'u' : 
+	    usign = 1;
+	    s++;
+	    continue ;
+	    break ;
+	case 'c':
+	    r->class = SPECIFIER;
+	    SPEC_NOUN(r) = V_CHAR;
+	    break;
+	case 's':
+	case 'i':
+	    r->class = SPECIFIER;
+	    SPEC_NOUN(r) = V_INT;
+	    break;
+	case 'l':
+	    r->class = SPECIFIER;
+	    SPEC_NOUN(r) = V_INT;
+	    SPEC_LONG(r) = 1;
+	    break;
+	case 'f':
+	    r->class = SPECIFIER;
+	    SPEC_NOUN(r) = V_FLOAT;
+	    break;
+	case 'v':
+	    r->class = SPECIFIER;
+	    SPEC_NOUN(r) = V_VOID;
+	    break;
+	case '*':
+	    DCL_TYPE(r) = port->unqualified_pointer;
+	    break;
+	case 'g':
+	case 'x':
+	case 'p':
+	case 'd':
+	case 'F':
+	    assert(*(s+1)=='*');
+	    nr = newLink();
+	    nr->next = r;
+	    r = nr;
+	    r->class = DECLARATOR ;
+	    switch (*s) {
+	    case 'g':
+		DCL_TYPE(r) = GPOINTER;
+		break;
+	    case 'x':
+		DCL_TYPE(r) = FPOINTER;
+		break;
+	    case 'p':
+		DCL_TYPE(r) = CPOINTER;
+		break;
+	    case 'd':
+		DCL_TYPE(r) = POINTER;
+		break;
+	    case 'F':
+		DCL_TYPE(r) = FUNCTION;
+		nr = newLink();
+		nr->next = r;
+		r = nr;
+		r->class = DECLARATOR ;
+		DCL_TYPE(r) = CPOINTER;
+		break;
+	    }
+	    s++;
+	    break;
+	default:
+	    werror(E_INTERNAL_ERROR, __FILE__, __LINE__, 
+		   "typeFromStr: unknown type");
+	    break;
+	}
+	if (IS_SPEC(r) && usign) {
+	    SPEC_USIGN(r) = 1;
+	    usign = 0;
+	}
+	s++;
+    } while (*s);
+    return r;
+}
+
 /*-----------------------------------------------------------------*/
 /* initCSupport - create functions for C support routines          */
 /*-----------------------------------------------------------------*/
@@ -2401,12 +2552,12 @@ initCSupport ()
 	      if (tofrom)
 		{
 		  sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
-		  __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent);
+		  __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
 		}
 	      else
 		{
 		  sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
-		  __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent);
+		  __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
 		}
 	    }
 	}
@@ -2444,3 +2595,21 @@ initCSupport ()
 	}
     }
 }
+
+/*-----------------------------------------------------------------*/
+/* initBuiltIns - create prototypes for builtin functions          */
+/*-----------------------------------------------------------------*/
+void initBuiltIns()
+{
+    int i;
+    symbol *sym;
+
+    if (!port->builtintable) return ;
+
+    for (i = 0 ; port->builtintable[i].name ; i++) {
+	sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
+			     port->builtintable[i].nParms,port->builtintable[i].parm_types);
+	FUNC_ISBUILTIN(sym->type) = 1;
+	FUNC_ISREENT(sym->type) = 0;	/* can never be reentrant */
+    }
+}