--- old/usr/src/tools/ctf/cvt/ctf.c	Wed Sep  4 06:59:33 2019
+++ /dev/null	Wed Sep  4 06:59:33 2019
@@ -1,1282 +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 2009 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-/*
- * Create and parse buffers containing CTF data.
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <strings.h>
-#include <ctype.h>
-#include <zlib.h>
-#include <elf.h>
-
-#include "ctf_headers.h"
-#include "ctftools.h"
-#include "strtab.h"
-#include "memory.h"
-
-/*
- * Name of the file currently being read, used to print error messages.  We
- * assume that only one file will be read at a time, and thus make no attempt
- * to allow curfile to be used simultaneously by multiple threads.
- *
- * The value is only valid during a call to ctf_load.
- */
-char *curfile;
-
-#define	CTF_BUF_CHUNK_SIZE	(64 * 1024)
-#define	RES_BUF_CHUNK_SIZE	(64 * 1024)
-
-struct ctf_buf {
-	strtab_t ctb_strtab;	/* string table */
-	caddr_t ctb_base;	/* pointer to base of buffer */
-	caddr_t ctb_end;	/* pointer to end of buffer */
-	caddr_t ctb_ptr;	/* pointer to empty buffer space */
-	size_t ctb_size;	/* size of buffer */
-	int nptent;		/* number of processed types */
-	int ntholes;		/* number of type holes */
-};
-
-/*PRINTFLIKE1*/
-static void
-parseterminate(char *fmt, ...)
-{
-	static char msgbuf[1024]; /* sigh */
-	va_list ap;
-
-	va_start(ap, fmt);
-	vsnprintf(msgbuf, sizeof (msgbuf), fmt, ap);
-	va_end(ap);
-
-	terminate("%s: %s\n", curfile, msgbuf);
-}
-
-void
-ctf_buf_grow(ctf_buf_t *b)
-{
-	off_t ptroff = b->ctb_ptr - b->ctb_base;
-
-	b->ctb_size += CTF_BUF_CHUNK_SIZE;
-	b->ctb_base = xrealloc(b->ctb_base, b->ctb_size);
-	b->ctb_end = b->ctb_base + b->ctb_size;
-	b->ctb_ptr = b->ctb_base + ptroff;
-}
-
-ctf_buf_t *
-ctf_buf_new(void)
-{
-	ctf_buf_t *b = xcalloc(sizeof (ctf_buf_t));
-
-	strtab_create(&b->ctb_strtab);
-	ctf_buf_grow(b);
-
-	return (b);
-}
-
-void
-ctf_buf_free(ctf_buf_t *b)
-{
-	strtab_destroy(&b->ctb_strtab);
-	free(b->ctb_base);
-	free(b);
-}
-
-uint_t
-ctf_buf_cur(ctf_buf_t *b)
-{
-	return (b->ctb_ptr - b->ctb_base);
-}
-
-void
-ctf_buf_write(ctf_buf_t *b, const void *p, size_t n)
-{
-	size_t len;
-
-	while (n != 0) {
-		if (b->ctb_ptr == b->ctb_end)
-			ctf_buf_grow(b);
-
-		len = MIN((size_t)(b->ctb_end - b->ctb_ptr), n);
-		bcopy(p, b->ctb_ptr, len);
-		b->ctb_ptr += len;
-
-		p = (char *)p + len;
-		n -= len;
-	}
-}
-
-static int
-write_label(labelent_t *le, ctf_buf_t *b)
-{
-	ctf_lblent_t ctl;
-
-	ctl.ctl_label = strtab_insert(&b->ctb_strtab, le->le_name);
-	ctl.ctl_typeidx = le->le_idx;
-
-	ctf_buf_write(b, &ctl, sizeof (ctl));
-
-	return (1);
-}
-
-static void
-write_objects(iidesc_t *idp, ctf_buf_t *b)
-{
-	ushort_t id = (idp ? idp->ii_dtype->t_id : 0);
-
-	ctf_buf_write(b, &id, sizeof (id));
-
-	debug(3, "Wrote object %s (%d)\n", (idp ? idp->ii_name : "(null)"), id);
-}
-
-static void
-write_functions(iidesc_t *idp, ctf_buf_t *b)
-{
-	ushort_t fdata[2];
-	ushort_t id;
-	int nargs;
-	int i;
-
-	if (!idp) {
-		fdata[0] = 0;
-		ctf_buf_write(b, &fdata[0], sizeof (fdata[0]));
-
-		debug(3, "Wrote function (null)\n");
-		return;
-	}
-
-	nargs = idp->ii_nargs + (idp->ii_vargs != 0);
-
-	if (nargs > CTF_MAX_VLEN) {
-		terminate("function %s has too many args: %d > %d\n",
-		    idp->ii_name, nargs, CTF_MAX_VLEN);
-	}
-
-	fdata[0] = CTF_TYPE_INFO(CTF_K_FUNCTION, 1, nargs);
-	fdata[1] = idp->ii_dtype->t_id;
-	ctf_buf_write(b, fdata, sizeof (fdata));
-
-	for (i = 0; i < idp->ii_nargs; i++) {
-		id = idp->ii_args[i]->t_id;
-		ctf_buf_write(b, &id, sizeof (id));
-	}
-
-	if (idp->ii_vargs) {
-		id = 0;
-		ctf_buf_write(b, &id, sizeof (id));
-	}
-
-	debug(3, "Wrote function %s (%d args)\n", idp->ii_name, nargs);
-}
-
-/*
- * Depending on the size of the type being described, either a ctf_stype_t (for
- * types with size < CTF_LSTRUCT_THRESH) or a ctf_type_t (all others) will be
- * written.  We isolate the determination here so the rest of the writer code
- * doesn't need to care.
- */
-static void
-write_sized_type_rec(ctf_buf_t *b, ctf_type_t *ctt, size_t size)
-{
-	if (size > CTF_MAX_SIZE) {
-		ctt->ctt_size = CTF_LSIZE_SENT;
-		ctt->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size);
-		ctt->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size);
-		ctf_buf_write(b, ctt, sizeof (*ctt));
-	} else {
-		ctf_stype_t *cts = (ctf_stype_t *)ctt;
-
-		cts->ctt_size = (ushort_t)size;
-		ctf_buf_write(b, cts, sizeof (*cts));
-	}
-}
-
-static void
-write_unsized_type_rec(ctf_buf_t *b, ctf_type_t *ctt)
-{
-	ctf_stype_t *cts = (ctf_stype_t *)ctt;
-
-	ctf_buf_write(b, cts, sizeof (*cts));
-}
-
-static int
-write_type(tdesc_t *tp, ctf_buf_t *b)
-{
-	elist_t *ep;
-	mlist_t *mp;
-	intr_t *ip;
-
-	size_t offset;
-	uint_t encoding;
-	uint_t data;
-	int isroot = tp->t_flags & TDESC_F_ISROOT;
-	int i;
-
-	ctf_type_t ctt;
-	ctf_array_t cta;
-	ctf_member_t ctm;
-	ctf_lmember_t ctlm;
-	ctf_enum_t cte;
-	ushort_t id;
-
-	ctlm.ctlm_pad = 0;
-
-	/*
-	 * There shouldn't be any holes in the type list (where a hole is
-	 * defined as two consecutive tdescs without consecutive ids), but
-	 * check for them just in case.  If we do find holes, we need to make
-	 * fake entries to fill the holes, or we won't be able to reconstruct
-	 * the tree from the written data.
-	 */
-	if (++b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) {
-		debug(2, "genctf: type hole from %d < x < %d\n",
-		    b->nptent - 1, CTF_TYPE_TO_INDEX(tp->t_id));
-
-		ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, 0);
-		ctt.ctt_info = CTF_TYPE_INFO(0, 0, 0);
-		while (b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) {
-			write_sized_type_rec(b, &ctt, 0);
-			b->nptent++;
-		}
-	}
-
-	offset = strtab_insert(&b->ctb_strtab, tp->t_name);
-	ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset);
-
-	switch (tp->t_type) {
-	case INTRINSIC:
-		ip = tp->t_intr;
-		if (ip->intr_type == INTR_INT)
-			ctt.ctt_info = CTF_TYPE_INFO(CTF_K_INTEGER,
-			    isroot, 1);
-		else
-			ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FLOAT, isroot, 1);
-		write_sized_type_rec(b, &ctt, tp->t_size);
-
-		encoding = 0;
-
-		if (ip->intr_type == INTR_INT) {
-			if (ip->intr_signed)
-				encoding |= CTF_INT_SIGNED;
-			if (ip->intr_iformat == 'c')
-				encoding |= CTF_INT_CHAR;
-			else if (ip->intr_iformat == 'b')
-				encoding |= CTF_INT_BOOL;
-			else if (ip->intr_iformat == 'v')
-				encoding |= CTF_INT_VARARGS;
-		} else
-			encoding = ip->intr_fformat;
-
-		data = CTF_INT_DATA(encoding, ip->intr_offset, ip->intr_nbits);
-		ctf_buf_write(b, &data, sizeof (data));
-		break;
-
-	case POINTER:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_POINTER, isroot, 0);
-		ctt.ctt_type = tp->t_tdesc->t_id;
-		write_unsized_type_rec(b, &ctt);
-		break;
-
-	case ARRAY:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ARRAY, isroot, 1);
-		write_sized_type_rec(b, &ctt, tp->t_size);
-
-		cta.cta_contents = tp->t_ardef->ad_contents->t_id;
-		cta.cta_index = tp->t_ardef->ad_idxtype->t_id;
-		cta.cta_nelems = tp->t_ardef->ad_nelems;
-		ctf_buf_write(b, &cta, sizeof (cta));
-		break;
-
-	case STRUCT:
-	case UNION:
-		for (i = 0, mp = tp->t_members; mp != NULL; mp = mp->ml_next)
-			i++; /* count up struct or union members */
-
-		if (i > CTF_MAX_VLEN) {
-			terminate("sou %s has too many members: %d > %d\n",
-			    tdesc_name(tp), i, CTF_MAX_VLEN);
-		}
-
-		if (tp->t_type == STRUCT)
-			ctt.ctt_info = CTF_TYPE_INFO(CTF_K_STRUCT, isroot, i);
-		else
-			ctt.ctt_info = CTF_TYPE_INFO(CTF_K_UNION, isroot, i);
-
-		write_sized_type_rec(b, &ctt, tp->t_size);
-
-		if (tp->t_size < CTF_LSTRUCT_THRESH) {
-			for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) {
-				offset = strtab_insert(&b->ctb_strtab,
-				    mp->ml_name);
-
-				ctm.ctm_name = CTF_TYPE_NAME(CTF_STRTAB_0,
-				    offset);
-				ctm.ctm_type = mp->ml_type->t_id;
-				ctm.ctm_offset = mp->ml_offset;
-				ctf_buf_write(b, &ctm, sizeof (ctm));
-			}
-		} else {
-			for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) {
-				offset = strtab_insert(&b->ctb_strtab,
-				    mp->ml_name);
-
-				ctlm.ctlm_name = CTF_TYPE_NAME(CTF_STRTAB_0,
-				    offset);
-				ctlm.ctlm_type = mp->ml_type->t_id;
-				ctlm.ctlm_offsethi =
-				    CTF_OFFSET_TO_LMEMHI(mp->ml_offset);
-				ctlm.ctlm_offsetlo =
-				    CTF_OFFSET_TO_LMEMLO(mp->ml_offset);
-				ctf_buf_write(b, &ctlm, sizeof (ctlm));
-			}
-		}
-		break;
-
-	case ENUM:
-		for (i = 0, ep = tp->t_emem; ep != NULL; ep = ep->el_next)
-			i++; /* count up enum members */
-
-		if (i > CTF_MAX_VLEN) {
-			terminate("enum %s has too many values: %d > %d\n",
-			    tdesc_name(tp), i, CTF_MAX_VLEN);
-		}
-
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ENUM, isroot, i);
-		write_sized_type_rec(b, &ctt, tp->t_size);
-
-		for (ep = tp->t_emem; ep != NULL; ep = ep->el_next) {
-			offset = strtab_insert(&b->ctb_strtab, ep->el_name);
-			cte.cte_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset);
-			cte.cte_value = ep->el_number;
-			ctf_buf_write(b, &cte, sizeof (cte));
-		}
-		break;
-
-	case FORWARD:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FORWARD, isroot, 0);
-		ctt.ctt_type = 0;
-		write_unsized_type_rec(b, &ctt);
-		break;
-
-	case TYPEDEF:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_TYPEDEF, isroot, 0);
-		ctt.ctt_type = tp->t_tdesc->t_id;
-		write_unsized_type_rec(b, &ctt);
-		break;
-
-	case VOLATILE:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_VOLATILE, isroot, 0);
-		ctt.ctt_type = tp->t_tdesc->t_id;
-		write_unsized_type_rec(b, &ctt);
-		break;
-
-	case CONST:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_CONST, isroot, 0);
-		ctt.ctt_type = tp->t_tdesc->t_id;
-		write_unsized_type_rec(b, &ctt);
-		break;
-
-	case FUNCTION:
-		i = tp->t_fndef->fn_nargs + tp->t_fndef->fn_vargs;
-
-		if (i > CTF_MAX_VLEN) {
-			terminate("function %s has too many args: %d > %d\n",
-			    i, CTF_MAX_VLEN);
-		}
-
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FUNCTION, isroot, i);
-		ctt.ctt_type = tp->t_fndef->fn_ret->t_id;
-		write_unsized_type_rec(b, &ctt);
-
-		for (i = 0; i < tp->t_fndef->fn_nargs; i++) {
-			id = tp->t_fndef->fn_args[i]->t_id;
-			ctf_buf_write(b, &id, sizeof (id));
-		}
-
-		if (tp->t_fndef->fn_vargs) {
-			id = 0;
-			ctf_buf_write(b, &id, sizeof (id));
-			i++;
-		}
-
-		if (i & 1) {
-			id = 0;
-			ctf_buf_write(b, &id, sizeof (id));
-		}
-		break;
-
-	case RESTRICT:
-		ctt.ctt_info = CTF_TYPE_INFO(CTF_K_RESTRICT, isroot, 0);
-		ctt.ctt_type = tp->t_tdesc->t_id;
-		write_unsized_type_rec(b, &ctt);
-		break;
-
-	default:
-		warning("Can't write unknown type %d\n", tp->t_type);
-	}
-
-	debug(3, "Wrote type %d %s\n", tp->t_id, tdesc_name(tp));
-
-	return (1);
-}
-
-typedef struct resbuf {
-	caddr_t rb_base;
-	caddr_t rb_ptr;
-	size_t rb_size;
-	z_stream rb_zstr;
-} resbuf_t;
-
-static void
-rbzs_grow(resbuf_t *rb)
-{
-	off_t ptroff = (caddr_t)rb->rb_zstr.next_out - rb->rb_base;
-
-	rb->rb_size += RES_BUF_CHUNK_SIZE;
-	rb->rb_base = xrealloc(rb->rb_base, rb->rb_size);
-	rb->rb_ptr = rb->rb_base + ptroff;
-	rb->rb_zstr.next_out = (Bytef *)(rb->rb_ptr);
-	rb->rb_zstr.avail_out += RES_BUF_CHUNK_SIZE;
-}
-
-static void
-compress_start(resbuf_t *rb)
-{
-	int rc;
-
-	rb->rb_zstr.zalloc = (alloc_func)0;
-	rb->rb_zstr.zfree = (free_func)0;
-	rb->rb_zstr.opaque = (voidpf)0;
-
-	if ((rc = deflateInit(&rb->rb_zstr, Z_BEST_COMPRESSION)) != Z_OK)
-		parseterminate("zlib start failed: %s", zError(rc));
-}
-
-static ssize_t
-compress_buffer(const void *buf, size_t n, void *data)
-{
-	resbuf_t *rb = (resbuf_t *)data;
-	int rc;
-
-	rb->rb_zstr.next_out = (Bytef *)rb->rb_ptr;
-	rb->rb_zstr.avail_out = rb->rb_size - (rb->rb_ptr - rb->rb_base);
-	rb->rb_zstr.next_in = (Bytef *)buf;
-	rb->rb_zstr.avail_in = n;
-
-	while (rb->rb_zstr.avail_in) {
-		if (rb->rb_zstr.avail_out == 0)
-			rbzs_grow(rb);
-
-		if ((rc = deflate(&rb->rb_zstr, Z_NO_FLUSH)) != Z_OK)
-			parseterminate("zlib deflate failed: %s", zError(rc));
-	}
-	rb->rb_ptr = (caddr_t)rb->rb_zstr.next_out;
-
-	return (n);
-}
-
-static void
-compress_flush(resbuf_t *rb, int type)
-{
-	int rc;
-
-	for (;;) {
-		if (rb->rb_zstr.avail_out == 0)
-			rbzs_grow(rb);
-
-		rc = deflate(&rb->rb_zstr, type);
-		if ((type == Z_FULL_FLUSH && rc == Z_BUF_ERROR) ||
-		    (type == Z_FINISH && rc == Z_STREAM_END))
-			break;
-		else if (rc != Z_OK)
-			parseterminate("zlib finish failed: %s", zError(rc));
-	}
-	rb->rb_ptr = (caddr_t)rb->rb_zstr.next_out;
-}
-
-static void
-compress_end(resbuf_t *rb)
-{
-	int rc;
-
-	compress_flush(rb, Z_FINISH);
-
-	if ((rc = deflateEnd(&rb->rb_zstr)) != Z_OK)
-		parseterminate("zlib end failed: %s", zError(rc));
-}
-
-/*
- * Pad the buffer to a power-of-2 boundary
- */
-static void
-pad_buffer(ctf_buf_t *buf, int align)
-{
-	uint_t cur = ctf_buf_cur(buf);
-	ssize_t topad = (align - (cur % align)) % align;
-	static const char pad[8] = { 0 };
-
-	while (topad > 0) {
-		ctf_buf_write(buf, pad, (topad > 8 ? 8 : topad));
-		topad -= 8;
-	}
-}
-
-static ssize_t
-bcopy_data(const void *buf, size_t n, void *data)
-{
-	caddr_t *posp = (caddr_t *)data;
-	bcopy(buf, *posp, n);
-	*posp += n;
-	return (n);
-}
-
-static caddr_t
-write_buffer(ctf_header_t *h, ctf_buf_t *buf, size_t *resszp)
-{
-	caddr_t outbuf;
-	caddr_t bufpos;
-
-	outbuf = xmalloc(sizeof (ctf_header_t) + (buf->ctb_ptr - buf->ctb_base)
-	    + buf->ctb_strtab.str_size);
-
-	bufpos = outbuf;
-	(void) bcopy_data(h, sizeof (ctf_header_t), &bufpos);
-	(void) bcopy_data(buf->ctb_base, buf->ctb_ptr - buf->ctb_base,
-	    &bufpos);
-	(void) strtab_write(&buf->ctb_strtab, bcopy_data, &bufpos);
-	*resszp = bufpos - outbuf;
-	return (outbuf);
-}
-
-/*
- * Create the compression buffer, and fill it with the CTF and string
- * table data.  We flush the compression state between the two so the
- * dictionary used for the string tables won't be polluted with values
- * that made sense for the CTF data.
- */
-static caddr_t
-write_compressed_buffer(ctf_header_t *h, ctf_buf_t *buf, size_t *resszp)
-{
-	resbuf_t resbuf;
-	resbuf.rb_size = RES_BUF_CHUNK_SIZE;
-	resbuf.rb_base = xmalloc(resbuf.rb_size);
-	bcopy(h, resbuf.rb_base, sizeof (ctf_header_t));
-	resbuf.rb_ptr = resbuf.rb_base + sizeof (ctf_header_t);
-
-	compress_start(&resbuf);
-	(void) compress_buffer(buf->ctb_base, buf->ctb_ptr - buf->ctb_base,
-	    &resbuf);
-	compress_flush(&resbuf, Z_FULL_FLUSH);
-	(void) strtab_write(&buf->ctb_strtab, compress_buffer, &resbuf);
-	compress_end(&resbuf);
-
-	*resszp = (resbuf.rb_ptr - resbuf.rb_base);
-	return (resbuf.rb_base);
-}
-
-caddr_t
-ctf_gen(iiburst_t *iiburst, size_t *resszp, int do_compress)
-{
-	ctf_buf_t *buf = ctf_buf_new();
-	ctf_header_t h;
-	caddr_t outbuf;
-
-	int i;
-
-	/*
-	 * Prepare the header, and create the CTF output buffers.  The data
-	 * object section and function section are both lists of 2-byte
-	 * integers; we pad these out to the next 4-byte boundary if needed.
-	 */
-	h.cth_magic = CTF_MAGIC;
-	h.cth_version = CTF_VERSION;
-	h.cth_flags = do_compress ? CTF_F_COMPRESS : 0;
-	h.cth_parlabel = strtab_insert(&buf->ctb_strtab,
-	    iiburst->iib_td->td_parlabel);
-	h.cth_parname = strtab_insert(&buf->ctb_strtab,
-	    iiburst->iib_td->td_parname);
-
-	h.cth_lbloff = 0;
-	(void) list_iter(iiburst->iib_td->td_labels, (int (*)())write_label,
-	    buf);
-
-	pad_buffer(buf, 2);
-	h.cth_objtoff = ctf_buf_cur(buf);
-	for (i = 0; i < iiburst->iib_nobjts; i++)
-		write_objects(iiburst->iib_objts[i], buf);
-
-	pad_buffer(buf, 2);
-	h.cth_funcoff = ctf_buf_cur(buf);
-	for (i = 0; i < iiburst->iib_nfuncs; i++)
-		write_functions(iiburst->iib_funcs[i], buf);
-
-	pad_buffer(buf, 4);
-	h.cth_typeoff = ctf_buf_cur(buf);
-	(void) list_iter(iiburst->iib_types, (int (*)())write_type, buf);
-
-	debug(2, "CTF wrote %d types\n", list_count(iiburst->iib_types));
-
-	h.cth_stroff = ctf_buf_cur(buf);
-	h.cth_strlen = strtab_size(&buf->ctb_strtab);
-
-	/*
-	 * We only do compression for ctfmerge, as ctfconvert is only
-	 * supposed to be used on intermediary build objects. This is
-	 * significantly faster.
-	 */
-	if (do_compress)
-		outbuf = write_compressed_buffer(&h, buf, resszp);
-	else
-		outbuf = write_buffer(&h, buf, resszp);
-
-	ctf_buf_free(buf);
-	return (outbuf);
-}
-
-void
-get_ctt_size(ctf_type_t *ctt, size_t *sizep, size_t *incrementp)
-{
-	if (ctt->ctt_size == CTF_LSIZE_SENT) {
-		*sizep = (size_t)CTF_TYPE_LSIZE(ctt);
-		*incrementp = sizeof (ctf_type_t);
-	} else {
-		*sizep = ctt->ctt_size;
-		*incrementp = sizeof (ctf_stype_t);
-	}
-}
-
-static int
-count_types(ctf_header_t *h, caddr_t data)
-{
-	caddr_t dptr = data + h->cth_typeoff;
-	int count = 0;
-
-	dptr = data + h->cth_typeoff;
-	while (dptr < data + h->cth_stroff) {
-		/* LINTED - pointer alignment */
-		ctf_type_t *ctt = (ctf_type_t *)dptr;
-		size_t vlen = CTF_INFO_VLEN(ctt->ctt_info);
-		size_t size, increment;
-
-		get_ctt_size(ctt, &size, &increment);
-
-		switch (CTF_INFO_KIND(ctt->ctt_info)) {
-		case CTF_K_INTEGER:
-		case CTF_K_FLOAT:
-			dptr += 4;
-			break;
-		case CTF_K_POINTER:
-		case CTF_K_FORWARD:
-		case CTF_K_TYPEDEF:
-		case CTF_K_VOLATILE:
-		case CTF_K_CONST:
-		case CTF_K_RESTRICT:
-		case CTF_K_FUNCTION:
-			dptr += sizeof (ushort_t) * (vlen + (vlen & 1));
-			break;
-		case CTF_K_ARRAY:
-			dptr += sizeof (ctf_array_t);
-			break;
-		case CTF_K_STRUCT:
-		case CTF_K_UNION:
-			if (size < CTF_LSTRUCT_THRESH)
-				dptr += sizeof (ctf_member_t) * vlen;
-			else
-				dptr += sizeof (ctf_lmember_t) * vlen;
-			break;
-		case CTF_K_ENUM:
-			dptr += sizeof (ctf_enum_t) * vlen;
-			break;
-		case CTF_K_UNKNOWN:
-			break;
-		default:
-			parseterminate("Unknown CTF type %d (#%d) at %#x",
-			    CTF_INFO_KIND(ctt->ctt_info), count, dptr - data);
-		}
-
-		dptr += increment;
-		count++;
-	}
-
-	debug(3, "CTF read %d types\n", count);
-
-	return (count);
-}
-
-/*
- * Resurrect the labels stored in the CTF data, returning the index associated
- * with a label provided by the caller.  There are several cases, outlined
- * below.  Note that, given two labels, the one associated with the lesser type
- * index is considered to be older than the other.
- *
- *  1. matchlbl == NULL - return the index of the most recent label.
- *  2. matchlbl == "BASE" - return the index of the oldest label.
- *  3. matchlbl != NULL, but doesn't match any labels in the section - warn
- *	the user, and proceed as if matchlbl == "BASE" (for safety).
- *  4. matchlbl != NULL, and matches one of the labels in the section - return
- *	the type index associated with the label.
- */
-static int
-resurrect_labels(ctf_header_t *h, tdata_t *td, caddr_t ctfdata, char *matchlbl)
-{
-	caddr_t buf = ctfdata + h->cth_lbloff;
-	caddr_t sbuf = ctfdata + h->cth_stroff;
-	size_t bufsz = h->cth_objtoff - h->cth_lbloff;
-	int lastidx = 0, baseidx = -1;
-	char *baselabel;
-	ctf_lblent_t *ctl;
-
-	/* LINTED - pointer alignment */
-	for (ctl = (ctf_lblent_t *)buf; (caddr_t)ctl < buf + bufsz; ctl++) {
-		char *label = sbuf + ctl->ctl_label;
-
-		lastidx = ctl->ctl_typeidx;
-
-		debug(3, "Resurrected label %s type idx %d\n", label, lastidx);
-
-		tdata_label_add(td, label, lastidx);
-
-		if (baseidx == -1) {
-			baseidx = lastidx;
-			baselabel = label;
-			if (matchlbl != NULL && streq(matchlbl, "BASE"))
-				return (lastidx);
-		}
-
-		if (matchlbl != NULL && streq(label, matchlbl))
-			return (lastidx);
-	}
-
-	if (matchlbl != NULL) {
-		/* User provided a label that didn't match */
-		warning("%s: Cannot find label `%s' - using base (%s)\n",
-		    curfile, matchlbl, (baselabel ? baselabel : "NONE"));
-
-		tdata_label_free(td);
-		tdata_label_add(td, baselabel, baseidx);
-
-		return (baseidx);
-	}
-
-	return (lastidx);
-}
-
-static void
-resurrect_objects(ctf_header_t *h, tdata_t *td, tdesc_t **tdarr, int tdsize,
-    caddr_t ctfdata, symit_data_t *si)
-{
-	caddr_t buf = ctfdata + h->cth_objtoff;
-	size_t bufsz = h->cth_funcoff - h->cth_objtoff;
-	caddr_t dptr;
-
-	symit_reset(si);
-	for (dptr = buf; dptr < buf + bufsz; dptr += 2) {
-		/* LINTED - pointer alignment */
-		ushort_t id = *((ushort_t *)dptr);
-		iidesc_t *ii;
-		GElf_Sym *sym;
-
-		if (!(sym = symit_next(si, STT_OBJECT)) && id != 0) {
-			parseterminate(
-			    "Unexpected end of object symbols at %x of %x",
-			    dptr - buf, bufsz);
-		}
-
-		if (id == 0) {
-			debug(3, "Skipping null object\n");
-			continue;
-		} else if (id >= tdsize) {
-			parseterminate("Reference to invalid type %d", id);
-		}
-
-		ii = iidesc_new(symit_name(si));
-		ii->ii_dtype = tdarr[id];
-		if (GELF_ST_BIND(sym->st_info) == STB_LOCAL) {
-			ii->ii_type = II_SVAR;
-			ii->ii_owner = xstrdup(symit_curfile(si));
-		} else
-			ii->ii_type = II_GVAR;
-		hash_add(td->td_iihash, ii);
-
-		debug(3, "Resurrected %s object %s (%d) from %s\n",
-		    (ii->ii_type == II_GVAR ? "global" : "static"),
-		    ii->ii_name, id, (ii->ii_owner ? ii->ii_owner : "(none)"));
-	}
-}
-
-static void
-resurrect_functions(ctf_header_t *h, tdata_t *td, tdesc_t **tdarr, int tdsize,
-    caddr_t ctfdata, symit_data_t *si)
-{
-	caddr_t buf = ctfdata + h->cth_funcoff;
-	size_t bufsz = h->cth_typeoff - h->cth_funcoff;
-	caddr_t dptr = buf;
-	iidesc_t *ii;
-	ushort_t info;
-	ushort_t retid;
-	GElf_Sym *sym;
-	int i;
-
-	symit_reset(si);
-	while (dptr < buf + bufsz) {
-		/* LINTED - pointer alignment */
-		info = *((ushort_t *)dptr);
-		dptr += 2;
-
-		if (!(sym = symit_next(si, STT_FUNC)) && info != 0)
-			parseterminate("Unexpected end of function symbols");
-
-		if (info == 0) {
-			debug(3, "Skipping null function (%s)\n",
-			    symit_name(si));
-			continue;
-		}
-
-		/* LINTED - pointer alignment */
-		retid = *((ushort_t *)dptr);
-		dptr += 2;
-
-		if (retid >= tdsize)
-			parseterminate("Reference to invalid type %d", retid);
-
-		ii = iidesc_new(symit_name(si));
-		ii->ii_dtype = tdarr[retid];
-		if (GELF_ST_BIND(sym->st_info) == STB_LOCAL) {
-			ii->ii_type = II_SFUN;
-			ii->ii_owner = xstrdup(symit_curfile(si));
-		} else
-			ii->ii_type = II_GFUN;
-		ii->ii_nargs = CTF_INFO_VLEN(info);
-		if (ii->ii_nargs)
-			ii->ii_args =
-			    xmalloc(sizeof (tdesc_t *) * ii->ii_nargs);
-
-		for (i = 0; i < ii->ii_nargs; i++, dptr += 2) {
-			/* LINTED - pointer alignment */
-			ushort_t id = *((ushort_t *)dptr);
-			if (id >= tdsize)
-				parseterminate("Reference to invalid type %d",
-				    id);
-			ii->ii_args[i] = tdarr[id];
-		}
-
-		if (ii->ii_nargs && ii->ii_args[ii->ii_nargs - 1] == NULL) {
-			ii->ii_nargs--;
-			ii->ii_vargs = 1;
-		}
-
-		hash_add(td->td_iihash, ii);
-
-		debug(3, "Resurrected %s function %s (%d, %d args)\n",
-		    (ii->ii_type == II_GFUN ? "global" : "static"),
-		    ii->ii_name, retid, ii->ii_nargs);
-	}
-}
-
-static void
-resurrect_types(ctf_header_t *h, tdata_t *td, tdesc_t **tdarr, int tdsize,
-    caddr_t ctfdata, int maxid)
-{
-	caddr_t buf = ctfdata + h->cth_typeoff;
-	size_t bufsz = h->cth_stroff - h->cth_typeoff;
-	caddr_t sbuf = ctfdata + h->cth_stroff;
-	caddr_t dptr = buf;
-	tdesc_t *tdp;
-	uint_t data;
-	uint_t encoding;
-	size_t size, increment;
-	int tcnt;
-	int iicnt = 0;
-	tid_t tid, argid;
-	int kind, vlen;
-	int i;
-
-	elist_t **epp;
-	mlist_t **mpp;
-	intr_t *ip;
-
-	ctf_type_t *ctt;
-	ctf_array_t *cta;
-	ctf_enum_t *cte;
-
-	/*
-	 * A maxid of zero indicates a request to resurrect all types, so reset
-	 * maxid to the maximum type id.
-	 */
-	if (maxid == 0)
-		maxid = CTF_MAX_TYPE;
-
-	for (dptr = buf, tcnt = 0, tid = 1; dptr < buf + bufsz; tcnt++, tid++) {
-		if (tid > maxid)
-			break;
-
-		if (tid >= tdsize)
-			parseterminate("Reference to invalid type %d", tid);
-
-		/* LINTED - pointer alignment */
-		ctt = (ctf_type_t *)dptr;
-
-		get_ctt_size(ctt, &size, &increment);
-		dptr += increment;
-
-		tdp = tdarr[tid];
-
-		if (CTF_NAME_STID(ctt->ctt_name) != CTF_STRTAB_0)
-			parseterminate(
-			    "Unable to cope with non-zero strtab id");
-		if (CTF_NAME_OFFSET(ctt->ctt_name) != 0) {
-			tdp->t_name =
-			    xstrdup(sbuf + CTF_NAME_OFFSET(ctt->ctt_name));
-		} else
-			tdp->t_name = NULL;
-
-		kind = CTF_INFO_KIND(ctt->ctt_info);
-		vlen = CTF_INFO_VLEN(ctt->ctt_info);
-
-		switch (kind) {
-		case CTF_K_INTEGER:
-			tdp->t_type = INTRINSIC;
-			tdp->t_size = size;
-
-			/* LINTED - pointer alignment */
-			data = *((uint_t *)dptr);
-			dptr += sizeof (uint_t);
-			encoding = CTF_INT_ENCODING(data);
-
-			ip = xmalloc(sizeof (intr_t));
-			ip->intr_type = INTR_INT;
-			ip->intr_signed = (encoding & CTF_INT_SIGNED) ? 1 : 0;
-
-			if (encoding & CTF_INT_CHAR)
-				ip->intr_iformat = 'c';
-			else if (encoding & CTF_INT_BOOL)
-				ip->intr_iformat = 'b';
-			else if (encoding & CTF_INT_VARARGS)
-				ip->intr_iformat = 'v';
-			else
-				ip->intr_iformat = '\0';
-
-			ip->intr_offset = CTF_INT_OFFSET(data);
-			ip->intr_nbits = CTF_INT_BITS(data);
-			tdp->t_intr = ip;
-			break;
-
-		case CTF_K_FLOAT:
-			tdp->t_type = INTRINSIC;
-			tdp->t_size = size;
-
-			/* LINTED - pointer alignment */
-			data = *((uint_t *)dptr);
-			dptr += sizeof (uint_t);
-
-			ip = xcalloc(sizeof (intr_t));
-			ip->intr_type = INTR_REAL;
-			ip->intr_fformat = CTF_FP_ENCODING(data);
-			ip->intr_offset = CTF_FP_OFFSET(data);
-			ip->intr_nbits = CTF_FP_BITS(data);
-			tdp->t_intr = ip;
-			break;
-
-		case CTF_K_POINTER:
-			tdp->t_type = POINTER;
-			tdp->t_tdesc = tdarr[ctt->ctt_type];
-			break;
-
-		case CTF_K_ARRAY:
-			tdp->t_type = ARRAY;
-			tdp->t_size = size;
-
-			/* LINTED - pointer alignment */
-			cta = (ctf_array_t *)dptr;
-			dptr += sizeof (ctf_array_t);
-
-			tdp->t_ardef = xmalloc(sizeof (ardef_t));
-			tdp->t_ardef->ad_contents = tdarr[cta->cta_contents];
-			tdp->t_ardef->ad_idxtype = tdarr[cta->cta_index];
-			tdp->t_ardef->ad_nelems = cta->cta_nelems;
-			break;
-
-		case CTF_K_STRUCT:
-		case CTF_K_UNION:
-			tdp->t_type = (kind == CTF_K_STRUCT ? STRUCT : UNION);
-			tdp->t_size = size;
-
-			if (size < CTF_LSTRUCT_THRESH) {
-				for (i = 0, mpp = &tdp->t_members; i < vlen;
-				    i++, mpp = &((*mpp)->ml_next)) {
-					/* LINTED - pointer alignment */
-					ctf_member_t *ctm = (ctf_member_t *)
-					    dptr;
-					dptr += sizeof (ctf_member_t);
-
-					*mpp = xmalloc(sizeof (mlist_t));
-					(*mpp)->ml_name = xstrdup(sbuf +
-					    ctm->ctm_name);
-					(*mpp)->ml_type = tdarr[ctm->ctm_type];
-					(*mpp)->ml_offset = ctm->ctm_offset;
-					(*mpp)->ml_size = 0;
-				}
-			} else {
-				for (i = 0, mpp = &tdp->t_members; i < vlen;
-				    i++, mpp = &((*mpp)->ml_next)) {
-					/* LINTED - pointer alignment */
-					ctf_lmember_t *ctlm = (ctf_lmember_t *)
-					    dptr;
-					dptr += sizeof (ctf_lmember_t);
-
-					*mpp = xmalloc(sizeof (mlist_t));
-					(*mpp)->ml_name = xstrdup(sbuf +
-					    ctlm->ctlm_name);
-					(*mpp)->ml_type =
-					    tdarr[ctlm->ctlm_type];
-					(*mpp)->ml_offset =
-					    (int)CTF_LMEM_OFFSET(ctlm);
-					(*mpp)->ml_size = 0;
-				}
-			}
-
-			*mpp = NULL;
-			break;
-
-		case CTF_K_ENUM:
-			tdp->t_type = ENUM;
-			tdp->t_size = size;
-
-			for (i = 0, epp = &tdp->t_emem; i < vlen;
-			    i++, epp = &((*epp)->el_next)) {
-				/* LINTED - pointer alignment */
-				cte = (ctf_enum_t *)dptr;
-				dptr += sizeof (ctf_enum_t);
-
-				*epp = xmalloc(sizeof (elist_t));
-				(*epp)->el_name = xstrdup(sbuf + cte->cte_name);
-				(*epp)->el_number = cte->cte_value;
-			}
-			*epp = NULL;
-			break;
-
-		case CTF_K_FORWARD:
-			tdp->t_type = FORWARD;
-			list_add(&td->td_fwdlist, tdp);
-			break;
-
-		case CTF_K_TYPEDEF:
-			tdp->t_type = TYPEDEF;
-			tdp->t_tdesc = tdarr[ctt->ctt_type];
-			break;
-
-		case CTF_K_VOLATILE:
-			tdp->t_type = VOLATILE;
-			tdp->t_tdesc = tdarr[ctt->ctt_type];
-			break;
-
-		case CTF_K_CONST:
-			tdp->t_type = CONST;
-			tdp->t_tdesc = tdarr[ctt->ctt_type];
-			break;
-
-		case CTF_K_FUNCTION:
-			tdp->t_type = FUNCTION;
-			tdp->t_fndef = xcalloc(sizeof (fndef_t));
-			tdp->t_fndef->fn_ret = tdarr[ctt->ctt_type];
-
-			/* LINTED - pointer alignment */
-			if (vlen > 0 && *(ushort_t *)(dptr +
-			    (sizeof (ushort_t) * (vlen - 1))) == 0)
-				tdp->t_fndef->fn_vargs = 1;
-
-			tdp->t_fndef->fn_nargs = vlen - tdp->t_fndef->fn_vargs;
-			tdp->t_fndef->fn_args = xcalloc(sizeof (tdesc_t) *
-			    vlen - tdp->t_fndef->fn_vargs);
-
-			for (i = 0; i < vlen; i++) {
-				/* LINTED - pointer alignment */
-				argid = *(ushort_t *)dptr;
-				dptr += sizeof (ushort_t);
-
-				if (argid != 0)
-					tdp->t_fndef->fn_args[i] = tdarr[argid];
-			}
-
-			if (vlen & 1)
-				dptr += sizeof (ushort_t);
-			break;
-
-		case CTF_K_RESTRICT:
-			tdp->t_type = RESTRICT;
-			tdp->t_tdesc = tdarr[ctt->ctt_type];
-			break;
-
-		case CTF_K_UNKNOWN:
-			break;
-
-		default:
-			warning("Can't parse unknown CTF type %d\n", kind);
-		}
-
-		if (CTF_INFO_ISROOT(ctt->ctt_info)) {
-			iidesc_t *ii = iidesc_new(tdp->t_name);
-			if (tdp->t_type == STRUCT || tdp->t_type == UNION ||
-			    tdp->t_type == ENUM)
-				ii->ii_type = II_SOU;
-			else
-				ii->ii_type = II_TYPE;
-			ii->ii_dtype = tdp;
-			hash_add(td->td_iihash, ii);
-
-			iicnt++;
-		}
-
-		debug(3, "Resurrected %d %stype %s (%d)\n", tdp->t_type,
-		    (CTF_INFO_ISROOT(ctt->ctt_info) ? "root " : ""),
-		    tdesc_name(tdp), tdp->t_id);
-	}
-
-	debug(3, "Resurrected %d types (%d were roots)\n", tcnt, iicnt);
-}
-
-/*
- * For lack of other inspiration, we're going to take the boring route.  We
- * count the number of types.  This lets us malloc that many tdesc structs
- * before we start filling them in.  This has the advantage of allowing us to
- * avoid a merge-esque remap step.
- */
-static tdata_t *
-ctf_parse(ctf_header_t *h, caddr_t buf, symit_data_t *si, char *label)
-{
-	tdata_t *td = tdata_new();
-	tdesc_t **tdarr;
-	int ntypes = count_types(h, buf);
-	int idx, i;
-
-	/* shudder */
-	tdarr = xcalloc(sizeof (tdesc_t *) * (ntypes + 1));
-	tdarr[0] = NULL;
-	for (i = 1; i <= ntypes; i++) {
-		tdarr[i] = xcalloc(sizeof (tdesc_t));
-		tdarr[i]->t_id = i;
-	}
-
-	td->td_parlabel = xstrdup(buf + h->cth_stroff + h->cth_parlabel);
-
-	/* we have the technology - we can rebuild them */
-	idx = resurrect_labels(h, td, buf, label);
-
-	resurrect_objects(h, td, tdarr, ntypes + 1, buf, si);
-	resurrect_functions(h, td, tdarr, ntypes + 1, buf, si);
-	resurrect_types(h, td, tdarr, ntypes + 1, buf, idx);
-
-	free(tdarr);
-
-	td->td_nextid = ntypes + 1;
-
-	return (td);
-}
-
-static size_t
-decompress_ctf(caddr_t cbuf, size_t cbufsz, caddr_t dbuf, size_t dbufsz)
-{
-	z_stream zstr;
-	int rc;
-
-	zstr.zalloc = (alloc_func)0;
-	zstr.zfree = (free_func)0;
-	zstr.opaque = (voidpf)0;
-
-	zstr.next_in = (Bytef *)cbuf;
-	zstr.avail_in = cbufsz;
-	zstr.next_out = (Bytef *)dbuf;
-	zstr.avail_out = dbufsz;
-
-	if ((rc = inflateInit(&zstr)) != Z_OK ||
-	    (rc = inflate(&zstr, Z_NO_FLUSH)) != Z_STREAM_END ||
-	    (rc = inflateEnd(&zstr)) != Z_OK) {
-		warning("CTF decompress zlib error %s\n", zError(rc));
-		return (0);
-	}
-
-	debug(3, "reflated %lu bytes to %lu, pointer at %d\n",
-	    zstr.total_in, zstr.total_out, (caddr_t)zstr.next_in - cbuf);
-
-	return (zstr.total_out);
-}
-
-/*
- * Reconstruct the type tree from a given buffer of CTF data.  Only the types
- * up to the type associated with the provided label, inclusive, will be
- * reconstructed.  If a NULL label is provided, all types will be reconstructed.
- *
- * This function won't work on files that have been uniquified.
- */
-tdata_t *
-ctf_load(char *file, caddr_t buf, size_t bufsz, symit_data_t *si, char *label)
-{
-	ctf_header_t *h;
-	caddr_t ctfdata;
-	size_t ctfdatasz;
-	tdata_t *td;
-
-	curfile = file;
-
-	if (bufsz < sizeof (ctf_header_t))
-		parseterminate("Corrupt CTF - short header");
-
-	/* LINTED - pointer alignment */
-	h = (ctf_header_t *)buf;
-	buf += sizeof (ctf_header_t);
-	bufsz -= sizeof (ctf_header_t);
-
-	if (h->cth_magic != CTF_MAGIC)
-		parseterminate("Corrupt CTF - bad magic 0x%x", h->cth_magic);
-
-	if (h->cth_version != CTF_VERSION)
-		parseterminate("Unknown CTF version %d", h->cth_version);
-
-	ctfdatasz = h->cth_stroff + h->cth_strlen;
-	if (h->cth_flags & CTF_F_COMPRESS) {
-		size_t actual;
-
-		ctfdata = xmalloc(ctfdatasz);
-		if ((actual = decompress_ctf(buf, bufsz, ctfdata, ctfdatasz)) !=
-		    ctfdatasz) {
-			parseterminate("Corrupt CTF - short decompression "
-			    "(was %d, expecting %d)", actual, ctfdatasz);
-		}
-	} else {
-		ctfdata = buf;
-		ctfdatasz = bufsz;
-	}
-
-	td = ctf_parse(h, ctfdata, si, label);
-
-	if (h->cth_flags & CTF_F_COMPRESS)
-		free(ctfdata);
-
-	curfile = NULL;
-
-	return (td);
-}
