[ctfdump/.git] / ctfdump.c

/*
 * Copyright (c) 2016 Martin Pieuchot <mpi@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.
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/exec_elf.h>
#include <sys/mman.h>

#include <err.h>
#include <fcntl.h>
#include <locale.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#ifdef ZLIB
#include <zlib.h>
#endif /* ZLIB */

#include "ctf.h"

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

#define SUNW_CTF	".SUNW_ctf"

#define DUMP_OBJECT	(1 << 0)
#define DUMP_FUNCTION	(1 << 1)
#define DUMP_HEADER	(1 << 2)
#define DUMP_LABEL	(1 << 3)
#define DUMP_STRTAB	(1 << 4)
#define DUMP_STATISTIC	(1 << 5)
#define DUMP_TYPE	(1 << 6)

int		 dump(const char *, uint8_t);
int		 isctf(const char *, size_t);
__dead void	 usage(void);

int		 ctf_dump(const char *, size_t, uint8_t);
unsigned int	 ctf_dump_type(struct ctf_header *, const char *, off_t,
		     unsigned int, unsigned int);
const char	*ctf_kind2name(unsigned short);
const char	*ctf_off2name(struct ctf_header *, const char *, off_t,
		     unsigned int);

int		 elf_dump(const char *, size_t, uint8_t);
const char	*elf_idx2sym(size_t *, unsigned char);

/* elf.c */
int		 iself(const char *, size_t);
int		 elf_getshstrtab(const char *, size_t, const char **, size_t *);
int		 elf_getsymtab(const char *, const char *, size_t,
		     const Elf_Sym **, size_t *);
int		 elf_getsection(const char *, const char *, const char *,
		     size_t, const char **, size_t *);

#ifdef ZLIB
char		*decompress(const char *, size_t, off_t);
#endif /* ZLIB */

int
main(int argc, char *argv[])
{
	const char *filename;
	uint8_t flags = 0;
	int ch, error = 0;

	setlocale(LC_ALL, "");

	while ((ch = getopt(argc, argv, "dfhlst")) != -1) {
		switch (ch) {
		case 'd':
			flags |= DUMP_OBJECT;
			break;
		case 'f':
			flags |= DUMP_FUNCTION;
			break;
		case 'h':
			flags |= DUMP_HEADER;
			break;
		case 'l':
			flags |= DUMP_LABEL;
			break;
		case 's':
			flags |= DUMP_STRTAB;
			break;
		case 't':
			flags |= DUMP_TYPE;
			break;
		default:
			usage();
		}
	}

	argc -= optind;
	argv += optind;

	/* Dump everything by default */
	if (flags == 0)
		flags = 0xff;

	while ((filename = *argv++) != NULL)
		error |= dump(filename, flags);

	return error;
}

int
dump(const char *path, uint8_t flags)
{
	struct stat		 st;
	int			 fd, error = 1;
	char			*p;

	fd = open(path, O_RDONLY);
	if (fd == -1) {
		warn("open");
		return 1;
	}
	if (fstat(fd, &st) == -1) {
		warn("fstat");
		return 1;
	}
	if (st.st_size < (off_t)sizeof(struct ctf_header)) {
		warnx("file too small to be CTF");
		return 1;
	}
	if ((uintmax_t)st.st_size > SIZE_MAX) {
		warnx("file too big to fit memory");
		return 1;
	}

	p = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (p == MAP_FAILED)
		err(1, "mmap");

	if (iself(p, st.st_size)) {
		error = elf_dump(p, st.st_size, flags);
	} else if (isctf(p, st.st_size)) {
		error = ctf_dump(p, st.st_size, flags);
	}

	munmap(p, st.st_size);
	close(fd);

	return error;
}

const char		*strtab;
const Elf_Sym		*symtab;
size_t			 strtabsize, nsymb;

const char *
elf_idx2sym(size_t *idx, unsigned char type)
{
	const Elf_Sym	*st;
	size_t		 i;

	for (i = *idx + 1; i < nsymb; i++) {
		st = &symtab[i];

		if (ELF_ST_TYPE(st->st_info) != type)
			continue;

		*idx = i;
		return strtab + st->st_name;
	}

	return NULL;
}

int
elf_dump(const char *p, size_t filesize, uint8_t flags)
{
	Elf_Ehdr		*eh = (Elf_Ehdr *)p;
	Elf_Shdr		*sh;
	const char		*shstrtab;
	size_t			 i, shstrtabsize;

	/* Find section header string table location and size. */
	if (elf_getshstrtab(p, filesize, &shstrtab, &shstrtabsize))
		return 1;

	/* Find symbol table location and number of symbols. */
	if (elf_getsymtab(p, shstrtab, shstrtabsize, &symtab, &nsymb))
		warnx("symbol table not found");

	/* Find string table location and size. */
	if (elf_getsection(p, ELF_STRTAB, shstrtab, shstrtabsize, &strtab, &strtabsize))
		warnx("string table not found");

	/* Find CTF section and dump it. */
	for (i = 0; i < eh->e_shnum; i++) {
		sh = (Elf_Shdr *)(p + eh->e_shoff + i * eh->e_shentsize);

		if ((sh->sh_link >= eh->e_shnum) ||
		    (sh->sh_name >= shstrtabsize))
			continue;

		if (strncmp(shstrtab + sh->sh_name, SUNW_CTF, strlen(SUNW_CTF)))
			continue;

		if (!isctf(p + sh->sh_offset, sh->sh_size))
			break;

		return ctf_dump(p + sh->sh_offset, sh->sh_size, flags);
	}

	warnx("%s section not found", SUNW_CTF);
	return 1;
}

