libjava/exception.cc

   1 // Functions for Exception Support for Java.
   2
   3 /* Copyright (C) 1998, 1999, 2001, 2002, 2006  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 #include <config.h>
  12
  13 #include <stddef.h>
  14 #include <stdlib.h>
  15
  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>
  21
  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
  26 {
  27   static __attribute__ ((__noreturn__)) void
  28   abort ()
  29   {
  30     ::abort ();
  31   }
  32 }
  33 #include "unwind.h"
  34
  35 struct alignment_test_struct
  36 {
  37   char space;
  38   char end[0] __attribute__((aligned));
  39 };
  40
  41 struct java_exception_header
  42 {
  43   /* Cache handler details between Phase 1 and Phase 2.  */
  44   _Unwind_Ptr landingPad;
  45   int handlerSwitchValue;
  46
  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)).  */
  50
  51   char pad[sizeof(jthrowable) < sizeof(alignment_test_struct)
  52            ? sizeof(alignment_test_struct) - sizeof(jthrowable) : 0]
  53     __attribute__((aligned));
  54
  55   jthrowable value;
  56
  57   /* The generic exception header.  */
  58   _Unwind_Exception unwindHeader;
  59 };
  60
  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');
  71
  72
  73 static inline java_exception_header *
  74 get_exception_header_from_ue (_Unwind_Exception *exc)
  75 {
  76   return reinterpret_cast<java_exception_header *>(exc + 1) - 1;
  77 }
  78
  79 /* Perform a throw, Java style. Throw will unwind through this call,
  80    so there better not be any handlers or exception thrown here. */
  81
  82 extern "C" void
  83 _Jv_Throw (jthrowable value)
  84 {
  85   java_exception_header *xh
  86     = static_cast<java_exception_header *>(_Jv_AllocRawObj (sizeof (*xh)));
  87
  88   if (value == NULL)
  89     value = new java::lang::NullPointerException ();
  90   xh->value = value;
  91
  92   xh->unwindHeader.exception_class = __gcj_exception_class;
  93   xh->unwindHeader.exception_cleanup = NULL;
  94
  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
 103
 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();
 112 }
 113
 114 \f
 115 #include "unwind-pe.h"
 116 \f
 117 struct lsda_header_info
 118 {
 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;
 125 };
 126
 127 static const unsigned char *
 128 parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
 129                    lsda_header_info *info)
 130 {
 131   _Unwind_Word tmp;
 132   unsigned char lpstart_encoding;
 133
 134   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
 135
 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;
 142
 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)
 146     {
 147       p = read_uleb128 (p, &tmp);
 148       info->TType = p + tmp;
 149     }
 150   else
 151     info->TType = 0;
 152
 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;
 158
 159   return p;
 160 }
 161
 162 static void **
 163 get_ttype_entry (_Unwind_Context *context, lsda_header_info *info, long i)
 164 {
 165   _Unwind_Ptr ptr;
 166
 167   i *= size_of_encoded_value (info->ttype_encoding);
 168   read_encoded_value (context, info->ttype_encoding, info->TType - i, &ptr);
 169
 170   return reinterpret_cast<void **>(ptr);
 171 }
 172
 173
 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
 182
 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)
 189 {
 190   java_exception_header *xh = get_exception_header_from_ue (ue_header);
 191
 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;
 201
 202
 203   // Interface version check.
 204   if (version != 1)
 205     return _URC_FATAL_PHASE1_ERROR;
 206
 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)
 210     {
 211       handler_switch_value = xh->handlerSwitchValue;
 212       landing_pad = xh->landingPad;
 213       goto install_context;
 214     }
 215
 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.
 224
 225   language_specific_data = (const unsigned char *)
 226     _Unwind_GetLanguageSpecificData (context);
 227
 228   // If no LSDA, then there are no handlers or cleanups.
 229   if (! language_specific_data)
 230     return _URC_CONTINUE_UNWIND;
 231
 232   // Parse the LSDA header.
 233   p = parse_lsda_header (context, language_specific_data, &info);
 234   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 235   if (! ip_before_insn)
 236     --ip;
 237   landing_pad = 0;
 238   action_record = 0;
 239   handler_switch_value = 0;
 240
 241 #ifdef SJLJ_EXCEPTIONS
 242   // The given "IP" is an index into the call-site table, with two
 243   // exceptions -- -1 means no-action, and 0 means terminate.  But
 244   // since we're using uleb128 values, we've not got random access
 245   // to the array.
 246   if ((int) ip <= 0)
 247     return _URC_CONTINUE_UNWIND;
 248   else
 249     {
 250       _Unwind_Word cs_lp, cs_action;
 251       do
 252         {
 253           p = read_uleb128 (p, &cs_lp);
 254           p = read_uleb128 (p, &cs_action);
 255         }
 256       while (--ip);
 257
 258       // Can never have null landing pad for sjlj -- that would have
 259       // been indicated by a -1 call site index.
 260       landing_pad = cs_lp + 1;
 261       if (cs_action)
 262         action_record = info.action_table + cs_action - 1;
 263       goto found_something;
 264     }
 265 #else
 266   // Search the call-site table for the action associated with this IP.
 267   while (p < info.action_table)
 268     {
 269       _Unwind_Ptr cs_start, cs_len, cs_lp;
 270       _Unwind_Word cs_action;
 271
 272       // Note that all call-site encodings are "absolute" displacements.
 273       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 274       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 275       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 276       p = read_uleb128 (p, &cs_action);
 277
 278       // The table is sorted, so if we've passed the ip, stop.
 279       if (ip < info.Start + cs_start)
 280         p = info.action_table;
 281       else if (ip < info.Start + cs_start + cs_len)
 282         {
 283           if (cs_lp)
 284             landing_pad = info.LPStart + cs_lp;
 285           if (cs_action)
 286             action_record = info.action_table + cs_action - 1;
 287           goto found_something;
 288         }
 289     }
 290 #endif // SJLJ_EXCEPTIONS
 291
 292   // If ip is not present in the table, C++ would call terminate.
 293   // ??? It is perhaps better to tweek the LSDA so that no-action
 294   // is mapped to no-entry for Java.
 295   return _URC_CONTINUE_UNWIND;
 296
 297  found_something:
 298   saw_cleanup = false;
 299   saw_handler = false;
 300
 301   if (landing_pad == 0)
 302     {
 303       // If ip is present, and has a null landing pad, there are
 304       // no cleanups or handlers to be run.
 305     }
 306   else if (action_record == 0)
 307     {
 308       // If ip is present, has a non-null landing pad, and a null
 309       // action table offset, then there are only cleanups present.
 310       // Cleanups use a zero switch value, as set above.
 311       saw_cleanup = true;
 312     }
 313   else
 314     {
 315       // Otherwise we have a catch handler.
 316       _Unwind_Sword ar_filter, ar_disp;
 317
 318       while (1)
 319         {
 320           p = action_record;
 321           p = read_sleb128 (p, &ar_filter);
 322           read_sleb128 (p, &ar_disp);
 323
 324           if (ar_filter == 0)
 325             {
 326               // Zero filter values are cleanups.
 327               saw_cleanup = true;
 328             }
 329
 330           // During forced unwinding, we only run cleanups.  With a
 331           // foreign exception class, we have no class info to match.
 332           else if ((actions & _UA_FORCE_UNWIND)
 333               || exception_class != __gcj_exception_class)
 334             ;
 335
 336           else if (ar_filter > 0)
 337             {
 338               // Positive filter values are handlers.
 339
 340               void **catch_word = get_ttype_entry (context, &info, ar_filter);
 341               jclass catch_type = (jclass)*catch_word;
 342
 343               // FIXME: This line is a kludge to work around exception
 344               // handlers written in C++, which don't yet use indirect
 345               // dispatch.
 346               if (catch_type == *(void **)&java::lang::Class::class$)
 347                 catch_type = (jclass)catch_word;
 348
 349               if (_Jv_IsInstanceOf (xh->value, catch_type))
 350                 {
 351                   handler_switch_value = ar_filter;
 352                   saw_handler = true;
 353                   break;
 354                 }
 355             }
 356           else
 357             {
 358               // Negative filter values are exception specifications,
 359               // which Java does not use.
 360               // ??? Perhaps better to make them an index into a table
 361               // of null-terminated strings instead of playing games
 362               // with Utf8Const+1 as above.
 363               abort ();
 364             }
 365
 366           if (ar_disp == 0)
 367             break;
 368           action_record = p + ar_disp;
 369         }
 370     }
 371
 372   if (! saw_handler && ! saw_cleanup)
 373     return _URC_CONTINUE_UNWIND;
 374
 375   if (actions & _UA_SEARCH_PHASE)
 376     {
 377       if (! saw_handler)
 378         return _URC_CONTINUE_UNWIND;
 379
 380       // For domestic exceptions, we cache data from phase 1 for phase 2.
 381       if (exception_class == __gcj_exception_class)
 382         {
 383           xh->handlerSwitchValue = handler_switch_value;
 384           xh->landingPad = landing_pad;
 385         }
 386       return _URC_HANDLER_FOUND;
 387     }
 388
 389  install_context:
 390   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 391                  (_Unwind_Ptr) &xh->unwindHeader);
 392   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
 393                  handler_switch_value);
 394   _Unwind_SetIP (context, landing_pad);
 395   return _URC_INSTALL_CONTEXT;
 396 }