Set specific DWFL_E_* codes.

diff --git a/libdwfl/dwfl_frame_state.c b/libdwfl/dwfl_frame_state.c
index 54267324314e07572d6fb705f641fb34af85a31e..1229aa29cbaeb1d47f3745bf980c2499c1e0d4ad 100644 (file)
--- a/libdwfl/dwfl_frame_state.c
+++ b/libdwfl/dwfl_frame_state.c
@@ -49,14 +49,14 @@ __libdwfl_state_fetch_pc (Dwfl_Frame_State *state)
       Dwarf_CIE abi_info;
       if (ebl_abi_cfi (ebl, &abi_info) != 0)
        {
-         __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+         __libdwfl_seterrno (DWFL_E_LIBEBL);
          return false;
        }
       unsigned ra = abi_info.return_address_register;
       /* dwarf_frame_state_reg_is_set is not applied here.  */
       if (ra >= ebl_frame_state_nregs (ebl))
        {
-         __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+         __libdwfl_seterrno (DWFL_E_LIBEBL_BAD);
          return false;
        }
       state->pc = state->regs[ra];

diff --git a/libdwfl/dwfl_frame_state_core.c b/libdwfl/dwfl_frame_state_core.c
index 4ffd099a6f56b19210eb6230e0c7740f5179fe55..737bcbb8f22a68968e4cd0d00a794b6239f6c3e4 100644 (file)
--- a/libdwfl/dwfl_frame_state_core.c
+++ b/libdwfl/dwfl_frame_state_core.c
@@ -77,7 +77,7 @@ dwfl_frame_state_core_memory_read (Dwarf_Addr addr, Dwarf_Addr *result,
        *result = *(const uint32_t *) data->d_buf;
       return true;
     }
-  __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+  __libdwfl_seterrno (DWFL_E_CORE_MISSING);
   return false;
 }
 
@@ -209,7 +209,7 @@ dwfl_frame_state_core (Dwfl *dwfl, const char *corefile)
              if (thread == NULL)
                {
                  __libdwfl_process_free (process);
-                 __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+                 __libdwfl_seterrno (DWFL_E_NOMEM);
                  return NULL;
                }
            }

diff --git a/libdwfl/dwfl_frame_state_data.c b/libdwfl/dwfl_frame_state_data.c
index 39accb37f01467c3aa5fc5fe8dabf578514422eb..9adfa7cf636db26dd5ce92b507e2dbb9768d4aaf 100644 (file)
--- a/libdwfl/dwfl_frame_state_data.c
+++ b/libdwfl/dwfl_frame_state_data.c
@@ -44,7 +44,7 @@ dwfl_frame_state_data (Dwfl *dwfl, bool pc_set, Dwarf_Addr pc, unsigned nregs,
     }
   if (ebl == NULL || nregs > ebl_frame_state_nregs (ebl))
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_LIBEBL_BAD);
       return NULL;
     }
   Dwfl_Frame_State_Process *process;
@@ -56,7 +56,7 @@ dwfl_frame_state_data (Dwfl *dwfl, bool pc_set, Dwarf_Addr pc, unsigned nregs,
   if (thread == NULL)
     {
       __libdwfl_process_free (process);
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_NOMEM);
       return NULL;
     }
   Dwfl_Frame_State *state = thread->unwound;
@@ -72,13 +72,18 @@ dwfl_frame_state_data (Dwfl *dwfl, bool pc_set, Dwarf_Addr pc, unsigned nregs,
         && ! dwfl_frame_state_reg_set (state, regno, regs[regno]))
       {
        __libdwfl_process_free (process);
-       __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+       __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
        return NULL;
       }
-  if (! ebl_frame_state (state) || ! __libdwfl_state_fetch_pc (state))
+  if (! ebl_frame_state (state))
+    {
+      __libdwfl_process_free (process);
+      __libdwfl_seterrno (DWFL_E_LIBEBL);
+      return NULL;
+    }
+  if (! __libdwfl_state_fetch_pc (state))
     {
       __libdwfl_process_free (process);
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
       return NULL;
     }
   return process->thread->unwound;

diff --git a/libdwfl/dwfl_frame_state_pid.c b/libdwfl/dwfl_frame_state_pid.c
index 9a7e4ff2d4705a374f8eb202a2eca28435b16c6d..89fbee2bb84e00df9c75bdb9c3416b24e92079c4 100644 (file)
--- a/libdwfl/dwfl_frame_state_pid.c
+++ b/libdwfl/dwfl_frame_state_pid.c
@@ -82,7 +82,7 @@ dwfl_frame_state_pid_memory_read (Dwarf_Addr addr, Dwarf_Addr *result,
                        (void *) (uintptr_t) addr, NULL);
       if (errno != 0)
        {
-         __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+         __libdwfl_seterrno (DWFL_E_PROCESS_MEMORY_READ);
          return false;
        }
       return true;
