path: root/usr.bin/ctfconv/parse.c

/*	$OpenBSD: parse.c,v 1.10 2017/10/31 10:08:51 mpi Exp $ */

/*
 * Copyright (c) 2016-2017 Martin Pieuchot
 * Copyright (c) 2016 Jasper Lievisse Adriaanse <jasper@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * DWARF to IT (internal type) representation parser.
 */

#include <sys/queue.h>
#include <sys/tree.h>
#include <sys/types.h>
#include <sys/ctf.h>

#include <assert.h>
#include <limits.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>

#include "itype.h"
#include "xmalloc.h"
#include "dwarf.h"
#include "dw.h"
#include "pool.h"

#ifdef DEBUG
#include <stdio.h>
#endif

#ifndef NOPOOL
struct pool it_pool, im_pool, ir_pool;
#endif /* NOPOOL */

#ifndef nitems
#define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
#endif

#define DPRINTF(x...)	do { /*printf(x)*/ } while (0)

#define VOID_OFFSET	1	/* Fake offset for generating "void" type. */

/*
 * Tree used to resolve per-CU types based on their offset in
 * the abbrev section.
 */
RB_HEAD(ioff_tree, itype);

/*
 * Per-type trees used to merge existing types with the ones of
 * a newly parsed CU.
 */
RB_HEAD(itype_tree, itype)	 itypet[CTF_K_MAX];

/*
 * Tree of symbols used to build a list matching the order of
 * the ELF symbol table.
 */
struct isymb_tree	 isymbt;

struct itype		*void_it;		/* no type is emited for void */
uint16_t		 tidx, fidx, oidx;	/* type, func & object IDs */
uint16_t		 long_tidx;		/* index of "long", for array */


void		 cu_stat(void);
void		 cu_parse(struct dwcu *, struct itype_queue *,
		     struct ioff_tree *);
void		 cu_resolve(struct dwcu *, struct itype_queue *,
		     struct ioff_tree *);
void		 cu_reference(struct dwcu *, struct itype_queue *);
void		 cu_merge(struct dwcu *, struct itype_queue *);

struct itype	*parse_base(struct dwdie *, size_t);
struct itype	*parse_refers(struct dwdie *, size_t, int);
struct itype	*parse_array(struct dwdie *, size_t);
struct itype	*parse_enum(struct dwdie *, size_t);
struct itype	*parse_struct(struct dwdie *, size_t, int, size_t);
struct itype	*parse_function(struct dwdie *, size_t);
struct itype	*parse_funcptr(struct dwdie *, size_t);
struct itype	*parse_variable(struct dwdie *, size_t);

void		 subparse_subrange(struct dwdie *, size_t, struct itype *);
void		 subparse_enumerator(struct dwdie *, size_t, struct itype *);
void		 subparse_member(struct dwdie *, size_t, struct itype *, size_t);
void		 subparse_arguments(struct dwdie *, size_t, struct itype *);

size_t		 dav2val(struct dwaval *, size_t);
const char	*dav2str(struct dwaval *);
const char	*enc2name(unsigned short);

struct itype	*it_new(uint64_t, size_t, const char *, uint32_t, uint16_t,
		     uint64_t, uint16_t, unsigned int);
void		 it_merge(struct itype *, struct itype *);
void		 it_reference(struct itype *);
void		 it_free(struct itype *);
int		 it_cmp(struct itype *, struct itype *);
int		 it_name_cmp(struct itype *, struct itype *);
int		 it_off_cmp(struct itype *, struct itype *);
void		 ir_add(struct itype *, struct itype *);
void		 ir_purge(struct itype *);
struct imember	*im_new(const char *, size_t, size_t);

RB_GENERATE(itype_tree, itype, it_node, it_cmp);
RB_GENERATE(isymb_tree, itype, it_node, it_name_cmp);
RB_GENERATE(ioff_tree, itype, it_node, it_off_cmp);

/*
 * Construct a list of internal type and functions based on DWARF
 * INFO and ABBREV sections.
 *
 * Multiple CUs are supported.
 */
