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