int
isctf(const char *p, size_t filesize)
{
	struct ctf_header	*cth = (struct ctf_header *)p;
	off_t 			 dlen = cth->cth_stroff + cth->cth_strlen;

	if (cth->cth_magic != CTF_MAGIC || cth->cth_version != CTF_VERSION)
		return 0;

	if (dlen > filesize && !(cth->cth_flags & CTF_F_COMPRESS)) {
		warnx("bogus file size");
		return 0;
	}

	if ((cth->cth_lbloff & 3) || (cth->cth_objtoff & 1) ||
	    (cth->cth_funcoff & 1) || (cth->cth_typeoff & 3)) {
		warnx("wrongly aligned offset");
		return 0;
	}

	if ((cth->cth_lbloff >= dlen) || (cth->cth_objtoff >= dlen) ||
	    (cth->cth_funcoff >= dlen) || (cth->cth_typeoff >= dlen)) {
		warnx("truncated file");
		return 0;
	}

	if ((cth->cth_lbloff > cth->cth_objtoff) ||
	    (cth->cth_objtoff > cth->cth_funcoff) ||
	    (cth->cth_funcoff > cth->cth_typeoff) ||
	    (cth->cth_typeoff > cth->cth_stroff)) {
		warnx("corrupted file");
		return 0;
	}

	return 1;
}

int
ctf_dump(const char *p, size_t size, uint8_t flags)
{
	struct ctf_header	*cth = (struct ctf_header *)p;
	off_t 			 dlen = cth->cth_stroff + cth->cth_strlen;
	char			*data;

	if (cth->cth_flags & CTF_F_COMPRESS) {
		data = decompress(p + sizeof(*cth), size - sizeof(*cth), dlen);
		if (data == NULL)
			return 1;
	} else {
		data = (char *)p + sizeof(*cth);
	}

	if (flags & DUMP_HEADER) {
		printf("  cth_magic    = 0x%04x\n", cth->cth_magic);
		printf("  cth_version  = %d\n", cth->cth_version);
		printf("  cth_flags    = 0x%02x\n", cth->cth_flags);
		printf("  cth_parlabel = %s\n",
		    ctf_off2name(cth, data, dlen, cth->cth_parname));
		printf("  cth_parname  = %s\n",
		    ctf_off2name(cth, data, dlen, cth->cth_parname));
		printf("  cth_lbloff   = %d\n", cth->cth_lbloff);
		printf("  cth_objtoff  = %d\n", cth->cth_objtoff);
		printf("  cth_funcoff  = %d\n", cth->cth_funcoff);
		printf("  cth_typeoff  = %d\n", cth->cth_typeoff);
		printf("  cth_stroff   = %d\n", cth->cth_stroff);
		printf("  cth_strlen   = %d\n", cth->cth_strlen);
		printf("\n");
	}

	if (flags & DUMP_LABEL) {
		unsigned int		 lbloff = cth->cth_lbloff;
		struct ctf_lblent	*ctl;

		while (lbloff < cth->cth_objtoff) {
			ctl = (struct ctf_lblent *)(data + lbloff);

			printf("  %5u %s\n", ctl->ctl_typeidx,
			    ctf_off2name(cth, data, dlen, ctl->ctl_label));

			lbloff += sizeof(*ctl);
		}
		printf("\n");
	}

	if (flags & DUMP_OBJECT) {
		unsigned int		 objtoff = cth->cth_objtoff;
		size_t			 idx = 0, i = 0;
		unsigned short		*dsp;
		const char		*s;
		int			 l;

		while (objtoff < cth->cth_funcoff) {
			dsp = (unsigned short *)(data + objtoff);

			l = printf("  [%zu] %u", i++, *dsp);
			if ((s = elf_idx2sym(&idx, STT_OBJECT)) != NULL)
				printf("%*s %s (%zu)\n", (14 - l), "", s, idx);
			else
				printf("\n");

			objtoff += sizeof(*dsp);
		}
	}

	if (flags & DUMP_FUNCTION) {
		unsigned short		*fsp, kind, vlen;
		size_t			 idx = 0, i = 0;
		const char		*s;
		int			 l;

		fsp = (unsigned short *)(data + cth->cth_funcoff);
		while (fsp < (unsigned short *)(data + cth->cth_typeoff)) {
			kind = CTF_INFO_KIND(*fsp);
			vlen = CTF_INFO_VLEN(*fsp);
			fsp++;

			if (kind == CTF_K_UNKNOWN && vlen == 0)
				continue;

			l = printf("  [%zu] FUNC ", i++);
			if ((s = elf_idx2sym(&idx, STT_FUNC)) != NULL)
				printf("(%s)", s);
			printf(" returns: %u args: (", *fsp++);
			while (vlen-- > 0)
				printf("%u%s", *fsp++, (vlen > 0) ? ", " : "");
			printf(")\n");
		}
		printf("\n");
	}

	if (flags & DUMP_STRTAB) {
		unsigned int		 offset = 0;
		const char		*str;

		while (offset < cth->cth_strlen) {
			str = ctf_off2name(cth, data, dlen, offset);

			printf("  [%u] ", offset);
			if (strcmp(str, "(anon)"))
				offset += printf("%s\n", str);
			else {
				printf("\\0\n");
				offset++;
			}
		}
		printf("\n");
	}

	if (flags & DUMP_TYPE) {
		unsigned int		 idx = 1, offset = 0;

		while (offset < cth->cth_stroff) {
			offset += ctf_dump_type(cth, data, dlen, offset, idx++);
		}
		printf("\n");
	}

	if (cth->cth_flags & CTF_F_COMPRESS)
		free(data);

	return 0;
}