void
dwarf_parse(const char *infobuf, size_t infolen, const char *abbuf,
    size_t ablen)
{
	struct dwbuf		 info = { .buf = infobuf, .len = infolen };
	struct dwbuf		 abbrev = { .buf = abbuf, .len = ablen };
	struct dwcu		*dcu = NULL;
	struct ioff_tree	 cu_iofft;
	struct itype_queue	 cu_itypeq;
	struct itype		*it;
	int			 i;

	for (i = 0; i < CTF_K_MAX; i++)
		RB_INIT(&itypet[i]);
	RB_INIT(&isymbt);

	void_it = it_new(++tidx, VOID_OFFSET, "void", 0,
	    CTF_INT_SIGNED, 0, CTF_K_INTEGER, 0);
	TAILQ_INSERT_TAIL(&itypeq, void_it, it_next);

	while (dw_cu_parse(&info, &abbrev, infolen, &dcu) == 0) {
		TAILQ_INIT(&cu_itypeq);

		/* We use a tree to speed-up type resolution. */
		RB_INIT(&cu_iofft);

		/* Parse this CU */
		cu_parse(dcu, &cu_itypeq, &cu_iofft);

		/* Resolve its types. */
		cu_resolve(dcu, &cu_itypeq, &cu_iofft);
		assert(RB_EMPTY(&cu_iofft));

		/* Mark used type as such. */
		cu_reference(dcu, &cu_itypeq);

#ifdef DEBUG
		/* Dump statistics for current CU. */
		cu_stat();
#endif

		/* Merge them with the common type list. */
		cu_merge(dcu, &cu_itypeq);

		dw_dcu_free(dcu);
	}

	/* We force array's index type to be 'long', for that we need its ID. */
	RB_FOREACH(it, itype_tree, &itypet[CTF_K_INTEGER]) {
		if (it_name(it) == NULL || it->it_size != (8 * sizeof(long)))
			continue;

		if (strcmp(it_name(it), "unsigned") == 0) {
			long_tidx = it->it_idx;
			break;
		}
	}
}

struct itype *
it_new(uint64_t index, size_t off, const char *name, uint32_t size,
    uint16_t enc, uint64_t ref, uint16_t type, unsigned int flags)
{
	struct itype *it;
#ifndef NOPOOL
	static int it_pool_inited = 0;

	if (!it_pool_inited) {
		pool_init(&it_pool, "it", 512, sizeof(struct itype));
		pool_init(&im_pool, "im", 1024, sizeof(struct imember));
		pool_init(&ir_pool, "ir", 1024, sizeof(struct itref));
		it_pool_inited = 1;
	}
#endif

	assert((name != NULL) || !(flags & (ITF_FUNC|ITF_OBJ)));

	it = pmalloc(&it_pool, sizeof(*it));
	SIMPLEQ_INIT(&it->it_refs);
	TAILQ_INIT(&it->it_members);
	it->it_off = off;
	it->it_ref = ref;
	it->it_refp = NULL;
	it->it_size = size;
	it->it_nelems = 0;
	it->it_enc = enc;
	it->it_idx = index;
	it->it_type = type;
	it->it_flags = flags;

	if (name == NULL) {
		it->it_flags |= ITF_ANON;
	} else {
		size_t n;

		if ((n = strlcpy(it->it_name, name, ITNAME_MAX)) > ITNAME_MAX)
			warnx("name %s too long %zd > %d", name, n, ITNAME_MAX);
	}

	return it;
}

struct itype *
it_dup(struct itype *it)
{
	struct imember *copim, *im;
	struct itype *copit;

	copit = it_new(it->it_idx, it->it_off, it_name(it), it->it_size,
	    it->it_enc, it->it_ref, it->it_type, it->it_flags);

	copit->it_refp = it->it_refp;
	copit->it_nelems = it->it_nelems;

	TAILQ_FOREACH(im, &it->it_members, im_next) {
		copim = im_new(im_name(im), im->im_ref, im->im_off);
		copim->im_refp = im->im_refp;
		TAILQ_INSERT_TAIL(&copit->it_members, copim, im_next);
	}

	return copit;
}

/*
 * Merge the content of ``it'', the full type declaration into the
 * forwarding representation ``fwd''.
 */
void
it_merge(struct itype *fwd, struct itype *it)
{
	assert(fwd->it_flags & ITF_FORWARD);
	assert(fwd->it_type == it->it_type);
	assert(TAILQ_EMPTY(&fwd->it_members));
	assert(SIMPLEQ_EMPTY(&it->it_refs));

	fwd->it_off = it->it_off;
	fwd->it_ref = it->it_ref;
	fwd->it_refp = it->it_refp;
	fwd->it_size = it->it_size;
	fwd->it_nelems = it->it_nelems;
	fwd->it_enc = it->it_enc;
	fwd->it_flags = it->it_flags;

	TAILQ_CONCAT(&fwd->it_members, &it->it_members, im_next);
	assert(TAILQ_EMPTY(&it->it_members));
}

const char *
it_name(struct itype *it)
{
	if (!(it->it_flags & ITF_ANON))
		return it->it_name;

	return NULL;
}

void
it_reference(struct itype *it)
{
	struct imember *im;

	if (it == NULL || it->it_flags & ITF_USED)
		return;

	it->it_flags |= ITF_USED;

	it_reference(it->it_refp);
	TAILQ_FOREACH(im, &it->it_members, im_next)
		it_reference(im->im_refp);
}

