[thirdparty/gcc.git] / libbacktrace / btest.c

/* btest.c -- Test for libbacktrace library
   Copyright (C) 2012-2018 Free Software Foundation, Inc.
   Written by Ian Lance Taylor, Google.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

    (1) Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    (2) Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in
    the documentation and/or other materials provided with the
    distribution.

    (3) The name of the author may not be used to
    endorse or promote products derived from this software without
    specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.  */

/* This program tests the externally visible interfaces of the
   libbacktrace library.  */

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "filenames.h"

#include "backtrace.h"
#include "backtrace-supported.h"

#include "testlib.h"

/* Test the backtrace function with non-inlined functions.  */

static int test1 (void) __attribute__ ((noinline, unused));
static int f2 (int) __attribute__ ((noinline));
static int f3 (int, int) __attribute__ ((noinline));

static int
test1 (void)
{
  /* Returning a value here and elsewhere avoids a tailcall which
     would mess up the backtrace.  */
  return f2 (__LINE__) + 1;
}

static int
f2 (int f1line)
{
  return f3 (f1line, __LINE__) + 2;
}

static int
f3 (int f1line, int f2line)
{
  struct info all[20];
  struct bdata data;
  int f3line;
  int i;

  data.all = &all[0];
  data.index = 0;
  data.max = 20;
  data.failed = 0;

  f3line = __LINE__ + 1;
  i = backtrace_full (state, 0, callback_one, error_callback_one, &data);

  if (i != 0)
    {
      fprintf (stderr, "test1: unexpected return value %d\n", i);
      data.failed = 1;
    }

  if (data.index < 3)
    {
      fprintf (stderr,
	       "test1: not enough frames; got %zu, expected at least 3\n",
	       data.index);
      data.failed = 1;
    }

  check ("test1", 0, all, f3line, "f3", "btest.c", &data.failed);
  check ("test1", 1, all, f2line, "f2", "btest.c", &data.failed);
  check ("test1", 2, all, f1line, "test1", "btest.c", &data.failed);

  printf ("%s: backtrace_full noinline\n", data.failed ? "FAIL" : "PASS");

  if (data.failed)
    ++failures;

  return failures;
}

/* Test the backtrace function with inlined functions.  */

static inline int test2 (void) __attribute__ ((always_inline, unused));
static inline int f12 (int) __attribute__ ((always_inline));
static inline int f13 (int, int) __attribute__ ((always_inline));

static inline int
test2 (void)
{
  return f12 (__LINE__) + 1;
}

static inline int
f12 (int f1line)
{
  return f13 (f1line, __LINE__) + 2;
}

static inline int
f13 (int f1line, int f2line)
{
  struct info all[20];
  struct bdata data;
  int f3line;
  int i;

  data.all = &all[0];
  data.index = 0;
  data.max = 20;
  data.failed = 0;

  f3line = __LINE__ + 1;
  i = backtrace_full (state, 0, callback_one, error_callback_one, &data);

  if (i != 0)
    {
      fprintf (stderr, "test2: unexpected return value %d\n", i);
      data.failed = 1;
    }

  check ("test2", 0, all, f3line, "f13", "btest.c", &data.failed);
  check ("test2", 1, all, f2line, "f12", "btest.c", &data.failed);
  check ("test2", 2, all, f1line, "test2", "btest.c", &data.failed);

  printf ("%s: backtrace_full inline\n", data.failed ? "FAIL" : "PASS");

  if (data.failed)
    ++failures;

  return failures;
}

/* Test the backtrace_simple function with non-inlined functions.  */

static int test3 (void) __attribute__ ((noinline, unused));
static int f22 (int) __attribute__ ((noinline));
static int f23 (int, int) __attribute__ ((noinline));

static int
test3 (void)
{
  return f22 (__LINE__) + 1;
}

static int
f22 (int f1line)
{
  return f23 (f1line, __LINE__) + 2;
}