unsigned int
ctf_dump_type(struct ctf_header *cth, const char *data, off_t dlen,
    unsigned int offset, unsigned int idx)
{
	const char		*p = data + cth->cth_typeoff + offset;
	const struct ctf_type	*ctt = (struct ctf_type *)p;
	unsigned short		 i, kind, vlen, root;
	unsigned int		 eob, toff;
	uint64_t		 size;
	const char		*name, *kname;

	kind = CTF_INFO_KIND(ctt->ctt_info);
	vlen = CTF_INFO_VLEN(ctt->ctt_info);
	root = CTF_INFO_ISROOT(ctt->ctt_info);
	name = ctf_off2name(cth, data, dlen, ctt->ctt_name);

	if (root)
		printf("  <%u> ", idx);
	else
		printf("  [%u] ", idx);

	if ((kname = ctf_kind2name(kind)) != NULL)
		printf("%s %s", kname, name);

	if (ctt->ctt_size <= CTF_MAX_SIZE) {
		size = ctt->ctt_size;
		toff = sizeof(struct ctf_stype);
	} else {
		size = CTF_TYPE_LSIZE(ctt);
		toff = sizeof(struct ctf_type);
	}

	switch (kind) {
	case CTF_K_UNKNOWN:
	case CTF_K_FORWARD:
		break;
	case CTF_K_INTEGER:
		eob = *((unsigned int *)((char *)ctt + toff));
		toff += sizeof(unsigned int);
		printf(" encoding=0x%x offset=%u bits=%u",
		    CTF_INT_ENCODING(eob), CTF_INT_OFFSET(eob),
		    CTF_INT_BITS(eob));
		break;
	case CTF_K_FLOAT:
		eob = *((unsigned int *)((char *)ctt + toff));
		toff += sizeof(unsigned int);
		printf(" encoding=0x%x offset=%u bits=%u",
		    CTF_FP_ENCODING(eob), CTF_FP_OFFSET(eob), CTF_FP_BITS(eob));
		break;
	case CTF_K_ARRAY:
		toff += sizeof(struct ctf_array);
		break;
	case CTF_K_FUNCTION:
		toff += (vlen + (vlen & 1)) * sizeof(unsigned short);
		break;
	case CTF_K_STRUCT:
	case CTF_K_UNION:
		printf(" (%llu bytes)\n", size);

		if (size < CTF_LSTRUCT_THRESH) {
			for (i = 0; i < vlen; i++) {
				struct ctf_member	*ctm;

				ctm = (struct ctf_member *)(p + toff);
				toff += sizeof(struct ctf_member);

				printf("\t%s type=%u off=%u\n",
				    ctf_off2name(cth, data, dlen,
					ctm->ctm_name),
				    ctm->ctm_type, ctm->ctm_offset);
			}
		} else {
			for (i = 0; i < vlen; i++) {
				struct ctf_lmember	*ctlm;

				ctlm = (struct ctf_lmember *)(p + toff);
				toff += sizeof(struct ctf_lmember);

				printf("\t%s type=%u off=%llu\n",
				    ctf_off2name(cth, data, dlen,
					ctlm->ctlm_name),
				    ctlm->ctlm_type, CTF_LMEM_OFFSET(ctlm));
			}
		}
		break;
	case CTF_K_ENUM:
		printf("\n");
		for (i = 0; i < vlen; i++) {
			struct ctf_enum	*cte;

			cte = (struct ctf_enum *)(p + toff);
			toff += sizeof(struct ctf_enum);

			printf("\t%s = %u\n",
			    ctf_off2name(cth, data, dlen, cte->cte_name),
			    cte->cte_value);
		}
		break;
	case CTF_K_POINTER:
	case CTF_K_TYPEDEF:
	case CTF_K_VOLATILE:
	case CTF_K_CONST:
	case CTF_K_RESTRICT:
		printf(" refers to %u", ctt->ctt_type);
		break;
	default:
		errx(1, "incorrect type %u at offset %u", kind, offset);
	}

	printf("\n");

	return toff;
}

