From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2103) id C4BF13849AD9; Fri, 19 Apr 2024 15:52:36 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C4BF13849AD9 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1713541956; bh=qfbasew21IJ6pmVZYFc7R+F6c6Tg3x1O8JiY+vVFoSI=; h=From:To:Subject:Date:From; b=AEijDtaIWZSz7MvIIApmTuBz6XVjelYHMYi3x3Sbe9AsqYwBN96LvaUSGP1N2i9Td LC6RqU0p+bkC7x9ri7zf77wFW0i0gyGrCBodpB4tZWeRMWc4KHx9ZlEIibEhHZHqJX /79zD2BPGwndkr9j1E9/b9roEgrJnUFtpe9f+o/E= Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Nick Alcock To: binutils-cvs@sourceware.org Subject: [binutils-gdb] libctf: don't pass errno into ctf_err_warn so often X-Act-Checkin: binutils-gdb X-Git-Author: Nick Alcock X-Git-Refname: refs/heads/master X-Git-Oldrev: b5ac272b872db997adc184b23da74f755d4b8f08 X-Git-Newrev: 7e1368b58f37f89152c5811eab98f4667d807b04 Message-Id: <20240419155236.C4BF13849AD9@sourceware.org> Date: Fri, 19 Apr 2024 15:52:36 +0000 (GMT) List-Id: https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D7e1368b58f37= f89152c5811eab98f4667d807b04 commit 7e1368b58f37f89152c5811eab98f4667d807b04 Author: Nick Alcock Date: Fri Apr 12 14:46:00 2024 +0100 libctf: don't pass errno into ctf_err_warn so often =20 The libctf-internal warning function ctf_err_warn() can be passed a lib= ctf errno as a parameter, and will add its textual errmsg form to the passe= d-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. =20 There are still a lot of places where we do =20 ctf_err_warn (fp, 0, EFOO, ...); return ctf_set_errno (fp, 0, EFOO); =20 I've left all of those alone, because fixing it makes the code a bit lo= nger: 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. =20 libctf/ =20 * ctf-dedup.c (ctf_dedup_walk_output_mapping): Drop the errno a= rg. (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: --- libctf/ctf-dedup.c | 8 ++++---- libctf/ctf-link.c | 22 +++++++++++----------- libctf/ctf-lookup.c | 4 ++-- libctf/ctf-subr.c | 4 ++-- 4 files changed, 19 insertions(+), 19 deletions(-) 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, ct= f_dict_t **inputs, } if (err !=3D 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 **inpu= ts, uint32_t ninputs, =20 if ((outputs =3D calloc (num_outputs, sizeof (ctf_dict_t *))) =3D=3D NUL= L) { - 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 =3D num_outputs; @@ -3146,7 +3146,7 @@ ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *s= rc_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, c= onst char *cu_name) =20 if ((cu_fp =3D ctf_create (&err)) =3D=3D 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; } =20 @@ -886,9 +886,9 @@ ctf_link_deduplicating_close_inputs (ctf_dict_t *fp, ct= f_dynhash_t *cu_names, } if (err !=3D 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) !=3D 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) =20 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; } =20 @@ -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 *symn= ame, 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; =20 } 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); }