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
52static int faketypenumber = 100000000;
53
54static tdesc_t *hash_table[BUCKETS];
55static tdesc_t *name_table[BUCKETS];
56
57list_t *typedbitfldmems;
58
59static void reset(void);
60static jmp_buf	resetbuf;
61
62static char *soudef(char *cp, stabtype_t type, tdesc_t **rtdp);
63static void enumdef(char *cp, tdesc_t **rtdp);
64static int compute_sum(const char *w);
65
66static char *number(char *cp, int *n);
67static char *name(char *cp, char **w);
68static char *id(char *cp, int *h);
69static char *whitesp(char *cp);
70static void addhash(tdesc_t *tdp, int num);
71static int tagadd(char *w, int h, tdesc_t *tdp);
72static char *tdefdecl(char *cp, int h, tdesc_t **rtdp);
73static char *intrinsic(char *cp, tdesc_t **rtdp);
74static char *arraydef(char *cp, tdesc_t **rtdp);
75
76extern int debug_level;
77int debug_parse = DEBUG_PARSE;
78
79/*PRINTFLIKE3*/
80static void
81parse_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. */
111static 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*/
125void
126parse_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
141void
142parse_finish(tdata_t *td)
143{
144	td->td_nextid = ++faketypenumber;
145}
146
147static tdesc_t *
148unres_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
159char *
160read_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
187static iitype_t
188parse_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
246static iitype_t
247parse_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
286static iitype_t
287parse_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
343static iitype_t
344parse_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
402int
403parse_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 */
463tdesc_t *
464lookup(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
477static char *
478whitesp(char *cp)
479{
480	char c;
481
482	for (c = *cp++; isspace(c); c = *cp++)
483		;
484	--cp;
485	return (cp);
486}
487
488static char *
489name(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
515static char *
516number(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
526static char *
527id(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
549static int
550tagadd(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
569static char *
570tdefdecl(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
773static char *
774intrinsic(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
833static tdesc_t *
834bitintrinsic(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
849static char *
850offsize(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
867static tdesc_t *
868find_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
885static char *
886soudef(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
975static char *
976arraydef(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
1028static void
1029enumdef(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
1053tdesc_t *
1054lookup_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
1071tdesc_t *
1072lookupname(const char *name)
1073{
1074	return (lookup_name(name_table, name));
1075}
1076
1077/*
1078 * Add a node to the hash queues.
1079 */
1080static void
1081addhash(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
1114static int
1115compute_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
1125static void
1126reset(void)
1127{
1128	longjmp(resetbuf, 1);
1129}
1130
1131void
1132check_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*/
1165static int
1166resolve_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
1205void
1206resolve_typed_bitfields(void)
1207{
1208	(void) list_iter(typedbitfldmems,
1209	    (int (*)())resolve_typed_bitfields_cb, NULL);
1210}
1211