const char *
ctf_kind2name(unsigned short kind)
{
	static const char *kind_name[] = { NULL, "INTEGER", "FLOAT", "POINTER",
	   "ARRAYS", "FUNCTION", "STRUCT", "UNION", "ENUM", "FORWARD",
	   "TYPEDEF", "VOLATILE", "CONST", "RESTRICT" };

	if (kind >= nitems(kind_name))
		return NULL;

	return kind_name[kind];
}

const char *
ctf_off2name(struct ctf_header *cth, const char *data, off_t dlen,
    unsigned int offset)
{
	const char		*name;

	if (CTF_NAME_STID(offset) != CTF_STRTAB_0)
		return "external";

	if (CTF_NAME_OFFSET(offset) >= cth->cth_strlen)
		return "exceeds strlab";

	if (cth->cth_stroff + CTF_NAME_OFFSET(offset) >= dlen)
		return "invalid";

	name = data + cth->cth_stroff + CTF_NAME_OFFSET(offset);
	if (*name == '\0')
		return "(anon)";

	return name;
}

char *
decompress(const char *buf, size_t size, off_t len)
{
#ifdef ZLIB
	z_stream		 stream;
	char			*data;
	int			 error;

	data = malloc(len);
	if (data == NULL) {
		warn(NULL);
		return NULL;
	}

	memset(&stream, 0, sizeof(stream));
	stream.next_in = (void *)buf;
	stream.avail_in = size;
	stream.next_out = data;
	stream.avail_out = len;

	if ((error = inflateInit(&stream)) != Z_OK) {
		warnx("zlib inflateInit failed: %s", zError(error));
		goto exit;
	}

	if ((error = inflate(&stream, Z_FINISH)) != Z_STREAM_END) {
		warnx("zlib inflate failed: %s", zError(error));
		inflateEnd(&stream);
		goto exit;
	}

	if ((error = inflateEnd(&stream)) != Z_OK) {
		warnx("zlib inflateEnd failed: %s", zError(error));
		goto exit;
	}

	if (stream.total_out != len) {
		warnx("decompression failed: %llu != %llu",
		    stream.total_out, len);
		goto exit;
	}

	return data;

exit:
	free(data);
#endif /* ZLIB */
	return NULL;
}

__dead void
usage(void)
{
	extern char		*__progname;

	fprintf(stderr, "usage: %s [-dfhlst] [file ...]\n",
	    __progname);
	exit(1);
}
Commit	Line	Data
f8621c6a MP	1	/*
	2	* Copyright (c) 2016 Martin Pieuchot <mpi@openbsd.org>
	3	*
	4	* Permission to use, copy, modify, and distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16
	17	#include <sys/param.h>
	18	#include <sys/types.h>
	19	#include <sys/stat.h>
	20	#include <sys/exec_elf.h>
	21	#include <sys/mman.h>
	22
	23	#include <err.h>
	24	#include <fcntl.h>
	25	#include <locale.h>
	26	#include <stdio.h>
	27	#include <stdint.h>
	28	#include <stdlib.h>
	29	#include <string.h>
	30	#include <unistd.h>
	31
	32	#ifdef ZLIB
	33	#include <zlib.h>
	34	#endif /* ZLIB */
	35
	36	#include "ctf.h"
	37
74b86e22 MP	38	#ifndef nitems
	39	#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
	40	#endif
	41
f8621c6a MP	42	#define SUNW_CTF ".SUNW_ctf"
	43
	44	#define DUMP_OBJECT (1 << 0)
	45	#define DUMP_FUNCTION (1 << 1)
	46	#define DUMP_HEADER (1 << 2)
751fc09a	47	#define DUMP_LABEL (1 << 3)
80c28199	48	#define DUMP_STRTAB (1 << 4)
74b86e22 MP	49	#define DUMP_STATISTIC (1 << 5)
74b86e22 MP	50	#define DUMP_TYPE (1 << 6)
f8621c6a	51
c1bd258a	52	int dump(const char *, uint8_t);
f8621c6a MP	53	int isctf(const char *, size_t);
	54	__dead void usage(void);
	55
c1bd258a	56	int ctf_dump(const char *, size_t, uint8_t);
74b86e22 MP	57	unsigned int ctf_dump_type(struct ctf_header , const char , off_t,
	58	unsigned int, unsigned int);
	59	const char *ctf_kind2name(unsigned short);
f8621c6a MP	60	const char ctf_off2name(struct ctf_header , const char *, off_t,
	61	unsigned int);
	62
c1bd258a	63	int elf_dump(const char *, size_t, uint8_t);
c36bfc0c MP	64	const char elf_idx2sym(size_t , unsigned char);
	65
	66	/* elf.c */
	67	int iself(const char *, size_t);
f8621c6a MP	68	int elf_getshstrtab(const char , size_t, const char , size_t );
	69	int elf_getsymtab(const char , const char , size_t,
	70	const Elf_Sym *, size_t );
