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