void
it_free(struct itype *it)
{
	struct imember *im;

	if (it == NULL)
		return;

	while ((im = TAILQ_FIRST(&it->it_members)) != NULL) {
		TAILQ_REMOVE(&it->it_members, im, im_next);
		pfree(&im_pool, im);
	}

	ir_purge(it);
	pfree(&it_pool, it);
}

/*
 * Return 0 if ``a'' matches ``b''.
 */
int
it_cmp(struct itype *a, struct itype *b)
{
	int diff;

	if ((diff = (a->it_type - b->it_type)) != 0)
		return diff;

	/* Match by name */
	if (!(a->it_flags & ITF_ANON) && !(b->it_flags & ITF_ANON))
		return strcmp(it_name(a), it_name(b));

	/* Only one of them is anonym */
	if ((a->it_flags & ITF_ANON) != (b->it_flags & ITF_ANON))
		return (a->it_flags & ITF_ANON) ? -1 : 1;

	/* Match by reference */
	if ((a->it_refp != NULL) && (b->it_refp != NULL))
		return it_cmp(a->it_refp, b->it_refp);

	return 1;
}

int
it_name_cmp(struct itype *a, struct itype *b)
{
	int diff;

	if ((diff = strcmp(it_name(a), it_name(b))) != 0)
		return diff;

	return ((a->it_flags|ITF_MASK) - (b->it_flags|ITF_MASK));
}

int
it_off_cmp(struct itype *a, struct itype *b)
{
	return a->it_off - b->it_off;
}

void
ir_add(struct itype *it, struct itype *tmp)
{
	struct itref *ir;

	SIMPLEQ_FOREACH(ir, &tmp->it_refs, ir_next) {
		if (ir->ir_itp == it)
			return;
	}

	ir = pmalloc(&ir_pool, sizeof(*ir));
	ir->ir_itp = it;
	SIMPLEQ_INSERT_TAIL(&tmp->it_refs, ir, ir_next);
}

void
ir_purge(struct itype *it)
{
	struct itref *ir;

	while ((ir = SIMPLEQ_FIRST(&it->it_refs)) != NULL) {
		SIMPLEQ_REMOVE_HEAD(&it->it_refs, ir_next);
		pfree(&ir_pool, ir);
	}
}

struct imember *
im_new(const char *name, size_t ref, size_t off)
{
	struct imember *im;

	im = pmalloc(&im_pool, sizeof(*im));
	im->im_ref = ref;
	im->im_off = off;
	im->im_refp = NULL;
	if (name == NULL) {
		im->im_flags = IMF_ANON;
	} else {
		size_t n;

		n = strlcpy(im->im_name, name, ITNAME_MAX);
		if (n > ITNAME_MAX)
			warnx("name %s too long %zd > %d", name, n,
			    ITNAME_MAX);
		im->im_flags = 0;
	}

	return im;
}

const char *
im_name(struct imember *im)
{
	if (!(im->im_flags & IMF_ANON))
		return im->im_name;

	return NULL;
}

void
cu_stat(void)
{
#ifndef NOPOOL
	pool_dump();
#endif
}

/*
 * Iterate over all types found in a given CU.  For all non-resolved types
 * use their DWARF relative offset to find the relative type they are pointing
 * to.  The CU offset tree, `cuot', is used to speedup relative type lookup.
 */
void
cu_resolve(struct dwcu *dcu, struct itype_queue *cutq, struct ioff_tree *cuot)
{
	struct itype	*it, *ref, tmp;
	struct imember	*im;
	unsigned int	 toresolve;
	size_t		 off = dcu->dcu_offset;

	TAILQ_FOREACH(it, cutq, it_next) {
		if (!(it->it_flags & (ITF_UNRES|ITF_UNRES_MEMB)))
			continue;

		/* If this type references another one, try to find it. */
		if (it->it_flags & ITF_UNRES) {
			tmp.it_off = it->it_ref + off;
			ref = RB_FIND(ioff_tree, cuot, &tmp);
			if (ref != NULL) {
				it->it_refp = ref;
				ir_add(it, ref);
				it->it_flags &= ~ITF_UNRES;
			}
		}

		/* If this type has members, resolve all of them. */
		toresolve = it->it_nelems;
		if ((it->it_flags & ITF_UNRES_MEMB) && toresolve > 0) {
			TAILQ_FOREACH(im, &it->it_members, im_next) {
				tmp.it_off = im->im_ref + off;
				ref = RB_FIND(ioff_tree, cuot, &tmp);
				if (ref != NULL) {
					im->im_refp = ref;
					ir_add(it, ref);
					toresolve--;
				}
			}
			if (toresolve == 0)
				it->it_flags &= ~ITF_UNRES_MEMB;
		}
#if defined(DEBUG)
		if (it->it_flags & (ITF_UNRES|ITF_UNRES_MEMB)) {
			printf("0x%zx: %s type=%d unresolved 0x%llx",
			    it->it_off, it_name(it), it->it_type, it->it_ref);
			if (toresolve)
				printf(": %d members", toresolve);
			TAILQ_FOREACH(im, &it->it_members, im_next) {
				if (im->im_refp != NULL)
					continue;
				printf("\n%zu: %s", im->im_ref, im_name(im));
			}
			printf("\n");
		}
#endif /* defined(DEBUG) */
	}

	/* We'll reuse the tree for the next CU, so empty it. */
	RB_FOREACH_SAFE(it, ioff_tree, cuot, ref)
		RB_REMOVE(ioff_tree, cuot, it);
}