2ef38d60 MP	71	int elf_getsection(const char , const char , const char *,
2ef38d60 MP	72	size_t, const char *, size_t );
f8621c6a MP	73
	74	#ifdef ZLIB
	75	char decompress(const char , size_t, off_t);
	76	#endif /* ZLIB */
	77
	78	int
	79	main(int argc, char *argv[])
	80	{
	81	const char *filename;
c1bd258a	82	uint8_t flags = 0;
f8621c6a MP	83	int ch, error = 0;
	84
	85	setlocale(LC_ALL, "");
	86
53477564	87	while ((ch = getopt(argc, argv, "dfhlst")) != -1) {
f8621c6a	88	switch (ch) {
9fe3b2c8 MP	89	case 'd':
	90	flags \|= DUMP_OBJECT;
	91	break;
acada86d MP	92	case 'f':
	93	flags \|= DUMP_FUNCTION;
	94	break;
f8621c6a MP	95	case 'h':
	96	flags \|= DUMP_HEADER;
	97	break;
751fc09a MP	98	case 'l':
	99	flags \|= DUMP_LABEL;
	100	break;
80c28199 MP	101	case 's':
	102	flags \|= DUMP_STRTAB;
	103	break;
74b86e22 MP	104	case 't':
	105	flags \|= DUMP_TYPE;
	106	break;
f8621c6a MP	107	default:
	108	usage();
	109	}
	110	}
	111
	112	argc -= optind;
	113	argv += optind;
	114
c1bd258a MP	115	/* Dump everything by default */
	116	if (flags == 0)
	117	flags = 0xff;
	118
f8621c6a MP	119	while ((filename = *argv++) != NULL)
	120	error \|= dump(filename, flags);
	121
	122	return error;
	123	}
	124
	125	int
c1bd258a	126	dump(const char *path, uint8_t flags)
f8621c6a MP	127	{
	128	struct stat st;
	129	int fd, error = 1;
	130	char *p;
	131
	132	fd = open(path, O_RDONLY);
	133	if (fd == -1) {
	134	warn("open");
	135	return 1;
	136	}
	137	if (fstat(fd, &st) == -1) {
	138	warn("fstat");
	139	return 1;
	140	}
	141	if (st.st_size < (off_t)sizeof(struct ctf_header)) {
	142	warnx("file too small to be CTF");
	143	return 1;
	144	}
	145	if ((uintmax_t)st.st_size > SIZE_MAX) {
	146	warnx("file too big to fit memory");
	147	return 1;
	148	}
	149
	150	p = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	151	if (p == MAP_FAILED)
	152	err(1, "mmap");
	153
	154	if (iself(p, st.st_size)) {
	155	error = elf_dump(p, st.st_size, flags);
	156	} else if (isctf(p, st.st_size)) {
	157	error = ctf_dump(p, st.st_size, flags);
	158	}
	159
	160	munmap(p, st.st_size);
	161	close(fd);
	162
	163	return error;
	164	}
	165
f8621c6a MP	166	const char *strtab;
	167	const Elf_Sym *symtab;
	168	size_t strtabsize, nsymb;
	169
9fe3b2c8 MP	170	const char *
	171	elf_idx2sym(size_t *idx, unsigned char type)
	172	{
	173	const Elf_Sym *st;
	174	size_t i;
	175
	176	for (i = *idx + 1; i < nsymb; i++) {
	177	st = &symtab[i];
	178
	179	if (ELF_ST_TYPE(st->st_info) != type)
	180	continue;
	181
	182	*idx = i;
	183	return strtab + st->st_name;
	184	}
	185
	186	return NULL;
	187	}
	188
f8621c6a	189	int
c1bd258a	190	elf_dump(const char *p, size_t filesize, uint8_t flags)
f8621c6a MP	191	{
	192	Elf_Ehdr eh = (Elf_Ehdr )p;
	193	Elf_Shdr *sh;
	194	const char *shstrtab;
	195	size_t i, shstrtabsize;
	196
	197	/* Find section header string table location and size. */
	198	if (elf_getshstrtab(p, filesize, &shstrtab, &shstrtabsize))
	199	return 1;
	200
	201	/* Find symbol table location and number of symbols. */
	202	if (elf_getsymtab(p, shstrtab, shstrtabsize, &symtab, &nsymb))
	203	warnx("symbol table not found");
	204
	205	/* Find string table location and size. */
2ef38d60	206	if (elf_getsection(p, ELF_STRTAB, shstrtab, shstrtabsize, &strtab, &strtabsize))
f8621c6a MP	207	warnx("string table not found");
	208
	209	/* Find CTF section and dump it. */
	210	for (i = 0; i < eh->e_shnum; i++) {
	211	sh = (Elf_Shdr )(p + eh->e_shoff + i eh->e_shentsize);
	212
	213	if ((sh->sh_link >= eh->e_shnum) \|\|
	214	(sh->sh_name >= shstrtabsize))
	215	continue;
	216
	217	if (strncmp(shstrtab + sh->sh_name, SUNW_CTF, strlen(SUNW_CTF)))
	218	continue;
	219
	220	if (!isctf(p + sh->sh_offset, sh->sh_size))
	221	break;
	222
	223	return ctf_dump(p + sh->sh_offset, sh->sh_size, flags);
	224	}
	225
	226	warnx("%s section not found", SUNW_CTF);
	227	return 1;
	228	}
	229
	230	int
	231	isctf(const char *p, size_t filesize)
	232	{
	233	struct ctf_header cth = (struct ctf_header )p;
	234	off_t dlen = cth->cth_stroff + cth->cth_strlen;
	235
	236	if (cth->cth_magic != CTF_MAGIC \|\| cth->cth_version != CTF_VERSION)
	237	return 0;
	238
	239	if (dlen > filesize && !(cth->cth_flags & CTF_F_COMPRESS)) {
	240	warnx("bogus file size");
	241	return 0;
	242	}
	243
	244	if ((cth->cth_lbloff & 3) \|\| (cth->cth_objtoff & 1) \|\|
	245	(cth->cth_funcoff & 1) \|\| (cth->cth_typeoff & 3)) {
	246	warnx("wrongly aligned offset");
	247	return 0;
	248	}
	249
	250	if ((cth->cth_lbloff >= dlen) \|\| (cth->cth_objtoff >= dlen) \|\|
	251	(cth->cth_funcoff >= dlen) \|\| (cth->cth_typeoff >= dlen)) {
	252	warnx("truncated file");
	253	return 0;
	254	}
	255
	256	if ((cth->cth_lbloff > cth->cth_objtoff) \|\|
	257	(cth->cth_objtoff > cth->cth_funcoff) \|\|
	258	(cth->cth_funcoff > cth->cth_typeoff) \|\|
	259	(cth->cth_typeoff > cth->cth_stroff)) {
	260	warnx("corrupted file");
	261	return 0;
	262	}
	263
	264	return 1;
	265	}
	266
	267	int
