src/libs/libunwind/ia64/unwind_i.h

   1 /* libunwind - a platform-independent unwind library
   2    Copyright (C) 2001-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 #ifndef unwind_i_h
  27 #define unwind_i_h
  28
  29 #include <string.h>
  30 #include <inttypes.h>
  31
  32 #include <libunwind-ia64.h>
  33
  34 #include "rse.h"
  35
  36 #include "libunwind_i.h"
  37
  38 #define IA64_UNW_VER(x)             ((x) >> 48)
  39 #define IA64_UNW_FLAG_MASK          ((unw_word_t) 0x0000ffff00000000ULL)
  40 #define IA64_UNW_FLAG_OSMASK        ((unw_word_t) 0x0000f00000000000ULL)
  41 #define IA64_UNW_FLAG_EHANDLER(x)   ((x) & (unw_word_t) 0x0000000100000000ULL)
  42 #define IA64_UNW_FLAG_UHANDLER(x)   ((x) & (unw_word_t) 0x0000000200000000ULL)
  43 #define IA64_UNW_LENGTH(x)          ((x) & (unw_word_t) 0x00000000ffffffffULL)
  44
  45 #ifdef MIN
  46 # undef MIN
  47 #endif
  48 #define MIN(a,b)        ((a) < (b) ? (a) : (b))
  49
  50 #if !defined(HAVE_SYS_UC_ACCESS_H) && !defined(UNW_REMOTE_ONLY)
  51
  52 static ALWAYS_INLINE void *
  53 inlined_uc_addr (ucontext_t *uc, int reg, uint8_t *nat_bitnr)
  54 {
  55   unw_word_t reg_addr;
  56   void *addr;
  57
  58   switch (reg)
  59     {
  60     case UNW_IA64_GR + 0:       addr = &unw.read_only.r0; break;
  61     case UNW_IA64_NAT + 0:      addr = &unw.read_only.r0; break;
  62     case UNW_IA64_FR + 0:       addr = &unw.read_only.f0; break;
  63     case UNW_IA64_FR + 1:
  64       if (__BYTE_ORDER == __BIG_ENDIAN)
  65         addr = &unw.read_only.f1_be;
  66       else
  67         addr = &unw.read_only.f1_le;
  68       break;
  69     case UNW_IA64_IP:           addr = &uc->uc_mcontext.sc_br[0]; break;
  70     case UNW_IA64_CFM:          addr = &uc->uc_mcontext.sc_ar_pfs; break;
  71     case UNW_IA64_AR_RNAT:      addr = &uc->uc_mcontext.sc_ar_rnat; break;
  72     case UNW_IA64_AR_UNAT:      addr = &uc->uc_mcontext.sc_ar_unat; break;
  73     case UNW_IA64_AR_LC:        addr = &uc->uc_mcontext.sc_ar_lc; break;
  74     case UNW_IA64_AR_FPSR:      addr = &uc->uc_mcontext.sc_ar_fpsr; break;
  75     case UNW_IA64_PR:           addr = &uc->uc_mcontext.sc_pr; break;
  76     case UNW_IA64_AR_BSPSTORE:  addr = &uc->uc_mcontext.sc_ar_bsp; break;
  77
  78     case UNW_IA64_GR + 4 ... UNW_IA64_GR + 7:
  79     case UNW_IA64_GR + 12:
  80       addr = &uc->uc_mcontext.sc_gr[reg - UNW_IA64_GR];
  81       break;
  82
  83     case UNW_IA64_NAT + 4 ... UNW_IA64_NAT + 7:
  84     case UNW_IA64_NAT + 12:
  85       addr = &uc->uc_mcontext.sc_nat;
  86       reg_addr = (unw_word_t) &uc->uc_mcontext.sc_gr[reg - UNW_IA64_NAT];
  87       *nat_bitnr = reg - UNW_IA64_NAT;
  88       break;
  89
  90     case UNW_IA64_BR + 1 ... UNW_IA64_BR + 5:
  91       addr = &uc->uc_mcontext.sc_br[reg - UNW_IA64_BR];
  92       break;
  93
  94     case UNW_IA64_FR+ 2 ... UNW_IA64_FR+ 5:
  95     case UNW_IA64_FR+16 ... UNW_IA64_FR+31:
  96       addr = &uc->uc_mcontext.sc_fr[reg - UNW_IA64_FR];
  97       break;
  98
  99     default:
 100       addr = NULL;
 101     }
 102   return addr;
 103 }
 104
 105 static inline void *
 106 uc_addr (ucontext_t *uc, int reg, uint8_t *nat_bitnr)
 107 {
 108   if (__builtin_constant_p (reg))
 109     return inlined_uc_addr (uc, reg, nat_bitnr);
 110   else
 111     return tdep_uc_addr (uc, reg, nat_bitnr);
 112 }
 113
 114 /* Return TRUE if ADDR points inside unw.read_only_reg.  */
 115
 116 static inline long
 117 ia64_read_only_reg (void *addr)
 118 {
 119   return ((unsigned long) ((char *) addr - (char *) &unw.read_only)
 120           < sizeof (unw.read_only));
 121 }
 122
 123 #endif /* !defined(HAVE_SYS_UC_ACCESS_H) && !defined(UNW_REMOTE_ONLY) */
 124
 125 /* Bits 0 and 1 of a location are used to encode its type:
 126         bit 0: set if location uses floating-point format.
 127         bit 1: set if location is a NaT bit on memory stack.  */
 128
 129 #define IA64_LOC_TYPE_FP                (1 << 0)
 130 #define IA64_LOC_TYPE_MEMSTK_NAT        (1 << 1)
 131
 132 #ifdef UNW_LOCAL_ONLY
 133 #define IA64_LOC_REG(r,t)       (((r) << 2) | (t))
 134 #define IA64_LOC_ADDR(a,t)      (((a) & ~0x3) | (t))
 135 #define IA64_LOC_UC_ADDR(a,t)   IA64_LOC_ADDR(a, t)
 136 #define IA64_NULL_LOC           (0)
 137
 138 #define IA64_GET_REG(l)         ((l) >> 2)
 139 #define IA64_GET_ADDR(l)        ((l) & ~0x3)
 140 #define IA64_IS_NULL_LOC(l)     ((l) == 0)
 141 #define IA64_IS_FP_LOC(l)       (((l) & IA64_LOC_TYPE_FP) != 0)
 142 #define IA64_IS_MEMSTK_NAT(l)   (((l) & IA64_LOC_TYPE_MEMSTK_NAT) != 0)
 143 #define IA64_IS_REG_LOC(l)      0
 144 #define IA64_IS_UC_LOC(l)       0
 145
 146 #define IA64_REG_LOC(c,r)       ((unw_word_t) uc_addr((c)->as_arg, r, NULL))
 147 #define IA64_REG_NAT_LOC(c,r,n) ((unw_word_t) uc_addr((c)->as_arg, r, n))
 148 #define IA64_FPREG_LOC(c,r)                                              \
 149         ((unw_word_t) uc_addr((c)->as_arg, (r), NULL) | IA64_LOC_TYPE_FP)
 150
 151 # define ia64_find_proc_info(c,ip,n)                                    \
 152         tdep_find_proc_info(unw_local_addr_space, (ip), &(c)->pi, (n),  \
 153                             (c)->as_arg)
 154 # define ia64_put_unwind_info(c, pi)    do { ; } while (0)
 155
 156 /* Note: the register accessors (ia64_{get,set}{,fp}()) must check for
 157    NULL locations because uc_addr() returns NULL for unsaved
 158    registers.  */
 159
 160 static inline int
 161 ia64_getfp (struct cursor *c, unw_word_t loc, unw_fpreg_t *val)
 162 {
 163   if (IA64_IS_NULL_LOC (loc))
 164     {
 165       Debug (16, "access to unsaved register\n");
 166       return -UNW_EBADREG;
 167     }
 168   *val = *(unw_fpreg_t *) IA64_GET_ADDR (loc);
 169   return 0;
 170 }
 171
 172 static inline int
 173 ia64_putfp (struct cursor *c, unw_word_t loc, unw_fpreg_t val)
 174 {
 175   unw_fpreg_t *addr = (unw_fpreg_t *) IA64_GET_ADDR (loc);
 176
 177   if (IA64_IS_NULL_LOC (loc))
 178     {
 179       Debug (16, "access to unsaved register\n");
 180       return -UNW_EBADREG;
 181     }
 182   else if (ia64_read_only_reg (addr))
 183     {
 184       Debug (16, "attempt to read-only register\n");
 185       return -UNW_EREADONLYREG;
 186     }
 187   *addr = val;
 188   return 0;
 189 }
 190
 191 static inline int
 192 ia64_get (struct cursor *c, unw_word_t loc, unw_word_t *val)
 193 {
 194   if (IA64_IS_NULL_LOC (loc))
 195     {
 196       Debug (16, "access to unsaved register\n");
 197       return -UNW_EBADREG;
 198     }
 199   *val = *(unw_word_t *) IA64_GET_ADDR (loc);
 200   return 0;
 201 }
 202
 203 static inline int
 204 ia64_put (struct cursor *c, unw_word_t loc, unw_word_t val)
 205 {
 206   unw_word_t *addr = (unw_word_t *) IA64_GET_ADDR (loc);
 207
 208   if (IA64_IS_NULL_LOC (loc))
 209     {
 210       Debug (16, "access to unsaved register\n");
 211       return -UNW_EBADREG;
 212     }
 213   else if (ia64_read_only_reg (addr))
 214     {
 215       Debug (16, "attempt to read-only register\n");
 216       return -UNW_EREADONLYREG;
 217     }
 218   *addr = val;
 219   return 0;
 220 }
 221
 222 #else /* !UNW_LOCAL_ONLY */
 223
 224 /* Bits 0 and 1 of the second word (w1) of a location are used
 225    to further distinguish what location we're dealing with:
 226
 227         bit 0: set if the location is a register
 228         bit 1: set of the location is accessed via uc_access(3)  */
 229 #define IA64_LOC_TYPE_REG       (1 << 0)
 230 #define IA64_LOC_TYPE_UC        (1 << 1)
 231
 232 #define IA64_LOC_REG(r,t)       ((ia64_loc_t) { ((r) << 2) | (t),       \
 233                                                 IA64_LOC_TYPE_REG })
 234 #define IA64_LOC_ADDR(a,t)      ((ia64_loc_t) { ((a) & ~0x3) | (t), 0 })
 235 #define IA64_LOC_UC_ADDR(a,t)   ((ia64_loc_t) { ((a) & ~0x3) | (t),     \
 236                                                 IA64_LOC_TYPE_UC })
 237 #define IA64_LOC_UC_REG(r,a)    ((ia64_loc_t) { ((r) << 2),              \
 238                                                 ((a) | IA64_LOC_TYPE_REG \
 239                                                  | IA64_LOC_TYPE_UC) })
 240 #define IA64_NULL_LOC           ((ia64_loc_t) { 0, 0 })
 241
 242 #define IA64_GET_REG(l)         ((l).w0 >> 2)
 243 #define IA64_GET_ADDR(l)        ((l).w0 & ~0x3)
 244 #define IA64_GET_AUX_ADDR(l)    ((l).w1 & ~0x3)
 245 #define IA64_IS_NULL_LOC(l)     (((l).w0 | (l).w1) == 0)
 246 #define IA64_IS_FP_LOC(l)       (((l).w0 & IA64_LOC_TYPE_FP) != 0)
 247 #define IA64_IS_MEMSTK_NAT(l)   (((l).w0 & IA64_LOC_TYPE_MEMSTK_NAT) != 0)
 248 #define IA64_IS_REG_LOC(l)      (((l).w1 & IA64_LOC_TYPE_REG) != 0)
 249 #define IA64_IS_UC_LOC(l)       (((l).w1 & IA64_LOC_TYPE_UC) != 0)
 250
 251 #define IA64_REG_LOC(c,r)       IA64_LOC_REG ((r), 0)
 252 #define IA64_REG_NAT_LOC(c,r,n) IA64_LOC_REG ((r), 0)
 253 #define IA64_FPREG_LOC(c,r)     IA64_LOC_REG ((r), IA64_LOC_TYPE_FP)
 254
 255 # define ia64_find_proc_info(c,ip,n)                                    \
 256         (*(c)->as->acc.find_proc_info)((c)->as, (ip), &(c)->pi, (n),    \
 257                                        (c)->as_arg)
 258 # define ia64_put_unwind_info(c,pi)                                     \
 259         (*(c)->as->acc.put_unwind_info)((c)->as, (pi), (c)->as_arg)
 260
 261 #define ia64_uc_access_reg      UNW_OBJ(uc_access_reg)
 262 #define ia64_uc_access_fpreg    UNW_OBJ(uc_access_fpreg)
 263
 264 extern int ia64_uc_access_reg (struct cursor *c, ia64_loc_t loc,
 265                                unw_word_t *valp, int write);
 266 extern int ia64_uc_access_fpreg (struct cursor *c, ia64_loc_t loc,
 267                                  unw_fpreg_t *valp, int write);
 268
 269 static inline int
 270 ia64_getfp (struct cursor *c, ia64_loc_t loc, unw_fpreg_t *val)
 271 {
 272   unw_word_t addr;
 273   int ret;
 274
 275   if (IA64_IS_NULL_LOC (loc))
 276     {
 277       Debug (16, "access to unsaved register\n");
 278       return -UNW_EBADREG;
 279     }
 280
 281   if (IA64_IS_UC_LOC (loc))
 282     return ia64_uc_access_fpreg (c, loc, val, 0);
 283
 284   if (IA64_IS_REG_LOC (loc))
 285     return (*c->as->acc.access_fpreg) (c->as, IA64_GET_REG (loc),
 286                                        val, 0, c->as_arg);
 287
 288   addr = IA64_GET_ADDR (loc);
 289   ret = (*c->as->acc.access_mem) (c->as, addr + 0, &val->raw.bits[0], 0,
 290                                   c->as_arg);
 291   if (ret < 0)
 292     return ret;
 293
 294   return (*c->as->acc.access_mem) (c->as, addr + 8, &val->raw.bits[1], 0,
 295                                    c->as_arg);
 296 }
 297
 298 static inline int
 299 ia64_putfp (struct cursor *c, ia64_loc_t loc, unw_fpreg_t val)
 300 {
 301   unw_word_t addr;
 302   int ret;
 303
 304   if (IA64_IS_NULL_LOC (loc))
 305     {
 306       Debug (16, "access to unsaved register\n");
 307       return -UNW_EBADREG;
 308     }
 309
 310   if (IA64_IS_UC_LOC (loc))
 311     return ia64_uc_access_fpreg (c, loc, &val, 1);
 312
 313   if (IA64_IS_REG_LOC (loc))
 314     return (*c->as->acc.access_fpreg) (c->as, IA64_GET_REG (loc), &val, 1,
 315                                        c->as_arg);
 316
 317   addr = IA64_GET_ADDR (loc);
 318   ret = (*c->as->acc.access_mem) (c->as, addr + 0, &val.raw.bits[0], 1,
 319                                   c->as_arg);
 320   if (ret < 0)
 321     return ret;
 322
 323   return (*c->as->acc.access_mem) (c->as, addr + 8, &val.raw.bits[1], 1,
 324                                    c->as_arg);
 325 }
 326
 327 /* Get the 64 data bits from location LOC.  If bit 0 is cleared, LOC
 328    is a memory address, otherwise it is a register number.  If the
 329    register is a floating-point register, the 64 bits are read from
 330    the significand bits.  */
 331
 332 static inline int
 333 ia64_get (struct cursor *c, ia64_loc_t loc, unw_word_t *val)
 334 {
 335   if (IA64_IS_NULL_LOC (loc))
 336     {
 337       Debug (16, "access to unsaved register\n");
 338       return -UNW_EBADREG;
 339     }
 340
 341   if (IA64_IS_FP_LOC (loc))
 342     {
 343       unw_fpreg_t tmp;
 344       int ret;
 345
 346       ret = ia64_getfp (c, loc, &tmp);
 347       if (ret < 0)
 348         return ret;
 349
 350       if (c->as->big_endian)
 351         *val = tmp.raw.bits[1];
 352       else
 353         *val = tmp.raw.bits[0];
 354       return 0;
 355     }
 356
 357   if (IA64_IS_UC_LOC (loc))
 358     return ia64_uc_access_reg (c, loc, val, 0);
 359
 360   if (IA64_IS_REG_LOC (loc))
 361     return (*c->as->acc.access_reg)(c->as, IA64_GET_REG (loc), val, 0,
 362                                     c->as_arg);
 363   else
 364     return (*c->as->acc.access_mem)(c->as, IA64_GET_ADDR (loc), val, 0,
 365                                     c->as_arg);
 366 }
 367
 368 static inline int
 369 ia64_put (struct cursor *c, ia64_loc_t loc, unw_word_t val)
 370 {
 371   if (IA64_IS_NULL_LOC (loc))
 372     {
 373       Debug (16, "access to unsaved register\n");
 374       return -UNW_EBADREG;
 375     }
 376
 377   if (IA64_IS_FP_LOC (loc))
 378     {
 379       unw_fpreg_t tmp;
 380
 381       memset (&tmp, 0, sizeof (tmp));
 382       if (c->as->big_endian)
 383         tmp.raw.bits[1] = val;
 384       else
 385         tmp.raw.bits[0] = val;
 386       return ia64_putfp (c, loc, tmp);
 387     }
 388
 389   if (IA64_IS_UC_LOC (loc))
 390     return ia64_uc_access_reg (c, loc, &val, 1);
 391
 392   if (IA64_IS_REG_LOC (loc))
 393     return (*c->as->acc.access_reg)(c->as, IA64_GET_REG (loc), &val, 1,
 394                                     c->as_arg);
 395   else
 396     return (*c->as->acc.access_mem)(c->as, IA64_GET_ADDR (loc), &val, 1,
 397                                     c->as_arg);
 398 }
 399
 400 #endif /* !UNW_LOCAL_ONLY */
 401
 402 struct ia64_unwind_block
 403   {
 404     unw_word_t header;
 405     unw_word_t desc[0];                 /* unwind descriptors */
 406
 407     /* Personality routine and language-specific data follow behind
 408        descriptors.  */
 409   };
 410
 411 enum ia64_where
 412   {
 413     IA64_WHERE_NONE,    /* register isn't saved at all */
 414     IA64_WHERE_GR,      /* register is saved in a general register */
 415     IA64_WHERE_FR,      /* register is saved in a floating-point register */
 416     IA64_WHERE_BR,      /* register is saved in a branch register */
 417     IA64_WHERE_SPREL,   /* register is saved on memstack (sp-relative) */
 418     IA64_WHERE_PSPREL,  /* register is saved on memstack (psp-relative) */
 419
 420     /* At the end of each prologue these locations get resolved to
 421        IA64_WHERE_PSPREL and IA64_WHERE_GR, respectively:  */
 422
 423     IA64_WHERE_SPILL_HOME, /* register is saved in its spill home */
 424     IA64_WHERE_GR_SAVE  /* register is saved in next general register */
 425   };
 426
 427 #define IA64_WHEN_NEVER 0x7fffffff
 428
 429 struct ia64_reg_info
 430   {
 431     unw_word_t val;             /* save location: register number or offset */
 432     enum ia64_where where;      /* where the register gets saved */
 433     int when;                   /* when the register gets saved */
 434   };
 435
 436 struct ia64_labeled_state;      /* opaque structure */
 437
 438 struct ia64_reg_state
 439   {
 440     struct ia64_reg_state *next;    /* next (outer) element on state stack */
 441     struct ia64_reg_info reg[IA64_NUM_PREGS];   /* register save locations */
 442   };
 443
 444 struct ia64_state_record
 445   {
 446     unsigned int first_region : 1;      /* is this the first region? */
 447     unsigned int done : 1;              /* are we done scanning descriptors? */
 448     unsigned int any_spills : 1;        /* got any register spills? */
 449     unsigned int in_body : 1;           /* are we inside prologue or body? */
 450     uint8_t *imask;             /* imask of spill_mask record or NULL */
 451     uint16_t abi_marker;
 452
 453     unw_word_t pr_val;          /* predicate values */
 454     unw_word_t pr_mask;         /* predicate mask */
 455
 456     long spill_offset;          /* psp-relative offset for spill base */
 457     int region_start;
 458     int region_len;
 459     int when_sp_restored;
 460     int epilogue_count;
 461     int when_target;
 462
 463     uint8_t gr_save_loc;        /* next save register */
 464     uint8_t return_link_reg;    /* branch register used as return pointer */
 465
 466     struct ia64_labeled_state *labeled_states;
 467     struct ia64_reg_state curr;
 468   };
 469
 470 struct ia64_labeled_state
 471   {
 472     struct ia64_labeled_state *next;    /* next label (or NULL) */
 473     unsigned long label;                        /* label for this state */
 474     struct ia64_reg_state saved_state;
 475   };
 476
 477 /* Convenience macros: */
 478 #define ia64_make_proc_info             UNW_OBJ(make_proc_info)
 479 #define ia64_fetch_proc_info            UNW_OBJ(fetch_proc_info)
 480 #define ia64_create_state_record        UNW_OBJ(create_state_record)
 481 #define ia64_free_state_record          UNW_OBJ(free_state_record)
 482 #define ia64_find_save_locs             UNW_OBJ(find_save_locs)
 483 #define ia64_validate_cache             UNW_OBJ(ia64_validate_cache)
 484 #define ia64_local_validate_cache       UNW_OBJ(ia64_local_validate_cache)
 485 #define ia64_per_thread_cache           UNW_OBJ(per_thread_cache)
 486 #define ia64_scratch_loc                UNW_OBJ(scratch_loc)
 487 #define ia64_local_resume               UNW_OBJ(local_resume)
 488 #define ia64_local_addr_space_init      UNW_OBJ(local_addr_space_init)
 489 #define ia64_strloc                     UNW_OBJ(strloc)
 490 #define ia64_install_cursor             UNW_OBJ(install_cursor)
 491 #define rbs_switch                      UNW_OBJ(rbs_switch)
 492 #define rbs_find_stacked                UNW_OBJ(rbs_find_stacked)
 493
 494 extern int ia64_make_proc_info (struct cursor *c);
 495 extern int ia64_fetch_proc_info (struct cursor *c, unw_word_t ip,
 496                                  int need_unwind_info);
 497 /* The proc-info must be valid for IP before this routine can be
 498    called:  */
 499 extern int ia64_create_state_record (struct cursor *c,
 500                                      struct ia64_state_record *sr);
 501 extern int ia64_free_state_record (struct ia64_state_record *sr);
 502 extern int ia64_find_save_locs (struct cursor *c);
 503 extern void ia64_validate_cache (unw_addr_space_t as, void *arg);
 504 extern int ia64_local_validate_cache (unw_addr_space_t as, void *arg);
 505 extern void ia64_local_addr_space_init (void);
 506 extern ia64_loc_t ia64_scratch_loc (struct cursor *c, unw_regnum_t reg,
 507                                     uint8_t *nat_bitnr);
 508
 509 extern NORETURN void ia64_install_cursor (struct cursor *c,
 510                                           unw_word_t pri_unat,
 511                                           unw_word_t *extra,
 512                                           unw_word_t bspstore,
 513                                           unw_word_t dirty_size,
 514                                           unw_word_t *dirty_partition,
 515                                           unw_word_t dirty_rnat);
 516 extern int ia64_local_resume (unw_addr_space_t as, unw_cursor_t *cursor,
 517                               void *arg);
 518 extern int rbs_switch (struct cursor *c,
 519                        unw_word_t saved_bsp, unw_word_t saved_bspstore,
 520                        ia64_loc_t saved_rnat_loc);
 521 extern int rbs_find_stacked (struct cursor *c, unw_word_t regs_to_skip,
 522                              ia64_loc_t *locp, ia64_loc_t *rnat_locp);
 523
 524 #ifndef UNW_REMOTE_ONLY
 525 # define NEED_RBS_COVER_AND_FLUSH
 526 # define rbs_cover_and_flush    UNW_OBJ(rbs_cover_and_flush)
 527   extern int rbs_cover_and_flush (struct cursor *c, unw_word_t nregs,
 528                                   unw_word_t *dirty_partition,
 529                                   unw_word_t *dirty_rnat,
 530                                   unw_word_t *bspstore);
 531 #endif
 532
 533 /* Warning: ia64_strloc() is for debugging only and it is NOT re-entrant! */
 534 extern const char *ia64_strloc (ia64_loc_t loc);
 535
 536 /* Return true if the register-backing store is inside a ucontext_t
 537    that needs to be accessed via uc_access(3).  */
 538
 539 static inline int
 540 rbs_on_uc (struct rbs_area *rbs)
 541 {
 542   return IA64_IS_UC_LOC (rbs->rnat_loc) && !IA64_IS_REG_LOC (rbs->rnat_loc);
 543 }
 544
 545 /* Return true if BSP points to a word that's stored on register
 546    backing-store RBS.  */
 547 static inline int
 548 rbs_contains (struct rbs_area *rbs, unw_word_t bsp)
 549 {
 550   int result;
 551
 552   /* Caveat: this takes advantage of unsigned arithmetic.  The full
 553      test is (bsp >= rbs->end - rbs->size) && (bsp < rbs->end).  We
 554      take advantage of the fact that -n == ~n + 1.  */
 555   result = bsp - rbs->end > ~rbs->size;
 556   Debug (16, "0x%lx in [0x%lx-0x%lx) => %d\n",
 557          (long) bsp, (long) (rbs->end - rbs->size), (long) rbs->end, result);
 558   return result;
 559 }
 560
 561 static inline ia64_loc_t
 562 rbs_get_rnat_loc (struct rbs_area *rbs, unw_word_t bsp)
 563 {
 564   unw_word_t rnat_addr = rse_rnat_addr (bsp);
 565   ia64_loc_t rnat_loc;
 566
 567   if (rbs_contains (rbs, rnat_addr))
 568     {
 569       if (rbs_on_uc (rbs))
 570         rnat_loc = IA64_LOC_UC_ADDR (rnat_addr, 0);
 571       else
 572         rnat_loc = IA64_LOC_ADDR (rnat_addr, 0);
 573     }
 574   else
 575     rnat_loc = rbs->rnat_loc;
 576   return rnat_loc;
 577 }
 578
 579 static inline ia64_loc_t
 580 rbs_loc (struct rbs_area *rbs, unw_word_t bsp)
 581 {
 582   if (rbs_on_uc (rbs))
 583     return IA64_LOC_UC_ADDR (bsp, 0);
 584   else
 585     return IA64_LOC_ADDR (bsp, 0);
 586 }
 587
 588 static inline int
 589 ia64_get_stacked (struct cursor *c, unw_word_t reg,
 590                   ia64_loc_t *locp, ia64_loc_t *rnat_locp)
 591 {
 592   struct rbs_area *rbs = c->rbs_area + c->rbs_curr;
 593   unw_word_t addr, regs_to_skip = reg - 32;
 594   int ret = 0;
 595
 596   assert (reg >= 32 && reg < 128);
 597
 598   addr = rse_skip_regs (c->bsp, regs_to_skip);
 599   if (locp)
 600     *locp = rbs_loc (rbs, addr);
 601   if (rnat_locp)
 602     *rnat_locp = rbs_get_rnat_loc (rbs, addr);
 603
 604   if (!rbs_contains (rbs, addr))
 605     ret = rbs_find_stacked (c, regs_to_skip, locp, rnat_locp);
 606   return ret;
 607 }
 608
 609 /* The UNaT slot # calculation is identical to the one for RNaT slots,
 610    but for readability/clarity, we don't want to use
 611    ia64_rnat_slot_num() directly.  */
 612 #define ia64_unat_slot_num(addr)        rse_slot_num(addr)
 613
 614 /* The following are helper macros which makes it easier for libunwind
 615    to be used in the kernel.  They allow the kernel to optimize away
 616    any unused code without littering everything with #ifdefs.  */
 617 #define ia64_is_big_endian(c)   ((c)->as->big_endian)
 618 #define ia64_get_abi(c)         ((c)->as->abi)
 619 #define ia64_set_abi(c, v)      ((c)->as->abi = (v))
 620 #define ia64_get_abi_marker(c)  ((c)->last_abi_marker)
 621
 622 /* XXX should be in glibc: */
 623 #ifndef IA64_SC_FLAG_ONSTACK
 624 # define IA64_SC_FLAG_ONSTACK_BIT    0 /* running on signal stack? */
 625 # define IA64_SC_FLAG_IN_SYSCALL_BIT 1 /* did signal interrupt a syscall? */
 626 # define IA64_SC_FLAG_FPH_VALID_BIT  2 /* is state in f[32]-f[127] valid? */
 627
 628 # define IA64_SC_FLAG_ONSTACK           (1 << IA64_SC_FLAG_ONSTACK_BIT)
 629 # define IA64_SC_FLAG_IN_SYSCALL        (1 << IA64_SC_FLAG_IN_SYSCALL_BIT)
 630 # define IA64_SC_FLAG_FPH_VALID         (1 << IA64_SC_FLAG_FPH_VALID_BIT)
 631 #endif
 632
 633 #endif /* unwind_i_h */