diff --git a/cddl/contrib/opensolaris/tools/ctf/cvt/compare.c b/cddl/contrib/opensolaris/tools/ctf/cvt/compare.c
deleted file mode 100644
index 26037f8a537a..000000000000
--- a/cddl/contrib/opensolaris/tools/ctf/cvt/compare.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (the "License").  You may not use this file except in compliance
- * with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
-/*
- * This is a test program designed to catch mismerges and mistranslations from
- * stabs to CTF.
- *
- * Given a file with stabs data and a file with CTF data, determine whether
- * or not all of the data structures and objects described by the stabs data
- * are present in the CTF data.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-
-#include "ctftools.h"
-
-char *progname;
-int debug_level = DEBUG_LEVEL;
-
-static void
-usage(void)
-{
-	fprintf(stderr, "Usage: %s ctf_file stab_file\n", progname);
-}
-
-int
-main(int argc, char **argv)
-{
-	tdata_t *ctftd, *stabrtd, *stabtd, *difftd;
-	char *ctfname, *stabname;
-	int new;
-
-	progname = argv[0];
-
-	if (argc != 3) {
-		usage();
-		exit(2);
-	}
-
-	ctfname = argv[1];
-	stabname = argv[2];
-
-	stabrtd = tdata_new();
-	stabtd = tdata_new();
-	difftd = tdata_new();
-
-	if (read_stabs(stabrtd, stabname, 0) != 0)
-		merge_into_master(stabrtd, stabtd, NULL, 1);
-	else if (read_ctf(&stabname, 1, NULL, read_ctf_save_cb, &stabtd, 0)
-	    == 0)
-		terminate("%s doesn't have stabs or CTF\n", stabname);
-
-	if (read_ctf(&ctfname, 1, NULL, read_ctf_save_cb, &ctftd, 0) == 0)
-		terminate("%s doesn't contain CTF data\n", ctfname);
-
-	merge_into_master(stabtd, ctftd, difftd, 0);
-
-	if ((new = hash_count(difftd->td_iihash)) != 0) {
-		(void) hash_iter(difftd->td_iihash, (int (*)())iidesc_dump,
-		    NULL);
-		terminate("%s grew by %d\n", stabname, new);
-	}
-
-	return (0);
-}
diff --git a/cddl/contrib/opensolaris/tools/ctf/cvt/ctfconvert.c b/cddl/contrib/opensolaris/tools/ctf/cvt/ctfconvert.c
index d40be25da27f..68969356e75e 100644
--- a/cddl/contrib/opensolaris/tools/ctf/cvt/ctfconvert.c
+++ b/cddl/contrib/opensolaris/tools/ctf/cvt/ctfconvert.c
@@ -83,7 +83,6 @@ file_read(tdata_t *td, char *filename, int ignore_non_c)
 {
 	typedef int (*reader_f)(tdata_t *, Elf *, char *);
 	static reader_f readers[] = {
-		stabs_read,
 		dw_read,
 		NULL
 	};
@@ -165,8 +164,6 @@ main(int argc, char **argv)
 
 	if (getenv("CTFCONVERT_DEBUG_LEVEL"))
 		debug_level = atoi(getenv("CTFCONVERT_DEBUG_LEVEL"));
-	if (getenv("CTFCONVERT_DEBUG_PARSE"))
-		debug_parse = atoi(getenv("CTFCONVERT_DEBUG_PARSE"));
 
 	while ((c = getopt(argc, argv, ":l:L:o:givs")) != EOF) {
 		switch (c) {
diff --git a/cddl/contrib/opensolaris/tools/ctf/cvt/ctftools.h b/cddl/contrib/opensolaris/tools/ctf/cvt/ctftools.h
index b7da16ac3ddd..974d22459991 100644
--- a/cddl/contrib/opensolaris/tools/ctf/cvt/ctftools.h
+++ b/cddl/contrib/opensolaris/tools/ctf/cvt/ctftools.h
@@ -50,9 +50,6 @@ extern "C" {
 #ifndef DEBUG_LEVEL
 #define	DEBUG_LEVEL 0
 #endif
-#ifndef DEBUG_PARSE
-#define	DEBUG_PARSE 0
-#endif
 
 #ifndef DEBUG_STREAM
 #define	DEBUG_STREAM stderr
@@ -100,7 +97,6 @@ extern "C" {
 
 extern const char *progname;
 extern int debug_level;
-extern int debug_parse;
 extern char *curhdr;
 
 /*
@@ -405,18 +401,6 @@ void merge_into_master(tdata_t *, tdata_t *, tdata_t *, int);
 
 void write_ctf(tdata_t *, const char *, const char *, int);
 
-/* parse.c */
-void parse_init(tdata_t *);
-void parse_finish(tdata_t *);
-int parse_stab(stab_t *, char *, iidesc_t **);
-tdesc_t *lookup(int);
-tdesc_t *lookupname(const char *);
-void check_hash(void);
-void resolve_typed_bitfields(void);
-
-/* stabs.c */
-int stabs_read(tdata_t *, Elf *, char *);
-
 /* dwarf.c */
 int dw_read(tdata_t *, Elf *, char *);
 const char *dw_tag2str(uint_t);
diff --git a/cddl/contrib/opensolaris/tools/ctf/cvt/fixup_tdescs.c b/cddl/contrib/opensolaris/tools/ctf/cvt/fixup_tdescs.c
index b239a62dc53b..ea4f4ee64625 100644
--- a/cddl/contrib/opensolaris/tools/ctf/cvt/fixup_tdescs.c
+++ b/cddl/contrib/opensolaris/tools/ctf/cvt/fixup_tdescs.c
@@ -38,125 +38,6 @@
 #include "hash.h"
 #include "memory.h"
 
