1/* Common unwinding code for ARM EABI and C6X. 2 Copyright (C) 2004-2022 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 "tconfig.h" 25#include "tsystem.h" 26#include "unwind.h" 27 28/* Used for SystemTap unwinder probe. */ 29#ifdef HAVE_SYS_SDT_H 30#include <sys/sdt.h> 31#endif 32 33#if __FDPIC__ 34/* Load r7 with rt_sigreturn value. */ 35#define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad /* mov r7, #0xad */ 36#define THUMB2_SET_R7_RT_SIGRETURN 0x07adf04f /* mov.w r7, #0xad */ 37 38/* FDPIC jump to restorer sequence. */ 39#define FDPIC_LDR_R12_WITH_FUNCDESC 0xe59fc004 /* ldr r12, [pc, #4] */ 40#define FDPIC_LDR_R9_WITH_GOT 0xe59c9004 /* ldr r9, [r12, #4] */ 41#define FDPIC_LDR_PC_WITH_RESTORER 0xe59cf000 /* ldr pc, [r12] */ 42#define FDPIC_T2_LDR_R12_WITH_FUNCDESC 0xc008f8df /* ldr.w r12, [pc, #8] */ 43#define FDPIC_T2_LDR_R9_WITH_GOT 0x9004f8dc /* ldr.w r9, [r12, #4] */ 44#define FDPIC_T2_LDR_PC_WITH_RESTORER 0xf000f8dc /* ldr.w pc, [r12] */ 45#define FDPIC_FUNCDESC_OFFSET 12 46 47/* Signal frame offsets. */ 48#define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80 49#define ARM_UCONTEXT_SIGCONTEXT 0x14 50#define ARM_SIGCONTEXT_R0 0xc 51#endif 52 53/* Definitions for C++ runtime support routines. We make these weak 54 declarations to avoid pulling in libsupc++ unnecessarily. */ 55typedef unsigned char bool; 56 57typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */ 58enum __cxa_type_match_result 59 { 60 ctm_failed = 0, 61 ctm_succeeded = 1, 62 ctm_succeeded_with_ptr_to_base = 2 63 }; 64 65void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp); 66bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp); 67enum __cxa_type_match_result __attribute__((weak)) __cxa_type_match 68 (_Unwind_Control_Block *ucbp, const type_info *rttip, 69 bool is_reference, void **matched_object); 70 71_Unwind_Ptr __attribute__((weak)) 72__gnu_Unwind_Find_exidx (_Unwind_Ptr, int *); 73 74#define EXIDX_CANTUNWIND 1 75#define uint32_highbit (((_uw) 1) << 31) 76 77#define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1) 78#define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2) 79#define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3) 80#define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4) 81#define UCB_PR_GOT(ucbp) ((ucbp)->unwinder_cache.reserved5) 82 83/* Unwind descriptors. */ 84 85typedef struct 86{ 87 _uw16 length; 88 _uw16 offset; 89} EHT16; 90 91typedef struct 92{ 93 _uw length; 94 _uw offset; 95} EHT32; 96 97/* An exception index table entry. */ 98 99typedef struct __EIT_entry 100{ 101 _uw fnoffset; 102 _uw content; 103} __EIT_entry; 104 105#ifdef __FDPIC__ 106 107/* Only used in FDPIC case. */ 108struct funcdesc_t 109{ 110 unsigned int ptr; 111 unsigned int got; 112}; 113#endif 114 115/* Assembly helper functions. */ 116 117/* Restore core register state. Never returns. */ 118void __attribute__((noreturn)) restore_core_regs (struct core_regs *); 119 120 121/* Restore coprocessor state after phase1 unwinding. */ 122static void restore_non_core_regs (phase1_vrs * vrs); 123 124/* A better way to do this would probably be to compare the absolute address 125 with a segment relative relocation of the same symbol. */ 126 127extern int __text_start; 128extern int __data_start; 129 130/* The exception index table location. */ 131extern __EIT_entry __exidx_start; 132extern __EIT_entry __exidx_end; 133 134/* Core unwinding functions. */ 135 136/* Calculate the address encoded by a 31-bit self-relative offset at address 137 P. */ 138static inline _uw selfrel_offset31 (const _uw *p); 139 140static _uw __gnu_unwind_get_pr_addr (int idx); 141 142static void _Unwind_DebugHook (void *, void *) 143 __attribute__ ((__noinline__, __used__, __noclone__)); 144 145/* This function is called during unwinding. It is intended as a hook 146 for a debugger to intercept exceptions. CFA is the CFA of the 147 target frame. HANDLER is the PC to which control will be 148 transferred. */ 149 150static void 151_Unwind_DebugHook (void *cfa __attribute__ ((__unused__)), 152 void *handler __attribute__ ((__unused__))) 153{ 154 /* We only want to use stap probes starting with v3. Earlier 155 versions added too much startup cost. */ 156#if defined (HAVE_SYS_SDT_H) && defined (STAP_PROBE2) && _SDT_NOTE_TYPE >= 3 157 STAP_PROBE2 (libgcc, unwind, cfa, handler); 158#else 159 asm (""); 160#endif 161} 162 163/* This is a wrapper to be called when we need to restore core registers. 164 It will call `_Unwind_DebugHook' before restoring the registers, thus 165 making it possible to intercept and debug exceptions. 166 167 When calling `_Unwind_DebugHook', the first argument (the CFA) is zero 168 because we are not interested in it. However, it must be there (even 169 being zero) because GDB expects to find it when using the probe. */ 170 171#define uw_restore_core_regs(TARGET, CORE) \ 172 do \ 173 { \ 174 void *handler = __builtin_frob_return_addr ((void *) VRS_PC (TARGET)); \ 175 _Unwind_DebugHook (0, handler); \ 176 restore_core_regs (CORE); \ 177 } \ 178 while (0) 179 180/* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains 181 NREC entries. */ 182 183static const __EIT_entry * 184search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address) 185{ 186 _uw next_fn; 187 _uw this_fn; 188 int n, left, right; 189 190 if (nrec == 0) 191 return (__EIT_entry *) 0; 192 193 left = 0; 194 right = nrec - 1; 195 196 while (1) 197 { 198 n = (left + right) / 2; 199 this_fn = selfrel_offset31 (&table[n].fnoffset); 200 if (n != nrec - 1) 201 next_fn = selfrel_offset31 (&table[n + 1].fnoffset) - 1; 202 else 203 next_fn = (_uw)0 - 1; 204 205 if (return_address < this_fn) 206 { 207 if (n == left) 208 return (__EIT_entry *) 0; 209 right = n - 1; 210 } 211 else if (return_address <= next_fn) 212 return &table[n]; 213 else 214 left = n + 1; 215 } 216} 217 218#if __FDPIC__ 219/* VFP is not restored, but this is sufficient to allow unwinding. */ 220static _Unwind_Reason_Code 221__gnu_personality_sigframe_fdpic (_Unwind_State state, 222 _Unwind_Control_Block *ucbp, 223 _Unwind_Context *context) 224{ 225 unsigned int sp; 226 unsigned int pc; 227 unsigned int funcdesc; 228 unsigned int handler; 229 unsigned int first_handler_instruction; 230 int i; 231 232 _Unwind_VRS_Get (context, _UVRSC_CORE, R_SP, _UVRSD_UINT32, &sp); 233 _Unwind_VRS_Get (context, _UVRSC_CORE, R_PC, _UVRSD_UINT32, &pc); 234 235 funcdesc = *(unsigned int *)((pc & ~1) + FDPIC_FUNCDESC_OFFSET); 236 handler = *(unsigned int *)(funcdesc); 237 first_handler_instruction = *(unsigned int *)(handler & ~1); 238 239 /* Adjust SP to point to the start of registers according to 240 signal type. */ 241 if (first_handler_instruction == ARM_SET_R7_RT_SIGRETURN 242 || first_handler_instruction == THUMB2_SET_R7_RT_SIGRETURN) 243 sp += ARM_NEW_RT_SIGFRAME_UCONTEXT 244 + ARM_UCONTEXT_SIGCONTEXT 245 + ARM_SIGCONTEXT_R0; 246 else 247 sp += ARM_UCONTEXT_SIGCONTEXT 248 + ARM_SIGCONTEXT_R0; 249 /* Restore regs saved on stack by the kernel. */ 250 for (i = 0; i < 16; i++) 251 _Unwind_VRS_Set (context, _UVRSC_CORE, i, _UVRSD_UINT32, sp + 4 * i); 252 253 return _URC_CONTINUE_UNWIND; 254} 255#endif 256 257/* Find the exception index table eintry for the given address. 258 Fill in the relevant fields of the UCB. 259 Returns _URC_FAILURE if an error occurred, _URC_OK on success. */ 260 261static _Unwind_Reason_Code 262get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address) 263{ 264 const __EIT_entry * eitp; 265 int nrec; 266 267 /* The return address is the address of the instruction following the 268 call instruction (plus one in thumb mode). If this was the last 269 instruction in the function the address will lie in the following 270 function. Subtract 2 from the address so that it points within the call 271 instruction itself. */ 272 return_address -= 2; 273 274 if (__gnu_Unwind_Find_exidx) 275 { 276 eitp = (const __EIT_entry *) __gnu_Unwind_Find_exidx (return_address, 277 &nrec); 278 if (!eitp) 279 { 280#if __FDPIC__ 281 /* If we are unwinding a signal handler then perhaps we have 282 reached a trampoline. Try to detect jump to restorer 283 sequence. */ 284 _uw *pc = (_uw *)((return_address+2) & ~1); 285 if ((pc[0] == FDPIC_LDR_R12_WITH_FUNCDESC 286 && pc[1] == FDPIC_LDR_R9_WITH_GOT 287 && pc[2] == FDPIC_LDR_PC_WITH_RESTORER) 288 || (pc[0] == FDPIC_T2_LDR_R12_WITH_FUNCDESC 289 && pc[1] == FDPIC_T2_LDR_R9_WITH_GOT 290 && pc[2] == FDPIC_T2_LDR_PC_WITH_RESTORER)) 291 { 292 struct funcdesc_t *funcdesc 293 = (struct funcdesc_t *) &__gnu_personality_sigframe_fdpic; 294 295 UCB_PR_ADDR (ucbp) = funcdesc->ptr; 296 UCB_PR_GOT (ucbp) = funcdesc->got; 297 298 return _URC_OK; 299 } 300#endif 301 UCB_PR_ADDR (ucbp) = 0; 302 return _URC_FAILURE; 303 } 304 } 305 else 306 { 307 eitp = &__exidx_start; 308 nrec = &__exidx_end - &__exidx_start; 309 } 310 311 eitp = search_EIT_table (eitp, nrec, return_address); 312 313 if (!eitp) 314 { 315#if __FDPIC__ 316 /* If we are unwinding a signal handler then perhaps we have 317 reached a trampoline. Try to detect jump to restorer 318 sequence. */ 319 _uw *pc = (_uw *)((return_address+2) & ~1); 320 if ((pc[0] == FDPIC_LDR_R12_WITH_FUNCDESC 321 && pc[1] == FDPIC_LDR_R9_WITH_GOT 322 && pc[2] == FDPIC_LDR_PC_WITH_RESTORER) 323 || (pc[0] == FDPIC_T2_LDR_R12_WITH_FUNCDESC 324 && pc[1] == FDPIC_T2_LDR_R9_WITH_GOT 325 && pc[2] == FDPIC_T2_LDR_PC_WITH_RESTORER)) 326 { 327 struct funcdesc_t *funcdesc 328 = (struct funcdesc_t *) &__gnu_personality_sigframe_fdpic; 329 330 UCB_PR_ADDR (ucbp) = funcdesc->ptr; 331 UCB_PR_GOT (ucbp) = funcdesc->got; 332 333 return _URC_OK; 334 } 335#endif 336 UCB_PR_ADDR (ucbp) = 0; 337 return _URC_FAILURE; 338 } 339 ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset); 340 341 /* Can this frame be unwound at all? */ 342 if (eitp->content == EXIDX_CANTUNWIND) 343 { 344#if __FDPIC__ 345 /* If we are unwinding a signal handler then perhaps we have 346 reached a trampoline. Try to detect jump to restorer 347 sequence. */ 348 _uw *pc = (_uw *)((return_address+2) & ~1); 349 if ((pc[0] == FDPIC_LDR_R12_WITH_FUNCDESC 350 && pc[1] == FDPIC_LDR_R9_WITH_GOT 351 && pc[2] == FDPIC_LDR_PC_WITH_RESTORER) 352 || (pc[0] == FDPIC_T2_LDR_R12_WITH_FUNCDESC 353 && pc[1] == FDPIC_T2_LDR_R9_WITH_GOT 354 && pc[2] == FDPIC_T2_LDR_PC_WITH_RESTORER)) 355 { 356 struct funcdesc_t *funcdesc 357 = (struct funcdesc_t *) &__gnu_personality_sigframe_fdpic; 358 359 UCB_PR_ADDR (ucbp) = funcdesc->ptr; 360 UCB_PR_GOT (ucbp) = funcdesc->got; 361 362 return _URC_OK; 363 } 364#endif 365 UCB_PR_ADDR (ucbp) = 0; 366 return _URC_END_OF_STACK; 367 } 368 369 /* Obtain the address of the "real" __EHT_Header word. */ 370 371 if (eitp->content & uint32_highbit) 372 { 373 /* It is immediate data. */ 374 ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content; 375 ucbp->pr_cache.additional = 1; 376 } 377 else 378 { 379 /* The low 31 bits of the content field are a self-relative 380 offset to an _Unwind_EHT_Entry structure. */ 381 ucbp->pr_cache.ehtp = 382 (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content); 383 ucbp->pr_cache.additional = 0; 384 } 385 386 /* Discover the personality routine address. */ 387 if (*ucbp->pr_cache.ehtp & (1u << 31)) 388 { 389 /* One of the predefined standard routines. */ 390 _uw idx = (*(_uw *) ucbp->pr_cache.ehtp >> 24) & 0xf; 391#if __FDPIC__ 392 { 393 struct funcdesc_t *funcdesc 394 = (struct funcdesc_t *) __gnu_unwind_get_pr_addr (idx); 395 if (funcdesc) 396 { 397 UCB_PR_ADDR (ucbp) = funcdesc->ptr; 398 UCB_PR_GOT (ucbp) = funcdesc->got; 399 } 400 else 401 UCB_PR_ADDR (ucbp) = 0; 402 } 403#else 404 UCB_PR_ADDR (ucbp) = __gnu_unwind_get_pr_addr (idx); 405#endif 406 if (UCB_PR_ADDR (ucbp) == 0) 407 { 408 /* Failed */ 409 return _URC_FAILURE; 410 } 411 } 412 else 413 { 414 /* Execute region offset to PR */ 415 UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp); 416#if __FDPIC__ 417 UCB_PR_GOT (ucbp) 418 = (unsigned int) _Unwind_gnu_Find_got ((_Unwind_Ptr) UCB_PR_ADDR (ucbp)); 419#endif 420 } 421 return _URC_OK; 422} 423 424 425/* Perform phase2 unwinding. VRS is the initial virtual register state. */ 426 427static void __attribute__((noreturn)) 428unwind_phase2 (_Unwind_Control_Block * ucbp, phase2_vrs * vrs) 429{ 430 _Unwind_Reason_Code pr_result; 431 432 do 433 { 434 /* Find the entry for this routine. */ 435 if (get_eit_entry (ucbp, VRS_PC(vrs)) != _URC_OK) 436 abort (); 437 438 UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC(vrs); 439 440 /* Call the pr to decide what to do. */ 441#if __FDPIC__ 442 { 443 volatile struct funcdesc_t funcdesc; 444 funcdesc.ptr = UCB_PR_ADDR (ucbp); 445 funcdesc.got = UCB_PR_GOT (ucbp); 446 pr_result = ((personality_routine) &funcdesc) 447 (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs); 448 } 449#else 450 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) 451 (_US_UNWIND_FRAME_STARTING, ucbp, (_Unwind_Context *) vrs); 452#endif 453 } 454 while (pr_result == _URC_CONTINUE_UNWIND); 455 456 if (pr_result != _URC_INSTALL_CONTEXT) 457 abort(); 458 459#if __FDPIC__ 460 /* r9 could have been lost due to PLT jump. Restore correct value. */ 461 vrs->core.r[FDPIC_REGNUM] = _Unwind_gnu_Find_got (VRS_PC (vrs)); 462#endif 463 464 uw_restore_core_regs (vrs, &vrs->core); 465} 466 467/* Perform phase2 forced unwinding. */ 468 469static _Unwind_Reason_Code 470unwind_phase2_forced (_Unwind_Control_Block *ucbp, phase2_vrs *entry_vrs, 471 int resuming) 472{ 473 _Unwind_Stop_Fn stop_fn = (_Unwind_Stop_Fn) UCB_FORCED_STOP_FN (ucbp); 474 void *stop_arg = (void *)UCB_FORCED_STOP_ARG (ucbp); 475 _Unwind_Reason_Code pr_result = 0; 476 /* We use phase1_vrs here even though we do not demand save, for the 477 prev_sp field. */ 478 phase1_vrs saved_vrs, next_vrs; 479 480 /* Save the core registers. */ 481 saved_vrs.core = entry_vrs->core; 482 /* We don't need to demand-save the non-core registers, because we 483 unwind in a single pass. */ 484 saved_vrs.demand_save_flags = 0; 485 486 /* Unwind until we reach a propagation barrier. */ 487 do 488 { 489 _Unwind_State action; 490 _Unwind_Reason_Code entry_code; 491 _Unwind_Reason_Code stop_code; 492 493 /* Find the entry for this routine. */ 494 entry_code = get_eit_entry (ucbp, VRS_PC (&saved_vrs)); 495 496 if (resuming) 497 { 498 action = _US_UNWIND_FRAME_RESUME | _US_FORCE_UNWIND; 499 resuming = 0; 500 } 501 else 502 action = _US_UNWIND_FRAME_STARTING | _US_FORCE_UNWIND; 503 504 if (entry_code == _URC_OK) 505 { 506 UCB_SAVED_CALLSITE_ADDR (ucbp) = VRS_PC (&saved_vrs); 507 508 next_vrs = saved_vrs; 509 510 /* Call the pr to decide what to do. */ 511#if __FDPIC__ 512 { 513 volatile struct funcdesc_t funcdesc; 514 funcdesc.ptr = UCB_PR_ADDR (ucbp); 515 funcdesc.got = UCB_PR_GOT (ucbp); 516 pr_result = ((personality_routine) &funcdesc) 517 (action, ucbp, (void *) &next_vrs); 518 } 519#else 520 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) 521 (action, ucbp, (void *) &next_vrs); 522#endif 523 524 saved_vrs.prev_sp = VRS_SP (&next_vrs); 525 } 526 else 527 { 528 /* Treat any failure as the end of unwinding, to cope more 529 gracefully with missing EH information. Mixed EH and 530 non-EH within one object will usually result in failure, 531 because the .ARM.exidx tables do not indicate the end 532 of the code to which they apply; but mixed EH and non-EH 533 shared objects should return an unwind failure at the 534 entry of a non-EH shared object. */ 535 action |= _US_END_OF_STACK; 536 537 saved_vrs.prev_sp = VRS_SP (&saved_vrs); 538 } 539 540 stop_code = stop_fn (1, action, ucbp->exception_class, ucbp, 541 (void *)&saved_vrs, stop_arg); 542 if (stop_code != _URC_NO_REASON) 543 return _URC_FAILURE; 544 545 if (entry_code != _URC_OK) 546 return entry_code; 547 548 saved_vrs = next_vrs; 549 } 550 while (pr_result == _URC_CONTINUE_UNWIND); 551 552 if (pr_result != _URC_INSTALL_CONTEXT) 553 { 554 /* Some sort of failure has occurred in the pr and probably the 555 pr returned _URC_FAILURE. */ 556 return _URC_FAILURE; 557 } 558 559#if __FDPIC__ 560 /* r9 could have been lost due to PLT jump. Restore correct value. */ 561 saved_vrs.core.r[FDPIC_REGNUM] = _Unwind_gnu_Find_got (VRS_PC (&saved_vrs)); 562#endif 563 564 uw_restore_core_regs (&saved_vrs, &saved_vrs.core); 565} 566 567/* This is a very limited implementation of _Unwind_GetCFA. It returns 568 the stack pointer as it is about to be unwound, and is only valid 569 while calling the stop function during forced unwinding. If the 570 current personality routine result is going to run a cleanup, this 571 will not be the CFA; but when the frame is really unwound, it will 572 be. */ 573 574_Unwind_Word 575_Unwind_GetCFA (_Unwind_Context *context) 576{ 577 return ((phase1_vrs *) context)->prev_sp; 578} 579 580/* Perform phase1 unwinding. UCBP is the exception being thrown, and 581 entry_VRS is the register state on entry to _Unwind_RaiseException. */ 582 583_Unwind_Reason_Code 584__gnu_Unwind_RaiseException (_Unwind_Control_Block *, phase2_vrs *); 585 586_Unwind_Reason_Code 587__gnu_Unwind_RaiseException (_Unwind_Control_Block * ucbp, 588 phase2_vrs * entry_vrs) 589{ 590 phase1_vrs saved_vrs; 591 _Unwind_Reason_Code pr_result; 592 593 /* Set the pc to the call site. */ 594 VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); 595 596 /* Save the core registers. */ 597 saved_vrs.core = entry_vrs->core; 598 /* Set demand-save flags. */ 599 saved_vrs.demand_save_flags = ~(_uw) 0; 600 601 /* Unwind until we reach a propagation barrier. */ 602 do 603 { 604 /* Find the entry for this routine. */ 605 if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) 606 return _URC_FAILURE; 607 608 /* Call the pr to decide what to do. */ 609#if __FDPIC__ 610 { 611 volatile struct funcdesc_t funcdesc; 612 funcdesc.ptr = UCB_PR_ADDR (ucbp); 613 funcdesc.got = UCB_PR_GOT (ucbp); 614 pr_result = ((personality_routine) &funcdesc) 615 (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs); 616 } 617#else 618 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) 619 (_US_VIRTUAL_UNWIND_FRAME, ucbp, (void *) &saved_vrs); 620#endif 621 } 622 while (pr_result == _URC_CONTINUE_UNWIND); 623 624 /* We've unwound as far as we want to go, so restore the original 625 register state. */ 626 restore_non_core_regs (&saved_vrs); 627 if (pr_result != _URC_HANDLER_FOUND) 628 { 629 /* Some sort of failure has occurred in the pr and probably the 630 pr returned _URC_FAILURE. */ 631 return _URC_FAILURE; 632 } 633 634 unwind_phase2 (ucbp, entry_vrs); 635} 636 637/* Resume unwinding after a cleanup has been run. UCBP is the exception 638 being thrown and ENTRY_VRS is the register state on entry to 639 _Unwind_Resume. */ 640_Unwind_Reason_Code 641__gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *, 642 _Unwind_Stop_Fn, void *, phase2_vrs *); 643 644_Unwind_Reason_Code 645__gnu_Unwind_ForcedUnwind (_Unwind_Control_Block *ucbp, 646 _Unwind_Stop_Fn stop_fn, void *stop_arg, 647 phase2_vrs *entry_vrs) 648{ 649 UCB_FORCED_STOP_FN (ucbp) = (_uw) stop_fn; 650 UCB_FORCED_STOP_ARG (ucbp) = (_uw) stop_arg; 651 652 /* Set the pc to the call site. */ 653 VRS_PC (entry_vrs) = VRS_RETURN(entry_vrs); 654 655 return unwind_phase2_forced (ucbp, entry_vrs, 0); 656} 657 658_Unwind_Reason_Code 659__gnu_Unwind_Resume (_Unwind_Control_Block *, phase2_vrs *); 660 661_Unwind_Reason_Code 662__gnu_Unwind_Resume (_Unwind_Control_Block * ucbp, phase2_vrs * entry_vrs) 663{ 664 _Unwind_Reason_Code pr_result; 665 666 /* Recover the saved address. */ 667 VRS_PC (entry_vrs) = UCB_SAVED_CALLSITE_ADDR (ucbp); 668 669 if (UCB_FORCED_STOP_FN (ucbp)) 670 { 671 unwind_phase2_forced (ucbp, entry_vrs, 1); 672 673 /* We can't return failure at this point. */ 674 abort (); 675 } 676 677 /* Call the cached PR. */ 678#if __FDPIC__ 679 { 680 volatile struct funcdesc_t funcdesc; 681 funcdesc.ptr = UCB_PR_ADDR (ucbp); 682 funcdesc.got = UCB_PR_GOT (ucbp); 683 pr_result = ((personality_routine) &funcdesc) 684 (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs); 685 } 686#else 687 pr_result = ((personality_routine) UCB_PR_ADDR (ucbp)) 688 (_US_UNWIND_FRAME_RESUME, ucbp, (_Unwind_Context *) entry_vrs); 689#endif 690 691 switch (pr_result) 692 { 693 case _URC_INSTALL_CONTEXT: 694 /* Upload the registers to enter the landing pad. */ 695#if __FDPIC__ 696 /* r9 could have been lost due to PLT jump. Restore correct value. */ 697 entry_vrs->core.r[FDPIC_REGNUM] = _Unwind_gnu_Find_got (VRS_PC (entry_vrs)); 698#endif 699 uw_restore_core_regs (entry_vrs, &entry_vrs->core); 700 701 case _URC_CONTINUE_UNWIND: 702 /* Continue unwinding the next frame. */ 703 unwind_phase2 (ucbp, entry_vrs); 704 705 default: 706 abort (); 707 } 708} 709 710_Unwind_Reason_Code 711__gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block *, phase2_vrs *); 712 713_Unwind_Reason_Code 714__gnu_Unwind_Resume_or_Rethrow (_Unwind_Control_Block * ucbp, 715 phase2_vrs * entry_vrs) 716{ 717 if (!UCB_FORCED_STOP_FN (ucbp)) 718 return __gnu_Unwind_RaiseException (ucbp, entry_vrs); 719 720 /* Set the pc to the call site. */ 721 VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); 722 /* Continue unwinding the next frame. */ 723 return unwind_phase2_forced (ucbp, entry_vrs, 0); 724} 725 726/* Clean up an exception object when unwinding is complete. */ 727void 728_Unwind_Complete (_Unwind_Control_Block * ucbp __attribute__((unused))) 729{ 730} 731 732 733/* Free an exception. */ 734 735void 736_Unwind_DeleteException (_Unwind_Exception * exc) 737{ 738 if (exc->exception_cleanup) 739 (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc); 740} 741 742 743/* Perform stack backtrace through unwind data. */ 744_Unwind_Reason_Code 745__gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, 746 phase2_vrs * entry_vrs); 747_Unwind_Reason_Code 748__gnu_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument, 749 phase2_vrs * entry_vrs) 750{ 751 phase1_vrs saved_vrs; 752 _Unwind_Reason_Code code; 753 754 _Unwind_Control_Block ucb; 755 _Unwind_Control_Block *ucbp = &ucb; 756 757 /* Set the pc to the call site. */ 758 VRS_PC (entry_vrs) = VRS_RETURN (entry_vrs); 759 760 /* Save the core registers. */ 761 saved_vrs.core = entry_vrs->core; 762 /* Set demand-save flags. */ 763 saved_vrs.demand_save_flags = ~(_uw) 0; 764 765 do 766 { 767 /* Find the entry for this routine. */ 768 if (get_eit_entry (ucbp, VRS_PC (&saved_vrs)) != _URC_OK) 769 { 770 code = _URC_FAILURE; 771 break; 772 } 773 774 /* The dwarf unwinder assumes the context structure holds things 775 like the function and LSDA pointers. The ARM implementation 776 caches these in the exception header (UCB). To avoid 777 rewriting everything we make the virtual IP register point at 778 the UCB. */ 779 _Unwind_SetGR((_Unwind_Context *)&saved_vrs, UNWIND_POINTER_REG, (_Unwind_Ptr) ucbp); 780 781 /* Call trace function. */ 782 if ((*trace) ((_Unwind_Context *) &saved_vrs, trace_argument) 783 != _URC_NO_REASON) 784 { 785 code = _URC_FAILURE; 786 break; 787 } 788 789 /* Call the pr to decide what to do. */ 790#if __FDPIC__ 791 { 792 volatile struct funcdesc_t funcdesc; 793 funcdesc.ptr = UCB_PR_ADDR (ucbp); 794 funcdesc.got = UCB_PR_GOT (ucbp); 795 code = ((personality_routine) &funcdesc) 796 (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, 797 ucbp, (void *) &saved_vrs); 798 } 799#else 800 code = ((personality_routine) UCB_PR_ADDR (ucbp)) 801 (_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, 802 ucbp, (void *) &saved_vrs); 803#endif 804 } 805 while (code != _URC_END_OF_STACK 806 && code != _URC_FAILURE); 807 808 restore_non_core_regs (&saved_vrs); 809 return code; 810} 811 812 813/* Common implementation for ARM ABI defined personality routines. 814 ID is the index of the personality routine, other arguments are as defined 815 by __aeabi_unwind_cpp_pr{0,1,2}. */ 816 817static _Unwind_Reason_Code 818__gnu_unwind_pr_common (_Unwind_State state, 819 _Unwind_Control_Block *ucbp, 820 _Unwind_Context *context, 821 int id) 822{ 823 __gnu_unwind_state uws; 824 _uw *data; 825 _uw offset; 826 _uw len; 827 _uw rtti_count; 828 int phase2_call_unexpected_after_unwind = 0; 829 int in_range = 0; 830 int forced_unwind = state & _US_FORCE_UNWIND; 831 832 state &= _US_ACTION_MASK; 833 834 data = (_uw *) ucbp->pr_cache.ehtp; 835 uws.data = *(data++); 836 uws.next = data; 837 if (id == 0) 838 { 839 uws.data <<= 8; 840 uws.words_left = 0; 841 uws.bytes_left = 3; 842 } 843 else if (id < 3) 844 { 845 uws.words_left = (uws.data >> 16) & 0xff; 846 uws.data <<= 16; 847 uws.bytes_left = 2; 848 data += uws.words_left; 849 } 850 851 /* Restore the saved pointer. */ 852 if (state == _US_UNWIND_FRAME_RESUME) 853 data = (_uw *) ucbp->cleanup_cache.bitpattern[0]; 854 855 if ((ucbp->pr_cache.additional & 1) == 0) 856 { 857 /* Process descriptors. */ 858 while (*data) 859 { 860 _uw addr; 861 _uw fnstart; 862 863 if (id == 2) 864 { 865 len = ((EHT32 *) data)->length; 866 offset = ((EHT32 *) data)->offset; 867 data += 2; 868 } 869 else 870 { 871 len = ((EHT16 *) data)->length; 872 offset = ((EHT16 *) data)->offset; 873 data++; 874 } 875 876 fnstart = ucbp->pr_cache.fnstart + (offset & ~1); 877 addr = _Unwind_GetGR (context, R_PC); 878 in_range = (fnstart <= addr && addr < fnstart + (len & ~1)); 879 880 switch (((offset & 1) << 1) | (len & 1)) 881 { 882 case 0: 883 /* Cleanup. */ 884 if (state != _US_VIRTUAL_UNWIND_FRAME 885 && in_range) 886 { 887 /* Cleanup in range, and we are running cleanups. */ 888 _uw lp; 889 890 /* Landing pad address is 31-bit pc-relative offset. */ 891 lp = selfrel_offset31 (data); 892 data++; 893 /* Save the exception data pointer. */ 894 ucbp->cleanup_cache.bitpattern[0] = (_uw) data; 895 if (!__cxa_begin_cleanup (ucbp)) 896 return _URC_FAILURE; 897 /* Setup the VRS to enter the landing pad. */ 898 _Unwind_SetGR (context, R_PC, lp); 899 return _URC_INSTALL_CONTEXT; 900 } 901 /* Cleanup not in range, or we are in stage 1. */ 902 data++; 903 break; 904 905 case 1: 906 /* Catch handler. */ 907 if (state == _US_VIRTUAL_UNWIND_FRAME) 908 { 909 if (in_range) 910 { 911 /* Check for a barrier. */ 912 _uw rtti; 913 bool is_reference = (data[0] & uint32_highbit) != 0; 914 void *matched; 915 enum __cxa_type_match_result match_type; 916 917 /* Check for no-throw areas. */ 918 if (data[1] == (_uw) -2) 919 return _URC_FAILURE; 920 921 /* The thrown object immediately follows the ECB. */ 922 matched = (void *)(ucbp + 1); 923 if (data[1] != (_uw) -1) 924 { 925 /* Match a catch specification. */ 926 rtti = _Unwind_decode_typeinfo_ptr (0, 927 (_uw) &data[1]); 928 match_type = __cxa_type_match (ucbp, 929 (type_info *) rtti, 930 is_reference, 931 &matched); 932 } 933 else 934 match_type = ctm_succeeded; 935 936 if (match_type) 937 { 938 ucbp->barrier_cache.sp = 939 _Unwind_GetGR (context, R_SP); 940 // ctm_succeeded_with_ptr_to_base really 941 // means _c_t_m indirected the pointer 942 // object. We have to reconstruct the 943 // additional pointer layer by using a temporary. 944 if (match_type == ctm_succeeded_with_ptr_to_base) 945 { 946 ucbp->barrier_cache.bitpattern[2] 947 = (_uw) matched; 948 ucbp->barrier_cache.bitpattern[0] 949 = (_uw) &ucbp->barrier_cache.bitpattern[2]; 950 } 951 else 952 ucbp->barrier_cache.bitpattern[0] = (_uw) matched; 953 ucbp->barrier_cache.bitpattern[1] = (_uw) data; 954 return _URC_HANDLER_FOUND; 955 } 956 } 957 /* Handler out of range, or not matched. */ 958 } 959 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) 960 && ucbp->barrier_cache.bitpattern[1] == (_uw) data) 961 { 962 /* Matched a previous propagation barrier. */ 963 _uw lp; 964 965 /* Setup for entry to the handler. */ 966 lp = selfrel_offset31 (data); 967 _Unwind_SetGR (context, R_PC, lp); 968 _Unwind_SetGR (context, 0, (_uw) ucbp); 969 return _URC_INSTALL_CONTEXT; 970 } 971 /* Catch handler not matched. Advance to the next descriptor. */ 972 data += 2; 973 break; 974 975 case 2: 976 rtti_count = data[0] & 0x7fffffff; 977 /* Exception specification. */ 978 if (state == _US_VIRTUAL_UNWIND_FRAME) 979 { 980 if (in_range && (!forced_unwind || !rtti_count)) 981 { 982 /* Match against the exception specification. */ 983 _uw i; 984 _uw rtti; 985 void *matched; 986 987 for (i = 0; i < rtti_count; i++) 988 { 989 matched = (void *)(ucbp + 1); 990 rtti = _Unwind_decode_typeinfo_ptr (0, 991 (_uw) &data[i + 1]); 992 if (__cxa_type_match (ucbp, (type_info *) rtti, 0, 993 &matched)) 994 break; 995 } 996 997 if (i == rtti_count) 998 { 999 /* Exception does not match the spec. */ 1000 ucbp->barrier_cache.sp = 1001 _Unwind_GetGR (context, R_SP); 1002 ucbp->barrier_cache.bitpattern[0] = (_uw) matched; 1003 ucbp->barrier_cache.bitpattern[1] = (_uw) data; 1004 return _URC_HANDLER_FOUND; 1005 } 1006 } 1007 /* Handler out of range, or exception is permitted. */ 1008 } 1009 else if (ucbp->barrier_cache.sp == _Unwind_GetGR (context, R_SP) 1010 && ucbp->barrier_cache.bitpattern[1] == (_uw) data) 1011 { 1012 /* Matched a previous propagation barrier. */ 1013 _uw lp; 1014 /* Record the RTTI list for __cxa_call_unexpected. */ 1015 ucbp->barrier_cache.bitpattern[1] = rtti_count; 1016 ucbp->barrier_cache.bitpattern[2] = 0; 1017 ucbp->barrier_cache.bitpattern[3] = 4; 1018 ucbp->barrier_cache.bitpattern[4] = (_uw) &data[1]; 1019 1020 if (data[0] & uint32_highbit) 1021 { 1022 data += rtti_count + 1; 1023 /* Setup for entry to the handler. */ 1024 lp = selfrel_offset31 (data); 1025 data++; 1026 _Unwind_SetGR (context, R_PC, lp); 1027 _Unwind_SetGR (context, 0, (_uw) ucbp); 1028 return _URC_INSTALL_CONTEXT; 1029 } 1030 else 1031 phase2_call_unexpected_after_unwind = 1; 1032 } 1033 if (data[0] & uint32_highbit) 1034 data++; 1035 data += rtti_count + 1; 1036 break; 1037 1038 default: 1039 /* Should never happen. */ 1040 return _URC_FAILURE; 1041 } 1042 /* Finished processing this descriptor. */ 1043 } 1044 } 1045 1046 if (id >= 3) 1047 { 1048 /* 24-bit ecoding */ 1049 if (__gnu_unwind_24bit (context, uws.data, id == 4) != _URC_OK) 1050 return _URC_FAILURE; 1051 } 1052 else 1053 { 1054 if (__gnu_unwind_execute (context, &uws) != _URC_OK) 1055 return _URC_FAILURE; 1056 } 1057 1058 if (phase2_call_unexpected_after_unwind) 1059 { 1060 /* Enter __cxa_unexpected as if called from the call site. */ 1061 _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC)); 1062 _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected); 1063 return _URC_INSTALL_CONTEXT; 1064 } 1065 1066 return _URC_CONTINUE_UNWIND; 1067} 1068