static int
f23 (int f1line, int f2line)
{
  uintptr_t addrs[20];
  struct sdata data;
  int f3line;
  int i;

  data.addrs = &addrs[0];
  data.index = 0;
  data.max = 20;
  data.failed = 0;

  f3line = __LINE__ + 1;
  i = backtrace_simple (state, 0, callback_two, error_callback_two, &data);

  if (i != 0)
    {
      fprintf (stderr, "test3: unexpected return value %d\n", i);
      data.failed = 1;
    }

  if (!data.failed)
    {
      struct info all[20];
      struct bdata bdata;
      int j;

      bdata.all = &all[0];
      bdata.index = 0;
      bdata.max = 20;
      bdata.failed = 0;

      for (j = 0; j < 3; ++j)
	{
	  i = backtrace_pcinfo (state, addrs[j], callback_one,
				error_callback_one, &bdata);
	  if (i != 0)
	    {
	      fprintf (stderr,
		       ("test3: unexpected return value "
			"from backtrace_pcinfo %d\n"),
		       i);
	      bdata.failed = 1;
	    }
	  if (!bdata.failed && bdata.index != (size_t) (j + 1))
	    {
	      fprintf (stderr,
		       ("wrong number of calls from backtrace_pcinfo "
			"got %u expected %d\n"),
		       (unsigned int) bdata.index, j + 1);
	      bdata.failed = 1;
	    }
	}

      check ("test3", 0, all, f3line, "f23", "btest.c", &bdata.failed);
      check ("test3", 1, all, f2line, "f22", "btest.c", &bdata.failed);
      check ("test3", 2, all, f1line, "test3", "btest.c", &bdata.failed);

      if (bdata.failed)
	data.failed = 1;

      for (j = 0; j < 3; ++j)
	{
	  struct symdata symdata;

	  symdata.name = NULL;
	  symdata.val = 0;
	  symdata.size = 0;
	  symdata.failed = 0;

	  i = backtrace_syminfo (state, addrs[j], callback_three,
				 error_callback_three, &symdata);
	  if (i == 0)
	    {
	      fprintf (stderr,
		       ("test3: [%d]: unexpected return value "
			"from backtrace_syminfo %d\n"),
		       j, i);
	      symdata.failed = 1;
	    }

	  if (!symdata.failed)
	    {
	      const char *expected;

	      switch (j)
		{
		case 0:
		  expected = "f23";
		  break;
		case 1:
		  expected = "f22";
		  break;
		case 2:
		  expected = "test3";
		  break;
		default:
		  assert (0);
		}

	      if (symdata.name == NULL)
		{
		  fprintf (stderr, "test3: [%d]: NULL syminfo name\n", j);
		  symdata.failed = 1;
		}
	      /* Use strncmp, not strcmp, because GCC might create a
		 clone.  */
	      else if (strncmp (symdata.name, expected, strlen (expected))
		       != 0)
		{
		  fprintf (stderr,
			   ("test3: [%d]: unexpected syminfo name "
			    "got %s expected %s\n"),
			   j, symdata.name, expected);
		  symdata.failed = 1;
		}
	    }

	  if (symdata.failed)
	    data.failed = 1;
	}
    }

  printf ("%s: backtrace_simple noinline\n", data.failed ? "FAIL" : "PASS");

  if (data.failed)
    ++failures;

  return failures;
}

/* Test the backtrace_simple function with inlined functions.  */

static inline int test4 (void) __attribute__ ((always_inline, unused));
static inline int f32 (int) __attribute__ ((always_inline));
static inline int f33 (int, int) __attribute__ ((always_inline));

static inline int
test4 (void)
{
  return f32 (__LINE__) + 1;
}

static inline int
f32 (int f1line)
{
  return f33 (f1line, __LINE__) + 2;
}

static inline int
f33 (int f1line, int f2line)
{
  uintptr_t addrs[20];
  struct sdata data;
  int f3line;
  int i;

  data.addrs = &addrs[0];
  data.index = 0;
  data.max = 20;
  data.failed = 0;

  f3line = __LINE__ + 1;
  i = backtrace_simple (state, 0, callback_two, error_callback_two, &data);

  if (i != 0)
    {
      fprintf (stderr, "test3: unexpected return value %d\n", i);
      data.failed = 1;
    }

  if (!data.failed)
    {
      struct info all[20];
      struct bdata bdata;

      bdata.all = &all[0];
      bdata.index = 0;
      bdata.max = 20;
      bdata.failed = 0;

      i = backtrace_pcinfo (state, addrs[0], callback_one, error_callback_one,
			    &bdata);
      if (i != 0)
	{
	  fprintf (stderr,
		   ("test4: unexpected return value "
		    "from backtrace_pcinfo %d\n"),
		   i);
	  bdata.failed = 1;
	}

      check ("test4", 0, all, f3line, "f33", "btest.c", &bdata.failed);
      check ("test4", 1, all, f2line, "f32", "btest.c", &bdata.failed);
      check ("test4", 2, all, f1line, "test4", "btest.c", &bdata.failed);

      if (bdata.failed)
	data.failed = 1;
    }

  printf ("%s: backtrace_simple inline\n", data.failed ? "FAIL" : "PASS");

  if (data.failed)
    ++failures;

  return failures;
}