void
cu_reference(struct dwcu *dcu, struct itype_queue *cutq)
{
	struct itype *it;

	TAILQ_FOREACH(it, cutq, it_next) {
		if (it->it_flags & (ITF_OBJ|ITF_FUNC))
			it_reference(it);
	}
}

/*
 * Merge type representation from a CU with already known types.
 */
void
cu_merge(struct dwcu *dcu, struct itype_queue *cutq)
{
	struct itype *it, *nit, *prev, *first;
	int diff;

	/* First ``it'' that needs a duplicate check. */
	first = TAILQ_FIRST(cutq);
	if (first == NULL)
		return;

	TAILQ_CONCAT(&itypeq, cutq, it_next);

	/*
	 * First pass: merge types
	 */
	for (it = first; it != NULL; it = nit) {
		nit = TAILQ_NEXT(it, it_next);

		/* Move functions & variable to their own list. */
		if (it->it_flags & (ITF_FUNC|ITF_OBJ)) {
			/*
			 * FIXME: allow static variables with the same name
			 * to be of different type.
			 */
			if (RB_FIND(isymb_tree, &isymbt, it) == NULL)
				RB_INSERT(isymb_tree, &isymbt, it);
			continue;
		}

		/* Look if we already have this type. */
		if (it->it_flags & ITF_USED)
			prev = RB_FIND(itype_tree, &itypet[it->it_type], it);
		else
			prev = NULL;

		if (prev != NULL) {
			struct itype *old = it;
			struct itref *ir;
			struct imember *im;

			/* Substitute references */
			while ((ir = SIMPLEQ_FIRST(&old->it_refs)) != NULL) {
				it = ir->ir_itp;

				SIMPLEQ_REMOVE_HEAD(&old->it_refs, ir_next);
				pfree(&ir_pool, ir);

				if (it->it_refp == old)
					it->it_refp = prev;

				TAILQ_FOREACH(im, &it->it_members, im_next) {
					if (im->im_refp == old)
						im->im_refp = prev;
				}
			}

			/* If we first got a forward reference, complete it. */
			if ((prev->it_flags & ITF_FORWARD) &&
			    (old->it_flags & ITF_FORWARD) == 0)
			    	it_merge(prev, old);

			old->it_flags &= ~ITF_USED;
		} else if (it->it_flags & ITF_USED) {
			RB_INSERT(itype_tree, &itypet[it->it_type], it);
		}
	}

	/*
	 * Second pass: update indexes
	 */
	diff = 0;
	for (it = first; it != NULL; it = nit) {
		nit = TAILQ_NEXT(it, it_next);

		if (it->it_flags & (ITF_FUNC|ITF_OBJ))
			continue;

		/* Adjust indexes */
		if (it->it_flags & ITF_USED) {
			it->it_idx -= diff;
			continue;
		}

		/* Remove unused */
		TAILQ_REMOVE(&itypeq, it, it_next);
		it_free(it);
		diff++;
	}

	/* Update global index to match removed entries. */
	it = TAILQ_LAST(&itypeq, itype_queue);
	while (it->it_flags & (ITF_FUNC|ITF_OBJ))
		it = TAILQ_PREV(it, itype_queue, it_next);

	tidx = it->it_idx;
}

/*
 * Parse a CU.
 */
