| /* ARM EABI compliant unwinding routines. |
| Copyright (C) 2004, 2005 Free Software Foundation, Inc. |
| Contributed by Paul Brook |
| |
| This file is free software; you can redistribute it and/or modify it |
| under the terms of the GNU General Public License as published by the |
| Free Software Foundation; either version 2, or (at your option) any |
| later version. |
| |
| In addition to the permissions in the GNU General Public License, the |
| Free Software Foundation gives you unlimited permission to link the |
| compiled version of this file into combinations with other programs, |
| and to distribute those combinations without any restriction coming |
| from the use of this file. (The General Public License restrictions |
| do apply in other respects; for example, they cover modification of |
| the file, and distribution when not linked into a combine |
| executable.) |
| |
| This file is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; see the file COPYING. If not, write to |
| the Free Software Foundation, 51 Franklin Street, Fifth Floor, |
| Boston, MA 02110-1301, USA. */ |
| |
| /**************************************************************************** |
| * The functions here are derived from gcc/config/arm/unwind-arm.c from the |
| * 4.3.x release. The main changes here involve the use of ptrace to retrieve |
| * memory/processor states from a remote process. |
| ****************************************************************************/ |
| |
| #include <cutils/logd.h> |
| #include <sys/ptrace.h> |
| #include <unwind.h> |
| #include "utility.h" |
| |
| typedef struct _ZSt9type_info type_info; /* This names C++ type_info type */ |
| |
| void __attribute__((weak)) __cxa_call_unexpected(_Unwind_Control_Block *ucbp); |
| bool __attribute__((weak)) __cxa_begin_cleanup(_Unwind_Control_Block *ucbp); |
| bool __attribute__((weak)) __cxa_type_match(_Unwind_Control_Block *ucbp, |
| const type_info *rttip, |
| bool is_reference, |
| void **matched_object); |
| |
| /* Misc constants. */ |
| #define R_IP 12 |
| #define R_SP 13 |
| #define R_LR 14 |
| #define R_PC 15 |
| |
| #define EXIDX_CANTUNWIND 1 |
| #define uint32_highbit (((_uw) 1) << 31) |
| |
| #define UCB_FORCED_STOP_FN(ucbp) ((ucbp)->unwinder_cache.reserved1) |
| #define UCB_PR_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved2) |
| #define UCB_SAVED_CALLSITE_ADDR(ucbp) ((ucbp)->unwinder_cache.reserved3) |
| #define UCB_FORCED_STOP_ARG(ucbp) ((ucbp)->unwinder_cache.reserved4) |
| |
| struct core_regs |
| { |
| _uw r[16]; |
| }; |
| |
| /* We use normal integer types here to avoid the compiler generating |
| coprocessor instructions. */ |
| struct vfp_regs |
| { |
| _uw64 d[16]; |
| _uw pad; |
| }; |
| |
| struct vfpv3_regs |
| { |
| /* Always populated via VSTM, so no need for the "pad" field from |
| vfp_regs (which is used to store the format word for FSTMX). */ |
| _uw64 d[16]; |
| }; |
| |
| struct fpa_reg |
| { |
| _uw w[3]; |
| }; |
| |
| struct fpa_regs |
| { |
| struct fpa_reg f[8]; |
| }; |
| |
| struct wmmxd_regs |
| { |
| _uw64 wd[16]; |
| }; |
| |
| struct wmmxc_regs |
| { |
| _uw wc[4]; |
| }; |
| |
| /* Unwind descriptors. */ |
| |
| typedef struct |
| { |
| _uw16 length; |
| _uw16 offset; |
| } EHT16; |
| |
| typedef struct |
| { |
| _uw length; |
| _uw offset; |
| } EHT32; |
| |
| /* The ABI specifies that the unwind routines may only use core registers, |
| except when actually manipulating coprocessor state. This allows |
| us to write one implementation that works on all platforms by |
| demand-saving coprocessor registers. |
| |
| During unwinding we hold the coprocessor state in the actual hardware |
| registers and allocate demand-save areas for use during phase1 |
| unwinding. */ |
| |
| typedef struct |
| { |
| /* The first fields must be the same as a phase2_vrs. */ |
| _uw demand_save_flags; |
| struct core_regs core; |
| _uw prev_sp; /* Only valid during forced unwinding. */ |
| struct vfp_regs vfp; |
| struct vfpv3_regs vfp_regs_16_to_31; |
| struct fpa_regs fpa; |
| struct wmmxd_regs wmmxd; |
| struct wmmxc_regs wmmxc; |
| } phase1_vrs; |
| |
| /* This must match the structure created by the assembly wrappers. */ |
| typedef struct |
| { |
| _uw demand_save_flags; |
| struct core_regs core; |
| } phase2_vrs; |
| |
| |
| /* An exception index table entry. */ |
| |
| typedef struct __EIT_entry |
| { |
| _uw fnoffset; |
| _uw content; |
| } __EIT_entry; |
| |
| /* Derived version to use ptrace */ |
| typedef _Unwind_Reason_Code (*personality_routine_with_ptrace) |
| (_Unwind_State, |
| _Unwind_Control_Block *, |
| _Unwind_Context *, |
| pid_t); |
| |
| /* Derived version to use ptrace */ |
| /* ABI defined personality routines. */ |
| static _Unwind_Reason_Code unwind_cpp_pr0_with_ptrace (_Unwind_State, |
| _Unwind_Control_Block *, _Unwind_Context *, pid_t); |
| static _Unwind_Reason_Code unwind_cpp_pr1_with_ptrace (_Unwind_State, |
| _Unwind_Control_Block *, _Unwind_Context *, pid_t); |
| static _Unwind_Reason_Code unwind_cpp_pr2_with_ptrace (_Unwind_State, |
| _Unwind_Control_Block *, _Unwind_Context *, pid_t); |
| |
| /* Execute the unwinding instructions described by UWS. */ |
| extern _Unwind_Reason_Code |
| unwind_execute_with_ptrace(_Unwind_Context * context, __gnu_unwind_state * uws, |
| pid_t pid); |
| |
| /* Derived version to use ptrace. Only handles core registers. Disregards |
| * FP and others. |
| */ |
| /* ABI defined function to pop registers off the stack. */ |
| |
| _Unwind_VRS_Result unwind_VRS_Pop_with_ptrace (_Unwind_Context *context, |
| _Unwind_VRS_RegClass regclass, |
| _uw discriminator, |
| _Unwind_VRS_DataRepresentation representation, |
| pid_t pid) |
| { |
| phase1_vrs *vrs = (phase1_vrs *) context; |
| |
| switch (regclass) |
| { |
| case _UVRSC_CORE: |
| { |
| _uw *ptr; |
| _uw mask; |
| int i; |
| |
| if (representation != _UVRSD_UINT32) |
| return _UVRSR_FAILED; |
| |
| mask = discriminator & 0xffff; |
| ptr = (_uw *) vrs->core.r[R_SP]; |
| /* Pop the requested registers. */ |
| for (i = 0; i < 16; i++) |
| { |
| if (mask & (1 << i)) { |
| vrs->core.r[i] = get_remote_word(pid, ptr); |
| ptr++; |
| } |
| } |
| /* Writeback the stack pointer value if it wasn't restored. */ |
| if ((mask & (1 << R_SP)) == 0) |
| vrs->core.r[R_SP] = (_uw) ptr; |
| } |
| return _UVRSR_OK; |
| |
| default: |
| return _UVRSR_FAILED; |
| } |
| } |
| |
| /* Core unwinding functions. */ |
| |
| /* Calculate the address encoded by a 31-bit self-relative offset at address |
| P. */ |
| static inline _uw |
| selfrel_offset31 (const _uw *p, pid_t pid) |
| { |
| _uw offset = get_remote_word(pid, (void*)p); |
| |
| //offset = *p; |
| /* Sign extend to 32 bits. */ |
| if (offset & (1 << 30)) |
| offset |= 1u << 31; |
| else |
| offset &= ~(1u << 31); |
| |
| return offset + (_uw) p; |
| } |
| |
| |
| /* Perform a binary search for RETURN_ADDRESS in TABLE. The table contains |
| NREC entries. */ |
| |
| static const __EIT_entry * |
| search_EIT_table (const __EIT_entry * table, int nrec, _uw return_address, |
| pid_t pid) |
| { |
| _uw next_fn; |
| _uw this_fn; |
| int n, left, right; |
| |
| if (nrec == 0) |
| return (__EIT_entry *) 0; |
| |
| left = 0; |
| right = nrec - 1; |
| |
| while (1) |
| { |
| n = (left + right) / 2; |
| this_fn = selfrel_offset31 (&table[n].fnoffset, pid); |
| if (n != nrec - 1) |
| next_fn = selfrel_offset31 (&table[n + 1].fnoffset, pid) - 1; |
| else |
| next_fn = (_uw)0 - 1; |
| |
| if (return_address < this_fn) |
| { |
| if (n == left) |
| return (__EIT_entry *) 0; |
| right = n - 1; |
| } |
| else if (return_address <= next_fn) |
| return &table[n]; |
| else |
| left = n + 1; |
| } |
| } |
| |
| /* Find the exception index table eintry for the given address. */ |
| static const __EIT_entry* |
| get_eitp(_uw return_address, pid_t pid, mapinfo *map, mapinfo **containing_map) |
| { |
| const __EIT_entry *eitp = NULL; |
| int nrec; |
| mapinfo *mi; |
| |
| /* The return address is the address of the instruction following the |
| call instruction (plus one in thumb mode). If this was the last |
| instruction in the function the address will lie in the following |
| function. Subtract 2 from the address so that it points within the call |
| instruction itself. */ |
| if (return_address >= 2) |
| return_address -= 2; |
| |
| for (mi = map; mi != NULL; mi = mi->next) { |
| if (return_address >= mi->start && return_address <= mi->end) break; |
| } |
| |
| if (mi) { |
| if (containing_map) *containing_map = mi; |
| eitp = (__EIT_entry *) mi->exidx_start; |
| nrec = (mi->exidx_end - mi->exidx_start)/sizeof(__EIT_entry); |
| eitp = search_EIT_table (eitp, nrec, return_address, pid); |
| } |
| return eitp; |
| } |
| |
| /* Find the exception index table eintry for the given address. |
| Fill in the relevant fields of the UCB. |
| Returns _URC_FAILURE if an error occurred, _URC_OK on success. */ |
| |
| static _Unwind_Reason_Code |
| get_eit_entry (_Unwind_Control_Block *ucbp, _uw return_address, pid_t pid, |
| mapinfo *map, mapinfo **containing_map) |
| { |
| const __EIT_entry *eitp; |
| |
| eitp = get_eitp(return_address, pid, map, containing_map); |
| |
| if (!eitp) |
| { |
| UCB_PR_ADDR (ucbp) = 0; |
| return _URC_FAILURE; |
| } |
| ucbp->pr_cache.fnstart = selfrel_offset31 (&eitp->fnoffset, pid); |
| |
| _uw eitp_content = get_remote_word(pid, (void *)&eitp->content); |
| |
| /* Can this frame be unwound at all? */ |
| if (eitp_content == EXIDX_CANTUNWIND) |
| { |
| UCB_PR_ADDR (ucbp) = 0; |
| return _URC_END_OF_STACK; |
| } |
| |
| /* Obtain the address of the "real" __EHT_Header word. */ |
| |
| if (eitp_content & uint32_highbit) |
| { |
| /* It is immediate data. */ |
| ucbp->pr_cache.ehtp = (_Unwind_EHT_Header *)&eitp->content; |
| ucbp->pr_cache.additional = 1; |
| } |
| else |
| { |
| /* The low 31 bits of the content field are a self-relative |
| offset to an _Unwind_EHT_Entry structure. */ |
| ucbp->pr_cache.ehtp = |
| (_Unwind_EHT_Header *) selfrel_offset31 (&eitp->content, pid); |
| ucbp->pr_cache.additional = 0; |
| } |
| |
| /* Discover the personality routine address. */ |
| if (get_remote_word(pid, ucbp->pr_cache.ehtp) & (1u << 31)) |
| { |
| /* One of the predefined standard routines. */ |
| _uw idx = (get_remote_word(pid, ucbp->pr_cache.ehtp) >> 24) & 0xf; |
| if (idx == 0) |
| UCB_PR_ADDR (ucbp) = (_uw) &unwind_cpp_pr0_with_ptrace; |
| else if (idx == 1) |
| UCB_PR_ADDR (ucbp) = (_uw) &unwind_cpp_pr1_with_ptrace; |
| else if (idx == 2) |
| UCB_PR_ADDR (ucbp) = (_uw) &unwind_cpp_pr2_with_ptrace; |
| else |
| { /* Failed */ |
| UCB_PR_ADDR (ucbp) = 0; |
| return _URC_FAILURE; |
| } |
| } |
| else |
| { |
| /* Execute region offset to PR */ |
| UCB_PR_ADDR (ucbp) = selfrel_offset31 (ucbp->pr_cache.ehtp, pid); |
| /* Since we are unwinding the stack from a different process, it is |
| * impossible to execute the personality routine in debuggerd. Punt here. |
| */ |
| return _URC_FAILURE; |
| } |
| return _URC_OK; |
| } |
| |
| /* Print out the current call level, pc, and module name in the crash log */ |
| static _Unwind_Reason_Code log_function(_Unwind_Context *context, pid_t pid, |
| int tfd, |
| int stack_level, |
| mapinfo *map, |
| unsigned int sp_list[], |
| bool at_fault) |
| { |
| _uw pc; |
| _uw rel_pc; |
| phase2_vrs *vrs = (phase2_vrs*) context; |
| const mapinfo *mi; |
| bool only_in_tombstone = !at_fault; |
| |
| if (stack_level < STACK_CONTENT_DEPTH) { |
| sp_list[stack_level] = vrs->core.r[R_SP]; |
| } |
| pc = vrs->core.r[R_PC]; |
| |
| // Top level frame |
| if (stack_level == 0) { |
| pc &= ~1; |
| } |
| // For deeper framers, rollback pc by one instruction |
| else { |
| pc = vrs->core.r[R_PC]; |
| /* Thumb mode - need to check whether the bl(x) has long offset or not. |
| * Examples: |
| * |
| * arm blx in the middle of thumb: |
| * 187ae: 2300 movs r3, #0 |
| * 187b0: f7fe ee1c blx 173ec |
| * 187b4: 2c00 cmp r4, #0 |
| * |
| * arm bl in the middle of thumb: |
| * 187d8: 1c20 adds r0, r4, #0 |
| * 187da: f136 fd15 bl 14f208 |
| * 187de: 2800 cmp r0, #0 |
| * |
| * pure thumb: |
| * 18894: 189b adds r3, r3, r2 |
| * 18896: 4798 blx r3 |
| * 18898: b001 add sp, #4 |
| */ |
| if (pc & 1) { |
| _uw prev_word; |
| pc = (pc & ~1); |
| prev_word = get_remote_word(pid, (void *) pc-4); |
| // Long offset |
| if ((prev_word & 0xf0000000) == 0xf0000000 && |
| (prev_word & 0x0000e000) == 0x0000e000) { |
| pc -= 4; |
| } |
| else { |
| pc -= 2; |
| } |
| } |
| else { |
| pc -= 4; |
| } |
| } |
| |
| /* We used to print the absolute PC in the back trace, and mask out the top |
| * 3 bits to guesstimate the offset in the .so file. This is not working for |
| * non-prelinked libraries since the starting offset may not be aligned on |
| * 1MB boundaries, and the library may be larger than 1MB. So for .so |
| * addresses we print the relative offset in back trace. |
| */ |
| rel_pc = pc; |
| mi = pc_to_mapinfo(map, pc, &rel_pc); |
| |
| _LOG(tfd, only_in_tombstone, |
| " #%02d pc %08x %s\n", stack_level, rel_pc, |
| mi ? mi->name : ""); |
| |
| return _URC_NO_REASON; |
| } |
| |
| /* Derived from __gnu_Unwind_Backtrace to use ptrace */ |
| /* Perform stack backtrace through unwind data. Return the level of stack it |
| * unwinds. |
| */ |
| int unwind_backtrace_with_ptrace(int tfd, pid_t pid, mapinfo *map, |
| unsigned int sp_list[], int *frame0_pc_sane, |
| bool at_fault) |
| { |
| phase1_vrs saved_vrs; |
| _Unwind_Reason_Code code = _URC_OK; |
| struct pt_regs r; |
| int i; |
| int stack_level = 0; |
| |
| _Unwind_Control_Block ucb; |
| _Unwind_Control_Block *ucbp = &ucb; |
| |
| if(ptrace(PTRACE_GETREGS, pid, 0, &r)) return 0; |
| |
| for (i = 0; i < 16; i++) { |
| saved_vrs.core.r[i] = r.uregs[i]; |
| /* |
| _LOG(tfd, "r[%d] = 0x%x\n", i, saved_vrs.core.r[i]); |
| */ |
| } |
| |
| /* Set demand-save flags. */ |
| saved_vrs.demand_save_flags = ~(_uw) 0; |
| |
| /* |
| * If the app crashes because of calling the weeds, we cannot pass the PC |
| * to the usual unwinding code as the EXIDX mapping will fail. |
| * Instead, we simply print out the 0 as the top frame, and resume the |
| * unwinding process with the value stored in LR. |
| */ |
| if (get_eitp(saved_vrs.core.r[R_PC], pid, map, NULL) == NULL) { |
| *frame0_pc_sane = 0; |
| log_function ((_Unwind_Context *) &saved_vrs, pid, tfd, stack_level, |
| map, sp_list, at_fault); |
| saved_vrs.core.r[R_PC] = saved_vrs.core.r[R_LR]; |
| stack_level++; |
| } |
| |
| do { |
| mapinfo *this_map = NULL; |
| /* Find the entry for this routine. */ |
| if (get_eit_entry(ucbp, saved_vrs.core.r[R_PC], pid, map, &this_map) |
| != _URC_OK) { |
| /* Uncomment the code below to study why the unwinder failed */ |
| #if 0 |
| /* Shed more debugging info for stack unwinder improvement */ |
| if (this_map) { |
| _LOG(tfd, 1, |
| "Relative PC=%#x from %s not contained in EXIDX\n", |
| saved_vrs.core.r[R_PC] - this_map->start, this_map->name); |
| } |
| _LOG(tfd, 1, "PC=%#x SP=%#x\n", |
| saved_vrs.core.r[R_PC], saved_vrs.core.r[R_SP]); |
| #endif |
| code = _URC_FAILURE; |
| break; |
| } |
| |
| /* The dwarf unwinder assumes the context structure holds things |
| like the function and LSDA pointers. The ARM implementation |
| caches these in the exception header (UCB). To avoid |
| rewriting everything we make the virtual IP register point at |
| the UCB. */ |
| _Unwind_SetGR((_Unwind_Context *)&saved_vrs, 12, (_Unwind_Ptr) ucbp); |
| |
| /* Call log function. */ |
| if (log_function ((_Unwind_Context *) &saved_vrs, pid, tfd, stack_level, |
| map, sp_list, at_fault) != _URC_NO_REASON) { |
| code = _URC_FAILURE; |
| break; |
| } |
| stack_level++; |
| |
| /* Call the pr to decide what to do. */ |
| code = ((personality_routine_with_ptrace) UCB_PR_ADDR (ucbp))( |
| _US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, ucbp, |
| (void *) &saved_vrs, pid); |
| /* |
| * In theory the unwinding process will stop when the end of stack is |
| * reached or there is no unwinding information for the code address. |
| * To add another level of guarantee that the unwinding process |
| * will terminate we will stop it when the STACK_CONTENT_DEPTH is reached. |
| */ |
| } while (code != _URC_END_OF_STACK && code != _URC_FAILURE && |
| stack_level < STACK_CONTENT_DEPTH); |
| return stack_level; |
| } |
| |
| |
| /* Derived version to use ptrace */ |
| /* Common implementation for ARM ABI defined personality routines. |
| ID is the index of the personality routine, other arguments are as defined |
| by __aeabi_unwind_cpp_pr{0,1,2}. */ |
| |
| static _Unwind_Reason_Code |
| unwind_pr_common_with_ptrace (_Unwind_State state, |
| _Unwind_Control_Block *ucbp, |
| _Unwind_Context *context, |
| int id, |
| pid_t pid) |
| { |
| __gnu_unwind_state uws; |
| _uw *data; |
| int phase2_call_unexpected_after_unwind = 0; |
| |
| state &= _US_ACTION_MASK; |
| |
| data = (_uw *) ucbp->pr_cache.ehtp; |
| uws.data = get_remote_word(pid, data); |
| data++; |
| uws.next = data; |
| if (id == 0) |
| { |
| uws.data <<= 8; |
| uws.words_left = 0; |
| uws.bytes_left = 3; |
| } |
| else |
| { |
| uws.words_left = (uws.data >> 16) & 0xff; |
| uws.data <<= 16; |
| uws.bytes_left = 2; |
| data += uws.words_left; |
| } |
| |
| /* Restore the saved pointer. */ |
| if (state == _US_UNWIND_FRAME_RESUME) |
| data = (_uw *) ucbp->cleanup_cache.bitpattern[0]; |
| |
| if ((ucbp->pr_cache.additional & 1) == 0) |
| { |
| /* Process descriptors. */ |
| while (get_remote_word(pid, data)) { |
| /********************************************************************** |
| * The original code here seems to deal with exceptions that are not |
| * applicable in our toolchain, thus there is no way to test it for now. |
| * Instead of leaving it here and causing potential instability in |
| * debuggerd, we'd better punt here and leave the stack unwound. |
| * In the future when we discover cases where the stack should be unwound |
| * further but is not, we can revisit the code here. |
| **********************************************************************/ |
| return _URC_FAILURE; |
| } |
| /* Finished processing this descriptor. */ |
| } |
| |
| if (unwind_execute_with_ptrace (context, &uws, pid) != _URC_OK) |
| return _URC_FAILURE; |
| |
| if (phase2_call_unexpected_after_unwind) |
| { |
| /* Enter __cxa_unexpected as if called from the call site. */ |
| _Unwind_SetGR (context, R_LR, _Unwind_GetGR (context, R_PC)); |
| _Unwind_SetGR (context, R_PC, (_uw) &__cxa_call_unexpected); |
| return _URC_INSTALL_CONTEXT; |
| } |
| |
| return _URC_CONTINUE_UNWIND; |
| } |
| |
| |
| /* ABI defined personality routine entry points. */ |
| |
| static _Unwind_Reason_Code |
| unwind_cpp_pr0_with_ptrace (_Unwind_State state, |
| _Unwind_Control_Block *ucbp, |
| _Unwind_Context *context, |
| pid_t pid) |
| { |
| return unwind_pr_common_with_ptrace (state, ucbp, context, 0, pid); |
| } |
| |
| static _Unwind_Reason_Code |
| unwind_cpp_pr1_with_ptrace (_Unwind_State state, |
| _Unwind_Control_Block *ucbp, |
| _Unwind_Context *context, |
| pid_t pid) |
| { |
| return unwind_pr_common_with_ptrace (state, ucbp, context, 1, pid); |
| } |
| |
| static _Unwind_Reason_Code |
| unwind_cpp_pr2_with_ptrace (_Unwind_State state, |
| _Unwind_Control_Block *ucbp, |
| _Unwind_Context *context, |
| pid_t pid) |
| { |
| return unwind_pr_common_with_ptrace (state, ucbp, context, 2, pid); |
| } |
