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
  27 value *aggregateToPointer (value *val);
  28 void printTypeChainRaw (sym_link * start, FILE * of);
  29
  30 void printFromToType(sym_link *from, sym_link *to) {
  31   fprintf (stderr, "from type '");
  32   printTypeChain (from, stderr);
  33   fprintf (stderr, "'\nto type '");
  34   printTypeChain (to, stderr);
  35   fprintf (stderr, "'\n");
  36 }
  37
  38 /* noun strings */
  39 char *nounName(sym_link *sl) {
  40   switch (SPEC_NOUN(sl))
  41     {
  42     case V_INT: {
  43       if (SPEC_LONG(sl)) return "long";
  44       if (sl->select.s._short) return "short";
  45       return "int";
  46     }
  47     case V_FLOAT: return "float";
  48     case V_CHAR: return "char";
  49     case V_VOID: return "void";
  50     case V_STRUCT: return "struct";
  51     case V_LABEL: return "label";
  52     case V_BITFIELD: return "bitfield";
  53     case V_BIT: return "bit";
  54     case V_SBIT: return "sbit";
  55     case V_DOUBLE: return "double";
  56     }
  57   return "unknown";
  58 };
  59
  60 bucket *SymbolTab[256];         /* the symbol    table  */
  61 bucket *StructTab[256];         /* the structure table  */
  62 bucket *TypedefTab[256];        /* the typedef   table  */
  63 bucket *LabelTab[256];          /* the Label     table  */
  64 bucket *enumTab[256];           /* enumerated    table  */
  65
  66 /*------------------------------------------------------------------*/
  67 /* initSymt () - initialises symbol table related stuff             */
  68 /*------------------------------------------------------------------*/
  69 void
  70 initSymt ()
  71 {
  72   int i = 0;
  73
  74   for (i = 0; i < 256; i++)
  75     SymbolTab[i] = StructTab[i] = (void *) NULL;
  76
  77
  78 }
  79 /*-----------------------------------------------------------------*/
  80 /* newBucket - allocates & returns a new bucket        */
  81 /*-----------------------------------------------------------------*/
  82 bucket *
  83 newBucket ()
  84 {
  85   bucket *bp;
  86
  87   bp = Safe_alloc ( sizeof (bucket));
  88
  89   return bp;
  90 }
  91
  92 /*-----------------------------------------------------------------*/
  93 /* hashKey - computes the hashkey given a symbol name              */
  94 /*-----------------------------------------------------------------*/
  95 int
  96 hashKey (const char *s)
  97 {
  98   unsigned long key = 0;
  99
 100   while (*s)
 101     key += *s++;
 102   return key % 256;
 103 }
 104
 105 /*-----------------------------------------------------------------*/
 106 /* addSym - adds a symbol to the hash Table                        */
 107 /*-----------------------------------------------------------------*/
 108 void
 109 addSym (bucket ** stab,
 110         void *sym,
 111         char *sname,
 112         int level,
 113         int block,
 114         int checkType)
 115 {
 116   int i;                        /* index into the hash Table */
 117   bucket *bp;                   /* temp bucket    *         */
 118
 119   if (checkType) {
 120     symbol *csym = (symbol *)sym;
 121
 122     if (getenv("DEBUG_SANITY")) {
 123       fprintf (stderr, "addSym: %s ", sname);
 124     }
 125     /* make sure the type is complete and sane */
 126     checkTypeSanity(csym->etype, csym->name);
 127   }
 128
 129   /* prevent overflow of the (r)name buffers */
 130   if (strlen(sname)>SDCC_SYMNAME_MAX) {
 131     werror (W_SYMBOL_NAME_TOO_LONG, SDCC_SYMNAME_MAX);
 132     sname[SDCC_SYMNAME_MAX]='\0';
 133   }
 134
 135   /* the symbols are always added at the head of the list  */
 136   i = hashKey (sname);
 137   /* get a free entry */
 138   bp = Safe_alloc ( sizeof (bucket));
 139
 140   bp->sym = sym;                /* update the symbol pointer  */
 141   bp->level = level;            /* update the nest level      */
 142   bp->block = block;
 143   strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
 144
 145   /* if this is the first entry */
 146   if (stab[i] == NULL)
 147     {
 148       bp->prev = bp->next = (void *) NULL;      /* point to nothing */
 149       stab[i] = bp;
 150     }
 151   /* not first entry then add @ head of list */
 152   else
 153     {
 154       bp->prev = NULL;
 155       stab[i]->prev = bp;
 156       bp->next = stab[i];
 157       stab[i] = bp;
 158     }
 159 }
 160
 161 /*-----------------------------------------------------------------*/
 162 /* deleteSym - deletes a symbol from the hash Table  entry     */
 163 /*-----------------------------------------------------------------*/
 164 void
 165 deleteSym (bucket ** stab, void *sym, char *sname)
 166 {
 167   int i = 0;
 168   bucket *bp;
 169
 170   i = hashKey (sname);
 171
 172   bp = stab[i];
 173   /* find the symbol */
 174   while (bp)
 175     {
 176       if (bp->sym == sym)       /* found it then break out */
 177         break;                  /* of the loop       */
 178       bp = bp->next;
 179     }
 180
 181   if (!bp)                      /* did not find it */
 182     return;
 183   /* if this is the first one in the chain */
 184   if (!bp->prev)
 185     {
 186       stab[i] = bp->next;
 187       if (stab[i])              /* if chain ! empty */
 188         stab[i]->prev = (void *) NULL;
 189     }
 190   /* middle || end of chain */
 191   else
 192     {
 193       if (bp->next)             /* if not end of chain */
 194         bp->next->prev = bp->prev;
 195
 196       bp->prev->next = bp->next;
 197     }
 198
 199 }
 200
 201 /*-----------------------------------------------------------------*/
 202 /* findSym - finds a symbol in a table           */
 203 /*-----------------------------------------------------------------*/
 204 void *
 205 findSym (bucket ** stab, void *sym, const char *sname)
 206 {
 207   bucket *bp;
 208
 209   bp = stab[hashKey (sname)];
 210   while (bp)
 211     {
 212       if (bp->sym == sym || strcmp (bp->name, sname) == 0)
 213         break;
 214       bp = bp->next;
 215     }
 216
 217   return (bp ? bp->sym : (void *) NULL);
 218 }
 219
 220 /*-----------------------------------------------------------------*/
 221 /* findSymWithLevel - finds a symbol with a name & level           */
 222 /*-----------------------------------------------------------------*/
 223 void *
 224 findSymWithLevel (bucket ** stab, symbol * sym)
 225 {
 226   bucket *bp;
 227
 228   bp = stab[hashKey (sym->name)];
 229
 230   /**
 231    **  do the search from the head of the list since the
 232    **  elements are added at the head it is ensured that
 233    ** we will find the deeper definitions before we find
 234    ** the global ones. we need to check for symbols with
 235    ** level <= to the level given, if levels match then block
 236    ** numbers need to match as well
 237    **/
 238   while (bp)
 239     {
 240       if (strcmp (bp->name, sym->name) == 0 && bp->level <= sym->level)
 241         {
 242           /* if this is parameter then nothing else need to be checked */
 243           if (((symbol *) (bp->sym))->_isparm)
 244             return (bp->sym);
 245           /* if levels match then block numbers should also match */
 246           if (bp->level && bp->level == sym->level && bp->block == sym->block)
 247             return (bp->sym);
 248           /* if levels don't match then we are okay */
 249           if (bp->level && bp->level != sym->level && bp->block <= sym->block)
 250             return (bp->sym);
 251           /* if this is a global variable then we are ok too */
 252           if (bp->level == 0)
 253             return (bp->sym);
 254         }
 255
 256       bp = bp->next;
 257     }
 258
 259   return (void *) NULL;
 260 }
 261
 262 /*-----------------------------------------------------------------*/
 263 /* findSymWithBlock - finds a symbol with name in with a block     */
 264 /*-----------------------------------------------------------------*/
 265 void *
 266 findSymWithBlock (bucket ** stab, symbol * sym, int block)
 267 {
 268   bucket *bp;
 269
 270   bp = stab[hashKey (sym->name)];
 271   while (bp)
 272     {
 273       if (strcmp (bp->name, sym->name) == 0 &&
 274           bp->block <= block)
 275         break;
 276       bp = bp->next;
 277     }
 278
 279   return (bp ? bp->sym : (void *) NULL);
 280 }
 281
 282 /*------------------------------------------------------------------*/
 283 /* newSymbol () - returns a new pointer to a symbol                 */
 284 /*------------------------------------------------------------------*/
 285 symbol *
 286 newSymbol (char *name, int scope)
 287 {
 288   symbol *sym;
 289
 290   sym = Safe_alloc ( sizeof (symbol));
 291
 292   strncpyz (sym->name, name, sizeof(sym->name));        /* copy the name */
 293   sym->level = scope;           /* set the level    */
 294   sym->block = currBlockno;
 295   sym->lineDef = mylineno;      /* set the line number */
 296   return sym;
 297 }
 298
 299 /*------------------------------------------------------------------*/
 300 /* newLink - creates a new link (declarator,specifier)              */
 301 /*------------------------------------------------------------------*/
 302 sym_link *
 303 newLink (SYM_LINK_CLASS select)
 304 {
 305   sym_link *p;
 306
 307   p = Safe_alloc ( sizeof (sym_link));
 308   p->class=select;
 309
 310   return p;
 311 }
 312
 313 /*------------------------------------------------------------------*/
 314 /* newStruct - creats a new structdef from the free list            */
 315 /*------------------------------------------------------------------*/
 316 structdef *
 317 newStruct (char *tag)
 318 {
 319   structdef *s;
 320
 321   s = Safe_alloc ( sizeof (structdef));
 322
 323   strncpyz (s->tag, tag, sizeof(s->tag));               /* copy the tag */
 324   return s;
 325 }
 326
 327 /*------------------------------------------------------------------*/
 328 /* sclsFromPtr - Return the storage class a pointer points into.    */
 329 /*               S_FIXED is returned for generic pointers or other  */
 330 /*               unexpected cases                                   */
 331 /*------------------------------------------------------------------*/
 332 STORAGE_CLASS
 333 sclsFromPtr(sym_link *ptr)
 334 {
 335   switch (DCL_TYPE (ptr))
 336     {
 337     case POINTER:
 338       return S_DATA;
 339     case GPOINTER:
 340       return S_FIXED;
 341     case FPOINTER:
 342       return S_XDATA;
 343     case CPOINTER:
 344       return S_CODE;
 345     case IPOINTER:
 346       return S_IDATA;
 347     case PPOINTER:
 348       return S_PDATA;
 349     case EEPPOINTER:
 350       return S_EEPROM;
 351     case FUNCTION:
 352       return S_CODE;
 353     default:
 354       return S_FIXED;
 355     }
 356 }
 357
 358 /*------------------------------------------------------------------*/
 359 /* pointerTypes - do the computation for the pointer types          */
 360 /*------------------------------------------------------------------*/
 361 void
 362 pointerTypes (sym_link * ptr, sym_link * type)
 363 {
 364   if (IS_SPEC (ptr))
 365     return;
 366
 367   /* find the first pointer type */
 368   while (ptr && !IS_PTR (ptr))
 369     ptr = ptr->next;
 370
 371   /* could not find it */
 372   if (!ptr || IS_SPEC (ptr))
 373     return;
 374
 375   if (IS_PTR(ptr) && DCL_TYPE(ptr)!=UPOINTER) {
 376     pointerTypes (ptr->next, type);
 377     return;
 378   }
 379
 380   /* change the pointer type depending on the
 381      storage class of the type */
 382   if (IS_SPEC (type))
 383     {
 384       switch (SPEC_SCLS (type))
 385         {
 386         case S_XDATA:
 387           DCL_TYPE (ptr) = FPOINTER;
 388           break;
 389         case S_IDATA:
 390           DCL_TYPE (ptr) = IPOINTER;
 391           break;
 392         case S_PDATA:
 393           DCL_TYPE (ptr) = PPOINTER;
 394           break;
 395         case S_DATA:
 396           DCL_TYPE (ptr) = POINTER;
 397           break;
 398         case S_CODE:
 399           DCL_TYPE (ptr) = CPOINTER;
 400           break;
 401         case S_EEPROM:
 402           DCL_TYPE (ptr) = EEPPOINTER;
 403           break;
 404         default:
 405           DCL_TYPE (ptr) = port->unqualified_pointer;
 406           break;
 407         }
 408       /* the storage class of type ends here */
 409       SPEC_SCLS (type) = 0;
 410     }
 411
 412   /* now change all the remaining unknown pointers
 413      to generic pointers */
 414   while (ptr)
 415     {
 416       if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
 417         DCL_TYPE (ptr) = port->unqualified_pointer;
 418       ptr = ptr->next;
 419     }
 420
 421   /* same for the type although it is highly unlikely that
 422      type will have a pointer */
 423   while (type)
 424     {
 425       if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
 426         DCL_TYPE (type) = port->unqualified_pointer;
 427       type = type->next;
 428     }
 429 }
 430
 431 /*------------------------------------------------------------------*/
 432 /* addDecl - adds a declarator @ the end of a chain                 */
 433 /*------------------------------------------------------------------*/
 434 void
 435 addDecl (symbol * sym, int type, sym_link * p)
 436 {
 437   sym_link *head;
 438   sym_link *tail;
 439   sym_link *t;
 440
 441   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
 442     fprintf (stderr, "SDCCsymt.c:addDecl(%s,%d,%p)\n", sym->name, type, p);
 443
 444   /* if we are passed a link then set head & tail */
 445   if (p)
 446     {
 447       tail = head = p;
 448       while (tail->next)
 449         tail = tail->next;
 450     }
 451   else
 452     {
 453       head = tail = newLink (DECLARATOR);
 454       DCL_TYPE (head) = type;
 455     }
 456
 457   /* if this is the first entry   */
 458   if (!sym->type)
 459     {
 460       sym->type = head;
 461       sym->etype = tail;
 462     }
 463   else
 464     {
 465       if (IS_SPEC (sym->etype) && IS_SPEC (head) && head == tail)
 466         {
 467           sym->etype = mergeSpec (sym->etype, head, sym->name);
 468         }
 469       else
 470         {
 471           if (IS_SPEC (sym->etype) && !IS_SPEC (head) && head == tail)
 472             {
 473               t = sym->type;
 474               while (t->next != sym->etype)
 475                 t = t->next;
 476               t->next = head;
 477               tail->next = sym->etype;
 478             }
 479           else
 480             {
 481               sym->etype->next = head;
 482               sym->etype = tail;
 483             }
 484         }
 485     }
 486
 487   /* if the type is an unknown pointer and has
 488      a tspec then take the storage class const & volatile
 489      attribute from the tspec & make it those of this
 490      symbol */
 491   if (p &&
 492       !IS_SPEC (p) &&
 493       //DCL_TYPE (p) == UPOINTER &&
 494       DCL_TSPEC (p))
 495     {
 496       if (!IS_SPEC (sym->etype))
 497         {
 498           sym->etype = sym->etype->next = newLink (SPECIFIER);
 499         }
 500       SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
 501       DCL_TSPEC (p) = NULL;
 502     }
 503
 504   // if there is a function in this type chain
 505   if (p && funcInChain(sym->type)) {
 506     processFuncArgs (sym);
 507   }
 508
 509   return;
 510 }
 511
 512 /*------------------------------------------------------------------
 513   checkTypeSanity: prevent the user from doing e.g.:
 514   unsigned float uf;
 515   ------------------------------------------------------------------*/
 516 void checkTypeSanity(sym_link *etype, char *name) {
 517   char *noun;
 518
 519   if (!etype) {
 520     if (getenv("DEBUG_SANITY")) {
 521       fprintf (stderr, "sanity check skipped for %s (etype==0)\n", name);
 522     }
 523     return;
 524   }
 525
 526   if (!IS_SPEC(etype)) {
 527     if (getenv("DEBUG_SANITY")) {
 528       fprintf (stderr, "sanity check skipped for %s (!IS_SPEC)\n", name);
 529     }
 530     return;
 531   }
 532
 533   noun=nounName(etype);
 534
 535   if (getenv("DEBUG_SANITY")) {
 536     fprintf (stderr, "checking sanity for %s %p\n", name, etype);
 537   }
 538
 539   if ((SPEC_NOUN(etype)==V_CHAR ||
 540        SPEC_NOUN(etype)==V_FLOAT ||
 541        SPEC_NOUN(etype)==V_DOUBLE ||
 542        SPEC_NOUN(etype)==V_VOID) &&
 543       (etype->select.s._short || SPEC_LONG(etype))) {
 544     // long or short for char float double or void
 545     werror (E_LONG_OR_SHORT_INVALID, noun, name);
 546   }
 547   if ((SPEC_NOUN(etype)==V_FLOAT ||
 548        SPEC_NOUN(etype)==V_DOUBLE ||
 549        SPEC_NOUN(etype)==V_VOID) &&
 550       (etype->select.s._signed || SPEC_USIGN(etype))) {
 551     // signed or unsigned for float double or void
 552     werror (E_SIGNED_OR_UNSIGNED_INVALID, noun, name);
 553   }
 554
 555   // special case for "short"
 556   if (etype->select.s._short) {
 557     SPEC_NOUN(etype) = options.shortis8bits ? V_CHAR : V_INT;
 558     etype->select.s._short = 0;
 559   }
 560
 561   /* if no noun e.g.
 562      "const a;" or "data b;" or "signed s" or "long l"
 563      assume an int */
 564   if (!SPEC_NOUN(etype)) {
 565     SPEC_NOUN(etype)=V_INT;
 566   }
 567
 568   if (etype->select.s._signed && SPEC_USIGN(etype)) {
 569     // signed AND unsigned
 570     werror (E_SIGNED_AND_UNSIGNED_INVALID, noun, name);
 571   }
 572   if (etype->select.s._short && SPEC_LONG(etype)) {
 573     // short AND long
 574     werror (E_LONG_AND_SHORT_INVALID, noun, name);
 575   }
 576
 577 }
 578
 579 /*------------------------------------------------------------------*/
 580 /* mergeSpec - merges two specifiers and returns the new one        */
 581 /*------------------------------------------------------------------*/
 582 sym_link *
 583 mergeSpec (sym_link * dest, sym_link * src, char *name)
 584 {
 585   if (!IS_SPEC(dest) || !IS_SPEC(src)) {
 586 #if 0
 587     werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
 588     exit (1);
 589 #else
 590     werror (E_SYNTAX_ERROR, yytext);
 591     // the show must go on
 592     return newIntLink();
 593 #endif
 594   }
 595
 596   if (SPEC_NOUN(src)) {
 597     if (!SPEC_NOUN(dest)) {
 598       SPEC_NOUN(dest)=SPEC_NOUN(src);
 599     } else {
 600       /* we shouldn't redeclare the type */
 601       if (getenv("DEBUG_SANITY")) {
 602         fprintf (stderr, "mergeSpec: ");
 603       }
 604       werror(E_TWO_OR_MORE_DATA_TYPES, name);
 605     }
 606   }
 607
 608   if (SPEC_SCLS(src)) {
 609     /* if destination has no storage class */
 610     if (!SPEC_SCLS (dest) || SPEC_SCLS(dest)==S_REGISTER) {
 611       SPEC_SCLS (dest) = SPEC_SCLS (src);
 612     } else {
 613       if (getenv("DEBUG_SANITY")) {
 614         fprintf (stderr, "mergeSpec: ");
 615       }
 616       werror(E_TWO_OR_MORE_STORAGE_CLASSES, name);
 617     }
 618   }
 619
 620   /* copy all the specifications  */
 621
 622   // we really should do:
 623 #if 0
 624   if (SPEC_what(src)) {
 625     if (SPEC_what(dest)) {
 626       werror(W_DUPLICATE_SPEC, "what");
 627     }
 628     SPEC_what(dst)|=SPEC_what(src);
 629   }
 630 #endif
 631   // but there are more important thing right now
 632
 633   SPEC_LONG (dest) |= SPEC_LONG (src);
 634   dest->select.s._short|=src->select.s._short;
 635   SPEC_USIGN (dest) |= SPEC_USIGN (src);
 636   dest->select.s._signed|=src->select.s._signed;
 637   SPEC_STAT (dest) |= SPEC_STAT (src);
 638   SPEC_EXTR (dest) |= SPEC_EXTR (src);
 639   SPEC_CONST(dest) |= SPEC_CONST (src);
 640   SPEC_ABSA (dest) |= SPEC_ABSA (src);
 641   SPEC_VOLATILE (dest) |= SPEC_VOLATILE (src);
 642   SPEC_ADDR (dest) |= SPEC_ADDR (src);
 643   SPEC_OCLS (dest) = SPEC_OCLS (src);
 644   SPEC_BLEN (dest) |= SPEC_BLEN (src);
 645   SPEC_BSTR (dest) |= SPEC_BSTR (src);
 646   SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
 647   SPEC_ENUM (dest) |= SPEC_ENUM (src);
 648   if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
 649       SPEC_ARGREG(dest) = SPEC_ARGREG(src);
 650
 651   if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
 652     SPEC_STRUCT (dest) = SPEC_STRUCT (src);
 653
 654   /* these are the only function attributes that will be set
 655      in a specifier while parsing */
 656   FUNC_NONBANKED(dest) |= FUNC_NONBANKED(src);
 657   FUNC_BANKED(dest) |= FUNC_BANKED(src);
 658   FUNC_ISCRITICAL(dest) |= FUNC_ISCRITICAL(src);
 659   FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
 660   FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
 661   FUNC_ISISR(dest) |= FUNC_ISISR(src);
 662   FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
 663   FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
 664   FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(src);
 665   FUNC_INTNO(dest) |= FUNC_INTNO(src);
 666   FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
 667
 668   return dest;
 669 }
 670
 671 /*------------------------------------------------------------------*/
 672 /* genSymName - generates and returns a name used for anonymous vars */
 673 /*------------------------------------------------------------------*/
 674 char *
 675 genSymName (int level)
 676 {
 677   static int gCount = 0;
 678   static char gname[SDCC_NAME_MAX + 1];
 679
 680   SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
 681   return gname;
 682 }
 683
 684 /*------------------------------------------------------------------*/
 685 /* getSpec - returns the specifier part from a declaration chain    */
 686 /*------------------------------------------------------------------*/
 687 sym_link *
 688 getSpec (sym_link * p)
 689 {
 690   sym_link *loop;
 691
 692   loop = p;
 693   while (p && !(IS_SPEC (p)))
 694     p = p->next;
 695
 696   return p;
 697 }
 698
 699 /*------------------------------------------------------------------*/
 700 /* newCharLink() - creates an char type                             */
 701 /*------------------------------------------------------------------*/
 702 sym_link *
 703 newCharLink ()
 704 {
 705   sym_link *p;
 706
 707   p = newLink (SPECIFIER);
 708   SPEC_NOUN (p) = V_CHAR;
 709
 710   return p;
 711 }
 712
 713 /*------------------------------------------------------------------*/
 714 /* newFloatLink - a new Float type                                  */
 715 /*------------------------------------------------------------------*/
 716 sym_link *
 717 newFloatLink ()
 718 {
 719   sym_link *p;
 720
 721   p = newLink (SPECIFIER);
 722   SPEC_NOUN (p) = V_FLOAT;
 723
 724   return p;
 725 }
 726
 727 /*------------------------------------------------------------------*/
 728 /* newLongLink() - new long type                                    */
 729 /*------------------------------------------------------------------*/
 730 sym_link *
 731 newLongLink ()
 732 {
 733   sym_link *p;
 734
 735   p = newLink (SPECIFIER);
 736   SPEC_NOUN (p) = V_INT;
 737   SPEC_LONG (p) = 1;
 738
 739   return p;
 740 }
 741
 742 /*------------------------------------------------------------------*/
 743 /* newIntLink() - creates an int type                               */
 744 /*------------------------------------------------------------------*/
 745 sym_link *
 746 newIntLink ()
 747 {
 748   sym_link *p;
 749
 750   p = newLink (SPECIFIER);
 751   SPEC_NOUN (p) = V_INT;
 752
 753   return p;
 754 }
 755
 756 /*------------------------------------------------------------------*/
 757 /* getSize - returns size of a type chain in bits                   */
 758 /*------------------------------------------------------------------*/
 759 unsigned int
 760 getSize (sym_link * p)
 761 {
 762   /* if nothing return 0 */
 763   if (!p)
 764     return 0;
 765   if (IS_SPEC (p))
 766     {                           /* if this is the specifier then */
 767       switch (SPEC_NOUN (p))
 768         {                       /* depending on the specifier type */
 769         case V_INT:
 770           return (IS_LONG (p) ? LONGSIZE : INTSIZE);
 771         case V_FLOAT:
 772           return FLOATSIZE;
 773         case V_CHAR:
 774           return CHARSIZE;
 775         case V_VOID:
 776           return 0;
 777         case V_STRUCT:
 778           return SPEC_STRUCT (p)->size;
 779         case V_LABEL:
 780           return 0;
 781         case V_SBIT:
 782         case V_BIT:
 783           return BITSIZE;
 784         case V_BITFIELD:
 785           return ((SPEC_BLEN (p) / 8) + (SPEC_BLEN (p) % 8 ? 1 : 0));
 786         default:
 787           return 0;
 788         }
 789     }
 790
 791   /* this is a specifier  */
 792   switch (DCL_TYPE (p))
 793     {
 794     case ARRAY:
 795       if (DCL_ELEM(p)) {
 796         return DCL_ELEM (p) * getSize (p->next);
 797       } else {
 798           //    werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 799           //    "can not tell the size of an array[]");
 800         return 0;
 801       }
 802     case IPOINTER:
 803     case PPOINTER:
 804     case POINTER:
 805       return (PTRSIZE);
 806     case EEPPOINTER:
 807     case FPOINTER:
 808     case CPOINTER:
 809     case FUNCTION:
 810       return (FPTRSIZE);
 811     case GPOINTER:
 812       return (GPTRSIZE);
 813
 814     default:
 815       return 0;
 816     }
 817 }
 818
 819 /*------------------------------------------------------------------*/
 820 /* bitsForType - returns # of bits required to store this type      */
 821 /*------------------------------------------------------------------*/
 822 unsigned int
 823 bitsForType (sym_link * p)
 824 {
 825   /* if nothing return 0 */
 826   if (!p)
 827     return 0;
 828
 829   if (IS_SPEC (p))
 830     {                           /* if this is the specifier then */
 831
 832       switch (SPEC_NOUN (p))
 833         {                       /* depending on the specifier type */
 834         case V_INT:
 835           return (IS_LONG (p) ? LONGSIZE * 8 : INTSIZE * 8);
 836         case V_FLOAT:
 837           return FLOATSIZE * 8;
 838         case V_CHAR:
 839           return CHARSIZE * 8;
 840         case V_VOID:
 841           return 0;
 842         case V_STRUCT:
 843           return SPEC_STRUCT (p)->size * 8;
 844         case V_LABEL:
 845           return 0;
 846         case V_SBIT:
 847         case V_BIT:
 848           return 1;
 849         case V_BITFIELD:
 850           return SPEC_BLEN (p);
 851         default:
 852           return 0;
 853         }
 854     }
 855
 856   /* this is a specifier  */
 857   switch (DCL_TYPE (p))
 858     {
 859     case ARRAY:
 860       return DCL_ELEM (p) * getSize (p->next) * 8;
 861     case IPOINTER:
 862     case PPOINTER:
 863     case POINTER:
 864       return (PTRSIZE * 8);
 865     case EEPPOINTER:
 866     case FPOINTER:
 867     case CPOINTER:
 868     case FUNCTION:
 869       return (FPTRSIZE * 8);
 870     case GPOINTER:
 871       return (GPTRSIZE * 8);
 872
 873     default:
 874       return 0;
 875     }
 876 }
 877
 878 /*------------------------------------------------------------------*/
 879 /* copySymbolChain - copies a symbol chain                          */
 880 /*------------------------------------------------------------------*/
 881 symbol *
 882 copySymbolChain (symbol * src)
 883 {
 884   symbol *dest;
 885
 886   if (!src)
 887     return NULL;
 888
 889   dest = copySymbol (src);
 890   dest->next = copySymbolChain (src->next);
 891   return dest;
 892 }
 893
 894 /*------------------------------------------------------------------*/
 895 /* copySymbol - makes a copy of a symbol                            */
 896 /*------------------------------------------------------------------*/
 897 symbol *
 898 copySymbol (symbol * src)
 899 {
 900   symbol *dest;
 901
 902   if (!src)
 903     return NULL;
 904
 905   dest = newSymbol (src->name, src->level);
 906   memcpy (dest, src, sizeof (symbol));
 907   dest->level = src->level;
 908   dest->block = src->block;
 909   dest->ival = copyIlist (src->ival);
 910   dest->type = copyLinkChain (src->type);
 911   dest->etype = getSpec (dest->type);
 912   dest->next = NULL;
 913   dest->key = src->key;
 914   dest->allocreq = src->allocreq;
 915   return dest;
 916 }
 917
 918 /*------------------------------------------------------------------*/
 919 /* reverseSyms - reverses the links for a symbol chain      */
 920 /*------------------------------------------------------------------*/
 921 symbol *
 922 reverseSyms (symbol * sym)
 923 {
 924   symbol *prev, *curr, *next;
 925
 926   if (!sym)
 927     return NULL;
 928
 929   prev = sym;
 930   curr = sym->next;
 931
 932   while (curr)
 933     {
 934       next = curr->next;
 935       curr->next = prev;
 936       prev = curr;
 937       curr = next;
 938     }
 939   sym->next = (void *) NULL;
 940   return prev;
 941 }
 942
 943 /*------------------------------------------------------------------*/
 944 /* reverseLink - reverses the links for a type chain        */
 945 /*------------------------------------------------------------------*/
 946 sym_link *
 947 reverseLink (sym_link * type)
 948 {
 949   sym_link *prev, *curr, *next;
 950
 951   if (!type)
 952     return NULL;
 953
 954   prev = type;
 955   curr = type->next;
 956
 957   while (curr)
 958     {
 959       next = curr->next;
 960       curr->next = prev;
 961       prev = curr;
 962       curr = next;
 963     }
 964   type->next = (void *) NULL;
 965   return prev;
 966 }
 967
 968 /*------------------------------------------------------------------*/
 969 /* addSymChain - adds a symbol chain to the symboltable             */
 970 /*------------------------------------------------------------------*/
 971 void
 972 addSymChain (symbol * symHead)
 973 {
 974   symbol *sym = symHead;
 975   symbol *csym = NULL;
 976
 977   for (; sym != NULL; sym = sym->next)
 978     {
 979       changePointer(sym);
 980       checkTypeSanity(sym->etype, sym->name);
 981
 982       /* if already exists in the symbol table then check if
 983          one of them is an extern definition if yes then
 984          then check if the type match, if the types match then
 985          delete the current entry and add the new entry      */
 986       if ((csym = findSymWithLevel (SymbolTab, sym)) &&
 987           csym->level == sym->level) {
 988
 989         /* one definition extern ? */
 990         if (IS_EXTERN (csym->etype) || IS_EXTERN (sym->etype)) {
 991           /* do types match ? */
 992           //checkDecl (sym, IS_EXTERN (sym->etype));
 993           if (compareTypeExact (csym->type, sym->type, sym->level) != 1) {
 994             /* no then error */
 995             werror (E_EXTERN_MISMATCH, csym->name);
 996             printFromToType (csym->type, sym->type);
 997             continue;
 998           }
 999         } else {
1000           /* not extern */
1001           //checkDecl (sym, 0);
1002           if (compareTypeExact (csym->type, sym->type, sym->level) != 1) {
1003             werror (E_DUPLICATE, sym->name);
1004             printFromToType (csym->type, sym->type);
1005             continue;
1006           }
1007         }
1008         /* delete current entry */
1009         deleteSym (SymbolTab, csym, csym->name);
1010         deleteFromSeg(csym);
1011       }
1012
1013       /* add new entry */
1014       addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
1015     }
1016 }
1017
1018
1019 /*------------------------------------------------------------------*/
1020 /* funcInChain - DCL Type 'FUNCTION' found in type chain            */
1021 /*------------------------------------------------------------------*/
1022 int
1023 funcInChain (sym_link * lnk)
1024 {
1025   while (lnk)
1026     {
1027       if (IS_FUNC (lnk))
1028         return 1;
1029       lnk = lnk->next;
1030     }
1031   return 0;
1032 }
1033
1034 /*------------------------------------------------------------------*/
1035 /* structElemType - returns the type info of a struct member        */
1036 /*------------------------------------------------------------------*/
1037 sym_link *
1038 structElemType (sym_link * stype, value * id)
1039 {
1040   symbol *fields = (SPEC_STRUCT (stype) ? SPEC_STRUCT (stype)->fields : NULL);
1041   sym_link *type, *etype;
1042   sym_link *petype = getSpec (stype);
1043
1044   if (fields && id) {
1045
1046     /* look for the id */
1047     while (fields)
1048       {
1049         if (strcmp (fields->rname, id->name) == 0)
1050           {
1051             type = copyLinkChain (fields->type);
1052             etype = getSpec (type);
1053             SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
1054                                  SPEC_SCLS (etype) : SPEC_SCLS (petype));
1055             if (IS_SPEC (type))
1056               SPEC_CONST (type) |= SPEC_CONST (stype);
1057             else
1058               DCL_PTR_CONST (type) |= SPEC_CONST (stype);
1059             return type;
1060           }
1061         fields = fields->next;
1062       }
1063   }
1064
1065   werror (E_NOT_MEMBER, id->name);
1066
1067   // the show must go on
1068   return newIntLink();
1069 }
1070
1071 /*------------------------------------------------------------------*/
1072 /* getStructElement - returns element of a tructure definition      */
1073 /*------------------------------------------------------------------*/
1074 symbol *
1075 getStructElement (structdef * sdef, symbol * sym)
1076 {
1077   symbol *field;
1078
1079   for (field = sdef->fields; field; field = field->next)
1080     if (strcmp (field->name, sym->name) == 0)
1081       return field;
1082
1083   werror (E_NOT_MEMBER, sym->name);
1084
1085   return sdef->fields;
1086 }
1087
1088 /*------------------------------------------------------------------*/
1089 /* compStructSize - computes the size of a structure                */
1090 /*------------------------------------------------------------------*/
1091 int
1092 compStructSize (int su, structdef * sdef)
1093 {
1094     int sum = 0, usum = 0;
1095     int bitOffset = 0;
1096     symbol *loop;
1097
1098     /* for the identifiers  */
1099     loop = sdef->fields;
1100     while (loop) {
1101
1102         /* create the internal name for this variable */
1103         SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
1104         if (su == UNION) {
1105             sum = 0;
1106             bitOffset = 0;
1107         }
1108         SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
1109
1110         /* if this is a bit field  */
1111         if (loop->bitVar) {
1112
1113             /* change it to a unsigned bit */
1114             SPEC_NOUN (loop->etype) = V_BITFIELD;
1115             SPEC_USIGN (loop->etype) = 1;
1116             SPEC_BLEN (loop->etype) = loop->bitVar;
1117
1118             if (loop->bitVar == BITVAR_PAD) {
1119                 /* A zero length bitfield forces padding */
1120                 SPEC_BSTR (loop->etype) = bitOffset;
1121                 SPEC_BLEN (loop->etype) = 0;
1122                 bitOffset = 8;
1123                 loop->offset = sum;
1124             }
1125             else {
1126                 if (bitOffset == 8) {
1127                     bitOffset = 0;
1128                     sum++;
1129                 }
1130                 /* check if this fit into the remaining   */
1131                 /* bits of this byte else align it to the */
1132                 /* next byte boundary                     */
1133                 if (loop->bitVar <= (8 - bitOffset)) {
1134                     /* fits into current byte */
1135                     loop->offset = sum;
1136                     SPEC_BSTR (loop->etype) = bitOffset;
1137                     bitOffset += loop->bitVar;
1138                 }
1139                 else if (!bitOffset) {
1140                     /* does not fit, but is already byte aligned */
1141                     loop->offset = sum;
1142                     SPEC_BSTR (loop->etype) = bitOffset;
1143                     bitOffset += loop->bitVar;
1144                 }
1145                 else {
1146                     /* does not fit; need to realign first */
1147                     sum++;
1148                     loop->offset = (su == UNION ? sum = 0 : sum);
1149                     bitOffset = 0;
1150                     SPEC_BSTR (loop->etype) = bitOffset;
1151                     bitOffset += loop->bitVar;
1152                 }
1153                 while (bitOffset>8) {
1154                     bitOffset -= 8;
1155                     sum++;
1156                 }
1157             }
1158         }
1159         else {
1160             /* This is a non-bit field. Make sure we are */
1161             /* byte aligned first */
1162             if (bitOffset) {
1163                 sum++;
1164                 loop->offset = (su == UNION ? sum = 0 : sum);
1165                 bitOffset = 0;
1166             }
1167             loop->offset = sum;
1168             checkDecl (loop, 1);
1169             sum += getSize (loop->type);
1170         }
1171
1172         loop = loop->next;
1173
1174         /* if union then size = sizeof larget field */
1175         if (su == UNION) {
1176             /* For UNION, round up after each field */
1177             sum += ((bitOffset+7)/8);
1178             usum = max (usum, sum);
1179         }
1180
1181     }
1182
1183     /* For STRUCT, round up after all fields processed */
1184     if (su != UNION)
1185         sum += ((bitOffset+7)/8);
1186
1187     return (su == UNION ? usum : sum);
1188 }
1189
1190 /*------------------------------------------------------------------*/
1191 /* checkSClass - check the storage class specification              */
1192 /*------------------------------------------------------------------*/
1193 static void
1194 checkSClass (symbol * sym, int isProto)
1195 {
1196   sym_link *t;
1197
1198   if (getenv("DEBUG_SANITY")) {
1199     fprintf (stderr, "checkSClass: %s \n", sym->name);
1200   }
1201
1202   /* type is literal can happen for enums change
1203      to auto */
1204   if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
1205     SPEC_SCLS (sym->etype) = S_AUTO;
1206
1207   /* if sfr or sbit then must also be volatile */
1208   if (SPEC_SCLS (sym->etype) == S_SBIT ||
1209       SPEC_SCLS (sym->etype) == S_SFR)
1210     {
1211       SPEC_VOLATILE (sym->etype) = 1;
1212     }
1213
1214   /* if absolute address given then it mark it as
1215      volatile -- except in the PIC port */
1216
1217 #if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
1218   /* The PIC port uses a different peep hole optimizer based on "pCode" */
1219   if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
1220 #endif
1221
1222     if (IS_ABSOLUTE (sym->etype))
1223       SPEC_VOLATILE (sym->etype) = 1;
1224
1225   /* If code memory is read only, then pointers to code memory */
1226   /* implicitly point to constants -- make this explicit       */
1227   t = sym->type;
1228   while (t && t->next) {
1229     if (IS_CODEPTR(t) && port->mem.code_ro) {
1230       if (IS_SPEC(t->next)) {
1231         SPEC_CONST (t->next) = 1;
1232       } else {
1233         DCL_PTR_CONST (t->next) = 1;
1234       }
1235     }
1236     t = t->next;
1237   }
1238
1239   /* global variables declared const put into code */
1240   /* if no other storage class specified */
1241   if (sym->level == 0 &&
1242       SPEC_SCLS(sym->etype) == S_FIXED &&
1243       !IS_FUNC(sym->type)) {
1244     /* find the first non-array link */
1245     t = sym->type;
1246     while (IS_ARRAY(t))
1247       t = t->next;
1248     if (IS_CONSTANT (t)) {
1249       SPEC_SCLS (sym->etype) = S_CODE;
1250     }
1251   }
1252
1253   /* global variable in code space is a constant */
1254   if (sym->level == 0 &&
1255       SPEC_SCLS (sym->etype) == S_CODE &&
1256       port->mem.code_ro) {
1257     /* find the first non-array link */
1258     t = sym->type;
1259     while (IS_ARRAY(t))
1260       t = t->next;
1261     if (IS_SPEC(t)) {
1262       SPEC_CONST (t) = 1;
1263     } else {
1264       DCL_PTR_CONST (t) = 1;
1265     }
1266   }
1267
1268   /* if bit variable then no storage class can be */
1269   /* specified since bit is already a storage */
1270   if (IS_BITVAR (sym->etype) &&
1271       (SPEC_SCLS (sym->etype) != S_FIXED &&
1272        SPEC_SCLS (sym->etype) != S_SBIT &&
1273        SPEC_SCLS (sym->etype) != S_BIT)
1274     )
1275     {
1276       werror (E_BITVAR_STORAGE, sym->name);
1277       SPEC_SCLS (sym->etype) = S_FIXED;
1278     }
1279
1280   /* extern variables cannot be initialized */
1281   if (IS_EXTERN (sym->etype) && sym->ival)
1282     {
1283       werror (E_EXTERN_INIT, sym->name);
1284       sym->ival = NULL;
1285     }
1286
1287   /* if this is an automatic symbol */
1288   if (sym->level && (options.stackAuto || reentrant)) {
1289     if ((SPEC_SCLS (sym->etype) == S_AUTO ||
1290          SPEC_SCLS (sym->etype) == S_FIXED ||
1291          SPEC_SCLS (sym->etype) == S_REGISTER ||
1292          SPEC_SCLS (sym->etype) == S_STACK ||
1293          SPEC_SCLS (sym->etype) == S_XSTACK)) {
1294       SPEC_SCLS (sym->etype) = S_AUTO;
1295     } else {
1296       /* storage class may only be specified for statics */
1297       if (!IS_STATIC(sym->etype)) {
1298         werror (E_AUTO_ASSUMED, sym->name);
1299       }
1300     }
1301   }
1302
1303   /* automatic symbols cannot be given   */
1304   /* an absolute address ignore it      */
1305   if (sym->level &&
1306       SPEC_ABSA (sym->etype) &&
1307       (options.stackAuto || reentrant))
1308     {
1309       werror (E_AUTO_ABSA, sym->name);
1310       SPEC_ABSA (sym->etype) = 0;
1311     }
1312
1313   /* arrays & pointers cannot be defined for bits   */
1314   /* SBITS or SFRs or BIT                           */
1315   if ((IS_ARRAY (sym->type) || IS_PTR (sym->type)) &&
1316       (SPEC_NOUN (sym->etype) == V_BIT ||
1317        SPEC_NOUN (sym->etype) == V_SBIT ||
1318        SPEC_NOUN (sym->etype) == V_BITFIELD ||
1319        SPEC_SCLS (sym->etype) == S_SFR))
1320     werror (E_BIT_ARRAY, sym->name);
1321
1322   /* if this is a bit|sbit then set length & start  */
1323   if (SPEC_NOUN (sym->etype) == V_BIT ||
1324       SPEC_NOUN (sym->etype) == V_SBIT)
1325     {
1326       SPEC_BLEN (sym->etype) = 1;
1327       SPEC_BSTR (sym->etype) = 0;
1328     }
1329
1330   if (!isProto) {
1331     /* variables declared in CODE space must have */
1332     /* initializers if not an extern */
1333     if (SPEC_SCLS (sym->etype) == S_CODE &&
1334         sym->ival == NULL &&
1335         //!sym->level &&
1336         port->mem.code_ro &&
1337         !IS_EXTERN (sym->etype) &&
1338         !funcInChain (sym->type))
1339       werror (E_CODE_NO_INIT, sym->name);
1340   }
1341
1342   /* if parameter or local variable then change */
1343   /* the storage class to reflect where the var will go */
1344   if (sym->level && SPEC_SCLS (sym->etype) == S_FIXED &&
1345       !IS_STATIC(sym->etype))
1346     {
1347       if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1348         {
1349           SPEC_SCLS (sym->etype) = (options.useXstack ?
1350                                     S_XSTACK : S_STACK);
1351         }
1352       else
1353         {
1354           /* hack-o-matic! I see no reason why the useXstack option should ever
1355            * control this allcoation, but the code was originally that way, and
1356            * changing it for non-390 ports breaks the compiler badly.
1357            */
1358           bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ?
1359                 1 : options.useXstack;
1360           SPEC_SCLS (sym->etype) = (useXdata ?
1361                                     S_XDATA : S_FIXED);
1362         }
1363     }
1364 }
1365
1366 /*------------------------------------------------------------------*/
1367 /* changePointer - change pointer to functions                      */
1368 /*------------------------------------------------------------------*/
1369 void
1370 changePointer (symbol * sym)
1371 {
1372   sym_link *p;
1373
1374   /* go thru the chain of declarations   */
1375   /* if we find a pointer to a function  */
1376   /* unconditionally change it to a ptr  */
1377   /* to code area                        */
1378   for (p = sym->type; p; p = p->next)
1379     {
1380       if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
1381         DCL_TYPE (p) = port->unqualified_pointer;
1382       if (IS_PTR (p) && IS_FUNC (p->next))
1383         DCL_TYPE (p) = CPOINTER;
1384     }
1385 }
1386
1387 /*------------------------------------------------------------------*/
1388 /* checkDecl - does semantic validation of a declaration                   */
1389 /*------------------------------------------------------------------*/
1390 int
1391 checkDecl (symbol * sym, int isProto)
1392 {
1393
1394   checkSClass (sym, isProto);           /* check the storage class      */
1395   changePointer (sym);          /* change pointers if required */
1396
1397   /* if this is an array without any dimension
1398      then update the dimension from the initial value */
1399   if (IS_ARRAY (sym->type) && !DCL_ELEM (sym->type))
1400     DCL_ELEM (sym->type) = getNelements (sym->type, sym->ival);
1401
1402   return 0;
1403 }
1404
1405 /*------------------------------------------------------------------*/
1406 /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */
1407 /*------------------------------------------------------------------*/
1408 sym_link *
1409 copyLinkChain (sym_link * p)
1410 {
1411   sym_link *head, *curr, *loop;
1412
1413   curr = p;
1414   head = loop = (curr ? newLink (p->class) : (void *) NULL);
1415   while (curr)
1416     {
1417       memcpy (loop, curr, sizeof (sym_link));   /* copy it */
1418       loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
1419       loop = loop->next;
1420       curr = curr->next;
1421     }
1422
1423   return head;
1424 }
1425
1426
1427 /*------------------------------------------------------------------*/
1428 /* cleanUpBlock - cleansup the symbol table specified for all the   */
1429 /*                symbols in the given block                        */
1430 /*------------------------------------------------------------------*/
1431 void
1432 cleanUpBlock (bucket ** table, int block)
1433 {
1434   int i;
1435   bucket *chain;
1436
1437   /* go thru the entire  table  */
1438   for (i = 0; i < 256; i++)
1439     {
1440       for (chain = table[i]; chain; chain = chain->next)
1441         {
1442           if (chain->block >= block)
1443             {
1444               deleteSym (table, chain->sym, chain->name);
1445             }
1446         }
1447     }
1448 }
1449
1450 /*------------------------------------------------------------------*/
1451 /* cleanUpLevel - cleansup the symbol table specified for all the   */
1452 /*                symbols in the given level                        */
1453 /*------------------------------------------------------------------*/
1454 void
1455 cleanUpLevel (bucket ** table, int level)
1456 {
1457   int i;
1458   bucket *chain;
1459
1460   /* go thru the entire  table  */
1461   for (i = 0; i < 256; i++)
1462     {
1463       for (chain = table[i]; chain; chain = chain->next)
1464         {
1465           if (chain->level >= level)
1466             {
1467               deleteSym (table, chain->sym, chain->name);
1468             }
1469         }
1470     }
1471 }
1472
1473 /*------------------------------------------------------------------*/
1474 /* computeType - computes the resultant type from two types         */
1475 /*------------------------------------------------------------------*/
1476 sym_link *
1477 computeType (sym_link * type1, sym_link * type2)
1478 {
1479   sym_link *rType;
1480   sym_link *reType;
1481   sym_link *etype1 = getSpec (type1);
1482   sym_link *etype2 = getSpec (type2);
1483
1484   /* if one of them is a float then result is a float */
1485   /* here we assume that the types passed are okay */
1486   /* and can be cast to one another                */
1487   /* which ever is greater in size */
1488   if (IS_FLOAT (etype1) || IS_FLOAT (etype2))
1489     rType = newFloatLink ();
1490   else
1491     /* if only one of them is a bit variable
1492        then the other one prevails */
1493   if (IS_BITVAR (etype1) && !IS_BITVAR (etype2))
1494     rType = copyLinkChain (type2);
1495   else if (IS_BITVAR (etype2) && !IS_BITVAR (etype1))
1496     rType = copyLinkChain (type1);
1497   else
1498     /* if one of them is a pointer or array then that
1499        prevails */
1500   if (IS_PTR (type1) || IS_ARRAY (type1))
1501     rType = copyLinkChain (type1);
1502   else if (IS_PTR (type2) || IS_ARRAY (type2))
1503     rType = copyLinkChain (type2);
1504   else if (getSize (type1) > getSize (type2))
1505     rType = copyLinkChain (type1);
1506   else
1507     rType = copyLinkChain (type2);
1508
1509   reType = getSpec (rType);
1510 #if 0
1511   if (SPEC_NOUN (reType) == V_CHAR)
1512     SPEC_NOUN (reType) = V_INT;
1513 #endif
1514
1515   /* if either of them unsigned but not val then make this unsigned */
1516   if ((SPEC_USIGN (etype1) || SPEC_USIGN (etype2)) &&
1517       !IS_FLOAT (reType))
1518     SPEC_USIGN (reType) = 1;
1519   else
1520     SPEC_USIGN (reType) = 0;
1521
1522   /* if result is a literal then make not so */
1523   if (IS_LITERAL (reType))
1524     SPEC_SCLS (reType) = S_REGISTER;
1525
1526   return rType;
1527 }
1528
1529 /*--------------------------------------------------------------------*/
1530 /* compareType - will do type check return 1 if match, -1 if castable */
1531 /*--------------------------------------------------------------------*/
1532 int
1533 compareType (sym_link * dest, sym_link * src)
1534 {
1535   if (!dest && !src)
1536     return 1;
1537
1538   if (dest && !src)
1539     return 0;
1540
1541   if (src && !dest)
1542     return 0;
1543
1544   /* if dest is a declarator then */
1545   if (IS_DECL (dest))
1546     {
1547       if (IS_DECL (src))
1548         {
1549           if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1550             if (IS_FUNC(src)) {
1551               //checkFunction(src,dest);
1552             }
1553             return compareType (dest->next, src->next);
1554           }
1555           if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
1556             return 1;
1557           }
1558           if (IS_PTR (src) && IS_GENPTR (dest))
1559             return -1;
1560           if (IS_PTR (dest) && IS_ARRAY (src)) {
1561             value *val=aggregateToPointer (valFromType(src));
1562             int res=compareType (dest, val->type);
1563             Safe_free(val->type);
1564             Safe_free(val);
1565             return res;
1566           }
1567           if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
1568             return compareType (dest->next, src);
1569           return 0;
1570         }
1571       else if (IS_PTR (dest) && IS_INTEGRAL (src))
1572         return -1;
1573       else
1574         return 0;
1575     }
1576
1577   /* if one is a specifier and the other is not */
1578   if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1579       (IS_SPEC (dest) && !IS_SPEC (src)))
1580     return 0;
1581
1582   /* if one of them is a void then ok */
1583   if (SPEC_NOUN (dest) == V_VOID &&
1584       SPEC_NOUN (src) != V_VOID)
1585     return -1;
1586
1587   if (SPEC_NOUN (dest) != V_VOID &&
1588       SPEC_NOUN (src) == V_VOID)
1589     return -1;
1590
1591   /* if they are both bitfields then if the lengths
1592      and starts don't match */
1593   if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1594       (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1595        SPEC_BSTR (dest) != SPEC_BSTR (src)))
1596     return -1;
1597
1598   /* it is a specifier */
1599   if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1600     {
1601       if (SPEC_USIGN (dest) == SPEC_USIGN (src) &&
1602           IS_INTEGRAL (dest) && IS_INTEGRAL (src) &&
1603           getSize (dest) == getSize (src))
1604         return 1;
1605       else if (IS_ARITHMETIC (dest) && IS_ARITHMETIC (src))
1606         return -1;
1607       else
1608         return 0;
1609     }
1610   else if (IS_STRUCT (dest))
1611     {
1612       if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1613         return 0;
1614       else
1615         return 1;
1616     }
1617   if (SPEC_LONG (dest) != SPEC_LONG (src))
1618     return -1;
1619
1620   if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1621     return -1;
1622
1623   return 1;
1624 }
1625
1626 /*--------------------------------------------------------------------*/
1627 /* compareTypeExact - will do type check return 1 if match exactly    */
1628 /*--------------------------------------------------------------------*/
1629 int
1630 compareTypeExact (sym_link * dest, sym_link * src, int level)
1631 {
1632   STORAGE_CLASS srcScls, destScls;
1633
1634   if (!dest && !src)
1635     return 1;
1636
1637   if (dest && !src)
1638     return 0;
1639
1640   if (src && !dest)
1641     return 0;
1642
1643   /* if dest is a declarator then */
1644   if (IS_DECL (dest))
1645     {
1646       if (IS_DECL (src))
1647         {
1648           if (DCL_TYPE (src) == DCL_TYPE (dest)) {
1649             if ((DCL_TYPE (src) == ARRAY) && (DCL_ELEM (src) != DCL_ELEM (dest)))
1650               return 0;
1651             if (DCL_PTR_CONST (src) != DCL_PTR_CONST (dest))
1652               return 0;
1653             if (DCL_PTR_VOLATILE (src) != DCL_PTR_VOLATILE (dest))
1654               return 0;
1655             if (IS_FUNC(src))
1656               return compareTypeExact (dest->next, src->next, -1);
1657             return compareTypeExact (dest->next, src->next, level);
1658           }
1659           return 0;
1660         }
1661       return 0;
1662     }
1663
1664   /* if one is a specifier and the other is not */
1665   if ((IS_SPEC (src) && !IS_SPEC (dest)) ||
1666       (IS_SPEC (dest) && !IS_SPEC (src)))
1667     return 0;
1668
1669   /* if one of them is a void then ok */
1670   if (SPEC_NOUN (dest) != SPEC_NOUN (src))
1671     return 0;
1672
1673   /* if they are both bitfields then if the lengths
1674      and starts don't match */
1675   if (IS_BITFIELD (dest) && IS_BITFIELD (src) &&
1676       (SPEC_BLEN (dest) != SPEC_BLEN (src) ||
1677        SPEC_BSTR (dest) != SPEC_BSTR (src)))
1678     return 0;
1679
1680   if (IS_INTEGRAL (dest))
1681     {
1682       /* signedness must match */
1683       if (SPEC_USIGN (dest) != SPEC_USIGN (src))
1684         return 0;
1685       /* size must match */
1686       if (SPEC_LONG (dest) != SPEC_LONG (src))
1687         return 0;
1688       if (SPEC_SHORT (dest) != SPEC_SHORT (src))
1689         return 0;
1690     }
1691
1692   if (IS_STRUCT (dest))
1693     {
1694       if (SPEC_STRUCT (dest) != SPEC_STRUCT (src))
1695         return 0;
1696     }
1697
1698   if (SPEC_CONST (dest) != SPEC_CONST (src))
1699     return 0;
1700   if (SPEC_VOLATILE (dest) != SPEC_VOLATILE (src))
1701     return 0;
1702   if (SPEC_STAT (dest) != SPEC_STAT (src))
1703     return 0;
1704
1705   destScls = SPEC_SCLS (dest);
1706   srcScls = SPEC_SCLS (src);
1707
1708   /* Compensate for const to const code change in checkSClass() */
1709   if (!level & port->mem.code_ro && SPEC_CONST (dest))
1710     {
1711       if (srcScls == S_CODE && destScls == S_FIXED)
1712         destScls = S_CODE;
1713       if (destScls == S_CODE && srcScls == S_FIXED)
1714         srcScls = S_CODE;
1715     }
1716
1717   /* compensate for allocGlobal() */
1718   if ((srcScls == S_FIXED || srcScls == S_AUTO)
1719       && port->mem.default_globl_map == xdata
1720       && !level)
1721     srcScls = S_XDATA;
1722
1723   if (level>0 && !SPEC_STAT (dest))
1724     {
1725       /* Compensate for hack-o-matic in checkSClass() */
1726       if (options.stackAuto || (currFunc && IFFUNC_ISREENT (currFunc->type)))
1727         {
1728           if (destScls == S_FIXED)
1729             destScls = (options.useXstack ? S_XSTACK : S_STACK);
1730           if (srcScls == S_FIXED)
1731             srcScls = (options.useXstack ? S_XSTACK : S_STACK);
1732         }
1733       else if (TARGET_IS_DS390 || TARGET_IS_DS400 || options.useXstack)
1734         {
1735           if (destScls == S_FIXED)
1736             destScls = S_XDATA;
1737           if (srcScls == S_FIXED)
1738             srcScls = S_XDATA;
1739         }
1740     }
1741
1742   #if 0
1743   if (srcScls != destScls)
1744     {
1745       printf ("level = %d\n", level);
1746       printf ("SPEC_SCLS (src) = %d, SPEC_SCLS (dest) = %d\n",
1747                 SPEC_SCLS (src), SPEC_SCLS (dest));
1748       printf ("srcScls = %d, destScls = %d\n",srcScls, destScls);
1749       return 0;
1750     }
1751   #endif
1752
1753   return 1;
1754 }
1755
1756 /*------------------------------------------------------------------*/
1757 /* inCalleeSaveList - return 1 if found in callee save list          */
1758 /*------------------------------------------------------------------*/
1759 static int
1760 calleeCmp(void *p1, void *p2)
1761 {
1762   return (strcmp((char *)p1, (char *)(p2)) == 0);
1763 }
1764
1765 bool
1766 inCalleeSaveList(char *s)
1767 {
1768   if (options.all_callee_saves)
1769     return 1;
1770   return isinSetWith(options.calleeSavesSet, s, calleeCmp);
1771 }
1772
1773 /*-----------------------------------------------------------------*/
1774 /* aggregateToPointer:  change an agggregate type function      */
1775 /*         argument to a pointer to that type.     */
1776 /*-----------------------------------------------------------------*/
1777 value *
1778 aggregateToPointer (value * val)
1779 {
1780   if (IS_AGGREGATE (val->type))
1781     {
1782       /* if this is a structure */
1783       /* then we need to add a new link */
1784       if (IS_STRUCT (val->type))
1785         {
1786           /* first lets add DECLARATOR type */
1787           sym_link *p = val->type;
1788
1789           werror (W_STRUCT_AS_ARG, val->name);
1790           val->type = newLink (DECLARATOR);
1791           val->type->next = p;
1792         }
1793
1794       /* change to a pointer depending on the */
1795       /* storage class specified        */
1796       switch (SPEC_SCLS (val->etype))
1797         {
1798         case S_IDATA:
1799           DCL_TYPE (val->type) = IPOINTER;
1800           break;
1801         case S_PDATA:
1802           DCL_TYPE (val->type) = PPOINTER;
1803           break;
1804         case S_FIXED:
1805           if (SPEC_OCLS(val->etype)) {
1806             DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
1807           } else {
1808             // this happens for (external) function parameters
1809             DCL_TYPE (val->type) = port->unqualified_pointer;
1810           }
1811           break;
1812         case S_AUTO:
1813         case S_DATA:
1814         case S_REGISTER:
1815           DCL_TYPE (val->type) = POINTER;
1816           break;
1817         case S_CODE:
1818           DCL_TYPE (val->type) = CPOINTER;
1819           break;
1820         case S_XDATA:
1821           DCL_TYPE (val->type) = FPOINTER;
1822           break;
1823         case S_EEPROM:
1824           DCL_TYPE (val->type) = EEPPOINTER;
1825           break;
1826         default:
1827           DCL_TYPE (val->type) = port->unqualified_pointer;
1828         }
1829
1830       /* is there is a symbol associated then */
1831       /* change the type of the symbol as well */
1832       if (val->sym)
1833         {
1834           val->sym->type = copyLinkChain (val->type);
1835           val->sym->etype = getSpec (val->sym->type);
1836         }
1837     }
1838   return val;
1839 }
1840 /*------------------------------------------------------------------*/
1841 /* checkFunction - does all kinds of check on a function            */
1842 /*------------------------------------------------------------------*/
1843 int
1844 checkFunction (symbol * sym, symbol *csym)
1845 {
1846   value *exargs, *acargs;
1847   value *checkValue;
1848   int argCnt = 0;
1849
1850   if (getenv("DEBUG_SANITY")) {
1851     fprintf (stderr, "checkFunction: %s ", sym->name);
1852   }
1853
1854   /* make sure the type is complete and sane */
1855   checkTypeSanity(((symbol *)sym)->etype, ((symbol *)sym)->name);
1856
1857   /* if not type then some kind of error */
1858   if (!sym->type)
1859     return 0;
1860
1861   /* if the function has no type then make it return int */
1862   if (!sym->type->next)
1863     sym->type->next = sym->etype = newIntLink ();
1864
1865   /* function cannot return aggregate */
1866   if (IS_AGGREGATE (sym->type->next))
1867     {
1868       werror (E_FUNC_AGGR, sym->name);
1869       return 0;
1870     }
1871
1872   /* function cannot return bit */
1873   if (IS_BITVAR (sym->type->next))
1874     {
1875       werror (E_FUNC_BIT, sym->name);
1876       return 0;
1877     }
1878
1879   /* check if this function is defined as calleeSaves
1880      then mark it as such */
1881   FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
1882
1883   /* if interrupt service routine  */
1884   /* then it cannot have arguments */
1885   if (IFFUNC_ARGS(sym->type) && FUNC_ISISR (sym->type))
1886     {
1887       if (!IS_VOID(FUNC_ARGS(sym->type)->type)) {
1888         werror (E_INT_ARGS, sym->name);
1889         FUNC_ARGS(sym->type)=NULL;
1890       }
1891     }
1892
1893   for (argCnt=1, acargs = FUNC_ARGS(sym->type);
1894        acargs;
1895        acargs=acargs->next, argCnt++) {
1896     if (!acargs->sym) {
1897       // this can happen for reentrant functions
1898       werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1899       // the show must go on: synthesize a name and symbol
1900       SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
1901       acargs->sym = newSymbol (acargs->name, 1);
1902       SPEC_OCLS (acargs->etype) = istack;
1903       acargs->sym->type = copyLinkChain (acargs->type);
1904       acargs->sym->etype = getSpec (acargs->sym->type);
1905       acargs->sym->_isparm = 1;
1906       strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
1907     } else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
1908       // synthesized name
1909       werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
1910     }
1911   }
1912   argCnt--;
1913
1914   if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
1915     return 1;                   /* not defined nothing more to check  */
1916
1917   /* check if body already present */
1918   if (csym && IFFUNC_HASBODY(csym->type))
1919     {
1920       werror (E_FUNC_BODY, sym->name);
1921       return 0;
1922     }
1923
1924   /* check the return value type   */
1925   if (compareType (csym->type, sym->type) <= 0)
1926     {
1927       werror (E_PREV_DEF_CONFLICT, csym->name, "type");
1928       printFromToType(csym->type, sym->type);
1929       return 0;
1930     }
1931
1932   if (FUNC_ISISR (csym->type) != FUNC_ISISR (sym->type))
1933     {
1934       werror (E_PREV_DEF_CONFLICT, csym->name, "interrupt");
1935     }
1936
1937   if (FUNC_REGBANK (csym->type) != FUNC_REGBANK (sym->type))
1938     {
1939       werror (E_PREV_DEF_CONFLICT, csym->name, "using");
1940     }
1941
1942   if (IFFUNC_ISNAKED (csym->type) != IFFUNC_ISNAKED (sym->type))
1943     {
1944       werror (E_PREV_DEF_CONFLICT, csym->name, "_naked");
1945     }
1946
1947   /* Really, reentrant should match regardless of argCnt, but     */
1948   /* this breaks some existing code (the fp lib functions). If    */
1949   /* the first argument is always passed the same way, this       */
1950   /* lax checking is ok (but may not be true for in future ports) */
1951   if (IFFUNC_ISREENT (csym->type) != IFFUNC_ISREENT (sym->type)
1952       && argCnt>1)
1953     {
1954       //printf("argCnt = %d\n",argCnt);
1955       werror (E_PREV_DEF_CONFLICT, csym->name, "reentrant");
1956     }
1957
1958   /* compare expected args with actual args */
1959   exargs = FUNC_ARGS(csym->type);
1960   acargs = FUNC_ARGS(sym->type);
1961
1962   /* for all the expected args do */
1963   for (argCnt = 1;
1964        exargs && acargs;
1965        exargs = exargs->next, acargs = acargs->next, argCnt++)
1966     {
1967       if (getenv("DEBUG_SANITY")) {
1968         fprintf (stderr, "checkFunction: %s ", exargs->name);
1969       }
1970       /* make sure the type is complete and sane */
1971       checkTypeSanity(exargs->etype, exargs->name);
1972
1973       /* If the actual argument is an array, any prototype
1974        * will have modified it to a pointer. Duplicate that
1975        * change here.
1976        */
1977       if (IS_AGGREGATE (acargs->type))
1978         {
1979           checkValue = copyValue (acargs);
1980           aggregateToPointer (checkValue);
1981         }
1982       else
1983         {
1984           checkValue = acargs;
1985         }
1986
1987       if (compareType (exargs->type, checkValue->type) <= 0)
1988         {
1989           werror (E_ARG_TYPE, argCnt);
1990           printFromToType(exargs->type, checkValue->type);
1991           return 0;
1992         }
1993     }
1994
1995   /* if one them ended we have a problem */
1996   if ((exargs && !acargs && !IS_VOID (exargs->type)) ||
1997       (!exargs && acargs && !IS_VOID (acargs->type)))
1998     werror (E_ARG_COUNT);
1999
2000   /* replace with this defition */
2001   sym->cdef = csym->cdef;
2002   deleteSym (SymbolTab, csym, csym->name);
2003   deleteFromSeg(csym);
2004   addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
2005   if (IS_EXTERN (csym->etype) && !
2006       IS_EXTERN (sym->etype))
2007     {
2008       addSet (&publics, sym);
2009     }
2010   return 1;
2011 }
2012
2013 /*------------------------------------------------------------------*/
2014 /* cdbStructBlock - calls struct printing for a blcks               */
2015 /*------------------------------------------------------------------*/
2016 void cdbStructBlock (int block)
2017 {
2018   int i;
2019   bucket **table = StructTab;
2020   bucket *chain;
2021
2022   /* go thru the entire  table  */
2023   for (i = 0; i < 256; i++)
2024     {
2025       for (chain = table[i]; chain; chain = chain->next)
2026         {
2027           if (chain->block >= block)
2028             {
2029               if(debugFile)
2030                 debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
2031             }
2032         }
2033     }
2034 }
2035
2036 /*-----------------------------------------------------------------*/
2037 /* processFuncArgs - does some processing with function args       */
2038 /*-----------------------------------------------------------------*/
2039 void
2040 processFuncArgs (symbol * func)
2041 {
2042   value *val;
2043   int pNum = 1;
2044   sym_link *funcType=func->type;
2045
2046   if (getenv("SDCC_DEBUG_FUNCTION_POINTERS"))
2047     fprintf (stderr, "SDCCsymt.c:processFuncArgs(%s)\n", func->name);
2048
2049   // if this is a pointer to a function
2050   if (IS_PTR(funcType)) {
2051     funcType=funcType->next;
2052   }
2053
2054   /* if this function has variable argument list */
2055   /* then make the function a reentrant one    */
2056   if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
2057     FUNC_ISREENT(funcType)=1;
2058
2059   /* check if this function is defined as calleeSaves
2060      then mark it as such */
2061   FUNC_CALLEESAVES(funcType) = inCalleeSaveList (func->name);
2062
2063   /* loop thru all the arguments   */
2064   val = FUNC_ARGS(funcType);
2065
2066   /* if it is void then remove parameters */
2067   if (val && IS_VOID (val->type))
2068     {
2069       FUNC_ARGS(funcType) = NULL;
2070       return;
2071     }
2072
2073   /* reset regparm for the port */
2074   (*port->reset_regparms) ();
2075   /* if any of the arguments is an aggregate */
2076   /* change it to pointer to the same type */
2077   while (val)
2078     {
2079         int argreg = 0;
2080       /* mark it as a register parameter if
2081          the function does not have VA_ARG
2082          and as port dictates */
2083       if (!IFFUNC_HASVARARGS(funcType) &&
2084           (argreg = (*port->reg_parm) (val->type)))
2085         {
2086           SPEC_REGPARM (val->etype) = 1;
2087           SPEC_ARGREG(val->etype) = argreg;
2088         } else if (IFFUNC_ISREENT(funcType)) {
2089             FUNC_HASSTACKPARM(funcType) = 1;
2090         }
2091
2092       if (IS_AGGREGATE (val->type))
2093         {
2094           aggregateToPointer (val);
2095         }
2096
2097       val = val->next;
2098       pNum++;
2099     }
2100
2101   /* if this is an internal generated function call */
2102   if (func->cdef) {
2103     /* ignore --stack-auto for this one, we don't know how it is compiled */
2104     /* simply trust on --int-long-reent or --float-reent */
2105     if (IFFUNC_ISREENT(funcType)) {
2106       return;
2107     }
2108   } else {
2109     /* if this function is reentrant or */
2110     /* automatics r 2b stacked then nothing */
2111     if (IFFUNC_ISREENT (funcType) || options.stackAuto)
2112       return;
2113   }
2114
2115   val = FUNC_ARGS(funcType);
2116   pNum = 1;
2117   while (val)
2118     {
2119
2120       /* if a symbolname is not given  */
2121       /* synthesize a variable name */
2122       if (!val->sym)
2123         {
2124           SNPRINTF (val->name, sizeof(val->name),
2125                     "_%s_PARM_%d", func->name, pNum++);
2126           val->sym = newSymbol (val->name, 1);
2127           SPEC_OCLS (val->etype) = port->mem.default_local_map;
2128           val->sym->type = copyLinkChain (val->type);
2129           val->sym->etype = getSpec (val->sym->type);
2130           val->sym->_isparm = 1;
2131           strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2132           if (IS_SPEC(func->etype)) {
2133             SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2134               SPEC_STAT (func->etype);
2135           }
2136           addSymChain (val->sym);
2137
2138         }
2139       else                      /* symbol name given create synth name */
2140         {
2141
2142           SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
2143           strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
2144           val->sym->_isparm = 1;
2145           SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
2146             (options.model != MODEL_SMALL ? xdata : data);
2147           if (IS_SPEC(func->etype)) {
2148             SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
2149               SPEC_STAT (func->etype);
2150           }
2151         }
2152       if (!isinSet(operKeyReset, val->sym)) {
2153         addSet (&operKeyReset, val->sym);
2154         applyToSet (operKeyReset, resetParmKey);
2155       }
2156       val = val->next;
2157     }
2158 }
2159
2160 /*-----------------------------------------------------------------*/
2161 /* isSymbolEqual - compares two symbols return 1 if they match     */
2162 /*-----------------------------------------------------------------*/
2163 int
2164 isSymbolEqual (symbol * dest, symbol * src)
2165 {
2166   /* if pointers match then equal */
2167   if (dest == src)
2168     return 1;
2169
2170   /* if one of them is null then don't match */
2171   if (!dest || !src)
2172     return 0;
2173
2174   /* if both of them have rname match on rname */
2175   if (dest->rname[0] && src->rname[0])
2176     return (!strcmp (dest->rname, src->rname));
2177
2178   /* otherwise match on name */
2179   return (!strcmp (dest->name, src->name));
2180 }
2181
2182 void PT(sym_link *type)
2183 {
2184         printTypeChain(type,0);
2185 }
2186 /*-----------------------------------------------------------------*/
2187 /* printTypeChain - prints the type chain in human readable form   */
2188 /*-----------------------------------------------------------------*/
2189 void
2190 printTypeChain (sym_link * start, FILE * of)
2191 {
2192   int nlr = 0;
2193   value *args;
2194   sym_link * type, * search;
2195   STORAGE_CLASS scls;
2196
2197   if (!of)
2198     {
2199       of = stdout;
2200       nlr = 1;
2201     }
2202
2203   if (start==NULL) {
2204     fprintf (of, "void");
2205     return;
2206   }
2207
2208   /* Print the chain as it is written in the source: */
2209   /* start with the last entry.                      */
2210   /* However, the storage class at the end of the    */
2211   /* chain reall applies to the first in the chain!  */
2212
2213   for (type = start; type && type->next; type = type->next)
2214     ;
2215   if (IS_SPEC (type))
2216     scls=SPEC_SCLS(type);
2217   else
2218     scls=0;
2219   while (type)
2220     {
2221       if (type==start) {
2222         switch (scls)
2223           {
2224           case S_DATA: fprintf (of, "data-"); break;
2225           case S_XDATA: fprintf (of, "xdata-"); break;
2226           case S_SFR: fprintf (of, "sfr-"); break;
2227           case S_SBIT: fprintf (of, "sbit-"); break;
2228           case S_CODE: fprintf (of, "code-"); break;
2229           case S_IDATA: fprintf (of, "idata-"); break;
2230           case S_PDATA: fprintf (of, "pdata-"); break;
2231           case S_LITERAL: fprintf (of, "literal-"); break;
2232           case S_STACK: fprintf (of, "stack-"); break;
2233           case S_XSTACK: fprintf (of, "xstack-"); break;
2234           case S_BIT: fprintf (of, "bit-"); break;
2235           case S_EEPROM: fprintf (of, "eeprom-"); break;
2236           default: break;
2237           }
2238       }
2239
2240       if (IS_DECL (type))
2241         {
2242           if (!IS_FUNC(type)) {
2243             if (DCL_PTR_VOLATILE (type)) {
2244               fprintf (of, "volatile-");
2245             }
2246             if (DCL_PTR_CONST (type)) {
2247               fprintf (of, "const-");
2248             }
2249           }
2250           switch (DCL_TYPE (type))
2251             {
2252             case FUNCTION:
2253               fprintf (of, "function %s %s",
2254                        (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2255                        (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2256               fprintf (of, "( ");
2257               for (args = FUNC_ARGS(type);
2258                    args;
2259                    args=args->next) {
2260                 printTypeChain(args->type, of);
2261                 if (args->next)
2262                   fprintf(of, ", ");
2263               }
2264               fprintf (of, ") ");
2265               break;
2266             case GPOINTER:
2267               fprintf (of, "generic* ");
2268               break;
2269             case CPOINTER:
2270               fprintf (of, "code* ");
2271               break;
2272             case FPOINTER:
2273               fprintf (of, "xdata* ");
2274               break;
2275             case EEPPOINTER:
2276               fprintf (of, "eeprom* ");
2277               break;
2278             case POINTER:
2279               fprintf (of, "near* ");
2280               break;
2281             case IPOINTER:
2282               fprintf (of, "idata* ");
2283               break;
2284             case PPOINTER:
2285               fprintf (of, "pdata* ");
2286               break;
2287             case UPOINTER:
2288               fprintf (of, "unknown* ");
2289               break;
2290             case ARRAY:
2291               if (DCL_ELEM(type)) {
2292                 fprintf (of, "[%d] ", DCL_ELEM(type));
2293               } else {
2294                 fprintf (of, "[] ");
2295               }
2296               break;
2297             }
2298         }
2299       else
2300         {
2301           if (SPEC_VOLATILE (type))
2302             fprintf (of, "volatile-");
2303           if (SPEC_CONST (type))
2304             fprintf (of, "const-");
2305           if (SPEC_USIGN (type))
2306             fprintf (of, "unsigned-");
2307           switch (SPEC_NOUN (type))
2308             {
2309             case V_INT:
2310               if (IS_LONG (type))
2311                 fprintf (of, "long-");
2312               fprintf (of, "int");
2313               break;
2314
2315             case V_CHAR:
2316               fprintf (of, "char");
2317               break;
2318
2319             case V_VOID:
2320               fprintf (of, "void");
2321               break;
2322
2323             case V_FLOAT:
2324               fprintf (of, "float");
2325               break;
2326
2327             case V_STRUCT:
2328               fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2329               break;
2330
2331             case V_SBIT:
2332               fprintf (of, "sbit");
2333               break;
2334
2335             case V_BIT:
2336               fprintf (of, "bit");
2337               break;
2338
2339             case V_BITFIELD:
2340               fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2341               break;
2342
2343             case V_DOUBLE:
2344               fprintf (of, "double");
2345               break;
2346
2347             default:
2348               fprintf (of, "unknown type");
2349               break;
2350             }
2351         }
2352       /* search entry in list before "type" */
2353       for (search = start; search && search->next != type;)
2354         search = search->next;
2355       type = search;
2356       if (type)
2357         fputc (' ', of);
2358     }
2359   if (nlr)
2360     fprintf (of, "\n");
2361 }
2362
2363 /*--------------------------------------------------------------------*/
2364 /* printTypeChainRaw - prints the type chain in human readable form   */
2365 /*                     in the raw data structure ordering             */
2366 /*--------------------------------------------------------------------*/
2367 void
2368 printTypeChainRaw (sym_link * start, FILE * of)
2369 {
2370   int nlr = 0;
2371   value *args;
2372   sym_link * type;
2373
2374   if (!of)
2375     {
2376       of = stdout;
2377       nlr = 1;
2378     }
2379
2380   if (start==NULL) {
2381     fprintf (of, "void");
2382     return;
2383   }
2384
2385   type = start;
2386
2387   while (type)
2388     {
2389       if (IS_DECL (type))
2390         {
2391           if (!IS_FUNC(type)) {
2392             if (DCL_PTR_VOLATILE (type)) {
2393               fprintf (of, "volatile-");
2394             }
2395             if (DCL_PTR_CONST (type)) {
2396               fprintf (of, "const-");
2397             }
2398           }
2399           switch (DCL_TYPE (type))
2400             {
2401             case FUNCTION:
2402               fprintf (of, "function %s %s",
2403                        (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
2404                        (IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
2405               fprintf (of, "( ");
2406               for (args = FUNC_ARGS(type);
2407                    args;
2408                    args=args->next) {
2409                 printTypeChain(args->type, of);
2410                 if (args->next)
2411                   fprintf(of, ", ");
2412               }
2413               fprintf (of, ") ");
2414               break;
2415             case GPOINTER:
2416               fprintf (of, "generic* ");
2417               break;
2418             case CPOINTER:
2419               fprintf (of, "code* ");
2420               break;
2421             case FPOINTER:
2422               fprintf (of, "xdata* ");
2423               break;
2424             case EEPPOINTER:
2425               fprintf (of, "eeprom* ");
2426               break;
2427             case POINTER:
2428               fprintf (of, "near* ");
2429               break;
2430             case IPOINTER:
2431               fprintf (of, "idata* ");
2432               break;
2433             case PPOINTER:
2434               fprintf (of, "pdata* ");
2435               break;
2436             case UPOINTER:
2437               fprintf (of, "unknown* ");
2438               break;
2439             case ARRAY:
2440               if (DCL_ELEM(type)) {
2441                 fprintf (of, "[%d] ", DCL_ELEM(type));
2442               } else {
2443                 fprintf (of, "[] ");
2444               }
2445               break;
2446             }
2447           if (DCL_TSPEC(type))
2448             {
2449               fprintf (of, "{");
2450               printTypeChainRaw(DCL_TSPEC(type), of);
2451               fprintf (of, "}");
2452             }
2453         }
2454       else if (IS_SPEC (type))
2455         {
2456         switch (SPEC_SCLS (type))
2457           {
2458           case S_DATA: fprintf (of, "data-"); break;
2459           case S_XDATA: fprintf (of, "xdata-"); break;
2460           case S_SFR: fprintf (of, "sfr-"); break;
2461           case S_SBIT: fprintf (of, "sbit-"); break;
2462           case S_CODE: fprintf (of, "code-"); break;
2463           case S_IDATA: fprintf (of, "idata-"); break;
2464           case S_PDATA: fprintf (of, "pdata-"); break;
2465           case S_LITERAL: fprintf (of, "literal-"); break;
2466           case S_STACK: fprintf (of, "stack-"); break;
2467           case S_XSTACK: fprintf (of, "xstack-"); break;
2468           case S_BIT: fprintf (of, "bit-"); break;
2469           case S_EEPROM: fprintf (of, "eeprom-"); break;
2470           default: break;
2471           }
2472           if (SPEC_VOLATILE (type))
2473             fprintf (of, "volatile-");
2474           if (SPEC_CONST (type))
2475             fprintf (of, "const-");
2476           if (SPEC_USIGN (type))
2477             fprintf (of, "unsigned-");
2478           switch (SPEC_NOUN (type))
2479             {
2480             case V_INT:
2481               if (IS_LONG (type))
2482                 fprintf (of, "long-");
2483               fprintf (of, "int");
2484               break;
2485
2486             case V_CHAR:
2487               fprintf (of, "char");
2488               break;
2489
2490             case V_VOID:
2491               fprintf (of, "void");
2492               break;
2493
2494             case V_FLOAT:
2495               fprintf (of, "float");
2496               break;
2497
2498             case V_STRUCT:
2499               fprintf (of, "struct %s", SPEC_STRUCT (type)->tag);
2500               break;
2501
2502             case V_SBIT:
2503               fprintf (of, "sbit");
2504               break;
2505
2506             case V_BIT:
2507               fprintf (of, "bit");
2508               break;
2509
2510             case V_BITFIELD:
2511               fprintf (of, "bitfield {%d,%d}", SPEC_BSTR (type), SPEC_BLEN (type));
2512               break;
2513
2514             case V_DOUBLE:
2515               fprintf (of, "double");
2516               break;
2517
2518             default:
2519               fprintf (of, "unknown type");
2520               break;
2521             }
2522         }
2523       else
2524         fprintf (of, "NOT_SPEC_OR_DECL");
2525       type = type->next;
2526       if (type)
2527         fputc (' ', of);
2528     }
2529   if (nlr)
2530     fprintf (of, "\n");
2531 }
2532
2533
2534 /*-----------------------------------------------------------------*/
2535 /* powof2 - returns power of two for the number if number is pow 2 */
2536 /*-----------------------------------------------------------------*/
2537 int
2538 powof2 (unsigned long num)
2539 {
2540   int nshifts = 0;
2541   int n1s = 0;
2542
2543   while (num)
2544     {
2545       if (num & 1)
2546         n1s++;
2547       num >>= 1;
2548       nshifts++;
2549     }
2550
2551   if (n1s > 1 || nshifts == 0)
2552     return 0;
2553   return nshifts - 1;
2554 }
2555
2556 symbol *__fsadd;
2557 symbol *__fssub;
2558 symbol *__fsmul;
2559 symbol *__fsdiv;
2560 symbol *__fseq;
2561 symbol *__fsneq;
2562 symbol *__fslt;
2563 symbol *__fslteq;
2564 symbol *__fsgt;
2565 symbol *__fsgteq;
2566
2567 /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2568 symbol *__muldiv[3][3][2];
2569 /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */
2570 sym_link *__multypes[3][2];
2571 /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */
2572 symbol *__conv[2][3][2];
2573 /* Dims: shift left/shift right, BYTE/WORD/DWORD, SIGNED/UNSIGNED */
2574 symbol *__rlrr[2][3][2];
2575
2576 sym_link *floatType;
2577
2578 static char *
2579 _mangleFunctionName(char *in)
2580 {
2581   if (port->getMangledFunctionName)
2582     {
2583       return port->getMangledFunctionName(in);
2584     }
2585   else
2586     {
2587       return in;
2588     }
2589 }
2590
2591 /*-----------------------------------------------------------------*/
2592 /* typeFromStr - create a typechain from an encoded string         */
2593 /* basic types -        'c' - char                                 */
2594 /*                      's' - short                                */
2595 /*                      'i' - int                                  */
2596 /*                      'l' - long                                 */
2597 /*                      'f' - float                                */
2598 /*                      'v' - void                                 */
2599 /*                      '*' - pointer - default (GPOINTER)         */
2600 /* modifiers -          'u' - unsigned                             */
2601 /* pointer modifiers -  'g' - generic                              */
2602 /*                      'x' - xdata                                */
2603 /*                      'p' - code                                 */
2604 /*                      'd' - data                                 */
2605 /*                      'F' - function                             */
2606 /* examples : "ig*" - generic int *                                */
2607 /*            "cx*" - char xdata *                                 */
2608 /*            "ui" -  unsigned int                                 */
2609 /*-----------------------------------------------------------------*/
2610 sym_link *typeFromStr (char *s)
2611 {
2612     sym_link *r = newLink(DECLARATOR);
2613     int usign = 0;
2614
2615     do {
2616         sym_link *nr;
2617         switch (*s) {
2618         case 'u' :
2619             usign = 1;
2620             s++;
2621             continue ;
2622             break ;
2623         case 'c':
2624             r->class = SPECIFIER;
2625             SPEC_NOUN(r) = V_CHAR;
2626             break;
2627         case 's':
2628         case 'i':
2629             r->class = SPECIFIER;
2630             SPEC_NOUN(r) = V_INT;
2631             break;
2632         case 'l':
2633             r->class = SPECIFIER;
2634             SPEC_NOUN(r) = V_INT;
2635             SPEC_LONG(r) = 1;
2636             break;
2637         case 'f':
2638             r->class = SPECIFIER;
2639             SPEC_NOUN(r) = V_FLOAT;
2640             break;
2641         case 'v':
2642             r->class = SPECIFIER;
2643             SPEC_NOUN(r) = V_VOID;
2644             break;
2645         case '*':
2646             DCL_TYPE(r) = port->unqualified_pointer;
2647             break;
2648         case 'g':
2649         case 'x':
2650         case 'p':
2651         case 'd':
2652         case 'F':
2653             assert(*(s+1)=='*');
2654             nr = newLink(DECLARATOR);
2655             nr->next = r;
2656             r = nr;
2657             switch (*s) {
2658             case 'g':
2659                 DCL_TYPE(r) = GPOINTER;
2660                 break;
2661             case 'x':
2662                 DCL_TYPE(r) = FPOINTER;
2663                 break;
2664             case 'p':
2665                 DCL_TYPE(r) = CPOINTER;
2666                 break;
2667             case 'd':
2668                 DCL_TYPE(r) = POINTER;
2669                 break;
2670             case 'F':
2671                 DCL_TYPE(r) = FUNCTION;
2672                 nr = newLink(DECLARATOR);
2673                 nr->next = r;
2674                 r = nr;
2675                 DCL_TYPE(r) = CPOINTER;
2676                 break;
2677             }
2678             s++;
2679             break;
2680         default:
2681             werror(E_INTERNAL_ERROR, __FILE__, __LINE__,
2682                    "typeFromStr: unknown type");
2683             break;
2684         }
2685         if (IS_SPEC(r) && usign) {
2686             SPEC_USIGN(r) = 1;
2687             usign = 0;
2688         }
2689         s++;
2690     } while (*s);
2691     return r;
2692 }
2693
2694 /*-----------------------------------------------------------------*/
2695 /* initCSupport - create functions for C support routines          */
2696 /*-----------------------------------------------------------------*/
2697 void
2698 initCSupport ()
2699 {
2700   const char *smuldivmod[] =
2701   {
2702     "mul", "div", "mod"
2703   };
2704   const char *sbwd[] =
2705   {
2706     "char", "int", "long"
2707   };
2708   const char *ssu[] =
2709   {
2710     "s", "u"
2711   };
2712   const char *srlrr[] =
2713   {
2714     "rl", "rr"
2715   };
2716
2717   int bwd, su, muldivmod, tofrom, rlrr;
2718
2719   if (getenv("SDCC_NO_C_SUPPORT")) {
2720     /* for debugging only */
2721     return;
2722   }
2723
2724   floatType = newFloatLink ();
2725
2726   for (bwd = 0; bwd < 3; bwd++)
2727     {
2728       sym_link *l = NULL;
2729       switch (bwd)
2730         {
2731         case 0:
2732           l = newCharLink ();
2733           break;
2734         case 1:
2735           l = newIntLink ();
2736           break;
2737         case 2:
2738           l = newLongLink ();
2739           break;
2740         default:
2741           assert (0);
2742         }
2743       __multypes[bwd][0] = l;
2744       __multypes[bwd][1] = copyLinkChain (l);
2745       SPEC_USIGN (__multypes[bwd][1]) = 1;
2746     }
2747
2748   __fsadd = funcOfType ("__fsadd", floatType, floatType, 2, options.float_rent);
2749   __fssub = funcOfType ("__fssub", floatType, floatType, 2, options.float_rent);
2750   __fsmul = funcOfType ("__fsmul", floatType, floatType, 2, options.float_rent);
2751   __fsdiv = funcOfType ("__fsdiv", floatType, floatType, 2, options.float_rent);
2752   __fseq = funcOfType ("__fseq", CHARTYPE, floatType, 2, options.float_rent);
2753   __fsneq = funcOfType ("__fsneq", CHARTYPE, floatType, 2, options.float_rent);
2754   __fslt = funcOfType ("__fslt", CHARTYPE, floatType, 2, options.float_rent);
2755   __fslteq = funcOfType ("__fslteq", CHARTYPE, floatType, 2, options.float_rent);
2756   __fsgt = funcOfType ("__fsgt", CHARTYPE, floatType, 2, options.float_rent);
2757   __fsgteq = funcOfType ("__fsgteq", CHARTYPE, floatType, 2, options.float_rent);
2758
2759   for (tofrom = 0; tofrom < 2; tofrom++)
2760     {
2761       for (bwd = 0; bwd < 3; bwd++)
2762         {
2763           for (su = 0; su < 2; su++)
2764             {
2765               if (tofrom)
2766                 {
2767                   SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
2768                   __conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
2769                 }
2770               else
2771                 {
2772                   SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
2773                   __conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
2774                 }
2775             }
2776         }
2777     }
2778
2779 /*
2780   for (muldivmod = 0; muldivmod < 3; muldivmod++)
2781     {
2782       for (bwd = 0; bwd < 3; bwd++)
2783         {
2784           for (su = 0; su < 2; su++)
2785             {
2786               SNPRINTF (buffer, sizeof(buffer),
2787                         "_%s%s%s",
2788                        smuldivmod[muldivmod],
2789                        ssu[su],
2790                        sbwd[bwd]);
2791               __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2792               FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2793             }
2794         }
2795     }
2796
2797   muluint() and mulsint() resp. mululong() and mulslong() return the same result.
2798   Therefore they've been merged into mulint() and mullong().
2799 */
2800
2801   for (bwd = 0; bwd < 3; bwd++)
2802     {
2803       for (su = 0; su < 2; su++)
2804         {
2805           for (muldivmod = 1; muldivmod < 3; muldivmod++)
2806             {
2807               /* div and mod */
2808               SNPRINTF (buffer, sizeof(buffer),
2809                         "_%s%s%s",
2810                        smuldivmod[muldivmod],
2811                        ssu[su],
2812                        sbwd[bwd]);
2813               __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2814               FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2815             }
2816         }
2817     }
2818   /* mul only */
2819   muldivmod = 0;
2820   /* byte */
2821   bwd = 0;
2822   for (su = 0; su < 2; su++)
2823     {
2824       /* muluchar and mulschar are still separate functions, because e.g. the z80
2825          port is sign/zero-extending to int before calling mulint() */
2826       SNPRINTF (buffer, sizeof(buffer),
2827                 "_%s%s%s",
2828                 smuldivmod[muldivmod],
2829                 ssu[su],
2830                 sbwd[bwd]);
2831       __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2832       FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
2833     }
2834   /* signed only */
2835   su = 0;
2836   /* word and doubleword */
2837   for (bwd = 1; bwd < 3; bwd++)
2838     {
2839       /* mul, int/long */
2840       SNPRINTF (buffer, sizeof(buffer),
2841                 "_%s%s",
2842                 smuldivmod[muldivmod],
2843                 sbwd[bwd]);
2844       __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
2845       FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
2846       /* signed = unsigned */
2847       __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
2848     }
2849
2850   for (rlrr = 0; rlrr < 2; rlrr++)
2851     {
2852       for (bwd = 0; bwd < 3; bwd++)
2853         {
2854           for (su = 0; su < 2; su++)
2855             {
2856               SNPRINTF (buffer, sizeof(buffer),
2857                         "_%s%s%s",
2858                        srlrr[rlrr],
2859                        ssu[su],
2860                        sbwd[bwd]);
2861               __rlrr[rlrr][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[0][0], 2, options.intlong_rent);
2862               FUNC_NONBANKED (__rlrr[rlrr][bwd][su]->type) = 1;
2863             }
2864         }
2865     }
2866 }
2867
2868 /*-----------------------------------------------------------------*/
2869 /* initBuiltIns - create prototypes for builtin functions          */
2870 /*-----------------------------------------------------------------*/
2871 void initBuiltIns()
2872 {
2873     int i;
2874     symbol *sym;
2875
2876     if (!port->builtintable) return ;
2877
2878     for (i = 0 ; port->builtintable[i].name ; i++) {
2879         sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
2880                              port->builtintable[i].nParms,port->builtintable[i].parm_types);
2881         FUNC_ISBUILTIN(sym->type) = 1;
2882         FUNC_ISREENT(sym->type) = 0;    /* can never be reentrant */
2883     }
2884 }
2885
2886 sym_link *validateLink(sym_link         *l,
2887                         const char      *macro,
2888                         const char      *args,
2889                         const char      select,
2890                         const char      *file,
2891                         unsigned        line)
2892 {
2893   if (l && l->class==select)
2894     {
2895         return l;
2896     }
2897     fprintf(stderr,
2898             "Internal error: validateLink failed in %s(%s) @ %s:%u:"
2899             " expected %s, got %s\n",
2900             macro, args, file, line,
2901             DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
2902     exit(-1);
2903     return l; // never reached, makes compiler happy.
2904 }