From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 91882 invoked by alias); 1 May 2019 00:13:24 -0000 Mailing-List: contact binutils-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: binutils-owner@sourceware.org Received: (qmail 91737 invoked by uid 89); 1 May 2019 00:13:23 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.1 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_SHORT,SPF_HELO_PASS,UNPARSEABLE_RELAY autolearn=ham version=3.3.1 spammy=desire X-HELO: userp2120.oracle.com Received: from userp2120.oracle.com (HELO userp2120.oracle.com) (156.151.31.85) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 01 May 2019 00:13:21 +0000 Received: from pps.filterd (userp2120.oracle.com [127.0.0.1]) by userp2120.oracle.com (8.16.0.27/8.16.0.27) with SMTP id x3UMt4Ag101912 for ; Tue, 30 Apr 2019 22:57:27 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding; s=corp-2018-07-02; bh=LcXLFBaFtbjcFr037a2u67TLBkCnELTsyIHV9LVOnVk=; b=eAj/WJNSUCJFW+0fK0Bws7vKcLsaW1ADwHdrZV7ZxabKBilHweYtNWiYX3xoesoD5xOg BoNkbZb4zlUVNIF4GKcOdzDJYebIq7Qyd98Or3wDBE5CHR0I9AjkcEDvhJOHN0AqClLW kM39EXQ/CkhCMgJY/i67jvIhE/DYfiseQMob3Cie/UHlADU2D+W95R+w+fCEflcSV5gR hHkUOTJ1W16hGylGbQr9VDejruDzx/2nf2co21uEC/TT5SIaqTndAuyOaa/9BVhI8M/S rCiZOZpQYKVtwZ3538thQ7Uz5norQzLlVN++swOlvBp19QmObaMgFRkGx1EYfO+ZpKYq rA== Received: from aserp3030.oracle.com (aserp3030.oracle.com [141.146.126.71]) by userp2120.oracle.com with ESMTP id 2s6xhyg6y8-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 30 Apr 2019 22:57:27 +0000 Received: from pps.filterd (aserp3030.oracle.com [127.0.0.1]) by aserp3030.oracle.com (8.16.0.27/8.16.0.27) with SMTP id x3UMuogU171901 for ; Tue, 30 Apr 2019 22:57:26 GMT Received: from aserv0121.oracle.com (aserv0121.oracle.com [141.146.126.235]) by aserp3030.oracle.com with ESMTP id 2s6xhg8q8p-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK) for ; Tue, 30 Apr 2019 22:57:26 +0000 Received: from abhmp0020.oracle.com (abhmp0020.oracle.com [141.146.116.26]) by aserv0121.oracle.com (8.14.4/8.13.8) with ESMTP id x3UMvPf3020973 for ; Tue, 30 Apr 2019 22:57:25 GMT Received: from loom.srvr.nix (/81.187.191.129) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Tue, 30 Apr 2019 15:57:25 -0700 From: Nick Alcock To: binutils@sourceware.org Subject: [PATCH 17/19] libctf: debug dumping Date: Wed, 01 May 2019 00:13:00 -0000 Message-Id: <20190430225706.159422-18-nick.alcock@oracle.com> In-Reply-To: <20190430225706.159422-1-nick.alcock@oracle.com> References: <20190430225706.159422-1-nick.alcock@oracle.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-IsSubscribed: yes X-SW-Source: 2019-05/txt/msg00000.txt.bz2 This introduces ctf_dump(), an iterator which returns a series of strings, each representing a debugging dump of one item from a given section in the CTF file. The items may be multiline: a callback is provided to allow the caller to decorate each line as they desire before the line is returned. This is all very new code (last week!) and needs review, though all existing dumpers for CTF have now been rewritten in terms of it, as well as new ones added to binutils in later commits in this series, and it seems to work. libctf/ * ctf-dump.c: New. include/ * ctf-api.h (ctf_dump_decorate_f): New. (ctf_dump_state_t): new. (ctf_dump): New. --- include/ctf-api.h | 9 + libctf/ctf-dump.c | 595 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 604 insertions(+) create mode 100644 libctf/ctf-dump.c diff --git a/include/ctf-api.h b/include/ctf-api.h index 7cf3f9a3de..d0e62086b5 100644 --- a/include/ctf-api.h +++ b/include/ctf-api.h @@ -213,6 +213,11 @@ typedef int ctf_label_f (const char *name, const ctf_lblinfo_t *info, typedef int ctf_archive_member_f (ctf_file_t *fp, const char *name, void *arg); typedef int ctf_archive_raw_member_f (const char *name, const void *content, size_t len, void *arg); +typedef char *ctf_dump_decorate_f (ctf_sect_names_t sect, + char *line, void *arg); + +typedef struct ctf_dump_state ctf_dump_state_t; + extern ctf_file_t *ctf_simple_open (const char *, size_t, const char *, size_t, size_t, const char *, size_t, int *); extern ctf_file_t *ctf_bufopen (const ctf_sect_t *, const ctf_sect_t *, @@ -290,6 +295,10 @@ extern int ctf_archive_iter (const ctf_archive_t *, ctf_archive_member_f *, void *); extern int ctf_archive_raw_iter (const ctf_archive_t *, ctf_archive_raw_member_f *, void *); +extern char *ctf_dump (ctf_file_t *, ctf_dump_state_t **state, + ctf_sect_names_t sect, ctf_dump_decorate_f *, + void *arg); + extern ctf_id_t ctf_add_array (ctf_file_t *, uint32_t, const ctf_arinfo_t *); extern ctf_id_t ctf_add_const (ctf_file_t *, uint32_t, ctf_id_t); diff --git a/libctf/ctf-dump.c b/libctf/ctf-dump.c new file mode 100644 index 0000000000..b45a28b2de --- /dev/null +++ b/libctf/ctf-dump.c @@ -0,0 +1,595 @@ +/* Textual dumping of CTF data. + Copyright (C) 2012-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 2, 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 + . */ + +#include +#include + +/* One item to be dumped, in string form. */ + +typedef struct ctf_dump_item +{ + ctf_list_t cdi_list; + char *cdi_item; +} ctf_dump_item_t; + +/* Cross-call state for dumping. Basically just enough to track the section in + use and a list of return strings. */ + +struct ctf_dump_state +{ + ctf_sect_names_t cds_sect; + ctf_file_t *cds_fp; + ctf_dump_item_t *cds_current; + ctf_list_t cds_items; +}; + +/* Cross-call state for ctf_dump_member. */ + +typedef struct ctf_dump_membstate +{ + char **cdm_str; + ctf_file_t *cdm_fp; +} ctf_dump_membstate_t; + +static int +ctf_dump_append (ctf_dump_state_t *state, char *str) +{ + ctf_dump_item_t *cdi; + + if ((cdi = ctf_alloc (sizeof (struct ctf_dump_item))) == NULL) + return (ctf_set_errno (state->cds_fp, ENOMEM)); + + cdi->cdi_item = str; + ctf_list_append (&state->cds_items, cdi); + return 0; +} + +static void +ctf_dump_free (ctf_dump_state_t *state) +{ + ctf_dump_item_t *cdi, *next_cdi; + + if (state == NULL) + return; + + for (cdi = ctf_list_next (&state->cds_items); cdi != NULL; + cdi = next_cdi) + { + free (cdi->cdi_item); + next_cdi = ctf_list_next (cdi); + ctf_free (cdi, sizeof (struct ctf_dump_item)); + } +} + +/* Slices need special handling to distinguish them from their referenced + type. */ + +static int +ctf_is_slice (ctf_file_t *fp, ctf_id_t id, ctf_encoding_t *enc) +{ + int kind = ctf_type_kind (fp, id); + + return (((kind == CTF_K_INTEGER) || (kind == CTF_K_ENUM) + || (kind == CTF_K_FLOAT)) + && ctf_type_reference (fp, id) != CTF_ERR + && ctf_type_encoding (fp, id, enc) != CTF_ERR); +} + +/* Return a dump for a single type, without member info: but do show the + type's references. */ + +static char * +ctf_dump_format_type (ctf_file_t *fp, ctf_id_t id) +{ + ctf_id_t new_id; + char *str = NULL, *bit = NULL, *buf = NULL; + + new_id = id; + do + { + ctf_encoding_t enc; + + id = new_id; + buf = ctf_type_aname (fp, id); + if (!buf) + goto oom; + + /* Slices get a different print representation. */ + + if (ctf_is_slice (fp, id, &enc)) + { + ctf_type_encoding (fp, id, &enc); + if (asprintf (&bit, " %lx: [slice 0x%x:0x%x]", + id, enc.cte_offset, enc.cte_bits) < 0) + goto oom; + } + else + { + if (asprintf (&bit, " %lx: %s (size %lx)", id, buf[0] == '\0' ? + "(nameless)" : buf, ctf_type_size (fp, id)) < 0) + goto oom; + } + free (buf); + buf = NULL; + str = ctf_str_append (str, bit); + free (bit); + bit = NULL; + + new_id = ctf_type_reference (fp, id); + if (new_id != CTF_ERR) + str = ctf_str_append (str, " ->"); + } while (new_id != CTF_ERR); + + if (ctf_errno (fp) != ECTF_NOTREF) + { + free (str); + return NULL; + } + + return str; + + oom: + free (buf); + free (str); + free (bit); + ctf_set_errno (fp, ENOMEM); + return NULL; +} + +/* Dump a single label into the cds_items. */ + +static int +ctf_dump_label (const char *name, const ctf_lblinfo_t *info, + void *arg) +{ + char *str; + char *typestr; + ctf_dump_state_t *state = arg; + + if (asprintf (&str, "%s -> ", name) < 0) + return (ctf_set_errno (state->cds_fp, ENOMEM)); + + if ((typestr = ctf_dump_format_type (state->cds_fp, info->ctb_type)) == NULL) + { + free (str); + return CTF_ERR; /* errno is set for us. */ + } + + str = ctf_str_append (str, typestr); + free (typestr); + + ctf_dump_append (state, str); + return 0; +} + +/* Dump all the object entries into the cds_items. (There is no iterator for + this section, so we just do it in a loop, and this function handles all of + them, rather than only one. */ + +static int +ctf_dump_objts (ctf_file_t *fp, ctf_dump_state_t *state) +{ + size_t i; + + for (i = 0; i < fp->ctf_nsyms; i++) + { + char *str; + char *typestr; + const char *sym_name; + ctf_id_t type; + + if ((type = ctf_lookup_by_symbol (state->cds_fp, i)) < 0) + switch (ctf_errno (state->cds_fp)) + { + /* Most errors are just an indication that this symbol is not a data + symbol, but this one indicates that we were called wrong, on a + CTF file with no associated symbol table. */ + case ECTF_NOSYMTAB: + return CTF_ERR; + case ECTF_NOTDATA: + case ECTF_NOTYPEDAT: + continue; + } + + /* Variable name. */ + sym_name = ctf_lookup_symbol_name (fp, i); + if (sym_name[0] == '\0') + { + if (asprintf (&str, "%lx -> ", i) < 0) + return (ctf_set_errno (fp, ENOMEM)); + } + else + { + if (asprintf (&str, "%s (%lx) -> ", sym_name, i) < 0) + return (ctf_set_errno (fp, ENOMEM)); + } + + /* Variable type. */ + if ((typestr = ctf_dump_format_type (state->cds_fp, type)) == NULL) + { + free (str); + return CTF_ERR; /* errno is set for us. */ + } + + str = ctf_str_append (str, typestr); + free (typestr); + + ctf_dump_append (state, str); + } + return 0; +} + +/* Dump all the function entries into the cds_items. (As above, there is no + iterator for this section.) */ + +static int +ctf_dump_funcs (ctf_file_t *fp, ctf_dump_state_t *state) +{ + size_t i; + + for (i = 0; i < fp->ctf_nsyms; i++) + { + char *str ; + char *bit; + const char *sym_name; + ctf_funcinfo_t fi; + ctf_id_t type; + size_t j; + ctf_id_t *args; + + if ((type = ctf_func_info (state->cds_fp, i, &fi)) < 0) + switch (ctf_errno (state->cds_fp)) + { + /* Most errors are just an indication that this symbol is not a data + symbol, but this one indicates that we were called wrong, on a + CTF file with no associated symbol table. */ + case ECTF_NOSYMTAB: + return CTF_ERR; + case ECTF_NOTDATA: + case ECTF_NOTYPEDAT: + continue; + } + if ((args = calloc (fi.ctc_argc, sizeof (ctf_id_t))) == NULL) + return (ctf_set_errno (fp, ENOMEM)); + + /* Return type. */ + if ((str = ctf_type_aname (state->cds_fp, type)) == NULL) + goto err; + + str = ctf_str_append (str, " "); + free (bit); + + /* Function name. */ + + sym_name = ctf_lookup_symbol_name (fp, i); + if (sym_name[0] == '\0') + { + if (asprintf (&bit, "%lx ", i) < 0) + goto oom; + } + else + { + if (asprintf (&bit, "%s (%lx) ", sym_name, i) < 0) + goto oom; + } + str = ctf_str_append (str, bit); + str = ctf_str_append (str, " ("); + + /* Function arguments. */ + + if (ctf_func_args (state->cds_fp, i, fi.ctc_argc, args) < 0) + goto err; + + for (j = 0; j < fi.ctc_argc; j++) + { + if ((bit = ctf_type_aname (state->cds_fp, args[j])) == NULL) + goto err; + str = ctf_str_append (str, bit); + if ((j < fi.ctc_argc - 1) || (fi.ctc_flags & CTF_FUNC_VARARG)) + str = ctf_str_append (str, ", "); + free (bit); + } + + if (fi.ctc_flags & CTF_FUNC_VARARG) + str = ctf_str_append (str, "..."); + str = ctf_str_append (str, ")"); + + free (args); + ctf_dump_append (state, str); + continue; + + oom: + free (args); + free (str); + return (ctf_set_errno (fp, ENOMEM)); + err: + free (args); + free (str); + return CTF_ERR; /* errno is set for us. */ + } + return 0; +} + +/* Dump a single variable into the cds_items. */ +static int +ctf_dump_var (const char *name, ctf_id_t type, void *arg) +{ + char *str; + char *typestr; + ctf_dump_state_t *state = arg; + + if (asprintf (&str, "%s -> ", name) < 0) + return (ctf_set_errno (state->cds_fp, ENOMEM)); + + if ((typestr = ctf_dump_format_type (state->cds_fp, type)) == NULL) + { + free (str); + return CTF_ERR; /* errno is set for us. */ + } + + str = ctf_str_append (str, typestr); + free (typestr); + + ctf_dump_append (state, str); + return 0; +} + +/* Dump a single member into the string in the membstate. */ +static int +ctf_dump_member (const char *name, ctf_id_t id, unsigned long offset, + int depth, void *arg) +{ + ctf_dump_membstate_t *state = arg; + char *typestr = NULL; + char *bit = NULL; + ctf_encoding_t ep; + ssize_t i; + + for (i = 0; i < depth; i++) + *state->cdm_str = ctf_str_append (*state->cdm_str, " "); + + if ((typestr = ctf_type_aname (state->cdm_fp, id)) == NULL) + goto oom; + + if (asprintf (&bit, " [0x%lx] (ID 0x%lx) (kind %i) %s %s (aligned at 0x%lx", + offset, id, ctf_type_kind (state->cdm_fp, id), typestr, name, + ctf_type_align (state->cdm_fp, id)) < 0) + goto oom; + *state->cdm_str = ctf_str_append (*state->cdm_str, bit); + free (typestr); + free (bit); + typestr = NULL; + bit = NULL; + + if ((ctf_type_kind (state->cdm_fp, id) == CTF_K_INTEGER) + || (ctf_type_kind (state->cdm_fp, id) == CTF_K_FLOAT) + || (ctf_is_slice (state->cdm_fp, id, &ep) == CTF_K_ENUM)) + { + ctf_type_encoding (state->cdm_fp, id, &ep); + if (asprintf (&bit, ", format 0x%x, offset:bits 0x%x:0x%x", ep.cte_format, + ep.cte_offset, ep.cte_bits) < 0) + goto oom; + *state->cdm_str = ctf_str_append (*state->cdm_str, bit); + free (bit); + bit = NULL; + } + + *state->cdm_str = ctf_str_append (*state->cdm_str, ")\n"); + return 0; + + oom: + free (typestr); + free (bit); + return (ctf_set_errno (state->cdm_fp, ENOMEM)); +} + +/* Dump a single type into the cds_items. */ + +static int +ctf_dump_type (ctf_id_t id, void *arg) +{ + char *str; + ctf_dump_state_t *state = arg; + ctf_dump_membstate_t membstate = { &str, state->cds_fp }; + size_t len; + + if ((str = ctf_dump_format_type (state->cds_fp, id)) == NULL) + goto err; + + str = ctf_str_append (str, "\n"); + if ((ctf_type_visit (state->cds_fp, id, ctf_dump_member, &membstate)) < 0) + goto err; + + /* Trim off the last linefeed added by ctf_dump_member(). */ + len = strlen (str); + if (str[len-1] == '\n') + str[len-1] = '\0'; + + ctf_dump_append (state, str); + return 0; + + err: + free (str); + return CTF_ERR; /* errno is set for us. */ +} + +/* Dump the string table into the cds_items. */ + +static int +ctf_dump_str (ctf_file_t *fp, ctf_dump_state_t *state) +{ + const char *s = fp->ctf_str[CTF_STRTAB_0].cts_strs; + + for (; s < fp->ctf_str[CTF_STRTAB_0].cts_strs + + fp->ctf_str[CTF_STRTAB_0].cts_len;) + { + char *str; + if (asprintf (&str, "%lx: %s", s - fp->ctf_str[CTF_STRTAB_0].cts_strs, + s) < 0) + return (ctf_set_errno (fp, ENOMEM)); + ctf_dump_append (state, str); + s += strlen (s) + 1; + } + + return 0; +} + +/* Dump a particular section of a CTF file, in textual form. Call with a + pointer to a NULL STATE: each call emits a dynamically allocated string + containing a description of one entity in the specified section, in order. + Only the first call (with a NULL state) may vary SECT. Once the CTF section + has been entirely dumped, the call returns NULL and frees and annuls the + STATE, ready for another section to be dumped. The returned textual content + may span multiple lines: between each call the FUNC is called with one + textual line at a time, and should return a suitably decorated line (it can + allocate a new one and return it if it likes). */ + +char * +ctf_dump (ctf_file_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect, + ctf_dump_decorate_f *func, void *arg) +{ + char *str; + char *line; + ctf_dump_state_t *state = NULL; + + if (*statep == NULL) + { + /* Data collection. Transforming a call-at-a-time iterator into a + return-at-a-time iterator in a language without call/cc is annoying. It + is easiest to simply collect everything at once and then return it bit + by bit. The first call will take (much) longer than otherwise, but the + amortized time needed is the same. */ + + if ((*statep = ctf_alloc (sizeof (struct ctf_dump_state))) == NULL) + { + ctf_set_errno (fp, ENOMEM); + goto end; + } + state = *statep; + + memset (state, 0, sizeof (struct ctf_dump_state)); + state->cds_fp = fp; + state->cds_sect = sect; + + switch (sect) + { + case CTF_SECT_HEADER: + /* Nothing doable (yet): entire header is discarded after read-phase. */ + str = strdup (""); + break; + case CTF_SECT_LABEL: + if (ctf_label_iter (fp, ctf_dump_label, state) < 0) + { + if (ctf_errno (fp) != ECTF_NOLABELDATA) + goto end; /* errno is set for us. */ + ctf_set_errno (fp, 0); + } + break; + case CTF_SECT_OBJT: + if (ctf_dump_objts (fp, state) < 0) + goto end; /* errno is set for us. */ + break; + case CTF_SECT_FUNC: + if (ctf_dump_funcs (fp, state) < 0) + goto end; /* errno is set for us. */ + break; + case CTF_SECT_VAR: + if (ctf_variable_iter (fp, ctf_dump_var, state) < 0) + goto end; /* errno is set for us. */ + break; + case CTF_SECT_TYPE: + if (ctf_type_iter (fp, ctf_dump_type, state) < 0) + goto end; /* errno is set for us. */ + break; + case CTF_SECT_STR: + ctf_dump_str (fp, state); + break; + default: + ctf_set_errno (fp, ECTF_DUMPSECTUNKNOWN); + goto end; + } + } + else + { + state = *statep; + + if (state->cds_sect != sect) + { + ctf_set_errno (fp, ECTF_DUMPSECTCHANGED); + goto end; + } + } + + if (state->cds_current == NULL) + state->cds_current = ctf_list_next (&state->cds_items); + else + state->cds_current = ctf_list_next (state->cds_current); + + if (state->cds_current == NULL) + goto end; + + /* Hookery. There is some extra complexity to preserve linefeeds within each + item while removing linefeeds at the end. */ + if (func) + { + size_t len; + + str = NULL; + for (line = state->cds_current->cdi_item; line && *line; ) + { + char *nline = line; + char *ret; + + nline = strchr (line, '\n'); + if (nline) + nline[0] = '\0'; + + ret = func (sect, line, arg); + str = ctf_str_append (str, ret); + str = ctf_str_append (str, "\n"); + if (ret != line) + free (ret); + + if (nline) + { + nline[0] = '\n'; + nline++; + } + + line = nline; + } + + len = strlen (str); + + if (str[len-1] == '\n') + str[len-1] = '\0'; + } + else + str = strdup (state->cds_current->cdi_item); + + ctf_set_errno (fp, 0); + return str; + + end: + ctf_dump_free (state); + ctf_free (state, sizeof (struct ctf_dump_state)); + ctf_set_errno (fp, 0); + *statep = NULL; + return NULL; +} -- 2.21.0.237.gd0cfaa883d