git: 6edd55f882b3 - releng/13.1 - ctf: Import ctf.h from OpenBSD

From: Mark Johnston <markj_at_FreeBSD.org>
Date: Mon, 18 Apr 2022 16:39:25 UTC
The branch releng/13.1 has been updated by markj:

URL: https://cgit.FreeBSD.org/src/commit/?id=6edd55f882b32bf5e74c9892920c0e40ba697d1f

commit 6edd55f882b32bf5e74c9892920c0e40ba697d1f
Author:     Mark Johnston <markj@FreeBSD.org>
AuthorDate: 2022-03-07 13:42:57 +0000
Commit:     Mark Johnston <markj@FreeBSD.org>
CommitDate: 2022-04-18 16:37:53 +0000

    ctf: Import ctf.h from OpenBSD
    
    Use it instead of the existing ctf.h from OpenSolaris.  This makes it
    easier to use CTF in the core kernel, and to extend the CTF format to
    support wider type IDs.
    
    The imported ctf.h is modified to depend only on _types.h, and also to
    provide macros which use the "parent" bit of a type ID to refer to types
    in a parent CTF container.
    
    No functional change intended.
    
    Approved by:    re (gjb)
    Reviewed by:    Domagoj Stolfa, emaste
    Sponsored by:   The FreeBSD Foundation
    
    (cherry picked from commit 2d5d2a986ce1a93b8567dbdf3f80bc2b545d6998)
    (cherry picked from commit 3681c4f065f1028ff84b654cfbfb238f2723b78c)
---
 .../opensolaris/tools/ctf/common/ctf_headers.h     |   2 +-
 cddl/lib/libdtrace/Makefile                        |   1 -
 sys/cddl/contrib/opensolaris/uts/common/sys/ctf.h  | 360 ---------------------
 sys/sys/ctf.h                                      | 214 ++++++++++++
 tools/build/Makefile                               |   1 +
 5 files changed, 216 insertions(+), 362 deletions(-)

diff --git a/cddl/contrib/opensolaris/tools/ctf/common/ctf_headers.h b/cddl/contrib/opensolaris/tools/ctf/common/ctf_headers.h
index b00b8fd9a650..ca66b9bf5486 100644
--- a/cddl/contrib/opensolaris/tools/ctf/common/ctf_headers.h
+++ b/cddl/contrib/opensolaris/tools/ctf/common/ctf_headers.h
@@ -65,7 +65,7 @@
  *    an explicit path #include.
  */
 
-#include <uts/common/sys/ctf.h>
+#include <sys/ctf.h>
 #include <uts/common/sys/ctf_api.h>
 #include <lib/libctf/common/libctf.h>
 
diff --git a/cddl/lib/libdtrace/Makefile b/cddl/lib/libdtrace/Makefile
index 26ff06b46c40..05b183215f4c 100644
--- a/cddl/lib/libdtrace/Makefile
+++ b/cddl/lib/libdtrace/Makefile
@@ -70,7 +70,6 @@ SYSINCSDIR=	${INCLUDEDIR}/sys
 INCS+=		${SRCTOP}/cddl/contrib/opensolaris/lib/libdtrace/common/dtrace.h
 SYSINCS+=	${SRCTOP}/sys/cddl/contrib/opensolaris/uts/common/sys/dtrace.h
 SYSINCS+=	${SRCTOP}/sys/cddl/contrib/opensolaris/uts/common/sys/ctf_api.h
-SYSINCS+=	${SRCTOP}/sys/cddl/contrib/opensolaris/uts/common/sys/ctf.h
 
 WARNS?=		1
 
