* error.c (show_locus): Remove always-false test.
[official-gcc.git] / libjava / exception.cc
blob4875dfde52f55652a83af73087483d0682653e61
1 // Functions for Exception Support for Java.
3 /* Copyright (C) 1998, 1999, 2001, 2002, 2006 Free Software Foundation
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
9 details. */
11 #include <config.h>
13 #include <stddef.h>
14 #include <stdlib.h>
16 #include <java/lang/Class.h>
17 #include <java/lang/NullPointerException.h>
18 #include <gnu/gcj/RawData.h>
19 #include <gcj/cni.h>
20 #include <jvm.h>
22 // unwind-pe.h uses std::abort(), but sometimes we compile libjava
23 // without libstdc++-v3. The following hack forces it to use
24 // stdlib.h's abort().
25 namespace std
27 static __attribute__ ((__noreturn__)) void
28 abort ()
30 ::abort ();
33 #include "unwind.h"
35 struct alignment_test_struct
37 char space;
38 char end[0] __attribute__((aligned));
41 struct java_exception_header
43 /* Cache handler details between Phase 1 and Phase 2. */
44 _Unwind_Ptr landingPad;
45 int handlerSwitchValue;
47 /* The object being thrown. Compiled code expects this to be immediately
48 before the generic exception header. Which is complicated by the fact
49 that _Unwind_Exception is ((aligned)). */
51 char pad[sizeof(jthrowable) < sizeof(alignment_test_struct)
52 ? sizeof(alignment_test_struct) - sizeof(jthrowable) : 0]
53 __attribute__((aligned));
55 jthrowable value;
57 /* The generic exception header. */
58 _Unwind_Exception unwindHeader;
61 // This is the exception class we report -- "GNUCJAVA".
62 const _Unwind_Exception_Class __gcj_exception_class
63 = ((((((((_Unwind_Exception_Class) 'G'
64 << 8 | (_Unwind_Exception_Class) 'N')
65 << 8 | (_Unwind_Exception_Class) 'U')
66 << 8 | (_Unwind_Exception_Class) 'C')
67 << 8 | (_Unwind_Exception_Class) 'J')
68 << 8 | (_Unwind_Exception_Class) 'A')
69 << 8 | (_Unwind_Exception_Class) 'V')
70 << 8 | (_Unwind_Exception_Class) 'A');
73 static inline java_exception_header *
74 get_exception_header_from_ue (_Unwind_Exception *exc)
76 return reinterpret_cast<java_exception_header *>(exc + 1) - 1;
79 /* Perform a throw, Java style. Throw will unwind through this call,
80 so there better not be any handlers or exception thrown here. */
82 extern "C" void
83 _Jv_Throw (jthrowable value)
85 java_exception_header *xh
86 = static_cast<java_exception_header *>(_Jv_AllocRawObj (sizeof (*xh)));
88 if (value == NULL)
89 value = new java::lang::NullPointerException ();
90 xh->value = value;
92 xh->unwindHeader.exception_class = __gcj_exception_class;
93 xh->unwindHeader.exception_cleanup = NULL;
95 /* We're happy with setjmp/longjmp exceptions or region-based
96 exception handlers: entry points are provided here for both. */
97 _Unwind_Reason_Code code;
98 #ifdef SJLJ_EXCEPTIONS
99 code = _Unwind_SjLj_RaiseException (&xh->unwindHeader);
100 #else
101 code = _Unwind_RaiseException (&xh->unwindHeader);
102 #endif
104 /* If code == _URC_END_OF_STACK, then we reached top of stack without
105 finding a handler for the exception. Since each thread is run in
106 a try/catch, this oughtn't happen. If code is something else, we
107 encountered some sort of heinous lossage from which we could not
108 recover. As is the way of such things, almost certainly we will have
109 crashed before now, rather than actually being able to diagnose the
110 problem. */
111 abort();
115 #include "unwind-pe.h"
117 struct lsda_header_info
119 _Unwind_Ptr Start;
120 _Unwind_Ptr LPStart;
121 const unsigned char *TType;
122 const unsigned char *action_table;
123 unsigned char ttype_encoding;
124 unsigned char call_site_encoding;
127 static const unsigned char *
128 parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
129 lsda_header_info *info)
131 _uleb128_t tmp;
132 unsigned char lpstart_encoding;
134 info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
136 // Find @LPStart, the base to which landing pad offsets are relative.
137 lpstart_encoding = *p++;
138 if (lpstart_encoding != DW_EH_PE_omit)
139 p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
140 else
141 info->LPStart = info->Start;
143 // Find @TType, the base of the handler and exception spec type data.
144 info->ttype_encoding = *p++;
145 if (info->ttype_encoding != DW_EH_PE_omit)
147 p = read_uleb128 (p, &tmp);
148 info->TType = p + tmp;
150 else
151 info->TType = 0;
153 // The encoding and length of the call-site table; the action table
154 // immediately follows.
155 info->call_site_encoding = *p++;
156 p = read_uleb128 (p, &tmp);
157 info->action_table = p + tmp;
159 return p;
162 static void **
163 get_ttype_entry (_Unwind_Context *context, lsda_header_info *info, long i)
165 _Unwind_Ptr ptr;
167 i *= size_of_encoded_value (info->ttype_encoding);
168 read_encoded_value (context, info->ttype_encoding, info->TType - i, &ptr);
170 return reinterpret_cast<void **>(ptr);
174 // Using a different personality function name causes link failures
175 // when trying to mix code using different exception handling models.
176 #ifdef SJLJ_EXCEPTIONS
177 #define PERSONALITY_FUNCTION __gcj_personality_sj0
178 #define __builtin_eh_return_data_regno(x) x
179 #else
180 #define PERSONALITY_FUNCTION __gcj_personality_v0
181 #endif
183 extern "C" _Unwind_Reason_Code
184 PERSONALITY_FUNCTION (int version,
185 _Unwind_Action actions,
186 _Unwind_Exception_Class exception_class,
187 struct _Unwind_Exception *ue_header,
188 struct _Unwind_Context *context)
190 java_exception_header *xh = get_exception_header_from_ue (ue_header);
192 lsda_header_info info;
193 const unsigned char *language_specific_data;
194 const unsigned char *action_record;
195 const unsigned char *p;
196 _Unwind_Ptr landing_pad, ip;
197 int handler_switch_value;
198 bool saw_cleanup;
199 bool saw_handler;
200 int ip_before_insn = 0;
203 // Interface version check.
204 if (version != 1)
205 return _URC_FATAL_PHASE1_ERROR;
207 // Shortcut for phase 2 found handler for domestic exception.
208 if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
209 && exception_class == __gcj_exception_class)
211 handler_switch_value = xh->handlerSwitchValue;
212 landing_pad = xh->landingPad;
213 goto install_context;
216 // FIXME: In Phase 1, record _Unwind_GetIPInfo in xh->obj as a part of
217 // the stack trace for this exception. This will only collect Java
218 // frames, but perhaps that is acceptable.
219 // FIXME2: _Unwind_GetIPInfo is nonsensical for SJLJ, being a call-site
220 // index instead of a PC value. We could perhaps arrange for
221 // _Unwind_GetRegionStart to return context->fc->jbuf[1], which
222 // is the address of the handler label for __builtin_longjmp, but
223 // there is no solution for DONT_USE_BUILTIN_SETJMP.
225 language_specific_data = (const unsigned char *)
226 _Unwind_GetLanguageSpecificData (context);
228 // If no LSDA, then there are no handlers or cleanups.
229 if (! language_specific_data)
230 return _URC_CONTINUE_UNWIND;
232 // Parse the LSDA header.
233 p = parse_lsda_header (context, language_specific_data, &info);
234 #ifdef HAVE_GETIPINFO
235 ip = _Unwind_GetIPInfo (context, &ip_before_insn);
236 if (! ip_before_insn)
237 --ip;
238 #else
239 ip = _Unwind_GetIP (context) - 1;
240 #endif
241 landing_pad = 0;
242 action_record = 0;
243 handler_switch_value = 0;
245 #ifdef SJLJ_EXCEPTIONS
246 // The given "IP" is an index into the call-site table, with two
247 // exceptions -- -1 means no-action, and 0 means terminate. But
248 // since we're using uleb128 values, we've not got random access
249 // to the array.
250 if ((int) ip <= 0)
251 return _URC_CONTINUE_UNWIND;
252 else
254 _uleb128_t cs_lp, cs_action;
257 p = read_uleb128 (p, &cs_lp);
258 p = read_uleb128 (p, &cs_action);
260 while (--ip);
262 // Can never have null landing pad for sjlj -- that would have
263 // been indicated by a -1 call site index.
264 landing_pad = cs_lp + 1;
265 if (cs_action)
266 action_record = info.action_table + cs_action - 1;
267 goto found_something;
269 #else
270 // Search the call-site table for the action associated with this IP.
271 while (p < info.action_table)
273 _Unwind_Ptr cs_start, cs_len, cs_lp;
274 _uleb128_t cs_action;
276 // Note that all call-site encodings are "absolute" displacements.
277 p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
278 p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
279 p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
280 p = read_uleb128 (p, &cs_action);
282 // The table is sorted, so if we've passed the ip, stop.
283 if (ip < info.Start + cs_start)
284 p = info.action_table;
285 else if (ip < info.Start + cs_start + cs_len)
287 if (cs_lp)
288 landing_pad = info.LPStart + cs_lp;
289 if (cs_action)
290 action_record = info.action_table + cs_action - 1;
291 goto found_something;
294 #endif // SJLJ_EXCEPTIONS
296 // If ip is not present in the table, C++ would call terminate.
297 // ??? It is perhaps better to tweek the LSDA so that no-action
298 // is mapped to no-entry for Java.
299 return _URC_CONTINUE_UNWIND;
301 found_something:
302 saw_cleanup = false;
303 saw_handler = false;
305 if (landing_pad == 0)
307 // If ip is present, and has a null landing pad, there are
308 // no cleanups or handlers to be run.
310 else if (action_record == 0)
312 // If ip is present, has a non-null landing pad, and a null
313 // action table offset, then there are only cleanups present.
314 // Cleanups use a zero switch value, as set above.
315 saw_cleanup = true;
317 else
319 // Otherwise we have a catch handler.
320 _sleb128_t ar_filter, ar_disp;
322 while (1)
324 p = action_record;
325 p = read_sleb128 (p, &ar_filter);
326 read_sleb128 (p, &ar_disp);
328 if (ar_filter == 0)
330 // Zero filter values are cleanups.
331 saw_cleanup = true;
334 // During forced unwinding, we only run cleanups. With a
335 // foreign exception class, we have no class info to match.
336 else if ((actions & _UA_FORCE_UNWIND)
337 || exception_class != __gcj_exception_class)
340 else if (ar_filter > 0)
342 // Positive filter values are handlers.
344 void **catch_word = get_ttype_entry (context, &info, ar_filter);
345 jclass catch_type = (jclass)*catch_word;
347 // FIXME: This line is a kludge to work around exception
348 // handlers written in C++, which don't yet use indirect
349 // dispatch.
350 if (catch_type == *(void **)&java::lang::Class::class$)
351 catch_type = (jclass)catch_word;
353 if (_Jv_IsInstanceOf (xh->value, catch_type))
355 handler_switch_value = ar_filter;
356 saw_handler = true;
357 break;
360 else
362 // Negative filter values are exception specifications,
363 // which Java does not use.
364 // ??? Perhaps better to make them an index into a table
365 // of null-terminated strings instead of playing games
366 // with Utf8Const+1 as above.
367 abort ();
370 if (ar_disp == 0)
371 break;
372 action_record = p + ar_disp;
376 if (! saw_handler && ! saw_cleanup)
377 return _URC_CONTINUE_UNWIND;
379 if (actions & _UA_SEARCH_PHASE)
381 if (! saw_handler)
382 return _URC_CONTINUE_UNWIND;
384 // For domestic exceptions, we cache data from phase 1 for phase 2.
385 if (exception_class == __gcj_exception_class)
387 xh->handlerSwitchValue = handler_switch_value;
388 xh->landingPad = landing_pad;
390 return _URC_HANDLER_FOUND;
393 install_context:
394 _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
395 (_Unwind_Ptr) &xh->unwindHeader);
396 _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
397 handler_switch_value);
398 _Unwind_SetIP (context, landing_pad);
399 return _URC_INSTALL_CONTEXT;