1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 
  25 /*
  26  * Copyright (c) 2018, Joyent, Inc.
  27  */
  28 
  29 /*
  30  * This file is a sewer.
  31  */
  32 
  33 #include <limits.h>
  34 #include <stdarg.h>
  35 #include <stdio.h>
  36 #include <assert.h>
  37 #include <strings.h>
  38 #include <setjmp.h>
  39 #include <ctype.h>
  40 #include <uts/common/sys/ctf.h>
  41 
  42 #include "ctftools.h"
  43 #include "memory.h"
  44 #include "list.h"
  45 
  46 #define HASH(NUM)       ((int)(NUM & (BUCKETS - 1)))
  47 #define BUCKETS         128
  48 
  49 #define TYPEPAIRMULT    10000
  50 #define MAKETYPEID(file, num)   ((file) * TYPEPAIRMULT + num)
  51 #define TYPEFILE(tid)           ((tid) / TYPEPAIRMULT)
  52 #define TYPENUM(tid)            ((tid) % TYPEPAIRMULT)
  53 
  54 #define expected(a, b, c) _expected(a, b, c, __LINE__)
  55 
  56 static int faketypenumber = 100000000;
  57 
  58 static tdesc_t *hash_table[BUCKETS];
  59 static tdesc_t *name_table[BUCKETS];
  60 
  61 list_t *typedbitfldmems;
  62 
  63 static void reset(void);
  64 static jmp_buf  resetbuf;
  65 
  66 static char *soudef(char *cp, stabtype_t type, tdesc_t **rtdp);
  67 static void enumdef(char *cp, tdesc_t **rtdp);
  68 static int compute_sum(const char *w);
  69 
  70 static char *number(char *cp, int *n);
  71 static char *name(char *cp, char **w);
  72 static char *id(char *cp, int *h);
  73 static char *whitesp(char *cp);
  74 static void addhash(tdesc_t *tdp, int num);
  75 static int tagadd(char *w, int h, tdesc_t *tdp);
  76 static char *tdefdecl(char *cp, int h, tdesc_t **rtdp);
  77 static char *intrinsic(char *cp, tdesc_t **rtdp);
  78 static char *arraydef(char *cp, tdesc_t **rtdp);
  79 
  80 extern int debug_level;
  81 int debug_parse = DEBUG_PARSE;
  82 
  83 /*PRINTFLIKE3*/
  84 static void
  85 parse_debug(int level, char *cp, char *fmt, ...)
  86 {
  87         va_list ap;
  88         char buf[1024];
  89         char tmp[32];
  90         int i;
  91 
  92         if (level > debug_level || !debug_parse)
  93                 return;
  94 
  95         if (cp != NULL) {
  96                 for (i = 0; i < 30; i++) {
  97                         if (cp[i] == '\0')
  98                                 break;
  99                         if (!iscntrl(cp[i]))
 100                                 tmp[i] = cp[i];
 101                 }
 102                 tmp[i] = '\0';
 103                 (void) snprintf(buf, sizeof (buf), "%s [cp='%s']\n", fmt, tmp);
 104         } else {
 105                 strcpy(buf, fmt);
 106                 strcat(buf, "\n");
 107         }
 108 
 109         va_start(ap, fmt);
 110         vadebug(level, buf, ap);
 111         va_end(ap);
 112 }
 113 
 114 /* Report unexpected syntax in stabs. */
 115 static void
 116 _expected(
 117         char *who,      /* what function, or part thereof, is reporting */
 118         char *what,     /* what was expected */
 119         char *where,    /* where we were in the line of input */
 120         int line)
 121 {
 122         fprintf(stderr, "%s, expecting \"%s\" at \"%s\"\n", who, what, where);
 123         fprintf(stderr, "code line: %d, file %s\n", line,
 124             (curhdr ? curhdr : "NO FILE"));
 125         reset();
 126 }
 127 
 128 /*ARGSUSED*/
 129 void
 130 parse_init(tdata_t *td)
 131 {
 132         int i;
 133 
 134         for (i = 0; i < BUCKETS; i++) {
 135                 hash_table[i] = NULL;
 136                 name_table[i] = NULL;
 137         }
 138 
 139         if (typedbitfldmems != NULL) {
 140                 list_free(typedbitfldmems, NULL, NULL);
 141                 typedbitfldmems = NULL;
 142         }
 143 }
 144 
 145 void
 146 parse_finish(tdata_t *td)
 147 {
 148         td->td_nextid = ++faketypenumber;
 149 }
 150 
 151 static tdesc_t *
 152 unres_new(int tid)
 153 {
 154         tdesc_t *tdp;
 155 
 156         tdp = xcalloc(sizeof (*tdp));
 157         tdp->t_type = TYPEDEF_UNRES;
 158         tdp->t_id = tid;
 159 
 160         return (tdp);
 161 }
 162 
 163 char *
 164 read_tid(char *cp, tdesc_t **tdpp)
 165 {
 166         tdesc_t *tdp;
 167         int tid;
 168 
 169         cp = id(cp, &tid);
 170 
 171         assert(tid != 0);
 172 
 173         if (*cp == '=') {
 174                 if (!(cp = tdefdecl(cp + 1, tid, &tdp)))
 175                         return (NULL);
 176                 if (tdp->t_id && tdp->t_id != tid) {
 177                         tdesc_t *ntdp = xcalloc(sizeof (*ntdp));
 178 
 179                         ntdp->t_type = TYPEDEF;
 180                         ntdp->t_tdesc = tdp;
 181                         tdp = ntdp;
 182                 }
 183                 addhash(tdp, tid);
 184         } else if ((tdp = lookup(tid)) == NULL)
 185                 tdp = unres_new(tid);
 186 
 187         *tdpp = tdp;
 188         return (cp);
 189 }
 190 
 191 static iitype_t
 192 parse_fun(char *cp, iidesc_t *ii)
 193 {
 194         iitype_t iitype;
 195         tdesc_t *tdp;
 196         tdesc_t **args = NULL;
 197         int nargs = 0;
 198         int va = 0;
 199 
 200         /*
 201          * name:P               prototype
 202          * name:F               global function
 203          * name:f               static function
 204          */
 205         switch (*cp++) {
 206         case 'P':
 207                 iitype = II_NOT; /* not interesting */
 208                 break;
 209 
 210         case 'F':
 211                 iitype = II_GFUN;
 212                 break;
 213 
 214         case 'f':
 215                 iitype = II_SFUN;
 216                 break;
 217 
 218         default:
 219                 expected("parse_nfun", "[PfF]", cp - 1);
 220         }
 221 
 222         if (!(cp = read_tid(cp, &tdp)))
 223                 return (-1);
 224 
 225         if (*cp)
 226                 args = xmalloc(sizeof (tdesc_t *) * FUNCARG_DEF);
 227 
 228         while (*cp && *++cp) {
 229                 if (*cp == '0') {
 230                         va = 1;
 231                         continue;
 232                 }
 233 
 234                 nargs++;
 235                 if (nargs > FUNCARG_DEF)
 236                         args = xrealloc(args, sizeof (tdesc_t *) * nargs);
 237                 if (!(cp = read_tid(cp, &args[nargs - 1])))
 238                         return (-1);
 239         }
 240 
 241         ii->ii_type = iitype;
 242         ii->ii_dtype = tdp;
 243         ii->ii_nargs = nargs;
 244         ii->ii_args = args;
 245         ii->ii_vargs = va;
 246 
 247         return (iitype);
 248 }
 249 
 250 static iitype_t
 251 parse_sym(char *cp, iidesc_t *ii)
 252 {
 253         tdesc_t *tdp;
 254         iitype_t iitype;
 255 
 256         /*
 257          * name:G               global variable
 258          * name:S               static variable
 259          */
 260         switch (*cp++) {
 261         case 'G':
 262                 iitype = II_GVAR;
 263                 break;
 264         case 'S':
 265                 iitype = II_SVAR;
 266                 break;
 267         case 'p':
 268                 iitype = II_PSYM;
 269                 break;
 270         case '(':
 271                 cp--;
 272                 /*FALLTHROUGH*/
 273         case 'r':
 274         case 'V':
 275                 iitype = II_NOT; /* not interesting */
 276                 break;
 277         default:
 278                 expected("parse_sym", "[GprSV(]", cp - 1);
 279         }
 280 
 281         if (!(cp = read_tid(cp, &tdp)))
 282                 return (-1);
 283 
 284         ii->ii_type = iitype;
 285         ii->ii_dtype = tdp;
 286 
 287         return (iitype);
 288 }
 289 
 290 static iitype_t
 291 parse_type(char *cp, iidesc_t *ii)
 292 {
 293         tdesc_t *tdp, *ntdp;
 294         int tid;
 295 
 296         if (*cp++ != 't')
 297                 expected("parse_type", "t (type)", cp - 1);
 298 
 299         cp = id(cp, &tid);
 300         if ((tdp = lookup(tid)) == NULL) {
 301                 if (*cp++ != '=')
 302                         expected("parse_type", "= (definition)", cp - 1);
 303 
 304                 (void) tdefdecl(cp, tid, &tdp);
 305 
 306                 if (tdp->t_id == tid) {
 307                         assert(tdp->t_type != TYPEDEF);
 308                         assert(!lookup(tdp->t_id));
 309 
 310                         if (!streq(tdp->t_name, ii->ii_name)) {
 311                                 ntdp = xcalloc(sizeof (*ntdp));
 312                                 ntdp->t_name = xstrdup(ii->ii_name);
 313                                 ntdp->t_type = TYPEDEF;
 314                                 ntdp->t_tdesc = tdp;
 315                                 tdp->t_id = faketypenumber++;
 316                                 tdp = ntdp;
 317                         }
 318                 } else if (tdp->t_id == 0) {
 319                         assert(tdp->t_type == FORWARD ||
 320                             tdp->t_type == INTRINSIC);
 321 
 322                         if (tdp->t_name && !streq(tdp->t_name, ii->ii_name)) {
 323                                 ntdp = xcalloc(sizeof (*ntdp));
 324                                 ntdp->t_name = xstrdup(ii->ii_name);
 325                                 ntdp->t_type = TYPEDEF;
 326                                 ntdp->t_tdesc = tdp;
 327                                 tdp->t_id = faketypenumber++;
 328                                 tdp = ntdp;
 329                         }
 330                 } else if (tdp->t_id != tid) {
 331                         ntdp = xcalloc(sizeof (*ntdp));
 332                         ntdp->t_name = xstrdup(ii->ii_name);
 333                         ntdp->t_type = TYPEDEF;
 334                         ntdp->t_tdesc = tdp;
 335                         tdp = ntdp;
 336                 }
 337 
 338                 if (tagadd(ii->ii_name, tid, tdp) < 0)
 339                         return (-1);
 340         }
 341 
 342         ii->ii_type = II_TYPE;
 343         ii->ii_dtype = tdp;
 344         return (II_TYPE);
 345 }
 346 
 347 static iitype_t
 348 parse_sou(char *cp, iidesc_t *idp)
 349 {
 350         tdesc_t *rtdp;
 351         int tid;
 352 
 353         if (*cp++ != 'T')
 354                 expected("parse_sou", "T (sou)", cp - 1);
 355 
 356         cp = id(cp, &tid);
 357         if (*cp++ != '=')
 358                 expected("parse_sou", "= (definition)", cp - 1);
 359 
 360         parse_debug(1, NULL, "parse_sou: declaring '%s'", idp->ii_name ?
 361             idp->ii_name : "(anon)");
 362         if ((rtdp = lookup(tid)) != NULL) {
 363                 if (idp->ii_name != NULL) {
 364                         if (rtdp->t_name != NULL &&
 365                             strcmp(rtdp->t_name, idp->ii_name) != 0) {
 366                                 tdesc_t *tdp;
 367 
 368                                 tdp = xcalloc(sizeof (*tdp));
 369                                 tdp->t_name = xstrdup(idp->ii_name);
 370                                 tdp->t_type = TYPEDEF;
 371                                 tdp->t_tdesc = rtdp;
 372                                 addhash(tdp, tid); /* for *(x,y) types */
 373                                 parse_debug(3, NULL, "    %s defined as %s(%d)",
 374                                     idp->ii_name, tdesc_name(rtdp), tid);
 375                         } else if (rtdp->t_name == NULL) {
 376                                 rtdp->t_name = xstrdup(idp->ii_name);
 377                                 addhash(rtdp, tid);
 378                         }
 379                 }
 380         } else {
 381                 rtdp = xcalloc(sizeof (*rtdp));
 382                 rtdp->t_name = idp->ii_name ? xstrdup(idp->ii_name) : NULL;
 383                 addhash(rtdp, tid);
 384         }
 385 
 386         switch (*cp++) {
 387         case 's':
 388                 (void) soudef(cp, STRUCT, &rtdp);
 389                 break;
 390         case 'u':
 391                 (void) soudef(cp, UNION, &rtdp);
 392                 break;
 393         case 'e':
 394                 enumdef(cp, &rtdp);
 395                 break;
 396         default:
 397                 expected("parse_sou", "<tag type s/u/e>", cp - 1);
 398                 break;
 399         }
 400 
 401         idp->ii_type = II_SOU;
 402         idp->ii_dtype = rtdp;
 403         return (II_SOU);
 404 }
 405 
 406 int
 407 parse_stab(stab_t *stab, char *cp, iidesc_t **iidescp)
 408 {
 409         iidesc_t *ii = NULL;
 410         iitype_t (*parse)(char *, iidesc_t *);
 411         int rc;
 412 
 413         /*
 414          * set up for reset()
 415          */
 416         if (setjmp(resetbuf))
 417                 return (-1);
 418 
 419         cp = whitesp(cp);
 420         ii = iidesc_new(NULL);
 421         cp = name(cp, &ii->ii_name);
 422 
 423         switch (stab->n_type) {
 424         case N_FUN:
 425                 parse = parse_fun;
 426                 break;
 427 
 428         case N_LSYM:
 429                 if (*cp == 't')
 430                         parse = parse_type;
 431                 else if (*cp == 'T')
 432                         parse = parse_sou;
 433                 else
 434                         parse = parse_sym;
 435                 break;
 436 
 437         case N_GSYM:
 438         case N_LCSYM:
 439         case N_PSYM:
 440         case N_ROSYM:
 441         case N_RSYM:
 442         case N_STSYM:
 443                 parse = parse_sym;
 444                 break;
 445         default:
 446                 parse_debug(1, cp, "Unknown stab type %#x", stab->n_type);
 447                 bzero(&resetbuf, sizeof (resetbuf));
 448                 return (-1);
 449         }
 450 
 451         rc = parse(cp, ii);
 452         bzero(&resetbuf, sizeof (resetbuf));
 453 
 454         if (rc < 0 || ii->ii_type == II_NOT) {
 455                 iidesc_free(ii);
 456                 return (rc);
 457         }
 458 
 459         *iidescp = ii;
 460 
 461         return (1);
 462 }
 463 
 464 /*
 465  * Check if we have this node in the hash table already
 466  */
 467 tdesc_t *
 468 lookup(int h)
 469 {
 470         int bucket = HASH(h);
 471         tdesc_t *tdp = hash_table[bucket];
 472 
 473         while (tdp != NULL) {
 474                 if (tdp->t_id == h)
 475                         return (tdp);
 476                 tdp = tdp->t_hash;
 477         }
 478         return (NULL);
 479 }
 480 
 481 static char *
 482 whitesp(char *cp)
 483 {
 484         char c;
 485 
 486         for (c = *cp++; isspace(c); c = *cp++)
 487                 ;
 488         --cp;
 489         return (cp);
 490 }
 491 
 492 static char *
 493 name(char *cp, char **w)
 494 {
 495         char *new, *orig, c;
 496         int len;
 497 
 498         orig = cp;
 499         c = *cp++;
 500         if (c == ':')
 501                 *w = NULL;
 502         else if (isalpha(c) || strchr("_.$#", c)) {
 503                 for (c = *cp++; isalnum(c) || strchr(" _.$#", c); c = *cp++)
 504                         ;
 505                 if (c != ':')
 506                         reset();
 507                 len = cp - orig;
 508                 new = xmalloc(len);
 509                 while (orig < cp - 1)
 510                         *new++ = *orig++;
 511                 *new = '\0';
 512                 *w = new - (len - 1);
 513         } else
 514                 reset();
 515 
 516         return (cp);
 517 }
 518 
 519 static char *
 520 number(char *cp, int *n)
 521 {
 522         char *next;
 523 
 524         *n = (int)strtol(cp, &next, 10);
 525         if (next == cp)
 526                 expected("number", "<number>", cp);
 527         return (next);
 528 }
 529 
 530 static char *
 531 id(char *cp, int *h)
 532 {
 533         int n1, n2;
 534 
 535         if (*cp == '(') {       /* SunPro style */
 536                 cp++;
 537                 cp = number(cp, &n1);
 538                 if (*cp++ != ',')
 539                         expected("id", ",", cp - 1);
 540                 cp = number(cp, &n2);
 541                 if (*cp++ != ')')
 542                         expected("id", ")", cp - 1);
 543                 *h = MAKETYPEID(n1, n2);
 544         } else if (isdigit(*cp)) { /* gcc style */
 545                 cp = number(cp, &n1);
 546                 *h = n1;
 547         } else {
 548                 expected("id", "(/0-9", cp);
 549         }
 550         return (cp);
 551 }
 552 
 553 static int
 554 tagadd(char *w, int h, tdesc_t *tdp)
 555 {
 556         tdesc_t *otdp;
 557 
 558         tdp->t_name = w;
 559         if (!(otdp = lookup(h)))
 560                 addhash(tdp, h);
 561         else if (otdp != tdp) {
 562                 warning("duplicate entry\n");
 563                 warning("  old: %s %d (%d,%d)\n", tdesc_name(otdp),
 564                     otdp->t_type, TYPEFILE(otdp->t_id), TYPENUM(otdp->t_id));
 565                 warning("  new: %s %d (%d,%d)\n", tdesc_name(tdp),
 566                     tdp->t_type, TYPEFILE(tdp->t_id), TYPENUM(tdp->t_id));
 567                 return (-1);
 568         }
 569 
 570         return (0);
 571 }
 572 
 573 static char *
 574 tdefdecl(char *cp, int h, tdesc_t **rtdp)
 575 {
 576         tdesc_t *ntdp;
 577         char *w;
 578         int c, h2;
 579         char type;
 580 
 581         parse_debug(3, cp, "tdefdecl h=%d", h);
 582 
 583         /* Type codes */
 584         switch (type = *cp) {
 585         case 'b': /* integer */
 586         case 'R': /* fp */
 587                 cp = intrinsic(cp, rtdp);
 588                 break;
 589         case '(': /* equiv to another type */
 590                 cp = id(cp, &h2);
 591                 ntdp = lookup(h2);
 592 
 593                 if (ntdp != NULL && *cp == '=') {
 594                         if (ntdp->t_type == FORWARD && *(cp + 1) == 'x') {
 595                                 /*
 596                                  * The 6.2 compiler, and possibly others, will
 597                                  * sometimes emit the same stab for a forward
 598                                  * declaration twice.  That is, "(1,2)=xsfoo:"
 599                                  * will sometimes show up in two different
 600                                  * places.  This is, of course, quite fun.  We
 601                                  * want CTF to work in spite of the compiler,
 602                                  * so we'll let this one through.
 603                                  */
 604                                 char *c2 = cp + 2;
 605                                 char *nm;
 606 
 607                                 if (!strchr("sue", *c2++)) {
 608                                         expected("tdefdecl/x-redefine", "[sue]",
 609                                             c2 - 1);
 610                                 }
 611 
 612                                 c2 = name(c2, &nm);
 613                                 if (strcmp(nm, ntdp->t_name) != 0) {
 614                                         terminate("Stabs error: Attempt to "
 615                                             "redefine type (%d,%d) as "
 616                                             "something else: %s\n",
 617                                             TYPEFILE(h2), TYPENUM(h2),
 618                                             c2 - 1);
 619                                 }
 620                                 free(nm);
 621 
 622                                 h2 = faketypenumber++;
 623                                 ntdp = NULL;
 624                         } else {
 625                                 terminate("Stabs error: Attempting to "
 626                                     "redefine type (%d,%d)\n", TYPEFILE(h2),
 627                                     TYPENUM(h2));
 628                         }
 629                 }
 630 
 631                 if (ntdp == NULL) {  /* if that type isn't defined yet */
 632                         if (*cp != '=') {
 633                                 /* record it as unresolved */
 634                                 parse_debug(3, NULL, "tdefdecl unres type %d",
 635                                     h2);
 636                                 *rtdp = calloc(1, sizeof (**rtdp));
 637                                 (*rtdp)->t_type = TYPEDEF_UNRES;
 638                                 (*rtdp)->t_id = h2;
 639                                 break;
 640                         } else
 641                                 cp++;
 642 
 643                         /* define a new type */
 644                         cp = tdefdecl(cp, h2, rtdp);
 645                         if ((*rtdp)->t_id && (*rtdp)->t_id != h2) {
 646                                 ntdp = calloc(1, sizeof (*ntdp));
 647                                 ntdp->t_type = TYPEDEF;
 648                                 ntdp->t_tdesc = *rtdp;
 649                                 *rtdp = ntdp;
 650                         }
 651 
 652                         addhash(*rtdp, h2);
 653 
 654                 } else { /* that type is already defined */
 655                         if (ntdp->t_type != TYPEDEF || ntdp->t_name != NULL) {
 656                                 *rtdp = ntdp;
 657                         } else {
 658                                 parse_debug(3, NULL,
 659                                     "No duplicate typedef anon for ref");
 660                                 *rtdp = ntdp;
 661                         }
 662                 }
 663                 break;
 664         case '*':
 665                 ntdp = NULL;
 666                 cp = tdefdecl(cp + 1, h, &ntdp);
 667                 if (ntdp == NULL)
 668                         expected("tdefdecl/*", "id", cp);
 669 
 670                 if (!ntdp->t_id)
 671                         ntdp->t_id = faketypenumber++;
 672 
 673                 *rtdp = xcalloc(sizeof (**rtdp));
 674                 (*rtdp)->t_type = POINTER;
 675                 (*rtdp)->t_size = 0;
 676                 (*rtdp)->t_id = h;
 677                 (*rtdp)->t_tdesc = ntdp;
 678                 break;
 679         case 'f':
 680                 cp = tdefdecl(cp + 1, h, &ntdp);
 681                 *rtdp = xcalloc(sizeof (**rtdp));
 682                 (*rtdp)->t_type = FUNCTION;
 683                 (*rtdp)->t_size = 0;
 684                 (*rtdp)->t_id = h;
 685                 (*rtdp)->t_fndef = xcalloc(sizeof (fndef_t));
 686                 /*
 687                  * The 6.1 compiler will sometimes generate incorrect stabs for
 688                  * function pointers (it'll get the return type wrong).  This
 689                  * causes merges to fail.  We therefore treat function pointers
 690                  * as if they all point to functions that return int.  When
 691                  * 4432549 is fixed, the lookupname() call below should be
 692                  * replaced with `ntdp'.
 693                  */
 694                 (*rtdp)->t_fndef->fn_ret = lookupname("int");
 695                 break;
 696         case 'a':
 697         case 'z':
 698                 cp++;
 699                 if (*cp++ != 'r')
 700                         expected("tdefdecl/[az]", "r", cp - 1);
 701                 *rtdp = xcalloc(sizeof (**rtdp));
 702                 (*rtdp)->t_type = ARRAY;
 703                 (*rtdp)->t_id = h;
 704                 cp = arraydef(cp, rtdp);
 705                 break;
 706         case 'x':
 707                 c = *++cp;
 708                 if (c != 's' && c != 'u' && c != 'e')
 709                         expected("tdefdecl/x", "[sue]", cp - 1);
 710                 cp = name(cp + 1, &w);
 711 
 712                 ntdp = xcalloc(sizeof (*ntdp));
 713                 ntdp->t_type = FORWARD;
 714                 ntdp->t_name = w;
 715                 /*
 716                  * We explicitly don't set t_id here - the caller will do it.
 717                  * The caller may want to use a real type ID, or they may
 718                  * choose to make one up.
 719                  */
 720 
 721                 *rtdp = ntdp;
 722                 break;
 723 
 724         case 'B': /* volatile */
 725                 cp = tdefdecl(cp + 1, h, &ntdp);
 726 
 727                 if (!ntdp->t_id)
 728                         ntdp->t_id = faketypenumber++;
 729 
 730                 *rtdp = xcalloc(sizeof (**rtdp));
 731                 (*rtdp)->t_type = VOLATILE;
 732                 (*rtdp)->t_size = 0;
 733                 (*rtdp)->t_tdesc = ntdp;
 734                 (*rtdp)->t_id = h;
 735                 break;
 736 
 737         case 'k': /* const */
 738                 cp = tdefdecl(cp + 1, h, &ntdp);
 739 
 740                 if (!ntdp->t_id)
 741                         ntdp->t_id = faketypenumber++;
 742 
 743                 *rtdp = xcalloc(sizeof (**rtdp));
 744                 (*rtdp)->t_type = CONST;
 745                 (*rtdp)->t_size = 0;
 746                 (*rtdp)->t_tdesc = ntdp;
 747                 (*rtdp)->t_id = h;
 748                 break;
 749 
 750         case 'K': /* restricted */
 751                 cp = tdefdecl(cp + 1, h, &ntdp);
 752 
 753                 if (!ntdp->t_id)
 754                         ntdp->t_id = faketypenumber++;
 755 
 756                 *rtdp = xcalloc(sizeof (**rtdp));
 757                 (*rtdp)->t_type = RESTRICT;
 758                 (*rtdp)->t_size = 0;
 759                 (*rtdp)->t_tdesc = ntdp;
 760                 (*rtdp)->t_id = h;
 761                 break;
 762 
 763         case 'u':
 764         case 's':
 765                 cp++;
 766 
 767                 *rtdp = xcalloc(sizeof (**rtdp));
 768                 (*rtdp)->t_name = NULL;
 769                 cp = soudef(cp, (type == 'u') ? UNION : STRUCT, rtdp);
 770                 break;
 771         default:
 772                 expected("tdefdecl", "<type code>", cp);
 773         }
 774         return (cp);
 775 }
 776 
 777 static char *
 778 intrinsic(char *cp, tdesc_t **rtdp)
 779 {
 780         intr_t *intr = xcalloc(sizeof (intr_t));
 781         tdesc_t *tdp;
 782         int width, fmt, i;
 783 
 784         switch (*cp++) {
 785         case 'b':
 786                 intr->intr_type = INTR_INT;
 787                 if (*cp == 's')
 788                         intr->intr_signed = 1;
 789                 else if (*cp != 'u')
 790                         expected("intrinsic/b", "[su]", cp);
 791                 cp++;
 792 
 793                 if (strchr("cbv", *cp))
 794                         intr->intr_iformat = *cp++;
 795 
 796                 cp = number(cp, &width);
 797                 if (*cp++ != ';')
 798                         expected("intrinsic/b", "; (post-width)", cp - 1);
 799 
 800                 cp = number(cp, &intr->intr_offset);
 801                 if (*cp++ != ';')
 802                         expected("intrinsic/b", "; (post-offset)", cp - 1);
 803 
 804                 cp = number(cp, &intr->intr_nbits);
 805                 break;
 806 
 807         case 'R':
 808                 intr->intr_type = INTR_REAL;
 809                 for (fmt = 0, i = 0; isdigit(*(cp + i)); i++)
 810                         fmt = fmt * 10 + (*(cp + i) - '0');
 811 
 812                 if (fmt < 1 || fmt > CTF_FP_MAX)
 813                         expected("intrinsic/R", "number <= CTF_FP_MAX", cp);
 814 
 815                 intr->intr_fformat = fmt;
 816                 cp += i;
 817 
 818                 if (*cp++ != ';')
 819                         expected("intrinsic/R", ";", cp - 1);
 820                 cp = number(cp, &width);
 821 
 822                 intr->intr_nbits = width * 8;
 823                 break;
 824         }
 825 
 826         tdp = xcalloc(sizeof (*tdp));
 827         tdp->t_type = INTRINSIC;
 828         tdp->t_size = width;
 829         tdp->t_name = NULL;
 830         tdp->t_intr = intr;
 831         parse_debug(3, NULL, "intrinsic: size=%d", width);
 832         *rtdp = tdp;
 833 
 834         return (cp);
 835 }
 836 
 837 static tdesc_t *
 838 bitintrinsic(tdesc_t *template, int nbits)
 839 {
 840         tdesc_t *newtdp = xcalloc(sizeof (tdesc_t));
 841 
 842         newtdp->t_name = xstrdup(template->t_name);
 843         newtdp->t_id = faketypenumber++;
 844         newtdp->t_type = INTRINSIC;
 845         newtdp->t_size = template->t_size;
 846         newtdp->t_intr = xmalloc(sizeof (intr_t));
 847         bcopy(template->t_intr, newtdp->t_intr, sizeof (intr_t));
 848         newtdp->t_intr->intr_nbits = nbits;
 849 
 850         return (newtdp);
 851 }
 852 
 853 static char *
 854 offsize(char *cp, mlist_t *mlp)
 855 {
 856         int offset, size;
 857 
 858         if (*cp == ',')
 859                 cp++;
 860         cp = number(cp, &offset);
 861         if (*cp++ != ',')
 862                 expected("offsize/2", ",", cp - 1);
 863         cp = number(cp, &size);
 864         if (*cp++ != ';')
 865                 expected("offsize/3", ";", cp - 1);
 866         mlp->ml_offset = offset;
 867         mlp->ml_size = size;
 868         return (cp);
 869 }
 870 
 871 static tdesc_t *
 872 find_intrinsic(tdesc_t *tdp)
 873 {
 874         for (;;) {
 875                 switch (tdp->t_type) {
 876                 case TYPEDEF:
 877                 case VOLATILE:
 878                 case CONST:
 879                 case RESTRICT:
 880                         tdp = tdp->t_tdesc;
 881                         break;
 882 
 883                 default:
 884                         return (tdp);
 885                 }
 886         }
 887 }
 888 
 889 static char *
 890 soudef(char *cp, stabtype_t type, tdesc_t **rtdp)
 891 {
 892         mlist_t *mlp, **prev;
 893         char *w;
 894         int h;
 895         int size;
 896         tdesc_t *tdp, *itdp;
 897 
 898         cp = number(cp, &size);
 899         (*rtdp)->t_size = size;
 900         (*rtdp)->t_type = type; /* s or u */
 901 
 902         /*
 903          * An '@' here indicates a bitmask follows.   This is so the
 904          * compiler can pass information to debuggers about how structures
 905          * are passed in the v9 world.  We don't need this information
 906          * so we skip over it.
 907          */
 908         if (cp[0] == '@') {
 909                 cp += 3;
 910         }
 911 
 912         parse_debug(3, cp, "soudef: %s size=%d", tdesc_name(*rtdp),
 913             (*rtdp)->t_size);
 914 
 915         prev = &((*rtdp)->t_members);
 916         /* now fill up the fields */
 917         while ((*cp != '\0') && (*cp != ';')) { /* signifies end of fields */
 918                 mlp = xcalloc(sizeof (*mlp));
 919                 *prev = mlp;
 920                 cp = name(cp, &w);
 921                 mlp->ml_name = w;
 922                 cp = id(cp, &h);
 923                 /*
 924                  * find the tdesc struct in the hash table for this type
 925                  * and stick a ptr in here
 926                  */
 927                 tdp = lookup(h);
 928                 if (tdp == NULL) { /* not in hash list */
 929                         parse_debug(3, NULL, "      defines %s (%d)", w, h);
 930                         if (*cp++ != '=') {
 931                                 tdp = unres_new(h);
 932                                 parse_debug(3, NULL,
 933                                     "      refers to %s (unresolved %d)",
 934                                     (w ? w : "anon"), h);
 935                         } else {
 936                                 cp = tdefdecl(cp, h, &tdp);
 937 
 938                                 if (tdp->t_id && tdp->t_id != h) {
 939                                         tdesc_t *ntdp = xcalloc(sizeof (*ntdp));
 940 
 941                                         ntdp->t_type = TYPEDEF;
 942                                         ntdp->t_tdesc = tdp;
 943                                         tdp = ntdp;
 944                                 }
 945 
 946                                 addhash(tdp, h);
 947                                 parse_debug(4, cp,
 948                                     "     soudef now looking at    ");
 949                                 cp++;
 950                         }
 951                 } else {
 952                         parse_debug(3, NULL, "      refers to %s (%d, %s)",
 953                             w ? w : "anon", h, tdesc_name(tdp));
 954                 }
 955 
 956                 cp = offsize(cp, mlp);
 957 
 958                 itdp = find_intrinsic(tdp);
 959                 if (itdp->t_type == INTRINSIC) {
 960                         if (mlp->ml_size != itdp->t_intr->intr_nbits) {
 961                                 parse_debug(4, cp, "making %d bit intrinsic "
 962                                     "from %s", mlp->ml_size, tdesc_name(itdp));
 963                                 mlp->ml_type = bitintrinsic(itdp, mlp->ml_size);
 964                         } else
 965                                 mlp->ml_type = tdp;
 966                 } else if (itdp->t_type == TYPEDEF_UNRES) {
 967                         list_add(&typedbitfldmems, mlp);
 968                         mlp->ml_type = tdp;
 969                 } else {
 970                         mlp->ml_type = tdp;
 971                 }
 972 
 973                 /* cp is now pointing to next field */
 974                 prev = &mlp->ml_next;
 975         }
 976         return (cp);
 977 }
 978 
 979 static char *
 980 arraydef(char *cp, tdesc_t **rtdp)
 981 {
 982         int start, end, h;
 983 
 984         cp = id(cp, &h);
 985         if (*cp++ != ';')
 986                 expected("arraydef/1", ";", cp - 1);
 987 
 988         (*rtdp)->t_ardef = xcalloc(sizeof (ardef_t));
 989         (*rtdp)->t_ardef->ad_idxtype = lookup(h);
 990 
 991         cp = number(cp, &start); /* lower */
 992         if (*cp++ != ';')
 993                 expected("arraydef/2", ";", cp - 1);
 994 
 995         if (*cp == 'S') {
 996                 /*
 997                  * variable length array - treat as null dimensioned
 998                  *
 999                  * For VLA variables on sparc, SS12 generated stab entry
1000                  * looks as follows:
1001                  * .stabs "buf:(0,28)=zr(0,4);0;S-12;(0,1)", 0x80, 0, 0, -16
1002                  * Whereas SS12u1 generated stab entry looks like this:
1003                  * .stabs "buf:(0,28)=zr(0,4);0;S0;(0,1)", 0x80, 0, 0, 0
1004                  * On x86, both versions generate the first type of entry.
1005                  * We should be able to parse both.
1006                  */
1007                 cp++;
1008                 if (*cp == '-')
1009                         cp++;
1010                 cp = number(cp, &end);
1011                 end = start;
1012         } else {
1013                 /*
1014                  * normal fixed-dimension array
1015                  * Stab entry for this looks as follows :
1016                  * .stabs "x:(0,28)=ar(0,4);0;9;(0,3)", 0x80, 0, 40, 0
1017                  */
1018                 cp = number(cp, &end);  /* upper */
1019         }
1020 
1021         if (*cp++ != ';')
1022                 expected("arraydef/3", ";", cp - 1);
1023         (*rtdp)->t_ardef->ad_nelems = end - start + 1;
1024         cp = tdefdecl(cp, h, &((*rtdp)->t_ardef->ad_contents));
1025 
1026         parse_debug(3, cp, "defined array idx type %d %d-%d next ",
1027             h, start, end);
1028 
1029         return (cp);
1030 }
1031 
1032 static void
1033 enumdef(char *cp, tdesc_t **rtdp)
1034 {
1035         elist_t *elp, **prev;
1036         char *w;
1037 
1038         (*rtdp)->t_type = ENUM;
1039         (*rtdp)->t_emem = NULL;
1040 
1041         prev = &((*rtdp)->t_emem);
1042         while (*cp != ';') {
1043                 elp = xcalloc(sizeof (*elp));
1044                 elp->el_next = NULL;
1045                 *prev = elp;
1046                 cp = name(cp, &w);
1047                 elp->el_name = w;
1048                 cp = number(cp, &elp->el_number);
1049                 parse_debug(3, NULL, "enum %s: %s=%d", tdesc_name(*rtdp),
1050                     elp->el_name, elp->el_number);
1051                 prev = &elp->el_next;
1052                 if (*cp++ != ',')
1053                         expected("enumdef", ",", cp - 1);
1054         }
1055 }
1056 
1057 tdesc_t *
1058 lookup_name(tdesc_t **hash, const char *name)
1059 {
1060         int bucket = compute_sum(name);
1061         tdesc_t *tdp, *ttdp = NULL;
1062 
1063         for (tdp = hash[bucket]; tdp != NULL; tdp = tdp->t_next) {
1064                 if (tdp->t_name != NULL && strcmp(tdp->t_name, name) == 0) {
1065                         if (tdp->t_type == STRUCT || tdp->t_type == UNION ||
1066                             tdp->t_type == ENUM || tdp->t_type == INTRINSIC)
1067                                 return (tdp);
1068                         if (tdp->t_type == TYPEDEF)
1069                                 ttdp = tdp;
1070                 }
1071         }
1072         return (ttdp);
1073 }
1074 
1075 tdesc_t *
1076 lookupname(const char *name)
1077 {
1078         return (lookup_name(name_table, name));
1079 }
1080 
1081 /*
1082  * Add a node to the hash queues.
1083  */
1084 static void
1085 addhash(tdesc_t *tdp, int num)
1086 {
1087         int hash = HASH(num);
1088         tdesc_t *ttdp;
1089         char added_num = 0, added_name = 0;
1090 
1091         /*
1092          * If it already exists in the hash table don't add it again
1093          * (but still check to see if the name should be hashed).
1094          */
1095         ttdp = lookup(num);
1096 
1097         if (ttdp == NULL) {
1098                 tdp->t_id = num;
1099                 tdp->t_hash = hash_table[hash];
1100                 hash_table[hash] = tdp;
1101                 added_num = 1;
1102         }
1103 
1104         if (tdp->t_name != NULL) {
1105                 ttdp = lookupname(tdp->t_name);
1106                 if (ttdp == NULL) {
1107                         hash = compute_sum(tdp->t_name);
1108                         tdp->t_next = name_table[hash];
1109                         name_table[hash] = tdp;
1110                         added_name = 1;
1111                 }
1112         }
1113         if (!added_num && !added_name) {
1114                 terminate("stabs: broken hash\n");
1115         }
1116 }
1117 
1118 static int
1119 compute_sum(const char *w)
1120 {
1121         char c;
1122         int sum;
1123 
1124         for (sum = 0; (c = *w) != '\0'; sum += c, w++)
1125                 ;
1126         return (HASH(sum));
1127 }
1128 
1129 static void
1130 reset(void)
1131 {
1132         longjmp(resetbuf, 1);
1133 }
1134 
1135 void
1136 check_hash(void)
1137 {
1138         tdesc_t *tdp;
1139         int i;
1140 
1141         printf("checking hash\n");
1142         for (i = 0; i < BUCKETS; i++) {
1143                 if (hash_table[i]) {
1144                         for (tdp = hash_table[i]->t_hash;
1145                             tdp && tdp != hash_table[i];
1146                             tdp = tdp->t_hash)
1147                                 continue;
1148                         if (tdp) {
1149                                 terminate("cycle in hash bucket %d\n", i);
1150                                 return;
1151                         }
1152                 }
1153 
1154                 if (name_table[i]) {
1155                         for (tdp = name_table[i]->t_next;
1156                             tdp && tdp != name_table[i];
1157                             tdp = tdp->t_next)
1158                                 continue;
1159                         if (tdp) {
1160                                 terminate("cycle in name bucket %d\n", i);
1161                                 return;
1162                         }
1163                 }
1164         }
1165         printf("done\n");
1166 }
1167 
1168 /*ARGSUSED1*/
1169 static int
1170 resolve_typed_bitfields_cb(mlist_t *ml, void *private)
1171 {
1172         tdesc_t *tdp = ml->ml_type;
1173 
1174         debug(3, "Resolving typed bitfields (member %s)\n",
1175             (ml->ml_name ? ml->ml_name : "(anon)"));
1176 
1177         while (tdp) {
1178                 switch (tdp->t_type) {
1179                 case INTRINSIC:
1180                         if (ml->ml_size != tdp->t_intr->intr_nbits) {
1181                                 debug(3, "making %d bit intrinsic from %s",
1182                                     ml->ml_size, tdesc_name(tdp));
1183                                 ml->ml_type = bitintrinsic(tdp, ml->ml_size);
1184                         } else {
1185                                 debug(3, "using existing %d bit %s intrinsic",
1186                                     ml->ml_size, tdesc_name(tdp));
1187                                 ml->ml_type = tdp;
1188                         }
1189                         return (1);
1190 
1191                 case POINTER:
1192                 case TYPEDEF:
1193                 case VOLATILE:
1194                 case CONST:
1195                 case RESTRICT:
1196                         tdp = tdp->t_tdesc;
1197                         break;
1198 
1199                 default:
1200                         return (1);
1201                 }
1202         }
1203 
1204         terminate("type chain for bitfield member %s has a NULL", ml->ml_name);
1205         /*NOTREACHED*/
1206         return (0);
1207 }
1208 
1209 void
1210 resolve_typed_bitfields(void)
1211 {
1212         (void) list_iter(typedbitfldmems,
1213             (int (*)())resolve_typed_bitfields_cb, NULL);
1214 }