void
cu_parse(struct dwcu *dcu, struct itype_queue *cutq, struct ioff_tree *cuot)
{
	struct itype *it = NULL;
	struct dwdie *die;
	size_t psz = dcu->dcu_psize;
	size_t off = dcu->dcu_offset;

	assert(RB_EMPTY(cuot));

	SIMPLEQ_FOREACH(die, &dcu->dcu_dies, die_next) {
		uint64_t tag = die->die_dab->dab_tag;

		switch (tag) {
		case DW_TAG_array_type:
			it = parse_array(die, dcu->dcu_psize);
			break;
		case DW_TAG_enumeration_type:
			it = parse_enum(die, dcu->dcu_psize);
			break;
		case DW_TAG_pointer_type:
			it = parse_refers(die, psz, CTF_K_POINTER);
			break;
		case DW_TAG_structure_type:
			it = parse_struct(die, psz, CTF_K_STRUCT, off);
			if (it == NULL)
				continue;
			break;
		case DW_TAG_typedef:
			it = parse_refers(die, psz, CTF_K_TYPEDEF);
			break;
		case DW_TAG_union_type:
			it = parse_struct(die, psz, CTF_K_UNION, off);
			if (it == NULL)
				continue;
			break;
		case DW_TAG_base_type:
			it = parse_base(die, psz);
			if (it == NULL)
				continue;
			break;
		case DW_TAG_const_type:
			it = parse_refers(die, psz, CTF_K_CONST);
			break;
		case DW_TAG_volatile_type:
			it = parse_refers(die, psz, CTF_K_VOLATILE);
			break;
		case DW_TAG_restrict_type:
			it = parse_refers(die, psz, CTF_K_RESTRICT);
			break;
		case DW_TAG_subprogram:
			it = parse_function(die, psz);
			if (it == NULL)
				continue;
			break;
		case DW_TAG_subroutine_type:
			it = parse_funcptr(die, psz);
			break;
		/*
		 * Children are assumed to be right after their parent in
		 * the list.  The parent parsing function takes care of
		 * parsing them.
		 */
		 case DW_TAG_member:
			 assert(it->it_type == CTF_K_STRUCT ||
			    it->it_type == CTF_K_UNION ||
			    it->it_type == CTF_K_ENUM);
			continue;
		 case DW_TAG_subrange_type:
			assert(it->it_type == CTF_K_ARRAY);
			continue;
		case DW_TAG_formal_parameter:
			/*
			 * If we skipped the second inline definition,
			 * skip its arguments.
			 */
			if (it == NULL)
				continue;

			/* See comment in subparse_arguments(). */
			if (it->it_type == CTF_K_STRUCT ||
			    it->it_type == CTF_K_UNION ||
			    it->it_type == CTF_K_ENUM ||
			    it->it_type == CTF_K_TYPEDEF)
				continue;

			if (it->it_flags & ITF_OBJ)
				continue;

			assert(it->it_type == CTF_K_FUNCTION);
			continue;
		case DW_TAG_variable:
			it = parse_variable(die, psz);
			/* Unnamed variables are discarded. */
			if (it == NULL)
				continue;
			break;
#if 1
		case DW_TAG_lexical_block:
		case DW_TAG_inlined_subroutine:
			continue;
#endif
		case DW_TAG_compile_unit:
		default:
			DPRINTF("%s\n", dw_tag2name(tag));
			continue;
		}

		TAILQ_INSERT_TAIL(cutq, it, it_next);
		RB_INSERT(ioff_tree, cuot, it);
	}
}

struct itype *
parse_base(struct dwdie *die, size_t psz)
{
	struct itype *it;
	struct dwaval *dav;
	uint16_t encoding, enc = 0, bits = 0;
	int type;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_encoding:
			enc = dav2val(dav, psz);
			break;
		case DW_AT_byte_size:
			bits = 8 * dav2val(dav, psz);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}

	switch (enc) {
	case DW_ATE_unsigned:
	case DW_ATE_address:
		encoding = 0;
		type = CTF_K_INTEGER;
		break;
	case DW_ATE_unsigned_char:
		encoding = CTF_INT_CHAR;
		type = CTF_K_INTEGER;
		break;
	case DW_ATE_signed:
		encoding = CTF_INT_SIGNED;
		type = CTF_K_INTEGER;
		break;
	case DW_ATE_signed_char:
		encoding = CTF_INT_SIGNED | CTF_INT_CHAR;
		type = CTF_K_INTEGER;
		break;
	case DW_ATE_boolean:
		encoding = CTF_INT_SIGNED | CTF_INT_BOOL;
		type = CTF_K_INTEGER;
		break;
	case DW_ATE_float:
		if (bits < psz)
			encoding = CTF_FP_SINGLE;
		else if (bits == psz)
			encoding = CTF_FP_DOUBLE;
		else
			encoding = CTF_FP_LDOUBLE;
		type = CTF_K_FLOAT;
		break;
	case DW_ATE_complex_float:
		if (bits < psz)
			encoding = CTF_FP_CPLX;
		else if (bits == psz)
			encoding = CTF_FP_DCPLX;
		else
			encoding = CTF_FP_LDCPLX;
		type = CTF_K_FLOAT;
		break;
	case DW_ATE_imaginary_float:
		if (bits < psz)
			encoding = CTF_FP_IMAGRY;
		else if (bits == psz)
			encoding = CTF_FP_DIMAGRY;
		else
			encoding = CTF_FP_LDIMAGRY;
		type = CTF_K_FLOAT;
		break;
	default:
		DPRINTF("unknown encoding: %d\n", enc);
		return (NULL);
	}

	it = it_new(++tidx, die->die_offset, enc2name(enc), bits,
	    encoding, 0, type, 0);

	return it;
}

