[binutils-gdb] libctf: don't pass errno into ctf_err_warn so often

[binutils-gdb] libctf: don't pass errno into ctf_err_warn so often

[Nick Alcock]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=7e1368b58f37f89152c5811eab98f4667d807b04

commit 7e1368b58f37f89152c5811eab98f4667d807b04
Author: Nick Alcock <nick.alcock@oracle.com>
Date:   Fri Apr 12 14:46:00 2024 +0100

    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:
---
 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, 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);
 }