1 /* DWARF2 EH unwinding support for IA64 VMS. 2 Copyright (C) 2005-2013 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published 8 by the Free Software Foundation; either version 3, or (at your 9 option) any later version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 14 License for more details. 15 16 Under Section 7 of GPL version 3, you are granted additional 17 permissions described in the GCC Runtime Library Exception, version 18 3.1, as published by the Free Software Foundation. 19 20 You should have received a copy of the GNU General Public License and 21 a copy of the GCC Runtime Library Exception along with this program; 22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 <http://www.gnu.org/licenses/>. */ 24 25 #define __NEW_STARLET 26 #include <libicb.h> 27 #include <chfdef.h> 28 #include <lib_c/chfctxdef.h> 29 #include <lib_c/intstkdef.h> 30 31 #include <stdio.h> 32 #include <string.h> 33 34 #define UNW_IVMS_MODE(HEADER) (((HEADER) >> 44) & 0x3L) 35 #define MD_UNW_COMPATIBLE_PERSONALITY_P(HEADER) (!UNW_IVMS_MODE (HEADER)) 36 37 #define DYN$C_SSENTRY 66 38 /* ??? would rather get the proper header file. */ 39 40 #define MD_FALLBACK_FRAME_STATE_FOR ia64_vms_fallback_frame_state 41 42 extern INVO_CONTEXT_BLK * LIB$I64_CREATE_INVO_CONTEXT (void); 43 44 extern int LIB$I64_IS_EXC_DISPATCH_FRAME (void *); 45 extern int LIB$I64_IS_AST_DISPATCH_FRAME (void *); 46 47 extern int LIB$I64_INIT_INVO_CONTEXT (INVO_CONTEXT_BLK *, int, int); 48 extern int LIB$I64_GET_CURR_INVO_CONTEXT (INVO_CONTEXT_BLK *); 49 extern int LIB$I64_GET_PREV_INVO_CONTEXT (INVO_CONTEXT_BLK *); 50 51 typedef unsigned int uint; 52 typedef unsigned __int64 uw_reg; 53 typedef uw_reg * uw_loc; 54 55 typedef char fp_reg[16]; 56 57 #define DENOTES_VMS_DISPATCHER_FRAME(icb) \ 58 (LIB$I64_IS_EXC_DISPATCH_FRAME (&(icb)->libicb$ih_pc)) 59 60 #define DENOTES_BOTTOM_OF_STACK(icb) ((icb)->libicb$v_bottom_of_stack) 61 62 #define FAIL_IF(COND) \ 63 do { if (COND) { context->rp = 0; return _URC_END_OF_STACK; } } while (0) 64 /* Clearing context->rp is required to prevent the ia64 gcc unwinder from 65 attempting to keep on walking the call chain. */ 66 67 static int 68 ia64_vms_fallback_frame_state (struct _Unwind_Context *context, 69 _Unwind_FrameState *fs) 70 { 71 int i, status; 72 73 INVO_CONTEXT_BLK local_icb; 74 INVO_CONTEXT_BLK *icb = &local_icb; 75 76 CHFCTX * chfctx; 77 CHF$MECH_ARRAY * chfmech; 78 CHF64$SIGNAL_ARRAY *chfsig64; 79 INTSTK * intstk; 80 81 static int eh_debug = -1; 82 int try_bs_copy = 0; 83 /* Non zero to attempt copy of alternate backing store contents for 84 dirty partition in interrupted context. ??? Alpha code, only activated 85 on specific request via specific bit in EH_DEBUG. */ 86 87 if (eh_debug == -1) 88 { 89 char * EH_DEBUG = getenv ("EH_DEBUG"); 90 const uint try_bs_copy_mask = (1 << 16); 91 92 eh_debug = EH_DEBUG ? atoi (EH_DEBUG) : 0; 93 94 /* Fetch and clear the try_bs_copy bit. */ 95 try_bs_copy = (uint)eh_debug & try_bs_copy_mask; 96 eh_debug &= ~try_bs_copy_mask; 97 } 98 99 /* We're called to attempt unwinding through a frame for which no unwind 100 info is available, typical of an operating system exception dispatcher 101 frame. The code below knows how to handle this case, and only this one, 102 returning a failure code if it finds it is not in this situation. 103 104 Note that we're called from deep down in the exception propagation call 105 chain, possibly below an exception dispatcher but for a frame above it 106 like some os entry point. */ 107 108 if (eh_debug) 109 printf ("FALLBACK - ctxt->rp=0x%lx, sp=0x%lx, psp=0x%lx, bsp=0x%lx\n", 110 context->rp, context->sp, context->psp, context->bsp); 111 112 /* Step 0 : 113 ------------------------------------------------------------------------- 114 VMS-unwind up until we reach a VMS dispatcher frame corresponding to the 115 context we are trying to unwind through. Fail if get past this context or 116 if we reach the bottom of stack along the way. 117 ------------------------------------------------------------------------- 118 */ 119 120 status = LIB$I64_INIT_INVO_CONTEXT (icb, LIBICB$K_INVO_CONTEXT_VERSION, 0); 121 FAIL_IF (status == 0); 122 123 status = LIB$I64_GET_CURR_INVO_CONTEXT (icb); 124 125 /* Beware: we might be unwinding through nested condition handlers, so the 126 dispatcher frame we seek might not be the first one on the way up. Loop 127 thus. */ 128 do { 129 130 /* Seek the next dispatcher frame up the "current" point. Stop if we 131 either get past the target context or hit the bottom-of-stack along 132 the way. */ 133 status = LIB$I64_GET_PREV_INVO_CONTEXT (icb); 134 FAIL_IF (status == 0); 135 FAIL_IF ((uw_reg)icb->libicb$ih_sp > (uw_reg)context->psp 136 || DENOTES_BOTTOM_OF_STACK (icb)); 137 138 if (eh_debug) 139 printf ("frame%s sp @ 0x%llx, pc @ 0x%llx bsp=0x%llx\n", 140 DENOTES_VMS_DISPATCHER_FRAME (icb) ? " (dispatcher)" : "", 141 icb->libicb$ih_sp, icb->libicb$ih_pc, icb->libicb$ih_bsp); 142 143 /* Continue until the target frame is found. */ 144 } while ((uw_reg)icb->libicb$ih_bsp != (uw_reg)context->bsp); 145 146 /* If this is not a dispatcher frame, this is certainly a frame for a leaf 147 subprogram. Use default unwind information. */ 148 if (! DENOTES_VMS_DISPATCHER_FRAME (icb)) 149 return _URC_END_OF_STACK; 150 151 /* At this point, we know we are really trying to unwind past an exception 152 dispatcher frame, and have it described in ICB. Proceed. */ 153 154 /* Step 1 : 155 ------------------------------------------------------------------------ 156 We have the VMS dispatcher frame ICB handy and know we are trying to 157 unwind past it. Fetch pointers to useful datastructures from there, then 158 unwind one step further up to the interrupted user context from which 159 some required values will be easily accessible. 160 ------------------------------------------------------------------------ 161 */ 162 163 chfctx = icb->libicb$ph_chfctx_addr; 164 FAIL_IF (chfctx == 0); 165 166 chfmech = (CHF$MECH_ARRAY *)chfctx->chfctx$q_mcharglst; 167 FAIL_IF (chfmech == 0); 168 169 chfsig64 = (CHF64$SIGNAL_ARRAY *)chfmech->chf$ph_mch_sig64_addr; 170 FAIL_IF (chfsig64 == 0); 171 172 intstk = (INTSTK *)chfmech->chf$q_mch_esf_addr; 173 FAIL_IF (intstk == 0 || intstk->intstk$b_subtype == DYN$C_SSENTRY); 174 175 status = LIB$I64_GET_PREV_INVO_CONTEXT (icb); 176 FAIL_IF (status == 0); 177 178 if (eh_debug) 179 printf ("User frame, " 180 "chfmech @ 0x%p, chfsig64 @ 0x%p, intstk @ 0x%p\n", 181 chfmech, chfsig64, intstk); 182 183 /* Step 2 : 184 ------------------------------------------------------------------------ 185 Point the GCC context locations/values required for further unwinding at 186 their corresponding locations/values in the datastructures at hand. 187 ------------------------------------------------------------------------ 188 */ 189 190 /* Static General Register locations, including scratch registers in case 191 the unwinder needs to refer to a value stored in one of them. */ 192 { 193 uw_reg * ctxregs = (uw_reg *)&intstk->intstk$q_regbase; 194 195 for (i = 2; i <= 3; i++) 196 context->ireg[i - 2].loc = (uw_loc)&ctxregs[i]; 197 for (i = 8; i <= 11; i++) 198 context->ireg[i - 2].loc = (uw_loc)&ctxregs[i]; 199 for (i = 14; i <= 31; i++) 200 context->ireg[i - 2].loc = (uw_loc)&ctxregs[i]; 201 } 202 203 /* Static Floating Point Register locations, as available from the 204 mechargs array, which happens to include all the to be preserved 205 ones + others. */ 206 { 207 fp_reg * ctxregs; 208 209 ctxregs = (fp_reg *)&chfmech->chf$fh_mch_savf2; 210 for (i = 2; i <= 5 ; i++) 211 context->fr_loc[i - 2] = (uw_loc)&ctxregs[i - 2]; 212 213 ctxregs = (fp_reg *)&chfmech->chf$fh_mch_savf12; 214 for (i = 12; i <= 31 ; i++) 215 context->fr_loc[i - 2] = (uw_loc)&ctxregs[i - 12]; 216 } 217 218 /* Relevant application register locations. */ 219 220 context->fpsr_loc = (uw_loc)&intstk->intstk$q_fpsr; 221 context->lc_loc = (uw_loc)&intstk->intstk$q_lc; 222 context->unat_loc = (uw_loc)&intstk->intstk$q_unat; 223 224 /* Branch register locations. */ 225 226 { 227 uw_reg * ctxregs = (uw_reg *)&intstk->intstk$q_b0; 228 229 for (i = 0; i < 8; i++) 230 context->br_loc[i] = (uw_loc)&ctxregs[i]; 231 } 232 233 /* Necessary register values. */ 234 235 /* ??? Still unclear if we need to account for possible flushes to an 236 alternate backing store (maybe the unwinding performed above did the 237 trick already) and how this would be handled. Blind alpha tentative 238 below for experimentation purposes in malfunctioning cases. */ 239 { 240 uw_reg q_bsp = (uw_reg) intstk->intstk$q_bsp; 241 uw_reg q_bspstore = (uw_reg) intstk->intstk$q_bspstore; 242 uw_reg q_bspbase = (uw_reg) intstk->intstk$q_bspbase; 243 uw_reg ih_bspbase = (uw_reg) icb->libicb$ih_bspbase; 244 245 if (eh_debug) 246 printf ("q_bspstore = 0x%lx, q_bsp = 0x%lx, q_bspbase = 0x%lx\n" 247 "ih_bspbase = 0x%lx\n", 248 q_bspstore, q_bsp, q_bspbase, ih_bspbase); 249 250 /* We witness many situations where q_bspbase is set while ih_bspbase is 251 null, and every attempt made with q_bspbase badly failed while doing 252 nothing resulted in proper behavior. */ 253 if (q_bspstore < q_bsp && ih_bspbase && try_bs_copy) 254 { 255 uw_reg dirty_size = q_bsp - q_bspstore; 256 uw_reg q_rnat = (uw_reg) intstk->intstk$q_rnat; 257 258 if (eh_debug) 259 printf ("Attempting an alternate backing store copy ...\n"); 260 261 ia64_copy_rbs 262 (context, q_bspstore, ih_bspbase, dirty_size, q_rnat); 263 /* Not clear if these are the proper arguments here. This is what 264 looked the closest to what is performed in the Linux case. */ 265 } 266 267 } 268 269 context->bsp = (uw_reg)intstk->intstk$q_bsp; 270 fs->no_reg_stack_frame = 1; 271 272 context->pr = (uw_reg)intstk->intstk$q_preds; 273 context->gp = (uw_reg)intstk->intstk$q_gp; 274 275 /* We're directly setting up the "context" for a VMS exception handler. 276 The "previous SP" for it is the SP upon the handler's entry, that is 277 the SP at the condition/interruption/exception point. */ 278 context->psp = (uw_reg)icb->libicb$ih_sp; 279 280 /* Previous Frame State location. What eventually ends up in pfs_loc is 281 installed with ar.pfs = pfs_loc; br.ret; so setup to target intstk->q_ifs 282 to have the interrupted context restored and not that of its caller if 283 we happen to have a handler in the interrupted context itself. */ 284 fs->curr.reg[UNW_REG_PFS].where = UNW_WHERE_PSPREL; 285 fs->curr.reg[UNW_REG_PFS].val 286 = (uw_reg)&intstk->intstk$q_ifs - (uw_reg)context->psp; 287 fs->curr.reg[UNW_REG_PFS].when = -1; 288 289 /* If we need to unwind further up, past the interrupted context, we need to 290 hand out the interrupted context's pfs, still. */ 291 context->signal_pfs_loc = (uw_loc) &intstk->intstk$q_pfs; 292 293 /* Finally, rules for RP . */ 294 { 295 uw_reg * post_sigarray 296 = (uw_reg *)chfsig64 + 1 + chfsig64->chf64$l_sig_args; 297 298 uw_reg * ih_pc_loc = post_sigarray - 2; 299 300 fs->curr.reg[UNW_REG_RP].where = UNW_WHERE_PSPREL; 301 fs->curr.reg[UNW_REG_RP].val 302 = (uw_reg)ih_pc_loc - (uw_reg)context->psp; 303 fs->curr.reg[UNW_REG_RP].when = -1; 304 } 305 306 return _URC_NO_REASON; 307 } 308 309