1 /* Textual dumping of CTF data.
2 Copyright (C) 2019 Free Software Foundation, Inc.
4 This file is part of libctf.
6 libctf is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING. If not see
18 <http://www.gnu.org/licenses/>. */
23 /* One item to be dumped, in string form. */
25 typedef struct ctf_dump_item
31 /* Cross-call state for dumping. Basically just enough to track the section in
32 use and a list of return strings. */
36 ctf_sect_names_t cds_sect
;
38 ctf_dump_item_t
*cds_current
;
42 /* Cross-call state for ctf_dump_member. */
44 typedef struct ctf_dump_membstate
48 } ctf_dump_membstate_t
;
51 ctf_dump_append (ctf_dump_state_t
*state
, char *str
)
55 if ((cdi
= ctf_alloc (sizeof (struct ctf_dump_item
))) == NULL
)
56 return (ctf_set_errno (state
->cds_fp
, ENOMEM
));
59 ctf_list_append (&state
->cds_items
, cdi
);
64 ctf_dump_free (ctf_dump_state_t
*state
)
66 ctf_dump_item_t
*cdi
, *next_cdi
;
71 for (cdi
= ctf_list_next (&state
->cds_items
); cdi
!= NULL
;
75 next_cdi
= ctf_list_next (cdi
);
80 /* Slices need special handling to distinguish them from their referenced
84 ctf_is_slice (ctf_file_t
*fp
, ctf_id_t id
, ctf_encoding_t
*enc
)
86 int kind
= ctf_type_kind (fp
, id
);
88 return (((kind
== CTF_K_INTEGER
) || (kind
== CTF_K_ENUM
)
89 || (kind
== CTF_K_FLOAT
))
90 && ctf_type_reference (fp
, id
) != CTF_ERR
91 && ctf_type_encoding (fp
, id
, enc
) == 0);
94 /* Return a dump for a single type, without member info: but do show the
98 ctf_dump_format_type (ctf_file_t
*fp
, ctf_id_t id
, int flag
)
101 char *str
= NULL
, *bit
= NULL
, *buf
= NULL
;
107 const char *nonroot_leader
= "";
108 const char *nonroot_trailer
= "";
111 if (flag
== CTF_ADD_NONROOT
)
113 nonroot_leader
= "{";
114 nonroot_trailer
= "}";
117 buf
= ctf_type_aname (fp
, id
);
121 /* Slices get a different print representation. */
123 if (ctf_is_slice (fp
, id
, &enc
))
125 ctf_type_encoding (fp
, id
, &enc
);
126 if (asprintf (&bit
, " %s%lx: [slice 0x%x:0x%x]%s",
127 nonroot_leader
, id
, enc
.cte_offset
, enc
.cte_bits
,
128 nonroot_trailer
) < 0)
133 if (asprintf (&bit
, " %s%lx: %s (size 0x%lx)%s", nonroot_leader
,
134 id
, buf
[0] == '\0' ? "(nameless)" : buf
,
135 (unsigned long) ctf_type_size (fp
, id
),
136 nonroot_trailer
) < 0)
141 str
= ctf_str_append (str
, bit
);
145 new_id
= ctf_type_reference (fp
, id
);
146 if (new_id
!= CTF_ERR
)
147 str
= ctf_str_append (str
, " ->");
148 } while (new_id
!= CTF_ERR
);
150 if (ctf_errno (fp
) != ECTF_NOTREF
)
162 ctf_set_errno (fp
, ENOMEM
);
166 /* Dump one string field from the file header into the cds_items. */
168 ctf_dump_header_strfield (ctf_file_t
*fp
, ctf_dump_state_t
*state
,
169 const char *name
, uint32_t value
)
174 if (asprintf (&str
, "%s: %s\n", name
, ctf_strptr (fp
, value
)) < 0)
176 ctf_dump_append (state
, str
);
181 return (ctf_set_errno (fp
, -ENOMEM
));
184 /* Dump one section-offset field from the file header into the cds_items. */
186 ctf_dump_header_sectfield (ctf_file_t
*fp
, ctf_dump_state_t
*state
,
187 const char *sect
, uint32_t off
, uint32_t nextoff
)
192 if (asprintf (&str
, "%s:\t0x%lx -- 0x%lx (0x%lx bytes)\n", sect
,
193 (unsigned long) off
, (unsigned long) (nextoff
- 1),
194 (unsigned long) (nextoff
- off
)) < 0)
196 ctf_dump_append (state
, str
);
201 return (ctf_set_errno (fp
, -ENOMEM
));
204 /* Dump the file header into the cds_items. */
206 ctf_dump_header (ctf_file_t
*fp
, ctf_dump_state_t
*state
)
209 const ctf_header_t
*hp
= fp
->ctf_header
;
210 const char *vertab
[] =
212 NULL
, "CTF_VERSION_1",
213 "CTF_VERSION_1_UPGRADED_3 (latest format, version 1 type "
216 "CTF_VERSION_3", NULL
218 const char *verstr
= NULL
;
220 if (asprintf (&str
, "Magic number: %x\n", hp
->cth_magic
) < 0)
222 ctf_dump_append (state
, str
);
224 if (hp
->cth_version
<= CTF_VERSION
)
225 verstr
= vertab
[hp
->cth_version
];
228 verstr
= "(not a valid version)";
230 if (asprintf (&str
, "Version: %i (%s)\n", hp
->cth_version
,
233 ctf_dump_append (state
, str
);
235 /* Everything else is only printed if present. */
237 /* The flags are unusual in that they represent the ctf_file_t *in memory*:
238 flags representing compression, etc, are turned off as the file is
239 decompressed. So we store a copy of the flags before they are changed, for
242 if (fp
->ctf_openflags
> 0)
244 if (fp
->ctf_openflags
)
245 if (asprintf (&str
, "Flags: 0x%x (%s)", fp
->ctf_openflags
,
246 fp
->ctf_openflags
& CTF_F_COMPRESS
? "CTF_F_COMPRESS"
249 ctf_dump_append (state
, str
);
252 if (ctf_dump_header_strfield (fp
, state
, "Parent label",
253 hp
->cth_parlabel
) < 0)
256 if (ctf_dump_header_strfield (fp
, state
, "Parent name", hp
->cth_parname
) < 0)
259 if (ctf_dump_header_strfield (fp
, state
, "Compilation unit name",
263 if (ctf_dump_header_sectfield (fp
, state
, "Label section", hp
->cth_lbloff
,
264 hp
->cth_objtoff
) < 0)
267 if (ctf_dump_header_sectfield (fp
, state
, "Data object section",
268 hp
->cth_objtoff
, hp
->cth_funcoff
) < 0)
271 if (ctf_dump_header_sectfield (fp
, state
, "Function info section",
272 hp
->cth_funcoff
, hp
->cth_varoff
) < 0)
275 if (ctf_dump_header_sectfield (fp
, state
, "Variable section",
276 hp
->cth_varoff
, hp
->cth_typeoff
) < 0)
279 if (ctf_dump_header_sectfield (fp
, state
, "Type section",
280 hp
->cth_typeoff
, hp
->cth_stroff
) < 0)
283 if (ctf_dump_header_sectfield (fp
, state
, "String section", hp
->cth_stroff
,
284 hp
->cth_stroff
+ hp
->cth_strlen
+ 1) < 0)
289 return (ctf_set_errno (fp
, -ENOMEM
));
292 /* Dump a single label into the cds_items. */
295 ctf_dump_label (const char *name
, const ctf_lblinfo_t
*info
,
300 ctf_dump_state_t
*state
= arg
;
302 if (asprintf (&str
, "%s -> ", name
) < 0)
303 return (ctf_set_errno (state
->cds_fp
, ENOMEM
));
305 if ((typestr
= ctf_dump_format_type (state
->cds_fp
, info
->ctb_type
,
306 CTF_ADD_ROOT
)) == NULL
)
309 return -1; /* errno is set for us. */
312 str
= ctf_str_append (str
, typestr
);
315 ctf_dump_append (state
, str
);
319 /* Dump all the object entries into the cds_items. (There is no iterator for
320 this section, so we just do it in a loop, and this function handles all of
321 them, rather than only one. */
324 ctf_dump_objts (ctf_file_t
*fp
, ctf_dump_state_t
*state
)
328 for (i
= 0; i
< fp
->ctf_nsyms
; i
++)
332 const char *sym_name
;
335 if ((type
= ctf_lookup_by_symbol (state
->cds_fp
, i
)) == CTF_ERR
)
336 switch (ctf_errno (state
->cds_fp
))
338 /* Most errors are just an indication that this symbol is not a data
339 symbol, but this one indicates that we were called wrong, on a
340 CTF file with no associated symbol table. */
349 sym_name
= ctf_lookup_symbol_name (fp
, i
);
350 if (sym_name
[0] == '\0')
352 if (asprintf (&str
, "%lx -> ", (unsigned long) i
) < 0)
353 return (ctf_set_errno (fp
, ENOMEM
));
357 if (asprintf (&str
, "%s (%lx) -> ", sym_name
, (unsigned long) i
) < 0)
358 return (ctf_set_errno (fp
, ENOMEM
));
362 if ((typestr
= ctf_dump_format_type (state
->cds_fp
, type
,
363 CTF_ADD_ROOT
)) == NULL
)
366 return -1; /* errno is set for us. */
369 str
= ctf_str_append (str
, typestr
);
372 ctf_dump_append (state
, str
);
377 /* Dump all the function entries into the cds_items. (As above, there is no
378 iterator for this section.) */
381 ctf_dump_funcs (ctf_file_t
*fp
, ctf_dump_state_t
*state
)
385 for (i
= 0; i
< fp
->ctf_nsyms
; i
++)
389 const char *sym_name
;
395 if ((type
= ctf_func_info (state
->cds_fp
, i
, &fi
)) == CTF_ERR
)
396 switch (ctf_errno (state
->cds_fp
))
398 /* Most errors are just an indication that this symbol is not a data
399 symbol, but this one indicates that we were called wrong, on a
400 CTF file with no associated symbol table. */
407 if ((args
= calloc (fi
.ctc_argc
, sizeof (ctf_id_t
))) == NULL
)
408 return (ctf_set_errno (fp
, ENOMEM
));
411 if ((str
= ctf_type_aname (state
->cds_fp
, type
)) == NULL
)
414 str
= ctf_str_append (str
, " ");
418 sym_name
= ctf_lookup_symbol_name (fp
, i
);
419 if (sym_name
[0] == '\0')
421 if (asprintf (&bit
, "0x%lx ", (unsigned long) i
) < 0)
426 if (asprintf (&bit
, "%s (0x%lx) ", sym_name
, (unsigned long) i
) < 0)
429 str
= ctf_str_append (str
, bit
);
430 str
= ctf_str_append (str
, " (");
433 /* Function arguments. */
435 if (ctf_func_args (state
->cds_fp
, i
, fi
.ctc_argc
, args
) < 0)
438 for (j
= 0; j
< fi
.ctc_argc
; j
++)
440 if ((bit
= ctf_type_aname (state
->cds_fp
, args
[j
])) == NULL
)
442 str
= ctf_str_append (str
, bit
);
443 if ((j
< fi
.ctc_argc
- 1) || (fi
.ctc_flags
& CTF_FUNC_VARARG
))
444 str
= ctf_str_append (str
, ", ");
448 if (fi
.ctc_flags
& CTF_FUNC_VARARG
)
449 str
= ctf_str_append (str
, "...");
450 str
= ctf_str_append (str
, ")");
453 ctf_dump_append (state
, str
);
459 return (ctf_set_errno (fp
, ENOMEM
));
463 return -1; /* errno is set for us. */
468 /* Dump a single variable into the cds_items. */
470 ctf_dump_var (const char *name
, ctf_id_t type
, void *arg
)
474 ctf_dump_state_t
*state
= arg
;
476 if (asprintf (&str
, "%s -> ", name
) < 0)
477 return (ctf_set_errno (state
->cds_fp
, ENOMEM
));
479 if ((typestr
= ctf_dump_format_type (state
->cds_fp
, type
,
480 CTF_ADD_ROOT
)) == NULL
)
483 return -1; /* errno is set for us. */
486 str
= ctf_str_append (str
, typestr
);
489 ctf_dump_append (state
, str
);
493 /* Dump a single member into the string in the membstate. */
495 ctf_dump_member (const char *name
, ctf_id_t id
, unsigned long offset
,
496 int depth
, void *arg
)
498 ctf_dump_membstate_t
*state
= arg
;
499 char *typestr
= NULL
;
504 for (i
= 0; i
< depth
; i
++)
505 *state
->cdm_str
= ctf_str_append (*state
->cdm_str
, " ");
507 if ((typestr
= ctf_type_aname (state
->cdm_fp
, id
)) == NULL
)
510 if (asprintf (&bit
, " [0x%lx] (ID 0x%lx) (kind %i) %s %s (aligned at 0x%lx",
511 offset
, id
, ctf_type_kind (state
->cdm_fp
, id
), typestr
, name
,
512 (unsigned long) ctf_type_align (state
->cdm_fp
, id
)) < 0)
514 *state
->cdm_str
= ctf_str_append (*state
->cdm_str
, bit
);
520 if ((ctf_type_kind (state
->cdm_fp
, id
) == CTF_K_INTEGER
)
521 || (ctf_type_kind (state
->cdm_fp
, id
) == CTF_K_FLOAT
)
522 || (ctf_is_slice (state
->cdm_fp
, id
, &ep
) == CTF_K_ENUM
))
524 ctf_type_encoding (state
->cdm_fp
, id
, &ep
);
525 if (asprintf (&bit
, ", format 0x%x, offset:bits 0x%x:0x%x", ep
.cte_format
,
526 ep
.cte_offset
, ep
.cte_bits
) < 0)
528 *state
->cdm_str
= ctf_str_append (*state
->cdm_str
, bit
);
533 *state
->cdm_str
= ctf_str_append (*state
->cdm_str
, ")\n");
539 return (ctf_set_errno (state
->cdm_fp
, ENOMEM
));
542 /* Dump a single type into the cds_items. */
545 ctf_dump_type (ctf_id_t id
, int flag
, void *arg
)
548 ctf_dump_state_t
*state
= arg
;
549 ctf_dump_membstate_t membstate
= { &str
, state
->cds_fp
};
552 if ((str
= ctf_dump_format_type (state
->cds_fp
, id
, flag
)) == NULL
)
555 str
= ctf_str_append (str
, "\n");
556 if ((ctf_type_visit (state
->cds_fp
, id
, ctf_dump_member
, &membstate
)) < 0)
559 /* Trim off the last linefeed added by ctf_dump_member(). */
561 if (str
[len
-1] == '\n')
564 ctf_dump_append (state
, str
);
569 return -1; /* errno is set for us. */
572 /* Dump the string table into the cds_items. */
575 ctf_dump_str (ctf_file_t
*fp
, ctf_dump_state_t
*state
)
577 const char *s
= fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
;
579 for (; s
< fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
+
580 fp
->ctf_str
[CTF_STRTAB_0
].cts_len
;)
583 if (asprintf (&str
, "%lx: %s",
584 (unsigned long) (s
- fp
->ctf_str
[CTF_STRTAB_0
].cts_strs
),
586 return (ctf_set_errno (fp
, ENOMEM
));
587 ctf_dump_append (state
, str
);
594 /* Dump a particular section of a CTF file, in textual form. Call with a
595 pointer to a NULL STATE: each call emits a dynamically allocated string
596 containing a description of one entity in the specified section, in order.
597 Only the first call (with a NULL state) may vary SECT. Once the CTF section
598 has been entirely dumped, the call returns NULL and frees and annuls the
599 STATE, ready for another section to be dumped. The returned textual content
600 may span multiple lines: between each call the FUNC is called with one
601 textual line at a time, and should return a suitably decorated line (it can
602 allocate a new one and return it if it likes). */
605 ctf_dump (ctf_file_t
*fp
, ctf_dump_state_t
**statep
, ctf_sect_names_t sect
,
606 ctf_dump_decorate_f
*func
, void *arg
)
610 ctf_dump_state_t
*state
= NULL
;
614 /* Data collection. Transforming a call-at-a-time iterator into a
615 return-at-a-time iterator in a language without call/cc is annoying. It
616 is easiest to simply collect everything at once and then return it bit
617 by bit. The first call will take (much) longer than otherwise, but the
618 amortized time needed is the same. */
620 if ((*statep
= ctf_alloc (sizeof (struct ctf_dump_state
))) == NULL
)
622 ctf_set_errno (fp
, ENOMEM
);
627 memset (state
, 0, sizeof (struct ctf_dump_state
));
629 state
->cds_sect
= sect
;
633 case CTF_SECT_HEADER
:
634 ctf_dump_header (fp
, state
);
637 if (ctf_label_iter (fp
, ctf_dump_label
, state
) < 0)
639 if (ctf_errno (fp
) != ECTF_NOLABELDATA
)
640 goto end
; /* errno is set for us. */
641 ctf_set_errno (fp
, 0);
645 if (ctf_dump_objts (fp
, state
) < 0)
646 goto end
; /* errno is set for us. */
649 if (ctf_dump_funcs (fp
, state
) < 0)
650 goto end
; /* errno is set for us. */
653 if (ctf_variable_iter (fp
, ctf_dump_var
, state
) < 0)
654 goto end
; /* errno is set for us. */
657 if (ctf_type_iter_all (fp
, ctf_dump_type
, state
) < 0)
658 goto end
; /* errno is set for us. */
661 ctf_dump_str (fp
, state
);
664 ctf_set_errno (fp
, ECTF_DUMPSECTUNKNOWN
);
672 if (state
->cds_sect
!= sect
)
674 ctf_set_errno (fp
, ECTF_DUMPSECTCHANGED
);
679 if (state
->cds_current
== NULL
)
680 state
->cds_current
= ctf_list_next (&state
->cds_items
);
682 state
->cds_current
= ctf_list_next (state
->cds_current
);
684 if (state
->cds_current
== NULL
)
687 /* Hookery. There is some extra complexity to preserve linefeeds within each
688 item while removing linefeeds at the end. */
694 for (line
= state
->cds_current
->cdi_item
; line
&& *line
; )
699 nline
= strchr (line
, '\n');
703 ret
= func (sect
, line
, arg
);
704 str
= ctf_str_append (str
, ret
);
705 str
= ctf_str_append (str
, "\n");
720 if (str
[len
-1] == '\n')
724 str
= strdup (state
->cds_current
->cdi_item
);
726 ctf_set_errno (fp
, 0);
730 ctf_dump_free (state
);
732 ctf_set_errno (fp
, 0);