--- /dev/null
+/* Textual dumping of CTF data.
+ 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/>. */
+
+#include <ctf-impl.h>
+#include <string.h>
+
+/* 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);
+ }
+}
+
+/* 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);
+ ctf_set_errno (fp, 0);
+ *statep = NULL;
+ return NULL;
+}
projects / binutils-gdb.git / commitdiff