static int test5 (void) __attribute__ ((unused));

int global = 1;

static int
test5 (void)
{
  struct symdata symdata;
  int i;
  uintptr_t addr = (uintptr_t) &global;

  if (sizeof (global) > 1)
    addr += 1;

  symdata.name = NULL;
  symdata.val = 0;
  symdata.size = 0;
  symdata.failed = 0;

  i = backtrace_syminfo (state, addr, callback_three,
			 error_callback_three, &symdata);
  if (i == 0)
    {
      fprintf (stderr,
	       "test5: unexpected return value from backtrace_syminfo %d\n",
	       i);
      symdata.failed = 1;
    }

  if (!symdata.failed)
    {
      if (symdata.name == NULL)
	{
	  fprintf (stderr, "test5: NULL syminfo name\n");
	  symdata.failed = 1;
	}
      else if (strcmp (symdata.name, "global") != 0)
	{
	  fprintf (stderr,
		   "test5: unexpected syminfo name got %s expected %s\n",
		   symdata.name, "global");
	  symdata.failed = 1;
	}
      else if (symdata.val != (uintptr_t) &global)
	{
	  fprintf (stderr,
		   "test5: unexpected syminfo value got %lx expected %lx\n",
		   (unsigned long) symdata.val,
		   (unsigned long) (uintptr_t) &global);
	  symdata.failed = 1;
	}
      else if (symdata.size != sizeof (global))
	{
	  fprintf (stderr,
		   "test5: unexpected syminfo size got %lx expected %lx\n",
		   (unsigned long) symdata.size,
		   (unsigned long) sizeof (global));
	  symdata.failed = 1;
	}
    }

  printf ("%s: backtrace_syminfo variable\n",
	  symdata.failed ? "FAIL" : "PASS");

  if (symdata.failed)
    ++failures;

  return failures;
}

/* Run all the tests.  */

int
main (int argc ATTRIBUTE_UNUSED, char **argv)
{
  state = backtrace_create_state (argv[0], BACKTRACE_SUPPORTS_THREADS,
				  error_callback_create, NULL);

#if BACKTRACE_SUPPORTED
  test1 ();
  test2 ();
  test3 ();
  test4 ();
#if BACKTRACE_SUPPORTS_DATA
  test5 ();
#endif
#endif

  exit (failures ? EXIT_FAILURE : EXIT_SUCCESS);
}
Commit	Line	Data
ecd3459e	1	/* btest.c -- Test for libbacktrace library
8e8f6434	2	Copyright (C) 2012-2018 Free Software Foundation, Inc.
ecd3459e	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
75c399ef	10	notice, this list of conditions and the following disclaimer.
ecd3459e	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
75c399ef	15	distribution.
75c399ef	16
ecd3459e	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	/* This program tests the externally visible interfaces of the
	34	libbacktrace library. */
	35
	36	#include <assert.h>
ecd3459e	37	#include <stdio.h>
	38	#include <stdlib.h>
	39	#include <string.h>
	40
	41	#include "filenames.h"
	42
	43	#include "backtrace.h"
	44	#include "backtrace-supported.h"
	45
3be33b09	46	#include "testlib.h"
ecd3459e	47
	48	/* Test the backtrace function with non-inlined functions. */
	49
