tests/Gia64-test-nat.c

   1 /* libunwind - a platform-independent unwind library
   2    Copyright (C) 2004-2005 Hewlett-Packard Co
   3         Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
   4
   5 This file is part of libunwind.
   6
   7 Permission is hereby granted, free of charge, to any person obtaining
   8 a copy of this software and associated documentation files (the
   9 "Software"), to deal in the Software without restriction, including
  10 without limitation the rights to use, copy, modify, merge, publish,
  11 distribute, sublicense, and/or sell copies of the Software, and to
  12 permit persons to whom the Software is furnished to do so, subject to
  13 the following conditions:
  14
  15 The above copyright notice and this permission notice shall be
  16 included in all copies or substantial portions of the Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  25
  26 /* This file tests corner-cases of NaT-bit handling.  */
  27
  28 #include <errno.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <libunwind.h>
  34 #include "compiler.h"
  35
  36 #ifdef HAVE_SYS_UC_ACCESS_H
  37 # include <sys/uc_access.h>
  38 #endif
  39
  40 #include "tdep-ia64/rse.h"
  41
  42 #define NUM_RUNS                1024
  43 //#define NUM_RUNS              1
  44 #define MAX_CHECKS              1024
  45 //#define MAX_CHECKS            2
  46 #define MAX_VALUES_PER_FUNC     4
  47
  48 #define panic(args...)                                                    \
  49         do { printf (args); ++nerrors; } while (0)
  50
  51 typedef void save_func_t (void *funcs, unsigned long *vals);
  52 typedef unw_word_t *check_func_t (unw_cursor_t *c, unsigned long *vals);
  53
  54 extern void flushrs (void);
  55
  56 extern save_func_t save_static_to_stacked;
  57 static check_func_t check_static_to_stacked;
  58
  59 extern save_func_t save_static_to_fr;
  60 static check_func_t check_static_to_fr;
  61
  62 extern save_func_t save_static_to_br;
  63 static check_func_t check_static_to_br;
  64
  65 extern save_func_t save_static_to_mem;
  66 static check_func_t check_static_to_mem;
  67
  68 extern save_func_t save_static_to_mem2;
  69 static check_func_t check_static_to_mem2;
  70
  71 extern save_func_t save_static_to_mem3;
  72 static check_func_t check_static_to_mem3;
  73
  74 extern save_func_t save_static_to_mem4;
  75 static check_func_t check_static_to_mem4;
  76
  77 extern save_func_t save_static_to_mem5;
  78 static check_func_t check_static_to_mem5;
  79
  80 extern save_func_t save_static_to_scratch;
  81 static check_func_t check_static_to_scratch;
  82
  83 extern save_func_t rotate_regs;
  84 static check_func_t check_rotate_regs;
  85
  86 extern save_func_t save_pr;
  87 static check_func_t check_pr;
  88
  89 static int verbose;
  90 static int nerrors;
  91
  92 static int num_checks;
  93 static save_func_t *funcs[MAX_CHECKS + 1];
  94 static check_func_t *checks[MAX_CHECKS];
  95 static unw_word_t values[MAX_CHECKS*MAX_VALUES_PER_FUNC];
  96
  97 static struct
  98   {
  99     save_func_t *func;
 100     check_func_t *check;
 101   }
 102 all_funcs[] =
 103   {
 104     { save_static_to_stacked,   check_static_to_stacked },
 105     { save_static_to_fr,        check_static_to_fr },
 106     { save_static_to_br,        check_static_to_br },
 107     { save_static_to_mem,       check_static_to_mem },
 108     { save_static_to_mem2,      check_static_to_mem2 },
 109     { save_static_to_mem3,      check_static_to_mem3 },
 110     { save_static_to_mem4,      check_static_to_mem4 },
 111     { save_static_to_mem5,      check_static_to_mem5 },
 112     { save_static_to_scratch,   check_static_to_scratch },
 113     { save_pr,                  check_pr },
 114     { rotate_regs,              check_rotate_regs },
 115   };
 116
 117 static unw_word_t
 118 random_word (void)
 119 {
 120   unw_word_t val = random ();
 121
 122   if (sizeof (unw_word_t) > 4)
 123     val |= ((unw_word_t) random ()) << 32;
 124
 125   return val;
 126 }
 127
 128 void
 129 sighandler (int signal, void *siginfo, void *context)
 130 {
 131   unsigned long *bsp, *arg1;
 132   save_func_t **arg0;
 133   ucontext_t *uc = context;
 134
 135 #if defined(__linux)
 136   {
 137     long sof;
 138     int sp;
 139
 140     if (verbose)
 141       printf ("sighandler: signal %d sp=%p nat=%08lx pr=%lx\n",
 142               signal, &sp, uc->uc_mcontext.sc_nat, uc->uc_mcontext.sc_pr);
 143     sof = uc->uc_mcontext.sc_cfm & 0x7f;
 144     bsp = (unsigned long *) rse_skip_regs (uc->uc_mcontext.sc_ar_bsp, -sof);
 145   }
 146 #elif defined(__hpux)
 147   if (__uc_get_ar (uc, UNW_IA64_AR_BSP - UNW_IA64_AR, &bsp) != 0)
 148     {
 149       panic ("%s: reading of ar.bsp failed, errno=%d", __FUNCTION__, errno);
 150       return;
 151     }
 152 #endif
 153
 154   flushrs ();
 155   arg0 = (save_func_t **) *bsp;
 156   bsp = (unsigned long *) rse_skip_regs ((uint64_t) bsp, 1);
 157   arg1 = (unsigned long *) *bsp;
 158
 159   (*arg0[0]) (arg0 + 1, arg1);
 160
 161   /* skip over the instruction which triggered sighandler() */
 162 #if defined(__linux)
 163   ++uc->uc_mcontext.sc_ip;
 164 #elif defined(HAVE_SYS_UC_ACCESS_H)
 165   {
 166     unsigned long ip;
 167
 168     if (__uc_get_ip (uc, &ip) != 0)
 169       {
 170         panic ("%s: reading of ip failed, errno=%d", __FUNCTION__, errno);
 171         return;
 172       }
 173     if (__uc_set_ip (uc, ip) != 0)
 174       {
 175         panic ("%s: writing of ip failed, errno=%d", __FUNCTION__, errno);
 176         return;
 177       }
 178   }
 179 #endif
 180 }
 181
 182 static void
 183 enable_sighandler (void)
 184 {
 185   struct sigaction act;
 186
 187   memset (&act, 0, sizeof (act));
 188   act.sa_handler = (void (*)(int)) sighandler;
 189   act.sa_flags = SA_SIGINFO | SA_NODEFER;
 190   if (sigaction (SIGSEGV, &act, NULL) < 0)
 191     panic ("sigaction: %s\n", strerror (errno));
 192 }
 193
 194 static void
 195 disable_sighandler (void)
 196 {
 197   struct sigaction act;
 198
 199   memset (&act, 0, sizeof (act));
 200   act.sa_handler = SIG_DFL;
 201   act.sa_flags = SA_SIGINFO | SA_NODEFER;
 202   if (sigaction (SIGSEGV, &act, NULL) < 0)
 203     panic ("sigaction: %s\n", strerror (errno));
 204 }
 205
 206 static unw_word_t *
 207 check_static_to_stacked (unw_cursor_t *c, unw_word_t *vals)
 208 {
 209   unw_word_t r[4];
 210   unw_word_t nat[4];
 211   int i, ret;
 212
 213   if (verbose)
 214     printf ("  %s()\n", __FUNCTION__);
 215
 216   vals -= 4;
 217
 218   for (i = 0; i < 4; ++i)
 219     if ((ret = unw_get_reg (c, UNW_IA64_GR + 4 + i, &r[i])) < 0)
 220       panic ("%s: failed to read register r%d, error=%d\n",
 221              __FUNCTION__, 4 + i, ret);
 222
 223   for (i = 0; i < 4; ++i)
 224     if ((ret = unw_get_reg (c, UNW_IA64_NAT + 4 + i, &nat[i])) < 0)
 225       panic ("%s: failed to read register nat%d, error=%d\n",
 226              __FUNCTION__, 4 + i, ret);
 227
 228   for (i = 0; i < 4; ++i)
 229     {
 230       if (verbose)
 231         printf ("    r%d = %c%016lx (expected %c%016lx)\n",
 232                 4 + i, nat[i] ? '*' : ' ', r[i],
 233                 (vals[i] & 1) ? '*' : ' ', vals[i]);
 234
 235       if (vals[i] & 1)
 236         {
 237           if (!nat[i])
 238             panic ("%s: r%d not a NaT!\n", __FUNCTION__, 4 + i);
 239         }
 240       else
 241         {
 242           if (nat[i])
 243             panic ("%s: r%d a NaT!\n", __FUNCTION__, 4 + i);
 244           if (r[i] != vals[i])
 245             panic ("%s: r%d=%lx instead of %lx!\n",
 246                    __FUNCTION__, 4 + i, r[i], vals[i]);
 247         }
 248     }
 249   return vals;
 250 }
 251
 252 static unw_word_t *
 253 check_static_to_fr (unw_cursor_t *c, unw_word_t *vals)
 254 {
 255   unw_word_t r4;
 256   unw_word_t nat4;
 257   int ret;
 258
 259   if (verbose)
 260     printf ("  %s()\n", __FUNCTION__);
 261
 262   vals -= 1;
 263
 264   if ((ret = unw_get_reg (c, UNW_IA64_GR + 4, &r4)) < 0)
 265     panic ("%s: failed to read register r4, error=%d\n", __FUNCTION__, ret);
 266
 267   if ((ret = unw_get_reg (c, UNW_IA64_NAT + 4, &nat4)) < 0)
 268     panic ("%s: failed to read register nat4, error=%d\n", __FUNCTION__, ret);
 269
 270   if (verbose)
 271     printf ("    r4 = %c%016lx (expected %c%016lx)\n",
 272             nat4 ? '*' : ' ', r4, (vals[0] & 1) ? '*' : ' ', vals[0]);
 273
 274   if (vals[0] & 1)
 275     {
 276       if (!nat4)
 277         panic ("%s: r4 not a NaT!\n", __FUNCTION__);
 278     }
 279   else
 280     {
 281       if (nat4)
 282         panic ("%s: r4 a NaT!\n", __FUNCTION__);
 283       if (r4 != vals[0])
 284         panic ("%s: r4=%lx instead of %lx!\n", __FUNCTION__, r4, vals[0]);
 285     }
 286   return vals;
 287 }
 288
 289 static unw_word_t *
 290 check_static_to_br (unw_cursor_t *c, unw_word_t *vals)
 291 {
 292   unw_word_t r4, nat4;
 293   int ret;
 294
 295   if (verbose)
 296     printf ("  %s()\n", __FUNCTION__);
 297
 298   vals -= 1;
 299
 300   if ((ret = unw_get_reg (c, UNW_IA64_GR + 4, &r4)) < 0)
 301     panic ("%s: failed to read register r4, error=%d\n", __FUNCTION__, ret);
 302
 303   if ((ret = unw_get_reg (c, UNW_IA64_NAT + 4, &nat4)) < 0)
 304     panic ("%s: failed to read register nat4, error=%d\n", __FUNCTION__, ret);
 305
 306   if (verbose)
 307     printf ("    r4 = %c%016lx (expected %c%016lx)\n",
 308             nat4 ? '*' : ' ', r4, (vals[0] & 1) ? '*' : ' ', vals[0]);
 309
 310   if (vals[0] & 1)
 311     {
 312       if (!nat4)
 313         panic ("%s: r4 not a NaT!\n", __FUNCTION__);
 314     }
 315   else
 316     {
 317       if (nat4)
 318         panic ("%s: r4 a NaT!\n", __FUNCTION__);
 319       if (r4 != vals[0])
 320         panic ("%s: r4=%lx instead of %lx!\n", __FUNCTION__, r4, vals[0]);
 321     }
 322   return vals;
 323 }
 324
 325 static unw_word_t *
 326 check_static_to_mem (unw_cursor_t *c, unw_word_t *vals)
 327 {
 328   unw_word_t r5, nat5;
 329   int ret;
 330
 331   if (verbose)
 332     printf ("  %s()\n", __FUNCTION__);
 333
 334   vals -= 1;
 335
 336   if ((ret = unw_get_reg (c, UNW_IA64_GR + 5, &r5)) < 0)
 337     panic ("%s: failed to read register r5, error=%d\n", __FUNCTION__, ret);
 338
 339   if ((ret = unw_get_reg (c, UNW_IA64_NAT + 5, &nat5)) < 0)
 340     panic ("%s: failed to read register nat5, error=%d\n", __FUNCTION__, ret);
 341
 342   if (verbose)
 343     printf ("    r5 = %c%016lx (expected %c%016lx)\n",
 344             nat5 ? '*' : ' ', r5, (vals[0] & 1) ? '*' : ' ', vals[0]);
 345
 346   if (vals[0] & 1)
 347     {
 348       if (!nat5)
 349         panic ("%s: r5 not a NaT!\n", __FUNCTION__);
 350     }
 351   else
 352     {
 353       if (nat5)
 354         panic ("%s: r5 a NaT!\n", __FUNCTION__);
 355       if (r5 != vals[0])
 356         panic ("%s: r5=%lx instead of %lx!\n", __FUNCTION__, r5, vals[0]);
 357     }
 358   return vals;
 359 }
 360
 361 static unw_word_t *
 362 check_static_to_memN (unw_cursor_t *c, unw_word_t *vals, const char *func)
 363 {
 364   unw_word_t r6, nat6;
 365   int ret;
 366
 367   if (verbose)
 368     printf ("  %s()\n", func);
 369
 370   vals -= 1;
 371
 372   if ((ret = unw_get_reg (c, UNW_IA64_GR + 6, &r6)) < 0)
 373     panic ("%s: failed to read register r6, error=%d\n", __FUNCTION__, ret);
 374
 375   if ((ret = unw_get_reg (c, UNW_IA64_NAT + 6, &nat6)) < 0)
 376     panic ("%s: failed to read register nat6, error=%d\n", __FUNCTION__, ret);
 377
 378   if (verbose)
 379     printf ("    r6 = %c%016lx (expected %c%016lx)\n",
 380             nat6 ? '*' : ' ', r6, (vals[0] & 1) ? '*' : ' ', vals[0]);
 381
 382   if (vals[0] & 1)
 383     {
 384       if (!nat6)
 385         panic ("%s: r6 not a NaT!\n", __FUNCTION__);
 386     }
 387   else
 388     {
 389       if (nat6)
 390         panic ("%s: r6 a NaT!\n", __FUNCTION__);
 391       if (r6 != vals[0])
 392         panic ("%s: r6=%lx instead of %lx!\n", __FUNCTION__, r6, vals[0]);
 393     }
 394   return vals;
 395 }
 396
 397 static unw_word_t *
 398 check_static_to_mem2 (unw_cursor_t *c, unw_word_t *vals)
 399 {
 400   return check_static_to_memN (c, vals, __FUNCTION__);
 401 }
 402
 403 static unw_word_t *
 404 check_static_to_mem3 (unw_cursor_t *c, unw_word_t *vals)
 405 {
 406   return check_static_to_memN (c, vals, __FUNCTION__);
 407 }
 408
 409 static unw_word_t *
 410 check_static_to_mem4 (unw_cursor_t *c, unw_word_t *vals)
 411 {
 412   return check_static_to_memN (c, vals, __FUNCTION__);
 413 }
 414
 415 static unw_word_t *
 416 check_static_to_mem5 (unw_cursor_t *c, unw_word_t *vals)
 417 {
 418   return check_static_to_memN (c, vals, __FUNCTION__);
 419 }
 420
 421 static unw_word_t *
 422 check_static_to_scratch (unw_cursor_t *c, unw_word_t *vals)
 423 {
 424   unw_word_t r[4], nat[4], ec, expected;
 425   unw_fpreg_t f4;
 426   int i, ret;
 427
 428   if (verbose)
 429     printf ("  %s()\n", __FUNCTION__);
 430
 431   vals -= 4;
 432
 433   while (!unw_is_signal_frame (c))
 434     if ((ret = unw_step (c)) < 0)
 435       panic ("%s: unw_step (ret=%d): Failed to skip over signal handler\n",
 436              __FUNCTION__, ret);
 437   if ((ret = unw_step (c)) < 0)
 438     panic ("%s: unw_step (ret=%d): Failed to skip over signal handler\n",
 439            __FUNCTION__, ret);
 440
 441   for (i = 0; i < 4; ++i)
 442     if ((ret = unw_get_reg (c, UNW_IA64_GR + 4 + i, &r[i])) < 0)
 443       panic ("%s: failed to read register r%d, error=%d\n",
 444              __FUNCTION__, 4 + i, ret);
 445
 446   for (i = 0; i < 4; ++i)
 447     if ((ret = unw_get_reg (c, UNW_IA64_NAT + 4 + i, &nat[i])) < 0)
 448       panic ("%s: failed to read register nat%d, error=%d\n",
 449              __FUNCTION__, 4 + i, ret);
 450
 451   for (i = 0; i < 4; ++i)
 452     {
 453       if (verbose)
 454         printf ("    r%d = %c%016lx (expected %c%016lx)\n",
 455                 4 + i, nat[i] ? '*' : ' ', r[i],
 456                 (vals[i] & 1) ? '*' : ' ', vals[i]);
 457
 458       if (vals[i] & 1)
 459         {
 460           if (!nat[i])
 461             panic ("%s: r%d not a NaT!\n", __FUNCTION__, 4 + i);
 462         }
 463       else
 464         {
 465           if (nat[i])
 466             panic ("%s: r%d a NaT!\n", __FUNCTION__, 4 + i);
 467           if (r[i] != vals[i])
 468             panic ("%s: r%d=%lx instead of %lx!\n",
 469                    __FUNCTION__, 4 + i, r[i], vals[i]);
 470         }
 471     }
 472   if ((ret = unw_get_fpreg (c, UNW_IA64_FR + 4, &f4)) < 0)
 473     panic ("%s: failed to read f4, error=%d\n", __FUNCTION__, ret);
 474
 475   /* These tests are little-endian specific: */
 476   if (nat[0])
 477     {
 478       if (f4.raw.bits[0] != 0 || f4.raw.bits[1] != 0x1fffe)
 479         panic ("%s: f4=%016lx.%016lx instead of NaTVal!\n",
 480                __FUNCTION__, f4.raw.bits[1], f4.raw.bits[0]);
 481     }
 482   else
 483     {
 484       if (f4.raw.bits[0] != r[0] || f4.raw.bits[1] != 0x1003e)
 485         panic ("%s: f4=%016lx.%016lx instead of %lx!\n",
 486                __FUNCTION__, f4.raw.bits[1], f4.raw.bits[0], r[0]);
 487     }
 488
 489   if ((unw_get_reg (c, UNW_IA64_AR_EC, &ec)) < 0)
 490     panic ("%s: failed to read register ar.ec, error=%d\n", __FUNCTION__, ret);
 491
 492   expected = vals[0] & 0x3f;
 493   if (ec != expected)
 494     panic ("%s: ar.ec=%016lx instead of %016lx!\n",
 495            __FUNCTION__, ec, expected);
 496
 497   return vals;
 498 }
 499
 500 static unw_word_t *
 501 check_pr (unw_cursor_t *c, unw_word_t *vals)
 502 {
 503   unw_word_t pr, expected;
 504   int ret;
 505 # define BIT(n) ((unw_word_t) 1 << (n))
 506 # define DONTCARE (BIT( 6) | BIT( 7) | BIT( 8) | BIT( 9) | BIT(10) \
 507                  | BIT(11) | BIT(12) | BIT(13) | BIT(14) | BIT(15))
 508
 509   if (verbose)
 510     printf ("  %s()\n", __FUNCTION__);
 511
 512   vals -= 1;
 513
 514   if ((ret = unw_get_reg (c, UNW_IA64_PR, &pr)) < 0)
 515     panic ("%s: failed to read register pr, error=%d\n", __FUNCTION__, ret);
 516
 517   pr &= ~DONTCARE;
 518   expected = (vals[0] & ~DONTCARE) | 1;
 519
 520   if (verbose)
 521     printf ("    pr = %016lx (expected %016lx)\n", pr, expected);
 522
 523   if (pr != expected)
 524     panic ("%s: pr=%lx instead of %lx!\n", __FUNCTION__, pr, expected);
 525
 526   if ((ret = unw_set_reg (c, UNW_IA64_PR, vals[0])) < 0)
 527     panic ("%s: failed to write register pr, error=%d\n", __FUNCTION__, ret);
 528
 529   if ((ret = unw_get_reg (c, UNW_IA64_PR, &pr)) < 0)
 530     panic ("%s: failed to read register pr, error=%d\n", __FUNCTION__, ret);
 531
 532   if (pr != vals[0])
 533     panic ("%s: secondary pr=%lx instead of %lx!\n",
 534            __FUNCTION__, pr, vals[0]);
 535   return vals;
 536 }
 537
 538 static unw_word_t *
 539 check_rotate_regs (unw_cursor_t *c, unw_word_t *vals)
 540 {
 541   if (verbose)
 542     printf ("  %s()\n", __FUNCTION__);
 543   return check_pr (c, vals - 1);
 544 }
 545
 546 static void
 547 start_checks (void *funcs, unsigned long *vals)
 548 {
 549   unw_context_t uc;
 550   unw_cursor_t c;
 551   int i, ret;
 552
 553   disable_sighandler ();
 554
 555   unw_getcontext (&uc);
 556
 557   if ((ret = unw_init_local (&c, &uc)) < 0)
 558     panic ("%s: unw_init_local (ret=%d)\n", __FUNCTION__, ret);
 559
 560   if ((ret = unw_step (&c)) < 0)
 561     panic ("%s: unw_step (ret=%d)\n", __FUNCTION__, ret);
 562
 563   for (i = 0; i < num_checks; ++i)
 564     {
 565       vals = (*checks[num_checks - 1 - i]) (&c, vals);
 566
 567       if ((ret = unw_step (&c)) < 0)
 568         panic ("%s: unw_step (ret=%d)\n", __FUNCTION__, ret);
 569     }
 570 }
 571
 572 static void
 573 run_check (int test)
 574 {
 575   int index, i;
 576
 577   if (test == 1)
 578     /* Make first test always go the full depth... */
 579     num_checks = MAX_CHECKS;
 580   else
 581     num_checks = (random () % MAX_CHECKS) + 1;
 582
 583   for (i = 0; i < num_checks * MAX_VALUES_PER_FUNC; ++i)
 584     values[i] = random_word ();
 585
 586   for (i = 0; i < num_checks; ++i)
 587     {
 588       if (test == 1)
 589         /* Make first test once go through each test... */
 590         index = i % (int) ARRAY_SIZE (all_funcs);
 591       else
 592         index = random () % (int) ARRAY_SIZE (all_funcs);
 593       funcs[i] = all_funcs[index].func;
 594       checks[i] = all_funcs[index].check;
 595     }
 596
 597   funcs[num_checks] = start_checks;
 598
 599   enable_sighandler ();
 600   (*funcs[0]) (funcs + 1, values);
 601 }
 602
 603 int
 604 main (int argc, char **argv)
 605 {
 606   int i;
 607
 608   if (argc > 1)
 609     verbose = 1;
 610
 611   for (i = 0; i < NUM_RUNS; ++i)
 612     {
 613       if (verbose)
 614         printf ("Run %d\n", i + 1);
 615       run_check (i + 1);
 616     }
 617
 618   if (nerrors > 0)
 619     {
 620       fprintf (stderr, "FAILURE: detected %d errors\n", nerrors);
 621       exit (-1);
 622     }
 623   if (verbose)
 624     printf ("SUCCESS.\n");
 625   return 0;
 626 }