git.gag.com Git - fw/sdcc/blob - src/SDCCsymt.c

   1 /*-------------------------------------------------------------------------
   2   SDCCsymt.c - Code file for Symbols table related structures and MACRO's.
   3         Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   4
   5    This program is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; either version 2, or (at your option) any
   8    later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19    In other words, you are welcome to use, share and improve this program.
  20    You are forbidden to forbid anyone else to use, share and improve
  21    what you give them.   Help stamp out software-hoarding!
  22 -------------------------------------------------------------------------*/
  23
  24 #include "common.h"
  25 #include "newalloc.h"
  26 #include "dbuf_string.h"
  27
  28 #include "SDCCsymt.h"
  29
  30 value *aggregateToPointer (value *val);
  31 void printTypeChainRaw (sym_link * start, FILE * of);
  32
  33 void printFromToType(sym_link *from, sym_link *to) {
  34   fprintf (stderr, "from type '");
  35   printTypeChain (from, stderr);
  36   fprintf (stderr, "'\nto type '");
  37   printTypeChain (to, stderr);
  38   fprintf (stderr, "'\n");
  39 }
  40
  41 /* noun strings */
  42 char *nounName(sym_link *sl) {
  43   switch (SPEC_NOUN(sl))
  44     {
  45     case V_INT: {
  46       if (SPEC_LONG(sl)) return "long";
  47       if (SPEC_SHORT(sl)) return "short";
  48       return "int";
  49     }
  50     case V_FLOAT: return "float";
  51     case V_FIXED16X16: return "fixed16x16";
  52     case V_CHAR: return "char";
  53     case V_VOID: return "void";
  54     case V_STRUCT: return "struct";
  55     case V_LABEL: return "label";
  56     case V_BITFIELD: return "bitfield";
  57     case V_BIT: return "bit";
  58     case V_SBIT: return "sbit";
  59     case V_DOUBLE: return "double";
  60     }
  61   return "unknown";
  62 };
  63
  64 bucket *SymbolTab[256];         /* the symbol    table  */
  65 bucket *StructTab[256];         /* the structure table  */
  66 bucket *TypedefTab[256];        /* the typedef   table  */
  67 bucket *LabelTab[256];          /* the Label     table  */
  68 bucket *enumTab[256];           /* enumerated    table  */
  69
  70 /*------------------------------------------------------------------*/
  71 /* initSymt () - initialises symbol table related stuff             */
  72 /*------------------------------------------------------------------*/
  73 void
  74 initSymt ()
  75 {
  76   int i = 0;
  77
  78   for (i = 0; i < 256; i++)
  79     SymbolTab[i] = StructTab[i] = (void *) NULL;
  80
  81
  82 }
  83 /*-----------------------------------------------------------------*/
  84 /* newBucket - allocates & returns a new bucket                    */
  85 /*-----------------------------------------------------------------*/
  86 bucket *
  87 newBucket ()
  88 {
  89   bucket *bp;
  90
  91   bp = Safe_alloc ( sizeof (bucket));
  92
  93   return bp;
  94 }
  95
  96 /*-----------------------------------------------------------------*/
  97 /* hashKey - computes the hashkey given a symbol name              */
  98 /*-----------------------------------------------------------------*/
  99 int
 100 hashKey (const char *s)
 101 {
 102   unsigned long key = 0;
 103
 104   while (*s)
 105     key += *s++;
 106   return key % 256;
 107 }
 108
 109 /*-----------------------------------------------------------------*/
 110 /* addSym - adds a symbol to the hash Table                        */
 111 /*-----------------------------------------------------------------*/
 112 void
 113 addSym (bucket ** stab,
 114         void *sym,
 115         char *sname,
 116         int level,
 117         int block,
 118         int checkType)
 119 {
 120   int i;                        /* index into the hash Table */
 121   bucket *bp;                   /* temp bucket    *          */
 122
 123   if (checkType) {
 124     symbol *csym = (symbol *)sym;
 125
 126     if (getenv("DEBUG_SANITY")) {
 127       fprintf (stderr, "addSym: %s ", sname);
 128     }
 129     /* make sure the type is complete and sane */
 130     checkTypeSanity(csym->etype, csym->name);
 131   }
 132
 133   /* prevent overflow of the (r)name buffers */
 134   if (strlen(sname)>SDCC_SYMNAME_MAX) {
 135     werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
 136     sname[SDCC_SYMNAME_MAX]='\0';
 137   }
 138
 139   /* the symbols are always added at the head of the list  */
 140   i = hashKey (sname);
 141   /* get a free entry */
 142   bp = Safe_alloc ( sizeof (bucket));
 143
 144   bp->sym = sym;                /* update the symbol pointer */
 145   bp->level = level;            /* update the nest level     */
 146   bp->block = block;
 147   strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
 148
 149   /* if this is the first entry */
 150   if (stab[i] == NULL)
 151     {
 152       bp->prev = bp->next = (void *) NULL;      /* point to nothing */
 153       stab[i] = bp;
 154     }
 155   /* not first entry then add @ head of list */
 156   else
 157     {
 158       bp->prev = NULL;
 159       stab[i]->prev = bp;
 160       bp->next = stab[i];
 161       stab[i] = bp;
 162     }
 163 }
 164
 165 /*-----------------------------------------------------------------*/
 166 /* deleteSym - deletes a symbol from the hash Table entry          */
 167 /*-----------------------------------------------------------------*/
 168 void
 169 deleteSym (bucket ** stab, void *sym, char *sname)
 170 {
 171   int i = 0;
 172   bucket *bp;
 173
 174   i = hashKey (sname);
 175
 176   bp = stab[i];
 177   /* find the symbol */
 178   while (bp)
 179     {
 180       if (bp->sym == sym)       /* found it then break out */
 181         break;                  /* of the loop       */
 182       bp = bp->next;
 183     }
 184
 185   if (!bp)                      /* did not find it */
 186     return;
 187   /* if this is the first one in the chain */
 188   if (!bp->prev)
 189     {
 190       stab[i] = bp->next;
 191       if (stab[i])              /* if chain ! empty */
 192         stab[i]->prev = (void *) NULL;
 193     }
 194   /* middle || end of chain */
 195   else
 196     {
 197       if (bp->next)             /* if not end of chain */
 198         bp->next->prev = bp->prev;
 199
 200       bp->prev->next = bp->next;
 201     }
 202
 203 }
 204
 205 /*-----------------------------------------------------------------*/
 206 /* findSym - finds a symbol in a table                             */
 207 /*-----------------------------------------------------------------*/
 208 void *
 209 findSym (bucket ** stab, void *sym, const char *sname)
 210 {
 211   bucket *bp;
 212
 213   bp = stab[hashKey (sname)];
 214   while (bp)
 215     {
 216       if (bp->sym == sym || strcmp (bp->name, sname) == 0)
 217         break;
 218       bp = bp->next;
 219     }
 220
 221   return (bp ? bp->sym : (void *) NULL);
 222 }
 223
 224 /*-----------------------------------------------------------------*/
 225 /* findSymWithLevel - finds a symbol with a name & level           */
 226 /*-----------------------------------------------------------------*/
 227 void *
 228 findSymWithLevel (bucket ** stab, symbol * sym)
 229 {
 230   bucket *bp;
 231
 232   bp = stab[hashKey (sym->name)];
 233
 234   /**
 235    **  do the search from the head of the list since the
 236    **  elements are added at the head it is ensured that
 237    ** we will find the deeper definitions before we find
 238    ** the global ones. we need to check for symbols with
 239    ** level <= to the level given, if levels match then block
 240    ** numbers need to match as well
 241    **/
 242   while (bp)
 243     {
 244       if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
 245         {
 246           /* if this is parameter then nothing else need to be checked */
 247           if (((symbol *) (bp->sym))->_isparm)
 248             return (bp->sym);
 249           /* if levels match then block numbers should also match */
 250           if (bp->level && bp->level == sym->level && bp->block == sym->block)
 251             return (bp->sym);
 252           /* if levels don't match then we are okay */
 253           if (bp->level && bp->level != sym->level && bp->block <= sym->block)
 254             return (bp->sym);
 255           /* if this is a global variable then we are ok too */
 256           if (bp->level == 0)
 257             return (bp->sym);
 258         }
 259
 260       bp = bp->next;
 261     }
 262
 263   return (void *) NULL;
 264 }
 265
 266 /*-----------------------------------------------------------------*/
 267 /* findSymWithBlock - finds a symbol with name in with a block     */
 268 /*-----------------------------------------------------------------*/
 269 void *
 270 findSymWithBlock (bucket ** stab, symbol * sym, int block)
 271 {
 272   bucket *bp;
 273
 274   bp = stab[hashKey (sym->name)];
 275   while (bp)
 276     {
 277       if (strcmp (bp->name, sym->name) == 0 &&
 278           bp->block <= block)
 279         break;
 280       bp = bp->next;
 281     }
 282
 283   return (bp ? bp->sym : (void *) NULL);
 284 }
 285
 286 /*------------------------------------------------------------------*/
 287 /* newSymbol () - returns a new pointer to a symbol                 */
 288 /*------------------------------------------------------------------*/
 289 symbol *
 290 newSymbol (char *name, int scope)
 291 {
 292   symbol *sym;
 293
 294   sym = Safe_alloc ( sizeof (symbol));
 295
 296   strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
 297   sym->level = scope;           /* set the level */
 298   sym->block = currBlockno;
 299   sym->lineDef = lexLineno;    /* set the line number */
 300   sym->fileDef = lexFilename;
 301   return sym;
 302 }
 303
 304 /*------------------------------------------------------------------*/
 305 /* newLink - creates a new link (declarator,specifier)              */
 306 /*------------------------------------------------------------------*/
 307 sym_link *
 308 newLink (SYM_LINK_CLASS select)
 309 {
 310   sym_link *p;
 311
 312   p = Safe_alloc ( sizeof (sym_link));
 313   p->class=select;
 314
 315   return p;
 316 }
 317
 318 /*------------------------------------------------------------------*/
 319 /* newStruct - creats a new structdef from the free list            */
 320 /*------------------------------------------------------------------*/
 321 structdef *
 322 newStruct (char *tag)
 323 {
 324   structdef *s;
 325
 326   s = Safe_alloc ( sizeof (structdef));
 327
 328   strncpyz (s->tag, tag, sizeof(s->tag));               /* copy the tag */
 329   return s;
 330 }
 331
 332 /*------------------------------------------------------------------*/
 333 /* sclsFromPtr - Return the storage class a pointer points into.    */
 334 /*               S_FIXED is returned for generic pointers or other  */
 335 /*               unexpected cases                                   */
 336 /*------------------------------------------------------------------*/
 337 STORAGE_CLASS
 338 sclsFromPtr(sym_link *ptr)
 339 {
 340   switch (DCL_TYPE (ptr))
 341     {
 342     case POINTER:
 343       return S_DATA;
 344     case GPOINTER:
 345       return S_FIXED;
 346     case FPOINTER:
 347       return S_XDATA;
 348     case CPOINTER:
 349       return S_CODE;
 350     case IPOINTER:
 351       return S_IDATA;
 352     case PPOINTER:
 353       return S_PDATA;
 354     case EEPPOINTER:
 355       return S_EEPROM;
 356     case FUNCTION:
 357       return S_CODE;
 358     default:
 359       return S_FIXED;
 360     }
 361 }
 362
 363 /*------------------------------------------------------------------*/
 364 /* pointerTypes - do the computation for the pointer types          */
 365 /*------------------------------------------------------------------*/
 366 void
 367 pointerTypes (sym_link * ptr, sym_link * type)
 368 {
 369   if (IS_SPEC (ptr))
 370     return;
 371
 372   /* find the first pointer type */
 373   while (ptr && !IS_PTR (ptr))
 374     ptr = ptr->next;
 375
 376   /* could not find it */
 377   if (!ptr || IS_SPEC (ptr))
 378     return;
 379
 380   if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
 381     pointerTypes (ptr->next, type);
 382     return;
 383   }
 384
 385   /* change the pointer type depending on the
 386      storage class of the type */
 387   if (IS_SPEC (type))
 388     {
 389       switch (SPEC_SCLS (type))
 390         {
 391         case S_XDATA:
 392           DCL_TYPE (ptr) = FPOINTER;
 393           break;
 394         case S_IDATA:
 395           DCL_TYPE (ptr) = IPOINTER;
 396           break;
 397         case S_PDATA:
 398           DCL_TYPE (ptr) = PPOINTER;
 399           break;
 400         case S_DATA:
 401           DCL_TYPE (ptr) = POINTER;
 402           break;
 403         case S_CODE:
 404           DCL_TYPE (ptr) = CPOINTER;
 405           break;
 406         case S_EEPROM:
 407           DCL_TYPE (ptr) = EEPPOINTER;
 408           break;
 409         default:
 410           DCL_TYPE (ptr) = port->unqualified_pointer;
 411           break;
 412         }
 413       /* the storage class of type ends here */
 414       SPEC_SCLS (type) = 0;
 415     }
 416
 417   /* now change all the remaining unknown pointers
 418      to generic pointers */
 419   while (ptr)
 420     {
 421       if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
 422         DCL_TYPE (ptr) = port->unqualified_pointer;
 423       ptr = ptr->next;
 424     }
 425
 426   /* same for the type although it is highly unlikely that
 427      type will have a pointer */
 428   while (type)
 429     {
 430       if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
 431         DCL_TYPE (type) = port->unqualified_pointer;
 432       type = type->next;
 433     }
 434 }
 435
 436 /*------------------------------------------------------------------*/
 437 /* addDecl - adds a declarator @ the end of a chain                 */
 438 /*------------------------------------------------------------------*/
 439 void
 440 addDecl (symbol * sym, int type, sym_link * p)
 441 {
 442   static sym_link *empty = NULL;
 443   sym_link *head;
 444   sym_link *tail;
 445   sym_link *t;
 446
 447   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
 448     fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
 449
 450   if (empty == NULL)
 451     empty = newLink(SPECIFIER);
 452
 453   /* if we are passed a link then set head & tail */
 454   if (p)
 455     {
 456       tail = head = p;
 457       while (tail->next)
 458         tail = tail->next;
 459     }
 460   else
 461     {
 462       head = tail = newLink (DECLARATOR);
 463       DCL_TYPE (head) = type;
 464     }
 465
 466   /* if this is the first entry   */
 467   if (!sym->type)
 468     {
 469       sym->type = head;
 470       sym->etype = tail;
 471     }
 472   else if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
 473     {
 474       sym->etype = mergeSpec (sym->etype, head, sym->name);
 475     }
 476   else if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
 477     {
 478       t = sym->type;
 479       while (t->next != sym->etype)
 480         t = t->next;
 481       t->next = head;
 482       tail->next = sym->etype;
 483     }
 484   else if (IS_FUNC (sym->type) && IS_SPEC (sym->type->next) &&
 485            !memcmp(sym->type->next, empty, sizeof(sym_link)))
 486     {
 487       sym->type->next = head;
 488       sym->etype = tail;
 489     }
 490   else
 491     {
 492       sym->etype->next = head;
 493       sym->etype = tail;
 494     }
 495
 496   /* if the type is an unknown pointer and has
 497      a tspec then take the storage class const & volatile
 498      attribute from the tspec & make it those of this
 499      symbol */
 500   if (p &&
 501       !IS_SPEC (p) &&
 502       //DCL_TYPE (p) == UPOINTER &&
 503       DCL_TSPEC (p))
 504     {
 505       if (!IS_SPEC (sym->etype))
 506         {
 507           sym->etype = sym->etype->next = newLink (SPECIFIER);
 508         }
 509       SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
 510       DCL_TSPEC (p) = NULL;
 511     }
 512
 513   // if there is a function in this type chain
 514   if (p && funcInChain(sym->type)) {
 515     processFuncArgs (sym);
 516   }
 517
 518   return;
 519 }
 520
 521 /*------------------------------------------------------------------
 522   checkTypeSanity: prevent the user from doing e.g.:
 523   unsigned float uf;
 524   ------------------------------------------------------------------*/
 525 void checkTypeSanity(sym_link *etype, char *name) {
 526   char *noun;
 527
 528   if (!etype) {
 529     if (getenv("DEBUG_SANITY")) {
 530       fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
 531     }
 532     return;
 533   }
 534
 535   if (!IS_SPEC(etype)) {
 536     if (getenv("DEBUG_SANITY")) {
 537       fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
 538     }
 539     return;
 540   }
 541
 542   noun=nounName(etype);
 543
 544   if (getenv("DEBUG_SANITY")) {
 545     fprintf (stderr, "checking sanity for %s %p\n", name, etype);
 546   }
 547
 548   if ((SPEC_NOUN(etype)==V_CHAR ||
 549        SPEC_NOUN(etype)==V_FLOAT ||
 550        SPEC_NOUN(etype)==V_FIXED16X16 ||
 551        SPEC_NOUN(etype)==V_DOUBLE ||
 552        SPEC_NOUN(etype)==V_VOID) &&
 553       (SPEC_SHORT(etype) || SPEC_LONG(etype))) {
 554     // long or short for char float double or void
 555     werror (E_LONG_OR_SHORT_INVALID, noun, name);
 556   }
 557   if ((SPEC_NOUN(etype)==V_FLOAT ||
 558        SPEC_NOUN(etype)==V_FIXED16X16 ||
 559        SPEC_NOUN(etype)==V_DOUBLE ||
 560        SPEC_NOUN(etype)==V_VOID) &&
 561       (etype->select.s.b_signed || SPEC_USIGN(etype))) {
 562     // signed or unsigned for float double or void
 563     werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
 564   }
 565
 566   // special case for "short"
 567   if (SPEC_SHORT(etype)) {
 568     SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
 569     SPEC_SHORT(etype) = 0;
 570   }
 571
 572   /* if no noun e.g.
 573      "const a;" or "data b;" or "signed s" or "long l"
 574      assume an int */
 575   if (!SPEC_NOUN(etype)) {
 576     SPEC_NOUN(etype)=V_INT;
 577   }
 578
 579   /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
 580   /* a "plain" int bitfield is unsigned */
 581   if (SPEC_NOUN(etype)==V_BIT ||
 582       SPEC_NOUN(etype)==V_SBIT) {
 583     if (!etype->select.s.b_signed)
 584       SPEC_USIGN(etype) = 1;
 585   }
 586
 587   if (etype->select.s.b_signed && SPEC_USIGN(etype)) {
 588     // signed AND unsigned
 589     werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
 590   }
 591   if (SPEC_SHORT(etype) && SPEC_LONG(etype)) {
 592     // short AND long
 593     werror (E_LONG_AND_SHORT_INVALID, noun, name);
 594   }
 595
 596 }
 597
 598 /*------------------------------------------------------------------*/
 599 /* mergeSpec - merges two specifiers and returns the new one        */
 600 /*------------------------------------------------------------------*/
 601 sym_link *
 602 mergeSpec (sym_link * dest, sym_link * src, char *name)
 603 {
 604   if (!IS_SPEC(dest) || !IS_SPEC(src)) {
 605 #if 0
 606     werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
 607     exit (1);
 608 #else
 609     werror (E_SYNTAX_ERROR, yytext);
 610     // the show must go on
 611     return newIntLink();
 612 #endif
 613   }
 614
 615   if (SPEC_NOUN(src)) {
 616     if (!SPEC_NOUN(dest)) {
 617       SPEC_NOUN(dest)=SPEC_NOUN(src);
 618     } else {
 619       /* we shouldn't redeclare the type */
 620       if (getenv("DEBUG_SANITY")) {
 621         fprintf (stderr, "mergeSpec: ");
 622       }
 623       werror(E_TWO_OR_MORE_DATA_TYPES, name);
 624     }
 625   }
 626
 627   if (SPEC_SCLS(src)) {
 628     /* if destination has no storage class */
 629     if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
 630       SPEC_SCLS (dest) = SPEC_SCLS (src);
 631     } else {
 632       if (getenv("DEBUG_SANITY")) {
 633         fprintf (stderr, "mergeSpec: ");
 634       }
 635       werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
 636     }
 637   }
 638
 639   /* copy all the specifications  */
 640
 641   // we really should do:
 642 #if 0
 643   if (SPEC_what(src)) {
 644     if (SPEC_what(dest)) {
 645       werror(W_DUPLICATE_SPEC, "what");
 646     }
 647     SPEC_what(dst)|=SPEC_what(src);
 648   }
 649 #endif
 650   // but there are more important thing right now
 651
 652   SPEC_LONG (dest) |= SPEC_LONG (src);
 653   SPEC_SHORT(dest) |= SPEC_SHORT(src);
 654   SPEC_USIGN (dest) |= SPEC_USIGN (src);
 655   dest->select.s.b_signed|=src->select.s.b_signed;
 656   SPEC_STAT (dest) |= SPEC_STAT (src);
 657   SPEC_EXTR (dest) |= SPEC_EXTR (src);
 658   SPEC_INLINE (dest) |= SPEC_INLINE (src);
 659   SPEC_CONST(dest) |= SPEC_CONST (src);
 660   SPEC_ABSA (dest) |= SPEC_ABSA (src);
 661   SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
 662   SPEC_RESTRICT (dest) |= SPEC_RESTRICT (src);
 663   SPEC_ADDR (dest) |= SPEC_ADDR (src);
 664   SPEC_OCLS (dest) = SPEC_OCLS (src);
 665   SPEC_BLEN (dest) |= SPEC_BLEN (src);
 666   SPEC_BSTR (dest) |= SPEC_BSTR (src);
 667   SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
 668   SPEC_ENUM (dest) |= SPEC_ENUM (src);
 669   if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
 670       SPEC_ARGREG(dest) = SPEC_ARGREG(src);
 671
 672   if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
 673     SPEC_STRUCT (dest) = SPEC_STRUCT (src);
 674
 675   /* these are the only function attributes that will be set
 676      in a specifier while parsing */
 677   FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
 678   FUNC_BANKED(dest) |= FUNC_BANKED(src);
 679   FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
 680   FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
 681   FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
 682   FUNC_ISISR(dest) |= FUNC_ISISR(src);
 683   FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
 684   FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
 685   FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
 686   FUNC_INTNO(dest) |= FUNC_INTNO(src);
 687   FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
 688   FUNC_ISINLINE (dest) |= FUNC_ISINLINE (src);
 689
 690   return dest;
 691 }
 692
 693 /*-------------------------------------------------------------------*/
 694 /* genSymName - generates and returns a name used for anonymous vars */
 695 /*-------------------------------------------------------------------*/
 696 char *
 697 genSymName (int level)
 698 {
 699   static int gCount = 0;
 700   static char gname[SDCC_NAME_MAX + 1];
 701
 702   SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
 703   return gname;
 704 }
 705
 706 /*------------------------------------------------------------------*/
 707 /* getSpec - returns the specifier part from a declaration chain    */
 708 /*------------------------------------------------------------------*/
 709 sym_link *
 710 getSpec (sym_link * p)
 711 {
 712   sym_link *loop;
 713
 714   loop = p;
 715   while (p && !(IS_SPEC (p)))
 716     p = p->next;
 717
 718   return p;
 719 }
 720
 721 /*------------------------------------------------------------------*/
 722 /* newCharLink() - creates an char type                             */
 723 /*------------------------------------------------------------------*/
 724 sym_link *
 725 newCharLink ()
 726 {
 727   sym_link *p;
 728
 729   p = newLink (SPECIFIER);
 730   SPEC_NOUN (p) = V_CHAR;
 731
 732   return p;
 733 }
 734
 735 /*------------------------------------------------------------------*/
 736 /* newFloatLink - a new Float type                                  */
 737 /*------------------------------------------------------------------*/
 738 sym_link *
 739 newFloatLink ()
 740 {
 741   sym_link *p;
 742
 743   p = newLink (SPECIFIER);
 744   SPEC_NOUN (p) = V_FLOAT;
 745
 746   return p;
 747 }
 748
 749 /*------------------------------------------------------------------*/
 750 /* newFixed16x16Link - a new Float type                             */
 751 /*------------------------------------------------------------------*/
 752 sym_link *
 753 newFixed16x16Link ()
 754 {
 755   sym_link *p;
 756
 757   p = newLink (SPECIFIER);
 758   SPEC_NOUN (p) = V_FIXED16X16;
 759
 760   return p;
 761 }
 762
 763 /*------------------------------------------------------------------*/
 764 /* newLongLink() - new long type                                    */
 765 /*------------------------------------------------------------------*/
 766 sym_link *
 767 newLongLink ()
 768 {
 769   sym_link *p;
 770
 771   p = newLink (SPECIFIER);
 772   SPEC_NOUN (p) = V_INT;
 773   SPEC_LONG (p) = 1;
 774
 775   return p;
 776 }
 777
 778 /*------------------------------------------------------------------*/
 779 /* newIntLink() - creates an int type                               */
 780 /*------------------------------------------------------------------*/
 781 sym_link *
 782 newIntLink ()
 783 {
 784   sym_link *p;
 785
 786   p = newLink (SPECIFIER);
 787   SPEC_NOUN (p) = V_INT;
 788
 789   return p;
 790 }
 791
 792 /*------------------------------------------------------------------*/
 793 /* newBoolLink() - creates an bool type                             */
 794 /*------------------------------------------------------------------*/
 795 sym_link *
 796 newBoolLink ()
 797 {
 798   sym_link *p;
 799
 800   p = newLink (SPECIFIER);
 801   SPEC_NOUN (p) = V_BIT;
 802
 803   return p;
 804 }
 805
 806 /*------------------------------------------------------------------*/
 807 /* getSize - returns size of a type chain in bytes                  */
 808 /*------------------------------------------------------------------*/
 809 unsigned int
 810 getSize (sym_link * p)
 811 {
 812   /* if nothing return 0 */
 813   if (!p)
 814     return 0;
 815   if (IS_SPEC (p))
 816     {                           /* if this is the specifier then */
 817       switch (SPEC_NOUN (p))
 818         {                       /* depending on the specifier type */
 819         case V_INT:
 820           return (IS_LONG (p) ? LONGSIZE : INTSIZE);
 821         case V_FLOAT:
 822           return FLOATSIZE;
 823         case V_FIXED16X16:
 824           return (4);
 825         case V_CHAR:
 826           return CHARSIZE;
 827         case V_VOID:
 828           return 0;
 829         case V_STRUCT:
 830           return SPEC_STRUCT (p)->size;
 831         case V_LABEL:
 832           return 0;
 833         case V_SBIT:
 834         case V_BIT:
 835           return BITSIZE;
 836         case V_BITFIELD:
 837           return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
 838         default:
 839           return 0;
 840         }
 841     }
 842
 843   /* this is a declarator */
 844   switch (DCL_TYPE (p))
 845     {
 846     case ARRAY:
 847       if (DCL_ELEM(p)) {
 848         return DCL_ELEM (p) * getSize (p->next);
 849       } else {
 850           //    werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 851           //    "can not tell the size of an array[]");
 852         return 0;
 853       }
 854     case IPOINTER:
 855     case PPOINTER:
 856     case POINTER:
 857       return (PTRSIZE);
 858     case EEPPOINTER:
 859     case FPOINTER:
 860     case CPOINTER:
 861     case FUNCTION:
 862       return (IFFUNC_BANKED (p) ? GPTRSIZE : FPTRSIZE);
 863     case GPOINTER:
 864       return (GPTRSIZE);
 865
 866     default:
 867       return 0;
 868     }
 869 }
 870
 871 /*------------------------------------------------------------------*/
 872 /* checkStructFlexArray - check tree behind a struct                */
 873 /*------------------------------------------------------------------*/
 874 static bool
 875 checkStructFlexArray (symbol *sym, sym_link *p)
 876 {
 877   /* if nothing return FALSE */
 878   if (!p)
 879     return FALSE;
 880
 881   if (IS_SPEC (p))
 882     {
 883       /* (nested) struct with flexible array member? */
 884       if (IS_STRUCT (p) && SPEC_STRUCT (p)->b_flexArrayMember)
 885         {
 886           werror (W_INVALID_FLEXARRAY);
 887           return FALSE;
 888         }
 889       return FALSE;
 890     }
 891
 892   /* this is a declarator */
 893   if (IS_ARRAY (p))
 894     {
 895       /* flexible array member? */
 896       if (!DCL_ELEM(p))
 897         {
 898           if (!options.std_c99)
 899             werror (W_C89_NO_FLEXARRAY);
 900           return TRUE;
 901         }
 902       /* walk tree */
 903       return checkStructFlexArray (sym, p->next);
 904     }
 905   return FALSE;
 906 }
 907
 908 /*------------------------------------------------------------------*/
 909 /* bitsForType - returns # of bits required to store this type      */
 910 /*------------------------------------------------------------------*/
 911 unsigned int
 912 bitsForType (sym_link * p)
 913 {
 914   /* if nothing return 0 */
 915   if (!p)
 916     return 0;
 917
 918   if (IS_SPEC (p))
 919     {                           /* if this is the specifier then */
 920
 921       switch (SPEC_NOUN (p))
 922         {                       /* depending on the specifier type */
 923         case V_INT:
 924           return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
 925         case V_FLOAT:
 926           return FLOATSIZE * 8;
 927         case V_FIXED16X16:
 928           return (32);
 929         case V_CHAR:
 930           return CHARSIZE * 8;
 931         case V_VOID:
 932           return 0;
 933         case V_STRUCT:
 934           return SPEC_STRUCT (p)->size * 8;
 935         case V_LABEL:
 936           return 0;
 937         case V_SBIT:
 938         case V_BIT:
 939           return 1;
 940         case V_BITFIELD:
 941           return SPEC_BLEN (p);
 942         default:
 943           return 0;
 944         }
 945     }
 946
 947   /* this is a specifier  */
 948   switch (DCL_TYPE (p))
 949     {
 950     case ARRAY:
 951       return DCL_ELEM (p) * getSize (p->next) * 8;
 952     case IPOINTER:
 953     case PPOINTER:
 954     case POINTER:
 955       return (PTRSIZE * 8);
 956     case EEPPOINTER:
 957     case FPOINTER:
 958     case CPOINTER:
 959     case FUNCTION:
 960       return (FPTRSIZE * 8);
 961     case GPOINTER:
 962       return (GPTRSIZE * 8);
 963
 964     default:
 965       return 0;
 966     }
 967 }
 968
 969 /*------------------------------------------------------------------*/
 970 /* copySymbolChain - copies a symbol chain                          */
 971 /*------------------------------------------------------------------*/
 972 symbol *
 973 copySymbolChain (symbol * src)
 974 {
 975   symbol *dest;
 976
 977   if (!src)
 978     return NULL;
 979
 980   dest = copySymbol (src);
 981   dest->next = copySymbolChain (src->next);
 982   return dest;
 983 }
 984
 985 /*------------------------------------------------------------------*/
 986 /* copySymbol - makes a copy of a symbol                            */
 987 /*------------------------------------------------------------------*/
 988 symbol *
 989 copySymbol (symbol * src)
 990 {
 991   symbol *dest;
 992
 993   if (!src)
 994     return NULL;
 995
 996   dest = newSymbol (src->name, src->level);
 997   memcpy (dest, src, sizeof (symbol));
 998   dest->level = src->level;
 999   dest->block = src->block;
1000   dest->ival = copyIlist (src->ival);
1001   dest->type = copyLinkChain (src->type);
1002   dest->etype = getSpec (dest->type);
1003   dest->next = NULL;
1004   dest->key = src->key;
1005   dest->allocreq = src->allocreq;
1006   return dest;
1007 }
1008
1009 /*------------------------------------------------------------------*/
1010 /* reverseSyms - reverses the links for a symbol chain              */
1011 /*------------------------------------------------------------------*/
1012 symbol *
1013 reverseSyms (symbol * sym)
1014 {
1015   symbol *prev, *curr, *next;
1016
1017   if (!sym)
1018     return NULL;
1019
1020   prev = sym;
1021   curr = sym->next;
1022
1023   while (curr)
1024     {
1025       next = curr->next;
1026       curr->next = prev;
1027       prev = curr;
1028       curr = next;
1029     }
1030   sym->next = (void *) NULL;
1031   return prev;
1032 }
1033
1034 /*------------------------------------------------------------------*/
1035 /* reverseLink - reverses the links for a type chain                */
1036 /*------------------------------------------------------------------*/
1037 sym_link *
1038 reverseLink (sym_link * type)
1039 {
1040   sym_link *prev, *curr, *next;
1041
1042   if (!type)
1043     return NULL;
1044
1045   prev = type;
1046   curr = type->next;
1047
1048   while (curr)
1049     {
1050       next = curr->next;
1051       curr->next = prev;
1052       prev = curr;
1053       curr = next;
1054     }
1055   type->next = (void *) NULL;
1056   return prev;
1057 }
1058
1059 /*------------------------------------------------------------------*/
1060 /* addSymChain - adds a symbol chain to the symboltable             */
1061 /*------------------------------------------------------------------*/
1062 void
1063 addSymChain (symbol ** symHead)
1064 {
1065   symbol *sym = *symHead;
1066   symbol *csym = NULL;
1067   symbol **symPtrPtr;
1068   int error = 0;
1069
1070   for (; sym != NULL; sym = sym->next)
1071     {
1072       changePointer(sym->type);
1073       checkTypeSanity(sym->etype, sym->name);
1074
1075       if (!sym->level && !(IS_SPEC(sym->etype) && IS_TYPEDEF(sym->etype)))
1076         checkDecl (sym, 0);
1077       else
1078         {
1079           /* if this is an array without any dimension
1080              then update the dimension from the initial value */
1081           if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1082             DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1083         }
1084
1085       /* if already exists in the symbol table on the same level */
1086       if ((csym = findSymWithLevel (SymbolTab, sym)) &&
1087           csym->level == sym->level)
1088         {
1089           /* if not formal parameter and not in file scope
1090              then show symbol redefined error
1091              else check if symbols have conpatible types */
1092           if (!sym->_isparm && sym->level > 0)
1093             error = 1;
1094           else
1095             {
1096               /* If the previous definition was for an array with incomplete
1097                  type, and the new definition has completed the type, update
1098                  the original type to match */
1099               if (IS_DECL(csym->type) && DCL_TYPE(csym->type)==ARRAY
1100                   && IS_DECL(sym->type) && DCL_TYPE(sym->type)==ARRAY)
1101                 {
1102                   if (!DCL_ELEM(csym->type) && DCL_ELEM(sym->type))
1103                     DCL_ELEM(csym->type) = DCL_ELEM(sym->type);
1104                 }
1105
1106               #if 0
1107               /* If only one of the definitions used the "at" keyword, copy */
1108               /* the address to the other. */
1109               if (IS_SPEC(csym->etype) && SPEC_ABSA(csym->etype)
1110                   && IS_SPEC(sym->etype) && !SPEC_ABSA(sym->etype))
1111                 {
1112                   SPEC_ABSA (sym->etype) = 1;
1113                   SPEC_ADDR (sym->etype) = SPEC_ADDR (csym->etype);
1114                 }
1115               if (IS_SPEC(csym->etype) && !SPEC_ABSA(csym->etype)
1116                   && IS_SPEC(sym->etype) && SPEC_ABSA(sym->etype))
1117                 {
1118                   SPEC_ABSA (csym->etype) = 1;
1119                   SPEC_ADDR (csym->etype) = SPEC_ADDR (sym->etype);
1120                 }
1121               #endif
1122
1123               error = 0;
1124               if (csym->ival && sym->ival)
1125                 error = 1;
1126               if (compareTypeExact (csym->type, sym->type, sym->level) != 1)
1127                 error = 1;
1128             }
1129
1130           if (error)
1131             {
1132               /* one definition extern ? */
1133               if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype))
1134                 werror (E_EXTERN_MISMATCH, sym->name);
1135               else
1136                 werror (E_DUPLICATE, sym->name);
1137               werrorfl (csym->fileDef, csym->lineDef, E_PREVIOUS_DEF);
1138               #if 0
1139               fprintf (stderr, "from type '");
1140               printTypeChain (csym->type, stderr);
1141               if (IS_SPEC (csym->etype) && SPEC_ABSA (csym->etype))
1142                 fprintf(stderr, " at 0x%x", SPEC_ADDR (csym->etype));
1143               fprintf (stderr, "'\nto type '");
1144               printTypeChain (sym->type, stderr);
1145               if (IS_SPEC (sym->etype) && SPEC_ABSA (sym->etype))
1146                 fprintf(stderr, " at 0x%x", SPEC_ADDR (sym->etype));
1147               fprintf (stderr, "'\n");
1148               #endif
1149               continue;
1150             }
1151
1152           if (csym->ival && !sym->ival)
1153             sym->ival = csym->ival;
1154
1155           if (!csym->cdef && !sym->cdef && IS_EXTERN (sym->etype))
1156             {
1157               /* if none of symbols is a compiler defined function
1158                  and at least one is not extern
1159                  then set the new symbol to non extern */
1160               SPEC_EXTR(sym->etype) = SPEC_EXTR(csym->etype);
1161             }
1162
1163           /* delete current entry */
1164           deleteSym (SymbolTab, csym, csym->name);
1165           deleteFromSeg(csym);
1166
1167           symPtrPtr = symHead;
1168           while (*symPtrPtr && *symPtrPtr != csym)
1169             symPtrPtr = &(*symPtrPtr)->next;
1170           if (*symPtrPtr == csym)
1171             *symPtrPtr = csym->next;
1172         }
1173
1174       /* add new entry */
1175       addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1176     }
1177 }
1178
1179
1180 /*------------------------------------------------------------------*/
1181 /* funcInChain - DCL Type 'FUNCTION' found in type chain            */
1182 /*------------------------------------------------------------------*/
1183 int
1184 funcInChain (sym_link * lnk)
1185 {
1186   while (lnk)
1187     {
1188       if (IS_FUNC (lnk))
1189         return 1;
1190       lnk = lnk->next;
1191     }
1192   return 0;
1193 }
1194
1195 /*------------------------------------------------------------------*/
1196 /* structElemType - returns the type info of a struct member        */
1197 /*------------------------------------------------------------------*/
1198 sym_link *
1199 structElemType (sym_link * stype, value * id)
1200 {
1201   symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1202   sym_link *type, *etype;
1203   sym_link *petype = getSpec (stype);
1204
1205   if (fields && id) {
1206
1207     /* look for the id */
1208     while (fields)
1209       {
1210         if (strcmp (fields->rname, id->name) == 0)
1211           {
1212             type = copyLinkChain (fields->type);
1213             etype = getSpec (type);
1214             SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1215                                  SPEC_SCLS (etype) : SPEC_SCLS (petype));
1216             if (IS_SPEC (type))
1217               SPEC_CONST (type) |= SPEC_CONST (stype);
1218             else
1219               DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1220             return type;
1221           }
1222         fields = fields->next;
1223       }
1224   }
1225
1226   werror (E_NOT_MEMBER, id->name);
1227
1228   // the show must go on
1229   return newIntLink();
1230 }
1231
1232 /*------------------------------------------------------------------*/
1233 /* getStructElement - returns element of a tructure definition      */
1234 /*------------------------------------------------------------------*/
1235 symbol *
1236 getStructElement (structdef * sdef, symbol * sym)
1237 {
1238   symbol *field;
1239
1240   for (field = sdef->fields; field; field = field->next)
1241     if (strcmp (field->name, sym->name) == 0)
1242       return field;
1243
1244   werror (E_NOT_MEMBER, sym->name);
1245
1246   return sdef->fields;
1247 }
1248
1249 /*------------------------------------------------------------------*/
1250 /* compStructSize - computes the size of a structure                */
1251 /*------------------------------------------------------------------*/
1252 int
1253 compStructSize (int su, structdef * sdef)
1254 {
1255   int sum = 0, usum = 0;
1256   int bitOffset = 0;
1257   symbol *loop;
1258
1259   /* for the identifiers  */
1260   loop = sdef->fields;
1261   while (loop) {
1262
1263     /* create the internal name for this variable */
1264     SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1265     if (su == UNION) {
1266         sum = 0;
1267         bitOffset = 0;
1268     }
1269     SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1270
1271     /* if this is a bit field  */
1272     if (loop->bitVar) {
1273
1274       /* change it to a unsigned bit */
1275       SPEC_NOUN (loop->etype) = V_BITFIELD;
1276       /* ISO/IEC 9899 J.3.9 implementation defined behaviour: */
1277       /* a "plain" int bitfield is unsigned */
1278       if (!loop->etype->select.s.b_signed)
1279         SPEC_USIGN(loop->etype) = 1;
1280
1281       SPEC_BLEN (loop->etype) = loop->bitVar;
1282
1283       if (loop->bitVar == BITVAR_PAD) {
1284         /* A zero length bitfield forces padding */
1285         SPEC_BSTR (loop->etype) = bitOffset;
1286         SPEC_BLEN (loop->etype) = 0;
1287         bitOffset = 8;
1288         loop->offset = sum;
1289       }
1290       else {
1291         if (bitOffset == 8) {
1292           bitOffset = 0;
1293           sum++;
1294         }
1295         /* check if this fit into the remaining   */
1296         /* bits of this byte else align it to the */
1297         /* next byte boundary                     */
1298         if (loop->bitVar <= (8 - bitOffset)) {
1299           /* fits into current byte */
1300           loop->offset = sum;
1301           SPEC_BSTR (loop->etype) = bitOffset;
1302           bitOffset += loop->bitVar;
1303         }
1304         else if (!bitOffset) {
1305           /* does not fit, but is already byte aligned */
1306           loop->offset = sum;
1307           SPEC_BSTR (loop->etype) = bitOffset;
1308           bitOffset += loop->bitVar;
1309         }
1310         else {
1311           if( TARGET_IS_PIC16 && getenv("PIC16_PACKED_BITFIELDS") ) {
1312             /* if PIC16 && enviroment variable is set, then
1313              * tightly pack bitfields, this means that when a
1314              * bitfield goes beyond byte alignment, do not
1315              * automatically start allocatint from next byte,
1316              * but also use the available bits first */
1317             fprintf(stderr, ": packing bitfields in structures\n");
1318             SPEC_BSTR (loop->etype) = bitOffset;
1319             bitOffset += loop->bitVar;
1320             loop->offset = (su == UNION ? sum = 0 : sum);
1321           } else {
1322             /* does not fit; need to realign first */
1323             sum++;
1324             loop->offset = (su == UNION ? sum = 0 : sum);
1325             bitOffset = 0;
1326             SPEC_BSTR (loop->etype) = bitOffset;
1327             bitOffset += loop->bitVar;
1328           }
1329         }
1330         while (bitOffset>8) {
1331           bitOffset -= 8;
1332           sum++;
1333         }
1334       }
1335     }
1336     else {
1337       /* This is a non-bit field. Make sure we are */
1338       /* byte aligned first */
1339       if (bitOffset) {
1340         sum++;
1341         loop->offset = (su == UNION ? sum = 0 : sum);
1342         bitOffset = 0;
1343       }
1344       loop->offset = sum;
1345       checkDecl (loop, 1);
1346       sum += getSize (loop->type);
1347
1348       /* search for "flexibel array members" */
1349       /* and do some syntax checks */
1350       if (   su == STRUCT
1351           && checkStructFlexArray (loop, loop->type))
1352         {
1353           /* found a "flexible array member" */
1354           sdef->b_flexArrayMember = TRUE;
1355           /* is another struct-member following? */
1356           if (loop->next)
1357             werror (E_FLEXARRAY_NOTATEND);
1358           /* is it the first struct-member? */
1359           else if (loop == sdef->fields)
1360             werror (E_FLEXARRAY_INEMPTYSTRCT);
1361         }
1362     }
1363
1364     loop = loop->next;
1365
1366     /* if union then size = sizeof largest field */
1367     if (su == UNION) {
1368       /* For UNION, round up after each field */
1369       sum += ((bitOffset+7)/8);
1370       usum = max (usum, sum);
1371     }
1372
1373   }
1374
1375   /* For STRUCT, round up after all fields processed */
1376   if (su != UNION)
1377     sum += ((bitOffset+7)/8);
1378
1379   return (su == UNION ? usum : sum);
1380 }
1381
1382 /*-------------------------------------------------------------------*/
1383 /* promoteAnonStructs - promote anonymous struct/union's fields into */
1384 /*                      an enclosing struct/union                    */
1385 /*-------------------------------------------------------------------*/
1386 void
1387 promoteAnonStructs (int su, structdef * sdef)
1388 {
1389   symbol *field;
1390   symbol *subfield;
1391   symbol **tofield;
1392   symbol *nextfield;
1393   symbol *dupfield;
1394   int base;
1395
1396   tofield = &sdef->fields;
1397   field = sdef->fields;
1398   while (field)
1399     {
1400       nextfield = field->next;
1401       if (!*field->name && IS_STRUCT (field->type))
1402         {
1403           /* Found an anonymous struct/union. Replace it */
1404           /* with the fields it contains and adjust all  */
1405           /* the offsets */
1406
1407           base = field->offset;
1408           subfield = copySymbolChain (SPEC_STRUCT (field->type)->fields);
1409           if (!subfield)
1410             continue;           /* just in case it's empty */
1411
1412           *tofield = subfield;
1413           for (;;)
1414             {
1415               /* check for field name conflicts resulting from promotion */
1416               dupfield = sdef->fields;
1417               while (dupfield && dupfield != subfield)
1418                 {
1419                   if (*subfield->name && !strcmp (dupfield->name, subfield->name))
1420                     {
1421                       werrorfl (subfield->fileDef, subfield->lineDef,
1422                                 E_DUPLICATE_MEMBER,
1423                                 su==STRUCT ? "struct" : "union",
1424                                 subfield->name);
1425                       werrorfl (dupfield->fileDef, dupfield->lineDef,
1426                                 E_PREVIOUS_DEF);
1427                     }
1428                   dupfield = dupfield->next;
1429                 }
1430
1431               subfield->offset += base;
1432               if (subfield->next)
1433                 subfield = subfield->next;
1434               else
1435                 break;
1436             }
1437           subfield->next = nextfield;
1438           tofield = &subfield->next;
1439         }
1440       else
1441         tofield = &field->next;
1442       field = nextfield;
1443     }
1444 }
1445
1446
1447 /*------------------------------------------------------------------*/
1448 /* checkSClass - check the storage class specification              */
1449 /*------------------------------------------------------------------*/
1450 static void
1451 checkSClass (symbol * sym, int isProto)
1452 {
1453   sym_link *t;
1454
1455   if (getenv("DEBUG_SANITY")) {
1456     fprintf (stderr, "checkSClass: %s \n", sym->name);
1457   }
1458
1459   /* type is literal can happen for enums change to auto */
1460   if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1461     SPEC_SCLS (sym->etype) = S_AUTO;
1462
1463   /* if sfr or sbit then must also be volatile */
1464   if (SPEC_SCLS (sym->etype) == S_SBIT ||
1465       SPEC_SCLS (sym->etype) == S_SFR)
1466     {
1467       SPEC_VOLATILE (sym->etype) = 1;
1468     }
1469
1470   /* make sure restrict is only used with pointers */
1471   if (SPEC_RESTRICT (sym->etype))
1472     {
1473       werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1474       SPEC_RESTRICT (sym->etype) = 0;
1475     }
1476   t = sym->type;
1477   while (t)
1478     {
1479       if (IS_DECL (t) && DCL_PTR_RESTRICT (t) && !IS_PTR (t))
1480         {
1481           werrorfl (sym->fileDef, sym->lineDef, E_BAD_RESTRICT);
1482           DCL_PTR_RESTRICT (t) = 0;
1483           break;
1484         }
1485       t = t->next;
1486     }
1487
1488   /* if absolute address given then it mark it as
1489      volatile -- except in the PIC port */
1490
1491 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1492   /* The PIC port uses a different peep hole optimizer based on "pCode" */
1493   if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1494 #endif
1495
1496     if (IS_ABSOLUTE (sym->etype))
1497       SPEC_VOLATILE (sym->etype) = 1;
1498
1499   if (TARGET_IS_MCS51 &&
1500       IS_ABSOLUTE (sym->etype) &&
1501       SPEC_SCLS (sym->etype) == S_SFR)
1502     {
1503       int n, size;
1504       unsigned addr;
1505
1506       if (SPEC_NOUN (sym->etype) == V_CHAR)
1507         size = 8;
1508       else if (SPEC_LONG (sym->etype) == 0)
1509         size = 16;
1510       else
1511         size = 32;
1512
1513       addr = SPEC_ADDR (sym->etype);
1514       for (n=0; n<size; n+=8)
1515         if (((addr >> n) & 0xFF) < 0x80)
1516           werror (W_SFR_ABSRANGE, sym->name);
1517     }
1518
1519   /* If code memory is read only, then pointers to code memory */
1520   /* implicitly point to constants -- make this explicit       */
1521   t = sym->type;
1522   while (t && t->next) {
1523     if (IS_CODEPTR(t) && port->mem.code_ro) {
1524       if (IS_SPEC(t->next)) {
1525         SPEC_CONST (t->next) = 1;
1526       } else {
1527         DCL_PTR_CONST (t->next) = 1;
1528       }
1529     }
1530     t = t->next;
1531   }
1532
1533   /* global variables declared const put into code */
1534   /* if no other storage class specified */
1535   if (sym->level == 0 &&
1536       SPEC_SCLS(sym->etype) == S_FIXED &&
1537       !IS_FUNC(sym->type)) {
1538     /* find the first non-array link */
1539     t = sym->type;
1540     while (IS_ARRAY(t))
1541       t = t->next;
1542     if (IS_CONSTANT (t)) {
1543       SPEC_SCLS (sym->etype) = S_CODE;
1544     }
1545   }
1546
1547   /* global variable in code space is a constant */
1548   if (sym->level == 0 &&
1549       SPEC_SCLS (sym->etype) == S_CODE &&
1550       port->mem.code_ro) {
1551     /* find the first non-array link */
1552     t = sym->type;
1553     while (IS_ARRAY(t))
1554       t = t->next;
1555     if (IS_SPEC(t)) {
1556       SPEC_CONST (t) = 1;
1557     } else {
1558       DCL_PTR_CONST (t) = 1;
1559     }
1560   }
1561
1562   /* if bit variable then no storage class can be */
1563   /* specified since bit is already a storage */
1564   if (IS_BITVAR (sym->etype) &&
1565       (SPEC_SCLS (sym->etype) != S_FIXED &&
1566        SPEC_SCLS (sym->etype) != S_SBIT &&
1567        SPEC_SCLS (sym->etype) != S_BIT)
1568     )
1569     {
1570       werror (E_BITVAR_STORAGE, sym->name);
1571       SPEC_SCLS (sym->etype) = S_FIXED;
1572     }
1573
1574   /* extern variables cannot be initialized */
1575   if (IS_EXTERN (sym->etype) && sym->ival)
1576     {
1577       werror (E_EXTERN_INIT, sym->name);
1578       sym->ival = NULL;
1579     }
1580
1581   /* if this is an automatic symbol */
1582   if (sym->level && (options.stackAuto || reentrant)) {
1583     if (SPEC_SCLS (sym->etype) != S_BIT) {
1584       if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1585            SPEC_SCLS (sym->etype) == S_FIXED ||
1586            SPEC_SCLS (sym->etype) == S_REGISTER ||
1587            SPEC_SCLS (sym->etype) == S_STACK ||
1588            SPEC_SCLS (sym->etype) == S_XSTACK)) {
1589         SPEC_SCLS (sym->etype) = S_AUTO;
1590       } else {
1591         /* storage class may only be specified for statics */
1592         if (!IS_STATIC(sym->etype)) {
1593           werror (E_AUTO_ASSUMED, sym->name);
1594         }
1595       }
1596     }
1597   }
1598
1599   /* automatic symbols cannot be given   */
1600   /* an absolute address ignore it      */
1601   if (sym->level && !IS_STATIC(sym->etype) &&
1602       SPEC_ABSA (sym->etype) &&
1603       (options.stackAuto || reentrant))
1604     {
1605       werror (E_AUTO_ABSA, sym->name);
1606       SPEC_ABSA (sym->etype) = 0;
1607     }
1608
1609   /* arrays & pointers cannot be defined for bits   */
1610   /* SBITS or SFRs or BIT                           */
1611   if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1612       !IS_FUNCPTR (sym->type) &&
1613       (SPEC_NOUN (sym->etype) == V_BIT ||
1614        SPEC_NOUN (sym->etype) == V_SBIT ||
1615        SPEC_NOUN (sym->etype) == V_BITFIELD ||
1616        SPEC_SCLS (sym->etype) == S_SFR))
1617     werror (E_BIT_ARRAY, sym->name);
1618
1619   /* if this is a bit|sbit then set length & start  */
1620   if (SPEC_NOUN (sym->etype) == V_BIT ||
1621       SPEC_NOUN (sym->etype) == V_SBIT)
1622     {
1623       SPEC_BLEN (sym->etype) = 1;
1624       SPEC_BSTR (sym->etype) = 0;
1625     }
1626
1627   if (!isProto) {
1628     /* variables declared in CODE space must have */
1629     /* initializers if not an extern */
1630     if (SPEC_SCLS (sym->etype) == S_CODE &&
1631         sym->ival == NULL &&
1632         !sym->_isparm &&
1633         //!sym->level &&
1634         port->mem.code_ro &&
1635         !IS_EXTERN (sym->etype) &&
1636         !SPEC_ABSA (sym->etype) &&
1637         !funcInChain (sym->type))
1638       werror (E_CODE_NO_INIT, sym->name);
1639   }
1640
1641   /* if parameter or local variable then change */
1642   /* the storage class to reflect where the var will go */
1643   if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED
1644    && !IS_STATIC(sym->etype)
1645       )
1646     {
1647       if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1648         {
1649           SPEC_SCLS (sym->etype) = (options.useXstack ?
1650                                     S_XSTACK : S_STACK);
1651         }
1652       else
1653         {
1654           /* hack-o-matic! I see no reason why the useXstack option should ever
1655            * control this allocation, but the code was originally that way, and
1656            * changing it for non-390 ports breaks the compiler badly.
1657            */
1658           bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1659                 1 : options.useXstack;
1660           SPEC_SCLS (sym->etype) = (useXdata ?
1661                                     S_XDATA : S_FIXED);
1662         }
1663     }
1664 }
1665
1666 /*------------------------------------------------------------------*/
1667 /* changePointer - change pointer to functions                      */
1668 /*------------------------------------------------------------------*/
1669 void
1670 changePointer (sym_link * p)
1671 {
1672
1673   /* go thru the chain of declarations   */
1674   /* if we find a pointer to a function  */
1675   /* change it to a ptr to code area     */
1676   /* unless the function is banked.      */
1677   for (; p; p = p->next)
1678     {
1679       if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1680         DCL_TYPE (p) = port->unqualified_pointer;
1681       if (IS_PTR (p) && IS_FUNC (p->next))
1682         if (!IFFUNC_BANKED(p->next))
1683         DCL_TYPE (p) = CPOINTER;
1684     }
1685 }
1686
1687 /*------------------------------------------------------------------*/
1688 /* checkDecl - does semantic validation of a declaration            */
1689 /*------------------------------------------------------------------*/
1690 int
1691 checkDecl (symbol * sym, int isProto)
1692 {
1693
1694   checkSClass (sym, isProto);        /* check the storage class     */
1695   changePointer (sym->type);         /* change pointers if required */
1696
1697   /* if this is an array without any dimension
1698      then update the dimension from the initial value */
1699   if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1700     DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1701
1702   return 0;
1703 }
1704
1705 /*------------------------------------------------------------------*/
1706 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1707 /*------------------------------------------------------------------*/
1708 sym_link *
1709 copyLinkChain (sym_link * p)
1710 {
1711   sym_link *head, *curr, *loop;
1712
1713   /* note: v_struct and v_struct->fields are not copied! */
1714   curr = p;
1715   head = loop = (curr ? newLink (p->class) : (void *) NULL);
1716   while (curr)
1717     {
1718       memcpy (loop, curr, sizeof (sym_link));   /* copy it */
1719       loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1720       loop = loop->next;
1721       curr = curr->next;
1722     }
1723
1724   return head;
1725 }
1726
1727 /*------------------------------------------------------------------*/
1728 /* cleanUpBlock - cleansup the symbol table specified for all the   */
1729 /*                symbols in the given block                        */
1730 /*------------------------------------------------------------------*/
1731 void
1732 cleanUpBlock (bucket ** table, int block)
1733 {
1734   int i;
1735   bucket *chain;
1736
1737   /* go thru the entire  table  */
1738   for (i = 0; i < 256; i++)
1739     {
1740       for (chain = table[i]; chain; chain = chain->next)
1741         {
1742           if (chain->block >= block)
1743             {
1744               deleteSym (table, chain->sym, chain->name);
1745             }
1746         }
1747     }
1748 }
1749
1750 /*------------------------------------------------------------------*/
1751 /* cleanUpLevel - cleansup the symbol table specified for all the   */
1752 /*                symbols in the given level                        */
1753 /*------------------------------------------------------------------*/
1754 void
1755 cleanUpLevel (bucket ** table, int level)
1756 {
1757   int i;
1758   bucket *chain;
1759
1760   /* go thru the entire  table  */
1761   for (i = 0; i < 256; i++)
1762     {
1763       for (chain = table[i]; chain; chain = chain->next)
1764         {
1765           if (chain->level >= level)
1766             {
1767               deleteSym (table, chain->sym, chain->name);
1768             }
1769         }
1770     }
1771 }
1772
1773 /*------------------------------------------------------------------*/
1774 /* computeTypeOr - computes the resultant type from two types       */
1775 /*------------------------------------------------------------------*/
1776 static sym_link *
1777 computeTypeOr (sym_link * etype1, sym_link * etype2, sym_link * reType)
1778 {
1779   /* sanity check */
1780   assert (   (IS_CHAR (etype1) || IS_BIT (etype1))
1781           && (IS_CHAR (etype2) || IS_BIT (etype2)));
1782
1783   if (SPEC_USIGN (etype1) == SPEC_USIGN (etype2))
1784     {
1785       SPEC_USIGN (reType) = SPEC_USIGN (etype1);
1786       return reType;
1787     }
1788
1789   if (SPEC_USIGN (etype1))
1790     {
1791       if (   IS_LITERAL (etype2)
1792           && floatFromVal (valFromType (etype2)) >= 0)
1793         SPEC_USIGN (reType) = 1;
1794       else
1795         {
1796           /* promote to int */
1797           SPEC_USIGN (reType) = 0;
1798           SPEC_NOUN (reType) = V_INT;
1799         }
1800     }
1801   else /* etype1 signed */
1802     {
1803       if (   IS_LITERAL (etype2)
1804           && floatFromVal (valFromType (etype2)) <= 127)
1805         SPEC_USIGN (reType) = 0;
1806       else
1807         {
1808           /* promote to int */
1809           SPEC_USIGN (reType) = 0;
1810           SPEC_NOUN (reType) = V_INT;
1811         }
1812     }
1813
1814   if (SPEC_USIGN (etype2))
1815     {
1816       if (   IS_LITERAL (etype1)
1817           && floatFromVal (valFromType (etype1)) >= 0)
1818         SPEC_USIGN (reType) = 1;
1819       else
1820         {
1821           /* promote to int */
1822           SPEC_USIGN (reType) = 0;
1823           SPEC_NOUN (reType) = V_INT;
1824         }
1825     }
1826   else /* etype2 signed */
1827     {
1828       if (   IS_LITERAL (etype1)
1829           && floatFromVal (valFromType (etype1)) <= 127)
1830         SPEC_USIGN (reType) = 0;
1831       else
1832         {
1833           /* promote to int */
1834           SPEC_USIGN (reType) = 0;
1835           SPEC_NOUN (reType) = V_INT;
1836         }
1837     }
1838   return reType;
1839 }
1840
1841 /*------------------------------------------------------------------*/
1842 /* computeType - computes the resultant type from two types         */
1843 /*------------------------------------------------------------------*/
1844 sym_link *
1845 computeType (sym_link * type1, sym_link * type2,
1846              RESULT_TYPE resultType, int op)
1847 {
1848   sym_link *rType;
1849   sym_link *reType;
1850   sym_link *etype1 = getSpec (type1);
1851   sym_link *etype2;
1852
1853   etype2 = type2 ? getSpec (type2) : type1;
1854
1855   /* if one of them is a float then result is a float */
1856   /* here we assume that the types passed are okay */
1857   /* and can be cast to one another                */
1858   /* which ever is greater in size */
1859   if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1860     rType = newFloatLink ();
1861   /* if both are fixed16x16 then result is float */
1862   else if (IS_FIXED16X16(etype1) && IS_FIXED16X16(etype2))
1863     rType = newFixed16x16Link();
1864   else if (IS_FIXED16X16(etype1) && IS_FLOAT (etype2))
1865     rType = newFloatLink ();
1866   else if (IS_FLOAT (etype1) && IS_FIXED16X16 (etype2) )
1867     rType = newFloatLink ();
1868
1869   /* if both are bitvars choose the larger one */
1870   else if (IS_BITVAR (etype1) && IS_BITVAR (etype2))
1871     rType = SPEC_BLEN (etype1) >= SPEC_BLEN (etype2) ?
1872             copyLinkChain (type1) : copyLinkChain (type1);
1873
1874   /* if only one of them is a bit variable then the other one prevails */
1875   else if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1876     {
1877       rType = copyLinkChain (type2);
1878       /* bitfield can have up to 16 bits */
1879       if (getSize (etype1) > 1)
1880         SPEC_NOUN (getSpec (rType)) = V_INT;
1881     }
1882   else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1883     {
1884       rType = copyLinkChain (type1);
1885       /* bitfield can have up to 16 bits */
1886       if (getSize (etype2) > 1)
1887         SPEC_NOUN (getSpec (rType)) = V_INT;
1888     }
1889   /* if one of them is a pointer or array then that
1890      prevails */
1891   else if (IS_PTR (type1) || IS_ARRAY (type1))
1892     rType = copyLinkChain (type1);
1893   else if (IS_PTR (type2) || IS_ARRAY (type2))
1894     rType = copyLinkChain (type2);
1895   else if (getSize (type1) > getSize (type2))
1896     rType = copyLinkChain (type1);
1897   else
1898     rType = copyLinkChain (type2);
1899
1900   reType = getSpec (rType);
1901
1902   /* avoid conflicting types */
1903   reType->select.s.b_signed = 0;
1904
1905   /* if result is a literal then make not so */
1906   if (IS_LITERAL (reType))
1907     SPEC_SCLS (reType) = S_REGISTER;
1908
1909   switch (resultType)
1910     {
1911       case RESULT_TYPE_IFX:
1912         if (TARGET_IS_HC08)
1913           break;
1914         //fallthrough
1915       case RESULT_TYPE_BIT:
1916         if (op == ':')
1917           {
1918             SPEC_NOUN (reType) = V_BIT;
1919             return rType;
1920           }
1921         break;
1922       case RESULT_TYPE_CHAR:
1923         if (IS_BITVAR (reType))
1924           {
1925             SPEC_NOUN (reType) = V_CHAR;
1926             SPEC_SCLS (reType) = 0;
1927             SPEC_USIGN (reType) = 0;
1928             return rType;
1929           }
1930         break;
1931       case RESULT_TYPE_INT:
1932       case RESULT_TYPE_NONE:
1933       case RESULT_TYPE_OTHER:
1934         if (IS_BIT (reType))
1935           {
1936             SPEC_NOUN (reType) = V_CHAR;
1937             SPEC_SCLS (reType) = 0;
1938             SPEC_USIGN (reType) = 0;
1939             return rType;
1940           }
1941         else if (IS_BITFIELD (reType))
1942           {
1943             /* could be smarter, but it depends on the op */
1944             /* this is for the worst case: a multiplication of 4 * 4 bit */
1945             SPEC_NOUN (reType) = SPEC_BLEN (reType) <= 4 ? V_CHAR : V_INT;
1946             SPEC_SCLS (reType) = 0;
1947             SPEC_USIGN (reType) = 0;
1948             return rType;
1949           }
1950         else if (IS_CHAR (reType))
1951           {
1952             /* promotion of some special cases */
1953             switch (op)
1954               {
1955                 case '|':
1956                 case '^':
1957                   return computeTypeOr (etype1, etype2, reType);
1958                 case '&':
1959                   if (SPEC_USIGN (etype1) != SPEC_USIGN (etype2))
1960                     {
1961                       SPEC_USIGN (reType) = 1;
1962                       return rType;
1963                     }
1964                   break;
1965                 case '*':
1966                   SPEC_NOUN (reType) = V_INT;
1967                   SPEC_USIGN (reType) = 0;
1968                   return rType;
1969                 case '/':
1970                   /* if both are unsigned char then no promotion required */
1971                   if (!(SPEC_USIGN (etype1) && SPEC_USIGN (etype2)))
1972                     {
1973                       SPEC_NOUN (reType) = V_INT;
1974                       SPEC_USIGN (reType) = 0;
1975                       return rType;
1976                     }
1977                   break;
1978                 default:
1979                   break;
1980               }
1981           }
1982         break;
1983       default:
1984         break;
1985     }
1986
1987   /* SDCC's sign promotion:
1988      - if one or both operands are unsigned, the resultant type will be unsigned
1989        (except char, see below)
1990      - if an operand is promoted to a larger type (char -> int, int -> long),
1991        the larger type will be signed
1992
1993      SDCC tries hard to avoid promotion to int and does 8 bit calculation as
1994      much as possible. We're leaving ISO IEC 9899 here and have to extrapolate
1995      the standard. The standard demands, that the result has to be the same
1996      "as if" the promotion would have been performed:
1997
1998      - if the result of an operation with two char's is promoted to a
1999        larger type, the result will be signed.
2000
2001      More sophisticated are these:
2002      - if the result of an operation with two char's is a char again,
2003        the result will only then be unsigned, if both operands are
2004        unsigned. In all other cases the result will be signed.
2005
2006        This seems to be contradictionary to the first two rules, but it makes
2007        real sense (all types are char's):
2008
2009         A signed char can be negative; this must be preserved in the result
2010                 -1 * 100 = -100;
2011
2012         Only if both operands are unsigned it's safe to make the result
2013         unsigned; this helps to avoid overflow:
2014                 2 * 100 =  200;
2015
2016      - ToDo: document '|', '^' and '&'
2017
2018      Homework: - why is (200 * 200 < 0) true?
2019                - why is { char l = 200, r = 200; (r * l > 0) } true?
2020   */
2021
2022   if (!IS_FLOAT (reType)
2023       && (   (SPEC_USIGN (etype1)
2024               /* if this operand is promoted to a larger type,
2025                  then it will be promoted to a signed type */
2026               && !(bitsForType (etype1) < bitsForType (reType))
2027               /* char require special handling */
2028               && !IS_CHAR (etype1))
2029           || /* same for 2nd operand */
2030              (SPEC_USIGN (etype2)
2031               && !(bitsForType (etype2) < bitsForType (reType))
2032               && !IS_CHAR (etype2))
2033           || /* if both are 'unsigned char' and not promoted
2034                 let the result be unsigned too */
2035              (   SPEC_USIGN (etype1)
2036               && SPEC_USIGN (etype2)
2037               && IS_CHAR (etype1)
2038               && IS_CHAR (etype2)
2039               && IS_CHAR (reType))))
2040     SPEC_USIGN (reType) = 1;
2041   else
2042     SPEC_USIGN (reType) = 0;
2043
2044   return rType;
2045 }
2046
2047 /*--------------------------------------------------------------------*/
2048 /* compareType - will do type check return 1 if match, -1 if castable */
2049 /*--------------------------------------------------------------------*/
2050 int
2051 compareType (sym_link * dest, sym_link * src)
2052 {
2053   if (!dest && !src)
2054     return 1;
2055
2056   if (dest && !src)
2057     return 0;
2058
2059   if (src && !dest)
2060     return 0;
2061
2062   /* if dest is a declarator then */
2063   if (IS_DECL (dest))
2064     {
2065       if (IS_DECL (src))
2066         {
2067           /* banked function pointer */
2068           if (IS_GENPTR (dest) && IS_GENPTR (src))
2069             {
2070               if (IS_FUNC (src->next) && IS_VOID(dest->next))
2071                 return -1;
2072               if (IS_FUNC (dest->next) && IS_VOID(src->next))
2073                 return -1;
2074               return compareType (dest->next, src->next);
2075             }
2076
2077           if (DCL_TYPE (src) == DCL_TYPE (dest))
2078             {
2079               if (IS_FUNC(src))
2080                 {
2081                   //checkFunction(src,dest);
2082                 }
2083               return compareType (dest->next, src->next);
2084             }
2085           if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next))
2086             {
2087               return -1;
2088             }
2089           if (IS_PTR (src) &&
2090               (IS_GENPTR (dest) ||
2091                ((DCL_TYPE(src) == POINTER) && (DCL_TYPE(dest) == IPOINTER))
2092              ))
2093             {
2094               if (compareType (dest->next, src->next))
2095                 return -1;
2096               else
2097                 return 0;
2098             }
2099           if (IS_PTR (dest) && IS_ARRAY (src))
2100             {
2101               value *val=aggregateToPointer (valFromType(src));
2102               int res=compareType (dest, val->type);
2103               Safe_free(val->type);
2104               Safe_free(val);
2105               return res;
2106             }
2107           if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
2108             return compareType (dest->next, src);
2109           return 0;
2110         }
2111       else if (IS_PTR (dest) && IS_INTEGRAL (src))
2112         return -1;
2113       else
2114         return 0;
2115     }
2116
2117   if (IS_PTR (src) && IS_VOID (dest))
2118     return -1;
2119
2120   /* if one is a specifier and the other is not */
2121   if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2122       (IS_SPEC (dest) && !IS_SPEC (src)))
2123     return 0;
2124
2125   /* if one of them is a void then ok */
2126   if (SPEC_NOUN (dest) == V_VOID &&
2127       SPEC_NOUN (src) != V_VOID)
2128     return -1;
2129
2130   if (SPEC_NOUN (dest) != V_VOID &&
2131       SPEC_NOUN (src) == V_VOID)
2132     return -1;
2133
2134   /* if they are both bitfields then if the lengths
2135      and starts don't match */
2136   if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2137       (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2138        SPEC_BSTR (dest) != SPEC_BSTR (src)))
2139     return -1;
2140
2141   /* it is a specifier */
2142   if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2143     {
2144       if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
2145           IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
2146           /* I would prefer
2147           bitsForType (dest) == bitsForType (src))
2148              instead of the next two lines, but the regression tests fail with
2149              them; I guess it's a problem with replaceCheaperOp  */
2150           getSize (dest) == getSize (src) &&
2151           (IS_BIT (dest) == IS_BIT (src)))
2152         return 1;
2153       else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
2154         return -1;
2155       else
2156         return 0;
2157     }
2158   else if (IS_STRUCT (dest))
2159     {
2160       if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2161         return 0;
2162       else
2163         return 1;
2164     }
2165   if (SPEC_LONG (dest) != SPEC_LONG (src))
2166     return -1;
2167
2168   if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2169     return -1;
2170
2171   return 1;
2172 }
2173
2174 /*--------------------------------------------------------------------*/
2175 /* compareTypeExact - will do type check return 1 if match exactly    */
2176 /*--------------------------------------------------------------------*/
2177 int
2178 compareTypeExact (sym_link * dest, sym_link * src, int level)
2179 {
2180   STORAGE_CLASS srcScls, destScls;
2181
2182   if (!dest && !src)
2183     return 1;
2184
2185   if (dest && !src)
2186     return 0;
2187
2188   if (src && !dest)
2189     return 0;
2190
2191   /* if dest is a declarator then */
2192   if (IS_DECL (dest))
2193     {
2194       if (IS_DECL (src))
2195         {
2196           if (DCL_TYPE (src) == DCL_TYPE (dest)) {
2197             if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
2198               return 0;
2199             if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
2200               return 0;
2201             if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
2202               return 0;
2203             if (IS_FUNC(src))
2204               {
2205                 value *exargs, *acargs, *checkValue;
2206
2207                 /* verify function return type */
2208                 if (!compareTypeExact (dest->next, src->next, -1))
2209                   return 0;
2210                 if (FUNC_ISISR (dest) != FUNC_ISISR (src))
2211                   return 0;
2212                 if (FUNC_REGBANK (dest) != FUNC_REGBANK (src))
2213                   return 0;
2214                 if (IFFUNC_ISNAKED (dest) != IFFUNC_ISNAKED (src))
2215                   return 0;
2216                 #if 0
2217                 if (IFFUNC_ISREENT (dest) != IFFUNC_ISREENT (src) && argCnt>1)
2218                   return 0;
2219                 #endif
2220
2221                 /* compare expected args with actual args */
2222                 exargs = FUNC_ARGS(dest);
2223                 acargs = FUNC_ARGS(src);
2224
2225                 /* for all the expected args do */
2226                 for (; exargs && acargs; exargs = exargs->next, acargs = acargs->next)
2227                   {
2228                     //checkTypeSanity(acargs->etype, acargs->name);
2229
2230                     if (IS_AGGREGATE (acargs->type))
2231                       {
2232                         checkValue = copyValue (acargs);
2233                         aggregateToPointer (checkValue);
2234                       }
2235                     else
2236                       checkValue = acargs;
2237
2238                     #if 0
2239                     if (!compareTypeExact (exargs->type, checkValue->type, -1))
2240                       return 0;
2241                     #endif
2242                   }
2243
2244                   /* if one them ended we have a problem */
2245                   if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2246                       (!exargs && acargs && !IS_VOID (acargs->type)))
2247                     return 0;
2248                   return 1;
2249               }
2250             return compareTypeExact (dest->next, src->next, level);
2251           }
2252           return 0;
2253         }
2254       return 0;
2255     }
2256
2257   /* if one is a specifier and the other is not */
2258   if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
2259       (IS_SPEC (dest) && !IS_SPEC (src)))
2260     return 0;
2261
2262   /* if one of them is a void then ok */
2263   if (SPEC_NOUN (dest) != SPEC_NOUN (src))
2264     return 0;
2265
2266   /* if they are both bitfields then if the lengths
2267      and starts don't match */
2268   if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
2269       (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
2270        SPEC_BSTR (dest) != SPEC_BSTR (src)))
2271     return 0;
2272
2273   if (IS_INTEGRAL (dest))
2274     {
2275       /* signedness must match */
2276       if (SPEC_USIGN (dest) != SPEC_USIGN (src))
2277         return 0;
2278       /* size must match */
2279       if (SPEC_LONG (dest) != SPEC_LONG (src))
2280         return 0;
2281       if (SPEC_SHORT (dest) != SPEC_SHORT (src))
2282         return 0;
2283     }
2284
2285   if (IS_STRUCT (dest))
2286     {
2287       if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
2288         return 0;
2289     }
2290
2291   if (SPEC_CONST (dest) != SPEC_CONST (src))
2292     return 0;
2293   if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
2294     return 0;
2295   if (SPEC_STAT (dest) != SPEC_STAT (src))
2296     return 0;
2297   if (SPEC_ABSA (dest) != SPEC_ABSA (src))
2298     return 0;
2299   if (SPEC_ABSA (dest) && SPEC_ADDR (dest) != SPEC_ADDR (src))
2300     return 0;
2301
2302   destScls = SPEC_SCLS (dest);
2303   srcScls = SPEC_SCLS (src);
2304
2305   /* Compensate for const to const code change in checkSClass() */
2306   if (!level & port->mem.code_ro && SPEC_CONST (dest))
2307     {
2308       if (srcScls == S_CODE && destScls == S_FIXED)
2309         destScls = S_CODE;
2310       if (destScls == S_CODE && srcScls == S_FIXED)
2311         srcScls = S_CODE;
2312     }
2313
2314   /* compensate for allocGlobal() */
2315   if ((srcScls == S_FIXED || srcScls == S_AUTO)
2316       && port->mem.default_globl_map == xdata
2317       && !level)
2318     srcScls = S_XDATA;
2319
2320   if (level>0 && !SPEC_STAT (dest))
2321     {
2322       /* Compensate for hack-o-matic in checkSClass() */
2323       if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
2324         {
2325           if (destScls == S_FIXED)
2326             destScls = (options.useXstack ? S_XSTACK : S_STACK);
2327           if (srcScls == S_FIXED)
2328             srcScls = (options.useXstack ? S_XSTACK : S_STACK);
2329         }
2330       else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
2331         {
2332           if (destScls == S_FIXED)
2333             destScls = S_XDATA;
2334           if (srcScls == S_FIXED)
2335             srcScls = S_XDATA;
2336         }
2337     }
2338
2339   if (srcScls != destScls)
2340     {
2341       #if 0
2342       printf ("level = %d\n", level);
2343       printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
2344                 SPEC_SCLS (src), SPEC_SCLS (dest));
2345       printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
2346       #endif
2347       return 0;
2348     }
2349
2350   return 1;
2351 }
2352
2353 /*------------------------------------------------------------------*/
2354 /* inCalleeSaveList - return 1 if found in callee save list         */
2355 /*------------------------------------------------------------------*/
2356 static int
2357 calleeCmp(void *p1, void *p2)
2358 {
2359   return (strcmp((char *)p1, (char *)(p2)) == 0);
2360 }
2361
2362 bool
2363 inCalleeSaveList(char *s)
2364 {
2365   if (options.all_callee_saves)
2366     return 1;
2367   return isinSetWith(options.calleeSavesSet, s, calleeCmp);
2368 }
2369
2370 /*-----------------------------------------------------------------*/
2371 /* aggregateToPointer:     change an aggregate type function       */
2372 /*                         argument to a pointer to that type.     */
2373 /*-----------------------------------------------------------------*/
2374 value *
2375 aggregateToPointer (value * val)
2376 {
2377   if (IS_AGGREGATE (val->type))
2378     {
2379       /* if this is a structure */
2380       /* then we need to add a new link */
2381       if (IS_STRUCT (val->type))
2382         {
2383           /* first lets add DECLARATOR type */
2384           sym_link *p = val->type;
2385
2386           werror (W_STRUCT_AS_ARG, val->name);
2387           val->type = newLink (DECLARATOR);
2388           val->type->next = p;
2389         }
2390
2391       /* change to a pointer depending on the */
2392       /* storage class specified        */
2393       switch (SPEC_SCLS (val->etype))
2394         {
2395         case S_IDATA:
2396           DCL_TYPE (val->type) = IPOINTER;
2397           break;
2398         case S_PDATA:
2399           DCL_TYPE (val->type) = PPOINTER;
2400           break;
2401         case S_FIXED:
2402           if (SPEC_OCLS(val->etype)) {
2403             DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
2404           } else {
2405             // this happens for (external) function parameters
2406             DCL_TYPE (val->type) = port->unqualified_pointer;
2407           }
2408           break;
2409         case S_AUTO:
2410         case S_DATA:
2411         case S_REGISTER:
2412           DCL_TYPE (val->type) = POINTER;
2413           break;
2414         case S_CODE:
2415           DCL_TYPE (val->type) = CPOINTER;
2416           break;
2417         case S_XDATA:
2418           DCL_TYPE (val->type) = FPOINTER;
2419           break;
2420         case S_EEPROM:
2421           DCL_TYPE (val->type) = EEPPOINTER;
2422           break;
2423         default:
2424           DCL_TYPE (val->type) = port->unqualified_pointer;
2425         }
2426
2427       /* is there is a symbol associated then */
2428       /* change the type of the symbol as well */
2429       if (val->sym)
2430         {
2431           val->sym->type = copyLinkChain (val->type);
2432           val->sym->etype = getSpec (val->sym->type);
2433         }
2434     }
2435   return val;
2436 }
2437 /*------------------------------------------------------------------*/
2438 /* checkFunction - does all kinds of check on a function            */
2439 /*------------------------------------------------------------------*/
2440 int
2441 checkFunction (symbol * sym, symbol *csym)
2442 {
2443   value *exargs, *acargs;
2444   value *checkValue;
2445   int argCnt = 0;
2446
2447   if (getenv("DEBUG_SANITY")) {
2448     fprintf (stderr, "checkFunction: %s ", sym->name);
2449   }
2450
2451   if (!IS_DECL(sym->type) || DCL_TYPE(sym->type)!=FUNCTION)
2452     {
2453       werror(E_SYNTAX_ERROR, sym->name);
2454       return 0;
2455     }
2456
2457   /* move inline specifier from return type to function attributes */
2458   if (IS_INLINE (sym->etype))
2459     {
2460       SPEC_INLINE (sym->etype) = 0;
2461       FUNC_ISINLINE (sym->type) = 1;
2462     }
2463
2464   /* make sure the type is complete and sane */
2465   checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
2466
2467   /* if not type then some kind of error */
2468   if (!sym->type)
2469     return 0;
2470
2471   /* if the function has no type then make it return int */
2472   if (!sym->type->next)
2473     sym->type->next = sym->etype = newIntLink ();
2474
2475   /* function cannot return aggregate */
2476   if (IS_AGGREGATE (sym->type->next))
2477     {
2478       werror (E_FUNC_AGGR, sym->name);
2479       return 0;
2480     }
2481
2482   /* check if this function is defined as calleeSaves
2483      then mark it as such */
2484   FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
2485
2486   /* if interrupt service routine  */
2487   /* then it cannot have arguments */
2488   if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
2489     {
2490       if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
2491         werror (E_INT_ARGS, sym->name);
2492         FUNC_ARGS(sym->type)=NULL;
2493       }
2494     }
2495
2496   if (IFFUNC_ISSHADOWREGS(sym->type) && !FUNC_ISISR (sym->type))
2497     {
2498       werror (E_SHADOWREGS_NO_ISR, sym->name);
2499     }
2500
2501   for (argCnt=1, acargs = FUNC_ARGS(sym->type);
2502        acargs;
2503        acargs=acargs->next, argCnt++) {
2504     if (!acargs->sym) {
2505       // this can happen for reentrant functions
2506       werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2507       // the show must go on: synthesize a name and symbol
2508       SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
2509       acargs->sym = newSymbol (acargs->name, 1);
2510       SPEC_OCLS (acargs->etype) = istack;
2511       acargs->sym->type = copyLinkChain (acargs->type);
2512       acargs->sym->etype = getSpec (acargs->sym->type);
2513       acargs->sym->_isparm = 1;
2514       strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
2515     } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
2516       // synthesized name
2517       werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
2518     }
2519   }
2520   argCnt--;
2521
2522   /*JCF: Mark the register bank as used*/
2523   RegBankUsed[FUNC_REGBANK (sym->type)] = 1;
2524
2525   if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
2526     return 1;                   /* not defined nothing more to check  */
2527
2528   /* check if body already present */
2529   if (csym && IFFUNC_HASBODY(csym->type))
2530     {
2531       werror (E_FUNC_BODY, sym->name);
2532       return 0;
2533     }
2534
2535   /* check the return value type   */
2536   if (compareType (csym->type, sym->type) <= 0)
2537     {
2538       werror (E_PREV_DEF_CONFLICT, csym->name, "type");
2539       printFromToType(csym->type, sym->type);
2540       return 0;
2541     }
2542
2543   if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
2544     {
2545       werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
2546     }
2547
2548   /* I don't think this is necessary for interrupts. An isr is a  */
2549   /* root in the calling tree.                                    */
2550   if ((FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type)) &&
2551       (!FUNC_ISISR (sym->type)))
2552     {
2553       werror (E_PREV_DEF_CONFLICT, csym->name, "using");
2554     }
2555
2556   if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
2557     {
2558       werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
2559     }
2560
2561   /* Really, reentrant should match regardless of argCnt, but     */
2562   /* this breaks some existing code (the fp lib functions). If    */
2563   /* the first argument is always passed the same way, this       */
2564   /* lax checking is ok (but may not be true for in future ports) */
2565   if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
2566       && argCnt>1)
2567     {
2568       //printf("argCnt = %d\n",argCnt);
2569       werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
2570     }
2571
2572   if (IFFUNC_ISWPARAM (csym->type) != IFFUNC_ISWPARAM (sym->type))
2573     {
2574       werror (E_PREV_DEF_CONFLICT, csym->name, "wparam");
2575     }
2576
2577   if (IFFUNC_ISSHADOWREGS (csym->type) != IFFUNC_ISSHADOWREGS (sym->type))
2578     {
2579       werror (E_PREV_DEF_CONFLICT, csym->name, "shadowregs");
2580     }
2581
2582
2583   /* compare expected args with actual args */
2584   exargs = FUNC_ARGS(csym->type);
2585   acargs = FUNC_ARGS(sym->type);
2586
2587   /* for all the expected args do */
2588   for (argCnt = 1;
2589        exargs && acargs;
2590        exargs = exargs->next, acargs = acargs->next, argCnt++)
2591     {
2592       if (getenv("DEBUG_SANITY")) {
2593         fprintf (stderr, "checkFunction: %s ", exargs->name);
2594       }
2595       /* make sure the type is complete and sane */
2596       checkTypeSanity(exargs->etype, exargs->name);
2597
2598       /* If the actual argument is an array, any prototype
2599        * will have modified it to a pointer. Duplicate that
2600        * change here.
2601        */
2602       if (IS_AGGREGATE (acargs->type))
2603         {
2604           checkValue = copyValue (acargs);
2605           aggregateToPointer (checkValue);
2606         }
2607       else
2608         {
2609           checkValue = acargs;
2610         }
2611
2612       if (compareType (exargs->type, checkValue->type) <= 0)
2613         {
2614           werror (E_ARG_TYPE, argCnt);
2615           printFromToType(exargs->type, checkValue->type);
2616           return 0;
2617         }
2618     }
2619
2620   /* if one them ended we have a problem */
2621   if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
2622       (!exargs && acargs && !IS_VOID (acargs->type)))
2623     werror (E_ARG_COUNT);
2624
2625   /* replace with this defition */
2626   sym->cdef = csym->cdef;
2627   deleteSym (SymbolTab, csym, csym->name);
2628   deleteFromSeg(csym);
2629   addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2630   if (IS_EXTERN (csym->etype) && !
2631       IS_EXTERN (sym->etype))
2632     {
2633       addSet (&publics, sym);
2634     }
2635   return 1;
2636 }
2637
2638 /*------------------------------------------------------------------*/
2639 /* cdbStructBlock - calls struct printing for a blcks               */
2640 /*------------------------------------------------------------------*/
2641 void cdbStructBlock (int block)
2642 {
2643   int i;
2644   bucket **table = StructTab;
2645   bucket *chain;
2646
2647   /* go thru the entire  table  */
2648   for (i = 0; i < 256; i++)
2649     {
2650       for (chain = table[i]; chain; chain = chain->next)
2651         {
2652           if (chain->block >= block)
2653             {
2654               if(debugFile)
2655                 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2656             }
2657         }
2658     }
2659 }
2660
2661 /*-----------------------------------------------------------------*/
2662 /* processFuncPtrArgs - does some processing with args of func ptrs*/
2663 /*-----------------------------------------------------------------*/
2664 void
2665 processFuncPtrArgs (sym_link * funcType)
2666 {
2667   value *val = FUNC_ARGS(funcType);
2668
2669   /* if it is void then remove parameters */
2670   if (val && IS_VOID (val->type))
2671     {
2672       FUNC_ARGS(funcType) = NULL;
2673       return;
2674     }
2675 }
2676
2677 /*-----------------------------------------------------------------*/
2678 /* processFuncArgs - does some processing with function args       */
2679 /*-----------------------------------------------------------------*/
2680 void
2681 processFuncArgs (symbol * func)
2682 {
2683   value *val;
2684   int pNum = 1;
2685   sym_link *funcType=func->type;
2686
2687   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2688     fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2689
2690   /* find the function declaration within the type */
2691   while (funcType && !IS_FUNC(funcType))
2692     funcType=funcType->next;
2693
2694   /* if this function has variable argument list */
2695   /* then make the function a reentrant one    */
2696   if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2697     FUNC_ISREENT(funcType)=1;
2698
2699   /* check if this function is defined as calleeSaves
2700      then mark it as such */
2701   FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2702
2703   /* loop thru all the arguments   */
2704   val = FUNC_ARGS(funcType);
2705
2706   /* if it is void then remove parameters */
2707   if (val && IS_VOID (val->type))
2708     {
2709       FUNC_ARGS(funcType) = NULL;
2710       return;
2711     }
2712
2713   /* reset regparm for the port */
2714   (*port->reset_regparms) ();
2715
2716   /* if any of the arguments is an aggregate */
2717   /* change it to pointer to the same type */
2718   while (val)
2719     {
2720       int argreg = 0;
2721       char buffer[SDCC_NAME_MAX+1];
2722
2723       SNPRINTF (buffer, sizeof(buffer), "%s parameter %d", func->name, pNum);
2724       checkTypeSanity (val->etype, buffer);
2725
2726       /* mark it as a register parameter if
2727          the function does not have VA_ARG
2728          and as port dictates */
2729       if (!IFFUNC_HASVARARGS(funcType) &&
2730           (argreg = (*port->reg_parm) (val->type, FUNC_ISREENT(funcType))))
2731         {
2732           SPEC_REGPARM (val->etype) = 1;
2733           SPEC_ARGREG(val->etype) = argreg;
2734         } else if (IFFUNC_ISREENT(funcType)) {
2735             FUNC_HASSTACKPARM(funcType) = 1;
2736         }
2737
2738       if (IS_AGGREGATE (val->type))
2739         {
2740           aggregateToPointer (val);
2741         }
2742
2743       val = val->next;
2744       pNum++;
2745     }
2746
2747   /* if this is an internal generated function call */
2748   if (func->cdef) {
2749     /* ignore --stack-auto for this one, we don't know how it is compiled */
2750     /* simply trust on --int-long-reent or --float-reent */
2751     if (IFFUNC_ISREENT(funcType)) {
2752       return;
2753     }
2754   } else {
2755     /* if this function is reentrant or */
2756     /* automatics r 2b stacked then nothing */
2757     if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2758       return;
2759   }
2760
2761   val = FUNC_ARGS(funcType);
2762   pNum = 1;
2763   while (val)
2764     {
2765
2766       /* if a symbolname is not given  */
2767       /* synthesize a variable name */
2768       if (!val->sym)
2769         {
2770           SNPRINTF (val->name, sizeof(val->name),
2771                     "_%s_PARM_%d", func->name, pNum++);
2772           val->sym = newSymbol (val->name, 1);
2773           if (SPEC_SCLS(val->etype) == S_BIT)
2774             SPEC_OCLS (val->etype) = bit;
2775           else
2776             SPEC_OCLS (val->etype) = port->mem.default_local_map;
2777           val->sym->type = copyLinkChain (val->type);
2778           val->sym->etype = getSpec (val->sym->type);
2779           val->sym->_isparm = 1;
2780           strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2781           #if 0
2782           /* ?? static functions shouldn't imply static parameters - EEP */
2783           if (IS_SPEC(func->etype)) {
2784             SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2785               SPEC_STAT (func->etype);
2786           }
2787           #endif
2788           addSymChain (&val->sym);
2789
2790         }
2791       else                      /* symbol name given create synth name */
2792         {
2793
2794           SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2795           strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2796           val->sym->_isparm = 1;
2797           if (SPEC_SCLS(val->etype) == S_BIT)
2798             SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) = bit;
2799           else
2800             SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2801               port->mem.default_local_map;
2802
2803           #if 0
2804           /* ?? static functions shouldn't imply static parameters - EEP */
2805           if (IS_SPEC(func->etype)) {
2806             SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2807               SPEC_STAT (func->etype);
2808           }
2809           #endif
2810         }
2811       if (SPEC_OCLS (val->sym->etype) == pdata)
2812         val->sym->iaccess = 1;
2813       if (!isinSet(operKeyReset, val->sym)) {
2814         addSet (&operKeyReset, val->sym);
2815         applyToSet (operKeyReset, resetParmKey);
2816       }
2817       val = val->next;
2818     }
2819 }
2820
2821 /*-----------------------------------------------------------------*/
2822 /* isSymbolEqual - compares two symbols return 1 if they match     */
2823 /*-----------------------------------------------------------------*/
2824 int
2825 isSymbolEqual (symbol * dest, symbol * src)
2826 {
2827   /* if pointers match then equal */
2828   if (dest == src)
2829     return 1;
2830
2831   /* if one of them is null then don't match */
2832   if (!dest || !src)
2833     return 0;
2834
2835   /* if both of them have rname match on rname */
2836   if (dest->rname[0] && src->rname[0])
2837     return (!strcmp (dest->rname, src->rname));
2838
2839   /* otherwise match on name */
2840   return (!strcmp (dest->name, src->name));
2841 }
2842
2843 void PT(sym_link *type)
2844 {
2845         printTypeChain(type,0);
2846 }
2847 /*-----------------------------------------------------------------*/
2848 /* printTypeChain - prints the type chain in human readable form   */
2849 /*-----------------------------------------------------------------*/
2850 void
2851 printTypeChain (sym_link * start, FILE * of)
2852 {
2853   struct dbuf_s dbuf;
2854   int nlr = 0;
2855
2856   if (!of)
2857     {
2858       of = stdout;
2859       nlr = 1;
2860     }
2861
2862   dbuf_init (&dbuf, 1024);
2863   dbuf_printTypeChain (start, &dbuf);
2864   dbuf_write_and_destroy (&dbuf, of);
2865
2866   if (nlr)
2867     putc ('\n', of);
2868 }
2869
2870 void
2871 dbuf_printTypeChain (sym_link * start, struct dbuf_s *dbuf)
2872 {
2873   value *args;
2874   sym_link * type, * search;
2875   STORAGE_CLASS scls;
2876
2877   if (start==NULL) {
2878     dbuf_append_str (dbuf, "void");
2879     return;
2880   }
2881
2882   /* Print the chain as it is written in the source: */
2883   /* start with the last entry.                      */
2884   /* However, the storage class at the end of the    */
2885   /* chain reall applies to the first in the chain!  */
2886
2887   for (type = start; type && type->next; type = type->next)
2888     ;
2889   if (IS_SPEC (type))
2890     scls=SPEC_SCLS(type);
2891   else
2892     scls=0;
2893   while (type)
2894     {
2895       if (type==start) {
2896         switch (scls)
2897           {
2898           case S_DATA: dbuf_append_str (dbuf, "data-"); break;
2899           case S_XDATA: dbuf_append_str (dbuf, "xdata-"); break;
2900           case S_SFR: dbuf_append_str (dbuf, "sfr-"); break;
2901           case S_SBIT: dbuf_append_str (dbuf, "sbit-"); break;
2902           case S_CODE: dbuf_append_str (dbuf, "code-"); break;
2903           case S_IDATA: dbuf_append_str (dbuf, "idata-"); break;
2904           case S_PDATA: dbuf_append_str (dbuf, "pdata-"); break;
2905           case S_LITERAL: dbuf_append_str (dbuf, "literal-"); break;
2906           case S_STACK: dbuf_append_str (dbuf, "stack-"); break;
2907           case S_XSTACK: dbuf_append_str (dbuf, "xstack-"); break;
2908           case S_BIT: dbuf_append_str (dbuf, "bit-"); break;
2909           case S_EEPROM: dbuf_append_str (dbuf, "eeprom-"); break;
2910           default: break;
2911           }
2912       }
2913
2914       if (IS_DECL (type))
2915         {
2916           if (!IS_FUNC(type)) {
2917             if (DCL_PTR_VOLATILE (type)) {
2918               dbuf_append_str (dbuf, "volatile-");
2919             }
2920             if (DCL_PTR_CONST (type)) {
2921               dbuf_append_str (dbuf, "const-");
2922             }
2923             if (DCL_PTR_RESTRICT (type)) {
2924               dbuf_append_str (dbuf, "restrict-");
2925             }
2926           }
2927           switch (DCL_TYPE (type))
2928             {
2929             case FUNCTION:
2930               dbuf_printf (dbuf, "function %s %s",
2931                        (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2932                        (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2933               dbuf_append_str (dbuf, "( ");
2934               for (args = FUNC_ARGS(type);
2935                    args;
2936                    args=args->next) {
2937                 dbuf_printTypeChain(args->type, dbuf);
2938                 if (args->next)
2939                   dbuf_append_str (dbuf, ", ");
2940               }
2941               dbuf_append_str (dbuf, ") ");
2942               break;
2943             case GPOINTER:
2944               dbuf_append_str (dbuf, "generic* ");
2945               break;
2946             case CPOINTER:
2947               dbuf_append_str (dbuf, "code* ");
2948               break;
2949             case FPOINTER:
2950               dbuf_append_str (dbuf, "xdata* ");
2951               break;
2952             case EEPPOINTER:
2953               dbuf_append_str (dbuf, "eeprom* ");
2954               break;
2955             case POINTER:
2956               dbuf_append_str (dbuf, "near* ");
2957               break;
2958             case IPOINTER:
2959               dbuf_append_str (dbuf, "idata* ");
2960               break;
2961             case PPOINTER:
2962               dbuf_append_str (dbuf, "pdata* ");
2963               break;
2964             case UPOINTER:
2965               dbuf_append_str (dbuf, "unknown* ");
2966               break;
2967             case ARRAY:
2968               if (DCL_ELEM(type)) {
2969                 dbuf_printf (dbuf, "[%d] ", DCL_ELEM(type));
2970               } else {
2971                 dbuf_append_str (dbuf, "[] ");
2972               }
2973               break;
2974             }
2975         }
2976       else
2977         {
2978           if (SPEC_VOLATILE (type))
2979             dbuf_append_str (dbuf, "volatile-");
2980           if (SPEC_CONST (type))
2981             dbuf_append_str (dbuf, "const-");
2982           if (SPEC_USIGN (type))
2983             dbuf_append_str (dbuf, "unsigned-");
2984           switch (SPEC_NOUN (type))
2985             {
2986             case V_INT:
2987               if (IS_LONG (type))
2988                 dbuf_append_str (dbuf, "long-");
2989               dbuf_append_str (dbuf, "int");
2990               break;
2991
2992             case V_CHAR:
2993               dbuf_append_str (dbuf, "char");
2994               break;
2995
2996             case V_VOID:
2997               dbuf_append_str (dbuf, "void");
2998               break;
2999
3000             case V_FLOAT:
3001               dbuf_append_str (dbuf, "float");
3002               break;
3003
3004             case V_FIXED16X16:
3005               dbuf_append_str (dbuf, "fixed16x16");
3006               break;
3007
3008             case V_STRUCT:
3009               dbuf_printf (dbuf, "struct %s", SPEC_STRUCT (type)->tag);
3010               break;
3011
3012             case V_SBIT:
3013               dbuf_append_str (dbuf, "sbit");
3014               break;
3015
3016             case V_BIT:
3017               dbuf_append_str (dbuf, "bit");
3018               break;
3019
3020             case V_BITFIELD:
3021               dbuf_printf (dbuf, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3022               break;
3023
3024             case V_DOUBLE:
3025               dbuf_append_str (dbuf, "double");
3026               break;
3027
3028             default:
3029               dbuf_append_str (dbuf, "unknown type");
3030               break;
3031             }
3032         }
3033       /* search entry in list before "type" */
3034       for (search = start; search && search->next != type;)
3035         search = search->next;
3036       type = search;
3037       if (type)
3038           dbuf_append_char(dbuf, ' ');
3039     }
3040 }
3041
3042 /*--------------------------------------------------------------------*/
3043 /* printTypeChainRaw - prints the type chain in human readable form   */
3044 /*                     in the raw data structure ordering             */
3045 /*--------------------------------------------------------------------*/
3046 void
3047 printTypeChainRaw (sym_link * start, FILE * of)
3048 {
3049   int nlr = 0;
3050   value *args;
3051   sym_link * type;
3052
3053   if (!of)
3054     {
3055       of = stdout;
3056       nlr = 1;
3057     }
3058
3059   if (start==NULL) {
3060     fprintf (of, "void");
3061     return;
3062   }
3063
3064   type = start;
3065
3066   while (type)
3067     {
3068       if (IS_DECL (type))
3069         {
3070           if (!IS_FUNC(type)) {
3071             if (DCL_PTR_VOLATILE (type)) {
3072               fprintf (of, "volatile-");
3073             }
3074             if (DCL_PTR_CONST (type)) {
3075               fprintf (of, "const-");
3076             }
3077             if (DCL_PTR_RESTRICT (type)) {
3078               fprintf (of, "restrict-");
3079             }
3080           }
3081           switch (DCL_TYPE (type))
3082             {
3083             case FUNCTION:
3084               if (IFFUNC_ISINLINE(type)) {
3085                 fprintf (of, "inline-");
3086               }
3087               fprintf (of, "function %s %s",
3088                        (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
3089                        (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
3090               fprintf (of, "( ");
3091               for (args = FUNC_ARGS(type);
3092                    args;
3093                    args=args->next) {
3094                 printTypeChain(args->type, of);
3095                 if (args->next)
3096                   fprintf(of, ", ");
3097               }
3098               fprintf (of, ") ");
3099               break;
3100             case GPOINTER:
3101               fprintf (of, "generic* ");
3102               break;
3103             case CPOINTER:
3104               fprintf (of, "code* ");
3105               break;
3106             case FPOINTER:
3107               fprintf (of, "xdata* ");
3108               break;
3109             case EEPPOINTER:
3110               fprintf (of, "eeprom* ");
3111               break;
3112             case POINTER:
3113               fprintf (of, "near* ");
3114               break;
3115             case IPOINTER:
3116               fprintf (of, "idata* ");
3117               break;
3118             case PPOINTER:
3119               fprintf (of, "pdata* ");
3120               break;
3121             case UPOINTER:
3122               fprintf (of, "unknown* ");
3123               break;
3124             case ARRAY:
3125               if (DCL_ELEM(type)) {
3126                 fprintf (of, "[%d] ", DCL_ELEM(type));
3127               } else {
3128                 fprintf (of, "[] ");
3129               }
3130               break;
3131             }
3132           if (DCL_TSPEC(type))
3133             {
3134               fprintf (of, "{");
3135               printTypeChainRaw(DCL_TSPEC(type), of);
3136               fprintf (of, "}");
3137             }
3138         }
3139       else if (IS_SPEC (type))
3140         {
3141         switch (SPEC_SCLS (type))
3142           {
3143           case S_DATA: fprintf (of, "data-"); break;
3144           case S_XDATA: fprintf (of, "xdata-"); break;
3145           case S_SFR: fprintf (of, "sfr-"); break;
3146           case S_SBIT: fprintf (of, "sbit-"); break;
3147           case S_CODE: fprintf (of, "code-"); break;
3148           case S_IDATA: fprintf (of, "idata-"); break;
3149           case S_PDATA: fprintf (of, "pdata-"); break;
3150           case S_LITERAL: fprintf (of, "literal-"); break;
3151           case S_STACK: fprintf (of, "stack-"); break;
3152           case S_XSTACK: fprintf (of, "xstack-"); break;
3153           case S_BIT: fprintf (of, "bit-"); break;
3154           case S_EEPROM: fprintf (of, "eeprom-"); break;
3155           default: break;
3156           }
3157           if (SPEC_VOLATILE (type))
3158             fprintf (of, "volatile-");
3159           if (SPEC_CONST (type))
3160             fprintf (of, "const-");
3161           if (SPEC_USIGN (type))
3162             fprintf (of, "unsigned-");
3163           switch (SPEC_NOUN (type))
3164             {
3165             case V_INT:
3166               if (IS_LONG (type))
3167                 fprintf (of, "long-");
3168               fprintf (of, "int");
3169               break;
3170
3171             case V_CHAR:
3172               fprintf (of, "char");
3173               break;
3174
3175             case V_VOID:
3176               fprintf (of, "void");
3177               break;
3178
3179             case V_FLOAT:
3180               fprintf (of, "float");
3181               break;
3182
3183             case V_FIXED16X16:
3184               fprintf (of, "fixed16x16");
3185               break;
3186
3187             case V_STRUCT:
3188               fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
3189               break;
3190
3191             case V_SBIT:
3192               fprintf (of, "sbit");
3193               break;
3194
3195             case V_BIT:
3196               fprintf (of, "bit");
3197               break;
3198
3199             case V_BITFIELD:
3200               fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
3201               break;
3202
3203             case V_DOUBLE:
3204               fprintf (of, "double");
3205               break;
3206
3207             default:
3208               fprintf (of, "unknown type");
3209               break;
3210             }
3211         }
3212       else
3213         fprintf (of, "NOT_SPEC_OR_DECL");
3214       type = type->next;
3215       if (type)
3216         fputc (' ', of);
3217     }
3218   if (nlr)
3219     fprintf (of, "\n");
3220 }
3221
3222
3223 /*-----------------------------------------------------------------*/
3224 /* powof2 - returns power of two for the number if number is pow 2 */
3225 /*-----------------------------------------------------------------*/
3226 int
3227 powof2 (TYPE_TARGET_ULONG num)
3228 {
3229   int nshifts = 0;
3230   int n1s = 0;
3231
3232   while (num)
3233     {
3234       if (num & 1)
3235         n1s++;
3236       num >>= 1;
3237       nshifts++;
3238     }
3239
3240   if (n1s > 1 || nshifts == 0)
3241     return -1;
3242   return nshifts - 1;
3243 }
3244
3245 symbol *__fsadd;
3246 symbol *__fssub;
3247 symbol *__fsmul;
3248 symbol *__fsdiv;
3249 symbol *__fseq;
3250 symbol *__fsneq;
3251 symbol *__fslt;
3252 symbol *__fslteq;
3253 symbol *__fsgt;
3254 symbol *__fsgteq;
3255
3256 symbol *__fps16x16_add;
3257 symbol *__fps16x16_sub;
3258 symbol *__fps16x16_mul;
3259 symbol *__fps16x16_div;
3260 symbol *__fps16x16_eq;
3261 symbol *__fps16x16_neq;
3262 symbol *__fps16x16_lt;
3263 symbol *__fps16x16_lteq;
3264 symbol *__fps16x16_gt;
3265 symbol *__fps16x16_gteq;
3266
3267 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3268 symbol *__muldiv[3][3][2];
3269 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
3270 sym_link *__multypes[3][2];
3271 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
3272 symbol *__conv[2][3][2];
3273 /* Dims: to/from fixed16x16, BYTE/WORD/DWORD/FLOAT, SIGNED/USIGNED */
3274 symbol *__fp16x16conv[2][4][2];
3275 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
3276 symbol *__rlrr[2][3][2];
3277
3278 sym_link *floatType;
3279 sym_link *fixed16x16Type;
3280
3281 static char *
3282 _mangleFunctionName(char *in)
3283 {
3284   if (port->getMangledFunctionName)
3285     {
3286       return port->getMangledFunctionName(in);
3287     }
3288   else
3289     {
3290       return in;
3291     }
3292 }
3293
3294 /*-----------------------------------------------------------------*/
3295 /* typeFromStr - create a typechain from an encoded string         */
3296 /* basic types -        'c' - char                                 */
3297 /*                      's' - short                                */
3298 /*                      'i' - int                                  */
3299 /*                      'l' - long                                 */
3300 /*                      'f' - float                                */
3301 /*                      'q' - fixed16x16                           */
3302 /*                      'v' - void                                 */
3303 /*                      '*' - pointer - default (GPOINTER)         */
3304 /* modifiers -          'u' - unsigned                             */
3305 /* pointer modifiers -  'g' - generic                              */
3306 /*                      'x' - xdata                                */
3307 /*                      'p' - code                                 */
3308 /*                      'd' - data                                 */
3309 /*                      'F' - function                             */
3310 /* examples : "ig*" - generic int *                                */
3311 /*            "cx*" - char xdata *                                 */
3312 /*            "ui" -  unsigned int                                 */
3313 /*-----------------------------------------------------------------*/
3314 sym_link *typeFromStr (char *s)
3315 {
3316     sym_link *r = newLink(DECLARATOR);
3317     int usign = 0;
3318
3319     do {
3320         sym_link *nr;
3321         switch (*s) {
3322         case 'u' :
3323             usign = 1;
3324             s++;
3325             continue ;
3326             break ;
3327         case 'c':
3328             r->class = SPECIFIER;
3329             SPEC_NOUN(r) = V_CHAR;
3330             break;
3331         case 's':
3332         case 'i':
3333             r->class = SPECIFIER;
3334             SPEC_NOUN(r) = V_INT;
3335             break;
3336         case 'l':
3337             r->class = SPECIFIER;
3338             SPEC_NOUN(r) = V_INT;
3339             SPEC_LONG(r) = 1;
3340             break;
3341         case 'f':
3342             r->class = SPECIFIER;
3343             SPEC_NOUN(r) = V_FLOAT;
3344             break;
3345         case 'q':
3346             r->class = SPECIFIER;
3347             SPEC_NOUN(r) = V_FIXED16X16;
3348             break;
3349         case 'v':
3350             r->class = SPECIFIER;
3351             SPEC_NOUN(r) = V_VOID;
3352             break;
3353         case '*':
3354             DCL_TYPE(r) = port->unqualified_pointer;
3355             break;
3356         case 'g':
3357         case 'x':
3358         case 'p':
3359         case 'd':
3360         case 'F':
3361             assert(*(s+1)=='*');
3362             nr = newLink(DECLARATOR);
3363             nr->next = r;
3364             r = nr;
3365             switch (*s) {
3366             case 'g':
3367                 DCL_TYPE(r) = GPOINTER;
3368                 break;
3369             case 'x':
3370                 DCL_TYPE(r) = FPOINTER;
3371                 break;
3372             case 'p':
3373                 DCL_TYPE(r) = CPOINTER;
3374                 break;
3375             case 'd':
3376                 DCL_TYPE(r) = POINTER;
3377                 break;
3378             case 'F':
3379                 DCL_TYPE(r) = FUNCTION;
3380                 nr = newLink(DECLARATOR);
3381                 nr->next = r;
3382                 r = nr;
3383                 DCL_TYPE(r) = CPOINTER;
3384                 break;
3385             }
3386             s++;
3387             break;
3388         default:
3389             werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
3390                    "typeFromStr: unknown type");
3391             break;
3392         }
3393         if (IS_SPEC(r) && usign) {
3394             SPEC_USIGN(r) = 1;
3395             usign = 0;
3396         }
3397         s++;
3398     } while (*s);
3399     return r;
3400 }
3401
3402 /*-----------------------------------------------------------------*/
3403 /* initCSupport - create functions for C support routines          */
3404 /*-----------------------------------------------------------------*/
3405 void
3406 initCSupport ()
3407 {
3408   const char *smuldivmod[] =
3409   {
3410     "mul", "div", "mod"
3411   };
3412   const char *sbwd[] =
3413   {
3414     "char", "int", "long", "fixed16x16",
3415   };
3416   const char *fp16x16sbwd[] =
3417   {
3418     "char", "int", "long", "float",
3419   };
3420   const char *ssu[] =
3421   {
3422     "s", "u"
3423   };
3424   const char *srlrr[] =
3425   {
3426     "rl", "rr"
3427   };
3428
3429   int bwd, su, muldivmod, tofrom, rlrr;
3430
3431   if (getenv("SDCC_NO_C_SUPPORT")) {
3432     /* for debugging only */
3433     return;
3434   }
3435
3436   floatType = newFloatLink ();
3437   fixed16x16Type = newFixed16x16Link ();
3438
3439   for (bwd = 0; bwd < 3; bwd++)
3440     {
3441       sym_link *l = NULL;
3442       switch (bwd)
3443         {
3444         case 0:
3445           l = newCharLink ();
3446           break;
3447         case 1:
3448           l = newIntLink ();
3449           break;
3450         case 2:
3451           l = newLongLink ();
3452           break;
3453         default:
3454           assert (0);
3455         }
3456       __multypes[bwd][0] = l;
3457       __multypes[bwd][1] = copyLinkChain (l);
3458       SPEC_USIGN (__multypes[bwd][1]) = 1;
3459     }
3460
3461   __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
3462   __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
3463   __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
3464   __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
3465   __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
3466   __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
3467   __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
3468   __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
3469   __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
3470   __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
3471
3472   __fps16x16_add = funcOfType ("__fps16x16_add", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3473   __fps16x16_sub = funcOfType ("__fps16x16_sub", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3474   __fps16x16_mul = funcOfType ("__fps16x16_mul", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3475   __fps16x16_div = funcOfType ("__fps16x16_div", fixed16x16Type, fixed16x16Type, 2, options.float_rent);
3476   __fps16x16_eq = funcOfType ("__fps16x16_eq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3477   __fps16x16_neq = funcOfType ("__fps16x16_neq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3478   __fps16x16_lt = funcOfType ("__fps16x16_lt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3479   __fps16x16_lteq = funcOfType ("__fps16x16_lteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3480   __fps16x16_gt = funcOfType ("__fps16x16_gt", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3481   __fps16x16_gteq = funcOfType ("__fps16x16_gteq", CHARTYPE, fixed16x16Type, 2, options.float_rent);
3482
3483
3484   for (tofrom = 0; tofrom < 2; tofrom++)
3485     {
3486       for (bwd = 0; bwd < 3; bwd++)
3487         {
3488           for (su = 0; su < 2; su++)
3489             {
3490               if (tofrom)
3491                 {
3492                   SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
3493                   __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
3494                 }
3495               else
3496                 {
3497                   SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
3498                   __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
3499                 }
3500             }
3501         }
3502     }
3503
3504   for (tofrom = 0; tofrom < 2; tofrom++)
3505     {
3506       for (bwd = 0; bwd < 4; bwd++)
3507         {
3508           for (su = 0; su < 2; su++)
3509             {
3510               if (tofrom)
3511                 {
3512                   SNPRINTF (buffer, sizeof(buffer), "__fps16x162%s%s", ssu[su], fp16x16sbwd[bwd]);
3513                   if(bwd == 3) {
3514                     __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, floatType, fixed16x16Type, 1, options.float_rent);
3515                   } else
3516                     __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], fixed16x16Type, 1, options.float_rent);
3517                 }
3518               else
3519                 {
3520                   SNPRINTF (buffer, sizeof(buffer), "__%s%s2fps16x16", ssu[su], fp16x16sbwd[bwd]);
3521                   if(bwd == 3) {
3522                     __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, floatType, 1, options.float_rent);
3523                   } else
3524                     __fp16x16conv[tofrom][bwd][su] = funcOfType (buffer, fixed16x16Type, __multypes[bwd][su], 1, options.float_rent);
3525                 }
3526             }
3527         }
3528     }
3529
3530 /*
3531   for (muldivmod = 0; muldivmod < 3; muldivmod++)
3532     {
3533       for (bwd = 0; bwd < 3; bwd++)
3534         {
3535           for (su = 0; su < 2; su++)
3536             {
3537               SNPRINTF (buffer, sizeof(buffer),
3538                         "_%s%s%s",
3539                        smuldivmod[muldivmod],
3540                        ssu[su],
3541                        sbwd[bwd]);
3542               __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3543               FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3544             }
3545         }
3546     }
3547
3548   muluint() and mulsint() resp. mululong() and mulslong() return the same result.
3549   Therefore they've been merged into mulint() and mullong().
3550 */
3551
3552   for (bwd = 0; bwd < 3; bwd++)
3553     {
3554       for (su = 0; su < 2; su++)
3555         {
3556           for (muldivmod = 1; muldivmod < 3; muldivmod++)
3557             {
3558               /* div and mod : s8_t x s8_t -> s8_t should be s8_t x s8_t -> s16_t, see below */
3559               if (!TARGET_IS_PIC16 || muldivmod != 1 || bwd != 0 || su != 0)
3560               {
3561                 SNPRINTF (buffer, sizeof(buffer),
3562                     "_%s%s%s",
3563                     smuldivmod[muldivmod],
3564                     ssu[su],
3565                     sbwd[bwd]);
3566                 __muldiv[muldivmod][bwd][su] = funcOfType (
3567                     _mangleFunctionName(buffer),
3568                     __multypes[bwd][su],
3569                     __multypes[bwd][su],
3570                     2,
3571                     options.intlong_rent);
3572                 FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3573               }
3574             }
3575         }
3576     }
3577
3578   if (TARGET_IS_PIC16)
3579   {
3580     /* PIC16 port wants __divschar/__modschar to return an int, so that both
3581      * 100 / -4 = -25 and -128 / -1 = 128 can be handled correctly
3582      * (first one would have to be sign extended, second one must not be).
3583      * Similarly, modschar should be handled, but the iCode introduces cast
3584      * here and forces '% : s8 x s8 -> s8' ... */
3585     su = 0; bwd = 0;
3586     for (muldivmod = 1; muldivmod < 2; muldivmod++) {
3587       SNPRINTF (buffer, sizeof(buffer),
3588           "_%s%s%s",
3589           smuldivmod[muldivmod],
3590           ssu[su],
3591           sbwd[bwd]);
3592       __muldiv[muldivmod][bwd][su] = funcOfType (
3593           _mangleFunctionName(buffer),
3594           __multypes[1][su],
3595           __multypes[bwd][su],
3596           2,
3597           options.intlong_rent);
3598       FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3599     }
3600   }
3601
3602   /* mul only */
3603   muldivmod = 0;
3604   /* byte */
3605   bwd = 0;
3606   for (su = 0; su < 2; su++)
3607     {
3608       /* muluchar and mulschar are still separate functions, because e.g. the z80
3609          port is sign/zero-extending to int before calling mulint() */
3610       SNPRINTF (buffer, sizeof(buffer),
3611                 "_%s%s%s",
3612                 smuldivmod[muldivmod],
3613                 ssu[su],
3614                 sbwd[bwd]);
3615       __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3616       FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
3617     }
3618   /* signed only */
3619   su = 0;
3620   /* word and doubleword */
3621   for (bwd = 1; bwd < 3; bwd++)
3622     {
3623       /* mul, int/long */
3624       SNPRINTF (buffer, sizeof(buffer),
3625                 "_%s%s",
3626                 smuldivmod[muldivmod],
3627                 sbwd[bwd]);
3628       __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
3629       FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
3630       /* signed = unsigned */
3631       __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
3632     }
3633
3634   for (rlrr = 0; rlrr < 2; rlrr++)
3635     {
3636       for (bwd = 0; bwd < 3; bwd++)
3637         {
3638           for (su = 0; su < 2; su++)
3639             {
3640               SNPRINTF (buffer, sizeof(buffer),
3641                         "_%s%s%s",
3642                        srlrr[rlrr],
3643                        ssu[su],
3644                        sbwd[bwd]);
3645               __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
3646               FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
3647             }
3648         }
3649     }
3650 }
3651
3652 /*-----------------------------------------------------------------*/
3653 /* initBuiltIns - create prototypes for builtin functions          */
3654 /*-----------------------------------------------------------------*/
3655 void initBuiltIns()
3656 {
3657     int i;
3658     symbol *sym;
3659
3660     if (!port->builtintable) return ;
3661
3662     for (i = 0 ; port->builtintable[i].name ; i++) {
3663         sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
3664                              port->builtintable[i].nParms,port->builtintable[i].parm_types);
3665         FUNC_ISBUILTIN(sym->type) = 1;
3666         FUNC_ISREENT(sym->type) = 0;    /* can never be reentrant */
3667     }
3668 }
3669
3670 sym_link *validateLink(sym_link         *l,
3671                         const char      *macro,
3672                         const char      *args,
3673                         const char      select,
3674                         const char      *file,
3675                         unsigned        line)
3676 {
3677   if (l && l->class==select)
3678     {
3679         return l;
3680     }
3681     fprintf(stderr,
3682             "Internal error: validateLink failed in %s(%s) @ %s:%u:"
3683             " expected %s, got %s\n",
3684             macro, args, file, line,
3685             DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
3686     exit(EXIT_FAILURE);
3687     return l; // never reached, makes compiler happy.
3688 }
3689
3690 /*--------------------------------------------------------------------*/
3691 /* newEnumType - create an integer type compatible with enumerations  */
3692 /*--------------------------------------------------------------------*/
3693 sym_link *
3694 newEnumType (symbol *enumlist)
3695 {
3696   int min, max, v;
3697   symbol *sym;
3698   sym_link *type;
3699
3700   if (!enumlist)
3701     {
3702       type = newLink (SPECIFIER);
3703       SPEC_NOUN (type) = V_INT;
3704       return type;
3705     }
3706
3707   /* Determine the range of the enumerated values */
3708   sym = enumlist;
3709   min = max = (int) ulFromVal (valFromType (sym->type));
3710   for (sym = sym->next; sym; sym = sym->next)
3711     {
3712       v = (int) ulFromVal (valFromType (sym->type));
3713       if (v<min)
3714         min = v;
3715       if (v>max)
3716         max = v;
3717     }
3718
3719   /* Determine the smallest integer type that is compatible with this range */
3720   type = newLink (SPECIFIER);
3721   if (min>=0 && max<=255)
3722     {
3723       SPEC_NOUN (type) = V_CHAR;
3724       SPEC_USIGN (type) = 1;
3725     }
3726   else if (min>=-128 && max<=127)
3727     {
3728       SPEC_NOUN (type) = V_CHAR;
3729     }
3730   else if (min>=0 && max<=65535)
3731     {
3732       SPEC_NOUN (type) = V_INT;
3733       SPEC_USIGN (type) = 1;
3734     }
3735   else if (min>=-32768 && max<=32767)
3736     {
3737       SPEC_NOUN (type) = V_INT;
3738     }
3739   else
3740     {
3741       SPEC_NOUN (type) = V_INT;
3742       SPEC_LONG (type) = 1;
3743       if (min>=0)
3744         SPEC_USIGN (type) = 1;
3745     }
3746
3747   return type;
3748 }