OSDN Git Service

gcc/java:
[pf3gnuchains/gcc-fork.git] / libjava / exception.cc
1 // Functions for Exception Support for Java.
2
3 /* Copyright (C) 1998, 1999, 2001, 2002, 2006, 2010, 2011
4    Free Software Foundation
5
6    This file is part of libgcj.
7
8 This software is copyrighted work licensed under the terms of the
9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
10 details.  */
11
12 #include <config.h>
13
14 #include <stddef.h>
15 #include <stdlib.h>
16
17 #include <java/lang/Class.h>
18 #include <java/lang/NullPointerException.h>
19 #include <gnu/gcj/RawData.h> 
20 #include <gcj/cni.h>
21 #include <jvm.h>
22
23 // unwind-pe.h uses std::abort(), but sometimes we compile libjava
24 // without libstdc++-v3. The following hack forces it to use
25 // stdlib.h's abort().
26 namespace std
27 {
28   __attribute__ ((__noreturn__)) void
29   abort ()
30   {
31     ::abort ();
32   }
33 }
34 #include "unwind.h"
35
36 struct alignment_test_struct
37 {
38   char space;
39   char end[0] __attribute__((aligned));
40 };
41
42 struct java_exception_header
43 {
44   /* Cache handler details between Phase 1 and Phase 2.  */
45   _Unwind_Ptr landingPad;
46   int handlerSwitchValue;
47
48   /* The object being thrown.  Compiled code expects this to be immediately
49      before the generic exception header.  Which is complicated by the fact
50      that _Unwind_Exception is ((aligned)).  */
51
52   char pad[sizeof(jthrowable) < sizeof(alignment_test_struct)
53            ? sizeof(alignment_test_struct) - sizeof(jthrowable) : 0]
54     __attribute__((aligned));
55
56   jthrowable value;
57
58   /* The generic exception header.  */
59   _Unwind_Exception unwindHeader;
60 };
61
62 #ifdef __ARM_EABI_UNWINDER__
63 // This is the exception class we report -- "GNUCJAVA".
64
65 const _Unwind_Exception_Class __gcj_exception_class
66   = {'G', 'N', 'U', 'C', 'J', 'A', 'V', 'A'};
67
68 static inline java_exception_header *
69 get_exception_header_from_ue (_Unwind_Exception *exc)
70 {
71   return reinterpret_cast<java_exception_header *>(exc + 1) - 1;
72 }
73
74 extern "C" void __cxa_begin_cleanup (_Unwind_Exception*);
75
76 #else // !__ARM_EABI_UNWINDER__
77 // This is the exception class we report -- "GNUCJAVA".
78 const _Unwind_Exception_Class __gcj_exception_class
79 = ((((((((_Unwind_Exception_Class) 'G' 
80          << 8 | (_Unwind_Exception_Class) 'N')
81         << 8 | (_Unwind_Exception_Class) 'U')
82        << 8 | (_Unwind_Exception_Class) 'C')
83       << 8 | (_Unwind_Exception_Class) 'J')
84      << 8 | (_Unwind_Exception_Class) 'A')
85     << 8 | (_Unwind_Exception_Class) 'V')
86    << 8 | (_Unwind_Exception_Class) 'A');
87
88
89 static inline java_exception_header *
90 get_exception_header_from_ue (_Unwind_Exception *exc)
91 {
92   return reinterpret_cast<java_exception_header *>(exc + 1) - 1;
93 }
94 #endif // !__ARM_EABI_UNWINDER__
95
96 /* Perform a throw, Java style. Throw will unwind through this call,
97    so there better not be any handlers or exception thrown here. */
98
99 extern "C" void
100 _Jv_Throw (jthrowable value)
101 {
102   java_exception_header *xh
103     = static_cast<java_exception_header *>(_Jv_AllocRawObj (sizeof (*xh)));
104
105   if (value == NULL)
106     value = new java::lang::NullPointerException ();
107   xh->value = value;
108
109   memcpy (&xh->unwindHeader.exception_class, &__gcj_exception_class,
110           sizeof xh->unwindHeader.exception_class);
111   xh->unwindHeader.exception_cleanup = NULL;
112
113   /* We're happy with setjmp/longjmp exceptions or region-based
114      exception handlers: entry points are provided here for both.  */
115 #ifdef SJLJ_EXCEPTIONS
116   _Unwind_SjLj_RaiseException (&xh->unwindHeader);
117 #else
118   _Unwind_RaiseException (&xh->unwindHeader);
119 #endif
120
121   /* If code == _URC_END_OF_STACK, then we reached top of stack without
122      finding a handler for the exception.  Since each thread is run in
123      a try/catch, this oughtn't happen.  If code is something else, we
124      encountered some sort of heinous lossage from which we could not
125      recover.  As is the way of such things, almost certainly we will have
126      crashed before now, rather than actually being able to diagnose the
127      problem.  */
128   abort();
129 }
130
131 \f
132 #include "unwind-pe.h"
133 \f
134 struct lsda_header_info
135 {
136   _Unwind_Ptr Start;
137   _Unwind_Ptr LPStart;
138   const unsigned char *TType;
139   const unsigned char *action_table;
140   unsigned char ttype_encoding;
141   unsigned char call_site_encoding;
142 };
143
144 static const unsigned char *
145 parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
146                    lsda_header_info *info)
147 {
148   _uleb128_t tmp;
149   unsigned char lpstart_encoding;
150
151   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
152
153   // Find @LPStart, the base to which landing pad offsets are relative.
154   lpstart_encoding = *p++;
155   if (lpstart_encoding != DW_EH_PE_omit)
156     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
157   else
158     info->LPStart = info->Start;
159
160   // Find @TType, the base of the handler and exception spec type data.
161   info->ttype_encoding = *p++;
162   if (info->ttype_encoding != DW_EH_PE_omit)
163     {
164       p = read_uleb128 (p, &tmp);
165       info->TType = p + tmp;
166     }
167   else
168     info->TType = 0;
169
170   // The encoding and length of the call-site table; the action table
171   // immediately follows.
172   info->call_site_encoding = *p++;
173   p = read_uleb128 (p, &tmp);
174   info->action_table = p + tmp;
175
176   return p;
177 }
178
179 #ifdef __ARM_EABI_UNWINDER__
180
181 static void **
182 get_ttype_entry(_Unwind_Context *, lsda_header_info* info, _uleb128_t i)
183 {
184   _Unwind_Ptr ptr;
185
186   ptr = (_Unwind_Ptr) (info->TType - (i * 4));
187   ptr = _Unwind_decode_target2(ptr);
188   
189   return reinterpret_cast<void **>(ptr);
190 }
191
192 #else
193
194 static void **
195 get_ttype_entry (_Unwind_Context *context, lsda_header_info *info, long i)
196 {
197   _Unwind_Ptr ptr;
198
199   i *= size_of_encoded_value (info->ttype_encoding);
200   read_encoded_value (context, info->ttype_encoding, info->TType - i, &ptr);
201
202   return reinterpret_cast<void **>(ptr);
203 }
204
205 #endif
206
207 // Using a different personality function name causes link failures
208 // when trying to mix code using different exception handling models.
209 #ifdef SJLJ_EXCEPTIONS
210 #define PERSONALITY_FUNCTION    __gcj_personality_sj0
211 #define __builtin_eh_return_data_regno(x) x
212 #else
213 #define PERSONALITY_FUNCTION    __gcj_personality_v0
214 #endif
215
216 #ifdef __ARM_EABI_UNWINDER__
217
218 #define CONTINUE_UNWINDING \
219   do                                                            \
220     {                                                           \
221       if (__gnu_unwind_frame(ue_header, context) != _URC_OK)    \
222         return _URC_FAILURE;                                    \
223       return _URC_CONTINUE_UNWIND;                              \
224     }                                                           \
225   while (0)
226
227 extern "C" _Unwind_Reason_Code
228 PERSONALITY_FUNCTION (_Unwind_State state,
229                       struct _Unwind_Exception* ue_header,
230                       struct _Unwind_Context* context)
231 #else
232
233 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
234
235 extern "C" _Unwind_Reason_Code
236 PERSONALITY_FUNCTION (int version,
237                       _Unwind_Action actions,
238                       _Unwind_Exception_Class exception_class,
239                       struct _Unwind_Exception *ue_header,
240                       struct _Unwind_Context *context)
241
242 #endif
243 {
244   java_exception_header *xh = get_exception_header_from_ue (ue_header);
245
246   lsda_header_info info;
247   const unsigned char *language_specific_data;
248   const unsigned char *action_record;
249   const unsigned char *p;
250   _Unwind_Ptr landing_pad, ip;
251   int handler_switch_value;
252   bool saw_cleanup;
253   bool saw_handler;
254   bool foreign_exception;
255   int ip_before_insn = 0;
256
257 #ifdef __ARM_EABI_UNWINDER__
258   _Unwind_Action actions;
259
260   switch (state & _US_ACTION_MASK)
261     {
262     case _US_VIRTUAL_UNWIND_FRAME:
263       actions = _UA_SEARCH_PHASE;
264       break;
265
266     case _US_UNWIND_FRAME_STARTING:
267       actions = _UA_CLEANUP_PHASE;
268       if (!(state & _US_FORCE_UNWIND)
269           && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 13))
270         actions |= _UA_HANDLER_FRAME;
271       break;
272
273     case _US_UNWIND_FRAME_RESUME:
274       CONTINUE_UNWINDING;
275       break;
276
277     default:
278       std::abort();
279     }
280   actions |= state & _US_FORCE_UNWIND;
281
282   // We don't know which runtime we're working with, so can't check this.
283   // However the ABI routines hide this from us, and we don't actually need
284   // to know.
285   foreign_exception = false;
286
287   // The dwarf unwinder assumes the context structure holds things like the
288   // function and LSDA pointers.  The ARM implementation caches these in
289   // the exception header (UCB).  To avoid rewriting everything we make the
290   // virtual IP register point at the UCB.
291   ip = (_Unwind_Ptr) ue_header;
292   _Unwind_SetGR(context, 12, ip);
293
294 #else
295   // Interface version check.
296   if (version != 1)
297     return _URC_FATAL_PHASE1_ERROR;
298   foreign_exception = exception_class != __gcj_exception_class;
299 #endif
300
301   // Shortcut for phase 2 found handler for domestic exception.
302   if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
303       && !foreign_exception)
304     {
305       handler_switch_value = xh->handlerSwitchValue;
306       landing_pad = xh->landingPad;
307       goto install_context;
308     }
309
310   // FIXME: In Phase 1, record _Unwind_GetIPInfo in xh->obj as a part of
311   // the stack trace for this exception.  This will only collect Java
312   // frames, but perhaps that is acceptable.
313   // FIXME2: _Unwind_GetIPInfo is nonsensical for SJLJ, being a call-site
314   // index instead of a PC value.  We could perhaps arrange for
315   // _Unwind_GetRegionStart to return context->fc->jbuf[1], which
316   // is the address of the handler label for __builtin_longjmp, but
317   // there is no solution for DONT_USE_BUILTIN_SETJMP.
318
319   language_specific_data = (const unsigned char *)
320     _Unwind_GetLanguageSpecificData (context);
321
322   // If no LSDA, then there are no handlers or cleanups.
323   if (! language_specific_data)
324     CONTINUE_UNWINDING;
325
326   // Parse the LSDA header.
327   p = parse_lsda_header (context, language_specific_data, &info);
328 #ifdef HAVE_GETIPINFO
329   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
330 #else
331   ip = _Unwind_GetIP (context);
332 #endif
333   if (! ip_before_insn)
334     --ip;
335   landing_pad = 0;
336   action_record = 0;
337   handler_switch_value = 0;
338
339 #ifdef SJLJ_EXCEPTIONS
340   // The given "IP" is an index into the call-site table, with two
341   // exceptions -- -1 means no-action, and 0 means terminate.  But
342   // since we're using uleb128 values, we've not got random access
343   // to the array.
344   if ((int) ip <= 0)
345     return _URC_CONTINUE_UNWIND;
346   else
347     {
348       _uleb128_t cs_lp, cs_action;
349       do
350         {
351           p = read_uleb128 (p, &cs_lp);
352           p = read_uleb128 (p, &cs_action);
353         }
354       while (--ip);
355
356       // Can never have null landing pad for sjlj -- that would have
357       // been indicated by a -1 call site index.
358       landing_pad = cs_lp + 1;
359       if (cs_action)
360         action_record = info.action_table + cs_action - 1;
361       goto found_something;
362     }
363 #else
364   // Search the call-site table for the action associated with this IP.
365   while (p < info.action_table)
366     {
367       _Unwind_Ptr cs_start, cs_len, cs_lp;
368       _uleb128_t cs_action;
369
370       // Note that all call-site encodings are "absolute" displacements.
371       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
372       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
373       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
374       p = read_uleb128 (p, &cs_action);
375
376       // The table is sorted, so if we've passed the ip, stop.
377       if (ip < info.Start + cs_start)
378         p = info.action_table;
379       else if (ip < info.Start + cs_start + cs_len)
380         {
381           if (cs_lp)
382             landing_pad = info.LPStart + cs_lp;
383           if (cs_action)
384             action_record = info.action_table + cs_action - 1;
385           goto found_something;
386         }
387     }
388 #endif // SJLJ_EXCEPTIONS
389
390   // If ip is not present in the table, C++ would call terminate.
391   // ??? It is perhaps better to tweek the LSDA so that no-action
392   // is mapped to no-entry for Java.
393   CONTINUE_UNWINDING;
394
395  found_something:
396   saw_cleanup = false;
397   saw_handler = false;
398
399   if (landing_pad == 0)
400     {
401       // If ip is present, and has a null landing pad, there are
402       // no cleanups or handlers to be run.
403     }
404   else if (action_record == 0)
405     {
406       // If ip is present, has a non-null landing pad, and a null
407       // action table offset, then there are only cleanups present.
408       // Cleanups use a zero switch value, as set above.
409       saw_cleanup = true;
410     }
411   else
412     {
413       // Otherwise we have a catch handler.
414       _sleb128_t ar_filter, ar_disp;
415
416       while (1)
417         {
418           p = action_record;
419           p = read_sleb128 (p, &ar_filter);
420           read_sleb128 (p, &ar_disp);
421
422           if (ar_filter == 0)
423             {
424               // Zero filter values are cleanups.
425               saw_cleanup = true;
426             }
427
428           // During forced unwinding, we only run cleanups.  With a
429           // foreign exception class, we have no class info to match.
430           else if ((actions & _UA_FORCE_UNWIND)
431                    || foreign_exception)
432             ;
433
434           else if (ar_filter > 0)
435             {
436               // Positive filter values are handlers.
437
438               void **catch_word = get_ttype_entry (context, &info, ar_filter);
439               jclass catch_type = (jclass)*catch_word;
440
441               // FIXME: This line is a kludge to work around exception
442               // handlers written in C++, which don't yet use indirect
443               // dispatch.
444               if (catch_type == *(void **)&java::lang::Class::class$)
445                 catch_type = (jclass)catch_word;
446
447               if (_Jv_IsInstanceOf (xh->value, catch_type))
448                 {
449                   handler_switch_value = ar_filter;
450                   saw_handler = true;
451                   break;
452                 }
453             }
454           else
455             {
456               // Negative filter values are exception specifications,
457               // which Java does not use.
458               // ??? Perhaps better to make them an index into a table
459               // of null-terminated strings instead of playing games
460               // with Utf8Const+1 as above.
461               abort ();
462             }
463
464           if (ar_disp == 0)
465             break;
466           action_record = p + ar_disp;
467         }
468     }
469
470   if (! saw_handler && ! saw_cleanup)
471         CONTINUE_UNWINDING;
472
473   if (actions & _UA_SEARCH_PHASE)
474     {
475       if (! saw_handler)
476         CONTINUE_UNWINDING;
477
478       // For domestic exceptions, we cache data from phase 1 for phase 2.
479       if (! foreign_exception)
480         {
481           xh->handlerSwitchValue = handler_switch_value;
482           xh->landingPad = landing_pad;
483         }
484       return _URC_HANDLER_FOUND;
485     }
486
487  install_context:
488   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
489                  (_Unwind_Ptr) &xh->unwindHeader);
490   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
491                  handler_switch_value);
492   _Unwind_SetIP (context, landing_pad);
493 #ifdef __ARM_EABI_UNWINDER__
494   if (saw_cleanup)
495     __cxa_begin_cleanup(ue_header);
496 #endif
497   return _URC_INSTALL_CONTEXT;
498 }