libbacktrace/testlib.c

   1 /* testlib.c -- test functions for libbacktrace library
   2    Copyright (C) 2012-2020 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Google.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are
   7 met:
   8
   9     (1) Redistributions of source code must retain the above copyright
  10     notice, this list of conditions and the following disclaimer.
  11
  12     (2) Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in
  14     the documentation and/or other materials provided with the
  15     distribution.
  16
  17     (3) The name of the author may not be used to
  18     endorse or promote products derived from this software without
  19     specific prior written permission.
  20
  21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31 POSSIBILITY OF SUCH DAMAGE.  */
  32
  33 #include <assert.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "filenames.h"
  39
  40 #include "backtrace.h"
  41
  42 #include "testlib.h"
  43
  44 /* The backtrace state.  */
  45
  46 void *state;
  47
  48 /* The number of failures.  */
  49
  50 int failures;
  51
  52 /* Return the base name in a path.  */
  53
  54 const char *
  55 base (const char *p)
  56 {
  57   const char *last;
  58   const char *s;
  59
  60   last = NULL;
  61   for (s = p; *s != '\0'; ++s)
  62     {
  63       if (IS_DIR_SEPARATOR (*s))
  64         last = s + 1;
  65     }
  66   return last != NULL ? last : p;
  67 }
  68
  69 /* Check an entry in a struct info array.  */
  70
  71 void
  72 check (const char *name, int index, const struct info *all, int want_lineno,
  73        const char *want_function, const char *want_file, int *failed)
  74 {
  75   if (*failed)
  76     return;
  77   if (all[index].filename == NULL || all[index].function == NULL)
  78     {
  79       fprintf (stderr, "%s: [%d]: missing file name or function name\n",
  80                name, index);
  81       *failed = 1;
  82       return;
  83     }
  84   if (strcmp (base (all[index].filename), want_file) != 0)
  85     {
  86       fprintf (stderr, "%s: [%d]: got %s expected %s\n", name, index,
  87                all[index].filename, want_file);
  88       *failed = 1;
  89     }
  90   if (all[index].lineno != want_lineno)
  91     {
  92       fprintf (stderr, "%s: [%d]: got %d expected %d\n", name, index,
  93                all[index].lineno, want_lineno);
  94       *failed = 1;
  95     }
  96   if (strcmp (all[index].function, want_function) != 0)
  97     {
  98       fprintf (stderr, "%s: [%d]: got %s expected %s\n", name, index,
  99                all[index].function, want_function);
 100       *failed = 1;
 101     }
 102 }
 103
 104 /* The backtrace callback function.  */
 105
 106 int
 107 callback_one (void *vdata, uintptr_t pc ATTRIBUTE_UNUSED,
 108               const char *filename, int lineno, const char *function)
 109 {
 110   struct bdata *data = (struct bdata *) vdata;
 111   struct info *p;
 112
 113   if (data->index >= data->max)
 114     {
 115       fprintf (stderr, "callback_one: callback called too many times\n");
 116       data->failed = 1;
 117       return 1;
 118     }
 119
 120   p = &data->all[data->index];
 121   if (filename == NULL)
 122     p->filename = NULL;
 123   else
 124     {
 125       p->filename = strdup (filename);
 126       assert (p->filename != NULL);
 127     }
 128   p->lineno = lineno;
 129   if (function == NULL)
 130     p->function = NULL;
 131   else
 132     {
 133       p->function = strdup (function);
 134       assert (p->function != NULL);
 135     }
 136   ++data->index;
 137
 138   return 0;
 139 }
 140
 141 /* An error callback passed to backtrace.  */
 142
 143 void
 144 error_callback_one (void *vdata, const char *msg, int errnum)
 145 {
 146   struct bdata *data = (struct bdata *) vdata;
 147
 148   fprintf (stderr, "%s", msg);
 149   if (errnum > 0)
 150     fprintf (stderr, ": %s", strerror (errnum));
 151   fprintf (stderr, "\n");
 152   data->failed = 1;
 153 }
 154
 155 /* The backtrace_simple callback function.  */
 156
 157 int
 158 callback_two (void *vdata, uintptr_t pc)
 159 {
 160   struct sdata *data = (struct sdata *) vdata;
 161
 162   if (data->index >= data->max)
 163     {
 164       fprintf (stderr, "callback_two: callback called too many times\n");
 165       data->failed = 1;
 166       return 1;
 167     }
 168
 169   data->addrs[data->index] = pc;
 170   ++data->index;
 171
 172   return 0;
 173 }
 174
 175 /* An error callback passed to backtrace_simple.  */
 176
 177 void
 178 error_callback_two (void *vdata, const char *msg, int errnum)
 179 {
 180   struct sdata *data = (struct sdata *) vdata;
 181
 182   fprintf (stderr, "%s", msg);
 183   if (errnum > 0)
 184     fprintf (stderr, ": %s", strerror (errnum));
 185   fprintf (stderr, "\n");
 186   data->failed = 1;
 187 }
 188
 189 /* The backtrace_syminfo callback function.  */
 190
 191 void
 192 callback_three (void *vdata, uintptr_t pc ATTRIBUTE_UNUSED,
 193                 const char *symname, uintptr_t symval,
 194                 uintptr_t symsize)
 195 {
 196   struct symdata *data = (struct symdata *) vdata;
 197
 198   if (symname == NULL)
 199     data->name = NULL;
 200   else
 201     {
 202       data->name = strdup (symname);
 203       assert (data->name != NULL);
 204     }
 205   data->val = symval;
 206   data->size = symsize;
 207 }
 208
 209 /* The backtrace_syminfo error callback function.  */
 210
 211 void
 212 error_callback_three (void *vdata, const char *msg, int errnum)
 213 {
 214   struct symdata *data = (struct symdata *) vdata;
 215
 216   fprintf (stderr, "%s", msg);
 217   if (errnum > 0)
 218     fprintf (stderr, ": %s", strerror (errnum));
 219   fprintf (stderr, "\n");
 220   data->failed = 1;
 221 }
 222
 223 /* The backtrace_create_state error callback function.  */
 224
 225 void
 226 error_callback_create (void *data ATTRIBUTE_UNUSED, const char *msg,
 227                        int errnum)
 228 {
 229   fprintf (stderr, "%s", msg);
 230   if (errnum > 0)
 231     fprintf (stderr, ": %s", strerror (errnum));
 232   fprintf (stderr, "\n");
 233   exit (EXIT_FAILURE);
 234 }