c1bd258a	268	ctf_dump(const char *p, size_t size, uint8_t flags)
f8621c6a MP	269	{
f8621c6a MP	270	struct ctf_header cth = (struct ctf_header )p;
f8621c6a	271	off_t dlen = cth->cth_stroff + cth->cth_strlen;
b51bd0d8	272	char *data;
f8621c6a MP	273
	274	if (cth->cth_flags & CTF_F_COMPRESS) {
	275	data = decompress(p + sizeof(cth), size - sizeof(cth), dlen);
	276	if (data == NULL)
	277	return 1;
b51bd0d8 MP	278	} else {
b51bd0d8 MP	279	data = (char )p + sizeof(cth);
f8621c6a MP	280	}
	281
	282	if (flags & DUMP_HEADER) {
6befd992 MP	283	printf(" cth_magic = 0x%04x\n", cth->cth_magic);
	284	printf(" cth_version = %d\n", cth->cth_version);
	285	printf(" cth_flags = 0x%02x\n", cth->cth_flags);
	286	printf(" cth_parlabel = %s\n",
f8621c6a	287	ctf_off2name(cth, data, dlen, cth->cth_parname));
6befd992	288	printf(" cth_parname = %s\n",
f8621c6a	289	ctf_off2name(cth, data, dlen, cth->cth_parname));
6befd992 MP	290	printf(" cth_lbloff = %d\n", cth->cth_lbloff);
	291	printf(" cth_objtoff = %d\n", cth->cth_objtoff);
	292	printf(" cth_funcoff = %d\n", cth->cth_funcoff);
	293	printf(" cth_typeoff = %d\n", cth->cth_typeoff);
	294	printf(" cth_stroff = %d\n", cth->cth_stroff);
	295	printf(" cth_strlen = %d\n", cth->cth_strlen);
	296	printf("\n");
f8621c6a MP	297	}
f8621c6a MP	298
751fc09a MP	299	if (flags & DUMP_LABEL) {
	300	unsigned int lbloff = cth->cth_lbloff;
	301	struct ctf_lblent *ctl;
	302
	303	while (lbloff < cth->cth_objtoff) {
	304	ctl = (struct ctf_lblent *)(data + lbloff);
	305
6befd992	306	printf(" %5u %s\n", ctl->ctl_typeidx,
751fc09a MP	307	ctf_off2name(cth, data, dlen, ctl->ctl_label));
	308
	309	lbloff += sizeof(*ctl);
	310	}
6befd992	311	printf("\n");
751fc09a MP	312	}
751fc09a MP	313
9fe3b2c8 MP	314	if (flags & DUMP_OBJECT) {
	315	unsigned int objtoff = cth->cth_objtoff;
	316	size_t idx = 0, i = 0;
	317	unsigned short *dsp;
	318	const char *s;
	319	int l;
	320
	321	while (objtoff < cth->cth_funcoff) {
	322	dsp = (unsigned short *)(data + objtoff);
	323
6befd992	324	l = printf(" [%zu] %u", i++, *dsp);
9fe3b2c8	325	if ((s = elf_idx2sym(&idx, STT_OBJECT)) != NULL)
86e1759d	326	printf("%*s %s (%zu)\n", (14 - l), "", s, idx);
9fe3b2c8 MP	327	else
	328	printf("\n");
	329
	330	objtoff += sizeof(*dsp);
	331	}
	332	}
	333
acada86d MP	334	if (flags & DUMP_FUNCTION) {
	335	unsigned short *fsp, kind, vlen;
	336	size_t idx = 0, i = 0;
	337	const char *s;
	338	int l;
	339
	340	fsp = (unsigned short *)(data + cth->cth_funcoff);
	341	while (fsp < (unsigned short *)(data + cth->cth_typeoff)) {
	342	kind = CTF_INFO_KIND(*fsp);
	343	vlen = CTF_INFO_VLEN(*fsp);
	344	fsp++;
	345
	346	if (kind == CTF_K_UNKNOWN && vlen == 0)
	347	continue;
	348
86e1759d	349	l = printf(" [%zu] FUNC ", i++);
acada86d	350	if ((s = elf_idx2sym(&idx, STT_FUNC)) != NULL)
86e1759d	351	printf("(%s)", s);
acada86d MP	352	printf(" returns: %u args: (", *fsp++);
	353	while (vlen-- > 0)
	354	printf("%u%s", *fsp++, (vlen > 0) ? ", " : "");
	355	printf(")\n");
	356	}
6befd992	357	printf("\n");
acada86d MP	358	}
acada86d MP	359
80c28199 MP	360	if (flags & DUMP_STRTAB) {
	361	unsigned int offset = 0;
	362	const char *str;
	363
	364	while (offset < cth->cth_strlen) {
3093320c	365	str = ctf_off2name(cth, data, dlen, offset);
80c28199	366
6befd992	367	printf(" [%u] ", offset);
3093320c	368	if (strcmp(str, "(anon)"))
80c28199 MP	369	offset += printf("%s\n", str);
	370	else {
	371	printf("\\0\n");
	372	offset++;
	373	}
	374	}
6befd992	375	printf("\n");
80c28199 MP	376	}
80c28199 MP	377
74b86e22 MP	378	if (flags & DUMP_TYPE) {
	379	unsigned int idx = 1, offset = 0;
	380
6befd992	381	while (offset < cth->cth_stroff) {
74b86e22	382	offset += ctf_dump_type(cth, data, dlen, offset, idx++);
6befd992 MP	383	}
6befd992 MP	384	printf("\n");
74b86e22 MP	385	}
74b86e22 MP	386
f8621c6a MP	387	if (cth->cth_flags & CTF_F_COMPRESS)
	388	free(data);
	389
	390	return 0;
	391	}
	392