d48b4b14	50	static int test1 (void) __attribute__ ((noinline, unused));
ecd3459e	51	static int f2 (int) __attribute__ ((noinline));
	52	static int f3 (int, int) __attribute__ ((noinline));
	53
	54	static int
	55	test1 (void)
	56	{
	57	/* Returning a value here and elsewhere avoids a tailcall which
	58	would mess up the backtrace. */
	59	return f2 (__LINE__) + 1;
	60	}
	61
	62	static int
	63	f2 (int f1line)
	64	{
	65	return f3 (f1line, __LINE__) + 2;
	66	}
	67
	68	static int
	69	f3 (int f1line, int f2line)
	70	{
	71	struct info all[20];
	72	struct bdata data;
	73	int f3line;
	74	int i;
	75
	76	data.all = &all[0];
	77	data.index = 0;
	78	data.max = 20;
	79	data.failed = 0;
	80
	81	f3line = __LINE__ + 1;
	82	i = backtrace_full (state, 0, callback_one, error_callback_one, &data);
	83
	84	if (i != 0)
	85	{
	86	fprintf (stderr, "test1: unexpected return value %d\n", i);
	87	data.failed = 1;
	88	}
	89
881a0840	90	if (data.index < 3)
	91	{
	92	fprintf (stderr,
	93	"test1: not enough frames; got %zu, expected at least 3\n",
	94	data.index);
	95	data.failed = 1;
	96	}
	97
3be33b09	98	check ("test1", 0, all, f3line, "f3", "btest.c", &data.failed);
	99	check ("test1", 1, all, f2line, "f2", "btest.c", &data.failed);
	100	check ("test1", 2, all, f1line, "test1", "btest.c", &data.failed);
ecd3459e	101
	102	printf ("%s: backtrace_full noinline\n", data.failed ? "FAIL" : "PASS");
	103
	104	if (data.failed)
	105	++failures;
	106
	107	return failures;
	108	}
	109
	110	/* Test the backtrace function with inlined functions. */
	111
d48b4b14	112	static inline int test2 (void) __attribute__ ((always_inline, unused));
ecd3459e	113	static inline int f12 (int) __attribute__ ((always_inline));
	114	static inline int f13 (int, int) __attribute__ ((always_inline));
	115
	116	static inline int
	117	test2 (void)
	118	{
	119	return f12 (__LINE__) + 1;
	120	}
	121
	122	static inline int
	123	f12 (int f1line)
	124	{
	125	return f13 (f1line, __LINE__) + 2;
	126	}
	127
	128	static inline int
	129	f13 (int f1line, int f2line)
	130	{
	131	struct info all[20];
	132	struct bdata data;
	133	int f3line;
	134	int i;
	135
	136	data.all = &all[0];
	137	data.index = 0;
	138	data.max = 20;
	139	data.failed = 0;
	140
	141	f3line = __LINE__ + 1;
	142	i = backtrace_full (state, 0, callback_one, error_callback_one, &data);
	143
	144	if (i != 0)
	145	{
	146	fprintf (stderr, "test2: unexpected return value %d\n", i);
	147	data.failed = 1;
	148	}
	149
3be33b09	150	check ("test2", 0, all, f3line, "f13", "btest.c", &data.failed);
	151	check ("test2", 1, all, f2line, "f12", "btest.c", &data.failed);
	152	check ("test2", 2, all, f1line, "test2", "btest.c", &data.failed);
ecd3459e	153
	154	printf ("%s: backtrace_full inline\n", data.failed ? "FAIL" : "PASS");
	155
	156	if (data.failed)
	157	++failures;
	158
	159	return failures;
	160	}
	161
	162	/* Test the backtrace_simple function with non-inlined functions. */
	163
