|
111
|
1 /* DWARF2 EH unwinding support for IA64 VMS.
|
|
|
2 Copyright (C) 2005-2017 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
|
