In general, the patch adds indirection to minimize the amount of code that needs to know about differences between v2 and v3. Specifically, some new ctf_get_ctt_* functions are added, and new LCTF_* macros are added to use the underlying container's version to do the right thing. CTF containers can have parent/child relationships, wherein a type ID in one container refers to a type in the parent. It is permitted for the parent and child to have different versions. MFC after: 1 month Sponsored by: The FreeBSD Foundation Differential Revision: https://reviews.freebsd.org/D34363
188 lines
4.8 KiB
C
188 lines
4.8 KiB
C
/*
|
|
* 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 2005 Sun Microsystems, Inc. All rights reserved.
|
|
* Use is subject to license terms.
|
|
*/
|
|
|
|
#pragma ident "%Z%%M% %I% %E% SMI"
|
|
|
|
/*
|
|
* CTF Declaration Stack
|
|
*
|
|
* In order to implement ctf_type_name(), we must convert a type graph back
|
|
* into a C type declaration. Unfortunately, a type graph represents a storage
|
|
* class ordering of the type whereas a type declaration must obey the C rules
|
|
* for operator precedence, and the two orderings are frequently in conflict.
|
|
* For example, consider these CTF type graphs and their C declarations:
|
|
*
|
|
* CTF_K_POINTER -> CTF_K_FUNCTION -> CTF_K_INTEGER : int (*)()
|
|
* CTF_K_POINTER -> CTF_K_ARRAY -> CTF_K_INTEGER : int (*)[]
|
|
*
|
|
* In each case, parentheses are used to raise operator * to higher lexical
|
|
* precedence, so the string form of the C declaration cannot be constructed by
|
|
* walking the type graph links and forming the string from left to right.
|
|
*
|
|
* The functions in this file build a set of stacks from the type graph nodes
|
|
* corresponding to the C operator precedence levels in the appropriate order.
|
|
* The code in ctf_type_name() can then iterate over the levels and nodes in
|
|
* lexical precedence order and construct the final C declaration string.
|
|
*/
|
|
|
|
#include <ctf_impl.h>
|
|
|
|
void
|
|
ctf_decl_init(ctf_decl_t *cd, char *buf, size_t len)
|
|
{
|
|
int i;
|
|
|
|
bzero(cd, sizeof (ctf_decl_t));
|
|
|
|
for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++)
|
|
cd->cd_order[i] = CTF_PREC_BASE - 1;
|
|
|
|
cd->cd_qualp = CTF_PREC_BASE;
|
|
cd->cd_ordp = CTF_PREC_BASE;
|
|
|
|
cd->cd_buf = buf;
|
|
cd->cd_ptr = buf;
|
|
cd->cd_end = buf + len;
|
|
}
|
|
|
|
void
|
|
ctf_decl_fini(ctf_decl_t *cd)
|
|
{
|
|
ctf_decl_node_t *cdp, *ndp;
|
|
int i;
|
|
|
|
for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++) {
|
|
for (cdp = ctf_list_next(&cd->cd_nodes[i]);
|
|
cdp != NULL; cdp = ndp) {
|
|
ndp = ctf_list_next(cdp);
|
|
ctf_free(cdp, sizeof (ctf_decl_node_t));
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ctf_decl_push(ctf_decl_t *cd, ctf_file_t *fp, ctf_id_t type)
|
|
{
|
|
ctf_decl_node_t *cdp;
|
|
ctf_decl_prec_t prec;
|
|
uint_t ctype, kind, n = 1;
|
|
int is_qual = 0;
|
|
|
|
const void *tp;
|
|
ctf_arinfo_t ar;
|
|
|
|
if ((tp = ctf_lookup_by_id(&fp, type)) == NULL) {
|
|
cd->cd_err = fp->ctf_errno;
|
|
return;
|
|
}
|
|
|
|
ctf_get_ctt_info(fp, tp, &kind, NULL, NULL);
|
|
ctf_get_ctt_index(fp, tp, NULL, &ctype, NULL);
|
|
|
|
switch (kind) {
|
|
case CTF_K_ARRAY:
|
|
(void) ctf_array_info(fp, type, &ar);
|
|
ctf_decl_push(cd, fp, ar.ctr_contents);
|
|
n = ar.ctr_nelems;
|
|
prec = CTF_PREC_ARRAY;
|
|
break;
|
|
|
|
case CTF_K_TYPEDEF:
|
|
if (ctf_type_rname(fp, tp)[0] == '\0') {
|
|
ctf_decl_push(cd, fp, ctype);
|
|
return;
|
|
}
|
|
prec = CTF_PREC_BASE;
|
|
break;
|
|
|
|
case CTF_K_FUNCTION:
|
|
ctf_decl_push(cd, fp, ctype);
|
|
prec = CTF_PREC_FUNCTION;
|
|
break;
|
|
|
|
case CTF_K_POINTER:
|
|
ctf_decl_push(cd, fp, ctype);
|
|
prec = CTF_PREC_POINTER;
|
|
break;
|
|
|
|
case CTF_K_VOLATILE:
|
|
case CTF_K_CONST:
|
|
case CTF_K_RESTRICT:
|
|
ctf_decl_push(cd, fp, ctype);
|
|
prec = cd->cd_qualp;
|
|
is_qual++;
|
|
break;
|
|
|
|
default:
|
|
prec = CTF_PREC_BASE;
|
|
}
|
|
|
|
if ((cdp = ctf_alloc(sizeof (ctf_decl_node_t))) == NULL) {
|
|
cd->cd_err = EAGAIN;
|
|
return;
|
|
}
|
|
|
|
cdp->cd_type = type;
|
|
cdp->cd_kind = kind;
|
|
cdp->cd_n = n;
|
|
|
|
if (ctf_list_next(&cd->cd_nodes[prec]) == NULL)
|
|
cd->cd_order[prec] = cd->cd_ordp++;
|
|
|
|
/*
|
|
* Reset cd_qualp to the highest precedence level that we've seen so
|
|
* far that can be qualified (CTF_PREC_BASE or CTF_PREC_POINTER).
|
|
*/
|
|
if (prec > cd->cd_qualp && prec < CTF_PREC_ARRAY)
|
|
cd->cd_qualp = prec;
|
|
|
|
/*
|
|
* C array declarators are ordered inside out so prepend them. Also by
|
|
* convention qualifiers of base types precede the type specifier (e.g.
|
|
* const int vs. int const) even though the two forms are equivalent.
|
|
*/
|
|
if (kind == CTF_K_ARRAY || (is_qual && prec == CTF_PREC_BASE))
|
|
ctf_list_prepend(&cd->cd_nodes[prec], cdp);
|
|
else
|
|
ctf_list_append(&cd->cd_nodes[prec], cdp);
|
|
}
|
|
|
|
/*PRINTFLIKE2*/
|
|
void
|
|
ctf_decl_sprintf(ctf_decl_t *cd, const char *format, ...)
|
|
{
|
|
size_t len = (size_t)(cd->cd_end - cd->cd_ptr);
|
|
va_list ap;
|
|
size_t n;
|
|
|
|
va_start(ap, format);
|
|
n = vsnprintf(cd->cd_ptr, len, format, ap);
|
|
va_end(ap);
|
|
|
|
cd->cd_ptr += MIN(n, len);
|
|
cd->cd_len += n;
|
|
}
|