mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
8b37e7b63e
This commit adds a long-missing piece of infrastructure to libctf: the ability to report errors and warnings using all the power of printf, rather than being restricted to one errno value. Internally, libctf calls ctf_err_warn() to add errors and warnings to a list: a new iterator ctf_errwarning_next() then consumes this list one by one and hands it to the caller, which can free it. New errors and warnings are added until the list is consumed by the caller or the ctf_file_t is closed, so you can dump them at intervals. The caller can of course choose to print only those warnings it wants. (I am not sure whether we want objdump, readelf or ld to print warnings or not: right now I'm printing them, but maybe we only want to print errors? This entirely depends on whether warnings are voluminous things describing e.g. the inability to emit single types because of name clashes or something. There are no users of this infrastructure yet, so it's hard to say.) There is no internationalization here yet, but this at least adds a place where internationalization can be added, to one of ctf_errwarning_next or ctf_err_warn. We also provide a new ctf_assert() function which uses this infrastructure to provide non-fatal assertion failures while emitting an assert-like string to the caller: to save space and avoid needlessly duplicating unchanging strings, the assertion test is inlined but the print-things-out failure case is not. All assertions in libctf will be converted to use this machinery in future commits and propagate assertion-failure errors up, so that the linker in particular cannot be killed by libctf assertion failures when it could perfectly well just print warnings and drop the CTF section. include/ * ctf-api.h (ECTF_INTERNAL): Adjust error text. (ctf_errwarning_next): New. libctf/ * ctf-impl.h (ctf_assert): New. (ctf_err_warning_t): Likewise. (ctf_file_t) <ctf_errs_warnings>: Likewise. (ctf_err_warn): New prototype. (ctf_assert_fail_internal): Likewise. * ctf-inlines.h (ctf_assert_internal): Likewise. * ctf-open.c (ctf_file_close): Free ctf_errs_warnings. * ctf-create.c (ctf_serialize): Copy it on serialization. * ctf-subr.c (ctf_err_warn): New, add an error/warning. (ctf_errwarning_next): New iterator, free and pass back errors/warnings in succession. * libctf.ver (ctf_errwarning_next): Add. ld/ * ldlang.c (lang_ctf_errs_warnings): New, print CTF errors and warnings. Assert when libctf asserts. (lang_merge_ctf): Call it. (land_write_ctf): Likewise. binutils/ * objdump.c (ctf_archive_member): Print CTF errors and warnings. * readelf.c (dump_ctf_archive_member): Likewise.
98 lines
2.4 KiB
C
98 lines
2.4 KiB
C
/* Inline functions.
|
|
Copyright (C) 2020 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/>. */
|
|
|
|
#ifndef _CTF_INLINES_H
|
|
#define _CTF_INLINES_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
#include "config.h"
|
|
|
|
#ifndef _libctf_malloc_
|
|
#error "ctf-inlines.h" should not be included directly: include "ctf-impl.h".
|
|
#endif
|
|
|
|
static inline ssize_t
|
|
ctf_get_ctt_size (const ctf_file_t *fp,
|
|
const ctf_type_t *tp,
|
|
ssize_t *sizep,
|
|
ssize_t *incrementp)
|
|
{
|
|
return (fp->ctf_fileops->ctfo_get_ctt_size (fp, tp, sizep, incrementp));
|
|
}
|
|
|
|
static inline int
|
|
ctf_forwardable_kind (int kind)
|
|
{
|
|
return (kind == CTF_K_STRUCT || kind == CTF_K_UNION || kind == CTF_K_ENUM);
|
|
}
|
|
|
|
static inline int
|
|
ctf_dynhash_cnext_sorted (ctf_dynhash_t *h, ctf_next_t **i, const void **key,
|
|
const void **value, ctf_hash_sort_f sort_fun,
|
|
void *sort_arg)
|
|
{
|
|
return ctf_dynhash_next_sorted (h, i, (void **) key, (void **) value,
|
|
sort_fun, sort_arg);
|
|
}
|
|
|
|
static inline int
|
|
ctf_dynhash_cnext (ctf_dynhash_t *h, ctf_next_t **it,
|
|
const void **key, const void **value)
|
|
{
|
|
return ctf_dynhash_next (h, it, (void **) key, (void **) value);
|
|
}
|
|
|
|
static inline int
|
|
ctf_dynhash_cinsert (ctf_dynhash_t *h, const void *k, const void *v)
|
|
{
|
|
return ctf_dynhash_insert (h, (void *) k, (void *) v);
|
|
}
|
|
|
|
static inline int
|
|
ctf_dynset_cnext (ctf_dynset_t *h, ctf_next_t **it, const void **key)
|
|
{
|
|
return ctf_dynset_next (h, it, (void **) key);
|
|
}
|
|
|
|
static inline int
|
|
ctf_dynset_cinsert (ctf_dynset_t *h, const void *k)
|
|
{
|
|
return ctf_dynset_insert (h, (void *) k);
|
|
}
|
|
|
|
static inline int
|
|
ctf_assert_internal (ctf_file_t *fp, const char *file, size_t line,
|
|
const char *exprstr, int expr)
|
|
{
|
|
if (_libctf_unlikely_ (!expr))
|
|
ctf_assert_fail_internal (fp, file, line, exprstr);
|
|
|
|
return expr;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _CTF_INLINES_H */
|