struct itype *
parse_refers(struct dwdie *die, size_t psz, int type)
{
	struct itype *it;
	struct dwaval *dav;
	const char *name = NULL;
	size_t ref = 0, size = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_name:
			name = dav2str(dav);
			break;
		case DW_AT_type:
			ref = dav2val(dav, psz);
			break;
		case DW_AT_byte_size:
			size = dav2val(dav, psz);
			assert(size < UINT_MAX);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}

	it = it_new(++tidx, die->die_offset, name, size, 0, ref, type,
	    ITF_UNRES);

	if (it->it_ref == 0 && (it->it_size == sizeof(void *) ||
	    type == CTF_K_CONST || type == CTF_K_VOLATILE ||
	    type == CTF_K_POINTER)) {
		/* Work around GCC/clang not emiting a type for void */
		it->it_flags &= ~ITF_UNRES;
		it->it_ref = VOID_OFFSET;
		it->it_refp = void_it;
	}

	return it;
}

struct itype *
parse_array(struct dwdie *die, size_t psz)
{
	struct itype *it;
	struct dwaval *dav;
	const char *name = NULL;
	size_t ref = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_name:
			name = dav2str(dav);
			break;
		case DW_AT_type:
			ref = dav2val(dav, psz);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}

	it = it_new(++tidx, die->die_offset, name, 0, 0, ref, CTF_K_ARRAY,
	    ITF_UNRES);

	subparse_subrange(die, psz, it);

	return it;
}

struct itype *
parse_enum(struct dwdie *die, size_t psz)
{
	struct itype *it;
	struct dwaval *dav;
	const char *name = NULL;
	size_t size = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_byte_size:
			size = dav2val(dav, psz);
			assert(size < UINT_MAX);
			break;
		case DW_AT_name:
			name = dav2str(dav);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}

	it = it_new(++tidx, die->die_offset, name, size, 0, 0, CTF_K_ENUM, 0);

	subparse_enumerator(die, psz, it);

	return it;
}

void
subparse_subrange(struct dwdie *die, size_t psz, struct itype *it)
{
	struct dwaval *dav;

	assert(it->it_type == CTF_K_ARRAY);

	if (die->die_dab->dab_children == DW_CHILDREN_no)
		return;

	/*
	 * This loop assumes that the children of a DIE are just
	 * after it on the list.
	 */
	while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
		uint64_t tag = die->die_dab->dab_tag;
		size_t nelems = 0;

		if (tag != DW_TAG_subrange_type)
			break;

		SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
			switch (dav->dav_dat->dat_attr) {
			case DW_AT_count:
				nelems = dav2val(dav, psz);
				break;
			case DW_AT_upper_bound:
				nelems = dav2val(dav, psz) + 1;
				break;
			default:
				DPRINTF("%s\n",
				    dw_at2name(dav->dav_dat->dat_attr));
				break;
			}
		}

		assert(nelems < UINT_MAX);
		it->it_nelems = nelems;
	}
}

void
subparse_enumerator(struct dwdie *die, size_t psz, struct itype *it)
{
	struct imember *im;
	struct dwaval *dav;

	assert(it->it_type == CTF_K_ENUM);

	if (die->die_dab->dab_children == DW_CHILDREN_no)
		return;

	/*
	 * This loop assumes that the children of a DIE are just
	 * after it on the list.
	 */
	while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
		uint64_t tag = die->die_dab->dab_tag;
		size_t val = 0;
		const char *name = NULL;

		if (tag != DW_TAG_enumerator)
			break;

		SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
			switch (dav->dav_dat->dat_attr) {
			case DW_AT_name:
				name = dav2str(dav);
				break;
			case DW_AT_const_value:
				val = dav2val(dav, psz);
				break;
			default:
				DPRINTF("%s\n",
				    dw_at2name(dav->dav_dat->dat_attr));
				break;
			}
		}

		if (name == NULL) {
			warnx("%s with anon member", it_name(it));
			continue;
		}

		im = im_new(name, val, 0);
		assert(it->it_nelems < UINT_MAX);
		it->it_nelems++;
		TAILQ_INSERT_TAIL(&it->it_members, im, im_next);
	}
}

