src/ia64/Ginit.c

   1 /* libunwind - a platform-independent unwind library
   2    Copyright (C) 2001-2005 Hewlett-Packard Co
   3    Copyright (C) 2007 David Mosberger-Tang
   4         Contributed by David Mosberger-Tang <dmosberger@gmail.com>
   5
   6 This file is part of libunwind.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice shall be
  17 included in all copies or substantial portions of the Software.
  18
  19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  23 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  26
  27 #include "unwind_i.h"
  28
  29 #ifdef HAVE_SYS_UC_ACCESS_H
  30 # include <sys/uc_access.h>
  31 #endif
  32
  33 #ifdef UNW_REMOTE_ONLY
  34
  35 /* unw_local_addr_space is a NULL pointer in this case.  */
  36 PROTECTED unw_addr_space_t unw_local_addr_space;
  37
  38 #else /* !UNW_REMOTE_ONLY */
  39
  40 static struct unw_addr_space local_addr_space;
  41
  42 PROTECTED unw_addr_space_t unw_local_addr_space = &local_addr_space;
  43
  44 #ifdef HAVE_SYS_UC_ACCESS_H
  45
  46 #else /* !HAVE_SYS_UC_ACCESS_H */
  47
  48 HIDDEN void *
  49 tdep_uc_addr (ucontext_t *uc, int reg, uint8_t *nat_bitnr)
  50 {
  51   return inlined_uc_addr (uc, reg, nat_bitnr);
  52 }
  53
  54 #endif /* !HAVE_SYS_UC_ACCESS_H */
  55
  56 static void
  57 put_unwind_info (unw_addr_space_t as, unw_proc_info_t *proc_info, void *arg)
  58 {
  59   /* it's a no-op */
  60 }
  61
  62 static int
  63 get_dyn_info_list_addr (unw_addr_space_t as, unw_word_t *dyn_info_list_addr,
  64                         void *arg)
  65 {
  66 #ifndef UNW_LOCAL_ONLY
  67 # pragma weak _U_dyn_info_list_addr
  68   if (!_U_dyn_info_list_addr)
  69     return -UNW_ENOINFO;
  70 #endif
  71   *dyn_info_list_addr = _U_dyn_info_list_addr ();
  72   return 0;
  73 }
  74
  75 static int
  76 access_mem (unw_addr_space_t as, unw_word_t addr, unw_word_t *val, int write,
  77             void *arg)
  78 {
  79   if (write)
  80     {
  81       Debug (12, "mem[%lx] <- %lx\n", addr, *val);
  82       *(unw_word_t *) addr = *val;
  83     }
  84   else
  85     {
  86       *val = *(unw_word_t *) addr;
  87       Debug (12, "mem[%lx] -> %lx\n", addr, *val);
  88     }
  89   return 0;
  90 }
  91
  92 #ifdef HAVE_SYS_UC_ACCESS_H
  93
  94 #define SYSCALL_CFM_SAVE_REG    11 /* on a syscall, ar.pfs is saved in r11 */
  95 #define REASON_SYSCALL          0
  96
  97 static int
  98 access_reg (unw_addr_space_t as, unw_regnum_t reg, unw_word_t *val, int write,
  99             void *arg)
 100 {
 101   ucontext_t *uc = arg;
 102   unsigned int nat, mask;
 103   uint64_t value;
 104   uint16_t reason;
 105   int ret;
 106
 107   __uc_get_reason (uc, &reason);
 108
 109   switch (reg)
 110     {
 111     case UNW_IA64_GR  ... UNW_IA64_GR + 31:
 112       if ((ret = __uc_get_grs (uc, (reg - UNW_IA64_GR), 1, &value, &nat)))
 113         break;
 114
 115       if (write)
 116         ret = __uc_set_grs (uc, (reg - UNW_IA64_GR), 1, val, nat);
 117       else
 118         *val = value;
 119       break;
 120
 121     case UNW_IA64_NAT ... UNW_IA64_NAT + 31:
 122       if ((ret = __uc_get_grs (uc, (reg - UNW_IA64_GR), 1, &value, &nat)))
 123         break;
 124
 125       mask = 1 << (reg - UNW_IA64_GR);
 126
 127       if (write)
 128         {
 129           if (*val)
 130             nat |= mask;
 131           else
 132             nat &= ~mask;
 133           ret = __uc_set_grs (uc, (reg - UNW_IA64_GR), 1, &value, nat);
 134         }
 135       else
 136         *val = (nat & mask) != 0;
 137       break;
 138
 139     case UNW_IA64_AR  ... UNW_IA64_AR + 127:
 140       if (reg == UNW_IA64_AR_BSP)
 141         {
 142           if (write)
 143             ret = __uc_set_ar (uc, (reg - UNW_IA64_AR), *val);
 144           else
 145             ret = __uc_get_ar (uc, (reg - UNW_IA64_AR), val);
 146         }
 147       else if (reg == UNW_IA64_AR_PFS && reason == REASON_SYSCALL)
 148         {
 149           /* As of HP-UX 11.22, getcontext() does not have unwind info
 150              and because of that, we need to hack thins manually here.
 151              Hopefully, this is OK because the HP-UX kernel also needs
 152              to know where AR.PFS has been saved, so the use of
 153              register r11 for this purpose is pretty much nailed
 154              down.  */
 155           if (write)
 156             ret = __uc_set_grs (uc, SYSCALL_CFM_SAVE_REG, 1, val, 0);
 157           else
 158             ret = __uc_get_grs (uc, SYSCALL_CFM_SAVE_REG, 1, val, &nat);
 159         }
 160       else
 161         {
 162           if (write)
 163             ret = __uc_set_ar (uc, (reg - UNW_IA64_AR), *val);
 164           else
 165             ret = __uc_get_ar (uc, (reg - UNW_IA64_AR), val);
 166         }
 167       break;
 168
 169     case UNW_IA64_BR  ... UNW_IA64_BR + 7:
 170       if (write)
 171         ret = __uc_set_brs (uc, (reg - UNW_IA64_BR), 1, val);
 172       else
 173         ret = __uc_get_brs (uc, (reg - UNW_IA64_BR), 1, val);
 174       break;
 175
 176     case UNW_IA64_PR:
 177       if (write)
 178         ret = __uc_set_prs (uc, *val);
 179       else
 180         ret = __uc_get_prs (uc, val);
 181       break;
 182
 183     case UNW_IA64_IP:
 184       if (write)
 185         ret = __uc_set_ip (uc, *val);
 186       else
 187         ret = __uc_get_ip (uc, val);
 188       break;
 189
 190     case UNW_IA64_CFM:
 191       if (write)
 192         ret = __uc_set_cfm (uc, *val);
 193       else
 194         ret = __uc_get_cfm (uc, val);
 195       break;
 196
 197     case UNW_IA64_FR  ... UNW_IA64_FR + 127:
 198     default:
 199       ret = EINVAL;
 200       break;
 201     }
 202
 203   if (ret != 0)
 204     {
 205       Debug (1, "failed to %s %s (ret = %d)\n",
 206              write ? "write" : "read", unw_regname (reg), ret);
 207       return -UNW_EBADREG;
 208     }
 209
 210   if (write)
 211     Debug (12, "%s <- %lx\n", unw_regname (reg), *val);
 212   else
 213     Debug (12, "%s -> %lx\n", unw_regname (reg), *val);
 214   return 0;
 215 }
 216
 217 static int
 218 access_fpreg (unw_addr_space_t as, unw_regnum_t reg, unw_fpreg_t *val,
 219               int write, void *arg)
 220 {
 221   ucontext_t *uc = arg;
 222   fp_regval_t fp_regval;
 223   int ret;
 224
 225   switch (reg)
 226     {
 227     case UNW_IA64_FR  ... UNW_IA64_FR + 127:
 228       if (write)
 229         {
 230           memcpy (&fp_regval, val, sizeof (fp_regval));
 231           ret = __uc_set_frs (uc, (reg - UNW_IA64_FR), 1, &fp_regval);
 232         }
 233       else
 234         {
 235           ret = __uc_get_frs (uc, (reg - UNW_IA64_FR), 1, &fp_regval);
 236           memcpy (val, &fp_regval, sizeof (*val));
 237         }
 238       break;
 239
 240     default:
 241       ret = EINVAL;
 242       break;
 243     }
 244   if (ret != 0)
 245     return -UNW_EBADREG;
 246
 247   return 0;
 248 }
 249
 250 #else /* !HAVE_SYS_UC_ACCESS_H */
 251
 252 static int
 253 access_reg (unw_addr_space_t as, unw_regnum_t reg, unw_word_t *val, int write,
 254             void *arg)
 255 {
 256   unw_word_t *addr, mask;
 257   ucontext_t *uc = arg;
 258
 259   if (reg >= UNW_IA64_NAT + 4 && reg <= UNW_IA64_NAT + 7)
 260     {
 261       mask = ((unw_word_t) 1) << (reg - UNW_IA64_NAT);
 262       if (write)
 263         {
 264           if (*val)
 265             uc->uc_mcontext.sc_nat |= mask;
 266           else
 267             uc->uc_mcontext.sc_nat &= ~mask;
 268         }
 269       else
 270         *val = (uc->uc_mcontext.sc_nat & mask) != 0;
 271
 272       if (write)
 273         Debug (12, "%s <- %lx\n", unw_regname (reg), *val);
 274       else
 275         Debug (12, "%s -> %lx\n", unw_regname (reg), *val);
 276       return 0;
 277     }
 278
 279   addr = tdep_uc_addr (uc, reg, NULL);
 280   if (!addr)
 281     goto badreg;
 282
 283   if (write)
 284     {
 285       if (ia64_read_only_reg (addr))
 286         {
 287           Debug (16, "attempt to write read-only register\n");
 288           return -UNW_EREADONLYREG;
 289         }
 290       *addr = *val;
 291       Debug (12, "%s <- %lx\n", unw_regname (reg), *val);
 292     }
 293   else
 294     {
 295       *val = *(unw_word_t *) addr;
 296       Debug (12, "%s -> %lx\n", unw_regname (reg), *val);
 297     }
 298   return 0;
 299
 300  badreg:
 301   Debug (1, "bad register number %u\n", reg);
 302   return -UNW_EBADREG;
 303 }
 304
 305 static int
 306 access_fpreg (unw_addr_space_t as, unw_regnum_t reg, unw_fpreg_t *val,
 307               int write, void *arg)
 308 {
 309   ucontext_t *uc = arg;
 310   unw_fpreg_t *addr;
 311
 312   if (reg < UNW_IA64_FR || reg >= UNW_IA64_FR + 128)
 313     goto badreg;
 314
 315   addr = tdep_uc_addr (uc, reg, NULL);
 316   if (!addr)
 317     goto badreg;
 318
 319   if (write)
 320     {
 321       if (ia64_read_only_reg (addr))
 322         {
 323           Debug (16, "attempt to write read-only register\n");
 324           return -UNW_EREADONLYREG;
 325         }
 326       *addr = *val;
 327       Debug (12, "%s <- %016lx.%016lx\n",
 328              unw_regname (reg), val->raw.bits[1], val->raw.bits[0]);
 329     }
 330   else
 331     {
 332       *val = *(unw_fpreg_t *) addr;
 333       Debug (12, "%s -> %016lx.%016lx\n",
 334              unw_regname (reg), val->raw.bits[1], val->raw.bits[0]);
 335     }
 336   return 0;
 337
 338  badreg:
 339   Debug (1, "bad register number %u\n", reg);
 340   /* attempt to access a non-preserved register */
 341   return -UNW_EBADREG;
 342 }
 343
 344 #endif /* !HAVE_SYS_UC_ACCESS_H */
 345
 346 static int
 347 get_static_proc_name (unw_addr_space_t as, unw_word_t ip,
 348                       char *buf, size_t buf_len, unw_word_t *offp,
 349                       void *arg)
 350 {
 351   return _Uelf64_get_proc_name (as, getpid (), ip, buf, buf_len, offp);
 352 }
 353
 354 HIDDEN void
 355 ia64_local_addr_space_init (void)
 356 {
 357   memset (&local_addr_space, 0, sizeof (local_addr_space));
 358   local_addr_space.big_endian = (__BYTE_ORDER == __BIG_ENDIAN);
 359 #if defined(__linux)
 360   local_addr_space.abi = ABI_LINUX;
 361 #elif defined(__hpux)
 362   local_addr_space.abi = ABI_HPUX;
 363 #endif
 364   local_addr_space.caching_policy = UNW_CACHE_GLOBAL;
 365   local_addr_space.acc.find_proc_info = tdep_find_proc_info;
 366   local_addr_space.acc.put_unwind_info = put_unwind_info;
 367   local_addr_space.acc.get_dyn_info_list_addr = get_dyn_info_list_addr;
 368   local_addr_space.acc.access_mem = access_mem;
 369   local_addr_space.acc.access_reg = access_reg;
 370   local_addr_space.acc.access_fpreg = access_fpreg;
 371   local_addr_space.acc.resume = ia64_local_resume;
 372   local_addr_space.acc.get_proc_name = get_static_proc_name;
 373   unw_flush_cache (&local_addr_space, 0, 0);
 374 }
 375
 376 #endif /* !UNW_REMOTE_ONLY */
 377
 378 #ifndef UNW_LOCAL_ONLY
 379
 380 HIDDEN int
 381 ia64_uc_access_reg (struct cursor *c, ia64_loc_t loc, unw_word_t *valp,
 382                     int write)
 383 {
 384 #ifdef HAVE_SYS_UC_ACCESS_H
 385   unw_word_t uc_addr = IA64_GET_AUX_ADDR (loc);
 386   ucontext_t *ucp;
 387   int ret;
 388
 389   Debug (16, "%s location %s\n",
 390          write ? "writing" : "reading", ia64_strloc (loc));
 391
 392   if (c->as == unw_local_addr_space)
 393     ucp = (ucontext_t *) uc_addr;
 394   else
 395     {
 396       unw_word_t *dst, src;
 397
 398       /* Need to copy-in ucontext_t first.  */
 399       ucp = alloca (sizeof (ucontext_t));
 400       if (!ucp)
 401         return -UNW_ENOMEM;
 402
 403       /* For now, there is no non-HP-UX implementation of the
 404          uc_access(3) interface.  Because of that, we cannot, e.g.,
 405          unwind an HP-UX program from a Linux program.  Should that
 406          become possible at some point in the future, the
 407          copy-in/copy-out needs to be adjusted to do byte-swapping if
 408          necessary. */
 409       assert (c->as->big_endian == (__BYTE_ORDER == __BIG_ENDIAN));
 410
 411       dst = (unw_word_t *) ucp;
 412       for (src = uc_addr; src < uc_addr + sizeof (ucontext_t); src += 8)
 413         if ((ret = (*c->as->acc.access_mem) (c->as, src, dst++, 0, c->as_arg))
 414             < 0)
 415           return ret;
 416     }
 417
 418   if (IA64_IS_REG_LOC (loc))
 419     ret = access_reg (unw_local_addr_space, IA64_GET_REG (loc), valp, write,
 420                       ucp);
 421   else
 422     {
 423       /* Must be an access to the RSE backing store in ucontext_t.  */
 424       unw_word_t addr = IA64_GET_ADDR (loc);
 425
 426       if (write)
 427         ret = __uc_set_rsebs (ucp, (uint64_t *) addr, 1, valp);
 428       else
 429         ret = __uc_get_rsebs (ucp, (uint64_t *) addr, 1, valp);
 430       if (ret != 0)
 431         ret = -UNW_EBADREG;
 432     }
 433   if (ret < 0)
 434     return ret;
 435
 436   if (write && c->as != unw_local_addr_space)
 437     {
 438       /* need to copy-out ucontext_t: */
 439       unw_word_t dst, *src = (unw_word_t *) ucp;
 440       for (dst = uc_addr; dst < uc_addr + sizeof (ucontext_t); dst += 8)
 441         if ((ret = (*c->as->acc.access_mem) (c->as, dst, src++, 1, c->as_arg))
 442             < 0)
 443           return ret;
 444     }
 445   return 0;
 446 #else /* !HAVE_SYS_UC_ACCESS_H */
 447   return -UNW_EINVAL;
 448 #endif /* !HAVE_SYS_UC_ACCESS_H */
 449 }
 450
 451 HIDDEN int
 452 ia64_uc_access_fpreg (struct cursor *c, ia64_loc_t loc, unw_fpreg_t *valp,
 453                       int write)
 454 {
 455 #ifdef HAVE_SYS_UC_ACCESS_H
 456   unw_word_t uc_addr = IA64_GET_AUX_ADDR (loc);
 457   ucontext_t *ucp;
 458   int ret;
 459
 460   if (c->as == unw_local_addr_space)
 461     ucp = (ucontext_t *) uc_addr;
 462   else
 463     {
 464       unw_word_t *dst, src;
 465
 466       /* Need to copy-in ucontext_t first.  */
 467       ucp = alloca (sizeof (ucontext_t));
 468       if (!ucp)
 469         return -UNW_ENOMEM;
 470
 471       /* For now, there is no non-HP-UX implementation of the
 472          uc_access(3) interface.  Because of that, we cannot, e.g.,
 473          unwind an HP-UX program from a Linux program.  Should that
 474          become possible at some point in the future, the
 475          copy-in/copy-out needs to be adjusted to do byte-swapping if
 476          necessary. */
 477       assert (c->as->big_endian == (__BYTE_ORDER == __BIG_ENDIAN));
 478
 479       dst = (unw_word_t *) ucp;
 480       for (src = uc_addr; src < uc_addr + sizeof (ucontext_t); src += 8)
 481         if ((ret = (*c->as->acc.access_mem) (c->as, src, dst++, 0, c->as_arg))
 482             < 0)
 483           return ret;
 484     }
 485
 486   if ((ret = access_fpreg (unw_local_addr_space, IA64_GET_REG (loc), valp,
 487                            write, ucp)) < 0)
 488     return ret;
 489
 490   if (write && c->as != unw_local_addr_space)
 491     {
 492       /* need to copy-out ucontext_t: */
 493       unw_word_t dst, *src = (unw_word_t *) ucp;
 494       for (dst = uc_addr; dst < uc_addr + sizeof (ucontext_t); dst += 8)
 495         if ((ret = (*c->as->acc.access_mem) (c->as, dst, src++, 1, c->as_arg))
 496             < 0)
 497           return ret;
 498     }
 499   return 0;
 500 #else /* !HAVE_SYS_UC_ACCESS_H */
 501   return -UNW_EINVAL;
 502 #endif /* !HAVE_SYS_UC_ACCESS_H */
 503 }
 504
 505 #endif /* UNW_LOCAL_ONLY */