d48b4b14	164	static int test3 (void) __attribute__ ((noinline, unused));
ecd3459e	165	static int f22 (int) __attribute__ ((noinline));
	166	static int f23 (int, int) __attribute__ ((noinline));
	167
	168	static int
	169	test3 (void)
	170	{
	171	return f22 (__LINE__) + 1;
	172	}
	173
	174	static int
	175	f22 (int f1line)
	176	{
	177	return f23 (f1line, __LINE__) + 2;
	178	}
	179
	180	static int
	181	f23 (int f1line, int f2line)
	182	{
	183	uintptr_t addrs[20];
	184	struct sdata data;
	185	int f3line;
	186	int i;
	187
	188	data.addrs = &addrs[0];
	189	data.index = 0;
	190	data.max = 20;
	191	data.failed = 0;
	192
	193	f3line = __LINE__ + 1;
	194	i = backtrace_simple (state, 0, callback_two, error_callback_two, &data);
	195
	196	if (i != 0)
	197	{
	198	fprintf (stderr, "test3: unexpected return value %d\n", i);
	199	data.failed = 1;
	200	}
	201
	202	if (!data.failed)
	203	{
	204	struct info all[20];
	205	struct bdata bdata;
	206	int j;
	207
	208	bdata.all = &all[0];
	209	bdata.index = 0;
	210	bdata.max = 20;
	211	bdata.failed = 0;
	212
	213	for (j = 0; j < 3; ++j)
	214	{
	215	i = backtrace_pcinfo (state, addrs[j], callback_one,
	216	error_callback_one, &bdata);
	217	if (i != 0)
	218	{
	219	fprintf (stderr,
	220	("test3: unexpected return value "
	221	"from backtrace_pcinfo %d\n"),
	222	i);
	223	bdata.failed = 1;
	224	}
	225	if (!bdata.failed && bdata.index != (size_t) (j + 1))
	226	{
	227	fprintf (stderr,
	228	("wrong number of calls from backtrace_pcinfo "
229	"got %u expected %d\n"),
230	(unsigned int) bdata.index, j + 1);
231	bdata.failed = 1;
232	}
75c399ef	233	}
ecd3459e	234
3be33b09	235	check ("test3", 0, all, f3line, "f23", "btest.c", &bdata.failed);
	236	check ("test3", 1, all, f2line, "f22", "btest.c", &bdata.failed);
	237	check ("test3", 2, all, f1line, "test3", "btest.c", &bdata.failed);
ecd3459e	238
	239	if (bdata.failed)
	240	data.failed = 1;
	241
	242	for (j = 0; j < 3; ++j)
	243	{
	244	struct symdata symdata;
	245
	246	symdata.name = NULL;
	247	symdata.val = 0;
32ccb438	248	symdata.size = 0;
ecd3459e	249	symdata.failed = 0;
	250
	251	i = backtrace_syminfo (state, addrs[j], callback_three,
	252	error_callback_three, &symdata);
	253	if (i == 0)
	254	{
	255	fprintf (stderr,
	256	("test3: [%d]: unexpected return value "
	257	"from backtrace_syminfo %d\n"),
	258	j, i);
	259	symdata.failed = 1;
	260	}
	261
	262	if (!symdata.failed)
	263	{
	264	const char *expected;
	265
	266	switch (j)
	267	{
	268	case 0:
	269	expected = "f23";
	270	break;
	271	case 1:
	272	expected = "f22";
	273	break;
	274	case 2:
	275	expected = "test3";
	276	break;
fd88e799	277	default:
ecd3459e	278	assert (0);
	279	}
	280
	281	if (symdata.name == NULL)
	282	{
	283	fprintf (stderr, "test3: [%d]: NULL syminfo name\n", j);
	284	symdata.failed = 1;
	285	}
	286	/* Use strncmp, not strcmp, because GCC might create a
	287	clone. */
	288	else if (strncmp (symdata.name, expected, strlen (expected))
	289	!= 0)
	290	{
	291	fprintf (stderr,
	292	("test3: [%d]: unexpected syminfo name "
	293	"got %s expected %s\n"),
	294	j, symdata.name, expected);
	295	symdata.failed = 1;
	296	}
	297	}
	298
	299	if (symdata.failed)
	300	data.failed = 1;
	301	}
	302	}
	303
	304	printf ("%s: backtrace_simple noinline\n", data.failed ? "FAIL" : "PASS");
	305
	306	if (data.failed)
	307	++failures;
	308
	309	return failures;
	310	}
	311
	312	/* Test the backtrace_simple function with inlined functions. */
	313