74b86e22 MP	393	unsigned int
	394	ctf_dump_type(struct ctf_header cth, const char data, off_t dlen,
	395	unsigned int offset, unsigned int idx)
	396	{
23543ec6 MP	397	const char *p = data + cth->cth_typeoff + offset;
	398	const struct ctf_type ctt = (struct ctf_type )p;
	399	unsigned short i, kind, vlen, root;
	400	unsigned int eob, toff;
74b86e22 MP	401	uint64_t size;
	402	const char name, kname;
	403
74b86e22 MP	404	kind = CTF_INFO_KIND(ctt->ctt_info);
	405	vlen = CTF_INFO_VLEN(ctt->ctt_info);
	406	root = CTF_INFO_ISROOT(ctt->ctt_info);
	407	name = ctf_off2name(cth, data, dlen, ctt->ctt_name);
	408
	409	if (root)
6befd992	410	printf(" <%u> ", idx);
74b86e22	411	else
6befd992	412	printf(" [%u] ", idx);
74b86e22 MP	413
	414	if ((kname = ctf_kind2name(kind)) != NULL)
	415	printf("%s %s", kname, name);
	416
	417	if (ctt->ctt_size <= CTF_MAX_SIZE) {
	418	size = ctt->ctt_size;
	419	toff = sizeof(struct ctf_stype);
	420	} else {
	421	size = CTF_TYPE_LSIZE(ctt);
	422	toff = sizeof(struct ctf_type);
	423	}
	424
	425	switch (kind) {
	426	case CTF_K_UNKNOWN:
	427	case CTF_K_FORWARD:
	428	break;
	429	case CTF_K_INTEGER:
23543ec6 MP	430	eob = ((unsigned int )((char *)ctt + toff));
	431	toff += sizeof(unsigned int);
	432	printf(" encoding=0x%x offset=%u bits=%u",
	433	CTF_INT_ENCODING(eob), CTF_INT_OFFSET(eob),
	434	CTF_INT_BITS(eob));
74b86e22 MP	435	break;
74b86e22 MP	436	case CTF_K_FLOAT:
23543ec6 MP	437	eob = ((unsigned int )((char *)ctt + toff));
	438	toff += sizeof(unsigned int);
	439	printf(" encoding=0x%x offset=%u bits=%u",
	440	CTF_FP_ENCODING(eob), CTF_FP_OFFSET(eob), CTF_FP_BITS(eob));
74b86e22 MP	441	break;
74b86e22 MP	442	case CTF_K_ARRAY:
23543ec6	443	toff += sizeof(struct ctf_array);
74b86e22 MP	444	break;
74b86e22 MP	445	case CTF_K_FUNCTION:
23543ec6	446	toff += (vlen + (vlen & 1)) * sizeof(unsigned short);
74b86e22 MP	447	break;
	448	case CTF_K_STRUCT:
	449	case CTF_K_UNION:
23543ec6 MP	450	printf(" (%llu bytes)\n", size);
	451
	452	if (size < CTF_LSTRUCT_THRESH) {
	453	for (i = 0; i < vlen; i++) {
	454	struct ctf_member *ctm;
	455
	456	ctm = (struct ctf_member *)(p + toff);
	457	toff += sizeof(struct ctf_member);
	458
	459	printf("\t%s type=%u off=%u\n",
	460	ctf_off2name(cth, data, dlen,
	461	ctm->ctm_name),
	462	ctm->ctm_type, ctm->ctm_offset);
	463	}
	464	} else {
	465	for (i = 0; i < vlen; i++) {
	466	struct ctf_lmember *ctlm;
	467
	468	ctlm = (struct ctf_lmember *)(p + toff);
	469	toff += sizeof(struct ctf_lmember);
	470
	471	printf("\t%s type=%u off=%llu\n",
	472	ctf_off2name(cth, data, dlen,
	473	ctlm->ctlm_name),
	474	ctlm->ctlm_type, CTF_LMEM_OFFSET(ctlm));
	475	}
	476	}
74b86e22 MP	477	break;
74b86e22 MP	478	case CTF_K_ENUM:
23543ec6 MP	479	printf("\n");
	480	for (i = 0; i < vlen; i++) {
	481	struct ctf_enum *cte;
	482
	483	cte = (struct ctf_enum *)(p + toff);
	484	toff += sizeof(struct ctf_enum);
	485
	486	printf("\t%s = %u\n",
	487	ctf_off2name(cth, data, dlen, cte->cte_name),
	488	cte->cte_value);
	489	}
74b86e22 MP	490	break;
74b86e22 MP	491	case CTF_K_POINTER:
74b86e22 MP	492	case CTF_K_TYPEDEF:
	493	case CTF_K_VOLATILE:
	494	case CTF_K_CONST:
	495	case CTF_K_RESTRICT:
	496	printf(" refers to %u", ctt->ctt_type);
	497	break;
	498	default:
	499	errx(1, "incorrect type %u at offset %u", kind, offset);
	500	}
	501
	502	printf("\n");
	503
23543ec6	504	return toff;
74b86e22 MP	505	}
	506
	507	const char *
	508	ctf_kind2name(unsigned short kind)
	509	{
	510	static const char *kind_name[] = { NULL, "INTEGER", "FLOAT", "POINTER",
	511	"ARRAYS", "FUNCTION", "STRUCT", "UNION", "ENUM", "FORWARD",
	512	"TYPEDEF", "VOLATILE", "CONST", "RESTRICT" };
	513
	514	if (kind >= nitems(kind_name))
	515	return NULL;
	516
	517	return kind_name[kind];
	518	}
	519