diff --git a/sys/cddl/contrib/opensolaris/uts/common/sys/ctf.h b/sys/cddl/contrib/opensolaris/uts/common/sys/ctf.h
deleted file mode 100644
index 528814118e1c..000000000000
--- a/sys/cddl/contrib/opensolaris/uts/common/sys/ctf.h
+++ /dev/null
@@ -1,360 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (the "License").  You may not use this file except in compliance
- * with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-#ifndef	_CTF_H
-#define	_CTF_H
-
-#ifdef illumos
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#endif
-
-#include <sys/types.h>
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-
-/*
- * CTF - Compact ANSI-C Type Format
- *
- * This file format can be used to compactly represent the information needed
- * by a debugger to interpret the ANSI-C types used by a given program.
- * Traditionally, this kind of information is generated by the compiler when
- * invoked with the -g flag and is stored in "stabs" strings or in the more
- * modern DWARF format.  CTF provides a representation of only the information
- * that is relevant to debugging a complex, optimized C program such as the
- * operating system kernel in a form that is significantly more compact than
- * the equivalent stabs or DWARF representation.  The format is data-model
- * independent, so consumers do not need different code depending on whether
- * they are 32-bit or 64-bit programs.  CTF assumes that a standard ELF symbol
- * table is available for use in the debugger, and uses the structure and data
- * of the symbol table to avoid storing redundant information.  The CTF data
- * may be compressed on disk or in memory, indicated by a bit in the header.
- * CTF may be interpreted in a raw disk file, or it may be stored in an ELF
- * section, typically named .SUNW_ctf.  Data structures are aligned so that
- * a raw CTF file or CTF ELF section may be manipulated using mmap(2).
- *
- * The CTF file or section itself has the following structure:
- *
- * +--------+--------+---------+----------+-------+--------+
- * |  file  |  type  |  data   | function | data  | string |
- * | header | labels | objects |   info   | types | table  |
- * +--------+--------+---------+----------+-------+--------+
- *
- * The file header stores a magic number and version information, encoding
- * flags, and the byte offset of each of the sections relative to the end of the
- * header itself.  If the CTF data has been uniquified against another set of
- * CTF data, a reference to that data also appears in the the header.  This
- * reference is the name of the label corresponding to the types uniquified
- * against.
- *
- * Following the header is a list of labels, used to group the types included in
- * the data types section.  Each label is accompanied by a type ID i.  A given
- * label refers to the group of types whose IDs are in the range [0, i].
- *
- * Data object and function records are stored in the same order as they appear
- * in the corresponding symbol table, except that symbols marked SHN_UNDEF are
- * not stored and symbols that have no type data are padded out with zeroes.
- * For each data object, the type ID (a small integer) is recorded.  For each
- * function, the type ID of the return type and argument types is recorded.
- *
- * The data types section is a list of variable size records that represent each
- * type, in order by their ID.  The types themselves form a directed graph,
- * where each node may contain one or more outgoing edges to other type nodes,
- * denoted by their ID.
- *
- * Strings are recorded as a string table ID (0 or 1) and a byte offset into the
- * string table.  String table 0 is the internal CTF string table.  String table
- * 1 is the external string table, which is the string table associated with the
- * ELF symbol table for this object.  CTF does not record any strings that are
- * already in the symbol table, and the CTF string table does not contain any
- * duplicated strings.
- *
- * If the CTF data has been merged with another parent CTF object, some outgoing
- * edges may refer to type nodes that exist in another CTF object.  The debugger
- * and libctf library are responsible for connecting the appropriate objects
- * together so that the full set of types can be explored and manipulated.
- */
-
-#define	CTF_MAX_TYPE	0xffff	/* max type identifier value */
-#define	CTF_MAX_NAME 0x7fffffff	/* max offset into a string table */
-#define	CTF_MAX_VLEN	0x3ff	/* max struct, union, enum members or args */
-#define	CTF_MAX_INTOFF	0xff	/* max offset of intrinsic value in bits */
-#define	CTF_MAX_INTBITS	0xffff	/* max size of an intrinsic in bits */
-
-/* See ctf_type_t */
-#define	CTF_MAX_SIZE	0xfffe	/* max size of a type in bytes */
-#define	CTF_LSIZE_SENT	0xffff	/* sentinel for ctt_size */
-#define	CTF_MAX_LSIZE	UINT64_MAX
-
-typedef struct ctf_preamble {
-	ushort_t ctp_magic;	/* magic number (CTF_MAGIC) */
-	uchar_t ctp_version;	/* data format version number (CTF_VERSION) */
-	uchar_t ctp_flags;	/* flags (see below) */
-} ctf_preamble_t;
-
-typedef struct ctf_header {
-	ctf_preamble_t cth_preamble;
-	uint_t cth_parlabel;	/* ref to name of parent lbl uniq'd against */
-	uint_t cth_parname;	/* ref to basename of parent */
-	uint_t cth_lbloff;	/* offset of label section */
-	uint_t cth_objtoff;	/* offset of object section */
-	uint_t cth_funcoff;	/* offset of function section */
-	uint_t cth_typeoff;	/* offset of type section */
-	uint_t cth_stroff;	/* offset of string section */
-	uint_t cth_strlen;	/* length of string section in bytes */
-} ctf_header_t;
-
-#define	cth_magic   cth_preamble.ctp_magic
-#define	cth_version cth_preamble.ctp_version
-#define	cth_flags   cth_preamble.ctp_flags
-
-#ifdef CTF_OLD_VERSIONS
-
-typedef struct ctf_header_v1 {
-	ctf_preamble_t cth_preamble;
-	uint_t cth_objtoff;
-	uint_t cth_funcoff;
-	uint_t cth_typeoff;
-	uint_t cth_stroff;
-	uint_t cth_strlen;
-} ctf_header_v1_t;
-
-#endif /* CTF_OLD_VERSIONS */
-
-#define	CTF_MAGIC	0xcff1	/* magic number identifying header */
-
-/* data format version number */
-#define	CTF_VERSION_1	1
-#define	CTF_VERSION_2	2
-#define	CTF_VERSION	CTF_VERSION_2	/* current version */
-
-#define	CTF_F_COMPRESS	0x1	/* data buffer is compressed */
-
-typedef struct ctf_lblent {
-	uint_t ctl_label;	/* ref to name of label */
-	uint_t ctl_typeidx;	/* last type associated with this label */
-} ctf_lblent_t;
-
-typedef struct ctf_stype {
-	uint_t ctt_name;	/* reference to name in string table */
-	ushort_t ctt_info;	/* encoded kind, variant length (see below) */
-	union {
-		ushort_t _size;	/* size of entire type in bytes */
-		ushort_t _type;	/* reference to another type */
-	} _u;
-} ctf_stype_t;
-
-/*
- * type sizes, measured in bytes, come in two flavors.  99% of them fit within
- * (USHRT_MAX - 1), and thus can be stored in the ctt_size member of a
- * ctf_stype_t.  The maximum value for these sizes is CTF_MAX_SIZE.  The sizes
- * larger than CTF_MAX_SIZE must be stored in the ctt_lsize member of a
- * ctf_type_t.  Use of this member is indicated by the presence of
- * CTF_LSIZE_SENT in ctt_size.
- */
-typedef struct ctf_type {
-	uint_t ctt_name;	/* reference to name in string table */
-	ushort_t ctt_info;	/* encoded kind, variant length (see below) */
-	union {
-		ushort_t _size;	/* always CTF_LSIZE_SENT */
-		ushort_t _type; /* do not use */
-	} _u;
-	uint_t ctt_lsizehi;	/* high 32 bits of type size in bytes */
-	uint_t ctt_lsizelo;	/* low 32 bits of type size in bytes */
-} ctf_type_t;
-
-#define	ctt_size _u._size	/* for fundamental types that have a size */
-#define	ctt_type _u._type	/* for types that reference another type */
-
-/*
- * The following macros compose and decompose values for ctt_info and
- * ctt_name, as well as other structures that contain name references.
- *
- *             ------------------------
- * ctt_info:   | kind | isroot | vlen |
- *             ------------------------
- *             15   11    10    9     0
- *
- * kind = CTF_INFO_KIND(c.ctt_info);     <-- CTF_K_* value (see below)
- * vlen = CTF_INFO_VLEN(c.ctt_info);     <-- length of variable data list
- *
- * stid = CTF_NAME_STID(c.ctt_name);     <-- string table id number (0 or 1)
- * offset = CTF_NAME_OFFSET(c.ctt_name); <-- string table byte offset
- *
- * c.ctt_info = CTF_TYPE_INFO(kind, vlen);
- * c.ctt_name = CTF_TYPE_NAME(stid, offset);
- */
-
-#define	CTF_INFO_KIND(info)	(((info) & 0xf800) >> 11)
-#define	CTF_INFO_ISROOT(info)	(((info) & 0x0400) >> 10)
-#define	CTF_INFO_VLEN(info)	(((info) & CTF_MAX_VLEN))
-
-#define	CTF_NAME_STID(name)	((name) >> 31)
-#define	CTF_NAME_OFFSET(name)	((name) & 0x7fffffff)
-
-#define	CTF_TYPE_INFO(kind, isroot, vlen) \
-	(((kind) << 11) | (((isroot) ? 1 : 0) << 10) | ((vlen) & CTF_MAX_VLEN))
-
-#define	CTF_TYPE_NAME(stid, offset) \
-	(((stid) << 31) | ((offset) & 0x7fffffff))
-
-#define	CTF_TYPE_ISPARENT(id)	((id) < 0x8000)
-#define	CTF_TYPE_ISCHILD(id)	((id) > 0x7fff)
-
-#define	CTF_TYPE_TO_INDEX(id)		((id) & 0x7fff)
-#define	CTF_INDEX_TO_TYPE(id, child)	((child) ? ((id) | 0x8000) : (id))
-#define	CTF_PARENT_SHIFT	15
-
-#define	CTF_STRTAB_0	0	/* symbolic define for string table id 0 */
-#define	CTF_STRTAB_1	1	/* symbolic define for string table id 1 */
-
-#define	CTF_TYPE_LSIZE(cttp) \
-	(((uint64_t)(cttp)->ctt_lsizehi) << 32 | (cttp)->ctt_lsizelo)
-#define	CTF_SIZE_TO_LSIZE_HI(size)	((uint32_t)((uint64_t)(size) >> 32))
-#define	CTF_SIZE_TO_LSIZE_LO(size)	((uint32_t)(size))
-
-#ifdef CTF_OLD_VERSIONS
-
-#define	CTF_INFO_KIND_V1(info)		(((info) & 0xf000) >> 12)
-#define	CTF_INFO_ISROOT_V1(info)	(((info) & 0x0800) >> 11)
-#define	CTF_INFO_VLEN_V1(info)		(((info) & 0x07ff))
-
-#define	CTF_TYPE_INFO_V1(kind, isroot, vlen) \
-	(((kind) << 12) | (((isroot) ? 1 : 0) << 11) | ((vlen) & 0x07ff))
-
-#endif /* CTF_OLD_VERSIONS */
-
-/*
- * Values for CTF_TYPE_KIND().  If the kind has an associated data list,
- * CTF_INFO_VLEN() will extract the number of elements in the list, and
- * the type of each element is shown in the comments below.
- */
-#define	CTF_K_UNKNOWN	0	/* unknown type (used for padding) */
-#define	CTF_K_INTEGER	1	/* variant data is CTF_INT_DATA() (see below) */
-#define	CTF_K_FLOAT	2	/* variant data is CTF_FP_DATA() (see below) */
-#define	CTF_K_POINTER	3	/* ctt_type is referenced type */
-#define	CTF_K_ARRAY	4	/* variant data is single ctf_array_t */
-#define	CTF_K_FUNCTION	5	/* ctt_type is return type, variant data is */
-				/* list of argument types (ushort_t's) */
-#define	CTF_K_STRUCT	6	/* variant data is list of ctf_member_t's */
-#define	CTF_K_UNION	7	/* variant data is list of ctf_member_t's */
-#define	CTF_K_ENUM	8	/* variant data is list of ctf_enum_t's */
-#define	CTF_K_FORWARD	9	/* no additional data; ctt_name is tag */
-#define	CTF_K_TYPEDEF	10	/* ctt_type is referenced type */
-#define	CTF_K_VOLATILE	11	/* ctt_type is base type */
-#define	CTF_K_CONST	12	/* ctt_type is base type */
-#define	CTF_K_RESTRICT	13	/* ctt_type is base type */
-
-#define	CTF_K_MAX	31	/* Maximum possible CTF_K_* value */
-
-/*
- * Values for ctt_type when kind is CTF_K_INTEGER.  The flags, offset in bits,
- * and size in bits are encoded as a single word using the following macros.
- */
-#define	CTF_INT_ENCODING(data)	(((data) & 0xff000000) >> 24)
-#define	CTF_INT_OFFSET(data)	(((data) & 0x00ff0000) >> 16)
-#define	CTF_INT_BITS(data)	(((data) & 0x0000ffff))
-
-#define	CTF_INT_DATA(encoding, offset, bits) \
-	(((encoding) << 24) | ((offset) << 16) | (bits))
-
-#define	CTF_INT_SIGNED	0x01	/* integer is signed (otherwise unsigned) */
-#define	CTF_INT_CHAR	0x02	/* character display format */
-#define	CTF_INT_BOOL	0x04	/* boolean display format */
-#define	CTF_INT_VARARGS	0x08	/* varargs display format */
-
-/*
- * Values for ctt_type when kind is CTF_K_FLOAT.  The encoding, offset in bits,
- * and size in bits are encoded as a single word using the following macros.
- */
-#define	CTF_FP_ENCODING(data)	(((data) & 0xff000000) >> 24)
-#define	CTF_FP_OFFSET(data)	(((data) & 0x00ff0000) >> 16)
-#define	CTF_FP_BITS(data)	(((data) & 0x0000ffff))
-
-#define	CTF_FP_DATA(encoding, offset, bits) \
-	(((encoding) << 24) | ((offset) << 16) | (bits))
-
-#define	CTF_FP_SINGLE	1	/* IEEE 32-bit float encoding */
-#define	CTF_FP_DOUBLE	2	/* IEEE 64-bit float encoding */
-#define	CTF_FP_CPLX	3	/* Complex encoding */
-#define	CTF_FP_DCPLX	4	/* Double complex encoding */
-#define	CTF_FP_LDCPLX	5	/* Long double complex encoding */
-#define	CTF_FP_LDOUBLE	6	/* Long double encoding */
-#define	CTF_FP_INTRVL	7	/* Interval (2x32-bit) encoding */
-#define	CTF_FP_DINTRVL	8	/* Double interval (2x64-bit) encoding */
-#define	CTF_FP_LDINTRVL	9	/* Long double interval (2x128-bit) encoding */
-#define	CTF_FP_IMAGRY	10	/* Imaginary (32-bit) encoding */
-#define	CTF_FP_DIMAGRY	11	/* Long imaginary (64-bit) encoding */
-#define	CTF_FP_LDIMAGRY	12	/* Long double imaginary (128-bit) encoding */
-
-#define	CTF_FP_MAX	12	/* Maximum possible CTF_FP_* value */
-
-typedef struct ctf_array {
-	ushort_t cta_contents;	/* reference to type of array contents */
-	ushort_t cta_index;	/* reference to type of array index */
-	uint_t cta_nelems;	/* number of elements */
-} ctf_array_t;
-
-/*
- * Most structure members have bit offsets that can be expressed using a
- * short.  Some don't.  ctf_member_t is used for structs which cannot
- * contain any of these large offsets, whereas ctf_lmember_t is used in the
- * latter case.  If ctt_size for a given struct is >= 8192 bytes, all members
- * will be stored as type ctf_lmember_t.
- */
-
-#define	CTF_LSTRUCT_THRESH	8192
-
-typedef struct ctf_member {
-	uint_t ctm_name;	/* reference to name in string table */
-	ushort_t ctm_type;	/* reference to type of member */
-	ushort_t ctm_offset;	/* offset of this member in bits */
-} ctf_member_t;
-
-typedef struct ctf_lmember {
-	uint_t ctlm_name;	/* reference to name in string table */
-	ushort_t ctlm_type;	/* reference to type of member */
-	ushort_t ctlm_pad;	/* padding */
-	uint_t ctlm_offsethi;	/* high 32 bits of member offset in bits */
-	uint_t ctlm_offsetlo;	/* low 32 bits of member offset in bits */
-} ctf_lmember_t;
-
-#define	CTF_LMEM_OFFSET(ctlmp) \
-	(((uint64_t)(ctlmp)->ctlm_offsethi) << 32 | (ctlmp)->ctlm_offsetlo)
-#define	CTF_OFFSET_TO_LMEMHI(offset)	((uint32_t)((uint64_t)(offset) >> 32))
-#define	CTF_OFFSET_TO_LMEMLO(offset)	((uint32_t)(offset))
-
-typedef struct ctf_enum {
-	uint_t cte_name;	/* reference to name in string table */
-	int cte_value;		/* value associated with this name */
-} ctf_enum_t;
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif	/* _CTF_H */
diff --git a/sys/sys/ctf.h b/sys/sys/ctf.h
new file mode 100644
index 000000000000..e6a806143d51
--- /dev/null
+++ b/sys/sys/ctf.h
@@ -0,0 +1,214 @@
+/*	$OpenBSD: ctf.h,v 1.5 2017/08/13 14:56:05 nayden Exp $	*/
+
+/*-
+ * SPDX-License-Identifier: ISC
+ *
+ * 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.
+ */
+
+#ifndef _SYS_CTF_H_
+#define _SYS_CTF_H_
+
+#include <sys/_types.h>
+
+/*
+ * CTF ``Compact ANSI-C Type Format'' ABI header file.
+ *
+ * See the ctf(5) manual page for a detailed description of the format.
+ */
+
+typedef struct ctf_preamble {
+	__uint16_t		ctp_magic;
+	__uint8_t		ctp_version;
+	__uint8_t		ctp_flags;
+} ctf_preamble_t;
+
+typedef struct ctf_header {
+	struct ctf_preamble	cth_preamble;
+#define cth_magic	cth_preamble.ctp_magic
+#define cth_version	cth_preamble.ctp_version
+#define cth_flags	cth_preamble.ctp_flags
+	__uint32_t		cth_parlabel;
+	__uint32_t		cth_parname;
+	__uint32_t		cth_lbloff;
+	__uint32_t		cth_objtoff;
+	__uint32_t		cth_funcoff;
+	__uint32_t		cth_typeoff;
+	__uint32_t		cth_stroff;
+	__uint32_t		cth_strlen;
+} ctf_header_t;
+
+#define CTF_F_COMPRESS		(1 << 0)	/* zlib compression */
+
+typedef struct ctf_lblent {
+	__uint32_t		ctl_label;
+	__uint32_t		ctl_typeidx;
+} ctf_lblent_t;
+
+typedef struct ctf_stype {
+	__uint32_t		ctt_name;
+	__uint16_t		ctt_info;
+	union {
+		__uint16_t _size;
+		__uint16_t _type;
+	} _u;
+} ctf_stype_t;
+
+typedef struct ctf_type {
+	__uint32_t		ctt_name;
+	__uint16_t		ctt_info;
+	union {
+		__uint16_t _size;
+		__uint16_t _type;
+	} _u;
+	__uint32_t		ctt_lsizehi;
+	__uint32_t		ctt_lsizelo;
+} ctf_type_t;
+
+#define ctt_size _u._size
+#define ctt_type _u._type
+
+typedef struct ctf_array {
+	__uint16_t		cta_contents;
+	__uint16_t		cta_index;
+	__uint32_t		cta_nelems;
+} ctf_array_t;
+
+typedef struct ctf_member {
+	__uint32_t		ctm_name;
+	__uint16_t		ctm_type;
+	__uint16_t		ctm_offset;
+} ctf_member_t;
+
+typedef struct ctf_lmember {
+	__uint32_t		ctlm_name;
+	__uint16_t		ctlm_type;
+	__uint16_t		ctlm_pad;
+	__uint32_t		ctlm_offsethi;
+	__uint32_t		ctlm_offsetlo;
+} ctf_lmember_t;
+
+#define CTF_LSTRUCT_THRESH	8192
+
+typedef struct ctf_enum {
+	__uint32_t		cte_name;
+	__int32_t		cte_value;
+} ctf_enum_t;
+
+#define CTF_MAGIC		0xcff1
+#define CTF_VERSION		CTF_VERSION_2
+#define CTF_VERSION_2		2
+#define CTF_VERSION_1		1
+
+#define CTF_MAX_NAME		0x7fffffff
+#define CTF_MAX_VLEN		0x03ff
+#define CTF_MAX_SIZE		0xfffe
+#define CTF_LSIZE_SENT		(CTF_MAX_SIZE + 1) /* sentinel for cts vs ctt */
+
+#define CTF_PARENT_SHIFT	15
+#define CTF_MAX_TYPE		0xffff
+#define CTF_TYPE_ISPARENT(id)	((id) < 0x8000)
+#define CTF_TYPE_ISCHILD(id)	((id) > 0x7fff)
+#define CTF_TYPE_TO_INDEX(t)	((t) & 0x7fff)
+#define CTF_INDEX_TO_TYPE(t, c)	(((t) & 0x7fff) | ((c) != 0 ? 0x8000 : 0))
+
+#define CTF_TYPE_INFO(k, r, l)	\
+	((k) << 11) | ((r) != 0 ? (1 << 10) : 0) | ((l) & ((1 << 10) - 1))
+
+#define CTF_STRTAB_0		0
+#define CTF_STRTAB_1		1
+
+#define CTF_TYPE_NAME(t, o)	(((t) << 31) | ((o) & ((1u << 31) - 1)))
+
+/*
+ * Info macro.
+ */
+#define CTF_INFO_VLEN(i)	(((i) & CTF_MAX_VLEN))
+#define CTF_INFO_ISROOT(i)	(((i) & 0x0400) >> 10)
+#define CTF_INFO_KIND(i)	(((i) & 0xf800) >> 11)
+#define  CTF_K_UNKNOWN		0
+#define  CTF_K_INTEGER		1
+#define  CTF_K_FLOAT		2
+#define  CTF_K_POINTER		3
+#define  CTF_K_ARRAY		4
+#define  CTF_K_FUNCTION		5
+#define  CTF_K_STRUCT		6
+#define  CTF_K_UNION		7
+#define  CTF_K_ENUM		8
+#define  CTF_K_FORWARD		9
+#define  CTF_K_TYPEDEF		10
+#define  CTF_K_VOLATILE		11
+#define  CTF_K_CONST		12
+#define  CTF_K_RESTRICT		13
+#define  CTF_K_MAX		31
+
+/*
+ * Integer/Float Encoding macro.
+ */
+#define _CTF_ENCODING(e)	(((e) & 0xff000000) >> 24)
+#define _CTF_OFFSET(e)		(((e) & 0x00ff0000) >> 16)
+#define _CTF_BITS(e)		(((e) & 0x0000ffff))
+#define _CTF_DATA(encoding, offset, bits) \
+	(((encoding) << 24) | ((offset) << 16) | (bits))
+
+#define CTF_INT_ENCODING(e)	_CTF_ENCODING(e)
+#define  CTF_INT_SIGNED		(1 << 0)
+#define  CTF_INT_CHAR		(1 << 1)
+#define  CTF_INT_BOOL		(1 << 2)
+#define  CTF_INT_VARARGS	(1 << 3)
+#define CTF_INT_OFFSET(e)	_CTF_OFFSET(e)
+#define CTF_INT_BITS(e)		_CTF_BITS(e)
+#define CTF_INT_DATA(e, o, b)	_CTF_DATA(e, o, b)
+
+#define CTF_FP_ENCODING(e)	_CTF_ENCODING(e)
+#define  CTF_FP_SINGLE		1
+#define  CTF_FP_DOUBLE		2
+#define  CTF_FP_CPLX		3
+#define  CTF_FP_DCPLX		4
+#define  CTF_FP_LDCPLX		5
+#define  CTF_FP_LDOUBLE		6
+#define  CTF_FP_INTRVL		7
+#define  CTF_FP_DINTRVL		8
+#define  CTF_FP_LDINTRVL	9
+#define  CTF_FP_IMAGRY		10
+#define  CTF_FP_DIMAGRY		11
+#define  CTF_FP_LDIMAGRY	12
+#define CTF_FP_OFFSET(e)	_CTF_OFFSET(e)
+#define CTF_FP_BITS(e)		_CTF_BITS(e)
+#define CTF_FP_DATA(e, o, b)	_CTF_DATA(e, o, b)
+
+/*
+ * Name reference macro.
+ */
+#define CTF_NAME_STID(n)	((n) >> 31)
+#define CTF_NAME_OFFSET(n)	((n) & CTF_MAX_NAME)
+
+/*
+ * Type macro.
+ */
+#define CTF_SIZE_TO_LSIZE_HI(s)	((uint32_t)((uint64_t)(s) >> 32))
+#define CTF_SIZE_TO_LSIZE_LO(s)	((uint32_t)(s))
+#define CTF_TYPE_LSIZE(t)	\
+	(((uint64_t)(t)->ctt_lsizehi) << 32 | (t)->ctt_lsizelo)
+
+/*
+ * Member macro.
+ */
+#define CTF_LMEM_OFFSET(m) \
+	(((__uint64_t)(m)->ctlm_offsethi) << 32 | (m)->ctlm_offsetlo)
+#define CTF_OFFSET_TO_LMEMHI(off)	((__uint32_t)((__uint64_t)(off) >> 32))
+#define CTF_OFFSET_TO_LMEMLO(off)	((__uint32_t)(off))
+
+#endif /* _SYS_CTF_H_ */
diff --git a/tools/build/Makefile b/tools/build/Makefile
index ee351dfa8c60..746f294aafba 100644
--- a/tools/build/Makefile
+++ b/tools/build/Makefile
@@ -253,6 +253,7 @@ SYSINCS+=	${SRCTOP}/sys/sys/fnv_hash.h
 # opensolaris compatibility
 INCS+=	${SRCTOP}/include/elf.h
 SYSINCS+=	${SRCTOP}/sys/sys/elf.h
+SYSINCS+=	${SRCTOP}/sys/sys/ctf.h
 
 # We want to run the build with only ${WORLDTMP} in $PATH to ensure we don't
 # accidentally run tools that are incompatible but happen to be in $PATH.