tools/ctf/cvt/st_parse.c

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