From: Nick Alcock Date: Fri, 12 Apr 2024 13:46:00 +0000 (+0100) Subject: libctf: don't pass errno into ctf_err_warn so often X-Git-Tag: gdb-15-branchpoint~318 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=7e1368b58f37f89152c5811eab98f4667d807b04;p=thirdparty%2Fbinutils-gdb.git libctf: don't pass errno into ctf_err_warn so often The libctf-internal warning function ctf_err_warn() can be passed a libctf errno as a parameter, and will add its textual errmsg form to the passed-in error message. But if there is an error on the fp already, and this is specifically an error and not a warning, ctf_err_warn() will print the error out regardless: there's no need to pass in anything but 0. There are still a lot of places where we do ctf_err_warn (fp, 0, EFOO, ...); return ctf_set_errno (fp, 0, EFOO); I've left all of those alone, because fixing it makes the code a bit longer: but fixing the cases where no return is involved and the error has just been set on the fp itself costs nothing and reduces redundancy a bit. libctf/ * ctf-dedup.c (ctf_dedup_walk_output_mapping): Drop the errno arg. (ctf_dedup_emit): Likewise. (ctf_dedup_type_mapping): Likewise. * ctf-link.c (ctf_create_per_cu): Likewise. (ctf_link_deduplicating_close_inputs): Likewise. (ctf_link_deduplicating_one_symtypetab): Likewise. (ctf_link_deduplicating_per_cu): Likewise. * ctf-lookup.c (ctf_lookup_symbol_idx): Likewise. * ctf-subr.c (ctf_assert_fail_internal): Likewise. --- diff --git a/libctf/ctf-dedup.c b/libctf/ctf-dedup.c index dc7a1cf79e2..c7db6ab4965 100644 --- a/libctf/ctf-dedup.c +++ b/libctf/ctf-dedup.c @@ -2398,8 +2398,8 @@ ctf_dedup_walk_output_mapping (ctf_dict_t *output, ctf_dict_t **inputs, } if (err != ECTF_NEXT_END) { - ctf_err_warn (output, 0, err, _("cannot recurse over output mapping")); ctf_set_errno (output, err); + ctf_err_warn (output, 0, 0, _("cannot recurse over output mapping")); goto err; } ctf_dynset_destroy (already_visited); @@ -3092,9 +3092,9 @@ ctf_dedup_emit (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs, if ((outputs = calloc (num_outputs, sizeof (ctf_dict_t *))) == NULL) { - ctf_err_warn (output, 0, ENOMEM, - _("out of memory allocating link outputs array")); ctf_set_errno (output, ENOMEM); + ctf_err_warn (output, 0, 0, + _("out of memory allocating link outputs array")); return NULL; } *noutputs = num_outputs; @@ -3146,7 +3146,7 @@ ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *src_fp, ctf_id_t src_type) else { ctf_set_errno (fp, ECTF_INTERNAL); - ctf_err_warn (fp, 0, ECTF_INTERNAL, + ctf_err_warn (fp, 0, 0, _("dict %p passed to ctf_dedup_type_mapping is not a " "deduplicated output"), (void *) fp); return CTF_ERR; diff --git a/libctf/ctf-link.c b/libctf/ctf-link.c index 44d4e496f6a..801b6ee599d 100644 --- a/libctf/ctf-link.c +++ b/libctf/ctf-link.c @@ -330,9 +330,9 @@ ctf_create_per_cu (ctf_dict_t *fp, ctf_dict_t *input, const char *cu_name) if ((cu_fp = ctf_create (&err)) == NULL) { - ctf_err_warn (fp, 0, err, _("cannot create per-CU CTF archive for " - "input CU %s"), cu_name); ctf_set_errno (fp, err); + ctf_err_warn (fp, 0, 0, _("cannot create per-CU CTF archive for " + "input CU %s"), cu_name); return NULL; } @@ -886,9 +886,9 @@ ctf_link_deduplicating_close_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names, } if (err != ECTF_NEXT_END) { - ctf_err_warn (fp, 0, err, _("iteration error in deduplicating link " - "input freeing")); ctf_set_errno (fp, err); + ctf_err_warn (fp, 0, 0, _("iteration error in deduplicating link " + "input freeing")); } } else @@ -1087,8 +1087,8 @@ ctf_link_deduplicating_one_symtypetab (ctf_dict_t *fp, ctf_dict_t *input, if (ctf_errno (input) != ECTF_NEXT_END) { ctf_set_errno (fp, ctf_errno (input)); - ctf_err_warn (fp, 0, ctf_errno (input), - functions ? _("iterating over function symbols") : + ctf_err_warn (fp, 0, 0, functions ? + _("iterating over function symbols") : _("iterating over data symbols")); return -1; } @@ -1156,9 +1156,9 @@ ctf_link_deduplicating_per_cu (ctf_dict_t *fp) if (labs ((long int) ninputs) > 0xfffffffe) { - ctf_err_warn (fp, 0, EFBIG, _("too many inputs in deduplicating " - "link: %li"), (long int) ninputs); ctf_set_errno (fp, EFBIG); + ctf_err_warn (fp, 0, 0, _("too many inputs in deduplicating " + "link: %li"), (long int) ninputs); goto err_open_inputs; } @@ -1180,10 +1180,10 @@ ctf_link_deduplicating_per_cu (ctf_dict_t *fp) &ai, NULL, 0, &err); if (!only_input->clin_fp) { - ctf_err_warn (fp, 0, err, _("cannot open archive %s in " - "CU-mapped CTF link"), - only_input->clin_filename); ctf_set_errno (fp, err); + ctf_err_warn (fp, 0, 0, _("cannot open archive %s in " + "CU-mapped CTF link"), + only_input->clin_filename); goto err_open_inputs; } ctf_next_destroy (ai); diff --git a/libctf/ctf-lookup.c b/libctf/ctf-lookup.c index 1b1ebedc4b7..e4d18bec112 100644 --- a/libctf/ctf-lookup.c +++ b/libctf/ctf-lookup.c @@ -665,8 +665,8 @@ ctf_lookup_symbol_idx (ctf_dict_t *fp, const char *symname, int try_parent, } oom: ctf_set_errno (fp, ENOMEM); - ctf_err_warn (fp, 0, ENOMEM, _("cannot allocate memory for symbol " - "lookup hashtab")); + ctf_err_warn (fp, 0, 0, _("cannot allocate memory for symbol " + "lookup hashtab")); return (unsigned long) -1; } diff --git a/libctf/ctf-subr.c b/libctf/ctf-subr.c index ecc68848d31..deb9e0ba5c4 100644 --- a/libctf/ctf-subr.c +++ b/libctf/ctf-subr.c @@ -340,7 +340,7 @@ void ctf_assert_fail_internal (ctf_dict_t *fp, const char *file, size_t line, const char *exprstr) { - ctf_err_warn (fp, 0, ECTF_INTERNAL, _("%s: %lu: libctf assertion failed: %s"), - file, (long unsigned int) line, exprstr); ctf_set_errno (fp, ECTF_INTERNAL); + ctf_err_warn (fp, 0, 0, _("%s: %lu: libctf assertion failed: %s"), + file, (long unsigned int) line, exprstr); }