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   _uleb128_t 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 #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;
 244
 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
 253     {
 254       _uleb128_t cs_lp, cs_action;
 255       do
 256         {
 257           p = read_uleb128 (p, &cs_lp);
 258           p = read_uleb128 (p, &cs_action);
 259         }
 260       while (--ip);
 261
 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;
 268     }
 269 #else
 270   // Search the call-site table for the action associated with this IP.
 271   while (p < info.action_table)
 272     {
 273       _Unwind_Ptr cs_start, cs_len, cs_lp;
 274       _uleb128_t cs_action;
 275
 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);
 281
 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)
 286         {
 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;
 292         }
 293     }
 294 #endif // SJLJ_EXCEPTIONS
 295
 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;
 300
 301  found_something:
 302   saw_cleanup = false;
 303   saw_handler = false;
 304
 305   if (landing_pad == 0)
 306     {
 307       // If ip is present, and has a null landing pad, there are
 308       // no cleanups or handlers to be run.
 309     }
 310   else if (action_record == 0)
 311     {
 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;
 316     }
 317   else
 318     {
 319       // Otherwise we have a catch handler.
 320       _sleb128_t ar_filter, ar_disp;
 321
 322       while (1)
 323         {
 324           p = action_record;
 325           p = read_sleb128 (p, &ar_filter);
 326           read_sleb128 (p, &ar_disp);
 327
 328           if (ar_filter == 0)
 329             {
 330               // Zero filter values are cleanups.
 331               saw_cleanup = true;
 332             }
 333
 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)
 338             ;
 339
 340           else if (ar_filter > 0)
 341             {
 342               // Positive filter values are handlers.
 343
 344               void **catch_word = get_ttype_entry (context, &info, ar_filter);
 345               jclass catch_type = (jclass)*catch_word;
 346
 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;
 352
 353               if (_Jv_IsInstanceOf (xh->value, catch_type))
 354                 {
 355                   handler_switch_value = ar_filter;
 356                   saw_handler = true;
 357                   break;
 358                 }
 359             }
 360           else
 361             {
 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 ();
 368             }
 369
 370           if (ar_disp == 0)
 371             break;
 372           action_record = p + ar_disp;
 373         }
 374     }
 375
 376   if (! saw_handler && ! saw_cleanup)
 377     return _URC_CONTINUE_UNWIND;
 378
 379   if (actions & _UA_SEARCH_PHASE)
 380     {
 381       if (! saw_handler)
 382         return _URC_CONTINUE_UNWIND;
 383
 384       // For domestic exceptions, we cache data from phase 1 for phase 2.
 385       if (exception_class == __gcj_exception_class)
 386         {
 387           xh->handlerSwitchValue = handler_switch_value;
 388           xh->landingPad = landing_pad;
 389         }
 390       return _URC_HANDLER_FOUND;
 391     }
 392
 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;
 400 }