d48b4b14	314	static inline int test4 (void) __attribute__ ((always_inline, unused));
ecd3459e	315	static inline int f32 (int) __attribute__ ((always_inline));
	316	static inline int f33 (int, int) __attribute__ ((always_inline));
	317
	318	static inline int
	319	test4 (void)
	320	{
	321	return f32 (__LINE__) + 1;
	322	}
	323
	324	static inline int
	325	f32 (int f1line)
	326	{
	327	return f33 (f1line, __LINE__) + 2;
	328	}
	329
	330	static inline int
	331	f33 (int f1line, int f2line)
	332	{
	333	uintptr_t addrs[20];
	334	struct sdata data;
	335	int f3line;
	336	int i;
	337
	338	data.addrs = &addrs[0];
	339	data.index = 0;
	340	data.max = 20;
	341	data.failed = 0;
	342
	343	f3line = __LINE__ + 1;
	344	i = backtrace_simple (state, 0, callback_two, error_callback_two, &data);
	345
	346	if (i != 0)
	347	{
	348	fprintf (stderr, "test3: unexpected return value %d\n", i);
	349	data.failed = 1;
	350	}
	351
	352	if (!data.failed)
	353	{
	354	struct info all[20];
	355	struct bdata bdata;
	356
	357	bdata.all = &all[0];
	358	bdata.index = 0;
	359	bdata.max = 20;
	360	bdata.failed = 0;
	361
	362	i = backtrace_pcinfo (state, addrs[0], callback_one, error_callback_one,
	363	&bdata);
	364	if (i != 0)
	365	{
	366	fprintf (stderr,
	367	("test4: unexpected return value "
	368	"from backtrace_pcinfo %d\n"),
	369	i);
	370	bdata.failed = 1;
	371	}
	372
3be33b09	373	check ("test4", 0, all, f3line, "f33", "btest.c", &bdata.failed);
	374	check ("test4", 1, all, f2line, "f32", "btest.c", &bdata.failed);
	375	check ("test4", 2, all, f1line, "test4", "btest.c", &bdata.failed);
ecd3459e	376
	377	if (bdata.failed)
	378	data.failed = 1;
	379	}
	380
	381	printf ("%s: backtrace_simple inline\n", data.failed ? "FAIL" : "PASS");
	382
	383	if (data.failed)
	384	++failures;
	385
	386	return failures;
	387	}
	388
673716e3	389	static int test5 (void) __attribute__ ((unused));
48ee217e	390
d4cc0c47	391	int global = 1;
	392
	393	static int
	394	test5 (void)
	395	{
	396	struct symdata symdata;
	397	int i;
32ccb438	398	uintptr_t addr = (uintptr_t) &global;
	399
	400	if (sizeof (global) > 1)
	401	addr += 1;
d4cc0c47	402
	403	symdata.name = NULL;
	404	symdata.val = 0;
32ccb438	405	symdata.size = 0;
d4cc0c47	406	symdata.failed = 0;
d4cc0c47	407
32ccb438	408	i = backtrace_syminfo (state, addr, callback_three,
d4cc0c47	409	error_callback_three, &symdata);
	410	if (i == 0)
	411	{
	412	fprintf (stderr,
	413	"test5: unexpected return value from backtrace_syminfo %d\n",
	414	i);
	415	symdata.failed = 1;
	416	}
	417
	418	if (!symdata.failed)
	419	{
	420	if (symdata.name == NULL)
	421	{
	422	fprintf (stderr, "test5: NULL syminfo name\n");
	423	symdata.failed = 1;
	424	}
	425	else if (strcmp (symdata.name, "global") != 0)
	426	{
	427	fprintf (stderr,
	428	"test5: unexpected syminfo name got %s expected %s\n",
	429	symdata.name, "global");
	430	symdata.failed = 1;
	431	}
32ccb438	432	else if (symdata.val != (uintptr_t) &global)
	433	{
	434	fprintf (stderr,
	435	"test5: unexpected syminfo value got %lx expected %lx\n",
	436	(unsigned long) symdata.val,
	437	(unsigned long) (uintptr_t) &global);
	438	symdata.failed = 1;
	439	}
	440	else if (symdata.size != sizeof (global))
	441	{
	442	fprintf (stderr,
	443	"test5: unexpected syminfo size got %lx expected %lx\n",
	444	(unsigned long) symdata.size,
	445	(unsigned long) sizeof (global));
	446	symdata.failed = 1;
	447	}
d4cc0c47	448	}
	449
	450	printf ("%s: backtrace_syminfo variable\n",
	451	symdata.failed ? "FAIL" : "PASS");
	452
	453	if (symdata.failed)
	454	++failures;
	455
	456	return failures;
	457	}
	458
ecd3459e	459	/* Run all the tests. */
	460
	461	int
	462	main (int argc ATTRIBUTE_UNUSED, char **argv)
	463	{
	464	state = backtrace_create_state (argv[0], BACKTRACE_SUPPORTS_THREADS,
	465	error_callback_create, NULL);
	466
	467	#if BACKTRACE_SUPPORTED
	468	test1 ();
	469	test2 ();
	470	test3 ();
	471	test4 ();
48ee217e	472	#if BACKTRACE_SUPPORTS_DATA
d4cc0c47	473	test5 ();
48ee217e	474	#endif
ecd3459e	475	#endif
	476
	477	exit (failures ? EXIT_FAILURE : EXIT_SUCCESS);
	478	}