ctf/cvt/ctf.c

	ctf.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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"

/*
 * 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);
    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 (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 */

        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:
        ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FUNCTION, isroot,
            tp->t_fndef->fn_nargs + tp->t_fndef->fn_vargs);
        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,
        (tp->t_name ? tp->t_name : "(anon)"));

    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 void
compress_buffer(caddr_t buf, size_t n, resbuf_t *rb)
{
    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;
}

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 void
bcopy_data(void *buf, size_t n, caddr_t *posp)
{
    bcopy(buf, *posp, n);
    *posp += 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;
    bcopy_data(h, sizeof (ctf_header_t), &bufpos);
    bcopy_data(buf->ctb_base, buf->ctb_ptr - buf->ctb_base,
        &bufpos);
    if (strtab_write(&buf->ctb_strtab, (ssize_t (*)())bcopy_data,
        &bufpos) < 0)
        terminate("strtab_write failed\n");
    *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);
    compress_buffer(buf->ctb_base, buf->ctb_ptr - buf->ctb_base, &resbuf);
    compress_flush(&resbuf, Z_FULL_FLUSH);
    if (strtab_write(&buf->ctb_strtab, (ssize_t (*)())compress_buffer,
        &resbuf) < 0)
        terminate("strtab_write failed\n");
    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 " : ""),
            (tdp->t_name ? tdp->t_name : "(anon)"), 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 (NULL);
    }

    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);
}