struct itype *
parse_struct(struct dwdie *die, size_t psz, int type, size_t off)
{
	struct itype *it = NULL;
	struct dwaval *dav;
	const char *name = NULL;
	unsigned int flags = 0;
	size_t size = 0;
	int forward = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_declaration:
			forward = dav2val(dav, psz);
			break;
		case DW_AT_byte_size:
			size = dav2val(dav, psz);
			assert(size < UINT_MAX);
			break;
		case DW_AT_name:
			name = dav2str(dav);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}


	if (forward)
		flags = ITF_FORWARD;
	it = it_new(++tidx, die->die_offset, name, size, 0, 0, type, flags);
	subparse_member(die, psz, it, off);

	return it;
}

void
subparse_member(struct dwdie *die, size_t psz, struct itype *it, size_t offset)
{
	struct imember *im;
	struct dwaval *dav;
	const char *name;
	size_t off = 0, ref = 0, bits = 0;
	uint8_t lvl = die->die_lvl;

	assert(it->it_type == CTF_K_STRUCT || it->it_type == CTF_K_UNION);

	if (die->die_dab->dab_children == DW_CHILDREN_no)
		return;

	/*
	 * This loop assumes that the children of a DIE are just
	 * after it on the list.
	 */
	while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
		int64_t tag = die->die_dab->dab_tag;

		name = NULL;
		if (die->die_lvl <= lvl)
			break;

		/* Skip members of members */
		if (die->die_lvl > lvl + 1)
			continue;
		/*
		 * Nested declaration.
		 *
		 * This matches the case where a ``struct'', ``union'',
		 * ``enum'' or ``typedef'' is first declared "inside" a
		 * union or struct declaration.
		 */
		if (tag == DW_TAG_structure_type || tag == DW_TAG_union_type ||
		    tag == DW_TAG_enumeration_type || tag == DW_TAG_typedef)
			continue;

		it->it_flags |= ITF_UNRES_MEMB;

		SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
			switch (dav->dav_dat->dat_attr) {
			case DW_AT_name:
				name = dav2str(dav);
				break;
			case DW_AT_type:
				ref = dav2val(dav, psz);
				break;
			case DW_AT_data_member_location:
				off = 8 * dav2val(dav, psz);
				break;
			case DW_AT_bit_size:
				bits = dav2val(dav, psz);
				assert(bits < USHRT_MAX);
				break;
			default:
				DPRINTF("%s\n",
				    dw_at2name(dav->dav_dat->dat_attr));
				break;
			}
		}

		/*
		 * When a structure is declared inside an union, we
		 * have to generate a reference to make the resolver
		 * happy.
		 */
		if ((ref == 0) && (tag == DW_TAG_structure_type))
			ref = die->die_offset - offset;

		im = im_new(name, ref, off);
		assert(it->it_nelems < UINT_MAX);
		it->it_nelems++;
		TAILQ_INSERT_TAIL(&it->it_members, im, im_next);
	}
}


void
subparse_arguments(struct dwdie *die, size_t psz, struct itype *it)
{
	struct imember *im;
	struct dwaval *dav;
	size_t ref = 0;

	assert(it->it_type == CTF_K_FUNCTION);

	if (die->die_dab->dab_children == DW_CHILDREN_no)
		return;

	/*
	 * This loop assumes that the children of a DIE are after it
	 * on the list.
	 */
	while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
		uint64_t tag = die->die_dab->dab_tag;

		if (tag == DW_TAG_unspecified_parameters) {
			/* TODO */
			continue;
		}

		/*
		 * Nested declaration.
		 *
		 * This matches the case where a ``struct'', ``union'',
		 * ``enum'' or ``typedef'' is first declared "inside" a
		 * function declaration.
		 */
		if (tag == DW_TAG_structure_type || tag == DW_TAG_union_type ||
		    tag == DW_TAG_enumeration_type || tag == DW_TAG_typedef)
			continue;

		if (tag != DW_TAG_formal_parameter)
			break;

		it->it_flags |= ITF_UNRES_MEMB;

		SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
			switch (dav->dav_dat->dat_attr) {
			case DW_AT_type:
				ref = dav2val(dav, psz);
				break;
			default:
				DPRINTF("%s\n",
				    dw_at2name(dav->dav_dat->dat_attr));
				break;
			}
		}

		im = im_new(NULL, ref, 0);
		assert(it->it_nelems < UINT_MAX);
		it->it_nelems++;
		TAILQ_INSERT_TAIL(&it->it_members, im, im_next);
	}
}