f8621c6a MP	520	const char *
	521	ctf_off2name(struct ctf_header cth, const char data, off_t dlen,
	522	unsigned int offset)
	523	{
	524	const char *name;
	525
	526	if (CTF_NAME_STID(offset) != CTF_STRTAB_0)
	527	return "external";
	528
	529	if (CTF_NAME_OFFSET(offset) >= cth->cth_strlen)
	530	return "exceeds strlab";
	531
	532	if (cth->cth_stroff + CTF_NAME_OFFSET(offset) >= dlen)
	533	return "invalid";
	534
	535	name = data + cth->cth_stroff + CTF_NAME_OFFSET(offset);
	536	if (*name == '\0')
	537	return "(anon)";
	538
	539	return name;
	540	}
	541
	542	char *
	543	decompress(const char *buf, size_t size, off_t len)
	544	{
	545	#ifdef ZLIB
	546	z_stream stream;
	547	char *data;
	548	int error;
	549
	550	data = malloc(len);
	551	if (data == NULL) {
	552	warn(NULL);
	553	return NULL;
	554	}
	555
	556	memset(&stream, 0, sizeof(stream));
	557	stream.next_in = (void *)buf;
	558	stream.avail_in = size;
	559	stream.next_out = data;
	560	stream.avail_out = len;
	561
	562	if ((error = inflateInit(&stream)) != Z_OK) {
	563	warnx("zlib inflateInit failed: %s", zError(error));
	564	goto exit;
	565	}
	566
	567	if ((error = inflate(&stream, Z_FINISH)) != Z_STREAM_END) {
	568	warnx("zlib inflate failed: %s", zError(error));
8aa77ab4	569	inflateEnd(&stream);
f8621c6a MP	570	goto exit;
	571	}
	572
	573	if ((error = inflateEnd(&stream)) != Z_OK) {
	574	warnx("zlib inflateEnd failed: %s", zError(error));
	575	goto exit;
	576	}
	577
	578	if (stream.total_out != len) {
	579	warnx("decompression failed: %llu != %llu",
	580	stream.total_out, len);
	581	goto exit;
	582	}
	583
	584	return data;
	585
	586	exit:
	587	free(data);
	588	#endif /* ZLIB */
	589	return NULL;
	590	}
	591
	592	__dead void
	593	usage(void)
	594	{
	595	extern char *__progname;
	596
53477564	597	fprintf(stderr, "usage: %s [-dfhlst] [file ...]\n",
f8621c6a MP	598	__progname);
	599	exit(1);
	600	}
	601