tpf-unwind.h revision 1.1.1.1
1/* DWARF2 EH unwinding support for TPF OS. 2 Copyright (C) 2004-2013 Free Software Foundation, Inc. 3 Contributed by P.J. Darcy (darcypj@us.ibm.com). 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17Under Section 7 of GPL version 3, you are granted additional 18permissions described in the GCC Runtime Library Exception, version 193.1, as published by the Free Software Foundation. 20 21You should have received a copy of the GNU General Public License and 22a copy of the GCC Runtime Library Exception along with this program; 23see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 24<http://www.gnu.org/licenses/>. */ 25 26#include <dlfcn.h> 27 28/* Function Name: __isPATrange 29 Parameters passed into it: address to check 30 Return Value: A 1 if address is in pat code "range", 0 if not 31 Description: This function simply checks to see if the address 32 passed to it is in the CP pat code range. */ 33 34#define MIN_PATRANGE 0x10000 35#define MAX_PATRANGE 0x800000 36 37static inline unsigned int 38__isPATrange (void *addr) 39{ 40 if (addr > (void *)MIN_PATRANGE && addr < (void *)MAX_PATRANGE) 41 return 1; 42 else 43 return 0; 44} 45 46/* TPF return address offset from start of stack frame. */ 47#define TPFRA_OFFSET 168 48 49/* Exceptions macro defined for TPF so that functions without 50 dwarf frame information can be used with exceptions. */ 51#define MD_FALLBACK_FRAME_STATE_FOR s390_fallback_frame_state 52 53static _Unwind_Reason_Code 54s390_fallback_frame_state (struct _Unwind_Context *context, 55 _Unwind_FrameState *fs) 56{ 57 unsigned long int regs; 58 unsigned long int new_cfa; 59 int i; 60 61 regs = *((unsigned long int *) 62 (((unsigned long int) context->cfa) - STACK_POINTER_OFFSET)); 63 64 /* Are we going through special linkage code? */ 65 if (__isPATrange (context->ra)) 66 { 67 68 /* Our return register isn't zero for end of stack, so 69 check backward stackpointer to see if it is zero. */ 70 if (regs == NULL) 71 return _URC_END_OF_STACK; 72 73 /* No stack frame. */ 74 fs->regs.cfa_how = CFA_REG_OFFSET; 75 fs->regs.cfa_reg = 15; 76 fs->regs.cfa_offset = STACK_POINTER_OFFSET; 77 78 /* All registers remain unchanged ... */ 79 for (i = 0; i < 32; i++) 80 { 81 fs->regs.reg[i].how = REG_SAVED_REG; 82 fs->regs.reg[i].loc.reg = i; 83 } 84 85 /* ... except for %r14, which is stored at CFA-112 86 and used as return address. */ 87 fs->regs.reg[14].how = REG_SAVED_OFFSET; 88 fs->regs.reg[14].loc.offset = TPFRA_OFFSET - STACK_POINTER_OFFSET; 89 fs->retaddr_column = 14; 90 91 return _URC_NO_REASON; 92 } 93 94 regs = *((unsigned long int *) 95 (((unsigned long int) context->cfa) - STACK_POINTER_OFFSET)); 96 new_cfa = regs + STACK_POINTER_OFFSET; 97 98 fs->regs.cfa_how = CFA_REG_OFFSET; 99 fs->regs.cfa_reg = 15; 100 fs->regs.cfa_offset = new_cfa - 101 (unsigned long int) context->cfa + STACK_POINTER_OFFSET; 102 103 for (i = 0; i < 16; i++) 104 { 105 fs->regs.reg[i].how = REG_SAVED_OFFSET; 106 fs->regs.reg[i].loc.offset = regs + i*8 - new_cfa; 107 } 108 109 for (i = 0; i < 4; i++) 110 { 111 fs->regs.reg[16 + i].how = REG_SAVED_OFFSET; 112 fs->regs.reg[16 + i].loc.offset = regs + 16*8 + i*8 - new_cfa; 113 } 114 115 fs->retaddr_column = 14; 116 117 return _URC_NO_REASON; 118} 119 120/* Function Name: __tpf_eh_return 121 Parameters passed into it: Destination address to jump to. 122 Return Value: Converted Destination address if a Pat Stub exists. 123 Description: This function swaps the unwinding return address 124 with the cp stub code. The original target return address is 125 then stored into the tpf return address field. The cp stub 126 code is searched for by climbing back up the stack and 127 comparing the tpf stored return address object address to 128 that of the targets object address. */ 129 130#define CURRENT_STACK_PTR() \ 131 ({ register unsigned long int *stack_ptr asm ("%r15"); stack_ptr; }) 132 133#define PREVIOUS_STACK_PTR() \ 134 ((unsigned long int *)(*(CURRENT_STACK_PTR()))) 135 136#define RA_OFFSET 112 137#define R15_OFFSET 120 138#define TPFAREA_OFFSET 160 139#define TPFAREA_SIZE STACK_POINTER_OFFSET-TPFAREA_OFFSET 140#define INVALID_RETURN 0 141 142void * __tpf_eh_return (void *target); 143 144void * 145__tpf_eh_return (void *target) 146{ 147 Dl_info targetcodeInfo, currentcodeInfo; 148 int retval; 149 void *current, *stackptr, *destination_frame; 150 unsigned long int shifter, is_a_stub; 151 152 is_a_stub = 0; 153 154 /* Get code info for target return's address. */ 155 retval = dladdr (target, &targetcodeInfo); 156 157 /* Ensure the code info is valid (for target). */ 158 if (retval != INVALID_RETURN) 159 { 160 161 /* Get the stack pointer of the stack frame to be modified by 162 the exception unwinder. So that we can begin our climb 163 there. */ 164 stackptr = (void *) *((unsigned long int *) (*(PREVIOUS_STACK_PTR()))); 165 166 /* Begin looping through stack frames. Stop if invalid 167 code information is retrieved or if a match between the 168 current stack frame iteration shared object's address 169 matches that of the target, calculated above. */ 170 do 171 { 172 /* Get return address based on our stackptr iterator. */ 173 current = (void *) *((unsigned long int *) 174 (stackptr+RA_OFFSET)); 175 176 /* Is it a Pat Stub? */ 177 if (__isPATrange (current)) 178 { 179 /* Yes it was, get real return address 180 in TPF stack area. */ 181 current = (void *) *((unsigned long int *) 182 (stackptr+TPFRA_OFFSET)); 183 is_a_stub = 1; 184 } 185 186 /* Get codeinfo on RA so that we can figure out 187 the module address. */ 188 retval = dladdr (current, ¤tcodeInfo); 189 190 /* Check that codeinfo for current stack frame is valid. 191 Then compare the module address of current stack frame 192 to target stack frame to determine if we have the pat 193 stub address we want. Also ensure we are dealing 194 with a module crossing, stub return address. */ 195 if (is_a_stub && retval != INVALID_RETURN 196 && targetcodeInfo.dli_fbase == currentcodeInfo.dli_fbase) 197 { 198 /* Yes! They are in the same module. 199 Force copy of TPF private stack area to 200 destination stack frame TPF private area. */ 201 destination_frame = (void *) *((unsigned long int *) 202 (*PREVIOUS_STACK_PTR() + R15_OFFSET)); 203 204 /* Copy TPF linkage area from current frame to 205 destination frame. */ 206 memcpy((void *) (destination_frame + TPFAREA_OFFSET), 207 (void *) (stackptr + TPFAREA_OFFSET), TPFAREA_SIZE); 208 209 /* Now overlay the 210 real target address into the TPF stack area of 211 the target frame we are jumping to. */ 212 *((unsigned long int *) (destination_frame + 213 TPFRA_OFFSET)) = (unsigned long int) target; 214 215 /* Before returning the desired pat stub address to 216 the exception handling unwinder so that it can 217 actually do the "leap" shift out the low order 218 bit designated to determine if we are in 64BIT mode. 219 This is necessary for CTOA stubs. 220 Otherwise we leap one byte past where we want to 221 go to in the TPF pat stub linkage code. */ 222 shifter = *((unsigned long int *) 223 (stackptr + RA_OFFSET)); 224 225 shifter &= ~1ul; 226 227 /* Store Pat Stub Address in destination Stack Frame. */ 228 *((unsigned long int *) (destination_frame + 229 RA_OFFSET)) = shifter; 230 231 /* Re-adjust pat stub address to go to correct place 232 in linkage. */ 233 shifter = shifter - 4; 234 235 return (void *) shifter; 236 } 237 238 /* Desired module pat stub not found ... 239 Bump stack frame iterator. */ 240 stackptr = (void *) *(unsigned long int *) stackptr; 241 242 is_a_stub = 0; 243 244 } while (stackptr && retval != INVALID_RETURN 245 && targetcodeInfo.dli_fbase != currentcodeInfo.dli_fbase); 246 } 247 248 /* No pat stub found, could be a problem? Simply return unmodified 249 target address. */ 250 return target; 251} 252 253