@@ -99,7 +99,7 @@ dwfl_frame_state_pid_memory_read (Dwarf_Addr addr, Dwarf_Addr *result,
                    (void *) (uintptr_t) addr, NULL);
   if (errno != 0)
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_PROCESS_MEMORY_READ);
       return false;
     }
 #if SIZEOF_LONG == 8
@@ -136,16 +136,16 @@ dwfl_frame_state_pid (Dwfl *dwfl, pid_t pid)
     }
   if (process->ebl == NULL)
     {
-      /* Not idenified EBL from any of the modules.  */
+      /* Not identified EBL from any of the modules.  */
       __libdwfl_process_free (process);
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_PROCESS_NO_ARCH);
       return NULL;
     }
   DIR *dir = opendir (dirname);
   if (dir == NULL)
     {
       __libdwfl_process_free (process);
-      __libdwfl_seterrno (DWFL_E_ERRNO);
+      __libdwfl_seterrno (DWFL_E_PARSE_PROC);
       return NULL;
     }
   for (;;)
@@ -157,7 +157,7 @@ dwfl_frame_state_pid (Dwfl *dwfl, pid_t pid)
          if (errno == 0)
            break;
          __libdwfl_process_free (process);
-         __libdwfl_seterrno (DWFL_E_ERRNO);
+         __libdwfl_seterrno (DWFL_E_PARSE_PROC);
          return NULL;
        }
       if (strcmp (dirent->d_name, ".") == 0
@@ -169,21 +169,21 @@ dwfl_frame_state_pid (Dwfl *dwfl, pid_t pid)
       if (errno != 0)
        {
          __libdwfl_process_free (process);
-         __libdwfl_seterrno (DWFL_E_ERRNO);
+         __libdwfl_seterrno (DWFL_E_PARSE_PROC);
          return NULL;
        }
       pid_t tid = tidl;
       if (tidl <= 0 || (end && *end) || tid != tidl)
        {
          __libdwfl_process_free (process);
-         __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+         __libdwfl_seterrno (DWFL_E_PARSE_PROC);
          return NULL;
        }
       Dwfl_Frame_State_Thread *thread = __libdwfl_thread_alloc (process, tid);
       if (thread == NULL)
        {
          __libdwfl_process_free (process);
-         __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+         __libdwfl_seterrno (DWFL_E_NOMEM);
          return NULL;
        }
       if (! tid_is_attached (dwfl, thread->tid))
@@ -205,14 +205,14 @@ dwfl_frame_state_pid (Dwfl *dwfl, pid_t pid)
   if (closedir (dir) != 0)
     {
       __libdwfl_process_free (process);
-      __libdwfl_seterrno (DWFL_E_ERRNO);
+      __libdwfl_seterrno (DWFL_E_PARSE_PROC);
       return NULL;
     }
   if (process->thread == NULL)
     {
       /* No valid threads recognized.  */
       __libdwfl_process_free (process);
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_NO_THREAD);
       return NULL;
     }
   return process->thread->unwound;

diff --git a/libdwfl/dwfl_frame_unwind.c b/libdwfl/dwfl_frame_unwind.c
index 53a4cd65ae3a383f4a74c3b3f33d90006d6582aa..e35ccb5d6133851ba94e3ef757b46a1debf9fb32 100644 (file)
--- a/libdwfl/dwfl_frame_unwind.c
+++ b/libdwfl/dwfl_frame_unwind.c
@@ -45,7 +45,7 @@ state_get_reg (Dwfl_Frame_State *state, unsigned regno, Dwarf_Addr *val)
 {
   if (! dwfl_frame_state_reg_get (state, regno, val))
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
       return false;
     }
   return true;
@@ -68,7 +68,7 @@ expr_eval (Dwfl_Frame_State *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
   Dwfl_Frame_State_Process *process = state->thread->process;
   if (nops == 0)
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
       return false;
     }
   Dwarf_Addr *stack = NULL;
