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 #if _GLIBCXX_OVERRIDE_TTYPE_ENCODING
 165       /* Older ARM EABI toolchains set this value incorrectly, so use a
 166          hardcoded OS-specific format.  */
 167   info->ttype_encoding = _GLIBCXX_OVERRIDE_TTYPE_ENCODING;
 168 #endif
 169       p = read_uleb128 (p, &tmp);
 170       info->TType = p + tmp;
 171     }
 172   else
 173     info->TType = 0;
 174
 175   // The encoding and length of the call-site table; the action table
 176   // immediately follows.
 177   info->call_site_encoding = *p++;
 178   p = read_uleb128 (p, &tmp);
 179   info->action_table = p + tmp;
 180
 181   return p;
 182 }
 183
 184 static void **
 185 get_ttype_entry (_Unwind_Context *context, lsda_header_info *info, long i)
 186 {
 187   _Unwind_Ptr ptr;
 188
 189   i *= size_of_encoded_value (info->ttype_encoding);
 190   read_encoded_value (context, info->ttype_encoding, info->TType - i, &ptr);
 191
 192   return reinterpret_cast<void **>(ptr);
 193 }
 194
 195 // Using a different personality function name causes link failures
 196 // when trying to mix code using different exception handling models.
 197 #ifdef SJLJ_EXCEPTIONS
 198 #define PERSONALITY_FUNCTION    __gcj_personality_sj0
 199 #define __builtin_eh_return_data_regno(x) x
 200 #else
 201 #define PERSONALITY_FUNCTION    __gcj_personality_v0
 202 #endif
 203
 204 #ifdef __ARM_EABI_UNWINDER__
 205
 206 #define CONTINUE_UNWINDING \
 207   do                                                            \
 208     {                                                           \
 209       if (__gnu_unwind_frame(ue_header, context) != _URC_OK)    \
 210         return _URC_FAILURE;                                    \
 211       return _URC_CONTINUE_UNWIND;                              \
 212     }                                                           \
 213   while (0)
 214
 215 extern "C" _Unwind_Reason_Code
 216 PERSONALITY_FUNCTION (_Unwind_State state,
 217                       struct _Unwind_Exception* ue_header,
 218                       struct _Unwind_Context* context)
 219 #else
 220
 221 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
 222
 223 extern "C" _Unwind_Reason_Code
 224 PERSONALITY_FUNCTION (int version,
 225                       _Unwind_Action actions,
 226                       _Unwind_Exception_Class exception_class,
 227                       struct _Unwind_Exception *ue_header,
 228                       struct _Unwind_Context *context)
 229
 230 #endif
 231 {
 232   java_exception_header *xh = get_exception_header_from_ue (ue_header);
 233
 234   lsda_header_info info;
 235   const unsigned char *language_specific_data;
 236   const unsigned char *action_record;
 237   const unsigned char *p;
 238   _Unwind_Ptr landing_pad, ip;
 239   int handler_switch_value;
 240   bool saw_cleanup;
 241   bool saw_handler;
 242   bool foreign_exception;
 243   int ip_before_insn = 0;
 244
 245 #ifdef __ARM_EABI_UNWINDER__
 246   _Unwind_Action actions;
 247
 248   switch (state & _US_ACTION_MASK)
 249     {
 250     case _US_VIRTUAL_UNWIND_FRAME:
 251       actions = _UA_SEARCH_PHASE;
 252       break;
 253
 254     case _US_UNWIND_FRAME_STARTING:
 255       actions = _UA_CLEANUP_PHASE;
 256       if (!(state & _US_FORCE_UNWIND)
 257           && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 13))
 258         actions |= _UA_HANDLER_FRAME;
 259       break;
 260
 261     case _US_UNWIND_FRAME_RESUME:
 262       CONTINUE_UNWINDING;
 263       break;
 264
 265     default:
 266       std::abort();
 267     }
 268   actions |= state & _US_FORCE_UNWIND;
 269
 270   // We don't know which runtime we're working with, so can't check this.
 271   // However the ABI routines hide this from us, and we don't actually need
 272   // to know.
 273   foreign_exception = false;
 274
 275   // The dwarf unwinder assumes the context structure holds things like the
 276   // function and LSDA pointers.  The ARM implementation caches these in
 277   // the exception header (UCB).  To avoid rewriting everything we make the
 278   // virtual IP register point at the UCB.
 279   ip = (_Unwind_Ptr) ue_header;
 280   _Unwind_SetGR(context, 12, ip);
 281
 282 #else
 283   // Interface version check.
 284   if (version != 1)
 285     return _URC_FATAL_PHASE1_ERROR;
 286   foreign_exception = exception_class != __gcj_exception_class;
 287 #endif
 288
 289   // Shortcut for phase 2 found handler for domestic exception.
 290   if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
 291       && !foreign_exception)
 292     {
 293       handler_switch_value = xh->handlerSwitchValue;
 294       landing_pad = xh->landingPad;
 295       goto install_context;
 296     }
 297
 298   // FIXME: In Phase 1, record _Unwind_GetIPInfo in xh->obj as a part of
 299   // the stack trace for this exception.  This will only collect Java
 300   // frames, but perhaps that is acceptable.
 301   // FIXME2: _Unwind_GetIPInfo is nonsensical for SJLJ, being a call-site
 302   // index instead of a PC value.  We could perhaps arrange for
 303   // _Unwind_GetRegionStart to return context->fc->jbuf[1], which
 304   // is the address of the handler label for __builtin_longjmp, but
 305   // there is no solution for DONT_USE_BUILTIN_SETJMP.
 306
 307   language_specific_data = (const unsigned char *)
 308     _Unwind_GetLanguageSpecificData (context);
 309
 310   // If no LSDA, then there are no handlers or cleanups.
 311   if (! language_specific_data)
 312     CONTINUE_UNWINDING;
 313
 314   // Parse the LSDA header.
 315   p = parse_lsda_header (context, language_specific_data, &info);
 316 #ifdef HAVE_GETIPINFO
 317   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 318 #else
 319   ip = _Unwind_GetIP (context);
 320 #endif
 321   if (! ip_before_insn)
 322     --ip;
 323   landing_pad = 0;
 324   action_record = 0;
 325   handler_switch_value = 0;
 326
 327 #ifdef SJLJ_EXCEPTIONS
 328   // The given "IP" is an index into the call-site table, with two
 329   // exceptions -- -1 means no-action, and 0 means terminate.  But
 330   // since we're using uleb128 values, we've not got random access
 331   // to the array.
 332   if ((int) ip <= 0)
 333     return _URC_CONTINUE_UNWIND;
 334   else
 335     {
 336       _uleb128_t cs_lp, cs_action;
 337       do
 338         {
 339           p = read_uleb128 (p, &cs_lp);
 340           p = read_uleb128 (p, &cs_action);
 341         }
 342       while (--ip);
 343
 344       // Can never have null landing pad for sjlj -- that would have
 345       // been indicated by a -1 call site index.
 346       landing_pad = cs_lp + 1;
 347       if (cs_action)
 348         action_record = info.action_table + cs_action - 1;
 349       goto found_something;
 350     }
 351 #else
 352   // Search the call-site table for the action associated with this IP.
 353   while (p < info.action_table)
 354     {
 355       _Unwind_Ptr cs_start, cs_len, cs_lp;
 356       _uleb128_t cs_action;
 357
 358       // Note that all call-site encodings are "absolute" displacements.
 359       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 360       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 361       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 362       p = read_uleb128 (p, &cs_action);
 363
 364       // The table is sorted, so if we've passed the ip, stop.
 365       if (ip < info.Start + cs_start)
 366         p = info.action_table;
 367       else if (ip < info.Start + cs_start + cs_len)
 368         {
 369           if (cs_lp)
 370             landing_pad = info.LPStart + cs_lp;
 371           if (cs_action)
 372             action_record = info.action_table + cs_action - 1;
 373           goto found_something;
 374         }
 375     }
 376 #endif // SJLJ_EXCEPTIONS
 377
 378   // If ip is not present in the table, C++ would call terminate.
 379   // ??? It is perhaps better to tweek the LSDA so that no-action
 380   // is mapped to no-entry for Java.
 381   CONTINUE_UNWINDING;
 382
 383  found_something:
 384   saw_cleanup = false;
 385   saw_handler = false;
 386
 387   if (landing_pad == 0)
 388     {
 389       // If ip is present, and has a null landing pad, there are
 390       // no cleanups or handlers to be run.
 391     }
 392   else if (action_record == 0)
 393     {
 394       // If ip is present, has a non-null landing pad, and a null
 395       // action table offset, then there are only cleanups present.
 396       // Cleanups use a zero switch value, as set above.
 397       saw_cleanup = true;
 398     }
 399   else
 400     {
 401       // Otherwise we have a catch handler.
 402       _sleb128_t ar_filter, ar_disp;
 403
 404       while (1)
 405         {
 406           p = action_record;
 407           p = read_sleb128 (p, &ar_filter);
 408           read_sleb128 (p, &ar_disp);
 409
 410           if (ar_filter == 0)
 411             {
 412               // Zero filter values are cleanups.
 413               saw_cleanup = true;
 414             }
 415
 416           // During forced unwinding, we only run cleanups.  With a
 417           // foreign exception class, we have no class info to match.
 418           else if ((actions & _UA_FORCE_UNWIND)
 419                    || foreign_exception)
 420             ;
 421
 422           else if (ar_filter > 0)
 423             {
 424               // Positive filter values are handlers.
 425
 426               void **catch_word = get_ttype_entry (context, &info, ar_filter);
 427               jclass catch_type = (jclass)*catch_word;
 428
 429               // FIXME: This line is a kludge to work around exception
 430               // handlers written in C++, which don't yet use indirect
 431               // dispatch.
 432               if (catch_type == *(void **)&java::lang::Class::class$)
 433                 catch_type = (jclass)catch_word;
 434
 435               if (_Jv_IsInstanceOf (xh->value, catch_type))
 436                 {
 437                   handler_switch_value = ar_filter;
 438                   saw_handler = true;
 439                   break;
 440                 }
 441             }
 442           else
 443             {
 444               // Negative filter values are exception specifications,
 445               // which Java does not use.
 446               // ??? Perhaps better to make them an index into a table
 447               // of null-terminated strings instead of playing games
 448               // with Utf8Const+1 as above.
 449               abort ();
 450             }
 451
 452           if (ar_disp == 0)
 453             break;
 454           action_record = p + ar_disp;
 455         }
 456     }
 457
 458   if (! saw_handler && ! saw_cleanup)
 459         CONTINUE_UNWINDING;
 460
 461   if (actions & _UA_SEARCH_PHASE)
 462     {
 463       if (! saw_handler)
 464         CONTINUE_UNWINDING;
 465
 466       // For domestic exceptions, we cache data from phase 1 for phase 2.
 467       if (! foreign_exception)
 468         {
 469           xh->handlerSwitchValue = handler_switch_value;
 470           xh->landingPad = landing_pad;
 471         }
 472       return _URC_HANDLER_FOUND;
 473     }
 474
 475  install_context:
 476   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 477                  (_Unwind_Ptr) &xh->unwindHeader);
 478   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
 479                  handler_switch_value);
 480   _Unwind_SetIP (context, landing_pad);
 481 #ifdef __ARM_EABI_UNWINDER__
 482   if (saw_cleanup)
 483     __cxa_begin_cleanup(ue_header);
 484 #endif
 485   return _URC_INSTALL_CONTEXT;
 486 }