libgcc/config/arm/unwind-arm.c

   1 /* ARM EABI compliant unwinding routines.
   2    Copyright (C) 2004-2016 Free Software Foundation, Inc.
   3    Contributed by Paul Brook
   4
   5    This file is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; either version 3, or (at your option) any
   8    later version.
   9
  10    This file is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    Under Section 7 of GPL version 3, you are granted additional
  16    permissions described in the GCC Runtime Library Exception, version
  17    3.1, as published by the Free Software Foundation.
  18
  19    You should have received a copy of the GNU General Public License and
  20    a copy of the GCC Runtime Library Exception along with this program;
  21    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22    <http://www.gnu.org/licenses/>.  */
  23
  24 #include "unwind.h"
  25
  26 /* Misc constants.  */
  27 #define R_IP    12
  28 #define R_SP    13
  29 #define R_LR    14
  30 #define R_PC    15
  31
  32 #define VRS_PC(vrs) ((vrs)->core.r[R_PC])
  33 #define VRS_SP(vrs) ((vrs)->core.r[R_SP])
  34 #define VRS_RETURN(vrs) ((vrs)->core.r[R_LR])
  35
  36 struct core_regs
  37 {
  38   _uw r[16];
  39 };
  40
  41 /* We use normal integer types here to avoid the compiler generating
  42    coprocessor instructions.  */
  43 struct vfp_regs
  44 {
  45   _uw64 d[16];
  46   _uw pad;
  47 };
  48
  49 struct vfpv3_regs
  50 {
  51   /* Always populated via VSTM, so no need for the "pad" field from
  52      vfp_regs (which is used to store the format word for FSTMX).  */
  53   _uw64 d[16];
  54 };
  55
  56 struct wmmxd_regs
  57 {
  58   _uw64 wd[16];
  59 };
  60
  61 struct wmmxc_regs
  62 {
  63   _uw wc[4];
  64 };
  65
  66 /* The ABI specifies that the unwind routines may only use core registers,
  67    except when actually manipulating coprocessor state.  This allows
  68    us to write one implementation that works on all platforms by
  69    demand-saving coprocessor registers.
  70
  71    During unwinding we hold the coprocessor state in the actual hardware
  72    registers and allocate demand-save areas for use during phase1
  73    unwinding.  */
  74
  75 typedef struct
  76 {
  77   /* The first fields must be the same as a phase2_vrs.  */
  78   _uw demand_save_flags;
  79   struct core_regs core;
  80   _uw prev_sp; /* Only valid during forced unwinding.  */
  81   struct vfp_regs vfp;
  82   struct vfpv3_regs vfp_regs_16_to_31;
  83   struct wmmxd_regs wmmxd;
  84   struct wmmxc_regs wmmxc;
  85 } phase1_vrs;
  86
  87 #define DEMAND_SAVE_VFP 1       /* VFP state has been saved if not set */
  88 #define DEMAND_SAVE_VFP_D 2     /* VFP state is for FLDMD/FSTMD if set */
  89 #define DEMAND_SAVE_VFP_V3 4    /* VFPv3 state for regs 16 .. 31 has
  90                                    been saved if not set */
  91 #define DEMAND_SAVE_WMMXD 8     /* iWMMXt data registers have been
  92                                    saved if not set.  */
  93 #define DEMAND_SAVE_WMMXC 16    /* iWMMXt control registers have been
  94                                    saved if not set.  */
  95
  96 /* This must match the structure created by the assembly wrappers.  */
  97 typedef struct
  98 {
  99   _uw demand_save_flags;
 100   struct core_regs core;
 101 } phase2_vrs;
 102
 103 /* Coprocessor register state manipulation functions.  */
 104
 105 /* Routines for FLDMX/FSTMX format...  */
 106 void __gnu_Unwind_Save_VFP (struct vfp_regs * p);
 107 void __gnu_Unwind_Restore_VFP (struct vfp_regs * p);
 108 void __gnu_Unwind_Save_WMMXD (struct wmmxd_regs * p);
 109 void __gnu_Unwind_Restore_WMMXD (struct wmmxd_regs * p);
 110 void __gnu_Unwind_Save_WMMXC (struct wmmxc_regs * p);
 111 void __gnu_Unwind_Restore_WMMXC (struct wmmxc_regs * p);
 112
 113 /* ...and those for FLDMD/FSTMD format...  */
 114 void __gnu_Unwind_Save_VFP_D (struct vfp_regs * p);
 115 void __gnu_Unwind_Restore_VFP_D (struct vfp_regs * p);
 116
 117 /* ...and those for VLDM/VSTM format, saving/restoring only registers
 118    16 through 31.  */
 119 void __gnu_Unwind_Save_VFP_D_16_to_31 (struct vfpv3_regs * p);
 120 void __gnu_Unwind_Restore_VFP_D_16_to_31 (struct vfpv3_regs * p);
 121
 122 /* Restore coprocessor state after phase1 unwinding.  */
 123 static void
 124 restore_non_core_regs (phase1_vrs * vrs)
 125 {
 126   if ((vrs->demand_save_flags & DEMAND_SAVE_VFP) == 0)
 127     {
 128       if (vrs->demand_save_flags & DEMAND_SAVE_VFP_D)
 129         __gnu_Unwind_Restore_VFP_D (&vrs->vfp);
 130       else
 131         __gnu_Unwind_Restore_VFP (&vrs->vfp);
 132     }
 133
 134   if ((vrs->demand_save_flags & DEMAND_SAVE_VFP_V3) == 0)
 135     __gnu_Unwind_Restore_VFP_D_16_to_31 (&vrs->vfp_regs_16_to_31);
 136
 137   if ((vrs->demand_save_flags & DEMAND_SAVE_WMMXD) == 0)
 138     __gnu_Unwind_Restore_WMMXD (&vrs->wmmxd);
 139   if ((vrs->demand_save_flags & DEMAND_SAVE_WMMXC) == 0)
 140     __gnu_Unwind_Restore_WMMXC (&vrs->wmmxc);
 141 }
 142
 143 #include "unwind-arm-common.inc"
 144
 145 /* ABI defined personality routines.  */
 146 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr0 (_Unwind_State,
 147     _Unwind_Control_Block *, _Unwind_Context *);// __attribute__((weak));
 148 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr1 (_Unwind_State,
 149     _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
 150 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr2 (_Unwind_State,
 151     _Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
 152
 153 /* ABI defined routine to store a virtual register to memory.  */
 154
 155 _Unwind_VRS_Result _Unwind_VRS_Get (_Unwind_Context *context,
 156                                     _Unwind_VRS_RegClass regclass,
 157                                     _uw regno,
 158                                     _Unwind_VRS_DataRepresentation representation,
 159                                     void *valuep)
 160 {
 161   phase1_vrs *vrs = (phase1_vrs *) context;
 162
 163   switch (regclass)
 164     {
 165     case _UVRSC_CORE:
 166       if (representation != _UVRSD_UINT32
 167           || regno > 15)
 168         return _UVRSR_FAILED;
 169       *(_uw *) valuep = vrs->core.r[regno];
 170       return _UVRSR_OK;
 171
 172     case _UVRSC_VFP:
 173     case _UVRSC_WMMXD:
 174     case _UVRSC_WMMXC:
 175       return _UVRSR_NOT_IMPLEMENTED;
 176
 177     default:
 178       return _UVRSR_FAILED;
 179     }
 180 }
 181
 182
 183 /* ABI defined function to load a virtual register from memory.  */
 184
 185 _Unwind_VRS_Result _Unwind_VRS_Set (_Unwind_Context *context,
 186                                     _Unwind_VRS_RegClass regclass,
 187                                     _uw regno,
 188                                     _Unwind_VRS_DataRepresentation representation,
 189                                     void *valuep)
 190 {
 191   phase1_vrs *vrs = (phase1_vrs *) context;
 192
 193   switch (regclass)
 194     {
 195     case _UVRSC_CORE:
 196       if (representation != _UVRSD_UINT32
 197           || regno > 15)
 198         return _UVRSR_FAILED;
 199
 200       vrs->core.r[regno] = *(_uw *) valuep;
 201       return _UVRSR_OK;
 202
 203     case _UVRSC_VFP:
 204     case _UVRSC_WMMXD:
 205     case _UVRSC_WMMXC:
 206       return _UVRSR_NOT_IMPLEMENTED;
 207
 208     default:
 209       return _UVRSR_FAILED;
 210     }
 211 }
 212
 213
 214 /* ABI defined function to pop registers off the stack.  */
 215
 216 _Unwind_VRS_Result _Unwind_VRS_Pop (_Unwind_Context *context,
 217                                     _Unwind_VRS_RegClass regclass,
 218                                     _uw discriminator,
 219                                     _Unwind_VRS_DataRepresentation representation)
 220 {
 221   phase1_vrs *vrs = (phase1_vrs *) context;
 222
 223   switch (regclass)
 224     {
 225     case _UVRSC_CORE:
 226       {
 227         _uw *ptr;
 228         _uw mask;
 229         int i;
 230
 231         if (representation != _UVRSD_UINT32)
 232           return _UVRSR_FAILED;
 233
 234         mask = discriminator & 0xffff;
 235         ptr = (_uw *) vrs->core.r[R_SP];
 236         /* Pop the requested registers.  */
 237         for (i = 0; i < 16; i++)
 238           {
 239             if (mask & (1 << i))
 240               vrs->core.r[i] = *(ptr++);
 241           }
 242         /* Writeback the stack pointer value if it wasn't restored.  */
 243         if ((mask & (1 << R_SP)) == 0)
 244           vrs->core.r[R_SP] = (_uw) ptr;
 245       }
 246       return _UVRSR_OK;
 247
 248     case _UVRSC_VFP:
 249       {
 250         _uw start = discriminator >> 16;
 251         _uw count = discriminator & 0xffff;
 252         struct vfp_regs tmp;
 253         struct vfpv3_regs tmp_16_to_31;
 254         int tmp_count;
 255         _uw *sp;
 256         _uw *dest;
 257         int num_vfpv3_regs = 0;
 258
 259         /* We use an approximation here by bounding _UVRSD_DOUBLE
 260            register numbers at 32 always, since we can't detect if
 261            VFPv3 isn't present (in such a case the upper limit is 16).  */
 262         if ((representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
 263             || start + count > (representation == _UVRSD_VFPX ? 16 : 32)
 264             || (representation == _UVRSD_VFPX && start >= 16))
 265           return _UVRSR_FAILED;
 266
 267         /* Check if we're being asked to pop VFPv3-only registers
 268            (numbers 16 through 31).  */
 269         if (start >= 16)
 270           num_vfpv3_regs = count;
 271         else if (start + count > 16)
 272           num_vfpv3_regs = start + count - 16;
 273
 274         if (num_vfpv3_regs && representation != _UVRSD_DOUBLE)
 275           return _UVRSR_FAILED;
 276
 277         /* Demand-save coprocessor registers for stage1.  */
 278         if (start < 16 && (vrs->demand_save_flags & DEMAND_SAVE_VFP))
 279           {
 280             vrs->demand_save_flags &= ~DEMAND_SAVE_VFP;
 281
 282             if (representation == _UVRSD_DOUBLE)
 283               {
 284                 /* Save in FLDMD/FSTMD format.  */
 285                 vrs->demand_save_flags |= DEMAND_SAVE_VFP_D;
 286                 __gnu_Unwind_Save_VFP_D (&vrs->vfp);
 287               }
 288             else
 289               {
 290                 /* Save in FLDMX/FSTMX format.  */
 291                 vrs->demand_save_flags &= ~DEMAND_SAVE_VFP_D;
 292                 __gnu_Unwind_Save_VFP (&vrs->vfp);
 293               }
 294           }
 295
 296         if (num_vfpv3_regs > 0
 297             && (vrs->demand_save_flags & DEMAND_SAVE_VFP_V3))
 298           {
 299             vrs->demand_save_flags &= ~DEMAND_SAVE_VFP_V3;
 300             __gnu_Unwind_Save_VFP_D_16_to_31 (&vrs->vfp_regs_16_to_31);
 301           }
 302
 303         /* Restore the registers from the stack.  Do this by saving the
 304            current VFP registers to a memory area, moving the in-memory
 305            values into that area, and restoring from the whole area.
 306            For _UVRSD_VFPX we assume FSTMX standard format 1.  */
 307         if (representation == _UVRSD_VFPX)
 308           __gnu_Unwind_Save_VFP (&tmp);
 309         else
 310           {
 311             /* Save registers 0 .. 15 if required.  */
 312             if (start < 16)
 313               __gnu_Unwind_Save_VFP_D (&tmp);
 314
 315             /* Save VFPv3 registers 16 .. 31 if required.  */
 316             if (num_vfpv3_regs)
 317               __gnu_Unwind_Save_VFP_D_16_to_31 (&tmp_16_to_31);
 318           }
 319
 320         /* Work out how many registers below register 16 need popping.  */
 321         tmp_count = num_vfpv3_regs > 0 ? 16 - start : count;
 322
 323         /* Copy registers below 16, if needed.
 324            The stack address is only guaranteed to be word aligned, so
 325            we can't use doubleword copies.  */
 326         sp = (_uw *) vrs->core.r[R_SP];
 327         if (tmp_count > 0)
 328           {
 329             tmp_count *= 2;
 330             dest = (_uw *) &tmp.d[start];
 331             while (tmp_count--)
 332               *(dest++) = *(sp++);
 333           }
 334
 335         /* Copy VFPv3 registers numbered >= 16, if needed.  */
 336         if (num_vfpv3_regs > 0)
 337           {
 338             /* num_vfpv3_regs is needed below, so copy it.  */
 339             int tmp_count_2 = num_vfpv3_regs * 2;
 340             int vfpv3_start = start < 16 ? 16 : start;
 341
 342             dest = (_uw *) &tmp_16_to_31.d[vfpv3_start - 16];
 343             while (tmp_count_2--)
 344               *(dest++) = *(sp++);
 345           }
 346
 347         /* Skip the format word space if using FLDMX/FSTMX format.  */
 348         if (representation == _UVRSD_VFPX)
 349           sp++;
 350
 351         /* Set the new stack pointer.  */
 352         vrs->core.r[R_SP] = (_uw) sp;
 353
 354         /* Reload the registers.  */
 355         if (representation == _UVRSD_VFPX)
 356           __gnu_Unwind_Restore_VFP (&tmp);
 357         else
 358           {
 359             /* Restore registers 0 .. 15 if required.  */
 360             if (start < 16)
 361               __gnu_Unwind_Restore_VFP_D (&tmp);
 362
 363             /* Restore VFPv3 registers 16 .. 31 if required.  */
 364             if (num_vfpv3_regs > 0)
 365               __gnu_Unwind_Restore_VFP_D_16_to_31 (&tmp_16_to_31);
 366           }
 367       }
 368       return _UVRSR_OK;
 369
 370     case _UVRSC_WMMXD:
 371       {
 372         _uw start = discriminator >> 16;
 373         _uw count = discriminator & 0xffff;
 374         struct wmmxd_regs tmp;
 375         _uw *sp;
 376         _uw *dest;
 377
 378         if ((representation != _UVRSD_UINT64) || start + count > 16)
 379           return _UVRSR_FAILED;
 380
 381         if (vrs->demand_save_flags & DEMAND_SAVE_WMMXD)
 382           {
 383             /* Demand-save resisters for stage1.  */
 384             vrs->demand_save_flags &= ~DEMAND_SAVE_WMMXD;
 385             __gnu_Unwind_Save_WMMXD (&vrs->wmmxd);
 386           }
 387
 388         /* Restore the registers from the stack.  Do this by saving the
 389            current WMMXD registers to a memory area, moving the in-memory
 390            values into that area, and restoring from the whole area.  */
 391         __gnu_Unwind_Save_WMMXD (&tmp);
 392
 393         /* The stack address is only guaranteed to be word aligned, so
 394            we can't use doubleword copies.  */
 395         sp = (_uw *) vrs->core.r[R_SP];
 396         dest = (_uw *) &tmp.wd[start];
 397         count *= 2;
 398         while (count--)
 399           *(dest++) = *(sp++);
 400
 401         /* Set the new stack pointer.  */
 402         vrs->core.r[R_SP] = (_uw) sp;
 403
 404         /* Reload the registers.  */
 405         __gnu_Unwind_Restore_WMMXD (&tmp);
 406       }
 407       return _UVRSR_OK;
 408
 409     case _UVRSC_WMMXC:
 410       {
 411         int i;
 412         struct wmmxc_regs tmp;
 413         _uw *sp;
 414
 415         if ((representation != _UVRSD_UINT32) || discriminator > 16)
 416           return _UVRSR_FAILED;
 417
 418         if (vrs->demand_save_flags & DEMAND_SAVE_WMMXC)
 419           {
 420             /* Demand-save resisters for stage1.  */
 421             vrs->demand_save_flags &= ~DEMAND_SAVE_WMMXC;
 422             __gnu_Unwind_Save_WMMXC (&vrs->wmmxc);
 423           }
 424
 425         /* Restore the registers from the stack.  Do this by saving the
 426            current WMMXC registers to a memory area, moving the in-memory
 427            values into that area, and restoring from the whole area.  */
 428         __gnu_Unwind_Save_WMMXC (&tmp);
 429
 430         sp = (_uw *) vrs->core.r[R_SP];
 431         for (i = 0; i < 4; i++)
 432           if (discriminator & (1 << i))
 433             tmp.wc[i] = *(sp++);
 434
 435         /* Set the new stack pointer.  */
 436         vrs->core.r[R_SP] = (_uw) sp;
 437
 438         /* Reload the registers.  */
 439         __gnu_Unwind_Restore_WMMXC (&tmp);
 440       }
 441       return _UVRSR_OK;
 442
 443     default:
 444       return _UVRSR_FAILED;
 445     }
 446 }
 447
 448
 449 /* Core unwinding functions.  */
 450
 451 /* Calculate the address encoded by a 31-bit self-relative offset at address
 452    P.  */
 453 static inline _uw
 454 selfrel_offset31 (const _uw *p)
 455 {
 456   _uw offset;
 457
 458   offset = *p;
 459   /* Sign extend to 32 bits.  */
 460   if (offset & (1 << 30))
 461     offset |= 1u << 31;
 462   else
 463     offset &= ~(1u << 31);
 464
 465   return offset + (_uw) p;
 466 }
 467
 468 static _uw
 469 __gnu_unwind_get_pr_addr (int idx)
 470 {
 471   switch (idx)
 472     {
 473     case 0:
 474       return (_uw) &__aeabi_unwind_cpp_pr0;
 475
 476     case 1:
 477       return (_uw) &__aeabi_unwind_cpp_pr1;
 478
 479     case 2:
 480       return (_uw) &__aeabi_unwind_cpp_pr2;
 481
 482     default:
 483       return 0;
 484     }
 485 }
 486
 487 /* ABI defined personality routine entry points.  */
 488
 489 _Unwind_Reason_Code
 490 __aeabi_unwind_cpp_pr0 (_Unwind_State state,
 491                         _Unwind_Control_Block *ucbp,
 492                         _Unwind_Context *context)
 493 {
 494   return __gnu_unwind_pr_common (state, ucbp, context, 0);
 495 }
 496
 497 _Unwind_Reason_Code
 498 __aeabi_unwind_cpp_pr1 (_Unwind_State state,
 499                         _Unwind_Control_Block *ucbp,
 500                         _Unwind_Context *context)
 501 {
 502   return __gnu_unwind_pr_common (state, ucbp, context, 1);
 503 }
 504
 505 _Unwind_Reason_Code
 506 __aeabi_unwind_cpp_pr2 (_Unwind_State state,
 507                         _Unwind_Control_Block *ucbp,
 508                         _Unwind_Context *context)
 509 {
 510   return __gnu_unwind_pr_common (state, ucbp, context, 2);
 511 }