@@ -82,7 +82,7 @@ expr_eval (Dwfl_Frame_State *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
        Dwarf_Addr *stack_new = realloc (stack, stack_allocated * sizeof (*stack));
        if (stack_new == NULL)
          {
-           __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+           __libdwfl_seterrno (DWFL_E_NOMEM);
            return false;
          }
        stack = stack_new;
@@ -95,7 +95,7 @@ expr_eval (Dwfl_Frame_State *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
   {
     if (stack_used == 0)
       {
-       __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+       __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
        return false;
       }
     *val = stack[--stack_used];
@@ -230,7 +230,7 @@ expr_eval (Dwfl_Frame_State *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
          {
            free (stack);
            /* PPC32 vDSO has such invalid operations.  */
-           __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+           __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
            return false;
          }
        /* Undo the 'for' statement increment.  */
@@ -273,7 +273,7 @@ expr_eval (Dwfl_Frame_State *state, Dwarf_Frame *frame, const Dwarf_Op *ops,
       BINOP_SIGNED (DW_OP_ne, !=)
 #undef BINOP_SIGNED
       default:
-       __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+       __libdwfl_seterrno (DWFL_E_UNSUPPORTED_DWARF);
        return false;
     }
   if (! pop (result))
@@ -299,7 +299,7 @@ have_unwound (Dwfl_Frame_State **statep)
   switch (unwound->pc_state)
   {
     case DWFL_FRAME_STATE_ERROR:
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
       *statep = NULL;
       return false;
     case DWFL_FRAME_STATE_PC_SET:
@@ -324,7 +324,7 @@ no_fde (Dwarf_Addr pc, Dwfl_Module *mod, Dwarf_Addr bias)
   const char *symname = INTUSE(dwfl_module_addrsym) (mod, pc, &sym, NULL);
   if (symname == NULL)
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_NO_DWARF);
       return false;
     }
   /* It has no FDE on PPC64; it can be still unwound via the stack frame.  */
@@ -338,7 +338,7 @@ no_fde (Dwarf_Addr pc, Dwfl_Module *mod, Dwarf_Addr bias)
     }
   if (pc < ehdr->e_entry + bias)
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_NO_DWARF);
       return false;
     }
   /* "_start" is size-less.  Search for PC, if the closest symbol is the one
@@ -346,7 +346,7 @@ no_fde (Dwarf_Addr pc, Dwfl_Module *mod, Dwarf_Addr bias)
   if (sym.st_value != ehdr->e_entry + bias
       || (sym.st_size != 0 && pc >= sym.st_value + sym.st_size))
     {
-      __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+      __libdwfl_seterrno (DWFL_E_NO_DWARF);
       return false;
     }
   return true;
@@ -422,7 +422,7 @@ handle_cfi (Dwfl_Frame_State **statep, Dwarf_Addr pc, Dwfl_Module *mod,
            }
          else
            {
-             __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+             __libdwfl_seterrno (DWFL_E_INVALID_DWARF);
              continue;
            }
        }
@@ -435,7 +435,7 @@ handle_cfi (Dwfl_Frame_State **statep, Dwarf_Addr pc, Dwfl_Module *mod,
        }
       if (! dwfl_frame_state_reg_set (unwound, regno, regval))
        {
-         __libdwfl_seterrno (DWFL_E_UNKNOWN_ERROR);
+         __libdwfl_seterrno (DWFL_E_INVALID_REGISTER);
          continue;
        }
     }

diff --git a/libdwfl/libdwflP.h b/libdwfl/libdwflP.h
index ebcdae548a8d809bc24109e16faee8c3631ee7f1..fb2f839b275ad0d3482f97af6d517074c9eb1cdf 100644 (file)
--- a/libdwfl/libdwflP.h
+++ b/libdwfl/libdwflP.h
@@ -78,7 +78,16 @@ typedef struct Dwfl_Frame_State_Thread Dwfl_Frame_State_Thread;
   DWFL_ERROR (BADELF, N_("not a valid ELF file"))                            \
   DWFL_ERROR (WEIRD_TYPE, N_("cannot handle DWARF type description"))        \
   DWFL_ERROR (WRONG_ID_ELF, N_("ELF file does not match build ID"))          \
-  DWFL_ERROR (BAD_PRELINK, N_("corrupt .gnu.prelink_undo section data"))
+  DWFL_ERROR (BAD_PRELINK, N_("corrupt .gnu.prelink_undo section data"))      \
+  DWFL_ERROR (LIBEBL_BAD, N_("Internal error due to ebl"))                   \
+  DWFL_ERROR (CORE_MISSING, N_("Missing data in core file"))                 \
+  DWFL_ERROR (INVALID_REGISTER, N_("Invalid register"))                              \
+  DWFL_ERROR (PROCESS_MEMORY_READ, N_("Error reading process memory"))       \
+  DWFL_ERROR (PROCESS_NO_ARCH, N_("Have not found ELF module in a process"))  \
+  DWFL_ERROR (PARSE_PROC, N_("Error parsing /proc filesystem"))                      \
+  DWFL_ERROR (NO_THREAD, N_("No thread found"))                                      \
+  DWFL_ERROR (INVALID_DWARF, N_("Invalid DWARF"))                            \
+  DWFL_ERROR (UNSUPPORTED_DWARF, N_("Unsupported DWARF"))
 
 #define DWFL_ERROR(name, text) DWFL_E_##name,
 typedef enum { DWFL_ERRORS DWFL_E_NUM } Dwfl_Error;