m2-internship/libunwind-eh_elf
1
0
Fork 0
mirror of https://github.com/tobast/libunwind-eh_elf.git synced 2025-02-02 04:52:53 +01:00
Code Issues Releases Activity

Add include of "ia64-test-rbs.h".

Browse source 
(NELEMS): New macro.
(RECURSION_DEPTH): Fix definition: loadup() allocates 93 local regs, not 95.
(spill_func_t): Make it return an "int".
(DCL): Adjust accordingly.
(verbose): New variable.
(nerrors): Make it an "int".
(unwind_count): Ditto.
(unwind_and_resume): Make it return an int.  Print info-output only if verbose is
	set.  After unwinding to the desired point, redirect IP to
	resumption_point_label and store return value in EH_ARG0 and original
	IP in EH_ARG1.
(run_check): New function.
(main): Remove open test code and call run_check() instead.

(Logical change 1.49)
This commit is contained in:
mostang.com!davidm 2003-02-15 08:49:55 +00:00
parent d8023cf208
commit fb1997ff0a
1 changed files with 91 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

115
tests/ia64-test-rbs.c
View file

@ -4,24 +4,29 @@
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#define panic(args...) \
do { fprintf (stderr, args); ++nerrors; return; } while (0)
#include "ia64-test-rbs.h"
#define panic(args...) \
do { fprintf (stderr, args); ++nerrors; return -9999; } while (0)
#define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
/* The loadrs field in ar.rsc is 14 bits wide, which limits all ia64
implementations to at most 2048 physical stacked registers
(actually, slightly less than that, because loadrs also counts RNaT
slots). Since we can dirty 95 stacked registers per recursion, we
slots). Since we can dirty 93 stacked registers per recursion, we
need to recurse RECURSION_DEPTH times to ensure all physical
stacked registers are in use. */
#define MAX_PHYS_STACKED 2048
#define RECURSION_DEPTH ((MAX_PHYS_STACKED + 94) / 95)
#define RECURSION_DEPTH ((MAX_PHYS_STACKED + 92) / 93)
typedef void spill_func_t (long iteration, void (*next_func[])());
typedef int spill_func_t (long iteration, int (*next_func[])());
extern void loadup (long iteration, int *values, void (*next_func[])());
extern int loadup (long iteration, int *values, int (*next_func[])());
extern char resumption_point_label;
#define DCL(n) \
extern void rbs_spill_##n (long iteration, void (*next_func[])())
extern int rbs_spill_##n (long iteration, int (*next_func[])())
DCL(2); DCL(3); DCL(4); DCL(5); DCL(6); DCL(7);
DCL(8); DCL(9); DCL(10); DCL(11); DCL(12); DCL(13); DCL(14); DCL(15);
DCL(16); DCL(17); DCL(18); DCL(19); DCL(20); DCL(21); DCL(22); DCL(23);
@ -52,18 +57,21 @@ spill_func_t *spill_funcs[] =
SPL(88), SPL(89), SPL(90), SPL(91), SPL(92), SPL(93), SPL(94)
};
static long nerrors;
static long unwind_count;
static int verbose;
static int nerrors;
static int unwind_count;
static void
unwind_and_resume (long iteration, void (*next_func[])())
static int
unwind_and_resume (long iteration, int (*next_func[])())
{
unw_context_t uc;
unw_cursor_t c;
unw_word_t ip;
int i, ret;
printf ("%s: iteration=%ld, next_func=%p\n",
__FUNCTION__, iteration, next_func);
if (verbose)
printf (" %s: test%ld, next_func=%p\n",
__FUNCTION__, iteration, next_func);
unw_getcontext (&uc);
if ((ret = unw_init_local (&c, &uc)) < 0)
@ -73,26 +81,85 @@ unwind_and_resume (long iteration, void (*next_func[])())
if ((ret = unw_step (&c)) < 0)
panic ("unw_step (ret=%d)", ret);
if (unw_get_reg (&c, UNW_REG_IP, &ip) < 0
|| unw_set_reg (&c, UNW_REG_IP, (unw_word_t) &resumption_point_label) < 0
|| unw_set_reg (&c, UNW_REG_EH_ARG0, 0) /* ret val */
|| unw_set_reg (&c, UNW_REG_EH_ARG1, ip))
panic ("failed to redirect to resumption_point\n");
if (verbose)
{
unw_word_t bsp;
if (unw_get_reg (&c, UNW_IA64_BSP, &bsp) < 0)
panic ("unw_get_reg() failed\n");
printf (" bsp=%lx, old ip=%lx, new ip=%p\n", bsp,
ip, &resumption_point_label);
}
ret = unw_resume (&c);
panic ("unw_resume() returned (ret=%d)!!\n", ret);
return 0;
}
static int
run_check (int test)
{
int nfuncs, nspills, n, ret, i, reg_values[88];
spill_func_t *func[NSTACKS + 1];
/* First, generate a set of 88 random values which loadup() will load
into loc2-loc89 (r37-r124). */
for (i = 0; i < NELEMS (reg_values); ++i)
{
reg_values[i] = random ();
/* Generate NaTs with a reasonably probability (1/16th): */
if (reg_values[i] < 0x10000000)
reg_values[i] = 0;
}
nspills = 0;
nfuncs = 0;
do
{
n = random () % NELEMS (spill_funcs);
func[nfuncs++] = spill_funcs[n];
nspills += 2 + n;
}
while (nspills < 128);
func[nfuncs++] = unwind_and_resume;
unwind_count = 1 + (random () % (nfuncs + RECURSION_DEPTH));
if (verbose)
printf ("test%d: nfuncs=%d, unwind_count=%d\n",
test, nfuncs, unwind_count);
ret = loadup (RECURSION_DEPTH, reg_values, func);
if (ret < 0)
panic ("test%d: load() returned %d\n", test, ret);
else if (ret != RECURSION_DEPTH + 1 + nfuncs - unwind_count)
panic ("test%d: resumed wrong frame: expected %d, got %d\n",
test, RECURSION_DEPTH + 1 + nfuncs - unwind_count, ret);
return 0;
}
int
main (int argc, char **argv)
{
spill_func_t *test1[16];
int i, reg_values[88];
int i;
for (i = 0; i < (int) (sizeof (reg_values) / sizeof (reg_values[0])); ++i)
reg_values[i] = random ();
if (argc > 1)
verbose = 1;
test1[0] = SPL (3);
test1[1] = SPL (10);
test1[2] = SPL (5);
test1[3] = SPL (17);
test1[4] = unwind_and_resume;
unwind_count = 6;
loadup (RECURSION_DEPTH, reg_values, test1);
for (i = 0; i < 100000; ++i)
run_check (i + 1);
if (nerrors > 0)
{
fprintf (stderr, "FAILURE: detected %d errors\n", nerrors);
exit (-1);
}
if (verbose)
printf ("SUCCESS.\n");
return 0;
}