diff options
author | Nick Alcock <nick.alcock@oracle.com> | 2019-04-24 11:03:37 +0100 |
---|---|---|
committer | Nick Alcock <nick.alcock@oracle.com> | 2019-05-28 17:08:14 +0100 |
commit | 316afdb130346e44622229793d1fb8d391059f8d (patch) | |
tree | 869ce03acfa79331cb89475282a11ca7e1cdb7e4 /libctf/ctf-decl.c | |
parent | 143dce8481f09f60704ab52b98cf8fe6d8b29fc9 (diff) | |
download | binutils-316afdb130346e44622229793d1fb8d391059f8d.zip binutils-316afdb130346e44622229793d1fb8d391059f8d.tar.gz binutils-316afdb130346e44622229793d1fb8d391059f8d.tar.bz2 |
libctf: core type lookup
Finally we get to the functions used to actually look up and enumerate
properties of types in a container (names, sizes, members, what type a
pointer or cv-qual references, determination of whether two types are
assignment-compatible, etc).
With a very few exceptions these do not work for types newly added via
ctf_add_*(): they only work on types in read-only containers, or types
added before the most recent call to ctf_update().
This also adds support for lookup of "variables" (string -> type ID
mappings) and for generation of C type names corresponding to a type ID.
libctf/
* ctf-decl.c: New file.
* ctf-types.c: Likewise.
* ctf-impl.h: New declarations.
include/
* ctf-api.h (ctf_visit_f): New definition.
(ctf_member_f): Likewise.
(ctf_enum_f): Likewise.
(ctf_variable_f): Likewise.
(ctf_type_f): Likewise.
(ctf_type_isparent): Likewise.
(ctf_type_ischild): Likewise.
(ctf_type_resolve): Likewise.
(ctf_type_aname): Likewise.
(ctf_type_lname): Likewise.
(ctf_type_name): Likewise.
(ctf_type_sizee): Likewise.
(ctf_type_align): Likewise.
(ctf_type_kind): Likewise.
(ctf_type_reference): Likewise.
(ctf_type_pointer): Likewise.
(ctf_type_encoding): Likewise.
(ctf_type_visit): Likewise.
(ctf_type_cmp): Likewise.
(ctf_type_compat): Likewise.
(ctf_member_info): Likewise.
(ctf_array_info): Likewise.
(ctf_enum_name): Likewise.
(ctf_enum_value): Likewise.
(ctf_member_iter): Likewise.
(ctf_enum_iter): Likewise.
(ctf_type_iter): Likewise.
(ctf_variable_iter): Likewise.
Diffstat (limited to 'libctf/ctf-decl.c')
-rw-r--r-- | libctf/ctf-decl.c | 195 |
1 files changed, 195 insertions, 0 deletions
diff --git a/libctf/ctf-decl.c b/libctf/ctf-decl.c new file mode 100644 index 0000000..c85982e --- /dev/null +++ b/libctf/ctf-decl.c @@ -0,0 +1,195 @@ +/* C declarator syntax glue. + Copyright (C) 2019 Free Software Foundation, Inc. + + This file is part of libctf. + + libctf is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3, or (at your option) any later + version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; see the file COPYING. If not see + <http://www.gnu.org/licenses/>. */ + +/* 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> +#include <string.h> + +void +ctf_decl_init (ctf_decl_t *cd) +{ + int i; + + memset (cd, 0, 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; +} + +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); + } + } +} + +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; + uint32_t kind, n = 1; + int is_qual = 0; + + const ctf_type_t *tp; + ctf_arinfo_t ar; + + if ((tp = ctf_lookup_by_id (&fp, type)) == NULL) + { + cd->cd_err = fp->ctf_errno; + return; + } + + switch (kind = LCTF_INFO_KIND (fp, tp->ctt_info)) + { + 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_strptr (fp, tp->ctt_name)[0] == '\0') + { + ctf_decl_push (cd, fp, tp->ctt_type); + return; + } + prec = CTF_PREC_BASE; + break; + + case CTF_K_FUNCTION: + ctf_decl_push (cd, fp, tp->ctt_type); + prec = CTF_PREC_FUNCTION; + break; + + case CTF_K_POINTER: + ctf_decl_push (cd, fp, tp->ctt_type); + prec = CTF_PREC_POINTER; + break; + + case CTF_K_SLICE: + ctf_decl_push (cd, fp, ctf_type_reference (fp, type)); + prec = CTF_PREC_BASE; + break; + + case CTF_K_VOLATILE: + case CTF_K_CONST: + case CTF_K_RESTRICT: + ctf_decl_push (cd, fp, tp->ctt_type); + 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); +} + +_libctf_printflike_ (2, 3) +void ctf_decl_sprintf (ctf_decl_t *cd, const char *format, ...) +{ + va_list ap; + char *str; + int n; + + if (cd->cd_enomem) + return; + + va_start (ap, format); + n = vasprintf (&str, format, ap); + va_end (ap); + + if (n > 0) + cd->cd_buf = ctf_str_append (cd->cd_buf, str); + + /* Sticky error condition. */ + if (n < 0) + { + free (cd->cd_buf); + cd->cd_buf = NULL; + cd->cd_enomem = 1; + } + + free (str); +} + +char *ctf_decl_buf (ctf_decl_t *cd) +{ + return cd->cd_buf; +} |