-/*
- * Due to 4432619, the 6.1 compiler will sometimes incorrectly generate pointer
- * stabs.  Given a struct foo, and a corresponding typedef struct foo foo_t.
- * In some cases, when faced with a pointer to a foo_t, the compiler will
- * sometimes generate a stab that describes a pointer to a struct foo.
- * Regardless of correctness, this breaks merges, as it occurs inconsistently
- * by file.  The following two routines know how to recognize and repair foo_t *
- * and foo_t ** bugs in a specific set of cases.  There is no general way to
- * solve this problem without a fix to the compiler.  In general, cases should
- * only be added to these routines to fix merging problems in genunix.
- */
-static void
-fix_ptrptr_to_struct(tdata_t *td)
-{
-	const char *strs[2] = { "as", "fdbuffer" };
-	const char *mems[2] = { "a_objectdir", "fd_shadow" };
-	const char *acts[2] = { "vnode", "page" };
-	const char *tgts[2] = { "vnode_t", "page_t" };
-	tdesc_t *str;
-	tdesc_t *act, *tgt;
-	tdesc_t *p1, *p2;
-	mlist_t *ml;
-	int i;
-
-	for (i = 0; i < (int) (sizeof (strs) / sizeof (strs[0])); i++) {
-		if (!(str = lookupname(strs[i])) || str->t_type != STRUCT)
-			continue;
-
-		for (ml = str->t_members; ml; ml = ml->ml_next) {
-			if (streq(ml->ml_name, mems[i]))
-				break;
-		}
-		if (!ml)
-			continue;
-
-		if (ml->ml_type->t_type != POINTER || ml->ml_type->t_name ||
-		    ml->ml_type->t_tdesc->t_type != POINTER ||
-		    ml->ml_type->t_tdesc->t_name)
-			continue;
-
-		act = ml->ml_type->t_tdesc->t_tdesc;
-		if (act->t_type != STRUCT || !streq(act->t_name, acts[i]))
-			continue;
-
-		if (!(tgt = lookupname(tgts[i])) || tgt->t_type != TYPEDEF)
-			continue;
-
-		/* We have an instance of the bug */
-		p2 = xcalloc(sizeof (*p2));
-		p2->t_type = POINTER;
-		p2->t_id = td->td_nextid++;
-		p2->t_tdesc = tgt;
-
-		p1 = xcalloc(sizeof (*p1));
-		p1->t_type = POINTER;
-		p1->t_id = td->td_nextid++;
-		p1->t_tdesc = p2;
-
-		ml->ml_type = p1;
-
-		debug(3, "Fixed %s->%s => ptrptr struct %s bug\n",
-		    strs[i], mems[i], acts[i]);
-	}
-}
-
-static void
-fix_ptr_to_struct(tdata_t *td)
-{
-	const char *strs[2] = { "vmem", "id_space" };
-	const char *mems[2] = { NULL, "is_vmem" };
-	tdesc_t *ptr = NULL;
-	tdesc_t *str, *vmt;
-	mlist_t *ml;
-	int i;
-
-	if ((vmt = lookupname("vmem_t")) == NULL || vmt->t_type != TYPEDEF)
-		return;
-
-	for (i = 0; i < (int) (sizeof (strs) / sizeof (strs[0])); i++) {
-		if (!(str = lookupname(strs[i])) || str->t_type != STRUCT)
-			continue;
-
-		for (ml = str->t_members; ml; ml = ml->ml_next) {
-			if (mems[i] && !streq(ml->ml_name, mems[i]))
-				continue;
-
-			if (ml->ml_type->t_type != POINTER ||
-			    ml->ml_type->t_name ||
-			    (ml->ml_type->t_tdesc->t_type != STRUCT &&
-			    ml->ml_type->t_tdesc->t_type != FORWARD) ||
-			    !streq(ml->ml_type->t_tdesc->t_name, "vmem"))
-				continue;
-
-			debug(3, "Fixed %s->%s => ptr struct vmem bug\n",
-			    strs[i], ml->ml_name);
-
-			if (!ptr) {
-				ptr = xcalloc(sizeof (*ptr));
-				ptr->t_type = POINTER;
-				ptr->t_id = td->td_nextid++;
-				ptr->t_tdesc = vmt;
-			}
-
-			ml->ml_type = ptr;
-		}
-	}
-}
-
-/*
- * Fix stabs generation bugs.  These routines must be run before the
- * post-conversion merge
- */
-void
-cvt_fixstabs(tdata_t *td)
-{
-	fix_ptrptr_to_struct(td);
-	fix_ptr_to_struct(td);
-}
-
 struct match {
 	tdesc_t *m_ret;
 	const char *m_name;
diff --git a/cddl/contrib/opensolaris/tools/ctf/cvt/st_parse.c b/cddl/contrib/opensolaris/tools/ctf/cvt/st_parse.c
deleted file mode 100644
index a452ca5960a7..000000000000
--- a/cddl/contrib/opensolaris/tools/ctf/cvt/st_parse.c
+++ /dev/null
@@ -1,1214 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License (the "License").
- * You may not use this file except in compliance with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
- */
-
-/*
- * This file is a sewer.
- */
-
-#include <limits.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <assert.h>
-#include <strings.h>
-#include <setjmp.h>
-#include <ctype.h>
-#include <uts/common/sys/ctf.h>
-
-#include "ctftools.h"
-#include "memory.h"
-#include "list.h"
-
-#define	HASH(NUM)	((int)(NUM & (BUCKETS - 1)))
-#define	BUCKETS		128
-
-#define	TYPEPAIRMULT	10000
-#define	MAKETYPEID(file, num)	((file) * TYPEPAIRMULT + num)
-#define	TYPEFILE(tid)		((tid) / TYPEPAIRMULT)
-#define	TYPENUM(tid)		((tid) % TYPEPAIRMULT)
-
-#define	expected(a, b, c) _expected(a, b, c, __LINE__)
-
-static int faketypenumber = 100000000;
-
-static tdesc_t *hash_table[BUCKETS];
-static tdesc_t *name_table[BUCKETS];
-
-static list_t *typedbitfldmems;
-
-static void reset(void);
-static jmp_buf	resetbuf;
-
-static char *soudef(char *cp, stabtype_t type, tdesc_t **rtdp);
-static void enumdef(char *cp, tdesc_t **rtdp);
-static int compute_sum(const char *w);
-
-static char *number(char *cp, int *n);
-static char *name(char *cp, char **w);
-static char *id(char *cp, int *h);
-static char *whitesp(char *cp);
-static void addhash(tdesc_t *tdp, int num);
-static int tagadd(char *w, int h, tdesc_t *tdp);
-static char *tdefdecl(char *cp, int h, tdesc_t **rtdp);
-static char *intrinsic(char *cp, tdesc_t **rtdp);
-static char *arraydef(char *cp, tdesc_t **rtdp);
-
-int debug_parse = DEBUG_PARSE;
-
-/*PRINTFLIKE3*/
-static void
-parse_debug(int level, char *cp, const char *fmt, ...)
-{
-	va_list ap;
-	char buf[1024];
-	char tmp[32];
-	int i;
-
-	if (level > debug_level || !debug_parse)
-		return;
-
-	if (cp != NULL) {
-		for (i = 0; i < 30; i++) {
-			if (cp[i] == '\0')
-				break;
-			if (!iscntrl(cp[i]))
-				tmp[i] = cp[i];
-		}
-		tmp[i] = '\0';
-		(void) snprintf(buf, sizeof (buf), "%s [cp='%s']\n", fmt, tmp);
-	} else {
-		strcpy(buf, fmt);
-		strcat(buf, "\n");
-	}
-
-	va_start(ap, fmt);
-	vadebug(level, buf, ap);
-	va_end(ap);
-}
-
-/* Report unexpected syntax in stabs. */
-static void
-_expected(
-	const char *who,	/* what function, or part thereof, is reporting */
-	const char *what,	/* what was expected */
-	const char *where,	/* where we were in the line of input */
-	int line)
-{
-	fprintf(stderr, "%s, expecting \"%s\" at \"%s\"\n", who, what, where);
-	fprintf(stderr, "code line: %d, file %s\n", line,
-	    (curhdr ? curhdr : "NO FILE"));
-	reset();
-}
-
-/*ARGSUSED*/
-void
-parse_init(tdata_t *td __unused)
-{
-	int i;
-
-	for (i = 0; i < BUCKETS; i++) {
-		hash_table[i] = NULL;
-		name_table[i] = NULL;
-	}
-
-	if (typedbitfldmems != NULL) {
-		list_free(typedbitfldmems, NULL, NULL);
-		typedbitfldmems = NULL;
-	}
-}
-
-void
-parse_finish(tdata_t *td)
-{
-	td->td_nextid = ++faketypenumber;
-}
-
-static tdesc_t *
-unres_new(int tid)
-{
-	tdesc_t *tdp;
-
-	tdp = xcalloc(sizeof (*tdp));
-	tdp->t_type = TYPEDEF_UNRES;
-	tdp->t_id = tid;
-
-	return (tdp);
-}
-
-static char *
-read_tid(char *cp, tdesc_t **tdpp)
-{
-	tdesc_t *tdp;
-	int tid;
-
-	cp = id(cp, &tid);
-
-	assert(tid != 0);
-
-	if (*cp == '=') {
-		if (!(cp = tdefdecl(cp + 1, tid, &tdp)))
-			return (NULL);
-		if (tdp->t_id && tdp->t_id != tid) {
-			tdesc_t *ntdp = xcalloc(sizeof (*ntdp));
-
-			ntdp->t_type = TYPEDEF;
-			ntdp->t_tdesc = tdp;
-			tdp = ntdp;
-		}
-		addhash(tdp, tid);
-	} else if ((tdp = lookup(tid)) == NULL)
-		tdp = unres_new(tid);
-
-	*tdpp = tdp;
-	return (cp);
-}
-
-static iitype_t
-parse_fun(char *cp, iidesc_t *ii)
-{
-	iitype_t iitype = 0;
-	tdesc_t *tdp;
-	tdesc_t **args = NULL;
-	int nargs = 0;
-	int va = 0;
-
-	/*
-	 * name:P		prototype
-	 * name:F		global function
-	 * name:f		static function
-	 */
-	switch (*cp++) {
-	case 'P':
-		iitype = II_NOT; /* not interesting */
-		break;
-
-	case 'F':
-		iitype = II_GFUN;
-		break;
-
-	case 'f':
-		iitype = II_SFUN;
-		break;
-
-	default:
-		expected("parse_nfun", "[PfF]", cp - 1);
-	}
-
-	if (!(cp = read_tid(cp, &tdp)))
-		return (-1);
-
-	if (*cp)
-		args = xmalloc(sizeof (tdesc_t *) * FUNCARG_DEF);
-
-	while (*cp && *++cp) {
-		if (*cp == '0') {
-			va = 1;
-			continue;
-		}
-
-		nargs++;
-		if (nargs > FUNCARG_DEF)
-			args = xrealloc(args, sizeof (tdesc_t *) * nargs);
-		if (!(cp = read_tid(cp, &args[nargs - 1]))) {
-			if (tdp->t_type == TYPEDEF_UNRES)
-				free(tdp);
-			free(args);
-			return (-1);
-		}
-	}
-
-	ii->ii_type = iitype;
-	ii->ii_dtype = tdp;
-	ii->ii_nargs = nargs;
-	ii->ii_args = args;
-	ii->ii_vargs = va;
-
-	return (iitype);
-}
-
-static iitype_t
-parse_sym(char *cp, iidesc_t *ii)
-{
-	tdesc_t *tdp;
-	iitype_t iitype = 0;
-
-	/*
-	 * name:G		global variable
-	 * name:S		static variable
-	 */
-	switch (*cp++) {
-	case 'G':
-		iitype = II_GVAR;
-		break;
-	case 'S':
-		iitype = II_SVAR;
-		break;
-	case 'p':
-		iitype = II_PSYM;
-		break;
-	case '(':
-		cp--;
-		/*FALLTHROUGH*/
-	case 'r':
-	case 'V':
-		iitype = II_NOT; /* not interesting */
-		break;
-	default:
-		expected("parse_sym", "[GprSV(]", cp - 1);
-	}
-
-	if (!(cp = read_tid(cp, &tdp)))
-		return (-1);
-
-	ii->ii_type = iitype;
-	ii->ii_dtype = tdp;
-
-	return (iitype);
-}
-
-static iitype_t
-parse_type(char *cp, iidesc_t *ii)
-{
-	tdesc_t *tdp, *ntdp;
-	int tid;
-
-	if (*cp++ != 't')
-		expected("parse_type", "t (type)", cp - 1);
-
-	cp = id(cp, &tid);
-	if ((tdp = lookup(tid)) == NULL) {
-		if (*cp++ != '=')
-			expected("parse_type", "= (definition)", cp - 1);
-
-		(void) tdefdecl(cp, tid, &tdp);
-
-		if (tdp->t_id == tid) {
-			assert(tdp->t_type != TYPEDEF);
-			assert(!lookup(tdp->t_id));
-
-			if (!streq(tdp->t_name, ii->ii_name)) {
-				ntdp = xcalloc(sizeof (*ntdp));
-				ntdp->t_name = xstrdup(ii->ii_name);
-				ntdp->t_type = TYPEDEF;
-				ntdp->t_tdesc = tdp;
-				tdp->t_id = faketypenumber++;
-				tdp = ntdp;
-			}
-		} else if (tdp->t_id == 0) {
-			assert(tdp->t_type == FORWARD ||
-			    tdp->t_type == INTRINSIC);
-
-			if (tdp->t_name && !streq(tdp->t_name, ii->ii_name)) {
-				ntdp = xcalloc(sizeof (*ntdp));
-				ntdp->t_name = xstrdup(ii->ii_name);
-				ntdp->t_type = TYPEDEF;
-				ntdp->t_tdesc = tdp;
-				tdp->t_id = faketypenumber++;
-				tdp = ntdp;
-			}
-		} else if (tdp->t_id != tid) {
-			ntdp = xcalloc(sizeof (*ntdp));
-			ntdp->t_name = xstrdup(ii->ii_name);
-			ntdp->t_type = TYPEDEF;
-			ntdp->t_tdesc = tdp;
-			tdp = ntdp;
-		}
-
-		if (tagadd(ii->ii_name, tid, tdp) < 0)
-			return (-1);
-	}
-
-	ii->ii_type = II_TYPE;
-	ii->ii_dtype = tdp;
-	return (II_TYPE);
-}
-
-static iitype_t
-parse_sou(char *cp, iidesc_t *idp)
-{
-	tdesc_t *rtdp;
-	int tid;
-
-	if (*cp++ != 'T')
-		expected("parse_sou", "T (sou)", cp - 1);
-
-	cp = id(cp, &tid);
-	if (*cp++ != '=')
-		expected("parse_sou", "= (definition)", cp - 1);
-
-	parse_debug(1, NULL, "parse_sou: declaring '%s'", idp->ii_name ?
-	    idp->ii_name : "(anon)");
-	if ((rtdp = lookup(tid)) != NULL) {
-		if (idp->ii_name != NULL) {
-			if (rtdp->t_name != NULL &&
-			    strcmp(rtdp->t_name, idp->ii_name) != 0) {
-				tdesc_t *tdp;
-
-				tdp = xcalloc(sizeof (*tdp));
-				tdp->t_name = xstrdup(idp->ii_name);
-				tdp->t_type = TYPEDEF;
-				tdp->t_tdesc = rtdp;
-				addhash(tdp, tid); /* for *(x,y) types */
-				parse_debug(3, NULL, "    %s defined as %s(%d)",
-				    idp->ii_name, tdesc_name(rtdp), tid);
-			} else if (rtdp->t_name == NULL) {
-				rtdp->t_name = xstrdup(idp->ii_name);
-				addhash(rtdp, tid);
-			}
-		}
-	} else {
-		rtdp = xcalloc(sizeof (*rtdp));
-		rtdp->t_name = idp->ii_name ? xstrdup(idp->ii_name) : NULL;
-		addhash(rtdp, tid);
-	}
-
-	switch (*cp++) {
-	case 's':
-		(void) soudef(cp, STRUCT, &rtdp);
-		break;
-	case 'u':
-		(void) soudef(cp, UNION, &rtdp);
-		break;
-	case 'e':
-		enumdef(cp, &rtdp);
-		break;
-	default:
-		expected("parse_sou", "<tag type s/u/e>", cp - 1);
-		break;
-	}
-
-	idp->ii_type = II_SOU;
-	idp->ii_dtype = rtdp;
-	return (II_SOU);
-}
-
-int
-parse_stab(stab_t *stab, char *cp, iidesc_t **iidescp)
-{
-	iidesc_t *ii = NULL;
-	iitype_t (*parse)(char *, iidesc_t *);
-	int rc;
-
-	/*
-	 * set up for reset()
-	 */
-	if (setjmp(resetbuf))
-		return (-1);
-
-	cp = whitesp(cp);
-	ii = iidesc_new(NULL);
-	cp = name(cp, &ii->ii_name);
-
-	switch (stab->n_type) {
-	case N_FUN:
-		parse = parse_fun;
-		break;
-
-	case N_LSYM:
-		if (*cp == 't')
-			parse = parse_type;
-		else if (*cp == 'T')
-			parse = parse_sou;
-		else
-			parse = parse_sym;
-		break;
-
-	case N_GSYM:
-	case N_LCSYM:
-	case N_PSYM:
-	case N_ROSYM:
-	case N_RSYM:
-	case N_STSYM:
-		parse = parse_sym;
-		break;
-	default:
-		parse_debug(1, cp, "Unknown stab type %#x", stab->n_type);
-		bzero(&resetbuf, sizeof (resetbuf));
-		return (-1);
-	}
-
-	rc = parse(cp, ii);
-	bzero(&resetbuf, sizeof (resetbuf));
-
-	if (rc < 0 || ii->ii_type == II_NOT) {
-		iidesc_free(ii, NULL);
-		return (rc);
-	}
-
-	*iidescp = ii;
-
-	return (1);
-}
-
-/*
- * Check if we have this node in the hash table already
- */
-tdesc_t *
-lookup(int h)
-{
-	int bucket = HASH(h);
-	tdesc_t *tdp = hash_table[bucket];
-
-	while (tdp != NULL) {
-		if (tdp->t_id == h)
-			return (tdp);
-		tdp = tdp->t_hash;
-	}
-	return (NULL);
-}
-
-static char *
-whitesp(char *cp)
-{
-	char c;
-
-	for (c = *cp++; isspace(c); c = *cp++)
-		;
-	--cp;
-	return (cp);
-}
-
-static char *
-name(char *cp, char **w)
-{
-	char *new, *orig, c;
-	int len;
-
-	orig = cp;
-	c = *cp++;
-	if (c == ':')
-		*w = NULL;
-	else if (isalpha(c) || strchr("_.$#", c)) {
-		for (c = *cp++; isalnum(c) || strchr(" _.$#", c); c = *cp++)
-			;
-		if (c != ':')
-			reset();
-		len = cp - orig;
-		new = xmalloc(len);
-		while (orig < cp - 1)
-			*new++ = *orig++;
-		*new = '\0';
-		*w = new - (len - 1);
-	} else
-		reset();
-
-	return (cp);
-}
-
-static char *
-number(char *cp, int *n)
-{
-	char *next;
-
-	*n = (int)strtol(cp, &next, 10);
-	if (next == cp)
-		expected("number", "<number>", cp);
-	return (next);
-}
-
-static char *
-id(char *cp, int *h)
-{
-	int n1, n2;
-
-	if (*cp == '(') {	/* SunPro style */
-		cp++;
-		cp = number(cp, &n1);
-		if (*cp++ != ',')
-			expected("id", ",", cp - 1);
-		cp = number(cp, &n2);
-		if (*cp++ != ')')
-			expected("id", ")", cp - 1);
-		*h = MAKETYPEID(n1, n2);
-	} else if (isdigit(*cp)) { /* gcc style */
-		cp = number(cp, &n1);
-		*h = n1;
-	} else {
-		expected("id", "(/0-9", cp);
-	}
-	return (cp);
-}
-
-static int
-tagadd(char *w, int h, tdesc_t *tdp)
-{
-	tdesc_t *otdp;
-
-	tdp->t_name = w;
-	if (!(otdp = lookup(h)))
-		addhash(tdp, h);
-	else if (otdp != tdp) {
-		warning("duplicate entry\n");
-		warning("  old: %s %d (%d,%d)\n", tdesc_name(otdp),
-		    otdp->t_type, TYPEFILE(otdp->t_id), TYPENUM(otdp->t_id));
-		warning("  new: %s %d (%d,%d)\n", tdesc_name(tdp),
-		    tdp->t_type, TYPEFILE(tdp->t_id), TYPENUM(tdp->t_id));
-		return (-1);
-	}
-
-	return (0);
-}
-
-static char *
-tdefdecl(char *cp, int h, tdesc_t **rtdp)
-{
-	tdesc_t *ntdp;
-	char *w;
-	int c, h2;
-	char type;
-
-	parse_debug(3, cp, "tdefdecl h=%d", h);
-
-	/* Type codes */
-	switch (type = *cp) {
-	case 'b': /* integer */
-	case 'R': /* fp */
-		cp = intrinsic(cp, rtdp);
-		break;
-	case '(': /* equiv to another type */
-		cp = id(cp, &h2);
-		ntdp = lookup(h2);
-
-		if (ntdp != NULL && *cp == '=') {
-			if (ntdp->t_type == FORWARD && *(cp + 1) == 'x') {
-				/*
-				 * The 6.2 compiler, and possibly others, will
-				 * sometimes emit the same stab for a forward
-				 * declaration twice.  That is, "(1,2)=xsfoo:"
-				 * will sometimes show up in two different
-				 * places.  This is, of course, quite fun.  We
-				 * want CTF to work in spite of the compiler,
-				 * so we'll let this one through.
-				 */
-				char *c2 = cp + 2;
-				char *nm;
-
-				if (!strchr("sue", *c2++)) {
-					expected("tdefdecl/x-redefine", "[sue]",
-					    c2 - 1);
-				}
-
-				c2 = name(c2, &nm);
-				if (strcmp(nm, ntdp->t_name) != 0) {
-					terminate("Stabs error: Attempt to "
-					    "redefine type (%d,%d) as "
-					    "something else: %s\n",
-					    TYPEFILE(h2), TYPENUM(h2),
-					    c2 - 1);
-				}
-				free(nm);
-
-				h2 = faketypenumber++;
-				ntdp = NULL;
-			} else {
-				terminate("Stabs error: Attempting to "
-				    "redefine type (%d,%d)\n", TYPEFILE(h2),
-				    TYPENUM(h2));
-			}
-		}
-
-		if (ntdp == NULL) {  /* if that type isn't defined yet */
-			if (*cp != '=') {
-				/* record it as unresolved */
-				parse_debug(3, NULL, "tdefdecl unres type %d",
-				    h2);
-				*rtdp = calloc(sizeof (**rtdp), 1);
-				(*rtdp)->t_type = TYPEDEF_UNRES;
-				(*rtdp)->t_id = h2;
-				break;
-			} else
-				cp++;
-
-			/* define a new type */
-			cp = tdefdecl(cp, h2, rtdp);
-			if ((*rtdp)->t_id && (*rtdp)->t_id != h2) {
-				ntdp = calloc(sizeof (*ntdp), 1);
-				ntdp->t_type = TYPEDEF;
-				ntdp->t_tdesc = *rtdp;
-				*rtdp = ntdp;
-			}
-
-			addhash(*rtdp, h2);
-
-		} else { /* that type is already defined */
-			if (ntdp->t_type != TYPEDEF || ntdp->t_name != NULL) {
-				*rtdp = ntdp;
-			} else {
-				parse_debug(3, NULL,
-				    "No duplicate typedef anon for ref");
-				*rtdp = ntdp;
-			}
-		}
-		break;
-	case '*':
-		ntdp = NULL;
-		cp = tdefdecl(cp + 1, h, &ntdp);
-		if (ntdp == NULL)
-			expected("tdefdecl/*", "id", cp);
-
-		if (!ntdp->t_id)
-			ntdp->t_id = faketypenumber++;
-
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_type = POINTER;
-		(*rtdp)->t_size = 0;
-		(*rtdp)->t_id = h;
-		(*rtdp)->t_tdesc = ntdp;
-		break;
-	case 'f':
-		cp = tdefdecl(cp + 1, h, &ntdp);
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_type = FUNCTION;
-		(*rtdp)->t_size = 0;
-		(*rtdp)->t_id = h;
-		(*rtdp)->t_fndef = xcalloc(sizeof (fndef_t));
-		/*
-		 * The 6.1 compiler will sometimes generate incorrect stabs for
-		 * function pointers (it'll get the return type wrong).  This
-		 * causes merges to fail.  We therefore treat function pointers
-		 * as if they all point to functions that return int.  When
-		 * 4432549 is fixed, the lookupname() call below should be
-		 * replaced with `ntdp'.
-		 */
-		(*rtdp)->t_fndef->fn_ret = lookupname("int");
-		break;
-	case 'a':
-	case 'z':
-		cp++;
-		if (*cp++ != 'r')
-			expected("tdefdecl/[az]", "r", cp - 1);
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_type = ARRAY;
-		(*rtdp)->t_id = h;
-		cp = arraydef(cp, rtdp);
-		break;
-	case 'x':
-		c = *++cp;
-		if (c != 's' && c != 'u' && c != 'e')
-			expected("tdefdecl/x", "[sue]", cp - 1);
-		cp = name(cp + 1, &w);
-
-		ntdp = xcalloc(sizeof (*ntdp));
-		ntdp->t_type = FORWARD;
-		ntdp->t_name = w;
-		/*
-		 * We explicitly don't set t_id here - the caller will do it.
-		 * The caller may want to use a real type ID, or they may
-		 * choose to make one up.
-		 */
-
-		*rtdp = ntdp;
-		break;
-
-	case 'B': /* volatile */
-		cp = tdefdecl(cp + 1, h, &ntdp);
-
-		if (!ntdp->t_id)
-			ntdp->t_id = faketypenumber++;
-
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_type = VOLATILE;
-		(*rtdp)->t_size = 0;
-		(*rtdp)->t_tdesc = ntdp;
-		(*rtdp)->t_id = h;
-		break;
-
-	case 'k': /* const */
-		cp = tdefdecl(cp + 1, h, &ntdp);
-
-		if (!ntdp->t_id)
-			ntdp->t_id = faketypenumber++;
-
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_type = CONST;
-		(*rtdp)->t_size = 0;
-		(*rtdp)->t_tdesc = ntdp;
-		(*rtdp)->t_id = h;
-		break;
-
-	case 'K': /* restricted */
-		cp = tdefdecl(cp + 1, h, &ntdp);
-
-		if (!ntdp->t_id)
-			ntdp->t_id = faketypenumber++;
-
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_type = RESTRICT;
-		(*rtdp)->t_size = 0;
-		(*rtdp)->t_tdesc = ntdp;
-		(*rtdp)->t_id = h;
-		break;
-
-	case 'u':
-	case 's':
-		cp++;
-
-		*rtdp = xcalloc(sizeof (**rtdp));
-		(*rtdp)->t_name = NULL;
-		cp = soudef(cp, (type == 'u') ? UNION : STRUCT, rtdp);
-		break;
-	default:
-		expected("tdefdecl", "<type code>", cp);
-	}
-	return (cp);
-}
-
-static char *
-intrinsic(char *cp, tdesc_t **rtdp)
-{
-	intr_t *intr = xcalloc(sizeof (intr_t));
-	tdesc_t *tdp;
-	int width, fmt, i;
-
-	switch (*cp++) {
-	case 'b':
-		intr->intr_type = INTR_INT;
-		if (*cp == 's')
-			intr->intr_signed = 1;
-		else if (*cp != 'u')
-			expected("intrinsic/b", "[su]", cp);
-		cp++;
-
-		if (strchr("cbv", *cp))
-			intr->intr_iformat = *cp++;
-
-		cp = number(cp, &width);
-		if (*cp++ != ';')
-			expected("intrinsic/b", "; (post-width)", cp - 1);
-
-		cp = number(cp, &intr->intr_offset);
-		if (*cp++ != ';')
-			expected("intrinsic/b", "; (post-offset)", cp - 1);
-
-		cp = number(cp, &intr->intr_nbits);
-		break;
-
-	case 'R':
-		intr->intr_type = INTR_REAL;
-		for (fmt = 0, i = 0; isdigit(*(cp + i)); i++)
-			fmt = fmt * 10 + (*(cp + i) - '0');
-
-		if (fmt < 1 || fmt > CTF_FP_MAX)
-			expected("intrinsic/R", "number <= CTF_FP_MAX", cp);
-
-		intr->intr_fformat = fmt;
-		cp += i;
-
-		if (*cp++ != ';')
-			expected("intrinsic/R", ";", cp - 1);
-		cp = number(cp, &width);
-
-		intr->intr_nbits = width * 8;
-		break;
-	}
-
-	tdp = xcalloc(sizeof (*tdp));
-	tdp->t_type = INTRINSIC;
-	tdp->t_size = width;
-	tdp->t_name = NULL;
-	tdp->t_intr = intr;
-	parse_debug(3, NULL, "intrinsic: size=%d", width);
-	*rtdp = tdp;
-
-	return (cp);
-}
-
-static tdesc_t *
-bitintrinsic(tdesc_t *template, int nbits)
-{
-	tdesc_t *newtdp = xcalloc(sizeof (tdesc_t));
-
-	newtdp->t_name = xstrdup(template->t_name);
-	newtdp->t_id = faketypenumber++;
-	newtdp->t_type = INTRINSIC;
-	newtdp->t_size = template->t_size;
-	newtdp->t_intr = xmalloc(sizeof (intr_t));
-	bcopy(template->t_intr, newtdp->t_intr, sizeof (intr_t));
-	newtdp->t_intr->intr_nbits = nbits;
-
-	return (newtdp);
-}
-
-static char *
-offsize(char *cp, mlist_t *mlp)
-{
-	int offset, size;
-
-	if (*cp == ',')
-		cp++;
-	cp = number(cp, &offset);
-	if (*cp++ != ',')
-		expected("offsize/2", ",", cp - 1);
-	cp = number(cp, &size);
-	if (*cp++ != ';')
-		expected("offsize/3", ";", cp - 1);
-	mlp->ml_offset = offset;
-	mlp->ml_size = size;
-	return (cp);
-}
-
-static tdesc_t *
-find_intrinsic(tdesc_t *tdp)
-{
-	for (;;) {
-		switch (tdp->t_type) {
-		case TYPEDEF:
-		case VOLATILE:
-		case CONST:
-		case RESTRICT:
-			tdp = tdp->t_tdesc;
-			break;
-
-		default:
-			return (tdp);
-		}
-	}
-}
-
-static char *
-soudef(char *cp, stabtype_t type, tdesc_t **rtdp)
-{
-	mlist_t *mlp, **prev;
-	char *w;
-	int h;
-	int size;
-	tdesc_t *tdp, *itdp;
-
-	cp = number(cp, &size);
-	(*rtdp)->t_size = size;
-	(*rtdp)->t_type = type; /* s or u */
-
-	/*
-	 * An '@' here indicates a bitmask follows.   This is so the
-	 * compiler can pass information to debuggers about how structures
-	 * are passed in the v9 world.  We don't need this information
-	 * so we skip over it.
-	 */
-	if (cp[0] == '@') {
-		cp += 3;
-	}
-
-	parse_debug(3, cp, "soudef: %s size=%d", tdesc_name(*rtdp),
-	    (*rtdp)->t_size);
-
-	prev = &((*rtdp)->t_members);
-	/* now fill up the fields */
-	while ((*cp != '\0') && (*cp != ';')) { /* signifies end of fields */
-		mlp = xcalloc(sizeof (*mlp));
-		*prev = mlp;
-		cp = name(cp, &w);
-		mlp->ml_name = w;
-		cp = id(cp, &h);
-		/*
-		 * find the tdesc struct in the hash table for this type
-		 * and stick a ptr in here
-		 */
-		tdp = lookup(h);
-		if (tdp == NULL) { /* not in hash list */
-			parse_debug(3, NULL, "      defines %s (%d)", w, h);
-			if (*cp++ != '=') {
-				tdp = unres_new(h);
-				parse_debug(3, NULL,
-				    "      refers to %s (unresolved %d)",
-				    (w ? w : "anon"), h);
-			} else {
-				cp = tdefdecl(cp, h, &tdp);
-
-				if (tdp->t_id && tdp->t_id != h) {
-					tdesc_t *ntdp = xcalloc(sizeof (*ntdp));
-
-					ntdp->t_type = TYPEDEF;
-					ntdp->t_tdesc = tdp;
-					tdp = ntdp;
-				}
-
-				addhash(tdp, h);
-				parse_debug(4, cp,
-				    "     soudef now looking at    ");
-				cp++;
-			}
-		} else {
-			parse_debug(3, NULL, "      refers to %s (%d, %s)",
-			    w ? w : "anon", h, tdesc_name(tdp));
-		}
-
-		cp = offsize(cp, mlp);
-
-		itdp = find_intrinsic(tdp);
-		if (itdp->t_type == INTRINSIC) {
-			if (mlp->ml_size != itdp->t_intr->intr_nbits) {
-				parse_debug(4, cp, "making %d bit intrinsic "
-				    "from %s", mlp->ml_size, tdesc_name(itdp));
-				mlp->ml_type = bitintrinsic(itdp, mlp->ml_size);
-			} else
-				mlp->ml_type = tdp;
-		} else if (itdp->t_type == TYPEDEF_UNRES) {
-			list_add(&typedbitfldmems, mlp);
-			mlp->ml_type = tdp;
-		} else {
-			mlp->ml_type = tdp;
-		}
-
-		/* cp is now pointing to next field */
-		prev = &mlp->ml_next;
-	}
-	return (cp);
-}
-
-static char *
-arraydef(char *cp, tdesc_t **rtdp)
-{
-	int start, end, h;
-
-	cp = id(cp, &h);
-	if (*cp++ != ';')
-		expected("arraydef/1", ";", cp - 1);
-
-	(*rtdp)->t_ardef = xcalloc(sizeof (ardef_t));
-	(*rtdp)->t_ardef->ad_idxtype = lookup(h);
-
-	cp = number(cp, &start); /* lower */
-	if (*cp++ != ';')
-		expected("arraydef/2", ";", cp - 1);
-
-	if (*cp == 'S') {
-		/*
-		 * variable length array - treat as null dimensioned
-		 *
-		 * For VLA variables on sparc, SS12 generated stab entry
-		 * looks as follows:
-		 * .stabs "buf:(0,28)=zr(0,4);0;S-12;(0,1)", 0x80, 0, 0, -16
-		 * Whereas SS12u1 generated stab entry looks like this:
-		 * .stabs "buf:(0,28)=zr(0,4);0;S0;(0,1)", 0x80, 0, 0, 0
-		 * On x86, both versions generate the first type of entry.
-		 * We should be able to parse both.
-		 */
-		cp++;
-		if (*cp == '-')
-			cp++;
-		cp = number(cp, &end);
-		end = start;
-	} else {
-		/*
-		 * normal fixed-dimension array
-		 * Stab entry for this looks as follows :
-		 * .stabs "x:(0,28)=ar(0,4);0;9;(0,3)", 0x80, 0, 40, 0
-		 */
-		cp = number(cp, &end);  /* upper */
-	}
-
-	if (*cp++ != ';')
-		expected("arraydef/3", ";", cp - 1);
-	(*rtdp)->t_ardef->ad_nelems = end - start + 1;
-	cp = tdefdecl(cp, h, &((*rtdp)->t_ardef->ad_contents));
-
-	parse_debug(3, cp, "defined array idx type %d %d-%d next ",
-	    h, start, end);
-
-	return (cp);
-}
-
-static void
-enumdef(char *cp, tdesc_t **rtdp)
-{
-	elist_t *elp, **prev;
-	char *w;
-
-	(*rtdp)->t_type = ENUM;
-	(*rtdp)->t_emem = NULL;
-
-	prev = &((*rtdp)->t_emem);
-	while (*cp != ';') {
-		elp = xcalloc(sizeof (*elp));
-		elp->el_next = NULL;
-		*prev = elp;
-		cp = name(cp, &w);
-		elp->el_name = w;
-		cp = number(cp, &elp->el_number);
-		parse_debug(3, NULL, "enum %s: %s=%d", tdesc_name(*rtdp),
-		    elp->el_name, elp->el_number);
-		prev = &elp->el_next;
-		if (*cp++ != ',')
-			expected("enumdef", ",", cp - 1);
-	}
-}
-
-static tdesc_t *
-lookup_name(tdesc_t **hash, const char *name1)
-{
-	int bucket = compute_sum(name1);
-	tdesc_t *tdp, *ttdp = NULL;
-
-	for (tdp = hash[bucket]; tdp != NULL; tdp = tdp->t_next) {
-		if (tdp->t_name != NULL && strcmp(tdp->t_name, name1) == 0) {
-			if (tdp->t_type == STRUCT || tdp->t_type == UNION ||
-			    tdp->t_type == ENUM || tdp->t_type == INTRINSIC)
-				return (tdp);
-			if (tdp->t_type == TYPEDEF)
-				ttdp = tdp;
-		}
-	}
-	return (ttdp);
-}
-
-tdesc_t *
-lookupname(const char *name1)
-{
-	return (lookup_name(name_table, name1));
-}
-
-/*
- * Add a node to the hash queues.
- */
-static void
-addhash(tdesc_t *tdp, int num)
-{
-	int hash = HASH(num);
-	tdesc_t *ttdp;
-	char added_num = 0, added_name = 0;
-
-	/*
-	 * If it already exists in the hash table don't add it again
-	 * (but still check to see if the name should be hashed).
-	 */
-	ttdp = lookup(num);
-
-	if (ttdp == NULL) {
-		tdp->t_id = num;
-		tdp->t_hash = hash_table[hash];
-		hash_table[hash] = tdp;
-		added_num = 1;
-	}
-
-	if (tdp->t_name != NULL) {
-		ttdp = lookupname(tdp->t_name);
-		if (ttdp == NULL) {
-			hash = compute_sum(tdp->t_name);
-			tdp->t_next = name_table[hash];
-			name_table[hash] = tdp;
-			added_name = 1;
-		}
-	}
-	if (!added_num && !added_name) {
-		terminate("stabs: broken hash\n");
-	}
-}
-
-static int
-compute_sum(const char *w)
-{
-	char c;
-	int sum;
-
-	for (sum = 0; (c = *w) != '\0'; sum += c, w++)
-		;
-	return (HASH(sum));
-}
-
-static void
-reset(void)
-{
-	longjmp(resetbuf, 1);
-}
-
-void
-check_hash(void)
-{
-	tdesc_t *tdp;
-	int i;
-
-	printf("checking hash\n");
-	for (i = 0; i < BUCKETS; i++) {
-		if (hash_table[i]) {
-			for (tdp = hash_table[i]->t_hash;
-			    tdp && tdp != hash_table[i];
-			    tdp = tdp->t_hash)
-				continue;
-			if (tdp) {
-				terminate("cycle in hash bucket %d\n", i);
-				return;
-			}
-		}
-
-		if (name_table[i]) {
-			for (tdp = name_table[i]->t_next;
-			    tdp && tdp != name_table[i];
-			    tdp = tdp->t_next)
-				continue;
-			if (tdp) {
-				terminate("cycle in name bucket %d\n", i);
-				return;
-			}
-		}
-	}
-	printf("done\n");
-}
-
-/*ARGSUSED1*/
-static int
-resolve_typed_bitfields_cb(void *arg, void *private __unused)
-{
-	mlist_t *ml = arg;
-	tdesc_t *tdp = ml->ml_type;
-
-	debug(3, "Resolving typed bitfields (member %s)\n",
-	    (ml->ml_name ? ml->ml_name : "(anon)"));
-
-	while (tdp) {
-		switch (tdp->t_type) {
-		case INTRINSIC:
-			if (ml->ml_size != tdp->t_intr->intr_nbits) {
-				debug(3, "making %d bit intrinsic from %s",
-				    ml->ml_size, tdesc_name(tdp));
-				ml->ml_type = bitintrinsic(tdp, ml->ml_size);
-			} else {
-				debug(3, "using existing %d bit %s intrinsic",
-				    ml->ml_size, tdesc_name(tdp));
-				ml->ml_type = tdp;
-			}
-			return (1);
-
-		case POINTER:
-		case TYPEDEF:
-		case VOLATILE:
-		case CONST:
-		case RESTRICT:
-			tdp = tdp->t_tdesc;
-			break;
-
-		default:
-			return (1);
-		}
-	}
-
-	terminate("type chain for bitfield member %s has a NULL", ml->ml_name);
-	/*NOTREACHED*/
-	return (0);
-}
-
-void
-resolve_typed_bitfields(void)
-{
-	(void) list_iter(typedbitfldmems,
-	    resolve_typed_bitfields_cb, NULL);
-}
diff --git a/cddl/contrib/opensolaris/tools/ctf/cvt/stabs.c b/cddl/contrib/opensolaris/tools/ctf/cvt/stabs.c
deleted file mode 100644
index c0c68b53e030..000000000000
--- a/cddl/contrib/opensolaris/tools/ctf/cvt/stabs.c
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License (the "License").
- * You may not use this file except in compliance with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
-/*
- * Routines used to read stabs data from a file, and to build a tdata structure
- * based on the interesting parts of that data.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <assert.h>
-#include <string.h>
-#include <libgen.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/param.h>
-
-#include "ctftools.h"
-#include "list.h"
-#include "stack.h"
-#include "memory.h"
-#include "traverse.h"
-
-char *curhdr;
-
-/*
- * The stabs generator will sometimes reference types before they've been
- * defined.  If this is the case, a TYPEDEF_UNRES tdesc will be generated.
- * Note that this is different from a forward declaration, in which the
- * stab is defined, but is defined as something that doesn't exist yet.
- * When we have read all of the stabs from the file, we can go back and
- * fix up all of the unresolved types.  We should be able to fix all of them.
- */
-/*ARGSUSED2*/
-static int
-resolve_tou_node(tdesc_t *node, tdesc_t **nodep, void *private __unused)
-{
-	tdesc_t *new;
-
-	debug(3, "Trying to resolve %s (%d)\n", tdesc_name(node), node->t_id);
-	new = lookup(node->t_id);
-
-	if (new == NULL) {
-		terminate("Couldn't resolve type %d\n", node->t_id);
-	}
-
-	debug(3, " Resolving to %d\n", new->t_id);
-
-	*nodep = new;
-
-	return (1);
-}
-
-/*ARGSUSED*/
-static int
-resolve_fwd_node(tdesc_t *node, tdesc_t **nodep, void *private __unused)
-{
-	tdesc_t *new = lookupname(node->t_name);
-
-	debug(3, "Trying to unforward %s (%d)\n", tdesc_name(node), node->t_id);
-
-	if (!new || (new->t_type != STRUCT && new->t_type != UNION))
-		return (0);
-
-	debug(3, " Unforwarded to %d\n", new->t_id);
-
-	*nodep = new;
-
-	return (1);
-}
-
-static tdtrav_cb_f resolve_cbs[] = {
-	NULL,
-	NULL,			/* intrinsic */
-	NULL,			/* pointer */
-	NULL,			/* array */
-	NULL,			/* function */
-	NULL,			/* struct */
-	NULL,			/* union */
-	NULL,			/* enum */
-	resolve_fwd_node,	/* forward */
-	NULL,			/* typedef */
-	resolve_tou_node,	/* typedef unres */
-	NULL,			/* volatile */
-	NULL,			/* const */
-	NULL,			/* restrict */
-};
-
-static void
-resolve_nodes(tdata_t *td)
-{
-	debug(2, "Resolving unresolved stabs\n");
-
-	(void) iitraverse_hash(td->td_iihash, &td->td_curvgen, resolve_cbs,
-	    NULL, NULL, td);
-}
-
-static char *
-concat(char *s1, char *s2, int s2strip)
-{
-	int savelen = strlen(s2) - s2strip;
-	int newlen = (s1 ? strlen(s1) : 0) + savelen + 1;
-	char *out;
-
-	out = xrealloc(s1, newlen);
-	if (s1)
-		strncpy(out + strlen(out), s2, savelen);
-	else
-		strncpy(out, s2, savelen);
-
-	out[newlen - 1] = '\0';
-
-	return (out);
-}
-
-/*
- * N_FUN stabs come with their arguments in promoted form.  In order to get the
- * actual arguments, we need to wait for the N_PSYM stabs that will come towards
- * the end of the function.  These routines free the arguments (fnarg_free) we
- * got from the N_FUN stab and add (fnarg_add) the ones from the N_PSYM stabs.
- */
-static void
-fnarg_add(iidesc_t *curfun, iidesc_t *arg)
-{
-	curfun->ii_nargs++;
-
-	if (curfun->ii_nargs == 1)
-		curfun->ii_args = xmalloc(sizeof (tdesc_t *) * FUNCARG_DEF);
-	else if (curfun->ii_nargs > FUNCARG_DEF) {
-		curfun->ii_args = xrealloc(curfun->ii_args,
-		    sizeof (tdesc_t *) * curfun->ii_nargs);
-	}
-
-	curfun->ii_args[curfun->ii_nargs - 1] = arg->ii_dtype;
-	arg->ii_dtype = NULL;
-}
-
-static void
-fnarg_free(iidesc_t *ii)
-{
-	ii->ii_nargs = 0;
-	free(ii->ii_args);
-	ii->ii_args = NULL;
-}
-
-/*
- * Read the stabs from the stab ELF section, and turn them into a tdesc tree,
- * assembled under an iidesc list.
- */
-int
-stabs_read(tdata_t *td, Elf *elf, char *file)
-{
-	Elf_Scn *scn;
-	Elf_Data *data;
-	stab_t *stab;
-	stk_t *file_stack;
-	iidesc_t *iidescp;
-	iidesc_t *curfun = NULL;
-	char curpath[MAXPATHLEN];
-	char *curfile = NULL;
-	char *str;
-	char *fstr = NULL, *ofstr = NULL;
-	int stabidx, stabstridx;
-	int nstabs, rc, i;
-	int scope = 0;
-
-	if (!((stabidx = findelfsecidx(elf, file, ".stab.excl")) >= 0 &&
-	    (stabstridx = findelfsecidx(elf, file, ".stab.exclstr")) >= 0) &&
-	    !((stabidx = findelfsecidx(elf, file, ".stab")) >= 0 &&
-	    (stabstridx = findelfsecidx(elf, file, ".stabstr")) >= 0)) {
-		errno = ENOENT;
-		return (-1);
-	}
-
-	file_stack = stack_new(free);
-
-	stack_push(file_stack, file);
-	curhdr = file;
-
-	debug(3, "Found stabs in %d, strings in %d\n", stabidx, stabstridx);
-
-	scn = elf_getscn(elf, stabidx);
-	data = elf_rawdata(scn, NULL);
-	nstabs = data->d_size / sizeof (stab_t);
-
-	parse_init(td);
-	for (i = 0; i < nstabs; i++) {
-		stab = &((stab_t *)data->d_buf)[i];
-
-		/* We don't want any local definitions */
-		if (stab->n_type == N_LBRAC) {
-			scope++;
-			debug(3, "stab %d: opening scope (%d)\n", i + 1, scope);
-			continue;
-		} else if (stab->n_type == N_RBRAC) {
-			scope--;
-			debug(3, "stab %d: closing scope (%d)\n", i + 1, scope);
-			continue;
-		} else if (stab->n_type == N_EINCL) {
-			/*
-			 * There's a bug in the 5.2 (Taz) compilers that causes
-			 * them to emit an extra N_EINCL if there's no actual
-			 * text in the file being compiled.  To work around this
-			 * bug, we explicitly check to make sure we're not
-			 * trying to pop a stack that only has the outer scope
-			 * on it.
-			 */
-			if (stack_level(file_stack) != 1) {
-				str = (char *)stack_pop(file_stack);
-				free(str);
-				curhdr = (char *)stack_peek(file_stack);
-			}
-		}
-
-		/* We only care about a subset of the stabs */
-		if (!(stab->n_type == N_FUN || stab->n_type == N_GSYM ||
-		    stab->n_type == N_LCSYM || stab->n_type == N_LSYM ||
-		    stab->n_type == N_PSYM || stab->n_type == N_ROSYM ||
-		    stab->n_type == N_RSYM ||
-		    stab->n_type == N_STSYM || stab->n_type == N_BINCL ||
-		    stab->n_type == N_SO || stab->n_type == N_OPT))
-			continue;
-
-		if ((str = elf_strptr(elf, stabstridx,
-		    (size_t)stab->n_strx)) == NULL) {
-			terminate("%s: Can't find string at %u for stab %d\n",
-			    file, stab->n_strx, i);
-		}
-
-		if (stab->n_type == N_BINCL) {
-			curhdr = xstrdup(str);
-			stack_push(file_stack, curhdr);
-			continue;
-		} else if (stab->n_type == N_SO) {
-			if (str[strlen(str) - 1] != '/') {
-				strcpy(curpath, str);
-				curfile = basename(curpath);
-			}
-			continue;
-		} else if (stab->n_type == N_OPT) {
-			if (strcmp(str, "gcc2_compiled.") == 0) {
-				terminate("%s: GCC-generated stabs are "
-				    "unsupported. Use DWARF instead.\n", file);
-			}
-			continue;
-		}
-
-		if (str[strlen(str) - 1] == '\\') {
-			int offset = 1;
-			/*
-			 * There's a bug in the compilers that causes them to
-			 * generate \ for continuations with just -g (this is
-			 * ok), and \\ for continuations with -g -O (this is
-			 * broken).  This bug is "fixed" in the 6.2 compilers
-			 * via the elimination of continuation stabs.
-			 */
-			if (str[strlen(str) - 2] == '\\')
-				offset = 2;
-			fstr = concat(fstr, str, offset);
-			continue;
-		} else
-			fstr = concat(fstr, str, 0);
-
-		debug(3, "%4d: .stabs \"%s\", %#x, %d, %hd, %d (from %s)\n", i,
-		    fstr, stab->n_type, 0, stab->n_desc,
-		    stab->n_value, curhdr);
-
-		if (debug_level >= 3)
-			check_hash();
-
-		/*
-		 * Sometimes the compiler stutters, and emits the same stab
-		 * twice.  This is bad for the parser, which will attempt to
-		 * redefine the type IDs indicated in the stabs.  This is
-		 * compiler bug 4433511.
-		 */
-		if (ofstr && strcmp(fstr, ofstr) == 0) {
-			debug(3, "Stutter stab\n");
-			free(fstr);
-			fstr = NULL;
-			continue;
-		}
-
-		if (ofstr)
-			free(ofstr);
-		ofstr = fstr;
-
-		iidescp = NULL;
-
-		if ((rc = parse_stab(stab, fstr, &iidescp)) < 0) {
-			terminate("%s: Couldn't parse stab \"%s\" "
-			    "(source file %s)\n", file, str, curhdr);
-		}
-
-		if (rc == 0)
-			goto parse_loop_end;
-
-		/* Make sure the scope tracking is working correctly */
-		assert(stab->n_type != N_FUN || (iidescp->ii_type != II_GFUN &&
-		    iidescp->ii_type != II_SFUN) || scope == 0);
-
-		/*
-		 * The only things we care about that are in local scope are
-		 * the N_PSYM stabs.
-		 */
-		if (scope && stab->n_type != N_PSYM) {
-			if (iidescp)
-				iidesc_free(iidescp, NULL);
-			goto parse_loop_end;
-		}
-
-		switch (iidescp->ii_type) {
-		case II_SFUN:
-			iidescp->ii_owner = xstrdup(curfile);
-			/*FALLTHROUGH*/
-		case II_GFUN:
-			curfun = iidescp;
-			fnarg_free(iidescp);
-			iidesc_add(td->td_iihash, iidescp);
-			break;
-
-		case II_SVAR:
-			iidescp->ii_owner = xstrdup(curfile);
-			/*FALLTHROUGH*/
-		case II_GVAR:
-		case II_TYPE:
-		case II_SOU:
-			iidesc_add(td->td_iihash, iidescp);
-			break;
-
-		case II_PSYM:
-			fnarg_add(curfun, iidescp);
-			iidesc_free(iidescp, NULL);
-			break;
-		default:
-			aborterr("invalid ii_type %d for stab type %d",
-			    iidescp->ii_type, stab->n_type);
-		}
-
-parse_loop_end:
-		fstr = NULL;
-	}
-
-	if (ofstr)
-		free(ofstr);
-
-	resolve_nodes(td);
-	resolve_typed_bitfields();
-	parse_finish(td);
-
-	cvt_fixstabs(td);
-	cvt_fixups(td, elf_ptrsz(elf));
-
-	return (0);
-}
diff --git a/cddl/usr.bin/ctfconvert/Makefile b/cddl/usr.bin/ctfconvert/Makefile
index 02cbe95640f5..78b65020452a 100644
--- a/cddl/usr.bin/ctfconvert/Makefile
+++ b/cddl/usr.bin/ctfconvert/Makefile
@@ -18,8 +18,6 @@ SRCS=		alist.c \
 		memory.c \
 		merge.c \
 		output.c \
-		st_parse.c \
-		stabs.c \
 		stack.c \
 		strtab.c \
 		symbol.c \