1 /* go-unwind.c -- unwind the stack for panic/recover.
3 Copyright 2010 The Go Authors. All rights reserved.
4 Use of this source code is governed by a BSD-style
5 license that can be found in the LICENSE file. */
13 #define NO_SIZE_OF_ENCODED_VALUE
14 #include "unwind-pe.h"
21 /* The code for a Go exception. */
23 #ifdef __ARM_EABI_UNWINDER__
24 static const _Unwind_Exception_Class __go_exception_class =
25 { 'G', 'N', 'U', 'C', 'G', 'O', '\0', '\0' };
27 static const _Unwind_Exception_Class __go_exception_class =
28 ((((((((_Unwind_Exception_Class) 'G'
29 << 8 | (_Unwind_Exception_Class) 'N')
30 << 8 | (_Unwind_Exception_Class) 'U')
31 << 8 | (_Unwind_Exception_Class) 'C')
32 << 8 | (_Unwind_Exception_Class) 'G')
33 << 8 | (_Unwind_Exception_Class) 'O')
34 << 8 | (_Unwind_Exception_Class) '\0')
35 << 8 | (_Unwind_Exception_Class) '\0');
39 /* This function is called by exception handlers used when unwinding
40 the stack after a recovered panic. The exception handler looks
42 __go_check_defer (frame);
44 If we have not yet reached the frame we are looking for, we
45 continue unwinding. */
48 __go_check_defer (_Bool *frame)
51 struct _Unwind_Exception *hdr;
57 /* Some other language has thrown an exception. We know there
58 are no defer handlers, so there is nothing to do. */
60 else if (g->is_foreign)
62 struct __go_panic_stack *n;
65 /* Some other language has thrown an exception. We need to run
66 the local defer handlers. If they call recover, we stop
67 unwinding the stack here. */
69 n = ((struct __go_panic_stack *)
70 __go_alloc (sizeof (struct __go_panic_stack)));
72 n->__arg.__type_descriptor = NULL;
73 n->__arg.__object = NULL;
74 n->__was_recovered = 0;
81 struct __go_defer_stack *d;
85 if (d == NULL || d->__frame != frame || d->__pfn == NULL)
95 if (n->__was_recovered)
97 /* The recover function caught the panic thrown by some
103 was_recovered = n->__was_recovered;
104 g->panic = n->__next;
109 /* Just return and continue executing Go code. */
114 /* We are panicing through this function. */
117 else if (g->defer != NULL
118 && g->defer->__pfn == NULL
119 && g->defer->__frame == frame)
121 struct __go_defer_stack *d;
123 /* This is the defer function which called recover. Simply
124 return to stop the stack unwind, and let the Go code continue
127 g->defer = d->__next;
130 /* We are returning from this function. */
136 /* This is some other defer function. It was already run by the
137 call to panic, or just above. Rethrow the exception. */
139 hdr = (struct _Unwind_Exception *) g->exception;
141 #ifdef LIBGO_SJLJ_EXCEPTIONS
142 _Unwind_SjLj_Resume_or_Rethrow (hdr);
144 #if defined(_LIBUNWIND_STD_ABI)
145 _Unwind_RaiseException (hdr);
147 _Unwind_Resume_or_Rethrow (hdr);
151 /* Rethrowing the exception should not return. */
155 /* Unwind function calls until we reach the one which used a defer
156 function which called recover. Each function which uses a defer
157 statement will have an exception handler, as shown above. */
162 struct _Unwind_Exception *hdr;
164 hdr = ((struct _Unwind_Exception *)
165 __go_alloc (sizeof (struct _Unwind_Exception)));
166 __builtin_memcpy (&hdr->exception_class, &__go_exception_class,
167 sizeof hdr->exception_class);
168 hdr->exception_cleanup = NULL;
170 runtime_g ()->exception = hdr;
172 #ifdef __USING_SJLJ_EXCEPTIONS__
173 _Unwind_SjLj_RaiseException (hdr);
175 _Unwind_RaiseException (hdr);
178 /* Raising an exception should not return. */
182 /* The rest of this code is really similar to gcc/unwind-c.c and
183 libjava/exception.cc. */
189 _Unwind_Ptr ttype_base;
190 const unsigned char *TType;
191 const unsigned char *action_table;
192 unsigned char ttype_encoding;
193 unsigned char call_site_encoding;
196 static const unsigned char *
197 parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p,
198 lsda_header_info *info)
201 unsigned char lpstart_encoding;
203 info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
205 /* Find @LPStart, the base to which landing pad offsets are relative. */
206 lpstart_encoding = *p++;
207 if (lpstart_encoding != DW_EH_PE_omit)
208 p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
210 info->LPStart = info->Start;
212 /* Find @TType, the base of the handler and exception spec type data. */
213 info->ttype_encoding = *p++;
214 if (info->ttype_encoding != DW_EH_PE_omit)
216 p = read_uleb128 (p, &tmp);
217 info->TType = p + tmp;
222 /* The encoding and length of the call-site table; the action table
223 immediately follows. */
224 info->call_site_encoding = *p++;
225 p = read_uleb128 (p, &tmp);
226 info->action_table = p + tmp;
231 /* The personality function is invoked when unwinding the stack due to
232 a panic. Its job is to find the cleanup and exception handlers to
233 run. We can't split the stack here, because we won't be able to
234 unwind from that split. */
236 #ifdef __ARM_EABI_UNWINDER__
237 /* ARM EABI personality routines must also unwind the stack. */
238 #define CONTINUE_UNWINDING \
241 if (__gnu_unwind_frame (ue_header, context) != _URC_OK) \
242 return _URC_FAILURE; \
243 return _URC_CONTINUE_UNWIND; \
247 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
250 #ifdef __USING_SJLJ_EXCEPTIONS__
251 #define PERSONALITY_FUNCTION __gccgo_personality_sj0
252 #define __builtin_eh_return_data_regno(x) x
254 #define PERSONALITY_FUNCTION __gccgo_personality_v0
257 #ifdef __ARM_EABI_UNWINDER__
259 PERSONALITY_FUNCTION (_Unwind_State, struct _Unwind_Exception *,
260 struct _Unwind_Context *)
261 __attribute__ ((no_split_stack, flatten));
264 PERSONALITY_FUNCTION (_Unwind_State state,
265 struct _Unwind_Exception * ue_header,
266 struct _Unwind_Context * context)
269 PERSONALITY_FUNCTION (int, _Unwind_Action, _Unwind_Exception_Class,
270 struct _Unwind_Exception *, struct _Unwind_Context *)
271 __attribute__ ((no_split_stack, flatten));
274 PERSONALITY_FUNCTION (int version,
275 _Unwind_Action actions,
276 _Unwind_Exception_Class exception_class,
277 struct _Unwind_Exception *ue_header,
278 struct _Unwind_Context *context)
281 lsda_header_info info;
282 const unsigned char *language_specific_data, *p, *action_record;
283 _Unwind_Ptr landing_pad, ip;
284 int ip_before_insn = 0;
288 #ifdef __ARM_EABI_UNWINDER__
289 _Unwind_Action actions;
291 switch (state & _US_ACTION_MASK)
293 case _US_VIRTUAL_UNWIND_FRAME:
294 actions = _UA_SEARCH_PHASE;
297 case _US_UNWIND_FRAME_STARTING:
298 actions = _UA_CLEANUP_PHASE;
299 if (!(state & _US_FORCE_UNWIND)
300 && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 13))
301 actions |= _UA_HANDLER_FRAME;
304 case _US_UNWIND_FRAME_RESUME:
311 actions |= state & _US_FORCE_UNWIND;
315 /* The dwarf unwinder assumes the context structure holds things like the
316 function and LSDA pointers. The ARM implementation caches these in
317 the exception header (UCB). To avoid rewriting everything we make the
318 virtual IP register point at the UCB. */
319 ip = (_Unwind_Ptr) ue_header;
320 _Unwind_SetGR (context, 12, ip);
323 return _URC_FATAL_PHASE1_ERROR;
325 is_foreign = exception_class != __go_exception_class;
328 language_specific_data = (const unsigned char *)
329 _Unwind_GetLanguageSpecificData (context);
331 /* If no LSDA, then there are no handlers or cleanups. */
332 if (! language_specific_data)
335 /* Parse the LSDA header. */
336 p = parse_lsda_header (context, language_specific_data, &info);
337 #ifdef HAVE_GETIPINFO
338 ip = _Unwind_GetIPInfo (context, &ip_before_insn);
340 ip = _Unwind_GetIP (context);
342 if (! ip_before_insn)
345 action_record = NULL;
347 #ifdef __USING_SJLJ_EXCEPTIONS__
348 /* The given "IP" is an index into the call-site table, with two
349 exceptions -- -1 means no-action, and 0 means terminate. But
350 since we're using uleb128 values, we've not got random access
353 return _URC_CONTINUE_UNWIND;
356 _uleb128_t cs_lp, cs_action;
359 p = read_uleb128 (p, &cs_lp);
360 p = read_uleb128 (p, &cs_action);
364 /* Can never have null landing pad for sjlj -- that would have
365 been indicated by a -1 call site index. */
366 landing_pad = (_Unwind_Ptr)cs_lp + 1;
368 action_record = info.action_table + cs_action - 1;
369 goto found_something;
372 /* Search the call-site table for the action associated with this IP. */
373 while (p < info.action_table)
375 _Unwind_Ptr cs_start, cs_len, cs_lp;
376 _uleb128_t cs_action;
378 /* Note that all call-site encodings are "absolute" displacements. */
379 p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
380 p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
381 p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
382 p = read_uleb128 (p, &cs_action);
384 /* The table is sorted, so if we've passed the ip, stop. */
385 if (ip < info.Start + cs_start)
386 p = info.action_table;
387 else if (ip < info.Start + cs_start + cs_len)
390 landing_pad = info.LPStart + cs_lp;
392 action_record = info.action_table + cs_action - 1;
393 goto found_something;
398 /* IP is not in table. No associated cleanups. */
402 if (landing_pad == 0)
404 /* IP is present, but has a null landing pad.
405 No handler to be run. */
409 if (actions & _UA_SEARCH_PHASE)
411 if (action_record == 0)
413 /* This indicates a cleanup rather than an exception
418 return _URC_HANDLER_FOUND;
421 /* It's possible for g to be NULL here for an exception thrown by a
422 language other than Go. */
431 g->exception = ue_header;
432 g->is_foreign = is_foreign;
435 _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
436 (_Unwind_Ptr) ue_header);
437 _Unwind_SetGR (context, __builtin_eh_return_data_regno (1), 0);
438 _Unwind_SetIP (context, landing_pad);
439 return _URC_INSTALL_CONTEXT;