struct itype *
parse_function(struct dwdie *die, size_t psz)
{
	struct itype *it;
	struct dwaval *dav;
	const char *name = NULL;
	size_t ref = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_name:
			name = dav2str(dav);
			break;
		case DW_AT_type:
			ref = dav2val(dav, psz);
			break;
		case DW_AT_abstract_origin:
			/*
			 * Skip second empty definition for inline
			 * functions.
			 */
			return NULL;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}

	/*
	 * Work around for clang 4.0 generating DW_TAG_subprogram without
	 * any attribute.
	 */
	if (name == NULL)
		return NULL;

	it = it_new(++fidx, die->die_offset, name, 0, 0, ref, CTF_K_FUNCTION,
	    ITF_UNRES|ITF_FUNC);

	subparse_arguments(die, psz, it);

	if (it->it_ref == 0) {
		/* Work around GCC not emiting a type for void */
		it->it_flags &= ~ITF_UNRES;
		it->it_ref = VOID_OFFSET;
		it->it_refp = void_it;
	}

	return it;
}

struct itype *
parse_funcptr(struct dwdie *die, size_t psz)
{
	struct itype *it;
	struct dwaval *dav;
	const char *name = NULL;
	size_t ref = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_name:
			name = dav2str(dav);
			break;
		case DW_AT_type:
			ref = dav2val(dav, psz);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}

	it = it_new(++tidx, die->die_offset, name, 0, 0, ref, CTF_K_FUNCTION,
	    ITF_UNRES);

	subparse_arguments(die, psz, it);

	if (it->it_ref == 0) {
		/* Work around GCC not emiting a type for void */
		it->it_flags &= ~ITF_UNRES;
		it->it_ref = VOID_OFFSET;
		it->it_refp = void_it;
	}

	return it;
}

struct itype *
parse_variable(struct dwdie *die, size_t psz)
{
	struct itype *it = NULL;
	struct dwaval *dav;
	const char *name = NULL;
	size_t ref = 0;
	int forward = 0;

	SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
		switch (dav->dav_dat->dat_attr) {
		case DW_AT_declaration:
			forward = dav2val(dav, psz);
			break;
		case DW_AT_name:
			name = dav2str(dav);
			break;
		case DW_AT_type:
			ref = dav2val(dav, psz);
			break;
		default:
			DPRINTF("%s\n", dw_at2name(dav->dav_dat->dat_attr));
			break;
		}
	}


	if (!forward && name != NULL) {
		it = it_new(++oidx, die->die_offset, name, 0, 0, ref, 0,
		    ITF_UNRES|ITF_OBJ);
	}

	return it;
}

size_t
dav2val(struct dwaval *dav, size_t psz)
{
	uint64_t val = (uint64_t)-1;

	switch (dav->dav_dat->dat_form) {
	case DW_FORM_addr:
	case DW_FORM_ref_addr:
		if (psz == sizeof(uint32_t))
			val = dav->dav_u32;
		else
			val = dav->dav_u64;
		break;
	case DW_FORM_block1:
	case DW_FORM_block2:
	case DW_FORM_block4:
	case DW_FORM_block:
		dw_loc_parse(&dav->dav_buf, NULL, &val, NULL);
		break;
	case DW_FORM_flag:
	case DW_FORM_data1:
	case DW_FORM_ref1:
		val = dav->dav_u8;
		break;
	case DW_FORM_data2:
	case DW_FORM_ref2:
		val = dav->dav_u16;
		break;
	case DW_FORM_data4:
	case DW_FORM_ref4:
		val = dav->dav_u32;
		break;
	case DW_FORM_sdata:
	case DW_FORM_data8:
	case DW_FORM_ref8:
		val = dav->dav_u64;
		break;
	case DW_FORM_strp:
		val = dav->dav_u32;
		break;
	case DW_FORM_flag_present:
		val = 1;
		break;
	default:
		break;
	}

	return val;
}

const char *
dav2str(struct dwaval *dav)
{
	const char *str = NULL;
	extern const char *dstrbuf;
	extern size_t dstrlen;

	switch (dav->dav_dat->dat_form) {
	case DW_FORM_string:
		str = dav->dav_str;
		break;
	case DW_FORM_strp:
		if (dav->dav_u32 >= dstrlen)
			str = NULL;
		else
			str = dstrbuf + dav->dav_u32;
		break;
	default:
		break;
	}

	return str;
}

const char *
enc2name(unsigned short enc)
{
	static const char *enc_name[] = { "address", "boolean", "complex float",
	    "float", "signed", "char", "unsigned", "unsigned char",
	    "imaginary float", "packed decimal", "numeric string", "edited",
	    "signed fixed", "unsigned fixed", "decimal float" };

	if (enc > 0 && enc <= nitems(enc_name))
		return enc_name[enc - 1];

	return "invalid";
}